#include <EcalDigiProducer.h>

Inheritance diagram for EcalDigiProducer:

Public Member Functions
void	accumulate (edm::Event const &e, edm::EventSetup const &c) override

void	accumulate (PileUpEventPrincipal const &e, edm::EventSetup const &c, edm::StreamID const &) override

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) override

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) override

	EcalDigiProducer (const edm::ParameterSet &params, edm::ProducerBase &mixMod, edm::ConsumesCollector &iC)

	EcalDigiProducer (const edm::ParameterSet &params, edm::ConsumesCollector &iC)

void	finalizeEvent (edm::Event &e, edm::EventSetup const &c) override

void	initializeEvent (edm::Event const &e, edm::EventSetup const &c) override

void	setEBNoiseSignalGenerator (EcalBaseSignalGenerator *noiseGenerator)

void	setEENoiseSignalGenerator (EcalBaseSignalGenerator *noiseGenerator)

void	setESNoiseSignalGenerator (EcalBaseSignalGenerator *noiseGenerator)

	~EcalDigiProducer () override

Public Member Functions inherited from DigiAccumulatorMixMod
	DigiAccumulatorMixMod ()

virtual void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup)

virtual void	endRun (edm::Run const &run, edm::EventSetup const &setup)

virtual void	finalizeBunchCrossing (edm::Event &event, edm::EventSetup const &setup, int bunchCrossing)

virtual PileupMixingContent *	getEventPileupInfo ()

virtual void	initializeBunchCrossing (edm::Event const &event, edm::EventSetup const &setup, int bunchCrossing)

virtual void	StorePileupInformation (std::vector< int > &numInteractionList, std::vector< int > &bunchCrossingList, std::vector< float > &TrueInteractionList, std::vector< edm::EventID > &eventList, int bunchSpace)

virtual	~DigiAccumulatorMixMod ()

Protected Attributes
std::unique_ptr< EBHitResponse >	m_EBResponse

std::unique_ptr< EEHitResponse >	m_EEResponse

std::unique_ptr< const EcalSimParameterMap >	m_ParameterMap

Private Types
typedef edm::Handle< std::vector< PCaloHit > >	HitsHandle

Private Member Functions
void	accumulateCaloHits (HitsHandle const &ebHandle, HitsHandle const &eeHandle, HitsHandle const &esHandle, int bunchCrossing)

virtual void	cacheEBDigis (const EBDigiCollection *ebDigiPtr) const

virtual void	cacheEEDigis (const EEDigiCollection *eeDigiPtr) const

void	checkCalibrations (const edm::Event &event, const edm::EventSetup &eventSetup)

void	checkGeometry (const edm::EventSetup &eventSetup)

void	updateGeometry ()

Private Attributes
const bool	m_addESNoise

std::unique_ptr< EcalCoder >	m_APDCoder

const std::string	m_apdDigiTag

std::unique_ptr< EBDigitizer >	m_APDDigitizer

std::unique_ptr< EcalElectronicsSim >	m_APDElectronicsSim

std::unique_ptr< const APDSimParameters >	m_apdParameters

std::unique_ptr< EBHitResponse >	m_APDResponse

const bool	m_apdSeparateDigi

APDShape	m_APDShape

std::unique_ptr< EBDigitizer >	m_BarrelDigitizer

std::unique_ptr< EcalCoder >	m_Coder

const bool	m_doEB

const bool	m_doEE

const bool	m_doES

const bool	m_doFastES

std::array< std::unique_ptr< CorrelatedNoisifier< EcalCorrMatrix > >, 3 >	m_EBCorrNoise

const std::string	m_EBdigiCollection

const double	m_EBs25notCont

EBShape	m_EBShape

std::array< std::unique_ptr< CorrelatedNoisifier< EcalCorrMatrix > >, 3 >	m_EECorrNoise

const std::string	m_EEdigiCollection

const double	m_EEs25notCont

EEShape	m_EEShape

std::unique_ptr< EcalElectronicsSim >	m_ElectronicsSim

std::unique_ptr< EEDigitizer >	m_EndcapDigitizer

const std::string	m_ESdigiCollection

std::unique_ptr< ESDigitizer >	m_ESDigitizer

std::unique_ptr< ESElectronicsSim >	m_ESElectronicsSim

std::unique_ptr< ESElectronicsSimFast >	m_ESElectronicsSimFast

std::unique_ptr< ESOldDigitizer >	m_ESOldDigitizer

std::unique_ptr< CaloHitResponse >	m_ESOldResponse

std::unique_ptr< ESHitResponse >	m_ESResponse

ESShape	m_ESShape

const CaloGeometry *	m_Geometry

const std::string	m_hitsProducerTag

const bool	m_PreMix1

const bool	m_PreMix2

const unsigned int	m_readoutFrameSize

bool	m_useLCcorrection

CLHEP::HepRandomEngine *	randomEngine_ = 0

Detailed Description

Definition at line 58 of file EcalDigiProducer.h.

Member Typedef Documentation

typedef edm::Handle<std::vector<PCaloHit> > EcalDigiProducer::HitsHandle

private

Definition at line 79 of file EcalDigiProducer.h.

Constructor & Destructor Documentation

EcalDigiProducer::EcalDigiProducer	(	const edm::ParameterSet &	params,
		edm::ProducerBase &	mixMod,
		edm::ConsumesCollector &	iC
	)

Definition at line 56 of file EcalDigiProducer.cc.

References m_apdDigiTag, m_apdSeparateDigi, m_EBdigiCollection, m_EEdigiCollection, m_ESdigiCollection, and edm::ProductRegistryHelper::produces().

     : EcalDigiProducer(params, iC) {
   if (m_apdSeparateDigi)
     mixMod.produces<EBDigiCollection>(m_apdDigiTag);
 
   mixMod.produces<EBDigiCollection>(m_EBdigiCollection);
   mixMod.produces<EEDigiCollection>(m_EEdigiCollection);
   mixMod.produces<ESDigiCollection>(m_ESdigiCollection);
 }

EcalDigiProducer::EcalDigiProducer	(	const edm::ParameterSet &	params,
		edm::ConsumesCollector &	iC
	)

Definition at line 69 of file EcalDigiProducer.cc.

References ecalElectronicsSim_cff::applyConstantTerm, ecalCosmicsSim_cff::cosmicsPhase, ecalCosmicsSim_cff::cosmicsShift, MillePedeFileConverter_cfg::e, m_APDCoder, m_APDDigitizer, m_APDElectronicsSim, m_APDResponse, m_apdSeparateDigi, m_BarrelDigitizer, m_Coder, m_doEB, m_doEE, m_doES, m_EBCorrNoise, m_EBResponse, m_EECorrNoise, m_EEResponse, m_ElectronicsSim, m_EndcapDigitizer, m_hitsProducerTag, m_ParameterMap, m_PreMix1, and m_readoutFrameSize.

     : DigiAccumulatorMixMod(),
       m_APDShape(true),
       m_EBShape(true),
       m_EEShape(true),
       m_ESShape(),
       m_EBdigiCollection(params.getParameter<std::string>("EBdigiCollection")),
       m_EEdigiCollection(params.getParameter<std::string>("EEdigiCollection")),
       m_ESdigiCollection(params.getParameter<std::string>("ESdigiCollection")),
       m_hitsProducerTag(params.getParameter<std::string>("hitsProducer")),
       m_useLCcorrection(params.getUntrackedParameter<bool>("UseLCcorrection")),
       m_apdSeparateDigi(params.getParameter<bool>("apdSeparateDigi")),
 
       m_EBs25notCont(params.getParameter<double>("EBs25notContainment")),
       m_EEs25notCont(params.getParameter<double>("EEs25notContainment")),
 
       m_readoutFrameSize(params.getParameter<int>("readoutFrameSize")),
       m_ParameterMap(new EcalSimParameterMap(params.getParameter<double>("simHitToPhotoelectronsBarrel"),
                                              params.getParameter<double>("simHitToPhotoelectronsEndcap"),
                                              params.getParameter<double>("photoelectronsToAnalogBarrel"),
                                              params.getParameter<double>("photoelectronsToAnalogEndcap"),
                                              params.getParameter<double>("samplingFactor"),
                                              params.getParameter<double>("timePhase"),
                                              m_readoutFrameSize,
                                              params.getParameter<int>("binOfMaximum"),
                                              params.getParameter<bool>("doPhotostatistics"),
                                              params.getParameter<bool>("syncPhase"))),
 
       m_apdDigiTag(params.getParameter<std::string>("apdDigiTag")),
       m_apdParameters(new APDSimParameters(params.getParameter<bool>("apdAddToBarrel"),
                                            m_apdSeparateDigi,
                                            params.getParameter<double>("apdSimToPELow"),
                                            params.getParameter<double>("apdSimToPEHigh"),
                                            params.getParameter<double>("apdTimeOffset"),
                                            params.getParameter<double>("apdTimeOffWidth"),
                                            params.getParameter<bool>("apdDoPEStats"),
                                            m_apdDigiTag,
                                            params.getParameter<std::vector<double>>("apdNonlParms"))),
 
       m_APDResponse(
           !m_apdSeparateDigi
               ? nullptr
               : new EBHitResponse(m_ParameterMap.get(), &m_EBShape, true, m_apdParameters.get(), &m_APDShape)),
 
       m_EBResponse(new EBHitResponse(m_ParameterMap.get(),
                                      &m_EBShape,
                                      false,  // barrel
                                      m_apdParameters.get(),
                                      &m_APDShape)),
 
       m_EEResponse(new EEHitResponse(m_ParameterMap.get(), &m_EEShape)),
       m_ESResponse(new ESHitResponse(m_ParameterMap.get(), &m_ESShape)),
       m_ESOldResponse(new CaloHitResponse(m_ParameterMap.get(), &m_ESShape)),
 
       m_addESNoise(params.getParameter<bool>("doESNoise")),
       m_PreMix1(params.getParameter<bool>("EcalPreMixStage1")),
       m_PreMix2(params.getParameter<bool>("EcalPreMixStage2")),
 
       m_doFastES(params.getParameter<bool>("doFast")),
 
       m_doEB(params.getParameter<bool>("doEB")),
       m_doEE(params.getParameter<bool>("doEE")),
       m_doES(params.getParameter<bool>("doES")),
 
       m_ESElectronicsSim(m_doFastES ? nullptr : new ESElectronicsSim(m_addESNoise)),
 
       m_ESOldDigitizer(m_doFastES ? nullptr
                                   : new ESOldDigitizer(m_ESOldResponse.get(), m_ESElectronicsSim.get(), m_addESNoise)),
 
       m_ESElectronicsSimFast(!m_doFastES ? nullptr : new ESElectronicsSimFast(m_addESNoise, m_PreMix1)),
 
       m_ESDigitizer(!m_doFastES ? nullptr
                                 : new ESDigitizer(m_ESResponse.get(), m_ESElectronicsSimFast.get(), m_addESNoise)),
 
       m_APDDigitizer(nullptr),
       m_BarrelDigitizer(nullptr),
       m_EndcapDigitizer(nullptr),
       m_ElectronicsSim(nullptr),
       m_Coder(nullptr),
       m_APDElectronicsSim(nullptr),
       m_APDCoder(nullptr),
       m_Geometry(nullptr),
       m_EBCorrNoise({{nullptr, nullptr, nullptr}}),
       m_EECorrNoise({{nullptr, nullptr, nullptr}}) {
   // "produces" statements taken care of elsewhere.
   //   if(m_apdSeparateDigi) mixMod.produces<EBDigiCollection>(m_apdDigiTag);
   // mixMod.produces<EBDigiCollection>(m_EBdigiCollection);
   // mixMod.produces<EEDigiCollection>(m_EEdigiCollection);
   // mixMod.produces<ESDigiCollection>(m_ESdigiCollection);
   if (m_doEB)
     iC.consumes<std::vector<PCaloHit>>(edm::InputTag(m_hitsProducerTag, "EcalHitsEB"));
   if (m_doEE)
     iC.consumes<std::vector<PCaloHit>>(edm::InputTag(m_hitsProducerTag, "EcalHitsEE"));
   if (m_doES)
     iC.consumes<std::vector<PCaloHit>>(edm::InputTag(m_hitsProducerTag, "EcalHitsES"));
 
   const std::vector<double> ebCorMatG12 = params.getParameter<std::vector<double>>("EBCorrNoiseMatrixG12");
   const std::vector<double> eeCorMatG12 = params.getParameter<std::vector<double>>("EECorrNoiseMatrixG12");
   const std::vector<double> ebCorMatG06 = params.getParameter<std::vector<double>>("EBCorrNoiseMatrixG06");
   const std::vector<double> eeCorMatG06 = params.getParameter<std::vector<double>>("EECorrNoiseMatrixG06");
   const std::vector<double> ebCorMatG01 = params.getParameter<std::vector<double>>("EBCorrNoiseMatrixG01");
   const std::vector<double> eeCorMatG01 = params.getParameter<std::vector<double>>("EECorrNoiseMatrixG01");
 
   const bool applyConstantTerm = params.getParameter<bool>("applyConstantTerm");
   const double rmsConstantTerm = params.getParameter<double>("ConstantTerm");
 
   const bool addNoise = params.getParameter<bool>("doENoise");
   const bool cosmicsPhase = params.getParameter<bool>("cosmicsPhase");
   const double cosmicsShift = params.getParameter<double>("cosmicsShift");
 
   //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
   // further phase for cosmics studies
   if (cosmicsPhase) {
     if (m_doEB)
       m_EBResponse->setPhaseShift(1. + cosmicsShift);
     if (m_doEE)
       m_EEResponse->setPhaseShift(1. + cosmicsShift);
   }
 
   EcalCorrMatrix ebMatrix[3];
   EcalCorrMatrix eeMatrix[3];
 
   assert(ebCorMatG12.size() == m_readoutFrameSize);
   assert(eeCorMatG12.size() == m_readoutFrameSize);
   assert(ebCorMatG06.size() == m_readoutFrameSize);
   assert(eeCorMatG06.size() == m_readoutFrameSize);
   assert(ebCorMatG01.size() == m_readoutFrameSize);
   assert(eeCorMatG01.size() == m_readoutFrameSize);
 
   assert(1.e-7 > fabs(ebCorMatG12[0] - 1.0));
   assert(1.e-7 > fabs(ebCorMatG06[0] - 1.0));
   assert(1.e-7 > fabs(ebCorMatG01[0] - 1.0));
   assert(1.e-7 > fabs(eeCorMatG12[0] - 1.0));
   assert(1.e-7 > fabs(eeCorMatG06[0] - 1.0));
   assert(1.e-7 > fabs(eeCorMatG01[0] - 1.0));
 
   for (unsigned int row(0); row != m_readoutFrameSize; ++row) {
     assert(0 == row || 1. >= ebCorMatG12[row]);
     assert(0 == row || 1. >= ebCorMatG06[row]);
     assert(0 == row || 1. >= ebCorMatG01[row]);
     assert(0 == row || 1. >= eeCorMatG12[row]);
     assert(0 == row || 1. >= eeCorMatG06[row]);
     assert(0 == row || 1. >= eeCorMatG01[row]);
     for (unsigned int column(0); column <= row; ++column) {
       const unsigned int index(row - column);
       ebMatrix[0](row, column) = ebCorMatG12[index];
       eeMatrix[0](row, column) = eeCorMatG12[index];
       ebMatrix[1](row, column) = ebCorMatG06[index];
       eeMatrix[1](row, column) = eeCorMatG06[index];
       ebMatrix[2](row, column) = ebCorMatG01[index];
       eeMatrix[2](row, column) = eeCorMatG01[index];
     }
   }
 
   m_EBCorrNoise[0].reset(new CorrelatedNoisifier<EcalCorrMatrix>(ebMatrix[0]));
   m_EECorrNoise[0].reset(new CorrelatedNoisifier<EcalCorrMatrix>(eeMatrix[0]));
   m_EBCorrNoise[1].reset(new CorrelatedNoisifier<EcalCorrMatrix>(ebMatrix[1]));
   m_EECorrNoise[1].reset(new CorrelatedNoisifier<EcalCorrMatrix>(eeMatrix[1]));
   m_EBCorrNoise[2].reset(new CorrelatedNoisifier<EcalCorrMatrix>(ebMatrix[2]));
   m_EECorrNoise[2].reset(new CorrelatedNoisifier<EcalCorrMatrix>(eeMatrix[2]));
 
   m_Coder.reset(new EcalCoder(addNoise,
                               m_PreMix1,
                               m_EBCorrNoise[0].get(),
                               m_EECorrNoise[0].get(),
                               m_EBCorrNoise[1].get(),
                               m_EECorrNoise[1].get(),
                               m_EBCorrNoise[2].get(),
                               m_EECorrNoise[2].get()));
 
   m_ElectronicsSim.reset(
       new EcalElectronicsSim(m_ParameterMap.get(), m_Coder.get(), applyConstantTerm, rmsConstantTerm));
 
   if (m_apdSeparateDigi) {
     m_APDCoder.reset(new EcalCoder(false,
                                    m_PreMix1,
                                    m_EBCorrNoise[0].get(),
                                    m_EECorrNoise[0].get(),
                                    m_EBCorrNoise[1].get(),
                                    m_EECorrNoise[1].get(),
                                    m_EBCorrNoise[2].get(),
                                    m_EECorrNoise[2].get()));
 
     m_APDElectronicsSim.reset(
         new EcalElectronicsSim(m_ParameterMap.get(), m_APDCoder.get(), applyConstantTerm, rmsConstantTerm));
 
     m_APDDigitizer.reset(new EBDigitizer(m_APDResponse.get(), m_APDElectronicsSim.get(), false));
   }
 
   if (m_doEB) {
     m_BarrelDigitizer.reset(new EBDigitizer(m_EBResponse.get(), m_ElectronicsSim.get(), addNoise));
   }
 
   if (m_doEE) {
     m_EndcapDigitizer.reset(new EEDigitizer(m_EEResponse.get(), m_ElectronicsSim.get(), addNoise));
   }
 }

EcalDigiProducer::~EcalDigiProducer ( )

override

Definition at line 268 of file EcalDigiProducer.cc.

268 {}

Member Function Documentation

void EcalDigiProducer::accumulate	(	edm::Event const &	e,
		edm::EventSetup const &	c
	)

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 319 of file EcalDigiProducer.cc.

References accumulateCaloHits(), edm::Event::getByLabel(), m_APDShape, m_doEB, m_doEE, m_doES, m_EBShape, m_EEShape, m_hitsProducerTag, and EcalShapeBase::setEventSetup().

Referenced by PreMixingEcalWorker::addSignals().

                                                                                     {
   // Step A: Get Inputs
   edm::Handle<std::vector<PCaloHit>> ebHandle;
   if (m_doEB) {
     m_EBShape.setEventSetup(eventSetup);   // need to set the eventSetup here, otherwise pre-mixing
                                            // module will not wrk
     m_APDShape.setEventSetup(eventSetup);  //
     edm::InputTag ebTag(m_hitsProducerTag, "EcalHitsEB");
     e.getByLabel(ebTag, ebHandle);
   }
 
   edm::Handle<std::vector<PCaloHit>> eeHandle;
   if (m_doEE) {
     m_EEShape.setEventSetup(eventSetup);  // need to set the eventSetup here, otherwise pre-mixing
                                           // module will not work
     edm::InputTag eeTag(m_hitsProducerTag, "EcalHitsEE");
     e.getByLabel(eeTag, eeHandle);
   }
 
   edm::Handle<std::vector<PCaloHit>> esHandle;
   if (m_doES) {
     edm::InputTag esTag(m_hitsProducerTag, "EcalHitsES");
     e.getByLabel(esTag, esHandle);
   }
 
   accumulateCaloHits(ebHandle, eeHandle, esHandle, 0);
 }

void EcalDigiProducer::accumulate	(	PileUpEventPrincipal const &	e,
		edm::EventSetup const &	c,
		edm::StreamID const &	streamID
	)

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 347 of file EcalDigiProducer.cc.

References accumulateCaloHits(), PileUpEventPrincipal::bunchCrossing(), PileUpEventPrincipal::getByLabel(), m_doEB, m_doEE, m_doES, and m_hitsProducerTag.

                                                                {
   // Step A: Get Inputs
   edm::Handle<std::vector<PCaloHit>> ebHandle;
   if (m_doEB) {
     edm::InputTag ebTag(m_hitsProducerTag, "EcalHitsEB");
     e.getByLabel(ebTag, ebHandle);
   }
 
   edm::Handle<std::vector<PCaloHit>> eeHandle;
   if (m_doEE) {
     edm::InputTag eeTag(m_hitsProducerTag, "EcalHitsEE");
     e.getByLabel(eeTag, eeHandle);
   }
 
   edm::Handle<std::vector<PCaloHit>> esHandle;
   if (m_doES) {
     edm::InputTag esTag(m_hitsProducerTag, "EcalHitsES");
     e.getByLabel(esTag, esHandle);
   }
 
   accumulateCaloHits(ebHandle, eeHandle, esHandle, e.bunchCrossing());
 }

void EcalDigiProducer::accumulateCaloHits	(	HitsHandle const &	ebHandle,
		HitsHandle const &	eeHandle,
		HitsHandle const &	esHandle,
		int	bunchCrossing
	)

private

Definition at line 294 of file EcalDigiProducer.cc.

References edm::HandleBase::isValid(), m_APDDigitizer, m_apdSeparateDigi, m_BarrelDigitizer, m_doEB, m_doEE, m_doES, m_doFastES, m_EndcapDigitizer, m_ESDigitizer, m_ESOldDigitizer, edm::Handle< T >::product(), and randomEngine_.

Referenced by accumulate().

                                                              {
   if (m_doEB && ebHandle.isValid()) {
     m_BarrelDigitizer->add(*ebHandle.product(), bunchCrossing, randomEngine_);
 
     if (m_apdSeparateDigi) {
       m_APDDigitizer->add(*ebHandle.product(), bunchCrossing, randomEngine_);
     }
   }
 
   if (m_doEE && eeHandle.isValid()) {
     m_EndcapDigitizer->add(*eeHandle.product(), bunchCrossing, randomEngine_);
   }
 
   if (m_doES && esHandle.isValid()) {
     if (m_doFastES) {
       m_ESDigitizer->add(*esHandle.product(), bunchCrossing, randomEngine_);
     } else {
       m_ESOldDigitizer->add(*esHandle.product(), bunchCrossing, randomEngine_);
     }
   }
 }

void EcalDigiProducer::beginLuminosityBlock	(	edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &	setup
	)

overridevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 419 of file EcalDigiProducer.cc.

References Exception, edm::RandomNumberGenerator::getEngine(), edm::LuminosityBlock::index(), edm::Service< T >::isAvailable(), m_APDResponse, m_doEB, and m_EBResponse.

Referenced by PreMixingEcalWorker::beginLuminosityBlock().

                                                                                                       {
   edm::Service<edm::RandomNumberGenerator> rng;
   if (!rng.isAvailable()) {
     throw cms::Exception("Configuration") << "RandomNumberGenerator service is not available.\n"
                                              "You must add the service in the configuration file\n"
                                              "or remove the module that requires it.";
   }
   CLHEP::HepRandomEngine *engine = &rng->getEngine(lumi.index());
 
   if (m_doEB) {
     if (nullptr != m_APDResponse)
       m_APDResponse->initialize(engine);
     m_EBResponse->initialize(engine);
   }
 }

void EcalDigiProducer::beginRun	(	edm::Run const &	run,
		edm::EventSetup const &	setup
	)

overridevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 611 of file EcalDigiProducer.cc.

References m_APDShape, m_EBShape, m_EEShape, and EcalShapeBase::setEventSetup().

                                                                              {
   m_EBShape.setEventSetup(setup);
   m_EEShape.setEventSetup(setup);
   m_APDShape.setEventSetup(setup);
 }

virtual void EcalDigiProducer::cacheEBDigis ( const EBDigiCollection * ebDigiPtr ) const

inlineprivatevirtual

Reimplemented in EcalTBDigiProducer.

Definition at line 76 of file EcalDigiProducer.h.

Referenced by finalizeEvent().

76 {}

virtual void EcalDigiProducer::cacheEEDigis ( const EEDigiCollection * eeDigiPtr ) const

inlineprivatevirtual

Reimplemented in EcalTBDigiProducer.

Definition at line 77 of file EcalDigiProducer.h.

Referenced by finalizeEvent().

77 {}

void EcalDigiProducer::checkCalibrations	(	const edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

private

Definition at line 435 of file EcalDigiProducer.cc.

References EcalMGPAGainRatio::gain12Over6(), EcalMGPAGainRatio::gain6Over1(), edm::EventSetup::get(), EcalADCToGeVConstant::getEBValue(), EcalADCToGeVConstant::getEEValue(), LogDebug, m_APDCoder, m_APDResponse, m_Coder, m_doES, m_doFastES, m_EBResponse, m_EBs25notCont, m_EEResponse, m_EEs25notCont, m_ESDigitizer, m_ESElectronicsSim, m_ESElectronicsSimFast, m_ESOldDigitizer, m_ESShape, m_useLCcorrection, edm::ESHandle< T >::product(), and ESShape::setGain().

Referenced by initializeEvent().

                                                                                                {
   // Pedestals from event setup
 
   edm::ESHandle<EcalPedestals> dbPed;
   eventSetup.get<EcalPedestalsRcd>().get(dbPed);
   const EcalPedestals *pedestals(dbPed.product());
 
   m_Coder->setPedestals(pedestals);
   if (nullptr != m_APDCoder)
     m_APDCoder->setPedestals(pedestals);
 
   // Ecal Intercalibration Constants
   edm::ESHandle<EcalIntercalibConstantsMC> pIcal;
   eventSetup.get<EcalIntercalibConstantsMCRcd>().get(pIcal);
   const EcalIntercalibConstantsMC *ical(pIcal.product());
 
   m_Coder->setIntercalibConstants(ical);
   if (nullptr != m_APDCoder)
     m_APDCoder->setIntercalibConstants(ical);
 
   m_EBResponse->setIntercal(ical);
   if (nullptr != m_APDResponse)
     m_APDResponse->setIntercal(ical);
 
   // Ecal LaserCorrection Constants
   edm::ESHandle<EcalLaserDbService> laser;
   eventSetup.get<EcalLaserDbRecord>().get(laser);
   const edm::TimeValue_t eventTimeValue = event.time().value();
 
   m_EBResponse->setEventTime(eventTimeValue);
   m_EBResponse->setLaserConstants(laser.product(), m_useLCcorrection);
 
   m_EEResponse->setEventTime(eventTimeValue);
   m_EEResponse->setLaserConstants(laser.product(), m_useLCcorrection);
 
   // ADC -> GeV Scale
   edm::ESHandle<EcalADCToGeVConstant> pAgc;
   eventSetup.get<EcalADCToGeVConstantRcd>().get(pAgc);
   const EcalADCToGeVConstant *agc = pAgc.product();
 
   // Gain Ratios
   edm::ESHandle<EcalGainRatios> pRatio;
   eventSetup.get<EcalGainRatiosRcd>().get(pRatio);
   const EcalGainRatios *gr = pRatio.product();
 
   m_Coder->setGainRatios(gr);
   if (nullptr != m_APDCoder)
     m_APDCoder->setGainRatios(gr);
 
   EcalMGPAGainRatio *defaultRatios = new EcalMGPAGainRatio();
 
   double theGains[m_Coder->NGAINS + 1];
   theGains[0] = 0.;
   theGains[3] = 1.;
   theGains[2] = defaultRatios->gain6Over1();
   theGains[1] = theGains[2] * (defaultRatios->gain12Over6());
 
   LogDebug("EcalDigi") << " Gains: "
                        << "\n"
                        << " g1 = " << theGains[1] << "\n"
                        << " g2 = " << theGains[2] << "\n"
                        << " g3 = " << theGains[3];
 
   delete defaultRatios;
 
   const double EBscale((agc->getEBValue()) * theGains[1] * (m_Coder->MAXADC) * m_EBs25notCont);
 
   LogDebug("EcalDigi") << " GeV/ADC = " << agc->getEBValue() << "\n"
                        << " notCont = " << m_EBs25notCont << "\n"
                        << " saturation for EB = " << EBscale << ", " << m_EBs25notCont;
 
   const double EEscale((agc->getEEValue()) * theGains[1] * (m_Coder->MAXADC) * m_EEs25notCont);
 
   LogDebug("EcalDigi") << " GeV/ADC = " << agc->getEEValue() << "\n"
                        << " notCont = " << m_EEs25notCont << "\n"
                        << " saturation for EB = " << EEscale << ", " << m_EEs25notCont;
 
   m_Coder->setFullScaleEnergy(EBscale, EEscale);
   if (nullptr != m_APDCoder)
     m_APDCoder->setFullScaleEnergy(EBscale, EEscale);
 
   if (nullptr != m_ESOldDigitizer || nullptr != m_ESDigitizer) {
     // ES condition objects
     edm::ESHandle<ESGain> hesgain;
     edm::ESHandle<ESMIPToGeVConstant> hesMIPToGeV;
     edm::ESHandle<ESPedestals> hesPedestals;
     edm::ESHandle<ESIntercalibConstants> hesMIPs;
 
     eventSetup.get<ESGainRcd>().get(hesgain);
     eventSetup.get<ESMIPToGeVConstantRcd>().get(hesMIPToGeV);
     eventSetup.get<ESPedestalsRcd>().get(hesPedestals);
     eventSetup.get<ESIntercalibConstantsRcd>().get(hesMIPs);
 
     const ESGain *esgain(hesgain.product());
     const ESPedestals *espeds(hesPedestals.product());
     const ESIntercalibConstants *esmips(hesMIPs.product());
     const ESMIPToGeVConstant *esMipToGeV(hesMIPToGeV.product());
     const int ESGain(1.1 > esgain->getESGain() ? 1 : 2);
     const double ESMIPToGeV((1 == ESGain) ? esMipToGeV->getESValueLow() : esMipToGeV->getESValueHigh());
 
     if (m_doES) {
       m_ESShape.setGain(ESGain);
       if (!m_doFastES) {
         m_ESElectronicsSim->setGain(ESGain);
         m_ESElectronicsSim->setPedestals(espeds);
         m_ESElectronicsSim->setMIPs(esmips);
         m_ESElectronicsSim->setMIPToGeV(ESMIPToGeV);
       } else {
         m_ESDigitizer->setGain(ESGain);
         m_ESElectronicsSimFast->setPedestals(espeds);
         m_ESElectronicsSimFast->setMIPs(esmips);
         m_ESElectronicsSimFast->setMIPToGeV(ESMIPToGeV);
       }
     }
   }
 }

void EcalDigiProducer::checkGeometry ( const edm::EventSetup & eventSetup )

private

Definition at line 552 of file EcalDigiProducer.cc.

References edm::EventSetup::get(), m_Geometry, and updateGeometry().

Referenced by initializeEvent().

                                                                     {
   // TODO find a way to avoid doing this every event
   edm::ESHandle<CaloGeometry> hGeometry;
   eventSetup.get<CaloGeometryRecord>().get(hGeometry);
 
   const CaloGeometry *pGeometry = &*hGeometry;
 
   if (pGeometry != m_Geometry) {
     m_Geometry = pGeometry;
     updateGeometry();
   }
 }

void EcalDigiProducer::finalizeEvent	(	edm::Event &	e,
		edm::EventSetup const &	c
	)

overridevirtual

Implements DigiAccumulatorMixMod.

Reimplemented in EcalTBDigiProducer.

Definition at line 372 of file EcalDigiProducer.cc.

References cacheEBDigis(), cacheEEDigis(), m_APDDigitizer, m_apdSeparateDigi, m_BarrelDigitizer, m_doEB, m_doEE, m_doES, m_doFastES, m_EBdigiCollection, m_EEdigiCollection, m_EndcapDigitizer, m_ESdigiCollection, m_ESDigitizer, m_ESOldDigitizer, eostools::move(), and randomEngine_.

Referenced by EcalTBDigiProducer::finalizeEvent(), and PreMixingEcalWorker::put().

                                                                                      {
   // Step B: Create empty output
   std::unique_ptr<EBDigiCollection> apdResult(!m_apdSeparateDigi || !m_doEB ? nullptr : new EBDigiCollection());
   std::unique_ptr<EBDigiCollection> barrelResult(new EBDigiCollection());
   std::unique_ptr<EEDigiCollection> endcapResult(new EEDigiCollection());
   std::unique_ptr<ESDigiCollection> preshowerResult(new ESDigiCollection());
 
   // run the algorithm
 
   if (m_doEB) {
     m_BarrelDigitizer->run(*barrelResult, randomEngine_);
     cacheEBDigis(&*barrelResult);
 
     edm::LogInfo("DigiInfo") << "EB Digis: " << barrelResult->size();
 
     if (m_apdSeparateDigi) {
       m_APDDigitizer->run(*apdResult, randomEngine_);
       edm::LogInfo("DigiInfo") << "APD Digis: " << apdResult->size();
     }
   }
 
   if (m_doEE) {
     m_EndcapDigitizer->run(*endcapResult, randomEngine_);
     edm::LogInfo("EcalDigi") << "EE Digis: " << endcapResult->size();
     cacheEEDigis(&*endcapResult);
   }
   if (m_doES) {
     if (m_doFastES) {
       m_ESDigitizer->run(*preshowerResult, randomEngine_);
     } else {
       m_ESOldDigitizer->run(*preshowerResult, randomEngine_);
     }
     edm::LogInfo("EcalDigi") << "ES Digis: " << preshowerResult->size();
   }
 
   // Step D: Put outputs into event
   if (m_apdSeparateDigi) {
     // event.put(std::move(apdResult),    m_apdDigiTag         ) ;
   }
 
   event.put(std::move(barrelResult), m_EBdigiCollection);
   event.put(std::move(endcapResult), m_EEdigiCollection);
   event.put(std::move(preshowerResult), m_ESdigiCollection);
 
   randomEngine_ = nullptr;  // to prevent access outside event
 }

void EcalDigiProducer::initializeEvent	(	edm::Event const &	e,
		edm::EventSetup const &	c
	)

overridevirtual

Implements DigiAccumulatorMixMod.

Reimplemented in EcalTBDigiProducer.

Definition at line 270 of file EcalDigiProducer.cc.

References checkCalibrations(), checkGeometry(), edm::RandomNumberGenerator::getEngine(), m_APDDigitizer, m_apdSeparateDigi, m_BarrelDigitizer, m_doEB, m_doEE, m_doES, m_doFastES, m_EndcapDigitizer, m_ESDigitizer, m_ESOldDigitizer, randomEngine_, and edm::Event::streamID().

Referenced by EcalTBDigiProducer::initializeEvent(), and PreMixingEcalWorker::initializeEvent().

                                                                                              {
   edm::Service<edm::RandomNumberGenerator> rng;
   randomEngine_ = &rng->getEngine(event.streamID());
 
   checkGeometry(eventSetup);
   checkCalibrations(event, eventSetup);
   if (m_doEB) {
     m_BarrelDigitizer->initializeHits();
     if (m_apdSeparateDigi) {
       m_APDDigitizer->initializeHits();
     }
   }
   if (m_doEE) {
     m_EndcapDigitizer->initializeHits();
   }
   if (m_doES) {
     if (m_doFastES) {
       m_ESDigitizer->initializeHits();
     } else {
       m_ESOldDigitizer->initializeHits();
     }
   }
 }

void EcalDigiProducer::setEBNoiseSignalGenerator ( EcalBaseSignalGenerator * noiseGenerator )

Definition at line 593 of file EcalDigiProducer.cc.

References m_BarrelDigitizer.

Referenced by PreMixingEcalWorker::PreMixingEcalWorker().

                                                                                         {
   // noiseGenerator->setParameterMap(theParameterMap);
   if (nullptr != m_BarrelDigitizer)
     m_BarrelDigitizer->setNoiseSignalGenerator(noiseGenerator);
 }

void EcalDigiProducer::setEENoiseSignalGenerator ( EcalBaseSignalGenerator * noiseGenerator )

Definition at line 599 of file EcalDigiProducer.cc.

References m_EndcapDigitizer.

Referenced by PreMixingEcalWorker::PreMixingEcalWorker().

                                                                                         {
   // noiseGenerator->setParameterMap(theParameterMap);
   if (nullptr != m_EndcapDigitizer)
     m_EndcapDigitizer->setNoiseSignalGenerator(noiseGenerator);
 }

void EcalDigiProducer::setESNoiseSignalGenerator ( EcalBaseSignalGenerator * noiseGenerator )

Definition at line 605 of file EcalDigiProducer.cc.

References m_ESDigitizer.

Referenced by PreMixingEcalWorker::PreMixingEcalWorker().

                                                                                         {
   // noiseGenerator->setParameterMap(theParameterMap);
   if (nullptr != m_ESDigitizer)
     m_ESDigitizer->setNoiseSignalGenerator(noiseGenerator);
 }

void EcalDigiProducer::updateGeometry ( )

private

Definition at line 565 of file EcalDigiProducer.cc.

References DetId::Ecal, EcalBarrel, EcalEndcap, EcalPreshower, CaloGeometry::getSubdetectorGeometry(), CaloSubdetectorGeometry::getValidDetIds(), m_APDResponse, m_doEB, m_doEE, m_doES, m_doFastES, m_EBResponse, m_EEResponse, m_ESDigitizer, m_ESOldDigitizer, m_ESOldResponse, m_ESResponse, and m_Geometry.

Referenced by checkGeometry().

                                       {
   if (m_doEB) {
     if (nullptr != m_APDResponse)
       m_APDResponse->setGeometry(m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalBarrel));
     m_EBResponse->setGeometry(m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalBarrel));
   }
   if (m_doEE) {
     m_EEResponse->setGeometry(m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalEndcap));
   }
   if (m_doES) {
     m_ESResponse->setGeometry(m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalPreshower));
     m_ESOldResponse->setGeometry(m_Geometry);
 
     const std::vector<DetId> *theESDets(
         nullptr != m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalPreshower)
             ? &m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalPreshower)->getValidDetIds()
             : nullptr);
 
     if (!m_doFastES) {
       if (nullptr != m_ESOldDigitizer && nullptr != theESDets)
         m_ESOldDigitizer->setDetIds(*theESDets);
     } else {
       if (nullptr != m_ESDigitizer && nullptr != theESDets)
         m_ESDigitizer->setDetIds(*theESDets);
     }
   }
 }