GlobalTrajectoryBuilderBase.h

Go to the documentation of this file.

#ifndef RecoMuon_GlobalTrackingTools_GlobalTrajectoryBuilderBase_H
#define RecoMuon_GlobalTrackingTools_GlobalTrajectoryBuilderBase_H
 
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "RecoMuon/TrackingTools/interface/MuonTrajectoryBuilder.h"
#include "RecoMuon/TransientTrackingRecHit/interface/MuonTransientTrackingRecHit.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
 
#include "RecoTracker/TkTrackingRegions/interface/RectangularEtaPhiTrackingRegion.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "TrackingTools/TrackRefitter/interface/TrackTransformer.h"
#include "TrackingTools/PatternTools/interface/Trajectory.h"
#include "TrackingTools/TrackFitters/interface/TrajectoryFitter.h"
#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h"
#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
 
//Forward declare classes from same package (RecoMuon)
class GlobalMuonTrackMatcher;
class MuonDetLayerMeasurements;
class MuonServiceProxy;
class MuonTrackingRegionBuilder;
class GlobalMuonRefitter;
class TransientRecHitRecord;
 
class GlobalTrajectoryBuilderBase : public MuonTrajectoryBuilder {
public:
  typedef TransientTrackingRecHit::RecHitContainer RecHitContainer;
  typedef TransientTrackingRecHit::ConstRecHitContainer ConstRecHitContainer;
  typedef TransientTrackingRecHit::RecHitPointer RecHitPointer;
  typedef TransientTrackingRecHit::ConstRecHitPointer ConstRecHitPointer;
  typedef MuonTransientTrackingRecHit::MuonRecHitPointer MuonRecHitPointer;
  typedef MuonTransientTrackingRecHit::ConstMuonRecHitPointer ConstMuonRecHitPointer;
  typedef MuonTransientTrackingRecHit::MuonRecHitContainer MuonRecHitContainer;
  typedef MuonTransientTrackingRecHit::ConstMuonRecHitContainer ConstMuonRecHitContainer;
  typedef std::vector<Trajectory> TC;
  typedef TC::const_iterator TI;
 
  GlobalTrajectoryBuilderBase(const edm::ParameterSet&, const MuonServiceProxy*, edm::ConsumesCollector&);
 
  ~GlobalTrajectoryBuilderBase() override;
 
  MuonTrajectoryBuilder::TrajectoryContainer trajectories(const TrajectorySeed&) override {
    return MuonTrajectoryBuilder::TrajectoryContainer();
  }
 
  void setEvent(const edm::Event&) override;
 
protected:
  enum RefitDirection { inToOut, outToIn, undetermined };
 
  MuonTrajectoryBuilder::CandidateContainer build(const TrackCand&, MuonTrajectoryBuilder::CandidateContainer&) const;
 
  virtual std::vector<TrackCand> makeTkCandCollection(const TrackCand&) = 0;
 
  std::vector<TrackCand> chooseRegionalTrackerTracks(const TrackCand&, const std::vector<TrackCand>&);
 
  RectangularEtaPhiTrackingRegion defineRegionOfInterest(const reco::TrackRef&) const;
 
  void checkMuonHits(const reco::Track&, ConstRecHitContainer&, ConstRecHitContainer&, std::vector<int>&) const;
 
  ConstRecHitContainer selectMuonHits(const Trajectory&, const std::vector<int>&) const;
 
  ConstRecHitContainer selectTrackerHits(const ConstRecHitContainer&) const;
 
  void fixTEC(ConstRecHitContainer& all, double scl_x, double scl_y) const;
 
  const Trajectory* chooseTrajectory(const std::vector<Trajectory*>&, int) const;
 
  double trackProbability(const Trajectory&) const;
 
  void printHits(const ConstRecHitContainer&) const;
 
  void addTraj(TrackCand&) {}  
 
  RefitDirection checkRecHitsOrdering(const ConstRecHitContainer&) const;
 
  TransientTrackingRecHit::ConstRecHitContainer getTransientRecHits(const reco::Track&) const;
 
  GlobalMuonTrackMatcher* trackMatcher() const { return theTrackMatcher; }
 
  const MuonServiceProxy* service() const { return theService; }
 
  struct ComparatorInOut {
    bool operator()(const TransientTrackingRecHit::ConstRecHitPointer& a,
                    const TransientTrackingRecHit::ConstRecHitPointer& b) const {
      bool barrel_a = (a->det()->subDetector() == GeomDetEnumerators::DT ||
                       a->det()->subDetector() == GeomDetEnumerators::RPCBarrel);
 
      bool barrel_b = (b->det()->subDetector() == GeomDetEnumerators::DT ||
                       b->det()->subDetector() == GeomDetEnumerators::RPCBarrel);
 
      if (barrel_a && barrel_b)
        return a->det()->surface().position().perp() < b->det()->surface().position().perp();
 
      else if (!barrel_a && !barrel_b)
        return fabs(a->globalPosition().z()) < fabs(b->globalPosition().z());
      else if (barrel_a && !barrel_b)
        return true;
      else if (!barrel_a && barrel_b)
        return false;
      //shouldn't really get here in any case (there's some sense to throw here )
      return false;
    }
  };
 
  std::string theCategory;
  float thePtCut;
  float thePCut;
 
private:
  GlobalMuonTrackMatcher* theTrackMatcher;
  MuonDetLayerMeasurements* theLayerMeasurements;
  TrackTransformer* theTrackTransformer;
  MuonTrackingRegionBuilder* theRegionBuilder;
  const MuonServiceProxy* theService;
  GlobalMuonRefitter* theGlbRefitter;
  bool theRPCInTheFit;
  bool theRefitFlag;
  int theMuonHitsOption;
  float theTECxScale;
  float theTECyScale;
  std::string theTrackerPropagatorName;
  const edm::Event* theEvent;
  edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> theTrackerRecHitBuilderToken;
  const TransientTrackingRecHitBuilder* theTrackerRecHitBuilder;
  edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> theMuonRecHitBuilderToken;
  const TransientTrackingRecHitBuilder* theMuonRecHitBuilder;
  edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> theTopoToken;
  const TrackerTopology* theTopo;
};
#endif