#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 71 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 76 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 120 of file AdaptiveVertexReconstructor.cc.

References MillePedeFileConverter_cfg::e, edm::ParameterSet::getParameter(), HLT_2018_cff::primcut, HLT_2018_cff::seccut, setupFitters(), HLT_2018_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, HLT_2018_cff::minweight, TransientVertex::originalTracks(), TransientVertex::priorError(), TransientVertex::priorPosition(), TransientVertex::refittedTracks(), runTheMatrix::ret, 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 235 of file AdaptiveVertexReconstructor.cc.

References mps_fire::i, runTheMatrix::ret, 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 42 of file AdaptiveVertexReconstructor.h.

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

42 { return new AdaptiveVertexReconstructor(*this); }

AdaptiveVertexReconstructor::AdaptiveVertexReconstructor

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

Definition: AdaptiveVertexReconstructor.cc:71

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 55 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 83 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 160 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 149 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 154 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 164 of file AdaptiveVertexReconstructor.cc.

References cleanUp(), cleanUpVertices(), filterCSVwithJSON::copy, dqmiodatasetharvest::ctr, MillePedeFileConverter_cfg::e, erase(), LogDebug, runTheMatrix::ret, 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);
 }