/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/DataFormats/MuonReco/interface/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/MuonEnergy.h"
#include "DataFormats/MuonReco/interface/MuonTime.h"
#include "DataFormats/MuonReco/interface/MuonQuality.h"

namespace reco {
 
  class Muon : public RecoCandidate {
  public:
    Muon();
    Muon(  Charge, const LorentzVector &, const Point & = Point( 0, 0, 0 ) );
    Muon * clone() const;
    
    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 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 );
    
    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_; }
    void setIsolation( const MuonIsolation& isoR03, const MuonIsolation& isoR05 );
    bool isIsolationValid() const { return isolationValid_; }

    enum ArbitrationType { NoArbitration, SegmentArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned };
    
    int numberOfChambers() const { return muMatches_.size(); }
    int numberOfMatches( ArbitrationType type = SegmentAndTrackArbitration ) const;
    int numberOfMatchedStations( ArbitrationType type = SegmentAndTrackArbitration ) const;
    unsigned int stationMask( ArbitrationType type = SegmentAndTrackArbitration ) 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;
    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; }
    
  private:
    virtual bool overlap( const Candidate & ) const;
    TrackRef innerTrack_;
    TrackRef outerTrack_;
    TrackRef globalTrack_;
    MuonEnergy calEnergy_;
    MuonQuality combinedQuality_;
    std::vector<MuonChamberMatch> muMatches_;
    MuonTime time_;
     
    bool energyValid_;
    bool matchesValid_;
    bool isolationValid_;
    bool qualityValid_;
    float caloCompatibility_;
    MuonIsolation isolationR03_;
    MuonIsolation isolationR05_;
    unsigned int type_;

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