Muon.h

Go to the documentation of this file.

#ifndef MuonReco_Muon_h
#define MuonReco_Muon_h

#include "DataFormats/RecoCandidate/interface/RecoCandidate.h"
#include "DataFormats/MuonReco/interface/MuonChamberMatch.h"
#include "DataFormats/MuonReco/interface/MuonIsolation.h"
#include "DataFormats/MuonReco/interface/MuonPFIsolation.h"
#include "DataFormats/MuonReco/interface/MuonEnergy.h"
#include "DataFormats/MuonReco/interface/MuonTime.h"
#include "DataFormats/MuonReco/interface/MuonQuality.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/TrackReco/interface/Track.h"

namespace reco {
 
  class Muon : public RecoCandidate {
  public:
    Muon();
    Muon(  Charge, const LorentzVector &, const Point & = Point( 0, 0, 0 ) );
    Muon * clone() const override;

    
    
    enum MuonTrackType {None, InnerTrack, OuterTrack, CombinedTrack, TPFMS, Picky, DYT};
    typedef std::map<MuonTrackType, reco::TrackRef> MuonTrackRefMap;
    typedef std::pair<TrackRef, Muon::MuonTrackType> MuonTrackTypePair;


    using reco::RecoCandidate::track;
    virtual TrackRef innerTrack() const { return innerTrack_; }
    TrackRef track() const override { return innerTrack(); }
    virtual TrackRef outerTrack() const { return outerTrack_; }
    TrackRef standAloneMuon() const override { return outerTrack(); }
    virtual TrackRef globalTrack() const { return globalTrack_; }
    TrackRef combinedMuon() const override { return globalTrack(); }

    virtual TrackRef tpfmsTrack() const { return muonTrackFromMap(TPFMS);}
    virtual TrackRef pickyTrack() const { return muonTrackFromMap(Picky);}
    virtual TrackRef dytTrack()   const { return muonTrackFromMap(DYT);}
    
    const Track * bestTrack() const override         {return muonTrack(bestTrackType_).get();}
    TrackBaseRef  bestTrackRef() const override      {return reco::TrackBaseRef(muonTrack(bestTrackType_));}
    virtual TrackRef      muonBestTrack() const     {return muonTrack(bestTrackType_);}
    virtual MuonTrackType muonBestTrackType() const {return bestTrackType_;}
    virtual TrackRef      tunePMuonBestTrack() const     {return muonTrack(bestTunePTrackType_);}
    virtual MuonTrackType tunePMuonBestTrackType() const {return bestTunePTrackType_;}



    bool isAValidMuonTrack(const MuonTrackType& type) const;
    TrackRef muonTrack(const MuonTrackType&) const;

    TrackRef muonTrackFromMap(const MuonTrackType& type) const {
      MuonTrackRefMap::const_iterator iter = refittedTrackMap_.find(type);
      if (iter != refittedTrackMap_.end()) 
    return iter->second;
      else 
    return TrackRef();
    }

    virtual void setInnerTrack( const TrackRef & t );
    virtual void setTrack( const TrackRef & t );
    virtual void setOuterTrack( const TrackRef & t );
    virtual void setStandAlone( const TrackRef & t );
    virtual void setGlobalTrack( const TrackRef & t );
    virtual void setCombined( const TrackRef & t );
    // set reference to the Best Track
    virtual void setBestTrack(MuonTrackType muonType) {bestTrackType_ = muonType;}
    // set reference to the Best Track by PF
    virtual void setTunePBestTrack(MuonTrackType muonType) {bestTunePTrackType_ = muonType;}

    void setMuonTrack(const MuonTrackType&, const TrackRef&);


    reco::Candidate::LorentzVector  pfP4() const  {return pfP4_;}
    virtual void setPFP4( const reco::Candidate::LorentzVector& p4_ ); 

    bool isEnergyValid() const { return energyValid_; }
    MuonEnergy calEnergy() const { return calEnergy_; }
    void setCalEnergy( const MuonEnergy& calEnergy ) { calEnergy_ = calEnergy; energyValid_ = true; }
    
    bool isQualityValid() const { return qualityValid_; }
    MuonQuality combinedQuality() const { return combinedQuality_; }
    void setCombinedQuality( const MuonQuality& combinedQuality ) { combinedQuality_ = combinedQuality; qualityValid_ = true; }

    bool isTimeValid() const { return (time_.nDof>0); }
    MuonTime time() const { return time_; }
    void setTime( const MuonTime& time ) { time_ = time; }
    MuonTime rpcTime() const { return rpcTime_; }
    void setRPCTime( const MuonTime& time ) { rpcTime_ = time; }
     
    bool isMatchesValid() const { return matchesValid_; }
    std::vector<MuonChamberMatch>& matches() { return muMatches_;}
    const std::vector<MuonChamberMatch>& matches() const { return muMatches_;   }
    void setMatches( const std::vector<MuonChamberMatch>& matches ) { muMatches_ = matches; matchesValid_ = true; }
     
    float caloCompatibility() const { return caloCompatibility_; }
    void  setCaloCompatibility(float input){ caloCompatibility_ = input; }
    bool  isCaloCompatibilityValid() const { return caloCompatibility_>=0; } 
    
    const MuonIsolation& isolationR03() const { return isolationR03_; }
    const MuonIsolation& isolationR05() const { return isolationR05_; }

    const MuonPFIsolation& pfIsolationR03() const { return pfIsolationR03_; }
    const MuonPFIsolation& pfMeanDRIsoProfileR03() const { return pfIsoMeanDRR03_; }
    const MuonPFIsolation& pfSumDRIsoProfileR03() const { return pfIsoSumDRR03_; }
    const MuonPFIsolation& pfIsolationR04() const { return pfIsolationR04_; }
    const MuonPFIsolation& pfMeanDRIsoProfileR04() const { return pfIsoMeanDRR04_; }
    const MuonPFIsolation& pfSumDRIsoProfileR04() const { return pfIsoSumDRR04_; }


    void setIsolation( const MuonIsolation& isoR03, const MuonIsolation& isoR05 );
    bool isIsolationValid() const { return isolationValid_; }
    void setPFIsolation(const std::string& label,const reco::MuonPFIsolation& deposit);


    bool isPFIsolationValid() const { return pfIsolationValid_; }


    // WARNING: There can be not more than 7 arbritration types. If 
    //          have more it will break the matching logic for types
    //          defined in MuonSegmentMatch

    enum ArbitrationType { NoArbitration, SegmentArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned,
               RPCHitAndTrackArbitration, GEMSegmentAndTrackArbitration, ME0SegmentAndTrackArbitration };

    enum Selector {
      CutBasedIdLoose        = 1UL<< 0,  
      CutBasedIdMedium       = 1UL<< 1,  
      CutBasedIdMediumPrompt = 1UL<< 2,  // medium with IP cuts
      CutBasedIdTight        = 1UL<< 3,  
      CutBasedIdGlobalHighPt = 1UL<< 4,  // high pt muon for Z',W' (better momentum resolution)
      CutBasedIdTrkHighPt    = 1UL<< 5,  // high pt muon for boosted Z (better efficiency)
      PFIsoVeryLoose         = 1UL<< 6,  // reliso<0.40
      PFIsoLoose             = 1UL<< 7,  // reliso<0.25
      PFIsoMedium            = 1UL<< 8,  // reliso<0.20
      PFIsoTight             = 1UL<< 9,  // reliso<0.15
      PFIsoVeryTight         = 1UL<<10,  // reliso<0.10
      TkIsoLoose             = 1UL<<11,  // reliso<0.10
      TkIsoTight             = 1UL<<12,  // reliso<0.05
      SoftCutBasedId         = 1UL<<13,  
      SoftMvaId              = 1UL<<14,  
      MvaLoose               = 1UL<<15,  
      MvaMedium              = 1UL<<16,  
      MvaTight               = 1UL<<17,
      MiniIsoLoose           = 1UL<<18,  // reliso<0.40
      MiniIsoMedium          = 1UL<<19,  // reliso<0.20
      MiniIsoTight           = 1UL<<20,  // reliso<0.10
      MiniIsoVeryTight       = 1UL<<21,  // reliso<0.05
      TriggerIdLoose         = 1UL<<22,  // robust selector for HLT
      InTimeMuon             = 1UL<<23,   
      PFIsoVeryVeryTight     = 1UL<<24,  // reliso<0.05
      MultiIsoLoose          = 1UL<<25,  // miniIso with ptRatio and ptRel 
      MultiIsoMedium         = 1UL<<26,   // miniIso with ptRatio and ptRel 
      PuppiIsoLoose          = 1UL<<27,
      PuppiIsoMedium         = 1UL<<28,
      PuppiIsoTight          = 1UL<<29, 
      MvaVTight              = 1UL<<30,
      MvaVVTight             = 1UL<<31,
      LowPtMvaLoose          = 1UL<<32,
      LowPtMvaMedium         = 1UL<<33,
    };
    
    bool passed( uint64_t selection ) const { return (selectors_ & selection)==selection; }
    bool passed( Selector selection ) const { return passed(static_cast<unsigned int>(selection)); }
    uint64_t selectors() const { return selectors_; }
    void setSelectors( uint64_t selectors ){ selectors_ = selectors; }
    void setSelector(Selector selector, bool passed){ 
      if (passed)
    selectors_ |= selector;
      else
    selectors_ &= ~selector;
    }

    int numberOfChambers() const { return muMatches_.size(); }
    int numberOfChambersCSCorDT() const;
    int numberOfMatches( ArbitrationType type = SegmentAndTrackArbitration ) const;
    int numberOfMatchedStations( ArbitrationType type = SegmentAndTrackArbitration ) const;
    unsigned int expectedNnumberOfMatchedStations( float minDistanceFromEdge = 10.0 ) const;
    unsigned int stationMask( ArbitrationType type = SegmentAndTrackArbitration ) const;
    int numberOfMatchedRPCLayers( ArbitrationType type = RPCHitAndTrackArbitration ) const;
    unsigned int RPClayerMask( ArbitrationType type = RPCHitAndTrackArbitration ) const;
    unsigned int stationGapMaskDistance( float distanceCut = 10. ) const;
    unsigned int stationGapMaskPull( float sigmaCut = 3. ) const;
    int nDigisInStation( int station, int muonSubdetId) const;
    bool hasShowerInStation( int station, int muonSubdetId, int nDtDigisCut = 20, int nCscDigisCut = 36 ) const;
    int numberOfShowers( int nDtDigisCut = 20, int nCscDigisCut = 36 ) const;

    static const unsigned int GlobalMuon     =  1<<1;
    static const unsigned int TrackerMuon    =  1<<2;
    static const unsigned int StandAloneMuon =  1<<3;
    static const unsigned int CaloMuon =  1<<4;
    static const unsigned int PFMuon =  1<<5;
    static const unsigned int RPCMuon =  1<<6;
    static const unsigned int GEMMuon =  1<<7;
    static const unsigned int ME0Muon =  1<<8;

    void setType( unsigned int type ) { type_ = type; } 
    unsigned int type() const { return type_; } 

   
    // override of method in base class reco::Candidate
    bool isMuon() const override { return true; }
    bool isGlobalMuon()     const override { return type_ & GlobalMuon; }
    bool isTrackerMuon()    const override { return type_ & TrackerMuon; }
    bool isStandAloneMuon() const override { return type_ & StandAloneMuon; }
    bool isCaloMuon() const override { return type_ & CaloMuon; }
    bool isPFMuon() const {return type_ & PFMuon;} //fix me ! Has to go to type
    bool isRPCMuon() const {return type_ & RPCMuon;}
    bool isGEMMuon() const {return type_ & GEMMuon;}
    bool isME0Muon() const {return type_ & ME0Muon;}
    
  private:
    bool overlap( const Candidate & ) const override;
    TrackRef innerTrack_;
    TrackRef outerTrack_;
    TrackRef globalTrack_;
    MuonTrackRefMap refittedTrackMap_;
    MuonTrackType bestTrackType_;
    MuonTrackType bestTunePTrackType_;

    MuonEnergy calEnergy_;
    MuonQuality combinedQuality_;
    std::vector<MuonChamberMatch> muMatches_;
    MuonTime time_;
    MuonTime rpcTime_;
    bool energyValid_;
    bool matchesValid_;
    bool isolationValid_;
    bool pfIsolationValid_;
    bool qualityValid_;
    float caloCompatibility_;
    MuonIsolation isolationR03_;
    MuonIsolation isolationR05_;

    MuonPFIsolation pfIsolationR03_;
    MuonPFIsolation pfIsoMeanDRR03_;
    MuonPFIsolation pfIsoSumDRR03_;
    MuonPFIsolation pfIsolationR04_;
    MuonPFIsolation pfIsoMeanDRR04_;
    MuonPFIsolation pfIsoSumDRR04_;

    unsigned int type_;
    
    //PF muon p4
    reco::Candidate::LorentzVector pfP4_;

    // FixMe: Still missing trigger information

    const std::vector<const MuonChamberMatch*> chambers( int station, int muonSubdetId ) const;
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> pair( const std::vector<const MuonChamberMatch*> &,
                                     ArbitrationType type = SegmentAndTrackArbitration ) const;
    uint64_t selectors_;
   public:
    int numberOfSegments( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float dX       ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float dY       ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float dDxDz    ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float dDyDz    ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float pullX    ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration, bool includeSegmentError = true ) const;
     float pullY    ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration, bool includeSegmentError = true ) const;
     float pullDxDz ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration, bool includeSegmentError = true ) const;
     float pullDyDz ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration, bool includeSegmentError = true ) const;
     float segmentX       ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float segmentY       ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float segmentDxDz    ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float segmentDyDz    ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float segmentXErr    ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float segmentYErr    ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float segmentDxDzErr ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float segmentDyDzErr ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float trackEdgeX   ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float trackEdgeY   ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float trackX       ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float trackY       ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float trackDxDz    ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float trackDyDz    ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float trackXErr    ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float trackYErr    ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float trackDxDzErr ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float trackDyDzErr ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float trackDist    ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     float trackDistErr ( int station, int muonSubdetId, ArbitrationType type = SegmentAndTrackArbitration ) const;
     
     float t0(int n=0) {
    int i = 0;
    for( std::vector<MuonChamberMatch>::const_iterator chamber = muMatches_.begin();
         chamber != muMatches_.end(); ++chamber )
      for ( std::vector<reco::MuonSegmentMatch>::const_iterator segment = chamber->segmentMatches.begin();
        segment != chamber->segmentMatches.end(); ++segment )
        {
           if (i==n) return segment->t0;
           ++i;
        }
    return 0;
     }
  };

}


#endif