ElectronLikelihood Class Reference

#include <ElectronLikelihood.h>

List of all members.

Public Member Functions
	ElectronLikelihood ()
	ctor, not used for this algo (need initialization from ES)
	ElectronLikelihood (const ElectronLikelihoodCalibration *calibration, LikelihoodSwitches eleIDSwitches, std::string signalWeightSplitting, std::string backgroundWeightSplitting, bool splitSignalPdfs, bool splitBackgroundPdfs)
	ctor
float	result (const reco::GsfElectron &electron, EcalClusterLazyTools) const
	get the result of the algorithm
float	resultLog (const reco::GsfElectron &electron, EcalClusterLazyTools) const
	get the log-expanded result of the algorithm
void	setup (const edm::ParameterSet &conf)
	not used for this algo
virtual	~ElectronLikelihood ()
	dtor
Private Member Functions
void	getInputVar (const reco::GsfElectron &electron, std::vector< float > &measuremnts, EcalClusterLazyTools) const
	get the input variables from the electron and the e-Setup
void	Setup (const ElectronLikelihoodCalibration *calibration, std::string signalWeightSplitting, std::string backgroundWeightSplitting, bool splitSignalPdfs, bool splitBackgroundPdfs)
Private Attributes
LikelihoodPdfProduct *	_EB0gt15lh
	likelihood above 15GeV/c
LikelihoodPdfProduct *	_EB0lt15lh
	likelihood below 15GeV/c
LikelihoodPdfProduct *	_EB1gt15lh
LikelihoodPdfProduct *	_EB1lt15lh
LikelihoodPdfProduct *	_EEgt15lh
LikelihoodPdfProduct *	_EElt15lh
std::string	m_backgroundWeightSplitting
LikelihoodSwitches	m_eleIDSwitches
	general parameters of all the ele id algorithms
std::string	m_signalWeightSplitting
	splitting rule for PDF's
bool	m_splitBackgroundPdfs
bool	m_splitSignalPdfs

---

Detailed Description

Definition at line 17 of file ElectronLikelihood.h.

---

Constructor & Destructor Documentation

ElectronLikelihood::ElectronLikelihood

(

)

[inline]

ctor, not used for this algo (need initialization from ES)

Definition at line 22 of file ElectronLikelihood.h.

{} ;

ElectronLikelihood::ElectronLikelihood	(	const ElectronLikelihoodCalibration *	calibration,
		LikelihoodSwitches	eleIDSwitches,
		std::string	signalWeightSplitting,
		std::string	backgroundWeightSplitting,
		bool	splitSignalPdfs,
		bool	splitBackgroundPdfs
	)

ctor

Definition at line 10 of file ElectronLikelihood.cc.

References Setup().

                                                                  :
  _EB0lt15lh (new LikelihoodPdfProduct ("electronID_EB0_ptLt15_likelihood",0,0)) ,
  _EB1lt15lh (new LikelihoodPdfProduct ("electronID_EB1_ptLt15_likelihood",1,0)) ,
  _EElt15lh (new LikelihoodPdfProduct ("electronID_EE_ptLt15_likelihood",2,0)) ,
  _EB0gt15lh (new LikelihoodPdfProduct ("electronID_EB0_ptGt15_likelihood",0,1)) ,
  _EB1gt15lh (new LikelihoodPdfProduct ("electronID_EB1_ptGt15_likelihood",1,1)) ,
  _EEgt15lh (new LikelihoodPdfProduct ("electronID_EE_ptGt15_likelihood",2,1)) ,
  m_eleIDSwitches (eleIDSwitches) ,
  m_signalWeightSplitting (signalWeightSplitting), 
  m_backgroundWeightSplitting (backgroundWeightSplitting),
  m_splitSignalPdfs (splitSignalPdfs), 
  m_splitBackgroundPdfs (splitBackgroundPdfs)  
{
  Setup (calibration,
         signalWeightSplitting, backgroundWeightSplitting,
         splitSignalPdfs, splitBackgroundPdfs) ;
}

ElectronLikelihood::~ElectronLikelihood

(

)

[virtual]

dtor

Definition at line 39 of file ElectronLikelihood.cc.

References _EB0gt15lh, _EB0lt15lh, _EB1gt15lh, _EB1lt15lh, _EEgt15lh, and _EElt15lh.

                                         {
  delete _EB0lt15lh ;
  delete _EB1lt15lh ;
  delete _EElt15lh ;
  delete _EB0gt15lh ;
  delete _EB1gt15lh ;
  delete _EEgt15lh ;
}

---

Member Function Documentation

void ElectronLikelihood::getInputVar	(	const reco::GsfElectron &	electron,
		std::vector< float > &	measuremnts,
		EcalClusterLazyTools	myEcalCluster
	)		const [private]

get the input variables from the electron and the e-Setup

Definition at line 324 of file ElectronLikelihood.cc.

References reco::GsfElectron::deltaEtaSuperClusterTrackAtVtx(), reco::GsfElectron::deltaPhiSuperClusterTrackAtVtx(), reco::GsfElectron::eSuperClusterOverP(), reco::GsfElectron::fbrem(), reco::LeafCandidate::get(), reco::GsfElectron::hadronicOverEm(), EcalClusterLazyTools::localCovariances(), m_eleIDSwitches, LikelihoodSwitches::m_useDeltaEta, LikelihoodSwitches::m_useDeltaPhi, LikelihoodSwitches::m_useEoverP, LikelihoodSwitches::m_useFBrem, LikelihoodSwitches::m_useHoverE, LikelihoodSwitches::m_useOneOverEMinusOneOverP, LikelihoodSwitches::m_useSigmaEtaEta, LikelihoodSwitches::m_useSigmaPhiPhi, mathSSE::sqrt(), and reco::GsfElectron::superCluster().

Referenced by result(), and resultLog().

{

  // the variables entering the likelihood
  if (m_eleIDSwitches.m_useDeltaPhi) measurements.push_back ( electron.deltaPhiSuperClusterTrackAtVtx () ) ;
  if (m_eleIDSwitches.m_useDeltaEta) measurements.push_back ( electron.deltaEtaSuperClusterTrackAtVtx () ) ;
  if (m_eleIDSwitches.m_useEoverP) measurements.push_back ( electron.eSuperClusterOverP () ) ;
  if (m_eleIDSwitches.m_useHoverE) measurements.push_back ( electron.hadronicOverEm () ) ;
  std::vector<float> vCov = myEcalCluster.localCovariances(*(electron.superCluster()->seed())) ;
  if (m_eleIDSwitches.m_useSigmaEtaEta) measurements.push_back ( sqrt (vCov[0]) );
  if (m_eleIDSwitches.m_useSigmaPhiPhi) measurements.push_back ( sqrt (vCov[2]) );
  if(m_eleIDSwitches.m_useFBrem) measurements.push_back( electron.fbrem() );
  // 1/E - 1/P calculated consistently with the variables used to make the PDFs
  reco::GsfTrackRef trkRef = electron.get<reco::GsfTrackRef>();
  float OneOverEMinusOneOverP = 1.0/(electron.eSuperClusterOverP() * trkRef->p()) - 1.0/trkRef->p();
  if(m_eleIDSwitches.m_useOneOverEMinusOneOverP) measurements.push_back( OneOverEMinusOneOverP );

}

float ElectronLikelihood::result	(	const reco::GsfElectron &	electron,
		EcalClusterLazyTools	myEcalCluster
	)		const

get the result of the algorithm

Definition at line 352 of file ElectronLikelihood.cc.

References _EB0gt15lh, _EB0lt15lh, _EB1gt15lh, _EB1lt15lh, _EEgt15lh, _EElt15lh, className(), EcalBarrel, EcalEndcap, reco::LeafCandidate::eta(), Exception, getInputVar(), LikelihoodPdfProduct::getRatio(), m_signalWeightSplitting, reco::GsfElectron::numberOfBrems(), reco::LeafCandidate::pt(), and reco::GsfElectron::superCluster().

{

  //=======================================================
  // used classification:
  // nbrem clusters = 0         =>  0
  // nbrem clusters >= 1        =>  1
  //=======================================================

  std::vector<float> measurements ;
  getInputVar (electron, measurements, myEcalCluster) ;

  // Split using only the number of brem clusters
  int bitVal=(electron.numberOfBrems()==0) ? 0 : 1 ;
  
  char className[20];
  if(m_signalWeightSplitting.compare("class")==0) {
    snprintf(className, 20, "class%d", bitVal);
  } else {
    throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
                                      << " splitting is implemented right now";
  }

  reco::SuperClusterRef sclusRef = electron.superCluster() ;
  EcalSubdetector subdet = EcalSubdetector (sclusRef->hitsAndFractions()[0].first.subdetId ()) ;
  float thisPt =  electron.pt();

  if (subdet==EcalBarrel && fabs(electron.eta())<=1.0 && thisPt<15.)
    return _EB0lt15lh->getRatio ("electrons",measurements,std::string (className)) ;
  else if (subdet==EcalBarrel && fabs(electron.eta())<=1.0 && thisPt>=15.)
    return _EB0gt15lh->getRatio ("electrons",measurements,std::string (className)) ;
  else if (subdet==EcalBarrel && fabs(electron.eta())>1.0 && thisPt<15.)
    return _EB1lt15lh->getRatio ("electrons",measurements,std::string (className)) ;
  else if (subdet==EcalBarrel && fabs(electron.eta())>1.0 && thisPt>=15.)
    return _EB1gt15lh->getRatio ("electrons",measurements,std::string (className)) ;
  else if (subdet==EcalEndcap && thisPt<15.)
    return _EElt15lh->getRatio ("electrons",measurements,std::string (className)) ;
  else if (subdet==EcalEndcap && thisPt>=15.)
    return _EEgt15lh->getRatio ("electrons",measurements,std::string (className)) ;
  else return -999. ;
}

float ElectronLikelihood::resultLog	(	const reco::GsfElectron &	electron,
		EcalClusterLazyTools	myEcalCluster
	)		const

get the log-expanded result of the algorithm

Definition at line 396 of file ElectronLikelihood.cc.

References _EB0gt15lh, _EB0lt15lh, _EB1gt15lh, _EB1lt15lh, _EEgt15lh, _EElt15lh, className(), EcalBarrel, EcalEndcap, reco::LeafCandidate::eta(), Exception, getInputVar(), LikelihoodPdfProduct::getRatio(), create_public_lumi_plots::log, m_signalWeightSplitting, reco::GsfElectron::numberOfBrems(), reco::LeafCandidate::pt(), and reco::GsfElectron::superCluster().

{

  //=======================================================
  // used classification:
  // nbrem clusters = 0         =>  0
  // nbrem clusters >= 1        =>  1
  //=======================================================

  std::vector<float> measurements ;
  getInputVar (electron, measurements, myEcalCluster) ;

  // Split using only the number of brem clusters
  int bitVal=(electron.numberOfBrems()==0) ? 0 : 1 ;
  
  char className[20];
  if(m_signalWeightSplitting.compare("class")==0) {
    snprintf(className, 20, "class%d", bitVal);
  } else {
    throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
                                      << " splitting is implemented right now";
  }

  reco::SuperClusterRef sclusRef = electron.superCluster() ;
  EcalSubdetector subdet = EcalSubdetector (sclusRef->hitsAndFractions()[0].first.subdetId ()) ;
  float thisPt =  electron.pt();

  float lh=-999.;

  if (subdet==EcalBarrel && fabs(electron.eta())<=1.0 && thisPt<15.)
    lh = _EB0lt15lh->getRatio ("electrons",measurements,std::string (className)) ;
  else if (subdet==EcalBarrel && fabs(electron.eta())<=1.0 && thisPt>=15.)
    lh = _EB0gt15lh->getRatio ("electrons",measurements,std::string (className)) ;
  else if (subdet==EcalBarrel && fabs(electron.eta())>1.0 && thisPt<15.)
    lh = _EB1lt15lh->getRatio ("electrons",measurements,std::string (className)) ;
  else if (subdet==EcalBarrel && fabs(electron.eta())>1.0 && thisPt>=15.)
    lh = _EB1gt15lh->getRatio ("electrons",measurements,std::string (className)) ;
  else if (subdet==EcalEndcap && thisPt<15.)
    lh = _EElt15lh->getRatio ("electrons",measurements,std::string (className)) ;
  else if (subdet==EcalEndcap && thisPt>=15.)
    lh = _EEgt15lh->getRatio ("electrons",measurements,std::string (className)) ;
  else lh = -999. ;

  if(lh<=0) return -20.;
  else if(lh==1) return 20.;
  else return log(lh/(1.0-lh));

}

void ElectronLikelihood::Setup	(	const ElectronLikelihoodCalibration *	calibration,
		std::string	signalWeightSplitting,
		std::string	backgroundWeightSplitting,
		bool	splitSignalPdfs,
		bool	splitBackgroundPdfs
	)		[private]

build the likelihood model from histograms in Barrel file and Endcap file

Definition at line 54 of file ElectronLikelihood.cc.

References _EB0gt15lh, _EB0lt15lh, _EB1gt15lh, _EB1lt15lh, _EEgt15lh, _EElt15lh, LikelihoodPdfProduct::addPdf(), LikelihoodPdfProduct::addSpecies(), Exception, LikelihoodPdfProduct::initFromDB(), m_eleIDSwitches, LikelihoodSwitches::m_useDeltaEta, LikelihoodSwitches::m_useDeltaPhi, LikelihoodSwitches::m_useEoverP, LikelihoodSwitches::m_useFBrem, LikelihoodSwitches::m_useHoverE, LikelihoodSwitches::m_useOneOverEMinusOneOverP, LikelihoodSwitches::m_useSigmaEtaEta, LikelihoodSwitches::m_useSigmaPhiPhi, and LikelihoodPdfProduct::setSplitFrac().

Referenced by ElectronLikelihood().

{

  // ECAL BARREL0 (|eta|<1.0) LIKELIHOOD - Pt < 15 GeV region
  _EB0lt15lh->initFromDB (calibration) ;

  _EB0lt15lh->addSpecies ("electrons") ;
  _EB0lt15lh->addSpecies ("hadrons") ;

  if(signalWeightSplitting.compare("class")==0) {
    _EB0lt15lh->setSplitFrac ("electrons", "class0") ;
    _EB0lt15lh->setSplitFrac ("electrons", "class1") ;
  }
  else {
    throw cms::Exception("BadConfig") << "Only class (non-showering / showering)"
                                      << " and fullclass (golden / bigbrem / narrow / showering)" 
                                      << " splitting is implemented right now";
  }

  if (m_eleIDSwitches.m_useDeltaPhi)     _EB0lt15lh->addPdf ("electrons", "dPhi",          splitSignalPdfs) ;   
  if (m_eleIDSwitches.m_useDeltaEta)     _EB0lt15lh->addPdf ("electrons", "dEta",          splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useEoverP)       _EB0lt15lh->addPdf ("electrons", "EoP",           splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useHoverE)       _EB0lt15lh->addPdf ("electrons", "HoE",           splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useSigmaEtaEta)  _EB0lt15lh->addPdf ("electrons", "sigmaIEtaIEta", splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useSigmaPhiPhi)  _EB0lt15lh->addPdf ("electrons", "sigmaIPhiIPhi", splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useFBrem)        _EB0lt15lh->addPdf ("electrons", "fBrem",         splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useOneOverEMinusOneOverP)        _EB0lt15lh->addPdf ("electrons", "OneOverEMinusOneOverP",         splitSignalPdfs) ;

  if(backgroundWeightSplitting.compare("class")==0) {
    _EB0lt15lh->setSplitFrac ("hadrons", "class0") ;
    _EB0lt15lh->setSplitFrac ("hadrons", "class1") ;
  }
  else {
    throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
                                      << " splitting is implemented right now";
  }

  if (m_eleIDSwitches.m_useDeltaPhi)     _EB0lt15lh->addPdf ("hadrons", "dPhi",          splitBackgroundPdfs) ;   
  if (m_eleIDSwitches.m_useDeltaEta)     _EB0lt15lh->addPdf ("hadrons", "dEta",          splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useEoverP)       _EB0lt15lh->addPdf ("hadrons", "EoP",           splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useHoverE)       _EB0lt15lh->addPdf ("hadrons", "HoE",           splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useSigmaEtaEta)  _EB0lt15lh->addPdf ("hadrons", "sigmaIEtaIEta", splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useSigmaPhiPhi)  _EB0lt15lh->addPdf ("hadrons", "sigmaIPhiIPhi", splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useFBrem)        _EB0lt15lh->addPdf ("hadrons", "fBrem",         splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useOneOverEMinusOneOverP)        _EB0lt15lh->addPdf ("hadrons", "OneOverEMinusOneOverP",         splitBackgroundPdfs) ;

  // ECAL BARREL0 (|eta|<1.0) LIKELIHOOD - Pt >= 15 GeV region
  _EB0gt15lh->initFromDB (calibration) ;

  _EB0gt15lh->addSpecies ("electrons") ;  
  _EB0gt15lh->addSpecies ("hadrons") ;

  if(signalWeightSplitting.compare("class")==0) {
    _EB0gt15lh->setSplitFrac ("electrons", "class0") ;
    _EB0gt15lh->setSplitFrac ("electrons", "class1") ;
  }
  else {
    throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
                                      << " splitting is implemented right now";
  }

  if (m_eleIDSwitches.m_useDeltaPhi)     _EB0gt15lh->addPdf ("electrons", "dPhi",          splitSignalPdfs) ;   
  if (m_eleIDSwitches.m_useDeltaEta)     _EB0gt15lh->addPdf ("electrons", "dEta",          splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useEoverP)       _EB0gt15lh->addPdf ("electrons", "EoP",           splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useHoverE)       _EB0gt15lh->addPdf ("electrons", "HoE",           splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useSigmaEtaEta)  _EB0gt15lh->addPdf ("electrons", "sigmaIEtaIEta", splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useSigmaPhiPhi)  _EB0gt15lh->addPdf ("electrons", "sigmaIPhiIPhi", splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useFBrem)        _EB0gt15lh->addPdf ("electrons", "fBrem",         splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useOneOverEMinusOneOverP)        _EB0gt15lh->addPdf ("electrons", "OneOverEMinusOneOverP",         splitSignalPdfs) ;

  if(backgroundWeightSplitting.compare("class")==0) {
    _EB0gt15lh->setSplitFrac ("hadrons", "class0") ;
    _EB0gt15lh->setSplitFrac ("hadrons", "class1") ;
  }
  else {
    throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
                                      << " splitting is implemented right now";
  }

  if (m_eleIDSwitches.m_useDeltaPhi)     _EB0gt15lh->addPdf ("hadrons", "dPhi",          splitBackgroundPdfs) ;   
  if (m_eleIDSwitches.m_useDeltaEta)     _EB0gt15lh->addPdf ("hadrons", "dEta",          splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useEoverP)       _EB0gt15lh->addPdf ("hadrons", "EoP",           splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useHoverE)       _EB0gt15lh->addPdf ("hadrons", "HoE",           splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useSigmaEtaEta)  _EB0gt15lh->addPdf ("hadrons", "sigmaIEtaIEta", splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useSigmaPhiPhi)  _EB0gt15lh->addPdf ("hadrons", "sigmaIPhiIPhi", splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useFBrem)        _EB0gt15lh->addPdf ("hadrons", "fBrem",         splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useOneOverEMinusOneOverP)        _EB0gt15lh->addPdf ("hadrons", "OneOverEMinusOneOverP",         splitBackgroundPdfs) ;


  // ECAL BARREL1 (|eta|>1.0) LIKELIHOOD - Pt < 15 GeV region
  _EB1lt15lh->initFromDB (calibration) ;

  _EB1lt15lh->addSpecies ("electrons") ;
  _EB1lt15lh->addSpecies ("hadrons") ;

  if(signalWeightSplitting.compare("class")==0) {
    _EB1lt15lh->setSplitFrac ("electrons", "class0") ;
    _EB1lt15lh->setSplitFrac ("electrons", "class1") ;
  }
  else {
    throw cms::Exception("BadConfig") << "Only class (non-showering / showering)"
                                      << " and fullclass (golden / bigbrem / narrow / showering)" 
                                      << " splitting is implemented right now";
  }

  if (m_eleIDSwitches.m_useDeltaPhi)     _EB1lt15lh->addPdf ("electrons", "dPhi",          splitSignalPdfs) ;   
  if (m_eleIDSwitches.m_useDeltaEta)     _EB1lt15lh->addPdf ("electrons", "dEta",          splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useEoverP)       _EB1lt15lh->addPdf ("electrons", "EoP",           splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useHoverE)       _EB1lt15lh->addPdf ("electrons", "HoE",           splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useSigmaEtaEta)  _EB1lt15lh->addPdf ("electrons", "sigmaIEtaIEta", splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useSigmaPhiPhi)  _EB1lt15lh->addPdf ("electrons", "sigmaIPhiIPhi", splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useFBrem)        _EB1lt15lh->addPdf ("electrons", "fBrem",         splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useOneOverEMinusOneOverP)        _EB1lt15lh->addPdf ("electrons", "OneOverEMinusOneOverP",         splitSignalPdfs) ;

  if(backgroundWeightSplitting.compare("class")==0) {
    _EB1lt15lh->setSplitFrac ("hadrons", "class0") ;
    _EB1lt15lh->setSplitFrac ("hadrons", "class1") ;
  }
  else {
    throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
                                      << " splitting is implemented right now";
  }

  if (m_eleIDSwitches.m_useDeltaPhi)     _EB1lt15lh->addPdf ("hadrons", "dPhi",          splitBackgroundPdfs) ;   
  if (m_eleIDSwitches.m_useDeltaEta)     _EB1lt15lh->addPdf ("hadrons", "dEta",          splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useEoverP)       _EB1lt15lh->addPdf ("hadrons", "EoP",           splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useHoverE)       _EB1lt15lh->addPdf ("hadrons", "HoE",           splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useSigmaEtaEta)  _EB1lt15lh->addPdf ("hadrons", "sigmaIEtaIEta", splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useSigmaPhiPhi)  _EB1lt15lh->addPdf ("hadrons", "sigmaIPhiIPhi", splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useFBrem)        _EB1lt15lh->addPdf ("hadrons", "fBrem",         splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useOneOverEMinusOneOverP)        _EB1lt15lh->addPdf ("hadrons", "OneOverEMinusOneOverP",         splitBackgroundPdfs) ;

  // ECAL BARREL1 (|eta|>1.0) LIKELIHOOD - Pt >= 15 GeV region
  _EB1gt15lh->initFromDB (calibration) ;

  _EB1gt15lh->addSpecies ("electrons") ;  
  _EB1gt15lh->addSpecies ("hadrons") ;

  if(signalWeightSplitting.compare("class")==0) {
    _EB1gt15lh->setSplitFrac ("electrons", "class0") ;
    _EB1gt15lh->setSplitFrac ("electrons", "class1") ;
  }
  else {
    throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
                                      << " splitting is implemented right now";
  }

  if (m_eleIDSwitches.m_useDeltaPhi)     _EB1gt15lh->addPdf ("electrons", "dPhi",          splitSignalPdfs) ;   
  if (m_eleIDSwitches.m_useDeltaEta)     _EB1gt15lh->addPdf ("electrons", "dEta",          splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useEoverP)       _EB1gt15lh->addPdf ("electrons", "EoP",           splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useHoverE)       _EB1gt15lh->addPdf ("electrons", "HoE",           splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useSigmaEtaEta)  _EB1gt15lh->addPdf ("electrons", "sigmaIEtaIEta", splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useSigmaPhiPhi)  _EB1gt15lh->addPdf ("electrons", "sigmaIPhiIPhi", splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useFBrem)        _EB1gt15lh->addPdf ("electrons", "fBrem",         splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useOneOverEMinusOneOverP)        _EB1gt15lh->addPdf ("electrons", "OneOverEMinusOneOverP",         splitSignalPdfs) ;

  if(backgroundWeightSplitting.compare("class")==0) {
    _EB1gt15lh->setSplitFrac ("hadrons", "class0") ;
    _EB1gt15lh->setSplitFrac ("hadrons", "class1") ;
  }
  else {
    throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
                                      << " splitting is implemented right now";
  }

  if (m_eleIDSwitches.m_useDeltaPhi)     _EB1gt15lh->addPdf ("hadrons", "dPhi",          splitBackgroundPdfs) ;   
  if (m_eleIDSwitches.m_useDeltaEta)     _EB1gt15lh->addPdf ("hadrons", "dEta",          splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useEoverP)       _EB1gt15lh->addPdf ("hadrons", "EoP",           splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useHoverE)       _EB1gt15lh->addPdf ("hadrons", "HoE",           splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useSigmaEtaEta)  _EB1gt15lh->addPdf ("hadrons", "sigmaIEtaIEta", splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useSigmaPhiPhi)  _EB1gt15lh->addPdf ("hadrons", "sigmaIPhiIPhi", splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useFBrem)        _EB1gt15lh->addPdf ("hadrons", "fBrem",         splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useOneOverEMinusOneOverP)        _EB1gt15lh->addPdf ("hadrons", "OneOverEMinusOneOverP",         splitBackgroundPdfs) ;

  // ECAL ENDCAP LIKELIHOOD - Pt < 15 GeV
  _EElt15lh->initFromDB (calibration) ;

  _EElt15lh->addSpecies ("electrons") ;
  _EElt15lh->addSpecies ("hadrons") ;

  if(signalWeightSplitting.compare("class")==0) {
    _EElt15lh->setSplitFrac ("electrons", "class0") ;
    _EElt15lh->setSplitFrac ("electrons", "class1") ;
  }
  else {
    throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
                                      << " splitting is implemented right now";
  }

  if (m_eleIDSwitches.m_useDeltaPhi)     _EElt15lh->addPdf ("electrons", "dPhi",          splitSignalPdfs) ;   
  if (m_eleIDSwitches.m_useDeltaEta)     _EElt15lh->addPdf ("electrons", "dEta",          splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useEoverP)       _EElt15lh->addPdf ("electrons", "EoP",           splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useHoverE)       _EElt15lh->addPdf ("electrons", "HoE",           splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useSigmaEtaEta)  _EElt15lh->addPdf ("electrons", "sigmaIEtaIEta", splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useSigmaPhiPhi)  _EElt15lh->addPdf ("electrons", "sigmaIPhiIPhi", splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useFBrem)        _EElt15lh->addPdf ("electrons", "fBrem",         splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useOneOverEMinusOneOverP)        _EElt15lh->addPdf ("electrons", "OneOverEMinusOneOverP",         splitSignalPdfs) ;

  if(backgroundWeightSplitting.compare("class")==0) {
    _EElt15lh->setSplitFrac ("hadrons", "class0") ;
    _EElt15lh->setSplitFrac ("hadrons", "class1") ;
  }
  else {
    throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
                                      << " splitting is implemented right now";
  }

  if (m_eleIDSwitches.m_useDeltaPhi)     _EElt15lh->addPdf ("hadrons", "dPhi",          splitBackgroundPdfs) ;   
  if (m_eleIDSwitches.m_useDeltaEta)     _EElt15lh->addPdf ("hadrons", "dEta",          splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useEoverP)       _EElt15lh->addPdf ("hadrons", "EoP",           splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useHoverE)       _EElt15lh->addPdf ("hadrons", "HoE",           splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useSigmaEtaEta)  _EElt15lh->addPdf ("hadrons", "sigmaIEtaIEta", splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useSigmaPhiPhi)  _EElt15lh->addPdf ("hadrons", "sigmaIPhiIPhi", splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useFBrem)        _EElt15lh->addPdf ("hadrons", "fBrem",         splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useOneOverEMinusOneOverP)        _EElt15lh->addPdf ("hadrons", "OneOverEMinusOneOverP",         splitBackgroundPdfs) ;

  // ECAL ENDCAP LIKELIHOOD - Pt >= 15 GeV
  _EEgt15lh->initFromDB (calibration) ;

  _EEgt15lh->addSpecies ("electrons") ;
  _EEgt15lh->addSpecies ("hadrons") ;

  if(signalWeightSplitting.compare("class")==0) {
    _EEgt15lh->setSplitFrac ("electrons", "class0") ;
    _EEgt15lh->setSplitFrac ("electrons", "class1") ;
  }
  else {
    throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
                                      << " splitting is implemented right now";
  }

  if (m_eleIDSwitches.m_useDeltaPhi)     _EEgt15lh->addPdf ("electrons", "dPhi",          splitSignalPdfs) ;   
  if (m_eleIDSwitches.m_useDeltaEta)     _EEgt15lh->addPdf ("electrons", "dEta",          splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useEoverP)       _EEgt15lh->addPdf ("electrons", "EoP",           splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useHoverE)       _EEgt15lh->addPdf ("electrons", "HoE",           splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useSigmaEtaEta)  _EEgt15lh->addPdf ("electrons", "sigmaIEtaIEta", splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useSigmaPhiPhi)  _EEgt15lh->addPdf ("electrons", "sigmaIPhiIPhi", splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useFBrem)        _EEgt15lh->addPdf ("electrons", "fBrem",         splitSignalPdfs) ;
  if (m_eleIDSwitches.m_useOneOverEMinusOneOverP)        _EEgt15lh->addPdf ("electrons", "OneOverEMinusOneOverP",         splitSignalPdfs) ;

  if(backgroundWeightSplitting.compare("class")==0) {
    _EEgt15lh->setSplitFrac ("hadrons", "class0") ;
    _EEgt15lh->setSplitFrac ("hadrons", "class1") ;
  }
  else {
    throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
                                      << " splitting is implemented right now";
  }

  if (m_eleIDSwitches.m_useDeltaPhi)     _EEgt15lh->addPdf ("hadrons", "dPhi",          splitBackgroundPdfs) ;   
  if (m_eleIDSwitches.m_useDeltaEta)     _EEgt15lh->addPdf ("hadrons", "dEta",          splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useEoverP)       _EEgt15lh->addPdf ("hadrons", "EoP",           splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useHoverE)       _EEgt15lh->addPdf ("hadrons", "HoE",           splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useSigmaEtaEta)  _EEgt15lh->addPdf ("hadrons", "sigmaIEtaIEta", splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useSigmaPhiPhi)  _EEgt15lh->addPdf ("hadrons", "sigmaIPhiIPhi", splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useFBrem)        _EEgt15lh->addPdf ("hadrons", "fBrem",         splitBackgroundPdfs) ;
  if (m_eleIDSwitches.m_useOneOverEMinusOneOverP)        _EEgt15lh->addPdf ("hadrons", "OneOverEMinusOneOverP",         splitBackgroundPdfs) ;
}

void ElectronLikelihood::setup

(

const edm::ParameterSet &

conf

)

[inline]

not used for this algo

Definition at line 36 of file ElectronLikelihood.h.

{} ;

---

Member Data Documentation

LikelihoodPdfProduct* ElectronLikelihood::_EB0gt15lh [private]

likelihood above 15GeV/c

Definition at line 64 of file ElectronLikelihood.h.

Referenced by result(), resultLog(), Setup(), and ~ElectronLikelihood().

LikelihoodPdfProduct* ElectronLikelihood::_EB0lt15lh [private]

likelihood below 15GeV/c

Definition at line 62 of file ElectronLikelihood.h.

Referenced by result(), resultLog(), Setup(), and ~ElectronLikelihood().

LikelihoodPdfProduct * ElectronLikelihood::_EB1gt15lh [private]

Definition at line 64 of file ElectronLikelihood.h.

Referenced by result(), resultLog(), Setup(), and ~ElectronLikelihood().

LikelihoodPdfProduct * ElectronLikelihood::_EB1lt15lh [private]

Definition at line 62 of file ElectronLikelihood.h.

Referenced by result(), resultLog(), Setup(), and ~ElectronLikelihood().

LikelihoodPdfProduct * ElectronLikelihood::_EEgt15lh [private]

Definition at line 64 of file ElectronLikelihood.h.

Referenced by result(), resultLog(), Setup(), and ~ElectronLikelihood().

LikelihoodPdfProduct * ElectronLikelihood::_EElt15lh [private]

Definition at line 62 of file ElectronLikelihood.h.

Referenced by result(), resultLog(), Setup(), and ~ElectronLikelihood().

std::string ElectronLikelihood::m_backgroundWeightSplitting [private]

Definition at line 71 of file ElectronLikelihood.h.

LikelihoodSwitches ElectronLikelihood::m_eleIDSwitches [private]

general parameters of all the ele id algorithms

Definition at line 67 of file ElectronLikelihood.h.

Referenced by getInputVar(), and Setup().

std::string ElectronLikelihood::m_signalWeightSplitting [private]

splitting rule for PDF's

Definition at line 70 of file ElectronLikelihood.h.

Referenced by result(), and resultLog().

bool ElectronLikelihood::m_splitBackgroundPdfs [private]

Definition at line 73 of file ElectronLikelihood.h.

bool ElectronLikelihood::m_splitSignalPdfs [private]

Definition at line 72 of file ElectronLikelihood.h.