#include <DataMixingModule.h>

Inheritance diagram for edm::DataMixingModule:

Public Member Functions
void	addSignals (const edm::Event &e, const edm::EventSetup &ES) override

void	beginLuminosityBlock (LuminosityBlock const &l1, EventSetup const &c) override

void	beginRun (edm::Run const &run, edm::EventSetup const &eventSetup) override

void	checkSignal (const edm::Event &e) override

void	createnewEDProduct () override

	DataMixingModule (const edm::ParameterSet &ps, MixingCache::Config const *globalConf)

void	doPileUp (edm::Event &e, const edm::EventSetup &ES) override

void	endLuminosityBlock (LuminosityBlock const &l1, EventSetup const &c) override

void	endRun (const edm::Run &r, const edm::EventSetup &setup) override

void	initializeEvent (edm::Event const &e, edm::EventSetup const &eventSetup) override

bool	pileWorker (const edm::EventPrincipal &, int bcr, int EventId, const edm::EventSetup &ES, ModuleCallingContext const *)

void	put (edm::Event &e, const edm::EventSetup &ES) override

	~DataMixingModule () override

Public Member Functions inherited from edm::BMixingModule
virtual void	addPileups (const int bcr, EventPrincipal *ep, unsigned int eventId, unsigned int worker, const edm::EventSetup &c)

double	averageNumber () const

void	beginLuminosityBlock (const edm::LuminosityBlock &l, const edm::EventSetup &setup) override

void	beginRun (const edm::Run &r, const edm::EventSetup &setup) override

	BMixingModule (const edm::ParameterSet &ps, MixingCache::Config const *globalConf)

void	endLuminosityBlock (const edm::LuminosityBlock &l, const edm::EventSetup &setup) override

void	endRun (const edm::Run &r, const edm::EventSetup &setup) override

virtual void	finalizeEvent (edm::Event &event, const edm::EventSetup &setup)

bool	poisson () const

void	produce (edm::Event &e1, const edm::EventSetup &c) override

virtual void	reload (const edm::EventSetup &setup)

virtual void	setBcrOffset ()

virtual void	setSourceOffset (const unsigned int s)

	~BMixingModule () override

Public Member Functions inherited from edm::stream::EDProducer< GlobalCache< MixingCache::Config > >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Member Functions
virtual void	getSubdetectorNames ()

Private Attributes
bool	AddedPileup_

std::string	CSCComparatorDigiCollectionDM_

std::string	CSCStripDigiCollectionDM_

std::string	CSCWireDigiCollectionDM_

std::string	DTDigiCollectionDM_

std::string	EBDigiCollectionDM_

edm::InputTag	EBPileInputTag_

std::string	EBRecHitCollectionDM_

std::string	EEDigiCollectionDM_

edm::InputTag	EEPileInputTag_

std::string	EERecHitCollectionDM_

DataMixingEMDigiWorker *	EMDigiWorker_

DataMixingEMWorker *	EMWorker_

std::string	ESDigiCollectionDM_

edm::InputTag	ESPileInputTag_

std::string	ESRecHitCollectionDM_

std::string	HBHEDigiCollectionDM_

edm::InputTag	HBHEPileInputTag_

std::string	HBHERecHitCollectionDM_

DataMixingHcalDigiWorker *	HcalDigiWorker_

DataMixingHcalDigiWorkerProd *	HcalDigiWorkerProd_

DataMixingHcalWorker *	HcalWorker_

std::string	HFDigiCollectionDM_

edm::InputTag	HFPileInputTag_

std::string	HFRecHitCollectionDM_

std::string	HODigiCollectionDM_

edm::InputTag	HOPileInputTag_

std::string	HORecHitCollectionDM_

std::string	label_

bool	MergeEMDigis_

bool	MergeHcalDigis_

bool	MergeHcalDigisProd_

bool	MergePileup_

bool	MergeTrackerDigis_

DataMixingMuonWorker *	MuonWorker_

std::string	PixelDigiCollectionDM_

DataMixingPileupCopy *	PUWorker_

std::string	QIE10DigiCollectionDM_

edm::InputTag	QIE10PileInputTag_

std::string	QIE11DigiCollectionDM_

edm::InputTag	QIE11PileInputTag_

std::string	RPCDigiCollectionDM_

DataMixingSiPixelWorker *	SiPixelWorker_

std::string	SiStripDigiCollectionDM_

std::string	siStripRawDigiSource_

DataMixingSiStripRawWorker *	SiStripRawWorker_

DataMixingSiStripWorker *	SiStripWorker_

std::vector< std::string >	Subdetectors_

edm::EDGetTokenT < HBHEDigitizerTraits::DigiCollection >	tok_hbhe_

edm::EDGetTokenT < HFDigitizerTraits::DigiCollection >	tok_hf_

edm::EDGetTokenT < HODigitizerTraits::DigiCollection >	tok_ho_

edm::EDGetTokenT < HcalQIE10DigitizerTraits::DigiCollection >	tok_qie10_

edm::EDGetTokenT < HcalQIE11DigitizerTraits::DigiCollection >	tok_qie11_

edm::EDGetTokenT < ZDCDigitizerTraits::DigiCollection >	tok_zdc_

const edm::ESGetToken < HcalDbService, HcalDbRecord >	tokDB_

bool	useSiStripRawDigi_

std::string	ZDCDigiCollectionDM_

edm::InputTag	ZDCPileInputTag_

std::string	ZDCRecHitCollectionDM_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< GlobalCache< MixingCache::Config > >
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Static Public Member Functions inherited from edm::BMixingModule
static void	globalEndJob (MixingCache::Config *)

static std::unique_ptr < MixingCache::Config >	initializeGlobalCache (edm::ParameterSet const &)

Protected Member Functions inherited from edm::BMixingModule
void	beginStream (edm::StreamID) override

void	dropUnwantedBranches (std::vector< std::string > const &wantedBranches)

void	endStream () override

void	setupPileUpEvent (const edm::EventSetup &setup)

void	update (edm::EventSetup const &)

Protected Attributes inherited from edm::BMixingModule
int	bunchSpace_

bool	checktof_

bool	doit_ [4]

unsigned int	eventId_

std::vector< std::shared_ptr < PileUp > >	inputSources_

int	maxBunch_

int	minBunch_

bool const	mixProdStep1_

bool const	mixProdStep2_

edm::ESWatcher< MixingRcd >	parameterWatcher_

bool	playback_

bool	readDB_

std::vector< float >	TrueNumInteractions_

int	vertexOffset_

Static Protected Attributes inherited from edm::BMixingModule
static const unsigned int	maxNbSources_ = 4

Detailed Description

Definition at line 45 of file DataMixingModule.h.

Constructor & Destructor Documentation

DataMixingModule::DataMixingModule	(	const edm::ParameterSet &	ps,
		MixingCache::Config const *	globalConf
	)

explicit

standard constructor

Definition at line 31 of file DataMixingModule.cc.

References CSCComparatorDigiCollectionDM_, CSCStripDigiCollectionDM_, CSCWireDigiCollectionDM_, DTDigiCollectionDM_, EBDigiCollectionDM_, EBRecHitCollectionDM_, EEDigiCollectionDM_, EERecHitCollectionDM_, EMDigiWorker_, EMWorker_, ESDigiCollectionDM_, ESRecHitCollectionDM_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), getSubdetectorNames(), HBHEDigiCollectionDM_, HBHEPileInputTag_, HBHERecHitCollectionDM_, HcalDigiWorker_, HcalDigiWorkerProd_, HcalWorker_, HFDigiCollectionDM_, HFPileInputTag_, HFRecHitCollectionDM_, HODigiCollectionDM_, HOPileInputTag_, HORecHitCollectionDM_, MergeEMDigis_, MergeHcalDigis_, MergeHcalDigisProd_, MergePileup_, MergeTrackerDigis_, MuonWorker_, PixelDigiCollectionDM_, PUWorker_, QIE10DigiCollectionDM_, QIE10PileInputTag_, QIE11DigiCollectionDM_, QIE11PileInputTag_, RPCDigiCollectionDM_, SiPixelWorker_, SiStripDigiCollectionDM_, SiStripRawWorker_, SiStripWorker_, AlCaHLTBitMon_QueryRunRegistry::string, tok_hbhe_, tok_hf_, tok_ho_, tok_qie10_, tok_qie11_, tok_zdc_, tokDB_, useSiStripRawDigi_, ZDCDigiCollectionDM_, ZDCPileInputTag_, and ZDCRecHitCollectionDM_.

       : BMixingModule(ps, globalConf),
         EBPileInputTag_(ps.getParameter<edm::InputTag>("EBPileInputTag")),
         EEPileInputTag_(ps.getParameter<edm::InputTag>("EEPileInputTag")),
         ESPileInputTag_(ps.getParameter<edm::InputTag>("ESPileInputTag")),
         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")),
         tokDB_(esConsumes<HcalDbService, HcalDbRecord>()),
         label_(ps.getParameter<std::string>("Label")) {
     // prepare for data access in DataMixingHcalDigiWorkerProd
     tok_hbhe_ = consumes<HBHEDigitizerTraits::DigiCollection>(HBHEPileInputTag_);
     tok_ho_ = consumes<HODigitizerTraits::DigiCollection>(HOPileInputTag_);
     tok_hf_ = consumes<HFDigitizerTraits::DigiCollection>(HFPileInputTag_);
     tok_zdc_ = consumes<ZDCDigitizerTraits::DigiCollection>(ZDCPileInputTag_);
     tok_qie10_ = consumes<HcalQIE10DigitizerTraits::DigiCollection>(QIE10PileInputTag_);
     tok_qie11_ = consumes<HcalQIE11DigitizerTraits::DigiCollection>(QIE11PileInputTag_);
 
     // get the subdetector names
     this->getSubdetectorNames();  // something like this may be useful to check
                                   // what we are supposed to do...
 
     // For now, list all of them here.  Later, make this selectable with input
     // parameters
     //
 
     // Check to see if we are working in Full or Fast Simulation
 
     MergeTrackerDigis_ = (ps.getParameter<std::string>("TrackerMergeType")) == "Digis";
     MergeEMDigis_ = (ps.getParameter<std::string>("EcalMergeType")) == "Digis";
     MergeHcalDigis_ = (ps.getParameter<std::string>("HcalMergeType")) == "Digis";
     if (MergeHcalDigis_)
       MergeHcalDigisProd_ = (ps.getParameter<std::string>("HcalDigiMerge") == "FullProd");
 
     // Put Fast Sim Sequences here for Simplification: Fewer options!
 
     if (MergeEMDigis_) {
       // cout<<"EM Digis TRUE!!!"<<endl;
 
       EBDigiCollectionDM_ = ps.getParameter<std::string>("EBDigiCollectionDM");
       EEDigiCollectionDM_ = ps.getParameter<std::string>("EEDigiCollectionDM");
       ESDigiCollectionDM_ = ps.getParameter<std::string>("ESDigiCollectionDM");
       //   nMaxPrintout_            =
       //   ps.getUntrackedParameter<int>("nMaxPrintout",10);
 
       produces<EBDigiCollection>(EBDigiCollectionDM_);
       produces<EEDigiCollection>(EEDigiCollectionDM_);
       produces<ESDigiCollection>(ESDigiCollectionDM_);
 
       EMDigiWorker_ = new DataMixingEMDigiWorker(ps, consumesCollector());
     } else {  // merge RecHits
       EBRecHitCollectionDM_ = ps.getParameter<std::string>("EBRecHitCollectionDM");
       EERecHitCollectionDM_ = ps.getParameter<std::string>("EERecHitCollectionDM");
       ESRecHitCollectionDM_ = ps.getParameter<std::string>("ESRecHitCollectionDM");
       //   nMaxPrintout_            =
       //   ps.getUntrackedParameter<int>("nMaxPrintout",10);
 
       produces<EBRecHitCollection>(EBRecHitCollectionDM_);
       produces<EERecHitCollection>(EERecHitCollectionDM_);
       produces<ESRecHitCollection>(ESRecHitCollectionDM_);
 
       EMWorker_ = new DataMixingEMWorker(ps, consumesCollector());
     }
     // Hcal next
 
     if (MergeHcalDigis_) {
       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");
 
       produces<HBHEDigiCollection>();
       produces<HODigiCollection>();
       produces<HFDigiCollection>();
       produces<ZDCDigiCollection>();
 
       produces<QIE10DigiCollection>("HFQIE10DigiCollection");
       produces<QIE11DigiCollection>("HBHEQIE11DigiCollection");
 
       if (ps.getParameter<bool>("debugCaloSamples")) {
         produces<CaloSamplesCollection>("HcalSamples");
       }
       if (ps.getParameter<bool>("injectTestHits")) {
         produces<edm::PCaloHitContainer>("HcalHits");
       }
 
       if (MergeHcalDigisProd_)
         HcalDigiWorkerProd_ = new DataMixingHcalDigiWorkerProd(ps, consumesCollector(), tokDB_);
       else
         HcalDigiWorker_ = new DataMixingHcalDigiWorker(ps, consumesCollector());
 
     } else {
       HBHERecHitCollectionDM_ = ps.getParameter<std::string>("HBHERecHitCollectionDM");
       HORecHitCollectionDM_ = ps.getParameter<std::string>("HORecHitCollectionDM");
       HFRecHitCollectionDM_ = ps.getParameter<std::string>("HFRecHitCollectionDM");
       ZDCRecHitCollectionDM_ = ps.getParameter<std::string>("ZDCRecHitCollectionDM");
 
       produces<HBHERecHitCollection>(HBHERecHitCollectionDM_);
       produces<HORecHitCollection>(HORecHitCollectionDM_);
       produces<HFRecHitCollection>(HFRecHitCollectionDM_);
       produces<ZDCRecHitCollection>(ZDCRecHitCollectionDM_);
 
       HcalWorker_ = new DataMixingHcalWorker(ps, consumesCollector());
     }
 
     // Muons
 
     DTDigiCollectionDM_ = ps.getParameter<std::string>("DTDigiCollectionDM");
     RPCDigiCollectionDM_ = ps.getParameter<std::string>("RPCDigiCollectionDM");
     CSCStripDigiCollectionDM_ = ps.getParameter<std::string>("CSCStripDigiCollectionDM");
     CSCWireDigiCollectionDM_ = ps.getParameter<std::string>("CSCWireDigiCollectionDM");
     CSCComparatorDigiCollectionDM_ = ps.getParameter<std::string>("CSCComparatorDigiCollectionDM");
 
     produces<DTDigiCollection>();
     produces<RPCDigiCollection>();
     produces<CSCStripDigiCollection>(CSCStripDigiCollectionDM_);
     produces<CSCWireDigiCollection>(CSCWireDigiCollectionDM_);
     produces<CSCComparatorDigiCollection>(CSCComparatorDigiCollectionDM_);
 
     MuonWorker_ = new DataMixingMuonWorker(ps, consumesCollector());
 
     // Si-Strips
 
     useSiStripRawDigi_ = ps.exists("SiStripRawDigiSource")
                              ? ps.getParameter<std::string>("SiStripRawDigiSource") == "PILEUP" ||
                                    ps.getParameter<std::string>("SiStripRawDigiSource") == "SIGNAL"
                              : false;
 
     SiStripDigiCollectionDM_ = ps.getParameter<std::string>("SiStripDigiCollectionDM");
 
     if (useSiStripRawDigi_) {
       produces<edm::DetSetVector<SiStripRawDigi>>(SiStripDigiCollectionDM_);
       SiStripRawWorker_ = new DataMixingSiStripRawWorker(ps, consumesCollector());
 
     } else {
       produces<edm::DetSetVector<SiStripDigi>>(SiStripDigiCollectionDM_);
 
       SiStripWorker_ = new DataMixingSiStripWorker(ps, consumesCollector());
     }
 
     // Pixels
 
     PixelDigiCollectionDM_ = ps.getParameter<std::string>("PixelDigiCollectionDM");
 
     produces<edm::DetSetVector<PixelDigi>>(PixelDigiCollectionDM_);
 
     SiPixelWorker_ = new DataMixingSiPixelWorker(ps, consumesCollector());
 
     // Pileup Information: if doing pre-mixing, we have to save the pileup
     // information from the Secondary stream
 
     MergePileup_ = ps.getParameter<bool>("MergePileupInfo");
 
     if (MergePileup_) {
       produces<std::vector<PileupSummaryInfo>>();
       produces<int>("bunchSpacing");
       produces<CrossingFramePlaybackInfoNew>();
 
       std::vector<edm::InputTag> GenPUProtonsInputTags;
       GenPUProtonsInputTags = ps.getParameter<std::vector<edm::InputTag>>("GenPUProtonsInputTags");
       for (std::vector<edm::InputTag>::const_iterator it_InputTag = GenPUProtonsInputTags.begin();
            it_InputTag != GenPUProtonsInputTags.end();
            ++it_InputTag)
         produces<std::vector<reco::GenParticle>>(it_InputTag->label());
 
       PUWorker_ = new DataMixingPileupCopy(ps, consumesCollector());
     }
   }

DataMixingModule::~DataMixingModule ( )

override

Default destructor

Definition at line 254 of file DataMixingModule.cc.

References EMDigiWorker_, EMWorker_, HcalDigiWorker_, HcalDigiWorkerProd_, HcalWorker_, MergeEMDigis_, MergeHcalDigis_, MergeHcalDigisProd_, MergePileup_, MuonWorker_, PUWorker_, SiPixelWorker_, SiStripRawWorker_, SiStripWorker_, and useSiStripRawDigi_.

                                       {
     if (MergeEMDigis_) {
       delete EMDigiWorker_;
     } else {
       delete EMWorker_;
     }
     if (MergeHcalDigis_) {
       if (MergeHcalDigisProd_) {
         delete HcalDigiWorkerProd_;
       } else {
         delete HcalDigiWorker_;
       }
     } else {
       delete HcalWorker_;
     }
     if (MuonWorker_)
       delete MuonWorker_;
     if (useSiStripRawDigi_)
       delete SiStripRawWorker_;
     else
       delete SiStripWorker_;
     delete SiPixelWorker_;
     if (MergePileup_) {
       delete PUWorker_;
     }
   }

Member Function Documentation

void DataMixingModule::addSignals	(	const edm::Event &	e,
		const edm::EventSetup &	ES
	)

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 281 of file DataMixingModule.cc.

                                                                               {
     // fill in maps of hits
 
     LogDebug("DataMixingModule") << "===============> adding MC signals for " << e.id();
 
     // Ecal
     if (MergeEMDigis_) {
       EMDigiWorker_->addEMSignals(e, ES);
     } else {
       EMWorker_->addEMSignals(e);
     }
 
     // Hcal
     if (MergeHcalDigis_) {
       if (MergeHcalDigisProd_) {
         HcalDigiWorkerProd_->addHcalSignals(e, ES);
       } else {
         HcalDigiWorker_->addHcalSignals(e, ES);
       }
     } else {
       HcalWorker_->addHcalSignals(e);
     }
 
     // Muon
     MuonWorker_->addMuonSignals(e);
 
     // SiStrips
     if (useSiStripRawDigi_)
       SiStripRawWorker_->addSiStripSignals(e);
     else
       SiStripWorker_->addSiStripSignals(e);
 
     // SiPixels
     SiPixelWorker_->addSiPixelSignals(e);
     AddedPileup_ = false;
   }  // end of addSignals

void DataMixingModule::beginLuminosityBlock	(	LuminosityBlock const &	l1,
		EventSetup const &	c
	)

override

Definition at line 462 of file DataMixingModule.cc.

References edm::BMixingModule::beginLuminosityBlock().

                                                                                             {
     BMixingModule::beginLuminosityBlock(l1, c);
   }

void DataMixingModule::beginRun	(	edm::Run const &	run,
		edm::EventSetup const &	eventSetup
	)

override

Definition at line 249 of file DataMixingModule.cc.

References edm::BMixingModule::beginRun().

249 { BMixingModule::beginRun(run, ES); }

edm::BMixingModule::beginRun

void beginRun(const edm::Run &r, const edm::EventSetup &setup) override

Definition: BMixingModule.cc:244

submitPVValidationJobs.run

tuple run

Definition: submitPVValidationJobs.py:227

void edm::DataMixingModule::checkSignal ( const edm::Event & e )

inlineoverridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 54 of file DataMixingModule.h.

54 {};

void edm::DataMixingModule::createnewEDProduct ( )

inlineoverridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 55 of file DataMixingModule.h.

55 {}

void DataMixingModule::doPileUp	(	edm::Event &	e,
		const edm::EventSetup &	ES
	)

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 381 of file DataMixingModule.cc.

References edm::EventBase::id(), edm::BMixingModule::inputSources_, edm::BMixingModule::maxBunch_, edm::BMixingModule::maxNbSources_, edm::BMixingModule::minBunch_, edm::Event::moduleCallingContext(), pileWorker(), edm::source(), edm::Event::streamID(), and edm::BMixingModule::TrueNumInteractions_.

                                                                       {
     using namespace std::placeholders;
 
     std::vector<edm::SecondaryEventIDAndFileInfo> recordEventID;
     std::vector<int> PileupList;
     PileupList.clear();
     TrueNumInteractions_.clear();
 
     ModuleCallingContext const *mcc = e.moduleCallingContext();
 
     for (int bunchCrossing = minBunch_; bunchCrossing <= maxBunch_; ++bunchCrossing) {
       for (unsigned int isource = 0; isource < maxNbSources_; ++isource) {
         std::shared_ptr<PileUp> source = inputSources_[isource];
         if (!source || !(source->doPileUp(bunchCrossing)))
           continue;
 
         if (isource == 0)
           source->CalculatePileup(minBunch_, maxBunch_, PileupList, TrueNumInteractions_, e.streamID());
 
         int NumPU_Events = 0;
         if (isource == 0) {
           NumPU_Events = PileupList[bunchCrossing - minBunch_];
         } else {
           // non-minbias pileup only gets one event for now. Fix later if desired.
           NumPU_Events = 1;
         }
 
         source->readPileUp(
             e.id(),
             recordEventID,
             std::bind(&DataMixingModule::pileWorker, std::ref(*this), _1, bunchCrossing, _2, std::cref(ES), mcc),
             NumPU_Events,
             e.streamID());
       }
     }
   }

void DataMixingModule::endLuminosityBlock	(	LuminosityBlock const &	l1,
		EventSetup const &	c
	)

override

Definition at line 466 of file DataMixingModule.cc.

References edm::BMixingModule::endLuminosityBlock().

                                                                                           {
     BMixingModule::endLuminosityBlock(l1, c);
   }

void DataMixingModule::endRun	(	const edm::Run &	r,
		const edm::EventSetup &	setup
	)

override

Definition at line 251 of file DataMixingModule.cc.

References edm::BMixingModule::endRun().

251 { BMixingModule::endRun(run, ES); }

edm::BMixingModule::endRun

void endRun(const edm::Run &r, const edm::EventSetup &setup) override

Definition: BMixingModule.cc:258

submitPVValidationJobs.run

tuple run

Definition: submitPVValidationJobs.py:227

void DataMixingModule::getSubdetectorNames ( )

privatevirtual

Definition at line 205 of file DataMixingModule.cc.

Referenced by DataMixingModule().

                                              {
     // get subdetector names
     // edm::Service<edm::ConstProductRegistry> reg;
     // Loop over provenance of products in registry.
     // for (edm::ProductRegistry::ProductList::const_iterator it =
     // reg->productList().begin(); it != reg->productList().end(); ++it) {
 
     //  **** Check this out.... ****
 
     // See FWCore/Framework/interface/BranchDescription.h
     // BranchDescription contains all the information for the product.
 
     // This section not very backwards-compatible in terms of digi-merging.  Need
     // to be able to specify here which data format to look at...
 
     //      edm::BranchDescription desc = it->second;
     // if (!desc.friendlyClassName_.compare(0,9,"EBRecHitC")) {
     //  Subdetectors_.push_back(desc.productInstanceName_);
     // LogInfo("DataMixingModule") <<"Adding container
     // "<<desc.productInstanceName_ <<" for pileup treatment";
     //}
     // else if (!desc.friendlyClassName_.compare(0,9,"EERecHitC")) {
     //      else if (!desc.friendlyClassName_.compare(0,9,"EErechitC") &&
     //      desc.productInstanceName_.compare(0,11,"TrackerHits")) {
     //  Subdetectors_.push_back(desc.productInstanceName_);
     // LogInfo("DataMixingModule") <<"Adding container
     // "<<desc.productInstanceName_ <<" for pileup treatment";
     //}
     // else if (!desc.friendlyClassName_.compare(0,9,"HBRecHitC")) {
     //  Subdetectors_.push_back(desc.productInstanceName_);
     // LogInfo("DataMixingModule") <<"Adding container
     // "<<desc.productInstanceName_ <<" for pileup treatment";
     //}
     // else if (!desc.friendlyClassName_.compare(0,9,"HERecHitC")) {
     //  Subdetectors_.push_back(desc.productInstanceName_);
     // LogInfo("DataMixingModule") <<"Adding container
     // "<<desc.productInstanceName_ <<" for pileup treatment";
     // }
     // and so on with other detector types...
     // }
   }

void DataMixingModule::initializeEvent	(	edm::Event const &	e,
		edm::EventSetup const &	eventSetup
	)

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 247 of file DataMixingModule.cc.

247 {}

bool DataMixingModule::pileWorker	(	const edm::EventPrincipal &	ep,
		int	bcr,
		int	EventId,
		const edm::EventSetup &	ES,
		edm::ModuleCallingContext const *	mcc
	)

Definition at line 318 of file DataMixingModule.cc.

Referenced by doPileUp().

                                                                                                                    {
     InternalContext internalContext(ep.id(), mcc);
     ParentContext parentContext(&internalContext);
     ModuleCallingContext moduleCallingContext(&moduleDescription());
     ModuleContextSentry moduleContextSentry(&moduleCallingContext, parentContext);
 
     LogDebug("DataMixingModule") << "\n===============> adding pileups from event  " << ep.id() << " for bunchcrossing "
                                  << bcr;
 
     // Note:  setupPileUpEvent may modify the run and lumi numbers of the
     // EventPrincipal to match that of the primary event.
     setupPileUpEvent(ES);
 
     // check and see if we need to copy the pileup information from
     // secondary stream to the output stream
     // We only have the pileup event here, so pick the first time and store the
     // info
 
     if (MergePileup_ && !AddedPileup_) {
       PUWorker_->addPileupInfo(&ep, eventNr, &moduleCallingContext);
 
       AddedPileup_ = true;
     }
 
     // fill in maps of hits; same code as addSignals, except now applied to the
     // pileup events
 
     // Ecal
     if (MergeEMDigis_) {
       EMDigiWorker_->addEMPileups(bcr, &ep, eventNr, ES, &moduleCallingContext);
     } else {
       EMWorker_->addEMPileups(bcr, &ep, eventNr, &moduleCallingContext);
     }
 
     // Hcal
     if (MergeHcalDigis_) {
       if (MergeHcalDigisProd_) {
         HcalDigiWorkerProd_->addHcalPileups(bcr, &ep, eventNr, ES, &moduleCallingContext);
       } else {
         HcalDigiWorker_->addHcalPileups(bcr, &ep, eventNr, ES, &moduleCallingContext);
       }
     } else {
       HcalWorker_->addHcalPileups(bcr, &ep, eventNr, &moduleCallingContext);
     }
 
     // Muon
     MuonWorker_->addMuonPileups(bcr, &ep, eventNr, &moduleCallingContext);
 
     // SiStrips
     if (useSiStripRawDigi_)
       SiStripRawWorker_->addSiStripPileups(bcr, &ep, eventNr, &moduleCallingContext);
     else
       SiStripWorker_->addSiStripPileups(bcr, &ep, eventNr, &moduleCallingContext);
 
     // SiPixels
     // whoops this should be for the MC worker ?????
     // SiPixelWorker_->setPileupInfo(ps,bunchSpacing);
     SiPixelWorker_->addSiPixelPileups(bcr, &ep, eventNr, &moduleCallingContext);
 
     return true;
   }

void DataMixingModule::put	(	edm::Event &	e,
		const edm::EventSetup &	ES
	)

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 418 of file DataMixingModule.cc.

References EMDigiWorker_, EMWorker_, edm::DataMixingPileupCopy::getPileupInfo(), HcalDigiWorker_, HcalDigiWorkerProd_, HcalWorker_, MergeEMDigis_, MergeHcalDigis_, MergeHcalDigisProd_, MergePileup_, MuonWorker_, edm::DataMixingEMWorker::putEM(), edm::DataMixingEMDigiWorker::putEM(), edm::DataMixingHcalWorker::putHcal(), edm::DataMixingHcalDigiWorker::putHcal(), edm::DataMixingHcalDigiWorkerProd::putHcal(), edm::DataMixingMuonWorker::putMuon(), edm::DataMixingPileupCopy::putPileupInfo(), edm::DataMixingSiPixelWorker::putSiPixel(), edm::DataMixingSiStripWorker::putSiStrip(), edm::DataMixingSiStripRawWorker::putSiStrip(), PUWorker_, SiPixelWorker_, SiStripRawWorker_, SiStripWorker_, and useSiStripRawDigi_.

                                                                  {
     // individual workers...
 
     // move pileup first so we have access to the information for the put step
 
     std::vector<PileupSummaryInfo> ps;
     int bunchSpacing = 10000;
 
     if (MergePileup_) {
       PUWorker_->getPileupInfo(ps, bunchSpacing);
       PUWorker_->putPileupInfo(e);
     }
 
     // Ecal
     if (MergeEMDigis_) {
       EMDigiWorker_->putEM(e, ES);
     } else {
       EMWorker_->putEM(e);
     }
 
     // Hcal
     if (MergeHcalDigis_) {
       if (MergeHcalDigisProd_) {
         HcalDigiWorkerProd_->putHcal(e, ES);
       } else {
         HcalDigiWorker_->putHcal(e, ES);
       }
     } else {
       HcalWorker_->putHcal(e);
     }
 
     // Muon
     MuonWorker_->putMuon(e);
 
     // SiStrips
     if (useSiStripRawDigi_)
       SiStripRawWorker_->putSiStrip(e);
     else
       SiStripWorker_->putSiStrip(e);
 
     // SiPixels
     SiPixelWorker_->putSiPixel(e);
   }

Member Data Documentation

bool edm::DataMixingModule::AddedPileup_

private

Definition at line 173 of file DataMixingModule.h.

Referenced by addSignals(), and pileWorker().

std::string edm::DataMixingModule::CSCComparatorDigiCollectionDM_

private

Definition at line 124 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::CSCStripDigiCollectionDM_

private

Definition at line 120 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::CSCWireDigiCollectionDM_

private

Definition at line 122 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::DTDigiCollectionDM_

private

Definition at line 118 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::EBDigiCollectionDM_

private

Definition at line 83 of file DataMixingModule.h.

Referenced by DataMixingModule().

edm::InputTag edm::DataMixingModule::EBPileInputTag_

private

Definition at line 151 of file DataMixingModule.h.

std::string edm::DataMixingModule::EBRecHitCollectionDM_

private

Definition at line 75 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::EEDigiCollectionDM_

private

Definition at line 85 of file DataMixingModule.h.

Referenced by DataMixingModule().

edm::InputTag edm::DataMixingModule::EEPileInputTag_

private

Definition at line 152 of file DataMixingModule.h.

std::string edm::DataMixingModule::EERecHitCollectionDM_

private

Definition at line 77 of file DataMixingModule.h.

Referenced by DataMixingModule().

DataMixingEMDigiWorker* edm::DataMixingModule::EMDigiWorker_

private

Definition at line 141 of file DataMixingModule.h.

Referenced by addSignals(), DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

DataMixingEMWorker* edm::DataMixingModule::EMWorker_

private

Definition at line 140 of file DataMixingModule.h.

Referenced by addSignals(), DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

std::string edm::DataMixingModule::ESDigiCollectionDM_

private

Definition at line 87 of file DataMixingModule.h.

Referenced by DataMixingModule().

edm::InputTag edm::DataMixingModule::ESPileInputTag_

private

Definition at line 153 of file DataMixingModule.h.

std::string edm::DataMixingModule::ESRecHitCollectionDM_

private

Definition at line 79 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::HBHEDigiCollectionDM_

private

Definition at line 103 of file DataMixingModule.h.

Referenced by DataMixingModule().

edm::InputTag edm::DataMixingModule::HBHEPileInputTag_

private

Definition at line 154 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::HBHERecHitCollectionDM_

private

Definition at line 93 of file DataMixingModule.h.

Referenced by DataMixingModule().

DataMixingHcalDigiWorker* edm::DataMixingModule::HcalDigiWorker_

private

Definition at line 147 of file DataMixingModule.h.

Referenced by addSignals(), DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

DataMixingHcalDigiWorkerProd* edm::DataMixingModule::HcalDigiWorkerProd_

private

Definition at line 148 of file DataMixingModule.h.

Referenced by addSignals(), DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

DataMixingHcalWorker* edm::DataMixingModule::HcalWorker_

private

Definition at line 146 of file DataMixingModule.h.

Referenced by addSignals(), DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

std::string edm::DataMixingModule::HFDigiCollectionDM_

private

Definition at line 107 of file DataMixingModule.h.

Referenced by DataMixingModule().

edm::InputTag edm::DataMixingModule::HFPileInputTag_

private

Definition at line 156 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::HFRecHitCollectionDM_

private

Definition at line 97 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::HODigiCollectionDM_

private

Definition at line 105 of file DataMixingModule.h.

Referenced by DataMixingModule().

edm::InputTag edm::DataMixingModule::HOPileInputTag_

private

Definition at line 155 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::HORecHitCollectionDM_

private

Definition at line 95 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::label_

private

Definition at line 197 of file DataMixingModule.h.

Referenced by SequenceTypes.DummyModule::__repr__(), Mixins._Labelable::_findDependencies(), and Mixins._Labelable::setLabel().

bool edm::DataMixingModule::MergeEMDigis_

private

Definition at line 142 of file DataMixingModule.h.

Referenced by addSignals(), DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

bool edm::DataMixingModule::MergeHcalDigis_

private

Definition at line 169 of file DataMixingModule.h.

Referenced by addSignals(), DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

bool edm::DataMixingModule::MergeHcalDigisProd_

private

Definition at line 170 of file DataMixingModule.h.

Referenced by addSignals(), DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

bool edm::DataMixingModule::MergePileup_

private

Definition at line 172 of file DataMixingModule.h.

Referenced by DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

bool edm::DataMixingModule::MergeTrackerDigis_

private

Definition at line 134 of file DataMixingModule.h.

Referenced by DataMixingModule().

DataMixingMuonWorker* edm::DataMixingModule::MuonWorker_

private

Definition at line 177 of file DataMixingModule.h.

Referenced by addSignals(), DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

std::string edm::DataMixingModule::PixelDigiCollectionDM_

private

Definition at line 131 of file DataMixingModule.h.

Referenced by DataMixingModule().

DataMixingPileupCopy* edm::DataMixingModule::PUWorker_

private

Definition at line 138 of file DataMixingModule.h.

Referenced by DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

std::string edm::DataMixingModule::QIE10DigiCollectionDM_

private

Definition at line 111 of file DataMixingModule.h.

Referenced by DataMixingModule().

edm::InputTag edm::DataMixingModule::QIE10PileInputTag_

private

Definition at line 158 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::QIE11DigiCollectionDM_

private

Definition at line 113 of file DataMixingModule.h.

Referenced by DataMixingModule().

edm::InputTag edm::DataMixingModule::QIE11PileInputTag_

private

Definition at line 159 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::RPCDigiCollectionDM_

private

Definition at line 119 of file DataMixingModule.h.

Referenced by DataMixingModule().

DataMixingSiPixelWorker* edm::DataMixingModule::SiPixelWorker_

private

Definition at line 188 of file DataMixingModule.h.

Referenced by addSignals(), DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

std::string edm::DataMixingModule::SiStripDigiCollectionDM_

private

Definition at line 127 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::siStripRawDigiSource_

private

Definition at line 184 of file DataMixingModule.h.

DataMixingSiStripRawWorker* edm::DataMixingModule::SiStripRawWorker_

private

Definition at line 182 of file DataMixingModule.h.

Referenced by addSignals(), DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

DataMixingSiStripWorker* edm::DataMixingModule::SiStripWorker_

private

Definition at line 181 of file DataMixingModule.h.

Referenced by addSignals(), DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

std::vector<std::string> edm::DataMixingModule::Subdetectors_

private

Definition at line 193 of file DataMixingModule.h.

edm::EDGetTokenT<HBHEDigitizerTraits::DigiCollection> edm::DataMixingModule::tok_hbhe_

private

Definition at line 160 of file DataMixingModule.h.

Referenced by DataMixingModule().

edm::EDGetTokenT<HFDigitizerTraits::DigiCollection> edm::DataMixingModule::tok_hf_

private

Definition at line 162 of file DataMixingModule.h.

Referenced by DataMixingModule().

edm::EDGetTokenT<HODigitizerTraits::DigiCollection> edm::DataMixingModule::tok_ho_

private

Definition at line 161 of file DataMixingModule.h.

Referenced by DataMixingModule().

edm::EDGetTokenT<HcalQIE10DigitizerTraits::DigiCollection> edm::DataMixingModule::tok_qie10_

private

Definition at line 164 of file DataMixingModule.h.

Referenced by DataMixingModule().

edm::EDGetTokenT<HcalQIE11DigitizerTraits::DigiCollection> edm::DataMixingModule::tok_qie11_

private

Definition at line 165 of file DataMixingModule.h.

Referenced by DataMixingModule().

edm::EDGetTokenT<ZDCDigitizerTraits::DigiCollection> edm::DataMixingModule::tok_zdc_

private

Definition at line 163 of file DataMixingModule.h.

Referenced by DataMixingModule().

const edm::ESGetToken<HcalDbService, HcalDbRecord> edm::DataMixingModule::tokDB_

private

Definition at line 167 of file DataMixingModule.h.

Referenced by DataMixingModule().

bool edm::DataMixingModule::useSiStripRawDigi_

private

Definition at line 183 of file DataMixingModule.h.

Referenced by addSignals(), DataMixingModule(), pileWorker(), put(), and ~DataMixingModule().

std::string edm::DataMixingModule::ZDCDigiCollectionDM_

private

Definition at line 109 of file DataMixingModule.h.

Referenced by DataMixingModule().

edm::InputTag edm::DataMixingModule::ZDCPileInputTag_

private

Definition at line 157 of file DataMixingModule.h.

Referenced by DataMixingModule().

std::string edm::DataMixingModule::ZDCRecHitCollectionDM_

private

Definition at line 99 of file DataMixingModule.h.

Referenced by DataMixingModule().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation