EcalDigiProducer.h

Go to the documentation of this file.

#ifndef SimCalorimetry_EcalSimProducers_EcalDigiProducer_h
#define SimCalorimetry_EcalSimProducers_EcalDigiProducer_h

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

#include "SimCalorimetry/CaloSimAlgos/interface/CaloTDigitizer.h"
#include "SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits.h"
#include "SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer.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;
  class ProducerBase;
  class Event;
  class EventSetup;
  template <typename T>
  class Handle;
  class ParameterSet;
  class StreamID;
}  // namespace edm

namespace CLHEP {
  class HepRandomEngine;
}

class EcalDigiProducer : public DigiAccumulatorMixMod {
public:
  EcalDigiProducer(const edm::ParameterSet &params, edm::ProducerBase &mixMod, edm::ConsumesCollector &iC);
  EcalDigiProducer(const edm::ParameterSet &params, edm::ConsumesCollector &iC);
  ~EcalDigiProducer() override;

  void initializeEvent(edm::Event const &e, edm::EventSetup const &c) override;
  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 finalizeEvent(edm::Event &e, edm::EventSetup const &c) override;
  void beginLuminosityBlock(edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) override;
  void beginRun(edm::Run const &run, 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);

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

  void updateGeometry();

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

  APDShape m_APDShape;
  EBShape m_EBShape;
  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;

  CLHEP::HepRandomEngine *randomEngine_ = nullptr;
};

#endif