PTDRElectronID Class Reference

#include <PTDRElectronID.h>

Inheritance diagram for PTDRElectronID:

Public Member Functions
	PTDRElectronID ()
double	result (const reco::GsfElectron *, const edm::Event &, const edm::EventSetup &) override
void	setup (const edm::ParameterSet &conf) override
	~PTDRElectronID () override
Public Member Functions inherited from ElectronIDAlgo
	ElectronIDAlgo ()
virtual	~ElectronIDAlgo ()

Private Attributes
std::vector< int >	acceptCracks_
edm::ParameterSet	cuts_
std::string	quality_
std::vector< int >	useBremFraction_
std::vector< int >	useDeltaEtaIn_
std::vector< int >	useDeltaPhiIn_
std::vector< int >	useDeltaPhiOut_
std::vector< int >	useE9overE25_
std::vector< int >	useEoverPIn_
std::vector< int >	useEoverPOut_
std::vector< int >	useHoverE_
std::vector< int >	useInvEMinusInvP_
std::vector< int >	useSigmaEtaEta_
std::vector< int >	useSigmaPhiPhi_
int	variables_

Additional Inherited Members
Protected Attributes inherited from ElectronIDAlgo
edm::InputTag	reducedBarrelRecHitCollection_
edm::InputTag	reducedEndcapRecHitCollection_

Detailed Description

Definition at line 6 of file PTDRElectronID.h.

Constructor & Destructor Documentation

PTDRElectronID()

PTDRElectronID::PTDRElectronID ( )

inline

Definition at line 8 of file PTDRElectronID.h.

{};

~PTDRElectronID()

PTDRElectronID::~PTDRElectronID ( )

inlineoverride

Definition at line 10 of file PTDRElectronID.h.

{};

Member Function Documentation

result()

double PTDRElectronID::result ( const reco::GsfElectron *  electron, const edm::Event &  e, const edm::EventSetup &  es  )

overridevirtual

Reimplemented from ElectronIDAlgo.

Definition at line 37 of file PTDRElectronID.cc.

                                                                                                         {
  //determine which element of the cut arrays in cfi file to read
  //depending on the electron classification
  int icut = 0;
  int elClass = electron->classification();
  if (electron->isEB())  //barrel
  {
    if (elClass == reco::GsfElectron::GOLDEN)
      icut = 0;
    if (elClass == reco::GsfElectron::BIGBREM)
      icut = 1;
    //if (elClass == reco::GsfElectron::NARROW)    icut=2;
    if (elClass == reco::GsfElectron::SHOWERING)
      icut = 3;
    if (elClass == reco::GsfElectron::GAP)
      icut = 8;
  }
  if (electron->isEE())  //endcap
  {
    if (elClass == reco::GsfElectron::GOLDEN)
      icut = 4;
    if (elClass == reco::GsfElectron::BIGBREM)
      icut = 5;
    //if (elClass == reco::GsfElectron::NARROW)    icut=6;
    if (elClass == reco::GsfElectron::SHOWERING)
      icut = 7;
    if (elClass == reco::GsfElectron::GAP)
      icut = 8;
  }
  if (elClass == reco::GsfElectron::UNKNOWN) {
    edm::LogError("PTDRElectronID") << "Error: unrecognized electron classification ";
    return 1.;
  }
 
  if (acceptCracks_[variables_])
    if (elClass == reco::GsfElectron::GAP)
      return 1.;
 
  if (useEoverPIn_[variables_]) {
    double value = electron->eSuperClusterOverP();
    std::vector<double> maxcut = cuts_.getParameter<std::vector<double> >("EoverPInMax");
    std::vector<double> mincut = cuts_.getParameter<std::vector<double> >("EoverPInMin");
    if (value < mincut[icut] || value > maxcut[icut])
      return 0.;
  }
 
  if (useDeltaEtaIn_[variables_]) {
    double value = electron->deltaEtaSuperClusterTrackAtVtx();
    std::vector<double> maxcut = cuts_.getParameter<std::vector<double> >("deltaEtaIn");
    if (fabs(value) > maxcut[icut])
      return 0.;
  }
 
  if (useDeltaPhiIn_[variables_]) {
    double value = electron->deltaPhiSuperClusterTrackAtVtx();
    std::vector<double> maxcut = cuts_.getParameter<std::vector<double> >("deltaPhiIn");
    if (fabs(value) > maxcut[icut])
      return 0.;
  }
 
  if (useHoverE_[variables_]) {
    double value = electron->hadronicOverEm();
    std::vector<double> maxcut = cuts_.getParameter<std::vector<double> >("HoverE");
    if (value > maxcut[icut])
      return 0.;
  }
 
  if (useEoverPOut_[variables_]) {
    double value = electron->eSeedClusterOverPout();
    std::vector<double> maxcut = cuts_.getParameter<std::vector<double> >("EoverPOutMax");
    std::vector<double> mincut = cuts_.getParameter<std::vector<double> >("EoverPOutMin");
    if (value < mincut[icut] || value > maxcut[icut])
      return 0.;
  }
 
  if (useDeltaPhiOut_[variables_]) {
    double value = electron->deltaPhiSeedClusterTrackAtCalo();
    std::vector<double> maxcut = cuts_.getParameter<std::vector<double> >("deltaPhiOut");
    if (fabs(value) > maxcut[icut])
      return 0.;
  }
 
  if (useInvEMinusInvP_[variables_]) {
    double value = (1. / electron->caloEnergy()) - (1. / electron->trackMomentumAtVtx().R());
    std::vector<double> maxcut = cuts_.getParameter<std::vector<double> >("invEMinusInvP");
    if (value > maxcut[icut])
      return 0.;
  }
 
  if (useBremFraction_[variables_]) {
    double value = electron->trackMomentumAtVtx().R() - electron->trackMomentumOut().R();
    std::vector<double> mincut = cuts_.getParameter<std::vector<double> >("bremFraction");
    if (value < mincut[icut])
      return 0.;
  }
 
  //EcalClusterLazyTools lazyTools = getClusterShape(e,es);
  //std::vector<float> vCov = lazyTools.localCovariances(*(electron->superCluster()->seed())) ;
  //std::vector<float> vCov = lazyTools.covariances(*(electron->superCluster()->seed())) ;
 
  if (useE9overE25_[variables_]) {
    double value = electron->r9() * electron->superCluster()->energy() / electron->e5x5();
    std::vector<double> mincut = cuts_.getParameter<std::vector<double> >("E9overE25");
    if (fabs(value) < mincut[icut])
      return 0.;
  }
 
  if (useSigmaEtaEta_[variables_]) {
    std::vector<double> maxcut = cuts_.getParameter<std::vector<double> >("sigmaEtaEtaMax");
    std::vector<double> mincut = cuts_.getParameter<std::vector<double> >("sigmaEtaEtaMin");
    if (electron->sigmaIetaIeta() < mincut[icut] || electron->sigmaIetaIeta() > maxcut[icut])
      return 0.;
  }
 
  if (useSigmaPhiPhi_[variables_]) {
    std::vector<double> mincut = cuts_.getParameter<std::vector<double> >("sigmaPhiPhiMin");
    std::vector<double> maxcut = cuts_.getParameter<std::vector<double> >("sigmaPhiPhiMax");
    if (electron->sigmaIphiIphi() < mincut[icut] || electron->sigmaIphiIphi() > maxcut[icut])
      return 0.;
  }
 
  return 1.;
}

References acceptCracks_, reco::GsfElectron::BIGBREM, cuts_, metsig::electron, reco::GsfElectron::GAP, edm::ParameterSet::getParameter(), reco::GsfElectron::GOLDEN, reco::GsfElectron::SHOWERING, reco::GsfElectron::UNKNOWN, useBremFraction_, useDeltaEtaIn_, useDeltaPhiIn_, useDeltaPhiOut_, useE9overE25_, useEoverPIn_, useEoverPOut_, useHoverE_, useInvEMinusInvP_, useSigmaEtaEta_, useSigmaPhiPhi_, and variables_.

setup()

void PTDRElectronID::setup ( const edm::ParameterSet &  conf )

overridevirtual

Reimplemented from ElectronIDAlgo.

Definition at line 3 of file PTDRElectronID.cc.

                                                      {
  // Get all the parameters
  //baseSetup(conf);
 
  quality_ = conf.getParameter<std::string>("electronQuality");
 
  useEoverPIn_ = conf.getParameter<std::vector<int> >("useEoverPIn");
  useDeltaEtaIn_ = conf.getParameter<std::vector<int> >("useDeltaEtaIn");
  useDeltaPhiIn_ = conf.getParameter<std::vector<int> >("useDeltaPhiIn");
  useHoverE_ = conf.getParameter<std::vector<int> >("useHoverE");
  useE9overE25_ = conf.getParameter<std::vector<int> >("useE9overE25");
  useEoverPOut_ = conf.getParameter<std::vector<int> >("useEoverPOut");
  useDeltaPhiOut_ = conf.getParameter<std::vector<int> >("useDeltaPhiOut");
  useInvEMinusInvP_ = conf.getParameter<std::vector<int> >("useInvEMinusInvP");
  useBremFraction_ = conf.getParameter<std::vector<int> >("useBremFraction");
  useSigmaEtaEta_ = conf.getParameter<std::vector<int> >("useSigmaEtaEta");
  useSigmaPhiPhi_ = conf.getParameter<std::vector<int> >("useSigmaPhiPhi");
  acceptCracks_ = conf.getParameter<std::vector<int> >("acceptCracks");
 
  if (quality_ == "tight") {
    cuts_ = conf.getParameter<edm::ParameterSet>("tightEleIDCuts");
    variables_ = 2;
  } else if (quality_ == "medium") {
    cuts_ = conf.getParameter<edm::ParameterSet>("mediumEleIDCuts");
    variables_ = 1;
  } else if (quality_ == "loose") {
    cuts_ = conf.getParameter<edm::ParameterSet>("looseEleIDCuts");
    variables_ = 0;
  } else {
    throw cms::Exception("Configuration")
        << "Invalid electronQuality parameter in PTDElectronID: must be tight, medium or loose.";
  }
}

References acceptCracks_, cuts_, Exception, edm::ParameterSet::getParameter(), quality_, AlCaHLTBitMon_QueryRunRegistry::string, useBremFraction_, useDeltaEtaIn_, useDeltaPhiIn_, useDeltaPhiOut_, useE9overE25_, useEoverPIn_, useEoverPOut_, useHoverE_, useInvEMinusInvP_, useSigmaEtaEta_, useSigmaPhiPhi_, and variables_.

Member Data Documentation

acceptCracks_

std::vector<int> PTDRElectronID::acceptCracks_

private

Definition at line 29 of file PTDRElectronID.h.

Referenced by result(), and setup().

cuts_

edm::ParameterSet PTDRElectronID::cuts_

private

Definition at line 31 of file PTDRElectronID.h.

Referenced by result(), and setup().

quality_

std::string PTDRElectronID::quality_

private

Definition at line 16 of file PTDRElectronID.h.

Referenced by setup().

useBremFraction_

std::vector<int> PTDRElectronID::useBremFraction_

private

Definition at line 26 of file PTDRElectronID.h.

Referenced by result(), and setup().

useDeltaEtaIn_

std::vector<int> PTDRElectronID::useDeltaEtaIn_

private

Definition at line 19 of file PTDRElectronID.h.

Referenced by result(), and setup().

useDeltaPhiIn_

std::vector<int> PTDRElectronID::useDeltaPhiIn_

private

Definition at line 20 of file PTDRElectronID.h.

Referenced by result(), and setup().

useDeltaPhiOut_

std::vector<int> PTDRElectronID::useDeltaPhiOut_

private

Definition at line 24 of file PTDRElectronID.h.

Referenced by result(), and setup().

useE9overE25_

std::vector<int> PTDRElectronID::useE9overE25_

private

Definition at line 22 of file PTDRElectronID.h.

Referenced by result(), and setup().

useEoverPIn_

std::vector<int> PTDRElectronID::useEoverPIn_

private

Definition at line 18 of file PTDRElectronID.h.

Referenced by result(), and setup().

useEoverPOut_

std::vector<int> PTDRElectronID::useEoverPOut_

private

Definition at line 23 of file PTDRElectronID.h.

Referenced by result(), and setup().

useHoverE_

std::vector<int> PTDRElectronID::useHoverE_

private

Definition at line 21 of file PTDRElectronID.h.

Referenced by result(), and setup().

useInvEMinusInvP_

std::vector<int> PTDRElectronID::useInvEMinusInvP_

private

Definition at line 25 of file PTDRElectronID.h.

Referenced by result(), and setup().

useSigmaEtaEta_

std::vector<int> PTDRElectronID::useSigmaEtaEta_

private

Definition at line 27 of file PTDRElectronID.h.

Referenced by result(), and setup().

useSigmaPhiPhi_

std::vector<int> PTDRElectronID::useSigmaPhiPhi_

private

Definition at line 28 of file PTDRElectronID.h.

Referenced by result(), and setup().

variables_

int PTDRElectronID::variables_

private

Definition at line 33 of file PTDRElectronID.h.

Referenced by result(), and setup().