MultiTrackSelector.h

Go to the documentation of this file.

#ifndef RecoAlgos_MultiTrackSelector_h
#define RecoAlgos_MultiTrackSelector_h
 
#include <utility>
#include <vector>
#include <memory>
#include <algorithm>
#include <map>
#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"
 
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackExtra.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include "TrackingTools/PatternTools/interface/Trajectory.h"
#include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h"
#include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit1D.h"
#include "CommonTools/Utils/interface/StringCutObjectSelector.h"
#include "CondFormats/EgammaObjects/interface/GBRForest.h"
 
class dso_hidden MultiTrackSelector : public edm::stream::EDProducer<> {
private:
public:
  explicit MultiTrackSelector();
  explicit MultiTrackSelector(const edm::ParameterSet &cfg);
  ~MultiTrackSelector() override;
 
  using MVACollection = std::vector<float>;
  using QualityMaskCollection = std::vector<unsigned char>;
 
protected:
  void beginStream(edm::StreamID) final;
 
  // void streamBeginRun(edm::StreamID, edm::Run const&, edm::EventSetup const&) const final {
  //  init();
  //}
  //void beginRun(edm::Run const&, edm::EventSetup const&) final { init(); }
  // void init(edm::EventSetup const& es) const;
 
  typedef math::XYZPoint Point;
  void produce(edm::Event &evt, const edm::EventSetup &es) final { run(evt, es); }
  virtual void run(edm::Event &evt, const edm::EventSetup &es) const;
 
  bool select(unsigned tsNum,
              const reco::BeamSpot &vertexBeamSpot,
              const TrackingRecHitCollection &recHits,
              const reco::Track &tk,
              const std::vector<Point> &points,
              std::vector<float> &vterr,
              std::vector<float> &vzerr,
              double mvaVal) const;
  void selectVertices(unsigned int tsNum,
                      const reco::VertexCollection &vtxs,
                      std::vector<Point> &points,
                      std::vector<float> &vterr,
                      std::vector<float> &vzerr) const;
 
  void processMVA(edm::Event &evt,
                  const edm::EventSetup &es,
                  const reco::BeamSpot &beamspot,
                  const reco::VertexCollection &vertices,
                  int selIndex,
                  std::vector<float> &mvaVals_,
                  bool writeIt = false) const;
  Point getBestVertex(const reco::TrackBaseRef, const reco::VertexCollection) const;
 
  edm::EDGetTokenT<reco::TrackCollection> src_;
  edm::EDGetTokenT<TrackingRecHitCollection> hSrc_;
  edm::EDGetTokenT<reco::BeamSpot> beamspot_;
  bool useVertices_;
  bool useVtxError_;
  bool useAnyMVA_;
  edm::EDGetTokenT<reco::VertexCollection> vertices_;
 
  std::vector<bool> setQualityBit_;
  std::vector<reco::TrackBase::TrackQuality> qualityToSet_;
 
  std::vector<int32_t> vtxNumber_;
  //StringCutObjectSelector is not const thread safe
  std::vector<StringCutObjectSelector<reco::Vertex> > vertexCut_;
 
  //  parameters for adapted optimal cuts on chi2 and primary vertex compatibility
  std::vector<std::vector<double> > res_par_;
  std::vector<double> chi2n_par_;
  std::vector<double> chi2n_no1Dmod_par_;
  std::vector<std::vector<double> > d0_par1_;
  std::vector<std::vector<double> > dz_par1_;
  std::vector<std::vector<double> > d0_par2_;
  std::vector<std::vector<double> > dz_par2_;
  // Boolean indicating if adapted primary vertex compatibility cuts are to be applied.
  std::vector<bool> applyAdaptedPVCuts_;
 
  std::vector<double> max_d0_;
  std::vector<double> max_z0_;
  std::vector<double> nSigmaZ_;
 
  std::vector<uint32_t> min_layers_;
  std::vector<uint32_t> min_3Dlayers_;
  std::vector<uint32_t> max_lostLayers_;
  std::vector<uint32_t> min_hits_bypass_;
 
  // pterror and nvalid hits cuts
  std::vector<double> max_relpterr_;
  std::vector<uint32_t> min_nhits_;
 
  std::vector<int32_t> max_minMissHitOutOrIn_;
  std::vector<int32_t> max_lostHitFraction_;
 
  std::vector<double> min_eta_;
  std::vector<double> max_eta_;
 
  // Flag and absolute cuts if no PV passes the selection
  std::vector<double> max_d0NoPV_;
  std::vector<double> max_z0NoPV_;
  std::vector<bool> applyAbsCutsIfNoPV_;
  //if true, selector flags but does not select
  std::vector<bool> keepAllTracks_;
 
  // allow one of the previous psets to be used as a prefilter
  std::vector<unsigned int> preFilter_;
  std::vector<std::string> name_;
 
  //setup mva selector
  std::vector<bool> useMVA_;
  std::vector<bool> useMVAonly_;
 
  std::vector<double> min_MVA_;
 
  std::vector<std::string> mvaType_;
  std::vector<std::string> forestLabel_;
  std::vector<GBRForest *> forest_;
  bool useForestFromDB_;
  std::string dbFileName_;
};
 
#endif