Inheritance diagram for PFRecoTauDiscriminationAgainstMuon:

Public Member Functions
double	discriminate (const PFTauRef &pfTau)

	PFRecoTauDiscriminationAgainstMuon (const edm::ParameterSet &iConfig)

	~PFRecoTauDiscriminationAgainstMuon ()

Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
virtual void	beginEvent (const edm::Event &evt, const edm::EventSetup &evtSetup)

virtual double	discriminate (const TauRef &tau)=0

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 Attributes
double	a

double	b

double	c

std::string	discriminatorOption_

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)

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_

Detailed Description

Definition at line 20 of file PFRecoTauDiscriminationAgainstMuon.cc.

Constructor & Destructor Documentation

PFRecoTauDiscriminationAgainstMuon::PFRecoTauDiscriminationAgainstMuon ( const edm::ParameterSet & iConfig )

inlineexplicit

Definition at line 22 of file PFRecoTauDiscriminationAgainstMuon.cc.

References a, b, trackerHits::c, and edm::ParameterSet::getParameter().

                                                                                  :PFTauDiscriminationProducerBase(iConfig) {   
          discriminatorOption_  = iConfig.getParameter<std::string>("discriminatorOption");  
          a  = iConfig.getParameter<double>("a");  
          b  = iConfig.getParameter<double>("b");  
          c  = iConfig.getParameter<double>("c");  
       }

PFRecoTauDiscriminationAgainstMuon::~PFRecoTauDiscriminationAgainstMuon ( )

inline

Definition at line 29 of file PFRecoTauDiscriminationAgainstMuon.cc.

29 {}

Member Function Documentation

double PFRecoTauDiscriminationAgainstMuon::discriminate ( const PFTauRef & pfTau )

Definition at line 40 of file PFRecoTauDiscriminationAgainstMuon.cc.

References a, muon::AllArbitrated, b, trackerHits::c, edm::hlt::Exception, muon::isGoodMuon(), muon::segmentCompatibility(), and edm::errors::UnimplementedFeature.

 {
    bool decision = true;
 
    if((*thePFTauRef).hasMuonReference() ){
 
       MuonRef muonref = (*thePFTauRef).leadPFChargedHadrCand()->muonRef();
       if (discriminatorOption_ == "noSegMatch") {
          if ( muonref ->numberOfMatches() > 0 ) {
             decision = false;
          }
       }
       else if (discriminatorOption_ == "twoDCut") {
          double seg = muon::segmentCompatibility(*muonref);
          double calo= muonref->caloCompatibility(); 
          double border = calo * a + seg * b +c;
          if ( border > 0 ) {
             decision = false; 
          } 
       }
       else if (discriminatorOption_ == "merePresence") decision = false;
       else if (discriminatorOption_ == "combined") { // testing purpose only
          unsigned int muType = 0;
          if(muonref->isGlobalMuon()) muType = 1;
          else if(muonref->isCaloMuon()) muType = 2;
          else if(muonref->isTrackerMuon()) muType = 3;
          double muonEnergyFraction = (*thePFTauRef).pfTauTagInfoRef()->pfjetRef()->chargedMuEnergyFraction();
          bool eta_veto = false;
          bool phi_veto = false;
          if(fabs(muonref->eta()) > 2.3 || (fabs(muonref->eta()) > 1.4 && fabs(muonref->eta()) < 1.6)) eta_veto = true;
          if(muonref->phi() < 0.1 && muonref->phi() > -0.1) phi_veto = true;
          if( muType != 1 || muonref ->numberOfMatches() > 0 || eta_veto || phi_veto || muonEnergyFraction > 0.9 ) decision = false; // as place holder
       }
       else if (discriminatorOption_ == "noAllArbitrated") { // One used in H->tautau 2010
     if(muon::isGoodMuon(*muonref,muon::AllArbitrated))
       decision = false;
       }
       else{
          throw edm::Exception(edm::errors::UnimplementedFeature) << " Invalid Discriminator Option! Please check cfi file \n";
       }
    } // valid muon ref
 
    return (decision ? 1. : 0.);
 } 