PFPileUp Class Reference

Identifies pile-up candidates from a collection of PFCandidates, and produces the corresponding collection of PileUpCandidates. More...

#include <PFPileUp.h>

Inheritance diagram for PFPileUp:

Public Types
typedef std::vector< edm::FwdPtr< reco::PFCandidate > >	PFCollection
typedef std::vector< reco::PFCandidate >	PFCollectionByValue
typedef edm::View< reco::PFCandidate >	PFView
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Public Member Functions
	PFPileUp (const edm::ParameterSet &)
void	produce (edm::Event &, const edm::EventSetup &) override
	~PFPileUp () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Private Attributes
bool	checkClosestZVertex_
	use the closest z vertex if a track is not in a vertex More...
bool	enable_
	enable PFPileUp selection More...
PFPileUpAlgo	pileUpAlgo_
edm::EDGetTokenT< PFCollection >	tokenPFCandidates_
	PFCandidates to be analyzed. More...
edm::EDGetTokenT< PFView >	tokenPFCandidatesView_
	fall-back token More...
edm::EDGetTokenT< reco::VertexCollection >	tokenVertices_
	vertices More...
bool	verbose_
	verbose ? More...

Detailed Description

Identifies pile-up candidates from a collection of PFCandidates, and produces the corresponding collection of PileUpCandidates.

Author

Colin Bernet

Date

february 2008 \updated Florian Beaudette 30/03/2012

Definition at line 31 of file PFPileUp.h.

Member Typedef Documentation

PFCollection

typedef std::vector<edm::FwdPtr<reco::PFCandidate> > PFPileUp::PFCollection

Definition at line 33 of file PFPileUp.h.

PFCollectionByValue

typedef std::vector<reco::PFCandidate> PFPileUp::PFCollectionByValue

Definition at line 35 of file PFPileUp.h.

PFView

typedef edm::View<reco::PFCandidate> PFPileUp::PFView

Definition at line 34 of file PFPileUp.h.

Constructor & Destructor Documentation

PFPileUp()

PFPileUp::PFPileUp ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 17 of file PFPileUp.cc.

                                                 {
  tokenPFCandidates_ = consumes<PFCollection>(iConfig.getParameter<InputTag>("PFCandidates"));
  tokenPFCandidatesView_ = mayConsume<PFView>(iConfig.getParameter<InputTag>("PFCandidates"));
 
  tokenVertices_ = consumes<VertexCollection>(iConfig.getParameter<InputTag>("Vertices"));
 
  enable_ = iConfig.getParameter<bool>("Enable");
 
  verbose_ = iConfig.getUntrackedParameter<bool>("verbose", false);
 
  if (iConfig.exists("checkClosestZVertex")) {
    checkClosestZVertex_ = iConfig.getParameter<bool>("checkClosestZVertex");
  } else {
    checkClosestZVertex_ = false;
  }
 
  // Configure the algo
  pileUpAlgo_.setVerbose(verbose_);
  pileUpAlgo_.setCheckClosestZVertex(checkClosestZVertex_);
 
  //produces<reco::PFCandidateCollection>();
  produces<PFCollection>();
  // produces< PFCollectionByValue > ();
}

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), and edm::ParameterSet::getUntrackedParameter().

~PFPileUp()

PFPileUp::~PFPileUp ( )

override

Definition at line 42 of file PFPileUp.cc.

{}

Member Function Documentation

produce()

void PFPileUp::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

override

Definition at line 44 of file PFPileUp.cc.

                                                              {
  //   LogDebug("PFPileUp")<<"START event: "<<iEvent.id().event()
  //             <<" in run "<<iEvent.id().run()<<endl;
 
  // get PFCandidates
 
  unique_ptr<PFCollection> pOutput(new PFCollection);
 
  unique_ptr<PFCollectionByValue> pOutputByValue(new PFCollectionByValue);
 
  if (enable_) {
    // get vertices
    Handle<VertexCollection> vertices;
    iEvent.getByToken(tokenVertices_, vertices);
 
    // get PF Candidates
    Handle<PFCollection> pfCandidates;
    PFCollection const* pfCandidatesRef = nullptr;
    PFCollection usedIfNoFwdPtrs;
    bool getFromFwdPtr = iEvent.getByToken(tokenPFCandidates_, pfCandidates);
    if (getFromFwdPtr) {
      pfCandidatesRef = pfCandidates.product();
    }
    // Maintain backwards-compatibility.
    // If there is no vector of FwdPtr<PFCandidate> found, then
    // make a dummy vector<FwdPtr<PFCandidate> > for the PFPileupAlgo,
    // set the pointer "pfCandidatesRef" to point to it, and
    // then we can pass it to the PFPileupAlgo.
    else {
      Handle<PFView> pfView;
      bool getFromView = iEvent.getByToken(tokenPFCandidatesView_, pfView);
      if (!getFromView) {
        throw cms::Exception(
            "PFPileUp is misconfigured. This needs to be either vector<FwdPtr<PFCandidate> >, or View<PFCandidate>");
      }
      for (edm::View<reco::PFCandidate>::const_iterator viewBegin = pfView->begin(),
                                                        viewEnd = pfView->end(),
                                                        iview = viewBegin;
           iview != viewEnd;
           ++iview) {
        usedIfNoFwdPtrs.push_back(
            edm::FwdPtr<reco::PFCandidate>(pfView->ptrAt(iview - viewBegin), pfView->ptrAt(iview - viewBegin)));
      }
      pfCandidatesRef = &usedIfNoFwdPtrs;
    }
 
    if (pfCandidatesRef == nullptr) {
      throw cms::Exception(
          "Something went dreadfully wrong with PFPileUp. pfCandidatesRef should never be zero, so this is a logic "
          "error.");
    }
 
    pileUpAlgo_.process(*pfCandidatesRef, *vertices);
    pOutput->insert(
        pOutput->end(), pileUpAlgo_.getPFCandidatesFromPU().begin(), pileUpAlgo_.getPFCandidatesFromPU().end());
 
    // for ( PFCollection::const_iterator byValueBegin = pileUpAlgo_.getPFCandidatesFromPU().begin(),
    //      byValueEnd = pileUpAlgo_.getPFCandidatesFromPU().end(), ibyValue = byValueBegin;
    //    ibyValue != byValueEnd; ++ibyValue ) {
    //   pOutputByValue->push_back( **ibyValue );
    // }
 
  }  // end if enabled
  // outsize of the loop to fill the collection anyway even when disabled
  iEvent.put(std::move(pOutput));
  // iEvent.put(std::move(pOutputByValue));
}

References Exception, iEvent, eostools::move(), zmumugammaAnalyzer_cfi::pfCandidates, and AlignmentTracksFromVertexSelector_cfi::vertices.

Member Data Documentation

checkClosestZVertex_

bool PFPileUp::checkClosestZVertex_

private

use the closest z vertex if a track is not in a vertex

Definition at line 61 of file PFPileUp.h.

enable_

bool PFPileUp::enable_

private

enable PFPileUp selection

Definition at line 55 of file PFPileUp.h.

pileUpAlgo_

PFPileUpAlgo PFPileUp::pileUpAlgo_

private

Definition at line 44 of file PFPileUp.h.

tokenPFCandidates_

edm::EDGetTokenT<PFCollection> PFPileUp::tokenPFCandidates_

private

PFCandidates to be analyzed.

Definition at line 47 of file PFPileUp.h.

tokenPFCandidatesView_

edm::EDGetTokenT<PFView> PFPileUp::tokenPFCandidatesView_

private

fall-back token

Definition at line 49 of file PFPileUp.h.

tokenVertices_

edm::EDGetTokenT<reco::VertexCollection> PFPileUp::tokenVertices_

private

vertices

Definition at line 52 of file PFPileUp.h.

verbose_

bool PFPileUp::verbose_

private

verbose ?

Definition at line 58 of file PFPileUp.h.