Muon.cc

Go to the documentation of this file.

//
//

#include "DataFormats/PatCandidates/interface/Muon.h"
#include "DataFormats/MuonReco/interface/MuonSelectors.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "DataFormats/Common/interface/RefToPtr.h"
#include <limits>

using namespace pat;


Muon::Muon() :
    Lepton<reco::Muon>(),
    embeddedMuonBestTrack_(false),
    embeddedTunePMuonBestTrack_(false),
    embeddedTrack_(false),
    embeddedStandAloneMuon_(false),
    embeddedCombinedMuon_(false),
    embeddedTCMETMuonCorrs_(false),
    embeddedCaloMETMuonCorrs_(false),
    embeddedPickyMuon_(false),
    embeddedTpfmsMuon_(false),
    embeddedDytMuon_(false),
    embeddedPFCandidate_(false),
    pfCandidateRef_(),
    cachedNormChi2_(false),
    cachedDB_(false),
    cachedNumberOfValidHits_(0),
    normChi2_(0.0),
    dB_(0.0),
    edB_(0.0),
    numberOfValidHits_(0)
{
  initImpactParameters();
}

Muon::Muon(const reco::Muon & aMuon) :
    Lepton<reco::Muon>(aMuon),
    embeddedMuonBestTrack_(false),
    embeddedTunePMuonBestTrack_(false),
    embeddedTrack_(false),
    embeddedStandAloneMuon_(false),
    embeddedCombinedMuon_(false),
    embeddedTCMETMuonCorrs_(false),
    embeddedCaloMETMuonCorrs_(false),
    embeddedPickyMuon_(false),
    embeddedTpfmsMuon_(false),
    embeddedDytMuon_(false),
    embeddedPFCandidate_(false),
    pfCandidateRef_(),
    cachedNormChi2_(false),
    cachedDB_(false),
    cachedNumberOfValidHits_(0),
    normChi2_(0.0),
    dB_(0.0),
    edB_(0.0),
    numberOfValidHits_(0)
{
  initImpactParameters();
}

Muon::Muon(const edm::RefToBase<reco::Muon> & aMuonRef) :
    Lepton<reco::Muon>(aMuonRef),
    embeddedMuonBestTrack_(false),
    embeddedTunePMuonBestTrack_(false),
    embeddedTrack_(false),
    embeddedStandAloneMuon_(false),
    embeddedCombinedMuon_(false),
    embeddedTCMETMuonCorrs_(false),
    embeddedCaloMETMuonCorrs_(false),
    embeddedPickyMuon_(false),
    embeddedTpfmsMuon_(false),
    embeddedDytMuon_(false),
    embeddedPFCandidate_(false),
    pfCandidateRef_(),
    cachedNormChi2_(false),
    cachedDB_(false),
    cachedNumberOfValidHits_(0),
    normChi2_(0.0),
    dB_(0.0),
    edB_(0.0),
    numberOfValidHits_(0)
{
  initImpactParameters();
}

Muon::Muon(const edm::Ptr<reco::Muon> & aMuonRef) :
    Lepton<reco::Muon>(aMuonRef),
    embeddedMuonBestTrack_(false),
    embeddedTunePMuonBestTrack_(false),
    embeddedTrack_(false),
    embeddedStandAloneMuon_(false),
    embeddedCombinedMuon_(false),
    embeddedTCMETMuonCorrs_(false),
    embeddedCaloMETMuonCorrs_(false),
    embeddedPickyMuon_(false),
    embeddedTpfmsMuon_(false),
    embeddedDytMuon_(false),
    embeddedPFCandidate_(false),
    pfCandidateRef_(),
    cachedNormChi2_(false),
    cachedDB_(false),
    cachedNumberOfValidHits_(0),
    normChi2_(0.0),
    dB_(0.0),
    edB_(0.0),
    numberOfValidHits_(0)
{
  initImpactParameters();
}

Muon::~Muon() {
}

std::ostream& 
reco::operator<<(std::ostream& out, const pat::Muon& obj) 
{
  if(!out) return out;
  
  out << "\tpat::Muon: ";
  out << std::setiosflags(std::ios::right);
  out << std::setiosflags(std::ios::fixed);
  out << std::setprecision(3);
  out << " E/pT/eta/phi " 
      << obj.energy()<<"/"
      << obj.pt()<<"/"
      << obj.eta()<<"/"
      << obj.phi();
  return out; 
}

// initialize impact parameter container vars
void Muon::initImpactParameters() {
  for (int i_ = 0; i_<5; ++i_){
    ip_.push_back(0.0);
    eip_.push_back(0.0);
    cachedIP_.push_back(false);
  }
}


reco::TrackRef Muon::track() const {
  if (embeddedTrack_) {
    return reco::TrackRef(&track_, 0);
  } else {
    return reco::Muon::innerTrack();
  }
}


reco::TrackRef Muon::standAloneMuon() const {
  if (embeddedStandAloneMuon_) {
    return reco::TrackRef(&standAloneMuon_, 0);
  } else {
    return reco::Muon::outerTrack();
  }
}


reco::TrackRef Muon::combinedMuon() const {
  if (embeddedCombinedMuon_) {
    return reco::TrackRef(&combinedMuon_, 0);
  } else {
    return reco::Muon::globalTrack();
  }
}

reco::TrackRef Muon::pickyTrack() const {
  if (embeddedPickyMuon_) {
    return reco::TrackRef(&pickyMuon_, 0);
  } else {
    return reco::Muon::pickyTrack();
  }
}

reco::TrackRef Muon::tpfmsTrack() const {
  if (embeddedTpfmsMuon_) {
    return reco::TrackRef(&tpfmsMuon_, 0);
  } else {
    return reco::Muon::tpfmsTrack();
  }
}

reco::TrackRef Muon::dytTrack() const {
  if (embeddedDytMuon_) {
    return reco::TrackRef(&dytMuon_, 0);
  } else {
    return reco::Muon::dytTrack();
  }
}

reco::TrackRef Muon::muonBestTrack() const {
  if (!muonBestTrack_.empty()) {
    return reco::TrackRef(&muonBestTrack_, 0);
  } else {
    return reco::Muon::muonBestTrack();
  }
}

reco::TrackRef Muon::tunePMuonBestTrack() const {
  if (!tunePMuonBestTrack_.empty()) {
    return reco::TrackRef(&tunePMuonBestTrack_, 0);
  } else if (muonBestTrackType() == tunePMuonBestTrackType()) {
    return muonBestTrack();
  } else {
    return reco::Muon::tunePMuonBestTrack();
  }
}




reco::PFCandidateRef Muon::pfCandidateRef() const {
  if (embeddedPFCandidate_) {
    return reco::PFCandidateRef(&pfCandidate_, 0);
  } else {
    return pfCandidateRef_;
  }
}

reco::CandidatePtr Muon::sourceCandidatePtr( size_type i ) const {
  if(pfCandidateRef_.isNonnull() && i==0 ) return reco::CandidatePtr(edm::refToPtr(pfCandidateRef_) );
  if(refToOrig_.isNonnull() &&  pfCandidateRef_.isNonnull() && i==1 ) return refToOrig_;
  if(refToOrig_.isNonnull() && ! pfCandidateRef_.isNonnull() && i==0 ) return refToOrig_;
  return reco::CandidatePtr();
}

void Muon::embedMuonBestTrack(bool force) {
  muonBestTrack_.clear();
  embeddedMuonBestTrack_ = false;
  bool alreadyEmbedded = force;
  if (!force) {
      switch (muonBestTrackType()) {
        case None: alreadyEmbedded = true; break;
        case InnerTrack: if (embeddedTrack_) alreadyEmbedded = true; break;
        case OuterTrack: if (embeddedStandAloneMuon_) alreadyEmbedded = true; break;
        case CombinedTrack: if (embeddedCombinedMuon_) alreadyEmbedded = true; break;
        case TPFMS: if (embeddedTpfmsMuon_) alreadyEmbedded = true; break;
        case Picky: if (embeddedPickyMuon_) alreadyEmbedded = true; break;
        case DYT: if (embeddedDytMuon_) alreadyEmbedded = true; break;
      }
  }
  if (!alreadyEmbedded) {
      muonBestTrack_.push_back(*reco::Muon::muonBestTrack());
      embeddedMuonBestTrack_ = true;
  }
}

void Muon::embedTunePMuonBestTrack(bool force) {
  tunePMuonBestTrack_.clear();
  bool alreadyEmbedded = force;
  embeddedTunePMuonBestTrack_ = false;
  if (!force) {
      switch (muonBestTrackType()) {
          case None: alreadyEmbedded = true; break;
          case InnerTrack: if (embeddedTrack_) alreadyEmbedded = true; break;
          case OuterTrack: if (embeddedStandAloneMuon_) alreadyEmbedded = true; break;
          case CombinedTrack: if (embeddedCombinedMuon_) alreadyEmbedded = true; break;
          case TPFMS: if (embeddedTpfmsMuon_) alreadyEmbedded = true; break;
          case Picky: if (embeddedPickyMuon_) alreadyEmbedded = true; break;
          case DYT: if (embeddedDytMuon_) alreadyEmbedded = true; break;
      }
      if (muonBestTrackType() == tunePMuonBestTrackType()) {
          if (embeddedMuonBestTrack_) alreadyEmbedded = true;
      }
  }
  if (!alreadyEmbedded) {
      tunePMuonBestTrack_.push_back(*reco::Muon::tunePMuonBestTrack());
      embeddedTunePMuonBestTrack_ = true;
  }
}


void Muon::embedTrack() {
  track_.clear();
  if (reco::Muon::innerTrack().isNonnull()) {
      track_.push_back(*reco::Muon::innerTrack());
      embeddedTrack_ = true;
  }
}


void Muon::embedStandAloneMuon() {
  standAloneMuon_.clear();
  if (reco::Muon::outerTrack().isNonnull()) {
      standAloneMuon_.push_back(*reco::Muon::outerTrack());
      embeddedStandAloneMuon_ = true;
  }
}


void Muon::embedCombinedMuon() {
  combinedMuon_.clear();
  if (reco::Muon::globalTrack().isNonnull()) {
      combinedMuon_.push_back(*reco::Muon::globalTrack());
      embeddedCombinedMuon_ = true;
  }
}

void Muon::embedCaloMETMuonCorrs(const reco::MuonMETCorrectionData& t) {
  caloMETMuonCorrs_.clear();
  caloMETMuonCorrs_.push_back(t);
  embeddedCaloMETMuonCorrs_ = true;
}

void Muon::embedTcMETMuonCorrs(const reco::MuonMETCorrectionData& t) {
  tcMETMuonCorrs_.clear();
  tcMETMuonCorrs_.push_back(t);
  embeddedTCMETMuonCorrs_ = true;
}

void Muon::embedPickyMuon() {
  pickyMuon_.clear();
  reco::TrackRef tk = reco::Muon::pickyTrack();
  if (tk.isNonnull()) {
    pickyMuon_.push_back(*tk);
    embeddedPickyMuon_ = true;
  }
}

void Muon::embedTpfmsMuon() {
  tpfmsMuon_.clear();
  reco::TrackRef tk = reco::Muon::tpfmsTrack();
  if (tk.isNonnull()) {
    tpfmsMuon_.push_back(*tk);
    embeddedTpfmsMuon_ = true;
  }
}

void Muon::embedDytMuon() {
  dytMuon_.clear();
  reco::TrackRef tk = reco::Muon::dytTrack();
  if (tk.isNonnull()) {
    dytMuon_.push_back(*tk);
    embeddedDytMuon_ = true;
  }
}

void Muon::embedPFCandidate() {
  pfCandidate_.clear();
  if ( pfCandidateRef_.isAvailable() && pfCandidateRef_.isNonnull()) {
    pfCandidate_.push_back( *pfCandidateRef_ );
    embeddedPFCandidate_ = true;
  }
}

bool Muon::muonID(const std::string& name) const {
  muon::SelectionType st = muon::selectionTypeFromString(name);
  return muon::isGoodMuon(*this, st);
}


double Muon::normChi2() const {
  if ( cachedNormChi2_ ) {
    return normChi2_;
  } else {
    reco::TrackRef t = globalTrack();
    return t->chi2() / t->ndof();
  }
}

unsigned int Muon::numberOfValidHits() const {
  if ( cachedNumberOfValidHits_ ) {
    return numberOfValidHits_;
  } else {
    reco::TrackRef t = innerTrack();
    return t->numberOfValidHits();
  }
}

// embed various impact parameters with errors
// IpType defines the type of the impact parameter
// None is default and reverts to old behavior controlled by 
// patMuons.usePV = True/False
double Muon::dB(IpType type_) const {
  
  // preserve old functionality exactly
  if (type_ == None){
    if ( cachedDB_ ) {
      return dB_;
    }
    else {
      return std::numeric_limits<double>::max();
    }
  }
  
  // more IP types (new)
  else if ( cachedIP_[type_] ) {
    return ip_[type_];
  } else {
    return std::numeric_limits<double>::max();
  }
}


// embed various impact parameters with errors
// IpType defines the type of the impact parameter
// None is default and reverts to old behavior controlled by 
// patMuons.usePV = True/False
double Muon::edB(IpType type_) const {

  // preserve old functionality exactly
  if (type_ == None){
    if ( cachedDB_ ) {
      return edB_;
    }
    else {
      return std::numeric_limits<double>::max();
    }
  }

  // more IP types (new)
  else if ( cachedIP_[type_] ) {
    return eip_[type_];
  } else {
    return std::numeric_limits<double>::max();
  }
}


double Muon::segmentCompatibility(reco::Muon::ArbitrationType arbitrationType) const {
   return muon::segmentCompatibility(*this, arbitrationType);
}

// Selectors
bool Muon::isTightMuon(const reco::Vertex&vtx) const {
  return muon::isTightMuon(*this, vtx);
}

bool Muon::isLooseMuon() const {
  return muon::isLooseMuon(*this);

}

bool Muon::isSoftMuon(const reco::Vertex& vtx) const {
  return muon::isSoftMuon(*this, vtx);
}


bool Muon::isHighPtMuon(const reco::Vertex& vtx) const{
  return muon::isHighPtMuon(*this, vtx);
}