#include <PrimaryVertexAssignment.h>

Public Types
enum	Quality { UsedInFit = 7, PrimaryDz = 6, PrimaryV0 = 5, BTrack = 4, Unused = 3, OtherDz = 2, NotReconstructedPrimary = 1, Unassigned = 0 }

Public Member Functions
std::pair< int, PrimaryVertexAssignment::Quality >	chargedHadronVertex (const reco::VertexCollection &vertices, const reco::TrackRef &trackRef, const reco::Track *track, float trackTime, float trackTimeResolution, const edm::View< reco::Candidate > &jets, const TransientTrackBuilder &builder) const

std::pair< int, PrimaryVertexAssignment::Quality >	chargedHadronVertex (const reco::VertexCollection &vertices, int iVertex, const reco::Track *track, float trackTime, float trackTimeResolution, const edm::View< reco::Candidate > &jets, const TransientTrackBuilder &builder) const

std::pair< int, PrimaryVertexAssignment::Quality >	chargedHadronVertex (const reco::VertexCollection &vertices, const reco::TrackRef &trackRef, float trackTime, float trackTimeResolution, const edm::View< reco::Candidate > &jets, const TransientTrackBuilder &builder) const

std::pair< int, PrimaryVertexAssignment::Quality >	chargedHadronVertex (const reco::VertexCollection &vertices, const reco::PFCandidate &pfcand, const edm::View< reco::Candidate > &jets, const TransientTrackBuilder &builder) const

std::pair< int, PrimaryVertexAssignment::Quality >	chargedHadronVertex (const reco::VertexCollection &vertices, const pat::PackedCandidate &pfcand, const edm::View< reco::Candidate > &jets, const TransientTrackBuilder &builder) const

std::pair< int, PrimaryVertexAssignment::Quality >	chargedHadronVertex (const reco::VertexCollection &vertices, const reco::RecoChargedRefCandidate &chcand, const edm::ValueMap< float > trackTimeTag, const edm::ValueMap< float > trackTimeResoTag, const edm::View< reco::Candidate > &jets, const TransientTrackBuilder &builder) const

	PrimaryVertexAssignment (const edm::ParameterSet &iConfig)

	~PrimaryVertexAssignment ()

Private Attributes
double	fDzCutForChargedFromPUVtxs_

double	fEtaMinUseDz_

unsigned int	fNumOfPUVtxsForCharged_

bool	fOnlyUseFirstDz_

double	fPtMaxCharged_

double	maxDistanceToJetAxis_

double	maxDtSigForPrimaryAssignment_

double	maxDxyForJetAxisAssigment_

double	maxDxyForNotReconstructedPrimary_

double	maxDxySigForNotReconstructedPrimary_

double	maxDzErrorForPrimaryAssignment_

double	maxDzForJetAxisAssigment_

double	maxDzForPrimaryAssignment_

double	maxDzSigForPrimaryAssignment_

double	maxJetDeltaR_

double	minJetPt_

bool	preferHighRanked_

bool	useTiming_

bool	useVertexFit_

Detailed Description

Definition at line 19 of file PrimaryVertexAssignment.h.

Member Enumeration Documentation

enum PrimaryVertexAssignment::Quality

Enumerator
UsedInFit
PrimaryDz
PrimaryV0
BTrack
Unused
OtherDz
NotReconstructedPrimary
Unassigned

Definition at line 21 of file PrimaryVertexAssignment.h.

                {
     UsedInFit = 7,
     PrimaryDz = 6,
     PrimaryV0 = 5,
     BTrack = 4,
     Unused = 3,
     OtherDz = 2,
     NotReconstructedPrimary = 1,
     Unassigned = 0
   };

Constructor & Destructor Documentation

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

inline

Definition at line 32 of file PrimaryVertexAssignment.h.

       : maxDzSigForPrimaryAssignment_(iConfig.getParameter<double>("maxDzSigForPrimaryAssignment")),
         maxDzForPrimaryAssignment_(iConfig.getParameter<double>("maxDzForPrimaryAssignment")),
         maxDzErrorForPrimaryAssignment_(iConfig.getParameter<double>("maxDzErrorForPrimaryAssignment")),
         maxDtSigForPrimaryAssignment_(iConfig.getParameter<double>("maxDtSigForPrimaryAssignment")),
         maxJetDeltaR_(iConfig.getParameter<double>("maxJetDeltaR")),
         minJetPt_(iConfig.getParameter<double>("minJetPt")),
         maxDistanceToJetAxis_(iConfig.getParameter<double>("maxDistanceToJetAxis")),
         maxDzForJetAxisAssigment_(iConfig.getParameter<double>("maxDzForJetAxisAssigment")),
         maxDxyForJetAxisAssigment_(iConfig.getParameter<double>("maxDxyForJetAxisAssigment")),
         maxDxySigForNotReconstructedPrimary_(iConfig.getParameter<double>("maxDxySigForNotReconstructedPrimary")),
         maxDxyForNotReconstructedPrimary_(iConfig.getParameter<double>("maxDxyForNotReconstructedPrimary")),
         useTiming_(iConfig.getParameter<bool>("useTiming")),
         useVertexFit_(iConfig.getParameter<bool>("useVertexFit")),
         preferHighRanked_(iConfig.getParameter<bool>("preferHighRanked")),
         fNumOfPUVtxsForCharged_(iConfig.getParameter<unsigned int>("NumOfPUVtxsForCharged")),
         fDzCutForChargedFromPUVtxs_(iConfig.getParameter<double>("DzCutForChargedFromPUVtxs")),
         fPtMaxCharged_(iConfig.getParameter<double>("PtMaxCharged")),
         fEtaMinUseDz_(iConfig.getParameter<double>("EtaMinUseDz")),
         fOnlyUseFirstDz_(iConfig.getParameter<bool>("OnlyUseFirstDz")) {}

PrimaryVertexAssignment::~PrimaryVertexAssignment ( )

inline

Definition at line 53 of file PrimaryVertexAssignment.h.

53 {}

Member Function Documentation

std::pair< int, PrimaryVertexAssignment::Quality > PrimaryVertexAssignment::chargedHadronVertex	(	const reco::VertexCollection &	vertices,
		const reco::TrackRef &	trackRef,
		const reco::Track *	track,
		float	trackTime,
		float	trackTimeResolution,
		const edm::View< reco::Candidate > &	jets,
		const TransientTrackBuilder &	builder
	)		const

Definition at line 9 of file PrimaryVertexAssignment.cc.

References w().

Referenced by chargedHadronVertex(), and PrimaryVertexSorter< ParticlesCollection >::runAlgo().

                                                 {
   typedef reco::VertexCollection::const_iterator IV;
   typedef reco::Vertex::trackRef_iterator IT;
 
   int iVertex = -1;
   size_t index = 0;
   float bestweight = 0;
   for (auto const& vtx : vertices) {
     float w = vtx.trackWeight(trackRef);
     if (w > bestweight) {
       bestweight = w;
       iVertex = index;
     }
     index++;
   }
   return chargedHadronVertex(vertices, iVertex, track, time, timeReso, jets, builder);
 }

std::pair< int, PrimaryVertexAssignment::Quality > PrimaryVertexAssignment::chargedHadronVertex	(	const reco::VertexCollection &	vertices,
		int	iVertex,
		const reco::Track *	track,
		float	trackTime,
		float	trackTimeResolution,
		const edm::View< reco::Candidate > &	jets,
		const TransientTrackBuilder &	builder
	)		const

Definition at line 34 of file PrimaryVertexAssignment.cc.

References funct::abs(), edm::View< T >::at(), edm::View< T >::begin(), BTrack, TransientTrackBuilder::build(), reco::deltaR2(), HLT_FULL_cff::distance, dt, reco::TrackBase::dxy(), reco::TrackBase::dxyError(), PVValHelper::dz, reco::TrackBase::dz(), reco::TrackBase::dzError(), alignCSCRings::e, edm::View< T >::end(), reco::TrackBase::eta(), fDzCutForChargedFromPUVtxs_, fEtaMinUseDz_, fNumOfPUVtxsForCharged_, fOnlyUseFirstDz_, fPtMaxCharged_, edm::isNotFinite(), gpuVertexFinder::iv, IPTools::jetTrackDistance(), SiStripPI::max, maxDistanceToJetAxis_, maxDtSigForPrimaryAssignment_, maxDxyForJetAxisAssigment_, maxDxyForNotReconstructedPrimary_, maxDxySigForNotReconstructedPrimary_, maxDzErrorForPrimaryAssignment_, maxDzForJetAxisAssigment_, maxDzForPrimaryAssignment_, maxDzSigForPrimaryAssignment_, maxJetDeltaR_, minJetPt_, NotReconstructedPrimary, or, OtherDz, preferHighRanked_, PrimaryDz, reco::TrackBase::pt(), mathSSE::sqrt(), submitPVValidationJobs::t, Unassigned, UsedInFit, useTiming_, and useVertexFit_.

                                                 {
   typedef reco::VertexCollection::const_iterator IV;
   typedef reco::Vertex::trackRef_iterator IT;
 
   bool useTime = useTiming_;
   if (edm::isNotFinite(time) || timeReso < 1e-6) {
     useTime = false;
     time = 0.;
     timeReso = -1.;
   }
 
   if (preferHighRanked_) {
     for (IV iv = vertices.begin(); iv != vertices.end(); ++iv) {
       int ivtx = iv - vertices.begin();
       if (useVertexFit_ && (iVertex == ivtx))
         return {ivtx, PrimaryVertexAssignment::UsedInFit};
 
       double dz = std::abs(track->dz(iv->position()));
       double dt = std::abs(time - iv->t());
 
       bool useTimeVtx = useTime && iv->tError() > 0.;
 
       if ((dz < maxDzForPrimaryAssignment_ or dz / track->dzError() < maxDzSigForPrimaryAssignment_) and
           (!useTimeVtx or dt / timeReso < maxDtSigForPrimaryAssignment_)) {
         return {ivtx, PrimaryVertexAssignment::PrimaryDz};
       }
     }
   }
 
   double firstVertexDz = std::numeric_limits<double>::max();
   if (!vertices.empty())
     firstVertexDz = std::abs(track->dz(vertices[0].position()));
   // recover cases where the primary vertex is split
   if (useVertexFit_ && (iVertex > 0) && (iVertex <= int(fNumOfPUVtxsForCharged_)) &&
       firstVertexDz < fDzCutForChargedFromPUVtxs_)
     return {0, PrimaryVertexAssignment::PrimaryDz};
 
   if (useVertexFit_ && (iVertex >= 0))
     return {iVertex, PrimaryVertexAssignment::UsedInFit};
 
   double distmin = std::numeric_limits<double>::max();
   double dzmin = std::numeric_limits<double>::max();
   double dtmin = std::numeric_limits<double>::max();
   int vtxIdMinSignif = -1;
   for (IV iv = vertices.begin(); iv != vertices.end(); ++iv) {
     double dz = std::abs(track->dz(iv->position()));
     double dt = std::abs(time - iv->t());
 
     double dzsig = dz / track->dzError();
     double dist = dzsig * dzsig;
 
     bool useTimeVtx = useTime && iv->tError() > 0.;
     if (useTime && !useTimeVtx) {
       dt = timeReso;
     }
 
     if (useTime) {
       double dtsig = dt / timeReso;
 
       dist += dtsig * dtsig;
     }
     if (dist < distmin) {
       distmin = dist;
       dzmin = dz;
       dtmin = dt;
       vtxIdMinSignif = iv - vertices.begin();
     }
   }
 
   // protect high pT particles from association to pileup vertices and assign them to the first vertex
   if ((fPtMaxCharged_ > 0) && (vtxIdMinSignif >= 0) && (track->pt() > fPtMaxCharged_)) {
     iVertex = 0;
   } else {
     // first use "closest in Z" with tight cuts (targetting primary particles)
     const float add_cov = vtxIdMinSignif >= 0 ? vertices[vtxIdMinSignif].covariance(2, 2) : 0.f;
     const float dzE = sqrt(track->dzError() * track->dzError() + add_cov);
     if (!fOnlyUseFirstDz_) {
       if (vtxIdMinSignif >= 0 and
           (dzmin < maxDzForPrimaryAssignment_ and dzmin / dzE < maxDzSigForPrimaryAssignment_ and
            track->dzError() < maxDzErrorForPrimaryAssignment_) and
           (!useTime or dtmin / timeReso < maxDtSigForPrimaryAssignment_))
         iVertex = vtxIdMinSignif;
     } else {
       // consider only distances to first vertex for association (originally used in PUPPI)
       if ((vtxIdMinSignif >= 0) && (std::abs(track->eta()) > fEtaMinUseDz_) &&
           ((firstVertexDz < maxDzForPrimaryAssignment_ && firstVertexDz / dzE < maxDzSigForPrimaryAssignment_ &&
             track->dzError() < maxDzErrorForPrimaryAssignment_) &&
            (!useTime || std::abs(time - vertices[0].t()) / timeReso < maxDtSigForPrimaryAssignment_)))
         iVertex = 0;
     }
   }
 
   if (iVertex >= 0)
     return {iVertex, PrimaryVertexAssignment::PrimaryDz};
 
   // if track not assigned yet, it could be a b-decay secondary , use jet axis dist criterion
   // first find the closest jet within maxJetDeltaR_
   int jetIdx = -1;
   double minDeltaR2 = maxJetDeltaR_ * maxJetDeltaR_;
   for (edm::View<reco::Candidate>::const_iterator ij = jets.begin(); ij != jets.end(); ++ij) {
     if (ij->pt() < minJetPt_)
       continue;  // skip jets below the jet Pt threshold
 
     double deltaR2 = reco::deltaR2(*ij, *track);
     if (deltaR2 < minDeltaR2 and track->dzError() < maxDzErrorForPrimaryAssignment_) {
       minDeltaR2 = deltaR2;
       jetIdx = std::distance(jets.begin(), ij);
     }
   }
   // if jet found
   if (jetIdx != -1) {
     reco::TransientTrack transientTrack = builder.build(*track);
     GlobalVector direction(jets.at(jetIdx).px(), jets.at(jetIdx).py(), jets.at(jetIdx).pz());
     // find the vertex with the smallest distanceToJetAxis that is still within maxDistaneToJetAxis_
     int vtxIdx = -1;
     double minDistanceToJetAxis = maxDistanceToJetAxis_;
     for (IV iv = vertices.begin(); iv != vertices.end(); ++iv) {
       // only check for vertices that are close enough in Z and for tracks that have not too high dXY
       if (std::abs(track->dz(iv->position())) > maxDzForJetAxisAssigment_ ||
           std::abs(track->dxy(iv->position())) > maxDxyForJetAxisAssigment_)
         continue;
 
       double distanceToJetAxis = IPTools::jetTrackDistance(transientTrack, direction, *iv).second.value();
       if (distanceToJetAxis < minDistanceToJetAxis) {
         minDistanceToJetAxis = distanceToJetAxis;
         vtxIdx = std::distance(vertices.begin(), iv);
       }
     }
     if (vtxIdx >= 0) {
       iVertex = vtxIdx;
     }
   }
   if (iVertex >= 0)
     return {iVertex, PrimaryVertexAssignment::BTrack};
 
   // if the track is not compatible with other PVs but is compatible with the BeamSpot, we may simply have not reco'ed the PV!
   //  we still point it to the closest in Z, but flag it as possible orphan-primary
   if (!vertices.empty() && std::abs(track->dxy(vertices[0].position())) < maxDxyForNotReconstructedPrimary_ &&
       std::abs(track->dxy(vertices[0].position()) / track->dxyError()) < maxDxySigForNotReconstructedPrimary_)
     return {vtxIdMinSignif, PrimaryVertexAssignment::NotReconstructedPrimary};
 
   //FIXME: here we could better handle V0s and NucInt
 
   // all other tracks could be non-B secondaries and we just attach them with closest Z
   if (vtxIdMinSignif >= 0)
     return {vtxIdMinSignif, PrimaryVertexAssignment::OtherDz};
   //If for some reason even the dz failed (when?) we consider the track not assigned
   return {-1, PrimaryVertexAssignment::Unassigned};
 }

std::pair<int, PrimaryVertexAssignment::Quality> PrimaryVertexAssignment::chargedHadronVertex	(	const reco::VertexCollection &	vertices,
		const reco::TrackRef &	trackRef,
		float	trackTime,
		float	trackTimeResolution,
		const edm::View< reco::Candidate > &	jets,
		const TransientTrackBuilder &	builder
	)		const

inline

Definition at line 73 of file PrimaryVertexAssignment.h.

References chargedHadronVertex().

                                                   {
     return chargedHadronVertex(vertices, trackRef, &(*trackRef), trackTime, trackTimeResolution, jets, builder);
   }

std::pair<int, PrimaryVertexAssignment::Quality> PrimaryVertexAssignment::chargedHadronVertex	(	const reco::VertexCollection &	vertices,
		const reco::PFCandidate &	pfcand,
		const edm::View< reco::Candidate > &	jets,
		const TransientTrackBuilder &	builder
	)		const

inline

Definition at line 83 of file PrimaryVertexAssignment.h.

References chargedHadronVertex(), reco::PFCandidate::gsfTrackRef(), edm::Ref< C, T, F >::isNull(), reco::PFCandidate::isTimeValid(), fwrapper::jets, reco::PFCandidate::time(), reco::PFCandidate::timeError(), HLT_FULL_cff::timeResolution, reco::PFCandidate::trackRef(), Unassigned, and useTiming_.

                                                                                                                    {
     float time = 0, timeResolution = -1;
     if (useTiming_ && pfcand.isTimeValid()) {
       time = pfcand.time();
       timeResolution = pfcand.timeError();
     }
     if (pfcand.gsfTrackRef().isNull()) {
       if (pfcand.trackRef().isNull())
         return {-1, PrimaryVertexAssignment::Unassigned};
       else
         return chargedHadronVertex(vertices, pfcand.trackRef(), time, timeResolution, jets, builder);
     }
     return chargedHadronVertex(
         vertices, reco::TrackRef(), &(*pfcand.gsfTrackRef()), time, timeResolution, jets, builder);
   }

std::pair<int, PrimaryVertexAssignment::Quality> PrimaryVertexAssignment::chargedHadronVertex	(	const reco::VertexCollection &	vertices,
		const pat::PackedCandidate &	pfcand,
		const edm::View< reco::Candidate > &	jets,
		const TransientTrackBuilder &	builder
	)		const

inline

Definition at line 102 of file PrimaryVertexAssignment.h.

References chargedHadronVertex(), pat::PackedCandidate::hasTrackDetails(), fwrapper::jets, edm::Ref< C, T, F >::key(), pat::PackedCandidate::pseudoTrack(), pat::PackedCandidate::pvAssociationQuality(), pat::PackedCandidate::time(), pat::PackedCandidate::timeError(), HLT_FULL_cff::timeResolution, Unassigned, pat::PackedCandidate::UsedInFitLoose, useTiming_, useVertexFit_, and pat::PackedCandidate::vertexRef().

                                                                                                                    {
     float time = 0, timeResolution = -1;
     if (useTiming_ && pfcand.timeError() > 0) {
       time = pfcand.time();
       timeResolution = pfcand.timeError();
     }
     if (!pfcand.hasTrackDetails())
       return {-1, PrimaryVertexAssignment::Unassigned};
     else
       return chargedHadronVertex(
           vertices,
           (useVertexFit_ && (pfcand.pvAssociationQuality() >= pat::PackedCandidate::UsedInFitLoose))
               ? pfcand.vertexRef().key()
               : -1,
           &pfcand.pseudoTrack(),
           time,
           timeResolution,
           jets,
           builder);
   }

std::pair<int, PrimaryVertexAssignment::Quality> PrimaryVertexAssignment::chargedHadronVertex	(	const reco::VertexCollection &	vertices,
		const reco::RecoChargedRefCandidate &	chcand,
		const edm::ValueMap< float > *	trackTimeTag,
		const edm::ValueMap< float > *	trackTimeResoTag,
		const edm::View< reco::Candidate > &	jets,
		const TransientTrackBuilder &	builder
	)		const

inline

Definition at line 126 of file PrimaryVertexAssignment.h.

References chargedHadronVertex(), edm::Ref< C, T, F >::isNull(), fwrapper::jets, HLT_FULL_cff::timeResolution, reco::RecoChargedRefCandidate::track(), Unassigned, and useTiming_.

                                                                                                                    {
     float time = 0, timeResolution = -1;
     if (useTiming_) {
       time = (*trackTimeTag)[chcand.track()];
       timeResolution = (*trackTimeResoTag)[chcand.track()];
     }
     if (chcand.track().isNull())
       return {-1, PrimaryVertexAssignment::Unassigned};
     return chargedHadronVertex(vertices, chcand.track(), time, timeResolution, jets, builder);
   }