PFRecoTauDiscriminationAgainstMuon2Helper Struct Reference

#include <PFRecoTauDiscriminationAgainstMuon2Helper.h>

Public Member Functions
bool	eval (const PFRecoTauDiscriminationAgainstMuonConfigSet &, const reco::PFTauRef &) const
	PFRecoTauDiscriminationAgainstMuon2Helper (const bool &, const std::string &, const bool, const double &, const double &, const bool &, std::atomic< unsigned int > &, const unsigned int &, const std::vector< int > &, const std::vector< int > &, const std::vector< int > &, const std::vector< int > &, const std::vector< int > &, const std::vector< int > &, const edm::Handle< reco::MuonCollection > &, const reco::PFTauRef &, const reco::PFCandidatePtr &)

Public Attributes
double	energyECALplusHCAL_
const reco::Track *	leadTrack_ = nullptr
int	numLast2StationsWithHits_ = 0
int	numStationsWithMatches_ = 0
const reco::PFCandidatePtr &	pfLeadChargedHadron_

Detailed Description

Definition at line 24 of file PFRecoTauDiscriminationAgainstMuon2Helper.h.

Constructor & Destructor Documentation

PFRecoTauDiscriminationAgainstMuon2Helper()

PFRecoTauDiscriminationAgainstMuon2Helper::PFRecoTauDiscriminationAgainstMuon2Helper	(	const bool &	verbosity,
		const std::string &	moduleLabel,
		const bool	srcMuons_label_empty,
		const double &	minPtMatchedMuon,
		const double &	dRmuonMatch,
		const bool &	dRmuonMatchLimitedToJetArea,
		std::atomic< unsigned int > &	numWarnings,
		const unsigned int &	maxWarnings,
		const std::vector< int > &	maskMatchesDT,
		const std::vector< int > &	maskMatchesCSC,
		const std::vector< int > &	maskMatchesRPC,
		const std::vector< int > &	maskHitsDT,
		const std::vector< int > &	maskHitsCSC,
		const std::vector< int > &	maskHitsRPC,
		const edm::Handle< reco::MuonCollection > &	muons,
		const reco::PFTauRef &	pfTau,
		const reco::PFCandidatePtr &	pfCand
	)

Definition at line 20 of file PFRecoTauDiscriminationAgainstMuon2Helper.cc.

    : pfLeadChargedHadron_{pfCand} {
  if (verbosity) {
    edm::LogPrint("PFTauAgainstMuon2") << "<PFRecoTauDiscriminationAgainstMuon2Container::discriminate>:";
    edm::LogPrint("PFTauAgainstMuon2") << " moduleLabel = " << moduleLabel;
    edm::LogPrint("PFTauAgainstMuon2") << "tau #" << pfTau.key() << ": Pt = " << pfTau->pt()
                                       << ", eta = " << pfTau->eta() << ", phi = " << pfTau->phi();
  }
 
  std::vector<int> numMatchesDT(4);
  std::vector<int> numMatchesCSC(4);
  std::vector<int> numMatchesRPC(4);
  std::vector<int> numHitsDT(4);
  std::vector<int> numHitsCSC(4);
  std::vector<int> numHitsRPC(4);
  for (int iStation = 0; iStation < 4; ++iStation) {
    numMatchesDT[iStation] = 0;
    numMatchesCSC[iStation] = 0;
    numMatchesRPC[iStation] = 0;
    numHitsDT[iStation] = 0;
    numHitsCSC[iStation] = 0;
    numHitsRPC[iStation] = 0;
  }
 
  //pfLeadChargedHadron_ = pfTau->leadPFChargedHadrCand();
  if (pfLeadChargedHadron_.isNonnull()) {
    reco::MuonRef muonRef = pfLeadChargedHadron_->muonRef();
    if (muonRef.isNonnull()) {
      if (verbosity)
        edm::LogPrint("PFTauAgainstMuon2") << " has muonRef.";
      reco::tau::countMatches(*muonRef, numMatchesDT, numMatchesCSC, numMatchesRPC);
      reco::tau::countHits(*muonRef, numHitsDT, numHitsCSC, numHitsRPC);
    }
  }
 
  if (!srcMuons_label_empty) {
    size_t numMuons = muons->size();
    for (size_t idxMuon = 0; idxMuon < numMuons; ++idxMuon) {
      reco::MuonRef muon(muons, idxMuon);
      if (verbosity)
        edm::LogPrint("PFTauAgainstMuon2") << "muon #" << muon.key() << ": Pt = " << muon->pt()
                                           << ", eta = " << muon->eta() << ", phi = " << muon->phi();
      if (!(muon->pt() > minPtMatchedMuon)) {
        if (verbosity) {
          edm::LogPrint("PFTauAgainstMuon2") << " fails Pt cut --> skipping it.";
        }
        continue;
      }
      if (pfLeadChargedHadron_.isNonnull()) {
        reco::MuonRef muonRef = pfLeadChargedHadron_->muonRef();
        if (muonRef.isNonnull() && muon == pfLeadChargedHadron_->muonRef()) {
          if (verbosity) {
            edm::LogPrint("PFTauAgainstMuon2") << " matches muonRef of tau --> skipping it.";
          }
          continue;
        }
      }
      double dR = deltaR(muon->p4(), pfTau->p4());
      double dRmatch = dRmuonMatch;
      if (dRmuonMatchLimitedToJetArea) {
        double jetArea = 0.;
        if (pfTau->jetRef().isNonnull())
          jetArea = pfTau->jetRef()->jetArea();
        if (jetArea > 0.) {
          dRmatch = std::min(dRmatch, std::sqrt(jetArea / M_PI));
        } else {
          if (numWarnings < maxWarnings) {
            edm::LogInfo("PFRecoTauDiscriminationAgainstMuon2Container::discriminate")
                << "Jet associated to Tau: Pt = " << pfTau->pt() << ", eta = " << pfTau->eta()
                << ", phi = " << pfTau->phi() << " has area = " << jetArea << " !!";
            ++numWarnings;
          }
          dRmatch = 0.1;
        }
      }
      if (dR < dRmatch) {
        if (verbosity)
          edm::LogPrint("PFTauAgainstMuon2") << " overlaps with tau, dR = " << dR;
        reco::tau::countMatches(*muon, numMatchesDT, numMatchesCSC, numMatchesRPC);
        reco::tau::countHits(*muon, numHitsDT, numHitsCSC, numHitsRPC);
      }
    }
  }
 
  for (int iStation = 0; iStation < 4; ++iStation) {
    if (numMatchesDT[iStation] > 0 && !maskMatchesDT[iStation])
      ++numStationsWithMatches_;
    if (numMatchesCSC[iStation] > 0 && !maskMatchesCSC[iStation])
      ++numStationsWithMatches_;
    if (numMatchesRPC[iStation] > 0 && !maskMatchesRPC[iStation])
      ++numStationsWithMatches_;
  }
 
  for (int iStation = 2; iStation < 4; ++iStation) {
    if (numHitsDT[iStation] > 0 && !maskHitsDT[iStation])
      ++numLast2StationsWithHits_;
    if (numHitsCSC[iStation] > 0 && !maskHitsCSC[iStation])
      ++numLast2StationsWithHits_;
    if (numHitsRPC[iStation] > 0 && !maskHitsRPC[iStation])
      ++numLast2StationsWithHits_;
  }
 
  if (verbosity) {
    edm::LogPrint("PFTauAgainstMuon2") << "numMatchesDT  = " << format_vint(numMatchesDT);
    edm::LogPrint("PFTauAgainstMuon2") << "numMatchesCSC = " << format_vint(numMatchesCSC);
    edm::LogPrint("PFTauAgainstMuon2") << "numMatchesRPC = " << format_vint(numMatchesRPC);
    edm::LogPrint("PFTauAgainstMuon2") << " --> numStationsWithMatches_ = " << numStationsWithMatches_;
    edm::LogPrint("PFTauAgainstMuon2") << "numHitsDT  = " << format_vint(numHitsDT);
    edm::LogPrint("PFTauAgainstMuon2") << "numHitsCSC = " << format_vint(numHitsCSC);
    edm::LogPrint("PFTauAgainstMuon2") << "numHitsRPC = " << format_vint(numHitsRPC);
    edm::LogPrint("PFTauAgainstMuon2") << " --> numLast2StationsWithHits_ = " << numLast2StationsWithHits_;
  }
 
  if (pfLeadChargedHadron_.isNonnull()) {
    energyECALplusHCAL_ = pfLeadChargedHadron_->ecalEnergy() + pfLeadChargedHadron_->hcalEnergy();
    if (verbosity) {
      if (pfLeadChargedHadron_->trackRef().isNonnull()) {
        edm::LogPrint("PFTauAgainstMuon2")
            << "decayMode = " << pfTau->decayMode() << ", energy(ECAL+HCAL) = " << energyECALplusHCAL_
            << ", leadPFChargedHadronP = " << pfLeadChargedHadron_->trackRef()->p();
      } else if (pfLeadChargedHadron_->gsfTrackRef().isNonnull()) {
        edm::LogPrint("PFTauAgainstMuon2")
            << "decayMode = " << pfTau->decayMode() << ", energy(ECAL+HCAL) = " << energyECALplusHCAL_
            << ", leadPFChargedHadronP = " << pfLeadChargedHadron_->gsfTrackRef()->p();
      }
    }
    if (pfLeadChargedHadron_->trackRef().isNonnull())
      leadTrack_ = pfLeadChargedHadron_->trackRef().get();
    else if (pfLeadChargedHadron_->gsfTrackRef().isNonnull())
      leadTrack_ = pfLeadChargedHadron_->gsfTrackRef().get();
  }
}

Member Function Documentation

eval()

bool PFRecoTauDiscriminationAgainstMuon2Helper::eval	(	const PFRecoTauDiscriminationAgainstMuonConfigSet &	config,
		const reco::PFTauRef &	pfTau
	)		const

Definition at line 170 of file PFRecoTauDiscriminationAgainstMuon2Helper.cc.

                                                                                      {
  bool passesCaloMuonVeto = true;
  if (pfLeadChargedHadron_.isNonnull()) {
    if (pfTau->decayMode() == 0 && leadTrack_ && energyECALplusHCAL_ < (config.hop * leadTrack_->p()))
      passesCaloMuonVeto = false;
  }
 
  bool discriminatorValue = false;
  if (config.discriminatorOption == PFRecoTauDiscriminationAgainstMuonConfigSet::kLoose &&
      numStationsWithMatches_ <= config.maxNumberOfMatches)
    discriminatorValue = true;
  else if (config.discriminatorOption == PFRecoTauDiscriminationAgainstMuonConfigSet::kMedium &&
           numStationsWithMatches_ <= config.maxNumberOfMatches &&
           numLast2StationsWithHits_ <= config.maxNumberOfHitsLast2Stations)
    discriminatorValue = true;
  else if (config.discriminatorOption == PFRecoTauDiscriminationAgainstMuonConfigSet::kTight &&
           numStationsWithMatches_ <= config.maxNumberOfMatches &&
           numLast2StationsWithHits_ <= config.maxNumberOfHitsLast2Stations && passesCaloMuonVeto)
    discriminatorValue = true;
  else if (config.discriminatorOption == PFRecoTauDiscriminationAgainstMuonConfigSet::kCustom) {
    discriminatorValue = true;
    if (config.maxNumberOfMatches >= 0 && numStationsWithMatches_ > config.maxNumberOfMatches)
      discriminatorValue = false;
    if (config.maxNumberOfHitsLast2Stations >= 0 && numLast2StationsWithHits_ > config.maxNumberOfHitsLast2Stations)
      discriminatorValue = false;
    if (config.doCaloMuonVeto && !passesCaloMuonVeto)
      discriminatorValue = false;
  }
  return discriminatorValue;
}

References energyECALplusHCAL_, edm::Ptr< T >::isNonnull(), PFRecoTauDiscriminationAgainstMuonConfigSet::kCustom, PFRecoTauDiscriminationAgainstMuonConfigSet::kLoose, PFRecoTauDiscriminationAgainstMuonConfigSet::kMedium, PFRecoTauDiscriminationAgainstMuonConfigSet::kTight, leadTrack_, numLast2StationsWithHits_, numStationsWithMatches_, reco::TrackBase::p(), and pfLeadChargedHadron_.

Member Data Documentation

energyECALplusHCAL_

double PFRecoTauDiscriminationAgainstMuon2Helper::energyECALplusHCAL_

Definition at line 25 of file PFRecoTauDiscriminationAgainstMuon2Helper.h.

Referenced by eval().

leadTrack_

const reco::Track* PFRecoTauDiscriminationAgainstMuon2Helper::leadTrack_ = nullptr

Definition at line 27 of file PFRecoTauDiscriminationAgainstMuon2Helper.h.

Referenced by eval().

numLast2StationsWithHits_

int PFRecoTauDiscriminationAgainstMuon2Helper::numLast2StationsWithHits_ = 0

Definition at line 29 of file PFRecoTauDiscriminationAgainstMuon2Helper.h.

Referenced by eval().

numStationsWithMatches_

int PFRecoTauDiscriminationAgainstMuon2Helper::numStationsWithMatches_ = 0

Definition at line 28 of file PFRecoTauDiscriminationAgainstMuon2Helper.h.

Referenced by eval().

pfLeadChargedHadron_

const reco::PFCandidatePtr& PFRecoTauDiscriminationAgainstMuon2Helper::pfLeadChargedHadron_

Definition at line 26 of file PFRecoTauDiscriminationAgainstMuon2Helper.h.

Referenced by eval().