#include <AntiElectronIDCut2.h>

Public Member Functions
	AntiElectronIDCut2 ()

void	ApplyCut_EcalCrack (bool keepAll_, bool rejectAll_)

void	ApplyCuts (bool applyCut_hcal3x3OverPLead, bool applyCut_leadPFChargedHadrEoP, bool applyCut_GammaEtaMom, bool applyCut_GammaPhiMom, bool applyCut_GammaEnFrac, bool applyCut_HLTSpecific)

double	Discriminator (float TauPt, float TauEta, float TauLeadChargedPFCandPt, float TauLeadChargedPFCandEtaAtEcalEntrance, float TauLeadPFChargedHadrEoP, float TauHcal3x3OverPLead, float TauGammaEtaMom, float TauGammaPhiMom, float TauGammaEnFrac)

double	Discriminator (float TauPt, float TauEta, float TauLeadChargedPFCandPt, float TauLeadChargedPFCandEtaAtEcalEntrance, float TauLeadPFChargedHadrEoP, float TauHcal3x3OverPLead, const std::vector< float > &GammasdEta, const std::vector< float > &GammasdPhi, const std::vector< float > &GammasPt)

template<typename T >
double	Discriminator (const T &thePFTau)

void	SetBarrelCutValues (float TauLeadPFChargedHadrEoP_min, float TauLeadPFChargedHadrEoP_max, float TauHcal3x3OverPLead_max, float TauGammaEtaMom_max, float TauGammaPhiMom_max, float TauGammaEnFrac_max)

void	SetEcalCracks (const std::vector< pdouble > &etaCracks)

void	SetEndcapCutValues (float TauLeadPFChargedHadrEoP_min_1, float TauLeadPFChargedHadrEoP_max_1, float TauLeadPFChargedHadrEoP_min_2, float TauLeadPFChargedHadrEoP_max_2, float TauHcal3x3OverPLead_max, float TauGammaEtaMom_max, float TauGammaPhiMom_max, float TauGammaEnFrac_max)

	~AntiElectronIDCut2 ()

Private Member Functions
bool	isInEcalCrack (double eta) const

Private Attributes
std::vector< pdouble >	ecalCracks_

bool	keepAllInEcalCrack_

bool	rejectAllInEcalCrack_

bool	Tau_applyCut_GammaEnFrac_

bool	Tau_applyCut_GammaEtaMom_

bool	Tau_applyCut_GammaPhiMom_

bool	Tau_applyCut_hcal3x3OverPLead_

bool	Tau_applyCut_HLTSpecific_

bool	Tau_applyCut_leadPFChargedHadrEoP_

float	TauGammaEnFrac_barrel_max_

float	TauGammaEnFrac_endcap_max_

float	TauGammaEtaMom_barrel_max_

float	TauGammaEtaMom_endcap_max_

float	TauGammaPhiMom_barrel_max_

float	TauGammaPhiMom_endcap_max_

float	TauHcal3x3OverPLead_barrel_max_

float	TauHcal3x3OverPLead_endcap_max_

float	TauLeadPFChargedHadrEoP_barrel_max_

float	TauLeadPFChargedHadrEoP_barrel_min_

float	TauLeadPFChargedHadrEoP_endcap_max1_

float	TauLeadPFChargedHadrEoP_endcap_max2_

float	TauLeadPFChargedHadrEoP_endcap_min1_

float	TauLeadPFChargedHadrEoP_endcap_min2_

int	verbosity_

Detailed Description

Definition at line 22 of file AntiElectronIDCut2.h.

Constructor & Destructor Documentation

AntiElectronIDCut2::AntiElectronIDCut2 ( )

Definition at line 11 of file AntiElectronIDCut2.cc.

References keepAllInEcalCrack_, rejectAllInEcalCrack_, Tau_applyCut_GammaEnFrac_, Tau_applyCut_GammaEtaMom_, Tau_applyCut_GammaPhiMom_, Tau_applyCut_hcal3x3OverPLead_, Tau_applyCut_HLTSpecific_, Tau_applyCut_leadPFChargedHadrEoP_, and verbosity_.

                                        {
   //default, keep all taus in cracks for HLT
   keepAllInEcalCrack_ = true;
   rejectAllInEcalCrack_ = false;
 
   //Default Cuts to be applied
   Tau_applyCut_hcal3x3OverPLead_ = true;
   Tau_applyCut_leadPFChargedHadrEoP_ = true;
   Tau_applyCut_GammaEtaMom_ = true;
   Tau_applyCut_GammaPhiMom_ = false;
   Tau_applyCut_GammaEnFrac_ = false;
   Tau_applyCut_HLTSpecific_ = true;
 
   verbosity_ = 0;
 }

AntiElectronIDCut2::~AntiElectronIDCut2 ( )

Definition at line 27 of file AntiElectronIDCut2.cc.

27 {}

Member Function Documentation

void AntiElectronIDCut2::ApplyCut_EcalCrack	(	bool	keepAll_,
		bool	rejectAll_
	)

inline

Definition at line 126 of file AntiElectronIDCut2.h.

References keepAllInEcalCrack_, and rejectAllInEcalCrack_.

                                                           {
     keepAllInEcalCrack_ = keepAll_;
     rejectAllInEcalCrack_ = rejectAll_;
   };

void AntiElectronIDCut2::ApplyCuts	(	bool	applyCut_hcal3x3OverPLead,
		bool	applyCut_leadPFChargedHadrEoP,
		bool	applyCut_GammaEtaMom,
		bool	applyCut_GammaPhiMom,
		bool	applyCut_GammaEnFrac,
		bool	applyCut_HLTSpecific
	)

Definition at line 189 of file AntiElectronIDCut2.cc.

References PFRecoTauDiscriminationAgainstElectron2_cfi::applyCut_GammaEnFrac, PFRecoTauDiscriminationAgainstElectron2_cfi::applyCut_GammaEtaMom, PFRecoTauDiscriminationAgainstElectron2_cfi::applyCut_GammaPhiMom, PFRecoTauDiscriminationAgainstElectron2_cfi::applyCut_hcal3x3OverPLead, PFRecoTauDiscriminationAgainstElectron2_cfi::applyCut_HLTSpecific, PFRecoTauDiscriminationAgainstElectron2_cfi::applyCut_leadPFChargedHadrEoP, Tau_applyCut_GammaEnFrac_, Tau_applyCut_GammaEtaMom_, Tau_applyCut_GammaPhiMom_, Tau_applyCut_hcal3x3OverPLead_, Tau_applyCut_HLTSpecific_, and Tau_applyCut_leadPFChargedHadrEoP_.

                                                               {
   Tau_applyCut_hcal3x3OverPLead_ = applyCut_hcal3x3OverPLead;
   Tau_applyCut_leadPFChargedHadrEoP_ = applyCut_leadPFChargedHadrEoP;
   Tau_applyCut_GammaEtaMom_ = applyCut_GammaEtaMom;
   Tau_applyCut_GammaPhiMom_ = applyCut_GammaPhiMom;
   Tau_applyCut_GammaEnFrac_ = applyCut_GammaEnFrac;
   Tau_applyCut_HLTSpecific_ = applyCut_HLTSpecific;
 }

double AntiElectronIDCut2::Discriminator	(	float	TauPt,
		float	TauEta,
		float	TauLeadChargedPFCandPt,
		float	TauLeadChargedPFCandEtaAtEcalEntrance,
		float	TauLeadPFChargedHadrEoP,
		float	TauHcal3x3OverPLead,
		float	TauGammaEtaMom,
		float	TauGammaPhiMom,
		float	TauGammaEnFrac
	)

Definition at line 29 of file AntiElectronIDCut2.cc.

References gather_cfg::cout, isInEcalCrack(), keepAllInEcalCrack_, rejectAllInEcalCrack_, Tau_applyCut_GammaEnFrac_, Tau_applyCut_GammaEtaMom_, Tau_applyCut_GammaPhiMom_, Tau_applyCut_hcal3x3OverPLead_, Tau_applyCut_HLTSpecific_, Tau_applyCut_leadPFChargedHadrEoP_, TauGammaEnFrac_barrel_max_, TauGammaEnFrac_endcap_max_, TauGammaEtaMom_barrel_max_, TauGammaEtaMom_endcap_max_, TauGammaPhiMom_barrel_max_, TauGammaPhiMom_endcap_max_, TauHcal3x3OverPLead_barrel_max_, TauHcal3x3OverPLead_endcap_max_, TauLeadPFChargedHadrEoP_barrel_max_, TauLeadPFChargedHadrEoP_barrel_min_, TauLeadPFChargedHadrEoP_endcap_max1_, TauLeadPFChargedHadrEoP_endcap_max2_, TauLeadPFChargedHadrEoP_endcap_min1_, TauLeadPFChargedHadrEoP_endcap_min2_, and verbosity_.

Referenced by Discriminator().

                                                                {
   if (verbosity_) {
     std::cout << "Tau GammaEnFrac " << TauGammaEnFrac << std::endl;
     std::cout << "Tau GammaEtaMom " << TauGammaEtaMom << std::endl;
     std::cout << "Tau GammaPhiMom " << TauGammaPhiMom << std::endl;
     std::cout << "Tau Hcal3x3OverPLead " << TauHcal3x3OverPLead << std::endl;
     std::cout << "Tau LeadPFChargedHadrEoP " << TauLeadPFChargedHadrEoP << std::endl;
     std::cout << "Tau LeadChargedPFCandEtaAtEcalEntrance " << TauLeadChargedPFCandEtaAtEcalEntrance << std::endl;
     std::cout << "Tau LeadChargedPFCandPt " << TauLeadChargedPFCandPt << std::endl;
     std::cout << "Tau Eta " << TauEta << std::endl;
     std::cout << "Tau Pt " << TauPt << std::endl;
   }
 
   // ensure tau has at least one charged object
   if (TauLeadChargedPFCandPt <= 0) {
     return 0.;
   } else {
     // Check if track goes to Ecal Crack
     if (isInEcalCrack(TauLeadChargedPFCandEtaAtEcalEntrance)) {
       if (keepAllInEcalCrack_)
         return 1.0;
       else if (rejectAllInEcalCrack_)
         return 0.;
     }
   }
 
   bool decision = false;
   //Apply separate cuts for barrel and endcap
   if (TMath::Abs(TauEta) < 1.479) {
     //Apply cut for barrel
     if (Tau_applyCut_GammaEnFrac_ && TauGammaEnFrac > TauGammaEnFrac_barrel_max_)
       decision = true;
 
     if (Tau_applyCut_GammaPhiMom_ && TauGammaPhiMom > TauGammaPhiMom_barrel_max_)
       decision = true;
 
     if (Tau_applyCut_GammaEtaMom_ && TauGammaEtaMom > TauGammaEtaMom_barrel_max_)
       decision = true;
 
     if (Tau_applyCut_hcal3x3OverPLead_ && TauHcal3x3OverPLead > TauHcal3x3OverPLead_barrel_max_)
       decision = true;
 
     if (Tau_applyCut_leadPFChargedHadrEoP_ && (TauLeadPFChargedHadrEoP < TauLeadPFChargedHadrEoP_barrel_min_ ||
                                                TauLeadPFChargedHadrEoP > TauLeadPFChargedHadrEoP_barrel_max_))
       decision = true;
   } else {
     //Apply cut for endcap
     if (Tau_applyCut_GammaEnFrac_ && TauGammaEnFrac > TauGammaEnFrac_endcap_max_)
       decision = true;
 
     if (Tau_applyCut_GammaPhiMom_ && TauGammaPhiMom > TauGammaPhiMom_endcap_max_)
       decision = true;
 
     if (Tau_applyCut_GammaEtaMom_ && TauGammaEtaMom > TauGammaEtaMom_endcap_max_)
       decision = true;
 
     //This cut is for both offline and HLT. For offline, use cut 0.99-1.01,
     //For HLT use cut 0.7-1.3
     if (Tau_applyCut_leadPFChargedHadrEoP_ && (TauLeadPFChargedHadrEoP < TauLeadPFChargedHadrEoP_endcap_min1_ ||
                                                TauLeadPFChargedHadrEoP > TauLeadPFChargedHadrEoP_endcap_max1_))
       decision = true;
 
     //This cut is only for HLT. For HLT, use cut like 0.99-1.01 & H3x3/P>0.1
     //For offline, keep the values same as above : 0.99-1.01 & H3x3/P>0, otherwise it may select events in a wrong way.
     if (Tau_applyCut_HLTSpecific_ &&
         (TauLeadPFChargedHadrEoP < TauLeadPFChargedHadrEoP_endcap_min2_ ||
          TauLeadPFChargedHadrEoP > TauLeadPFChargedHadrEoP_endcap_max2_) &&
         TauHcal3x3OverPLead > TauHcal3x3OverPLead_endcap_max_)
       decision = true;
   }
 
   return (decision ? 1. : 0.);
 }

double AntiElectronIDCut2::Discriminator	(	float	TauPt,
		float	TauEta,
		float	TauLeadChargedPFCandPt,
		float	TauLeadChargedPFCandEtaAtEcalEntrance,
		float	TauLeadPFChargedHadrEoP,
		float	TauHcal3x3OverPLead,
		const std::vector< float > &	GammasdEta,
		const std::vector< float > &	GammasdPhi,
		const std::vector< float > &	GammasPt
	)

Definition at line 111 of file AntiElectronIDCut2.cc.

References Discriminator(), mps_fire::i, and Pi.

                                                                            {
   double sumPt = 0.;
   double dEta2 = 0.;
   double dPhi2 = 0.;
   for (unsigned int i = 0; i < GammasPt.size(); ++i) {
     double pt_i = GammasPt[i];
     double phi_i = GammasdPhi[i];
     if (GammasdPhi[i] > TMath::Pi())
       phi_i = GammasdPhi[i] - 2 * TMath::Pi();
     else if (GammasdPhi[i] < -TMath::Pi())
       phi_i = GammasdPhi[i] + 2 * TMath::Pi();
     double eta_i = GammasdEta[i];
     sumPt += pt_i;
     dEta2 += (pt_i * eta_i * eta_i);
     dPhi2 += (pt_i * phi_i * phi_i);
   }
 
   float TauGammaEnFrac = sumPt / TauPt;
 
   if (sumPt > 0.) {
     dEta2 /= sumPt;
     dPhi2 /= sumPt;
   }
 
   float TauGammaEtaMom = TMath::Sqrt(dEta2) * TMath::Sqrt(TauGammaEnFrac) * TauPt;
   float TauGammaPhiMom = TMath::Sqrt(dPhi2) * TMath::Sqrt(TauGammaEnFrac) * TauPt;
 
   return Discriminator(TauPt,
                        TauEta,
                        TauLeadChargedPFCandPt,
                        TauLeadChargedPFCandEtaAtEcalEntrance,
                        TauLeadPFChargedHadrEoP,
                        TauHcal3x3OverPLead,
                        TauGammaEtaMom,
                        TauGammaPhiMom,
                        TauGammaEnFrac);
 }

template<typename T >

double AntiElectronIDCut2::Discriminator ( const T & thePFTau )

inline

Definition at line 48 of file AntiElectronIDCut2.h.

References Discriminator(), reco::TrackBase::eta(), mps_fire::i, reco::TrackBase::pt(), and HLT_FULL_cff::track.

                                           {
     float TauLeadChargedPFCandEtaAtEcalEntrance = -99.;
     float TauLeadChargedPFCandPt = -99.;
     const std::vector<reco::PFCandidatePtr>& signalPFCands = thePFTau.signalPFCands();
     for (std::vector<reco::PFCandidatePtr>::const_iterator pfCandidate = signalPFCands.begin();
          pfCandidate != signalPFCands.end();
          ++pfCandidate) {
       const reco::Track* track = nullptr;
       if ((*pfCandidate)->trackRef().isNonnull())
         track = (*pfCandidate)->trackRef().get();
       else if ((*pfCandidate)->muonRef().isNonnull() && (*pfCandidate)->muonRef()->innerTrack().isNonnull())
         track = (*pfCandidate)->muonRef()->innerTrack().get();
       else if ((*pfCandidate)->muonRef().isNonnull() && (*pfCandidate)->muonRef()->globalTrack().isNonnull())
         track = (*pfCandidate)->muonRef()->globalTrack().get();
       else if ((*pfCandidate)->muonRef().isNonnull() && (*pfCandidate)->muonRef()->outerTrack().isNonnull())
         track = (*pfCandidate)->muonRef()->outerTrack().get();
       else if ((*pfCandidate)->gsfTrackRef().isNonnull())
         track = (*pfCandidate)->gsfTrackRef().get();
       if (track) {
         if (track->pt() > TauLeadChargedPFCandPt) {
           TauLeadChargedPFCandEtaAtEcalEntrance = (*pfCandidate)->positionAtECALEntrance().eta();
           TauLeadChargedPFCandPt = track->pt();
         }
       }
     }
 
     float TauPt = thePFTau.pt();
     float TauEta = thePFTau.eta();
     //float TauLeadPFChargedHadrHoP = 0.;
     float TauLeadPFChargedHadrEoP = 0.;
     if (thePFTau.leadPFChargedHadrCand()->p() > 0.) {
       //TauLeadPFChargedHadrHoP = thePFTau.leadPFChargedHadrCand()->hcalEnergy()/thePFTau.leadPFChargedHadrCand()->p();
       TauLeadPFChargedHadrEoP = thePFTau.leadPFChargedHadrCand()->ecalEnergy() / thePFTau.leadPFChargedHadrCand()->p();
     }
 
     std::vector<float> GammasdEta;
     std::vector<float> GammasdPhi;
     std::vector<float> GammasPt;
     for (unsigned i = 0; i < thePFTau.signalGammaCands().size(); ++i) {
       reco::CandidatePtr gamma = thePFTau.signalGammaCands().at(i);
       if (thePFTau.leadChargedHadrCand().isNonnull()) {
         GammasdEta.push_back(gamma->eta() - thePFTau.leadChargedHadrCand()->eta());
         GammasdPhi.push_back(gamma->phi() - thePFTau.leadChargedHadrCand()->phi());
       } else {
         GammasdEta.push_back(gamma->eta() - thePFTau.eta());
         GammasdPhi.push_back(gamma->phi() - thePFTau.phi());
       }
       GammasPt.push_back(gamma->pt());
     }
 
     float TauHcal3x3OverPLead = thePFTau.hcal3x3OverPLead();
 
     return Discriminator(TauPt,
                          TauEta,
                          TauLeadChargedPFCandPt,
                          TauLeadChargedPFCandEtaAtEcalEntrance,
                          TauLeadPFChargedHadrEoP,
                          TauHcal3x3OverPLead,
                          GammasdEta,
                          GammasdPhi,
                          GammasPt);
   };

bool AntiElectronIDCut2::isInEcalCrack ( double eta ) const

private

Definition at line 203 of file AntiElectronIDCut2.cc.

References ecalCracks_, and edm::second().

Referenced by Discriminator().

                                                        {
   bool in_ecal_crack = false;
 
   eta = fabs(eta);
   for (std::vector<pdouble>::const_iterator etaCrack = ecalCracks_.begin(); etaCrack != ecalCracks_.end(); ++etaCrack)
     if (eta >= etaCrack->first && eta < etaCrack->second)
       in_ecal_crack = true;
 
   return in_ecal_crack;
 }

void AntiElectronIDCut2::SetBarrelCutValues	(	float	TauLeadPFChargedHadrEoP_min,
		float	TauLeadPFChargedHadrEoP_max,
		float	TauHcal3x3OverPLead_max,
		float	TauGammaEtaMom_max,
		float	TauGammaPhiMom_max,
		float	TauGammaEnFrac_max
	)

Definition at line 157 of file AntiElectronIDCut2.cc.

References TauGammaEnFrac_barrel_max_, TauGammaEtaMom_barrel_max_, TauGammaPhiMom_barrel_max_, TauHcal3x3OverPLead_barrel_max_, TauLeadPFChargedHadrEoP_barrel_max_, and TauLeadPFChargedHadrEoP_barrel_min_.

                                                                       {
   TauLeadPFChargedHadrEoP_barrel_min_ = TauLeadPFChargedHadrEoP_min;
   TauLeadPFChargedHadrEoP_barrel_max_ = TauLeadPFChargedHadrEoP_max;
   TauHcal3x3OverPLead_barrel_max_ = TauHcal3x3OverPLead_max;
   TauGammaEtaMom_barrel_max_ = TauGammaEtaMom_max;
   TauGammaPhiMom_barrel_max_ = TauGammaPhiMom_max;
   TauGammaEnFrac_barrel_max_ = TauGammaEnFrac_max;
 }

void AntiElectronIDCut2::SetEcalCracks ( const std::vector< pdouble > & etaCracks )

inline

Definition at line 138 of file AntiElectronIDCut2.h.

References ecalCracks_, and mps_fire::i.

                                                           {
     ecalCracks_.clear();
     for (size_t i = 0; i < etaCracks.size(); i++)
       ecalCracks_.push_back(etaCracks[i]);
   }

void AntiElectronIDCut2::SetEndcapCutValues	(	float	TauLeadPFChargedHadrEoP_min_1,
		float	TauLeadPFChargedHadrEoP_max_1,
		float	TauLeadPFChargedHadrEoP_min_2,
		float	TauLeadPFChargedHadrEoP_max_2,
		float	TauHcal3x3OverPLead_max,
		float	TauGammaEtaMom_max,
		float	TauGammaPhiMom_max,
		float	TauGammaEnFrac_max
	)

Definition at line 171 of file AntiElectronIDCut2.cc.

References TauGammaEnFrac_endcap_max_, TauGammaEtaMom_endcap_max_, TauGammaPhiMom_endcap_max_, TauHcal3x3OverPLead_endcap_max_, TauLeadPFChargedHadrEoP_endcap_max1_, TauLeadPFChargedHadrEoP_endcap_max2_, TauLeadPFChargedHadrEoP_endcap_min1_, and TauLeadPFChargedHadrEoP_endcap_min2_.

                                                                       {
   TauLeadPFChargedHadrEoP_endcap_min1_ = TauLeadPFChargedHadrEoP_min_1;
   TauLeadPFChargedHadrEoP_endcap_max1_ = TauLeadPFChargedHadrEoP_max_1;
   TauLeadPFChargedHadrEoP_endcap_min2_ = TauLeadPFChargedHadrEoP_min_2;
   TauLeadPFChargedHadrEoP_endcap_max2_ = TauLeadPFChargedHadrEoP_max_2;
   TauHcal3x3OverPLead_endcap_max_ = TauHcal3x3OverPLead_max;
   TauGammaEtaMom_endcap_max_ = TauGammaEtaMom_max;
   TauGammaPhiMom_endcap_max_ = TauGammaPhiMom_max;
   TauGammaEnFrac_endcap_max_ = TauGammaEnFrac_max;
 }