#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::vector< std::vector< reco::GenParticle > >	GenPUProtons_

std::vector< std::string >	GenPUProtons_labels_

std::vector< edm::InputTag >	GenPUProtonsInputTags_

std::string	label_

edm::InputTag	PileupInfoInputTag_

std::vector< PileupSummaryInfo >	PileupSummaryStorage_

Detailed Description

Definition at line 40 of file DataMixingPileupCopy.h.

Constructor & Destructor Documentation

◆ DataMixingPileupCopy() [1/2]

DataMixingPileupCopy::DataMixingPileupCopy ( )

Definition at line 22 of file DataMixingPileupCopy.cc.

22 {}

◆ DataMixingPileupCopy() [2/2]

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

explicit

standard constructor

Definition at line 25 of file DataMixingPileupCopy.cc.

       : 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");
  
     GenPUProtonsInputTags_ = ps.getParameter<std::vector<edm::InputTag>>("GenPUProtonsInputTags");
  
     // apparently, we don't need consumes from Secondary input stream
     // iC.consumes<std::vector<PileupSummaryInfo>>(PileupInfoInputTag_);
     // iC.consumes<int>(BunchSpacingInputTag_);
     // iC.consumes<CrossingFramePlaybackInfoNew>(CFPlaybackInputTag_);
   }

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

◆ ~DataMixingPileupCopy()

DataMixingPileupCopy::~DataMixingPileupCopy ( )

virtual

Default destructor

Definition at line 44 of file DataMixingPileupCopy.cc.

44 {}

Member Function Documentation

◆ addPileupInfo()

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

Definition at line 46 of file DataMixingPileupCopy.cc.

                                                                             {
     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;
     }
  
     // Gen. PU protons
     std::shared_ptr<edm::Wrapper<std::vector<reco::GenParticle>> const> GenPUProtonsPTR;
     for (std::vector<edm::InputTag>::const_iterator it_InputTag = GenPUProtonsInputTags_.begin();
          it_InputTag != GenPUProtonsInputTags_.end();
          ++it_InputTag) {
       GenPUProtonsPTR = getProductByTag<std::vector<reco::GenParticle>>(*ep, *it_InputTag, mcc);
       if (GenPUProtonsPTR != nullptr) {
         GenPUProtons_.push_back(*(GenPUProtonsPTR->product()));
         GenPUProtons_labels_.push_back(it_InputTag->label());
       } else
         edm::LogWarning("DataMixingPileupCopy") << "Missing product with label: " << (*it_InputTag).label();
     }
  
     // Playback
     std::shared_ptr<Wrapper<CrossingFramePlaybackInfoNew> const> PlaybackPTR =
         getProductByTag<CrossingFramePlaybackInfoNew>(*ep, CFPlaybackInputTag_, mcc);
     FoundPlayback_ = false;
     if (PlaybackPTR) {
       CrossingFramePlaybackStorage_ = *(PlaybackPTR->product());
       FoundPlayback_ = true;
     }
   }

References bsStorage_, BunchSpacingInputTag_, CFPlaybackInputTag_, CrossingFramePlaybackStorage_, SiStripBadComponentsDQMServiceTemplate_cfg::ep, FoundPlayback_, GenPUProtons_, GenPUProtons_labels_, GenPUProtonsInputTags_, LogDebug, PileupInfoInputTag_, and PileupSummaryStorage_.

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

◆ getPileupInfo()

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

inline

Definition at line 53 of file DataMixingPileupCopy.h.

                                                                   {
       ps = PileupSummaryStorage_;
       bs = bsStorage_;
     }

References cms::cuda::bs, bsStorage_, and PileupSummaryStorage_.

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

◆ putPileupInfo()

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

Definition at line 94 of file DataMixingPileupCopy.cc.

                                                       {
     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");
  
     // Gen. PU protons
     for (size_t idx = 0; idx < GenPUProtons_.size(); ++idx) {
       std::unique_ptr<std::vector<reco::GenParticle>> GenPUProtons_ptr(new std::vector<reco::GenParticle>());
       std::vector<reco::GenParticle>::const_iterator it_GenParticle = GenPUProtons_.at(idx).begin();
       std::vector<reco::GenParticle>::const_iterator it_GenParticle_end = GenPUProtons_.at(idx).end();
       for (; it_GenParticle != it_GenParticle_end; ++it_GenParticle)
         GenPUProtons_ptr->push_back(*it_GenParticle);
  
       e.put(std::move(GenPUProtons_ptr), GenPUProtons_labels_.at(idx));
     }
  
     // clear local storage after this event
     PileupSummaryStorage_.clear();
     GenPUProtons_.clear();
     GenPUProtons_labels_.clear();
   }