diff --git a/README.md b/README.md index 5367930..ecf521b 100644 --- a/README.md +++ b/README.md @@ -24,6 +24,15 @@ Status of the supported boards: | 1151N | Lecroy Scaler | Full | yes | yes | yes | | TTCvi | TTC controler | Full | yes | yes | yes | +## Requirements +The following external libraries are required to compile and run this project: + - CAENVMELib library (https://www.caen.it/download/?filter=CAENVMELib%20Library) + - boost (stacktrace_basic, stacktrace_noop, thread, log, log_setup, python27). Tested with boost 1.69.0 + - Python development headers (for python bindings) + - c++17 compatible compiler. Tested with gcc/g++ 7.3.0 + +In addition, in order to be able to connect to the VME bridge, the CAEN USB driver for the V1718 must be installed (https://www.caen.it/download/?filter=V1718) + ## Installation The project is built through cmake: diff --git a/include/TDC.h b/include/TDC.h index 9cf8923..d1f2155 100644 --- a/include/TDC.h +++ b/include/TDC.h @@ -30,7 +30,7 @@ class V1190ControlRegister { public: - + // meaning of the control bits typedef enum CVRegisterWordBit { cvBERREN = 0, /* Bus Error enable bit. Used in D32 and Block Transfer mode */ @@ -42,22 +42,22 @@ class V1190ControlRegister cvTESTEN = 6, /* Test FIFO enable */ cvRCSEN = 7, /* Read Compensation SRAM enable */ cvFIFOEN = 8, /* Event FIFO enable */ - cvEXTDTTEN= 9, /* Extended Trigger Time Tag enable */ - cv16MBMEB = 12,/* 16MB address range MEB access enable */ + cvEXTDTTEN= 9, /* Extended Trigger Time Tag enable */ + cv16MBMEB = 12,/* 16MB address range MEB access enable */ } CVRegisterWordBit; - + V1190ControlRegister(uint32_t reg):register_(reg) {} ~V1190ControlRegister() {} - + // return the status word inline uint16_t registr() const { return register_; } - + // extract a given bit inline bool bit(V1190ControlRegister::CVRegisterWordBit n) const { return ((register_>>n)&1); } - + // set a bit inline void setBit(V1190ControlRegister::CVRegisterWordBit n, bool enable=true) { if (enable^bit(n)) register_ ^= 1 << n;} - + private: uint16_t register_; }; @@ -66,7 +66,7 @@ class V1190ControlRegister class V1190StatusRegister { public: - + // meaning of the status bits typedef enum CVRegisterWordBit { cvDATA_READY= 0, /* Data present in the output buffer */ @@ -78,24 +78,24 @@ class V1190StatusRegister cvERROR0 = 6, /* error in TDC 0 */ cvERROR1 = 7, /* error in TDC 1 */ cvERROR2 = 8, /* error in TDC 2 */ - cvERROR3 = 9, /* error in TDC 3 */ - cvBERR_FLAG = 10,/* Bus error */ + cvERROR3 = 9, /* error in TDC 3 */ + cvBERR_FLAG = 10,/* Bus error */ cvPURG = 11,/* Purged */ cvRES_0 = 12,/* Resolution LSB */ cvRES_1 = 13,/* Resolution MSB */ cvPAIR = 14,/* Pair mode */ cvTRIGLOST = 15,/* Trigger lost */ } CVRegisterWordBit; - + V1190StatusRegister(uint32_t reg):register_(reg) {} ~V1190StatusRegister() {} - + // return the status word inline uint16_t registr() const { return register_; } - + // extract a given bit inline bool bit(V1190StatusRegister::CVRegisterWordBit n) const { return ((register_>>n)&1); } - + private: uint16_t register_; }; @@ -115,19 +115,19 @@ class Tdc:public VmeBoard uint16_t revision_major_; uint8_t firmwareVersion_; }; - + // acquisition modes typedef enum CVAcquisitionMode { cvContinuous = 0, cvTrigger = 1, } CVAcquisitionMode; - + // configurations typedef enum CVConfiguration { cvDefault = 0, cvUser = 1, } CVConfiguration; - + // edge detection mode typedef enum CVEdgeDetection { cvPairMode = 0, @@ -135,14 +135,14 @@ class Tdc:public VmeBoard cvLeading = 2, cvBoth = 3, } CVEdgeDetection; - + // edge detection resolution typedef enum CVEdgeLSB { cv800ps = 0, cv200ps = 1, cv100ps = 2, } CVEdgeLSB; - + // pair mode edge resolution typedef enum CVPairModeEdgeLSB { cvpme100ps = 0, @@ -154,7 +154,7 @@ class Tdc:public VmeBoard cvpme6250ps = 6, cvpme12500ps = 7, } CVPairModeEdgeLSB; - + // pair mode width resolution typedef enum CVPairModeWidthLSB { cvpmw100ps = 0, @@ -172,7 +172,7 @@ class Tdc:public VmeBoard cvpmw400ns = 12, cvpmw800ns = 13, } CVPairModeWidthLSB; - + // dead time typedef enum CVDeadTime { cvdt5ns = 0, @@ -180,7 +180,7 @@ class Tdc:public VmeBoard cvdt30ns = 2, cvdt100ns = 3, } CVDeadTime; - + // trigger window configuration struct WindowConfiguration { uint16_t width; // ns @@ -188,91 +188,91 @@ class Tdc:public VmeBoard uint16_t extraMargin; uint16_t rejectMargin; bool triggerTimeSubstraction; - + static uint16_t computeOffset(int16_t signedOffset) { assert(signedOffset>=-2048 && signedOffset<=40); - return signedOffset<0 ? 0xF000+abs(signedOffset) : abs(signedOffset); + return signedOffset<0 ? ~abs(signedOffset)+1 : abs(signedOffset); } }; - + Tdc(VmeController* controller,uint32_t address=0x00120000); ///////////////////////// //// Configuration, status, info, ... ///////////////////////// - + // Get module info inline ModuleInfo getModuleInfo() const { return info_; } - + // Reads the control register V1190ControlRegister getControlRegister(); - + // Writes the control register void setControlRegister(V1190ControlRegister& reg); - - // Enables FIFO + + // Enables FIFO void enableFIFO(bool enable); - + // Enables BERR // note: BERR stop condition should be avoided, since this implementation would discard the last BLT read. void enableBERR(bool enable); - + // Enables Extd trigger time void enableExtdTrigTime(bool enable); - + // Enables Compensation void enableCompensation(bool enable); // Get the TDC status V1190StatusRegister getStatus(); - + // Program interrupt void setInterrupt(uint8_t level=0X0, uint16_t vector = 0xDD); // Reset the board void reset(bool moduleReset=true, bool softClear=true, bool softEvtReset=true); - + // Generates a software trigger - void trigger(); - + void trigger(); + // get the event count uint32_t eventCount(); - + // get the stored event count uint16_t storedEventCount(); - + // set the almost-full level void setAlmostFullLevel(uint16_t level); - + // get the almost-full level uint16_t getAlmostFullLevel(); - + // reads the event FIFO std::pair readFIFO(); - + // reads the FIFO count uint16_t getFIFOCount(); - + // reads the FIFO status uint8_t getFIFOStatus(); - + ///////////////////////// //// Read data from the board ///////////////////////// - + // Gets data from TDC in trigger mode V1190Event getEvent(bool useFIFO=true); // Gets data from TDC in trigger mode std::vector getEvents(bool useFIFO=true); - + // Gets data from TDC in countinuous mode TDCHit getHit(); ///////////////////////// //// Generic opcode methods ///////////////////////// - + // Write a command line of 16 bit in the Micro Controller register. void writeOpcode(uint16_t data); @@ -282,100 +282,100 @@ class Tdc:public VmeBoard ///////////////////////// //// Acquisition mode ///////////////////////// - + // Set the acquisition mode : Trigger (1), Continuous (0). void setAcquisitionMode(Tdc::CVAcquisitionMode mode = cvTrigger); - + // Get the acquisition mode Tdc::CVAcquisitionMode getAcquisitionMode(); - + // Keep the token or not (TDC chip buffer access) void keepToken(bool keep=true); - + // save configuration void saveUserConfiguration(); - + // load configuration void loadConfiguration(Tdc::CVConfiguration conf); - + // set startup configuration void setStartupConfiguration(Tdc::CVConfiguration conf); ///////////////////////// // Trigger ///////////////////////// - + // set the trigger window configuration void setTriggerWindow(Tdc::WindowConfiguration &conf); - + // read the trigger window configuration Tdc::WindowConfiguration getTriggerWindow(); - + ///////////////////////// // TDC edge detection and resolution ///////////////////////// - + // Set edge detection configuration void setEdgeDetectionConfiguration(Tdc::CVEdgeDetection conf); - + // Read edge detection configuration Tdc::CVEdgeDetection getEdgeDetectionConfiguration(); - + // Set LSB of leading/trailing edge void setEdgeLSB(Tdc::CVEdgeLSB lsb); - + // Set leading time and width resolution when pair void setPairResolution(Tdc::CVPairModeEdgeLSB edge, Tdc::CVPairModeWidthLSB width); - - // Read resolution + + // Read resolution Tdc::CVEdgeLSB getResolution(); std::pair getPairResolution(); - + // set dead time void setDeadTime(Tdc::CVDeadTime dt); - + // get dead time Tdc::CVDeadTime getDeadTime(); - + ///////////////////////// - // TDC Readout + // TDC Readout ///////////////////////// - + // enable/disable the TDC header and trailer void enableTDCHeader(bool enable); - + // check if TDC header and trailer are enabled bool isTDCHeaderEnabled(); - + // set the maximum number of hits per event // can be 0, a power of 2 (up to 128) or -1 (infinity) void setMaxHitsPerEvent(int numHits); - + // get the maximum number of hits per event (-1 = no limits) int getMaxHitsPerEvent(); - + // configure TDC readout. Refer tp the manual for the meaning of internalErrorTypes and fifoSize void configureTDCReadout(bool enableErrorMask, bool enableBypass, uint16_t internalErrorTypes, uint16_t fifoSize); - + // Read enabled TDC internal error internalErrorTypes uint16_t getInternalErrorTypes(); - + // Read effective size of readout FIFO uint16_t getFifoSize(); - + ///////////////////////// // Channel enable/disable ///////////////////////// // Enable/Disable channel. 128 or higher means "all" void enableChannel(uint8_t channel, bool enable); - + // Write Enable pattern void writeEnablePattern(std::bitset<128> &pattern); - + // Read Enable pattern std::bitset<128> readEnablePattern(); - + ///////////////////////// // Other Opcodes ///////////////////////// @@ -392,7 +392,7 @@ class Tdc:public VmeBoard int outputBuffer_; int eventFIFO_; int controlRegister_; - + // Module info ModuleInfo info_; diff --git a/include/V1190Event.h b/include/V1190Event.h index 5130b26..b94f1d3 100644 --- a/include/V1190Event.h +++ b/include/V1190Event.h @@ -13,19 +13,19 @@ class TDCHit measurement_ = data&0x7FFFF; } ~TDCHit() {} - + inline uint16_t getChannel() const { return channel_; } inline uint8_t getType() const { return type_; } inline uint32_t getMeasurement() const { return measurement_; } - + inline void setChannel(uint16_t channel) { channel_ = channel&0x7F; } inline void setType(uint8_t type) { type_ = type&0x1; } inline void setMeasurement(uint32_t measurement) { measurement_ = measurement&0x7FFFF; } - + operator uint32_t() const { return (type_<<26) + (channel_<<19) + measurement_; } - + std::string toString() const; - + private: uint32_t type_:1, channel_:7, measurement_:19; //TDC measurement }; @@ -39,29 +39,29 @@ class TDCEvent bunchid_ = header&0xFFF; } ~TDCEvent() {} - + inline uint8_t getTDCId() const { return tdcid_; } inline uint16_t getEventId() const { return eventid_; } inline uint16_t getBunchId() const { return bunchid_; } inline uint16_t getErrorFlags() const { return errorflags_; } inline const std::vector& getHits() const { return hits_; } - + inline void setTDCId(uint8_t id) { tdcid_ = id&0x3; } inline void setEventId(uint16_t id) { eventid_ = id&0xFFF; } inline void setBunchId(uint16_t id) { bunchid_ = id&0xFFF; } inline void setErrorFlags(uint16_t flags) { errorflags_ = flags; } - + inline void addHit(TDCHit hit) { hits_.push_back(hit); } - + std::string toString() const; - + friend bool operator==(const TDCEvent& lhs, const TDCEvent& rhs); - + private: uint32_t tdcid_:2,eventid_:12, bunchid_:12; // TDC header word uint16_t errorflags_; // TDC error word std::vector hits_; - + }; class V1190Event @@ -73,26 +73,26 @@ class V1190Event status_ = (trailer>>24)&0x7; } ~V1190Event() {} - + inline uint32_t getEventCount() const { return eventCount_; } inline uint8_t getGeo() const { return geo_; } inline uint8_t getStatus() const { return status_; } inline uint32_t getExtdTriggerTime() const { return extTriggerTime_; } inline const std::vector& getHits() const { return hits_; } inline const std::vector& getTDCEvents() const { return tdcevents_; } - + inline void setEventCount(uint32_t count) { eventCount_ = count&0x7FFFFF; } inline void setGeo(uint8_t geo) { geo_ = geo&0x1F; } inline void setStatus(uint8_t status) { status_ = status&0x7; } inline void setExtdTriggerTime(uint32_t time) { extTriggerTime_ = time&0x7FFFFFF; } - + inline void addHit(TDCHit hit) { hits_.push_back(hit); } inline void addTDCEvent(TDCEvent &tdc) { tdcevents_.push_back(tdc); } - + std::string toString() const; - + friend bool operator==(const V1190Event& lhs, const V1190Event& rhs); - + private: uint32_t eventCount_:22, geo_:5, status_:3; // header & trailer uint32_t extTriggerTime_; // extended time (if enabled) diff --git a/src/TDC.cpp b/src/TDC.cpp index 2872465..be6e8ad 100644 --- a/src/TDC.cpp +++ b/src/TDC.cpp @@ -59,10 +59,10 @@ Tdc::Tdc(VmeController* controller,uint32_t address):VmeBoard(controller, addres info_.revision_minor_ |= (readData(baseAddress()+0x4040)&0xFF)<<8; // firmware version info_.firmwareVersion_ = readData(baseAddress()+0x1026)&0xFF; - - LOG_DEBUG("CAEN V1190"+ ((info_.version_&0x1) ? string("B") : string("A")) + " initialized. " + - "Serial number: " + int_to_hex(info_.serial_number_) + - " rev. " + to_string(info_.revision_major_) + "." + to_string(info_.revision_minor_) + + + LOG_DEBUG("CAEN V1190"+ ((info_.version_&0x1) ? string("B") : string("A")) + " initialized. " + + "Serial number: " + int_to_hex(info_.serial_number_) + + " rev. " + to_string(info_.revision_major_) + "." + to_string(info_.revision_minor_) + " fw. " + to_string(info_.firmwareVersion_>>4) + "." + to_string(info_.firmwareVersion_&0xF)); } @@ -79,7 +79,7 @@ void Tdc::enableFIFO(bool enable) { reg.setBit(V1190ControlRegister::cvFIFOEN,enable); setControlRegister(reg); if(enable) { - LOG_INFO("FIFO enabled !") + LOG_INFO("FIFO enabled !"); } else { LOG_INFO("FIFO disabled !"); } @@ -90,7 +90,7 @@ void Tdc::enableBERR(bool enable) { reg.setBit(V1190ControlRegister::cvBERREN,enable); setControlRegister(reg); if(enable) { - LOG_INFO("BERR enabled !") + LOG_INFO("BERR enabled !"); } else { LOG_INFO("BERR disabled !"); } @@ -100,8 +100,8 @@ void Tdc::enableExtdTrigTime(bool enable) { V1190ControlRegister reg = getControlRegister(); reg.setBit(V1190ControlRegister::cvEXTDTTEN,enable); setControlRegister(reg); - if(enable) { - LOG_INFO("Extended Trigger Time Tag enabled !") + if(enable) { + LOG_INFO("Extended Trigger Time Tag enabled !"); } else { LOG_INFO("Extended Trigger Time Tag disabled !"); } @@ -112,7 +112,7 @@ void Tdc::enableCompensation(bool enable) { reg.setBit(V1190ControlRegister::cvCOMPEN,enable); setControlRegister(reg); if(enable) { - LOG_INFO("Compensation enabled !") + LOG_INFO("Compensation enabled !"); } else { LOG_INFO("Compensation disabled !"); } @@ -179,13 +179,13 @@ V1190Event Tdc::getEvent(bool useFIFO) { std::tie(eventId, nwords) = readFIFO(); } // in D32 readout, read until we get to the trailer and fill progressively the event record - for(uint16_t i=0; !(useFIFO&&i) || (imode(cvA32_U_DATA,cvD32)->readData(baseAddress()); switch(data>>27) { case 0x8: // global header event = V1190Event(data); if(useFIFO && event.getEventCount()!=eventId) - LOG_WARN("Event Count mismatch: Expected " + to_string(eventId) + " from FIFO but got " + LOG_WARN("Event Count mismatch: Expected " + to_string(eventId) + " from FIFO but got " + to_string(event.getEventCount()) + " in the output buffer."); break; case 0x10: // global trailer @@ -241,7 +241,7 @@ std::vector Tdc::getEvents(bool useFIFO) { // read all bool done = false; while(!done) { - std::vector tmp; + std::vector tmp; // read n 32 bits words (from FIFO or default) try { tmp = controller()->mode(cvA32_U_BLT,cvD32)->blockReadData(baseAddress(), nwords); @@ -286,7 +286,7 @@ std::vector Tdc::getEvents(bool useFIFO) { case 0x3: // TDC trailer event.addTDCEvent(tdc); break; - case 0x18: // Filler... + case 0x18: // Filler... break; } } @@ -304,27 +304,27 @@ void Tdc::setAcquisitionMode(Tdc::CVAcquisitionMode mode) { writeOpcode((mode==cvTrigger ? 0x0000 :0x0100)); LOG_DEBUG("Trigger Mode : " + to_string(mode)); } - + Tdc::CVAcquisitionMode Tdc::getAcquisitionMode(){ writeOpcode(0x0200); return CVAcquisitionMode(readOpcode()&0x1); } - + void Tdc::keepToken(bool keep) { writeOpcode((keep ? 0x0300 :0x0400)); LOG_DEBUG("Keep Token : " + to_string(keep)); } - + void Tdc::saveUserConfiguration() { writeOpcode(0x0600); LOG_DEBUG("User configuration saved."); } - + void Tdc::loadConfiguration(Tdc::CVConfiguration conf) { writeOpcode((conf==Tdc::cvDefault ? 0x0500 : 0x0700)); LOG_DEBUG("Loaded " + std::string(conf==Tdc::cvDefault ? "default" : "user") + " configuration."); } - + void Tdc::setStartupConfiguration(Tdc::CVConfiguration conf) { writeOpcode((conf==cvDefault ? 0x0900 : 0x0800)); LOG_DEBUG("Set auto load " + std::string(conf==cvDefault ? "default" : "user") + " configuration."); @@ -342,7 +342,7 @@ void Tdc::setTriggerWindow(Tdc::WindowConfiguration &conf) { writeOpcode((conf.triggerTimeSubstraction ? 0x1400 : 0x1500)); LOG_DEBUG("Trigger Window configured."); } - + Tdc::WindowConfiguration Tdc::getTriggerWindow() { writeOpcode(0x1600); Tdc::WindowConfiguration conf; @@ -358,22 +358,22 @@ void Tdc::setEdgeDetectionConfiguration(Tdc::CVEdgeDetection conf){ writeOpcode(0x2200); writeOpcode(conf); } - + Tdc::CVEdgeDetection Tdc::getEdgeDetectionConfiguration(){ writeOpcode(0x2300); return Tdc::CVEdgeDetection(readOpcode()&0x3); } - + void Tdc::setEdgeLSB(Tdc::CVEdgeLSB lsb){ writeOpcode(0x2400); writeOpcode(lsb); } - + void Tdc::setPairResolution(Tdc::CVPairModeEdgeLSB edge, Tdc::CVPairModeWidthLSB width){ writeOpcode(0x2500); writeOpcode(uint16_t(edge) + (uint16_t(width)<<8)); } - + Tdc::CVEdgeLSB Tdc::getResolution(){ writeOpcode(0x2600); // assumes to be in leading/trailing edge mode @@ -386,12 +386,12 @@ std::pair Tdc::getPairResolutio // assumes to be in pair mode return make_pair(Tdc::CVPairModeEdgeLSB(opcode&0x7),Tdc::CVPairModeWidthLSB((opcode>>8)&0xF)); } - + void Tdc::setDeadTime(Tdc::CVDeadTime dt){ writeOpcode(0x2800); writeOpcode(dt); } - + Tdc::CVDeadTime Tdc::getDeadTime(){ writeOpcode(0x2900); return Tdc::CVDeadTime(readOpcode()&0x3); @@ -400,12 +400,12 @@ Tdc::CVDeadTime Tdc::getDeadTime(){ void Tdc::enableTDCHeader(bool enable){ writeOpcode((enable? 0x3000 : 0x3100)); } - + bool Tdc::isTDCHeaderEnabled(){ writeOpcode(0x3200); return (readOpcode()&0x1); } - + void Tdc::setMaxHitsPerEvent(int numHits){ writeOpcode(0x3300); uint16_t opcode; @@ -418,7 +418,7 @@ void Tdc::setMaxHitsPerEvent(int numHits){ } writeOpcode(opcode); } - + int Tdc::getMaxHitsPerEvent(){ writeOpcode(0x3400); uint16_t opcode = readOpcode()&0xF; @@ -426,7 +426,7 @@ int Tdc::getMaxHitsPerEvent(){ if(opcode==9) return -1; return 1<<(opcode-1); } - + void Tdc::configureTDCReadout(bool enableErrorMask, bool enableBypass, uint16_t internalErrorTypes, uint16_t fifoSize){ writeOpcode((enableErrorMask? 0x3500 : 0x3600)); writeOpcode((enableBypass? 0x3700 : 0x3800)); @@ -435,12 +435,12 @@ void Tdc::configureTDCReadout(bool enableErrorMask, bool enableBypass, uint16_t writeOpcode(0x3B00); writeOpcode(fifoSize); } - + uint16_t Tdc::getInternalErrorTypes(){ writeOpcode(0x3A00); return readOpcode(); } - + uint16_t Tdc::getFifoSize(){ writeOpcode(0x3C00); return readOpcode(); @@ -451,7 +451,7 @@ void Tdc::enableChannel(uint8_t channel, bool enable){ if(channel&128) opcode = (enable? 0x4200 : 0x4300); writeOpcode(opcode); } - + void Tdc::writeEnablePattern(std::bitset<128> &pattern){ writeOpcode(0x4400); int nTDC = (info_.version_&0x1) ? 4 : 8; @@ -459,7 +459,7 @@ void Tdc::writeEnablePattern(std::bitset<128> &pattern){ writeOpcode((pattern>>(16*i)).to_ulong()); // shift and truncate } } - + std::bitset<128> Tdc::readEnablePattern(){ writeOpcode(0x4500); std::bitset<128> pattern = 0; @@ -667,7 +667,7 @@ template<> void exposeToPython() { .def_readwrite("rejectMargin", &Tdc::WindowConfiguration::rejectMargin) .def_readwrite("triggerTimeSubstraction", &Tdc::WindowConfiguration::triggerTimeSubstraction) .def("computeOffset",&Tdc::WindowConfiguration::computeOffset) - .staticmethod("computeOffset") + .staticmethod("computeOffset") ; enum_("CVAcquisitionMode") .value("cvContinuous", Tdc::CVAcquisitionMode::cvContinuous) diff --git a/src/V1190Event.cpp b/src/V1190Event.cpp index 2f52b11..f7215dd 100644 --- a/src/V1190Event.cpp +++ b/src/V1190Event.cpp @@ -33,13 +33,13 @@ bool operator==(const V1190Event& lhs, const V1190Event& rhs) std::string TDCHit::toString() const { std::stringstream output; if(getType()) { + output << "Trailing edge measurement on channel " << std::dec << getChannel(); + output << " : " << getMeasurement() << std::endl; + } else { output << "Leading edge measurement on channel " << std::dec << getChannel(); output << " : " << getMeasurement(); output << " ( width = " << (getMeasurement()>>12); output << ", leading time = " << (getMeasurement()&0xFFF) << " for pair measurement )" << std::endl; - } else { - output << "Trailing edge measurement on channel " << std::dec << getChannel(); - output << " : " << getMeasurement() << std::endl; } return output.str(); } @@ -50,7 +50,7 @@ std::string TDCEvent::toString() const { output << ", bunch id: " << bunchid_ << " :" << std::endl; output << " Errors: " << std::showbase << std::hex << errorflags_ << std::endl; if(hits_.size()) { - output << " Recorded measurements :" << std::endl; + output << " Recorded measurements :" << std::endl; for (auto measurement : hits_) { output << " " << measurement << std::endl; } @@ -64,12 +64,12 @@ std::string V1190Event::toString() const { output << " (GEO " << std::showbase << std::hex << geo_ << ", status " << status_ << ")" << std::endl; if(extTriggerTime_) output << "Extended Trigger Time: " << std::dec << extTriggerTime_ << std::endl; if(hits_.size()) { - output << "Recorded measurements :" << std::endl; + output << "Recorded measurements :" << std::endl; for (auto measurement : hits_) { output << " " << measurement << std::endl; } } else if (tdcevents_.size()) { - output << "Recorded TDC events :" << std::endl; + output << "Recorded TDC events :" << std::endl; for (auto measurement : tdcevents_) { output << measurement << std::endl; }