#include <PFPileUpAlgo.h>

Public Types
typedef std::vector< edm::FwdPtr< reco::PFCandidate > >	PFCollection

Public Member Functions
int	chargedHadronVertex (const reco::VertexCollection &vertices, const reco::PFCandidate &pfcand) const

const PFCollection &	getPFCandidatesFromPU () const

const PFCollection &	getPFCandidatesFromVtx () const

	PFPileUpAlgo ()

	PFPileUpAlgo (bool checkClosestZVertex, bool verbose=false)

void	process (const PFCollection &pfCandidates, const reco::VertexCollection &vertices)

void	setCheckClosestZVertex (bool val)

void	setVerbose (bool verbose)

	~PFPileUpAlgo ()

Private Attributes
bool	checkClosestZVertex_
	use the closest z vertex if a track is not in a vertex More...

PFCollection	pfCandidatesFromPU_

PFCollection	pfCandidatesFromVtx_

bool	verbose_
	verbose ? More...

Detailed Description

Definition at line 12 of file PFPileUpAlgo.h.

Member Typedef Documentation

◆ PFCollection

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

Definition at line 14 of file PFPileUpAlgo.h.

Constructor & Destructor Documentation

◆ PFPileUpAlgo() [1/2]

PFPileUpAlgo::PFPileUpAlgo ( )

inline

Definition at line 16 of file PFPileUpAlgo.h.

16 : checkClosestZVertex_(true), verbose_(false) { ; }

◆ PFPileUpAlgo() [2/2]

PFPileUpAlgo::PFPileUpAlgo	(	bool	checkClosestZVertex,
		bool	verbose = `false`
	)

inline

Definition at line 18 of file PFPileUpAlgo.h.

       : checkClosestZVertex_(checkClosestZVertex), verbose_(verbose) {
     ;
   }

◆ ~PFPileUpAlgo()

PFPileUpAlgo::~PFPileUpAlgo ( )

inline

Definition at line 23 of file PFPileUpAlgo.h.

23 { ; }

Member Function Documentation

◆ chargedHadronVertex()

int PFPileUpAlgo::chargedHadronVertex	(	const reco::VertexCollection &	vertices,
		const reco::PFCandidate &	pfcand
	)		const

Definition at line 37 of file PFPileUpAlgo.cc.

                                                                                                                {
   auto const& track = pfcand.trackRef();
   size_t iVertex = 0;
   unsigned int index = 0;
   unsigned int nFoundVertex = 0;
   float bestweight = 0;
   for (auto const& vtx : vertices) {
     float w = vtx.trackWeight(track);
     //select the vertex for which the track has the highest weight
     if (w > bestweight) {
       bestweight = w;
       iVertex = index;
       nFoundVertex++;
     }
     ++index;
   }
  
   if (nFoundVertex > 0) {
     if (nFoundVertex != 1)
       edm::LogWarning("TrackOnTwoVertex") << "a track is shared by at least two verteces. Used to be an assert";
     return iVertex;
   }
   // no vertex found with this track.
  
   // optional: as a secondary solution, associate the closest vertex in z
   if (checkClosestZVertex_) {
     double dzmin = 10000;
     double ztrack = pfcand.vertex().z();
     bool foundVertex = false;
     index = 0;
     for (auto iv = vertices.begin(); iv != vertices.end(); ++iv, ++index) {
       double dz = fabs(ztrack - iv->z());
       if (dz < dzmin) {
         dzmin = dz;
         iVertex = index;
         foundVertex = true;
       }
     }
  
     if (foundVertex)
       return iVertex;
   }
  
   return -1;
 }

References checkClosestZVertex_, PVValHelper::dz, pfDeepBoostedJetPreprocessParams_cfi::pfcand, HLT_2018_cff::track, pwdgSkimBPark_cfi::vertices, badGlobalMuonTaggersAOD_cff::vtx, and w.

Referenced by process().

◆ getPFCandidatesFromPU()

const PFCollection& PFPileUpAlgo::getPFCandidatesFromPU ( ) const

inline

Definition at line 32 of file PFPileUpAlgo.h.

32 { return pfCandidatesFromPU_; }

References pfCandidatesFromPU_.

◆ getPFCandidatesFromVtx()

const PFCollection& PFPileUpAlgo::getPFCandidatesFromVtx ( ) const

inline

Definition at line 34 of file PFPileUpAlgo.h.

34 { return pfCandidatesFromVtx_; }

References pfCandidatesFromVtx_.

◆ process()

void PFPileUpAlgo::process	(	const PFCollection &	pfCandidates,
		const reco::VertexCollection &	vertices
	)

Definition at line 5 of file PFPileUpAlgo.cc.

                                                                                                  {
   pfCandidatesFromVtx_.clear();
   pfCandidatesFromPU_.clear();
  
   for (unsigned i = 0; i < pfCandidates.size(); i++) {
     const reco::PFCandidate& cand = *(pfCandidates[i]);
  
     int ivertex;
  
     switch (cand.particleId()) {
       case reco::PFCandidate::h:
         ivertex = chargedHadronVertex(vertices, cand);
         break;
       default:
         continue;
     }
  
     // no associated vertex, or primary vertex
     // not pile-up
     if (ivertex == -1 || ivertex == 0) {
       if (verbose_)
         std::cout << "VTX " << i << " " << *(pfCandidates[i]) << std::endl;
       pfCandidatesFromVtx_.push_back(pfCandidates[i]);
     } else {
       if (verbose_)
         std::cout << "PU  " << i << " " << *(pfCandidates[i]) << std::endl;
       // associated to a vertex
       pfCandidatesFromPU_.push_back(pfCandidates[i]);
     }
   }
 }