Inheritance diagram for PFRecoTauDiscriminationAgainstMuon:

Public Member Functions
double	discriminate (const PFTauRef &pfTau) const override

	PFRecoTauDiscriminationAgainstMuon (const edm::ParameterSet &iConfig)

	~PFRecoTauDiscriminationAgainstMuon () override

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

virtual double	discriminate (const TauRef &tau) const =0

virtual void	endEvent (edm::Event &)

void	produce (edm::Event &, const edm::EventSetup &) override

	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)

	TauDiscriminationProducerBase ()

	~TauDiscriminationProducerBase () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
static void	fillProducerDescriptions (edm::ParameterSetDescription &desc)

Private Attributes
double	a

double	b

double	c

bool	checkNumMatches_

std::string	discriminatorOption_

double	hop_

int	maxNumberOfMatches_

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::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Protected Attributes inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
std::string	moduleLabel_

double	prediscriminantFailValue_

edm::EDGetTokenT< TauCollection >	Tau_token

size_t	tauIndex_

edm::InputTag	TauProducer_

Detailed Description

Definition at line 21 of file PFRecoTauDiscriminationAgainstMuon.cc.

Constructor & Destructor Documentation

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

inlineexplicit

Definition at line 23 of file PFRecoTauDiscriminationAgainstMuon.cc.

References a, b, HltBtagPostValidation_cff::c, edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

       : PFTauDiscriminationProducerBase(iConfig) {
     discriminatorOption_ = iConfig.getParameter<std::string>("discriminatorOption");
     hop_ = iConfig.getParameter<double>("HoPMin");
     a = iConfig.getParameter<double>("a");
     b = iConfig.getParameter<double>("b");
     c = iConfig.getParameter<double>("c");
     maxNumberOfMatches_ = iConfig.getParameter<int>("maxNumberOfMatches");
     checkNumMatches_ = iConfig.getParameter<bool>("checkNumMatches");
   }

PFRecoTauDiscriminationAgainstMuon::~PFRecoTauDiscriminationAgainstMuon ( )

inlineoverride

Definition at line 34 of file PFRecoTauDiscriminationAgainstMuon.cc.

References fillDescriptions().

34 {}

Member Function Documentation

double PFRecoTauDiscriminationAgainstMuon::discriminate ( const PFTauRef & pfTau ) const

override

Definition at line 50 of file PFRecoTauDiscriminationAgainstMuon.cc.

References a, muon::AllArbitrated, b, HltBtagPostValidation_cff::c, reco::PFJet::chargedMuEnergyFraction(), Exception, edm::Ref< C, T, F >::get(), muon::isGoodMuon(), edm::Ref< C, T, F >::isNonnull(), reco::btau::muonEnergyFraction, muon::segmentCompatibility(), and edm::errors::UnimplementedFeature.

                                                                                          {
   bool decision = true;
 
   if (thePFTauRef->hasMuonReference()) {
     MuonRef muonref = thePFTauRef->leadPFChargedHadrCand()->muonRef();
     if (discriminatorOption_ == "noSegMatch") {
       if (muonref->numberOfMatches() > maxNumberOfMatches_)
         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;
       float muonEnergyFraction = 0.;
       const reco::PFJet* pfJetPtr = dynamic_cast<const reco::PFJet*>(thePFTauRef->pfTauTagInfoRef()->pfjetRef().get());
       if (pfJetPtr) {
         muonEnergyFraction = pfJetPtr->chargedMuEnergyFraction();
       } else
         throw cms::Exception("Type Mismatch") << "The PFTau was not made from PFJets, and this outdated algorithm was "
                                                  "not updated to cope with PFTaus made from other Jets.\n";
       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" || discriminatorOption_ == "noAllArbitratedWithHOP") {
       if (checkNumMatches_ && muonref->numberOfMatches() > maxNumberOfMatches_)
         decision = false;
       if (muon::isGoodMuon(*muonref, muon::AllArbitrated))
         decision = false;
     } else if (discriminatorOption_ == "HOP") {
       decision = true;  // only calo. muon cut requested: keep all tau candidates, regardless of signals in muon system
     } else {
       throw edm::Exception(edm::errors::UnimplementedFeature)
           << " Invalid Discriminator option = " << discriminatorOption_ << " --> please check cfi file !!\n";
     }
   }  // valid muon ref
 
   // Additional calo. muon cut: veto one prongs compatible with MIP signature
   if (discriminatorOption_ == "HOP" || discriminatorOption_ == "noAllArbitratedWithHOP") {
     if (thePFTauRef->leadPFChargedHadrCand().isNonnull()) {
       double muonCaloEn =
           thePFTauRef->leadPFChargedHadrCand()->hcalEnergy() + thePFTauRef->leadPFChargedHadrCand()->ecalEnergy();
       if (thePFTauRef->decayMode() == 0 && muonCaloEn < (hop_ * thePFTauRef->leadPFChargedHadrCand()->p()))
         decision = false;
     }
   }
 
   return (decision ? 1. : 0.);
 }

void PFRecoTauDiscriminationAgainstMuon::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 115 of file PFRecoTauDiscriminationAgainstMuon.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), DEFINE_FWK_MODULE, HLT_2018_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                     {
   // pfRecoTauDiscriminationAgainstMuon
   edm::ParameterSetDescription desc;
   desc.add<double>("a", 0.5);
   desc.add<double>("c", 0.0);
   desc.add<double>("b", 0.5);
   desc.add<edm::InputTag>("PFTauProducer", edm::InputTag("pfRecoTauProducer"));
   {
     edm::ParameterSetDescription psd0;
     psd0.add<std::string>("BooleanOperator", "and");
     {
       edm::ParameterSetDescription psd1;
       psd1.add<double>("cut");
       psd1.add<edm::InputTag>("Producer");
       psd0.addOptional<edm::ParameterSetDescription>("leadTrack", psd1);
     }
     desc.add<edm::ParameterSetDescription>("Prediscriminants", psd0);
   }
   desc.add<std::string>("discriminatorOption", "noSegMatch");
   desc.add<double>("HoPMin", 0.2);
   desc.add<int>("maxNumberOfMatches", 0);
   desc.add<bool>("checkNumMatches", false);
   descriptions.add("pfRecoTauDiscriminationAgainstMuon", desc);
 }