GlobalTrajectoryBuilderBase.h

Go to the documentation of this file.

#ifndef RecoMuon_GlobalTrackingTools_GlobalTrajectoryBuilderBase_H
#define RecoMuon_GlobalTrackingTools_GlobalTrajectoryBuilderBase_H

#include "FWCore/Framework/interface/ESHandle.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 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;
  unsigned long long theCacheId_TRH;
  bool theRPCInTheFit;
  bool theRefitFlag;
  int theMuonHitsOption;
  float theTECxScale;
  float theTECyScale;
  std::string theTrackerPropagatorName;
  const edm::Event* theEvent;
  std::string theTrackerRecHitBuilderName;
  edm::ESHandle<TransientTrackingRecHitBuilder> theTrackerRecHitBuilder;
  std::string theMuonRecHitBuilderName;
  edm::ESHandle<TransientTrackingRecHitBuilder> theMuonRecHitBuilder;
  const TrackerTopology* theTopo;
};
#endif