PFRecoTauDiscriminationAgainstMuon2 Class Reference

Inheritance diagram for PFRecoTauDiscriminationAgainstMuon2:

Public Member Functions
void	beginEvent (const edm::Event &, const edm::EventSetup &) override
double	discriminate (const reco::PFTauRef &) override
	PFRecoTauDiscriminationAgainstMuon2 (const edm::ParameterSet &cfg)
	~PFRecoTauDiscriminationAgainstMuon2 ()
Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
virtual double	discriminate (const TauRef &tau)=0
virtual void	endEvent (edm::Event &evt)
void	produce (edm::Event &, const edm::EventSetup &)
	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)
	TauDiscriminationProducerBase ()
virtual	~TauDiscriminationProducerBase ()
Public Member Functions inherited from edm::EDProducer
	EDProducer ()
ModuleDescription const &	moduleDescription () const
virtual	~EDProducer ()
Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
virtual	~ProducerBase ()
Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()
ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

Private Types
enum	{ kLoose, kMedium, kTight, kCustom }

Private Attributes
int	discriminatorOption_
bool	doCaloMuonVeto_
double	dRmuonMatch_
bool	dRmuonMatchLimitedToJetArea_
double	hop_
std::vector< int >	maskHitsCSC_
std::vector< int >	maskHitsDT_
std::vector< int >	maskHitsRPC_
std::vector< int >	maskMatchesCSC_
std::vector< int >	maskMatchesDT_
std::vector< int >	maskMatchesRPC_
int	maxNumberOfHitsLast2Stations_
int	maxNumberOfMatches_
int	maxWarnings_
double	minPtMatchedMuon_
std::string	moduleLabel_
edm::Handle< reco::MuonCollection >	muons_
edm::EDGetTokenT < reco::MuonCollection >	Muons_token
int	numWarnings_
edm::InputTag	srcMuons_
int	verbosity_

Additional Inherited Members
Public Types inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
typedef std::vector< TauType >	TauCollection
typedef edm::Ref< TauCollection >	TauRef
typedef edm::RefProd < TauCollection >	TauRefProd
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType
Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
Protected Attributes inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
std::string	moduleLabel_
double	prediscriminantFailValue_
edm::EDGetTokenT< TauCollection >	Tau_token
edm::InputTag	TauProducer_

Detailed Description

Compute tau Id. discriminator against muons.

Author

Christian Veelken, LLR

Definition at line 28 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Member Enumeration Documentation

anonymous enum

private

Enumerator
kLoose
kMedium
kTight
kCustom

Definition at line 30 of file PFRecoTauDiscriminationAgainstMuon2.cc.

{ kLoose, kMedium, kTight, kCustom };

Constructor & Destructor Documentation

PFRecoTauDiscriminationAgainstMuon2::PFRecoTauDiscriminationAgainstMuon2 ( const edm::ParameterSet &  cfg )

inlineexplicit

Definition at line 32 of file PFRecoTauDiscriminationAgainstMuon2.cc.

References discriminatorOption_, doCaloMuonVeto_, dRmuonMatch_, dRmuonMatchLimitedToJetArea_, edm::hlt::Exception, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), hop_, kCustom, kLoose, kMedium, kTight, maskHitsCSC_, maskHitsDT_, maskHitsRPC_, maskMatchesCSC_, maskMatchesDT_, maskMatchesRPC_, maxNumberOfHitsLast2Stations_, maxNumberOfMatches_, maxWarnings_, minPtMatchedMuon_, Muons_token, numWarnings_, srcMuons_, AlCaHLTBitMon_QueryRunRegistry::string, edm::errors::UnimplementedFeature, verbosity_, and vint.

    : PFTauDiscriminationProducerBase(cfg),
      moduleLabel_(cfg.getParameter<std::string>("@module_label"))
  {   
    std::string discriminatorOption_string  = cfg.getParameter<std::string>("discriminatorOption");  
    if      ( discriminatorOption_string == "loose"  ) discriminatorOption_ = kLoose;
    else if ( discriminatorOption_string == "medium" ) discriminatorOption_ = kMedium;
    else if ( discriminatorOption_string == "tight"  ) discriminatorOption_ = kTight;
    else if ( discriminatorOption_string == "custom" ) discriminatorOption_ = kCustom;
    else throw edm::Exception(edm::errors::UnimplementedFeature) 
      << " Invalid Configuration parameter 'discriminatorOption' = " << discriminatorOption_string << " !!\n";
    hop_ = cfg.getParameter<double>("HoPMin"); 
    maxNumberOfMatches_ = cfg.exists("maxNumberOfMatches") ? cfg.getParameter<int>("maxNumberOfMatches"): 0;
    doCaloMuonVeto_ = cfg.exists("doCaloMuonVeto") ? cfg.getParameter<bool>("doCaloMuonVeto"): false;
    maxNumberOfHitsLast2Stations_ = cfg.exists("maxNumberOfHitsLast2Stations") ? cfg.getParameter<int>("maxNumberOfHitsLast2Stations"): 0;
    if ( cfg.exists("srcMuons") ) {
      srcMuons_ = cfg.getParameter<edm::InputTag>("srcMuons");
      Muons_token = consumes<reco::MuonCollection>(srcMuons_);
      dRmuonMatch_ = cfg.getParameter<double>("dRmuonMatch");
      dRmuonMatchLimitedToJetArea_ = cfg.getParameter<bool>("dRmuonMatchLimitedToJetArea");
      minPtMatchedMuon_ = cfg.getParameter<double>("minPtMatchedMuon");
    }
    typedef std::vector<int> vint;
    maskMatchesDT_  = cfg.getParameter<vint>("maskMatchesDT");
    maskMatchesCSC_ = cfg.getParameter<vint>("maskMatchesCSC");
    maskMatchesRPC_ = cfg.getParameter<vint>("maskMatchesRPC");
    maskHitsDT_     = cfg.getParameter<vint>("maskHitsDT");
    maskHitsCSC_    = cfg.getParameter<vint>("maskHitsCSC");
    maskHitsRPC_    = cfg.getParameter<vint>("maskHitsRPC");
    numWarnings_ = 0;
    maxWarnings_ = 3;
    verbosity_ = cfg.exists("verbosity") ? cfg.getParameter<int>("verbosity") : 0;
   }

PFRecoTauDiscriminationAgainstMuon2::~PFRecoTauDiscriminationAgainstMuon2 ( )

inline

Definition at line 65 of file PFRecoTauDiscriminationAgainstMuon2.cc.

{} 

Member Function Documentation

void PFRecoTauDiscriminationAgainstMuon2::beginEvent ( const edm::Event &  evt, const edm::EventSetup &  es  )

overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 95 of file PFRecoTauDiscriminationAgainstMuon2.cc.

References edm::Event::getByToken(), edm::InputTag::label(), muons_, Muons_token, and srcMuons_.

{
  if ( srcMuons_.label() != "" ) {
    evt.getByToken(Muons_token, muons_);
  }
}

double PFRecoTauDiscriminationAgainstMuon2::discriminate ( const reco::PFTauRef &  pfTau )

override

Definition at line 152 of file PFRecoTauDiscriminationAgainstMuon2.cc.

References deltaR(), discriminatorOption_, doCaloMuonVeto_, PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, dRmuonMatch_, dRmuonMatchLimitedToJetArea_, edm::Ptr< T >::get(), hop_, edm::Ptr< T >::isNonnull(), edm::Ref< C, T, F >::isNonnull(), kCustom, edm::Ref< C, T, F >::key(), kLoose, kMedium, kTight, edm::InputTag::label(), singlePfTauSkim_cff::leadTrack, maskHitsCSC_, maskHitsDT_, maskHitsRPC_, maskMatchesCSC_, maskMatchesDT_, maskMatchesRPC_, maxNumberOfHitsLast2Stations_, maxNumberOfMatches_, maxWarnings_, Min(), minPtMatchedMuon_, moduleLabel_, metsig::muon, muons_, patZpeak::numMuons, numWarnings_, reco::TrackBase::p(), Pi, srcMuons_, and verbosity_.

{
  if ( verbosity_ ) {
    edm::LogPrint("PFTauAgainstMuon2") << "<PFRecoTauDiscriminationAgainstMuon2::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;
  } 

  const reco::PFCandidatePtr& pfLeadChargedHadron = pfTau->leadPFChargedHadrCand();
  if ( pfLeadChargedHadron.isNonnull() ) {
    reco::MuonRef muonRef = pfLeadChargedHadron->muonRef();      
    if ( muonRef.isNonnull() ) {
      if ( verbosity_ ) edm::LogPrint("PFTauAgainstMuon2") << " has muonRef." ;
      countMatches(*muonRef, numMatchesDT, numMatchesCSC, numMatchesRPC);
      countHits(*muonRef, numHitsDT, numHitsCSC, numHitsRPC);
    }
  }
  
  if ( srcMuons_.label() != "" ) {
    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() && pfLeadChargedHadron->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 = TMath::Min(dRmatch, TMath::Sqrt(jetArea/TMath::Pi()));
    } else {
      if ( numWarnings_ < maxWarnings_ ) {
        edm::LogWarning("PFRecoTauDiscriminationAgainstMuon2::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 ;
    countMatches(*muon, numMatchesDT, numMatchesCSC, numMatchesRPC);
    countHits(*muon, numHitsDT, numHitsCSC, numHitsRPC);
      }
    }
  }

  int numStationsWithMatches = 0;
  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;
  }

  int numLast2StationsWithHits = 0;
  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 ;
  }
  
  bool passesCaloMuonVeto = true;
  if ( pfLeadChargedHadron.isNonnull() ) {
    double 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() ;
      }
    }
    const reco::Track* leadTrack = 0;
    if ( pfLeadChargedHadron->trackRef().isNonnull() ) leadTrack = pfLeadChargedHadron->trackRef().get();
    else if ( pfLeadChargedHadron->gsfTrackRef().isNonnull() ) leadTrack = pfLeadChargedHadron->gsfTrackRef().get();
    if ( pfTau->decayMode() == 0 && leadTrack && energyECALplusHCAL < (hop_*leadTrack->p()) ) passesCaloMuonVeto = false;
  }
  
  double discriminatorValue = 0.;
  if      ( discriminatorOption_ == kLoose  && numStationsWithMatches <= maxNumberOfMatches_                                                                                    ) discriminatorValue = 1.;
  else if ( discriminatorOption_ == kMedium && numStationsWithMatches <= maxNumberOfMatches_ && numLast2StationsWithHits <= maxNumberOfHitsLast2Stations_                       ) discriminatorValue = 1.;
  else if ( discriminatorOption_ == kTight  && numStationsWithMatches <= maxNumberOfMatches_ && numLast2StationsWithHits <= maxNumberOfHitsLast2Stations_ && passesCaloMuonVeto ) discriminatorValue = 1.;
  else if ( discriminatorOption_ == kCustom ) {
    bool pass = true;
    if ( maxNumberOfMatches_ >= 0 && numStationsWithMatches > maxNumberOfMatches_ ) pass = false;
    if ( maxNumberOfHitsLast2Stations_ >= 0 && numLast2StationsWithHits > maxNumberOfHitsLast2Stations_ ) pass = false;
    if ( doCaloMuonVeto_ && !passesCaloMuonVeto ) pass = false;
    discriminatorValue = pass ? 1.: 0.;
  }
  if ( verbosity_ ) edm::LogPrint("PFTauAgainstMuon2") << "--> returning discriminatorValue = " << discriminatorValue ;

  return discriminatorValue;
} 

Member Data Documentation

int PFRecoTauDiscriminationAgainstMuon2::discriminatorOption_

private

Definition at line 73 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

bool PFRecoTauDiscriminationAgainstMuon2::doCaloMuonVeto_

private

Definition at line 76 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

double PFRecoTauDiscriminationAgainstMuon2::dRmuonMatch_

private

Definition at line 81 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

bool PFRecoTauDiscriminationAgainstMuon2::dRmuonMatchLimitedToJetArea_

private

Definition at line 82 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

double PFRecoTauDiscriminationAgainstMuon2::hop_

private

Definition at line 74 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

std::vector<int> PFRecoTauDiscriminationAgainstMuon2::maskHitsCSC_

private

Definition at line 88 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

std::vector<int> PFRecoTauDiscriminationAgainstMuon2::maskHitsDT_

private

Definition at line 87 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

std::vector<int> PFRecoTauDiscriminationAgainstMuon2::maskHitsRPC_

private

Definition at line 89 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

std::vector<int> PFRecoTauDiscriminationAgainstMuon2::maskMatchesCSC_

private

Definition at line 85 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

std::vector<int> PFRecoTauDiscriminationAgainstMuon2::maskMatchesDT_

private

Definition at line 84 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

std::vector<int> PFRecoTauDiscriminationAgainstMuon2::maskMatchesRPC_

private

Definition at line 86 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

int PFRecoTauDiscriminationAgainstMuon2::maxNumberOfHitsLast2Stations_

private

Definition at line 77 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

int PFRecoTauDiscriminationAgainstMuon2::maxNumberOfMatches_

private

Definition at line 75 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

int PFRecoTauDiscriminationAgainstMuon2::maxWarnings_

private

Definition at line 91 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

double PFRecoTauDiscriminationAgainstMuon2::minPtMatchedMuon_

private

Definition at line 83 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

std::string PFRecoTauDiscriminationAgainstMuon2::moduleLabel_

private

Definition at line 72 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), Mixins._TypedParameterizable::insertInto(), Modules.ESSource::nameInProcessDesc_(), and Modules.ESProducer::nameInProcessDesc_().

edm::Handle<reco::MuonCollection> PFRecoTauDiscriminationAgainstMuon2::muons_

private

Definition at line 79 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by beginEvent(), and discriminate().

edm::EDGetTokenT<reco::MuonCollection> PFRecoTauDiscriminationAgainstMuon2::Muons_token

private

Definition at line 80 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by beginEvent(), and PFRecoTauDiscriminationAgainstMuon2().

int PFRecoTauDiscriminationAgainstMuon2::numWarnings_

mutableprivate

Definition at line 90 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

edm::InputTag PFRecoTauDiscriminationAgainstMuon2::srcMuons_

private

Definition at line 78 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by beginEvent(), discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

int PFRecoTauDiscriminationAgainstMuon2::verbosity_

private

Definition at line 92 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().