---

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;

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

    std::vector<Trajectory> refitTrajectory(const Trajectory&) const;

    std::vector<Trajectory> glbTrajectory(const TrajectorySeed& seed,
                                          const ConstRecHitContainer& trackerhits,
                                          const ConstRecHitContainer& muonhits,
                                          const TrajectoryStateOnSurface& firstPredTsos) const;

    GlobalMuonTrackMatcher* trackMatcher() const { return theTrackMatcher; }

    const MuonServiceProxy* service() const { return theService; }

  TransientTrackingRecHit::ConstRecHitContainer
    getTransientRecHits(const reco::TransientTrack& track) const;

    struct RadiusComparatorInOut{
      bool operator()(const TransientTrackingRecHit::ConstRecHitPointer &a,
                      const TransientTrackingRecHit::ConstRecHitPointer &b) const{ 
        return a->det()->surface().position().perp() < b->det()->surface().position().perp(); 
      }
    };

    struct ZedComparatorInOut{  
      bool operator()( const TransientTrackingRecHit::ConstRecHitPointer &a, 
                       const TransientTrackingRecHit::ConstRecHitPointer &b) const{ 
        return fabs(a->globalPosition().z()) < fabs(b->globalPosition().z()); 
      }
    };

    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(); 
        if ( barrel_a && barrel_b )      return  a->globalPosition().perp() < b->globalPosition().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;
      }
    };

  protected:

    std::string theCategory;
    bool theTkTrajsAvailableFlag;
    float thePtCut;

  private:

    GlobalMuonTrackMatcher* theTrackMatcher;
    MuonDetLayerMeasurements* theLayerMeasurements;
    TrackTransformer* theTrackTransformer;
    MuonTrackingRegionBuilder* theRegionBuilder;
    const MuonServiceProxy* theService;
    edm::ESHandle<TrajectoryFitter> theKFFitter;

    unsigned long long theCacheId_TRH;
    bool theRPCInTheFit;
  
    int   theMuonHitsOption;
    float theProbCut;
    int   theHitThreshold;
    float theDTChi2Cut;
    float theCSCChi2Cut;
    float theRPCChi2Cut;
    std::string theKFFitterName;
    std::string theTrackerPropagatorName;
 
    const edm::Event* theEvent;

    std::string theTrackerRecHitBuilderName;
    edm::ESHandle<TransientTrackingRecHitBuilder> theTrackerRecHitBuilder;
    
    std::string theMuonRecHitBuilderName;
    edm::ESHandle<TransientTrackingRecHitBuilder> theMuonRecHitBuilder;
    
};
#endif

---