HGCFEElectronics.h

Go to the documentation of this file.

#ifndef _hgcfeelectronics_h_
#define _hgcfeelectronics_h_

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "CLHEP/Random/RandGauss.h"
#include "CLHEP/Random/RandGaussQ.h"

#include "SimCalorimetry/HGCalSimProducers/interface/HGCDigitizerTypes.h"

namespace hgc = hgc_digi;

template <class DFr>
class HGCFEElectronics
{
 public:
  
  enum HGCFEElectronicsFirmwareVersion { TRIVIAL, SIMPLE, WITHTOT };
  enum HGCFEElectronicsTOTMode { WEIGHTEDBYE, SIMPLETHRESHOLD };

  HGCFEElectronics(const edm::ParameterSet &ps);

  inline void runShaper(DFr &dataFrame, hgc::HGCSimHitData& chargeColl, 
                        hgc::HGCSimHitData& toa, int thickness, CLHEP::HepRandomEngine* engine, float cce = 1.0)
  {    
    switch(fwVersion_)
      {
      case SIMPLE :  { runSimpleShaper(dataFrame,chargeColl, thickness, cce);      break; }
      case WITHTOT : { runShaperWithToT(dataFrame,chargeColl,toa, thickness, engine, cce); break; }
      default :      { runTrivialShaper(dataFrame,chargeColl, thickness, cce);     break; }
      }
  }


  void SetNoiseValues(const std::vector<float>& noise_fC){
    noise_fC_.insert(noise_fC_.end(), noise_fC.begin(), noise_fC.end());
  };

  float getTimeJitter(float totalCharge, int thickness){
    float A2 = jitterNoise2_ns_.at(thickness-1);
    float C2 = jitterConstant2_ns_.at(thickness-1);
    float X2 = pow((totalCharge/noise_fC_.at(thickness-1)), 2.);
    float jitter2 = A2 / X2 + C2;
    return sqrt(jitter2);
  };

  float getADClsb()       { return adcLSB_fC_;       }
  float getTDClsb()       { return tdcLSB_fC_;       }  
  float getADCThreshold() { return adcThreshold_fC_; }
  float getTDCOnset()     { return tdcOnset_fC_;     }
  std::array<float,3> getTDCForToAOnset()    { return tdcForToAOnset_fC_; }
  void setADClsb(float newLSB) { adcLSB_fC_=newLSB; }

  void runTrivialShaper(DFr &dataFrame, hgc::HGCSimHitData& chargeColl, int thickness, float cce = 1.0);

  void runSimpleShaper(DFr &dataFrame, hgc::HGCSimHitData& chargeColl, int thickness, float cce = 1.0);

  void runShaperWithToT(DFr &dataFrame, hgc::HGCSimHitData& chargeColl, 
                        hgc::HGCSimHitData& toa, int thickness, CLHEP::HepRandomEngine* engine, float cce = 1.0);

  uint32_t toaMode() const { return toaMode_; }
  
  ~HGCFEElectronics() {}

 private:
  
  //private members
  uint32_t fwVersion_;
  std::array<float,6> adcPulse_, pulseAvgT_;
  std::array<float,3> tdcForToAOnset_fC_;
  std::vector<float> tdcChargeDrainParameterisation_;
  float adcSaturation_fC_, adcLSB_fC_, tdcLSB_fC_, tdcSaturation_fC_,
    adcThreshold_fC_, tdcOnset_fC_, toaLSB_ns_, tdcResolutionInNs_;
  std::array<float,3> jitterNoise2_ns_, jitterConstant2_ns_;
  std::vector<float> noise_fC_;
  uint32_t toaMode_;
  bool thresholdFollowsMIP_;
  //caches
  std::array<bool,hgc::nSamples>  busyFlags, totFlags, toaFlags;
  hgc::HGCSimHitData newCharge, toaFromToT;
};

#endif