Inheritance diagram for edm::PreMixingModule:

Classes
class	AdjustPileupDistribution

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)

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
bool	pileWorker (const edm::EventPrincipal &, int bcr, int EventId, const edm::EventSetup &ES, ModuleCallingContext const , AdjustPileupDistribution const pileupAdjuster)

Private Attributes
bool	addedPileup_ = false

std::vector < AdjustPileupDistribution >	pileupAdjusters_

PreMixingPileupCopy	puWorker_

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

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 39 of file PreMixingModule.cc.

Constructor & Destructor Documentation

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

Definition at line 105 of file PreMixingModule.cc.

       : BMixingModule(ps, globalConf),
         puWorker_(ps.getParameter<edm::ParameterSet>("workers").getParameter<edm::ParameterSet>("pileup"),
                   producesCollector(),
                   consumesCollector()),
         pileupAdjusters_(
             edm::vector_transform(ps.getParameter<std::vector<edm::ParameterSet>>("adjustPileupDistribution"),
                                   [](const auto& ps) { return AdjustPileupDistribution(ps); })) {

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 171 of file PreMixingModule.cc.

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

                                                                              {
     // 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 305 of file PreMixingModule.cc.

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

                                                                                            {
     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 157 of file PreMixingModule.cc.

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

                                                                            {
     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 45 of file PreMixingModule.cc.

45 {};

void edm::PreMixingModule::createnewEDProduct ( )

inlineoverridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 46 of file PreMixingModule.cc.

46 {}

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

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 231 of file PreMixingModule.cc.

References Exception, edm::EventBase::id(), edm::BMixingModule::inputSources_, edm::BMixingModule::maxBunch_, edm::BMixingModule::maxNbSources_, edm::BMixingModule::minBunch_, edm::Event::moduleCallingContext(), pileupAdjusters_, pileWorker(), edm::EventID::run(), edm::source(), edm::Event::streamID(), edm::BMixingModule::TrueNumInteractions_, w(), and workers_.

                                                                      {
     using namespace std::placeholders;
 
     std::vector<edm::SecondaryEventIDAndFileInfo> recordEventID;
     std::vector<int> PileupList;
     TrueNumInteractions_.clear();
 
     ModuleCallingContext const* mcc = e.moduleCallingContext();
 
     AdjustPileupDistribution const* pileupAdjuster = nullptr;
     if (not pileupAdjusters_.empty()) {
       // Find the adjustment settings for the run of the signal event
       // the container should be small-enough to not really gain
       // anything with binary search
       auto it = std::find_if(pileupAdjusters_.rbegin(),
                              pileupAdjusters_.rend(),
                              [iRun = e.id().run()](const auto& elem) { return elem.firstRun() <= iRun; });
       if (it == pileupAdjusters_.rend()) {
         throw cms::Exception("LogicError") << "Encountered run " << e.id().run()
                                            << ", but the first run available in the pileup adjustment configuration is "
                                            << pileupAdjusters_.front().firstRun() << ". Please fix the configuration.";
       }
       pileupAdjuster = &*it;
     }
 
     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, pileupAdjuster),
             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 312 of file PreMixingModule.cc.

References edm::BMixingModule::endLuminosityBlock().

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

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

override

Definition at line 164 of file PreMixingModule.cc.

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

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

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

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 151 of file PreMixingModule.cc.

References w(), and workers_.

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

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

private

Definition at line 183 of file PreMixingModule.cc.

References addedPileup_, edm::PreMixingPileupCopy::addPileupInfo(), edm::RandomNumberGenerator::getEngine(), edm::PreMixingPileupCopy::getTrueNumInteractions(), edm::EventPrincipal::id(), LogDebug, edm::PreMixingModule::AdjustPileupDistribution::probability(), puWorker_, edm::BMixingModule::setupPileUpEvent(), edm::EventPrincipal::streamID(), w(), and workers_.

Referenced by doPileUp().

                                                                                    {
     InternalContext internalContext(ep.id(), mcc);
     ParentContext parentContext(&internalContext);
     ModuleCallingContext moduleCallingContext(&moduleDescription());
     ModuleContextSentry moduleContextSentry(&moduleCallingContext, parentContext);
 
     PileUpEventPrincipal pep(ep, &moduleCallingContext, bcr);
 
     if (pileupAdjuster) {
       float trueNumInteractions = puWorker_.getTrueNumInteractions(pep);
       double prob = pileupAdjuster->probability(static_cast<unsigned int>(trueNumInteractions));
       edm::Service<edm::RandomNumberGenerator> rng;
       CLHEP::HepRandomEngine& engine = rng->getEngine(ep.streamID());
       if (engine.flat() > prob) {
         // engine.flat() should give a double in ]0,1[ range
         // the choice above means that "prob = 1-ulp" is treatead as 1
         return false;
       }
     }
 
     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);
     }
 
     return true;
   }

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

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 292 of file PreMixingModule.cc.

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

                                                                 {
     // 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 99 of file PreMixingModule.cc.

Referenced by addSignals(), and pileWorker().

std::vector<AdjustPileupDistribution> edm::PreMixingModule::pileupAdjusters_

private

Definition at line 101 of file PreMixingModule.cc.

Referenced by doPileUp().

PreMixingPileupCopy edm::PreMixingModule::puWorker_

private

Definition at line 98 of file PreMixingModule.cc.

Referenced by pileWorker(), and put().

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

private

Definition at line 102 of file PreMixingModule.cc.

Referenced by addSignals(), beginLuminosityBlock(), beginRun(), doPileUp(), endRun(), edm::for(), initializeEvent(), pileWorker(), and put().

Classes

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation