HgcrocDigiCollection.h

Go to the documentation of this file.

 
#ifndef RECON_EVENT_HGCROCDIGICOLLECTION_H_
#define RECON_EVENT_HGCROCDIGICOLLECTION_H_
 
// ROOT
#include "TObject.h"  //for ClassDef
 
// STL
#include <stdint.h>  //32bit words
 
#include <iostream>  //Print method
#include <vector>    //vector lists
 
namespace ldmx {
 
class HgcrocDigiCollection {
 public:
  class Sample {
   public:
    Sample(bool tot_progress, bool tot_complete, int firstMeas, int seconMeas,
           int toa, int version = 3);
 
    Sample(uint32_t w, int version = 3) : word_(w), version_{version} {}
 
    Sample() {}
 
    bool isTOTinProgress() const {
      return (ONE_BIT_MASK & (word_ >> FIRSTFLAG_POS));
    }
 
    bool isTOTComplete() const {
      return (ONE_BIT_MASK & (word_ >> SECONFLAG_POS));
    }
 
    int toa() const {
      if (version_ == 2) {
        return secon();
      } else {
        return third();
      }
    }
 
    int tot() const {
      if (version_ == 2) {
        return 0xfff & (word_ >> FIRSTMEAS_POS);
      }
 
      int meas = secon();
      if (meas > 512) meas = (meas - 512) * 8;
      return meas;
    }
 
    int adc_tm1() const { return first(); }
 
    int adc_t() const {
      if (version_ == 2) {
        return third();
      }
 
      if (not isTOTComplete())
        return secon();  // running modes
      else
        return first();  // calibration mode
    }
 
    uint32_t raw() const { return word_; }
 
   private:
    int first() const { return TEN_BIT_MASK & (word_ >> FIRSTMEAS_POS); }
 
    int secon() const { return TEN_BIT_MASK & (word_ >> SECONMEAS_POS); }
 
    int third() const { return TEN_BIT_MASK & word_; }
 
   private:
    uint32_t word_;
    int version_;
  };  // Sample
 
 public:
  class HgcrocDigi {
   public:
    HgcrocDigi(unsigned int id, std::vector<uint32_t>::const_iterator first,
               const HgcrocDigiCollection& collection)
        : id_(id), first_(first), collection_(collection) {}
 
    unsigned int id() const { return id_; }
 
    bool isADC() const {
      return !(soi().isTOTinProgress() or soi().isTOTComplete());
    }
 
    bool isTOT() const { return !isADC(); }
 
    int tot() const {
      if (not isTOT()) return -1;
      if (soi().isTOTinProgress()) return -2;
      return soi().tot();
    }
 
    HgcrocDigiCollection::Sample at(unsigned int i_sample) const {
      return Sample(*(first_ + i_sample), collection_.getVersion());
    }
 
    HgcrocDigiCollection::Sample soi() const {
      return at(collection_.getSampleOfInterestIndex());
    }
 
    unsigned int size() const { return collection_.getNumSamplesPerDigi(); }
 
   private:
    unsigned int id_;
 
    std::vector<uint32_t>::const_iterator first_;
 
    const HgcrocDigiCollection& collection_;
 
  };  // HgcrocDigi
 
 public:
  HgcrocDigiCollection() {}
 
  virtual ~HgcrocDigiCollection() {}
 
  void Clear();
 
  void Print() const;
 
  int getVersion() const { return version_; }
 
  void setVersion(int v) {
    version_ = v;
    return;
  }
 
  unsigned int getNumSamplesPerDigi() const { return numSamplesPerDigi_; }
 
  void setNumSamplesPerDigi(unsigned int n) {
    numSamplesPerDigi_ = n;
    return;
  }
 
  unsigned int getSampleOfInterestIndex() const { return sampleOfInterest_; }
 
  void setSampleOfInterestIndex(unsigned int n) {
    sampleOfInterest_ = n;
    return;
  }
 
  const HgcrocDigi getDigi(unsigned int digiIndex) const;
 
  unsigned int getNumDigis() const { return channelIDs_.size(); }
 
  unsigned int size() const { return channelIDs_.size(); }
 
  void addDigi(unsigned int id, const std::vector<Sample>& digi);
  void addDigi(unsigned int id, const std::vector<uint32_t>& digi);
 
 public:
  class iterator
      : public std::iterator<std::input_iterator_tag, HgcrocDigi, long> {
   public:
    explicit iterator(HgcrocDigiCollection& c, long index = 0)
        : digi_index_{index}, coll_{c} {}
    iterator& operator++() {
      digi_index_++;
      return *this;
    }
    iterator operator++(int) {
      iterator retval = *this;
      ++(*this);
      return retval;
    }
    bool operator==(iterator other) const {
      return digi_index_ == other.digi_index_;
    }
    bool operator!=(iterator other) const { return !(*this == other); }
    const HgcrocDigi operator*() const { return coll_.getDigi(digi_index_); }
 
   private:
    long digi_index_{0};
    HgcrocDigiCollection& coll_;
  };  // iterator
 
 public:
  iterator begin() { return iterator(*this, 0); }
 
  iterator end() { return iterator(*this, getNumDigis()); }
 
 private:
  static const int ONE_BIT_MASK = 1;
 
  static const int TEN_BIT_MASK = (1 << 10) - 1;
 
  static const int FIRSTFLAG_POS = 31;
 
  static const int SECONFLAG_POS = 30;
 
  static const int FIRSTMEAS_POS = 20;
 
  static const int SECONMEAS_POS = 10;
 
 private:
  std::vector<unsigned int> channelIDs_;
 
  std::vector<uint32_t> samples_;
 
  unsigned int numSamplesPerDigi_;
 
  unsigned int sampleOfInterest_;
 
  int version_;
 
  ClassDef(HgcrocDigiCollection, 4);
};
}  // namespace ldmx
 
std::ostream& operator<<(std::ostream& s,
                         const ldmx::HgcrocDigiCollection::Sample& sample);
 
std::ostream& operator<<(std::ostream& s,
                         const ldmx::HgcrocDigiCollection::HgcrocDigi& digi);
 
std::ostream& operator<<(std::ostream& s,
                         const ldmx::HgcrocDigiCollection& col);
 
#endif /* RECON_EVENT_ECALDIGI_H_ */