PrimaryVertexAssignment Class Reference

#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::PFCandidate &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
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, const reco::TrackRef &trackRef, float trackTime, float trackTimeResolution, const edm::View< reco::Candidate > &jets, const TransientTrackBuilder &builder) const
	PrimaryVertexAssignment (const edm::ParameterSet &iConfig)
	~PrimaryVertexAssignment ()

Private Attributes
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_

Detailed Description

Definition at line 18 of file PrimaryVertexAssignment.h.

Member Enumeration Documentation

Quality

enum PrimaryVertexAssignment::Quality

Enumerator
UsedInFit
PrimaryDz
PrimaryV0
BTrack
Unused
OtherDz
NotReconstructedPrimary
Unassigned

Definition at line 20 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::PrimaryVertexAssignment ( const edm::ParameterSet &  iConfig )

inline

Definition at line 31 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")),
        preferHighRanked_(iConfig.getParameter<bool>("preferHighRanked")) {}

~PrimaryVertexAssignment()

PrimaryVertexAssignment::~PrimaryVertexAssignment ( )

inline

Definition at line 46 of file PrimaryVertexAssignment.h.

{}

Member Function Documentation

chargedHadronVertex() [1/4]

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 67 of file PrimaryVertexAssignment.h.

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

References chargedHadronVertex(), singleTopDQM_cfi::jets, pfDeepBoostedJetPreprocessParams_cfi::pfcand, ntuplemaker::time, HLT_2018_cff::timeResolution, Unassigned, useTiming_, and pwdgSkimBPark_cfi::vertices.

chargedHadronVertex() [2/4]

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 85 of file PrimaryVertexAssignment.h.

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

References chargedHadronVertex(), edm::Ref< C, T, F >::isNull(), singleTopDQM_cfi::jets, ntuplemaker::time, HLT_2018_cff::timeResolution, reco::RecoChargedRefCandidate::track(), Unassigned, useTiming_, and pwdgSkimBPark_cfi::vertices.

chargedHadronVertex() [3/4]

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.

                                                {
  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++;
  }
 
  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 (iVertex == ivtx)
        return std::pair<int, PrimaryVertexAssignment::Quality>(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 std::pair<int, PrimaryVertexAssignment::Quality>(ivtx, PrimaryVertexAssignment::PrimaryDz);
      }
    }
  }
 
  if (iVertex >= 0)
    return std::pair<int, PrimaryVertexAssignment::Quality>(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();
    }
  }
 
  // 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 (vtxIdMinSignif >= 0 and
      (dzmin < maxDzForPrimaryAssignment_ and dzmin / dzE < maxDzSigForPrimaryAssignment_ and
       track->dzError() < maxDzErrorForPrimaryAssignment_) and
      (!useTime or dtmin / timeReso < maxDtSigForPrimaryAssignment_)) {
    iVertex = vtxIdMinSignif;
  }
 
  if (iVertex >= 0)
    return std::pair<int, PrimaryVertexAssignment::Quality>(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 minDeltaR = 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 deltaR = reco::deltaR(*ij, *track);
    if (deltaR < minDeltaR and track->dzError() < maxDzErrorForPrimaryAssignment_) {
      minDeltaR = deltaR;
      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 std::pair<int, PrimaryVertexAssignment::Quality>(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 std::pair<int, PrimaryVertexAssignment::Quality>(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 std::pair<int, PrimaryVertexAssignment::Quality>(vtxIdMinSignif, PrimaryVertexAssignment::OtherDz);
  //If for some reason even the dz failed (when?) we consider the track not assigned
  return std::pair<int, PrimaryVertexAssignment::Quality>(-1, PrimaryVertexAssignment::Unassigned);
}

References funct::abs(), BTrack, TransientTrackBuilder::build(), reco::deltaR(), PbPb_ZMuSkimMuonDPG_cff::deltaR, HLT_2018_cff::distance, dt, PVValHelper::dz, MillePedeFileConverter_cfg::e, edm::isNotFinite(), electrons_cff::jetIdx, singleTopDQM_cfi::jets, IPTools::jetTrackDistance(), SiStripPI::max, maxDistanceToJetAxis_, maxDtSigForPrimaryAssignment_, maxDxyForJetAxisAssigment_, maxDxyForNotReconstructedPrimary_, maxDxySigForNotReconstructedPrimary_, maxDzErrorForPrimaryAssignment_, maxDzForJetAxisAssigment_, maxDzForPrimaryAssignment_, maxDzSigForPrimaryAssignment_, maxJetDeltaR_, HLT_2018_cff::minDeltaR, minJetPt_, NotReconstructedPrimary, or, OtherDz, preferHighRanked_, PrimaryDz, mathSSE::sqrt(), ntuplemaker::time, HLT_2018_cff::track, Unassigned, UsedInFit, useTiming_, pwdgSkimBPark_cfi::vertices, badGlobalMuonTaggersAOD_cff::vtx, and w.

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

chargedHadronVertex() [4/4]

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 57 of file PrimaryVertexAssignment.h.

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

References chargedHadronVertex(), singleTopDQM_cfi::jets, and pwdgSkimBPark_cfi::vertices.

Member Data Documentation

maxDistanceToJetAxis_

double PrimaryVertexAssignment::maxDistanceToJetAxis_

private

Definition at line 108 of file PrimaryVertexAssignment.h.

Referenced by chargedHadronVertex().

maxDtSigForPrimaryAssignment_

double PrimaryVertexAssignment::maxDtSigForPrimaryAssignment_

private

Definition at line 105 of file PrimaryVertexAssignment.h.

Referenced by chargedHadronVertex().

maxDxyForJetAxisAssigment_

double PrimaryVertexAssignment::maxDxyForJetAxisAssigment_

private

Definition at line 110 of file PrimaryVertexAssignment.h.

Referenced by chargedHadronVertex().

maxDxyForNotReconstructedPrimary_

double PrimaryVertexAssignment::maxDxyForNotReconstructedPrimary_

private

Definition at line 112 of file PrimaryVertexAssignment.h.

Referenced by chargedHadronVertex().

maxDxySigForNotReconstructedPrimary_

double PrimaryVertexAssignment::maxDxySigForNotReconstructedPrimary_

private

Definition at line 111 of file PrimaryVertexAssignment.h.

Referenced by chargedHadronVertex().

maxDzErrorForPrimaryAssignment_

double PrimaryVertexAssignment::maxDzErrorForPrimaryAssignment_

private

Definition at line 104 of file PrimaryVertexAssignment.h.

Referenced by chargedHadronVertex().

maxDzForJetAxisAssigment_

double PrimaryVertexAssignment::maxDzForJetAxisAssigment_

private

Definition at line 109 of file PrimaryVertexAssignment.h.

Referenced by chargedHadronVertex().

maxDzForPrimaryAssignment_

double PrimaryVertexAssignment::maxDzForPrimaryAssignment_

private

Definition at line 103 of file PrimaryVertexAssignment.h.

Referenced by chargedHadronVertex().

maxDzSigForPrimaryAssignment_

double PrimaryVertexAssignment::maxDzSigForPrimaryAssignment_

private

Definition at line 102 of file PrimaryVertexAssignment.h.

Referenced by chargedHadronVertex().

maxJetDeltaR_

double PrimaryVertexAssignment::maxJetDeltaR_

private

Definition at line 106 of file PrimaryVertexAssignment.h.

Referenced by chargedHadronVertex().

minJetPt_

double PrimaryVertexAssignment::minJetPt_

private

Definition at line 107 of file PrimaryVertexAssignment.h.

Referenced by chargedHadronVertex().

preferHighRanked_

bool PrimaryVertexAssignment::preferHighRanked_

private

Definition at line 114 of file PrimaryVertexAssignment.h.

Referenced by chargedHadronVertex().

useTiming_

bool PrimaryVertexAssignment::useTiming_

private

Definition at line 113 of file PrimaryVertexAssignment.h.

Referenced by chargedHadronVertex().