GlobalMuonRefitter.h

Go to the documentation of this file.

#ifndef RecoMuon_GlobalTrackingTools_GlobalMuonRefitter_H
#define RecoMuon_GlobalTrackingTools_GlobalMuonRefitter_H

#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "RecoMuon/TrackingTools/interface/MuonTrajectoryBuilder.h"
#include "RecoMuon/TransientTrackingRecHit/interface/MuonTransientTrackingRecHit.h"
#include "TrackingTools/TrackRefitter/interface/TrackTransformer.h"
#include "DataFormats/DTRecHit/interface/DTRecHitCollection.h"
#include "DataFormats/CSCRecHit/interface/CSCSegmentCollection.h"
#include "DataFormats/DTRecHit/interface/DTRecSegment4DCollection.h"
#include "DataFormats/GEMRecHit/interface/GEMRecHitCollection.h"
#include "DataFormats/MuonReco/interface/DYTInfo.h"
#include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h"

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

class TrajectoryStateOnSurface;
class TrackerTopology;

class MuonDetLayerMeasurements;
class MuonServiceProxy;
class Trajectory;

class TrajectoryFitter;

class GlobalMuonRefitter {

  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;

    enum subDetector { PXB = 1, PXF = 2, TIB = 3, TID = 4, TOB = 5, TEC = 6 };

  public:

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

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

    void setServices(const edm::EventSetup&);

    std::vector<Trajectory> refit(const reco::Track& globalTrack, const int theMuonHitsOption, 
                  const TrackerTopology *tTopo) const;

    std::vector<Trajectory> refit(const reco::Track& globalTrack,
                  const reco::TransientTrack track,
                  const TransientTrackingRecHit::ConstRecHitContainer& allRecHitsTemp,
                  const int theMuonHitsOption,
                  const TrackerTopology *tTopo) const;

    std::vector<Trajectory> transform(const reco::Track& newTrack,
                                      const reco::TransientTrack track,
                                      const TransientTrackingRecHit::ConstRecHitContainer& recHitsForReFit) const;
    
    // get rid of selected station RecHits
    ConstRecHitContainer getRidOfSelectStationHits(const ConstRecHitContainer& hits,
                           const TrackerTopology *tTopo) const;

    // return DYT-related informations           
    const reco::DYTInfo* getDYTInfo() {return dytInfo;}
    
  protected:

    enum RefitDirection{insideOut,outsideIn,undetermined};
    
    void checkMuonHits(const reco::Track&, ConstRecHitContainer&, 
                       std::map<DetId, int> &) const;

    void getFirstHits(const reco::Track&, ConstRecHitContainer&, 
                       ConstRecHitContainer&) const;
 
    ConstRecHitContainer selectMuonHits(const Trajectory&, 
                                        const std::map<DetId, int> &) const;
 
    void printHits(const ConstRecHitContainer&) const;

    RefitDirection checkRecHitsOrdering(const ConstRecHitContainer&) const;

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

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

  private:
  
    int   theMuonHitsOption;
    float theProbCut;
    int   theHitThreshold;
    float theDTChi2Cut;
    float theCSCChi2Cut;
    float theRPCChi2Cut;
    float theGEMChi2Cut;
    bool  theCosmicFlag;

    edm::InputTag theDTRecHitLabel;
    edm::InputTag theCSCRecHitLabel;
    edm::InputTag theGEMRecHitLabel;
    edm::Handle<DTRecHitCollection>    theDTRecHits;
    edm::Handle<CSCRecHit2DCollection> theCSCRecHits;
    edm::Handle<GEMRecHitCollection> theGEMRecHits;
    edm::EDGetTokenT<DTRecHitCollection> theDTRecHitToken;
    edm::EDGetTokenT<CSCRecHit2DCollection> theCSCRecHitToken;
    edm::EDGetTokenT<GEMRecHitCollection> theGEMRecHitToken;

    int   theSkipStation;
    int   theTrackerSkipSystem;
    int   theTrackerSkipSection;

    unsigned long long theCacheId_TRH;        

    std::string thePropagatorName;
  
    bool theRPCInTheFit;

    double theRescaleErrorFactor;

    RefitDirection theRefitDirection;

    std::vector<int> theDYTthrs;
    int theDYTselector;
    bool theDYTupdator;
    bool theDYTuseAPE;
    reco::DYTInfo *dytInfo;

    std::string theFitterName;
    std::unique_ptr<TrajectoryFitter> theFitter;
  
    std::string theTrackerRecHitBuilderName;
    edm::ESHandle<TransientTrackingRecHitBuilder> theTrackerRecHitBuilder;
    TkClonerImpl hitCloner;
  
    std::string theMuonRecHitBuilderName;
    edm::ESHandle<TransientTrackingRecHitBuilder> theMuonRecHitBuilder;

    const MuonServiceProxy* theService;
    const edm::Event* theEvent;

    edm::EDGetTokenT<CSCSegmentCollection> CSCSegmentsToken;
    edm::EDGetTokenT<DTRecSegment4DCollection> all4DSegmentsToken;
    edm::Handle<CSCSegmentCollection> CSCSegments;
    edm::Handle<DTRecSegment4DCollection> all4DSegments;
};
#endif