HGCalSiNoiseMap.h

Go to the documentation of this file.

#ifndef simcalorimetry_hgcalsimalgos_hgcalsinoisemap
#define simcalorimetry_hgcalsimalgos_hgcalsinoisemap
 
#include "SimCalorimetry/HGCalSimAlgos/interface/HGCalRadiationMap.h"
#include "SimCalorimetry/HGCalSimProducers/interface/HGCFEElectronics.h"
#include "DataFormats/ForwardDetId/interface/HGCSiliconDetId.h"
#include "DataFormats/ForwardDetId/interface/HFNoseDetId.h"
#include "Geometry/HGCalGeometry/interface/HGCalGeometry.h"
#include <string>
#include <array>
#include <unordered_map>
 
template <typename T>
class HGCalSiNoiseMap : public HGCalRadiationMap {
public:
  enum GainRange_t { q80fC, q160fC, q320fC, AUTO };
  enum NoiseMapAlgoBits_t { FLUENCE, CCE, NOISE, PULSEPERGAIN, CACHEDOP };
 
  struct SiCellOpCharacteristicsCore {
    SiCellOpCharacteristicsCore() : cce(0.), noise(0.), gain(0), thrADC(0) {}
    float cce, noise;
    unsigned short gain, thrADC;
  };
 
  struct SiCellOpCharacteristics {
    SiCellOpCharacteristics() : lnfluence(0.), fluence(0.), ileak(0.), enc_s(0.), enc_p(0.), mipfC(0), mipADC(0) {}
    SiCellOpCharacteristicsCore core;
    double lnfluence, fluence, ileak, enc_s, enc_p, mipfC;
    unsigned int mipADC;
  };
 
  HGCalSiNoiseMap();
  ~HGCalSiNoiseMap(){};
 
  void setIleakParam(const std::vector<double> &pars) { ileakParam_ = pars; }
 
  void setCceParam(const std::vector<double> &parsFine,
                   const std::vector<double> &parsThin,
                   const std::vector<double> &parsThick) {
    cceParam_.push_back(parsFine);   //120
    cceParam_.push_back(parsThin);   //200
    cceParam_.push_back(parsThick);  //300
  }
 
  void setDoseMap(const std::string &, const unsigned int &);
 
  void setGeometry(const CaloSubdetectorGeometry *, GainRange_t gain = GainRange_t::AUTO, int aimMIPtoADC = 10);
 
  const SiCellOpCharacteristicsCore getSiCellOpCharacteristicsCore(const T &did, GainRange_t gain, int aimMIPtoADC);
  const SiCellOpCharacteristicsCore getSiCellOpCharacteristicsCore(const T &did) {
    return getSiCellOpCharacteristicsCore(did, defaultGain_, defaultAimMIPtoADC_);
  }
 
  SiCellOpCharacteristics getSiCellOpCharacteristics(const T &did,
                                                     GainRange_t gain = GainRange_t::AUTO,
                                                     int aimMIPtoADC = 10);
  SiCellOpCharacteristics getSiCellOpCharacteristics(double &cellCap,
                                                     double &cellVol,
                                                     double &mipEqfC,
                                                     std::vector<double> &cceParam,
                                                     int &subdet,
                                                     int &layer,
                                                     double &radius,
                                                     GainRange_t &gain,
                                                     int &aimMIPtoADC);
 
  std::array<double, 3> &getMipEqfC() { return mipEqfC_; }
  std::array<double, 3> &getCellCapacitance() { return cellCapacitance_; }
  std::array<double, 3> &getCellVolume() { return cellVolume_; }
  std::vector<std::vector<double> > &getCCEParam() { return cceParam_; }
  std::vector<double> &getIleakParam() { return ileakParam_; }
  std::vector<std::vector<double> > &getENCsParam() { return encsParam_; }
  std::vector<double> &getLSBPerGain() { return lsbPerGain_; }
  void setDefaultADCPulseShape(const hgc_digi::FEADCPulseShape &adcPulse) { defaultADCPulse_ = adcPulse; };
  const hgc_digi::FEADCPulseShape &adcPulseForGain(GainRange_t gain) {
    if (ignoreGainDependentPulse_)
      return defaultADCPulse_;
    return adcPulses_[gain];
  };
  std::vector<double> &getMaxADCPerGain() { return chargeAtFullScaleADCPerGain_; }
  double getENCpad(double ileak);
  void setCachedOp(bool flag) { activateCachedOp_ = flag; }
 
  inline void setENCCommonNoiseSubScale(double val) { encCommonNoiseSub_ = val; }
 
private:
  GainRange_t defaultGain_;
  int defaultAimMIPtoADC_;
 
  //cache of SiCellOpCharacteristics
  std::map<uint32_t, SiCellOpCharacteristicsCore> siopCache_;
 
  //vector of three params, per sensor type: 0:120 [mum], 1:200, 2:300
  std::array<double, 3> mipEqfC_, cellCapacitance_, cellVolume_;
  std::vector<std::vector<double> > cceParam_;
 
  //leakage current/volume vs fluence
  std::vector<double> ileakParam_;
 
  //common noise subtraction noise (final scaling value)
  double encCommonNoiseSub_;
 
  //electron charge in fC
  const double qe2fc_;
 
  //electronics noise (series+parallel) polynomial coeffs and ADC pulses;
  std::vector<std::vector<double> > encsParam_;
  hgc_digi::FEADCPulseShape defaultADCPulse_;
  std::vector<hgc_digi::FEADCPulseShape> adcPulses_;
 
  //lsb
  std::vector<double> lsbPerGain_, chargeAtFullScaleADCPerGain_;
 
  //conversions
  const double unitToMicro_ = 1.e6;
  const double unitToMicroLog_ = log(unitToMicro_);
 
  //flags used to disable specific components of the Si operation parameters or usage of operation cache
  bool ignoreFluence_, ignoreCCE_, ignoreNoise_, ignoreGainDependentPulse_, activateCachedOp_;
};
 
#include "HGCalSiNoiseMap.icc"
 
template class HGCalSiNoiseMap<HGCSiliconDetId>;
template class HGCalSiNoiseMap<HFNoseDetId>;
 
#endif