#include <AdaptiveVertexReconstructor.h>

Inheritance diagram for AdaptiveVertexReconstructor:

Public Member Functions
	AdaptiveVertexReconstructor (float primcut=2.0, float seccut=6.0, float minweight=0.5, bool smoothing=false)

	AdaptiveVertexReconstructor (const edm::ParameterSet &s)

AdaptiveVertexReconstructor *	clone () const override

std::vector< TransientVertex >	vertices (const std::vector< reco::TransientTrack > &v) const override

std::vector< TransientVertex >	vertices (const std::vector< reco::TransientTrack > &, const reco::BeamSpot &) const override

std::vector< TransientVertex >	vertices (const std::vector< reco::TransientTrack > &primaries, const std::vector< reco::TransientTrack > &tracks, const reco::BeamSpot &) const override

	~AdaptiveVertexReconstructor () override

Public Member Functions inherited from VertexReconstructor
	VertexReconstructor ()

virtual	~VertexReconstructor ()

Private Member Functions
TransientVertex	cleanUp (const TransientVertex &old) const

std::vector< TransientVertex >	cleanUpVertices (const std::vector< TransientVertex > &) const

void	erase (const TransientVertex &newvtx, std::set< reco::TransientTrack > &remainingtrks, float w) const

void	setupFitters (float primcut, float primT, float primr, float seccut, float secT, float secr, bool smoothing)

std::vector< TransientVertex >	vertices (const std::vector< reco::TransientTrack > &primaries, const std::vector< reco::TransientTrack > &trks, const reco::BeamSpot &, bool has_primaries, bool usespot) const

Private Attributes
float	theMinWeight

AdaptiveVertexFitter *	thePrimaryFitter

AdaptiveVertexFitter *	theSecondaryFitter

float	theWeightThreshold

Detailed Description

Definition at line 9 of file AdaptiveVertexReconstructor.h.

Constructor & Destructor Documentation

AdaptiveVertexReconstructor::AdaptiveVertexReconstructor	(	float	primcut = `2.0`,
		float	seccut = `6.0`,
		float	minweight = `0.5`,
		bool	smoothing = `false`
	)

Definition at line 87 of file AdaptiveVertexReconstructor.cc.

References setupFitters().

Referenced by clone().

                                                                     :
   thePrimaryFitter ( nullptr ), theSecondaryFitter ( nullptr ),
        theMinWeight( min_weight ), theWeightThreshold ( 0.001 )
 {
   setupFitters ( primcut, 256., 0.25, seccut, 256., 0.25, smoothing );
 }

AdaptiveVertexReconstructor::~AdaptiveVertexReconstructor ( )

override

Definition at line 95 of file AdaptiveVertexReconstructor.cc.

References thePrimaryFitter, and theSecondaryFitter.

 {
   if ( thePrimaryFitter ) delete thePrimaryFitter;
   if ( theSecondaryFitter ) delete theSecondaryFitter;
 }

AdaptiveVertexReconstructor::AdaptiveVertexReconstructor ( const edm::ParameterSet & s )

The ParameterSet should have the following defined: double primcut double seccut double minweight for descriptions see

Definition at line 134 of file AdaptiveVertexReconstructor.cc.

References MillePedeFileConverter_cfg::e, edm::ParameterSet::getParameter(), ghostTrackVertexReco_cff::primcut, ghostTrackVertexReco_cff::seccut, setupFitters(), vertexReco_cff::smoothing, theMinWeight, theWeightThreshold, and cms::Exception::what().

   : thePrimaryFitter(nullptr), theSecondaryFitter(nullptr), theMinWeight(0.5), theWeightThreshold ( 0.001 )
 {
   float primcut = 2.0;
   float seccut = 6.0;
   bool smoothing=false;
   // float primT = 4096.;
   // float primr = 0.125;
   float primT = 256.;
   float primr = 0.25;
   float secT = 256.;
   float secr = 0.25;
   
   try {
     primcut =  m.getParameter<double>("primcut");
     primT =  m.getParameter<double>("primT");
     primr =  m.getParameter<double>("primr");
     seccut =  m.getParameter<double>("seccut");
     secT =  m.getParameter<double>("secT");
     secr =  m.getParameter<double>("secr");
     theMinWeight = m.getParameter<double>("minweight");
     theWeightThreshold = m.getParameter<double>("weightthreshold");
     smoothing =  m.getParameter<bool>("smoothing");
   } catch ( edm::Exception & e ) {
     edm::LogError ("AdaptiveVertexReconstructor") << e.what();
   }
 
   setupFitters ( primcut, primT, primr, seccut, secT, secr, smoothing );
 }

Member Function Documentation

TransientVertex AdaptiveVertexReconstructor::cleanUp ( const TransientVertex & old ) const

private

Definition at line 11 of file AdaptiveVertexReconstructor.cc.

References TransientVertex::degreesOfFreedom(), TransientVertex::hasPrior(), TransientVertex::hasRefittedTracks(), mps_fire::i, vertexReco_cff::minweight, TransientVertex::originalTracks(), TransientVertex::priorError(), TransientVertex::priorPosition(), TransientVertex::refittedTracks(), TransientVertex::totalChiSquared(), TransientVertex::trackWeight(), TransientVertex::vertexState(), and TransientVertex::weightMap().

Referenced by clone(), and vertices().

 {
   vector < reco::TransientTrack > trks = old.originalTracks();
   vector < reco::TransientTrack > newtrks;
   TransientVertex::TransientTrackToFloatMap mp;
   static const float minweight = 1.e-8; // discard all tracks with lower weight
   for ( vector< reco::TransientTrack >::const_iterator i=trks.begin();
         i!=trks.end() ; ++i )
   {
     if ( old.trackWeight ( *i ) > minweight )
     {
       newtrks.push_back ( *i );
       mp[*i]=old.trackWeight ( *i );
     }
   }
 
   TransientVertex ret;
 
   if ( old.hasPrior() )
   {
     VertexState priorstate ( old.priorPosition(), old.priorError() );
     ret=TransientVertex ( priorstate, old.vertexState(), newtrks,
         old.totalChiSquared(), old.degreesOfFreedom() );
   } else {
     ret=TransientVertex ( old.vertexState(), newtrks,
                           old.totalChiSquared(), old.degreesOfFreedom() );
   }
   ret.weightMap ( mp ); // set weight map
 
   if ( old.hasRefittedTracks() )
   {
     // we have refitted tracks -- copy them!
     vector < reco::TransientTrack > newrfs;
     vector < reco::TransientTrack > oldrfs=old.refittedTracks();
     vector < reco::TransientTrack >::const_iterator origtrkiter=trks.begin();
     for ( vector< reco::TransientTrack >::const_iterator i=oldrfs.begin(); i!=oldrfs.end() ; ++i )
     {
       if ( old.trackWeight ( *origtrkiter ) > minweight )
       {
         newrfs.push_back ( *i );
       }
       origtrkiter++;
     }
     if ( !newrfs.empty() ) ret.refittedTracks ( newrfs ); // copy refitted tracks
   }
 
   if ( ret.refittedTracks().size() > ret.originalTracks().size() )
   {
     edm::LogError("AdaptiveVertexReconstructor" )
       << "More refitted tracks than original tracks!";
   }
 
   return ret;
 }

vector< TransientVertex > AdaptiveVertexReconstructor::cleanUpVertices ( const std::vector< TransientVertex > & old ) const

private

cleanup reconstructed vertices. discard all with too few significant tracks.

Definition at line 266 of file AdaptiveVertexReconstructor.cc.

References mps_fire::i, theWeightThreshold, and w.

Referenced by clone(), and vertices().

 {
   vector < TransientVertex > ret;
   for ( vector< TransientVertex >::const_iterator i=old.begin(); i!=old.end() ; ++i )
   {
     if (!(i->hasTrackWeight()))
     { // if we dont have track weights, we take the vtx
       ret.push_back ( *i );
       continue;
     }
 
     // maybe this should be replaced with asking for the ndf ...
     // e.g. if ( ndf > - 1. )
     int nsig=0; // number of significant tracks. 
     TransientVertex::TransientTrackToFloatMap wm = i->weightMap();
     for ( TransientVertex::TransientTrackToFloatMap::const_iterator w=wm.begin(); w!=wm.end() ; ++w )
     {
       if (w->second > theWeightThreshold) nsig++;
     }
     if ( nsig > 1 ) ret.push_back ( *i );
   }
 
   return ret;
 }

AdaptiveVertexReconstructor* AdaptiveVertexReconstructor::clone ( void ) const

inlineoverridevirtual

Implements VertexReconstructor.

Definition at line 45 of file AdaptiveVertexReconstructor.h.

References AdaptiveVertexReconstructor(), cleanUp(), cleanUpVertices(), erase(), ghostTrackVertexReco_cff::primcut, ghostTrackVertexReco_cff::seccut, setupFitters(), vertexReco_cff::smoothing, vertices(), and w.

                                                        {
     return new AdaptiveVertexReconstructor( * this );
   }

void AdaptiveVertexReconstructor::erase	(	const TransientVertex &	newvtx,
		std::set< reco::TransientTrack > &	remainingtrks,
		float	w
	)		const

private

contrary to what its name has you believe, ::erase removes all newvtx.originalTracks() above theMinWeight from remainingtrks.

Definition at line 66 of file AdaptiveVertexReconstructor.cc.

References mps_fire::i, TransientVertex::originalTracks(), and TransientVertex::trackWeight().

Referenced by clone(), and vertices().

 {
   /*
    * Erase tracks that are in newvtx from remainingtrks 
    * But erase only if trackweight > w
    */
   const vector < reco::TransientTrack > & origtrks = newvtx.originalTracks();
   for ( vector< reco::TransientTrack >::const_iterator i=origtrks.begin();
         i!=origtrks.end(); ++i )
   {
     double weight = newvtx.trackWeight ( *i );
     if ( weight > w )
     {
       remainingtrks.erase ( *i );
     };
   };
 }

void AdaptiveVertexReconstructor::setupFitters	(	float	primcut,
		float	primT,
		float	primr,
		float	seccut,
		float	secT,
		float	secr,
		bool	smoothing
	)

private

setup the vertex fitters.

Definition at line 101 of file AdaptiveVertexReconstructor.cc.

References AdaptiveVertexFitter::setWeightThreshold(), thePrimaryFitter, theSecondaryFitter, and theWeightThreshold.

Referenced by AdaptiveVertexReconstructor(), and clone().

 {
   VertexSmoother<5> * smoother ;
   if ( smoothing )
   {
     smoother = new KalmanVertexSmoother();
   } else {
     smoother = new DummyVertexSmoother<5>();
   }
 
   if ( thePrimaryFitter ) delete thePrimaryFitter;
   if ( theSecondaryFitter ) delete theSecondaryFitter;
 
   /*
   edm::LogError ("AdaptiveVertexReconstructor" )
     << "Tini and r are hardcoded now!";
     */
   thePrimaryFitter = new AdaptiveVertexFitter ( GeometricAnnealing ( primcut, primT, primr ), DefaultLinearizationPointFinder(),
       KalmanVertexUpdator<5>(), KalmanVertexTrackCompatibilityEstimator<5>(), *smoother );
   thePrimaryFitter->setWeightThreshold ( theWeightThreshold );
   // if the primary fails, sth is wrong, so here we set a threshold on the weight.
   theSecondaryFitter = new AdaptiveVertexFitter ( GeometricAnnealing ( seccut, secT, secr ), DefaultLinearizationPointFinder(),
       KalmanVertexUpdator<5>(), 
       KalmanVertexTrackCompatibilityEstimator<5>(), *smoother );
   theSecondaryFitter->setWeightThreshold ( 0. );
   // need to set it or else we have 
   // unwanted exceptions to deal with.
   // cleanup can come later!
   delete smoother;
 }

vector< TransientVertex > AdaptiveVertexReconstructor::vertices ( const std::vector< reco::TransientTrack > & ) const

overridevirtual

Reconstruct vertices

Implements VertexReconstructor.

Definition at line 179 of file AdaptiveVertexReconstructor.cc.

Referenced by clone(), and vertices().

 {
   return vertices ( vector<reco::TransientTrack>(), tracks, reco::BeamSpot(), 
                     false, false );
 }

vector< TransientVertex > AdaptiveVertexReconstructor::vertices	(	const std::vector< reco::TransientTrack > &	t,
		const reco::BeamSpot &
	)		const

overridevirtual

Reconstruct vertices, exploiting the beamspot constraint for the primary vertex

Reimplemented from VertexReconstructor.

Definition at line 165 of file AdaptiveVertexReconstructor.cc.

References vertices().

 {
   return vertices ( vector<reco::TransientTrack>(), t, s, false, true );
 }

vector< TransientVertex > AdaptiveVertexReconstructor::vertices	(	const std::vector< reco::TransientTrack > &	primaries,
		const std::vector< reco::TransientTrack > &	tracks,
		const reco::BeamSpot &	spot
	)		const

overridevirtual

Reconstruct vertices, but exploit the fact that you know that some tracks cannot come from a secondary vertex. primaries Tracks that cannot come from a secondary vertex (but can, in principle, be non-primaries, also). tracks These are the tracks that are of unknown origin. These tracks are subjected to pattern recognition. spot A beamspot constraint is mandatory in this method.

Reimplemented from VertexReconstructor.

Definition at line 172 of file AdaptiveVertexReconstructor.cc.

References vertices().

 {
   return vertices ( primaries, tracks, s, true, true );
 }

vector< TransientVertex > AdaptiveVertexReconstructor::vertices	(	const std::vector< reco::TransientTrack > &	primaries,
		const std::vector< reco::TransientTrack > &	trks,
		const reco::BeamSpot &	s,
		bool	has_primaries,
		bool	usespot
	)		const

private

the actual fit to avoid code duplication

Definition at line 186 of file AdaptiveVertexReconstructor.cc.

References cleanUp(), cleanUpVertices(), popcon2dropbox::copy(), MillePedeFileConverter_cfg::e, erase(), LogDebug, theMinWeight, thePrimaryFitter, theSecondaryFitter, findQualityFiles::v, and AdaptiveVertexFitter::vertex().

 {
   vector < TransientVertex > ret;
   set < reco::TransientTrack > remainingtrks;
 
   copy(tracks.begin(), tracks.end(), 
         inserter(remainingtrks, remainingtrks.begin()));
 
   int ctr=0;
   unsigned int n_tracks = remainingtrks.size();
 
   // cout << "[AdaptiveVertexReconstructor] DEBUG ::vertices!!" << endl;
   try {
     while ( remainingtrks.size() > 1 )
     {
       /*
       cout << "[AdaptiveVertexReconstructor] next round: "
            << remainingtrks.size() << endl;
            */
       ctr++;
       const AdaptiveVertexFitter * fitter = theSecondaryFitter;
       if ( ret.empty() )
       {
         fitter = thePrimaryFitter;
       };
       vector < reco::TransientTrack > fittrks;
       fittrks.reserve ( remainingtrks.size() );
 
       copy(remainingtrks.begin(), remainingtrks.end(), back_inserter(fittrks));
 
       TransientVertex tmpvtx;
       if ( (ret.empty()) && has_primaries )
       {
         // add the primaries to the fitted tracks.
         copy ( primaries.begin(), primaries.end(), back_inserter(fittrks) );
       }
       if ( (ret.empty()) && usespot )
       {
         tmpvtx=fitter->vertex ( fittrks, s );
       } else {
         tmpvtx=fitter->vertex ( fittrks );
       }
       TransientVertex newvtx = cleanUp ( tmpvtx );
       ret.push_back ( newvtx );
       erase ( newvtx, remainingtrks, theMinWeight );
       if ( n_tracks == remainingtrks.size() )
       {
         if ( usespot )
         {
           // try once more without beamspot constraint!
           usespot=false;
           LogDebug("AdaptiveVertexReconstructor") 
             << "no tracks in vertex. trying again without beamspot constraint!";
           continue;
         }
         LogDebug("AdaptiveVertexReconstructor") << "all tracks (" << n_tracks
              << ") would be recycled for next fit. Trying with low threshold!";
         erase ( newvtx, remainingtrks, 1.e-5 );
         if ( n_tracks == remainingtrks.size() )
         {
           LogDebug("AdaptiveVertexReconstructor") << "low threshold didnt help! "
                                                   << "Discontinue procedure!";
           break;
         }
       };
 
       // cout << "[AdaptiveVertexReconstructor] erased" << endl;
       n_tracks = remainingtrks.size();
     };
   } catch ( VertexException & v ) {
     // Will catch all (not enough significant tracks exceptions.
     // in this case, the iteration can safely terminate.
   };
 
   return cleanUpVertices ( ret );
 }