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