#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	setDzCutForChargedFromPUVtxs (double val)

void	setNumOfPUVtxsForCharged (unsigned int val)

void	setVerbose (bool verbose)

	~PFPileUpAlgo ()

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

double	fDzCutForChargedFromPUVtxs_

unsigned int	fNumOfPUVtxsForCharged_

PFCollection	pfCandidatesFromPU_

PFCollection	pfCandidatesFromVtx_

bool	verbose_
	verbose ? More...

Detailed Description

Definition at line 12 of file PFPileUpAlgo.h.

Member Typedef Documentation

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

Definition at line 14 of file PFPileUpAlgo.h.

Constructor & Destructor Documentation

PFPileUpAlgo::PFPileUpAlgo ( )

inline

Definition at line 16 of file PFPileUpAlgo.h.

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

PFPileUpAlgo::verbose_

bool verbose_

verbose ?

Definition: PFPileUpAlgo.h:47

PFPileUpAlgo::checkClosestZVertex_

bool checkClosestZVertex_

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

Definition: PFPileUpAlgo.h:42

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

inline

Definition at line 18 of file PFPileUpAlgo.h.

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

PFPileUpAlgo::~PFPileUpAlgo ( )

inline

Definition at line 23 of file PFPileUpAlgo.h.

23 { ; }

Member Function Documentation

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

Definition at line 40 of file PFPileUpAlgo.cc.

References checkClosestZVertex_, PVValHelper::dz, gpuVertexFinder::iv, HLT_FULL_cff::track, reco::PFCandidate::trackRef(), reco::PFCandidate::vertex(), and w().

Referenced by process().

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

const PFCollection& PFPileUpAlgo::getPFCandidatesFromPU ( ) const

inline

Definition at line 34 of file PFPileUpAlgo.h.

References pfCandidatesFromPU_.

34 { return pfCandidatesFromPU_; }

PFPileUpAlgo::pfCandidatesFromPU_

PFCollection pfCandidatesFromPU_

Definition: PFPileUpAlgo.h:50

const PFCollection& PFPileUpAlgo::getPFCandidatesFromVtx ( ) const

inline

Definition at line 36 of file PFPileUpAlgo.h.

References pfCandidatesFromVtx_.

36 { return pfCandidatesFromVtx_; }

PFPileUpAlgo::pfCandidatesFromVtx_

PFCollection pfCandidatesFromVtx_

Definition: PFPileUpAlgo.h:49

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

Definition at line 6 of file PFPileUpAlgo.cc.

References funct::abs(), chargedHadronVertex(), gather_cfg::cout, fDzCutForChargedFromPUVtxs_, fNumOfPUVtxsForCharged_, reco::PFCandidate::h, mps_fire::i, reco::PFCandidate::particleId(), pfCandidatesFromPU_, pfCandidatesFromVtx_, verbose_, and reco::PFCandidate::vertex().

                                                                                                  {
   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 ||
          (fNumOfPUVtxsForCharged_ > 0 && !vertices.empty() && ivertex <= int(fNumOfPUVtxsForCharged_) &&
           std::abs(cand.vertex().z() - vertices[0].z()) < fDzCutForChargedFromPUVtxs_))) {
       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]);
     }
   }
 }