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