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	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_

std::ifstream	channelMapFile_

std::map< int, int >	channelMap_

std::string	inputCollection_

std::string	inputPassName_

std::string	outputCollection_

bool	verbose_ {false}

int	nChannels_ {50}

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 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.

18 : Producer(name, process) {}

framework::Producer::Producer

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

Class constructor.

Definition EventProcessor.cxx:68

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
  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");
  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_
                  << "\nverbose          = " << verbose_;
 
  // set up channel mapping
  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;
    // 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
    channelMap_.insert(std::pair<int, int>(chID, elID));
    ldmx_log(debug) << "elID " << elID << "  chID " << chID;
  }
  if (elID != nChannels_ - 1)
    ldmx_log(fatal) << "The set number of channels " << nChannels_
                    << " seems not to match the number from the map (+1) :"
                    << elID;
  channelMapFile_.close();
 
  return;
}

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

◆ 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> qieOuts;
  int nSamp = QIEStream::NUM_SAMPLES;
  std::vector<int> initVec(nSamp, 0);
  ldmx_log(debug) << "num samples = " << nSamp;
 
  // we're keeping a list ordered in elec ID since this is the order we'll use
  // to write them to stream
  for (int iQ = 0; iQ < nChannels_; iQ++) {
    QIEStream qieOut;
    qieOut.setADC(initVec);
    qieOut.setTDC(initVec);
    qieOut.setCID(initVec);
    qieOut.setElectronicsID(iQ);  // assume id is index
 
    qieOuts.push_back(qieOut);
  }
 
  ldmx_log(debug) << "Looking up input collection " << inputCollection_ << "_"
                  << inputPassName_;
  const auto digis{event.getCollection<trigscint::TrigScintQIEDigis>(
      inputCollection_, inputPassName_)};
  ldmx_log(debug) << "Got input collection" << inputCollection_ << "_"
                  << inputPassName_;
 
  bool isCIDunsync = false;  // mismatch between CID reported by channels within
                             // the same time sample
  bool isCIDskipped = false;     // a gap in the CID increment
  bool isCRC0malformed = false;  // an issue with CRC from fiber0
  bool isCRC1malformed = false;  // an issue with CRC from fiber1
 
  int firstCID = -1;
  ldmx_log(debug) << "entering loop over digis ";
  for (auto &digi : digis) {
    int bar = digi.getChanID();
    auto itr = channelMap_.find(bar);
    if (itr == channelMap_.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.
    qieOuts.at(idx).setChannelID(bar);
    qieOuts.at(idx).setElectronicsID(idx);
    ldmx_log(debug) << "Channel " << bar << " elec ID "
                    << qieOuts.at(idx).getElectronicsID();
    std::vector<int> LEtdcs;  // make the LE (Leading Edge) truncation explicit
    std::vector<uint8_t> cids;
    for (int iS = 0; iS < nSamp; iS++) {
      int tdc = digi.getTDC().at(iS);
      int cid = digi.getCID().at(iS);
      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.
        isCIDskipped = true;
      }
      if (verbose_) {  // all this is only useful for debugging
        std::vector<uint8_t> adcs;
        int adc = digi.getADC().at(iS);
        uint8_t mant = adc % 64;
        uint8_t exp = adc / 64;
        ldmx_log(debug) << "\tSample " << iS << 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
      LEtdcs.push_back(tdc);
      cids.push_back((uint8_t)cid);
    }  // over samples
    if (firstCID == -1) {
      // just store the 5th one, doesn't matter; if all channels
      // are aligned then cids should match at any given time sample
      firstCID = cids.back();
    }
    if (firstCID != cids.back()) {
      isCIDunsync =
          true;  // any one channel not aligned is enough to set this bool
    }
    qieOuts.at(idx).setADC(digi.getADC());
    qieOuts.at(idx).setTDC(LEtdcs);
  }  // over digis
  if (isCIDunsync) ldmx_log(debug) << "Found unsynced CIDs!";
  if (isCIDskipped) 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 triggerID = event.getEventHeader().getEventNumber();
  uint8_t randomChecksum =
      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 |= (isCRC0malformed << QIEStream::CRC0_ERR_POS);
  flags |= (isCRC1malformed << QIEStream::CRC1_ERR_POS);
  flags |= (isCIDunsync << QIEStream::CID_UNSYNC_POS);
  flags |= (isCIDskipped << QIEStream::CID_SKIP_POS);
  ldmx_log(debug) << "FLAGS: " << std::bitset<8>(flags);
 
  std::vector<uint8_t> outWord;
  std::vector<uint8_t> triggerIDwords;
  for (int iW = QIEStream::TRIGID_LEN_BYTES - 1; iW >= 0; iW--) {
    // assume the whole 2B are written as a single 16-bit word
    uint8_t tIDword = triggerID >> iW * 8;  // shift by a byte at a time
    triggerIDwords.push_back(tIDword);
    outWord.push_back(tIDword);
  }
 
  outWord.push_back(flags);
  outWord.push_back(randomChecksum);
 
  if (verbose_) {
    std::cout << "header word ";
    for (auto word : outWord) 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 iS = 0; iS < nSamp; iS++) {
    for (int iQ = 0; iQ < nChannels_; iQ++) {
      outWord.push_back(qieOuts.at(iQ).getADC().at(iS));
    }  // over channels : ADC
    for (int iQ = 0; iQ < nChannels_; iQ++) {
      outWord.push_back(qieOuts.at(iQ).getTDC().at(iS));
    }  // over channels: TDC
  }    // over time samples
 
  // in verbose mode, print this all to screen
  if (verbose_) {
    std::cout << "total word ";
    int widx = 0;
    int iWstart =
        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 : outWord) {
      if ((widx - iWstart) % nChannels_ == 0) {
        int sample = (widx - iWstart) / nChannels_;
        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(outputCollection_, outWord);
}

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

Member Data Documentation

◆ channelMap_

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

private

Definition at line 41 of file QIEEncoder.h.

◆ channelMapFile_

std::ifstream trigscint::QIEEncoder::channelMapFile_

private

Definition at line 40 of file QIEEncoder.h.

◆ channelMapFileName_

std::string trigscint::QIEEncoder::channelMapFileName_

private

Definition at line 39 of file QIEEncoder.h.

◆ inputCollection_

std::string trigscint::QIEEncoder::inputCollection_

private

Definition at line 44 of file QIEEncoder.h.

◆ inputPassName_

std::string trigscint::QIEEncoder::inputPassName_

private

Definition at line 45 of file QIEEncoder.h.

◆ nChannels_

int trigscint::QIEEncoder::nChannels_ {50}

private

Definition at line 54 of file QIEEncoder.h.

54{50};

◆ outputCollection_

std::string trigscint::QIEEncoder::outputCollection_

private

Definition at line 47 of file QIEEncoder.h.

◆ verbose_

bool trigscint::QIEEncoder::verbose_ {false}

private

Definition at line 51 of file QIEEncoder.h.

51{false};

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

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ QIEEncoder()

Member Function Documentation

◆ configure()

◆ onProcessEnd()

◆ onProcessStart()

◆ produce()

Member Data Documentation

◆ channelMap_

◆ channelMapFile_

◆ channelMapFileName_

◆ inputCollection_

◆ inputPassName_

◆ nChannels_

◆ outputCollection_

◆ verbose_