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 LinearizationPointFinder *	linearizationPointFinder () const
const AbstractLTSFactory< N > *	linearizedTrackStateFactory () const
const float	maxShift () const
const int	maxStep () const
const edm::ParameterSet	parameterSet () const
	SequentialVertexFitter (const edm::ParameterSet &pSet, const LinearizationPointFinder &linP, const VertexUpdator< N > &updator, const VertexSmoother< N > &smoother, const AbstractLTSFactory< N > &ltsf)
	SequentialVertexFitter (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)
CachingVertex< N >	vertex (const std::vector< reco::TransientTrack > &tracks) 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 GlobalPoint &priorPos, const GlobalError &priorError) const override
CachingVertex< N >	vertex (const std::vector< reco::TransientTrack > &tracks, const reco::BeamSpot &beamSpot) const override
CachingVertex< N >	vertex (const std::vector< RefCountedVertexTrack > &tracks) const override
CachingVertex< N >	vertex (const std::vector< RefCountedVertexTrack > &tracks, const GlobalPoint &priorPos, const GlobalError &priorError) const override
CachingVertex< N >	vertex (const std::vector< RefCountedVertexTrack > &tracks, const reco::BeamSpot &spot) 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 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 ()

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

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 21 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 33 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 47 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 58 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 172 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. \parameter tracks The tracks to use in the fit. \paraemter priorVertex The prior estimate of the vertex

Returns

The fitted vertex

Definition at line 221 of file SequentialVertexFitter.cc.

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

Referenced by trackingPlots.Iteration::modules().

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 221 of file SequentialVertexFitter.h.

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

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 184 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.

{ return theMaxShift; }

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

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

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

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

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

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

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

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.

{ theMaxShift = maxShift; }

Referenced by GsfVertexFitter::GsfVertexFitter().

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.

{ theMaxStep = maxIterations; }

Referenced by GsfVertexFitter::GsfVertexFitter().

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

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

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

vertex() [2/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 116 of file SequentialVertexFitter.cc.

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

Referenced by Tau.Tau::dxy().

vertex() [3/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 161 of file SequentialVertexFitter.cc.

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

Referenced by Tau.Tau::dxy().

vertex() [4/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 132 of file SequentialVertexFitter.cc.

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

Referenced by Tau.Tau::dxy().

vertex() [5/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 102 of file SequentialVertexFitter.cc.

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

Referenced by Tau.Tau::dxy().

vertex() [6/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 174 of file SequentialVertexFitter.cc.

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

Referenced by Tau.Tau::dxy().

vertex() [7/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 95 of file SequentialVertexFitter.cc.

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

Referenced by Tau.Tau::dxy().

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 230 of file SequentialVertexFitter.h.

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

theLTrackFactory

template<unsigned int N>

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

private

Definition at line 233 of file SequentialVertexFitter.h.

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

theMaxShift

template<unsigned int N>

float SequentialVertexFitter< N >::theMaxShift

private

Definition at line 226 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 227 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 229 of file SequentialVertexFitter.h.

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

theSmoother

template<unsigned int N>

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

private

Definition at line 232 of file SequentialVertexFitter.h.

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

theUpdator

template<unsigned int N>

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

private

Definition at line 231 of file SequentialVertexFitter.h.

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

theVTrackFactory

template<unsigned int N>

VertexTrackFactory<N> SequentialVertexFitter< N >::theVTrackFactory

private

Definition at line 235 of file SequentialVertexFitter.h.