SequentialVertexFitter.h

Go to the documentation of this file.

#ifndef SequentialVertexFitter_H
#define SequentialVertexFitter_H
 
#include "RecoVertex/VertexPrimitives/interface/VertexFitter.h"
#include "RecoVertex/VertexTools/interface/LinearizationPointFinder.h"
#include "RecoVertex/VertexPrimitives/interface/VertexUpdator.h"
#include "RecoVertex/VertexPrimitives/interface/VertexSmoother.h"
#include "RecoVertex/VertexTools/interface/LinearizedTrackStateFactory.h"
#include "RecoVertex/VertexTools/interface/VertexTrackFactory.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/isFinite.h"
#include <cmath>
// #include "TrackingTools/TransientTrack/interface/TransientTrack.h"
// #include "Vertex/VertexPrimitives/interface/VertexSeedFactory.h"
 
template <unsigned int N>
class SequentialVertexFitter : public VertexFitter<N> {
public:
  typedef ReferenceCountingPointer<RefittedTrackState<N> > RefCountedRefittedTrackState;
  typedef ReferenceCountingPointer<VertexTrack<N> > RefCountedVertexTrack;
  typedef ReferenceCountingPointer<LinearizedTrackState<N> > RefCountedLinearizedTrackState;
 
  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);
 
  ~SequentialVertexFitter() override;
 
  void setMaximumDistance(float maxShift) { theMaxShift = maxShift; }
 
  void setMaximumNumberOfIterations(int maxIterations) { theMaxStep = maxIterations; }
 
  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;
 
  //  virtual CachingVertex<N> vertex(const RefCountedVertexSeed seed) const;
 
  const LinearizationPointFinder* linearizationPointFinder() const { return theLinP; }
 
  const VertexUpdator<N>* vertexUpdator() const { return theUpdator; }
 
  const VertexSmoother<N>* vertexSmoother() const { return theSmoother; }
 
  const float maxShift() const { return theMaxShift; }
 
  const int maxStep() const { return theMaxStep; }
 
  const edm::ParameterSet parameterSet() const { return thePSet; }
 
  SequentialVertexFitter* clone() const override { return new SequentialVertexFitter(*this); }
 
  const AbstractLTSFactory<N>* linearizedTrackStateFactory() const { return theLTrackFactory; }
 
protected:
  SequentialVertexFitter() {}
 
private:
  CachingVertex<N> fit(const std::vector<RefCountedVertexTrack>& tracks,
                       const VertexState priorVertex,
                       bool withPrior) const;
 
  std::vector<RefCountedVertexTrack> linearizeTracks(const std::vector<reco::TransientTrack>& tracks,
                                                     const VertexState state) const;
 
  std::vector<RefCountedVertexTrack> reLinearizeTracks(const std::vector<RefCountedVertexTrack>& tracks,
                                                       const VertexState state) const;
 
  void readParameters();
  void setDefaultParameters();
 
  inline bool hasNan(const GlobalPoint& point) const {
    using namespace std;
    return (edm::isNotFinite(point.x()) || edm::isNotFinite(point.y()) || edm::isNotFinite(point.z()));
  }
 
  float theMaxShift;
  int theMaxStep;
 
  edm::ParameterSet thePSet;
  LinearizationPointFinder* theLinP;
  VertexUpdator<N>* theUpdator;
  VertexSmoother<N>* theSmoother;
  const AbstractLTSFactory<N>* theLTrackFactory;
  //   LinearizedTrackStateFactoryAbstractLTSFactory theLTrackFactory;
  VertexTrackFactory<N> theVTrackFactory;
 
  // VertexSeedFactory theVSeedFactory;
};
 
#endif