AdaptiveVertexFitter.h

Go to the documentation of this file.

#ifndef AdaptiveVertexFitter_H
#define AdaptiveVertexFitter_H

#include "RecoVertex/VertexPrimitives/interface/VertexFitter.h"
#include "RecoVertex/LinearizationPointFinders/interface/DefaultLinearizationPointFinder.h"
#include "RecoVertex/VertexTools/interface/GeometricAnnealing.h"
#include "RecoVertex/KalmanVertexFit/interface/KalmanVertexUpdator.h"
#include "RecoVertex/VertexTools/interface/DummyVertexSmoother.h"
// #include "RecoVertex/AdaptiveVertexFit/interface/KalmanVertexSmoother.h"
#include "RecoVertex/VertexPrimitives/interface/VertexState.h"
#include "RecoVertex/VertexPrimitives/interface/VertexTrackCompatibilityEstimator.h"
#include "RecoVertex/VertexTools/interface/LinearizedTrackStateFactory.h"
#include "RecoVertex/KalmanVertexFit/interface/KalmanVertexTrackCompatibilityEstimator.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

class AdaptiveVertexFitter : public VertexFitter<5> {

public:

  typedef ReferenceCountingPointer<VertexTrack<5> > RefCountedVertexTrack;
  typedef ReferenceCountingPointer<LinearizedTrackState<5> > RefCountedLinearizedTrackState;

  AdaptiveVertexFitter(
      const AnnealingSchedule & ann = GeometricAnnealing(),
      const LinearizationPointFinder & linP =
             DefaultLinearizationPointFinder(),
      const VertexUpdator<5> & updator = KalmanVertexUpdator<5>(),
      const VertexTrackCompatibilityEstimator<5> & estor =
             KalmanVertexTrackCompatibilityEstimator<5>(),
      const VertexSmoother<5> & smoother = DummyVertexSmoother<5>(),
      const AbstractLTSFactory<5> & ltsf = LinearizedTrackStateFactory() );

  AdaptiveVertexFitter( const AdaptiveVertexFitter & original );

  ~AdaptiveVertexFitter() override;

  CachingVertex<5> vertex( const std::vector<reco::TransientTrack> & ) const override;

  CachingVertex<5> vertex(const std::vector<RefCountedVertexTrack> & ) const override;

  CachingVertex<5> vertex(const std::vector<RefCountedVertexTrack> &,
     const reco::BeamSpot & spot ) const override;

  CachingVertex<5> vertex( const std::vector<reco::TransientTrack> &,
                                const GlobalPoint& linPoint ) const override;

  CachingVertex<5> vertex( const std::vector<reco::TransientTrack> &,
                                const GlobalPoint & priorPos,
                                const GlobalError & priorError ) const override;

  CachingVertex<5> vertex(const std::vector<reco::TransientTrack> & tracks,
        const reco::BeamSpot& beamSpot) const override;


  CachingVertex<5> vertex( const std::vector<RefCountedVertexTrack> &,
                                const GlobalPoint & priorPos,
                                const GlobalError & priorError ) const override;

  AdaptiveVertexFitter * clone() const override;

  void setWeightThreshold ( float w );

  void setParameters( double maxshift=0.0001, double maxlpshift=0.1, 
                      unsigned maxstep=30, double weightthreshold=.001 );

  void setParameters ( const edm::ParameterSet & );

  void gsfIntermediarySmoothing(bool sm) { gsfIntermediarySmoothing_ = sm; }

  bool gsfIntermediarySmoothing() const { return gsfIntermediarySmoothing_;}

private:
  std::vector<RefCountedVertexTrack> reLinearizeTracks(
                const std::vector<RefCountedVertexTrack> & tracks,
                const CachingVertex<5> & vertex ) const;


  std::vector<RefCountedVertexTrack> reWeightTracks(
                        const std::vector<RefCountedLinearizedTrackState> &,
                        const CachingVertex<5> & seed ) const;

  std::vector<RefCountedVertexTrack> reWeightTracks(
                        const std::vector<RefCountedVertexTrack> &,
                        const CachingVertex<5> & seed) const;


  std::vector<RefCountedVertexTrack> weightTracks(
                        const std::vector<RefCountedLinearizedTrackState> &,
                        const VertexState & seed ) const;

  std::vector<RefCountedVertexTrack> linearizeTracks(
                        const std::vector<reco::TransientTrack> &,
                        const VertexState & ) const;
  CachingVertex<5> fit( const std::vector<RefCountedVertexTrack> & tracks,
                     const VertexState & priorSeed,
                     bool withPrior) const;

  double getWeight ( float chi2 ) const;
private:
  double theMaxShift;
  double theMaxLPShift;
  int theMaxStep;
  double theWeightThreshold;
  mutable int theNr;

  LinearizationPointFinder * theLinP;
  VertexUpdator<5> * theUpdator;
  VertexSmoother<5> * theSmoother;
  AnnealingSchedule * theAssProbComputer;
  VertexTrackCompatibilityEstimator<5> * theComp;
  const AbstractLTSFactory<5> * theLinTrkFactory;
  bool gsfIntermediarySmoothing_;
};

#endif