Public Member Functions
const float	getEffectiveArea (float eta) const

void	newEvent (const edm::Event &, const edm::EventSetup &)

bool	operator() (const reco::GsfElectron &) const

void	printEffectiveAreas () const

	ZElectronsSelector (const edm::ParameterSet &, edm::ConsumesCollector &iC)

Public Attributes
edm::Handle< double >	_rhoHandle

std::vector< double >	absEtaMax_

std::vector< double >	absEtaMin_

vector< double >	dEtaInSeedCut

vector< double >	dPhiInCut

std::vector< double >	effectiveAreaValues_

vector< double >	EInvMinusPInv

edm::ParameterSet	eleIDWP

vector< double >	hOverECut

vector< int >	missHits

vector< double >	relCombIso

vector< double >	sigmaIEtaIEtaCut

edm::EDGetTokenT< reco::GsfElectronCollection >	theGsfEToken

edm::EDGetTokenT< double >	theRhoToken

Detailed Description

Definition at line 45 of file ZElectronsSelector.cc.

Constructor & Destructor Documentation

ZElectronsSelector::ZElectronsSelector	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &	iC
	)

Definition at line 92 of file ZElectronsSelector.cc.

References absEtaMax_, absEtaMin_, dEtaInSeedCut, dPhiInCut, effectiveAreaValues_, EInvMinusPInv, eleIDWP, edm::ParameterSet::getParameter(), hOverECut, missHits, relCombIso, and sigmaIEtaIEtaCut.

     : theRhoToken(iC.consumes<double>(cfg.getParameter<edm::InputTag>("rho"))) {
   absEtaMin_ = cfg.getParameter<std::vector<double> >("absEtaMin");
   absEtaMax_ = cfg.getParameter<std::vector<double> >("absEtaMax");
   effectiveAreaValues_ = cfg.getParameter<std::vector<double> >("effectiveAreaValues");
   //printEffectiveAreas();
   eleIDWP = cfg.getParameter<edm::ParameterSet>("eleID");
 
   missHits = eleIDWP.getParameter<std::vector<int> >("missingHitsCut");
   sigmaIEtaIEtaCut = eleIDWP.getParameter<std::vector<double> >("full5x5_sigmaIEtaIEtaCut");
   dEtaInSeedCut = eleIDWP.getParameter<std::vector<double> >("dEtaInSeedCut");
   dPhiInCut = eleIDWP.getParameter<std::vector<double> >("dPhiInCut");
   hOverECut = eleIDWP.getParameter<std::vector<double> >("hOverECut");
   relCombIso = eleIDWP.getParameter<std::vector<double> >("relCombIsolationWithEACut");
   EInvMinusPInv = eleIDWP.getParameter<std::vector<double> >("EInverseMinusPInverseCut");
 }

Member Function Documentation

const float ZElectronsSelector::getEffectiveArea ( float eta ) const

Definition at line 79 of file ZElectronsSelector.cc.

References funct::abs(), ticl::constants::nEtaBins, and parallelization::uint.

Referenced by operator()().

                                                                 {
   float effArea = 0;
   uint nEtaBins = absEtaMin_.size();
   for (uint iEta = 0; iEta < nEtaBins; iEta++) {
     if (std::abs(eta) >= absEtaMin_[iEta] && std::abs(eta) < absEtaMax_[iEta]) {
       effArea = effectiveAreaValues_[iEta];
       break;
     }
   }
 
   return effArea;
 }

void ZElectronsSelector::newEvent	(	const edm::Event &	ev,
		const edm::EventSetup &
	)

Definition at line 109 of file ZElectronsSelector.cc.

References _rhoHandle, edm::Event::getByToken(), and theRhoToken.

                                                                           {
   ev.getByToken(theRhoToken, _rhoHandle);
 }

bool ZElectronsSelector::operator() ( const reco::GsfElectron & el ) const

Definition at line 113 of file ZElectronsSelector.cc.

                                                                    {
   float pt_e = el.pt();
   unsigned int ind = 0;
   auto etrack = el.gsfTrack();
   float abseta = fabs((el.superCluster().get())->position().eta());
 
   if (el.isEB()) {
     if (abseta > 1.479)
       return false;  // check if it is really needed
   }
   if (el.isEE()) {
     ind = 1;
     if (abseta < 1.479)
       return false;  // check if it is really needed
     if (abseta >= 2.5)
       return false;  // check if it is really needed
   }
 
   if (etrack->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) > missHits[ind])
     return false;
   if (el.full5x5_sigmaIetaIeta() > sigmaIEtaIEtaCut[ind])
     return false;
   if (fabs(el.deltaPhiSuperClusterTrackAtVtx()) > dPhiInCut[ind])
     return false;
   if (fabs(el.deltaEtaSeedClusterTrackAtVtx()) > dEtaInSeedCut[ind])
     return false;
   if (el.hadronicOverEm() > hOverECut[ind])
     return false;
   const float eA = getEffectiveArea(abseta);
   const float rho = _rhoHandle.isValid() ? (float)(*_rhoHandle.product()) : 0;
   if ((el.pfIsolationVariables().sumChargedHadronPt +
        std::max(float(0.0),
                 el.pfIsolationVariables().sumNeutralHadronEt + el.pfIsolationVariables().sumPhotonEt - eA * rho)) >
       relCombIso[ind] * pt_e)
     return false;
   const float ecal_energy_inverse = 1.0 / el.ecalEnergy();
   const float eSCoverP = el.eSuperClusterOverP();
   if (std::abs(1.0 - eSCoverP) * ecal_energy_inverse > EInvMinusPInv[ind])
     return false;
 
   return true;
 }

void ZElectronsSelector::printEffectiveAreas ( ) const

Definition at line 72 of file ZElectronsSelector.cc.

References ticl::constants::nEtaBins, and parallelization::uint.

                                                    {
   printf("  eta_min   eta_max    effective area\n");
   uint nEtaBins = absEtaMin_.size();
   for (uint iEta = 0; iEta < nEtaBins; iEta++) {
     printf("  %8.4f    %8.4f   %8.5f\n", absEtaMin_[iEta], absEtaMax_[iEta], effectiveAreaValues_[iEta]);
   }
 }