TrimmedVertexFinder Class Reference

#include <TrimmedVertexFinder.h>

Public Types
typedef ReferenceCountingPointer< LinearizedTrackState< 5 > >	RefCountedLinearizedTrackState
typedef ReferenceCountingPointer< VertexTrack< 5 > >	RefCountedVertexTrack

Public Member Functions
TrimmedVertexFinder *	clone () const
void	setTrackCompatibilityCut (float cut)
float	trackCompatibilityCut () const
	TrimmedVertexFinder (const VertexFitter< 5 > *vf, const VertexUpdator< 5 > *vu, const VertexTrackCompatibilityEstimator< 5 > *ve)
	TrimmedVertexFinder (const TrimmedVertexFinder &other)
std::vector< TransientVertex >	vertices (std::vector< reco::TransientTrack > &remain) const
std::vector< TransientVertex >	vertices (std::vector< reco::TransientTrack > &remain, const reco::BeamSpot &s, bool use_beamspot=true) const
	~TrimmedVertexFinder ()

Private Member Functions
std::vector< RefCountedVertexTrack >::iterator	theWorst (const CachingVertex< 5 > &vtx, std::vector< RefCountedVertexTrack > &vtxTracks, float cut) const

Private Attributes
VertexTrackCompatibilityEstimator< 5 > *	theEstimator
VertexFitter< 5 > *	theFitter
float	theMinProb
VertexUpdator< 5 > *	theUpdator

Detailed Description

Algorithm to find 0 or 1 cluster of tracks that are compatible with a single vertex, among remain, the initial set of tracks. A track is declared incompatible with the vertex if the chi-squared probability between the track and the vertex is smaller than min. The algorithm applied is:
1) fit a single vertex with all tracks;
2) remove incompatible tracks 1 by 1 starting from the least compatible one.
On output, remain contains the incompatible tracks. This algorithm has 1 parameter that can be set at runtime via the corresponding set() method:

• "trackCompatibilityCut" (default: 0.05) which defines the probability below which a track is considered incompatible with a vertex.

Definition at line 28 of file TrimmedVertexFinder.h.

Member Typedef Documentation

RefCountedLinearizedTrackState

typedef ReferenceCountingPointer<LinearizedTrackState<5> > TrimmedVertexFinder::RefCountedLinearizedTrackState

Definition at line 31 of file TrimmedVertexFinder.h.

RefCountedVertexTrack

typedef ReferenceCountingPointer<VertexTrack<5> > TrimmedVertexFinder::RefCountedVertexTrack

Definition at line 30 of file TrimmedVertexFinder.h.

Constructor & Destructor Documentation

TrimmedVertexFinder() [1/2]

TrimmedVertexFinder::TrimmedVertexFinder	(	const VertexFitter< 5 > *	vf,
		const VertexUpdator< 5 > *	vu,
		const VertexTrackCompatibilityEstimator< 5 > *	ve
	)

Definition at line 9 of file TrimmedVertexFinder.cc.

Referenced by clone().

    : theFitter(vf->clone()), theUpdator(vu->clone()), theEstimator(ve->clone()), theMinProb(0.05) {}

TrimmedVertexFinder() [2/2]

TrimmedVertexFinder::TrimmedVertexFinder

(

const TrimmedVertexFinder &

other

)

Copy constructor, needed to handle copy of pointer data members correctly

Definition at line 14 of file TrimmedVertexFinder.cc.

    : theFitter(other.theFitter->clone()),
      theUpdator(other.theUpdator->clone()),
      theEstimator(other.theEstimator->clone()),
      theMinProb(other.theMinProb) {}

~TrimmedVertexFinder()

TrimmedVertexFinder::~TrimmedVertexFinder

(

)

Definition at line 20 of file TrimmedVertexFinder.cc.

References theEstimator, theFitter, and theUpdator.

                                          {
  delete theFitter;
  delete theUpdator;
  delete theEstimator;
}

Member Function Documentation

clone()

TrimmedVertexFinder* TrimmedVertexFinder::clone ( void  ) const

inline

clone method

Definition at line 65 of file TrimmedVertexFinder.h.

References TrimmedVertexFinder().

{ return new TrimmedVertexFinder(*this); }

setTrackCompatibilityCut()

void TrimmedVertexFinder::setTrackCompatibilityCut ( float  cut )

inline

Set parameter

Definition at line 61 of file TrimmedVertexFinder.h.

References TkAlMuonSelectors_cfi::cut, and theMinProb.

Referenced by ConfigurableTrimmedVertexFinder::vertexCandidates().

{ theMinProb = cut; }

theWorst()

std::vector< TrimmedVertexFinder::RefCountedVertexTrack >::iterator TrimmedVertexFinder::theWorst ( const CachingVertex< 5 > &  vtx, std::vector< RefCountedVertexTrack > &  vtxTracks, float  cut  ) const

private

Definition at line 131 of file TrimmedVertexFinder.cc.

References nano_mu_local_reco_cff::chi2, ChiSquaredProbability(), VertexTrackCompatibilityEstimator< N >::estimate(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::newV, TtFullHadEvtBuilder_cfi::prob, VertexUpdator< N >::remove(), mps_fire::result, theEstimator, theUpdator, and L1BJetProducer_cff::vtx.

Referenced by vertices().

                                                                                               {
  //  cout << "Cut is now " << cut << endl;

  // find track with worst compatibility
  std::vector<RefCountedVertexTrack>::iterator iWorst = vtxTracks.end();
  float worseChi2 = 0.;
  for (std::vector<RefCountedVertexTrack>::iterator itr = vtxTracks.begin(); itr != vtxTracks.end(); itr++) {
    CachingVertex<5> newV = theUpdator->remove(vtx, *itr);
    if (!newV.isValid())
      return itr;
    std::pair<bool, double> result = theEstimator->estimate(newV, *itr);
    if (!result.first)
      return itr;
    float chi2 = result.second;

    // compute number of degrees of freedom
    if (chi2 > 0.) {
      // we want to keep negative chi squares, and avoid calling
      // ChiSquaredProbability with a negative chi2.
      int ndf = 2;
      if (vtx.tracks().size() == 2)
        ndf = 1;

      float prob = ChiSquaredProbability(chi2, ndf);
      if (prob < cut && chi2 >= worseChi2) {
        // small inconsistency: sorting on chi2, not on chi2 probability
        // because large chi2 are not rounded off while small probabilities
        // are rounded off to 0....
        // should not matter since at a given iteration
        // all track chi2 increments have the same ndf
        iWorst = itr;
        worseChi2 = chi2;
      }
    }
  }

  return iWorst;
}

trackCompatibilityCut()

float TrimmedVertexFinder::trackCompatibilityCut ( ) const

inline

Access to parameter

Definition at line 57 of file TrimmedVertexFinder.h.

References theMinProb.

{ return theMinProb; }

vertices() [1/2]

std::vector< TransientVertex > TrimmedVertexFinder::vertices

(

std::vector< reco::TransientTrack > &

remain

)

const

Make 0 or 1 vertex On output, remain contains the incompatible tracks

Definition at line 26 of file TrimmedVertexFinder.cc.

Referenced by ConfigurableTrimmedVertexFinder::vertexCandidates().

                                                                                             {
  // FIXME write this!!!
  return vertices(tks, reco::BeamSpot(), false);
}

vertices() [2/2]

std::vector< TransientVertex > TrimmedVertexFinder::vertices	(	std::vector< reco::TransientTrack > &	remain,
		const reco::BeamSpot &	s,
		bool	use_beamspot = true
	)		const

Same as above, only with the extra information of the beamspot constraint.

Definition at line 31 of file TrimmedVertexFinder.cc.

References python.cmstools::all(), Exception, newFWLiteAna::found, mps_fire::i, submitPVValidationJobs::t, theFitter, theMinProb, theWorst(), PerigeeLinearizedTrackState::track(), VertexFitter< N >::vertex(), and L1BJetProducer_cff::vtx.

                                                                                {
  std::vector<TransientVertex> all;
  if (tks.size() < 2)
    return all;

  // prepare vertex tracks and initial vertex
  CachingVertex<5> vtx;
  if (use_spot) {
    vtx = theFitter->vertex(tks, spot);
  } else {
    vtx = theFitter->vertex(tks);
  }
  if (!vtx.isValid()) {
    edm::LogWarning("TrimmedVertexFinder") << "initial vertex invalid."
                                           << " vertex finding stops here.";
    return all;
  }

  std::vector<RefCountedVertexTrack> selected = vtx.tracks();

  // reject incompatible tracks starting from the worst
  std::vector<RefCountedVertexTrack> remain;
  bool found = false;
  while (!found && selected.size() >= 2) {
    // find track with worst compatibility
    std::vector<RefCountedVertexTrack>::iterator iWorst = theWorst(vtx, selected, theMinProb);

    if (iWorst != selected.end()) {
      // reject track
      remain.push_back(*iWorst);
      selected.erase(iWorst);

      if (selected.size() == 1) {
        // not enough tracks to build new vertices
        remain.push_back(selected.front());
      } else {
        // removing track from vertex
        // need to redo the vertex fit instead of removing the track;
        // successive removals lead to numerical problems
        // this is however quick since intermediate quantities are cached
        // in the RefCountedVertexTracks
        if (use_spot)  // && all.size()==0 )
        {
          vtx = theFitter->vertex(selected, spot);
        } else {
          vtx = theFitter->vertex(selected);
        }
        if (!vtx.isValid()) {
          edm::LogWarning("TrimmedVertexFinder") << "current vertex invalid"
                                                 << "vertex finding stops here.";
          return all;
        }

        // ref-counted tracks may have changed during the fit
        // if the linearization point has moved too much
        selected = vtx.tracks();
      }

    } else {
      // no incompatible track remains, make vertex
      found = true;
      int n_tracks_in_vertex = selected.size();

      // now return all tracks with weight < 0.5 to 'remain'.
      for (std::vector<RefCountedVertexTrack>::const_iterator t = selected.begin(); t != selected.end(); ++t) {
        if ((**t).weight() < 0.5) {
          /*
          cout << "[TrimmedVertexFinder] recycling track with weight "
               << (**t).weight() << endl;*/
          remain.push_back(*t);
          n_tracks_in_vertex--;  // one 'good' track less in the vertex
        };
      };

      if (n_tracks_in_vertex > 1) {
        all.push_back(vtx);
      } else {
        edm::LogError("TrimmedVertexFinder") << "found vertex has less than 2 tracks";
      }
    }
  }

  // modify list of incompatible tracks
  tks.clear();
  for (std::vector<RefCountedVertexTrack>::const_iterator i = remain.begin(); i != remain.end(); i++) {
    const PerigeeLinearizedTrackState* plts =
        dynamic_cast<const PerigeeLinearizedTrackState*>((**i).linearizedTrack().get());
    if (plts == nullptr) {
      throw cms::Exception("TrimmedVertexFinder: can't take track from non-perigee track state");
    }

    tks.push_back(plts->track());
  }

  // return 0 or 1 vertex
  return all;
}

Member Data Documentation

theEstimator

VertexTrackCompatibilityEstimator<5>* TrimmedVertexFinder::theEstimator

private

Definition at line 77 of file TrimmedVertexFinder.h.

Referenced by theWorst(), and ~TrimmedVertexFinder().

theFitter

VertexFitter<5>* TrimmedVertexFinder::theFitter

private

Definition at line 75 of file TrimmedVertexFinder.h.

Referenced by vertices(), and ~TrimmedVertexFinder().

theMinProb

float TrimmedVertexFinder::theMinProb

private

Definition at line 78 of file TrimmedVertexFinder.h.

Referenced by setTrackCompatibilityCut(), trackCompatibilityCut(), and vertices().

theUpdator

VertexUpdator<5>* TrimmedVertexFinder::theUpdator

private

Definition at line 76 of file TrimmedVertexFinder.h.

Referenced by theWorst(), and ~TrimmedVertexFinder().