PFRecoTauDiscriminationAgainstMuon2 Class Reference

Inheritance diagram for PFRecoTauDiscriminationAgainstMuon2:

Public Member Functions
void	beginEvent (const edm::Event &, const edm::EventSetup &)
double	discriminate (const reco::PFTauRef &)
	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 ()
virtual	~EDProducer ()
Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
boost::function< void(const BranchDescription &)>	registrationCallback () const
	used by the fwk to register list of products More...
virtual	~ProducerBase ()

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

Private Attributes
int	discriminatorOption_
bool	doCaloMuonVeto_
double	dRmuonMatch_
double	hop_
int	maxNumberOfHitsLast2Stations_
int	maxNumberOfMatches_
std::string	moduleLabel_
edm::Handle< reco::MuonCollection >	muons_
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
typedef WorkerT< EDProducer >	WorkerType
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::EDProducer
CurrentProcessingContext const *	currentContext () const
Protected Member Functions inherited from edm::ProducerBase
template<class TProducer , class TMethod >
void	callWhenNewProductsRegistered (TProducer *iProd, TMethod iMethod)
Protected Attributes inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
double	prediscriminantFailValue_
edm::InputTag	TauProducer_

Detailed Description

Compute tau Id. discriminator against muons.

Author

Christian Veelken, LLR

Version

Revision:

1.10

Id:

PFRecoTauDiscriminationAgainstMuon2.cc,v 1.10 2013/04/08 11:45:27 jez Exp

Definition at line 31 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Member Enumeration Documentation

anonymous enum

private

Enumerator
kLoose
kMedium
kTight
kCustom

Definition at line 33 of file PFRecoTauDiscriminationAgainstMuon2.cc.

{ kLoose, kMedium, kTight, kCustom };

Constructor & Destructor Documentation

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

inlineexplicit

Definition at line 35 of file PFRecoTauDiscriminationAgainstMuon2.cc.

References discriminatorOption_, doCaloMuonVeto_, dRmuonMatch_, edm::hlt::Exception, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), hop_, kCustom, kLoose, kMedium, kTight, maxNumberOfHitsLast2Stations_, maxNumberOfMatches_, srcMuons_, edm::errors::UnimplementedFeature, and verbosity_.

    : 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");
      dRmuonMatch_ = cfg.getParameter<double>("dRmuonMatch");
    }
    verbosity_ = cfg.exists("verbosity") ? cfg.getParameter<int>("verbosity") : 0;
   }

PFRecoTauDiscriminationAgainstMuon2::~PFRecoTauDiscriminationAgainstMuon2 ( )

inline

Definition at line 56 of file PFRecoTauDiscriminationAgainstMuon2.cc.

{} 

Member Function Documentation

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

virtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 75 of file PFRecoTauDiscriminationAgainstMuon2.cc.

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

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

double PFRecoTauDiscriminationAgainstMuon2::discriminate

(

const reco::PFTauRef &

pfTau

)

Definition at line 117 of file PFRecoTauDiscriminationAgainstMuon2.cc.

References gather_cfg::cout, deltaR(), discriminatorOption_, doCaloMuonVeto_, PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, dRmuonMatch_, edm::Ref< C, T, F >::get(), hop_, edm::Ref< C, T, F >::isNonnull(), kCustom, edm::Ref< C, T, F >::key(), kLoose, kMedium, kTight, edm::InputTag::label(), singlePfTauSkim_cff::leadTrack, maxNumberOfHitsLast2Stations_, maxNumberOfMatches_, moduleLabel_, metsig::muon, muons_, reco::Muon::NoArbitration, patZpeak::numMuons, reco::TrackBase::p(), srcMuons_, and verbosity_.

{
  if ( verbosity_ ) {
    std::cout << "<PFRecoTauDiscriminationAgainstMuon2::discriminate>:" << std::endl;
    std::cout << " moduleLabel = " << moduleLabel_ << std::endl;
    std::cout << "tau #" << pfTau.key() << ": Pt = " << pfTau->pt() << ", eta = " << pfTau->eta() << ", phi = " << pfTau->phi() << std::endl;   
  }

  int numMatches = 0;

  std::vector<int> numHitsDT(4);
  std::vector<int> numHitsCSC(4);
  std::vector<int> numHitsRPC(4);
  for ( int iStation = 0; iStation < 4; ++iStation ) {
    numHitsDT[iStation]  = 0;
    numHitsCSC[iStation] = 0;
    numHitsRPC[iStation] = 0;
  }

  const reco::PFCandidateRef& pfLeadChargedHadron = pfTau->leadPFChargedHadrCand();
  if ( pfLeadChargedHadron.isNonnull() ) {
    reco::MuonRef muonRef = pfLeadChargedHadron->muonRef();      
    if ( muonRef.isNonnull() ) {
      if ( verbosity_ ) std::cout << " has muonRef." << std::endl;
      numMatches = muonRef->numberOfMatches(reco::Muon::NoArbitration);
      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_ ) std::cout << "muon #" << muon.key() << ": Pt = " << muon->pt() << ", eta = " << muon->eta() << ", phi = " << muon->phi() << std::endl;
      if ( pfLeadChargedHadron.isNonnull() && pfLeadChargedHadron->muonRef().isNonnull() && muon == pfLeadChargedHadron->muonRef() ) {  
    if ( verbosity_ ) std::cout << " matches muonRef of tau --> skipping it." << std::endl;
    continue;
      }
      double dR = deltaR(muon->p4(), pfTau->p4());
      if ( dR < dRmuonMatch_ ) {
    if ( verbosity_ ) std::cout << " overlaps with tau, dR = " << dR << std::endl;
    numMatches += muon->numberOfMatches(reco::Muon::NoArbitration);
    countHits(*muon, numHitsDT, numHitsCSC, numHitsRPC);
      }
    }
  }

  if ( verbosity_ ) {
    std::cout << "numMatches = " << numMatches << std::endl;
    std::cout << "numHitsDT  = " << format_vint(numHitsDT)  << std::endl;
    std::cout << "numHitsCSC = " << format_vint(numHitsCSC) << std::endl;
    std::cout << "numHitsRPC = " << format_vint(numHitsRPC) << std::endl;
  }
  
  int numLast2StationsWithHits = 0;
  for ( int iStation = 2; iStation < 4; ++iStation ) {
    if ( numHitsDT[iStation]  > 0 ) ++numLast2StationsWithHits;
    if ( numHitsCSC[iStation] > 0 ) ++numLast2StationsWithHits;
    if ( numHitsRPC[iStation] > 0 ) ++numLast2StationsWithHits;
  }


  bool passesCaloMuonVeto = true;
  if ( pfLeadChargedHadron.isNonnull() ) {
    double energyECALplusHCAL = pfLeadChargedHadron->ecalEnergy() + pfLeadChargedHadron->hcalEnergy();    
    if ( verbosity_ ) {
      if ( pfLeadChargedHadron->trackRef().isNonnull() ) std::cout << "decayMode = " << pfTau->decayMode() << ", energy(ECAL+HCAL) = " << energyECALplusHCAL << ", leadPFChargedHadronP = " << pfLeadChargedHadron->trackRef()->p() << std::endl;
      else if ( pfLeadChargedHadron->gsfTrackRef().isNonnull() ) 
std::cout << "decayMode = " << pfTau->decayMode() << ", energy(ECAL+HCAL) = " << energyECALplusHCAL << ", leadPFChargedHadronP = " << pfLeadChargedHadron->gsfTrackRef()->p() << std::endl;

    }
    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  && numMatches <= maxNumberOfMatches_                                                                                    ) discriminatorValue = 1.;
  else if ( discriminatorOption_ == kMedium && numMatches <= maxNumberOfMatches_ && numLast2StationsWithHits <= maxNumberOfHitsLast2Stations_                       ) discriminatorValue = 1.;
  else if ( discriminatorOption_ == kTight  && numMatches <= maxNumberOfMatches_ && numLast2StationsWithHits <= maxNumberOfHitsLast2Stations_ && passesCaloMuonVeto ) discriminatorValue = 1.;
  else if ( discriminatorOption_ == kCustom ) {
    bool pass = true;
    if ( maxNumberOfMatches_ >= 0 && numMatches > maxNumberOfMatches_ ) pass = false;
    if ( maxNumberOfHitsLast2Stations_ >= 0 && numLast2StationsWithHits > maxNumberOfHitsLast2Stations_ ) pass = false;
    if ( doCaloMuonVeto_ && !passesCaloMuonVeto ) pass = false;
    discriminatorValue = pass ? 1.: 0.;
  }
  if ( verbosity_ ) std::cout << "--> returning discriminatorValue = " << discriminatorValue << std::endl;

  return discriminatorValue;
} 

Member Data Documentation

int PFRecoTauDiscriminationAgainstMuon2::discriminatorOption_

private

Definition at line 64 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

bool PFRecoTauDiscriminationAgainstMuon2::doCaloMuonVeto_

private

Definition at line 67 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

double PFRecoTauDiscriminationAgainstMuon2::dRmuonMatch_

private

Definition at line 71 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

double PFRecoTauDiscriminationAgainstMuon2::hop_

private

Definition at line 65 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

int PFRecoTauDiscriminationAgainstMuon2::maxNumberOfHitsLast2Stations_

private

Definition at line 68 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

int PFRecoTauDiscriminationAgainstMuon2::maxNumberOfMatches_

private

Definition at line 66 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().

std::string PFRecoTauDiscriminationAgainstMuon2::moduleLabel_

private

Definition at line 63 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 70 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by beginEvent(), and discriminate().

edm::InputTag PFRecoTauDiscriminationAgainstMuon2::srcMuons_

private

Definition at line 69 of file PFRecoTauDiscriminationAgainstMuon2.cc.

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

int PFRecoTauDiscriminationAgainstMuon2::verbosity_

private

Definition at line 72 of file PFRecoTauDiscriminationAgainstMuon2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationAgainstMuon2().