Inheritance diagram for PFRecoTauDiscriminationAgainstElectron2:

Public Member Functions
void	beginEvent (const edm::Event &, const edm::EventSetup &) override

double	discriminate (const PFTauRef &) const override

	PFRecoTauDiscriminationAgainstElectron2 (const edm::ParameterSet &iConfig)

	~PFRecoTauDiscriminationAgainstElectron2 () override

Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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 Member Functions
bool	isInEcalCrack (double) const

Private Attributes
bool	applyCut_GammaEnFrac_

bool	applyCut_GammaEtaMom_

bool	applyCut_GammaPhiMom_

bool	applyCut_hcal3x3OverPLead_

bool	applyCut_HLTSpecific_

bool	applyCut_leadPFChargedHadrEoP_

AntiElectronIDCut2 *	cuts2_

std::vector< pdouble >	etaCracks_

std::vector< std::string >	etaCracks_string_

double	GammaEnFrac_barrel_max_

double	GammaEnFrac_endcap_max_

double	GammaEtaMom_barrel_max_

double	GammaEtaMom_endcap_max_

double	GammaPhiMom_barrel_max_

double	GammaPhiMom_endcap_max_

double	Hcal3x3OverPLead_barrel_max_

double	Hcal3x3OverPLead_endcap_max_

bool	keepTausInEcalCrack_

double	LeadPFChargedHadrEoP_barrel_max_

double	LeadPFChargedHadrEoP_barrel_min_

double	LeadPFChargedHadrEoP_endcap_max1_

double	LeadPFChargedHadrEoP_endcap_max2_

double	LeadPFChargedHadrEoP_endcap_min1_

double	LeadPFChargedHadrEoP_endcap_min2_

bool	rejectTausInEcalCrack_

int	verbosity_

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<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::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 33 of file PFRecoTauDiscriminationAgainstElectron2.cc.

Constructor & Destructor Documentation

◆ PFRecoTauDiscriminationAgainstElectron2()

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

inlineexplicit

Definition at line 35 of file PFRecoTauDiscriminationAgainstElectron2.cc.

       : PFTauDiscriminationProducerBase(iConfig) {
     LeadPFChargedHadrEoP_barrel_min_ = iConfig.getParameter<double>("LeadPFChargedHadrEoP_barrel_min");
     LeadPFChargedHadrEoP_barrel_max_ = iConfig.getParameter<double>("LeadPFChargedHadrEoP_barrel_max");
     Hcal3x3OverPLead_barrel_max_ = iConfig.getParameter<double>("Hcal3x3OverPLead_barrel_max");
     GammaEtaMom_barrel_max_ = iConfig.getParameter<double>("GammaEtaMom_barrel_max");
     GammaPhiMom_barrel_max_ = iConfig.getParameter<double>("GammaPhiMom_barrel_max");
     GammaEnFrac_barrel_max_ = iConfig.getParameter<double>("GammaEnFrac_barrel_max");
     LeadPFChargedHadrEoP_endcap_min1_ = iConfig.getParameter<double>("LeadPFChargedHadrEoP_endcap_min1");
     LeadPFChargedHadrEoP_endcap_max1_ = iConfig.getParameter<double>("LeadPFChargedHadrEoP_endcap_max1");
     LeadPFChargedHadrEoP_endcap_min2_ = iConfig.getParameter<double>("LeadPFChargedHadrEoP_endcap_min2");
     LeadPFChargedHadrEoP_endcap_max2_ = iConfig.getParameter<double>("LeadPFChargedHadrEoP_endcap_max2");
     Hcal3x3OverPLead_endcap_max_ = iConfig.getParameter<double>("Hcal3x3OverPLead_endcap_max");
     GammaEtaMom_endcap_max_ = iConfig.getParameter<double>("GammaEtaMom_endcap_max");
     GammaPhiMom_endcap_max_ = iConfig.getParameter<double>("GammaPhiMom_endcap_max");
     GammaEnFrac_endcap_max_ = iConfig.getParameter<double>("GammaEnFrac_endcap_max");
     keepTausInEcalCrack_ = iConfig.getParameter<bool>("keepTausInEcalCrack");
     rejectTausInEcalCrack_ = iConfig.getParameter<bool>("rejectTausInEcalCrack");
  
     applyCut_hcal3x3OverPLead_ = iConfig.getParameter<bool>("applyCut_hcal3x3OverPLead");
     applyCut_leadPFChargedHadrEoP_ = iConfig.getParameter<bool>("applyCut_leadPFChargedHadrEoP");
     applyCut_GammaEtaMom_ = iConfig.getParameter<bool>("applyCut_GammaEtaMom");
     applyCut_GammaPhiMom_ = iConfig.getParameter<bool>("applyCut_GammaPhiMom");
     applyCut_GammaEnFrac_ = iConfig.getParameter<bool>("applyCut_GammaEnFrac");
     applyCut_HLTSpecific_ = iConfig.getParameter<bool>("applyCut_HLTSpecific");
  
     etaCracks_string_ = iConfig.getParameter<std::vector<std::string>>("etaCracks");
  
     verbosity_ = iConfig.getParameter<int>("verbosity");
  
     cuts2_ = new AntiElectronIDCut2();
   }

References edm::ParameterSet::getParameter().

◆ ~PFRecoTauDiscriminationAgainstElectron2()

PFRecoTauDiscriminationAgainstElectron2::~PFRecoTauDiscriminationAgainstElectron2 ( )

inlineoverride

Definition at line 72 of file PFRecoTauDiscriminationAgainstElectron2.cc.

72 {}

Member Function Documentation

◆ beginEvent()

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

overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >.

Definition at line 111 of file PFRecoTauDiscriminationAgainstElectron2.cc.

                                                                                                      {
   cuts2_->SetBarrelCutValues(LeadPFChargedHadrEoP_barrel_min_,
                              LeadPFChargedHadrEoP_barrel_max_,
                              Hcal3x3OverPLead_barrel_max_,
                              GammaEtaMom_barrel_max_,
                              GammaPhiMom_barrel_max_,
                              GammaEnFrac_barrel_max_);
  
   cuts2_->SetEndcapCutValues(LeadPFChargedHadrEoP_endcap_min1_,
                              LeadPFChargedHadrEoP_endcap_max1_,
                              LeadPFChargedHadrEoP_endcap_min2_,
                              LeadPFChargedHadrEoP_endcap_max2_,
                              Hcal3x3OverPLead_endcap_max_,
                              GammaEtaMom_endcap_max_,
                              GammaPhiMom_endcap_max_,
                              GammaEnFrac_endcap_max_);
  
   cuts2_->ApplyCut_EcalCrack(keepTausInEcalCrack_, rejectTausInEcalCrack_);
  
   cuts2_->ApplyCuts(applyCut_hcal3x3OverPLead_,
                     applyCut_leadPFChargedHadrEoP_,
                     applyCut_GammaEtaMom_,
                     applyCut_GammaPhiMom_,
                     applyCut_GammaEnFrac_,
                     applyCut_HLTSpecific_);
   //Ecal cracks in eta
   etaCracks_.clear();
   TPRegexp regexpParser_range("([0-9.e+/-]+):([0-9.e+/-]+)");
   for (std::vector<std::string>::const_iterator etaCrack = etaCracks_string_.begin();
        etaCrack != etaCracks_string_.end();
        ++etaCrack) {
     TObjArray* subStrings = regexpParser_range.MatchS(etaCrack->data());
     if (subStrings->GetEntries() == 3) {
       //std::cout << "substrings(1) = " << ((TObjString*)subStrings->At(1))->GetString() << std::endl;
       double range_begin = ((TObjString*)subStrings->At(1))->GetString().Atof();
       //std::cout << "substrings(2) = " << ((TObjString*)subStrings->At(2))->GetString() << std::endl;
       double range_end = ((TObjString*)subStrings->At(2))->GetString().Atof();
       etaCracks_.push_back(pdouble(range_begin, range_end));
     }
   }
  
   cuts2_->SetEcalCracks(etaCracks_);
 }

◆ discriminate()

double PFRecoTauDiscriminationAgainstElectron2::discriminate ( const PFTauRef & thePFTauRef ) const

override

Definition at line 155 of file PFRecoTauDiscriminationAgainstElectron2.cc.

                                                                                               {
   double discriminator = 0.;
  
   // ensure tau has at least one charged object
  
   if ((*thePFTauRef).leadChargedHadrCand().isNull()) {
     return 0.;
   } else {
     discriminator = cuts2_->Discriminator(*thePFTauRef);
   }
  
   if (verbosity_) {
     std::cout << " Taus : " << TauProducer_ << std::endl;
     std::cout << "<PFRecoTauDiscriminationAgainstElectron2::discriminate>:" << std::endl;
     std::cout << " tau: Pt = " << thePFTauRef->pt() << ", eta = " << thePFTauRef->eta()
               << ", phi = " << thePFTauRef->phi() << std::endl;
     std::cout << " discriminator value = " << discriminator << std::endl;
     std::cout << " Prongs in tau: " << thePFTauRef->signalChargedHadrCands().size() << std::endl;
   }
  
   return discriminator;
 }

References gather_cfg::cout, and PDWG_TauSkim_cff::discriminator.

◆ fillDescriptions()

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

static

Definition at line 184 of file PFRecoTauDiscriminationAgainstElectron2.cc.

                                                                                                          {
   // pfRecoTauDiscriminationAgainstElectron2
   edm::ParameterSetDescription desc;
   desc.add<bool>("rejectTausInEcalCrack", false);
   desc.add<edm::InputTag>("PFTauProducer", edm::InputTag("pfRecoTauProducer"));
   desc.add<bool>("applyCut_GammaEnFrac", true);
   desc.add<bool>("applyCut_HLTSpecific", true);
   desc.add<double>("GammaEnFrac_barrel_max", 0.15);
   desc.add<bool>("keepTausInEcalCrack", true);
   {
     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<bool>("applyCut_GammaPhiMom", false);
   desc.add<double>("GammaPhiMom_endcap_max", 1.5);
   desc.add<double>("GammaPhiMom_barrel_max", 1.5);
   desc.add<bool>("applyCut_leadPFChargedHadrEoP", true);
   desc.add<double>("LeadPFChargedHadrEoP_barrel_max", 1.01);
   desc.add<double>("GammaEtaMom_endcap_max", 1.5);
   desc.add<double>("GammaEtaMom_barrel_max", 1.5);
   desc.add<double>("Hcal3x3OverPLead_endcap_max", 0.1);
   desc.add<double>("LeadPFChargedHadrEoP_barrel_min", 0.99);
   desc.add<double>("LeadPFChargedHadrEoP_endcap_max2", 1.01);
   desc.add<double>("LeadPFChargedHadrEoP_endcap_min1", 0.7);
   desc.add<double>("LeadPFChargedHadrEoP_endcap_min2", 0.99);
   desc.add<double>("LeadPFChargedHadrEoP_endcap_max1", 1.3);
   desc.add<int>("verbosity", 0);
   desc.add<double>("GammaEnFrac_endcap_max", 0.2);
   desc.add<bool>("applyCut_hcal3x3OverPLead", true);
   desc.add<bool>("applyCut_GammaEtaMom", false);
   desc.add<std::vector<std::string>>("etaCracks",
                                      {
                                          "0.0:0.018",
                                          "0.423:0.461",
                                          "0.770:0.806",
                                          "1.127:1.163",
                                          "1.460:1.558",
                                      });
   desc.add<double>("Hcal3x3OverPLead_barrel_max", 0.2);
   descriptions.add("pfRecoTauDiscriminationAgainstElectron2", desc);
 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ isInEcalCrack()

bool PFRecoTauDiscriminationAgainstElectron2::isInEcalCrack ( double eta ) const

private

Definition at line 178 of file PFRecoTauDiscriminationAgainstElectron2.cc.

                                                                             {
   eta = fabs(eta);
   return (eta < 0.018 || (eta > 0.423 && eta < 0.461) || (eta > 0.770 && eta < 0.806) || (eta > 1.127 && eta < 1.163) ||
           (eta > 1.460 && eta < 1.558));
 }