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(
      const TrajectoryContainer&, edm::Event&, const TrackerTopology& ttopo, const std::string& = "", bool = true);

  edm::OrphanHandle<reco::TrackCollection> loadTracks(const TrajectoryContainer&,
                                                      edm::Event&,
                                                      std::vector<bool>&,
                                                      const TrackerTopology& ttopo,
                                                      const std::string& = "",
                                                      bool = true);

  edm::OrphanHandle<reco::TrackCollection> loadTracks(const 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(const 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;
  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