#include <MixingModule.h>

Inheritance diagram for edm::MixingModule:

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

Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

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

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

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

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

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

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

	MixingModule (const edm::ParameterSet &ps)

virtual void	reload (const edm::EventSetup &)

virtual	~MixingModule ()

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

	BMixingModule (const edm::ParameterSet &ps)

bool	poisson () const

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

virtual void	setBcrOffset ()

virtual void	setSourceOffset (const unsigned int s)

virtual	~BMixingModule ()

Public Member Functions inherited from edm::one::EDProducer< edm::one::SharedResources, edm::one::WatchRuns, edm::one::WatchLuminosityBlocks >
	EDProducer ()=default

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
virtual void	addSignals (const edm::Event &e, const edm::EventSetup &es)

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

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

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

virtual void	createnewEDProduct ()

virtual 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 &)

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

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_

Additional Inherited Members
Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::BMixingModule
void	dropUnwantedBranches (std::vector< std::string > const &wantedBranches)

virtual void	endJob () override

void	setupPileUpEvent (const edm::EventSetup &setup)

void	update (edm::EventSetup const &)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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< std::string >	sourceNames_

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 )

explicit

standard constructor

Definition at line 41 of file MixingModule.cc.

References adjustersObjects_, edm::binary_search_all(), branchesActivate(), edm::BMixingModule::bunchSpace_, edm::EDConsumerBase::consumesCollector(), createDigiAccumulators(), edm::BMixingModule::dropUnwantedBranches(), edm::InputTag::encode(), edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), edm::ParameterSet::getUntrackedParameter(), cuy::ii, HLT_25ns14e33_v1_cff::InputTag, inputTagPlayback_, edm::InputTag::instance(), edm::InputTag::kSkipCurrentProcess, diffTwoXMLs::label, edm::InputTag::label(), LogDebug, edm::BMixingModule::maxBunch_, edm::BMixingModule::maxNbSources_, edm::BMixingModule::minBunch_, mixProdStep1_, mixProdStep2_, cscdqm::h::names, edm::BMixingModule::playback_, edm::sort_all(), AlCaHLTBitMon_QueryRunRegistry::string, subdets, GlobalPosition_Frontier_DevDB_cff::tag, o2o::tags, useCurrentProcessOnly_, wantedBranches_, and workersObjects_.

                                                           :
   BMixingModule(ps_mix),
   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_);
     }
 
     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.size()>0) 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()));
             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.size()>0) 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);
         InputTag mvatag(tag.label(),"MVAVals");
             branchesActivate(TypeID(typeid(edm::ValueMap<float>)).friendlyClassName(),std::string(""),mvatag,label);
             adjustersObjects_.push_back(new Adjuster<edm::OwnVector<TrackingRecHit> >(tag, consumesCollector()));
         // 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.size()>0) 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()));
             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.size()>0) 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));
               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;
 
           } 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()));
               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);
             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()));
               if(binary_search_all(crossingFrames, tag.instance())) {
                 workersObjects_.push_back(new MixingWorker<PSimHit>(minBunch_,maxBunch_,bunchSpace_,subdets[ii],label,labelCF,maxNbSources_,tag,tagCF));
                 produces<CrossingFrame<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 ( )

virtual

Default destructor

Definition at line 280 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 547 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 554 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
	)

privatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 294 of file MixingModule.cc.

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

                                                                              {
 
     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

Reimplemented from edm::BMixingModule.

Definition at line 59 of file MixingModule.h.

59 {}

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

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 525 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
	)

overridevirtual

Reimplemented from edm::BMixingModule.

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

References EgammaHLTValidationUtils::getProcessName(), HLT_25ns14e33_v1_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 )

privatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 253 of file MixingModule.cc.

References adjusters_, adjustersObjects_, workers_, and workersObjects_.

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

References digiAccumulators_, edm::DigiAccumulatorMixModFactory::get(), edm::ParameterSet::getParameterNames(), edm::ParameterSet::getParameterSet(), and edm::DigiAccumulatorMixModFactory::makeDigiAccumulator().

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);
         std::auto_ptr<DigiAccumulatorMixMod> accumulator = std::auto_ptr<DigiAccumulatorMixMod>(DigiAccumulatorMixModFactory::get()->makeDigiAccumulator(pset, *this, iC));
         // Create appropriate DigiAccumulator
         if(accumulator.get() != 0) {
           digiAccumulators_.push_back(accumulator.release());
         }
     }
   }

void MixingModule::createnewEDProduct ( )

privatevirtual

Reimplemented from edm::BMixingModule.

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

References begin, edm::BMixingModule::bunchSpace_, digiAccumulators_, end, edm::hlt::Exception, edm::Event::getByLabel(), edm::EventBase::id(), cuy::ii, edm::BMixingModule::inputSources_, inputTagPlayback_, edm::BMixingModule::maxBunch_, edm::BMixingModule::maxNbSources_, edm::BMixingModule::minBunch_, edm::Event::moduleCallingContext(), 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());
 
     }
 
     //    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
 
     std::vector<edm::EventID> eventInfoList;
     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::auto_ptr<PileupMixingContent> PileupMixing_;
 
     std::vector<int> numInteractionList;
     std::vector<int> bunchCrossingList;
     std::vector<float> TrueInteractionList;
 
     //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_]);
       }
     }
 
     for(Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end(); accItr != accEnd; ++accItr) {
       (*accItr)->StorePileupInformation( bunchCrossingList,
                      numInteractionList,
                      TrueInteractionList,
                      eventInfoList,
                      bunchSpace_);
     }
 
 
     PileupMixing_ = std::auto_ptr<PileupMixingContent>(new PileupMixingContent(bunchCrossingList,
                                                                                numInteractionList,
                                                                                TrueInteractionList,
                                            eventInfoList,
                                            bunchSpace_));
 
     e.put(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
	)

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 532 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
	)

overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 518 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
	)

virtual

Reimplemented from edm::BMixingModule.

Definition at line 561 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
	)

virtual

Reimplemented from edm::BMixingModule.

Definition at line 540 of file MixingModule.cc.

References digiAccumulators_.

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

References accumulateEvent(), adjusters_, edm::BMixingModule::bunchSpace_, edm::EventPrincipal::id(), LogDebug, edm::one::EDProducerBase::moduleDescription(), 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);
     }
   }

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

privatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 503 of file MixingModule.cc.

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

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

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

virtual

Reimplemented from edm::BMixingModule.

Definition at line 226 of file MixingModule.cc.

References edm::BMixingModule::bunchSpace_, HDQMDatabaseProducer::config, edm::EventSetup::get(), cuy::ii, edm::BMixingModule::maxBunch_, edm::BMixingModule::minBunch_, and workersObjects_.

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