#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

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

Definition at line 33 of file TrimmedVertexFinder.h.

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

Definition at line 32 of file TrimmedVertexFinder.h.

Constructor & Destructor Documentation

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::TrimmedVertexFinder ( const TrimmedVertexFinder & other )

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

Definition at line 17 of file TrimmedVertexFinder.cc.

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

TrimmedVertexFinder::~TrimmedVertexFinder ( )

Definition at line 26 of file TrimmedVertexFinder.cc.

References theEstimator, theFitter, and theUpdator.

                                           {
   delete theFitter;
   delete theUpdator;
   delete theEstimator;
 }

Member Function Documentation

TrimmedVertexFinder* TrimmedVertexFinder::clone ( void ) const

inline

clone method

Definition at line 68 of file TrimmedVertexFinder.h.

References TrimmedVertexFinder().

                                       {
     return new TrimmedVertexFinder(*this);
   }

void TrimmedVertexFinder::setTrackCompatibilityCut ( float cut )

inline

Set parameter

Definition at line 64 of file TrimmedVertexFinder.h.

References GOODCOLL_filter_cfg::cut, and theMinProb.

Referenced by ConfigurableTrimmedVertexFinder::vertexCandidates().

64 { theMinProb = cut; }

TrimmedVertexFinder::theMinProb

float theMinProb

Definition: TrimmedVertexFinder.h:86

GOODCOLL_filter_cfg.cut

tuple cut

Definition: GOODCOLL_filter_cfg.py:65

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

private

Definition at line 153 of file TrimmedVertexFinder.cc.

References ChiSquaredProbability(), VertexTrackCompatibilityEstimator< N >::estimate(), CachingVertex< N >::isValid(), mix_2012_Summer_inTimeOnly_cff::prob, VertexUpdator< N >::remove(), query::result, theEstimator, theUpdator, and CachingVertex< N >::tracks().

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

float TrimmedVertexFinder::trackCompatibilityCut ( ) const

inline

Access to parameter

Definition at line 60 of file TrimmedVertexFinder.h.

References theMinProb.

60 { return theMinProb; }

TrimmedVertexFinder::theMinProb

float theMinProb

Definition: TrimmedVertexFinder.h:86

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 33 of file TrimmedVertexFinder.cc.

Referenced by ConfigurableTrimmedVertexFinder::vertexCandidates().

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

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 40 of file TrimmedVertexFinder.cc.

References cond::ecalcond::all, edm::hlt::Exception, newFWLiteAna::found, i, CachingVertex< N >::isValid(), edmStreamStallGrapher::t, theFitter, theMinProb, theWorst(), PerigeeLinearizedTrackState::track(), CachingVertex< N >::tracks(), and VertexFitter< N >::vertex().

 {
   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 == 0) {
       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;
 }