Move premixing worker plugins to packages with corresponding MixingModule plugins

SimCalorimetry/EcalSimProducers/plugins/BuildFile.xml

@@ -1,4 +1,5 @@
 <use   name="SimCalorimetry/EcalSimProducers"/>
+<use   name="SimGeneral/PreMixingModule"/>
 <library   file="*.cc" name="SimCalorimetryEcalSimProducersPlugins">
   <flags   EDM_PLUGIN="1"/>
 </library>

SimCalorimetry/EcalSimProducers/plugins/PreMixingEcalWorker.cc

@@ -0,0 +1,120 @@
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
+#include "FWCore/Framework/interface/ProducerBase.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "SimGeneral/MixingModule/interface/PileUpEventPrincipal.h"
+
+#include "DataFormats/Common/interface/Handle.h"
+#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
+#include "DataFormats/EcalDigi/interface/EBDataFrame.h"
+#include "DataFormats/EcalDigi/interface/EEDataFrame.h"
+#include "DataFormats/EcalDigi/interface/ESDataFrame.h"
+#include "SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer.h"
+#include "SimCalorimetry/EcalSimAlgos/interface/EcalSignalGenerator.h"
+
+#include "SimGeneral/PreMixingModule/interface/PreMixingWorker.h"
+#include "SimGeneral/PreMixingModule/interface/PreMixingWorkerFactory.h"
+
+class PreMixingEcalWorker: public PreMixingWorker {
+public:
+  PreMixingEcalWorker(const edm::ParameterSet& ps, edm::ProducerBase& producer, edm::ConsumesCollector&& iC);
+  ~PreMixingEcalWorker() override = default;
+
+  PreMixingEcalWorker(const PreMixingEcalWorker&) = delete;
+  PreMixingEcalWorker& operator=(const PreMixingEcalWorker&) = delete;
+
+  void beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& setup) override;
+
+  void initializeEvent(edm::Event const& e, edm::EventSetup const& ES) override;
+  void addSignals(edm::Event const& e, edm::EventSetup const& ES) override;
+  void addPileups(PileUpEventPrincipal const& pep, edm::EventSetup const& es) override;
+  void put(edm::Event &e, edm::EventSetup const& iSetup, std::vector<PileupSummaryInfo> const& ps, int bs) override;
+
+private:
+  edm::InputTag EBPileInputTag_; // InputTag for Pileup Digis collection
+  edm::InputTag EEPileInputTag_  ; // InputTag for Pileup Digis collection
+  edm::InputTag ESPileInputTag_  ; // InputTag for Pileup Digis collection
+
+  std::string EBDigiCollectionDM_; // secondary name to be given to collection of digis
+  std::string EEDigiCollectionDM_  ; // secondary name to be given to collection of digis
+  std::string ESDigiCollectionDM_  ; // secondary name to be given to collection of digis
+
+  edm::EDGetTokenT<EBDigitizerTraits::DigiCollection> tok_eb_;
+  edm::EDGetTokenT<EEDigitizerTraits::DigiCollection> tok_ee_;
+  edm::EDGetTokenT<ESDigitizerTraits::DigiCollection> tok_es_;
+
+  const double m_EBs25notCont;
+  const double m_EEs25notCont;
+  const double m_peToABarrel;
+  const double m_peToAEndcap;
+
+  EBSignalGenerator theEBSignalGenerator;
+  EESignalGenerator theEESignalGenerator;
+  ESSignalGenerator theESSignalGenerator;
+  EcalDigiProducer myEcalDigitizer_;
+};
+
+
+// Constructor
+PreMixingEcalWorker::PreMixingEcalWorker(const edm::ParameterSet& ps, edm::ProducerBase& producer, edm::ConsumesCollector&& iC) : 
+  EBPileInputTag_(ps.getParameter<edm::InputTag>("EBPileInputTag")),
+  EEPileInputTag_(ps.getParameter<edm::InputTag>("EEPileInputTag")),
+  ESPileInputTag_(ps.getParameter<edm::InputTag>("ESPileInputTag")),
+  tok_eb_(iC.consumes<EBDigitizerTraits::DigiCollection>(EBPileInputTag_)),
+  tok_ee_(iC.consumes<EEDigitizerTraits::DigiCollection>(EEPileInputTag_)),
+  tok_es_(iC.consumes<ESDigitizerTraits::DigiCollection>(ESPileInputTag_)),
+  m_EBs25notCont(ps.getParameter<double>("EBs25notContainment") ) ,
+  m_EEs25notCont(ps.getParameter<double>("EEs25notContainment") ) ,
+  m_peToABarrel(ps.getParameter<double>("photoelectronsToAnalogBarrel") ) ,
+  m_peToAEndcap(ps.getParameter<double>("photoelectronsToAnalogEndcap") ),
+  theEBSignalGenerator(EBPileInputTag_,tok_eb_, m_EBs25notCont, m_EEs25notCont, m_peToABarrel, m_peToAEndcap),
+  theEESignalGenerator(EEPileInputTag_,tok_ee_, m_EBs25notCont, m_EEs25notCont, m_peToABarrel, m_peToAEndcap),
+  theESSignalGenerator(ESPileInputTag_,tok_es_, m_EBs25notCont, m_EEs25notCont, m_peToABarrel, m_peToAEndcap),
+  myEcalDigitizer_(ps, iC)
+{
+  EBDigiCollectionDM_   = ps.getParameter<std::string>("EBDigiCollectionDM");
+  EEDigiCollectionDM_   = ps.getParameter<std::string>("EEDigiCollectionDM");
+  ESDigiCollectionDM_   = ps.getParameter<std::string>("ESDigiCollectionDM");
+
+  producer.produces< EBDigiCollection >(EBDigiCollectionDM_);
+  producer.produces< EEDigiCollection >(EEDigiCollectionDM_);
+  producer.produces< ESDigiCollection >(ESDigiCollectionDM_);
+
+  myEcalDigitizer_.setEBNoiseSignalGenerator( & theEBSignalGenerator );
+  myEcalDigitizer_.setEENoiseSignalGenerator( & theEESignalGenerator );
+  myEcalDigitizer_.setESNoiseSignalGenerator( & theESSignalGenerator );
+}
+
+void PreMixingEcalWorker::initializeEvent(const edm::Event &e, const edm::EventSetup& ES) {
+  myEcalDigitizer_.initializeEvent(e, ES);
+}
+
+void PreMixingEcalWorker::addSignals(const edm::Event &e,const edm::EventSetup& ES) { 
+  myEcalDigitizer_.accumulate(e, ES);
+}
+
+void PreMixingEcalWorker::addPileups(const PileUpEventPrincipal& pep, const edm::EventSetup& ES) {
+
+  LogDebug("PreMixingEcalWorker") <<"\n===============> adding pileups from event  "<<pep.principal().id()<<" for bunchcrossing "<<pep.bunchCrossing();
+
+  theEBSignalGenerator.initializeEvent(&pep.principal(), &ES);
+  theEESignalGenerator.initializeEvent(&pep.principal(), &ES);
+  theESSignalGenerator.initializeEvent(&pep.principal(), &ES);
+
+  // add noise signals using incoming digis
+  theEBSignalGenerator.fill(pep.moduleCallingContext());
+  theEESignalGenerator.fill(pep.moduleCallingContext());
+  theESSignalGenerator.fill(pep.moduleCallingContext());
+}
+
+void PreMixingEcalWorker::put(edm::Event &e,const edm::EventSetup& ES, std::vector<PileupSummaryInfo> const& ps, int bs) {
+  myEcalDigitizer_.finalizeEvent( e, ES );
+}
+
+void PreMixingEcalWorker::beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& setup) {
+  myEcalDigitizer_.beginLuminosityBlock(lumi,setup);
+}
+
+DEFINE_EDM_PLUGIN(PreMixingWorkerFactory, PreMixingEcalWorker, "PreMixingEcalWorker");

SimCalorimetry/HcalSimProducers/plugins/BuildFile.xml

@@ -1,5 +1,6 @@
 <use   name="SimCalorimetry/HcalSimProducers"/>
 <use   name="SimGeneral/MixingModule"/>
+<use   name="SimGeneral/PreMixingModule"/>
 <library   file="*.cc" name="SimCalorimetryHcalSimProducersPlugins">
   <flags   EDM_PLUGIN="1"/>
 </library>

SimCalorimetry/HcalSimProducers/plugins/PreMixingHcalWorker.cc

@@ -0,0 +1,156 @@
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
+#include "FWCore/Framework/interface/ProducerBase.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "SimGeneral/MixingModule/interface/PileUpEventPrincipal.h"
+
+#include "DataFormats/Common/interface/Handle.h"
+#include "DataFormats/HcalDigi/interface/HcalDigiCollections.h"
+#include "DataFormats/HcalDigi/interface/HBHEDataFrame.h"
+#include "DataFormats/HcalDigi/interface/HODataFrame.h"
+#include "DataFormats/HcalDigi/interface/HFDataFrame.h"
+#include "DataFormats/HcalDigi/interface/QIE10DataFrame.h"
+#include "DataFormats/HcalDigi/interface/QIE11DataFrame.h"
+#include "SimCalorimetry/HcalSimProducers/interface/HcalDigiProducer.h"
+#include "SimCalorimetry/HcalSimAlgos/interface/HcalSignalGenerator.h"
+
+#include "SimGeneral/PreMixingModule/interface/PreMixingWorker.h"
+#include "SimGeneral/PreMixingModule/interface/PreMixingWorkerFactory.h"
+
+class PreMixingHcalWorker: public PreMixingWorker {
+public:
+  PreMixingHcalWorker(const edm::ParameterSet& ps, edm::ProducerBase& producer, edm::ConsumesCollector&& iC);
+  ~PreMixingHcalWorker() override = default;
+
+  PreMixingHcalWorker(const PreMixingHcalWorker&) = delete;
+  PreMixingHcalWorker& operator=(const PreMixingHcalWorker&) = delete;
+
+  void beginRun(const edm::Run& run, const edm::EventSetup& ES) override;
+  void initializeEvent(const edm::Event &e, const edm::EventSetup& ES) override;
+  void addSignals(const edm::Event &e, const edm::EventSetup& ES) override;
+  void addPileups(const PileUpEventPrincipal&, const edm::EventSetup& ES) override;
+  void put(edm::Event &e,const edm::EventSetup& ES, std::vector<PileupSummaryInfo> const& ps, int bs) override;
+
+
+private:
+  edm::InputTag HBHEPileInputTag_; // InputTag for Pileup Digis collection  
+  edm::InputTag HOPileInputTag_  ; // InputTag for Pileup Digis collection
+  edm::InputTag HFPileInputTag_  ; // InputTag for Pileup Digis collection
+  edm::InputTag ZDCPileInputTag_ ; // InputTag for Pileup Digis collection
+  edm::InputTag QIE10PileInputTag_ ; // InputTag for Pileup Digis collection
+  edm::InputTag QIE11PileInputTag_ ; // InputTag for Pileup Digis collection
+  std::string HBHEDigiCollectionDM_; // secondary name to be given to collection of digis
+  std::string HODigiCollectionDM_  ; // secondary name to be given to collection of digis
+  std::string HFDigiCollectionDM_  ; // secondary name to be given to collection of digis
+  std::string ZDCDigiCollectionDM_ ; // secondary name to be given to collection of digis
+  std::string QIE10DigiCollectionDM_ ; // secondary name to be given to collection of digis
+  std::string QIE11DigiCollectionDM_ ; // secondary name to be given to collection of digis
+
+  edm::EDGetTokenT<HBHEDigitizerTraits::DigiCollection> tok_hbhe_;
+  edm::EDGetTokenT<HODigitizerTraits::DigiCollection> tok_ho_;
+  edm::EDGetTokenT<HFDigitizerTraits::DigiCollection> tok_hf_;
+  edm::EDGetTokenT<ZDCDigitizerTraits::DigiCollection> tok_zdc_;
+  edm::EDGetTokenT<HcalQIE10DigitizerTraits::DigiCollection> tok_qie10_;
+  edm::EDGetTokenT<HcalQIE11DigitizerTraits::DigiCollection> tok_qie11_;
+
+  HcalDigiProducer myHcalDigitizer_;
+  HBHESignalGenerator theHBHESignalGenerator;
+  HOSignalGenerator theHOSignalGenerator;
+  HFSignalGenerator theHFSignalGenerator;
+  ZDCSignalGenerator theZDCSignalGenerator;
+  QIE10SignalGenerator theQIE10SignalGenerator;
+  QIE11SignalGenerator theQIE11SignalGenerator;
+};
+
+// Constructor 
+PreMixingHcalWorker::PreMixingHcalWorker(const edm::ParameterSet& ps, edm::ProducerBase& producer, edm::ConsumesCollector&& iC): 
+  HBHEPileInputTag_(ps.getParameter<edm::InputTag>("HBHEPileInputTag")),
+  HOPileInputTag_(ps.getParameter<edm::InputTag>("HOPileInputTag")),
+  HFPileInputTag_(ps.getParameter<edm::InputTag>("HFPileInputTag")),
+  ZDCPileInputTag_(ps.getParameter<edm::InputTag>("ZDCPileInputTag")),
+  QIE10PileInputTag_(ps.getParameter<edm::InputTag>("QIE10PileInputTag")),
+  QIE11PileInputTag_(ps.getParameter<edm::InputTag>("QIE11PileInputTag")),
+  myHcalDigitizer_(ps, iC)
+{  
+  tok_hbhe_ = iC.consumes<HBHEDigitizerTraits::DigiCollection>(HBHEPileInputTag_);
+  tok_ho_ = iC.consumes<HODigitizerTraits::DigiCollection>(HOPileInputTag_);
+  tok_hf_ = iC.consumes<HFDigitizerTraits::DigiCollection>(HFPileInputTag_);
+  tok_zdc_ = iC.consumes<ZDCDigitizerTraits::DigiCollection>(ZDCPileInputTag_);
+  tok_qie10_ = iC.consumes<HcalQIE10DigitizerTraits::DigiCollection>(QIE10PileInputTag_);
+  tok_qie11_ = iC.consumes<HcalQIE11DigitizerTraits::DigiCollection>(QIE11PileInputTag_);
+
+  theHBHESignalGenerator = HBHESignalGenerator(HBHEPileInputTag_,tok_hbhe_);
+  theHOSignalGenerator = HOSignalGenerator(HOPileInputTag_,tok_ho_);
+  theHFSignalGenerator = HFSignalGenerator(HFPileInputTag_,tok_hf_);
+  theZDCSignalGenerator = ZDCSignalGenerator(ZDCPileInputTag_,tok_zdc_);
+  theQIE10SignalGenerator = QIE10SignalGenerator(QIE10PileInputTag_,tok_qie10_);
+  theQIE11SignalGenerator = QIE11SignalGenerator(QIE11PileInputTag_,tok_qie11_);
+
+  // Hcal 
+  // Signal inputs now handled by HcalDigitizer - gets pSimHits directly
+
+  HBHEDigiCollectionDM_ = ps.getParameter<std::string>("HBHEDigiCollectionDM");
+  HODigiCollectionDM_   = ps.getParameter<std::string>("HODigiCollectionDM");
+  HFDigiCollectionDM_   = ps.getParameter<std::string>("HFDigiCollectionDM");
+  ZDCDigiCollectionDM_  = ps.getParameter<std::string>("ZDCDigiCollectionDM");
+  QIE10DigiCollectionDM_  = ps.getParameter<std::string>("QIE10DigiCollectionDM");
+  QIE11DigiCollectionDM_  = ps.getParameter<std::string>("QIE11DigiCollectionDM");
+
+  producer.produces< HBHEDigiCollection >();
+  producer.produces< HODigiCollection >();
+  producer.produces< HFDigiCollection >();
+  producer.produces< ZDCDigiCollection >();
+
+  producer.produces<QIE10DigiCollection>("HFQIE10DigiCollection");
+  producer.produces<QIE11DigiCollection>("HBHEQIE11DigiCollection");
+
+  // initialize HcalDigitizer here...
+  myHcalDigitizer_.setHBHENoiseSignalGenerator( & theHBHESignalGenerator );
+  myHcalDigitizer_.setHFNoiseSignalGenerator( & theHFSignalGenerator );
+  myHcalDigitizer_.setHONoiseSignalGenerator( & theHOSignalGenerator );
+  myHcalDigitizer_.setZDCNoiseSignalGenerator( & theZDCSignalGenerator );
+  myHcalDigitizer_.setQIE10NoiseSignalGenerator( & theQIE10SignalGenerator );
+  myHcalDigitizer_.setQIE11NoiseSignalGenerator( & theQIE11SignalGenerator );
+
+}
+
+void PreMixingHcalWorker::beginRun(const edm::Run& run, const edm::EventSetup& ES) {
+  myHcalDigitizer_.beginRun(run, ES); 
+}
+
+void PreMixingHcalWorker::initializeEvent(const edm::Event &e, const edm::EventSetup& ES) {
+  myHcalDigitizer_.initializeEvent(e, ES); 
+}
+
+void PreMixingHcalWorker::addSignals(const edm::Event &e,const edm::EventSetup& ES) { 
+  myHcalDigitizer_.accumulate(e, ES);
+}
+
+void PreMixingHcalWorker::addPileups(const PileUpEventPrincipal& pep, const edm::EventSetup& ES) {
+  const auto& ep = pep.principal();
+  LogDebug("PreMixingHcalWorker") <<"\n===============> adding pileups from event  "<<ep.id()<<" for bunchcrossing "<<pep.bunchCrossing();
+
+  theHBHESignalGenerator.initializeEvent(&ep, &ES);
+  theHOSignalGenerator.initializeEvent(&ep, &ES);
+  theHFSignalGenerator.initializeEvent(&ep, &ES);
+  theZDCSignalGenerator.initializeEvent(&ep, &ES);
+  theQIE10SignalGenerator.initializeEvent(&ep, &ES);
+  theQIE11SignalGenerator.initializeEvent(&ep, &ES);
+
+  // put digis from pileup event into digitizer
+
+  const auto *mcc = pep.moduleCallingContext();
+  theHBHESignalGenerator.fill(mcc);
+  theHOSignalGenerator.fill(mcc);
+  theHFSignalGenerator.fill(mcc);
+  theQIE10SignalGenerator.fill(mcc);
+  theQIE11SignalGenerator.fill(mcc);
+}
+
+void PreMixingHcalWorker::put(edm::Event &e,const edm::EventSetup& ES, std::vector<PileupSummaryInfo> const& ps, int bs) {
+  myHcalDigitizer_.finalizeEvent( e, ES);
+}
+
+DEFINE_EDM_PLUGIN(PreMixingWorkerFactory, PreMixingHcalWorker, "PreMixingHcalWorker");

SimGeneral/MixingModule/interface/PileUpEventPrincipal.h

@@ -30,6 +30,10 @@ class PileUpEventPrincipal {
     return principal_;
   }
 
+  edm::ModuleCallingContext const *moduleCallingContext() const {
+    return mcc_;
+  }
+
   int bunchCrossing() const {
     return bunchCrossing_;
   }

SimGeneral/PreMixingModule/BuildFile.xml

@@ -0,0 +1,7 @@
+<use   name="FWCore/Framework"/>
+<use   name="FWCore/ParameterSet"/>
+<use   name="FWCore/PluginManager"/>
+<use   name="FWCore/ServiceRegistry"/>
+<export>
+  <lib   name="1"/>
+</export>

SimGeneral/PreMixingModule/interface/PreMixingDigiSimLinkWorker.h

@@ -0,0 +1,73 @@
+#ifndef SimGeneral_PremixingModule_PreMixingDigiSimLinkWorker_h
+#define SimGeneral_PremixingModule_PreMixingDigiSimLinkWorker_h
+
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventPrincipal.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
+#include "FWCore/Framework/interface/ProducerBase.h"
+#include "SimGeneral/MixingModule/interface/PileUpEventPrincipal.h"
+
+#include "DataFormats/Common/interface/Handle.h"
+
+#include "SimGeneral/PreMixingModule/interface/PreMixingWorker.h"
+
+template <typename DigiSimLinkCollection>
+class PreMixingDigiSimLinkWorker: public PreMixingWorker {
+public:
+  PreMixingDigiSimLinkWorker(const edm::ParameterSet& ps, edm::ProducerBase& producer, edm::ConsumesCollector&& iC);
+  ~PreMixingDigiSimLinkWorker() override = default;
+
+  void initializeEvent(edm::Event const& iEvent, edm::EventSetup const& iSetup) override {}
+  void addSignals(edm::Event const& iEvent, edm::EventSetup const& iSetup) override;
+  void addPileups(PileUpEventPrincipal const& pep, edm::EventSetup const& iSetup) override;
+  void put(edm::Event& iEvent, edm::EventSetup const& iSetup, std::vector<PileupSummaryInfo> const& ps, int bunchSpacing) override;
+
+private:
+  edm::EDGetTokenT<DigiSimLinkCollection> signalToken_;
+  edm::InputTag pileupTag_;
+  std::string collectionDM_; // secondary name to be given to new digis
+
+  std::unique_ptr<DigiSimLinkCollection> merged_;
+};
+
+template <typename DigiSimLinkCollection>
+PreMixingDigiSimLinkWorker<DigiSimLinkCollection>::PreMixingDigiSimLinkWorker(const edm::ParameterSet& ps, edm::ProducerBase& producer, edm::ConsumesCollector&& iC):
+  signalToken_(iC.consumes<DigiSimLinkCollection>(ps.getParameter<edm::InputTag>("labelSig"))),
+  pileupTag_(ps.getParameter<edm::InputTag>("pileInputTag")),
+  collectionDM_(ps.getParameter<std::string>("collectionDM"))
+{
+  producer.produces<DigiSimLinkCollection>(collectionDM_);
+}
+
+template <typename DigiSimLinkCollection>
+void PreMixingDigiSimLinkWorker<DigiSimLinkCollection>::addSignals(edm::Event const& iEvent, edm::EventSetup const& iSetup) {
+  edm::Handle<DigiSimLinkCollection> digis;
+  iEvent.getByToken(signalToken_, digis);
+
+  if(digis.isValid()) {
+    merged_ = std::make_unique<DigiSimLinkCollection>(*digis); // for signal we can just copy
+  }
+  else {
+    merged_ = std::make_unique<DigiSimLinkCollection>();
+  }
+}
+
+template <typename DigiSimLinkCollection>
+void PreMixingDigiSimLinkWorker<DigiSimLinkCollection>::addPileups(PileUpEventPrincipal const& pep, edm::EventSetup const& iSetup) {
+  edm::Handle<DigiSimLinkCollection> digis;
+  pep.getByLabel(pileupTag_, digis);
+  if(digis.isValid()) {
+    for(const auto& detsetSource: *digis) {
+      auto& detsetTarget = merged_->find_or_insert(detsetSource.detId());
+      std::copy(detsetSource.begin(), detsetSource.end(), std::back_inserter(detsetTarget));
+    }
+  }
+}
+
+template <typename DigiSimLinkCollection>
+void PreMixingDigiSimLinkWorker<DigiSimLinkCollection>::put(edm::Event& iEvent, edm::EventSetup const& iSetup, std::vector<PileupSummaryInfo> const& ps, int bunchSpacing) {
+  iEvent.put(std::move(merged_), collectionDM_);
+}
+
+#endif