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)

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

Constructor & Destructor Documentation

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

Definition at line 98 of file PreMixingModule.cc.

References a, b, popcon2dropbox::copy(), beamerCreator::create(), spr::find(), reco::get(), mps_fire::i, eostools::move(), dataset::name, names, pileupAdjusters_, muonDTDigis_cfi::pset, jetUpdater_cfi::sort, 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()),
     pileupAdjusters_(edm::vector_transform(ps.getParameter<std::vector<edm::ParameterSet> >("adjustPileupDistribution"),
                                            [](const auto& ps) { return AdjustPileupDistribution(ps); }))
   {  
     std::sort(pileupAdjusters_.begin(), pileupAdjusters_.end(),
               [](const auto& a, const auto& b) {
                 return a.firstRun() < b.firstRun();
               });
 
     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 164 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 296 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 150 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 46 of file PreMixingModule.cc.

46 {};

void edm::PreMixingModule::createnewEDProduct ( )

inlineoverridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 47 of file PreMixingModule.cc.

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

47 {}

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

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 220 of file PreMixingModule.cc.

References HTMLExport::elem(), 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_.

Referenced by createnewEDProduct().

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

References w, and workers_.

Referenced by createnewEDProduct().

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

References addedPileup_, edm::PreMixingPileupCopy::addPileupInfo(), edm::RandomNumberGenerator::getEngine(), edm::PreMixingPileupCopy::getTrueNumInteractions(), edm::EventPrincipal::id(), LogDebug, TtFullHadEvtBuilder_cfi::prob, 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 283 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 92 of file PreMixingModule.cc.

Referenced by addSignals(), and pileWorker().

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

private

Definition at line 94 of file PreMixingModule.cc.

Referenced by doPileUp(), and PreMixingModule().

PreMixingPileupCopy edm::PreMixingModule::puWorker_

private

Definition at line 91 of file PreMixingModule.cc.

Referenced by pileWorker(), and put().

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

private

Definition at line 95 of file PreMixingModule.cc.

Referenced by addSignals(), beginLuminosityBlock(), beginRun(), doPileUp(), endRun(), initializeEvent(), pileWorker(), PreMixingModule(), 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