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

  const bool insideTrackerBounds(const GlobalPoint& point) const {
    return ((point.transverse() < trackerBoundsRadius) && (abs(point.z()) < trackerBoundsHalfLength));
  }

  void setTrackerBounds(float radius, float halfLength) {
    trackerBoundsRadius = radius;
    trackerBoundsHalfLength = halfLength;
  }

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;

  // FIXME using hard-coded tracker bounds as default instead of taking them from geometry service
  float trackerBoundsRadius{112.};
  float trackerBoundsHalfLength{273.5};

  edm::ParameterSet thePSet;
  LinearizationPointFinder* theLinP;
  VertexUpdator<N>* theUpdator;
  VertexSmoother<N>* theSmoother;
  const AbstractLTSFactory<N>* theLTrackFactory;
  //   LinearizedTrackStateFactoryAbstractLTSFactory theLTrackFactory;
  VertexTrackFactory<N> theVTrackFactory;

  // VertexSeedFactory theVSeedFactory;
};

#endif