#include <RecoJets/FFTJetProducers/plugins/FFTJetPFPileupCleaner.cc>

Inheritance diagram for FFTJetPFPileupCleaner:

Public Member Functions
	FFTJetPFPileupCleaner (const edm::ParameterSet &)

	FFTJetPFPileupCleaner ()=delete

	FFTJetPFPileupCleaner (const FFTJetPFPileupCleaner &)=delete

FFTJetPFPileupCleaner &	operator= (const FFTJetPFPileupCleaner &)=delete

	~FFTJetPFPileupCleaner () 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

Protected Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

Private Member Functions
void	buildRemovalMask ()

reco::VertexRef	findSomeVertexWFakes (const edm::Handle< reco::VertexCollection > &vertices, const edm::Handle< reco::VertexCollection > &fakeVertices, const reco::PFCandidate &pfcand, bool *fromFakeSet) const

bool	isAcceptableVtx (reco::VertexCollection::const_iterator iv) const

bool	isRemovable (reco::PFCandidate::ParticleType ptype) const

void	setRemovalBit (reco::PFCandidate::ParticleType ptype, bool onOff)

Private Attributes
bool	checkClosestZVertex

double	etaMax

double	etaMin

edm::InputTag	FakePrimaryVertices

edm::EDGetTokenT< reco::VertexCollection >	FakePrimaryVerticesToken

bool	keepIfPVneighbor

edm::InputTag	PFCandidates

edm::EDGetTokenT< reco::PFCandidateCollection >	PFCandidatesToken

unsigned	removalMask

bool	remove_e

bool	remove_egamma_HF

bool	remove_gamma

bool	remove_h

bool	remove_h0

bool	remove_h_HF

bool	remove_mu

bool	remove_X

bool	removeMainVertex

bool	removeUnassociated

bool	reverseRemovalDecision

bool	useFakePrimaryVertex

double	vertexNdofCut

double	vertexRhoCut

double	vertexZmaxCut

edm::InputTag	Vertices

edm::EDGetTokenT< reco::VertexCollection >	VerticesToken

std::vector< std::pair< double, unsigned > >	zAssoc

Additional Inherited Members
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

Detailed Description

Description: cleans up a collection of partice flow objects

Implementation: [Notes on implementation]

Definition at line 45 of file FFTJetPFPileupCleaner.cc.

Constructor & Destructor Documentation

◆ FFTJetPFPileupCleaner() [1/3]

FFTJetPFPileupCleaner::FFTJetPFPileupCleaner ( const edm::ParameterSet & ps )

explicit

Definition at line 136 of file FFTJetPFPileupCleaner.cc.

References buildRemovalMask(), FakePrimaryVertices, FakePrimaryVerticesToken, PFCandidates, PFCandidatesToken, useFakePrimaryVertex, Vertices, and VerticesToken.

     : init_param(edm::InputTag, PFCandidates),
       init_param(edm::InputTag, Vertices),
       init_param(edm::InputTag, FakePrimaryVertices),
       init_param(bool, useFakePrimaryVertex),
       init_param(bool, checkClosestZVertex),
       init_param(bool, keepIfPVneighbor),
       init_param(bool, removeMainVertex),
       init_param(bool, removeUnassociated),
       init_param(bool, reverseRemovalDecision),
       init_param(bool, remove_X),
       init_param(bool, remove_h),
       init_param(bool, remove_e),
       init_param(bool, remove_mu),
       init_param(bool, remove_gamma),
       init_param(bool, remove_h0),
       init_param(bool, remove_h_HF),
       init_param(bool, remove_egamma_HF),
       removalMask(0),
       init_param(double, etaMin),
       init_param(double, etaMax),
       init_param(double, vertexNdofCut),
       init_param(double, vertexZmaxCut),
       init_param(double, vertexRhoCut) {
   buildRemovalMask();
 
   PFCandidatesToken = consumes<reco::PFCandidateCollection>(PFCandidates);
   VerticesToken = consumes<reco::VertexCollection>(Vertices);
   if (useFakePrimaryVertex)
     FakePrimaryVerticesToken = consumes<reco::VertexCollection>(FakePrimaryVertices);
 
   produces<reco::PFCandidateCollection>();
 }

◆ FFTJetPFPileupCleaner() [2/3]

FFTJetPFPileupCleaner::FFTJetPFPileupCleaner ( )

delete

◆ FFTJetPFPileupCleaner() [3/3]

FFTJetPFPileupCleaner::FFTJetPFPileupCleaner ( const FFTJetPFPileupCleaner & )

delete

◆ ~FFTJetPFPileupCleaner()

FFTJetPFPileupCleaner::~FFTJetPFPileupCleaner ( )

override

Definition at line 170 of file FFTJetPFPileupCleaner.cc.

170 {}

Member Function Documentation

◆ buildRemovalMask()

void FFTJetPFPileupCleaner::buildRemovalMask ( )

private

Definition at line 435 of file FFTJetPFPileupCleaner.cc.

References reco::PFCandidate::e, reco::PFCandidate::egamma_HF, reco::PFCandidate::gamma, reco::PFCandidate::h, reco::PFCandidate::h0, reco::PFCandidate::h_HF, reco::PFCandidate::mu, remove_e, remove_egamma_HF, remove_gamma, remove_h, remove_h0, remove_h_HF, remove_mu, remove_X, setRemovalBit(), and reco::PFCandidate::X.

Referenced by FFTJetPFPileupCleaner().

                                              {
   setRemovalBit(reco::PFCandidate::X, remove_X);
   setRemovalBit(reco::PFCandidate::h, remove_h);
   setRemovalBit(reco::PFCandidate::e, remove_e);
   setRemovalBit(reco::PFCandidate::mu, remove_mu);
   setRemovalBit(reco::PFCandidate::gamma, remove_gamma);
   setRemovalBit(reco::PFCandidate::h0, remove_h0);
   setRemovalBit(reco::PFCandidate::h_HF, remove_h_HF);
   setRemovalBit(reco::PFCandidate::egamma_HF, remove_egamma_HF);
 }

◆ findSomeVertexWFakes()

reco::VertexRef FFTJetPFPileupCleaner::findSomeVertexWFakes	(	const edm::Handle< reco::VertexCollection > &	vertices,
		const edm::Handle< reco::VertexCollection > &	fakeVertices,
		const reco::PFCandidate &	pfcand,
		bool *	fromFakeSet
	)		const

private

Definition at line 260 of file FFTJetPFPileupCleaner.cc.

References funct::abs(), checkClosestZVertex, PVValHelper::dz, dqmdumpme::first, isAcceptableVtx(), gpuVertexFinder::iv, keepIfPVneighbor, pfDeepBoostedJetPreprocessParams_cfi::pfcand, jetUpdater_cfi::sort, mitigatedMETSequence_cff::U, pfDeepBoostedJetPreprocessParams_cfi::upper_bound, useFakePrimaryVertex, AlignmentTracksFromVertexSelector_cfi::vertices, L1BJetProducer_cff::vtx, w(), z, and zAssoc.

Referenced by produce().

                                                                                      {
   typedef reco::VertexCollection::const_iterator IV;
   typedef reco::Vertex::trackRef_iterator IT;
 
   *fromFakeSet = false;
   reco::TrackBaseRef trackBaseRef(pfcand.trackRef());
 
   size_t iVertex = 0;
   unsigned nFoundVertex = 0;
   const IV vertend(vertices->end());
 
   {
     unsigned index = 0;
     double bestweight = 0.0;
     for (IV iv = vertices->begin(); iv != vertend; ++iv, ++index)
       if (isAcceptableVtx(iv)) {
         const reco::Vertex& vtx = *iv;
 
         // loop on tracks in vertices
         IT trackend(vtx.tracks_end());
         for (IT iTrack = vtx.tracks_begin(); iTrack != trackend; ++iTrack) {
           const reco::TrackBaseRef& baseRef = *iTrack;
 
           // one of the tracks in the vertex is the same as
           // the track considered in the function
           if (baseRef == trackBaseRef) {
             // select the vertex for which the track has the highest weight
             const double w = vtx.trackWeight(baseRef);
             if (w > bestweight) {
               bestweight = w;
               iVertex = index;
               nFoundVertex++;
             }
           }
         }
       }
   }
 
   if (nFoundVertex > 0) {
     if (nFoundVertex != 1)
       edm::LogWarning("TrackOnTwoVertex") << "a track is shared by at least two vertices. "
                                           << "Used to be an assert";
 
     // Check if we can re-associate this track with one
     // of the fake vertices
     if (useFakePrimaryVertex) {
       const double ztrack = pfcand.vertex().z();
       double dzmin = std::abs(ztrack - ((*vertices)[iVertex]).z());
 
       const IV fakeEnd(fakeVertices->end());
       unsigned index = 0;
       for (IV iv = fakeVertices->begin(); iv != fakeEnd; ++iv, ++index)
         if (isAcceptableVtx(iv)) {
           const double dz = std::abs(ztrack - iv->z());
           if (dz < dzmin) {
             dzmin = dz;
             iVertex = index;
             *fromFakeSet = true;
           }
         }
     }
 
     return reco::VertexRef(*fromFakeSet ? fakeVertices : vertices, iVertex);
   }
 
   // optional: as a secondary solution, associate the closest vertex in z
   if (checkClosestZVertex) {
     const double ztrack = pfcand.vertex().z();
     bool foundVertex = false;
 
     if (keepIfPVneighbor) {
       // Sort all vertices according to their Z coordinate
       zAssoc.clear();
       unsigned index = 0;
       for (IV iv = vertices->begin(); iv != vertend; ++iv, ++index)
         if (isAcceptableVtx(iv))
           zAssoc.push_back(std::pair<double, unsigned>(iv->z(), index));
       const unsigned numRealVertices = index;
 
       // Mix the fake vertex collection into zAssoc.
       // Note that we do not reset "index" before doing this.
       if (useFakePrimaryVertex) {
         const IV fakeEnd(fakeVertices->end());
         for (IV iv = fakeVertices->begin(); iv != fakeEnd; ++iv, ++index)
           if (isAcceptableVtx(iv))
             zAssoc.push_back(std::pair<double, unsigned>(iv->z(), index));
       }
 
       // Check where the track z position fits into this sequence
       if (!zAssoc.empty()) {
         std::sort(zAssoc.begin(), zAssoc.end());
         std::pair<double, unsigned> tPair(ztrack, UINT_MAX);
         const unsigned iAbove = std::upper_bound(zAssoc.begin(), zAssoc.end(), tPair) - zAssoc.begin();
 
         // Check whether one of the vertices with indices
         // iAbove or (iAbove - 1) is a primary vertex.
         // If so, return it. Otherwise return the one
         // with closest distance to the track.
         unsigned ich[2] = {0U, 0U};
         unsigned nch = 1;
         if (iAbove) {
           ich[0] = iAbove - 1U;
           ich[1] = iAbove;
           if (iAbove < zAssoc.size())
             nch = 2;
         }
 
         double dzmin = 1.0e100;
         unsigned bestVertexNum = UINT_MAX;
         for (unsigned icheck = 0; icheck < nch; ++icheck) {
           const unsigned zAssocIndex = ich[icheck];
           const unsigned vertexNum = zAssoc[zAssocIndex].second;
 
           if (vertexNum == numRealVertices || (!useFakePrimaryVertex && vertexNum == 0U)) {
             bestVertexNum = vertexNum;
             break;
           }
 
           const double dz = std::abs(ztrack - zAssoc[zAssocIndex].first);
           if (dz < dzmin) {
             dzmin = dz;
             bestVertexNum = vertexNum;
           }
         }
 
         foundVertex = bestVertexNum < UINT_MAX;
         if (foundVertex) {
           iVertex = bestVertexNum;
           if (iVertex >= numRealVertices) {
             *fromFakeSet = true;
             iVertex -= numRealVertices;
           }
         }
       }
     } else {
       // This is a simple association algorithm (from PFPileUp)
       // extended to take fake vertices into account
       double dzmin = 1.0e100;
       unsigned index = 0;
       for (IV iv = vertices->begin(); iv != vertend; ++iv, ++index)
         if (isAcceptableVtx(iv)) {
           const double dz = std::abs(ztrack - iv->z());
           if (dz < dzmin) {
             dzmin = dz;
             iVertex = index;
             foundVertex = true;
           }
         }
 
       if (useFakePrimaryVertex) {
         const IV fakeEnd(fakeVertices->end());
         index = 0;
         for (IV iv = fakeVertices->begin(); iv != fakeEnd; ++iv, ++index)
           if (isAcceptableVtx(iv)) {
             const double dz = std::abs(ztrack - iv->z());
             if (dz < dzmin) {
               dzmin = dz;
               iVertex = index;
               *fromFakeSet = true;
               foundVertex = true;
             }
           }
       }
     }
 
     if (foundVertex)
       return reco::VertexRef(*fromFakeSet ? fakeVertices : vertices, iVertex);
   }
 
   return reco::VertexRef();
 }

◆ isAcceptableVtx()

bool FFTJetPFPileupCleaner::isAcceptableVtx ( reco::VertexCollection::const_iterator iv ) const

private

Definition at line 172 of file FFTJetPFPileupCleaner.cc.

References funct::abs(), gpuVertexFinder::iv, vertexNdofCut, vertexRhoCut, and vertexZmaxCut.

Referenced by findSomeVertexWFakes().

                                                                                        {
   return !iv->isFake() && static_cast<double>(iv->ndof()) > vertexNdofCut && std::abs(iv->z()) < vertexZmaxCut &&
          iv->position().rho() < vertexRhoCut;
 }

◆ isRemovable()

bool FFTJetPFPileupCleaner::isRemovable ( reco::PFCandidate::ParticleType ptype ) const

private

Definition at line 241 of file FFTJetPFPileupCleaner.cc.

References cms::cuda::assert(), OfflineHarvestingSequence_cosmic::ptype, removalMask, edm::shift, and mitigatedMETSequence_cff::U.

Referenced by produce().

                                                                                      {
   const unsigned shift = static_cast<unsigned>(ptype);
   assert(shift < 32U);
   return removalMask & (1U << shift);
 }

◆ operator=()

FFTJetPFPileupCleaner& FFTJetPFPileupCleaner::operator= ( const FFTJetPFPileupCleaner & )

delete

◆ produce()

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

overrideprotected

Definition at line 178 of file FFTJetPFPileupCleaner.cc.

References PVValHelper::eta, etaMax, FakePrimaryVerticesToken, findSomeVertexWFakes(), mps_fire::i, iEvent, edm::Ref< C, T, F >::isNull(), isRemovable(), edm::HandleBase::isValid(), edm::Ref< C, T, F >::key(), eostools::move(), zmumugammaAnalyzer_cfi::pfCandidates, PFCandidatesToken, removeMainVertex, removeUnassociated, reverseRemovalDecision, useFakePrimaryVertex, AlignmentTracksFromVertexSelector_cfi::vertices, and VerticesToken.

                                                                                  {
   // get PFCandidates
   auto pOutput = std::make_unique<reco::PFCandidateCollection>();
 
   edm::Handle<reco::PFCandidateCollection> pfCandidates;
   iEvent.getByToken(PFCandidatesToken, pfCandidates);
 
   // get vertices
   edm::Handle<reco::VertexCollection> vertices;
   iEvent.getByToken(VerticesToken, vertices);
 
   edm::Handle<reco::VertexCollection> fakeVertices;
   if (useFakePrimaryVertex) {
     iEvent.getByToken(FakePrimaryVerticesToken, fakeVertices);
     if (!fakeVertices.isValid())
       throw cms::Exception("FFTJetBadConfig") << "ERROR in FFTJetPFPileupCleaner:"
                                                  " could not find fake vertices"
                                               << std::endl;
   }
 
   const unsigned ncand = pfCandidates->size();
   for (unsigned i = 0; i < ncand; ++i) {
     reco::PFCandidatePtr candptr(pfCandidates, i);
     bool remove = false;
 
     if (isRemovable(candptr->particleId())) {
       bool fromFakeSet = false;
       reco::VertexRef vertexref(findSomeVertexWFakes(vertices, fakeVertices, *candptr, &fromFakeSet));
       if (vertexref.isNull()) {
         // Track is not associated with any vertex
         // in any of the vertex sets
         remove = removeUnassociated;
       } else if (vertexref.key() == 0 && (!useFakePrimaryVertex || fromFakeSet)) {
         // Track is associated with the main primary vertex
         // However, if we are using fake vertices, this only
         // matters if the vertex comes from the fake set. If
         // it comes from the real set, remove the track anyway
         // because in the combined set the associated vertex
         // would not be the main primary vertex.
         remove = removeMainVertex;
       } else
         remove = true;
     }
 
     // Check the eta range
     if (!remove) {
       const double eta = candptr->p4().Eta();
       remove = eta < etaMin || eta > etaMax;
     }
 
     // Should we remember this candidate?
     if (reverseRemovalDecision)
       remove = !remove;
     if (!remove) {
       const reco::PFCandidate& cand = (*pfCandidates)[i];
       pOutput->push_back(cand);
       pOutput->back().setSourceCandidatePtr(candptr);
     }
   }
 
   iEvent.put(std::move(pOutput));
 }

◆ setRemovalBit()

void FFTJetPFPileupCleaner::setRemovalBit	(	reco::PFCandidate::ParticleType	ptype,
		bool	onOff
	)

private

Definition at line 247 of file FFTJetPFPileupCleaner.cc.

References cms::cuda::assert(), gpuClustering::pixelStatus::mask, OfflineHarvestingSequence_cosmic::ptype, removalMask, edm::shift, and mitigatedMETSequence_cff::U.

Referenced by buildRemovalMask().

                                                                                                    {
   const unsigned shift = static_cast<unsigned>(ptype);
   assert(shift < 32U);
   const unsigned mask = (1U << shift);
   if (value)
     removalMask |= mask;
   else
     removalMask &= ~mask;
 }

Member Data Documentation

◆ checkClosestZVertex

bool FFTJetPFPileupCleaner::checkClosestZVertex

private

Definition at line 82 of file FFTJetPFPileupCleaner.cc.

Referenced by findSomeVertexWFakes().

◆ etaMax

double FFTJetPFPileupCleaner::etaMax

private

Definition at line 118 of file FFTJetPFPileupCleaner.cc.

Referenced by produce().

◆ etaMin

double FFTJetPFPileupCleaner::etaMin

private

Definition at line 117 of file FFTJetPFPileupCleaner.cc.

◆ FakePrimaryVertices

edm::InputTag FFTJetPFPileupCleaner::FakePrimaryVertices

private

Definition at line 70 of file FFTJetPFPileupCleaner.cc.

Referenced by FFTJetPFPileupCleaner().

◆ FakePrimaryVerticesToken

edm::EDGetTokenT<reco::VertexCollection> FFTJetPFPileupCleaner::FakePrimaryVerticesToken

private

Definition at line 74 of file FFTJetPFPileupCleaner.cc.

Referenced by FFTJetPFPileupCleaner(), and produce().

◆ keepIfPVneighbor

bool FFTJetPFPileupCleaner::keepIfPVneighbor

private

Definition at line 89 of file FFTJetPFPileupCleaner.cc.

Referenced by findSomeVertexWFakes().

◆ PFCandidates

edm::InputTag FFTJetPFPileupCleaner::PFCandidates

private

Definition at line 68 of file FFTJetPFPileupCleaner.cc.

Referenced by FFTJetPFPileupCleaner().

◆ PFCandidatesToken

edm::EDGetTokenT<reco::PFCandidateCollection> FFTJetPFPileupCleaner::PFCandidatesToken

private

Definition at line 72 of file FFTJetPFPileupCleaner.cc.

Referenced by FFTJetPFPileupCleaner(), and produce().

◆ removalMask

unsigned FFTJetPFPileupCleaner::removalMask

private

Definition at line 114 of file FFTJetPFPileupCleaner.cc.

Referenced by isRemovable(), and setRemovalBit().

◆ remove_e

bool FFTJetPFPileupCleaner::remove_e

private

Definition at line 106 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ remove_egamma_HF

bool FFTJetPFPileupCleaner::remove_egamma_HF

private

Definition at line 111 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ remove_gamma

bool FFTJetPFPileupCleaner::remove_gamma

private

Definition at line 108 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ remove_h

bool FFTJetPFPileupCleaner::remove_h

private

Definition at line 105 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ remove_h0

bool FFTJetPFPileupCleaner::remove_h0

private

Definition at line 109 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ remove_h_HF

bool FFTJetPFPileupCleaner::remove_h_HF

private

Definition at line 110 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ remove_mu

bool FFTJetPFPileupCleaner::remove_mu

private

Definition at line 107 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ remove_X

bool FFTJetPFPileupCleaner::remove_X

private

Definition at line 104 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ removeMainVertex

bool FFTJetPFPileupCleaner::removeMainVertex

private

Definition at line 93 of file FFTJetPFPileupCleaner.cc.

Referenced by produce().

◆ removeUnassociated

bool FFTJetPFPileupCleaner::removeUnassociated

private

Definition at line 97 of file FFTJetPFPileupCleaner.cc.

Referenced by produce().

◆ reverseRemovalDecision

bool FFTJetPFPileupCleaner::reverseRemovalDecision

private

Definition at line 100 of file FFTJetPFPileupCleaner.cc.

Referenced by produce().

◆ useFakePrimaryVertex

bool FFTJetPFPileupCleaner::useFakePrimaryVertex

private

Definition at line 78 of file FFTJetPFPileupCleaner.cc.

Referenced by FFTJetPFPileupCleaner(), findSomeVertexWFakes(), and produce().

◆ vertexNdofCut

double FFTJetPFPileupCleaner::vertexNdofCut

private

Definition at line 121 of file FFTJetPFPileupCleaner.cc.

Referenced by isAcceptableVtx().

◆ vertexRhoCut

double FFTJetPFPileupCleaner::vertexRhoCut

private

Definition at line 127 of file FFTJetPFPileupCleaner.cc.

Referenced by isAcceptableVtx().

◆ vertexZmaxCut

double FFTJetPFPileupCleaner::vertexZmaxCut

private

Definition at line 124 of file FFTJetPFPileupCleaner.cc.

Referenced by isAcceptableVtx().

◆ Vertices

edm::InputTag FFTJetPFPileupCleaner::Vertices

private

Definition at line 69 of file FFTJetPFPileupCleaner.cc.

Referenced by FFTJetPFPileupCleaner().

◆ VerticesToken

edm::EDGetTokenT<reco::VertexCollection> FFTJetPFPileupCleaner::VerticesToken

private

Definition at line 73 of file FFTJetPFPileupCleaner.cc.

Referenced by FFTJetPFPileupCleaner(), and produce().

◆ zAssoc

std::vector<std::pair<double, unsigned> > FFTJetPFPileupCleaner::zAssoc

mutableprivate

Definition at line 130 of file FFTJetPFPileupCleaner.cc.

Referenced by findSomeVertexWFakes().

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FFTJetPFPileupCleaner() [1/3]

◆ FFTJetPFPileupCleaner() [2/3]

◆ FFTJetPFPileupCleaner() [3/3]

◆ ~FFTJetPFPileupCleaner()

Member Function Documentation

◆ buildRemovalMask()

◆ findSomeVertexWFakes()

◆ isAcceptableVtx()

◆ isRemovable()

◆ operator=()

◆ produce()

◆ setRemovalBit()

Member Data Documentation

◆ checkClosestZVertex

◆ etaMax

◆ etaMin

◆ FakePrimaryVertices

◆ FakePrimaryVerticesToken

◆ keepIfPVneighbor

◆ PFCandidates

◆ PFCandidatesToken

◆ removalMask

◆ remove_e

◆ remove_egamma_HF

◆ remove_gamma

◆ remove_h

◆ remove_h0

◆ remove_h_HF

◆ remove_mu

◆ remove_X

◆ removeMainVertex

◆ removeUnassociated

◆ reverseRemovalDecision

◆ useFakePrimaryVertex

◆ vertexNdofCut

◆ vertexRhoCut

◆ vertexZmaxCut

◆ Vertices

◆ VerticesToken

◆ zAssoc