EcalDigiProducer.h

Go to the documentation of this file.

#ifndef SimCalorimetry_EcalSimProducers_EcalDigiProducer_h
#define SimCalorimetry_EcalSimProducers_EcalDigiProducer_h

#include "SimCalorimetry/EcalSimAlgos/interface/APDShape.h"
#include "SimCalorimetry/EcalSimAlgos/interface/EBShape.h"
#include "SimCalorimetry/EcalSimAlgos/interface/EEShape.h"
#include "SimCalorimetry/EcalSimAlgos/interface/ESShape.h"
#include "DataFormats/Math/interface/Error.h"
#include "SimGeneral/NoiseGenerators/interface/CorrelatedNoisifier.h"
#include "SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix.h"
#include "SimCalorimetry/EcalSimAlgos/interface/ESElectronicsSim.h"

#include "SimCalorimetry/CaloSimAlgos/interface/CaloTDigitizer.h"
#include "SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer.h"
#include "SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits.h"
#include "SimGeneral/MixingModule/interface/DigiAccumulatorMixMod.h"


#include <vector>

typedef EcalTDigitizer<EBDigitizerTraits> EBDigitizer  ;
typedef EcalTDigitizer<EEDigitizerTraits> EEDigitizer  ;
typedef CaloTDigitizer<ESOldDigitizerTraits> ESOldDigitizer  ;

class ESDigitizer ;

class APDSimParameters ;
class EBHitResponse ;
class EEHitResponse ;
class ESHitResponse ;
class CaloHitResponse ;
class EcalSimParameterMap ;
class EcalCoder ;
class EcalElectronicsSim ;
class ESElectronicsSim ;
class ESElectronicsSimFast ;
class EcalBaseSignalGenerator;
class CaloGeometry ;
class EBDigiCollection ;
class EEDigiCollection ;
class ESDigiCollection ;
class PileUpEventPrincipal ;

namespace edm {
  class ConsumesCollector;
  namespace one {
    class EDProducerBase;
  }
  class Event;
  class EventSetup;
  template<typename T> class Handle;
  class ParameterSet;
  class StreamID;
}

namespace CLHEP {
  class HepRandomEngine;
}

class EcalDigiProducer : public DigiAccumulatorMixMod {
   public:

      EcalDigiProducer( const edm::ParameterSet& params , edm::one::EDProducerBase& mixMod, edm::ConsumesCollector& iC);
      EcalDigiProducer( const edm::ParameterSet& params , edm::ConsumesCollector& iC);
      virtual ~EcalDigiProducer();

      virtual void initializeEvent(edm::Event const& e, edm::EventSetup const& c) override;
      virtual void accumulate(edm::Event const& e, edm::EventSetup const& c) override;
      virtual void accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& c, edm::StreamID const&) override;
      virtual void finalizeEvent(edm::Event& e, edm::EventSetup const& c) override;
      virtual void beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& setup) override;

      void setEBNoiseSignalGenerator(EcalBaseSignalGenerator * noiseGenerator);
      void setEENoiseSignalGenerator(EcalBaseSignalGenerator * noiseGenerator);
      void setESNoiseSignalGenerator(EcalBaseSignalGenerator * noiseGenerator);

   private:

      virtual void cacheEBDigis( const EBDigiCollection* ebDigiPtr ) const { }
      virtual void cacheEEDigis( const EEDigiCollection* eeDigiPtr ) const { }

      typedef edm::Handle<std::vector<PCaloHit> > HitsHandle;
      void accumulateCaloHits(HitsHandle const& ebHandle, HitsHandle const& eeHandle, HitsHandle const& esHandle, int bunchCrossing, CLHEP::HepRandomEngine*);

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

      void updateGeometry() ;

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

      CLHEP::HepRandomEngine* randomEngine(edm::StreamID const& streamID);

      const APDShape m_APDShape ;
      const EBShape  m_EBShape  ;
      const EEShape  m_EEShape  ;
      ESShape        m_ESShape  ; // no const because gain must be set

      const std::string m_EBdigiCollection ;
      const std::string m_EEdigiCollection ;
      const std::string m_ESdigiCollection ;
      const std::string m_hitsProducerTag  ;

      bool  m_useLCcorrection;

      const bool m_apdSeparateDigi ;

      const double m_EBs25notCont ;
      const double m_EEs25notCont ;

      const unsigned int         m_readoutFrameSize ;
   protected:
      std::unique_ptr<const EcalSimParameterMap> m_ParameterMap  ;
   private:
      const std::string          m_apdDigiTag    ;
      std::unique_ptr<const APDSimParameters>    m_apdParameters ;

      std::unique_ptr<EBHitResponse> m_APDResponse ;
   protected:
      std::unique_ptr<EBHitResponse> m_EBResponse ;
      std::unique_ptr<EEHitResponse> m_EEResponse ;
   private:
      std::unique_ptr<ESHitResponse> m_ESResponse ;
      std::unique_ptr<CaloHitResponse> m_ESOldResponse ;

      const bool m_addESNoise ;
      const bool m_PreMix1 ;
      const bool m_PreMix2 ;

      const bool m_doFastES   ;

      const bool m_doEB, m_doEE, m_doES;

      std::unique_ptr<ESElectronicsSim>     m_ESElectronicsSim     ;
      std::unique_ptr<ESOldDigitizer>       m_ESOldDigitizer       ;
      std::unique_ptr<ESElectronicsSimFast> m_ESElectronicsSimFast ;
      std::unique_ptr<ESDigitizer>          m_ESDigitizer          ;

      std::unique_ptr<EBDigitizer>          m_APDDigitizer ;
      std::unique_ptr<EBDigitizer>          m_BarrelDigitizer ;
      std::unique_ptr<EEDigitizer>          m_EndcapDigitizer ;

      std::unique_ptr<EcalElectronicsSim>   m_ElectronicsSim ;
      std::unique_ptr<EcalCoder>            m_Coder ;

      std::unique_ptr<EcalElectronicsSim>   m_APDElectronicsSim ;
      std::unique_ptr<EcalCoder>            m_APDCoder ;

      const CaloGeometry*   m_Geometry ;

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

      std::vector<CLHEP::HepRandomEngine*> randomEngines_;
};

#endif