#include <HcalSignalGenerator.h>

Inheritance diagram for HcalSignalGenerator< Traits >:

Public Types
typedef Traits::DigiCollection	COLLECTION

typedef Traits::Digi	DIGI

Public Member Functions
virtual void	fill (edm::ModuleCallingContext const *mcc)

	HcalSignalGenerator ()

	HcalSignalGenerator (const edm::InputTag &inputTag, const edm::EDGetTokenT< COLLECTION > &t)

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

	~HcalSignalGenerator () override

Public Member Functions inherited from HcalBaseSignalGenerator
	HcalBaseSignalGenerator ()

void	setElectronicsSim (HcalElectronicsSim *electronicsSim)

void	setParameterMap (HcalSimParameterMap *map)

	~HcalBaseSignalGenerator () 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 Member Functions
virtual void	fillDigis (const COLLECTION *digis)

void	fillNoiseSignals () override

void	fillNoiseSignals (CLHEP::HepRandomEngine *) override

CaloSamples	samplesInPE (const DIGI &digi)

bool	validDigi (const DIGI &digi)

Private Attributes
edm::ESHandle< HcalDbService >	theConditions

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 Member Functions inherited from HcalBaseSignalGenerator
void	fC2pe (CaloSamples &samples) const

Protected Attributes inherited from HcalBaseSignalGenerator
HcalElectronicsSim *	theElectronicsSim

HcalSimParameterMap *	theParameterMap

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

Detailed Description

template<class Traits>
class HcalSignalGenerator< Traits >

Definition at line 31 of file HcalSignalGenerator.h.

Member Typedef Documentation

◆ COLLECTION

template<class Traits>

typedef Traits::DigiCollection HcalSignalGenerator< Traits >::COLLECTION

Definition at line 34 of file HcalSignalGenerator.h.

◆ DIGI

template<class Traits>

typedef Traits::Digi HcalSignalGenerator< Traits >::DIGI

Definition at line 33 of file HcalSignalGenerator.h.

Constructor & Destructor Documentation

◆ HcalSignalGenerator() [1/2]

template<class Traits>

HcalSignalGenerator< Traits >::HcalSignalGenerator ( )

inline

Definition at line 36 of file HcalSignalGenerator.h.

36 : HcalBaseSignalGenerator() {}

◆ HcalSignalGenerator() [2/2]

template<class Traits>

HcalSignalGenerator< Traits >::HcalSignalGenerator	(	const edm::InputTag &	inputTag,
		const edm::EDGetTokenT< COLLECTION > &	t
	)

inline

Definition at line 38 of file HcalSignalGenerator.h.

39 : HcalBaseSignalGenerator(), theEvent(nullptr), theEventPrincipal(nullptr), theInputTag(inputTag), tok_(t) {}

◆ ~HcalSignalGenerator()

template<class Traits>

HcalSignalGenerator< Traits >::~HcalSignalGenerator ( )

inlineoverride

Definition at line 41 of file HcalSignalGenerator.h.

41 {}

Member Function Documentation

◆ fill()

template<class Traits>

virtual void HcalSignalGenerator< Traits >::fill ( edm::ModuleCallingContext const * mcc )

inlinevirtual

Definition at line 56 of file HcalSignalGenerator.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
         LogTrace("HcalSignalGenerator") << "total # digis  for " << theInputTag << " " << digis->size();
       } else {
         throw cms::Exception("HcalSignalGenerator") << "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("HcalSignalGenerator") << "No Event or EventPrincipal was set";
     }
  
     if (digis)
       fillDigis(digis);
   }

Referenced by edm::DataMixingHcalDigiWorkerProd::addHcalPileups(), and PreMixingHcalWorker::addPileups().

◆ fillDigis()

template<class Traits>

virtual void HcalSignalGenerator< Traits >::fillDigis ( const COLLECTION * digis )

inlineprivatevirtual

Definition at line 83 of file HcalSignalGenerator.h.

                                                   {
     // loop over digis, adding these to the existing maps
     for (typename COLLECTION::const_iterator it = digis->begin(); it != digis->end(); ++it) {
       // for the first signal, set the starting cap id
       if ((it == digis->begin()) && theElectronicsSim) {
         int startingCapId = (*it)[0].capid();
         theElectronicsSim->setStartingCapId(startingCapId);
         // theParameterMap->setFrameSize(it->id(), it->size()); //don't need this
       }
       if (validDigi(*it)) {
         theNoiseSignals.push_back(samplesInPE(*it));
       }
     }
   }

Referenced by HcalSignalGenerator< HBHEDigitizerTraits >::fill().

◆ fillNoiseSignals() [1/2]

template<class Traits>

void HcalSignalGenerator< Traits >::fillNoiseSignals ( )

inlineoverrideprivatevirtual

Implements CaloVNoiseSignalGenerator.

Definition at line 99 of file HcalSignalGenerator.h.

99 {}

◆ fillNoiseSignals() [2/2]

template<class Traits>

void HcalSignalGenerator< Traits >::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 98 of file HcalSignalGenerator.h.

98 {}

◆ initializeEvent() [1/2]

template<class Traits>

void HcalSignalGenerator< Traits >::initializeEvent	(	const edm::Event *	event,
		const edm::EventSetup *	eventSetup
	)

inline

Definition at line 43 of file HcalSignalGenerator.h.

                                                                                {
     theEvent = event;
     eventSetup->get<HcalDbRecord>().get(theConditions);
     theParameterMap->setDbService(theConditions.product());
   }

Referenced by edm::DataMixingHcalDigiWorkerProd::addHcalPileups(), and PreMixingHcalWorker::addPileups().

◆ initializeEvent() [2/2]

template<class Traits>

void HcalSignalGenerator< Traits >::initializeEvent	(	const edm::EventPrincipal *	eventPrincipal,
		const edm::EventSetup *	eventSetup
	)

inline

some users use EventPrincipals, not Events. We support both

Definition at line 50 of file HcalSignalGenerator.h.

                                                                                                  {
     theEventPrincipal = eventPrincipal;
     eventSetup->get<HcalDbRecord>().get(theConditions);
     theParameterMap->setDbService(theConditions.product());
   }

◆ samplesInPE()

template<class Traits>

CaloSamples HcalSignalGenerator< Traits >::samplesInPE ( const DIGI & digi )

inlineprivate

Definition at line 110 of file HcalSignalGenerator.h.

                                             {
     // For PreMixing, (Note that modifications will need to be made for DataMixing) the
     // energy for each channel is kept as fC*10, but stored as an integer in ADC.  If this
     // results in an overflow, the "standard" ADC conversion is used and that channel is marked
     // with an error that allows the "standard" decoding to convert ADC back to fC.  So, most
     // channels get to fC by just dividing ADC/10; some require special treatment.
  
     // calibration, for future reference:  (same block for all Hcal types)
     HcalDetId cell = digi.id();
     CaloSamples result = CaloSamples(cell, digi.size());
  
     // first, check if there was an overflow in this fake digi:
     bool overflow = false;
     // find and list them
  
     for (int isample = 0; isample < digi.size(); ++isample) {
       if (digi[isample].er())
         overflow = true;
     }
  
     if (overflow) {  // do full conversion, go back and overwrite fake entries
  
       const HcalQIECoder* channelCoder = theConditions->getHcalCoder(cell);
       const HcalQIEShape* channelShape = theConditions->getHcalShape(cell);
       HcalCoderDb coder(*channelCoder, *channelShape);
       coder.adc2fC(digi, result);
  
       // overwrite with coded information
       for (int isample = 0; isample < digi.size(); ++isample) {
         if (!digi[isample].er())
           result[isample] = float(digi[isample].adc()) / Traits::PreMixFactor;
       }
     } else {  // saves creating the coder, etc., every time
       // use coded information
       for (int isample = 0; isample < digi.size(); ++isample) {
         result[isample] = float(digi[isample].adc()) / Traits::PreMixFactor;
       }
       result.setPresamples(digi.presamples());
     }
  
     // translation done in fC, convert to pe:
     fC2pe(result);
  
     return result;
   }

Referenced by HcalSignalGenerator< HBHEDigitizerTraits >::fillDigis().

◆ validDigi()

template<class Traits>

bool HcalSignalGenerator< Traits >::validDigi ( const DIGI & digi )

inlineprivate

Definition at line 101 of file HcalSignalGenerator.h.

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