trigscint::QIEEncoder Class Reference

Public Member Functions
	QIEEncoder (const std::string &name, framework::Process &process)
virtual	~QIEEncoder ()=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_
std::ifstream	channel_map_file_
std::map< int, int >	channel_map_
std::string	input_collection_
std::string	input_pass_name_
std::string	output_collection_
bool	verbose_ {false}
int	n_channels_ {50}

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 15 of file QIEEncoder.h.

Constructor & Destructor Documentation

QIEEncoder()

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

inline

Definition at line 17 of file QIEEncoder.h.

      : Producer(name, process) {}

Member Function Documentation

configure()

void trigscint::QIEEncoder::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 8 of file QIEEncoder.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");
  verbose_ = ps.get<bool>("verbose");
 
  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_
                  << "\nverbose          = " << verbose_;
 
  // set up channel mapping
  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;
    // for test beam, we will only know the elecID from
    // the position of the word in the stream.
    // so these need to be strictly ordered in the map.
    // barID can always be set, or looked up, as a property of the digi.
 
    // make this based on channel ID. this is like looking up the position in a
    // vector of a certain value. but it's fine
    channel_map_.insert(std::pair<int, int>(ch_id, el_id));
    ldmx_log(debug) << "elID " << el_id << "  chID " << ch_id;
  }
  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;
  channel_map_file_.close();
 
  return;
}

References framework::config::Parameters::get().

onProcessEnd()

void trigscint::QIEEncoder::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 236 of file QIEEncoder.cxx.

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

onProcessStart()

void trigscint::QIEEncoder::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 230 of file QIEEncoder.cxx.

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

produce()

void trigscint::QIEEncoder::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 58 of file QIEEncoder.cxx.

                                              {
  ldmx_log(debug) << "QIEEncoder: produce() starts! Event number: "
                  << event.getEventHeader().getEventNumber();
 
  std::vector<trigscint::QIEStream> qie_outs;
  int n_samp = QIEStream::NUM_SAMPLES;
  std::vector<int> init_vec(n_samp, 0);
  ldmx_log(debug) << "num samples = " << n_samp;
 
  // we're keeping a list ordered in elec ID since this is the order we'll use
  // to write them to stream
  for (int i_q = 0; i_q < n_channels_; i_q++) {
    QIEStream qie_out;
    qie_out.setADC(init_vec);
    qie_out.setTDC(init_vec);
    qie_out.setCID(init_vec);
    qie_out.setElectronicsID(i_q);  // assume id is index
 
    qie_outs.push_back(qie_out);
  }
 
  ldmx_log(debug) << "Looking up input collection " << input_collection_ << "_"
                  << input_pass_name_;
  const auto digis{event.getCollection<trigscint::TrigScintQIEDigis>(
      input_collection_, input_pass_name_)};
  ldmx_log(debug) << "Got input collection" << input_collection_ << "_"
                  << input_pass_name_;
 
  bool is_ci_dunsync = false;      // mismatch between CID reported by channels
                                   // within the same time sample
  bool is_ci_dskipped = false;     // a gap in the CID increment
  bool is_cr_c0malformed = false;  // an issue with CRC from fiber0
  bool is_cr_c1malformed = false;  // an issue with CRC from fiber1
 
  int first_cid = -1;
  ldmx_log(debug) << "entering loop over digis ";
  for (auto &digi : digis) {
    int bar = digi.getChanID();
    auto itr = channel_map_.find(bar);
    if (itr == channel_map_.end()) {  // yikes! didn't find the bar in the map
      ldmx_log(fatal) << "Couldn't find an entry for bar " << bar
                      << "; check the (choice of) channel map!. Exiting event "
                      << event.getEventHeader().getEventNumber();
      return;
    }
    int idx = itr->second;  // here we're just using the order. no actual elID
                            // is assumed.
    qie_outs.at(idx).setChannelID(bar);
    qie_outs.at(idx).setElectronicsID(idx);
    ldmx_log(debug) << "Channel " << bar << " elec ID "
                    << qie_outs.at(idx).getElectronicsID();
    std::vector<int> l_etdcs;  // make the LE (Leading Edge) truncation explicit
    std::vector<uint8_t> cids;
    for (int i_s = 0; i_s < n_samp; i_s++) {
      int tdc = digi.getTDC().at(i_s);
      int cid = digi.getCID().at(i_s);
      if (cids.size() > 0 && (cid % 4) != ((cids.back() + 1) % 4)) {
        // by construction shouldn't happen in simulation. still, explicitly
        // checking here, considering any future changes to our CID simulation.
        is_ci_dskipped = true;
      }
      if (verbose_) {  // all this is only useful for debugging
        std::vector<uint8_t> adcs;
        int adc = digi.getADC().at(i_s);
        uint8_t mant = adc % 64;
        uint8_t exp = adc / 64;
        ldmx_log(debug) << "\tSample " << i_s << std::left << std::setw(6)
                        << " ADC " << adc << ",\texp " << unsigned(exp)
                        << " mant " << unsigned(mant) << ",\tTDC = " << tdc
                        << ", LE TDC = " << std::bitset<8>(tdc / 16)
                        << " and capID= " << cid;
        adcs.push_back(64 * exp + mant);
        ldmx_log(debug) << "Combined ADC: " << std::showbase
                        << std::bitset<8>(adcs.back()) << " and original adc "
                        << std::bitset<8>(adc) << std::dec;
      }  // if verbose
 
      tdc /= 16;  // do LE (leading edge) TDC
      l_etdcs.push_back(tdc);
      cids.push_back((uint8_t)cid);
    }  // over samples
    if (first_cid == -1) {
      // just store the 5th one, doesn't matter; if all channels
      // are aligned then cids should match at any given time sample
      first_cid = cids.back();
    }
    if (first_cid != cids.back()) {
      is_ci_dunsync =
          true;  // any one channel not aligned is enough to set this bool
    }
    qie_outs.at(idx).setADC(digi.getADC());
    qie_outs.at(idx).setTDC(l_etdcs);
  }  // over digis
  if (is_ci_dunsync) ldmx_log(debug) << "Found unsynced CIDs!";
  if (is_ci_dskipped) ldmx_log(info) << "Found skipped CIDs!";
 
  // data format:
  // RM ID: we don't set it for testbeam so skip for now.
  // 16 bit trigger ID.
  // 4 bits of flags, then 4 reserved 0 for now
  // some 8-bit error word/checksum.
  // all channel 8-bit ADCs.
  // all channel TDCS.
  // done.
 
  uint16_t trigger_id = event.getEventHeader().getEventNumber();
  uint8_t random_checksum =
      30;             // just some number for now. TODO implement a checksum
  uint8_t flags = 0;  // we use this to contain the four reserved 0's too
  // put it all in, at the assigned position
  flags |= (is_cr_c0malformed << QIEStream::CRC0_ERR_POS);
  flags |= (is_cr_c1malformed << QIEStream::CRC1_ERR_POS);
  flags |= (is_ci_dunsync << QIEStream::CID_UNSYNC_POS);
  flags |= (is_ci_dskipped << QIEStream::CID_SKIP_POS);
  ldmx_log(debug) << "FLAGS: " << std::bitset<8>(flags);
 
  std::vector<uint8_t> out_word;
  std::vector<uint8_t> trigger_i_dwords;
  for (int i_w = QIEStream::TRIGID_LEN_BYTES - 1; i_w >= 0; i_w--) {
    // assume the whole 2B are written as a single 16-bit word
    uint8_t t_i_dword = trigger_id >> i_w * 8;  // shift by a byte at a time
    trigger_i_dwords.push_back(t_i_dword);
    out_word.push_back(t_i_dword);
  }
 
  out_word.push_back(flags);
  out_word.push_back(random_checksum);
 
  if (verbose_) {
    std::cout << "header word ";
    for (auto word : out_word) std::cout << std::bitset<8>(word) << " ";
    std::cout << std::endl;
  }
 
  // now write this in sequence: ADC of all channels, then TDC; repeat for all
  // samples
  for (int i_s = 0; i_s < n_samp; i_s++) {
    for (int i_q = 0; i_q < n_channels_; i_q++) {
      out_word.push_back(qie_outs.at(i_q).getADC().at(i_s));
    }  // over channels : ADC
    for (int i_q = 0; i_q < n_channels_; i_q++) {
      out_word.push_back(qie_outs.at(i_q).getTDC().at(i_s));
    }  // over channels: TDC
  }  // over time samples
 
  // in verbose mode, print this all to screen
  if (verbose_) {
    std::cout << "total word ";
    int widx = 0;
    int i_wstart =
        std::max(std::max(QIEStream::ERROR_POS, QIEStream::CHECKSUM_POS),
                 QIEStream::TRIGID_POS + (QIEStream::TRIGID_LEN_BYTES)) +
        1;  // probably overkill :D should be 4
    for (auto word : out_word) {
      if ((widx - i_wstart) % n_channels_ == 0) {
        int sample = (widx - i_wstart) / n_channels_;
        if (sample % 2 == 0)
          std::cout << "\n sample " << sample / 2 << " |  ";
        else
          std::cout << "\n TDC:        ";
      }
      std::cout << (unsigned)word << " ";
      // std::cout <<  std::bitset<8>(word)  << " " ;  //for binary output
      // format
      widx++;
    }
    std::cout << std::endl;
  }  // if verbose
 
  event.add(output_collection_, out_word);
}

References trigscint::QIEStream::setADC(), trigscint::QIEStream::setCID(), trigscint::QIEStream::setElectronicsID(), and trigscint::QIEStream::setTDC().

Member Data Documentation

channel_map_

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

private

Definition at line 41 of file QIEEncoder.h.

channel_map_file_

std::ifstream trigscint::QIEEncoder::channel_map_file_

private

Definition at line 40 of file QIEEncoder.h.

channel_map_file_name_

std::string trigscint::QIEEncoder::channel_map_file_name_

private

Definition at line 39 of file QIEEncoder.h.

input_collection_

std::string trigscint::QIEEncoder::input_collection_

private

Definition at line 44 of file QIEEncoder.h.

input_pass_name_

std::string trigscint::QIEEncoder::input_pass_name_

private

Definition at line 45 of file QIEEncoder.h.

n_channels_

int trigscint::QIEEncoder::n_channels_ {50}

private

Definition at line 54 of file QIEEncoder.h.

{50};

output_collection_

std::string trigscint::QIEEncoder::output_collection_

private

Definition at line 47 of file QIEEncoder.h.

verbose_

bool trigscint::QIEEncoder::verbose_ {false}

private

Definition at line 51 of file QIEEncoder.h.

{false};

---

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

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