MatcherUsingTracksAlgorithm.h

Go to the documentation of this file.

#ifndef MuonAnalysis_MuonAssociators_MatcherUsingTracksAlgorithm_h
#define MuonAnalysis_MuonAssociators_MatcherUsingTracksAlgorithm_h
//
//

#include "DataFormats/Candidate/interface/CandidateFwd.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"

#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h"
#include "MagneticField/Engine/interface/MagneticField.h"
#include "TrackingTools/GeomPropagators/interface/Propagator.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateClosestToPoint.h"
#include "CommonTools/Utils/interface/StringCutObjectSelector.h"

class IdealMagneticFieldRecord;
class TrackingComponentsRecord;
class GlobalTrackingGeometryRecord;

class MatcherUsingTracksAlgorithm {
public:
  explicit MatcherUsingTracksAlgorithm(const edm::ParameterSet &iConfig, edm::ConsumesCollector);
  virtual ~MatcherUsingTracksAlgorithm() {}

  void init(const edm::EventSetup &iSetup);

  bool match(const reco::Candidate &c1,
             const reco::Candidate &c2,
             float &deltaR,
             float &deltaEta,
             float &deltaPhi,
             float &deltaLocalPos,
             float &deltaPtRel,
             float &chi2) const;

  int match(const reco::Candidate &tk,
            const edm::View<reco::Candidate> &c2s,
            float &deltaR,
            float &deltaEta,
            float &deltaPhi,
            float &deltaLocalPos,
            float &deltaPtRel,
            float &chi2) const;

  bool hasMetrics() const { return algo_ != ByTrackRef; }

  bool hasChi2() const { return useChi2_; }

  static double getChi2(const FreeTrajectoryState &start,
                        const FreeTrajectoryState &other,
                        bool diagonalOnly,
                        bool useVertex,
                        bool useFirstMomentum);

  static double getChi2(const FreeTrajectoryState &start,
                        const TrajectoryStateClosestToPoint &other,
                        bool diagonalOnly,
                        bool useVertex);

  static double getChi2(const TrajectoryStateOnSurface &start,
                        const TrajectoryStateOnSurface &other,
                        bool diagonalOnly,
                        bool usePosition);

  static void cropAndInvert(AlgebraicSymMatrix55 &cov, bool diagonalOnly, bool top3by3only);

private:
  enum AlgoType {
    ByTrackRef,
    ByDirectComparison,
    ByPropagatingSrc,
    ByPropagatingMatched,
    ByPropagatingSrcTSCP,
    ByPropagatingMatchedTSCP
  };  // propagate closest to point
  enum WhichTrack { None, TrackerTk, MuonTk, GlobalTk };
  enum WhichState { AtVertex, Innermost, Outermost };

  AlgoType algo_;
  WhichTrack whichTrack1_, whichTrack2_;
  WhichState whichState1_, whichState2_;

  // Preselection cuts on both sides
  StringCutObjectSelector<reco::Candidate, true> srcCut_, matchedCut_;

  // Matching cuts
  float maxLocalPosDiff_;
  float maxGlobalMomDeltaR_;
  float maxGlobalMomDeltaEta_;
  float maxGlobalMomDeltaPhi_;
  float maxGlobalDPtRel_;
  float maxChi2_;
  bool requireSameCharge_;
  bool useChi2_, chi2UseVertex_, chi2DiagonalOnly_, chi2FirstMomentum_;
  enum SortBy { LocalPosDiff, GlobalMomDeltaR, GlobalMomDeltaEta, GlobalMomDeltaPhi, GlobalDPtRel, Chi2 };
  SortBy sortBy_;

  //- Tools
  edm::ESHandle<MagneticField> magfield_;
  edm::ESHandle<Propagator> propagator_;
  edm::ESHandle<GlobalTrackingGeometry> geometry_;

  edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> magfieldToken_;
  edm::ESGetToken<Propagator, TrackingComponentsRecord> propagatorToken_;
  edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> geometryToken_;

  reco::TrackRef getTrack(const reco::Candidate &reco, WhichTrack which) const;

  FreeTrajectoryState startingState(const reco::Candidate &reco, WhichTrack whichTrack, WhichState whichState) const;

  TrajectoryStateOnSurface targetState(const reco::Candidate &reco, WhichTrack whichTrack, WhichState whichState) const;

  bool matchWithPropagation(const FreeTrajectoryState &start,
                            const FreeTrajectoryState &target,
                            float &lastDeltaR,
                            float &lastDeltaEta,
                            float &lastDeltaPhi,
                            float &lastDeltaLocalPos,
                            float &lastGlobalDPtRel,
                            float &lastChi2) const;

  bool matchWithPropagation(const FreeTrajectoryState &start,
                            const TrajectoryStateOnSurface &target,
                            float &lastDeltaR,
                            float &lastDeltaEta,
                            float &lastDeltaPhi,
                            float &lastDeltaLocalPos,
                            float &lastGlobalDPtRel,
                            float &lastChi2) const;

  bool matchByDirectComparison(const FreeTrajectoryState &start,
                               const FreeTrajectoryState &other,
                               float &lastDeltaR,
                               float &lastDeltaEta,
                               float &lastDeltaPhi,
                               float &lastDeltaLocalPos,
                               float &lastGlobalDPtRel,
                               float &lastChi2) const;

  void getConf(const edm::ParameterSet &iConfig,
               const std::string &whatFor,
               WhichTrack &whichTrack,
               WhichState &whichState);
};

#endif