Inheritance diagram for PFRecoTauDiscriminationAgainstElectron2:

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

double	discriminate (const PFTauRef &)

	PFRecoTauDiscriminationAgainstElectron2 (const edm::ParameterSet &iConfig)

	~PFRecoTauDiscriminationAgainstElectron2 ()

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 ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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 >
typedef std::vector< TauType >	TauCollection

typedef edm::Ref< TauCollection >	TauRef

typedef edm::RefProd < TauCollection >	TauRefProd

Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

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::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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

double	prediscriminantFailValue_

edm::EDGetTokenT< TauCollection >	Tau_token

edm::InputTag	TauProducer_

Detailed Description

Definition at line 29 of file PFRecoTauDiscriminationAgainstElectron2.cc.

Constructor & Destructor Documentation

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

inlineexplicit

Definition at line 31 of file PFRecoTauDiscriminationAgainstElectron2.cc.

References edm::ParameterSet::exists(), and edm::ParameterSet::getParameter().

     : 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.exists("verbosity") ) ?
       iConfig.getParameter<int>("verbosity") : 0;
 
     cuts2_ = new AntiElectronIDCut2();
   }

PFRecoTauDiscriminationAgainstElectron2::~PFRecoTauDiscriminationAgainstElectron2 ( )

inline

Definition at line 71 of file PFRecoTauDiscriminationAgainstElectron2.cc.

72 { }

Member Function Documentation

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

virtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 109 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_);
 
 }

double PFRecoTauDiscriminationAgainstElectron2::discriminate ( const PFTauRef & thePFTauRef )

Definition at line 157 of file PFRecoTauDiscriminationAgainstElectron2.cc.

References gather_cfg::cout.

 {
   double discriminator = 0.;
   
   // ensure tau has at least one charged object
 
   if( (*thePFTauRef).leadPFChargedHadrCand().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->signalPFChargedHadrCands().size() << std::endl;
   }
 
   return discriminator;
 }

bool PFRecoTauDiscriminationAgainstElectron2::isInEcalCrack ( double eta ) const

private

Definition at line 185 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));
 }