#include <MixingModule.h>

Inheritance diagram for edm::MixingModule:

Public Member Functions
virtual void	beginJob ()

	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

virtual void	beginLuminosityBlock (edm::LuminosityBlock &, edm::EventSetup const &)

virtual void	beginRun (edm::Run &r, const edm::EventSetup &setup)

	BMixingModule (const edm::ParameterSet &ps)

virtual void	getEventStartInfo (edm::Event &e, const unsigned int source)

bool	poisson () const

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

virtual void	setBcrOffset ()

virtual void	setEventStartInfo (const unsigned int s)

virtual void	setSourceOffset (const unsigned int s)

virtual	~BMixingModule ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

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)

virtual void	createnewEDProduct ()

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

void	pileAllWorkers (EventPrincipal const &ep, int bcr, int id, int &offset)

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

Private Attributes
std::string	labelPlayback_

bool	mixProdStep1_

bool	mixProdStep2_

CrossingFramePlaybackInfoExtended *	playbackInfo_

Selector *	sel_

bool	useCurrentProcessOnly_

std::vector< std::string >	wantedBranches_

std::vector< MixingWorkerBase * >	workers_

std::vector< MixingWorkerBase * >	workersObjects_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

typedef WorkerT< EDProducer >	WorkerType

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

Static Public Member Functions inherited from edm::EDProducer
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 ()

void	update (edm::EventSetup const &)

Protected Member Functions inherited from edm::EDProducer
CurrentProcessingContext const *	currentContext () const

Protected Member Functions inherited from edm::ProducerBase
template<class TProducer , class TMethod >
void	callWhenNewProductsRegistered (TProducer *iProd, TMethod iMethod)

Protected Attributes inherited from edm::BMixingModule
int	bunchSpace_

bool	checktof_

bool	doit_ [4]

unsigned int	eventId_

std::vector< boost::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_

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

static int	vertexoffset = 0

Detailed Description

Definition at line 44 of file MixingModule.h.

Constructor & Destructor Documentation

MixingModule::MixingModule ( const edm::ParameterSet & ps )

explicit

standard constructor

Definition at line 27 of file MixingModule.cc.

References branchesActivate(), edm::BMixingModule::bunchSpace_, edm::BMixingModule::dropUnwantedBranches(), edm::InputTag::encode(), edm::ParameterSet::exists(), spr::find(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), diffTwoXMLs::label, labelPlayback_, LogDebug, edm::BMixingModule::maxBunch_, edm::BMixingModule::maxNbSources_, edm::BMixingModule::minBunch_, mixProdStep1_, mixProdStep2_, h::names, sel_, edm::sort_all(), subdets, GlobalPosition_Frontier_DevDB_cff::tag, o2o::tags, useCurrentProcessOnly_, wantedBranches_, and workersObjects_.

                                                           : 
   BMixingModule(ps_mix),
   labelPlayback_(ps_mix.getParameter<std::string>("LabelPlayback")),
   mixProdStep2_(ps_mix.getParameter<bool>("mixProdStep2")),
   mixProdStep1_(ps_mix.getParameter<bool>("mixProdStep1"))
   {
     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_;
     }
     if (labelPlayback_.size()>0){
       sel_=new Selector( ModuleLabelSelector(labelPlayback_));
     }
     else {
       sel_=new Selector( MatchAllSelector());
     }
 
     ParameterSet ps=ps_mix.getParameter<ParameterSet>("mixObjects");
     std::vector<std::string> names = ps.getParameterNames();
     for (std::vector<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_){
       //SimTracks
           if (object=="SimTrackPCrossingFrame") {
             InputTag tag;
         if (tags.size()>0) tag=tags[0];
             std::string label;
             branchesActivate(TypeID(typeid(PCrossingFrame<SimTrack>)).friendlyClassName(),std::string(""),tag,label);
            
         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 ;
 
         //---------------------------------
         // set an appropriate label for the CrossingFrame
         if (find(names.begin(), names.end(), "mixTracks") != names.end())
             { 
            edm::ParameterSet psin=ps.getParameter<edm::ParameterSet>("mixTracks");
            if (!psin.exists("type"))  continue; //to allow replacement by empty pset
            std::string object = psin.getParameter<std::string>("type");
            std::vector<InputTag>  tags=psin.getParameter<std::vector<InputTag> >("input");
     
            InputTag tagCF;
            if (tags.size()>0) tagCF=tags[0];
                std::string labelCF;
        
            branchesActivate(TypeID(typeid(std::vector<SimTrack>)).friendlyClassName(),std::string(""),tagCF,labelCF);
            workersObjects_.push_back(new MixingWorker<SimTrack>(minBunch_,maxBunch_,bunchSpace_,std::string(""),label,labelCF,maxNbSources_,tag,tagCF,mixProdStep2_));  
            
            produces<CrossingFrame<SimTrack> >(labelCF);
         }       
         //--------------------------------      
 
           }else if (object=="SimVertexPCrossingFrame") {
             InputTag tag;
         if (tags.size()>0) tag=tags[0];
             std::string label;
             branchesActivate(TypeID(typeid(PCrossingFrame<SimVertex>)).friendlyClassName(),std::string(""),tag,label);
 
         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 ;
         
         //---------------------------------
         // set an appropriate label for the CrossingFrame
         if (find(names.begin(), names.end(), "mixVertices") != names.end())
             { 
                edm::ParameterSet psin=ps.getParameter<edm::ParameterSet>("mixVertices");
            if (!psin.exists("type"))  continue; //to allow replacement by empty pset
            std::string object = psin.getParameter<std::string>("type");
            std::vector<InputTag>  tags=psin.getParameter<std::vector<InputTag> >("input");
            
            InputTag tagCF;
            if (tags.size()>0) tagCF=tags[0];
                std::string labelCF;
            
                branchesActivate(TypeID(typeid(std::vector<SimVertex>)).friendlyClassName(),std::string(""),tagCF,labelCF);
            workersObjects_.push_back(new MixingWorker<SimVertex>(minBunch_,maxBunch_,bunchSpace_,std::string(""),label,labelCF,maxNbSources_,tag,tagCF,mixProdStep2_));  
 
            produces<CrossingFrame<SimVertex> >(labelCF);
         }
         //---------------------------------
       }
 
       else if (object=="HepMCProductPCrossingFrame") {
             InputTag tag;
         if (tags.size()>0) tag=tags[0];
             std::string label;
             branchesActivate(TypeID(typeid(PCrossingFrame<HepMCProduct>)).friendlyClassName(),std::string(""),tag,label);
 
         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;
         
         //---------------------------------
         // set an appropriate label for the CrossingFrame
         if (find(names.begin(), names.end(), "mixHepMC") != names.end())
             {   
                edm::ParameterSet psin=ps.getParameter<edm::ParameterSet>("mixHepMC");
            if (!psin.exists("type"))  continue; //to allow replacement by empty pset
            std::string object = psin.getParameter<std::string>("type");
            std::vector<InputTag>  tags=psin.getParameter<std::vector<InputTag> >("input");
            
            InputTag tagCF;
            if (tags.size()>0) tagCF=tags[0];
                std::string labelCF;
                   
            branchesActivate(TypeID(typeid(HepMCProduct)).friendlyClassName(),std::string(""),tagCF,labelCF);
            workersObjects_.push_back(new MixingWorker<HepMCProduct>(minBunch_,maxBunch_,bunchSpace_,std::string(""),label,labelCF,maxNbSources_,tag,tagCF,mixProdStep2_));  
 
            produces<CrossingFrame<HepMCProduct> >(labelCF);
         }
         //--------------------------------  
           }else if (object=="PCaloHitPCrossingFrame") {
             std::vector<std::string> subdets=pset.getParameter<std::vector<std::string> >("subdets");
         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(PCrossingFrame<PCaloHit>)).friendlyClassName(),subdets[ii],tag,label);
 
           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;
           
           //---------------------------------
           // set an appropriate label for the product CrossingFrame
           if (find(names.begin(), names.end(), "mixCH") != names.end())
               {  
                  edm::ParameterSet psin=ps.getParameter<edm::ParameterSet>("mixCH");
              if (!psin.exists("type"))  continue; //to allow replacement by empty pset
              std::string object = psin.getParameter<std::string>("type");
              std::vector<InputTag>  tags=psin.getParameter<std::vector<InputTag> >("input");
            
              InputTag tagCF;
              if (tags.size()==1) tagCF=tags[0];
          else if(tags.size()>1) tagCF=tags[ii];
                  std::string labelCF;
         
              branchesActivate(TypeID(typeid(std::vector<PCaloHit>)).friendlyClassName(),subdets[ii],tagCF,labelCF);
              workersObjects_.push_back(new MixingWorker<PCaloHit>(minBunch_,maxBunch_,bunchSpace_,subdets[ii],label,labelCF,maxNbSources_,tag,tagCF,mixProdStep2_));  
 
          produces<CrossingFrame<PCaloHit> > (labelCF);
           }
           //--------------------------------
         }
 
           }else if (object=="PSimHitPCrossingFrame") {
         std::vector<std::string> subdets=pset.getParameter<std::vector<std::string> >("subdets");
         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(PCrossingFrame<PSimHit>)).friendlyClassName(),subdets[ii],tag,label);
        
           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;
           
           
           //---------------------------------
           // set an appropriate label for the CrossingFrame
           if (find(names.begin(), names.end(), "mixSH") != names.end())
               { 
                  edm::ParameterSet psin=ps.getParameter<edm::ParameterSet>("mixSH");
              if (!psin.exists("type"))  continue; //to allow replacement by empty pset
              std::string object = psin.getParameter<std::string>("type");
              std::vector<InputTag>  tags=psin.getParameter<std::vector<InputTag> >("input");
            
              InputTag tagCF;
              if (tags.size()==1) tagCF=tags[0];
          else if(tags.size()>1) tagCF=tags[ii];
                  std::string labelCF;
              branchesActivate(TypeID(typeid(std::vector<PSimHit>)).friendlyClassName(),subdets[ii],tagCF,labelCF);             
          workersObjects_.push_back(new MixingWorker<PSimHit>(minBunch_,maxBunch_,bunchSpace_,subdets[ii],label,labelCF,maxNbSources_,tag,tagCF,mixProdStep2_));                 
         
              produces<CrossingFrame<PSimHit> > (labelCF);
           }
           //-------------------------------
         }
 
       }
       }//mixProdStep2
      
       
       if (!mixProdStep2_){
         
       InputTag tagCF = InputTag();
       std::string labelCF = " ";      
       
       //SimTracks
           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);
         workersObjects_.push_back(new MixingWorker<SimTrack>(minBunch_,maxBunch_,bunchSpace_,std::string(""),label,labelCF,maxNbSources_,tag,tagCF,mixProdStep2_));  
 
         produces<CrossingFrame<SimTrack> >(label);
         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);
         
         workersObjects_.push_back(new MixingWorker<SimVertex>(minBunch_,maxBunch_,bunchSpace_,std::string(""),label,labelCF,maxNbSources_,tag,tagCF,mixProdStep2_));  
         produces<CrossingFrame<SimVertex> >(label);
         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);
         workersObjects_.push_back(new MixingWorker<HepMCProduct>(minBunch_,maxBunch_,bunchSpace_,std::string(""),label,labelCF,maxNbSources_,tag,tagCF,mixProdStep2_));  
             
         produces<CrossingFrame<HepMCProduct> >(label);
         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");
         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);
           workersObjects_.push_back(new MixingWorker<PCaloHit>(minBunch_,maxBunch_,bunchSpace_,subdets[ii],label,labelCF,maxNbSources_,tag,tagCF,mixProdStep2_));  
 
           produces<CrossingFrame<PCaloHit> > (label);
           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");
         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);
               workersObjects_.push_back(new MixingWorker<PSimHit>(minBunch_,maxBunch_,bunchSpace_,subdets[ii],label,labelCF,maxNbSources_,tag,tagCF,mixProdStep2_));  
 
               produces<CrossingFrame<PSimHit> > (label);
           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<CrossingFramePlaybackInfoExtended>();
   }

MixingModule::~MixingModule ( )

virtual

Default destructor

Definition at line 363 of file MixingModule.cc.

References sel_, and workersObjects_.

                               { 
     for (unsigned int ii=0;ii<workersObjects_.size();ii++){ 
       delete workersObjects_[ii];}
     delete sel_;  
   }  

Member Function Documentation

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

privatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 369 of file MixingModule.cc.

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

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

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

inlinevirtual

Reimplemented from edm::EDProducer.

Definition at line 54 of file MixingModule.h.

54 {}

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

privatevirtual

Definition at line 324 of file MixingModule.cc.

References EgammaHLTValidationUtils::getProcessName(), edm::InputTag::instance(), edm::InputTag::label(), 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 340 of file MixingModule.cc.

References workers_, and workersObjects_.

                                                  {
     if (workers_.size()==0){
       for (unsigned int ii=0;ii<workersObjects_.size();ii++){
         if (workersObjects_[ii]->checkSignal(e)){
           workers_.push_back(workersObjects_[ii]);
         }
       }
     }
   }

void MixingModule::createnewEDProduct ( )

privatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 351 of file MixingModule.cc.

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

                                         {
     //create playback info
     playbackInfo_=new CrossingFramePlaybackInfoExtended(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
	)

privatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 395 of file MixingModule.cc.

References edm::hlt::Exception, edm::Event::get(), edm::EventBase::id(), edm::BMixingModule::inputSources_, edm::BMixingModule::maxBunch_, edm::BMixingModule::maxNbSources_, edm::BMixingModule::minBunch_, mixProdStep2_, pileAllWorkers(), edm::BMixingModule::playback_, playbackInfo_, edm::Event::put(), sel_, CrossingFramePlaybackInfoExtended::setStartEventId(), LaserTracksInput_cfi::source, edm::BMixingModule::TrueNumInteractions_, and workers_.

   {
     // Don't allocate because PileUp will do it for us.
     std::vector<edm::EventID> recordEventID;
     edm::Handle<CrossingFramePlaybackInfoExtended>  playbackInfo_H;
     if (playback_) {
       bool got=e.get((*sel_), playbackInfo_H); 
       if (!got) {
         throw cms::Exception("MixingProductNotFound") << " No "
           "CrossingFramePlaybackInfoExtended on the input file, but playback "
           "option set!!!!! Please change the input file if you really want "
           "playback!!!!!!"  << endl;    
       }
     }
 
     // source[0] is "real" pileup.  Check to see that this is what we are doing.
 
     std::vector<int> PileupList;
     PileupList.clear();
     TrueNumInteractions_.clear();
 
     boost::shared_ptr<PileUp> source0 = inputSources_[0];
 
     if( (source0 && source0->doPileUp() ) && !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_);      
 
     }
 
     //    for (int bunchIdx = minBunch_; bunchIdx <= maxBunch_; ++bunchIdx) {
     //  std::cout << " bunch ID, Pileup, True " << bunchIdx << " " << PileupList[bunchIdx-minBunch_] << " " <<  TrueNumInteractions_[bunchIdx-minBunch_] << std::endl;
     //}
 
     int KeepTrackOfPileup = 0;
 
     for (int bunchIdx = minBunch_; bunchIdx <= maxBunch_; ++bunchIdx) {
       for ( size_t setBcrIdx=0; setBcrIdx<workers_.size(); setBcrIdx++) {
         workers_[setBcrIdx]->setBcrOffset();
       }
 
       for ( size_t readSrcIdx=0; readSrcIdx<maxNbSources_; readSrcIdx++ ) {
         boost::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()) continue;
 
     int NumPU_Events = 0;
 
     if(readSrcIdx ==0 && !playback_) { NumPU_Events = PileupList[bunchIdx - minBunch_];}
     else { NumPU_Events = 1;}  // non-minbias pileup only gets one event for now. Fix later if desired.
 
     //        int eventId = 0;
     int vertexOffset = 0;
 
         if (!playback_) {
           inputSources_[readSrcIdx]->readPileUp(e.id(), recordEventID,
             boost::bind(&MixingModule::pileAllWorkers, boost::ref(*this), _1, bunchIdx,
                         _2, vertexOffset), NumPU_Events
             );
           playbackInfo_->setStartEventId(recordEventID, readSrcIdx, bunchIdx, KeepTrackOfPileup);
           KeepTrackOfPileup+=NumPU_Events;
         } else {
       int dummyId = 0 ;
           const std::vector<edm::EventID>& playEventID =
             playbackInfo_H->getStartEventId(readSrcIdx, bunchIdx);
       if(readSrcIdx == 0) {
         PileupList.push_back(playEventID.size());
         TrueNumInteractions_.push_back(playEventID.size());
       }
           inputSources_[readSrcIdx]->playPileUp(
             playEventID,
             boost::bind(&MixingModule::pileAllWorkers, boost::ref(*this), _1, bunchIdx,
                         dummyId, vertexOffset)
             );
         }
       }
     }
 
     // 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()) {
         numInteractionList.push_back(0);
         TrueInteractionList.push_back(0);
       }
       else {
         numInteractionList.push_back(PileupList[bunchCrossing-minBunch_]);
         TrueInteractionList.push_back((TrueNumInteractions_)[bunchCrossing-minBunch_]); 
       }
     }
 
     
     PileupMixing_ = std::auto_ptr< PileupMixingContent >(new PileupMixingContent( bunchCrossingList,
                                           numInteractionList,
                                           TrueInteractionList));
 
     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++) {
         //not apply setTof in Step2 mode because it was done in the Step1
     if (!mixProdStep2_){ 
           workers_[ii]->setTof();
     }
         workers_[ii]->put(e);
       }
  }

void MixingModule::pileAllWorkers	(	EventPrincipal const &	ep,
		int	bcr,
		int	id,
		int &	offset
	)

private

Definition at line 379 of file MixingModule.cc.

References edm::EventPrincipal::id(), LogDebug, edm::BMixingModule::vertexoffset, and workers_.

Referenced by doPileUp().

   {
     for (unsigned int ii=0;ii<workers_.size();ii++) {
       LogDebug("MixingModule") <<" merging Event:  id " << eventPrincipal.id();
       //      std::cout <<"PILEALLWORKERS merging Event:  id " << eventPrincipal.id() << std::endl;
 
         workers_[ii]->addPileups(bunchCrossing,eventPrincipal,
                  //                                 ++eventId,vertexoffset);
                                  eventId,vertexoffset);
     }
   }

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

privatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 521 of file MixingModule.cc.

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

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

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

virtual

Reimplemented from edm::BMixingModule.

Definition at line 310 of file MixingModule.cc.

References edm::BMixingModule::bunchSpace_, HDQMDatabaseProducer::config, edm::EventSetup::get(), 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);
     }
   }