HBHEChannelInfo.h

Go to the documentation of this file.

#ifndef DataFormats_HcalRecHit_HBHEChannelInfo_h_
#define DataFormats_HcalRecHit_HBHEChannelInfo_h_

#include <cfloat>

#include "DataFormats/HcalDetId/interface/HcalDetId.h"
#include "DataFormats/HcalRecHit/interface/HcalSpecialTimes.h"

class HBHEChannelInfo {
public:
  typedef HcalDetId key_type;

  static const unsigned MAXSAMPLES = 10;

  constexpr HBHEChannelInfo()
      : id_(),
        rawCharge_{0.},
        pedestal_{0.},
        pedestalWidth_{0.},
        gain_{0.},
        gainWidth_{0.},
        darkCurrent_{0},
        fcByPE_{0},
        lambda_{0},
        riseTime_{0.f},
        adc_{0},
        dFcPerADC_{0.f},
        recoShape_{0},
        nSamples_{0},
        soi_{0},
        capid_{0},
        hasTimeInfo_{false},
        hasEffectivePedestals_{false},
        dropped_{true},
        hasLinkError_{false},
        hasCapidError_{false} {}

  constexpr explicit HBHEChannelInfo(const bool hasTimeFromTDC, const bool hasEffectivePed)
      : id_(),
        rawCharge_{0.},
        pedestal_{0.},
        pedestalWidth_{0.},
        gain_{0.},
        gainWidth_{0.},
        darkCurrent_{0},
        fcByPE_{0},
        lambda_{0},
        riseTime_{0.f},
        adc_{0},
        dFcPerADC_{0.f},
        recoShape_{0},
        nSamples_{0},
        soi_{0},
        capid_{0},
        hasTimeInfo_(hasTimeFromTDC),
        hasEffectivePedestals_(hasEffectivePed),
        dropped_{true},
        hasLinkError_{false},
        hasCapidError_{false} {}

  constexpr void clear() {
    id_ = HcalDetId(0U);
    recoShape_ = 0;
    nSamples_ = 0;
    soi_ = 0;
    capid_ = 0;
    darkCurrent_ = 0;
    fcByPE_ = 0;
    lambda_ = 0, dropped_ = true;
    hasLinkError_ = false;
    hasCapidError_ = false;
  }

  constexpr void setChannelInfo(const HcalDetId& detId,
                                const int recoShape,
                                const unsigned nSamp,
                                const unsigned iSoi,
                                const int iCapid,
                                const double darkCurrent,
                                const double fcByPE,
                                const double lambda,
                                const bool linkError,
                                const bool capidError,
                                const bool dropThisChannel) {
    recoShape_ = recoShape;
    id_ = detId;
    nSamples_ = nSamp < MAXSAMPLES ? nSamp : MAXSAMPLES;
    soi_ = iSoi;
    capid_ = iCapid;
    darkCurrent_ = darkCurrent;
    fcByPE_ = fcByPE;
    lambda_ = lambda, dropped_ = dropThisChannel;
    hasLinkError_ = linkError;
    hasCapidError_ = capidError;
  }

  constexpr void tagAsDropped() { dropped_ = true; }

  // For speed, the "setSample" function does not perform bounds checking
  constexpr void setSample(const unsigned ts,
                           const uint8_t rawADC,
                           const float differentialChargeGain,
                           const double q,
                           const double ped,
                           const double pedWidth,
                           const double g,
                           const double gainWidth,
                           const float t) {
    rawCharge_[ts] = q;
    riseTime_[ts] = t;
    adc_[ts] = rawADC;
    dFcPerADC_[ts] = differentialChargeGain;
    pedestal_[ts] = ped;
    gain_[ts] = g;
    pedestalWidth_[ts] = pedWidth;
    gainWidth_[ts] = gainWidth;
  }

  // Inspectors
  constexpr HcalDetId id() const { return id_; }

  // access the recoShape
  constexpr int recoShape() const { return recoShape_; }

  constexpr unsigned nSamples() const { return nSamples_; }
  constexpr unsigned soi() const { return soi_; }
  constexpr int capid() const { return capid_; }
  constexpr bool hasTimeInfo() const { return hasTimeInfo_; }
  constexpr bool hasEffectivePedestals() const { return hasEffectivePedestals_; }
  constexpr double darkCurrent() const { return darkCurrent_; }
  constexpr double fcByPE() const { return fcByPE_; }
  constexpr double lambda() const { return lambda_; }
  constexpr bool isDropped() const { return dropped_; }
  constexpr bool hasLinkError() const { return hasLinkError_; }
  constexpr bool hasCapidError() const { return hasCapidError_; }

  // Direct read-only access to time slice arrays
  constexpr double const* rawCharge() const { return rawCharge_; }
  constexpr double const* pedestal() const { return pedestal_; }
  constexpr double const* pedestalWidth() const { return pedestalWidth_; }
  constexpr double const* gain() const { return gain_; }
  constexpr double const* gainWidth() const { return gainWidth_; }
  constexpr uint8_t const* adc() const { return adc_; }
  constexpr float const* dFcPerADC() const { return dFcPerADC_; }
  constexpr float const* riseTime() const {
    if (hasTimeInfo_)
      return riseTime_;
    else
      return nullptr;
  }

  // Indexed access to time slice quantities. No bounds checking.
  constexpr double tsRawCharge(const unsigned ts) const { return rawCharge_[ts]; }
  constexpr double tsPedestal(const unsigned ts) const { return pedestal_[ts]; }
  constexpr double tsPedestalWidth(const unsigned ts) const { return pedestalWidth_[ts]; }
  constexpr double tsGain(const unsigned ts) const { return gain_[ts]; }
  constexpr double tsGainWidth(const unsigned ts) const { return gainWidth_[ts]; }
  constexpr double tsCharge(const unsigned ts) const { return rawCharge_[ts] - pedestal_[ts]; }
  constexpr double tsEnergy(const unsigned ts) const { return (rawCharge_[ts] - pedestal_[ts]) * gain_[ts]; }
  constexpr uint8_t tsAdc(const unsigned ts) const { return adc_[ts]; }
  constexpr float tsDFcPerADC(const unsigned ts) const { return dFcPerADC_[ts]; }
  constexpr float tsRiseTime(const unsigned ts) const {
    return hasTimeInfo_ ? riseTime_[ts] : HcalSpecialTimes::UNKNOWN_T_NOTDC;
  }

  // Signal rise time measurement for the SOI, if available
  constexpr float soiRiseTime() const {
    return (hasTimeInfo_ && soi_ < nSamples_) ? riseTime_[soi_] : HcalSpecialTimes::UNKNOWN_T_NOTDC;
  }

  // The TS with the "end" index is not included in the window
  constexpr double chargeInWindow(const unsigned begin, const unsigned end) const {
    double sum = 0.0;
    const unsigned imax = end < nSamples_ ? end : nSamples_;
    for (unsigned i = begin; i < imax; ++i)
      sum += (rawCharge_[i] - pedestal_[i]);
    return sum;
  }

  constexpr double energyInWindow(const unsigned begin, const unsigned end) const {
    double sum = 0.0;
    const unsigned imax = end < nSamples_ ? end : nSamples_;
    for (unsigned i = begin; i < imax; ++i)
      sum += (rawCharge_[i] - pedestal_[i]) * gain_[i];
    return sum;
  }

  // The two following methods return MAXSAMPLES if the specified
  // window does not overlap with the samples stored
  constexpr unsigned peakChargeTS(const unsigned begin, const unsigned end) const {
    unsigned iPeak = MAXSAMPLES;
    double dmax = -DBL_MAX;
    const unsigned imax = end < nSamples_ ? end : nSamples_;
    for (unsigned i = begin; i < imax; ++i) {
      const double q = rawCharge_[i] - pedestal_[i];
      if (q > dmax) {
        dmax = q;
        iPeak = i;
      }
    }
    return iPeak;
  }

  constexpr unsigned peakEnergyTS(const unsigned begin, const unsigned end) const {
    unsigned iPeak = MAXSAMPLES;
    double dmax = -DBL_MAX;
    const unsigned imax = end < nSamples_ ? end : nSamples_;
    for (unsigned i = begin; i < imax; ++i) {
      const double e = (rawCharge_[i] - pedestal_[i]) * gain_[i];
      if (e > dmax) {
        dmax = e;
        iPeak = i;
      }
    }
    return iPeak;
  }

  // The following function can be used, for example,
  // in a check for presence of saturated ADC values
  constexpr uint8_t peakAdcValue(const unsigned begin, const unsigned end) const {
    uint8_t peak = 0;
    const unsigned imax = end < nSamples_ ? end : nSamples_;
    for (unsigned i = begin; i < imax; ++i)
      if (adc_[i] > peak)
        peak = adc_[i];
    return peak;
  }

private:
  HcalDetId id_;

  // Charge in fC for all time slices
  double rawCharge_[MAXSAMPLES];

  // Pedestal in fC
  double pedestal_[MAXSAMPLES];

  // Pedestal Width in fC
  double pedestalWidth_[MAXSAMPLES];

  // fC to GeV conversion factor
  double gain_[MAXSAMPLES];

  // fC to GeV conversion factor
  double gainWidth_[MAXSAMPLES];

  // needed for the dark current
  double darkCurrent_;
  double fcByPE_;
  double lambda_;

  // Signal rise time from TDC in ns (if provided)
  float riseTime_[MAXSAMPLES];

  // Raw QIE ADC values
  uint8_t adc_[MAXSAMPLES];

  // Differential fC/ADC gain. Needed for proper determination
  // of the ADC quantization error.
  float dFcPerADC_[MAXSAMPLES];

  // Reco Shapes
  int32_t recoShape_;

  // Number of time slices actually filled
  uint32_t nSamples_;

  // "Sample of interest" in the array of time slices
  uint32_t soi_;

  // QIE8 or QIE11 CAPID for the sample of interest
  int32_t capid_;

  // Flag indicating presence of the time info from TDC (QIE11)
  bool hasTimeInfo_;

  // Flag indicating use of effective pedestals
  bool hasEffectivePedestals_;

  // Flag indicating that this channel should be dropped
  // (typically, tagged bad from DB or zero-suppressed)
  bool dropped_;

  // Flags indicating presence of hardware errors
  bool hasLinkError_;
  bool hasCapidError_;
};

#endif  // DataFormats_HcalRecHit_HBHEChannelInfo_h_