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;

    
    
    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_; }
    virtual TrackRef track() const { return innerTrack(); }
    virtual TrackRef outerTrack() const { return outerTrack_; }
    virtual TrackRef standAloneMuon() const { return outerTrack(); }
    virtual TrackRef globalTrack() const { return globalTrack_; }
    virtual TrackRef combinedMuon() const { return globalTrack(); }

    virtual TrackRef tpfmsTrack() const { return muonTrackFromMap(TPFMS);}
    virtual TrackRef pickyTrack() const { return muonTrackFromMap(Picky);}
    virtual TrackRef dytTrack()   const { return muonTrackFromMap(DYT);}
    
    virtual const Track * bestTrack() const         {return muonTrack(bestTrackType_).get();}
    virtual TrackBaseRef  bestTrackRef() const      {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; }
     
    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_; }


    enum ArbitrationType { NoArbitration, SegmentArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned, RPCHitAndTrackArbitration };
    
    int numberOfChambers() const { return muMatches_.size(); }
    int numberOfChambersNoRPC() const;
    int numberOfMatches( ArbitrationType type = SegmentAndTrackArbitration ) const;
    int numberOfMatchedStations( ArbitrationType type = SegmentAndTrackArbitration ) 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;
     
    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;

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

    MuonEnergy calEnergy_;
    MuonQuality combinedQuality_;
    std::vector<MuonChamberMatch> muMatches_;
    MuonTime time_;
    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;
     
   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