#include <EcalSignalGenerator.h>

Inheritance diagram for EcalSignalGenerator< ECALDIGITIZERTRAITS >:

Public Types
typedef std::unordered_map< uint32_t, double >	CalibCache

typedef ECALDIGITIZERTRAITS::DigiCollection	COLLECTION

typedef ECALDIGITIZERTRAITS::Digi	DIGI

Public Member Functions
	EcalSignalGenerator ()

	EcalSignalGenerator (const edm::InputTag &inputTag, const edm::EDGetTokenT< COLLECTION > &t, const double EBs25notCont, const double EEs25notCont, const double peToABarrel, const double peToAEndcap, const bool timeDependent=false)

virtual void	fill (edm::ModuleCallingContext const *mcc)

void	initializeEvent (const edm::Event event, const edm::EventSetup eventSetup)

void	initializeEvent (const edm::EventPrincipal eventPrincipal, const edm::EventSetup eventSetup)
	some users use EventPrincipals, not Events. We support both More...

	~EcalSignalGenerator () override

Public Member Functions inherited from EcalBaseSignalGenerator
	EcalBaseSignalGenerator ()

	~EcalBaseSignalGenerator () override

Public Member Functions inherited from CaloVNoiseSignalGenerator
	CaloVNoiseSignalGenerator ()

bool	contains (const DetId &detId) const

void	fillEvent ()

void	fillEvent (CLHEP::HepRandomEngine *)
	fill theNoiseSignals with one event's worth of noise, in units of pe More...

void	getNoiseSignals (std::vector< CaloSamples > &noiseSignals)

void	setNoiseSignals (const std::vector< CaloSamples > &noiseSignals)

virtual	~CaloVNoiseSignalGenerator ()

Private Types
enum	{ NBITS = 12, MAXADC = 4095, ADCGAINSWITCH = 4079, NGAINS = 3 }

Private Member Functions
void	fillNoiseSignals () override

void	fillNoiseSignals (CLHEP::HepRandomEngine *) override

double	findLaserConstant_LC (const DetId &detId) const

double	findLaserConstant_LC_prime (const DetId &detId) const

double	fullScaleEnergy (const DetId &detId) const

const std::vector< float >	GetGainRatios (const DetId &detid)

double	peToAConversion (const DetId &detId) const

CaloSamples	samplesInPE (const DIGI &digi)

bool	validDigi (const DIGI &digi)

Private Attributes
const EcalADCToGeVConstant *	agc

const ESGain *	esgain

int	ESgain

const ESIntercalibConstants *	esmips

const ESMIPToGeVConstant *	esMipToGeV

double	ESMIPToGeV

edm::ESHandle< EcalGainRatios >	grHandle

edm::ESHandle< ESGain >	hesgain

edm::ESHandle< ESIntercalibConstants >	hesMIPs

edm::ESHandle< ESMIPToGeVConstant >	hesMIPToGeV

const EcalIntercalibConstantsMC *	ical

double	m_EBs25notCont

double	m_EEs25notCont

edm::TimeValue_t	m_iTime

const EcalLaserDbService *	m_lasercals

const EcalLaserDbService *	m_lasercals_prime

double	m_maxEneEB

double	m_maxEneEE

double	m_peToABarrel

double	m_peToAEndcap

bool	m_timeDependent

CalibCache	m_valueLCCache_LC

CalibCache	m_valueLCCache_LC_prime

edm::ESHandle< EcalADCToGeVConstant >	pAgc

edm::ESHandle< EcalIntercalibConstantsMC >	pIcal

double	theDefaultGains [NGAINS]

const edm::Event *	theEvent
	these fields are set in initializeEvent() More...

const edm::EventPrincipal *	theEventPrincipal

edm::InputTag	theInputTag
	these come from the ParameterSet More...

edm::EDGetTokenT< COLLECTION >	tok_

Additional Inherited Members
Protected Attributes inherited from CaloVNoiseSignalGenerator
std::vector< CaloSamples >	theNoiseSignals

Detailed Description

template<class ECALDIGITIZERTRAITS>
class EcalSignalGenerator< ECALDIGITIZERTRAITS >

Definition at line 55 of file EcalSignalGenerator.h.

Member Typedef Documentation

◆ CalibCache

template<class ECALDIGITIZERTRAITS>

typedef std::unordered_map<uint32_t, double> EcalSignalGenerator< ECALDIGITIZERTRAITS >::CalibCache

Definition at line 60 of file EcalSignalGenerator.h.

◆ COLLECTION

template<class ECALDIGITIZERTRAITS>

typedef ECALDIGITIZERTRAITS::DigiCollection EcalSignalGenerator< ECALDIGITIZERTRAITS >::COLLECTION

Definition at line 58 of file EcalSignalGenerator.h.

◆ DIGI

template<class ECALDIGITIZERTRAITS>

typedef ECALDIGITIZERTRAITS::Digi EcalSignalGenerator< ECALDIGITIZERTRAITS >::DIGI

Definition at line 57 of file EcalSignalGenerator.h.

Member Enumeration Documentation

◆ anonymous enum

template<class ECALDIGITIZERTRAITS>

anonymous enum

private

Enumerator
NBITS
MAXADC
ADCGAINSWITCH
NGAINS

Definition at line 256 of file EcalSignalGenerator.h.

        {
     NBITS = 12,            // number of available bits
     MAXADC = 4095,         // 2^12 -1,  adc max range
     ADCGAINSWITCH = 4079,  // adc gain switch
     NGAINS = 3
   };  // number of electronic gains

Constructor & Destructor Documentation

◆ EcalSignalGenerator() [1/2]

template<class ECALDIGITIZERTRAITS>

EcalSignalGenerator< ECALDIGITIZERTRAITS >::EcalSignalGenerator ( )

inline

Definition at line 62 of file EcalSignalGenerator.h.

62 : EcalBaseSignalGenerator() {}

◆ EcalSignalGenerator() [2/2]

template<class ECALDIGITIZERTRAITS>

EcalSignalGenerator< ECALDIGITIZERTRAITS >::EcalSignalGenerator	(	const edm::InputTag &	inputTag,
		const edm::EDGetTokenT< COLLECTION > &	t,
		const double	EBs25notCont,
		const double	EEs25notCont,
		const double	peToABarrel,
		const double	peToAEndcap,
		const bool	timeDependent = `false`
	)

inline

Definition at line 64 of file EcalSignalGenerator.h.

       : EcalBaseSignalGenerator(), theEvent(nullptr), theEventPrincipal(nullptr), theInputTag(inputTag), tok_(t) {
     EcalMGPAGainRatio* defaultRatios = new EcalMGPAGainRatio();
     theDefaultGains[2] = defaultRatios->gain6Over1();
     theDefaultGains[1] = theDefaultGains[2] * (defaultRatios->gain12Over6());
     m_EBs25notCont = EBs25notCont;
     m_EEs25notCont = EEs25notCont;
     m_peToABarrel = peToABarrel;
     m_peToAEndcap = peToAEndcap;
     m_timeDependent = timeDependent;
   }

◆ ~EcalSignalGenerator()

template<class ECALDIGITIZERTRAITS>

EcalSignalGenerator< ECALDIGITIZERTRAITS >::~EcalSignalGenerator ( )

inlineoverride

Definition at line 82 of file EcalSignalGenerator.h.

82 {}

Member Function Documentation

◆ fill()

template<class ECALDIGITIZERTRAITS>

virtual void EcalSignalGenerator< ECALDIGITIZERTRAITS >::fill ( edm::ModuleCallingContext const * mcc )

inlinevirtual

Definition at line 208 of file EcalSignalGenerator.h.

                                                         {
     theNoiseSignals.clear();
     edm::Handle<COLLECTION> pDigis;
     const COLLECTION* digis = nullptr;
     // try accessing by whatever is set, Event or EventPrincipal
     if (theEvent) {
       if (theEvent->getByToken(tok_, pDigis)) {
         digis = pDigis.product();  // get a ptr to the product
       } else {
         throw cms::Exception("EcalSignalGenerator") << "Cannot find input data " << theInputTag;
       }
     } else if (theEventPrincipal) {
       std::shared_ptr<edm::Wrapper<COLLECTION> const> digisPTR =
           edm::getProductByTag<COLLECTION>(*theEventPrincipal, theInputTag, mcc);
       if (digisPTR) {
         digis = digisPTR->product();
       }
     } else {
       throw cms::Exception("EcalSignalGenerator") << "No Event or EventPrincipal was set";
     }
  
     if (digis) {
       // loop over digis, adding these to the existing maps
       for (typename COLLECTION::const_iterator it = digis->begin(); it != digis->end(); ++it) {
         // need to convert to something useful
         if (validDigi(*it)) {
           theNoiseSignals.push_back(samplesInPE(*it));
         }
       }
     }
     //else { std::cout << " NO digis for this input: " << theInputTag << std::endl;}
   }

Referenced by PreMixingEcalWorker::addPileups().

◆ fillNoiseSignals() [1/2]

template<class ECALDIGITIZERTRAITS>

void EcalSignalGenerator< ECALDIGITIZERTRAITS >::fillNoiseSignals ( )

inlineoverrideprivatevirtual

Implements CaloVNoiseSignalGenerator.

Definition at line 251 of file EcalSignalGenerator.h.

251 {}

◆ fillNoiseSignals() [2/2]

template<class ECALDIGITIZERTRAITS>

void EcalSignalGenerator< ECALDIGITIZERTRAITS >::fillNoiseSignals ( CLHEP::HepRandomEngine * )

inlineoverrideprivatevirtual

if you want to fill signals on demand, override this subclass is responsible for clearing theNoiseSignals before adding

Implements CaloVNoiseSignalGenerator.

Definition at line 252 of file EcalSignalGenerator.h.

252 {}

◆ findLaserConstant_LC()

template<class ECALDIGITIZERTRAITS>

double EcalSignalGenerator< ECALDIGITIZERTRAITS >::findLaserConstant_LC ( const DetId & detId ) const

inlineprivate

Definition at line 266 of file EcalSignalGenerator.h.

                                                         {
     const edm::Timestamp& evtTimeStamp = edm::Timestamp(m_iTime);
     return (m_lasercals->getLaserCorrection(detId, evtTimeStamp));
   }

◆ findLaserConstant_LC_prime()

template<class ECALDIGITIZERTRAITS>

double EcalSignalGenerator< ECALDIGITIZERTRAITS >::findLaserConstant_LC_prime ( const DetId & detId ) const

inlineprivate

Definition at line 273 of file EcalSignalGenerator.h.

                                                               {
     const edm::Timestamp& evtTimeStamp = edm::Timestamp(m_iTime);
     return (m_lasercals_prime->getLaserCorrection(detId, evtTimeStamp));
   }

◆ fullScaleEnergy()

template<class ECALDIGITIZERTRAITS>

double EcalSignalGenerator< ECALDIGITIZERTRAITS >::fullScaleEnergy ( const DetId & detId ) const

inlineprivate

Definition at line 291 of file EcalSignalGenerator.h.

291 { return detId.subdetId() == EcalBarrel ? m_maxEneEB : m_maxEneEE; }

◆ GetGainRatios()

template<class ECALDIGITIZERTRAITS>

const std::vector<float> EcalSignalGenerator< ECALDIGITIZERTRAITS >::GetGainRatios ( const DetId & detid )

inlineprivate

Definition at line 278 of file EcalSignalGenerator.h.

                                                            {
     std::vector<float> gainRatios(4);
     // get gain ratios
     EcalMGPAGainRatio theRatio = (*grHandle)[detid];
  
     gainRatios[0] = 0.;
     gainRatios[3] = 1.;
     gainRatios[2] = theRatio.gain6Over1();
     gainRatios[1] = theRatio.gain6Over1() * theRatio.gain12Over6();
  
     return gainRatios;
   }

◆ initializeEvent() [1/2]

template<class ECALDIGITIZERTRAITS>

void EcalSignalGenerator< ECALDIGITIZERTRAITS >::initializeEvent	(	const edm::Event *	event,
		const edm::EventSetup *	eventSetup
	)

inline

Definition at line 84 of file EcalSignalGenerator.h.

                                                                                {
     theEvent = event;
     eventSetup->get<EcalGainRatiosRcd>().get(grHandle);  // find the gains
     // Ecal Intercalibration Constants
     eventSetup->get<EcalIntercalibConstantsMCRcd>().get(pIcal);
     ical = pIcal.product();
     // adc to GeV
     eventSetup->get<EcalADCToGeVConstantRcd>().get(pAgc);
     agc = pAgc.product();
  
     m_maxEneEB = (agc->getEBValue()) * theDefaultGains[1] * MAXADC * m_EBs25notCont;
     m_maxEneEE = (agc->getEEValue()) * theDefaultGains[1] * MAXADC * m_EEs25notCont;
  
     if (m_timeDependent) {
       //----
       // Ecal LaserCorrection Constants for laser correction ratio
       edm::ESHandle<EcalLaserDbService> laser;
       eventSetup->get<EcalLaserDbRecord>().get(laser);
  
       //
       const edm::TimeValue_t eventTimeValue = theEvent->getRun().runAuxiliary().beginTime().value();
       //
       //         The "time" will have to match in the generation of the tag
       //         for the MC from ECAL (apd/pn, alpha, whatever time dependent is needed)
       //
       m_iTime = eventTimeValue;
  
       m_lasercals = laser.product();
  
       //
       // the "prime" is exactly the same as the usual laser service, BUT
       // it has only 1 IOV, so that effectively you are dividing IOV_n / IOV_0
       // NB: in the creation of the tag make sure the "prime" (MC) tag is prepared properly!
       // NB again: if many IOVs also in "MC" tag, then fancy things could be perfomed ... left for the future
       //
       edm::ESHandle<EcalLaserDbService> laser_prime;
       eventSetup->get<EcalLaserDbRecordMC>().get(laser_prime);
       m_lasercals_prime = laser_prime.product();
  
       //clear the laser cache for each event time
       CalibCache().swap(m_valueLCCache_LC);
       CalibCache().swap(m_valueLCCache_LC_prime);  //--- also the "prime" ... yes
  
       //----
     }
  
     //ES
     eventSetup->get<ESGainRcd>().get(hesgain);
     eventSetup->get<ESMIPToGeVConstantRcd>().get(hesMIPToGeV);
     eventSetup->get<ESIntercalibConstantsRcd>().get(hesMIPs);
  
     esgain = hesgain.product();
     esmips = hesMIPs.product();
     esMipToGeV = hesMIPToGeV.product();
     if (1.1 > esgain->getESGain())
       ESgain = 1;
     else
       ESgain = 2;
     if (ESgain == 1)
       ESMIPToGeV = esMipToGeV->getESValueLow();
     else
       ESMIPToGeV = esMipToGeV->getESValueHigh();
   }

Referenced by PreMixingEcalWorker::addPileups().

◆ initializeEvent() [2/2]

template<class ECALDIGITIZERTRAITS>

void EcalSignalGenerator< ECALDIGITIZERTRAITS >::initializeEvent	(	const edm::EventPrincipal *	eventPrincipal,
		const edm::EventSetup *	eventSetup
	)

inline

some users use EventPrincipals, not Events. We support both

Definition at line 149 of file EcalSignalGenerator.h.

                                                                                                  {
     theEventPrincipal = eventPrincipal;
     eventSetup->get<EcalGainRatiosRcd>().get(grHandle);  // find the gains
     // Ecal Intercalibration Constants
     eventSetup->get<EcalIntercalibConstantsMCRcd>().get(pIcal);
     ical = pIcal.product();
     // adc to GeV
     eventSetup->get<EcalADCToGeVConstantRcd>().get(pAgc);
     agc = pAgc.product();
     m_maxEneEB = (agc->getEBValue()) * theDefaultGains[1] * MAXADC * m_EBs25notCont;
     m_maxEneEE = (agc->getEEValue()) * theDefaultGains[1] * MAXADC * m_EEs25notCont;
  
     if (m_timeDependent) {
       //----
       // Ecal LaserCorrection Constants for laser correction ratio
       edm::ESHandle<EcalLaserDbService> laser;
       eventSetup->get<EcalLaserDbRecord>().get(laser);
       edm::TimeValue_t eventTimeValue = 0;
       if (theEventPrincipal) {
         //
         eventTimeValue = theEventPrincipal->runPrincipal().beginTime().value();
         //
         //         The "time" will have to match in the generation of the tag
         //         for the MC from ECAL (apd/pn, alpha, whatever time dependent is needed)
         //
       } else {
         edm::LogError("EcalSignalGenerator") << " theEventPrincipal not defined??? " << std::endl;
       }
       m_iTime = eventTimeValue;
       m_lasercals = laser.product();
  
       edm::ESHandle<EcalLaserDbService> laser_prime;
       eventSetup->get<EcalLaserDbRecordMC>().get(laser_prime);
       m_lasercals_prime = laser_prime.product();
  
       //clear the laser cache for each event time
       CalibCache().swap(m_valueLCCache_LC);
       CalibCache().swap(m_valueLCCache_LC_prime);  //--- also the "prime" ... yes
       //----
     }
  
     //ES
     eventSetup->get<ESGainRcd>().get(hesgain);
     eventSetup->get<ESMIPToGeVConstantRcd>().get(hesMIPToGeV);
     eventSetup->get<ESIntercalibConstantsRcd>().get(hesMIPs);
  
     esgain = hesgain.product();
     esmips = hesMIPs.product();
     esMipToGeV = hesMIPToGeV.product();
     if (1.1 > esgain->getESGain())
       ESgain = 1;
     else
       ESgain = 2;
     if (ESgain == 1)
       ESMIPToGeV = esMipToGeV->getESValueLow();
     else
       ESMIPToGeV = esMipToGeV->getESValueHigh();
   }

◆ peToAConversion()

template<class ECALDIGITIZERTRAITS>

double EcalSignalGenerator< ECALDIGITIZERTRAITS >::peToAConversion ( const DetId & detId ) const

inlineprivate

Definition at line 293 of file EcalSignalGenerator.h.

                                                    {
     return detId.subdetId() == EcalBarrel ? m_peToABarrel : m_peToAEndcap;
   }

◆ samplesInPE()

template<class ECALDIGITIZERTRAITS>

CaloSamples EcalSignalGenerator< ECALDIGITIZERTRAITS >::samplesInPE ( const DIGI & digi )

private

Referenced by EcalSignalGenerator< EEDigitizerTraits >::fill().

◆ validDigi()

template<class ECALDIGITIZERTRAITS>

bool EcalSignalGenerator< ECALDIGITIZERTRAITS >::validDigi ( const DIGI & digi )

inlineprivate

Definition at line 242 of file EcalSignalGenerator.h.

                                    {
     int DigiSum = 0;
     for (int id = 0; id < digi.size(); id++) {
       if (digi[id].adc() > 0)
         ++DigiSum;
     }
     return (DigiSum > 0);
   }