#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 81 of file EcalDigiProducer.h.

Constructor & Destructor Documentation

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

Definition at line 57 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 68 of file EcalDigiProducer.cc.

References ecalElectronicsSim_cff::applyConstantTerm, ecalCosmicsSim_cff::cosmicsPhase, ecalCosmicsSim_cff::cosmicsShift, MillePedeFileConverter_cfg::e, funct::false, 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 290 of file EcalDigiProducer.cc.

291 {}

Member Function Documentation

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 342 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 369 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 319 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 443 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 654 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 78 of file EcalDigiProducer.h.

Referenced by finalizeEvent().

78 { }

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

inlineprivatevirtual

Reimplemented in EcalTBDigiProducer.

Definition at line 79 of file EcalDigiProducer.h.

Referenced by finalizeEvent().

79 { }

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

private

Definition at line 461 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 586 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 393 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 294 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 638 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 643 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 648 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 602 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, m_Geometry, and nullptr.

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 ) ; 
    }
   }
 }