#include <HGCDigitizerBase.h>

Public Types
typedef edm::SortedCollection< DFr >	DColl

typedef DFr	DigiType

Public Member Functions
void	GenerateGaussianNoise (CLHEP::HepRandomEngine *engine, const double NoiseMean, const double NoiseStd)
	Gaussian Noise Generation Member Function. More...

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

float	keV2fC () const
	getters More...

void	run (std::unique_ptr< DColl > &digiColl, hgc::HGCSimHitDataAccumulator &simData, const CaloSubdetectorGeometry theGeom, const std::unordered_set< DetId > &validIds, uint32_t digitizationType, CLHEP::HepRandomEngine engine)
	steer digitization mode More...

virtual void	runDigitizer (std::unique_ptr< DColl > &coll, hgc::HGCSimHitDataAccumulator &simData, const CaloSubdetectorGeometry theGeom, const std::unordered_set< DetId > &validIds, uint32_t digitizerType, CLHEP::HepRandomEngine engine)
	to be specialized by top class More...

void	runSimple (std::unique_ptr< DColl > &coll, hgc::HGCSimHitDataAccumulator &simData, const CaloSubdetectorGeometry theGeom, const std::unordered_set< DetId > &validIds, CLHEP::HepRandomEngine engine)
	a trivial digitization: sum energies and digitize without noise More...

std::array< float, 3 >	tdcForToAOnset () const

float	tdcOnset () const

bool	toaModeByEnergy () const

void	updateOutput (std::unique_ptr< DColl > &coll, const DFr &rawDataFrame)
	prepares the output according to the number of time samples to produce More...

virtual	~HGCDigitizerBase ()
	DTOR. More...

Protected Attributes
double	bxTime_

std::vector< double >	cce_

std::string	doseMapFile_

bool	doTimeSamples_

std::array< std::array< double, samplesize_ >, NoiseArrayLength_ >	GaussianNoiseArray_

float	keV2fC_

edm::ParameterSet	myCfg_

std::unique_ptr< HGCFEElectronics< DFr > >	myFEelectronics_

std::vector< float >	noise_fC_

bool	NoiseGeneration_Method_

const double	NoiseMean_

const double	NoiseStd_

bool	RandNoiseGenerationFlag_

HGCalSiNoiseMap	scal_

bool	scaleByDose_

bool	thresholdFollowsMIP_

Static Protected Attributes
static const size_t	NoiseArrayLength_ = 200000

static const size_t	samplesize_ = 15

Detailed Description

template<class DFr>
class HGCDigitizerBase< DFr >

Definition at line 61 of file HGCDigitizerBase.h.

Member Typedef Documentation

◆ DColl

template<class DFr>

typedef edm::SortedCollection<DFr> HGCDigitizerBase< DFr >::DColl

Definition at line 65 of file HGCDigitizerBase.h.

◆ DigiType

template<class DFr>

typedef DFr HGCDigitizerBase< DFr >::DigiType

Definition at line 63 of file HGCDigitizerBase.h.

Constructor & Destructor Documentation

◆ HGCDigitizerBase()

template<class DFr >

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

CTOR.

Definition at line 9 of file HGCDigitizerBase.cc.

     : scaleByDose_(false), NoiseMean_(0.0), NoiseStd_(1.0) {
   bxTime_ = ps.getParameter<double>("bxTime");
   myCfg_ = ps.getParameter<edm::ParameterSet>("digiCfg");
   NoiseGeneration_Method_ = ps.getParameter<bool>("NoiseGeneration_Method");
   doTimeSamples_ = myCfg_.getParameter<bool>("doTimeSamples");
   thresholdFollowsMIP_ = myCfg_.getParameter<bool>("thresholdFollowsMIP");
   if (myCfg_.exists("keV2fC"))
     keV2fC_ = myCfg_.getParameter<double>("keV2fC");
   else
     keV2fC_ = 1.0;
  
   if (myCfg_.existsAs<edm::ParameterSet>("chargeCollectionEfficiencies")) {
     cce_ = myCfg_.getParameter<edm::ParameterSet>("chargeCollectionEfficiencies")
                .template getParameter<std::vector<double>>("values");
   }
  
   if (myCfg_.existsAs<double>("noise_fC")) {
     noise_fC_.reserve(1);
     noise_fC_.push_back(myCfg_.getParameter<double>("noise_fC"));
   } else if (myCfg_.existsAs<std::vector<double>>("noise_fC")) {
     const auto& noises = myCfg_.getParameter<std::vector<double>>("noise_fC");
     noise_fC_ = std::vector<float>(noises.begin(), noises.end());
   } else if (myCfg_.existsAs<edm::ParameterSet>("noise_fC")) {
     const auto& noises =
         myCfg_.getParameter<edm::ParameterSet>("noise_fC").template getParameter<std::vector<double>>("values");
     noise_fC_ = std::vector<float>(noises.begin(), noises.end());
     scaleByDose_ = myCfg_.getParameter<edm::ParameterSet>("noise_fC").template getParameter<bool>("scaleByDose");
     int scaleByDoseAlgo =
         myCfg_.getParameter<edm::ParameterSet>("noise_fC").template getParameter<uint32_t>("scaleByDoseAlgo");
     doseMapFile_ = myCfg_.getParameter<edm::ParameterSet>("noise_fC").template getParameter<std::string>("doseMap");
     scal_.setDoseMap(doseMapFile_, scaleByDoseAlgo);
   } else {
     noise_fC_.resize(1, 1.f);
   }
   if (myCfg_.existsAs<edm::ParameterSet>("ileakParam")) {
     scal_.setIleakParam(
         myCfg_.getParameter<edm::ParameterSet>("ileakParam").template getParameter<std::vector<double>>("ileakParam"));
   }
   if (myCfg_.existsAs<edm::ParameterSet>("cceParams")) {
     scal_.setCceParam(
         myCfg_.getParameter<edm::ParameterSet>("cceParams").template getParameter<std::vector<double>>("cceParamFine"),
         myCfg_.getParameter<edm::ParameterSet>("cceParams").template getParameter<std::vector<double>>("cceParamThin"),
         myCfg_.getParameter<edm::ParameterSet>("cceParams").template getParameter<std::vector<double>>("cceParamThick"));
   }
   edm::ParameterSet feCfg = myCfg_.getParameter<edm::ParameterSet>("feCfg");
   myFEelectronics_ = std::unique_ptr<HGCFEElectronics<DFr>>(new HGCFEElectronics<DFr>(feCfg));
   myFEelectronics_->SetNoiseValues(noise_fC_);
   RandNoiseGenerationFlag_ = 0;
 }

◆ ~HGCDigitizerBase()

template<class DFr>

virtual HGCDigitizerBase< DFr >::~HGCDigitizerBase ( )

inlinevirtual

DTOR.

Definition at line 122 of file HGCDigitizerBase.h.

122 {};

Member Function Documentation

◆ GenerateGaussianNoise()

template<class DFr >

void HGCDigitizerBase< DFr >::GenerateGaussianNoise	(	CLHEP::HepRandomEngine *	engine,
		const double	NoiseMean,
		const double	NoiseStd
	)

Gaussian Noise Generation Member Function.

Definition at line 61 of file HGCDigitizerBase.cc.

                                                                          {
   for (size_t i = 0; i < NoiseArrayLength_; i++) {
     for (size_t j = 0; j < samplesize_; j++) {
       GaussianNoiseArray_[i][j] = CLHEP::RandGaussQ::shoot(engine, NoiseMean, NoiseStd);
     }
   }
 }

◆ keV2fC()

template<class DFr>

float HGCDigitizerBase< DFr >::keV2fC ( ) const

inline

getters

Definition at line 88 of file HGCDigitizerBase.h.

88 { return keV2fC_; }

◆ run()

template<class DFr >

void HGCDigitizerBase< DFr >::run	(	std::unique_ptr< DColl > &	digiColl,
		hgc::HGCSimHitDataAccumulator &	simData,
		const CaloSubdetectorGeometry *	theGeom,
		const std::unordered_set< DetId > &	validIds,
		uint32_t	digitizationType,
		CLHEP::HepRandomEngine *	engine
	)

steer digitization mode

Definition at line 72 of file HGCDigitizerBase.cc.

                                                               {
   if (scaleByDose_)
     scal_.setGeometry(theGeom);
   if (NoiseGeneration_Method_ == true) {
     if (RandNoiseGenerationFlag_ == false) {
       GenerateGaussianNoise(engine, NoiseMean_, NoiseStd_);
       RandNoiseGenerationFlag_ = true;
     }
   }
   if (digitizationType == 0)
     runSimple(digiColl, simData, theGeom, validIds, engine);
   else
     runDigitizer(digiColl, simData, theGeom, validIds, digitizationType, engine);
 }

◆ runDigitizer()

template<class DFr>

virtual void HGCDigitizerBase< DFr >::runDigitizer	(	std::unique_ptr< DColl > &	coll,
		hgc::HGCSimHitDataAccumulator &	simData,
		const CaloSubdetectorGeometry *	theGeom,
		const std::unordered_set< DetId > &	validIds,
		uint32_t	digitizerType,
		CLHEP::HepRandomEngine *	engine
	)

inlinevirtual

to be specialized by top class

Reimplemented in HGCHEbackDigitizer, HFNoseDigitizer, HGCEEDigitizer, and HGCHEfrontDigitizer.

Definition at line 110 of file HGCDigitizerBase.h.

                                                           {
     throw cms::Exception("HGCDigitizerBaseException") << " Failed to find specialization of runDigitizer";
   }

◆ runSimple()

template<class DFr >

void HGCDigitizerBase< DFr >::runSimple	(	std::unique_ptr< DColl > &	coll,
		hgc::HGCSimHitDataAccumulator &	simData,
		const CaloSubdetectorGeometry *	theGeom,
		const std::unordered_set< DetId > &	validIds,
		CLHEP::HepRandomEngine *	engine
	)

a trivial digitization: sum energies and digitize without noise

Definition at line 93 of file HGCDigitizerBase.cc.

                                                                     {
   HGCSimHitData chargeColl, toa;
  
   // this represents a cell with no signal charge
   HGCCellInfo zeroData;
   zeroData.hit_info[0].fill(0.f);  //accumulated energy
   zeroData.hit_info[1].fill(0.f);  //time-of-flight
   std::array<double, samplesize_> cellNoiseArray;
   for (size_t i = 0; i < samplesize_; i++)
     cellNoiseArray[i] = 0.0;
   for (const auto& id : validIds) {
     chargeColl.fill(0.f);
     toa.fill(0.f);
     HGCSimHitDataAccumulator::iterator it = simData.find(id);
     HGCCellInfo& cell = (simData.end() == it ? zeroData : it->second);
     addCellMetadata(cell, theGeom, id);
     if (NoiseGeneration_Method_ == true) {
       size_t hash_index = (CLHEP::RandFlat::shootInt(engine, (NoiseArrayLength_ - 1)) + id) % NoiseArrayLength_;
  
       cellNoiseArray = GaussianNoiseArray_[hash_index];
     }
     //set the noise,cce, LSB and threshold to be used
     float cce(1.f), noiseWidth(0.f), lsbADC(-1.f), maxADC(-1.f);
     // half the target mip value is the specification for ZS threshold
     uint32_t thrADC(std::floor(myFEelectronics_->getTargetMipValue() / 2));
     uint32_t gainIdx = 0;
     if (scaleByDose_) {
       HGCSiliconDetId detId(id);
       HGCalSiNoiseMap::SiCellOpCharacteristics siop =
           scal_.getSiCellOpCharacteristics(detId, HGCalSiNoiseMap::AUTO, myFEelectronics_->getTargetMipValue());
       cce = siop.cce;
       noiseWidth = siop.noise;
       lsbADC = scal_.getLSBPerGain()[(HGCalSiNoiseMap::GainRange_t)siop.gain];
       maxADC = scal_.getMaxADCPerGain()[(HGCalSiNoiseMap::GainRange_t)siop.gain];
       gainIdx = siop.gain;
  
       if (thresholdFollowsMIP_)
         thrADC = siop.thrADC;
     } else if (noise_fC_[cell.thickness - 1] != 0) {
       //this is kept for legacy compatibility with the TDR simulation
       //probably should simply be removed in a future iteration
       //note that in this legacy case, gainIdx is kept at 0, fixed
       cce = (cce_.empty() ? 1.f : cce_[cell.thickness - 1]);
       noiseWidth = cell.size * noise_fC_[cell.thickness - 1];
       thrADC =
           thresholdFollowsMIP_
               ? std::floor(cell.thickness * cce * myFEelectronics_->getADCThreshold() / myFEelectronics_->getADClsb())
               : std::floor(cell.thickness * myFEelectronics_->getADCThreshold() / myFEelectronics_->getADClsb());
     }
  
     //loop over time samples and add noise
     for (size_t i = 0; i < cell.hit_info[0].size(); i++) {
       double rawCharge(cell.hit_info[0][i]);
  
       //time of arrival
       toa[i] = cell.hit_info[1][i];
       if (myFEelectronics_->toaMode() == HGCFEElectronics<DFr>::WEIGHTEDBYE && rawCharge > 0)
         toa[i] = cell.hit_info[1][i] / rawCharge;
  
       //final charge estimation
       float noise;
       if (NoiseGeneration_Method_ == true)
         noise = (float)cellNoiseArray[i] * noiseWidth;
       else
         noise = CLHEP::RandGaussQ::shoot(engine, cellNoiseArray[i], noiseWidth);
       float totalCharge(rawCharge * cce + noise);
       if (totalCharge < 0.f)
         totalCharge = 0.f;
       chargeColl[i] = totalCharge;
     }
  
     //run the shaper to create a new data frame
     DFr rawDataFrame(id);
     int thickness = cell.thickness > 0 ? cell.thickness : 1;
     myFEelectronics_->runShaper(rawDataFrame, chargeColl, toa, engine, thrADC, lsbADC, gainIdx, maxADC, thickness);
  
     //update the output according to the final shape
     updateOutput(coll, rawDataFrame);
   }
 }

◆ tdcForToAOnset()

template<class DFr>

std::array<float, 3> HGCDigitizerBase< DFr >::tdcForToAOnset ( ) const

inline

Definition at line 91 of file HGCDigitizerBase.h.

91 { return myFEelectronics_->getTDCForToAOnset(); }

◆ tdcOnset()

template<class DFr>

float HGCDigitizerBase< DFr >::tdcOnset ( ) const

inline

Definition at line 90 of file HGCDigitizerBase.h.

90 { return myFEelectronics_->getTDCOnset(); }

◆ toaModeByEnergy()

template<class DFr>

bool HGCDigitizerBase< DFr >::toaModeByEnergy ( ) const

inline

Definition at line 89 of file HGCDigitizerBase.h.

89 { return (myFEelectronics_->toaMode() == HGCFEElectronics<DFr>::WEIGHTEDBYE); }

◆ updateOutput()

template<class DFr>

void HGCDigitizerBase< DFr >::updateOutput	(	std::unique_ptr< DColl > &	coll,
		const DFr &	rawDataFrame
	)

prepares the output according to the number of time samples to produce

Definition at line 179 of file HGCDigitizerBase.cc.

                                                                                                             {
   int itIdx(9);
   if (rawDataFrame.size() <= itIdx + 2)
     return;
  
   DFr dataFrame(rawDataFrame.id());
   dataFrame.resize(5);
   bool putInEvent(false);
   for (int it = 0; it < 5; it++) {
     dataFrame.setSample(it, rawDataFrame[itIdx - 2 + it]);
     if (it == 2)
       putInEvent = rawDataFrame[itIdx - 2 + it].threshold();
   }
  
   if (putInEvent) {
     coll->push_back(dataFrame);
   }
 }

Member Data Documentation

◆ bxTime_

template<class DFr>

double HGCDigitizerBase< DFr >::bxTime_

protected

Definition at line 150 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCalDataFrame >::HGCDigitizerBase().

◆ cce_

template<class DFr>

std::vector<double> HGCDigitizerBase< DFr >::cce_

protected

Definition at line 135 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCalDataFrame >::HGCDigitizerBase().

◆ doseMapFile_

template<class DFr>

std::string HGCDigitizerBase< DFr >::doseMapFile_

protected

Definition at line 141 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCalDataFrame >::HGCDigitizerBase().

◆ doTimeSamples_

template<class DFr>

bool HGCDigitizerBase< DFr >::doTimeSamples_

protected

Definition at line 153 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCalDataFrame >::HGCDigitizerBase().

◆ GaussianNoiseArray_

template<class DFr>

std::array<std::array<double, samplesize_>, NoiseArrayLength_> HGCDigitizerBase< DFr >::GaussianNoiseArray_

protected

Definition at line 163 of file HGCDigitizerBase.h.

◆ keV2fC_

template<class DFr>

float HGCDigitizerBase< DFr >::keV2fC_

protected

Definition at line 129 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCalDataFrame >::HGCDigitizerBase(), and HGCDigitizerBase< HGCalDataFrame >::keV2fC().

◆ myCfg_

template<class DFr>

edm::ParameterSet HGCDigitizerBase< DFr >::myCfg_

protected

Definition at line 122 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCalDataFrame >::HGCDigitizerBase().

◆ myFEelectronics_

template<class DFr>

std::unique_ptr<HGCFEElectronics<DFr> > HGCDigitizerBase< DFr >::myFEelectronics_

protected

Definition at line 147 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCalDataFrame >::HGCDigitizerBase(), HGCDigitizerBase< HGCalDataFrame >::tdcForToAOnset(), HGCDigitizerBase< HGCalDataFrame >::tdcOnset(), and HGCDigitizerBase< HGCalDataFrame >::toaModeByEnergy().

◆ noise_fC_

template<class DFr>

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

protected

Definition at line 132 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCalDataFrame >::HGCDigitizerBase().

◆ NoiseArrayLength_

template<class DFr>

const size_t HGCDigitizerBase< DFr >::NoiseArrayLength_ = 200000

staticprotected

Definition at line 161 of file HGCDigitizerBase.h.

◆ NoiseGeneration_Method_

template<class DFr>

bool HGCDigitizerBase< DFr >::NoiseGeneration_Method_

protected

Definition at line 166 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCalDataFrame >::HGCDigitizerBase().

◆ NoiseMean_

template<class DFr>

const double HGCDigitizerBase< DFr >::NoiseMean_

protected

Definition at line 160 of file HGCDigitizerBase.h.

◆ NoiseStd_

template<class DFr>

const double HGCDigitizerBase< DFr >::NoiseStd_

protected

Definition at line 160 of file HGCDigitizerBase.h.

◆ RandNoiseGenerationFlag_

template<class DFr>

bool HGCDigitizerBase< DFr >::RandNoiseGenerationFlag_

protected

Definition at line 164 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCalDataFrame >::HGCDigitizerBase().

◆ samplesize_

template<class DFr>

const size_t HGCDigitizerBase< DFr >::samplesize_ = 15

staticprotected

Definition at line 162 of file HGCDigitizerBase.h.

◆ scal_

template<class DFr>

HGCalSiNoiseMap HGCDigitizerBase< DFr >::scal_

protected

Definition at line 144 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCalDataFrame >::HGCDigitizerBase().

◆ scaleByDose_

template<class DFr>

bool HGCDigitizerBase< DFr >::scaleByDose_

protected

Definition at line 138 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCalDataFrame >::HGCDigitizerBase().

◆ thresholdFollowsMIP_

template<class DFr>

bool HGCDigitizerBase< DFr >::thresholdFollowsMIP_

protected

Definition at line 156 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCalDataFrame >::HGCDigitizerBase().

Public Types

Public Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

template<class DFr> class HGCDigitizerBase< DFr >

Member Typedef Documentation

◆ DColl

◆ DigiType

Constructor & Destructor Documentation

◆ HGCDigitizerBase()

◆ ~HGCDigitizerBase()

Member Function Documentation

◆ GenerateGaussianNoise()

◆ keV2fC()

◆ run()

◆ runDigitizer()

◆ runSimple()

◆ tdcForToAOnset()

◆ tdcOnset()

◆ toaModeByEnergy()

◆ updateOutput()

Member Data Documentation

◆ bxTime_

◆ cce_

◆ doseMapFile_

◆ doTimeSamples_

◆ GaussianNoiseArray_

◆ keV2fC_

◆ myCfg_

◆ myFEelectronics_

◆ noise_fC_

◆ NoiseArrayLength_

◆ NoiseGeneration_Method_

◆ NoiseMean_

◆ NoiseStd_

◆ RandNoiseGenerationFlag_

◆ samplesize_

◆ scal_

◆ scaleByDose_

◆ thresholdFollowsMIP_

template<class DFr>
class HGCDigitizerBase< DFr >