#include <AdaptiveVertexFitter.h>

Inheritance diagram for AdaptiveVertexFitter:

Public Types
typedef ReferenceCountingPointer< LinearizedTrackState< 5 > >	RefCountedLinearizedTrackState

typedef ReferenceCountingPointer< VertexTrack< 5 > >	RefCountedVertexTrack

Public Member Functions
	AdaptiveVertexFitter (const AdaptiveVertexFitter &original)

	AdaptiveVertexFitter (const AnnealingSchedule &ann=GeometricAnnealing(), const LinearizationPointFinder &linP=DefaultLinearizationPointFinder(), const VertexUpdator< 5 > &updator=KalmanVertexUpdator< 5 >(), const VertexTrackCompatibilityEstimator< 5 > &estor=KalmanVertexTrackCompatibilityEstimator< 5 >(), const VertexSmoother< 5 > &smoother=DummyVertexSmoother< 5 >(), const AbstractLTSFactory< 5 > &ltsf=LinearizedTrackStateFactory())

AdaptiveVertexFitter *	clone () const override

bool	gsfIntermediarySmoothing () const

void	gsfIntermediarySmoothing (bool sm)

void	setParameters (const edm::ParameterSet &)

void	setParameters (double maxshift=0.0001, double maxlpshift=0.1, unsigned maxstep=30, double weightthreshold=.001)

void	setWeightThreshold (float w)

CachingVertex< 5 >	vertex (const std::vector< reco::TransientTrack > &) const override

CachingVertex< 5 >	vertex (const std::vector< reco::TransientTrack > &, const GlobalPoint &linPoint) const override

CachingVertex< 5 >	vertex (const std::vector< reco::TransientTrack > &, const GlobalPoint &priorPos, const GlobalError &priorError) const override

CachingVertex< 5 >	vertex (const std::vector< reco::TransientTrack > &tracks, const reco::BeamSpot &beamSpot) const override

CachingVertex< 5 >	vertex (const std::vector< RefCountedVertexTrack > &) const override

CachingVertex< 5 >	vertex (const std::vector< RefCountedVertexTrack > &, const GlobalPoint &priorPos, const GlobalError &priorError) const override

CachingVertex< 5 >	vertex (const std::vector< RefCountedVertexTrack > &, const reco::BeamSpot &spot) const override

	~AdaptiveVertexFitter () override

Public Member Functions inherited from VertexFitter< 5 >
virtual CachingVertex< N >	vertex (const std::vector< typename CachingVertex< N >::RefCountedVertexTrack > &tracks) const=0

virtual CachingVertex< N >	vertex (const std::vector< typename CachingVertex< N >::RefCountedVertexTrack > &tracks, const GlobalPoint &priorPos, const GlobalError &priorError) const=0

virtual CachingVertex< N >	vertex (const std::vector< typename CachingVertex< N >::RefCountedVertexTrack > &tracks, const reco::BeamSpot &spot) const=0

	VertexFitter ()

virtual	~VertexFitter ()

Private Member Functions
CachingVertex< 5 >	fit (const std::vector< RefCountedVertexTrack > &tracks, const VertexState &priorSeed, bool withPrior) const

double	getWeight (float chi2) const

std::vector< RefCountedVertexTrack >	linearizeTracks (const std::vector< reco::TransientTrack > &, const VertexState &) const

std::vector< RefCountedVertexTrack >	reLinearizeTracks (const std::vector< RefCountedVertexTrack > &tracks, const CachingVertex< 5 > &vertex) const

std::vector< RefCountedVertexTrack >	reWeightTracks (const std::vector< RefCountedLinearizedTrackState > &, const CachingVertex< 5 > &seed) const

std::vector< RefCountedVertexTrack >	reWeightTracks (const std::vector< RefCountedVertexTrack > &, const CachingVertex< 5 > &seed) const

std::vector< RefCountedVertexTrack >	weightTracks (const std::vector< RefCountedLinearizedTrackState > &, const VertexState &seed) const

Private Attributes
bool	gsfIntermediarySmoothing_

AnnealingSchedule *	theAssProbComputer

VertexTrackCompatibilityEstimator< 5 > *	theComp

LinearizationPointFinder *	theLinP

const AbstractLTSFactory< 5 > *	theLinTrkFactory

double	theMaxLPShift

double	theMaxShift

int	theMaxStep

int	theNr

VertexSmoother< 5 > *	theSmoother

VertexUpdator< 5 > *	theUpdator

double	theWeightThreshold

Detailed Description

An iterative reweighted fitter. Very robust, very adaptive.

See CMS Note 2007/008.

Exceptions VertexException( "Supplied fewer than two tracks" ) VertexException( "fewer than 2 significant tracks (w>threshold)" )

Definition at line 29 of file AdaptiveVertexFitter.h.

Member Typedef Documentation

◆ RefCountedLinearizedTrackState

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

Definition at line 32 of file AdaptiveVertexFitter.h.

◆ RefCountedVertexTrack

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

Definition at line 31 of file AdaptiveVertexFitter.h.

Constructor & Destructor Documentation

◆ AdaptiveVertexFitter() [1/2]

AdaptiveVertexFitter::AdaptiveVertexFitter	(	const AnnealingSchedule &	ann = `GeometricAnnealing()`,
		const LinearizationPointFinder &	linP = `DefaultLinearizationPointFinder()`,
		const VertexUpdator< 5 > &	updator = `KalmanVertexUpdator<5>()`,
		const VertexTrackCompatibilityEstimator< 5 > &	estor = `KalmanVertexTrackCompatibilityEstimator<5>()`,
		const VertexSmoother< 5 > &	smoother = `DummyVertexSmoother<5>()`,
		const AbstractLTSFactory< 5 > &	ltsf = `LinearizedTrackStateFactory()`
	)

Reimplemented constructors to use any kind of linearisation point finder, vertex updator and smoother. If no smoother is to be used, do not specify an instance for it.

Definition at line 102 of file AdaptiveVertexFitter.cc.

     : theNr(0),
       theLinP(linP.clone()),
       theUpdator(updator.clone()),
       theSmoother(smoother.clone()),
       theAssProbComputer(ann.clone()),
       theComp(crit.clone()),
       theLinTrkFactory(ltsf.clone()),
       gsfIntermediarySmoothing_(false) {
   setParameters();
 }

References setParameters().

Referenced by clone().

◆ AdaptiveVertexFitter() [2/2]

AdaptiveVertexFitter::AdaptiveVertexFitter ( const AdaptiveVertexFitter & original )

Definition at line 121 of file AdaptiveVertexFitter.cc.

     : theMaxShift(o.theMaxShift),
       theMaxLPShift(o.theMaxLPShift),
       theMaxStep(o.theMaxStep),
       theWeightThreshold(o.theWeightThreshold),
       theNr(o.theNr),
       theLinP(o.theLinP->clone()),
       theUpdator(o.theUpdator->clone()),
       theSmoother(o.theSmoother->clone()),
       theAssProbComputer(o.theAssProbComputer->clone()),
       theComp(o.theComp->clone()),
       theLinTrkFactory(o.theLinTrkFactory->clone()),
       gsfIntermediarySmoothing_(o.gsfIntermediarySmoothing_) {}

◆ ~AdaptiveVertexFitter()

AdaptiveVertexFitter::~AdaptiveVertexFitter ( )

override

Definition at line 135 of file AdaptiveVertexFitter.cc.

                                             {
   delete theLinP;
   delete theUpdator;
   delete theSmoother;
   delete theAssProbComputer;
   delete theComp;
   delete theLinTrkFactory;
 }

References theAssProbComputer, theComp, theLinP, theLinTrkFactory, theSmoother, and theUpdator.

Member Function Documentation

◆ clone()

AdaptiveVertexFitter * AdaptiveVertexFitter::clone ( void ) const

overridevirtual

Fit vertex out of a VertexSeed

Implements VertexFitter< 5 >.

Definition at line 327 of file AdaptiveVertexFitter.cc.

327 { return new AdaptiveVertexFitter(*this); }

References AdaptiveVertexFitter().

◆ fit()

CachingVertex< 5 > AdaptiveVertexFitter::fit	(	const std::vector< RefCountedVertexTrack > &	tracks,
		const VertexState &	priorSeed,
		bool	withPrior
	)		const

private

perform the fit

Definition at line 451 of file AdaptiveVertexFitter.cc.

                                                                  {
   // cout << "[AdaptiveVertexFit] fit with " << tracks.size() << endl;
   theAssProbComputer->resetAnnealing();
  
   vector<RefCountedVertexTrack> initialTracks;
   GlobalPoint priorVertexPosition = priorSeed.position();
   GlobalError priorVertexError = priorSeed.error();
  
   CachingVertex<5> returnVertex(priorVertexPosition, priorVertexError, initialTracks, 0);
   if (withPrior) {
     returnVertex = CachingVertex<5>(
         priorVertexPosition, priorVertexError, priorVertexPosition, priorVertexError, initialTracks, 0);
   }
  
   std::vector<RefCountedVertexTrack> globalVTracks = tracks;
   // sort the tracks, according to distance to seed!
   sortByDistanceToRefPoint(globalVTracks, priorSeed.position());
  
   // main loop through all the VTracks
   int lpStep = 0;
   int step = 0;
  
   CachingVertex<5> initialVertex = returnVertex;
  
   GlobalPoint newPosition = priorVertexPosition;
   GlobalPoint previousPosition = newPosition;
  
   int ns_trks = 0;  // number of significant tracks.
   // If we have only two significant tracks, we return an invalid vertex
  
   // cout << "[AdaptiveVertexFit] start " << tracks.size() << endl;
   /*
   for ( vector< RefCountedVertexTrack >::const_iterator 
         i=globalVTracks.begin(); i!=globalVTracks.end() ; ++i )
   {
     cout << "  " << (**i).linearizedTrack()->track().initialFreeState().momentum() << endl;
   }*/
   do {
     ns_trks = 0;
     CachingVertex<5> fVertex = initialVertex;
     // cout << "[AdaptiveVertexFit] step " << step << " at " << fVertex.position() << endl;
     if ((previousPosition - newPosition).transverse() > theMaxLPShift) {
       // relinearize and reweight.
       // (reLinearizeTracks also reweights tracks)
       // cout << "[AdaptiveVertexFit] relinearize at " << returnVertex.position() << endl;
       if (gsfIntermediarySmoothing_)
         returnVertex = theSmoother->smooth(returnVertex);
       globalVTracks = reLinearizeTracks(globalVTracks, returnVertex);
       lpStep++;
     } else if (step) {
       // reweight, if it is not the first step
       // cout << "[AdaptiveVertexFit] reweight at " << returnVertex.position() << endl;
       if (gsfIntermediarySmoothing_)
         returnVertex = theSmoother->smooth(returnVertex);
       globalVTracks = reWeightTracks(globalVTracks, returnVertex);
     }
     // cout << "[AdaptiveVertexFit] relinarized, reweighted" << endl;
     // update sequentially the vertex estimate
     CachingVertex<5> nVertex;
     for (vector<RefCountedVertexTrack>::const_iterator i = globalVTracks.begin(); i != globalVTracks.end(); i++) {
       if ((**i).weight() > 0.)
         nVertex = theUpdator->add(fVertex, *i);
       else
         nVertex = fVertex;
       if (nVertex.isValid()) {
         if ((**i).weight() >= theWeightThreshold)
           ns_trks++;
  
         if (fabs(nVertex.position().z()) > 10000. || nVertex.position().perp() > 120.) {
           // were more than 100 m off!!
           LogInfo("AdaptiveVertexFitter")
               << "Vertex candidate just took off to " << nVertex.position() << "! Will discard this update!";
           //        //<< "track pt was " << (**i).linearizedTrack()->track().pt()
           //                         << "track momentum was " << (**i).linearizedTrack()->track().initialFreeState().momentum()
           //                         << "track position was " << (**i).linearizedTrack()->track().initialFreeState().position()
           //                         << "track chi2 was " << (**i).linearizedTrack()->track().chi2()
           //                         << "track ndof was " << (**i).linearizedTrack()->track().ndof()
           //                         << "track w was " << (**i).weight()
           //                         << "track schi2 was " << (**i).smoothedChi2();
         } else {
           fVertex = nVertex;
         }
       } else {
         LogInfo("RecoVertex/AdaptiveVertexFitter")
             << "The updator returned an invalid vertex when adding track " << i - globalVTracks.begin()
             << ".\n Your vertex might just have lost one good track.";
       }
     }
     previousPosition = newPosition;
     newPosition = fVertex.position();
     returnVertex = fVertex;
     theAssProbComputer->anneal();
     step++;
     if (step >= theMaxStep)
       break;
  
   } while (
       // repeat as long as
       // - vertex moved too much or
       // - we're not yet annealed
       (((previousPosition - newPosition).mag() > theMaxShift) || (!(theAssProbComputer->isAnnealed()))));
  
   if (theWeightThreshold > 0. && ns_trks < 2 && !withPrior) {
     LogDebug("AdaptiveVertexFitter") << "fewer than two significant tracks (w>" << theWeightThreshold << ")."
                                      << " Fitted vertex is invalid.";
     return CachingVertex<5>();  // return invalid vertex
   }
  
 #ifdef STORE_WEIGHTS
   map<string, dataharvester::MultiType> m;
   m["chi2"] = chi2;
   m["w"] = theAssProbComputer->weight(chi2);
   m["T"] = theAssProbComputer->currentTemp();
   m["n"] = iter;
   m["id"] = getId(*i);
   m["pos"] = "final";
   dataharvester::Writer::file("w.txt").save(m);
 #endif
   // cout << "[AdaptiveVertexFit] /fit" << endl;
   return theSmoother->smooth(returnVertex);
 }

References VertexUpdator< N >::add(), AnnealingSchedule::anneal(), hltPixelTracks_cff::chi2, AnnealingSchedule::currentTemp(), VertexState::error(), geometryDiff::file, getId(), gsfIntermediarySmoothing_, mps_fire::i, AnnealingSchedule::isAnnealed(), LogDebug, visualization-live-secondInstance_cfg::m, mag(), L1TEGammaOffline_cfi::nVertex, VertexState::position(), CachingVertex< N >::position(), reLinearizeTracks(), AnnealingSchedule::resetAnnealing(), reWeightTracks(), VertexSmoother< N >::smooth(), theAssProbComputer, theMaxLPShift, theMaxShift, theMaxStep, theSmoother, theUpdator, theWeightThreshold, tracks, and AnnealingSchedule::weight().

Referenced by trackingPlots.Iteration::modules(), and vertex().

◆ getWeight()

double AdaptiveVertexFitter::getWeight ( float chi2 ) const

private

Definition at line 329 of file AdaptiveVertexFitter.cc.

                                                        {
   double weight = theAssProbComputer->weight(chi2);
  
   if (weight > 1.0) {
     LogInfo("RecoVertex/AdaptiveVertexFitter") << "Weight " << weight << " > 1.0!";
     weight = 1.0;
   };
  
   if (weight < 1e-20) {
     // LogInfo("RecoVertex/AdaptiveVertexFitter") << "Weight " << weight << " < 0.0!";
     weight = 1e-20;
   };
   return weight;
 }

References hltPixelTracks_cff::chi2, MillePedeFileConverter_cfg::e, theAssProbComputer, AnnealingSchedule::weight(), and mps_merge::weight.

Referenced by reWeightTracks(), and weightTracks().

◆ gsfIntermediarySmoothing() [1/2]

bool AdaptiveVertexFitter::gsfIntermediarySmoothing ( ) const

inline

Definition at line 137 of file AdaptiveVertexFitter.h.

137 { return gsfIntermediarySmoothing_; }

References gsfIntermediarySmoothing_.

◆ gsfIntermediarySmoothing() [2/2]

void AdaptiveVertexFitter::gsfIntermediarySmoothing ( bool sm )

inline

Definition at line 135 of file AdaptiveVertexFitter.h.

135 { gsfIntermediarySmoothing_ = sm; }

References gsfIntermediarySmoothing_.

Referenced by AdaptiveGsfVertexFitter::AdaptiveGsfVertexFitter().

◆ linearizeTracks()

vector< AdaptiveVertexFitter::RefCountedVertexTrack > AdaptiveVertexFitter::linearizeTracks	(	const std::vector< reco::TransientTrack > &	tracks,
		const VertexState &	seed
	)		const

private

Linearize tracks, for the first time in the iteration.

Construct a container of VertexTrack from a set of reco::TransientTracks. As this is the first iteration of the adaptive fit, the initial error does not enter in the computation of the weights. This is to avoid that all tracks get the same weight when using a very large initial error matrix.

Definition at line 283 of file AdaptiveVertexFitter.cc.

                                                                              {
   const GlobalPoint& linP(seed.position());
   vector<RefCountedLinearizedTrackState> lTracks;
   for (vector<reco::TransientTrack>::const_iterator i = tracks.begin(); i != tracks.end(); ++i) {
     try {
       RefCountedLinearizedTrackState lTrData = theLinTrkFactory->linearizedTrackState(linP, *i);
       lTracks.push_back(lTrData);
     } catch (exception& e) {
       LogInfo("RecoVertex/AdaptiveVertexFitter") << "Exception " << e.what() << " in ::linearizeTracks."
                                                  << "Your future vertex has just lost a track.";
     };
   }
   return weightTracks(lTracks, seed);
 }

References MillePedeFileConverter_cfg::e, cppFunctionSkipper::exception, mps_fire::i, AbstractLTSFactory< N >::linearizedTrackState(), fileCollector::seed, theLinTrkFactory, tracks, and weightTracks().

Referenced by vertex().

◆ reLinearizeTracks()

vector< AdaptiveVertexFitter::RefCountedVertexTrack > AdaptiveVertexFitter::reLinearizeTracks	(	const std::vector< RefCountedVertexTrack > &	tracks,
		const CachingVertex< 5 > &	vertex
	)		const

private

Construct new a container of VertexTrack with a new linearization point and vertex seed, from an existing set of VertexTrack, from which only the recTracks will be used.

Parameters

tracks	The original container of VertexTracks, from which the reco::TransientTracks will be extracted.
vertex	The seed to use for the VertexTracks. This position will also be used as the new linearization point.

Returns: The container of VertexTracks which are to be used in the next fit.

Construct new a container of VertexTrack with a new linearization point and vertex seed, from an existing set of VertexTrack, from which only the recTracks will be used.

Definition at line 304 of file AdaptiveVertexFitter.cc.

                                                                                        {
   const VertexState& seed = vertex.vertexState();
   GlobalPoint linP = seed.position();
   vector<RefCountedLinearizedTrackState> lTracks;
   for (vector<RefCountedVertexTrack>::const_iterator i = tracks.begin(); i != tracks.end(); i++) {
     try {
       RefCountedLinearizedTrackState lTrData =
           theLinTrkFactory->linearizedTrackState(linP, (**i).linearizedTrack()->track());
       /*
       RefCountedLinearizedTrackState lTrData =
               (**i).linearizedTrack()->stateWithNewLinearizationPoint(linP);
               */
       lTracks.push_back(lTrData);
     } catch (exception& e) {
       LogInfo("RecoVertex/AdaptiveVertexFitter") << "Exception " << e.what() << " in ::relinearizeTracks. "
                                                  << "Will not relinearize this track.";
       lTracks.push_back((**i).linearizedTrack());
     };
   };
   return reWeightTracks(lTracks, vertex);
 }

References MillePedeFileConverter_cfg::e, cppFunctionSkipper::exception, mps_fire::i, AbstractLTSFactory< N >::linearizedTrackState(), reWeightTracks(), fileCollector::seed, theLinTrkFactory, tracks, vertex(), and CachingVertex< N >::vertexState().

Referenced by fit().

◆ reWeightTracks() [1/2]

vector< AdaptiveVertexFitter::RefCountedVertexTrack > AdaptiveVertexFitter::reWeightTracks	(	const std::vector< RefCountedLinearizedTrackState > &	lTracks,
		const CachingVertex< 5 > &	seed
	)		const

private

Construct a new container of VertexTracks with new weights accounting for vertex error, from an existing set of LinearizedTracks.

Definition at line 344 of file AdaptiveVertexFitter.cc.

                                                                                                  {
   const VertexState& seed = vertex.vertexState();
   // cout << "[AdaptiveVertexFitter] now reweight around " << seed.position() << endl;
   theNr++;
   // GlobalPoint pos = seed.position();
  
   vector<RefCountedVertexTrack> finalTracks;
   VertexTrackFactory<5> vTrackFactory;
 #ifdef STORE_WEIGHTS
   iter++;
 #endif
   for (vector<RefCountedLinearizedTrackState>::const_iterator i = lTracks.begin(); i != lTracks.end(); i++) {
     double weight = 0.;
     // cout << "[AdaptiveVertexFitter] estimate " << endl;
     pair<bool, double> chi2Res(false, 0.);
     try {
       chi2Res = theComp->estimate(vertex, *i, std::distance(lTracks.begin(), i));
     } catch (exception const& e) {
     };
     // cout << "[AdaptiveVertexFitter] /estimate " << endl;
     if (!chi2Res.first) {
       // cout << "[AdaptiveVertexFitter] aie... vertex candidate is at  " << vertex.position() << endl;
       LogInfo("AdaptiveVertexFitter") << "When reweighting, chi2<0. Will add this track with w=0.";
       // edm::LogInfo("AdaptiveVertexFitter" ) << "pt=" << (**i).track().pt();
     } else {
       weight = getWeight(chi2Res.second);
     }
  
     RefCountedVertexTrack vTrData = vTrackFactory.vertexTrack(*i, seed, weight);
  
 #ifdef STORE_WEIGHTS
     map<string, dataharvester::MultiType> m;
     m["chi2"] = chi2;
     m["w"] = theAssProbComputer->weight(chi2);
     m["T"] = theAssProbComputer->currentTemp();
     m["n"] = iter;
     m["pos"] = "reweight";
     m["id"] = getId(*i);
     dataharvester::Writer::file("w.txt").save(m);
 #endif
  
     finalTracks.push_back(vTrData);
   }
   sortByDistanceToRefPoint(finalTracks, vertex.position());
   // cout << "[AdaptiveVertexFitter] /now reweight" << endl;
   return finalTracks;
 }

References hltPixelTracks_cff::chi2, AnnealingSchedule::currentTemp(), HLT_FULL_cff::distance, MillePedeFileConverter_cfg::e, VertexTrackCompatibilityEstimator< N >::estimate(), cppFunctionSkipper::exception, geometryDiff::file, getId(), getWeight(), mps_fire::i, visualization-live-secondInstance_cfg::m, CachingVertex< N >::position(), fileCollector::seed, theAssProbComputer, theComp, theNr, vertex(), CachingVertex< N >::vertexState(), VertexTrackFactory< N >::vertexTrack(), and AnnealingSchedule::weight().

Referenced by fit(), reLinearizeTracks(), and reWeightTracks().

◆ reWeightTracks() [2/2]

vector< AdaptiveVertexFitter::RefCountedVertexTrack > AdaptiveVertexFitter::reWeightTracks	(	const std::vector< RefCountedVertexTrack > &	tracks,
		const CachingVertex< 5 > &	seed
	)		const

private

Construct new a container of VertexTracks with new weights accounting for vertex error, from an existing set of VertexTracks. From these the LinearizedTracks will be reused.

Construct new a container of VertexTrack with new weights accounting for vertex error, from an existing set of VertexTracks. From these the LinearizedTracks will be reused.

Definition at line 437 of file AdaptiveVertexFitter.cc.

                                                                                      {
   vector<RefCountedLinearizedTrackState> lTracks;
   for (vector<RefCountedVertexTrack>::const_iterator i = tracks.begin(); i != tracks.end(); i++) {
     lTracks.push_back((**i).linearizedTrack());
   }
  
   return reWeightTracks(lTracks, seed);
 }

References mps_fire::i, reWeightTracks(), fileCollector::seed, and tracks.

◆ setParameters() [1/2]

void AdaptiveVertexFitter::setParameters ( const edm::ParameterSet & s )

Sets parameters. The following parameters are expected: maxshift, maxlpshift, maxstep, weightthreshold

Definition at line 151 of file AdaptiveVertexFitter.cc.

                                                                  {
   setParameters(s.getParameter<double>("maxshift"),
                 s.getParameter<double>("maxlpshift"),
                 s.getParameter<int>("maxstep"),
                 s.getParameter<double>("weightthreshold"));
 }

References alignCSCRings::s, and setParameters().

◆ setParameters() [2/2]

void AdaptiveVertexFitter::setParameters	(	double	maxshift = `0.0001`,
		double	maxlpshift = `0.1`,
		unsigned	maxstep = `30`,
		double	weightthreshold = `.001`
	)

Reads the configurable parameters.

Parameters

maxshift	if the vertex moves further than this (in cm), then we re-iterate.
maxlpshift	if the vertex moves further than this, then we re-linearize the tracks.
maxstep	that's the maximum of iterations that we allow for.
weightthreshold	that's the minimum track weight for a track to be considered "significant". If fewer than two tracks are significant, an exception is thrown.

Definition at line 144 of file AdaptiveVertexFitter.cc.

                                                                                                                      {
   theMaxShift = maxshift;
   theMaxLPShift = maxlpshift;
   theMaxStep = maxstep;
   theWeightThreshold = weightthreshold;
 }

References theMaxLPShift, theMaxShift, theMaxStep, theWeightThreshold, and HLT_FULL_cff::weightthreshold.

Referenced by AdaptiveGsfVertexFitter::AdaptiveGsfVertexFitter(), AdaptiveVertexFitter(), ConfigurableAdaptiveFitter::configure(), and setParameters().

◆ setWeightThreshold()

void AdaptiveVertexFitter::setWeightThreshold ( float w )

Set the weight threshold should be used only to find (once) a good value FIXME this should disappear in the final version

Definition at line 119 of file AdaptiveVertexFitter.cc.

119 { theWeightThreshold = w; }

References theWeightThreshold, and w.

Referenced by PFTauPrimaryVertexProducerBase::produce(), and AdaptiveVertexReconstructor::setupFitters().

◆ vertex() [1/7]

CachingVertex< 5 > AdaptiveVertexFitter::vertex ( const std::vector< reco::TransientTrack > & unstracks ) const

overridevirtual

Method returning the fitted vertex, from a container of reco::TransientTracks. The linearization point will be searched with the given LP finder. No prior vertex position will be used in the vertex fit.

Returns: The fitted vertex

Implements VertexFitter< 5 >.

Definition at line 158 of file AdaptiveVertexFitter.cc.

                                                                                                {
   if (unstracks.size() < 2) {
     LogError("RecoVertex|AdaptiveVertexFitter") << "Supplied fewer than two tracks. Vertex is invalid.";
     return CachingVertex<5>();  // return invalid vertex
   };
   vector<reco::TransientTrack> tracks = unstracks;
   sortTracksByPt(tracks);
   // Linearization Point
   GlobalPoint linP = theLinP->getLinearizationPoint(tracks);
   // Initial vertex seed, with a very large error matrix
   VertexState lseed(linP, linPointError);
   vector<RefCountedVertexTrack> vtContainer = linearizeTracks(tracks, lseed);
  
   VertexState seed(linP, fitError);
   return fit(vtContainer, seed, false);
 }

References fit(), LinearizationPointFinder::getLinearizationPoint(), linearizeTracks(), fileCollector::seed, theLinP, and tracks.

Referenced by SplitVertexResolution::analyze(), PrimaryVertexResolution::Plots::calculateAndFillResolution(), Tau.Tau::dxy(), V0Fitter::fitAll(), PFDisplacedVertexFinder::fitVertexFromSeed(), PFTauPrimaryVertexProducerBase::produce(), TemplatedInclusiveVertexFinder< InputContainer, VTX >::produce(), reLinearizeTracks(), reWeightTracks(), TrackVertexArbitration< VTX >::trackVertexArbitrator(), AdaptiveGsfVertexFitter::vertex(), and AdaptiveVertexReconstructor::vertices().

◆ vertex() [2/7]

CachingVertex< 5 > AdaptiveVertexFitter::vertex	(	const std::vector< reco::TransientTrack > &	tracks,
		const GlobalPoint &	linPoint
	)		const

overridevirtual

Fit vertex out of a std::vector of reco::TransientTracks. Uses the specified linearization point.

Fit vertex out of a set of reco::TransientTracks. Uses the specified linearization point.

Implements VertexFitter< 5 >.

Definition at line 199 of file AdaptiveVertexFitter.cc.

                                                                                  {
   if (tracks.size() < 2) {
     LogError("RecoVertex|AdaptiveVertexFitter") << "Supplied fewer than two tracks. Vertex is invalid.";
     return CachingVertex<5>();  // return invalid vertex
   };
   // Initial vertex seed, with a very large error matrix
   VertexState seed(linPoint, linPointError);
   vector<RefCountedVertexTrack> vtContainer = linearizeTracks(tracks, seed);
   VertexState fitseed(linPoint, fitError);
   return fit(vtContainer, fitseed, false);
 }

References fit(), linearizeTracks(), fileCollector::seed, and tracks.

Referenced by Tau.Tau::dxy().

◆ vertex() [3/7]

CachingVertex< 5 > AdaptiveVertexFitter::vertex	(	const std::vector< reco::TransientTrack > &	tracks,
		const GlobalPoint &	priorPos,
		const GlobalError &	priorError
	)		const

overridevirtual

Fit vertex out of a set of reco::TransientTracks. Uses the position as both the linearization point AND as prior estimate of the vertex position. The error is used for the weight of the prior estimate.

Implements VertexFitter< 5 >.

Definition at line 247 of file AdaptiveVertexFitter.cc.

 {
   if (tracks.empty()) {
     LogError("RecoVertex|AdaptiveVertexFitter") << "Supplied no tracks. Vertex is invalid.";
     return CachingVertex<5>();  // return invalid vertex
   };
   VertexState seed(priorPos, priorError);
   vector<RefCountedVertexTrack> vtContainer = linearizeTracks(tracks, seed);
   return fit(vtContainer, seed, true);
 }

References fit(), linearizeTracks(), fileCollector::seed, and tracks.

Referenced by Tau.Tau::dxy().

◆ vertex() [4/7]

CachingVertex< 5 > AdaptiveVertexFitter::vertex	(	const std::vector< reco::TransientTrack > &	tracks,
		const reco::BeamSpot &	beamSpot
	)		const

overridevirtual

Fit vertex out of a set of TransientTracks. The specified BeamSpot will be used as priot, but NOT for the linearization. The specified LinearizationPointFinder will be used to find the linearization point.

Implements VertexFitter< 5 >.

Definition at line 216 of file AdaptiveVertexFitter.cc.

                                                                                   {
   if (unstracks.empty()) {
     LogError("RecoVertex|AdaptiveVertexFitter") << "Supplied no tracks. Vertex is invalid.";
     return CachingVertex<5>();  // return invalid vertex
   };
  
   VertexState beamSpotState(beamSpot);
   vector<RefCountedVertexTrack> vtContainer;
  
   vector<reco::TransientTrack> tracks = unstracks;
   sortTracksByPt(tracks);
  
   if (tracks.size() > 1) {
     // Linearization Point search if there are more than 1 track
     GlobalPoint linP = theLinP->getLinearizationPoint(tracks);
     VertexState lpState(linP, linPointError);
     vtContainer = linearizeTracks(tracks, lpState);
   } else {
     // otherwise take the beamspot position.
     vtContainer = linearizeTracks(tracks, beamSpotState);
   }
  
   return fit(vtContainer, beamSpotState, true);
 }

References pwdgSkimBPark_cfi::beamSpot, fit(), LinearizationPointFinder::getLinearizationPoint(), linearizeTracks(), theLinP, and tracks.

Referenced by Tau.Tau::dxy().

◆ vertex() [5/7]

CachingVertex< 5 > AdaptiveVertexFitter::vertex ( const std::vector< RefCountedVertexTrack > & tracks ) const

override

Method returning the fitted vertex, from a container of VertexTracks. For the first loop, the LinearizedTrack contained in the VertexTracks will be used. If subsequent loops are needed, the new VertexTracks will be created with the last estimate of the vertex as linearization point. No prior vertex position will be used in the vertex fit.

Returns: The fitted vertex

Definition at line 175 of file AdaptiveVertexFitter.cc.

                                                                                                {
   if (tracks.size() < 2) {
     LogError("RecoVertex|AdaptiveVertexFitter") << "Supplied fewer than two tracks. Vertex is invalid.";
     return CachingVertex<5>();  // return invalid vertex
   };
   // Initial vertex seed, with a very small weight matrix
   GlobalPoint linP = tracks[0]->linearizedTrack()->linearizationPoint();
   VertexState seed(linP, fitError);
   return fit(tracks, seed, false);
 }

References fit(), fileCollector::seed, and tracks.

Referenced by Tau.Tau::dxy().

◆ vertex() [6/7]

CachingVertex< 5 > AdaptiveVertexFitter::vertex	(	const std::vector< RefCountedVertexTrack > &	tracks,
		const GlobalPoint &	priorPos,
		const GlobalError &	priorError
	)		const

override

Fit vertex out of a set of VertexTracks Uses the position and error for the prior estimate of the vertex. This position is not used to relinearize the tracks.

Definition at line 265 of file AdaptiveVertexFitter.cc.

                                                                                    {
   if (tracks.empty()) {
     LogError("RecoVertex|AdaptiveVertexFitter") << "Supplied no tracks. Vertex is invalid.";
     return CachingVertex<5>();  // return invalid vertex
   };
   VertexState seed(priorPos, priorError);
   return fit(tracks, seed, true);
 }

References fit(), fileCollector::seed, and tracks.

Referenced by Tau.Tau::dxy().

◆ vertex() [7/7]

CachingVertex< 5 > AdaptiveVertexFitter::vertex	(	const std::vector< RefCountedVertexTrack > &	tracks,
		const reco::BeamSpot &	spot
	)		const

override

Same as above, only now also with BeamSpot constraint.

Definition at line 186 of file AdaptiveVertexFitter.cc.

                                                                               {
   if (tracks.empty()) {
     LogError("RecoVertex|AdaptiveVertexFitter") << "Supplied no tracks. Vertex is invalid.";
     return CachingVertex<5>();  // return invalid vertex
   };
   VertexState beamSpotState(spot);
   return fit(tracks, beamSpotState, true);
 }

References fit(), and tracks.

Referenced by Tau.Tau::dxy().

◆ weightTracks()

vector< AdaptiveVertexFitter::RefCountedVertexTrack > AdaptiveVertexFitter::weightTracks	(	const std::vector< RefCountedLinearizedTrackState > &	lTracks,
		const VertexState &	seed
	)		const

private

Weight the tracks, for the first time, using KalmanChiSquare.

track weighting, as opposed to re-weighting, must always be done with a reset annealer!

Definition at line 393 of file AdaptiveVertexFitter.cc.

                                                                                           {
   theNr++;
   CachingVertex<5> seedvtx(seed, vector<RefCountedVertexTrack>(), 0.);
   theAssProbComputer->resetAnnealing();
  
   vector<RefCountedVertexTrack> finalTracks;
   VertexTrackFactory<5> vTrackFactory;
 #ifdef STORE_WEIGHTS
   iter++;
 #endif
   for (vector<RefCountedLinearizedTrackState>::const_iterator i = lTracks.begin(); i != lTracks.end(); i++) {
     double weight = 0.;
     pair<bool, double> chi2Res = theComp->estimate(seedvtx, *i, std::distance(lTracks.begin(), i));
     if (!chi2Res.first) {
       // cout << "[AdaptiveVertexFitter] Aiee! " << endl;
       LogInfo("AdaptiveVertexFitter") << "When weighting a track, chi2 calculation failed;"
                                       << " will add with w=0.";
     } else {
       weight = getWeight(chi2Res.second);
     }
     RefCountedVertexTrack vTrData = vTrackFactory.vertexTrack(*i, seed, weight);
 #ifdef STORE_WEIGHTS
     map<string, dataharvester::MultiType> m;
     m["chi2"] = chi2;
     m["w"] = theAssProbComputer->weight(chi2);
     m["T"] = theAssProbComputer->currentTemp();
     m["n"] = iter;
     m["id"] = getId(*i);
     m["pos"] = "weight";
     dataharvester::Writer::file("w.txt").save(m);
 #endif
     finalTracks.push_back(vTrData);
   }
   return finalTracks;
 }

References hltPixelTracks_cff::chi2, AnnealingSchedule::currentTemp(), HLT_FULL_cff::distance, VertexTrackCompatibilityEstimator< N >::estimate(), geometryDiff::file, getId(), getWeight(), mps_fire::i, visualization-live-secondInstance_cfg::m, AnnealingSchedule::resetAnnealing(), fileCollector::seed, theAssProbComputer, theComp, theNr, VertexTrackFactory< N >::vertexTrack(), and AnnealingSchedule::weight().

Referenced by linearizeTracks().

Member Data Documentation

◆ gsfIntermediarySmoothing_

bool AdaptiveVertexFitter::gsfIntermediarySmoothing_

private

Definition at line 203 of file AdaptiveVertexFitter.h.

Referenced by fit(), and gsfIntermediarySmoothing().

◆ theAssProbComputer

AnnealingSchedule* AdaptiveVertexFitter::theAssProbComputer

private

Definition at line 200 of file AdaptiveVertexFitter.h.

Referenced by fit(), getWeight(), reWeightTracks(), weightTracks(), and ~AdaptiveVertexFitter().

◆ theComp

VertexTrackCompatibilityEstimator<5>* AdaptiveVertexFitter::theComp

private

Definition at line 201 of file AdaptiveVertexFitter.h.

Referenced by reWeightTracks(), weightTracks(), and ~AdaptiveVertexFitter().

◆ theLinP

LinearizationPointFinder* AdaptiveVertexFitter::theLinP

private

Definition at line 197 of file AdaptiveVertexFitter.h.

Referenced by vertex(), and ~AdaptiveVertexFitter().

◆ theLinTrkFactory

const AbstractLTSFactory<5>* AdaptiveVertexFitter::theLinTrkFactory

private

Definition at line 202 of file AdaptiveVertexFitter.h.

Referenced by linearizeTracks(), reLinearizeTracks(), and ~AdaptiveVertexFitter().

◆ theMaxLPShift

double AdaptiveVertexFitter::theMaxLPShift

private

Definition at line 192 of file AdaptiveVertexFitter.h.

Referenced by fit(), and setParameters().

◆ theMaxShift

double AdaptiveVertexFitter::theMaxShift

private

Definition at line 191 of file AdaptiveVertexFitter.h.

Referenced by fit(), and setParameters().

◆ theMaxStep

int AdaptiveVertexFitter::theMaxStep

private

Definition at line 193 of file AdaptiveVertexFitter.h.

Referenced by fit(), and setParameters().

◆ theNr

int AdaptiveVertexFitter::theNr

mutableprivate

Definition at line 195 of file AdaptiveVertexFitter.h.

Referenced by reWeightTracks(), and weightTracks().

◆ theSmoother

VertexSmoother<5>* AdaptiveVertexFitter::theSmoother

private

Definition at line 199 of file AdaptiveVertexFitter.h.

Referenced by fit(), and ~AdaptiveVertexFitter().

◆ theUpdator

VertexUpdator<5>* AdaptiveVertexFitter::theUpdator

private

Definition at line 198 of file AdaptiveVertexFitter.h.

Referenced by fit(), and ~AdaptiveVertexFitter().

◆ theWeightThreshold

double AdaptiveVertexFitter::theWeightThreshold

private

Definition at line 194 of file AdaptiveVertexFitter.h.

Referenced by fit(), setParameters(), and setWeightThreshold().

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ RefCountedLinearizedTrackState

◆ RefCountedVertexTrack

Constructor & Destructor Documentation

◆ AdaptiveVertexFitter() [1/2]

◆ AdaptiveVertexFitter() [2/2]

◆ ~AdaptiveVertexFitter()

Member Function Documentation

◆ clone()

◆ fit()

◆ getWeight()

◆ gsfIntermediarySmoothing() [1/2]

◆ gsfIntermediarySmoothing() [2/2]

◆ linearizeTracks()

◆ reLinearizeTracks()

◆ reWeightTracks() [1/2]

◆ reWeightTracks() [2/2]

◆ setParameters() [1/2]

◆ setParameters() [2/2]

◆ setWeightThreshold()

◆ vertex() [1/7]

◆ vertex() [2/7]

◆ vertex() [3/7]

◆ vertex() [4/7]

◆ vertex() [5/7]

◆ vertex() [6/7]

◆ vertex() [7/7]

◆ weightTracks()

Member Data Documentation

◆ gsfIntermediarySmoothing_

◆ theAssProbComputer

◆ theComp

◆ theLinP

◆ theLinTrkFactory

◆ theMaxLPShift

◆ theMaxShift

◆ theMaxStep

◆ theNr

◆ theSmoother

◆ theUpdator

◆ theWeightThreshold