HFSimpleTimeCheck.h

Go to the documentation of this file.

#ifndef RecoLocalCalo_HcalRecAlgos_HFSimpleTimeCheck_h_
#define RecoLocalCalo_HcalRecAlgos_HFSimpleTimeCheck_h_

#include <utility>

#include "RecoLocalCalo/HcalRecAlgos/interface/AbsHFPhase1Algo.h"
#include "RecoLocalCalo/HcalRecAlgos/interface/HFAnodeStatus.h"

class HFSimpleTimeCheck : public AbsHFPhase1Algo {
public:
  // "tlimits" are the rise time limits for the anode pair.
  // The first element of the pair is the min rise time and the
  // second element is the max rise time. tlimits[0] is for the
  // first anode and tlimits[1] is for the second one.
  //
  // "energyWeights" is the lookup table for the energy weights
  // based on the multi-state decision about anode quality.
  // The first index of this array corresponds to the decision
  // about the status of the anodes, and the second index corresponds
  // to the anode number. Possible status values are given in the
  // HFAnodeStatus enum. Mapping of the first index to the possible
  // status values is as follows:
  //
  // Indices 0 to HFAnodeStatus::N_POSSIBLE_STATES-1 correspond to
  // the situations in which the first anode has the status "OK"
  // and the second anode has the status given by the index.
  //
  // HFAnodeStatus::N_POSSIBLE_STATES to HFAnodeStatus::N_POSSIBLE_STATES-2
  // correspond to the situations in which the second anode has
  // the status "OK" and the first anode has the status given
  // by index - HFAnodeStatus::N_POSSIBLE_STATES + 1. This excludes
  // the state {OK, OK} already covered.
  //
  // "soiPhase" argument specifies the desired position of the
  // sample of interest ADC in the ADC bytes written out into the
  // aux words of the HFRecHit. For more detail, see comments
  // inside the HFRecHitAuxSetter.h header.
  //
  // "timeShift" value (in ns) will be added to all valid times
  // returned by QIE10 TDCs. This shift is used both for applying
  // the timing cuts and for rechit construction.
  //
  // "triseIfNoTDC" and "tfallIfNoTDC": the rechit rise and
  // fall times will be set to these values in case meaningful
  // TDC information is not available for any of the PMT anodes
  // (time shift is not added to these numbers).
  //
  // For monitoring purposes, "rejectAllFailures" can be set to
  // "false". In this case, for the energy reconstruction purposes,
  // all status values indicating that the anode is not passing
  // algorithm cuts will be mapped to "OK". However, HFRecHit
  // will still be made using proper status flags.
  //
  // If "alwaysCalculateChargeAsymmetry" is true, charge asymmetry
  // status bit will be set whenever the data is available for both
  // anodes. If "alwaysCalculateChargeAsymmetry" is false, the bit
  // will be set only if the status of both anodes is "OK" (or mapped
  // into "OK").
  //
  HFSimpleTimeCheck(const std::pair<float, float> tlimits[2],
                    const float energyWeights[2 * HFAnodeStatus::N_POSSIBLE_STATES - 1][2],
                    unsigned soiPhase,
                    float timeShift,
                    float triseIfNoTDC,
                    float tfallIfNoTDC,
                    float minChargeForUndershoot,
                    float minChargeForOvershoot,
                    bool rejectAllFailures = true,
                    bool alwaysCalculateChargeAsymmetry = true);

  inline ~HFSimpleTimeCheck() override {}

  inline bool isConfigurable() const override { return false; }

  HFRecHit reconstruct(const HFPreRecHit& prehit,
                       const HcalCalibrations& calibs,
                       const bool flaggedBadInDB[2],
                       bool expectSingleAnodePMT) override;

  inline unsigned soiPhase() const { return soiPhase_; }
  inline float timeShift() const { return timeShift_; }
  inline float triseIfNoTDC() const { return triseIfNoTDC_; }
  inline float tfallIfNoTDC() const { return tfallIfNoTDC_; }
  inline float minChargeForUndershoot() const { return minChargeForUndershoot_; }
  inline float minChargeForOvershoot() const { return minChargeForOvershoot_; }
  inline bool rejectingAllFailures() const { return rejectAllFailures_; }
  inline bool alwaysCalculatingQAsym() const { return alwaysQAsym_; }

protected:
  virtual unsigned determineAnodeStatus(unsigned anodeNumber, const HFQIE10Info& anode, bool* isTimingReliable) const;

private:
  // Map possible status values into the first index of "energyWeights_"
  unsigned mapStatusIntoIndex(const unsigned states[2]) const;

  std::pair<float, float> tlimits_[2];
  float energyWeights_[2 * HFAnodeStatus::N_POSSIBLE_STATES - 1][2];
  unsigned soiPhase_;
  float timeShift_;
  float triseIfNoTDC_;
  float tfallIfNoTDC_;
  float minChargeForUndershoot_;
  float minChargeForOvershoot_;
  bool rejectAllFailures_;
  bool alwaysQAsym_;
};

#endif  // RecoLocalCalo_HcalRecAlgos_HFSimpleTimeCheck_h_