Inheritance diagram for HGCHEbackDigitizer:

Public Member Functions
	HGCHEbackDigitizer (const edm::ParameterSet &ps)

void	runDigitizer (std::unique_ptr< HGCalDigiCollection > &digiColl, hgc::HGCSimHitDataAccumulator &simData, const CaloSubdetectorGeometry theGeom, const std::unordered_set< DetId > &validIds, CLHEP::HepRandomEngine engine) override

	~HGCHEbackDigitizer () override

Public Member Functions inherited from HGCDigitizerBase
DetId::Detector	det () const

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, CLHEP::HepRandomEngine engine)=0
	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 More...

ForwardSubdetector	subdet () const

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...

Private Member Functions
void	runCaliceLikeDigitizer (std::unique_ptr< HGCalDigiCollection > &digiColl, hgc::HGCSimHitDataAccumulator &simData, const CaloSubdetectorGeometry theGeom, const std::unordered_set< DetId > &validIds, CLHEP::HepRandomEngine engine)

void	runEmptyDigitizer (std::unique_ptr< HGCalDigiCollection > &digiColl, hgc::HGCSimHitDataAccumulator &simData, const CaloSubdetectorGeometry theGeom, const std::unordered_set< DetId > &validIds, CLHEP::HepRandomEngine engine)

void	runRealisticDigitizer (std::unique_ptr< HGCalDigiCollection > &digiColl, hgc::HGCSimHitDataAccumulator &simData, const CaloSubdetectorGeometry theGeom, const std::unordered_set< DetId > &validIds, CLHEP::HepRandomEngine engine)

Private Attributes
uint32_t	algo_

std::string	doseMapFile_

float	keV2MIP_

float	noise_MIP_

float	nPEperMIP_

float	nTotalPE_

HGCalSciNoiseMap	scal_

bool	scaleByDose_

float	sdPixels_

std::string	sipmMapFile_

bool	thresholdFollowsMIP_

float	xTalk_

Additional Inherited Members
Public Types inherited from HGCDigitizerBase
typedef edm::SortedCollection< DFr >	DColl

typedef HGCalDataFrame	DFr

Protected Attributes inherited from HGCDigitizerBase
double	bxTime_

std::vector< double >	cce_

DetId::Detector	det_

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< HGCSiliconDetId >	scal_

bool	scaleByDose_

double	scaleByDoseFactor_

HGCalSiNoiseMap< HFNoseDetId >	scalHFNose_

ForwardSubdetector	subdet_

bool	thresholdFollowsMIP_

Static Protected Attributes inherited from HGCDigitizerBase
static const size_t	NoiseArrayLength_ = 200000

static const size_t	samplesize_ = 15

Detailed Description

Definition at line 15 of file HGCHEbackDigitizer.cc.

Constructor & Destructor Documentation

◆ HGCHEbackDigitizer()

HGCHEbackDigitizer::HGCHEbackDigitizer ( const edm::ParameterSet & ps )

Definition at line 53 of file HGCHEbackDigitizer.cc.

References algo_, looper::cfg, HGCDigitizerBase::det_, doseMapFile_, HGCalSciNoiseMap::getNPeInSiPM(), edm::ParameterSet::getParameter(), DetId::HGCalHSc, HGCDigitizerBase::keV2fC_, keV2MIP_, HGCDigitizerBase::myFEelectronics_, noise_MIP_, nPEperMIP_, nTotalPE_, scal_, scaleByDose_, hgcalLayerClustersEE_cfi::scaleByDoseAlgo, HGCDigitizerBase::scaleByDoseFactor_, sdPixels_, HGCalSciNoiseMap::setDoseMap(), HGCalRadiationMap::setFluenceScaleFactor(), HGCalSciNoiseMap::setReferenceCrossTalk(), HGCalSciNoiseMap::setReferenceDarkCurrent(), HGCalSciNoiseMap::setSipmMap(), sipmMapFile_, thresholdFollowsMIP_, and xTalk_.

                                                                 : HGCDigitizerBase(ps) {
   edm::ParameterSet cfg = ps.getParameter<edm::ParameterSet>("digiCfg");
   algo_ = cfg.getParameter<uint32_t>("algo");
   sipmMapFile_ = cfg.getParameter<edm::ParameterSet>("noise").getParameter<std::string>("sipmMap");
   scaleByDose_ = cfg.getParameter<edm::ParameterSet>("noise").getParameter<bool>("scaleByDose");
   unsigned int scaleByDoseAlgo = cfg.getParameter<edm::ParameterSet>("noise").getParameter<uint32_t>("scaleByDoseAlgo");
   scaleByDoseFactor_ = cfg.getParameter<edm::ParameterSet>("noise").getParameter<double>("scaleByDoseFactor");
   doseMapFile_ = cfg.getParameter<edm::ParameterSet>("noise").getParameter<std::string>("doseMap");
   noise_MIP_ = cfg.getParameter<edm::ParameterSet>("noise").getParameter<double>("noise_MIP");
   double refIdark = cfg.getParameter<edm::ParameterSet>("noise").getParameter<double>("referenceIdark");
   xTalk_ = cfg.getParameter<edm::ParameterSet>("noise").getParameter<double>("referenceXtalk");
   thresholdFollowsMIP_ = cfg.getParameter<bool>("thresholdFollowsMIP");
   keV2MIP_ = cfg.getParameter<double>("keV2MIP");
   this->keV2fC_ = 1.0;  //keV2MIP_; // hack for HEB
   this->det_ = DetId::HGCalHSc;
   nPEperMIP_ = cfg.getParameter<double>("nPEperMIP");
   nTotalPE_ = cfg.getParameter<double>("nTotalPE");
   sdPixels_ = cfg.getParameter<double>("sdPixels");
 
   scal_.setDoseMap(doseMapFile_, scaleByDoseAlgo);
   scal_.setReferenceDarkCurrent(refIdark);
   scal_.setFluenceScaleFactor(scaleByDoseFactor_);
   scal_.setSipmMap(sipmMapFile_);
   scal_.setReferenceCrossTalk(xTalk_);
   //the ADC will be updated on the fly depending on the gain
   //but the TDC scale needs to be updated to use pe instead of MIP units
   if (scaleByDose_)
     this->myFEelectronics_->setTDCfsc(2 * scal_.getNPeInSiPM());
 }

◆ ~HGCHEbackDigitizer()

HGCHEbackDigitizer::~HGCHEbackDigitizer ( )

override

Definition at line 322 of file HGCHEbackDigitizer.cc.

322 {}

Member Function Documentation

◆ runCaliceLikeDigitizer()

void HGCHEbackDigitizer::runCaliceLikeDigitizer	(	std::unique_ptr< HGCalDigiCollection > &	digiColl,
		hgc::HGCSimHitDataAccumulator &	simData,
		const CaloSubdetectorGeometry *	theGeom,
		const std::unordered_set< DetId > &	validIds,
		CLHEP::HepRandomEngine *	engine
	)

private

Definition at line 255 of file HGCHEbackDigitizer.cc.

References hgc_digi_utils::addCellMetadata(), debug, f, myMath::fast_expf(), myMath::fast_logf(), nano_mu_digi_cff::float, hgc_digi::HGCCellInfo::hit_info, mps_fire::i, keV2MIP_, SiStripPI::max, HGCDigitizerBase::myFEelectronics_, noise_MIP_, nPEperMIP_, nTotalPE_, sdPixels_, HGCDigitizerBase::updateOutput(), x, and xTalk_.

Referenced by runDigitizer().

                                                                               {
   //switch to true if you want to print some details
   constexpr bool debug(false);
 
   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
 
   for (const auto& id : validIds) {
     chargeColl.fill(0.f);
     HGCSimHitDataAccumulator::iterator it = simData.find(id);
     HGCCellInfo& cell = (simData.end() == it ? zeroData : it->second);
     addCellMetadata(cell, theGeom, id);
 
     for (size_t i = 0; i < cell.hit_info[0].size(); ++i) {
       //convert total energy keV->MIP, since converted to keV in accumulator
       const float totalIniMIPs(cell.hit_info[0][i] * keV2MIP_);
 
       //generate random number of photon electrons
       const uint32_t npe = std::floor(CLHEP::RandPoissonQ::shoot(engine, totalIniMIPs * nPEperMIP_));
 
       //number of pixels
       const float x = vdt::fast_expf(-((float)npe) / nTotalPE_);
       uint32_t nPixel(0);
       if (xTalk_ * x != 1)
         nPixel = (uint32_t)std::max(nTotalPE_ * (1.f - x) / (1.f - xTalk_ * x), 0.f);
 
       //update signal
       if (sdPixels_ != 0)
         nPixel = (uint32_t)std::max(CLHEP::RandGaussQ::shoot(engine, (double)nPixel, sdPixels_), 0.);
 
       //convert to MIP again and saturate
       float totalMIPs(0.f), xtalk = 0.f;
       const float peDiff = nTotalPE_ - (float)nPixel;
       if (peDiff != 0.f) {
         xtalk = (nTotalPE_ - xTalk_ * ((float)nPixel)) / peDiff;
         if (xtalk > 0.f && nPEperMIP_ != 0.f)
           totalMIPs = (nTotalPE_ / nPEperMIP_) * vdt::fast_logf(xtalk);
       }
 
       //add noise (in MIPs)
       chargeColl[i] = totalMIPs;
       if (noise_MIP_ != 0)
         chargeColl[i] += std::max(CLHEP::RandGaussQ::shoot(engine, 0., noise_MIP_), 0.);
       if (debug && cell.hit_info[0][i] > 0)
         edm::LogVerbatim("HGCDigitizer") << "[runCaliceLikeDigitizer] xtalk=" << xtalk << " En=" << cell.hit_info[0][i]
                                          << " keV -> " << totalIniMIPs << " raw-MIPs -> " << chargeColl[i]
                                          << " digi-MIPs";
     }
 
     //init a new data frame and run shaper
     HGCalDataFrame newDataFrame(id);
     this->myFEelectronics_->runShaper(newDataFrame, chargeColl, toa, engine);
 
     //prepare the output
     this->updateOutput(digiColl, newDataFrame);
   }
 }

◆ runDigitizer()

void HGCHEbackDigitizer::runDigitizer	(	std::unique_ptr< HGCalDigiCollection > &	digiColl,
		hgc::HGCSimHitDataAccumulator &	simData,
		const CaloSubdetectorGeometry *	theGeom,
		const std::unordered_set< DetId > &	validIds,
		CLHEP::HepRandomEngine *	engine
	)

override

Definition at line 84 of file HGCHEbackDigitizer.cc.

References algo_, DigiToRawDM_cff::digiColl, runCaliceLikeDigitizer(), runEmptyDigitizer(), and runRealisticDigitizer().

                                                                     {
   if (algo_ == 0)
     runEmptyDigitizer(digiColl, simData, theGeom, validIds, engine);
   else if (algo_ == 1)
     runCaliceLikeDigitizer(digiColl, simData, theGeom, validIds, engine);
   else if (algo_ == 2)
     runRealisticDigitizer(digiColl, simData, theGeom, validIds, engine);
 }

◆ runEmptyDigitizer()

void HGCHEbackDigitizer::runEmptyDigitizer	(	std::unique_ptr< HGCalDigiCollection > &	digiColl,
		hgc::HGCSimHitDataAccumulator &	simData,
		const CaloSubdetectorGeometry *	theGeom,
		const std::unordered_set< DetId > &	validIds,
		CLHEP::HepRandomEngine *	engine
	)

private

Definition at line 97 of file HGCHEbackDigitizer.cc.

References hgc_digi_utils::addCellMetadata(), f, hgc_digi::HGCCellInfo::hit_info, mps_fire::i, keV2MIP_, HGCDigitizerBase::myFEelectronics_, and HGCDigitizerBase::updateOutput().

Referenced by runDigitizer().

                                                                          {
   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
 
   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);
 
     for (size_t i = 0; i < cell.hit_info[0].size(); ++i) {
       //convert total energy keV->MIP, since converted to keV in accumulator
       const float totalIniMIPs(cell.hit_info[0][i] * keV2MIP_);
 
       //store
       chargeColl[i] = totalIniMIPs;
     }
 
     //init a new data frame and run shaper
     HGCalDataFrame newDataFrame(id);
     this->myFEelectronics_->runShaper(newDataFrame, chargeColl, toa, engine);
 
     //prepare the output
     this->updateOutput(digiColl, newDataFrame);
   }
 }

◆ runRealisticDigitizer()

void HGCHEbackDigitizer::runRealisticDigitizer	(	std::unique_ptr< HGCalDigiCollection > &	digiColl,
		hgc::HGCSimHitDataAccumulator &	simData,
		const CaloSubdetectorGeometry *	theGeom,
		const std::unordered_set< DetId > &	validIds,
		CLHEP::HepRandomEngine *	engine
	)

private

Definition at line 132 of file HGCHEbackDigitizer.cc.

References hgc_digi_utils::addCellMetadata(), HGCalRadiationMap::computeRadius(), debug, HGCDigitizerBase::det(), MillePedeFileConverter_cfg::e, f, myMath::fast_expf(), HGCalSciNoiseMap::getLSBPerGain(), HGCalSciNoiseMap::getMaxADCPerGain(), DetId::HGCalHSc, hgc_digi::HGCCellInfo::hit_info, mps_fire::i, HGCalSciNoiseMap::ignoreAutoPedestalSubtraction(), keV2MIP_, LogDebug, SiStripPI::max, HGCDigitizerBase::myFEelectronics_, noise_MIP_, nPEperMIP_, nTotalPE_, EcalCondDBWriter_cfi::pedestal, conifer::pow(), CosmicsPD_Skims::radius, nano_mu_digi_cff::rawId, HGCalSciNoiseMap::SiPMonTileCharacteristics::s, scal_, HGCalSciNoiseMap::scaleByDose(), scaleByDose_, HGCalRadiationMap::setGeometry(), thresholdFollowsMIP_, HGCDigitizerBase::updateOutput(), x, hgchebackDigitizer_cfi::xTalk, and xTalk_.

Referenced by runDigitizer().

                                                                              {
   //switch to true if you want to print some details
   constexpr bool debug(false);
 
   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
 
   // needed to compute the radiation and geometry scale factors
   scal_.setGeometry(theGeom);
 
   //vanilla reference values are indepenent of the ids and were set by
   //configuration in the python - no need to recomput them every time
   //in the digitization loop
   float scaledPePerMip = nPEperMIP_;                                //needed to scale according to tile geometry
   float tunedNoise = nPEperMIP_ * noise_MIP_;                       //flat noise case
   float vanillaADCThr = this->myFEelectronics_->getADCThreshold();  //vanilla thrs  in MIPs
   float adcLsb(this->myFEelectronics_->getADClsb());
   float maxADC(-1);  //vanilla will rely on what has been configured by default
   uint32_t thrADC(thresholdFollowsMIP_ ? std::floor(vanillaADCThr / adcLsb * scaledPePerMip / nPEperMIP_)
                                        : std::floor(vanillaADCThr / adcLsb));
   float nTotalPixels(nTotalPE_);
   float xTalk(xTalk_);
   int gainIdx(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);
 
     //in case realistic scenario (noise, fluence, dose, sipm/tile area) are to be used
     //we update vanilla values with the realistic ones
     if (id.det() == DetId::HGCalHSc && scaleByDose_) {
       HGCScintillatorDetId scId(id.rawId());
       double radius = scal_.computeRadius(scId);
       auto opChar = scal_.scaleByDose(scId, radius);
       scaledPePerMip = opChar.s;
       tunedNoise = opChar.n;
       gainIdx = opChar.gain;
       thrADC = opChar.thrADC;
       adcLsb = scal_.getLSBPerGain()[gainIdx];
       maxADC = scal_.getMaxADCPerGain()[gainIdx] - 1e-6;
       nTotalPixels = opChar.ntotalPE;
       xTalk = opChar.xtalk;
     }
 
     //set mean for poissonian noise
     float meanN = std::pow(tunedNoise, 2);
 
     for (size_t i = 0; i < cell.hit_info[0].size(); ++i) {
       //convert total energy keV->MIP, since converted to keV in accumulator
       float totalIniMIPs(cell.hit_info[0][i] * keV2MIP_);
 
       //generate the number of photo-electrons from the energy deposit
       const uint32_t npeS = std::floor(CLHEP::RandPoissonQ::shoot(engine, totalIniMIPs * scaledPePerMip) + 0.5);
 
       //generate the noise associated to the dark current
       const uint32_t npeN = std::floor(CLHEP::RandPoissonQ::shoot(engine, meanN) + 0.5);
 
       //total number of pe from signal + noise  (not subtracting pedestal)
       const uint32_t npe = npeS + npeN;
 
       //take into account SiPM saturation
       uint32_t nPixel(npe);
       if (xTalk >= 0) {
         const float x = vdt::fast_expf(-((float)npe) / nTotalPixels);
         if (xTalk_ * x != 1)
           nPixel = (uint32_t)std::max(nTotalPixels * (1.f - x) / (1.f - xTalk_ * x), 0.f);
       }
 
       //take into account the gain fluctuations of each pixel
       //FDG: just a note for now, par to be defined
       //const float nPixelTot = nPixel + sqrt(nPixel) * CLHEP::RandGaussQ::shoot(engine, 0., 0.05);
 
       //realistic behavior: subtract the pedestal
       //Note: for now the saturation effects are ignored...
       if (scaleByDose_) {
         float pedestal(meanN);
         if (scal_.ignoreAutoPedestalSubtraction())
           pedestal = 0.f;
         chargeColl[i] = std::max(nPixel - pedestal, 0.f);
       }
       //vanilla simulation: scale back to MIP units... and to calibrated response depending on the thresholdFollowsMIP_ flag
       else {
         float totalMIPs = thresholdFollowsMIP_ ? std::max((nPixel - meanN), 0.f) / nPEperMIP_ : nPixel / nPEperMIP_;
 
         if (debug && totalIniMIPs > 0) {
           LogDebug("HGCHEbackDigitizer") << "npeS: " << npeS << " npeN: " << npeN << " npe: " << npe
                                          << " meanN: " << meanN << " noise_MIP_: " << noise_MIP_
                                          << " nPEperMIP_: " << nPEperMIP_ << " scaledPePerMip: " << scaledPePerMip
                                          << " nPixel: " << nPixel;
           LogDebug("HGCHEbackDigitizer") << "totalIniMIPs: " << totalIniMIPs << " totalMIPs: " << totalMIPs
                                          << std::endl;
         }
 
         //store charge
         chargeColl[i] = totalMIPs;
       }
 
       //update time of arrival
       toa[i] = cell.hit_info[1][i];
       if (myFEelectronics_->toaMode() == HGCFEElectronics<HGCalDataFrame>::WEIGHTEDBYE && totalIniMIPs > 0)
         toa[i] = cell.hit_info[1][i] / totalIniMIPs;
     }
 
     //init a new data frame and run shaper
     HGCalDataFrame newDataFrame(id);
     this->myFEelectronics_->runShaper(newDataFrame, chargeColl, toa, engine, thrADC, adcLsb, gainIdx, maxADC);
 
     //prepare the output
     this->updateOutput(digiColl, newDataFrame);
   }
 }

Member Data Documentation

◆ algo_

uint32_t HGCHEbackDigitizer::algo_

private

Definition at line 27 of file HGCHEbackDigitizer.cc.

Referenced by HGCHEbackDigitizer(), and runDigitizer().

◆ doseMapFile_

std::string HGCHEbackDigitizer::doseMapFile_

private

Definition at line 31 of file HGCHEbackDigitizer.cc.

Referenced by HGCHEbackDigitizer().

◆ keV2MIP_

float HGCHEbackDigitizer::keV2MIP_

private

Definition at line 29 of file HGCHEbackDigitizer.cc.

Referenced by HGCHEbackDigitizer(), runCaliceLikeDigitizer(), runEmptyDigitizer(), and runRealisticDigitizer().

◆ noise_MIP_

float HGCHEbackDigitizer::noise_MIP_

private

Definition at line 29 of file HGCHEbackDigitizer.cc.

Referenced by HGCHEbackDigitizer(), runCaliceLikeDigitizer(), and runRealisticDigitizer().

◆ nPEperMIP_

float HGCHEbackDigitizer::nPEperMIP_

private

Definition at line 30 of file HGCHEbackDigitizer.cc.

Referenced by HGCHEbackDigitizer(), runCaliceLikeDigitizer(), and runRealisticDigitizer().

◆ nTotalPE_

float HGCHEbackDigitizer::nTotalPE_

private

Definition at line 30 of file HGCHEbackDigitizer.cc.

Referenced by HGCHEbackDigitizer(), runCaliceLikeDigitizer(), and runRealisticDigitizer().

◆ scal_

HGCalSciNoiseMap HGCHEbackDigitizer::scal_

private

Definition at line 32 of file HGCHEbackDigitizer.cc.

Referenced by HGCHEbackDigitizer(), and runRealisticDigitizer().

◆ scaleByDose_

bool HGCHEbackDigitizer::scaleByDose_

private

Definition at line 28 of file HGCHEbackDigitizer.cc.

Referenced by HGCHEbackDigitizer(), and runRealisticDigitizer().

◆ sdPixels_

float HGCHEbackDigitizer::sdPixels_

private

Definition at line 30 of file HGCHEbackDigitizer.cc.

Referenced by HGCHEbackDigitizer(), and runCaliceLikeDigitizer().

◆ sipmMapFile_

std::string HGCHEbackDigitizer::sipmMapFile_

private

Definition at line 31 of file HGCHEbackDigitizer.cc.

Referenced by HGCHEbackDigitizer().

◆ thresholdFollowsMIP_

bool HGCHEbackDigitizer::thresholdFollowsMIP_

private

Definition at line 28 of file HGCHEbackDigitizer.cc.

Referenced by HGCHEbackDigitizer(), and runRealisticDigitizer().

◆ xTalk_

float HGCHEbackDigitizer::xTalk_

private

Definition at line 30 of file HGCHEbackDigitizer.cc.

Referenced by HGCHEbackDigitizer(), runCaliceLikeDigitizer(), and runRealisticDigitizer().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ HGCHEbackDigitizer()

◆ ~HGCHEbackDigitizer()

Member Function Documentation

◆ runCaliceLikeDigitizer()

◆ runDigitizer()

◆ runEmptyDigitizer()

◆ runRealisticDigitizer()

Member Data Documentation

◆ algo_

◆ doseMapFile_

◆ keV2MIP_

◆ noise_MIP_

◆ nPEperMIP_

◆ nTotalPE_

◆ scal_

◆ scaleByDose_

◆ sdPixels_

◆ sipmMapFile_

◆ thresholdFollowsMIP_

◆ xTalk_