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
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)
virtual CachingVertex< N >	vertex (const std::vector< reco::TransientTrack > &tracks) const
virtual CachingVertex< N >	vertex (const std::vector< RefCountedVertexTrack > &tracks) const
virtual CachingVertex< N >	vertex (const std::vector< RefCountedVertexTrack > &tracks, const reco::BeamSpot &spot) const
virtual CachingVertex< N >	vertex (const std::vector< reco::TransientTrack > &tracks, const GlobalPoint &linPoint) const
virtual CachingVertex< N >	vertex (const std::vector< reco::TransientTrack > &tracks, const reco::BeamSpot &beamSpot) const
virtual CachingVertex< N >	vertex (const std::vector< reco::TransientTrack > &tracks, const GlobalPoint &priorPos, const GlobalError &priorError) const
virtual CachingVertex< N >	vertex (const std::vector< RefCountedVertexTrack > &tracks, const GlobalPoint &priorPos, const GlobalError &priorError) const
const VertexSmoother< N > *	vertexSmoother () const
const VertexUpdator< N > *	vertexUpdator () const
virtual	~SequentialVertexFitter ()
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

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

Member Typedef Documentation

template<unsigned int N>

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

Definition at line 41 of file SequentialVertexFitter.h.

template<unsigned int N>

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

Definition at line 39 of file SequentialVertexFitter.h.

template<unsigned int N>

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

Definition at line 40 of file SequentialVertexFitter.h.

Constructor & Destructor Documentation

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

References SequentialVertexFitter< N >::setDefaultParameters().

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

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

References SequentialVertexFitter< N >::readParameters().

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

template<unsigned int N>

SequentialVertexFitter< N >::SequentialVertexFitter

(

const SequentialVertexFitter< N > &

original

)

Copy constructor

Definition at line 46 of file SequentialVertexFitter.cc.

References LinearizationPointFinder::clone(), SequentialVertexFitter< N >::linearizationPointFinder(), SequentialVertexFitter< N >::linearizedTrackStateFactory(), SequentialVertexFitter< N >::maxShift(), SequentialVertexFitter< N >::maxStep(), SequentialVertexFitter< N >::parameterSet(), SequentialVertexFitter< N >::vertexSmoother(), and SequentialVertexFitter< N >::vertexUpdator().

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

template<unsigned int N>

SequentialVertexFitter< N >::~SequentialVertexFitter ( )

virtual

Definition at line 60 of file SequentialVertexFitter.cc.

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

template<unsigned int N>

SequentialVertexFitter< N >::SequentialVertexFitter ( )

inlineprotected

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

Definition at line 193 of file SequentialVertexFitter.h.

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

{}

Member Function Documentation

template<unsigned int N>

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

inlinevirtual

Fit vertex out of a VertexSeed

Implements VertexFitter< N >.

Definition at line 180 of file SequentialVertexFitter.h.

Referenced by GsfVertexFitter::GsfVertexFitter().

                                         {
    return new SequentialVertexFitter(* this);
  }

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

References error, VertexState::error(), i, CachingVertex< N >::isValid(), LogDebug, VertexState::position(), CachingVertex< N >::position(), relval_parameters_module::step, testEve_cfg::tracks, transverse(), and CachingVertex< N >::vertexState().

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

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

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

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

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

  {return theLinP;}

template<unsigned int N>

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

inline

Definition at line 184 of file SequentialVertexFitter.h.

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

  { return theLTrackFactory;}

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

References i, and VertexState::position().

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

template<unsigned int N>

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

inline

Definition at line 171 of file SequentialVertexFitter.h.

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

  {return theMaxShift;}

template<unsigned int N>

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

inline

Definition at line 174 of file SequentialVertexFitter.h.

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

  {return theMaxStep;}

template<unsigned int N>

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

inline

Definition at line 177 of file SequentialVertexFitter.h.

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

  {return thePSet;}

template<unsigned int N>

void SequentialVertexFitter< N >::readParameters ( )

private

Reads the configurable parameters.

Definition at line 70 of file SequentialVertexFitter.cc.

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

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

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

References i, VertexState::position(), and VertexState::weight().

{

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

template<unsigned int N>

void SequentialVertexFitter< N >::setDefaultParameters ( )

private

Definition at line 77 of file SequentialVertexFitter.cc.

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

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

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

{theMaxShift = maxShift;}

template<unsigned int N>

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

inline

Method to set the maximum number of iterations to perform

Definition at line 86 of file SequentialVertexFitter.h.

    {theMaxStep = maxIterations;}

template<unsigned int N>

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

virtual

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

References error, and evf::utils::state.

Referenced by 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);
}

template<unsigned int N>

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

virtual

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

References error, and evf::utils::state.

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

template<unsigned int N>

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

virtual

Same as above, only now also with BeamSpot!

Definition at line 102 of file SequentialVertexFitter.cc.

References evf::utils::state.

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

template<unsigned int N>

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

virtual

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

Implements VertexFitter< N >.

Definition at line 129 of file SequentialVertexFitter.cc.

References error, and evf::utils::state.

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

template<unsigned int N>

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

virtual

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

References error.

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

template<unsigned int N>

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

virtual

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

References evf::utils::state.

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

template<unsigned int N>

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

virtual

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

References evf::utils::state.

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

template<unsigned int N>

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

inline

Definition at line 168 of file SequentialVertexFitter.h.

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

  {return theSmoother;}

template<unsigned int N>

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

inline

Definition at line 165 of file SequentialVertexFitter.h.

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

  {return theUpdator;}

Member Data Documentation

template<unsigned int N>

LinearizationPointFinder* SequentialVertexFitter< N >::theLinP

private

Definition at line 254 of file SequentialVertexFitter.h.

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

template<unsigned int N>

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

private

Definition at line 257 of file SequentialVertexFitter.h.

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

template<unsigned int N>

float SequentialVertexFitter< N >::theMaxShift

private

Definition at line 250 of file SequentialVertexFitter.h.

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

template<unsigned int N>

int SequentialVertexFitter< N >::theMaxStep

private

Definition at line 251 of file SequentialVertexFitter.h.

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

template<unsigned int N>

edm::ParameterSet SequentialVertexFitter< N >::thePSet

private

Definition at line 253 of file SequentialVertexFitter.h.

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

template<unsigned int N>

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

private

Definition at line 256 of file SequentialVertexFitter.h.

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

template<unsigned int N>

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

private

Definition at line 255 of file SequentialVertexFitter.h.

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

template<unsigned int N>

VertexTrackFactory<N> SequentialVertexFitter< N >::theVTrackFactory

private

Definition at line 259 of file SequentialVertexFitter.h.