#include <HPDIonFeedbackSim.h>

Inheritance diagram for HPDIonFeedbackSim:

Public Member Functions
void	addThermalNoise (CaloSamples &samples, CLHEP::HepRandomEngine *)

double	correctPE (const DetId &detId, double npe, CLHEP::HepRandomEngine *) const override

double	getIonFeedback (DetId detId, double signal, double pedWidth, bool doThermal, bool isInGeV, CLHEP::HepRandomEngine *)

	HPDIonFeedbackSim (const edm::ParameterSet &, const CaloShapes *shapes)
	need a shaper in order to set thermal noise More...

void	setDbService (const HcalDbService *service)

	~HPDIonFeedbackSim () override

Public Member Functions inherited from CaloVPECorrection
virtual	~CaloVPECorrection ()

Private Member Functions
double	fCtoGeV (const DetId &detId) const

Private Attributes
const HcalDbService *	theDbService

const CaloShapes *	theShapes

Detailed Description

Definition at line 27 of file HPDIonFeedbackSim.h.

Constructor & Destructor Documentation

◆ HPDIonFeedbackSim()

HPDIonFeedbackSim::HPDIonFeedbackSim	(	const edm::ParameterSet &	iConfig,
		const CaloShapes *	shapes
	)

need a shaper in order to set thermal noise

Definition at line 32 of file HPDIonFeedbackSim.cc.

33 : theDbService(nullptr), theShapes(shapes) {}

HPDIonFeedbackSim::theDbService

const HcalDbService * theDbService

Definition: HPDIonFeedbackSim.h:45

HPDIonFeedbackSim::theShapes

const CaloShapes * theShapes

Definition: HPDIonFeedbackSim.h:46

◆ ~HPDIonFeedbackSim()

HPDIonFeedbackSim::~HPDIonFeedbackSim ( )

override

Definition at line 35 of file HPDIonFeedbackSim.cc.

35 {}

Member Function Documentation

◆ addThermalNoise()

void HPDIonFeedbackSim::addThermalNoise	(	CaloSamples &	samples,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 96 of file HPDIonFeedbackSim.cc.

References correctPE(), mps_fire::i, dqmiolumiharvest::j, PresampleTask_cfi::nSamples, EgammaValidation_cff::samples, CaloShapes::shape(), and theShapes.

Referenced by HcalAmplifier::amplify().

                                                                                           {
   // make some chance to add a PE (with a chance of feedback)
   // for each time sample
   double meanPE = 0.02;
   DetId detId(samples.id());
   int nSamples = samples.size();
   const CaloVShape* shape = theShapes->shape(detId);
   for (int i = 0; i < nSamples; ++i) {
     CLHEP::RandPoissonQ theRandPoissonQ(*engine, meanPE);
     double npe = theRandPoissonQ.fire();
     // TODOprobably should time-smear these
     if (npe > 0.) {
       // chance of feedback
       npe = correctPE(detId, npe, engine);
       for (int j = i; j < nSamples; ++j) {
         double timeFromPE = (j - i) * 25.;
         samples[j] += (*shape)(timeFromPE)*npe;
       }
     }
   }
 }

◆ correctPE()

double HPDIonFeedbackSim::correctPE	(	const DetId &	detId,
		double	npe,
		CLHEP::HepRandomEngine *	engine
	)		const

overridevirtual

Implements CaloVPECorrection.

Definition at line 61 of file HPDIonFeedbackSim.cc.

References createfilelist::int, dqmiolumiharvest::j, SiStripPI::max, hgchebackDigitizer_cfi::noise, and pe2Charge.

Referenced by addThermalNoise(), and getIonFeedback().

                                                                                                       {
   double rateInTail = 0.000211988;        //read this from XML file
   double rateInSecondTail = 4.61579e-06;  //read this from XML file
 
   // three gauss fit is applied to data to get ion feedback distribution
   // parameters (in fC)
   // first gaussian
   // double p0 = 9.53192e+05;
   // double p1 = -3.13653e-01;
   // double p2 = 2.78350e+00;
 
   // second gaussian
   // double p3 = 2.41611e+03;
   double p4 = 2.06117e+01;
   double p5 = 1.09239e+01;
 
   // third gaussian
   // double p6 = 3.42793e+01;
   double p7 = 5.45548e+01;
   double p8 = 1.59696e+01;
 
   double noise = 0.;  // fC
   int nFirst = (int)(CLHEP::RandBinomial::shoot(engine, npe, rateInTail));
   int nSecond = (int)(CLHEP::RandBinomial::shoot(engine, npe, rateInSecondTail));
 
   for (int j = 0; j < nFirst; ++j) {
     noise += CLHEP::RandGaussQ::shoot(engine, p4, p5);
   }
   for (int j = 0; j < nSecond; ++j) {
     noise += CLHEP::RandGaussQ::shoot(engine, p7, p8);
   }
 
   return npe + std::max(noise / pe2Charge, 0.);
 }

◆ fCtoGeV()

double HPDIonFeedbackSim::fCtoGeV ( const DetId & detId ) const

private

Definition at line 118 of file HPDIonFeedbackSim.cc.

References cms::cuda::assert(), ecalph2::gains, HcalDbService::getGain(), HcalDbService::getGainWidth(), mps_fire::result, and theDbService.

Referenced by getIonFeedback().

                                                           {
   assert(theDbService != nullptr);
   HcalGenericDetId hcalGenDetId(detId);
   const HcalGain* gains = theDbService->getGain(hcalGenDetId);
   const HcalGainWidth* gwidths = theDbService->getGainWidth(hcalGenDetId);
   double result = 0.0;
   if (!gains || !gwidths) {
     edm::LogError("HcalAmplifier") << "Could not fetch HCAL conditions for channel " << hcalGenDetId;
   } else {
     // only one gain will be recorded per channel, so just use capID 0 for now
     result = gains->getValue(0);
   }
   return result;
 }

◆ getIonFeedback()

double HPDIonFeedbackSim::getIonFeedback	(	DetId	detId,
		double	signal,
		double	pedWidth,
		bool	doThermal,
		bool	isInGeV,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 37 of file HPDIonFeedbackSim.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, correctPE(), fCtoGeV(), createfilelist::int, hgchebackDigitizer_cfi::noise, and pe2Charge.

                                                                                                              {
   //    HcalDetId id = detId;
 
   double GeVperfC = 1.;
   if (isInGeV)
     GeVperfC = 1. / fCtoGeV(detId);
 
   double charge = signal / GeVperfC;
 
   double noise = 0.;             // fC
   if (charge > 3. * pedWidth) {  // 3 sigma away from pedestal mean
     int npe = int(charge / pe2Charge);
     if (doThermal) {
       double electronEmission = 0.08;
       CLHEP::RandPoissonQ theRandPoissonQ(*engine, electronEmission);
       npe += theRandPoissonQ.fire();
     }
 
     noise = correctPE(detId, npe, engine) - npe;
   }
   return (noise * GeVperfC);
 }