Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-04-04 01:26:57 

0001 #include <memory>
0002 
0003 #include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
0004 #include "FWCore/Framework/interface/Event.h"
0005 #include "SimCalorimetry/CaloSimAlgos/interface/CaloHitResponse.h"
0006 #include "SimCalorimetry/EcalSimAlgos/interface/APDSimParameters.h"
0007 #include "SimCalorimetry/EcalSimAlgos/interface/ComponentSimParameterMap.h"
0008 #include "SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.h"
0009 #include "SimCalorimetry/EcalSimAlgos/interface/EEHitResponse.h"
0010 #include "SimCalorimetry/EcalSimAlgos/interface/ESElectronicsSim.h"
0011 #include "SimCalorimetry/EcalSimAlgos/interface/ESElectronicsSimFast.h"
0012 #include "SimCalorimetry/EcalSimAlgos/interface/ESHitResponse.h"
0013 #include "SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h"
0014 #include "SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim.h"
0015 #include "SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap.h"
0016 #include "SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer.h"
0017 #include "CalibFormats/CaloObjects/interface/CaloSamples.h"
0018 #include "DataFormats/Common/interface/Handle.h"
0019 #include "FWCore/AbstractServices/interface/RandomNumberGenerator.h"
0020 #include "FWCore/Framework/interface/ConsumesCollector.h"
0021 #include "FWCore/Framework/interface/Event.h"
0022 #include "FWCore/Framework/interface/EventSetup.h"
0023 #include "FWCore/Framework/interface/LuminosityBlock.h"
0024 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0025 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0026 #include "FWCore/ServiceRegistry/interface/Service.h"
0027 #include "FWCore/Utilities/interface/Exception.h"
0028 #include "FWCore/Utilities/interface/StreamID.h"
0029 #include "Geometry/CaloGeometry/interface/CaloGeometry.h"
0030 #include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"
0031 #include "SimCalorimetry/EcalSimAlgos/interface/ESDigitizer.h"
0032 #include "SimGeneral/MixingModule/interface/PileUpEventPrincipal.h"
0033 
0034 #include "Geometry/EcalAlgo/interface/EcalEndcapGeometry.h"
0035 
0036 EcalDigiProducer::EcalDigiProducer(const edm::ParameterSet &params,
0037                                    edm::ProducesCollector producesCollector,
0038                                    edm::ConsumesCollector &iC)
0039     : EcalDigiProducer(params, iC) {
0040   if (m_apdSeparateDigi)
0041     producesCollector.produces<EBDigiCollection>(m_apdDigiTag);
0042 
0043   if (m_componentSeparateDigi)
0044     producesCollector.produces<EBDigiCollection>(m_componentDigiTag);
0045 
0046   producesCollector.produces<EBDigiCollection>(m_EBdigiCollection);
0047   producesCollector.produces<EEDigiCollection>(m_EEdigiCollection);
0048   producesCollector.produces<ESDigiCollection>(m_ESdigiCollection);
0049 }
0050 
0051 // version for Pre-Mixing, for use outside of MixingModule
0052 EcalDigiProducer::EcalDigiProducer(const edm::ParameterSet &params, edm::ConsumesCollector &iC)
0053     : DigiAccumulatorMixMod(),
0054       m_APDShape(iC),
0055       m_ComponentShapes(iC),
0056       m_EBShape(iC),
0057       m_EEShape(iC),
0058       m_ESShape(),
0059       m_EBdigiCollection(params.getParameter<std::string>("EBdigiCollection")),
0060       m_EEdigiCollection(params.getParameter<std::string>("EEdigiCollection")),
0061       m_ESdigiCollection(params.getParameter<std::string>("ESdigiCollection")),
0062       m_hitsProducerTag(params.getParameter<std::string>("hitsProducer")),
0063       m_HitsEBToken_(iC.consumes<std::vector<PCaloHit>>(edm::InputTag(m_hitsProducerTag, "EcalHitsEB"))),
0064       m_HitsEEToken_(iC.consumes<std::vector<PCaloHit>>(edm::InputTag(m_hitsProducerTag, "EcalHitsEE"))),
0065       m_HitsESToken_(iC.consumes<std::vector<PCaloHit>>(edm::InputTag(m_hitsProducerTag, "EcalHitsES"))),
0066       m_pedestalsToken(iC.esConsumes()),
0067       m_icalToken(iC.esConsumes()),
0068       m_laserToken(iC.esConsumes()),
0069       m_agcToken(iC.esConsumes()),
0070       m_grToken(iC.esConsumes()),
0071       m_geometryToken(iC.esConsumes()),
0072       m_useLCcorrection(params.getUntrackedParameter<bool>("UseLCcorrection")),
0073       m_apdSeparateDigi(params.getParameter<bool>("apdSeparateDigi")),
0074       m_componentSeparateDigi(params.getParameter<bool>("componentSeparateDigi")),
0075 
0076       m_EBs25notCont(params.getParameter<double>("EBs25notContainment")),
0077       m_EEs25notCont(params.getParameter<double>("EEs25notContainment")),
0078 
0079       m_readoutFrameSize(ecalPh1::sampleSize),
0080       m_ParameterMap(new EcalSimParameterMap(params.getParameter<double>("simHitToPhotoelectronsBarrel"),
0081                                              params.getParameter<double>("simHitToPhotoelectronsEndcap"),
0082                                              params.getParameter<double>("photoelectronsToAnalogBarrel"),
0083                                              params.getParameter<double>("photoelectronsToAnalogEndcap"),
0084                                              params.getParameter<double>("samplingFactor"),
0085                                              params.getParameter<double>("timePhase"),
0086                                              m_readoutFrameSize,
0087                                              params.getParameter<int>("binOfMaximum"),
0088                                              params.getParameter<bool>("doPhotostatistics"),
0089                                              params.getParameter<bool>("syncPhase"))),
0090 
0091       m_apdDigiTag(params.getParameter<std::string>("apdDigiTag")),
0092       m_apdParameters(new APDSimParameters(params.getParameter<bool>("apdAddToBarrel"),
0093                                            m_apdSeparateDigi,
0094                                            params.getParameter<double>("apdSimToPELow"),
0095                                            params.getParameter<double>("apdSimToPEHigh"),
0096                                            params.getParameter<double>("apdTimeOffset"),
0097                                            params.getParameter<double>("apdTimeOffWidth"),
0098                                            params.getParameter<bool>("apdDoPEStats"),
0099                                            m_apdDigiTag,
0100                                            params.getParameter<std::vector<double>>("apdNonlParms"))),
0101 
0102       m_componentDigiTag(params.getParameter<std::string>("componentDigiTag")),
0103       m_componentParameters(
0104           std::make_unique<ComponentSimParameterMap>(params.getParameter<bool>("componentAddToBarrel"),
0105                                                      m_componentSeparateDigi,
0106                                                      params.getParameter<double>("simHitToPhotoelectronsBarrel"),
0107                                                      0,  // endcap parameters not needed
0108                                                      params.getParameter<double>("photoelectronsToAnalogBarrel"),
0109                                                      0,
0110                                                      params.getParameter<double>("samplingFactor"),
0111                                                      params.getParameter<double>("componentTimePhase"),
0112                                                      m_readoutFrameSize,
0113                                                      params.getParameter<int>("binOfMaximum"),
0114                                                      params.getParameter<bool>("doPhotostatistics"),
0115                                                      params.getParameter<bool>("syncPhase"))),
0116 
0117       m_APDResponse(!m_apdSeparateDigi ? nullptr
0118                                        : new EBHitResponse(m_ParameterMap.get(),
0119                                                            &m_EBShape,
0120                                                            true,
0121                                                            false,
0122                                                            m_apdParameters.get(),
0123                                                            &m_APDShape,
0124                                                            m_componentParameters.get(),
0125                                                            &m_ComponentShapes)),
0126 
0127       m_ComponentResponse(!m_componentSeparateDigi
0128                               ? nullptr
0129                               : std::make_unique<EBHitResponse>(
0130                                     m_ParameterMap.get(),
0131                                     &m_EBShape,
0132                                     false,
0133                                     true,
0134                                     m_apdParameters.get(),
0135                                     &m_APDShape,
0136                                     m_componentParameters.get(),
0137                                     &m_ComponentShapes)),  // check if that false is correct // TODO HERE JCH
0138 
0139       m_EBResponse(new EBHitResponse(m_ParameterMap.get(),
0140                                      &m_EBShape,
0141                                      false,  // barrel
0142                                      false,  // normal non-component shape based
0143                                      m_apdParameters.get(),
0144                                      &m_APDShape,
0145                                      m_componentParameters.get(),
0146                                      &m_ComponentShapes)),
0147 
0148       m_EEResponse(new EEHitResponse(m_ParameterMap.get(), &m_EEShape)),
0149       m_ESResponse(new ESHitResponse(m_ParameterMap.get(), &m_ESShape)),
0150       m_ESOldResponse(new CaloHitResponse(m_ParameterMap.get(), &m_ESShape)),
0151 
0152       m_addESNoise(params.getParameter<bool>("doESNoise")),
0153       m_PreMix1(params.getParameter<bool>("EcalPreMixStage1")),
0154       m_PreMix2(params.getParameter<bool>("EcalPreMixStage2")),
0155 
0156       m_doFastES(params.getParameter<bool>("doFast")),
0157 
0158       m_doEB(params.getParameter<bool>("doEB")),
0159       m_doEE(params.getParameter<bool>("doEE")),
0160       m_doES(params.getParameter<bool>("doES")),
0161 
0162       m_ESElectronicsSim(m_doFastES ? nullptr : new ESElectronicsSim(m_addESNoise)),
0163 
0164       m_ESOldDigitizer(m_doFastES ? nullptr
0165                                   : new ESOldDigitizer(m_ESOldResponse.get(), m_ESElectronicsSim.get(), m_addESNoise)),
0166 
0167       m_ESElectronicsSimFast(!m_doFastES ? nullptr : new ESElectronicsSimFast(m_addESNoise, m_PreMix1)),
0168 
0169       m_ESDigitizer(!m_doFastES ? nullptr
0170                                 : new ESDigitizer(m_ESResponse.get(), m_ESElectronicsSimFast.get(), m_addESNoise)),
0171 
0172       m_APDDigitizer(nullptr),
0173       m_ComponentDigitizer(nullptr),
0174       m_BarrelDigitizer(nullptr),
0175       m_EndcapDigitizer(nullptr),
0176       m_ElectronicsSim(nullptr),
0177       m_Coder(nullptr),
0178       m_APDElectronicsSim(nullptr),
0179       m_APDCoder(nullptr),
0180       m_Geometry(nullptr),
0181       m_EBCorrNoise({{nullptr, nullptr, nullptr}}),
0182       m_EECorrNoise({{nullptr, nullptr, nullptr}}) {
0183   // "produces" statements taken care of elsewhere.
0184   //   if(m_apdSeparateDigi) mixMod.produces<EBDigiCollection>(m_apdDigiTag);
0185   // mixMod.produces<EBDigiCollection>(m_EBdigiCollection);
0186   // mixMod.produces<EEDigiCollection>(m_EEdigiCollection);
0187   // mixMod.produces<ESDigiCollection>(m_ESdigiCollection);
0188   if (m_doEB)
0189     iC.consumes<std::vector<PCaloHit>>(edm::InputTag(m_hitsProducerTag, "EcalHitsEB"));
0190   if (m_doEE)
0191     iC.consumes<std::vector<PCaloHit>>(edm::InputTag(m_hitsProducerTag, "EcalHitsEE"));
0192   if (m_doES) {
0193     iC.consumes<std::vector<PCaloHit>>(edm::InputTag(m_hitsProducerTag, "EcalHitsES"));
0194     m_esGainToken = iC.esConsumes();
0195     m_esMIPToGeVToken = iC.esConsumes();
0196     m_esPedestalsToken = iC.esConsumes();
0197     m_esMIPsToken = iC.esConsumes();
0198   }
0199 
0200   const std::vector<double> ebCorMatG12 = params.getParameter<std::vector<double>>("EBCorrNoiseMatrixG12");
0201   const std::vector<double> eeCorMatG12 = params.getParameter<std::vector<double>>("EECorrNoiseMatrixG12");
0202   const std::vector<double> ebCorMatG06 = params.getParameter<std::vector<double>>("EBCorrNoiseMatrixG06");
0203   const std::vector<double> eeCorMatG06 = params.getParameter<std::vector<double>>("EECorrNoiseMatrixG06");
0204   const std::vector<double> ebCorMatG01 = params.getParameter<std::vector<double>>("EBCorrNoiseMatrixG01");
0205   const std::vector<double> eeCorMatG01 = params.getParameter<std::vector<double>>("EECorrNoiseMatrixG01");
0206 
0207   const bool applyConstantTerm = params.getParameter<bool>("applyConstantTerm");
0208   const double rmsConstantTerm = params.getParameter<double>("ConstantTerm");
0209 
0210   const bool addNoise = params.getParameter<bool>("doENoise");
0211   const bool cosmicsPhase = params.getParameter<bool>("cosmicsPhase");
0212   const double cosmicsShift = params.getParameter<double>("cosmicsShift");
0213 
0214   //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
0215 
0216   // further phase for cosmics studies
0217   if (cosmicsPhase) {
0218     if (m_doEB)
0219       m_EBResponse->setPhaseShift(1. + cosmicsShift);
0220     if (m_doEE)
0221       m_EEResponse->setPhaseShift(1. + cosmicsShift);
0222   }
0223 
0224   EcalCorrMatrix ebMatrix[3];
0225   EcalCorrMatrix eeMatrix[3];
0226 
0227   assert(ebCorMatG12.size() == m_readoutFrameSize);
0228   assert(eeCorMatG12.size() == m_readoutFrameSize);
0229   assert(ebCorMatG06.size() == m_readoutFrameSize);
0230   assert(eeCorMatG06.size() == m_readoutFrameSize);
0231   assert(ebCorMatG01.size() == m_readoutFrameSize);
0232   assert(eeCorMatG01.size() == m_readoutFrameSize);
0233 
0234   assert(1.e-7 > fabs(ebCorMatG12[0] - 1.0));
0235   assert(1.e-7 > fabs(ebCorMatG06[0] - 1.0));
0236   assert(1.e-7 > fabs(ebCorMatG01[0] - 1.0));
0237   assert(1.e-7 > fabs(eeCorMatG12[0] - 1.0));
0238   assert(1.e-7 > fabs(eeCorMatG06[0] - 1.0));
0239   assert(1.e-7 > fabs(eeCorMatG01[0] - 1.0));
0240 
0241   for (unsigned int row(0); row != m_readoutFrameSize; ++row) {
0242     assert(0 == row || 1. >= ebCorMatG12[row]);
0243     assert(0 == row || 1. >= ebCorMatG06[row]);
0244     assert(0 == row || 1. >= ebCorMatG01[row]);
0245     assert(0 == row || 1. >= eeCorMatG12[row]);
0246     assert(0 == row || 1. >= eeCorMatG06[row]);
0247     assert(0 == row || 1. >= eeCorMatG01[row]);
0248     for (unsigned int column(0); column <= row; ++column) {
0249       const unsigned int index(row - column);
0250       ebMatrix[0](row, column) = ebCorMatG12[index];
0251       eeMatrix[0](row, column) = eeCorMatG12[index];
0252       ebMatrix[1](row, column) = ebCorMatG06[index];
0253       eeMatrix[1](row, column) = eeCorMatG06[index];
0254       ebMatrix[2](row, column) = ebCorMatG01[index];
0255       eeMatrix[2](row, column) = eeCorMatG01[index];
0256     }
0257   }
0258 
0259   m_EBCorrNoise[0] = std::make_unique<CorrelatedNoisifier<EcalCorrMatrix>>(ebMatrix[0]);
0260   m_EECorrNoise[0] = std::make_unique<CorrelatedNoisifier<EcalCorrMatrix>>(eeMatrix[0]);
0261   m_EBCorrNoise[1] = std::make_unique<CorrelatedNoisifier<EcalCorrMatrix>>(ebMatrix[1]);
0262   m_EECorrNoise[1] = std::make_unique<CorrelatedNoisifier<EcalCorrMatrix>>(eeMatrix[1]);
0263   m_EBCorrNoise[2] = std::make_unique<CorrelatedNoisifier<EcalCorrMatrix>>(ebMatrix[2]);
0264   m_EECorrNoise[2] = std::make_unique<CorrelatedNoisifier<EcalCorrMatrix>>(eeMatrix[2]);
0265 
0266   m_Coder = std::make_unique<EcalCoder>(addNoise,
0267                                         m_PreMix1,
0268                                         m_EBCorrNoise[0].get(),
0269                                         m_EECorrNoise[0].get(),
0270                                         m_EBCorrNoise[1].get(),
0271                                         m_EECorrNoise[1].get(),
0272                                         m_EBCorrNoise[2].get(),
0273                                         m_EECorrNoise[2].get());
0274 
0275   m_ElectronicsSim =
0276       std::make_unique<EcalElectronicsSim_Ph1>(m_ParameterMap.get(), m_Coder.get(), applyConstantTerm, rmsConstantTerm);
0277 
0278   if (m_apdSeparateDigi) {
0279     m_APDCoder = std::make_unique<EcalCoder>(false,
0280                                              m_PreMix1,
0281                                              m_EBCorrNoise[0].get(),
0282                                              m_EECorrNoise[0].get(),
0283                                              m_EBCorrNoise[1].get(),
0284                                              m_EECorrNoise[1].get(),
0285                                              m_EBCorrNoise[2].get(),
0286                                              m_EECorrNoise[2].get());
0287 
0288     m_APDElectronicsSim = std::make_unique<EcalElectronicsSim_Ph1>(
0289         m_ParameterMap.get(), m_APDCoder.get(), applyConstantTerm, rmsConstantTerm);
0290 
0291     m_APDDigitizer = std::make_unique<EBDigitizer>(m_APDResponse.get(), m_APDElectronicsSim.get(), false);
0292   }
0293   if (m_componentSeparateDigi) {
0294     m_ComponentCoder = std::make_unique<EcalCoder>(addNoise,
0295                                                    m_PreMix1,
0296                                                    m_EBCorrNoise[0].get(),
0297                                                    m_EECorrNoise[0].get(),
0298                                                    m_EBCorrNoise[1].get(),
0299                                                    m_EECorrNoise[1].get(),
0300                                                    m_EBCorrNoise[2].get(),
0301                                                    m_EECorrNoise[2].get());
0302     m_ComponentElectronicsSim = std::make_unique<EcalElectronicsSim_Ph1>(
0303         m_ParameterMap.get(), m_ComponentCoder.get(), applyConstantTerm, rmsConstantTerm);
0304     m_ComponentDigitizer =
0305         std::make_unique<EBDigitizer>(m_ComponentResponse.get(), m_ComponentElectronicsSim.get(), addNoise);
0306   }
0307 
0308   if (m_doEB) {
0309     m_BarrelDigitizer = std::make_unique<EBDigitizer>(m_EBResponse.get(), m_ElectronicsSim.get(), addNoise);
0310   }
0311 
0312   if (m_doEE) {
0313     m_EndcapDigitizer = std::make_unique<EEDigitizer>(m_EEResponse.get(), m_ElectronicsSim.get(), addNoise);
0314   }
0315 }
0316 
0317 EcalDigiProducer::~EcalDigiProducer() {}
0318 
0319 void EcalDigiProducer::initializeEvent(edm::Event const &event, edm::EventSetup const &eventSetup) {
0320   edm::Service<edm::RandomNumberGenerator> rng;
0321   randomEngine_ = &rng->getEngine(event.streamID());
0322 
0323   checkGeometry(eventSetup);
0324   checkCalibrations(event, eventSetup);
0325   if (m_doEB) {
0326     m_BarrelDigitizer->initializeHits();
0327     if (m_apdSeparateDigi) {
0328       m_APDDigitizer->initializeHits();
0329     }
0330     if (m_componentSeparateDigi) {
0331       m_ComponentDigitizer->initializeHits();
0332     }
0333   }
0334   if (m_doEE) {
0335     m_EndcapDigitizer->initializeHits();
0336   }
0337   if (m_doES) {
0338     if (m_doFastES) {
0339       m_ESDigitizer->initializeHits();
0340     } else {
0341       m_ESOldDigitizer->initializeHits();
0342     }
0343   }
0344 }
0345 
0346 void EcalDigiProducer::accumulateCaloHits(HitsHandle const &ebHandle,
0347                                           HitsHandle const &eeHandle,
0348                                           HitsHandle const &esHandle,
0349                                           int bunchCrossing) {
0350   if (m_doEB && ebHandle.isValid()) {
0351     m_BarrelDigitizer->add(*ebHandle.product(), bunchCrossing, randomEngine_);
0352 
0353     if (m_apdSeparateDigi) {
0354       m_APDDigitizer->add(*ebHandle.product(), bunchCrossing, randomEngine_);
0355     }
0356     if (m_componentSeparateDigi) {
0357       m_ComponentDigitizer->add(*ebHandle.product(), bunchCrossing, randomEngine_);
0358     }
0359   }
0360 
0361   if (m_doEE && eeHandle.isValid()) {
0362     m_EndcapDigitizer->add(*eeHandle.product(), bunchCrossing, randomEngine_);
0363   }
0364 
0365   if (m_doES && esHandle.isValid()) {
0366     if (m_doFastES) {
0367       m_ESDigitizer->add(*esHandle.product(), bunchCrossing, randomEngine_);
0368     } else {
0369       m_ESOldDigitizer->add(*esHandle.product(), bunchCrossing, randomEngine_);
0370     }
0371   }
0372 }
0373 
0374 void EcalDigiProducer::accumulate(edm::Event const &e, edm::EventSetup const &eventSetup) {
0375   // Step A: Get Inputs
0376   const edm::Handle<std::vector<PCaloHit>> &ebHandle = e.getHandle(m_HitsEBToken_);
0377   if (m_doEB) {
0378     m_EBShape.setEventSetup(eventSetup);
0379     m_APDShape.setEventSetup(eventSetup);
0380     m_ComponentShapes.setEventSetup(eventSetup);
0381   }
0382 
0383   const edm::Handle<std::vector<PCaloHit>> &eeHandle = e.getHandle(m_HitsEEToken_);
0384   if (m_doEE) {
0385     m_EEShape.setEventSetup(eventSetup);
0386   }
0387 
0388   const edm::Handle<std::vector<PCaloHit>> &esHandle = e.getHandle(m_HitsESToken_);
0389 
0390   accumulateCaloHits(ebHandle, eeHandle, esHandle, 0);
0391 }
0392 
0393 void EcalDigiProducer::accumulate(PileUpEventPrincipal const &e,
0394                                   edm::EventSetup const &eventSetup,
0395                                   edm::StreamID const &streamID) {
0396   // Step A: Get Inputs
0397   edm::Handle<std::vector<PCaloHit>> ebHandle;
0398   if (m_doEB) {
0399     edm::InputTag ebTag(m_hitsProducerTag, "EcalHitsEB");
0400     e.getByLabel(ebTag, ebHandle);
0401   }
0402 
0403   edm::Handle<std::vector<PCaloHit>> eeHandle;
0404   if (m_doEE) {
0405     edm::InputTag eeTag(m_hitsProducerTag, "EcalHitsEE");
0406     e.getByLabel(eeTag, eeHandle);
0407   }
0408 
0409   edm::Handle<std::vector<PCaloHit>> esHandle;
0410   if (m_doES) {
0411     edm::InputTag esTag(m_hitsProducerTag, "EcalHitsES");
0412     e.getByLabel(esTag, esHandle);
0413   }
0414 
0415   accumulateCaloHits(ebHandle, eeHandle, esHandle, e.bunchCrossing());
0416 }
0417 
0418 void EcalDigiProducer::finalizeEvent(edm::Event &event, edm::EventSetup const &eventSetup) {
0419   // Step B: Create empty output
0420   std::unique_ptr<EBDigiCollection> apdResult(!m_apdSeparateDigi || !m_doEB ? nullptr : new EBDigiCollection());
0421   std::unique_ptr<EBDigiCollection> componentResult(!m_componentSeparateDigi || !m_doEB ? nullptr
0422                                                                                         : new EBDigiCollection());
0423   std::unique_ptr<EBDigiCollection> barrelResult(new EBDigiCollection());
0424   std::unique_ptr<EEDigiCollection> endcapResult(new EEDigiCollection());
0425   std::unique_ptr<ESDigiCollection> preshowerResult(new ESDigiCollection());
0426 
0427   // run the algorithm
0428 
0429   if (m_doEB) {
0430     m_BarrelDigitizer->run(*barrelResult, randomEngine_);
0431     cacheEBDigis(&*barrelResult);
0432 
0433     edm::LogInfo("DigiInfo") << "EB Digis: " << barrelResult->size();
0434 
0435     if (m_apdSeparateDigi) {
0436       m_APDDigitizer->run(*apdResult, randomEngine_);
0437       edm::LogInfo("DigiInfo") << "APD Digis: " << apdResult->size();
0438     }
0439     if (m_componentSeparateDigi) {
0440       m_ComponentDigitizer->run(*componentResult, randomEngine_);
0441       edm::LogInfo("DigiInfo") << "Component Digis: " << componentResult->size();
0442     }
0443   }
0444 
0445   if (m_doEE) {
0446     m_EndcapDigitizer->run(*endcapResult, randomEngine_);
0447     edm::LogInfo("EcalDigi") << "EE Digis: " << endcapResult->size();
0448     cacheEEDigis(&*endcapResult);
0449   }
0450   if (m_doES) {
0451     if (m_doFastES) {
0452       m_ESDigitizer->run(*preshowerResult, randomEngine_);
0453     } else {
0454       m_ESOldDigitizer->run(*preshowerResult, randomEngine_);
0455     }
0456     edm::LogInfo("EcalDigi") << "ES Digis: " << preshowerResult->size();
0457   }
0458 
0459   // Step D: Put outputs into event
0460   if (m_apdSeparateDigi) {
0461     // event.put(std::move(apdResult),    m_apdDigiTag         ) ;
0462   }
0463 
0464   event.put(std::move(barrelResult), m_EBdigiCollection);
0465   if (m_componentSeparateDigi) {
0466     event.put(std::move(componentResult), m_componentDigiTag);
0467   }
0468   event.put(std::move(endcapResult), m_EEdigiCollection);
0469   event.put(std::move(preshowerResult), m_ESdigiCollection);
0470 
0471   randomEngine_ = nullptr;  // to prevent access outside event
0472 }
0473 
0474 void EcalDigiProducer::beginLuminosityBlock(edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) {
0475   edm::Service<edm::RandomNumberGenerator> rng;
0476   if (!rng.isAvailable()) {
0477     throw cms::Exception("Configuration") << "RandomNumberGenerator service is not available.\n"
0478                                              "You must add the service in the configuration file\n"
0479                                              "or remove the module that requires it.";
0480   }
0481   CLHEP::HepRandomEngine *engine = &rng->getEngine(lumi.index());
0482 
0483   if (m_doEB) {
0484     if (nullptr != m_APDResponse)
0485       m_APDResponse->initialize(engine);
0486     if (nullptr != m_ComponentResponse)
0487       m_ComponentResponse->initialize(engine);
0488     m_EBResponse->initialize(engine);
0489   }
0490 }
0491 
0492 void EcalDigiProducer::checkCalibrations(const edm::Event &event, const edm::EventSetup &eventSetup) {
0493   // Pedestals from event setup
0494 
0495   const EcalPedestals *pedestals = &eventSetup.getData(m_pedestalsToken);
0496 
0497   m_Coder->setPedestals(pedestals);
0498   if (nullptr != m_APDCoder)
0499     m_APDCoder->setPedestals(pedestals);
0500   if (nullptr != m_ComponentCoder)
0501     m_ComponentCoder->setPedestals(pedestals);
0502 
0503   // Ecal Intercalibration Constants
0504   const EcalIntercalibConstantsMC *ical = &eventSetup.getData(m_icalToken);
0505 
0506   m_Coder->setIntercalibConstants(ical);
0507   if (nullptr != m_APDCoder)
0508     m_APDCoder->setIntercalibConstants(ical);
0509   if (nullptr != m_ComponentCoder)
0510     m_ComponentCoder->setIntercalibConstants(ical);
0511 
0512   m_EBResponse->setIntercal(ical);
0513   if (nullptr != m_APDResponse)
0514     m_APDResponse->setIntercal(ical);
0515   if (nullptr != m_ComponentResponse)
0516     m_ComponentResponse->setIntercal(ical);
0517 
0518   // Ecal LaserCorrection Constants
0519   const EcalLaserDbService *laser = &eventSetup.getData(m_laserToken);
0520   const edm::TimeValue_t eventTimeValue = event.time().value();
0521 
0522   m_EBResponse->setEventTime(eventTimeValue);
0523   m_EBResponse->setLaserConstants(laser, m_useLCcorrection);
0524 
0525   m_EEResponse->setEventTime(eventTimeValue);
0526   m_EEResponse->setLaserConstants(laser, m_useLCcorrection);
0527 
0528   // ADC -> GeV Scale
0529   const EcalADCToGeVConstant *agc = &eventSetup.getData(m_agcToken);
0530 
0531   // Gain Ratios
0532   const EcalGainRatios *gr = &eventSetup.getData(m_grToken);
0533 
0534   m_Coder->setGainRatios(gr);
0535   if (nullptr != m_APDCoder)
0536     m_APDCoder->setGainRatios(gr);
0537   if (nullptr != m_ComponentCoder)
0538     m_ComponentCoder->setGainRatios(gr);
0539 
0540   EcalMGPAGainRatio *defaultRatios = new EcalMGPAGainRatio();
0541 
0542   double theGains[m_Coder->NGAINS + 1];
0543   theGains[0] = 0.;
0544   theGains[3] = 1.;
0545   theGains[2] = defaultRatios->gain6Over1();
0546   theGains[1] = theGains[2] * (defaultRatios->gain12Over6());
0547 
0548   LogDebug("EcalDigi") << " Gains: "
0549                        << "\n"
0550                        << " g1 = " << theGains[1] << "\n"
0551                        << " g2 = " << theGains[2] << "\n"
0552                        << " g3 = " << theGains[3];
0553 
0554   delete defaultRatios;
0555 
0556   const double EBscale((agc->getEBValue()) * theGains[1] * (m_Coder->MAXADC) * m_EBs25notCont);
0557 
0558   LogDebug("EcalDigi") << " GeV/ADC = " << agc->getEBValue() << "\n"
0559                        << " notCont = " << m_EBs25notCont << "\n"
0560                        << " saturation for EB = " << EBscale << ", " << m_EBs25notCont;
0561 
0562   const double EEscale((agc->getEEValue()) * theGains[1] * (m_Coder->MAXADC) * m_EEs25notCont);
0563 
0564   LogDebug("EcalDigi") << " GeV/ADC = " << agc->getEEValue() << "\n"
0565                        << " notCont = " << m_EEs25notCont << "\n"
0566                        << " saturation for EB = " << EEscale << ", " << m_EEs25notCont;
0567 
0568   m_Coder->setFullScaleEnergy(EBscale, EEscale);
0569   if (nullptr != m_APDCoder)
0570     m_APDCoder->setFullScaleEnergy(EBscale, EEscale);
0571   if (nullptr != m_ComponentCoder)
0572     m_ComponentCoder->setFullScaleEnergy(EBscale, EEscale);
0573 
0574   if (m_doES) {
0575     // ES condition objects
0576     const ESGain *esgain = &eventSetup.getData(m_esGainToken);
0577     const ESPedestals *espeds = &eventSetup.getData(m_esPedestalsToken);
0578     const ESIntercalibConstants *esmips = &eventSetup.getData(m_esMIPsToken);
0579     const ESMIPToGeVConstant *esMipToGeV = &eventSetup.getData(m_esMIPToGeVToken);
0580     const int ESGain(1.1 > esgain->getESGain() ? 1 : 2);
0581     const double ESMIPToGeV((1 == ESGain) ? esMipToGeV->getESValueLow() : esMipToGeV->getESValueHigh());
0582 
0583     m_ESShape.setGain(ESGain);
0584     if (!m_doFastES) {
0585       m_ESElectronicsSim->setGain(ESGain);
0586       m_ESElectronicsSim->setPedestals(espeds);
0587       m_ESElectronicsSim->setMIPs(esmips);
0588       m_ESElectronicsSim->setMIPToGeV(ESMIPToGeV);
0589     } else {
0590       m_ESDigitizer->setGain(ESGain);
0591       m_ESElectronicsSimFast->setPedestals(espeds);
0592       m_ESElectronicsSimFast->setMIPs(esmips);
0593       m_ESElectronicsSimFast->setMIPToGeV(ESMIPToGeV);
0594     }
0595   }
0596 }
0597 
0598 void EcalDigiProducer::checkGeometry(const edm::EventSetup &eventSetup) {
0599   if (m_geometryWatcher.check(eventSetup)) {
0600     m_Geometry = &eventSetup.getData(m_geometryToken);
0601     updateGeometry();
0602   }
0603 }
0604 
0605 void EcalDigiProducer::updateGeometry() {
0606   if (m_doEB) {
0607     if (nullptr != m_APDResponse)
0608       m_APDResponse->setGeometry(m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalBarrel));
0609     if (nullptr != m_ComponentResponse)
0610       m_ComponentResponse->setGeometry(m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalBarrel));
0611     m_EBResponse->setGeometry(m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalBarrel));
0612   }
0613   if (m_doEE) {
0614     m_EEResponse->setGeometry(m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalEndcap));
0615   }
0616   if (m_doES) {
0617     m_ESResponse->setGeometry(m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalPreshower));
0618     m_ESOldResponse->setGeometry(m_Geometry);
0619 
0620     const std::vector<DetId> *theESDets(
0621         nullptr != m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalPreshower)
0622             ? &m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalPreshower)->getValidDetIds()
0623             : nullptr);
0624 
0625     if (!m_doFastES) {
0626       if (nullptr != m_ESOldDigitizer && nullptr != theESDets)
0627         m_ESOldDigitizer->setDetIds(*theESDets);
0628     } else {
0629       if (nullptr != m_ESDigitizer && nullptr != theESDets)
0630         m_ESDigitizer->setDetIds(*theESDets);
0631     }
0632   }
0633 }
0634 
0635 void EcalDigiProducer::setEBNoiseSignalGenerator(EcalBaseSignalGenerator *noiseGenerator) {
0636   // noiseGenerator->setParameterMap(theParameterMap);
0637   if (nullptr != m_BarrelDigitizer)
0638     m_BarrelDigitizer->setNoiseSignalGenerator(noiseGenerator);
0639 }
0640 
0641 void EcalDigiProducer::setEENoiseSignalGenerator(EcalBaseSignalGenerator *noiseGenerator) {
0642   // noiseGenerator->setParameterMap(theParameterMap);
0643   if (nullptr != m_EndcapDigitizer)
0644     m_EndcapDigitizer->setNoiseSignalGenerator(noiseGenerator);
0645 }
0646 
0647 void EcalDigiProducer::setESNoiseSignalGenerator(EcalBaseSignalGenerator *noiseGenerator) {
0648   // noiseGenerator->setParameterMap(theParameterMap);
0649   if (nullptr != m_ESDigitizer)
0650     m_ESDigitizer->setNoiseSignalGenerator(noiseGenerator);
0651 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!