trigscint::QIEDecoder Class Reference

Public Member Functions
	QIEDecoder (const std::string &name, framework::Process &process)
virtual	~QIEDecoder ()=default
	Default destructor, closes up boost archive and input stream.
void	configure (framework::config::Parameters &ps) override
	Configure our converter based off the configuration parameters decoded from the passed python script.
void	produce (framework::Event &event) override
	Process the event and put new data products into it.
void	onProcessStart () override
	Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.
void	onProcessEnd () override
	Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.
Public Member Functions inherited from framework::Producer
	Producer (const std::string &name, Process &process)
	Class constructor.
virtual void	beforeNewRun (ldmx::RunHeader &header)
	Handle allowing producers to modify run headers before the run begins.
Public Member Functions inherited from framework::EventProcessor
	EventProcessor (const std::string &name, Process &process)
	Class constructor.
virtual	~EventProcessor ()
	Class destructor.
virtual void	onNewRun (const ldmx::RunHeader &runHeader)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.
virtual void	onFileOpen (EventFile &eventFile)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.
virtual void	onFileClose (EventFile &eventFile)
	Callback for the EventProcessor to take any necessary action when a event input ROOT file is closed.
template<class T >
const T &	getCondition (const std::string &condition_name)
	Access a conditions object for the current event.
TDirectory *	getHistoDirectory ()
	Access/create a directory in the histogram file for this event processor to create histograms and analysis tuples.
void	setStorageHint (framework::StorageControl::Hint hint)
	Mark the current event as having the given storage control hint from this module.
void	setStorageHint (framework::StorageControl::Hint hint, const std::string &purposeString)
	Mark the current event as having the given storage control hint from this module and the given purpose string.
int	getLogFrequency () const
	Get the current logging frequency from the process.
int	getRunNumber () const
	Get the run number from the process.
std::string	getName () const
	Get the processor name.
void	createHistograms (const std::vector< framework::config::Parameters > &histos)
	Internal function which is used to create histograms passed from the python configuration @parma histos vector of Parameters that configure histograms to create.

Private Attributes
std::string	channelMapFileName_
	the channel mapping
std::ifstream	channelMapFile_
std::map< int, int >	channelMap_
std::string	inputCollection_
std::string	outputCollection_
std::string	inputPassName_
bool	verbose_ {false}
int	nChannels_ {50}
int	nSamples_ {5}
bool	isRealData_ {false}

Additional Inherited Members
Static Public Member Functions inherited from framework::EventProcessor
static void	declare (const std::string &classname, int classtype, EventProcessorMaker *)
	Internal function which is part of the PluginFactory machinery.
Static Public Attributes inherited from framework::Producer
static const int	CLASSTYPE {1}
	Constant used to track EventProcessor types by the PluginFactory.
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.
Protected Attributes inherited from framework::EventProcessor
HistogramHelper	histograms_
	Interface class for making and filling histograms.
NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.
logging::logger	theLog_
	The logger for this EventProcessor.

Detailed Description

Definition at line 16 of file QIEDecoder.h.

Constructor & Destructor Documentation

QIEDecoder()

trigscint::QIEDecoder::QIEDecoder ( const std::string &  name, framework::Process &  process  )

inline

Definition at line 18 of file QIEDecoder.h.

      : Producer(name, process) {}

Member Function Documentation

configure()

void trigscint::QIEDecoder::configure ( framework::config::Parameters &  ps )

overridevirtual

Configure our converter based off the configuration parameters decoded from the passed python script.

Reimplemented from framework::EventProcessor.

Definition at line 9 of file QIEDecoder.cxx.

                                                        {
  // Configure this instance of the encoder
  outputCollection_ = ps.getParameter<std::string>("output_collection");
  inputCollection_ = ps.getParameter<std::string>("input_collection");
  inputPassName_ = ps.getParameter<std::string>("input_pass_name");
  channelMapFileName_ = ps.getParameter<std::string>("channel_map_file");
  nChannels_ = ps.getParameter<int>("number_channels");
  nSamples_ = ps.getParameter<int>("number_time_samples");
  isRealData_ = ps.getParameter<bool>("is_real_data");
  verbose_ = ps.getParameter<bool>("verbose");
 
  ldmx_log(debug) << "In configure, got parameters:"
                  << "\noutput_collection = " << outputCollection_
                  << "\ninput_collection = " << inputCollection_
                  << "\ninput_pass_name  = " << inputPassName_
                  << "\nchannel_map_file = " << channelMapFileName_
                  << "\nnumber_channels  = " << nChannels_
                  << "\nnumber_time_samples  = " << nSamples_
                  << "\nis_real_data  = " << isRealData_
                  << "\nverbose          = " << verbose_;
 
  channelMapFile_.open(channelMapFileName_, std::ios::in);
  if (!channelMapFile_.is_open()) {
    EXCEPTION_RAISE(
        "BadMapFile",
        "The channel mapping file cannot be opened.");  // <-- appears this
                                                        // needs implementing
                                                        // first
    ldmx_log(fatal) << "The channel mapping file cannot be opened.";
    return;
  }
  int chID, elID;
  while (!channelMapFile_.eof()) {
    channelMapFile_ >> elID >> chID;
    // make the map based on electronics ID, to look up channel ID.
    // the reason is, we will only know the elecID from the position
    // of the word in the stream. so these need to be strictly ordered.
    // writing the right bar in the right position is easier if we can just
    // read this map from beginning to end.
    // barID can always be set, or looked up, as a property of the digi.
 
    // here make the elecID the key (other way around when encoding)
    channelMap_.insert(std::pair<int, int>(elID, chID));
    ldmx_log(debug) << elID << "  chID " << chID;
  }
  channelMapFile_.close();
  if (elID != nChannels_ - 1)
    ldmx_log(fatal) << "The set number of channels " << nChannels_
                    << " seems not to match the number from the map (+1) :"
                    << elID;
  return;
}

References channelMapFileName_, and framework::config::Parameters::getParameter().

onProcessEnd()

void trigscint::QIEDecoder::onProcessEnd ( )

overridevirtual

Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.

Reimplemented from framework::EventProcessor.

Definition at line 296 of file QIEDecoder.cxx.

                              {
  ldmx_log(debug) << "Process ends!";
 
  return;
}

onProcessStart()

void trigscint::QIEDecoder::onProcessStart ( )

overridevirtual

Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.

Reimplemented from framework::EventProcessor.

Definition at line 290 of file QIEDecoder.cxx.

                                {
  ldmx_log(debug) << "Process starts!";
 
  return;
}

produce()

void trigscint::QIEDecoder::produce ( framework::Event &  event )

overridevirtual

Process the event and put new data products into it.

Parameters

event

The Event to process.

Implements framework::Producer.

Definition at line 62 of file QIEDecoder.cxx.

                                              {
  ldmx_log(debug) << "QIEDecoder: produce() starts! Event number: "
                  << event.getEventHeader().getEventNumber();
 
  // turns out this need to be configurable for now, to read real data
  int nSamp = nSamples_;  // QIEStream::NUM_SAMPLES ;
  ldmx_log(debug) << "num samples = " << nSamp;
 
  ldmx_log(debug) << "Looking up input collection " << inputCollection_ << "_"
                  << inputPassName_;
  const auto eventStream{
      event.getCollection<uint8_t>(inputCollection_, inputPassName_)};
  ldmx_log(debug) << "Got input collection" << inputCollection_ << "_"
                  << inputPassName_;
 
  uint32_t timeEpoch = 0;
  // these don't have to be in any particular order, position is anyway looked
  // up from definition in header
  for (int iW = 0; iW < QIEStream::TIMESTAMP_LEN_BYTES; iW++) {
    int pos = QIEStream::TIMESTAMP_POS + iW;
    uint8_t timeWord = eventStream.at(pos);
    ldmx_log(debug) << "time stamp word at position " << pos
                    << " (with iW = " << iW
                    << ") = " << std::bitset<8>(timeWord);
    timeEpoch |= (timeWord << iW * 8);  // shift by a byte at a time
  }
 
  uint32_t timeClock = 0;
  for (int iW = 0; iW < QIEStream::TIMESTAMPCLOCK_LEN_BYTES; iW++) {
    int pos = QIEStream::TIMESTAMPCLOCK_POS + iW;
    uint8_t timeWord = eventStream.at(pos);
    ldmx_log(debug) << "time stamp ns word at position " << pos
                    << " (with iW = " << iW
                    << ") = " << std::bitset<8>(timeWord);
    timeClock |= (timeWord << iW * 8);  // shift by a byte at a time
  }
 
  uint32_t timeSpill = 0;
  ldmx_log(debug) << "Before starting, timeSpill = " << timeSpill << " ("
                  << std::bitset<64>(timeSpill) << ", or, " << std::hex
                  << timeSpill << std::dec << ") counts since start of spill";
 
  for (int iW = 0; iW < QIEStream::TIMESINCESPILL_LEN_BYTES; iW++) {
    int pos = QIEStream::TIMESINCESPILL_POS + iW;
    uint8_t timeWord = eventStream.at(pos);
    ldmx_log(debug) << "time since spill word at position " << pos
                    << " (with iW = " << iW
                    << ") = " << std::bitset<8>(timeWord);
    timeSpill |= (timeWord << iW * 8);  // shift by a byte at a time
  }
  ldmx_log(debug) << "time stamp words are : " << timeEpoch << " ("
                  << std::bitset<64>(timeEpoch) << ") and " << timeClock << " ("
                  << std::bitset<64>(timeClock) << ") clock ticks, and "
                  << timeSpill << " (" << std::bitset<64>(timeSpill) << ", or, "
                  << std::hex << timeSpill << std::dec
                  << ") counts since start of spill";
 
  int sigBitsSkip = 6;  // the first 6 bits are part of something else.
  int divisor = TMath::Power(2, 32 - sigBitsSkip);
  // remove them by taking remainder in division by
  // the values of the last skipped bit
  timeSpill = timeSpill % divisor;
  ldmx_log(debug) << "After taking it mod 2^" << 32 - sigBitsSkip
                  << " (which is " << divisor << ", spill time is "
                  << timeSpill;
  event.getEventHeader().setIntParameter("timeSinceSpill", timeSpill);
 
  TTimeStamp *timeStamp = new TTimeStamp(timeEpoch);
  event.getEventHeader().setTimestamp(*timeStamp);
 
  // trigger ID event number
  uint32_t triggerID = 0;
 
  for (int iW = 0; iW < QIEStream::TRIGID_LEN_BYTES; iW++) {
    // assume the whole 3B are written as a single 24 bits word
    int pos = QIEStream::TRIGID_POS + iW;
    uint8_t tIDword = eventStream.at(pos);
    ldmx_log(debug) << "trigger word at position " << pos
                    << " (with iW = " << iW
                    << ") = " << std::bitset<8>(tIDword);
    triggerID |= (tIDword << iW * 8);  // shift by a byte at a time
  }
 
  //  ldmx_log(debug) << " got triggerID " << std::bitset<16>(triggerID) ;
  ldmx_log(debug) << " got triggerID " << std::bitset<32>(triggerID);
 
  if (triggerID != event.getEventHeader().getEventNumber()) {
    // this probably only applies to digi emulation,
    // unless an event number is explicitly set in unpacking
    ldmx_log(fatal) << "Got event number mismatch: framework reports "
                    << event.getEventHeader().getEventNumber()
                    << ", stream says " << triggerID;
  }
 
  // error word
  /* the error word contains
         - 4 trailing reserved 0's, for now
         - isCIDunsync : if there is a mismatch between CID reported by channels
     within the same time sample
         - isCIDskipped : if there is a gap in the CID increment of a channel
     beweeen samples
         - isCRC0malformed : if there was an issue with CRC from fiber0
         - isCRC1malformed : if there was an issue with CRC from fiber1
  */
  uint8_t flags = eventStream.at(QIEStream::ERROR_POS);
 
  bool isCIDskipped{static_cast<bool>((flags >> QIEStream::CID_SKIP_POS) &
                                      mask8<QIEStream::FLAG_SIZE_BITS>::m)};
  bool isCIDunsync{static_cast<bool>((flags >> QIEStream::CID_UNSYNC_POS) &
                                     mask8<QIEStream::FLAG_SIZE_BITS>::m)};
  // These are unused, should they be? FIXME
  // bool isCRC1malformed{static_cast<bool>((flags >> QIEStream::CRC1_ERR_POS) &
  //                                        mask8<QIEStream::FLAG_SIZE_BITS>::m)};
  // bool isCRC0malformed{static_cast<bool>((flags >> QIEStream::CRC0_ERR_POS) &
  //                                       mask8<QIEStream::FLAG_SIZE_BITS>::m)};
 
  // checksum
  // really, this is just empty for now.
  // TODO: implement a checksum set/get
  uint8_t referenceChecksum = 0;
  int checksum{(flags >> QIEStream::CHECKSUM_POS) &
               mask8<QIEStream::CHECKSUM_SIZE_BITS>::
                   m};  // eventStream.at(QIEStream::CRC0_ERR_POS)
                        // QIEStream::CHECKSUM_POS);
  if (checksum != referenceChecksum)
    ldmx_log(fatal) << "Got checksum mismatch: expected "
                    << (int)referenceChecksum << ", stream says " << checksum;
  if (isCIDunsync) ldmx_log(debug) << "Found unsynced CIDs!";
  if (isCIDskipped) ldmx_log(fatal) << "Found skipped CIDs!";
 
  /* -- TS event header done; read the channel contents -- */
  std::vector<trigscint::TrigScintQIEDigis> outDigis;
  std::map<int, std::vector<int>> ADCmap;
  std::map<int, std::vector<int>> TDCmap;
 
  // read in words from the stream. line them up per channel and time sample.
  // channels are in the electronics ordering
  int iWstart =
      std::max(std::max(QIEStream::ERROR_POS, QIEStream::CHECKSUM_POS),
               QIEStream::TRIGID_POS + (QIEStream::TRIGID_LEN_BYTES)) +
      1;  // make sure we're at end of header
  int nWords =
      nSamp * nChannels_ * 2 + iWstart;  // 1 ADC, 1 TDC per channel per sample,
                                         // + the words in the header
  int iWord = iWstart;
  ldmx_log(debug) << "Event parsing starts at vector idx " << iWstart
                  << " and nWords = " << nWords;
  // outer loop: over nSamples
  // inner loop over nChannels to get ADCs, then repeat to get TDCs
  for (int iS = 0; iS < nSamp; iS++) {
    for (int iQ = 0; iQ < nChannels_; iQ++) {
      if (iWord >= nWords) {
        ldmx_log(fatal)
            << "More words than expected! Breaking ADC loop in sample " << iS
            << " at iQ = " << iQ;
        break;
      }
      uint8_t val = eventStream.at(iWord);
      if (val > 0) {  // add only the digis with non-zero ADC value
        ldmx_log(debug) << "got ADC value " << (unsigned)val
                        << " at channel (elec) idx " << iQ;
        if (ADCmap.find(iQ) == ADCmap.end()) {  // we have a new channel
          std::vector<int> adcs(nSamp, 0);
          ADCmap.insert(std::pair<int, std::vector<int>>(iQ, adcs));
        }
        ADCmap[iQ].at(iS) = val;
      }
      iWord++;
    }
    for (int iQ = 0; iQ < nChannels_; iQ++) {
      if (iWord >= nWords) {
        ldmx_log(debug)
            << "More words than expected! Breaking TDC loop in sample " << iS
            << " at iQ = " << iQ;
        break;
      }
      uint8_t val = eventStream.at(iWord);
      if (val > 0) {  // TODO: check if this channel is also present in ADC map?
                      // in the end?
        ldmx_log(debug) << "got TDC value " << (unsigned)val
                        << " at channel (elec) idx " << iQ;
        ;
        if (TDCmap.find(iQ) == TDCmap.end()) {  // we have a new channel
          std::vector<int> tdcs(nSamp, 0);
          TDCmap.insert(std::pair<int, std::vector<int>>(iQ, tdcs));
        }
        // this is LETDC; only the two most significant bits included
        // they are shipped as least significant bits --> shift them
        TDCmap[iQ].at(iS) = (val + 1) * 16;  // want LE TDC = 3 to correspond to
                                             // 64 > 49 (which is maxTDC in sim)
      }
      iWord++;
    }
    ldmx_log(debug) << "Done with sample " << iS;
  }
 
  ldmx_log(debug) << "Done reading in header, ADC and TDC for event "
                  << triggerID;
  for (std::map<int, std::vector<int>>::iterator itr = ADCmap.begin();
       itr != ADCmap.end(); ++itr) {
    TrigScintQIEDigis digi;
    digi.setADC(itr->second);
    if (channelMap_.find(itr->first) == channelMap_.end()) {
      ldmx_log(fatal)
          << "Couldn't find the bar ID corresponding to electronics ID "
          << itr->first << "!! Skipping.";
      continue;
    }
    int bar = channelMap_[itr->first];
    digi.setElecID(itr->first);
    digi.setChanID(bar);
    digi.setTDC(TDCmap[itr->first]);
    digi.setTimeSinceSpill(timeSpill);
    if (bar == 0)
      ldmx_log(debug) << "for bar 0, got time since spill "
                      << digi.getTimeSinceSpill();
    outDigis.push_back(digi);
    ldmx_log(debug) << "Iterator points to key " << itr->first
                    << " and mapped channel supposedly  is " << bar;
    ldmx_log(debug) << "Made digi with elecID = " << digi.getElecID()
                    << ", barID = " << digi.getChanID() << ", third adc value "
                    << digi.getADC().at(2) << " and third tdc "
                    << digi.getTDC().at(2);
  }
 
  event.add(outputCollection_, outDigis);
}

References trigscint::TrigScintQIEDigis::getADC(), trigscint::TrigScintQIEDigis::getChanID(), trigscint::TrigScintQIEDigis::getElecID(), framework::Event::getEventHeader(), ldmx::EventHeader::getEventNumber(), trigscint::TrigScintQIEDigis::getTDC(), trigscint::TrigScintQIEDigis::getTimeSinceSpill(), trigscint::TrigScintQIEDigis::setADC(), trigscint::TrigScintQIEDigis::setChanID(), trigscint::TrigScintQIEDigis::setElecID(), trigscint::TrigScintQIEDigis::setTDC(), and trigscint::TrigScintQIEDigis::setTimeSinceSpill().

Member Data Documentation

channelMap_

std::map<int, int> trigscint::QIEDecoder::channelMap_

private

Definition at line 42 of file QIEDecoder.h.

channelMapFile_

std::ifstream trigscint::QIEDecoder::channelMapFile_

private

Definition at line 41 of file QIEDecoder.h.

channelMapFileName_

std::string trigscint::QIEDecoder::channelMapFileName_

private

the channel mapping

Definition at line 40 of file QIEDecoder.h.

Referenced by configure().

inputCollection_

std::string trigscint::QIEDecoder::inputCollection_

private

Definition at line 45 of file QIEDecoder.h.

inputPassName_

std::string trigscint::QIEDecoder::inputPassName_

private

Definition at line 47 of file QIEDecoder.h.

isRealData_

bool trigscint::QIEDecoder::isRealData_ {false}

private

Definition at line 58 of file QIEDecoder.h.

{false};

nChannels_

int trigscint::QIEDecoder::nChannels_ {50}

private

Definition at line 54 of file QIEDecoder.h.

{50};

nSamples_

int trigscint::QIEDecoder::nSamples_ {5}

private

Definition at line 56 of file QIEDecoder.h.

{5};

outputCollection_

std::string trigscint::QIEDecoder::outputCollection_

private

Definition at line 46 of file QIEDecoder.h.

verbose_

bool trigscint::QIEDecoder::verbose_ {false}

private

Definition at line 51 of file QIEDecoder.h.

{false};

---

The documentation for this class was generated from the following files:

• TrigScint/include/TrigScint/QIEDecoder.h
• TrigScint/src/TrigScint/QIEDecoder.cxx