ConfigurableTrimmedVertexFinder.h

Go to the documentation of this file.

#ifndef _ConfigurableTrimmedVertexFinder_H_
#define _ConfigurableTrimmedVertexFinder_H_

#include "RecoVertex/VertexPrimitives/interface/VertexReconstructor.h"
#include "RecoVertex/TrimmedKalmanVertexFinder/interface/TrimmedVertexFinder.h"
#include "RecoVertex/TrimmedKalmanVertexFinder/interface/TrimmedTrackFilter.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include <vector>

class ConfigurableTrimmedVertexFinder : public VertexReconstructor {
public:
  ConfigurableTrimmedVertexFinder(const VertexFitter<5>* vf,
                                  const VertexUpdator<5>* vu,
                                  const VertexTrackCompatibilityEstimator<5>* ve);

  ~ConfigurableTrimmedVertexFinder() override {}

  std::vector<TransientVertex> vertices(const std::vector<reco::TransientTrack>& tracks) const override;

  std::vector<TransientVertex> vertices(const std::vector<reco::TransientTrack>& tracks,
                                        const reco::BeamSpot& spot) const override;

  std::vector<TransientVertex> vertices(const std::vector<reco::TransientTrack>& tracks,
                                        std::vector<reco::TransientTrack>& unused,
                                        const reco::BeamSpot& spot,
                                        bool use_spot) const;

  float ptCut() const { return theFilter.ptCut(); }
  const TrimmedTrackFilter& trackFilter() const { return theFilter; }
  float trackCompatibilityCut() const { return theTrackCompatibilityToPV; }
  float trackCompatibilityToSV() const { return theTrackCompatibilityToSV; }
  float vertexFitProbabilityCut() const { return theVtxFitProbCut; }
  int maxNbOfVertices() const { return theMaxNbOfVertices; }

  void setParameters(const edm::ParameterSet&);

  void setPtCut(float cut) { theFilter.setPtCut(cut); }
  void setTrackCompatibilityCut(float cut) { theTrackCompatibilityToPV = cut; }
  void setTrackCompatibilityToSV(float cut) { theTrackCompatibilityToSV = cut; }
  void setVertexFitProbabilityCut(float cut) { theVtxFitProbCut = cut; }
  void setMaxNbOfVertices(int max) { theMaxNbOfVertices = max; }

  ConfigurableTrimmedVertexFinder* clone() const override { return new ConfigurableTrimmedVertexFinder(*this); }

protected:
  virtual void resetEvent(const std::vector<reco::TransientTrack>& tracks) const {}

  virtual void analyseInputTracks(const std::vector<reco::TransientTrack>& tracks) const {}

  virtual void analyseClusterFinder(const std::vector<TransientVertex>& vts,
                                    const std::vector<reco::TransientTrack>& remain) const {}

  virtual void analyseVertexCandidates(const std::vector<TransientVertex>& vts) const {}

  virtual void analyseFoundVertices(const std::vector<TransientVertex>& vts) const {}

private:
  using VertexReconstructor::vertices;

  // separate tracks passing the filter
  //  void separateTracks(std::vector<TransientTrack>& filtered,
  //              std::vector<TransientTrack>& unused) const;

  // find vertex candidates
  std::vector<TransientVertex> vertexCandidates(const std::vector<reco::TransientTrack>& tracks,
                                                std::vector<reco::TransientTrack>& unused,
                                                const reco::BeamSpot& spot,
                                                bool use_spot) const;

  // remove bad candidates
  std::vector<TransientVertex> clean(const std::vector<TransientVertex>& candidates) const;

  //
  mutable TrimmedVertexFinder theClusterFinder;
  float theVtxFitProbCut;
  float theTrackCompatibilityToPV;
  float theTrackCompatibilityToSV;
  int theMaxNbOfVertices;
  TrimmedTrackFilter theFilter;
};

#endif