PropagateToMuon.h

Go to the documentation of this file.

#ifndef MuonAnalysis_MuonAssociators_interface_PropagateToMuon_h
#define MuonAnalysis_MuonAssociators_interface_PropagateToMuon_h
//
//

#include "DataFormats/Candidate/interface/Candidate.h"
#include "DataFormats/GeometrySurface/interface/BoundCylinder.h"
#include "DataFormats/GeometrySurface/interface/BoundDisk.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "MagneticField/Engine/interface/MagneticField.h"
#include "RecoMuon/DetLayers/interface/MuonDetLayerGeometry.h"
#include "TrackingTools/GeomPropagators/interface/Propagator.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "SimDataFormats/Track/interface/SimTrackContainer.h"
#include "SimDataFormats/Vertex/interface/SimVertexContainer.h"
#include "MuonAnalysis/MuonAssociators/interface/trackStateEnums.h"

class IdealMagneticFieldRecord;
class TrackingComponentsRecord;
class MuonRecoGeometryRecord;

class PropagateToMuon {
public:
  explicit PropagateToMuon() {}
  explicit PropagateToMuon(edm::ESHandle<MagneticField>,
                           edm::ESHandle<Propagator>,
                           edm::ESHandle<Propagator>,
                           edm::ESHandle<Propagator>,
                           edm::ESHandle<MuonDetLayerGeometry>,
                           bool,
                           bool,
                           bool,
                           WhichTrack,
                           WhichState,
                           bool,
                           bool);
  ~PropagateToMuon() {}

  TrajectoryStateOnSurface extrapolate(const reco::Track &tk) const { return extrapolate(startingState(tk)); }

  TrajectoryStateOnSurface extrapolate(const reco::Candidate &tk) const { return extrapolate(startingState(tk)); }

  //  don't ask me why SimVertexContainer is in edm namespace
  TrajectoryStateOnSurface extrapolate(const SimTrack &tk, const edm::SimVertexContainer &vtxs) const {
    return extrapolate(startingState(tk, vtxs));
  }

  TrajectoryStateOnSurface extrapolate(const FreeTrajectoryState &state) const;

private:
  // needed services for track propagation
  edm::ESHandle<MagneticField> magfield_;
  edm::ESHandle<Propagator> propagator_, propagatorAny_, propagatorOpposite_;
  edm::ESHandle<MuonDetLayerGeometry> muonGeometry_;

  bool useSimpleGeometry_ = false;

  bool useMB2_ = false;

  bool fallbackToME1_ = false;

  WhichTrack whichTrack_ = None;
  WhichState whichState_ = AtVertex;

  bool cosmicPropagation_ = false;

  bool useMB2InOverlap_ = false;

  // simplified geometry for track propagation
  const BoundCylinder *barrelCylinder_ = nullptr;
  const BoundDisk *endcapDiskPos_[3] = {nullptr, nullptr, nullptr};
  const BoundDisk *endcapDiskNeg_[3] = {nullptr, nullptr, nullptr};
  double barrelHalfLength_ = 0.;
  std::pair<float, float> endcapRadii_[3] = {{0.f, 0.f}, {0.f, 0.f}, {0.f, 0.f}};

  FreeTrajectoryState startingState(const reco::Candidate &reco) const;

  FreeTrajectoryState startingState(const reco::Track &tk) const;

  FreeTrajectoryState startingState(const SimTrack &tk, const edm::SimVertexContainer &vtxs) const;

  TrajectoryStateOnSurface getBestDet(const TrajectoryStateOnSurface &tsos, const DetLayer *station) const;
};

#endif