SimpleCutBasedElectronIDSelectionFunctor Class Reference

#include <SimpleCutBasedElectronIDSelectionFunctor.h>

Inheritance diagram for SimpleCutBasedElectronIDSelectionFunctor:

Public Types
enum	Version_t {   relIso95 =0, cIso95, relIso90, cIso90,   relIso85, cIso85, relIso80, cIso80,   relIso70, cIso70, relIso60, cIso60,   NONE }
Public Types inherited from Selector< pat::Electron >
typedef std::binary_function< pat::Electron, pat::strbitset, bool >	base_type
typedef std::pair< index_type, size_t >	cut_flow_item
typedef std::vector< cut_flow_item >	cut_flow_map
typedef pat::Electron	data_type
typedef std::map< index_type, double >	double_map
typedef pat::strbitset::index_type	index_type
typedef std::map< index_type, int >	int_map

Public Member Functions
void	initialize (Version_t version)
void	initialize (Double_t trackIso_EB, Double_t ecalIso_EB, Double_t hcalIso_EB, Double_t sihih_EB, Double_t dphi_EB, Double_t deta_EB, Double_t hoe_EB, Double_t cIso_EB, Double_t trackIso_EE, Double_t ecalIso_EE, Double_t hcalIso_EE, Double_t sihih_EE, Double_t dphi_EE, Double_t deta_EE, Double_t hoe_EE, Double_t cIso_EE, Int_t conversionRejection, Int_t maxNumberOfExpectedMissingHits)
bool	operator() (const pat::Electron &electron, pat::strbitset &ret) override
	SimpleCutBasedElectronIDSelectionFunctor ()
	SimpleCutBasedElectronIDSelectionFunctor (edm::ParameterSet const &parameters)
	SimpleCutBasedElectronIDSelectionFunctor (Version_t version)
bool	spring10Variables (const pat::Electron &electron, pat::strbitset &ret)
Public Member Functions inherited from Selector< pat::Electron >
void	clear (std::string const &s)
	Turn off a given selection cut. More...
void	clear (index_type const &i)
bool	considerCut (std::string const &s) const
	consider the cut at index "s" More...
bool	considerCut (index_type const &i) const
int	cut (index_type const &i, int val) const
	Access the int cut values at index "s". More...
double	cut (index_type const &i, double val) const
	Access the double cut values at index "s". More...
int	cut (std::string s, int val) const
	Access the int cut values at index "s". More...
double	cut (std::string s, double val) const
	Access the double cut values at index "s". More...
pat::strbitset	getBitTemplate () const
	Get an empty bitset with the proper names. More...
double	getPasses (std::string const &s) const
	Return the number of passing cases. More...
double	getPasses (index_type const &i) const
bool	ignoreCut (std::string const &s) const
	ignore the cut at index "s" More...
bool	ignoreCut (index_type const &i) const
virtual bool	operator() (pat::Electron const &t, pat::strbitset &ret)=0
	This provides the interface for base classes to select objects. More...
virtual bool	operator() (pat::Electron const &t)
	This provides an alternative signature without the second ret. More...
virtual bool	operator() (pat::Electron const &t, edm::EventBase const &e, pat::strbitset &ret)
	This provides an alternative signature that includes extra information. More...
virtual bool	operator() (pat::Electron const &t, edm::EventBase const &e)
	This provides an alternative signature that includes extra information. More...
bool	operator[] (std::string const &s) const
bool	operator[] (index_type const &i) const
void	passCut (pat::strbitset &ret, std::string const &s)
	Passing cuts. More...
void	passCut (pat::strbitset &ret, index_type const &i)
void	print (std::ostream &out) const
	Print the cut flow. More...
void	printActiveCuts (std::ostream &out) const
	Print the cuts being considered. More...
virtual void	push_back (std::string const &s)
	This is the registration of an individual cut string. More...
virtual void	push_back (std::string const &s, int cut)
	This is the registration of an individual cut string, with an int cut value. More...
virtual void	push_back (std::string const &s, double cut)
	This is the registration of an individual cut string, with a double cut value. More...
	Selector ()
	Constructor clears the bits. More...
void	set (std::string const &s, bool val=true)
	Set a given selection cut, on or off. More...
void	set (index_type const &i, bool val=true)
void	set (std::string const &s, int cut, bool val=true)
	Set a given selection cut, on or off, and reset int cut value. More...
void	set (index_type const &i, int cut, bool val=true)
void	set (std::string const &s, double cut, bool val=true)
	Set a given selection cut, on or off, and reset int cut value. More...
void	set (index_type const &i, double cut, bool val=true)
void	setIgnored (pat::strbitset &ret)
	set ignored bits More...
void	setIgnoredCuts (std::vector< std::string > const &bitsToIgnore)
	set the bits to ignore from a vector More...
virtual	~Selector ()

Private Attributes
Version_t	version_

Additional Inherited Members
Protected Attributes inherited from Selector< pat::Electron >
pat::strbitset	bits_
	the bitset indexed by strings More...
cut_flow_map	cutFlow_
	map of cut flows in "human" order More...
double_map	doubleCuts_
	the double-value cut map More...
int_map	intCuts_
	the int-value cut map More...
pat::strbitset	retInternal_
	internal ret if users don't care about return bits More...

Detailed Description

Definition at line 61 of file SimpleCutBasedElectronIDSelectionFunctor.h.

Member Enumeration Documentation

enum SimpleCutBasedElectronIDSelectionFunctor::Version_t

Enumerator
relIso95
cIso95
relIso90
cIso90
relIso85
cIso85
relIso80
cIso80
relIso70
cIso70
relIso60
cIso60
NONE

Definition at line 65 of file SimpleCutBasedElectronIDSelectionFunctor.h.

                 { relIso95=0, cIso95,  relIso90, cIso90, relIso85, cIso85, 
           relIso80, cIso80,  relIso70, cIso70, relIso60, cIso60, NONE };

Constructor & Destructor Documentation

SimpleCutBasedElectronIDSelectionFunctor::SimpleCutBasedElectronIDSelectionFunctor ( )

inline

Definition at line 68 of file SimpleCutBasedElectronIDSelectionFunctor.h.

{}

SimpleCutBasedElectronIDSelectionFunctor::SimpleCutBasedElectronIDSelectionFunctor ( edm::ParameterSet const &  parameters )

inline

Definition at line 71 of file SimpleCutBasedElectronIDSelectionFunctor.h.

References Selector< pat::Electron >::getBitTemplate(), edm::ParameterSet::getParameter(), initialize(), and Selector< pat::Electron >::retInternal_.

    {
      // get the cuts from the PS
      initialize( parameters.getParameter<Double_t>("trackIso_EB"), 
          parameters.getParameter<Double_t>("ecalIso_EB"), 
          parameters.getParameter<Double_t>("hcalIso_EB"), 
          parameters.getParameter<Double_t>("sihih_EB"), 
          parameters.getParameter<Double_t>("dphi_EB"), 
          parameters.getParameter<Double_t>("deta_EB"), 
          parameters.getParameter<Double_t>("hoe_EB"), 
          parameters.getParameter<Double_t>("cIso_EB"), 
          parameters.getParameter<Double_t>("trackIso_EE"), 
          parameters.getParameter<Double_t>("ecalIso_EE"), 
          parameters.getParameter<Double_t>("hcalIso_EE"), 
          parameters.getParameter<Double_t>("sihih_EE"), 
          parameters.getParameter<Double_t>("dphi_EE"), 
          parameters.getParameter<Double_t>("deta_EE"), 
          parameters.getParameter<Double_t>("hoe_EE"), 
          parameters.getParameter<Double_t>("cIso_EE"), 
          parameters.getParameter<Int_t>("conversionRejection"), 
          parameters.getParameter<Int_t>("maxNumberOfExpectedMissingHits"));
      retInternal_ = getBitTemplate();
    }

SimpleCutBasedElectronIDSelectionFunctor::SimpleCutBasedElectronIDSelectionFunctor ( Version_t  version )

inline

Definition at line 95 of file SimpleCutBasedElectronIDSelectionFunctor.h.

References cIso80, gather_cfg::cout, Selector< pat::Electron >::getBitTemplate(), initialize(), and Selector< pat::Electron >::retInternal_.

    {
      if (version == NONE) {
    std::cout << "SimpleCutBasedElectronIDSelectionFunctor: If you want to use version NONE "
          << "then you have also to provide the selection cuts by yourself " << std::endl;
    std::cout << "SimpleCutBasedElectronIDSelectionFunctor: ID Version is changed to 80cIso "
          << std::endl;
    version = cIso80;
      }
      initialize(version);
      retInternal_ = getBitTemplate();
    }

Member Function Documentation

void SimpleCutBasedElectronIDSelectionFunctor::initialize ( Version_t  version )

inline

Definition at line 108 of file SimpleCutBasedElectronIDSelectionFunctor.h.

References cIso60, cIso70, cIso80, cIso85, cIso90, cIso95, Selector< pat::Electron >::push_back(), relIso60, relIso70, relIso80, relIso85, relIso90, relIso95, jets_cff::version, and version_.

Referenced by SimpleCutBasedElectronIDSelectionFunctor().

  {
    version_ = version;
    // push back the variables
    push_back("trackIso_EB");
    push_back("ecalIso_EB" );
    push_back("hcalIso_EB" );
    push_back("sihih_EB"   );
    push_back("dphi_EB"    );
    push_back("deta_EB"    );
    push_back("hoe_EB"     );
    push_back("cIso_EB"    );
    
    push_back("trackIso_EE");
    push_back("ecalIso_EE" );
    push_back("hcalIso_EE" );
    push_back("sihih_EE"   );
    push_back("dphi_EE"    );
    push_back("deta_EE"    );
    push_back("hoe_EE"     );
    push_back("cIso_EE"    );
    
    push_back("conversionRejection"            );
    push_back("maxNumberOfExpectedMissingHits" );
    
    
    
    
    if (version_ == relIso95) {
      set("trackIso_EB", 1.5e-01);
      set("ecalIso_EB",  2.0e+00);
      set("hcalIso_EB",  1.2e-01);
      set("sihih_EB",    1.0e-02);
      set("dphi_EB",     8.0e-01);
      set("deta_EB",     7.0e-03);
      set("hoe_EB",      1.5e-01);
      set("cIso_EB",     10000. );
      
      set("trackIso_EE", 8.0e-02);
      set("ecalIso_EE",  6.0e-02);
      set("hcalIso_EE",  5.0e-02);
      set("sihih_EE",    3.0e-02);
      set("dphi_EE",     7.0e-01);
      set("deta_EE",     1.0e-02);
      set("hoe_EE",      7.0e-02);
      set("cIso_EE",     10000. );
      
      set("conversionRejection",            0);
      set("maxNumberOfExpectedMissingHits", 1);

    }
    else if (version_ == cIso95) {
      set("trackIso_EB", 100000.);
      set("ecalIso_EB",  100000.);
      set("hcalIso_EB",  100000.);
      set("sihih_EB",    1.0e-02);
      set("dphi_EB",     8.0e-01);
      set("deta_EB",     7.0e-03);
      set("hoe_EB",      1.5e-01);
      set("cIso_EB",     1.5e-01);
                                              
      set("trackIso_EE", 100000.);
      set("ecalIso_EE",  100000.);
      set("hcalIso_EE",  100000.);
      set("sihih_EE",    3.0e-02);
      set("dphi_EE",     7.0e-01);
      set("deta_EE",     1.0e-02);
      set("hoe_EE",      7.0e-02);
      set("cIso_EE",     1.0e-01);
      
      set("conversionRejection",            0);
      set("maxNumberOfExpectedMissingHits", 1);
      
    }
    else if (version_ == relIso90) {
      set("trackIso_EB", 1.2e-01);
      set("ecalIso_EB",  9.0e-02);
      set("hcalIso_EB",  1.0e-01);
      set("sihih_EB",    1.0e-02);
      set("dphi_EB",     8.0e-01);
      set("deta_EB",     7.0e-03);
      set("hoe_EB",      1.2e-01);
      set("cIso_EB",     10000. );

      set("trackIso_EE", 5.0e-02);
      set("ecalIso_EE",  6.0e-02);
      set("hcalIso_EE",  3.0e-02);
      set("sihih_EE",    3.0e-02);
      set("dphi_EE",     7.0e-01);
      set("deta_EE",     9.0e-03);
      set("hoe_EE",      5.0e-02);
      set("cIso_EE",     10000. );
      
      set("conversionRejection",            1);
      set("maxNumberOfExpectedMissingHits", 1);
    }
    else if (version_ == cIso90) {
      set("trackIso_EB", 100000.);
      set("ecalIso_EB",  100000.);
      set("hcalIso_EB",  100000.);
      set("sihih_EB",    1.0e-02);
      set("dphi_EB",     8.0e-01);
      set("deta_EB",     7.0e-03);
      set("hoe_EB",      1.2e-01);
      set("cIso_EB",     1.0e-01);

      set("trackIso_EE", 100000.);
      set("ecalIso_EE",  100000.);
      set("hcalIso_EE",  100000.);
      set("sihih_EE",    3.0e-02);
      set("dphi_EE",     7.0e-01);
      set("deta_EE",     9.0e-03);
      set("hoe_EE",      5.0e-02);
      set("cIso_EE",     7.0e-02);
      
      set("conversionRejection",            1);
      set("maxNumberOfExpectedMissingHits", 1);
    }
    else if (version_ == relIso85) {
      set("trackIso_EB", 9.0e-02);
      set("ecalIso_EB",  8.0e-02);
      set("hcalIso_EB",  1.0e-01);
      set("sihih_EB",    1.0e-02);
      set("dphi_EB",     6.0e-02);
      set("deta_EB",     6.0e-03);
      set("hoe_EB",      4.0e-02);
      set("cIso_EB",     10000. );

      set("trackIso_EE", 5.0e-02);
      set("ecalIso_EE",  5.0e-02);
      set("hcalIso_EE",  2.5e-02);
      set("sihih_EE",    3.0e-02);
      set("dphi_EE",     4.0e-02);
      set("deta_EE",     7.0e-03);
      set("hoe_EE",      2.5e-02);
      set("cIso_EE",     10000. );
      
      set("conversionRejection",            1);
      set("maxNumberOfExpectedMissingHits", 1);
    }
    else if (version_ == cIso85) {
      set("trackIso_EB", 100000.);
      set("ecalIso_EB",  100000.);
      set("hcalIso_EB",  100000.);
      set("sihih_EB",    1.0e-02);
      set("dphi_EB",     6.0e-02);
      set("deta_EB",     6.0e-03);
      set("hoe_EB",      4.0e-02);
      set("cIso_EB",     9.0e-02);

      set("trackIso_EE", 100000.);
      set("ecalIso_EE",  100000.);
      set("hcalIso_EE",  100000.);
      set("sihih_EE",    3.0e-02);
      set("dphi_EE",     4.0e-02);
      set("deta_EE",     7.0e-03);
      set("hoe_EE",      2.5e-02);
      set("cIso_EE",     6.0e-02);
      
      set("conversionRejection",            1);
      set("maxNumberOfExpectedMissingHits", 1);
    }
    else if (version_ == relIso80) {
      set("trackIso_EB", 9.0e-02);
      set("ecalIso_EB",  7.0e-02);
      set("hcalIso_EB",  1.0e-01);
      set("sihih_EB",    1.0e-02);
      set("dphi_EB",     6.0e-02);
      set("deta_EB",     4.0e-03);
      set("hoe_EB",      4.0e-02);
      set("cIso_EB",     100000.);

      set("trackIso_EE", 4.0e-02);
      set("ecalIso_EE",  5.0e-02);
      set("hcalIso_EE",  2.5e-02);
      set("sihih_EE",    3.0e-02);
      set("dphi_EE",     3.0e-02);
      set("deta_EE",     7.0e-03);
      set("hoe_EE",      2.5e-02);
      set("cIso_EE",     100000.);
      
      set("conversionRejection",            1);
      set("maxNumberOfExpectedMissingHits", 0);
    }
    else if (version_ == cIso80) {
      set("trackIso_EB", 100000.);
      set("ecalIso_EB",  100000.);
      set("hcalIso_EB",  100000.);
      set("sihih_EB",    1.0e-02);
      set("dphi_EB",     6.0e-02);
      set("deta_EB",     4.0e-03);
      set("hoe_EB",      4.0e-02);
      set("cIso_EB",     7.0e-02);

      set("trackIso_EE", 100000.);
      set("ecalIso_EE",  100000.);
      set("hcalIso_EE",  100000.);
      set("sihih_EE",    3.0e-02);
      set("dphi_EE",     3.0e-02);
      set("deta_EE",     7.0e-03);
      set("hoe_EE",      2.5e-02);
      set("cIso_EE",     6.0e-02);
      
      set("conversionRejection",            1);
      set("maxNumberOfExpectedMissingHits", 0);
    }
    else if (version_ == relIso70) {
      set("trackIso_EB", 5.0e-02);
      set("ecalIso_EB",  6.0e-02);
      set("hcalIso_EB",  3.0e-02);
      set("sihih_EB",    1.0e-02);
      set("dphi_EB",     3.0e-02);
      set("deta_EB",     4.0e-03);
      set("hoe_EB",      2.5e-02);
      set("cIso_EB",     100000.);

      set("trackIso_EE", 2.5e-02);
      set("ecalIso_EE",  2.5e-02);
      set("hcalIso_EE",  2.0e-02);
      set("sihih_EE",    3.0e-02);
      set("dphi_EE",     2.0e-02);
      set("deta_EE",     5.0e-03);
      set("hoe_EE",      2.5e-02);
      set("cIso_EE",     100000.);
      
      set("conversionRejection",            1);
      set("maxNumberOfExpectedMissingHits", 0);
    }
    else if (version_ == cIso70) {
      set("trackIso_EB", 100000.);
      set("ecalIso_EB",  100000.);
      set("hcalIso_EB",  100000.);
      set("sihih_EB",    1.0e-02);
      set("dphi_EB",     3.0e-02);
      set("deta_EB",     4.0e-03);
      set("hoe_EB",      2.5e-02);
      set("cIso_EB",     4.0e-02);

      set("trackIso_EE", 100000.);
      set("ecalIso_EE",  100000.);
      set("hcalIso_EE",  100000.);
      set("sihih_EE",    3.0e-02);
      set("dphi_EE",     2.0e-02);
      set("deta_EE",     5.0e-03);
      set("hoe_EE",      2.5e-02);
      set("cIso_EE",     3.0e-02);
      
      set("conversionRejection",            1);
      set("maxNumberOfExpectedMissingHits", 0);
    }
    else if (version_ == relIso60) {
      set("trackIso_EB", 4.0e-02);
      set("ecalIso_EB",  4.0e-02);
      set("hcalIso_EB",  3.0e-02);
      set("sihih_EB",    1.0e-02);
      set("dphi_EB",     2.5e-02);
      set("deta_EB",     4.0e-03);
      set("hoe_EB",      2.5e-02);
      set("cIso_EB",     100000.);

      set("trackIso_EE", 2.5e-02);
      set("ecalIso_EE",  2.0e-02);
      set("hcalIso_EE",  2.0e-02);
      set("sihih_EE",    3.0e-02);
      set("dphi_EE",     2.0e-02);
      set("deta_EE",     5.0e-03);
      set("hoe_EE",      2.5e-02);
      set("cIso_EE",     100000.);
      
      set("conversionRejection",            1);
      set("maxNumberOfExpectedMissingHits", 0);
    }
    else if (version_ == cIso60) {
      set("trackIso_EB", 100000.);
      set("ecalIso_EB",  100000.);
      set("hcalIso_EB",  100000.);
      set("sihih_EB",    1.0e-02);
      set("dphi_EB",     2.5e-02);
      set("deta_EB",     4.0e-03);
      set("hoe_EB",      2.5e-02);
      set("cIso_EB",     3.0e-02);

      set("trackIso_EE", 100000.);
      set("ecalIso_EE",  100000.);
      set("hcalIso_EE",  100000.);
      set("sihih_EE",    3.0e-02);
      set("dphi_EE",     2.0e-02);
      set("deta_EE",     5.0e-03);
      set("hoe_EE",      2.5e-02);
      set("cIso_EE",     2.0e-02);
      
      set("conversionRejection",            1);
      set("maxNumberOfExpectedMissingHits", 0);
    }
  }

void SimpleCutBasedElectronIDSelectionFunctor::initialize ( Double_t  trackIso_EB, Double_t  ecalIso_EB, Double_t  hcalIso_EB, Double_t  sihih_EB, Double_t  dphi_EB, Double_t  deta_EB, Double_t  hoe_EB, Double_t  cIso_EB, Double_t  trackIso_EE, Double_t  ecalIso_EE, Double_t  hcalIso_EE, Double_t  sihih_EE, Double_t  dphi_EE, Double_t  deta_EE, Double_t  hoe_EE, Double_t  cIso_EE, Int_t  conversionRejection, Int_t  maxNumberOfExpectedMissingHits  )

inline

Definition at line 404 of file SimpleCutBasedElectronIDSelectionFunctor.h.

References NONE, Selector< pat::Electron >::push_back(), and version_.

  {
    version_ = NONE;
    push_back("trackIso_EB");
    push_back("ecalIso_EB" );
    push_back("hcalIso_EB" );
    push_back("sihih_EB"   );
    push_back("dphi_EB"    );
    push_back("deta_EB"    );
    push_back("hoe_EB"     );
    push_back("cIso_EB"    );
    
    push_back("trackIso_EE");
    push_back("ecalIso_EE" );
    push_back("hcalIso_EE" );
    push_back("sihih_EE"   );
    push_back("dphi_EE"    );
    push_back("deta_EE"    );
    push_back("hoe_EE"     );
    push_back("cIso_EE"    );
    
    push_back("conversionRejection"            );
    push_back("maxNumberOfExpectedMissingHits" );
    
   
    set("trackIso_EB", trackIso_EB);
    set("ecalIso_EB",  ecalIso_EB);
    set("hcalIso_EB",  hcalIso_EB);
    set("sihih_EB",    sihih_EB);
    set("dphi_EB",     dphi_EB);
    set("deta_EB",     deta_EB);
    set("hoe_EB",      hoe_EB);
    set("cIso_EB",     cIso_EB);
    
    set("trackIso_EE", trackIso_EE);
    set("ecalIso_EE",  ecalIso_EE);
    set("hcalIso_EE",  hcalIso_EE);
    set("sihih_EE",    sihih_EE);
    set("dphi_EE",     dphi_EE);
    set("deta_EE",     deta_EE);
    set("hoe_EE",      hoe_EE);
    set("cIso_EE",     cIso_EE);
    
    set("conversionRejection",            conversionRejection);
    set("maxNumberOfExpectedMissingHits", maxNumberOfExpectedMissingHits);
    
  }

bool SimpleCutBasedElectronIDSelectionFunctor::operator() ( const pat::Electron &  electron, pat::strbitset &  ret  )

inlineoverride

Definition at line 458 of file SimpleCutBasedElectronIDSelectionFunctor.h.

References Utilities::operator, and spring10Variables().

  {
    // for the time being only Spring10 variable definition
    return spring10Variables(electron, ret);
  }

bool SimpleCutBasedElectronIDSelectionFunctor::spring10Variables ( const pat::Electron &  electron, pat::strbitset &  ret  )

inline

Definition at line 465 of file SimpleCutBasedElectronIDSelectionFunctor.h.

References reco::GsfElectron::convDcot(), reco::GsfElectron::convDist(), Selector< pat::Electron >::cut(), reco::GsfElectron::deltaEtaSuperClusterTrackAtVtx(), reco::GsfElectron::deltaPhiSuperClusterTrackAtVtx(), reco::GsfElectron::dr03EcalRecHitSumEt(), reco::GsfElectron::dr03HcalTowerSumEt(), reco::GsfElectron::dr03TkSumPt(), pat::Electron::gsfTrack(), reco::GsfElectron::hadronicOverEm(), Selector< pat::Electron >::ignoreCut(), reco::GsfElectron::isEB(), SiStripPI::max, reco::HitPattern::MISSING_INNER_HITS, reco::GsfElectron::p4(), Selector< pat::Electron >::passCut(), pat::strbitset::set(), Selector< pat::Electron >::setIgnored(), and reco::GsfElectron::sigmaIetaIeta().

Referenced by operator()().

  {
    ret.set(false);
    //
    Double_t eleET = electron.p4().Pt();
    Double_t trackIso = electron.dr03TkSumPt()/eleET;
    Double_t ecalIso = electron.dr03EcalRecHitSumEt()/eleET;
    Double_t hcalIso = electron.dr03HcalTowerSumEt()/eleET;
    Double_t sihih   = electron.sigmaIetaIeta();
    Double_t Dphi    = electron.deltaPhiSuperClusterTrackAtVtx();
    Double_t Deta    = electron.deltaEtaSuperClusterTrackAtVtx();
    Double_t HoE     = electron.hadronicOverEm();
    Double_t cIso    = 0;
    if (electron.isEB()) { cIso = 
    ( electron.dr03TkSumPt() + std::max(0.,electron.dr03EcalRecHitSumEt() -1.) 
      + electron.dr03HcalTowerSumEt() ) / eleET;
    }
    else {
      cIso = ( electron.dr03TkSumPt()+electron.dr03EcalRecHitSumEt()+
           electron.dr03HcalTowerSumEt()  ) / eleET;
    }
    Int_t innerHits = electron.gsfTrack()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);
    // in 39 conversion rejection variables are accessible from Gsf electron
    Double_t dist = electron.convDist(); // default value is -9999 if conversion partner not found
    Double_t dcot = electron.convDcot(); // default value is -9999 if conversion partner not found
    Bool_t isConv = fabs(dist) < 0.02 && fabs(dcot) < 0.02;
    // now apply the cuts
    if (electron.isEB()) { // BARREL case
      // check the EB cuts
      if ( trackIso   <  cut("trackIso_EB", double()) || ignoreCut("trackIso_EB")) passCut(ret, "trackIso_EB");
      if ( ecalIso    <  cut("ecalIso_EB",  double()) || ignoreCut("ecalIso_EB") ) passCut(ret, "ecalIso_EB");
      if ( hcalIso    <  cut("hcalIso_EB",  double()) || ignoreCut("hcalIso_EB") ) passCut(ret, "hcalIso_EB");
      if ( sihih      <  cut("sihih_EB",    double()) || ignoreCut("sihih_EB")   ) passCut(ret, "sihih_EB");
      if ( fabs(Dphi) <  cut("dphi_EB",     double()) || ignoreCut("dphi_EB")    ) passCut(ret, "dphi_EB");
      if ( fabs(Deta) <  cut("deta_EB",     double()) || ignoreCut("deta_EB")    ) passCut(ret, "deta_EB");
      if ( HoE        <  cut("hoe_EB",      double()) || ignoreCut("hoe_EB")     ) passCut(ret, "hoe_EB");
      if ( cIso       <  cut("cIso_EB",     double()) || ignoreCut("cIso_EB")    ) passCut(ret, "cIso_EB");
      // pass all the EE cuts
      passCut(ret, "trackIso_EE");  
      passCut(ret, "ecalIso_EE");   
      passCut(ret, "hcalIso_EE");   
      passCut(ret, "sihih_EE"); 
      passCut(ret, "dphi_EE");  
      passCut(ret, "deta_EE");  
      passCut(ret, "hoe_EE");   
      passCut(ret, "cIso_EE");     
    } else {  // ENDCAPS case
      // check the EE cuts
      if ( trackIso   <  cut("trackIso_EE", double()) || ignoreCut("trackIso_EE")) passCut(ret, "trackIso_EE");
      if ( ecalIso    <  cut("ecalIso_EE",  double()) || ignoreCut("ecalIso_EE") ) passCut(ret, "ecalIso_EE");
      if ( hcalIso    <  cut("hcalIso_EE",  double()) || ignoreCut("hcalIso_EE") ) passCut(ret, "hcalIso_EE");
      if ( sihih      <  cut("sihih_EE",    double()) || ignoreCut("sihih_EE")   ) passCut(ret, "sihih_EE");
      if ( fabs(Dphi) <  cut("dphi_EE",     double()) || ignoreCut("dphi_EE")    ) passCut(ret, "dphi_EE");
      if ( fabs(Deta) <  cut("deta_EE",     double()) || ignoreCut("deta_EE")    ) passCut(ret, "deta_EE");
      if ( HoE        <  cut("hoe_EE",      double()) || ignoreCut("hoe_EE")     ) passCut(ret, "hoe_EE");
      if ( cIso       <  cut("cIso_EE",     double()) || ignoreCut("cIso_EE")    ) passCut(ret, "cIso_EE");     
      // pass all the EB cuts
      passCut(ret, "trackIso_EB");  
      passCut(ret, "ecalIso_EB");   
      passCut(ret, "hcalIso_EB");   
      passCut(ret, "sihih_EB"); 
      passCut(ret, "dphi_EB");  
      passCut(ret, "deta_EB");  
      passCut(ret, "hoe_EB");   
      passCut(ret, "cIso_EB");     
    }

    // conversion rejection common for EB and EE
    if ( innerHits  <=  cut("maxNumberOfExpectedMissingHits", int())) 
      passCut(ret, "maxNumberOfExpectedMissingHits");    
    if ( 0==cut("conversionRejection", int()) || isConv==false)
      passCut(ret, "conversionRejection");
    setIgnored(ret);   
    return (bool)ret;
  }

Member Data Documentation

Version_t SimpleCutBasedElectronIDSelectionFunctor::version_

private

Definition at line 545 of file SimpleCutBasedElectronIDSelectionFunctor.h.

Referenced by initialize().