SequentialVertexFitter< N > Class Template Reference

#include <SequentialVertexFitter.h>

Inheritance diagram for SequentialVertexFitter< N >:

Public Types
typedef ReferenceCountingPointer< LinearizedTrackState< N > >	RefCountedLinearizedTrackState
typedef ReferenceCountingPointer< RefittedTrackState< N > >	RefCountedRefittedTrackState
typedef ReferenceCountingPointer< VertexTrack< N > >	RefCountedVertexTrack

Public Member Functions
SequentialVertexFitter *	clone () const override
const bool	insideTrackerBounds (const GlobalPoint &point) const
const LinearizationPointFinder *	linearizationPointFinder () const
const AbstractLTSFactory< N > *	linearizedTrackStateFactory () const
const float	maxShift () const
const int	maxStep () const
const edm::ParameterSet	parameterSet () const
	SequentialVertexFitter (const LinearizationPointFinder &linP, const VertexUpdator< N > &updator, const VertexSmoother< N > &smoother, const AbstractLTSFactory< N > &ltsf)
	SequentialVertexFitter (const edm::ParameterSet &pSet, const LinearizationPointFinder &linP, const VertexUpdator< N > &updator, const VertexSmoother< N > &smoother, const AbstractLTSFactory< N > &ltsf)
	SequentialVertexFitter (const SequentialVertexFitter &original)
void	setMaximumDistance (float maxShift)
void	setMaximumNumberOfIterations (int maxIterations)
void	setTrackerBounds (float radius, float halfLength)
CachingVertex< N >	vertex (const std::vector< reco::TransientTrack > &tracks) const override
CachingVertex< N >	vertex (const std::vector< RefCountedVertexTrack > &tracks) const override
CachingVertex< N >	vertex (const std::vector< RefCountedVertexTrack > &tracks, const reco::BeamSpot &spot) const override
CachingVertex< N >	vertex (const std::vector< reco::TransientTrack > &tracks, const GlobalPoint &linPoint) const override
CachingVertex< N >	vertex (const std::vector< reco::TransientTrack > &tracks, const reco::BeamSpot &beamSpot) const override
CachingVertex< N >	vertex (const std::vector< reco::TransientTrack > &tracks, const GlobalPoint &priorPos, const GlobalError &priorError) const override
CachingVertex< N >	vertex (const std::vector< RefCountedVertexTrack > &tracks, const GlobalPoint &priorPos, const GlobalError &priorError) const override
const VertexSmoother< N > *	vertexSmoother () const
const VertexUpdator< N > *	vertexUpdator () const
	~SequentialVertexFitter () override
Public Member Functions inherited from VertexFitter< N >
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 ()

Protected Member Functions
	SequentialVertexFitter ()

Private Member Functions
CachingVertex< N >	fit (const std::vector< RefCountedVertexTrack > &tracks, const VertexState priorVertex, bool withPrior) const
bool	hasNan (const GlobalPoint &point) const
std::vector< RefCountedVertexTrack >	linearizeTracks (const std::vector< reco::TransientTrack > &tracks, const VertexState state) const
void	readParameters ()
std::vector< RefCountedVertexTrack >	reLinearizeTracks (const std::vector< RefCountedVertexTrack > &tracks, const VertexState state) const
void	setDefaultParameters ()

Private Attributes
LinearizationPointFinder *	theLinP
const AbstractLTSFactory< N > *	theLTrackFactory
float	theMaxShift
int	theMaxStep
edm::ParameterSet	thePSet
VertexSmoother< N > *	theSmoother
VertexUpdator< N > *	theUpdator
VertexTrackFactory< N >	theVTrackFactory
float	trackerBoundsHalfLength {273.5}
float	trackerBoundsRadius {112.}

Detailed Description

template<unsigned int N>
class SequentialVertexFitter< N >

Sequential vertex fitter, where the vertex is updated one track at the time. The fitter will iterate over the set of tracks until the transverse distance between vertices computed in the previous and the current iterations is less than the specified convergence criteria, or until the maximum number of iterations is reached. The transverse distance determines the linearization error. The default convergence criterion is 1 mm. The default maximum number of steps is 10. These parameters can be configured in .orcarc ( SequentialVertexFitter:maximumDistance and SequentialVertexFitter:maximumNumberOfIterations). After the vertex fit, the tracks can be refit with the additional constraint of the vertex position.

Definition at line 34 of file SequentialVertexFitter.h.

Member Typedef Documentation

RefCountedLinearizedTrackState

template<unsigned int N>

typedef ReferenceCountingPointer<LinearizedTrackState<N> > SequentialVertexFitter< N >::RefCountedLinearizedTrackState

Definition at line 38 of file SequentialVertexFitter.h.

RefCountedRefittedTrackState

template<unsigned int N>

typedef ReferenceCountingPointer<RefittedTrackState<N> > SequentialVertexFitter< N >::RefCountedRefittedTrackState

Definition at line 36 of file SequentialVertexFitter.h.

RefCountedVertexTrack

template<unsigned int N>

typedef ReferenceCountingPointer<VertexTrack<N> > SequentialVertexFitter< N >::RefCountedVertexTrack

Definition at line 37 of file SequentialVertexFitter.h.

Constructor & Destructor Documentation

SequentialVertexFitter() [1/4]

template<unsigned int N>

SequentialVertexFitter< N >::SequentialVertexFitter	(	const LinearizationPointFinder &	linP,
		const VertexUpdator< N > &	updator,
		const VertexSmoother< N > &	smoother,
		const AbstractLTSFactory< N > &	ltsf
	)

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 10 of file SequentialVertexFitter.cc.

    : theLinP(linP.clone()),
      theUpdator(updator.clone()),
      theSmoother(smoother.clone()),
      theLTrackFactory(ltsf.clone()) {
  setDefaultParameters();
}

SequentialVertexFitter() [2/4]

template<unsigned int N>

SequentialVertexFitter< N >::SequentialVertexFitter	(	const edm::ParameterSet &	pSet,
		const LinearizationPointFinder &	linP,
		const VertexUpdator< N > &	updator,
		const VertexSmoother< N > &	smoother,
		const AbstractLTSFactory< N > &	ltsf
	)

Same as above, using a ParameterSet to set the convergence criteria

Definition at line 22 of file SequentialVertexFitter.cc.

    : thePSet(pSet),
      theLinP(linP.clone()),
      theUpdator(updator.clone()),
      theSmoother(smoother.clone()),
      theLTrackFactory(ltsf.clone()) {
  readParameters();
}

SequentialVertexFitter() [3/4]

template<unsigned int N>

SequentialVertexFitter< N >::SequentialVertexFitter

(

const SequentialVertexFitter< N > &

original

)

Copy constructor

Definition at line 36 of file SequentialVertexFitter.cc.

                                                                                        {
  thePSet = original.parameterSet();
  theLinP = original.linearizationPointFinder()->clone();
  theUpdator = original.vertexUpdator()->clone();
  theSmoother = original.vertexSmoother()->clone();
  theMaxShift = original.maxShift();
  theMaxStep = original.maxStep();
  theLTrackFactory = original.linearizedTrackStateFactory()->clone();
}

~SequentialVertexFitter()

template<unsigned int N>

SequentialVertexFitter< N >::~SequentialVertexFitter ( )

override

Definition at line 47 of file SequentialVertexFitter.cc.

                                                   {
  delete theLinP;
  delete theUpdator;
  delete theSmoother;
  delete theLTrackFactory;
}

SequentialVertexFitter() [4/4]

template<unsigned int N>

SequentialVertexFitter< N >::SequentialVertexFitter ( )

inlineprotected

Default constructor. Is here, as we do not want anybody to use it.

Definition at line 188 of file SequentialVertexFitter.h.

Referenced by SequentialVertexFitter< 5 >::clone().

{}

Member Function Documentation

clone()

template<unsigned int N>

SequentialVertexFitter* SequentialVertexFitter< N >::clone ( ) const

inlineoverridevirtual

Fit vertex out of a VertexSeed

Implements VertexFitter< N >.

Definition at line 163 of file SequentialVertexFitter.h.

{ return new SequentialVertexFitter(*this); }

fit()

template<unsigned int N>

CachingVertex< N > SequentialVertexFitter< N >::fit ( const std::vector< RefCountedVertexTrack > &  tracks, const VertexState  priorVertex, bool  withPrior  ) const

private

The methode where the vrte fit is actually done. The seed is used as the prior estimate in the vertex fit (in case its error is large, it will have little influence on the fit. The tracks will be relinearized in case further loops are needed. tracks The tracks to use in the fit. priorVertex The prior estimate of the vertex

Returns

The fitted vertex

Definition at line 210 of file SequentialVertexFitter.cc.

Referenced by trackingPlots.Iteration::modules().

                                                                      {
  std::vector<RefCountedVertexTrack> initialTracks;
  GlobalPoint priorVertexPosition = priorVertex.position();
  GlobalError priorVertexError = priorVertex.error();

  CachingVertex<N> returnVertex(priorVertexPosition, priorVertexError, initialTracks, 0);
  if (withPrior) {
    returnVertex = CachingVertex<N>(
        priorVertexPosition, priorVertexError, priorVertexPosition, priorVertexError, initialTracks, 0);
  }
  CachingVertex<N> initialVertex = returnVertex;
  std::vector<RefCountedVertexTrack> globalVTracks = tracks;

  // main loop through all the VTracks
  bool validVertex = true;
  int step = 0;
  GlobalPoint newPosition = priorVertexPosition;
  GlobalPoint previousPosition;
  do {
    CachingVertex<N> fVertex = initialVertex;
    // make new linearized and vertex tracks for the next iteration
    if (step != 0)
      globalVTracks = reLinearizeTracks(tracks, returnVertex.vertexState());

    // update sequentially the vertex estimate
    for (typename std::vector<RefCountedVertexTrack>::const_iterator i = globalVTracks.begin();
         i != globalVTracks.end();
         i++) {
      fVertex = theUpdator->add(fVertex, *i);
      if (!fVertex.isValid())
        break;
    }

    validVertex = fVertex.isValid();
    // check tracker bounds and NaN in position
    if (validVertex && hasNan(fVertex.position())) {
      LogDebug("RecoVertex/SequentialVertexFitter") << "Fitted position is NaN.\n";
      validVertex = false;
    }

    if (validVertex && !insideTrackerBounds(fVertex.position())) {
      LogDebug("RecoVertex/SequentialVertexFitter") << "Fitted position is out of tracker bounds.\n";
      validVertex = false;
    }

    if (!validVertex) {
      // reset initial vertex position to (0,0,0) and force new iteration
      // if number of steps not exceeded
      ROOT::Math::SMatrixIdentity id;
      AlgebraicSymMatrix33 we(id);
      GlobalError error(we * 10000);
      fVertex = CachingVertex<N>(GlobalPoint(0, 0, 0), error, initialTracks, 0);
    }

    previousPosition = newPosition;
    newPosition = fVertex.position();

    returnVertex = fVertex;
    globalVTracks.clear();
    step++;
  } while ((step != theMaxStep) && (((previousPosition - newPosition).transverse() > theMaxShift) || (!validVertex)));

  if (!validVertex) {
    LogDebug("RecoVertex/SequentialVertexFitter")
        << "Fitted position is invalid (out of tracker bounds or has NaN). Returned vertex is invalid\n";
    return CachingVertex<N>();  // return invalid vertex
  }

  if (step >= theMaxStep) {
    LogDebug("RecoVertex/SequentialVertexFitter")
        << "The maximum number of steps has been exceeded. Returned vertex is invalid\n";
    return CachingVertex<N>();  // return invalid vertex
  }

  // smoothing
  returnVertex = theSmoother->smooth(returnVertex);

  return returnVertex;
}

hasNan()

template<unsigned int N>

bool SequentialVertexFitter< N >::hasNan ( const GlobalPoint &  point ) const

inlineprivate

Checks whether any of the three coordinates is a Nan

Definition at line 237 of file SequentialVertexFitter.h.

                                                     {
    using namespace std;
    return (edm::isNotFinite(point.x()) || edm::isNotFinite(point.y()) || edm::isNotFinite(point.z()));
  }

insideTrackerBounds()

template<unsigned int N>

const bool SequentialVertexFitter< N >::insideTrackerBounds ( const GlobalPoint &  point ) const

inline

Method checking whether a point is within the "tracker" bounds. The default values are set to the CMS inner tracker and vertices outsides these bounds will be rejected. To reconstruct vertices within the full detector including the muon system, set the tracker bounds to larger values.

Definition at line 174 of file SequentialVertexFitter.h.

                                                                 {
    return ((point.transverse() < trackerBoundsRadius) && (abs(point.z()) < trackerBoundsHalfLength));
  }

linearizationPointFinder()

template<unsigned int N>

const LinearizationPointFinder* SequentialVertexFitter< N >::linearizationPointFinder ( ) const

inline

Method returning the fitted vertex, from a VertexSeed. For the first loop, the position of the VertexSeed will be used as linearization point. If subsequent loops are needed, the new VertexTracks will be created with the last estimate of the vertex as linearization point. In case a non-sero error is given, the position and error of the VertexSeed will be used as prior estimate in the vertex fit.

Parameters

seed	The VertexSeed to fit.

Returns

The fitted vertex Access methods

Definition at line 151 of file SequentialVertexFitter.h.

{ return theLinP; }

linearizedTrackStateFactory()

template<unsigned int N>

const AbstractLTSFactory<N>* SequentialVertexFitter< N >::linearizedTrackStateFactory ( ) const

inline

Definition at line 165 of file SequentialVertexFitter.h.

{ return theLTrackFactory; }

linearizeTracks()

template<unsigned int N>

vector< typename SequentialVertexFitter< N >::RefCountedVertexTrack > SequentialVertexFitter< N >::linearizeTracks ( const std::vector< reco::TransientTrack > &  tracks, const VertexState  state  ) const

private

Construct a container of VertexTrack from a set of RecTracks.

Parameters

tracks	The container of RecTracks.
seed	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.

Definition at line 173 of file SequentialVertexFitter.cc.

                                                                                {
  GlobalPoint linP = state.position();
  std::vector<RefCountedVertexTrack> finalTracks;
  finalTracks.reserve(tracks.size());
  for (vector<reco::TransientTrack>::const_iterator i = tracks.begin(); i != tracks.end(); i++) {
    RefCountedLinearizedTrackState lTrData = theLTrackFactory->linearizedTrackState(linP, *i);
    RefCountedVertexTrack vTrData = theVTrackFactory.vertexTrack(lTrData, state);
    finalTracks.push_back(vTrData);
  }
  return finalTracks;
}

maxShift()

template<unsigned int N>

const float SequentialVertexFitter< N >::maxShift ( ) const

inline

Definition at line 157 of file SequentialVertexFitter.h.

Referenced by SequentialVertexFitter< 5 >::setMaximumDistance().

{ return theMaxShift; }

maxStep()

template<unsigned int N>

const int SequentialVertexFitter< N >::maxStep ( ) const

inline

Definition at line 159 of file SequentialVertexFitter.h.

{ return theMaxStep; }

parameterSet()

template<unsigned int N>

const edm::ParameterSet SequentialVertexFitter< N >::parameterSet ( ) const

inline

Definition at line 161 of file SequentialVertexFitter.h.

{ return thePSet; }

readParameters()

template<unsigned int N>

void SequentialVertexFitter< N >::readParameters ( )

private

Reads the configurable parameters.

Definition at line 55 of file SequentialVertexFitter.cc.

Referenced by SequentialVertexFitter< 5 >::SequentialVertexFitter().

                                               {
  theMaxShift = thePSet.getParameter<double>("maxDistance");     //0.01
  theMaxStep = thePSet.getParameter<int>("maxNbrOfIterations");  //10
}

reLinearizeTracks()

template<unsigned int N>

vector< typename SequentialVertexFitter< N >::RefCountedVertexTrack > SequentialVertexFitter< N >::reLinearizeTracks ( const std::vector< RefCountedVertexTrack > &  tracks, const VertexState  state  ) 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 RecTracks will be extracted.
seed	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.

Definition at line 191 of file SequentialVertexFitter.cc.

                                                                                   {
  GlobalPoint linP = state.position();
  std::vector<RefCountedVertexTrack> finalTracks;
  finalTracks.reserve(tracks.size());
  for (typename std::vector<RefCountedVertexTrack>::const_iterator i = tracks.begin(); i != tracks.end(); i++) {
    RefCountedLinearizedTrackState lTrData = (**i).linearizedTrack()->stateWithNewLinearizationPoint(linP);
    //    RefCountedLinearizedTrackState lTrData =
    //      theLTrackFactory->linearizedTrackState(linP,
    //                  (**i).linearizedTrack()->track());
    RefCountedVertexTrack vTrData = theVTrackFactory.vertexTrack(lTrData, state, (**i).weight());
    finalTracks.push_back(vTrData);
  }
  return finalTracks;
}

setDefaultParameters()

template<unsigned int N>

void SequentialVertexFitter< N >::setDefaultParameters ( )

private

Definition at line 61 of file SequentialVertexFitter.cc.

Referenced by SequentialVertexFitter< 5 >::SequentialVertexFitter().

                                                     {
  thePSet.addParameter<double>("maxDistance", 0.01);
  thePSet.addParameter<int>("maxNbrOfIterations", 10);  //10
  readParameters();
}

setMaximumDistance()

template<unsigned int N>

void SequentialVertexFitter< N >::setMaximumDistance ( float  maxShift )

inline

Method to set the convergence criterion (the maximum distance between the vertex computed in the previous and the current iterations to consider the fit to have converged)

Definition at line 75 of file SequentialVertexFitter.h.

Referenced by GsfVertexFitter::GsfVertexFitter().

{ theMaxShift = maxShift; }

setMaximumNumberOfIterations()

template<unsigned int N>

void SequentialVertexFitter< N >::setMaximumNumberOfIterations ( int  maxIterations )

inline

Method to set the maximum number of iterations to perform

Definition at line 81 of file SequentialVertexFitter.h.

Referenced by GsfVertexFitter::GsfVertexFitter().

{ theMaxStep = maxIterations; }

setTrackerBounds()

template<unsigned int N>

void SequentialVertexFitter< N >::setTrackerBounds ( float  radius, float  halfLength  )

inline

Definition at line 178 of file SequentialVertexFitter.h.

                                                        {
    trackerBoundsRadius = radius;
    trackerBoundsHalfLength = halfLength;
  }

vertex() [1/7]

template<unsigned int N>

CachingVertex< N > SequentialVertexFitter< N >::vertex ( const std::vector< reco::TransientTrack > &  tracks ) 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.

Parameters

tracks

The container of RecTracks to fit.

Returns

The fitted vertex

Implements VertexFitter< N >.

Definition at line 68 of file SequentialVertexFitter.cc.

Referenced by Tau.Tau::dxy(), GsfVertexFitter::vertex(), and KalmanVertexFitter::vertex().

                                                                                                    {
  // Linearization Point
  GlobalPoint linP = theLinP->getLinearizationPoint(tracks);
  if (!insideTrackerBounds(linP))
    linP = GlobalPoint(0, 0, 0);

  // Initial vertex state, with a very large error matrix
  ROOT::Math::SMatrixIdentity id;
  AlgebraicSymMatrix33 we(id);
  GlobalError error(we * 10000);
  VertexState state(linP, error);
  std::vector<RefCountedVertexTrack> vtContainer = linearizeTracks(tracks, state);
  return fit(vtContainer, state, false);
}

vertex() [2/7]

template<unsigned int N>

CachingVertex< N > SequentialVertexFitter< N >::vertex ( const std::vector< RefCountedVertexTrack > &  tracks ) const

override

Method returning the fitted vertex, from a container of VertexTracks. For the first loop, the LinearizedTrackState 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.

Parameters

tracks

The container of VertexTracks to fit.

Returns

The fitted vertex

Definition at line 91 of file SequentialVertexFitter.cc.

Referenced by Tau.Tau::dxy().

                                                                                                       {
  // Initial vertex state, with a very small weight matrix
  GlobalPoint linP = tracks[0]->linearizedTrack()->linearizationPoint();
  ROOT::Math::SMatrixIdentity id;
  AlgebraicSymMatrix33 we(id);
  GlobalError error(we * 10000);
  VertexState state(linP, error);
  return fit(tracks, state, false);
}

vertex() [3/7]

template<unsigned int N>

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

override

Same as above, only now also with BeamSpot!

Definition at line 84 of file SequentialVertexFitter.cc.

Referenced by Tau.Tau::dxy().

                                                                                   {
  VertexState state(spot);
  return fit(tracks, state, true);
}

vertex() [4/7]

template<unsigned int N>

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

overridevirtual

Fit vertex out of a set of RecTracks. Uses the specified linearization point.

Implements VertexFitter< N >.

Definition at line 105 of file SequentialVertexFitter.cc.

Referenced by Tau.Tau::dxy().

                                                                                      {
  // Initial vertex state, with a very large error matrix
  ROOT::Math::SMatrixIdentity id;
  AlgebraicSymMatrix33 we(id);
  GlobalError error(we * 10000);
  VertexState state(linPoint, error);
  std::vector<RefCountedVertexTrack> vtContainer = linearizeTracks(tracks, state);
  return fit(vtContainer, state, false);
}

vertex() [5/7]

template<unsigned int N>

CachingVertex< N > SequentialVertexFitter< N >::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< N >.

Definition at line 121 of file SequentialVertexFitter.cc.

Referenced by Tau.Tau::dxy().

                                                                                   {
  VertexState beamSpotState(beamSpot);
  std::vector<RefCountedVertexTrack> vtContainer;

  if (tracks.size() > 1) {
    // Linearization Point search if there are more than 1 track
    GlobalPoint linP = theLinP->getLinearizationPoint(tracks);
    if (!insideTrackerBounds(linP))
      linP = GlobalPoint(0, 0, 0);
    ROOT::Math::SMatrixIdentity id;
    AlgebraicSymMatrix33 we(id);
    GlobalError error(we * 10000);
    VertexState lpState(linP, error);
    vtContainer = linearizeTracks(tracks, lpState);
  } else {
    // otherwise take the beamspot position.
    vtContainer = linearizeTracks(tracks, beamSpotState);
  }

  return fit(vtContainer, beamSpotState, true);
}

vertex() [6/7]

template<unsigned int N>

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

overridevirtual

Fit vertex out of a set of RecTracks. 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< N >.

Definition at line 150 of file SequentialVertexFitter.cc.

Referenced by Tau.Tau::dxy().

                                                                                        {
  VertexState state(priorPos, priorError);
  std::vector<RefCountedVertexTrack> vtContainer = linearizeTracks(tracks, state);
  return fit(vtContainer, state, true);
}

vertex() [7/7]

template<unsigned int N>

CachingVertex< N > SequentialVertexFitter< N >::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 163 of file SequentialVertexFitter.cc.

Referenced by Tau.Tau::dxy().

                                                                                        {
  VertexState state(priorPos, priorError);
  return fit(tracks, state, true);
}

vertexSmoother()

template<unsigned int N>

const VertexSmoother<N>* SequentialVertexFitter< N >::vertexSmoother ( ) const

inline

Definition at line 155 of file SequentialVertexFitter.h.

{ return theSmoother; }

vertexUpdator()

template<unsigned int N>

const VertexUpdator<N>* SequentialVertexFitter< N >::vertexUpdator ( ) const

inline

Definition at line 153 of file SequentialVertexFitter.h.

{ return theUpdator; }

Member Data Documentation

theLinP

template<unsigned int N>

LinearizationPointFinder* SequentialVertexFitter< N >::theLinP

private

Definition at line 250 of file SequentialVertexFitter.h.

Referenced by SequentialVertexFitter< 5 >::linearizationPointFinder().

theLTrackFactory

template<unsigned int N>

const AbstractLTSFactory<N>* SequentialVertexFitter< N >::theLTrackFactory

private

Definition at line 253 of file SequentialVertexFitter.h.

Referenced by SequentialVertexFitter< 5 >::linearizedTrackStateFactory().

theMaxShift

template<unsigned int N>

float SequentialVertexFitter< N >::theMaxShift

private

Definition at line 242 of file SequentialVertexFitter.h.

Referenced by SequentialVertexFitter< 5 >::maxShift(), and SequentialVertexFitter< 5 >::setMaximumDistance().

theMaxStep

template<unsigned int N>

int SequentialVertexFitter< N >::theMaxStep

private

Definition at line 243 of file SequentialVertexFitter.h.

Referenced by SequentialVertexFitter< 5 >::maxStep(), and SequentialVertexFitter< 5 >::setMaximumNumberOfIterations().

thePSet

template<unsigned int N>

edm::ParameterSet SequentialVertexFitter< N >::thePSet

private

Definition at line 249 of file SequentialVertexFitter.h.

Referenced by SequentialVertexFitter< 5 >::parameterSet().

theSmoother

template<unsigned int N>

VertexSmoother<N>* SequentialVertexFitter< N >::theSmoother

private

Definition at line 252 of file SequentialVertexFitter.h.

Referenced by SequentialVertexFitter< 5 >::vertexSmoother().

theUpdator

template<unsigned int N>

VertexUpdator<N>* SequentialVertexFitter< N >::theUpdator

private

Definition at line 251 of file SequentialVertexFitter.h.

Referenced by SequentialVertexFitter< 5 >::vertexUpdator().

theVTrackFactory

template<unsigned int N>

VertexTrackFactory<N> SequentialVertexFitter< N >::theVTrackFactory

private

Definition at line 255 of file SequentialVertexFitter.h.

trackerBoundsHalfLength

template<unsigned int N>

float SequentialVertexFitter< N >::trackerBoundsHalfLength {273.5}

private

Definition at line 247 of file SequentialVertexFitter.h.

Referenced by SequentialVertexFitter< 5 >::insideTrackerBounds(), and SequentialVertexFitter< 5 >::setTrackerBounds().

trackerBoundsRadius

template<unsigned int N>

float SequentialVertexFitter< N >::trackerBoundsRadius {112.}

private

Definition at line 246 of file SequentialVertexFitter.h.

Referenced by SequentialVertexFitter< 5 >::insideTrackerBounds(), and SequentialVertexFitter< 5 >::setTrackerBounds().