models the behavior of the front-end electronics More...

#include <HGCFEElectronics.h>

Public Types
enum	HGCFEElectronicsFirmwareVersion { TRIVIAL, SIMPLE, WITHTOT }

enum	HGCFEElectronicsTOTMode { WEIGHTEDBYE, SIMPLETHRESHOLD }

Public Member Functions
float	getADClsb ()
	returns the LSB in MIP currently configured More...

float	getADCThreshold ()

hgc_digi::FEADCPulseShape &	getDefaultADCPulse ()
	getter for the default ADC pulse configured by python More...

int	getTargetMipValue ()

std::array< float, 3 >	getTDCForToAOnset ()

float	getTDClsb ()

float	getTDCOnset ()

float	getTimeJitter (float totalCharge, int thickness)

	HGCFEElectronics (const edm::ParameterSet &ps)
	CTOR. More...

void	runShaper (DFr &dataFrame, hgc::HGCSimHitData &chargeColl, hgc::HGCSimHitData &toa, CLHEP::HepRandomEngine *engine, uint32_t thrADC=0, float lsbADC=-1, uint32_t gainIdx=0, float maxADC=-1, int thickness=1)

void	runShaper (DFr &dataFrame, hgc::HGCSimHitData &chargeColl, hgc::HGCSimHitData &toa, const hgc_digi::FEADCPulseShape &adcPulse, CLHEP::HepRandomEngine *engine, uint32_t thrADC=0, float lsbADC=-1, uint32_t gainIdx=0, float maxADC=-1, int thickness=1, float tdcOnsetAuto=-1)
	switches according to the firmware version More...

void	runShaperWithToT (DFr &dataFrame, hgc::HGCSimHitData &chargeColl, hgc::HGCSimHitData &toa, CLHEP::HepRandomEngine *engine, uint32_t thrADC, float lsbADC, uint32_t gainIdx, float maxADC, int thickness, float tdcOnsetAuto)

void	runShaperWithToT (DFr &dataFrame, hgc::HGCSimHitData &chargeColl, hgc::HGCSimHitData &toa, CLHEP::HepRandomEngine *engine, uint32_t thrADC, float lsbADC, uint32_t gainIdx, float maxADC, int thickness, float tdcOnsetAuto, const hgc_digi::FEADCPulseShape &adcPulse)
	implements pulse shape and switch to time over threshold including deadtime More...

void	runSimpleShaper (DFr &dataFrame, hgc::HGCSimHitData &chargeColl, uint32_t thrADC, float lsbADC, uint32_t gainIdx, float maxADC)

void	runSimpleShaper (DFr &dataFrame, hgc::HGCSimHitData &chargeColl, uint32_t thrADC, float lsbADC, uint32_t gainIdx, float maxADC, const hgc_digi::FEADCPulseShape &adcPulse)
	applies a shape to each time sample and propagates the tails to the subsequent time samples More...

void	runTrivialShaper (DFr &dataFrame, hgc::HGCSimHitData &chargeColl, uint32_t thrADC, float lsbADC, uint32_t gainIdx, float maxADC)
	converts charge to digis without pulse shape More...

void	setADClsb (float newLSB)

void	SetNoiseValues (const std::vector< float > &noise_fC)

uint32_t	toaMode () const
	returns how ToT will be computed More...

	~HGCFEElectronics ()
	DTOR. More...

Private Attributes
float	adcLSB_fC_

hgc_digi::FEADCPulseShape	adcPulse_

float	adcSaturation_fC_

float	adcThreshold_fC_

std::array< bool, hgc::nSamples >	busyFlags

uint32_t	fwVersion_

std::array< float, 3 >	jitterConstant2_ns_

std::array< float, 3 >	jitterNoise2_ns_

hgc::HGCSimHitData	newCharge

std::vector< float >	noise_fC_

hgc_digi::FEADCPulseShape	pulseAvgT_

uint32_t	targetMIPvalue_ADC_

std::vector< float >	tdcChargeDrainParameterisation_

std::array< float, 3 >	tdcForToAOnset_fC_

float	tdcLSB_fC_

float	tdcOnset_fC_

float	tdcResolutionInNs_

float	tdcSaturation_fC_

bool	thresholdFollowsMIP_

std::array< bool, hgc::nSamples >	toaFlags

hgc::HGCSimHitData	toaFromToT

float	toaLSB_ns_

uint32_t	toaMode_

std::array< bool, hgc::nSamples >	totFlags

Detailed Description

template<class DFr>
class HGCFEElectronics< DFr >

models the behavior of the front-end electronics

Definition at line 24 of file HGCFEElectronics.h.

Member Enumeration Documentation

◆ HGCFEElectronicsFirmwareVersion

template<class DFr >

enum HGCFEElectronics::HGCFEElectronicsFirmwareVersion

Enumerator
TRIVIAL
SIMPLE
WITHTOT

Definition at line 26 of file HGCFEElectronics.h.

26 { TRIVIAL, SIMPLE, WITHTOT };

◆ HGCFEElectronicsTOTMode

template<class DFr >

enum HGCFEElectronics::HGCFEElectronicsTOTMode

Enumerator
WEIGHTEDBYE
SIMPLETHRESHOLD

Definition at line 27 of file HGCFEElectronics.h.

27 { WEIGHTEDBYE, SIMPLETHRESHOLD };

Constructor & Destructor Documentation

◆ HGCFEElectronics()

template<class DFr >

HGCFEElectronics< DFr >::HGCFEElectronics ( const edm::ParameterSet & ps )

CTOR.

Definition at line 11 of file HGCFEElectronics.cc.

     : fwVersion_{ps.getParameter<uint32_t>("fwVersion")},
       adcPulse_{},
       pulseAvgT_{},
       tdcForToAOnset_fC_{},
       adcSaturation_fC_{-1.0},
       adcLSB_fC_{},
       tdcLSB_fC_{},
       tdcSaturation_fC_{-1.0},
       adcThreshold_fC_{},
       tdcOnset_fC_{},
       toaLSB_ns_{},
       tdcResolutionInNs_{1e-9},  // set time resolution very small by default
       targetMIPvalue_ADC_{},
       jitterNoise2_ns_{},
       jitterConstant2_ns_{},
       noise_fC_{},
       toaMode_(WEIGHTEDBYE) {
   edm::LogVerbatim("HGCFE") << "[HGCFEElectronics] running with version " << fwVersion_ << std::endl;
   if (ps.exists("adcPulse")) {
     auto temp = ps.getParameter<std::vector<double> >("adcPulse");
     for (unsigned i = 0; i < temp.size(); ++i) {
       adcPulse_[i] = (float)temp[i];
     }
     // normalize adc pulse
     for (unsigned i = 0; i < adcPulse_.size(); ++i) {
       adcPulse_[i] = adcPulse_[i] / adcPulse_[2];
     }
     temp = ps.getParameter<std::vector<double> >("pulseAvgT");
     for (unsigned i = 0; i < temp.size(); ++i) {
       pulseAvgT_[i] = (float)temp[i];
     }
   }
   if (ps.exists("adcNbits")) {
     uint32_t adcNbits = ps.getParameter<uint32_t>("adcNbits");
     adcSaturation_fC_ = ps.getParameter<double>("adcSaturation_fC");
     adcLSB_fC_ = adcSaturation_fC_ / pow(2., adcNbits);
     edm::LogVerbatim("HGCFE") << "[HGCFEElectronics] " << adcNbits << " bit ADC defined"
                               << " with LSB=" << adcLSB_fC_ << " saturation to occur @ " << adcSaturation_fC_
                               << std::endl;
   }
  
   if (ps.exists("tdcNbits")) {
     uint32_t tdcNbits = ps.getParameter<uint32_t>("tdcNbits");
     tdcSaturation_fC_ = ps.getParameter<double>("tdcSaturation_fC");
     tdcLSB_fC_ = tdcSaturation_fC_ / pow(2., tdcNbits);
     // lower tdcSaturation_fC_ by one part in a million
     // to ensure largest charge converted in bits is 0xfff and not 0x000
     tdcSaturation_fC_ *= (1. - 1e-6);
     edm::LogVerbatim("HGCFE") << "[HGCFEElectronics] " << tdcNbits << " bit TDC defined with LSB=" << tdcLSB_fC_
                               << " saturation to occur @ " << tdcSaturation_fC_
                               << " (NB lowered by 1 part in a million)" << std::endl;
   }
   if (ps.exists("targetMIPvalue_ADC"))
     targetMIPvalue_ADC_ = ps.getParameter<uint32_t>("targetMIPvalue_ADC");
   if (ps.exists("adcThreshold_fC"))
     adcThreshold_fC_ = ps.getParameter<double>("adcThreshold_fC");
   if (ps.exists("tdcOnset_fC"))
     tdcOnset_fC_ = ps.getParameter<double>("tdcOnset_fC");
   if (ps.exists("tdcForToAOnset_fC")) {
     auto temp = ps.getParameter<std::vector<double> >("tdcForToAOnset_fC");
     if (temp.size() == tdcForToAOnset_fC_.size()) {
       std::copy_n(temp.begin(), temp.size(), tdcForToAOnset_fC_.begin());
     } else {
       throw cms::Exception("BadConfiguration") << " HGCFEElectronics wrong size for ToA thresholds ";
     }
   }
   if (ps.exists("toaLSB_ns"))
     toaLSB_ns_ = ps.getParameter<double>("toaLSB_ns");
   if (ps.exists("tdcChargeDrainParameterisation")) {
     for (auto val : ps.getParameter<std::vector<double> >("tdcChargeDrainParameterisation")) {
       tdcChargeDrainParameterisation_.push_back((float)val);
     }
   }
   if (ps.exists("tdcResolutionInPs"))
     tdcResolutionInNs_ = ps.getParameter<double>("tdcResolutionInPs") * 1e-3;  // convert to ns
   if (ps.exists("toaMode"))
     toaMode_ = ps.getParameter<uint32_t>("toaMode");
  
   if (ps.exists("jitterNoise_ns")) {
     auto temp = ps.getParameter<std::vector<double> >("jitterNoise_ns");
     if (temp.size() == jitterNoise2_ns_.size()) {
       std::copy_n(temp.begin(), temp.size(), jitterNoise2_ns_.begin());
     } else {
       throw cms::Exception("BadConfiguration") << " HGCFEElectronics wrong size for ToA jitterNoise ";
     }
   }
   if (ps.exists("jitterConstant_ns")) {
     auto temp = ps.getParameter<std::vector<double> >("jitterConstant_ns");
     if (temp.size() == jitterConstant2_ns_.size()) {
       std::copy_n(temp.begin(), temp.size(), jitterConstant2_ns_.begin());
     } else {
       throw cms::Exception("BadConfiguration") << " HGCFEElectronics wrong size for ToA jitterConstant ";
     }
   }
 }

References edm::ParameterSet::getParameter().

◆ ~HGCFEElectronics()

template<class DFr >

HGCFEElectronics< DFr >::~HGCFEElectronics ( )

inline

DTOR.

Definition at line 161 of file HGCFEElectronics.h.

161 {}

Member Function Documentation

◆ getADClsb()

template<class DFr >

float HGCFEElectronics< DFr >::getADClsb ( )

inline

returns the LSB in MIP currently configured

Definition at line 91 of file HGCFEElectronics.h.

91 { return adcLSB_fC_; }

References HGCFEElectronics< DFr >::adcLSB_fC_.

◆ getADCThreshold()

template<class DFr >

float HGCFEElectronics< DFr >::getADCThreshold ( )

inline

Definition at line 94 of file HGCFEElectronics.h.

94 { return adcThreshold_fC_; }

References HGCFEElectronics< DFr >::adcThreshold_fC_.

◆ getDefaultADCPulse()

template<class DFr >

hgc_digi::FEADCPulseShape& HGCFEElectronics< DFr >::getDefaultADCPulse ( )

inline

getter for the default ADC pulse configured by python

Definition at line 156 of file HGCFEElectronics.h.

156 { return adcPulse_; }

References HGCFEElectronics< DFr >::adcPulse_.

◆ getTargetMipValue()

template<class DFr >

int HGCFEElectronics< DFr >::getTargetMipValue ( )

inline

Definition at line 93 of file HGCFEElectronics.h.

93 { return targetMIPvalue_ADC_; }

References HGCFEElectronics< DFr >::targetMIPvalue_ADC_.

◆ getTDCForToAOnset()

template<class DFr >

std::array<float, 3> HGCFEElectronics< DFr >::getTDCForToAOnset ( )

inline

Definition at line 96 of file HGCFEElectronics.h.

96 { return tdcForToAOnset_fC_; }

References HGCFEElectronics< DFr >::tdcForToAOnset_fC_.

◆ getTDClsb()

template<class DFr >

float HGCFEElectronics< DFr >::getTDClsb ( )

inline

Definition at line 92 of file HGCFEElectronics.h.

92 { return tdcLSB_fC_; }

References HGCFEElectronics< DFr >::tdcLSB_fC_.

◆ getTDCOnset()

template<class DFr >

float HGCFEElectronics< DFr >::getTDCOnset ( )

inline

Definition at line 95 of file HGCFEElectronics.h.

95 { return tdcOnset_fC_; }

References HGCFEElectronics< DFr >::tdcOnset_fC_.

◆ getTimeJitter()

template<class DFr >

float HGCFEElectronics< DFr >::getTimeJitter	(	float	totalCharge,
		int	thickness
	)

inline

Definition at line 80 of file HGCFEElectronics.h.

                                                         {
     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);
   };

References HGCFEElectronics< DFr >::jitterConstant2_ns_, HGCFEElectronics< DFr >::jitterNoise2_ns_, HGCFEElectronics< DFr >::noise_fC_, funct::pow(), mathSSE::sqrt(), and Calorimetry_cff::thickness.

◆ runShaper() [1/2]

template<class DFr >

void HGCFEElectronics< DFr >::runShaper	(	DFr &	dataFrame,
		hgc::HGCSimHitData &	chargeColl,
		hgc::HGCSimHitData &	toa,
		CLHEP::HepRandomEngine *	engine,
		uint32_t	thrADC = `0`,
		float	lsbADC = `-1`,
		uint32_t	gainIdx = `0`,
		float	maxADC = `-1`,
		int	thickness = `1`
	)

inline

Definition at line 64 of file HGCFEElectronics.h.

                                            {
     runShaper(dataFrame, chargeColl, toa, adcPulse_, engine, thrADC, lsbADC, gainIdx, maxADC, thickness);
   }

References HGCFEElectronics< DFr >::adcPulse_, HGCFEElectronics< DFr >::runShaper(), and Calorimetry_cff::thickness.

◆ runShaper() [2/2]

template<class DFr >

void HGCFEElectronics< DFr >::runShaper	(	DFr &	dataFrame,
		hgc::HGCSimHitData &	chargeColl,
		hgc::HGCSimHitData &	toa,
		const hgc_digi::FEADCPulseShape &	adcPulse,
		CLHEP::HepRandomEngine *	engine,
		uint32_t	thrADC = `0`,
		float	lsbADC = `-1`,
		uint32_t	gainIdx = `0`,
		float	maxADC = `-1`,
		int	thickness = `1`,
		float	tdcOnsetAuto = `-1`
	)

inline

switches according to the firmware version

Definition at line 37 of file HGCFEElectronics.h.

                                                  {
     switch (fwVersion_) {
       case SIMPLE: {
         runSimpleShaper(dataFrame, chargeColl, thrADC, lsbADC, gainIdx, maxADC, adcPulse);
         break;
       }
       case WITHTOT: {
         runShaperWithToT(
             dataFrame, chargeColl, toa, engine, thrADC, lsbADC, gainIdx, maxADC, thickness, tdcOnsetAuto, adcPulse);
         break;
       }
       default: {
         runTrivialShaper(dataFrame, chargeColl, thrADC, lsbADC, gainIdx, maxADC);
         break;
       }
     }
   }

References hgcROCParameters_cfi::adcPulse, HGCFEElectronics< DFr >::fwVersion_, HGCFEElectronics< DFr >::runShaperWithToT(), HGCFEElectronics< DFr >::runSimpleShaper(), HGCFEElectronics< DFr >::runTrivialShaper(), HGCFEElectronics< DFr >::SIMPLE, Calorimetry_cff::thickness, and HGCFEElectronics< DFr >::WITHTOT.

Referenced by HGCFEElectronics< DFr >::runShaper().

◆ runShaperWithToT() [1/2]

template<class DFr >

void HGCFEElectronics< DFr >::runShaperWithToT	(	DFr &	dataFrame,
		hgc::HGCSimHitData &	chargeColl,
		hgc::HGCSimHitData &	toa,
		CLHEP::HepRandomEngine *	engine,
		uint32_t	thrADC,
		float	lsbADC,
		uint32_t	gainIdx,
		float	maxADC,
		int	thickness,
		float	tdcOnsetAuto
	)

inline

Definition at line 134 of file HGCFEElectronics.h.

                                             {
     runShaperWithToT(
         dataFrame, chargeColl, toa, engine, thrADC, lsbADC, gainIdx, maxADC, thickness, tdcOnsetAuto, adcPulse_);
   }

References HGCFEElectronics< DFr >::adcPulse_, HGCFEElectronics< DFr >::runShaperWithToT(), and Calorimetry_cff::thickness.

◆ runShaperWithToT() [2/2]

template<class DFr >

void HGCFEElectronics< DFr >::runShaperWithToT	(	DFr &	dataFrame,
		hgc::HGCSimHitData &	chargeColl,
		hgc::HGCSimHitData &	toa,
		CLHEP::HepRandomEngine *	engine,
		uint32_t	thrADC,
		float	lsbADC,
		uint32_t	gainIdx,
		float	maxADC,
		int	thickness,
		float	tdcOnsetAuto,
		const hgc_digi::FEADCPulseShape &	adcPulse
	)

implements pulse shape and switch to time over threshold including deadtime

Definition at line 207 of file HGCFEElectronics.cc.

                                                                                       {
   busyFlags.fill(false);
   totFlags.fill(false);
   toaFlags.fill(false);
   newCharge.fill(0.f);
   toaFromToT.fill(0.f);
  
 #ifdef EDM_ML_DEBUG
   constexpr bool debug_state(true);
 #else
   constexpr bool debug_state(false);
 #endif
  
   bool debug = debug_state;
   float timeToA = 0.f;
  
   //first look at time
   //for pileup look only at intime signals
   //ToA is in central BX if fired -- std::floor(BX/25.)+9;
   int fireBX = 9;
   //noise fluctuation on charge is added after ToA computation
   //do not recheck the ToA firing threshold tdcForToAOnset_fC_[thickness-1] not to bias the efficiency
   //to be done properly with realistic ToA shaper and jitter for the moment accounted in the smearing
   if (toaColl[fireBX] != 0.f) {
     timeToA = toaColl[fireBX];
     float jitter = getTimeJitter(chargeColl[fireBX], thickness);
     if (jitter != 0)
       timeToA = CLHEP::RandGaussQ::shoot(engine, timeToA, jitter);
     else if (tdcResolutionInNs_ != 0)
       timeToA = CLHEP::RandGaussQ::shoot(engine, timeToA, tdcResolutionInNs_);
     if (timeToA >= 0.f && timeToA <= 25.f)
       toaFlags[fireBX] = true;
   }
  
   //now look at charge
   //first identify bunches which will trigger ToT
   //if(debug_state) edm::LogVerbatim("HGCFE") << "[runShaperWithToT]" << std::endl;
   for (int it = 0; it < (int)(chargeColl.size()); ++it) {
     debug = debug_state;
     //if already flagged as busy it can't be re-used to trigger the ToT
     if (busyFlags[it])
       continue;
  
     if (tdcOnsetAuto < 0) {
       tdcOnsetAuto = tdcOnset_fC_;
     }
     //if below TDC onset will be handled by SARS ADC later
     float charge = chargeColl[it];
     if (charge < tdcOnsetAuto) {
       debug = false;
       continue;
     }
  
     //raise TDC mode for charge computation
     //ToA anyway fired independently will be sorted out with realistic ToA dedicated shaper
     float toa = timeToA;
     totFlags[it] = true;
  
     if (debug)
       edm::LogVerbatim("HGCFE") << "\t q=" << charge << " fC with <toa>=" << toa << " ns, triggers ToT @ " << it
                                 << std::endl;
  
     //compute total charge to be integrated and integration time
     //needs a loop as ToT will last as long as there is charge to dissipate
     int busyBxs(0);
     float totalCharge(charge), finalToA(toa), integTime(0);
     while (true) {
       //compute integration time in ns and # bunches
       //float newIntegTime(0);
       int poffset = 0;
       float charge_offset = 0.f;
       const float charge_kfC(totalCharge * 1e-3);
       if (charge_kfC < tdcChargeDrainParameterisation_[3]) {
         //newIntegTime=tdcChargeDrainParameterisation_[0]*pow(charge_kfC,2)+tdcChargeDrainParameterisation_[1]*charge_kfC+tdcChargeDrainParameterisation_[2];
       } else if (charge_kfC < tdcChargeDrainParameterisation_[7]) {
         poffset = 4;
         charge_offset = tdcChargeDrainParameterisation_[3];
         //newIntegTime=tdcChargeDrainParameterisation_[4]*pow(charge_kfC-tdcChargeDrainParameterisation_[3],2)+tdcChargeDrainParameterisation_[5]*(charge_kfC-tdcChargeDrainParameterisation_[3])+tdcChargeDrainParameterisation_[6];
       } else {
         poffset = 8;
         charge_offset = tdcChargeDrainParameterisation_[7];
         //newIntegTime=tdcChargeDrainParameterisation_[8]*pow(charge_kfC-tdcChargeDrainParameterisation_[7],2)+tdcChargeDrainParameterisation_[9]*(charge_kfC-tdcChargeDrainParameterisation_[7])+tdcChargeDrainParameterisation_[10];
       }
       const float charge_mod = charge_kfC - charge_offset;
       const float newIntegTime =
           ((tdcChargeDrainParameterisation_[poffset] * charge_mod + tdcChargeDrainParameterisation_[poffset + 1]) *
                charge_mod +
            tdcChargeDrainParameterisation_[poffset + 2]);
  
       const int newBusyBxs = std::floor(newIntegTime / 25.f) + 1;
  
       //if no update is needed regarding the number of bunches,
       //then the ToT integration time has converged
       integTime = newIntegTime;
       if (newBusyBxs == busyBxs)
         break;
  
       //update charge integrated during ToT
       if (debug) {
         if (busyBxs == 0)
           edm::LogVerbatim("HGCFE") << "\t Intial busy estimate=" << integTime << " ns = " << newBusyBxs << " bxs"
                                     << std::endl;
         else
           edm::LogVerbatim("HGCFE") << "\t ...integrated charge overflows initial busy estimate, interating again"
                                     << std::endl;
       }
  
       //update number of busy bunches
       busyBxs = newBusyBxs;
  
       //reset charge to be integrated
       totalCharge = charge;
       if (toaMode_ == WEIGHTEDBYE)
         finalToA = toa * charge;
  
       //add leakage from previous bunches in SARS ADC mode
       for (int jt = 0; jt < it; ++jt) {
         const unsigned int deltaT = (it - jt);
         if ((deltaT + 2) >= adcPulse.size() || chargeColl[jt] == 0.f || totFlags[jt] || busyFlags[jt])
           continue;
  
         const float leakCharge = chargeColl[jt] * adcPulse[deltaT + 2];
         totalCharge += leakCharge;
         if (toaMode_ == WEIGHTEDBYE)
           finalToA += leakCharge * pulseAvgT_[deltaT + 2];
  
         if (debug)
           edm::LogVerbatim("HGCFE") << "\t\t leaking " << chargeColl[jt] << " fC @ deltaT=-" << deltaT << " -> +"
                                     << leakCharge << " with avgT=" << pulseAvgT_[deltaT + 2] << std::endl;
       }
  
       //add contamination from posterior bunches
       for (int jt = it + 1; jt < it + busyBxs && jt < dataFrame.size(); ++jt) {
         //this charge will be integrated in TDC mode
         //disable for SARS ADC
         busyFlags[jt] = true;
  
         const float extraCharge = chargeColl[jt];
         if (extraCharge == 0.f)
           continue;
         if (debug)
           edm::LogVerbatim("HGCFE") << "\t\t adding " << extraCharge << " fC @ deltaT=+" << (jt - it) << std::endl;
  
         totalCharge += extraCharge;
         if (toaMode_ == WEIGHTEDBYE)
           finalToA += extraCharge * toaColl[jt];
       }
  
       //finalize ToA contamination
       if (toaMode_ == WEIGHTEDBYE)
         finalToA /= totalCharge;
     }
     newCharge[it] = (totalCharge - tdcOnsetAuto);
  
     if (debug)
       edm::LogVerbatim("HGCFE") << "\t Final busy estimate=" << integTime << " ns = " << busyBxs << " bxs" << std::endl
                                 << "\t Total integrated=" << totalCharge << " fC <toa>=" << toaFromToT[it]
                                 << " (raw=" << finalToA << ") ns " << std::endl;
  
     //last fC (tdcOnset) are dissipated trough pulse
     if (it + busyBxs < (int)(newCharge.size())) {
       const float deltaT2nextBx((busyBxs * 25 - integTime));
       const float tdcOnsetLeakage(tdcOnsetAuto * vdt::fast_expf(-deltaT2nextBx / tdcChargeDrainParameterisation_[11]));
       if (debug)
         edm::LogVerbatim("HGCFE") << "\t Leaking remainder of TDC onset " << tdcOnsetAuto << " fC, to be dissipated in "
                                   << deltaT2nextBx << " DeltaT/tau=" << deltaT2nextBx << " / "
                                   << tdcChargeDrainParameterisation_[11] << " ns, adds " << tdcOnsetLeakage << " fC @ "
                                   << it + busyBxs << " bx (first free bx)" << std::endl;
       newCharge[it + busyBxs] += tdcOnsetLeakage;
     }
   }
  
   //including the leakage from bunches in SARS ADC when not declared busy or in ToT
   auto runChargeSharing = [&]() {
     int ipulse = 0;
     for (int it = 0; it < (int)(chargeColl.size()); ++it) {
       //if busy, charge has been already integrated
       //if(debug) edm::LogVerbatim("HGCFE") << "\t SARS ADC pulse activated @ " << it << " : ";
       if (!totFlags[it] & !busyFlags[it]) {
         const int start = std::max(0, 2 - it);
         const int stop = std::min((int)adcPulse.size(), (int)newCharge.size() - it + 2);
         for (ipulse = start; ipulse < stop; ++ipulse) {
           const int itoffset = it + ipulse - 2;
           //notice that if the channel is already busy,
           //it has already been affected by the leakage of the SARS ADC
           //if(totFlags[itoffset] || busyFlags[itoffset]) continue;
           if (!totFlags[itoffset] & !busyFlags[itoffset]) {
             newCharge[itoffset] += chargeColl[it] * adcPulse[ipulse];
           }
           //if(debug) edm::LogVerbatim("HGCFE") << " | " << itoffset << " " << chargeColl[it]*adcPulse[ipulse] << "( " << chargeColl[it] << "->";
           //if(debug) edm::LogVerbatim("HGCFE") << newCharge[itoffset] << ") ";
         }
       }
  
       if (debug)
         edm::LogVerbatim("HGCFE") << std::endl;
     }
   };
   runChargeSharing();
  
   //For the future need to understand how to deal with toa for out of time signals
   //and for that should keep track of the BX firing the ToA somewhere (also to restore the use of finalToA)
   /*
   float finalToA(0.);
   for(int it=0; it<(int)(newCharge.size()); it++){
     if(toaFlags[it]){
       finalToA = toaFromToT[it];
       //to avoid +=25 for small negative time taken as 0
       while(finalToA < -1.e-5)  finalToA+=25.f;
       while(finalToA > 25.f) finalToA-=25.f;
       toaFromToT[it] = finalToA;
     }
   }
   */
   //timeToA is already in 0-25ns range by construction
  
   //set new ADCs and ToA
   if (debug)
     edm::LogVerbatim("HGCFE") << "\t final result : ";
   if (lsbADC < 0)
     lsbADC = adcLSB_fC_;
   if (maxADC < 0)
     maxADC = adcSaturation_fC_;
   for (int it = 0; it < (int)(newCharge.size()); it++) {
     if (debug)
       edm::LogVerbatim("HGCFE") << chargeColl[it] << " -> " << newCharge[it] << " ";
  
     HGCSample newSample;
     if (totFlags[it] || busyFlags[it]) {
       if (totFlags[it]) {
         //brute force saturation, maybe could to better with an exponential like saturation
         const float saturatedCharge(std::min(newCharge[it], tdcSaturation_fC_));
         //working version for in-time PU and signal
         newSample.set(
             true, true, gainIdx, (uint16_t)(timeToA / toaLSB_ns_), (uint16_t)(std::floor(saturatedCharge / tdcLSB_fC_)));
         if (toaFlags[it])
           newSample.setToAValid(true);
       } else {
         newSample.set(false, true, gainIdx, 0, 0);
       }
     } else {
       //brute force saturation, maybe could to better with an exponential like saturation
       const uint16_t adc = std::floor(std::min(newCharge[it], maxADC) / lsbADC);
       //working version for in-time PU and signal
       newSample.set(adc > thrADC, false, gainIdx, (uint16_t)(timeToA / toaLSB_ns_), adc);
       if (toaFlags[it])
         newSample.setToAValid(true);
     }
     dataFrame.setSample(it, newSample);
   }
  
   if (debug) {
     std::ostringstream msg;
     dataFrame.print(msg);
     edm::LogVerbatim("HGCFE") << msg.str() << std::endl;
   }
 }

References gpuClustering::adc, hgcROCParameters_cfi::adcPulse, ALCARECOTkAlJpsiMuMu_cff::charge, debug, MillePedeFileConverter_cfg::e, f, myMath::fast_expf(), createfilelist::int, SiStripPI::max, min(), mps_check::msg, HGCSample::set(), HGCSample::setToAValid(), and Calorimetry_cff::thickness.

Referenced by HGCFEElectronics< DFr >::runShaper(), and HGCFEElectronics< DFr >::runShaperWithToT().

◆ runSimpleShaper() [1/2]

template<class DFr >

void HGCFEElectronics< DFr >::runSimpleShaper	(	DFr &	dataFrame,
		hgc::HGCSimHitData &	chargeColl,
		uint32_t	thrADC,
		float	lsbADC,
		uint32_t	gainIdx,
		float	maxADC
	)

inline

Definition at line 115 of file HGCFEElectronics.h.

                                                                                                                    {
     runSimpleShaper(dataFrame, chargeColl, thrADC, lsbADC, gainIdx, maxADC, adcPulse_);
   }

References HGCFEElectronics< DFr >::adcPulse_, and HGCFEElectronics< DFr >::runSimpleShaper().

◆ runSimpleShaper() [2/2]

template<class DFr >

void HGCFEElectronics< DFr >::runSimpleShaper	(	DFr &	dataFrame,
		hgc::HGCSimHitData &	chargeColl,
		uint32_t	thrADC,
		float	lsbADC,
		uint32_t	gainIdx,
		float	maxADC,
		const hgc_digi::FEADCPulseShape &	adcPulse
	)

applies a shape to each time sample and propagates the tails to the subsequent time samples

Definition at line 149 of file HGCFEElectronics.cc.

                                                                                      {
   //convolute with pulse shape to compute new ADCs
   newCharge.fill(0.f);
   bool debug(false);
   for (int it = 0; it < (int)(chargeColl.size()); it++) {
     const float charge(chargeColl[it]);
     if (charge == 0.f)
       continue;
  
 #ifdef EDM_ML_DEBUG
     debug |= (charge > adcThreshold_fC_);
 #endif
  
     if (debug)
       edm::LogVerbatim("HGCFE") << "\t Redistributing SARS ADC" << charge << " @ " << it;
  
     for (int ipulse = -2; ipulse < (int)(adcPulse.size()) - 2; ipulse++) {
       if (it + ipulse < 0)
         continue;
       if (it + ipulse >= (int)(dataFrame.size()))
         continue;
       const float chargeLeak = charge * adcPulse[(ipulse + 2)];
       newCharge[it + ipulse] += chargeLeak;
  
       if (debug)
         edm::LogVerbatim("HGCFE") << " | " << it + ipulse << " " << chargeLeak;
     }
  
     if (debug)
       edm::LogVerbatim("HGCFE") << std::endl;
   }
  
   for (int it = 0; it < (int)(newCharge.size()); it++) {
     //brute force saturation, maybe could to better with an exponential like saturation
     const uint32_t adc = std::floor(std::min(newCharge[it], maxADC) / lsbADC);
     HGCSample newSample;
     newSample.set(adc > thrADC, false, gainIdx, 0, adc);
     dataFrame.setSample(it, newSample);
  
     if (debug)
       edm::LogVerbatim("HGCFE") << adc << " (" << std::min(newCharge[it], maxADC) << "/" << lsbADC << " ) ";
   }
  
   if (debug) {
     std::ostringstream msg;
     dataFrame.print(msg);
     edm::LogVerbatim("HGCFE") << msg.str() << std::endl;
   }
 }

References gpuClustering::adc, hgcROCParameters_cfi::adcPulse, ALCARECOTkAlJpsiMuMu_cff::charge, debug, f, createfilelist::int, min(), mps_check::msg, and HGCSample::set().

Referenced by HGCFEElectronics< DFr >::runShaper(), and HGCFEElectronics< DFr >::runSimpleShaper().

◆ runTrivialShaper()

template<class DFr >

void HGCFEElectronics< DFr >::runTrivialShaper	(	DFr &	dataFrame,
		hgc::HGCSimHitData &	chargeColl,
		uint32_t	thrADC,
		float	lsbADC,
		uint32_t	gainIdx,
		float	maxADC
	)

converts charge to digis without pulse shape

Definition at line 110 of file HGCFEElectronics.cc.

                                                                                                               {
   bool debug(false);
  
 #ifdef EDM_ML_DEBUG
   for (int it = 0; it < (int)(chargeColl.size()); it++)
     debug |= (chargeColl[it] > adcThreshold_fC_);
 #endif
  
   if (debug)
     edm::LogVerbatim("HGCFE") << "[runTrivialShaper]" << std::endl;
  
   if (lsbADC < 0)
     lsbADC = adcLSB_fC_;
   if (maxADC < 0)
     // lower adcSaturation_fC_ by one part in a million
     // to ensure largest charge converted in bits is 0xfff==4095, not 0x1000
     // no effect on charges loewer than; no impact on cpu time, only done once
     maxADC = adcSaturation_fC_ * (1 - 1e-6);
   for (int it = 0; it < (int)(chargeColl.size()); it++) {
     //brute force saturation, maybe could to better with an exponential like saturation
     const uint32_t adc = std::floor(std::min(chargeColl[it], maxADC) / lsbADC);
     HGCSample newSample;
     newSample.set(adc > thrADC, false, gainIdx, 0, adc);
     dataFrame.setSample(it, newSample);
  
     if (debug)
       edm::LogVerbatim("HGCFE") << adc << " (" << chargeColl[it] << "/" << adcLSB_fC_ << ") ";
   }
  
   if (debug) {
     std::ostringstream msg;
     dataFrame.print(msg);
     edm::LogVerbatim("HGCFE") << msg.str() << std::endl;
   }
 }

References gpuClustering::adc, debug, MillePedeFileConverter_cfg::e, createfilelist::int, min(), mps_check::msg, and HGCSample::set().

Referenced by HGCFEElectronics< DFr >::runShaper().

◆ setADClsb()

template<class DFr >

void HGCFEElectronics< DFr >::setADClsb ( float newLSB )

inline

Definition at line 97 of file HGCFEElectronics.h.

97 { adcLSB_fC_ = newLSB; }

References HGCFEElectronics< DFr >::adcLSB_fC_.

◆ SetNoiseValues()

template<class DFr >

void HGCFEElectronics< DFr >::SetNoiseValues ( const std::vector< float > & noise_fC )

inline

Definition at line 76 of file HGCFEElectronics.h.

                                                         {
     noise_fC_.insert(noise_fC_.end(), noise_fC.begin(), noise_fC.end());
   };

References hgcalDigitizer_cfi::noise_fC, and HGCFEElectronics< DFr >::noise_fC_.

◆ toaMode()

template<class DFr >

uint32_t HGCFEElectronics< DFr >::toaMode ( ) const

inline

returns how ToT will be computed

Definition at line 151 of file HGCFEElectronics.h.

151 { return toaMode_; }

References HGCFEElectronics< DFr >::toaMode_.

Member Data Documentation

◆ adcLSB_fC_

template<class DFr >

float HGCFEElectronics< DFr >::adcLSB_fC_

private

Definition at line 169 of file HGCFEElectronics.h.

Referenced by HGCFEElectronics< DFr >::getADClsb(), and HGCFEElectronics< DFr >::setADClsb().

◆ adcPulse_

template<class DFr >

hgc_digi::FEADCPulseShape HGCFEElectronics< DFr >::adcPulse_

private

Definition at line 166 of file HGCFEElectronics.h.

Referenced by HGCFEElectronics< DFr >::getDefaultADCPulse(), HGCFEElectronics< DFr >::runShaper(), HGCFEElectronics< DFr >::runShaperWithToT(), and HGCFEElectronics< DFr >::runSimpleShaper().

◆ adcSaturation_fC_

template<class DFr >

float HGCFEElectronics< DFr >::adcSaturation_fC_

private

Definition at line 169 of file HGCFEElectronics.h.

◆ adcThreshold_fC_

template<class DFr >

float HGCFEElectronics< DFr >::adcThreshold_fC_

private

Definition at line 169 of file HGCFEElectronics.h.

Referenced by HGCFEElectronics< DFr >::getADCThreshold().

◆ busyFlags

template<class DFr >

std::array<bool, hgc::nSamples> HGCFEElectronics< DFr >::busyFlags

private

Definition at line 177 of file HGCFEElectronics.h.

◆ fwVersion_

template<class DFr >

uint32_t HGCFEElectronics< DFr >::fwVersion_

private

Definition at line 165 of file HGCFEElectronics.h.

Referenced by HGCFEElectronics< DFr >::runShaper().

◆ jitterConstant2_ns_

template<class DFr >

std::array<float, 3> HGCFEElectronics< DFr >::jitterConstant2_ns_

private

Definition at line 172 of file HGCFEElectronics.h.

Referenced by HGCFEElectronics< DFr >::getTimeJitter().

◆ jitterNoise2_ns_

template<class DFr >

std::array<float, 3> HGCFEElectronics< DFr >::jitterNoise2_ns_

private

Definition at line 172 of file HGCFEElectronics.h.

Referenced by HGCFEElectronics< DFr >::getTimeJitter().

◆ newCharge

template<class DFr >

hgc::HGCSimHitData HGCFEElectronics< DFr >::newCharge

private

Definition at line 178 of file HGCFEElectronics.h.

◆ noise_fC_

template<class DFr >

std::vector<float> HGCFEElectronics< DFr >::noise_fC_

private

Definition at line 173 of file HGCFEElectronics.h.

Referenced by HGCFEElectronics< DFr >::getTimeJitter(), and HGCFEElectronics< DFr >::SetNoiseValues().

◆ pulseAvgT_

template<class DFr >

hgc_digi::FEADCPulseShape HGCFEElectronics< DFr >::pulseAvgT_

private

Definition at line 166 of file HGCFEElectronics.h.

◆ targetMIPvalue_ADC_

template<class DFr >

uint32_t HGCFEElectronics< DFr >::targetMIPvalue_ADC_

private

Definition at line 171 of file HGCFEElectronics.h.

Referenced by HGCFEElectronics< DFr >::getTargetMipValue().

◆ tdcChargeDrainParameterisation_

template<class DFr >

std::vector<float> HGCFEElectronics< DFr >::tdcChargeDrainParameterisation_

private

Definition at line 168 of file HGCFEElectronics.h.

◆ tdcForToAOnset_fC_

template<class DFr >

std::array<float, 3> HGCFEElectronics< DFr >::tdcForToAOnset_fC_

private

Definition at line 167 of file HGCFEElectronics.h.

Referenced by HGCFEElectronics< DFr >::getTDCForToAOnset().

◆ tdcLSB_fC_

template<class DFr >

float HGCFEElectronics< DFr >::tdcLSB_fC_

private

Definition at line 169 of file HGCFEElectronics.h.

Referenced by HGCFEElectronics< DFr >::getTDClsb().

◆ tdcOnset_fC_

template<class DFr >

float HGCFEElectronics< DFr >::tdcOnset_fC_

private

Definition at line 169 of file HGCFEElectronics.h.

Referenced by HGCFEElectronics< DFr >::getTDCOnset().

◆ tdcResolutionInNs_

template<class DFr >

float HGCFEElectronics< DFr >::tdcResolutionInNs_

private

Definition at line 169 of file HGCFEElectronics.h.

◆ tdcSaturation_fC_

template<class DFr >

float HGCFEElectronics< DFr >::tdcSaturation_fC_

private

Definition at line 169 of file HGCFEElectronics.h.

◆ thresholdFollowsMIP_

template<class DFr >

bool HGCFEElectronics< DFr >::thresholdFollowsMIP_

private

Definition at line 175 of file HGCFEElectronics.h.

◆ toaFlags

template<class DFr >

std::array<bool, hgc::nSamples> HGCFEElectronics< DFr >::toaFlags

private

Definition at line 177 of file HGCFEElectronics.h.

◆ toaFromToT

template<class DFr >

hgc::HGCSimHitData HGCFEElectronics< DFr >::toaFromToT

private

Definition at line 178 of file HGCFEElectronics.h.

◆ toaLSB_ns_

template<class DFr >

float HGCFEElectronics< DFr >::toaLSB_ns_

private

Definition at line 169 of file HGCFEElectronics.h.

◆ toaMode_

template<class DFr >

uint32_t HGCFEElectronics< DFr >::toaMode_

private

Definition at line 174 of file HGCFEElectronics.h.

Referenced by HGCFEElectronics< DFr >::toaMode().

◆ totFlags

template<class DFr >

std::array<bool, hgc::nSamples> HGCFEElectronics< DFr >::totFlags

private

Definition at line 177 of file HGCFEElectronics.h.

Public Types

Public Member Functions

Private Attributes

Detailed Description

template<class DFr> class HGCFEElectronics< DFr >

Member Enumeration Documentation

◆ HGCFEElectronicsFirmwareVersion

◆ HGCFEElectronicsTOTMode

Constructor & Destructor Documentation

◆ HGCFEElectronics()

◆ ~HGCFEElectronics()

Member Function Documentation

◆ getADClsb()

◆ getADCThreshold()

◆ getDefaultADCPulse()

◆ getTargetMipValue()

◆ getTDCForToAOnset()

◆ getTDClsb()

◆ getTDCOnset()

◆ getTimeJitter()

◆ runShaper() [1/2]

◆ runShaper() [2/2]

◆ runShaperWithToT() [1/2]

◆ runShaperWithToT() [2/2]

◆ runSimpleShaper() [1/2]

◆ runSimpleShaper() [2/2]

◆ runTrivialShaper()

◆ setADClsb()

◆ SetNoiseValues()

◆ toaMode()

Member Data Documentation

◆ adcLSB_fC_

◆ adcPulse_

◆ adcSaturation_fC_

◆ adcThreshold_fC_

◆ busyFlags

◆ fwVersion_

◆ jitterConstant2_ns_

◆ jitterNoise2_ns_

◆ newCharge

◆ noise_fC_

◆ pulseAvgT_

◆ targetMIPvalue_ADC_

◆ tdcChargeDrainParameterisation_

◆ tdcForToAOnset_fC_

◆ tdcLSB_fC_

◆ tdcOnset_fC_

◆ tdcResolutionInNs_

◆ tdcSaturation_fC_

◆ thresholdFollowsMIP_

◆ toaFlags

◆ toaFromToT

◆ toaLSB_ns_

◆ toaMode_

◆ totFlags

template<class DFr>
class HGCFEElectronics< DFr >