Muon.h

Go to the documentation of this file.

//
// $Id: Muon.h,v 1.39.2.1 2012/12/13 09:56:16 bellan 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(); }
      reco::TrackRef muonBestTrack() const;
      reco::TrackRef improvedMuonBestTrack() const;

      // get reference to the Improved Best Track
      virtual MuonTrackType improvedMuonBestTrackType() const {return improvedMuonBestTrackType_;}
      // set reference to the Improved Best Track
      virtual void setImprovedBestTrack(MuonTrackType muonType) {improvedMuonBestTrackType_ = muonType;}

      void embedMuonBestTrack();
      void embedImprovedMuonBestTrack();
      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 pickyTrack() const;
      reco::TrackRef tpfmsTrack() const;
      reco::TrackRef dytTrack() const;
      reco::TrackRef pickyMuon() const { return pickyTrack(); } // JMTBAD gcc deprecated attribute?
      reco::TrackRef tpfmsMuon() const { return tpfmsTrack(); } // JMTBAD gcc deprecated attribute?
      void embedPickyMuon();
      void embedTpfmsMuon();
      void embedDytMuon();

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

      bool isTightMuon(const reco::Vertex&) const;
      bool isLooseMuon() const;
      bool isSoftMuon(const reco::Vertex&) const;

      bool isHighPtMuon(const reco::Vertex&, reco::TunePType) 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 pat::Muon& obj);

    protected:

      // ---- for content embedding ----

      bool embeddedMuonBestTrack_;
      std::vector<reco::Track> muonBestTrack_;
      bool embeddedImprovedMuonBestTrack_;
      std::vector<reco::Track> improvedMuonBestTrack_;
      MuonTrackType improvedMuonBestTrackType_;
      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_;

      // Capability to embed TeV refit tracks as the inner/outer/combined ones.
      bool embeddedPickyMuon_;
      bool embeddedTpfmsMuon_;
      bool embeddedDytMuon_;
      std::vector<reco::Track> pickyMuon_;
      std::vector<reco::Track> tpfmsMuon_;
      std::vector<reco::Track> dytMuon_;

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