#include <MixingModule.h>

Inheritance diagram for edm::MixingModule:

Public Types
typedef std::vector < DigiAccumulatorMixMod * >	Accumulators

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

Public Member Functions
void	accumulateEvent (Event const &event, EventSetup const &setup)

void	accumulateEvent (PileUpEventPrincipal const &event, EventSetup const &setup, edm::StreamID const &)

virtual void	beginJob ()

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

void	beginRun (Run const &r1, EventSetup const &c) override

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

void	endRun (Run const &r1, EventSetup const &c) override

void	finalizeEvent (Event &event, EventSetup const &setup) override

void	initializeEvent (Event const &event, EventSetup const &setup) override

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

void	reload (const edm::EventSetup &) override

	~MixingModule () 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

bool	poisson () const

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

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
void	addSignals (const edm::Event &e, const edm::EventSetup &es) override

virtual void	branchesActivate (const std::string &friendlyName, const std::string &subdet, InputTag &tag, std::string &label)

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

void	createDigiAccumulators (const edm::ParameterSet &mixingPSet, edm::ConsumesCollector &iC)

void	createnewEDProduct () override

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

bool	pileAllWorkers (EventPrincipal const &ep, ModuleCallingContext const *, int bcr, int id, int &offset, const edm::EventSetup &setup, edm::StreamID const &)

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

Private Attributes
std::vector< AdjusterBase * >	adjusters_

std::vector< AdjusterBase * >	adjustersObjects_

edm::ESGetToken < MixingModuleConfig, MixingRcd >	configToken_

Accumulators	digiAccumulators_

InputTag	inputTagPlayback_

bool	mixProdStep1_

bool	mixProdStep2_

CrossingFramePlaybackInfoNew *	playbackInfo_

bool	skipSignal_

bool	useCurrentProcessOnly_

std::vector< std::string >	wantedBranches_

std::vector< MixingWorkerBase * >	workers_

std::vector< MixingWorkerBase * >	workersObjects_

bool	wrapLongTimes_

Additional Inherited Members
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 49 of file MixingModule.h.

Member Typedef Documentation

typedef std::vector<DigiAccumulatorMixMod*> edm::MixingModule::Accumulators

Definition at line 51 of file MixingModule.h.

Constructor & Destructor Documentation

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

explicit

standard constructor

Definition at line 41 of file MixingModule.cc.

References adjustersObjects_, edm::binary_search_all(), branchesActivate(), edm::BMixingModule::bunchSpace_, edm::MixingCache::Config::configFromDB_, configToken_, createDigiAccumulators(), edm::BMixingModule::dropUnwantedBranches(), edm::InputTag::encode(), edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, cuy::ii, HLT_FULL_cff::InputTag, inputTagPlayback_, edm::InputTag::instance(), edm::InputTag::kSkipCurrentProcess, label, LogDebug, edm::BMixingModule::maxBunch_, edm::BMixingModule::maxNbSources_, edm::BMixingModule::minBunch_, mixProdStep1_, mixProdStep2_, edm::names, mixObjects_cfi::pcrossingFrames, edm::BMixingModule::playback_, TrackValidation_cff::pset, skipSignal_, edm::sort_all(), AlCaHLTBitMon_QueryRunRegistry::string, fireworks::subdets, GlobalPosition_Frontier_DevDB_cff::tag, getPayloadData::tags, useCurrentProcessOnly_, wantedBranches_, workersObjects_, and wrapLongTimes_.

       : BMixingModule(ps_mix, globalConf),
         inputTagPlayback_(),
         mixProdStep2_(ps_mix.getParameter<bool>("mixProdStep2")),
         mixProdStep1_(ps_mix.getParameter<bool>("mixProdStep1")),
         digiAccumulators_() {
     if (!mixProdStep1_ && !mixProdStep2_)
       LogInfo("MixingModule") << " The MixingModule was run in the Standard mode.";
     if (mixProdStep1_)
       LogInfo("MixingModule") << " The MixingModule was run in the Step1 mode. It produces a mixed secondary source.";
     if (mixProdStep2_)
       LogInfo("MixingModule") << " The MixingModule was run in the Step2 mode. It uses a mixed secondary source.";
 
     useCurrentProcessOnly_ = false;
     if (ps_mix.exists("useCurrentProcessOnly")) {
       useCurrentProcessOnly_ = ps_mix.getParameter<bool>("useCurrentProcessOnly");
       LogInfo("MixingModule") << " using given Parameter 'useCurrentProcessOnly' =" << useCurrentProcessOnly_;
     }
     std::string labelPlayback;
     if (ps_mix.exists("LabelPlayback")) {
       labelPlayback = ps_mix.getParameter<std::string>("LabelPlayback");
     }
     if (labelPlayback.empty()) {
       labelPlayback = ps_mix.getParameter<std::string>("@module_label");
     }
     if (playback_) {
       inputTagPlayback_ = InputTag(labelPlayback, "", edm::InputTag::kSkipCurrentProcess);
       consumes<CrossingFramePlaybackInfoNew>(inputTagPlayback_);
     }
     wrapLongTimes_ = false;
     if (ps_mix.exists("WrapLongTimes")) {
       wrapLongTimes_ = ps_mix.getParameter<bool>("WrapLongTimes");
     }
 
     skipSignal_ = false;
     if (ps_mix.exists("skipSignal")) {
       skipSignal_ = ps_mix.getParameter<bool>("skipSignal");
     }
 
     ParameterSet ps = ps_mix.getParameter<ParameterSet>("mixObjects");
     std::vector<std::string> names = ps.getParameterNames();
     for (std::vector<std::string>::iterator it = names.begin(); it != names.end(); ++it) {
       ParameterSet pset = ps.getParameter<ParameterSet>((*it));
       if (!pset.exists("type"))
         continue;  //to allow replacement by empty pset
       std::string object = pset.getParameter<std::string>("type");
       std::vector<InputTag> tags = pset.getParameter<std::vector<InputTag> >("input");
 
       //if (!mixProdStep2_) {
 
       InputTag tagCF = InputTag();
       std::string labelCF = " ";
 
       if (object == "SimTrack") {
         InputTag tag;
         if (!tags.empty())
           tag = tags[0];
         std::string label;
 
         branchesActivate(TypeID(typeid(std::vector<SimTrack>)).friendlyClassName(), std::string(""), tag, label);
         adjustersObjects_.push_back(new Adjuster<std::vector<SimTrack> >(tag, consumesCollector(), wrapLongTimes_));
         bool makeCrossingFrame = pset.getUntrackedParameter<bool>("makeCrossingFrame", false);
         if (makeCrossingFrame) {
           workersObjects_.push_back(new MixingWorker<SimTrack>(
               minBunch_, maxBunch_, bunchSpace_, std::string(""), label, labelCF, maxNbSources_, tag, tagCF));
           produces<CrossingFrame<SimTrack> >(label);
         }
         consumes<std::vector<SimTrack> >(tag);
 
         LogInfo("MixingModule") << "Will mix " << object << "s with InputTag= " << tag.encode() << ", label will be "
                                 << label;
         //            std::cout <<"Will mix "<<object<<"s with InputTag= "<<tag.encode()<<", label will be "<<label<<std::endl;
 
       } else if (object == "RecoTrack") {
         InputTag tag;
         if (!tags.empty())
           tag = tags[0];
         std::string label;
 
         branchesActivate(TypeID(typeid(std::vector<reco::Track>)).friendlyClassName(), std::string(""), tag, label);
         branchesActivate(
             TypeID(typeid(std::vector<reco::TrackExtra>)).friendlyClassName(), std::string(""), tag, label);
         branchesActivate(
             TypeID(typeid(edm::OwnVector<TrackingRecHit, edm::ClonePolicy<TrackingRecHit> >)).friendlyClassName(),
             std::string(""),
             tag,
             label);
         adjustersObjects_.push_back(
             new Adjuster<edm::OwnVector<TrackingRecHit> >(tag, consumesCollector(), wrapLongTimes_));
         // note: no crossing frame is foreseen to be used for this object type
 
         LogInfo("MixingModule") << "Will mix " << object << "s with InputTag= " << tag.encode() << ", label will be "
                                 << label;
         //std::cout <<"Will mix "<<object<<"s with InputTag= "<<tag.encode()<<", label will be "<<label<<std::endl;
 
       } else if (object == "SimVertex") {
         InputTag tag;
         if (!tags.empty())
           tag = tags[0];
         std::string label;
 
         branchesActivate(TypeID(typeid(std::vector<SimVertex>)).friendlyClassName(), std::string(""), tag, label);
         adjustersObjects_.push_back(new Adjuster<std::vector<SimVertex> >(tag, consumesCollector(), wrapLongTimes_));
         bool makeCrossingFrame = pset.getUntrackedParameter<bool>("makeCrossingFrame", false);
         if (makeCrossingFrame) {
           workersObjects_.push_back(new MixingWorker<SimVertex>(
               minBunch_, maxBunch_, bunchSpace_, std::string(""), label, labelCF, maxNbSources_, tag, tagCF));
           produces<CrossingFrame<SimVertex> >(label);
         }
         consumes<std::vector<SimVertex> >(tag);
 
         LogInfo("MixingModule") << "Will mix " << object << "s with InputTag " << tag.encode() << ", label will be "
                                 << label;
         //            std::cout <<"Will mix "<<object<<"s with InputTag "<<tag.encode()<<", label will be "<<label<<std::endl;
 
       } else if (object == "HepMCProduct") {
         InputTag tag;
         if (!tags.empty())
           tag = tags[0];
         std::string label;
 
         branchesActivate(TypeID(typeid(HepMCProduct)).friendlyClassName(), std::string(""), tag, label);
         bool makeCrossingFrame = pset.getUntrackedParameter<bool>("makeCrossingFrame", false);
         if (makeCrossingFrame) {
           workersObjects_.push_back(new MixingWorker<HepMCProduct>(
               minBunch_, maxBunch_, bunchSpace_, std::string(""), label, labelCF, maxNbSources_, tag, tagCF, tags));
           produces<CrossingFrame<HepMCProduct> >(label);
         }
         consumes<HepMCProduct>(tag);
 
         LogInfo("MixingModule") << "Will mix " << object << "s with InputTag= " << tag.encode() << ", label will be "
                                 << label;
         //            std::cout <<"Will mix "<<object<<"s with InputTag= "<<tag.encode()<<", label will be "<<label<<std::endl;
         for (size_t i = 1; i < tags.size(); ++i) {
           InputTag fallbackTag = tags[i];
           std::string fallbackLabel;
           branchesActivate(
               TypeID(typeid(HepMCProduct)).friendlyClassName(), std::string(""), fallbackTag, fallbackLabel);
           mayConsume<HepMCProduct>(fallbackTag);
         }
 
       } else if (object == "PCaloHit") {
         std::vector<std::string> subdets = pset.getParameter<std::vector<std::string> >("subdets");
         std::vector<std::string> crossingFrames =
             pset.getUntrackedParameter<std::vector<std::string> >("crossingFrames", std::vector<std::string>());
         sort_all(crossingFrames);
         for (unsigned int ii = 0; ii < subdets.size(); ++ii) {
           InputTag tag;
           if (tags.size() == 1)
             tag = tags[0];
           else if (tags.size() > 1)
             tag = tags[ii];
           std::string label;
 
           branchesActivate(TypeID(typeid(std::vector<PCaloHit>)).friendlyClassName(), subdets[ii], tag, label);
           adjustersObjects_.push_back(new Adjuster<std::vector<PCaloHit> >(tag, consumesCollector(), wrapLongTimes_));
           if (binary_search_all(crossingFrames, tag.instance())) {
             workersObjects_.push_back(new MixingWorker<PCaloHit>(
                 minBunch_, maxBunch_, bunchSpace_, subdets[ii], label, labelCF, maxNbSources_, tag, tagCF));
             produces<CrossingFrame<PCaloHit> >(label);
             consumes<std::vector<PCaloHit> >(tag);
           }
 
           LogInfo("MixingModule") << "Will mix " << object << "s with InputTag= " << tag.encode() << ", label will be "
                                   << label;
           //              std::cout <<"Will mix "<<object<<"s with InputTag= "<<tag.encode()<<", label will be "<<label<<std::endl;
         }
 
       } else if (object == "PSimHit") {
         std::vector<std::string> subdets = pset.getParameter<std::vector<std::string> >("subdets");
         std::vector<std::string> crossingFrames =
             pset.getUntrackedParameter<std::vector<std::string> >("crossingFrames", std::vector<std::string>());
         sort_all(crossingFrames);
         std::vector<std::string> pcrossingFrames =
             pset.getUntrackedParameter<std::vector<std::string> >("pcrossingFrames", std::vector<std::string>());
         sort_all(pcrossingFrames);
         for (unsigned int ii = 0; ii < subdets.size(); ++ii) {
           InputTag tag;
           if (tags.size() == 1)
             tag = tags[0];
           else if (tags.size() > 1)
             tag = tags[ii];
           std::string label;
 
           branchesActivate(TypeID(typeid(std::vector<PSimHit>)).friendlyClassName(), subdets[ii], tag, label);
           adjustersObjects_.push_back(new Adjuster<std::vector<PSimHit> >(tag, consumesCollector(), wrapLongTimes_));
           if (binary_search_all(crossingFrames, tag.instance())) {
             bool makePCrossingFrame = binary_search_all(pcrossingFrames, tag.instance());
             workersObjects_.push_back(new MixingWorker<PSimHit>(minBunch_,
                                                                 maxBunch_,
                                                                 bunchSpace_,
                                                                 subdets[ii],
                                                                 label,
                                                                 labelCF,
                                                                 maxNbSources_,
                                                                 tag,
                                                                 tagCF,
                                                                 makePCrossingFrame));
             produces<CrossingFrame<PSimHit> >(label);
             if (makePCrossingFrame) {
               produces<PCrossingFrame<PSimHit> >(label);
             }
             consumes<std::vector<PSimHit> >(tag);
           }
 
           LogInfo("MixingModule") << "Will mix " << object << "s with InputTag= " << tag.encode() << ", label will be "
                                   << label;
           //              std::cout <<"Will mix "<<object<<"s with InputTag= "<<tag.encode()<<", label will be "<<label<<std::endl;
         }
       } else {
         LogWarning("MixingModule")
             << "You have asked to mix an unknown type of object(" << object
             << ").\n If you want to include it in mixing, please contact the authors of the MixingModule!";
       }
       //} //if for mixProdStep2
     }  //while over the mixObjects parameters
 
     sort_all(wantedBranches_);
     for (unsigned int branch = 0; branch < wantedBranches_.size(); ++branch)
       LogDebug("MixingModule") << "Will keep branch " << wantedBranches_[branch] << " for mixing ";
 
     dropUnwantedBranches(wantedBranches_);
 
     produces<PileupMixingContent>();
 
     produces<CrossingFramePlaybackInfoNew>();
 
     edm::ConsumesCollector iC(consumesCollector());
     if (globalConf->configFromDB_) {
       configToken_ = esConsumes<edm::Transition::BeginLuminosityBlock>();
     }
     // Create and configure digitizers
     createDigiAccumulators(ps_mix, iC);
   }

MixingModule::~MixingModule ( )

override

Default destructor

Definition at line 346 of file MixingModule.cc.

References adjustersObjects_, digiAccumulators_, and workersObjects_.

                               {
     for (auto& worker : workersObjects_) {
       delete worker;
     }
 
     for (auto& adjuster : adjustersObjects_) {
       delete adjuster;
     }
 
     for (auto& digiAccumulator : digiAccumulators_) {
       delete digiAccumulator;
     }
   }

Member Function Documentation

void MixingModule::accumulateEvent	(	edm::Event const &	event,
		edm::EventSetup const &	setup
	)

Definition at line 680 of file MixingModule.cc.

References digiAccumulators_.

Referenced by addSignals(), and pileAllWorkers().

                                                                                       {
     for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
          accItr != accEnd;
          ++accItr) {
       (*accItr)->accumulate(event, setup);
     }
   }

void MixingModule::accumulateEvent	(	PileUpEventPrincipal const &	event,
		edm::EventSetup const &	setup,
		edm::StreamID const &	streamID
	)

Definition at line 688 of file MixingModule.cc.

References digiAccumulators_.

                                                                   {
     for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
          accItr != accEnd;
          ++accItr) {
       (*accItr)->accumulate(event, setup, streamID);
     }
   }

void MixingModule::addSignals	(	const edm::Event &	e,
		const edm::EventSetup &	es
	)

overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 360 of file MixingModule.cc.

References accumulateEvent(), edm::EventBase::id(), cuy::ii, LogDebug, skipSignal_, and workers_.

                                                                              {
     if (skipSignal_) {
       return;
     }
 
     LogDebug("MixingModule") << "===============> adding signals for " << e.id();
 
     accumulateEvent(e, setup);
     // fill in signal part of CrossingFrame
     for (unsigned int ii = 0; ii < workers_.size(); ++ii) {
       workers_[ii]->addSignals(e);
     }
   }

virtual void edm::MixingModule::beginJob ( void )

inlinevirtual

Definition at line 59 of file MixingModule.h.

59 {}

void MixingModule::beginLuminosityBlock	(	edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &	setup
	)

override

Definition at line 654 of file MixingModule.cc.

References edm::BMixingModule::beginLuminosityBlock(), and digiAccumulators_.

                                                                                                     {
     for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
          accItr != accEnd;
          ++accItr) {
       (*accItr)->beginLuminosityBlock(lumi, setup);
     }
     BMixingModule::beginLuminosityBlock(lumi, setup);
   }

void MixingModule::beginRun	(	edm::Run const &	run,
		edm::EventSetup const &	setup
	)

override

Definition at line 636 of file MixingModule.cc.

References edm::BMixingModule::beginRun(), and digiAccumulators_.

                                                                            {
     for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
          accItr != accEnd;
          ++accItr) {
       (*accItr)->beginRun(run, setup);
     }
     BMixingModule::beginRun(run, setup);
   }

void MixingModule::branchesActivate	(	const std::string &	friendlyName,
		const std::string &	subdet,
		InputTag &	tag,
		std::string &	label
	)

privatevirtual

Definition at line 305 of file MixingModule.cc.

References EgammaHLTValidationUtils::getProcessName(), HLT_FULL_cff::InputTag, edm::InputTag::instance(), edm::InputTag::label(), FSQHLTOfflineSource_cfi::processName, AlCaHLTBitMon_QueryRunRegistry::string, useCurrentProcessOnly_, and wantedBranches_.

Referenced by MixingModule().

                                                         {
     label = tag.label() + tag.instance();
     wantedBranches_.push_back(friendlyName + '_' + tag.label() + '_' + tag.instance());
 
     //if useCurrentProcessOnly, we have to change the input tag
     if (useCurrentProcessOnly_) {
       const std::string processName = edm::Service<edm::service::TriggerNamesService>()->getProcessName();
       tag = InputTag(tag.label(), tag.instance(), processName);
     }
   }

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

overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 319 of file MixingModule.cc.

References adjusters_, adjustersObjects_, or, skipSignal_, workers_, and workersObjects_.

                                                   {
     if (adjusters_.empty()) {
       for (auto const& adjuster : adjustersObjects_) {
         if (skipSignal_ or adjuster->checkSignal(e)) {
           adjusters_.push_back(adjuster);
         }
       }
     }
     if (workers_.empty()) {
       for (auto const& worker : workersObjects_) {
         if (skipSignal_ or worker->checkSignal(e)) {
           workers_.push_back(worker);
         }
       }
     }
   }

void MixingModule::createDigiAccumulators	(	const edm::ParameterSet &	mixingPSet,
		edm::ConsumesCollector &	iC
	)

private

Definition at line 276 of file MixingModule.cc.

References digiAccumulators_, edm::ParameterSet::existsAs(), edm::DigiAccumulatorMixModFactory::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), edm::ParameterSet::getParameterSet(), edm::DigiAccumulatorMixModFactory::makeDigiAccumulator(), and TrackValidation_cff::pset.

Referenced by MixingModule().

                                                                                                        {
     ParameterSet const& digiPSet = mixingPSet.getParameterSet("digitizers");
     std::vector<std::string> digiNames = digiPSet.getParameterNames();
     for (auto const& digiName : digiNames) {
       ParameterSet const& pset = digiPSet.getParameterSet(digiName);
       if (pset.existsAs<edm::InputTag>("HepMCProductLabel")) {
         consumes<HepMCProduct>(pset.getParameter<edm::InputTag>("HepMCProductLabel"));
       }
       std::unique_ptr<DigiAccumulatorMixMod> accumulator = std::unique_ptr<DigiAccumulatorMixMod>(
           DigiAccumulatorMixModFactory::get()->makeDigiAccumulator(pset, producesCollector(), iC));
       // Create appropriate DigiAccumulator
       if (accumulator.get() != nullptr) {
         digiAccumulators_.push_back(accumulator.release());
       }
     }
   }

void MixingModule::createnewEDProduct ( )

overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 336 of file MixingModule.cc.

References cuy::ii, edm::BMixingModule::maxBunch_, edm::BMixingModule::maxNbSources_, edm::BMixingModule::minBunch_, playbackInfo_, and workers_.

                                         {
     //create playback info
     playbackInfo_ = new CrossingFramePlaybackInfoNew(minBunch_, maxBunch_, maxNbSources_);
     //and CrossingFrames
     for (unsigned int ii = 0; ii < workers_.size(); ++ii) {
       workers_[ii]->createnewEDProduct();
     }
   }

void MixingModule::doPileUp	(	edm::Event &	e,
		const edm::EventSetup &	es
	)

overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 403 of file MixingModule.cc.

References SplitLinear::begin, edm::BMixingModule::bunchSpace_, digiAccumulators_, dataset::end, Exception, edm::Event::getByLabel(), edm::EventBase::id(), cuy::ii, edm::BMixingModule::inputSources_, inputTagPlayback_, B2GTnPMonitor_cfi::item, edm::BMixingModule::maxBunch_, edm::BMixingModule::maxNbSources_, edm::BMixingModule::minBunch_, edm::Event::moduleCallingContext(), eostools::move(), pileAllWorkers(), edm::BMixingModule::playback_, playbackInfo_, edm::Event::put(), CrossingFramePlaybackInfoNew::setInfo(), edm::source(), edm::Event::streamID(), edm::BMixingModule::TrueNumInteractions_, and workers_.

                                                                      {
     using namespace std::placeholders;
 
     // Don't allocate because PileUp will do it for us.
     std::vector<edm::SecondaryEventIDAndFileInfo> recordEventID;
     std::vector<size_t> sizes;
     sizes.reserve(maxNbSources_ * (maxBunch_ + 1 - minBunch_));
     size_t playbackCounter = 0U;
     edm::Handle<CrossingFramePlaybackInfoNew> playbackInfo_H;
     edm::Handle<CrossingFramePlaybackInfoExtended> oldFormatPlaybackInfo_H;
     bool oldFormatPlayback = false;
     if (playback_) {
       bool got = e.getByLabel(inputTagPlayback_, playbackInfo_H);
       if (!got) {
         bool gotOld = e.getByLabel(inputTagPlayback_, oldFormatPlaybackInfo_H);
         if (!gotOld) {
           throw cms::Exception("MixingProductNotFound")
               << " No "
                  "CrossingFramePlaybackInfoNew on the input file, but playback "
                  "option set!!!!! Please change the input file if you really want "
                  "playback!!!!!!"
               << std::endl;
         }
         oldFormatPlayback = true;
       }
     }
 
     // source[0] is "real" pileup.  Check to see that this is what we are doing.
 
     std::vector<int> PileupList;
     PileupList.clear();
     TrueNumInteractions_.clear();
 
     std::shared_ptr<PileUp> source0 = inputSources_[0];
 
     if ((source0 && source0->doPileUp(0)) && !playback_) {
       //    if((!inputSources_[0] || !inputSources_[0]->doPileUp()) && !playback_ )
 
       // Pre-calculate all pileup distributions before we go fishing for events
 
       source0->CalculatePileup(minBunch_, maxBunch_, PileupList, TrueNumInteractions_, e.streamID());
     }
 
     // pre-populate Pileup information
     // necessary for luminosity-dependent effects during hit accumulation
 
     std::vector<int> numInteractionList;
     std::vector<int> bunchCrossingList;
     std::vector<float> TrueInteractionList;
     std::vector<edm::EventID> eventInfoList;  // will be empty if we pre-populate, but it's not used in digitizers
 
     if (!playback_) {
       //Makin' a list: Basically, we don't care about the "other" sources at this point.
       for (int bunchCrossing = minBunch_; bunchCrossing <= maxBunch_; ++bunchCrossing) {
         bunchCrossingList.push_back(bunchCrossing);
         if (!inputSources_[0] || !inputSources_[0]->doPileUp(0)) {
           numInteractionList.push_back(0);
           TrueInteractionList.push_back(0);
         } else {
           numInteractionList.push_back(PileupList[bunchCrossing - minBunch_]);
           TrueInteractionList.push_back((TrueNumInteractions_)[bunchCrossing - minBunch_]);
         }
       }
     } else {  // have to read PU information from playback info
       for (int bunchIdx = minBunch_; bunchIdx <= maxBunch_; ++bunchIdx) {
         bunchCrossingList.push_back(bunchIdx);
         for (size_t readSrcIdx = 0; readSrcIdx < maxNbSources_; ++readSrcIdx) {
           if (oldFormatPlayback) {
             std::vector<edm::EventID> const& playEventID =
                 oldFormatPlaybackInfo_H->getStartEventId(readSrcIdx, bunchIdx);
             size_t numberOfEvents = playEventID.size();
             if (readSrcIdx == 0) {
               PileupList.push_back(numberOfEvents);
               TrueNumInteractions_.push_back(numberOfEvents);
               numInteractionList.push_back(numberOfEvents);
               TrueInteractionList.push_back(numberOfEvents);
             }
           } else {
             size_t numberOfEvents = playbackInfo_H->getNumberOfEvents(bunchIdx, readSrcIdx);
             if (readSrcIdx == 0) {
               PileupList.push_back(numberOfEvents);
               TrueNumInteractions_.push_back(numberOfEvents);
               numInteractionList.push_back(numberOfEvents);
               TrueInteractionList.push_back(numberOfEvents);
             }
           }
         }
       }
     }
 
     for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
          accItr != accEnd;
          ++accItr) {
       (*accItr)->StorePileupInformation(
           bunchCrossingList, numInteractionList, TrueInteractionList, eventInfoList, bunchSpace_);
     }
 
     //    for (int bunchIdx = minBunch_; bunchIdx <= maxBunch_; ++bunchIdx) {
     //  std::cout << " bunch ID, Pileup, True " << bunchIdx << " " << PileupList[bunchIdx-minBunch_] << " " <<  TrueNumInteractions_[bunchIdx-minBunch_] << std::endl;
     //}
 
     for (int bunchIdx = minBunch_; bunchIdx <= maxBunch_; ++bunchIdx) {
       for (size_t setBcrIdx = 0; setBcrIdx < workers_.size(); ++setBcrIdx) {
         workers_[setBcrIdx]->setBcrOffset();
       }
       for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
            accItr != accEnd;
            ++accItr) {
         (*accItr)->initializeBunchCrossing(e, setup, bunchIdx);
       }
 
       for (size_t readSrcIdx = 0; readSrcIdx < maxNbSources_; ++readSrcIdx) {
         std::shared_ptr<PileUp> source = inputSources_[readSrcIdx];  // this looks like we create
                                                                      // new PileUp objects for each
                                                                      // source for each event?
                                                                      // Why?
         for (size_t setSrcIdx = 0; setSrcIdx < workers_.size(); ++setSrcIdx) {
           workers_[setSrcIdx]->setSourceOffset(readSrcIdx);
         }
 
         if (!source || !source->doPileUp(bunchIdx)) {
           sizes.push_back(0U);
           if (playback_ && !oldFormatPlayback) {
             playbackCounter += playbackInfo_H->getNumberOfEvents(bunchIdx, readSrcIdx);
           }
           continue;
         }
 
         //        int eventId = 0;
         int vertexOffset = 0;
 
         ModuleCallingContext const* mcc = e.moduleCallingContext();
         if (!playback_) {
           // non-minbias pileup only gets one event for now. Fix later if desired.
           int numberOfEvents = (readSrcIdx == 0 ? PileupList[bunchIdx - minBunch_] : 1);
           sizes.push_back(numberOfEvents);
           inputSources_[readSrcIdx]->readPileUp(e.id(),
                                                 recordEventID,
                                                 std::bind(&MixingModule::pileAllWorkers,
                                                           std::ref(*this),
                                                           _1,
                                                           mcc,
                                                           bunchIdx,
                                                           _2,
                                                           vertexOffset,
                                                           std::ref(setup),
                                                           e.streamID()),
                                                 numberOfEvents,
                                                 e.streamID());
         } else if (oldFormatPlayback) {
           std::vector<edm::EventID> const& playEventID = oldFormatPlaybackInfo_H->getStartEventId(readSrcIdx, bunchIdx);
           size_t numberOfEvents = playEventID.size();
           if (readSrcIdx == 0) {
             PileupList.push_back(numberOfEvents);
             TrueNumInteractions_.push_back(numberOfEvents);
           }
           sizes.push_back(numberOfEvents);
           std::vector<EventID>::const_iterator begin = playEventID.begin();
           std::vector<EventID>::const_iterator end = playEventID.end();
           inputSources_[readSrcIdx]->playOldFormatPileUp(begin,
                                                          end,
                                                          recordEventID,
                                                          std::bind(&MixingModule::pileAllWorkers,
                                                                    std::ref(*this),
                                                                    _1,
                                                                    mcc,
                                                                    bunchIdx,
                                                                    _2,
                                                                    vertexOffset,
                                                                    std::ref(setup),
                                                                    e.streamID()));
         } else {
           size_t numberOfEvents = playbackInfo_H->getNumberOfEvents(bunchIdx, readSrcIdx);
           if (readSrcIdx == 0) {
             PileupList.push_back(numberOfEvents);
             TrueNumInteractions_.push_back(numberOfEvents);
           }
           sizes.push_back(numberOfEvents);
           std::vector<SecondaryEventIDAndFileInfo>::const_iterator begin = playbackInfo_H->getEventId(playbackCounter);
           playbackCounter += numberOfEvents;
           std::vector<SecondaryEventIDAndFileInfo>::const_iterator end = playbackInfo_H->getEventId(playbackCounter);
           inputSources_[readSrcIdx]->playPileUp(begin,
                                                 end,
                                                 recordEventID,
                                                 std::bind(&MixingModule::pileAllWorkers,
                                                           std::ref(*this),
                                                           _1,
                                                           mcc,
                                                           bunchIdx,
                                                           _2,
                                                           vertexOffset,
                                                           std::ref(setup),
                                                           e.streamID()));
         }
       }
       for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
            accItr != accEnd;
            ++accItr) {
         (*accItr)->finalizeBunchCrossing(e, setup, bunchIdx);
       }
     }
 
     // Save playback information
     for (auto const item : recordEventID) {
       eventInfoList.emplace_back(item.eventID());
     }
 
     // setInfo swaps recordEventID, so recordEventID is useless (empty) after the call.
     playbackInfo_->setInfo(recordEventID, sizes);
 
     // Keep track of pileup accounting...
 
     std::unique_ptr<PileupMixingContent> PileupMixing_;
 
     PileupMixing_ = std::make_unique<PileupMixingContent>(
         bunchCrossingList, numInteractionList, TrueInteractionList, eventInfoList, bunchSpace_);
 
     e.put(std::move(PileupMixing_));
 
     // we have to do the ToF transformation for PSimHits once all pileup has been added
     for (unsigned int ii = 0; ii < workers_.size(); ++ii) {
       workers_[ii]->setTof();
       workers_[ii]->put(e);
     }
   }

void MixingModule::endLuminosityBlock	(	edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &	setup
	)

override

Definition at line 663 of file MixingModule.cc.

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

                                                                                                   {
     for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
          accItr != accEnd;
          ++accItr) {
       (*accItr)->endLuminosityBlock(lumi, setup);
     }
     BMixingModule::endLuminosityBlock(lumi, setup);
   }

void MixingModule::endRun	(	edm::Run const &	run,
		edm::EventSetup const &	setup
	)

override

Definition at line 645 of file MixingModule.cc.

References digiAccumulators_, and edm::BMixingModule::endRun().

                                                                          {
     for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
          accItr != accEnd;
          ++accItr) {
       (*accItr)->endRun(run, setup);
     }
     BMixingModule::endRun(run, setup);
   }

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

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 698 of file MixingModule.cc.

References digiAccumulators_.

                                                                               {
     for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
          accItr != accEnd;
          ++accItr) {
       (*accItr)->finalizeEvent(event, setup);
     }
   }

void MixingModule::initializeEvent	(	edm::Event const &	event,
		edm::EventSetup const &	setup
	)

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 672 of file MixingModule.cc.

References digiAccumulators_.

                                                                                       {
     for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
          accItr != accEnd;
          ++accItr) {
       (*accItr)->initializeEvent(event, setup);
     }
   }

bool MixingModule::pileAllWorkers	(	EventPrincipal const &	ep,
		ModuleCallingContext const *	mcc,
		int	bcr,
		int	id,
		int &	offset,
		const edm::EventSetup &	setup,
		edm::StreamID const &	streamID
	)

private

Definition at line 374 of file MixingModule.cc.

References accumulateEvent(), adjusters_, edm::BMixingModule::bunchSpace_, edm::EventPrincipal::id(), LogDebug, and workers_.

Referenced by doPileUp().

                                                               {
     InternalContext internalContext(eventPrincipal.id(), mcc);
     ParentContext parentContext(&internalContext);
     ModuleCallingContext moduleCallingContext(&moduleDescription());
     ModuleContextSentry moduleContextSentry(&moduleCallingContext, parentContext);
 
     for (auto const& adjuster : adjusters_) {
       adjuster->doOffset(bunchSpace_, bunchCrossing, eventPrincipal, &moduleCallingContext, eventId, vertexOffset);
     }
     PileUpEventPrincipal pep(eventPrincipal, &moduleCallingContext, bunchCrossing);
 
     accumulateEvent(pep, setup, streamID);
 
     for (auto const& worker : workers_) {
       LogDebug("MixingModule") << " merging Event:  id " << eventPrincipal.id();
       //      std::cout <<"PILEALLWORKERS merging Event:  id " << eventPrincipal.id() << std::endl;
 
       worker->addPileups(eventPrincipal, &moduleCallingContext, eventId);
     }
 
     return true;
   }

void MixingModule::put	(	edm::Event &	e,
		const edm::EventSetup &	es
	)

overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 629 of file MixingModule.cc.

References eostools::move(), playbackInfo_, and edm::Event::put().

                                                                 {
     if (playbackInfo_) {
       std::unique_ptr<CrossingFramePlaybackInfoNew> pOut(playbackInfo_);
       e.put(std::move(pOut));
     }
   }

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

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 293 of file MixingModule.cc.

References edm::BMixingModule::bunchSpace_, submitPVResolutionJobs::config, configToken_, edm::EventSetup::getData(), cuy::ii, edm::BMixingModule::maxBunch_, edm::BMixingModule::minBunch_, and workersObjects_.

                                                       {
     //change the basic parameters.
     auto const& config = setup.getData(configToken_);
     minBunch_ = config.minBunch();
     maxBunch_ = config.maxBunch();
     bunchSpace_ = config.bunchSpace();
     //propagate to change the workers
     for (unsigned int ii = 0; ii < workersObjects_.size(); ++ii) {
       workersObjects_[ii]->reload(minBunch_, maxBunch_, bunchSpace_);
     }
   }