#include <PreMixingPileupCopy.h>

Public Member Functions
void	addPileupInfo (PileUpEventPrincipal const &pep)

int	getBunchSpacing () const

const std::vector< PileupSummaryInfo > &	getPileupSummaryInfo () const

float	getTrueNumInteractions (PileUpEventPrincipal const &pep) const

	PreMixingPileupCopy (const edm::ParameterSet &ps, edm::ProducesCollector, edm::ConsumesCollector &&iC)

void	putPileupInfo (edm::Event &e)

	~PreMixingPileupCopy ()=default

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_

edm::InputTag	pileupInfoInputTag_

std::vector< PileupSummaryInfo >	pileupSummaryStorage_

Detailed Description

Definition at line 34 of file PreMixingPileupCopy.h.

Constructor & Destructor Documentation

◆ PreMixingPileupCopy()

PreMixingPileupCopy::PreMixingPileupCopy	(	const edm::ParameterSet &	ps,
		edm::ProducesCollector	producesCollector,
		edm::ConsumesCollector &&	iC
	)

Definition at line 12 of file PreMixingPileupCopy.cc.

       : 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")) {
     producesCollector.produces<std::vector<PileupSummaryInfo>>();
     producesCollector.produces<int>("bunchSpacing");
     producesCollector.produces<CrossingFramePlaybackInfoNew>();
  
     for (const auto& tag : genPUProtonsInputTags_) {
       producesCollector.produces<std::vector<reco::GenParticle>>(tag.label());
     }
   }

References genPUProtonsInputTags_, edm::ProducesCollector::produces(), and makeGlobalPositionRcd_cfg::tag.

◆ ~PreMixingPileupCopy()

edm::PreMixingPileupCopy::~PreMixingPileupCopy ( )

default

Member Function Documentation

◆ addPileupInfo()

void PreMixingPileupCopy::addPileupInfo ( PileUpEventPrincipal const & pep )

Definition at line 41 of file PreMixingPileupCopy.cc.

                                                                          {
     LogDebug("PreMixingPileupCopy") << "\n===============> adding pileup Info from event  " << pep.principal().id();
  
     // find PileupSummaryInfo, CFPlayback information, if it's there
  
     // Pileup info first
     edm::Handle<std::vector<PileupSummaryInfo>> pileupInfoHandle;
     pep.getByLabel(pileupInfoInputTag_, pileupInfoHandle);
  
     edm::Handle<int> bsHandle;
     pep.getByLabel(bunchSpacingInputTag_, bsHandle);
  
     if (pileupInfoHandle.isValid()) {
       pileupSummaryStorage_ = *pileupInfoHandle;
       LogDebug("PreMixingPileupCopy") << "PileupInfo Size: " << pileupSummaryStorage_.size();
     }
     bsStorage_ = bsHandle.isValid() ? *bsHandle : 10000;
  
     // Gen. PU protons
     edm::Handle<std::vector<reco::GenParticle>> genPUProtonsHandle;
     for (const auto& tag : genPUProtonsInputTags_) {
       pep.getByLabel(tag, genPUProtonsHandle);
       if (genPUProtonsHandle.isValid()) {
         genPUProtons_.push_back(*genPUProtonsHandle);
         genPUProtons_labels_.push_back(tag.label());
       } else {
         edm::LogWarning("PreMixingPileupCopy") << "Missing product with label: " << tag.label();
       }
     }
  
     // Playback
     edm::Handle<CrossingFramePlaybackInfoNew> playbackHandle;
     pep.getByLabel(cfPlaybackInputTag_, playbackHandle);
     foundPlayback_ = false;
     if (playbackHandle.isValid()) {
       crossingFramePlaybackStorage_ = *playbackHandle;
       foundPlayback_ = true;
     }
   }

References bsStorage_, bunchSpacingInputTag_, cfPlaybackInputTag_, crossingFramePlaybackStorage_, foundPlayback_, genPUProtons_, genPUProtons_labels_, genPUProtonsInputTags_, PileUpEventPrincipal::getByLabel(), edm::EventPrincipal::id(), edm::HandleBase::isValid(), LogDebug, pileupInfoInputTag_, pileupSummaryStorage_, PileUpEventPrincipal::principal(), and makeGlobalPositionRcd_cfg::tag.

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

◆ getBunchSpacing()

int edm::PreMixingPileupCopy::getBunchSpacing ( ) const

inline

Definition at line 43 of file PreMixingPileupCopy.h.

43 { return bsStorage_; }

References bsStorage_.

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

◆ getPileupSummaryInfo()

const std::vector<PileupSummaryInfo>& edm::PreMixingPileupCopy::getPileupSummaryInfo ( ) const

inline

Definition at line 42 of file PreMixingPileupCopy.h.

42 { return pileupSummaryStorage_; }

References pileupSummaryStorage_.

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

◆ getTrueNumInteractions()

float PreMixingPileupCopy::getTrueNumInteractions ( PileUpEventPrincipal const & pep ) const

Definition at line 28 of file PreMixingPileupCopy.cc.

                                                                                          {
     edm::Handle<std::vector<PileupSummaryInfo>> pileupInfoHandle;
     pep.getByLabel(pileupInfoInputTag_, pileupInfoHandle);
  
     auto it = std::find_if(
         pileupInfoHandle->begin(), pileupInfoHandle->end(), [](const auto& s) { return s.getBunchCrossing() == 0; });
     if (it == pileupInfoHandle->end()) {
       throw cms::Exception("LogicError") << "Did not find PileupSummaryInfo in bunch crossing 0";
     }
  
     return it->getTrueNumInteractions();
   }

References Exception, PileUpEventPrincipal::getByLabel(), pileupInfoInputTag_, and alignCSCRings::s.

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

◆ putPileupInfo()

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

Definition at line 81 of file PreMixingPileupCopy.cc.

                                                      {
     if (foundPlayback_) {
       e.put(std::make_unique<CrossingFramePlaybackInfoNew>(std::move(crossingFramePlaybackStorage_)));
     }
     e.put(std::make_unique<std::vector<PileupSummaryInfo>>(std::move(pileupSummaryStorage_)));
     e.put(std::make_unique<int>(bsStorage_), "bunchSpacing");
  
     // Gen. PU protons
     for (size_t idx = 0; idx < genPUProtons_.size(); ++idx) {
       e.put(std::make_unique<std::vector<reco::GenParticle>>(std::move(genPUProtons_[idx])), genPUProtons_labels_[idx]);
     }
  
     // clear local storage after this event
     pileupSummaryStorage_.clear();
     genPUProtons_.clear();
     genPUProtons_labels_.clear();
   }