PFPileUp Class Reference

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

Inheritance diagram for PFPileUp:

Public Types
typedef edm::Association < reco::VertexCollection >	CandToVertex
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...
bool	fUseVertexAssociation
PFPileUpAlgo	pileUpAlgo_
edm::EDGetTokenT< PFCollection >	tokenPFCandidates_
	PFCandidates to be analyzed. More...
edm::EDGetTokenT< PFView >	tokenPFCandidatesView_
	fall-back token More...
edm::EDGetTokenT< CandToVertex >	tokenVertexAssociation_
edm::EDGetTokenT < edm::ValueMap< int > >	tokenVertexAssociationQuality_
edm::EDGetTokenT < reco::VertexCollection >	tokenVertices_
	vertices More...
bool	verbose_
	verbose ? More...
int	vertexAssociationQuality_

Detailed Description

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

Author

Colin Bernet

Date

february 2008 Florian Beaudette 30/03/2012

Definition at line 42 of file PFPileUp.cc.

Member Typedef Documentation

typedef edm::Association<reco::VertexCollection> PFPileUp::CandToVertex

Definition at line 47 of file PFPileUp.cc.

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

Definition at line 44 of file PFPileUp.cc.

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

Definition at line 46 of file PFPileUp.cc.

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

Definition at line 45 of file PFPileUp.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 81 of file PFPileUp.cc.

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

                                                 {
  tokenPFCandidates_ = consumes<PFCollection>(iConfig.getParameter<InputTag>("PFCandidates"));
  tokenPFCandidatesView_ = mayConsume<PFView>(iConfig.getParameter<InputTag>("PFCandidates"));

  tokenVertices_ = consumes<VertexCollection>(iConfig.getParameter<InputTag>("Vertices"));

  fUseVertexAssociation = iConfig.getParameter<bool>("useVertexAssociation");
  vertexAssociationQuality_ = iConfig.getParameter<int>("vertexAssociationQuality");
  if (fUseVertexAssociation) {
    tokenVertexAssociation_ = consumes<CandToVertex>(iConfig.getParameter<edm::InputTag>("vertexAssociation"));
    tokenVertexAssociationQuality_ =
        consumes<edm::ValueMap<int>>(iConfig.getParameter<edm::InputTag>("vertexAssociation"));
  }

  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 > ();
}

PFPileUp::~PFPileUp ( )

override

Definition at line 114 of file PFPileUp.cc.

{}

Member Function Documentation

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

override

Definition at line 116 of file PFPileUp.cc.

References Exception, edm::Event::get(), edm::Event::getByToken(), edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), eostools::move(), AlCaHLTBitMon_ParallelJobs::p, slimmedMuons_cfi::pfCandidates, edm::Handle< T >::product(), edm::Event::put(), quality, and beam_dqm_sourceclient-live_cfg::vertices.

                                                              {
  //   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.");
    }

    if (fUseVertexAssociation) {
      const edm::Association<reco::VertexCollection>& associatedPV = iEvent.get(tokenVertexAssociation_);
      const edm::ValueMap<int>& associationQuality = iEvent.get(tokenVertexAssociationQuality_);
      PFCollection pfCandidatesFromPU;
      for (auto& p : (*pfCandidatesRef)) {
        const reco::VertexRef& PVOrig = associatedPV[p];
        int quality = associationQuality[p];
        if (PVOrig.isNonnull() && (PVOrig.key() > 0) && (quality >= vertexAssociationQuality_))
          pfCandidatesFromPU.push_back(p);
      }
      pOutput->insert(pOutput->end(), pfCandidatesFromPU.begin(), pfCandidatesFromPU.end());
    } else {
      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));
}

Member Data Documentation

bool PFPileUp::checkClosestZVertex_

private

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

Definition at line 73 of file PFPileUp.cc.

bool PFPileUp::enable_

private

enable PFPileUp selection

Definition at line 67 of file PFPileUp.cc.

bool PFPileUp::fUseVertexAssociation

private

Definition at line 77 of file PFPileUp.cc.

PFPileUpAlgo PFPileUp::pileUpAlgo_

private

Definition at line 56 of file PFPileUp.cc.

edm::EDGetTokenT<PFCollection> PFPileUp::tokenPFCandidates_

private

PFCandidates to be analyzed.

Definition at line 59 of file PFPileUp.cc.

edm::EDGetTokenT<PFView> PFPileUp::tokenPFCandidatesView_

private

fall-back token

Definition at line 61 of file PFPileUp.cc.

edm::EDGetTokenT<CandToVertex> PFPileUp::tokenVertexAssociation_

private

Definition at line 75 of file PFPileUp.cc.

edm::EDGetTokenT<edm::ValueMap<int> > PFPileUp::tokenVertexAssociationQuality_

private

Definition at line 76 of file PFPileUp.cc.

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

private

vertices

Definition at line 64 of file PFPileUp.cc.

bool PFPileUp::verbose_

private

verbose ?

Definition at line 70 of file PFPileUp.cc.

int PFPileUp::vertexAssociationQuality_

private

Definition at line 78 of file PFPileUp.cc.