#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_

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_

const bool	mixProdStep1_

const bool	mixProdStep2_

edm::ESWatcher< MixingRcd >	parameterWatcher_

bool	playback_

bool	readDB_

std::vector< float >	TrueNumInteractions_

int	vertexOffset_

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

Detailed Description

Definition at line 49 of file MixingModule.h.

Member Typedef Documentation

◆ Accumulators

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

Definition at line 51 of file MixingModule.h.

Constructor & Destructor Documentation

◆ MixingModule()

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

explicit

standard constructor

Definition at line 41 of file MixingModule.cc.

       : 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());
     // Create and configure digitizers
     createDigiAccumulators(ps_mix, iC);
   }

References adjustersObjects_, edm::binary_search_all(), MicroEventContent_cff::branch, branchesActivate(), edm::BMixingModule::bunchSpace_, createDigiAccumulators(), DigiHGCalTB160_cff::crossingFrames, edm::BMixingModule::dropUnwantedBranches(), edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), mps_fire::i, cuy::ii, HLT_FULL_cff::InputTag, inputTagPlayback_, edm::InputTag::kSkipCurrentProcess, label, LogDebug, DigiHGCalTB160_cff::makeCrossingFrame, edm::BMixingModule::maxBunch_, edm::BMixingModule::maxNbSources_, edm::BMixingModule::minBunch_, mixProdStep1_, mixProdStep2_, names, mixObjects_cfi::pcrossingFrames, edm::BMixingModule::playback_, muonDTDigis_cfi::pset, skipSignal_, edm::sort_all(), AlCaHLTBitMon_QueryRunRegistry::string, fireworks::subdets, makeGlobalPositionRcd_cfg::tag, triggerMatcherToHLTDebug_cfi::tags, useCurrentProcessOnly_, wantedBranches_, workersObjects_, and wrapLongTimes_.

◆ ~MixingModule()

MixingModule::~MixingModule ( )

override

Default destructor

Definition at line 345 of file MixingModule.cc.

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

References adjustersObjects_, digiAccumulators_, and workersObjects_.

Member Function Documentation

◆ accumulateEvent() [1/2]

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

Definition at line 679 of file MixingModule.cc.

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

References digiAccumulators_, and singleTopDQM_cfi::setup.

Referenced by addSignals(), and pileAllWorkers().

◆ accumulateEvent() [2/2]

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

Definition at line 687 of file MixingModule.cc.

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

References digiAccumulators_, and singleTopDQM_cfi::setup.

◆ addSignals()

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

overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 359 of file MixingModule.cc.

                                                                              {
     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);
     }
   }

References accumulateEvent(), MillePedeFileConverter_cfg::e, cuy::ii, LogDebug, singleTopDQM_cfi::setup, skipSignal_, and workers_.

◆ beginJob()

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

inlinevirtual

Definition at line 59 of file MixingModule.h.

59 {}

◆ beginLuminosityBlock()

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

override

Definition at line 653 of file MixingModule.cc.

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

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

◆ beginRun()

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

override

Definition at line 635 of file MixingModule.cc.

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

References edm::BMixingModule::beginRun(), digiAccumulators_, writedatasetfile::run, and singleTopDQM_cfi::setup.

◆ branchesActivate()

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

privatevirtual

Definition at line 304 of file MixingModule.cc.

                                                         {
     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);
     }
   }

References edm::friendlyname::friendlyName(), HLT_FULL_cff::InputTag, label, SimL1EmulatorRepack_CalouGT_cff::processName, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, useCurrentProcessOnly_, and wantedBranches_.

Referenced by MixingModule().

◆ checkSignal()

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

overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 318 of file MixingModule.cc.

                                                   {
     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);
         }
       }
     }
   }

References adjusters_, adjustersObjects_, MillePedeFileConverter_cfg::e, or, skipSignal_, workers_, and workersObjects_.

◆ createDigiAccumulators()

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

private

Definition at line 273 of file MixingModule.cc.

                                                                                                        {
     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());
       }
     }
   }

References mixOne_premix_on_sim_cfi::accumulator, digiAccumulators_, edm::DigiAccumulatorMixModFactory::get(), edm::ParameterSet::getParameterNames(), edm::ParameterSet::getParameterSet(), and muonDTDigis_cfi::pset.

Referenced by MixingModule().

◆ createnewEDProduct()

void MixingModule::createnewEDProduct ( )

overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 335 of file MixingModule.cc.

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

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

◆ doPileUp()

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

overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 402 of file MixingModule.cc.

                                                                      {
     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);
     }
   }

References genPUProtons_cfi::bunchCrossingList, edm::BMixingModule::bunchSpace_, digiAccumulators_, MillePedeFileConverter_cfg::e, mps_fire::end, Exception, CrossingFramePlaybackInfoNew::getEventId(), CrossingFramePlaybackInfoNew::getNumberOfEvents(), CrossingFramePlaybackInfoExtended::getStartEventId(), cuy::ii, edm::BMixingModule::inputSources_, inputTagPlayback_, B2GTnPMonitor_cfi::item, edm::BMixingModule::maxBunch_, edm::BMixingModule::maxNbSources_, edm::BMixingModule::minBunch_, eostools::move(), pileAllWorkers(), edm::BMixingModule::playback_, playbackInfo_, CrossingFramePlaybackInfoNew::setInfo(), singleTopDQM_cfi::setup, edm::source(), edm::BMixingModule::TrueNumInteractions_, mitigatedMETSequence_cff::U, and workers_.

◆ endLuminosityBlock()

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

override

Definition at line 662 of file MixingModule.cc.

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

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

◆ endRun()

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

override

Definition at line 644 of file MixingModule.cc.

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

References digiAccumulators_, edm::BMixingModule::endRun(), writedatasetfile::run, and singleTopDQM_cfi::setup.

◆ finalizeEvent()

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

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 697 of file MixingModule.cc.

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

References digiAccumulators_, and singleTopDQM_cfi::setup.

◆ initializeEvent()

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

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 671 of file MixingModule.cc.

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

References digiAccumulators_, and singleTopDQM_cfi::setup.

◆ pileAllWorkers()

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 373 of file MixingModule.cc.

                                                               {
     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;
   }

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

Referenced by doPileUp().

◆ put()

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

overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 628 of file MixingModule.cc.

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

References MillePedeFileConverter_cfg::e, eostools::move(), playbackInfo_, and L1TrackObjectNtupleMaker_cfg::pOut.

◆ reload()

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

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 290 of file MixingModule.cc.

                                                       {
     // TODO for esConsumes migration: assume for now this function is mostly unused
     //change the basic parameters.
     edm::ESHandle<MixingModuleConfig> config;
     setup.get<MixingRcd>().get(config);
     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(setup);
     }
   }

References edm::BMixingModule::bunchSpace_, submitPVResolutionJobs::config, edm::get(), cuy::ii, edm::BMixingModule::maxBunch_, edm::BMixingModule::minBunch_, singleTopDQM_cfi::setup, and workersObjects_.

Member Data Documentation

◆ adjusters_

std::vector<AdjusterBase*> edm::MixingModule::adjusters_

private

Definition at line 103 of file MixingModule.h.

Referenced by checkSignal(), and pileAllWorkers().

◆ adjustersObjects_

std::vector<AdjusterBase*> edm::MixingModule::adjustersObjects_

private

Definition at line 104 of file MixingModule.h.

Referenced by checkSignal(), MixingModule(), and ~MixingModule().

◆ digiAccumulators_

Accumulators edm::MixingModule::digiAccumulators_

private

Definition at line 113 of file MixingModule.h.

Referenced by accumulateEvent(), beginLuminosityBlock(), beginRun(), createDigiAccumulators(), doPileUp(), endLuminosityBlock(), endRun(), finalizeEvent(), initializeEvent(), and ~MixingModule().

◆ inputTagPlayback_

InputTag edm::MixingModule::inputTagPlayback_

private

Definition at line 98 of file MixingModule.h.

Referenced by doPileUp(), and MixingModule().

◆ mixProdStep1_

bool edm::MixingModule::mixProdStep1_

private

Definition at line 100 of file MixingModule.h.

Referenced by MixingModule().

◆ mixProdStep2_

bool edm::MixingModule::mixProdStep2_

private

Definition at line 99 of file MixingModule.h.

Referenced by MixingModule().

◆ playbackInfo_

CrossingFramePlaybackInfoNew* edm::MixingModule::playbackInfo_

private

Definition at line 101 of file MixingModule.h.

Referenced by createnewEDProduct(), doPileUp(), and put().

◆ skipSignal_

bool edm::MixingModule::skipSignal_

private

Definition at line 110 of file MixingModule.h.

Referenced by addSignals(), checkSignal(), and MixingModule().

◆ useCurrentProcessOnly_

bool edm::MixingModule::useCurrentProcessOnly_

private

Definition at line 108 of file MixingModule.h.

Referenced by branchesActivate(), and MixingModule().

◆ wantedBranches_

std::vector<std::string> edm::MixingModule::wantedBranches_

private

Definition at line 107 of file MixingModule.h.

Referenced by branchesActivate(), and MixingModule().

◆ workers_

std::vector<MixingWorkerBase*> edm::MixingModule::workers_

private

Definition at line 105 of file MixingModule.h.

Referenced by addSignals(), checkSignal(), createnewEDProduct(), doPileUp(), and pileAllWorkers().

◆ workersObjects_

std::vector<MixingWorkerBase*> edm::MixingModule::workersObjects_

private

Definition at line 106 of file MixingModule.h.

Referenced by checkSignal(), MixingModule(), reload(), and ~MixingModule().

◆ wrapLongTimes_

bool edm::MixingModule::wrapLongTimes_

private

Definition at line 109 of file MixingModule.h.

Referenced by MixingModule().

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Accumulators

Constructor & Destructor Documentation

◆ MixingModule()

◆ ~MixingModule()

Member Function Documentation

◆ accumulateEvent() [1/2]

◆ accumulateEvent() [2/2]

◆ addSignals()

◆ beginJob()

◆ beginLuminosityBlock()

◆ beginRun()

◆ branchesActivate()

◆ checkSignal()

◆ createDigiAccumulators()

◆ createnewEDProduct()

◆ doPileUp()

◆ endLuminosityBlock()

◆ endRun()

◆ finalizeEvent()

◆ initializeEvent()

◆ pileAllWorkers()

◆ put()

◆ reload()

Member Data Documentation

◆ adjusters_

◆ adjustersObjects_

◆ digiAccumulators_

◆ inputTagPlayback_

◆ mixProdStep1_

◆ mixProdStep2_

◆ playbackInfo_

◆ skipSignal_

◆ useCurrentProcessOnly_

◆ wantedBranches_

◆ workers_

◆ workersObjects_

◆ wrapLongTimes_