AdaptiveVertexFitter Class Reference

#include <AdaptiveVertexFitter.h>

Inheritance diagram for AdaptiveVertexFitter:

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

Public Member Functions
	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 (const AdaptiveVertexFitter &original)
AdaptiveVertexFitter *	clone () const override
void	gsfIntermediarySmoothing (bool sm)
bool	gsfIntermediarySmoothing () const
void	setParameters (double maxshift=0.0001, double maxlpshift=0.1, unsigned maxstep=30, double weightthreshold=.001)
void	setParameters (const edm::ParameterSet &)
void	setWeightThreshold (float w)
CachingVertex< 5 >	vertex (const std::vector< reco::TransientTrack > &) const override
CachingVertex< 5 >	vertex (const std::vector< RefCountedVertexTrack > &) const override
CachingVertex< 5 >	vertex (const std::vector< RefCountedVertexTrack > &, const reco::BeamSpot &spot) 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 GlobalPoint &priorPos, const GlobalError &priorError) 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 reco::BeamSpot &spot) const=0
virtual CachingVertex< N >	vertex (const std::vector< typename CachingVertex< N >::RefCountedVertexTrack > &tracks, const GlobalPoint &priorPos, const GlobalError &priorError) 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.

References setParameters().

Referenced by clone().

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

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.

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

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

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.

References AdaptiveVertexFitter().

{ return new AdaptiveVertexFitter(*this); }

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.

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().

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

getWeight()

double AdaptiveVertexFitter::getWeight ( float  chi2 ) const

private

Definition at line 329 of file AdaptiveVertexFitter.cc.

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

Referenced by reWeightTracks(), and weightTracks().

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

gsfIntermediarySmoothing() [1/2]

void AdaptiveVertexFitter::gsfIntermediarySmoothing ( bool  sm )

inline

Definition at line 135 of file AdaptiveVertexFitter.h.

References gsfIntermediarySmoothing_.

Referenced by AdaptiveGsfVertexFitter::AdaptiveGsfVertexFitter().

{ gsfIntermediarySmoothing_ = sm; }

gsfIntermediarySmoothing() [2/2]

bool AdaptiveVertexFitter::gsfIntermediarySmoothing ( ) const

inline

Definition at line 137 of file AdaptiveVertexFitter.h.

References gsfIntermediarySmoothing_.

{ return gsfIntermediarySmoothing_; }

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.

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

Referenced by vertex().

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

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.

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().

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

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.

References hltPixelTracks_cff::chi2, AnnealingSchedule::currentTemp(), HLT_2022v12_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().

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

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.

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

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

  return reWeightTracks(lTracks, seed);
}

setParameters() [1/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.

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

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

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

setParameters() [2/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.

References alignCSCRings::s, and setParameters().

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

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.

References theWeightThreshold, and w().

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

{ theWeightThreshold = w; }

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.

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().

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

vertex() [2/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.

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

Referenced by Tau.Tau::dxy().

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

vertex() [3/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.

References fit(), and tracks.

Referenced by Tau.Tau::dxy().

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

vertex() [4/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.

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

Referenced by Tau.Tau::dxy().

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

vertex() [5/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.

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

Referenced by Tau.Tau::dxy().

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

vertex() [6/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.

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

Referenced by Tau.Tau::dxy().

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

vertex() [7/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.

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

Referenced by Tau.Tau::dxy().

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

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.

References hltPixelTracks_cff::chi2, AnnealingSchedule::currentTemp(), HLT_2022v12_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().

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

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().