CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Types | Public Member Functions | Protected Member Functions | Private Member Functions | Private Attributes
SequentialVertexFitter< N > Class Template Reference

#include <SequentialVertexFitter.h>

Inheritance diagram for SequentialVertexFitter< N >:
VertexFitter< N >

Public Types

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

Public Member Functions

SequentialVertexFitterclone () const
 
const LinearizationPointFinderlinearizationPointFinder () 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

LinearizationPointFindertheLinP
 
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

Definition at line 40 of file SequentialVertexFitter.h.

Definition at line 38 of file SequentialVertexFitter.h.

Definition at line 39 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().

26  :
27  theLinP(linP.clone()), theUpdator(updator.clone()),
28  theSmoother(smoother.clone()), theLTrackFactory ( ltsf.clone() )
29 {
31 }
LinearizationPointFinder * theLinP
VertexUpdator< N > * theUpdator
virtual VertexSmoother * clone() const =0
const AbstractLTSFactory< N > * theLTrackFactory
virtual const AbstractLTSFactory * clone() const =0
virtual LinearizationPointFinder * clone() const =0
virtual VertexUpdator * clone() const =0
VertexSmoother< N > * theSmoother
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().

37  :
38  thePSet(pSet), theLinP(linP.clone()), theUpdator(updator.clone()),
39  theSmoother(smoother.clone()), theLTrackFactory ( ltsf.clone() )
40 {
42 }
LinearizationPointFinder * theLinP
VertexUpdator< N > * theUpdator
virtual VertexSmoother * clone() const =0
const AbstractLTSFactory< N > * theLTrackFactory
virtual const AbstractLTSFactory * clone() const =0
virtual LinearizationPointFinder * clone() const =0
virtual VertexUpdator * clone() const =0
VertexSmoother< N > * theSmoother
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().

48 {
49  thePSet = original.parameterSet();
50  theLinP = original.linearizationPointFinder()->clone();
51  theUpdator = original.vertexUpdator()->clone();
52  theSmoother = original.vertexSmoother()->clone();
53  theMaxShift = original.maxShift();
54  theMaxStep = original.maxStep();
55  theLTrackFactory = original.linearizedTrackStateFactory()->clone();
56 }
LinearizationPointFinder * theLinP
const VertexUpdator< N > * vertexUpdator() const
VertexUpdator< N > * theUpdator
const AbstractLTSFactory< N > * theLTrackFactory
const AbstractLTSFactory< N > * linearizedTrackStateFactory() const
const VertexSmoother< N > * vertexSmoother() const
const edm::ParameterSet parameterSet() const
virtual LinearizationPointFinder * clone() const =0
const float maxShift() const
VertexSmoother< N > * theSmoother
const LinearizationPointFinder * linearizationPointFinder() const
template<unsigned int N>
SequentialVertexFitter< N >::~SequentialVertexFitter ( )
virtual

Definition at line 60 of file SequentialVertexFitter.cc.

61 {
62  delete theLinP;
63  delete theUpdator;
64  delete theSmoother;
65  delete theLTrackFactory;
66 }
LinearizationPointFinder * theLinP
VertexUpdator< N > * theUpdator
const AbstractLTSFactory< N > * theLTrackFactory
VertexSmoother< N > * theSmoother
template<unsigned int N>
SequentialVertexFitter< N >::SequentialVertexFitter ( )
inlineprotected

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

Definition at line 192 of file SequentialVertexFitter.h.

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

192 {}

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

Referenced by GsfVertexFitter::GsfVertexFitter().

179  {
180  return new SequentialVertexFitter(* this);
181  }
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 254 of file SequentialVertexFitter.cc.

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

256 {
257  std::vector<RefCountedVertexTrack> initialTracks;
258  GlobalPoint priorVertexPosition = priorVertex.position();
259  GlobalError priorVertexError = priorVertex.error();
260 
261  CachingVertex<N> returnVertex(priorVertexPosition,priorVertexError,initialTracks,0);
262  if (withPrior) {
263  returnVertex = CachingVertex<N>(priorVertexPosition,priorVertexError,
264  priorVertexPosition,priorVertexError,initialTracks,0);
265  }
266  CachingVertex<N> initialVertex = returnVertex;
267  std::vector<RefCountedVertexTrack> globalVTracks = tracks;
268 
269  // main loop through all the VTracks
270  bool validVertex = true;
271  int step = 0;
272  GlobalPoint newPosition = priorVertexPosition;
273  GlobalPoint previousPosition;
274  do {
275  CachingVertex<N> fVertex = initialVertex;
276  // make new linearized and vertex tracks for the next iteration
277  if(step != 0) globalVTracks = reLinearizeTracks(tracks,
278  returnVertex.vertexState());
279 
280  // update sequentially the vertex estimate
281  for (typename std::vector<RefCountedVertexTrack>::const_iterator i
282  = globalVTracks.begin(); i != globalVTracks.end(); i++) {
283  fVertex = theUpdator->add(fVertex,*i);
284  if (!fVertex.isValid()) break;
285  }
286 
287  validVertex = fVertex.isValid();
288  // check tracker bounds and NaN in position
289  if (validVertex && hasNan(fVertex.position())) {
290  LogDebug("RecoVertex/SequentialVertexFitter")
291  << "Fitted position is NaN.\n";
292  validVertex = false;
293  }
294 
295  if (validVertex && !insideTrackerBounds(fVertex.position())) {
296  LogDebug("RecoVertex/SequentialVertexFitter")
297  << "Fitted position is out of tracker bounds.\n";
298  validVertex = false;
299  }
300 
301  if (!validVertex) {
302  // reset initial vertex position to (0,0,0) and force new iteration
303  // if number of steps not exceeded
305  fVertex = CachingVertex<N>(GlobalPoint(0,0,0), error,
306  initialTracks, 0);
307  }
308 
309  previousPosition = newPosition;
310  newPosition = fVertex.position();
311 
312  returnVertex = fVertex;
313  globalVTracks.clear();
314  step++;
315  } while ( (step != theMaxStep) &&
316  (((previousPosition - newPosition).transverse() > theMaxShift) ||
317  (!validVertex) ) );
318 
319  if (!validVertex) {
320  LogDebug("RecoVertex/SequentialVertexFitter")
321  << "Fitted position is invalid (out of tracker bounds or has NaN). Returned vertex is invalid\n";
322  return CachingVertex<N>(); // return invalid vertex
323  }
324 
325  if (step >= theMaxStep) {
326  LogDebug("RecoVertex/SequentialVertexFitter")
327  << "The maximum number of steps has been exceeded. Returned vertex is invalid\n";
328  return CachingVertex<N>(); // return invalid vertex
329  }
330 
331  // smoothing
332  returnVertex = theSmoother->smooth(returnVertex);
333 
334  return returnVertex;
335 }
#define LogDebug(id)
int i
Definition: DBlmapReader.cc:9
std::vector< RefCountedVertexTrack > reLinearizeTracks(const std::vector< RefCountedVertexTrack > &tracks, const VertexState state) const
list step
Definition: launcher.py:15
VertexUpdator< N > * theUpdator
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
GlobalPoint position() const
Definition: VertexState.h:29
tuple tracks
Definition: testEve_cfg.py:39
GlobalPoint position() const
T transverse() const
Another name for perp()
CLHEP::HepSymMatrix AlgebraicSymMatrix
bool isValid() const
Definition: CachingVertex.h:96
GlobalError error() const
Definition: VertexState.h:34
bool hasNan(const GlobalPoint &point) const
VertexSmoother< N > * theSmoother
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 243 of file SequentialVertexFitter.h.

243  {
244  using namespace std;
245  return (isnan(point.x())|| isnan(point.y()) || isnan(point.z()));
246  }
T y() const
Definition: PV3DBase.h:57
bool isnan(float x)
Definition: math.h:13
T z() const
Definition: PV3DBase.h:58
T x() const
Definition: PV3DBase.h:56
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
seedThe VertexSeed to fit.
Returns
The fitted vertex Access methods

Definition at line 161 of file SequentialVertexFitter.h.

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

162  {return theLinP;}
LinearizationPointFinder * theLinP
template<unsigned int N>
const AbstractLTSFactory<N>* SequentialVertexFitter< N >::linearizedTrackStateFactory ( ) const
inline

Definition at line 183 of file SequentialVertexFitter.h.

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

184  { return theLTrackFactory;}
const AbstractLTSFactory< N > * 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
tracksThe container of RecTracks.
seedThe 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 203 of file SequentialVertexFitter.cc.

References i, and VertexState::position().

206 {
207  GlobalPoint linP = state.position();
208  std::vector<RefCountedVertexTrack> finalTracks;
209  finalTracks.reserve(tracks.size());
210  for(vector<reco::TransientTrack>::const_iterator i = tracks.begin();
211  i != tracks.end(); i++) {
213  = theLTrackFactory->linearizedTrackState(linP, *i);
214  RefCountedVertexTrack vTrData = theVTrackFactory.vertexTrack(lTrData,state);
215  finalTracks.push_back(vTrData);
216  }
217  return finalTracks;
218 }
int i
Definition: DBlmapReader.cc:9
VertexTrackFactory< N > theVTrackFactory
const AbstractLTSFactory< N > * theLTrackFactory
GlobalPoint position() const
Definition: VertexState.h:29
ReferenceCountingPointer< VertexTrack< N > > RefCountedVertexTrack
tuple tracks
Definition: testEve_cfg.py:39
ReferenceCountingPointer< LinearizedTrackState< N > > RefCountedLinearizedTrackState
template<unsigned int N>
const float SequentialVertexFitter< N >::maxShift ( ) const
inline
template<unsigned int N>
const int SequentialVertexFitter< N >::maxStep ( ) const
inline
template<unsigned int N>
const edm::ParameterSet SequentialVertexFitter< N >::parameterSet ( ) const
inline

Definition at line 176 of file SequentialVertexFitter.h.

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

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

71 {
72  theMaxShift = thePSet.getParameter<double>("maxDistance"); //0.01
73  theMaxStep = thePSet.getParameter<int>("maxNbrOfIterations"); //10
74 }
T getParameter(std::string const &) const
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
tracksThe original container of VertexTracks, from which the RecTracks will be extracted.
seedThe 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 227 of file SequentialVertexFitter.cc.

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

230 {
231 
232  GlobalPoint linP = state.position();
233  std::vector<RefCountedVertexTrack> finalTracks;
234  finalTracks.reserve(tracks.size());
235  for(typename std::vector<RefCountedVertexTrack>::const_iterator i = tracks.begin();
236  i != tracks.end(); i++) {
238  (**i).linearizedTrack()->stateWithNewLinearizationPoint(linP);
239  // RefCountedLinearizedTrackState lTrData =
240  // theLTrackFactory->linearizedTrackState(linP,
241  // (**i).linearizedTrack()->track());
242  RefCountedVertexTrack vTrData =
243  theVTrackFactory.vertexTrack(lTrData,state, (**i).weight() );
244  finalTracks.push_back(vTrData);
245  }
246  return finalTracks;
247 }
int i
Definition: DBlmapReader.cc:9
VertexTrackFactory< N > theVTrackFactory
GlobalPoint position() const
Definition: VertexState.h:29
ReferenceCountingPointer< VertexTrack< N > > RefCountedVertexTrack
GlobalWeight weight() const
Definition: VertexState.h:39
tuple tracks
Definition: testEve_cfg.py:39
ReferenceCountingPointer< LinearizedTrackState< N > > RefCountedLinearizedTrackState
template<unsigned int N>
void SequentialVertexFitter< N >::setDefaultParameters ( )
private

Definition at line 77 of file SequentialVertexFitter.cc.

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

78 {
79  thePSet.addParameter<double>("maxDistance", 0.01);
80  thePSet.addParameter<int>("maxNbrOfIterations", 10); //10
82 }
void addParameter(std::string const &name, T const &value)
Definition: ParameterSet.h:139
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 78 of file SequentialVertexFitter.h.

template<unsigned int N>
void SequentialVertexFitter< N >::setMaximumNumberOfIterations ( int  maxIterations)
inline

Method to set the maximum number of iterations to perform

Definition at line 85 of file SequentialVertexFitter.h.

86  {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
tracksThe 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().

87 {
88  // Linearization Point
90  if (!insideTrackerBounds(linP)) linP = GlobalPoint(0,0,0);
91 
92  // Initial vertex state, with a very large error matrix
93  AlgebraicSymMatrix we(3,1);
94  GlobalError error(we*10000);
95  VertexState state(linP, error);
96  std::vector<RefCountedVertexTrack> vtContainer = linearizeTracks(tracks, state);
97  return fit(vtContainer, state, false);
98 }
LinearizationPointFinder * theLinP
CachingVertex< N > fit(const std::vector< RefCountedVertexTrack > &tracks, const VertexState priorVertex, bool withPrior) const
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
tuple tracks
Definition: testEve_cfg.py:39
char state
Definition: procUtils.cc:75
virtual GlobalPoint getLinearizationPoint(const std::vector< reco::TransientTrack > &) const =0
CLHEP::HepSymMatrix AlgebraicSymMatrix
std::vector< RefCountedVertexTrack > linearizeTracks(const std::vector< reco::TransientTrack > &tracks, const VertexState state) const
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
tracksThe container of VertexTracks to fit.
Returns
The fitted vertex

Definition at line 111 of file SequentialVertexFitter.cc.

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

112 {
113  // Initial vertex state, with a very small weight matrix
114  GlobalPoint linP = tracks[0]->linearizedTrack()->linearizationPoint();
115  AlgebraicSymMatrix we(3,1);
116  GlobalError error(we*10000);
117  VertexState state(linP, error);
118  return fit(tracks, state, false);
119 }
CachingVertex< N > fit(const std::vector< RefCountedVertexTrack > &tracks, const VertexState priorVertex, bool withPrior) const
tuple tracks
Definition: testEve_cfg.py:39
char state
Definition: procUtils.cc:75
CLHEP::HepSymMatrix AlgebraicSymMatrix
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 101 of file SequentialVertexFitter.cc.

References evf::utils::state.

104 {
105  VertexState state(spot);
106  return fit(tracks, state, true );
107 }
CachingVertex< N > fit(const std::vector< RefCountedVertexTrack > &tracks, const VertexState priorVertex, bool withPrior) const
tuple tracks
Definition: testEve_cfg.py:39
char state
Definition: procUtils.cc:75
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 127 of file SequentialVertexFitter.cc.

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

129 {
130  // Initial vertex state, with a very large error matrix
131  AlgebraicSymMatrix we(3,1);
132  GlobalError error(we*10000);
133  VertexState state(linPoint, error);
134  std::vector<RefCountedVertexTrack> vtContainer = linearizeTracks(tracks, state);
135  return fit(vtContainer, state, false);
136 }
CachingVertex< N > fit(const std::vector< RefCountedVertexTrack > &tracks, const VertexState priorVertex, bool withPrior) const
tuple tracks
Definition: testEve_cfg.py:39
char state
Definition: procUtils.cc:75
CLHEP::HepSymMatrix AlgebraicSymMatrix
std::vector< RefCountedVertexTrack > linearizeTracks(const std::vector< reco::TransientTrack > &tracks, const VertexState state) const
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 145 of file SequentialVertexFitter.cc.

References error.

147 {
148  VertexState beamSpotState(beamSpot);
149  std::vector<RefCountedVertexTrack> vtContainer;
150 
151  if (tracks.size() > 1) {
152  // Linearization Point search if there are more than 1 track
154  if (!insideTrackerBounds(linP)) linP = GlobalPoint(0,0,0);
155  AlgebraicSymMatrix we(3,1);
156  GlobalError error(we*10000);
157  VertexState lpState(linP, error);
158  vtContainer = linearizeTracks(tracks, lpState);
159  } else {
160  // otherwise take the beamspot position.
161  vtContainer = linearizeTracks(tracks, beamSpotState);
162  }
163 
164  return fit(vtContainer, beamSpotState, true);
165 }
LinearizationPointFinder * theLinP
CachingVertex< N > fit(const std::vector< RefCountedVertexTrack > &tracks, const VertexState priorVertex, bool withPrior) const
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
tuple tracks
Definition: testEve_cfg.py:39
virtual GlobalPoint getLinearizationPoint(const std::vector< reco::TransientTrack > &) const =0
CLHEP::HepSymMatrix AlgebraicSymMatrix
std::vector< RefCountedVertexTrack > linearizeTracks(const std::vector< reco::TransientTrack > &tracks, const VertexState state) const
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 174 of file SequentialVertexFitter.cc.

References evf::utils::state.

178 {
179  VertexState state(priorPos, priorError);
180  std::vector<RefCountedVertexTrack> vtContainer = linearizeTracks(tracks, state);
181  return fit(vtContainer, state, true);
182 }
CachingVertex< N > fit(const std::vector< RefCountedVertexTrack > &tracks, const VertexState priorVertex, bool withPrior) const
tuple tracks
Definition: testEve_cfg.py:39
char state
Definition: procUtils.cc:75
std::vector< RefCountedVertexTrack > linearizeTracks(const std::vector< reco::TransientTrack > &tracks, const VertexState state) const
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 189 of file SequentialVertexFitter.cc.

References evf::utils::state.

193 {
194  VertexState state(priorPos, priorError);
195  return fit(tracks, state, true);
196 }
CachingVertex< N > fit(const std::vector< RefCountedVertexTrack > &tracks, const VertexState priorVertex, bool withPrior) const
tuple tracks
Definition: testEve_cfg.py:39
char state
Definition: procUtils.cc:75
template<unsigned int N>
const VertexSmoother<N>* SequentialVertexFitter< N >::vertexSmoother ( ) const
inline

Definition at line 167 of file SequentialVertexFitter.h.

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

168  {return theSmoother;}
VertexSmoother< N > * theSmoother
template<unsigned int N>
const VertexUpdator<N>* SequentialVertexFitter< N >::vertexUpdator ( ) const
inline

Definition at line 164 of file SequentialVertexFitter.h.

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

165  {return theUpdator;}
VertexUpdator< N > * theUpdator

Member Data Documentation

template<unsigned int N>
LinearizationPointFinder* SequentialVertexFitter< N >::theLinP
private
template<unsigned int N>
const AbstractLTSFactory<N>* SequentialVertexFitter< N >::theLTrackFactory
private
template<unsigned int N>
float SequentialVertexFitter< N >::theMaxShift
private
template<unsigned int N>
int SequentialVertexFitter< N >::theMaxStep
private
template<unsigned int N>
edm::ParameterSet SequentialVertexFitter< N >::thePSet
private

Definition at line 252 of file SequentialVertexFitter.h.

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

template<unsigned int N>
VertexSmoother<N>* SequentialVertexFitter< N >::theSmoother
private
template<unsigned int N>
VertexUpdator<N>* SequentialVertexFitter< N >::theUpdator
private
template<unsigned int N>
VertexTrackFactory<N> SequentialVertexFitter< N >::theVTrackFactory
private

Definition at line 258 of file SequentialVertexFitter.h.