#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::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector < edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector < edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector < ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
void	beginJob () override

void	endJob () override

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

Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

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::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

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::FFTJetPFPileupCleaner ( const edm::ParameterSet & ps )

explicit

Definition at line 138 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::FFTJetPFPileupCleaner ( )

delete

FFTJetPFPileupCleaner::FFTJetPFPileupCleaner ( const FFTJetPFPileupCleaner & )

delete

FFTJetPFPileupCleaner::~FFTJetPFPileupCleaner ( )

override

Definition at line 172 of file FFTJetPFPileupCleaner.cc.

172 {}

Member Function Documentation

void FFTJetPFPileupCleaner::beginJob ( void )

overrideprotectedvirtual

Reimplemented from edm::EDProducer.

Definition at line 449 of file FFTJetPFPileupCleaner.cc.

449 {}

void FFTJetPFPileupCleaner::buildRemovalMask ( )

private

Definition at line 437 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);
 }

void FFTJetPFPileupCleaner::endJob ( void )

overrideprotectedvirtual

Reimplemented from edm::EDProducer.

Definition at line 452 of file FFTJetPFPileupCleaner.cc.

452 {}

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 262 of file FFTJetPFPileupCleaner.cc.

References funct::abs(), checkClosestZVertex, PVValHelper::dz, first, isAcceptableVtx(), gpuVertexFinder::iv, keepIfPVneighbor, reco::PFCandidate::trackRef(), reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), reco::Vertex::trackWeight(), cuda_std::upper_bound(), useFakePrimaryVertex, reco::PFCandidate::vertex(), 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();
 }

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

private

Definition at line 174 of file FFTJetPFPileupCleaner.cc.

References funct::abs(), 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;
 }

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

private

Definition at line 243 of file FFTJetPFPileupCleaner.cc.

References cms::cuda::assert(), removalMask, and edm::shift.

Referenced by produce().

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

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

delete

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

overrideprotectedvirtual

Implements edm::EDProducer.

Definition at line 180 of file FFTJetPFPileupCleaner.cc.

References PVValHelper::eta, etaMax, FakePrimaryVerticesToken, findSomeVertexWFakes(), edm::Event::getByToken(), mps_fire::i, edm::Ref< C, T, F >::isNull(), isRemovable(), edm::HandleBase::isValid(), edm::Ref< C, T, F >::key(), eostools::move(), slimmedMuons_cfi::pfCandidates, PFCandidatesToken, edm::Event::put(), removeMainVertex, removeUnassociated, reverseRemovalDecision, reco::PFCandidate::setSourceCandidatePtr(), useFakePrimaryVertex, beam_dqm_sourceclient-live_cfg::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));
 }

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

private

Definition at line 249 of file FFTJetPFPileupCleaner.cc.

References cms::cuda::assert(), removalMask, and edm::shift.

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