#include <DataMixingPileupCopy.h>

Public Member Functions
void	addPileupInfo (const edm::EventPrincipal , unsigned int EventId, ModuleCallingContext const mcc)

	DataMixingPileupCopy ()

	DataMixingPileupCopy (const edm::ParameterSet &ps, edm::ConsumesCollector &&iC)

void	getPileupInfo (std::vector< PileupSummaryInfo > &ps, int &bs)

void	putPileupInfo (edm::Event &e)

virtual	~DataMixingPileupCopy ()

Private Attributes
int	bsStorage_

edm::InputTag	BunchSpacingInputTag_

edm::InputTag	CFPlaybackInputTag_

CrossingFramePlaybackInfoNew	CrossingFramePlaybackStorage_

bool	FoundPlayback_

std::string	label_

edm::InputTag	PileupInfoInputTag_

std::vector< PileupSummaryInfo >	PileupSummaryStorage_

Detailed Description

Definition at line 37 of file DataMixingPileupCopy.h.

Constructor & Destructor Documentation

DataMixingPileupCopy::DataMixingPileupCopy ( )

Definition at line 27 of file DataMixingPileupCopy.cc.

27 { }

DataMixingPileupCopy::DataMixingPileupCopy	(	const edm::ParameterSet &	ps,
		edm::ConsumesCollector &&	iC
	)

explicit

standard constructor

Definition at line 30 of file DataMixingPileupCopy.cc.

References BunchSpacingInputTag_, CFPlaybackInputTag_, edm::ParameterSet::getParameter(), and PileupInfoInputTag_.

                                                                                                   : 
                                 label_(ps.getParameter<std::string>("Label"))
 
   {                                                         
 
     // Pileup/Playback information
 
     PileupInfoInputTag_ = ps.getParameter<edm::InputTag>("PileupInfoInputTag");
     BunchSpacingInputTag_ = ps.getParameter<edm::InputTag>("BunchSpacingInputTag");
     CFPlaybackInputTag_ = ps.getParameter<edm::InputTag>("CFPlaybackInputTag");
 
 
     // apparently, we don't need consumes from Secondary input stream
     //iC.consumes<std::vector<PileupSummaryInfo>>(PileupInfoInputTag_);
     //iC.consumes<int>(BunchSpacingInputTag_);
     //iC.consumes<CrossingFramePlaybackInfoNew>(CFPlaybackInputTag_);
   }

DataMixingPileupCopy::~DataMixingPileupCopy ( )

virtual

Default destructor

Definition at line 49 of file DataMixingPileupCopy.cc.

49 {

50 }

Member Function Documentation

void DataMixingPileupCopy::addPileupInfo	(	const edm::EventPrincipal *	ep,
		unsigned int	EventId,
		ModuleCallingContext const *	mcc
	)

Definition at line 53 of file DataMixingPileupCopy.cc.

References bsStorage_, BunchSpacingInputTag_, CFPlaybackInputTag_, CrossingFramePlaybackStorage_, FoundPlayback_, edm::EventPrincipal::id(), LogDebug, PileupInfoInputTag_, and PileupSummaryStorage_.

Referenced by edm::DataMixingModule::pileWorker().

                                                                             {
   
     LogDebug("DataMixingPileupCopy") <<"\n===============> adding pileup Info from event  "<<ep->id();
 
     // find PileupSummaryInfo, CFPlayback information, if it's there
 
     // Pileup info first
 
     std::shared_ptr<Wrapper< std::vector<PileupSummaryInfo> >  const> PileupInfoPTR =
       getProductByTag<std::vector<PileupSummaryInfo>>(*ep,PileupInfoInputTag_, mcc);
 
     std::shared_ptr<Wrapper< int >  const> bsPTR =
       getProductByTag<int>(*ep,BunchSpacingInputTag_, mcc);
 
     if(PileupInfoPTR ) {
       PileupSummaryStorage_ = *(PileupInfoPTR->product()) ;
       LogDebug("DataMixingEMWorker") << "PileupInfo Size: " << PileupSummaryStorage_.size();
     }
 
     if(bsPTR ) {
       bsStorage_ = *(bsPTR->product()) ;
     }
     else {
       bsStorage_=10000;
     }
 
     // Playback
     std::shared_ptr<Wrapper<CrossingFramePlaybackInfoNew>  const> PlaybackPTR =
       getProductByTag<CrossingFramePlaybackInfoNew>(*ep,CFPlaybackInputTag_, mcc);
     FoundPlayback_ = false;
     if(PlaybackPTR ) {
       CrossingFramePlaybackStorage_ = *(PlaybackPTR->product()) ;
       FoundPlayback_ = true;
     }
   }

void edm::DataMixingPileupCopy::getPileupInfo	(	std::vector< PileupSummaryInfo > &	ps,
		int &	bs
	)

inline

Definition at line 53 of file DataMixingPileupCopy.h.

References bsStorage_, and PileupSummaryStorage_.

Referenced by edm::DataMixingModule::put().

53 { ps=PileupSummaryStorage_; bs=bsStorage_;}

edm::DataMixingPileupCopy::bsStorage_

int bsStorage_

Definition: DataMixingPileupCopy.h:68

edm::DataMixingPileupCopy::PileupSummaryStorage_

std::vector< PileupSummaryInfo > PileupSummaryStorage_

Definition: DataMixingPileupCopy.h:67

void DataMixingPileupCopy::putPileupInfo ( edm::Event & e )

Definition at line 90 of file DataMixingPileupCopy.cc.

References bsStorage_, CrossingFramePlaybackStorage_, FoundPlayback_, eostools::move(), PileupSummaryStorage_, and edm::Event::put().

Referenced by edm::DataMixingModule::put().

                                                       {
     std::unique_ptr<std::vector<PileupSummaryInfo> > PSIVector(new std::vector<PileupSummaryInfo>);
     std::unique_ptr<int> bsInt(new int);
 
     std::vector<PileupSummaryInfo>::const_iterator PSiter;
     for(PSiter = PileupSummaryStorage_.begin(); PSiter != PileupSummaryStorage_.end(); PSiter++){
       PSIVector->push_back(*PSiter);
     }
 
     *bsInt=bsStorage_;
 
     if(FoundPlayback_ ) {
       std::unique_ptr<CrossingFramePlaybackInfoNew> CFPlaybackInfo(new CrossingFramePlaybackInfoNew(CrossingFramePlaybackStorage_));
       e.put(std::move(CFPlaybackInfo));
     }
     e.put(std::move(PSIVector));
     e.put(std::move(bsInt),"bunchSpacing");
 
     // clear local storage after this event
     PileupSummaryStorage_.clear();
   }