/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/DataFormats/PatCandidates/interface/Muon.h

Go to the documentation of this file.

//
// $Id: Muon.h,v 1.36 2011/06/08 20:40:18 rwolf Exp $
//

#ifndef DataFormats_PatCandidates_Muon_h
#define DataFormats_PatCandidates_Muon_h

#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "DataFormats/MuonReco/interface/MuonSelectors.h"
#include "DataFormats/MuonReco/interface/MuonMETCorrectionData.h"

#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/PatCandidates/interface/Lepton.h"
#include "DataFormats/ParticleFlowCandidate/interface/IsolatedPFCandidateFwd.h"
#include "DataFormats/ParticleFlowCandidate/interface/IsolatedPFCandidate.h"


// Define typedefs for convenience
namespace pat {
  class Muon;
  typedef std::vector<Muon>              MuonCollection; 
  typedef edm::Ref<MuonCollection>       MuonRef; 
  typedef edm::RefVector<MuonCollection> MuonRefVector; 
}

namespace reco {
  std::ostream& operator<<(std::ostream& out, const pat::Muon& obj);
}

// Class definition
namespace pat {


  class Muon : public Lepton<reco::Muon> {

    public:

      Muon();
      Muon(const reco::Muon & aMuon);
      Muon(const edm::RefToBase<reco::Muon> & aMuonRef);
      Muon(const edm::Ptr<reco::Muon> & aMuonRef);
      virtual ~Muon();

      virtual Muon * clone() const { return new Muon(*this); }

      // ---- methods for content embedding ----
      reco::TrackRef track() const;
      using reco::RecoCandidate::track; // avoid hiding the base implementation
      reco::TrackRef innerTrack() const { return track(); }
      reco::TrackRef standAloneMuon() const;
      reco::TrackRef outerTrack() const { return standAloneMuon(); }
      reco::TrackRef combinedMuon() const;
      reco::TrackRef globalTrack() const { return combinedMuon(); }
      void embedTrack();
      void embedStandAloneMuon();
      void embedCombinedMuon();

      // ---- methods for MuonMETCorrectionData ----
      reco::MuonMETCorrectionData caloMETMuonCorrs() const { return (embeddedCaloMETMuonCorrs_ ? caloMETMuonCorrs_.front() : reco::MuonMETCorrectionData());};
      void embedCaloMETMuonCorrs(const reco::MuonMETCorrectionData& t);
      reco::MuonMETCorrectionData tcMETMuonCorrs() const {return (embeddedTCMETMuonCorrs_ ? tcMETMuonCorrs_.front() : reco::MuonMETCorrectionData());};
      void embedTcMETMuonCorrs(const reco::MuonMETCorrectionData& t);

      // ---- methods for TeV refit tracks ----
      reco::TrackRef pickyMuon() const;
      void setPickyMuon(const reco::TrackRef& t) { pickyMuonRef_ = t; }
      reco::TrackRef tpfmsMuon() const;
      void setTpfmsMuon(const reco::TrackRef& t) { tpfmsMuonRef_ = t; }
      void embedPickyMuon();
      void embedTpfmsMuon();

      // ---- PF specific methods ----
      reco::PFCandidateRef pfCandidateRef() const;
      void setPFCandidateRef(const reco::PFCandidateRef& ref) {
        pfCandidateRef_ = ref;
      } 
      void embedPFCandidate();
      size_t numberOfSourceCandidatePtrs() const { 
        return pfCandidateRef_.isNonnull() ? 1 : 0;
      }
      reco::CandidatePtr sourceCandidatePtr( size_type i ) const;

      // ---- methods for accessing muon identification ----
      bool muonID (const std::string& name) const;
      bool isGood (const std::string& name) const { return muonID(name); }
      //bool isMuonIDAvailable(const std::string& name) const;

      // ---- overload of isolation functions ----
      float trackIso() const { return isolationR03().sumPt; }
      float ecalIso()  const { return isolationR03().emEt; }
      float hcalIso()  const { return isolationR03().hadEt; }
      float caloIso()  const { return ecalIso()+hcalIso(); }

      //  as external input. 
        
        // ---- embed various impact parameters with errors ----
        //
        // example:
        //
        //    // this will return the muon inner track
        //    // transverse impact parameter
        //    // relative to the primary vertex
        //    muon->dB(pat::Muon::PV2D);
        //
        //    // this will return the uncertainty
        //    // on the muon inner track
        //    // transverse impact parameter
        //    // relative to the primary vertex
        //    // or -1.0 if there is no valid PV in the event
        //    muon->edB(pat::Muon::PV2D);
        //
        // IpType defines the type of the impact parameter
        // None is default and reverts to old behavior controlled by 
        // patMuons.usePV = True/False
        typedef enum IPTYPE 
          {
            None = 0, PV2D = 1, PV3D = 2, BS2D = 3, BS3D = 4
          } IpType; 
        void initImpactParameters(void); // init IP defaults in a constructor
        double dB(IpType type = None) const;
        double edB(IpType type = None) const;
        void   setDB ( double dB, double edB, IpType type = None ) { 
          if (type == None) {
            dB_ = dB; edB_ = edB; 
            cachedDB_ = true;
          }
          ip_[type] = dB; eip_[type] = edB; cachedIP_[type] = true;
        }

      unsigned int numberOfValidHits() const;
      void setNumberOfValidHits(unsigned int numberOfValidHits ) 
      { numberOfValidHits_ = numberOfValidHits; cachedNumberOfValidHits_ = true; }

      double normChi2() const;
      void setNormChi2 (double normChi2 ) 
      { normChi2_ = normChi2; cachedNormChi2_ = true; }

      double segmentCompatibility(reco::Muon::ArbitrationType arbitrationType = reco::Muon::SegmentAndTrackArbitration) const ;

      friend std::ostream& reco::operator<<(std::ostream& out, const Muon& obj);

    protected:

      // ---- for content embedding ----
      bool embeddedTrack_;
      std::vector<reco::Track> track_;
      bool embeddedStandAloneMuon_;
      std::vector<reco::Track> standAloneMuon_;
      bool embeddedCombinedMuon_;
      std::vector<reco::Track> combinedMuon_;

      bool embeddedTCMETMuonCorrs_;
      std::vector<reco::MuonMETCorrectionData> tcMETMuonCorrs_;
      bool embeddedCaloMETMuonCorrs_;
      std::vector<reco::MuonMETCorrectionData> caloMETMuonCorrs_;

      // TeV refit tracks, which are not currently stored in the
      // reco::Muon like the above tracks are. Also provide capability
      // to embed them.
      bool embeddedPickyMuon_;
      bool embeddedTpfmsMuon_;
      reco::TrackRef pickyMuonRef_;
      reco::TrackRef tpfmsMuonRef_;
      std::vector<reco::Track> pickyMuon_;
      std::vector<reco::Track> tpfmsMuon_;

      // ---- PF specific members ----
      bool embeddedPFCandidate_;      
      reco::PFCandidateCollection pfCandidate_;
      reco::PFCandidateRef pfCandidateRef_;

      // V+Jets group selection variables. 
      bool    cachedNormChi2_;         
      bool    cachedDB_;               

      bool    cachedNumberOfValidHits_;
      double  normChi2_;               
      double  dB_;                     
      double  edB_;                    // and its uncertainty as recommended by the tracking group

      // ---- cached impact parameters ----
      std::vector<bool>    cachedIP_;  // has the IP (former dB) been cached?
      std::vector<double>  ip_;        // dB and edB are the impact parameter at the primary vertex,
      std::vector<double>  eip_;       // and its uncertainty as recommended by the tracking group

      unsigned int  numberOfValidHits_;

  };


}

#endif