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"

class RectangularEtaPhiTrackingRegion;
class TrajectoryStateOnSurface;
class GlobalMuonTrackMatcher;
class MuonDetLayerMeasurements;
class MuonServiceProxy;
class Trajectory;
class TrackTransformer;
class TrajectoryFitter;
class MuonTrackingRegionBuilder;
class TransientTrackingRecHitBuilder;
class GlobalMuonRefitter;
class TrackerTopology;

namespace edm {class ParameterSet; class Event;}
namespace reco {class TransientTrack;}

//              ---------------------
//              -- Class Interface --
//              ---------------------

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;

  public:

    GlobalTrajectoryBuilderBase(const edm::ParameterSet&, const MuonServiceProxy*);
          
    virtual ~GlobalTrajectoryBuilderBase();

    MuonTrajectoryBuilder::TrajectoryContainer trajectories(const TrajectorySeed&) { return MuonTrajectoryBuilder::TrajectoryContainer(); }

    virtual void setEvent(const edm::Event&);

  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;
      }
    };

  protected:

    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;
  
    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 *tTopo_;
};
#endif