Inheritance diagram for edm::PreMixingModule:

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

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

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

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

	~PreMixingModule () override=default

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)

virtual void	initializeEvent (const 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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

Private Member Functions
void	pileWorker (const edm::EventPrincipal &, int bcr, int EventId, const edm::EventSetup &ES, ModuleCallingContext const *)

Private Attributes
bool	addedPileup_ = false

PreMixingPileupCopy	puWorker_

std::vector< std::unique_ptr< PreMixingWorker > >	workers_

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

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	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 34 of file PreMixingModule.cc.

Constructor & Destructor Documentation

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

Definition at line 61 of file PreMixingModule.cc.

References popcon2dropbox::copy(), beamerCreator::create(), spr::find(), reco::get(), edm::ParameterSet::getParameter(), mps_fire::i, eostools::move(), dataset::name, cscdqm::h::names, muonDTDigis_cfi::pset, AlCaHLTBitMon_QueryRunRegistry::string, tmp, mixOne_premix_on_sim_cfi::workers, and workers_.

                                                                                                 :
     BMixingModule(ps, globalConf),
     puWorker_(ps.getParameter<edm::ParameterSet>("workers").getParameter<edm::ParameterSet>("pileup"), *this, consumesCollector())
   {  
     const auto& workers = ps.getParameter<edm::ParameterSet>("workers");
     std::vector<std::string> names = workers.getParameterNames();
 
     // Hack to keep the random number sequence unchanged for migration
     // from DataMixingModule to PreMixingModule. To be removed in a
     // subsequent PR doing only that.
     {
       std::vector<std::string> tmp;
       auto hack = [&](const std::string& name) {
         auto i = std::find(names.begin(), names.end(), name);
         if(i != names.end()) {
           tmp.push_back(*i);
           names.erase(i);
         }
       };
       hack("ecal");
       hack("hcal");
       hack("strip");
       hack("pixel");
       std::copy(names.begin(), names.end(), std::back_inserter(tmp));
       names = std::move(tmp);
     }
 
     for(const auto& name: names) {
       if(name == "pileup") {
         continue;
       }
       const auto& pset = workers.getParameter<edm::ParameterSet>(name);
       std::string type = pset.getParameter<std::string>("workerType");
       workers_.emplace_back(PreMixingWorkerFactory::get()->create(type, pset, *this, consumesCollector()));
     }
   }

edm::PreMixingModule::~PreMixingModule ( )

overridedefault

Member Function Documentation

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

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 120 of file PreMixingModule.cc.

References addedPileup_, edm::EventBase::id(), LogDebug, w, and workers_.

Referenced by createnewEDProduct().

                                                                              { 
     // fill in maps of hits
 
     LogDebug("PreMixingModule")<<"===============> adding MC signals for "<<e.id();
 
     for(auto& w: workers_) {
       w->addSignals(e, ES);
     }
 
     addedPileup_ = false; 
   }

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

override

Definition at line 220 of file PreMixingModule.cc.

References edm::BMixingModule::beginLuminosityBlock(), w, and workers_.

Referenced by createnewEDProduct().

                                                                                            {
     BMixingModule::beginLuminosityBlock(l1, c);
     for(auto& w: workers_) {
       w->beginLuminosityBlock(l1,c);
     }
   }

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

override

Definition at line 106 of file PreMixingModule.cc.

References edm::BMixingModule::beginRun(), w, and workers_.

Referenced by createnewEDProduct().

                                                                            { 
     BMixingModule::beginRun( run, ES);
     for(auto& w: workers_) {
       w->beginRun(run, ES);
     }
   }

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

inlineoverridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 40 of file PreMixingModule.cc.

40 {};

void edm::PreMixingModule::createnewEDProduct ( )

inlineoverridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 41 of file PreMixingModule.cc.

References addSignals(), beginLuminosityBlock(), beginRun(), EnergyCorrector::c, doPileUp(), MillePedeFileConverter_cfg::e, endLuminosityBlock(), endRun(), initializeEvent(), pileWorker(), put(), alignCSCRings::r, findQualityFiles::run, and GeneralSetup::setup().

41 {}

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

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 160 of file PreMixingModule.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(), edm::BMixingModule::TrueNumInteractions_, w, and workers_.

Referenced by createnewEDProduct().

   {
     using namespace std::placeholders;
 
     std::vector<edm::SecondaryEventIDAndFileInfo> recordEventID;
     std::vector<int> PileupList;
     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;
         }  
 
         for(auto& w: workers_) {
           w->initializeBunchCrossing(e, ES, bunchCrossing);
         }
 
         source->readPileUp(
                 e.id(),
                 recordEventID,
                 std::bind(&PreMixingModule::pileWorker, std::ref(*this),
               _1, bunchCrossing, _2, std::cref(ES), mcc),
         NumPU_Events,
                 e.streamID()
                );
 
         for(auto& w: workers_) {
           w->finalizeBunchCrossing(e, ES, bunchCrossing);
         }
       }
     }
   }

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

override

Definition at line 227 of file PreMixingModule.cc.

References DEFINE_FWK_MODULE, and edm::BMixingModule::endLuminosityBlock().

Referenced by createnewEDProduct().

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

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

override

Definition at line 113 of file PreMixingModule.cc.

References edm::BMixingModule::endRun(), w, and workers_.

Referenced by createnewEDProduct().

                                                                          { 
     for(auto& w: workers_) {
       w->endRun();
     }
     BMixingModule::endRun( run, ES);
   }

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

override

Definition at line 99 of file PreMixingModule.cc.

References w, and workers_.

Referenced by createnewEDProduct().

                                                                                   {
     for(auto& w: workers_) {
       w->initializeEvent(e, ES);
     }
   }

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

private

Definition at line 132 of file PreMixingModule.cc.

References addedPileup_, edm::PreMixingPileupCopy::addPileupInfo(), edm::EventPrincipal::id(), LogDebug, puWorker_, edm::BMixingModule::setupPileUpEvent(), w, and workers_.

Referenced by createnewEDProduct(), and doPileUp().

                                                                                                                                               {  
     InternalContext internalContext(ep.id(), mcc);
     ParentContext parentContext(&internalContext);
     ModuleCallingContext moduleCallingContext(&moduleDescription());
     ModuleContextSentry moduleContextSentry(&moduleCallingContext, parentContext);
 
     PileUpEventPrincipal pep(ep, &moduleCallingContext, bcr);
 
     LogDebug("PreMixingModule") <<"\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(!addedPileup_) {
       puWorker_.addPileupInfo(pep);
       addedPileup_ = true;
     }
 
     // fill in maps of hits; same code as addSignals, except now applied to the pileup events
 
     for(auto& w: workers_) {
       w->addPileups(pep, ES);
     }
   }

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

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 207 of file PreMixingModule.cc.

References edm::PreMixingPileupCopy::getBunchSpacing(), edm::PreMixingPileupCopy::getPileupSummaryInfo(), edm::PreMixingPileupCopy::putPileupInfo(), puWorker_, w, and workers_.

Referenced by createnewEDProduct().

                                                                {
     // individual workers...
     // move pileup first so we have access to the information for the put step
     const auto& ps = puWorker_.getPileupSummaryInfo();
     int bunchSpacing = puWorker_.getBunchSpacing();
 
     for(auto& w: workers_) {
       w->put(e, ES, ps, bunchSpacing);
     }
 
     puWorker_.putPileupInfo(e);
   }

Member Data Documentation

bool edm::PreMixingModule::addedPileup_ = false

private

Definition at line 56 of file PreMixingModule.cc.

Referenced by addSignals(), and pileWorker().

PreMixingPileupCopy edm::PreMixingModule::puWorker_

private

Definition at line 55 of file PreMixingModule.cc.

Referenced by pileWorker(), and put().

std::vector<std::unique_ptr<PreMixingWorker> > edm::PreMixingModule::workers_

private

Definition at line 58 of file PreMixingModule.cc.

Referenced by addSignals(), beginLuminosityBlock(), beginRun(), doPileUp(), endRun(), initializeEvent(), pileWorker(), PreMixingModule(), and put().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation