MuonTrackLoader.h

Go to the documentation of this file.

#ifndef RecoMuon_TrackingTools_MuonTrackLoader_H
#define RecoMuon_TrackingTools_MuonTrackLoader_H
 
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/EventSetup.h"
 
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/TrackReco/interface/TrackExtraFwd.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/OrphanHandle.h"
#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
 
#include "FWCore/Utilities/interface/InputTag.h"
 
#include "RecoMuon/TrackingTools/interface/MuonCandidate.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
 
#include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h"
 
namespace edm {
  class Event;
  class EventSetup;
  class ParameterSet;
}  // namespace edm
 
class Trajectory;
class Propagator;
class MuonServiceProxy;
class MuonUpdatorAtVertex;
class TrajectorySmoother;
class ForwardDetLayer;
class BarrelDetLayer;
class TrackerTopology;
 
class MuonTrackLoader {
public:
  typedef MuonCandidate::TrajectoryContainer TrajectoryContainer;
  typedef MuonCandidate::CandidateContainer CandidateContainer;
 
  MuonTrackLoader(edm::ParameterSet& parameterSet,
                  edm::ConsumesCollector& iC,
                  const MuonServiceProxy* service = nullptr);
 
  virtual ~MuonTrackLoader();
 
  edm::OrphanHandle<reco::TrackCollection> loadTracks(
      TrajectoryContainer&, edm::Event&, const TrackerTopology& ttopo, const std::string& = "", bool = true);
 
  edm::OrphanHandle<reco::TrackCollection> loadTracks(TrajectoryContainer&,
                                                      edm::Event&,
                                                      std::vector<bool>&,
                                                      const TrackerTopology& ttopo,
                                                      const std::string& = "",
                                                      bool = true);
 
  edm::OrphanHandle<reco::TrackCollection> loadTracks(TrajectoryContainer&,
                                                      edm::Event&,
                                                      const std::vector<std::pair<Trajectory*, reco::TrackRef> >&,
                                                      edm::Handle<reco::TrackCollection> const& trackHandle,
                                                      const TrackerTopology& ttopo,
                                                      const std::string& = "",
                                                      bool = true);
 
  edm::OrphanHandle<reco::MuonTrackLinksCollection> loadTracks(CandidateContainer&,
                                                               edm::Event&,
                                                               const TrackerTopology& ttopo);
 
private:
  static std::vector<const TrackingRecHit*> unpackHit(const TrackingRecHit& hit);
 
  std::pair<bool, reco::Track> buildTrackAtPCA(const Trajectory& trajectory, const reco::BeamSpot&) const;
 
  std::pair<bool, reco::Track> buildTrackUpdatedAtPCA(const reco::Track& trackAtPCA, const reco::BeamSpot&) const;
 
  reco::TrackExtra buildTrackExtra(const Trajectory&) const;
 
  const MuonServiceProxy* theService;
 
  bool theUpdatingAtVtx;
  std::unique_ptr<MuonUpdatorAtVertex> theUpdatorAtVtx;
 
  bool theTrajectoryFlag;
 
  bool theSmoothingStep;
  std::string theSmootherName;
  std::string theTrackerRecHitBuilderName;
  std::unique_ptr<TrajectorySmoother> theSmoother;
  TkClonerImpl hitCloner;
 
  edm::InputTag theBeamSpotInputTag;
  edm::EDGetTokenT<reco::BeamSpot> theBeamSpotToken;
 
  std::string theL2SeededTkLabel;
  bool thePutTkTrackFlag;
  bool theSmoothTkTrackFlag;
  bool theAllowNoVtxFlag;
};
#endif