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	process (Event &event) final
	Processing an event for a Producer is calling produce.

Public Member Functions inherited from framework::EventProcessor
	DECLARE_FACTORY (EventProcessor, EventProcessor *, const std::string &, Process &)
	declare that we have a factory for this class

	EventProcessor (const std::string &name, Process &process)
	Class constructor.

virtual	~EventProcessor ()=default
	Class destructor.

virtual void	beforeNewRun (ldmx::RunHeader &run_header)
	Callback for Producers to add parameters to the run header before conditions are initialized.

virtual void	onNewRun (const ldmx::RunHeader &run_header)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.

virtual void	onFileOpen (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.

virtual void	onFileClose (EventFile &event_file)
	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	channel_map_file_name_
	the channel mapping

std::ifstream	channel_map_file_

std::map< int, int >	channel_map_

std::string	input_collection_

std::string	output_collection_

std::string	input_pass_name_

int	n_channels_ {50}

int	n_samples_ {5}

bool	is_real_data_ {false}

Additional Inherited Members
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.

Protected Attributes inherited from framework::EventProcessor
HistogramPool	histograms_
	helper object for making and filling histograms

NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.

logging::logger	the_log_
	The logger for this EventProcessor.

Detailed Description

Definition at line 11 of file QIEDecoder.h.

Constructor & Destructor Documentation

◆ QIEDecoder()

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

inline

Definition at line 13 of file QIEDecoder.h.

14 : Producer(name, process) {}

framework::Producer::Producer

Producer(const std::string &name, Process &process)

Class constructor.

Definition EventProcessor.cxx:53

framework::Producer::process

virtual void process(Event &event) final

Processing an event for a Producer is calling produce.

Definition EventProcessor.h:276

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 14 of file QIEDecoder.cxx.

                                                        {
  // Configure this instance of the encoder
  output_collection_ = ps.get<std::string>("output_collection");
  input_collection_ = ps.get<std::string>("input_collection");
  input_pass_name_ = ps.get<std::string>("input_pass_name");
  channel_map_file_name_ = ps.get<std::string>("channel_map_file");
  n_channels_ = ps.get<int>("number_channels");
  n_samples_ = ps.get<int>("number_time_samples");
  is_real_data_ = ps.get<bool>("is_real_data");
 
  ldmx_log(debug) << "In configure, got parameters:" << "\noutput_collection = "
                  << output_collection_
                  << "\ninput_collection = " << input_collection_
                  << "\ninput_pass_name  = " << input_pass_name_
                  << "\nchannel_map_file = " << channel_map_file_name_
                  << "\nnumber_channels  = " << n_channels_
                  << "\nnumber_time_samples  = " << n_samples_
                  << "\nis_real_data  = " << is_real_data_;
 
  channel_map_file_.open(channel_map_file_name_, std::ios::in);
  if (!channel_map_file_.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 ch_id, el_id;
  while (!channel_map_file_.eof()) {
    channel_map_file_ >> el_id >> ch_id;
    // 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)
    channel_map_.insert(std::pair<int, int>(el_id, ch_id));
    ldmx_log(debug) << el_id << "  chID " << ch_id;
  }
  channel_map_file_.close();
  if (el_id != n_channels_ - 1)
    ldmx_log(fatal) << "The set number of channels " << n_channels_
                    << " seems not to match the number from the map (+1) :"
                    << el_id;
  return;
}

References channel_map_file_name_, and framework::config::Parameters::get().

◆ 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 302 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 296 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 65 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 n_samp = n_samples_;  // QIEStream::NUM_SAMPLES ;
  ldmx_log(debug) << "num samples = " << n_samp;
 
  ldmx_log(debug) << "Looking up input collection " << input_collection_ << "_"
                  << input_pass_name_;
  const auto event_stream{
      event.getCollection<uint8_t>(input_collection_, input_pass_name_)};
  ldmx_log(debug) << "Got input collection" << input_collection_ << "_"
                  << input_pass_name_;
 
  uint32_t time_epoch = 0;
  // these don't have to be in any particular order, position is anyway looked
  // up from definition in header
  for (int i_w = 0; i_w < QIEStream::TIMESTAMP_LEN_BYTES; i_w++) {
    int pos = QIEStream::TIMESTAMP_POS + i_w;
    uint8_t time_word = event_stream.at(pos);
    ldmx_log(debug) << "time stamp word at position " << pos
                    << " (with iW = " << i_w
                    << ") = " << std::bitset<8>(time_word);
    time_epoch |= (time_word << i_w * 8);  // shift by a byte at a time
  }
 
  uint32_t time_clock = 0;
  for (int i_w = 0; i_w < QIEStream::TIMESTAMPCLOCK_LEN_BYTES; i_w++) {
    int pos = QIEStream::TIMESTAMPCLOCK_POS + i_w;
    uint8_t time_word = event_stream.at(pos);
    ldmx_log(debug) << "time stamp ns word at position " << pos
                    << " (with iW = " << i_w
                    << ") = " << std::bitset<8>(time_word);
    time_clock |= (time_word << i_w * 8);  // shift by a byte at a time
  }
 
  uint32_t time_spill = 0;
  ldmx_log(debug) << "Before starting, timeSpill = " << time_spill << " ("
                  << std::bitset<64>(time_spill) << ", or, " << std::hex
                  << time_spill << std::dec << ") counts since start of spill";
 
  for (int i_w = 0; i_w < QIEStream::TIMESINCESPILL_LEN_BYTES; i_w++) {
    int pos = QIEStream::TIMESINCESPILL_POS + i_w;
    uint8_t time_word = event_stream.at(pos);
    ldmx_log(debug) << "time since spill word at position " << pos
                    << " (with iW = " << i_w
                    << ") = " << std::bitset<8>(time_word);
    time_spill |= (time_word << i_w * 8);  // shift by a byte at a time
  }
  ldmx_log(debug) << "time stamp words are : " << time_epoch << " ("
                  << std::bitset<64>(time_epoch) << ") and " << time_clock
                  << " (" << std::bitset<64>(time_clock)
                  << ") clock ticks, and " << time_spill << " ("
                  << std::bitset<64>(time_spill) << ", or, " << std::hex
                  << time_spill << std::dec << ") counts since start of spill";
 
  int sig_bits_skip = 6;  // the first 6 bits are part of something else.
  int divisor = TMath::Power(2, 32 - sig_bits_skip);
  // remove them by taking remainder in division by
  // the values of the last skipped bit
  time_spill = time_spill % divisor;
  ldmx_log(debug) << "After taking it mod 2^" << 32 - sig_bits_skip
                  << " (which is " << divisor << ", spill time is "
                  << time_spill;
  event.getEventHeader().setIntParameter("timeSinceSpill", time_spill);
 
  TTimeStamp* time_stamp = new TTimeStamp(time_epoch);
  event.getEventHeader().setTimestamp(*time_stamp);
 
  // trigger ID event number
  uint32_t trigger_id = 0;
 
  for (int i_w = 0; i_w < QIEStream::TRIGID_LEN_BYTES; i_w++) {
    // assume the whole 3B are written as a single 24 bits word
    int pos = QIEStream::TRIGID_POS + i_w;
    uint8_t t_i_dword = event_stream.at(pos);
    ldmx_log(debug) << "trigger word at position " << pos
                    << " (with iW = " << i_w
                    << ") = " << std::bitset<8>(t_i_dword);
    trigger_id |= (t_i_dword << i_w * 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>(trigger_id);
 
  if (trigger_id != 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 " << trigger_id;
  }
 
  // 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 = event_stream.at(QIEStream::ERROR_POS);
 
  bool is_ci_dskipped{static_cast<bool>((flags >> QIEStream::CID_SKIP_POS) &
                                        Mask8<QIEStream::FLAG_SIZE_BITS>::M)};
  bool is_ci_dunsync{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 reference_checksum = 0;
  int checksum{(flags >> QIEStream::CHECKSUM_POS) &
               Mask8<QIEStream::CHECKSUM_SIZE_BITS>::M};
  // eventStream.at(QIEStream::CRC0_ERR_POS)
  // QIEStream::CHECKSUM_POS);
  if (checksum != reference_checksum)
    ldmx_log(fatal) << "Got checksum mismatch: expected "
                    << (int)reference_checksum << ", stream says " << checksum;
  if (is_ci_dunsync) ldmx_log(debug) << "Found unsynced CIDs!";
  if (is_ci_dskipped) ldmx_log(fatal) << "Found skipped CIDs!";
 
  /* -- TS event header done; read the channel contents -- */
  std::vector<trigscint::TrigScintQIEDigis> out_digis;
  std::map<int, std::vector<int>> ad_cmap;
  std::map<int, std::vector<int>> td_cmap;
 
  // read in words from the stream. line them up per channel and time sample.
  // channels are in the electronics ordering
  int i_wstart =
      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 n_words = n_samp * n_channels_ * 2 + i_wstart;
  // 1 ADC, 1 TDC per channel per sample,
  // + the words in the header
  int i_word = i_wstart;
  ldmx_log(debug) << "Event parsing starts at vector idx " << i_wstart
                  << " and nWords = " << n_words;
  // outer loop: over nSamples
  // inner loop over nChannels to get ADCs, then repeat to get TDCs
  for (int i_s = 0; i_s < n_samp; i_s++) {
    for (int i_q = 0; i_q < n_channels_; i_q++) {
      if (i_word >= n_words) {
        ldmx_log(fatal)
            << "More words than expected! Breaking ADC loop in sample " << i_s
            << " at iQ = " << i_q;
        break;
      }
      uint8_t val = event_stream.at(i_word);
      if (val > 0) {  // add only the digis with non-zero ADC value
        ldmx_log(debug) << "got ADC value " << (unsigned)val
                        << " at channel (elec) idx " << i_q;
        if (ad_cmap.find(i_q) == ad_cmap.end()) {  // we have a new channel
          std::vector<int> adcs(n_samp, 0);
          ad_cmap.insert(std::pair<int, std::vector<int>>(i_q, adcs));
        }
        ad_cmap[i_q].at(i_s) = val;
      }
      i_word++;
    }
    for (int i_q = 0; i_q < n_channels_; i_q++) {
      if (i_word >= n_words) {
        ldmx_log(debug)
            << "More words than expected! Breaking TDC loop in sample " << i_s
            << " at iQ = " << i_q;
        break;
      }
      uint8_t val = event_stream.at(i_word);
      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 " << i_q;
        ;
        if (td_cmap.find(i_q) == td_cmap.end()) {  // we have a new channel
          std::vector<int> tdcs(n_samp, 0);
          td_cmap.insert(std::pair<int, std::vector<int>>(i_q, 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)
        td_cmap[i_q].at(i_s) = val;  // have full 6-bit TDC at SLAC
      }
      i_word++;
    }
    ldmx_log(debug) << "Done with sample " << i_s;
  }
 
  ldmx_log(debug) << "Done reading in header, ADC and TDC for event "
                  << trigger_id;
  for (std::map<int, std::vector<int>>::iterator itr = ad_cmap.begin();
       itr != ad_cmap.end(); ++itr) {
    TrigScintQIEDigis digi;
    digi.setADC(itr->second);
    if (channel_map_.find(itr->first) == channel_map_.end()) {
      ldmx_log(fatal)
          << "Couldn't find the bar ID corresponding to electronics ID "
          << itr->first << "!! Skipping.";
      continue;
    }
    int bar = channel_map_[itr->first];
    digi.setElecID(itr->first);
    digi.setChanID(bar);
    digi.setTDC(td_cmap[itr->first]);
    digi.setTimeSinceSpill(time_spill);
    if (bar == 0)
      ldmx_log(debug) << "for bar 0, got time since spill "
                      << digi.getTimeSinceSpill();
    out_digis.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(output_collection_, out_digis);
}

Member Data Documentation

◆ channel_map_

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

private

Definition at line 37 of file QIEDecoder.h.

◆ channel_map_file_

std::ifstream trigscint::QIEDecoder::channel_map_file_

private

Definition at line 36 of file QIEDecoder.h.

◆ channel_map_file_name_

std::string trigscint::QIEDecoder::channel_map_file_name_

private

the channel mapping

Definition at line 35 of file QIEDecoder.h.

Referenced by configure().

◆ input_collection_

std::string trigscint::QIEDecoder::input_collection_

private

Definition at line 40 of file QIEDecoder.h.

◆ input_pass_name_

std::string trigscint::QIEDecoder::input_pass_name_

private

Definition at line 42 of file QIEDecoder.h.

◆ is_real_data_

bool trigscint::QIEDecoder::is_real_data_ {false}

private

Definition at line 49 of file QIEDecoder.h.

49{false};

◆ n_channels_

int trigscint::QIEDecoder::n_channels_ {50}

private

Definition at line 45 of file QIEDecoder.h.

45{50};

◆ n_samples_

int trigscint::QIEDecoder::n_samples_ {5}

private

Definition at line 47 of file QIEDecoder.h.

47{5};

◆ output_collection_

std::string trigscint::QIEDecoder::output_collection_

private

Definition at line 41 of file QIEDecoder.h.

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

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ QIEDecoder()

Member Function Documentation

◆ configure()

◆ onProcessEnd()

◆ onProcessStart()

◆ produce()

Member Data Documentation

◆ channel_map_

◆ channel_map_file_

◆ channel_map_file_name_

◆ input_collection_

◆ input_pass_name_

◆ is_real_data_

◆ n_channels_

◆ n_samples_

◆ output_collection_