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