PFRecoTauDiscriminationAgainstMuon Class Reference

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, TauDiscriminatorDataType, ConsumeType >
virtual void	beginEvent (const edm::Event &, const edm::EventSetup &)
virtual TauDiscriminatorDataType	discriminate (const TauRef &tau) const =0
virtual void	endEvent (edm::Event &)
void	produce (edm::Event &, const edm::EventSetup &) override
	TauDiscriminationProducerBase ()
	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)
	~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, TauDiscriminatorDataType, ConsumeType >
static void	fillProducerDescriptions (edm::ParameterSetDescription &desc)
static std::string	getTauTypeString ()
	helper method to retrieve tau type name, e.g. to build correct cfi getter More...

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, TauDiscriminatorDataType, ConsumeType >
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, TauDiscriminatorDataType, ConsumeType >
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::PFRecoTauDiscriminationAgainstMuon ( const edm::ParameterSet &  iConfig )

inlineexplicit

Definition at line 23 of file PFRecoTauDiscriminationAgainstMuon.cc.

      : 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");
  }

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

~PFRecoTauDiscriminationAgainstMuon()

PFRecoTauDiscriminationAgainstMuon::~PFRecoTauDiscriminationAgainstMuon ( )

inlineoverride

Definition at line 34 of file PFRecoTauDiscriminationAgainstMuon.cc.

{}

Member Function Documentation

discriminate()

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

override

Definition at line 50 of file PFRecoTauDiscriminationAgainstMuon.cc.

                                                                                         {
  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.);
}

References a, muon::AllArbitrated, b, HltBtagPostValidation_cff::c, L1TowerCalibrationProducer_cfi::calo, 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.

fillDescriptions()

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

static

Definition at line 115 of file PFRecoTauDiscriminationAgainstMuon.cc.

                                                                                                    {
  // 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);
}

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

Member Data Documentation

a

double PFRecoTauDiscriminationAgainstMuon::a

private

Definition at line 43 of file PFRecoTauDiscriminationAgainstMuon.cc.

b

double PFRecoTauDiscriminationAgainstMuon::b

private

Definition at line 44 of file PFRecoTauDiscriminationAgainstMuon.cc.

c

double PFRecoTauDiscriminationAgainstMuon::c

private

Definition at line 45 of file PFRecoTauDiscriminationAgainstMuon.cc.

checkNumMatches_

bool PFRecoTauDiscriminationAgainstMuon::checkNumMatches_

private

Definition at line 47 of file PFRecoTauDiscriminationAgainstMuon.cc.

discriminatorOption_

std::string PFRecoTauDiscriminationAgainstMuon::discriminatorOption_

private

Definition at line 41 of file PFRecoTauDiscriminationAgainstMuon.cc.

hop_

double PFRecoTauDiscriminationAgainstMuon::hop_

private

Definition at line 42 of file PFRecoTauDiscriminationAgainstMuon.cc.

maxNumberOfMatches_

int PFRecoTauDiscriminationAgainstMuon::maxNumberOfMatches_

private

Definition at line 46 of file PFRecoTauDiscriminationAgainstMuon.cc.