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

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

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	setBcrOffset ()

virtual void	setSourceOffset (const unsigned int s)

	~BMixingModule () override

Public Member Functions inherited from edm::stream::EDProducer< GlobalCache< MixingCache::Config > >
	EDProducer ()=default

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

Private Member Functions
void	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

void	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	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(), MicroEventContent_cff::branch, branchesActivate(), edm::BMixingModule::bunchSpace_, createDigiAccumulators(), DigiHGCalTB160_cff::crossingFrames, edm::BMixingModule::dropUnwantedBranches(), edm::InputTag::encode(), edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, cuy::ii, inputTagPlayback_, edm::InputTag::instance(), 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, edm::sort_all(), AlCaHLTBitMon_QueryRunRegistry::string, fireworks::subdets, GlobalPosition_Frontier_DevDB_cff::tag, 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");
     }
 
 
     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);
   }

MixingModule::~MixingModule ( )

override

Default destructor

Definition at line 298 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 599 of file MixingModule.cc.

References digiAccumulators_.

Referenced by addSignals(), beginJob(), 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 606 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 312 of file MixingModule.cc.

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

Referenced by beginJob().

                                                                              {
 
     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

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

override

Definition at line 577 of file MixingModule.cc.

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

Referenced by beginJob().

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

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

Referenced by beginJob().

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

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

Referenced by beginJob(), and 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 271 of file MixingModule.cc.

References adjusters_, adjustersObjects_, workers_, and workersObjects_.

Referenced by beginJob().

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

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

private

Definition at line 228 of file MixingModule.cc.

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

Referenced by beginJob(), and 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, *this, iC));
         // Create appropriate DigiAccumulator
         if(accumulator.get() != nullptr) {
           digiAccumulators_.push_back(accumulator.release());
         }
     }
   }

void MixingModule::createnewEDProduct ( )

overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 288 of file MixingModule.cc.

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

Referenced by beginJob().

                                         {
     //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 351 of file MixingModule.cc.

References begin, genPUProtons_cfi::bunchCrossingList, edm::BMixingModule::bunchSpace_, digiAccumulators_, end, Exception, edm::Event::getByLabel(), CrossingFramePlaybackInfoNew::getEventId(), CrossingFramePlaybackInfoNew::getNumberOfEvents(), CrossingFramePlaybackInfoExtended::getStartEventId(), edm::EventBase::id(), cuy::ii, edm::BMixingModule::inputSources_, inputTagPlayback_, 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_, mitigatedMETSequence_cff::U, and workers_.

Referenced by beginJob().

                                                                      {
     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::unique_ptr<PileupMixingContent>(new 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 584 of file MixingModule.cc.

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

Referenced by beginJob().

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

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

Referenced by beginJob().

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

override

Definition at line 613 of file MixingModule.cc.

References digiAccumulators_.

Referenced by beginJob().

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

override

Definition at line 592 of file MixingModule.cc.

References digiAccumulators_.

Referenced by beginJob().

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

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

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

Referenced by beginJob(), and 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);
     }
   }

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

overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 555 of file MixingModule.cc.

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

Referenced by beginJob().

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

References MixingModuleConfig::bunchSpace(), edm::BMixingModule::bunchSpace_, looper::config, edm::EventSetup::get(), cuy::ii, MixingModuleConfig::maxBunch(), edm::BMixingModule::maxBunch_, MixingModuleConfig::minBunch(), edm::BMixingModule::minBunch_, and workersObjects_.

Referenced by beginJob().

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