ZCCMOutput.h

#ifndef TRIGSCINT_EVENT_ZCCMOUTPUT_H
#define TRIGSCINT_EVENT_ZCCMOUTPUT_H
 
#include <Rtypes.h>
 
#include <cstdint>
#include <ostream>
#include <vector>
 
namespace trigscint {
 
class ZCCMOutput {
 public:
  ZCCMOutput() = default;
 
  virtual ~ZCCMOutput() = default;
 
  friend std::ostream& operator<<(std::ostream& o, const ZCCMOutput& d);
 
  void clear(Option_t* option = "");
 
  bool operator<(const ZCCMOutput& rhs) const {
    return this->chan_id_ < rhs.chan_id_;
  }
 
  int getChannelID() const { return chan_id_; }
 
  uint8_t getElectronicsID() const { return electronics_id_; }
 
  std::vector<int> getADC() const { return adcs_; }
 
  std::vector<int> getTDC() const { return tdcs_; }
 
  std::vector<int> getCID() const { return cids_; }
 
  void setChannelID(const int chanid) { chan_id_ = chanid; }
 
  void setElectronicsID(const int elecid) { electronics_id_ = elecid; }
 
  void setADC(const std::vector<int> adc) { adcs_ = adc; }
 
  void setTDC(const std::vector<int> tdc) { tdcs_ = tdc; }
 
  void setCID(const std::vector<int> cid) { cids_ = cid; }
 
 public:
  const static int TIMESTAMP_POS{0};
  const static int TIMESTAMP_LEN_BYTES{8};
  const static int EMPTY_HEADER_WORD_POS{TIMESTAMP_POS + TIMESTAMP_LEN_BYTES};
  const static int EMPTY_HEADER_WORD_LEN_BYTES{8};
  // this marks the start of event data (i.e. after end of event header)
  const static int EVENTDATA_POS{EMPTY_HEADER_WORD_POS +
                                 EMPTY_HEADER_WORD_LEN_BYTES};
  /*
    the time sample word has ADC, TDC, flags and lane:
    one for each lane, in every time sample
    the following positions are within this time sample word, for one lane
  */
  // the number of channels sets the length of the ADC and TDC streams
  const static int NUM_CHAN_PER_LANE{6};
  const static int ADC_SAMPLE_WORD_POS{0};
  const static int ADC_LEN_BYTES{1 * NUM_CHAN_PER_LANE};
  const static int EMPTY_WORD_SAMPLE_WORD_POS{ADC_SAMPLE_WORD_POS +
                                              ADC_LEN_BYTES};
  const static int EMPTY_WORD_LEN_BYTES{2};
  const static int TDC_SAMPLE_WORD_POS{EMPTY_WORD_SAMPLE_WORD_POS +
                                       EMPTY_WORD_LEN_BYTES};
  const static int TDC_LEN_BYTES{1 * NUM_CHAN_PER_LANE};
  const static int FLAGS_SAMPLE_WORD_POS{TDC_SAMPLE_WORD_POS + TDC_LEN_BYTES};
  const static int FLAGS_LEN_BYTES{1};
  const static int LANE_SAMPLE_WORD_POS{FLAGS_SAMPLE_WORD_POS +
                                        FLAGS_LEN_BYTES};
  const static int LANE_LEN_BYTES{1};
  // and positions of error bits/flags inside the flags word
  const static int CAPID_POS_IN_FLAG{0};
  const static int CAPID_LEN_BITS{2};
  const static int CE_POS_IN_FLAG{CAPID_POS_IN_FLAG + CAPID_LEN_BITS};
  const static int CE_LEN_BITS{1};
  const static int BC0_POS_IN_FLAG{CE_POS_IN_FLAG + CE_LEN_BITS};
  const static int BC0_LEN_BITS{1};
  const static int EMPTY_FLAG_WORD_POS_IN_FLAG{BC0_POS_IN_FLAG + BC0_LEN_BITS};
  const static int EMPTY_FLAG_WORD_LEN_BITS{4};
 
  // event data concludes the readout.
 
  // for convenience, define the length of a message (time sample for one lane)
  const static int SAMPLE_WORD_LEN_BYTES = ADC_LEN_BYTES + TDC_LEN_BYTES +
                                           EMPTY_WORD_LEN_BYTES +
                                           FLAGS_LEN_BYTES + LANE_LEN_BYTES;
 
 private:
  int lane_;
  int module_;
  int chan_id_;
  int electronics_id_;
  std::vector<int> adcs_;
  std::vector<int> tdcs_;
  std::vector<int> cids_;
 
  ClassDef(ZCCMOutput, 1);
};
}  // namespace trigscint
#endif