00001 #include "FWCore/Utilities/interface/Exception.h"
00002 #include "FWCore/MessageLogger/interface/MessageLogger.h"
00003 #include "DataFormats/EcalDetId/interface/EcalSubdetector.h"
00004 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
00005
00006 #include "RecoEgamma/ElectronIdentification/interface/ElectronLikelihood.h"
00007 #include <iostream>
00008
00009
00010 ElectronLikelihood::ElectronLikelihood (const ElectronLikelihoodCalibration *calibration,
00011 LikelihoodSwitches eleIDSwitches,
00012 std::string signalWeightSplitting,
00013 std::string backgroundWeightSplitting,
00014 bool splitSignalPdfs,
00015 bool splitBackgroundPdfs) :
00016 _EB0lt15lh (new LikelihoodPdfProduct ("electronID_EB0_ptLt15_likelihood",0,0)) ,
00017 _EB1lt15lh (new LikelihoodPdfProduct ("electronID_EB1_ptLt15_likelihood",1,0)) ,
00018 _EElt15lh (new LikelihoodPdfProduct ("electronID_EE_ptLt15_likelihood",2,0)) ,
00019 _EB0gt15lh (new LikelihoodPdfProduct ("electronID_EB0_ptGt15_likelihood",0,1)) ,
00020 _EB1gt15lh (new LikelihoodPdfProduct ("electronID_EB1_ptGt15_likelihood",1,1)) ,
00021 _EEgt15lh (new LikelihoodPdfProduct ("electronID_EE_ptGt15_likelihood",2,1)) ,
00022 m_eleIDSwitches (eleIDSwitches) ,
00023 m_signalWeightSplitting (signalWeightSplitting),
00024 m_backgroundWeightSplitting (backgroundWeightSplitting),
00025 m_splitSignalPdfs (splitSignalPdfs),
00026 m_splitBackgroundPdfs (splitBackgroundPdfs)
00027 {
00028 Setup (calibration,
00029 signalWeightSplitting, backgroundWeightSplitting,
00030 splitSignalPdfs, splitBackgroundPdfs) ;
00031 }
00032
00033
00034
00035
00036
00037
00038
00039 ElectronLikelihood::~ElectronLikelihood () {
00040 delete _EB0lt15lh ;
00041 delete _EB1lt15lh ;
00042 delete _EElt15lh ;
00043 delete _EB0gt15lh ;
00044 delete _EB1gt15lh ;
00045 delete _EEgt15lh ;
00046 }
00047
00048
00049
00050
00051
00052
00053 void
00054 ElectronLikelihood::Setup (const ElectronLikelihoodCalibration *calibration,
00055 std::string signalWeightSplitting,
00056 std::string backgroundWeightSplitting,
00057 bool splitSignalPdfs,
00058 bool splitBackgroundPdfs)
00059 {
00060
00061
00062 _EB0lt15lh->initFromDB (calibration) ;
00063
00064 _EB0lt15lh->addSpecies ("electrons") ;
00065 _EB0lt15lh->addSpecies ("hadrons") ;
00066
00067 if(signalWeightSplitting.compare("class")==0) {
00068 _EB0lt15lh->setSplitFrac ("electrons", "class0") ;
00069 _EB0lt15lh->setSplitFrac ("electrons", "class1") ;
00070 }
00071 else {
00072 throw cms::Exception("BadConfig") << "Only class (non-showering / showering)"
00073 << " and fullclass (golden / bigbrem / narrow / showering)"
00074 << " splitting is implemented right now";
00075 }
00076
00077 if (m_eleIDSwitches.m_useDeltaPhi) _EB0lt15lh->addPdf ("electrons", "dPhi", splitSignalPdfs) ;
00078 if (m_eleIDSwitches.m_useDeltaEta) _EB0lt15lh->addPdf ("electrons", "dEta", splitSignalPdfs) ;
00079 if (m_eleIDSwitches.m_useEoverP) _EB0lt15lh->addPdf ("electrons", "EoP", splitSignalPdfs) ;
00080 if (m_eleIDSwitches.m_useHoverE) _EB0lt15lh->addPdf ("electrons", "HoE", splitSignalPdfs) ;
00081 if (m_eleIDSwitches.m_useSigmaEtaEta) _EB0lt15lh->addPdf ("electrons", "sigmaIEtaIEta", splitSignalPdfs) ;
00082 if (m_eleIDSwitches.m_useSigmaPhiPhi) _EB0lt15lh->addPdf ("electrons", "sigmaIPhiIPhi", splitSignalPdfs) ;
00083 if (m_eleIDSwitches.m_useFBrem) _EB0lt15lh->addPdf ("electrons", "fBrem", splitSignalPdfs) ;
00084 if (m_eleIDSwitches.m_useOneOverEMinusOneOverP) _EB0lt15lh->addPdf ("electrons", "OneOverEMinusOneOverP", splitSignalPdfs) ;
00085
00086 if(backgroundWeightSplitting.compare("class")==0) {
00087 _EB0lt15lh->setSplitFrac ("hadrons", "class0") ;
00088 _EB0lt15lh->setSplitFrac ("hadrons", "class1") ;
00089 }
00090 else {
00091 throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
00092 << " splitting is implemented right now";
00093 }
00094
00095 if (m_eleIDSwitches.m_useDeltaPhi) _EB0lt15lh->addPdf ("hadrons", "dPhi", splitBackgroundPdfs) ;
00096 if (m_eleIDSwitches.m_useDeltaEta) _EB0lt15lh->addPdf ("hadrons", "dEta", splitBackgroundPdfs) ;
00097 if (m_eleIDSwitches.m_useEoverP) _EB0lt15lh->addPdf ("hadrons", "EoP", splitBackgroundPdfs) ;
00098 if (m_eleIDSwitches.m_useHoverE) _EB0lt15lh->addPdf ("hadrons", "HoE", splitBackgroundPdfs) ;
00099 if (m_eleIDSwitches.m_useSigmaEtaEta) _EB0lt15lh->addPdf ("hadrons", "sigmaIEtaIEta", splitBackgroundPdfs) ;
00100 if (m_eleIDSwitches.m_useSigmaPhiPhi) _EB0lt15lh->addPdf ("hadrons", "sigmaIPhiIPhi", splitBackgroundPdfs) ;
00101 if (m_eleIDSwitches.m_useFBrem) _EB0lt15lh->addPdf ("hadrons", "fBrem", splitBackgroundPdfs) ;
00102 if (m_eleIDSwitches.m_useOneOverEMinusOneOverP) _EB0lt15lh->addPdf ("hadrons", "OneOverEMinusOneOverP", splitBackgroundPdfs) ;
00103
00104
00105 _EB0gt15lh->initFromDB (calibration) ;
00106
00107 _EB0gt15lh->addSpecies ("electrons") ;
00108 _EB0gt15lh->addSpecies ("hadrons") ;
00109
00110 if(signalWeightSplitting.compare("class")==0) {
00111 _EB0gt15lh->setSplitFrac ("electrons", "class0") ;
00112 _EB0gt15lh->setSplitFrac ("electrons", "class1") ;
00113 }
00114 else {
00115 throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
00116 << " splitting is implemented right now";
00117 }
00118
00119 if (m_eleIDSwitches.m_useDeltaPhi) _EB0gt15lh->addPdf ("electrons", "dPhi", splitSignalPdfs) ;
00120 if (m_eleIDSwitches.m_useDeltaEta) _EB0gt15lh->addPdf ("electrons", "dEta", splitSignalPdfs) ;
00121 if (m_eleIDSwitches.m_useEoverP) _EB0gt15lh->addPdf ("electrons", "EoP", splitSignalPdfs) ;
00122 if (m_eleIDSwitches.m_useHoverE) _EB0gt15lh->addPdf ("electrons", "HoE", splitSignalPdfs) ;
00123 if (m_eleIDSwitches.m_useSigmaEtaEta) _EB0gt15lh->addPdf ("electrons", "sigmaIEtaIEta", splitSignalPdfs) ;
00124 if (m_eleIDSwitches.m_useSigmaPhiPhi) _EB0gt15lh->addPdf ("electrons", "sigmaIPhiIPhi", splitSignalPdfs) ;
00125 if (m_eleIDSwitches.m_useFBrem) _EB0gt15lh->addPdf ("electrons", "fBrem", splitSignalPdfs) ;
00126 if (m_eleIDSwitches.m_useOneOverEMinusOneOverP) _EB0gt15lh->addPdf ("electrons", "OneOverEMinusOneOverP", splitSignalPdfs) ;
00127
00128 if(backgroundWeightSplitting.compare("class")==0) {
00129 _EB0gt15lh->setSplitFrac ("hadrons", "class0") ;
00130 _EB0gt15lh->setSplitFrac ("hadrons", "class1") ;
00131 }
00132 else {
00133 throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
00134 << " splitting is implemented right now";
00135 }
00136
00137 if (m_eleIDSwitches.m_useDeltaPhi) _EB0gt15lh->addPdf ("hadrons", "dPhi", splitBackgroundPdfs) ;
00138 if (m_eleIDSwitches.m_useDeltaEta) _EB0gt15lh->addPdf ("hadrons", "dEta", splitBackgroundPdfs) ;
00139 if (m_eleIDSwitches.m_useEoverP) _EB0gt15lh->addPdf ("hadrons", "EoP", splitBackgroundPdfs) ;
00140 if (m_eleIDSwitches.m_useHoverE) _EB0gt15lh->addPdf ("hadrons", "HoE", splitBackgroundPdfs) ;
00141 if (m_eleIDSwitches.m_useSigmaEtaEta) _EB0gt15lh->addPdf ("hadrons", "sigmaIEtaIEta", splitBackgroundPdfs) ;
00142 if (m_eleIDSwitches.m_useSigmaPhiPhi) _EB0gt15lh->addPdf ("hadrons", "sigmaIPhiIPhi", splitBackgroundPdfs) ;
00143 if (m_eleIDSwitches.m_useFBrem) _EB0gt15lh->addPdf ("hadrons", "fBrem", splitBackgroundPdfs) ;
00144 if (m_eleIDSwitches.m_useOneOverEMinusOneOverP) _EB0gt15lh->addPdf ("hadrons", "OneOverEMinusOneOverP", splitBackgroundPdfs) ;
00145
00146
00147
00148 _EB1lt15lh->initFromDB (calibration) ;
00149
00150 _EB1lt15lh->addSpecies ("electrons") ;
00151 _EB1lt15lh->addSpecies ("hadrons") ;
00152
00153 if(signalWeightSplitting.compare("class")==0) {
00154 _EB1lt15lh->setSplitFrac ("electrons", "class0") ;
00155 _EB1lt15lh->setSplitFrac ("electrons", "class1") ;
00156 }
00157 else {
00158 throw cms::Exception("BadConfig") << "Only class (non-showering / showering)"
00159 << " and fullclass (golden / bigbrem / narrow / showering)"
00160 << " splitting is implemented right now";
00161 }
00162
00163 if (m_eleIDSwitches.m_useDeltaPhi) _EB1lt15lh->addPdf ("electrons", "dPhi", splitSignalPdfs) ;
00164 if (m_eleIDSwitches.m_useDeltaEta) _EB1lt15lh->addPdf ("electrons", "dEta", splitSignalPdfs) ;
00165 if (m_eleIDSwitches.m_useEoverP) _EB1lt15lh->addPdf ("electrons", "EoP", splitSignalPdfs) ;
00166 if (m_eleIDSwitches.m_useHoverE) _EB1lt15lh->addPdf ("electrons", "HoE", splitSignalPdfs) ;
00167 if (m_eleIDSwitches.m_useSigmaEtaEta) _EB1lt15lh->addPdf ("electrons", "sigmaIEtaIEta", splitSignalPdfs) ;
00168 if (m_eleIDSwitches.m_useSigmaPhiPhi) _EB1lt15lh->addPdf ("electrons", "sigmaIPhiIPhi", splitSignalPdfs) ;
00169 if (m_eleIDSwitches.m_useFBrem) _EB1lt15lh->addPdf ("electrons", "fBrem", splitSignalPdfs) ;
00170 if (m_eleIDSwitches.m_useOneOverEMinusOneOverP) _EB1lt15lh->addPdf ("electrons", "OneOverEMinusOneOverP", splitSignalPdfs) ;
00171
00172 if(backgroundWeightSplitting.compare("class")==0) {
00173 _EB1lt15lh->setSplitFrac ("hadrons", "class0") ;
00174 _EB1lt15lh->setSplitFrac ("hadrons", "class1") ;
00175 }
00176 else {
00177 throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
00178 << " splitting is implemented right now";
00179 }
00180
00181 if (m_eleIDSwitches.m_useDeltaPhi) _EB1lt15lh->addPdf ("hadrons", "dPhi", splitBackgroundPdfs) ;
00182 if (m_eleIDSwitches.m_useDeltaEta) _EB1lt15lh->addPdf ("hadrons", "dEta", splitBackgroundPdfs) ;
00183 if (m_eleIDSwitches.m_useEoverP) _EB1lt15lh->addPdf ("hadrons", "EoP", splitBackgroundPdfs) ;
00184 if (m_eleIDSwitches.m_useHoverE) _EB1lt15lh->addPdf ("hadrons", "HoE", splitBackgroundPdfs) ;
00185 if (m_eleIDSwitches.m_useSigmaEtaEta) _EB1lt15lh->addPdf ("hadrons", "sigmaIEtaIEta", splitBackgroundPdfs) ;
00186 if (m_eleIDSwitches.m_useSigmaPhiPhi) _EB1lt15lh->addPdf ("hadrons", "sigmaIPhiIPhi", splitBackgroundPdfs) ;
00187 if (m_eleIDSwitches.m_useFBrem) _EB1lt15lh->addPdf ("hadrons", "fBrem", splitBackgroundPdfs) ;
00188 if (m_eleIDSwitches.m_useOneOverEMinusOneOverP) _EB1lt15lh->addPdf ("hadrons", "OneOverEMinusOneOverP", splitBackgroundPdfs) ;
00189
00190
00191 _EB1gt15lh->initFromDB (calibration) ;
00192
00193 _EB1gt15lh->addSpecies ("electrons") ;
00194 _EB1gt15lh->addSpecies ("hadrons") ;
00195
00196 if(signalWeightSplitting.compare("class")==0) {
00197 _EB1gt15lh->setSplitFrac ("electrons", "class0") ;
00198 _EB1gt15lh->setSplitFrac ("electrons", "class1") ;
00199 }
00200 else {
00201 throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
00202 << " splitting is implemented right now";
00203 }
00204
00205 if (m_eleIDSwitches.m_useDeltaPhi) _EB1gt15lh->addPdf ("electrons", "dPhi", splitSignalPdfs) ;
00206 if (m_eleIDSwitches.m_useDeltaEta) _EB1gt15lh->addPdf ("electrons", "dEta", splitSignalPdfs) ;
00207 if (m_eleIDSwitches.m_useEoverP) _EB1gt15lh->addPdf ("electrons", "EoP", splitSignalPdfs) ;
00208 if (m_eleIDSwitches.m_useHoverE) _EB1gt15lh->addPdf ("electrons", "HoE", splitSignalPdfs) ;
00209 if (m_eleIDSwitches.m_useSigmaEtaEta) _EB1gt15lh->addPdf ("electrons", "sigmaIEtaIEta", splitSignalPdfs) ;
00210 if (m_eleIDSwitches.m_useSigmaPhiPhi) _EB1gt15lh->addPdf ("electrons", "sigmaIPhiIPhi", splitSignalPdfs) ;
00211 if (m_eleIDSwitches.m_useFBrem) _EB1gt15lh->addPdf ("electrons", "fBrem", splitSignalPdfs) ;
00212 if (m_eleIDSwitches.m_useOneOverEMinusOneOverP) _EB1gt15lh->addPdf ("electrons", "OneOverEMinusOneOverP", splitSignalPdfs) ;
00213
00214 if(backgroundWeightSplitting.compare("class")==0) {
00215 _EB1gt15lh->setSplitFrac ("hadrons", "class0") ;
00216 _EB1gt15lh->setSplitFrac ("hadrons", "class1") ;
00217 }
00218 else {
00219 throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
00220 << " splitting is implemented right now";
00221 }
00222
00223 if (m_eleIDSwitches.m_useDeltaPhi) _EB1gt15lh->addPdf ("hadrons", "dPhi", splitBackgroundPdfs) ;
00224 if (m_eleIDSwitches.m_useDeltaEta) _EB1gt15lh->addPdf ("hadrons", "dEta", splitBackgroundPdfs) ;
00225 if (m_eleIDSwitches.m_useEoverP) _EB1gt15lh->addPdf ("hadrons", "EoP", splitBackgroundPdfs) ;
00226 if (m_eleIDSwitches.m_useHoverE) _EB1gt15lh->addPdf ("hadrons", "HoE", splitBackgroundPdfs) ;
00227 if (m_eleIDSwitches.m_useSigmaEtaEta) _EB1gt15lh->addPdf ("hadrons", "sigmaIEtaIEta", splitBackgroundPdfs) ;
00228 if (m_eleIDSwitches.m_useSigmaPhiPhi) _EB1gt15lh->addPdf ("hadrons", "sigmaIPhiIPhi", splitBackgroundPdfs) ;
00229 if (m_eleIDSwitches.m_useFBrem) _EB1gt15lh->addPdf ("hadrons", "fBrem", splitBackgroundPdfs) ;
00230 if (m_eleIDSwitches.m_useOneOverEMinusOneOverP) _EB1gt15lh->addPdf ("hadrons", "OneOverEMinusOneOverP", splitBackgroundPdfs) ;
00231
00232
00233 _EElt15lh->initFromDB (calibration) ;
00234
00235 _EElt15lh->addSpecies ("electrons") ;
00236 _EElt15lh->addSpecies ("hadrons") ;
00237
00238 if(signalWeightSplitting.compare("class")==0) {
00239 _EElt15lh->setSplitFrac ("electrons", "class0") ;
00240 _EElt15lh->setSplitFrac ("electrons", "class1") ;
00241 }
00242 else {
00243 throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
00244 << " splitting is implemented right now";
00245 }
00246
00247 if (m_eleIDSwitches.m_useDeltaPhi) _EElt15lh->addPdf ("electrons", "dPhi", splitSignalPdfs) ;
00248 if (m_eleIDSwitches.m_useDeltaEta) _EElt15lh->addPdf ("electrons", "dEta", splitSignalPdfs) ;
00249 if (m_eleIDSwitches.m_useEoverP) _EElt15lh->addPdf ("electrons", "EoP", splitSignalPdfs) ;
00250 if (m_eleIDSwitches.m_useHoverE) _EElt15lh->addPdf ("electrons", "HoE", splitSignalPdfs) ;
00251 if (m_eleIDSwitches.m_useSigmaEtaEta) _EElt15lh->addPdf ("electrons", "sigmaIEtaIEta", splitSignalPdfs) ;
00252 if (m_eleIDSwitches.m_useSigmaPhiPhi) _EElt15lh->addPdf ("electrons", "sigmaIPhiIPhi", splitSignalPdfs) ;
00253 if (m_eleIDSwitches.m_useFBrem) _EElt15lh->addPdf ("electrons", "fBrem", splitSignalPdfs) ;
00254 if (m_eleIDSwitches.m_useOneOverEMinusOneOverP) _EElt15lh->addPdf ("electrons", "OneOverEMinusOneOverP", splitSignalPdfs) ;
00255
00256 if(backgroundWeightSplitting.compare("class")==0) {
00257 _EElt15lh->setSplitFrac ("hadrons", "class0") ;
00258 _EElt15lh->setSplitFrac ("hadrons", "class1") ;
00259 }
00260 else {
00261 throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
00262 << " splitting is implemented right now";
00263 }
00264
00265 if (m_eleIDSwitches.m_useDeltaPhi) _EElt15lh->addPdf ("hadrons", "dPhi", splitBackgroundPdfs) ;
00266 if (m_eleIDSwitches.m_useDeltaEta) _EElt15lh->addPdf ("hadrons", "dEta", splitBackgroundPdfs) ;
00267 if (m_eleIDSwitches.m_useEoverP) _EElt15lh->addPdf ("hadrons", "EoP", splitBackgroundPdfs) ;
00268 if (m_eleIDSwitches.m_useHoverE) _EElt15lh->addPdf ("hadrons", "HoE", splitBackgroundPdfs) ;
00269 if (m_eleIDSwitches.m_useSigmaEtaEta) _EElt15lh->addPdf ("hadrons", "sigmaIEtaIEta", splitBackgroundPdfs) ;
00270 if (m_eleIDSwitches.m_useSigmaPhiPhi) _EElt15lh->addPdf ("hadrons", "sigmaIPhiIPhi", splitBackgroundPdfs) ;
00271 if (m_eleIDSwitches.m_useFBrem) _EElt15lh->addPdf ("hadrons", "fBrem", splitBackgroundPdfs) ;
00272 if (m_eleIDSwitches.m_useOneOverEMinusOneOverP) _EElt15lh->addPdf ("hadrons", "OneOverEMinusOneOverP", splitBackgroundPdfs) ;
00273
00274
00275 _EEgt15lh->initFromDB (calibration) ;
00276
00277 _EEgt15lh->addSpecies ("electrons") ;
00278 _EEgt15lh->addSpecies ("hadrons") ;
00279
00280 if(signalWeightSplitting.compare("class")==0) {
00281 _EEgt15lh->setSplitFrac ("electrons", "class0") ;
00282 _EEgt15lh->setSplitFrac ("electrons", "class1") ;
00283 }
00284 else {
00285 throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
00286 << " splitting is implemented right now";
00287 }
00288
00289 if (m_eleIDSwitches.m_useDeltaPhi) _EEgt15lh->addPdf ("electrons", "dPhi", splitSignalPdfs) ;
00290 if (m_eleIDSwitches.m_useDeltaEta) _EEgt15lh->addPdf ("electrons", "dEta", splitSignalPdfs) ;
00291 if (m_eleIDSwitches.m_useEoverP) _EEgt15lh->addPdf ("electrons", "EoP", splitSignalPdfs) ;
00292 if (m_eleIDSwitches.m_useHoverE) _EEgt15lh->addPdf ("electrons", "HoE", splitSignalPdfs) ;
00293 if (m_eleIDSwitches.m_useSigmaEtaEta) _EEgt15lh->addPdf ("electrons", "sigmaIEtaIEta", splitSignalPdfs) ;
00294 if (m_eleIDSwitches.m_useSigmaPhiPhi) _EEgt15lh->addPdf ("electrons", "sigmaIPhiIPhi", splitSignalPdfs) ;
00295 if (m_eleIDSwitches.m_useFBrem) _EEgt15lh->addPdf ("electrons", "fBrem", splitSignalPdfs) ;
00296 if (m_eleIDSwitches.m_useOneOverEMinusOneOverP) _EEgt15lh->addPdf ("electrons", "OneOverEMinusOneOverP", splitSignalPdfs) ;
00297
00298 if(backgroundWeightSplitting.compare("class")==0) {
00299 _EEgt15lh->setSplitFrac ("hadrons", "class0") ;
00300 _EEgt15lh->setSplitFrac ("hadrons", "class1") ;
00301 }
00302 else {
00303 throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
00304 << " splitting is implemented right now";
00305 }
00306
00307 if (m_eleIDSwitches.m_useDeltaPhi) _EEgt15lh->addPdf ("hadrons", "dPhi", splitBackgroundPdfs) ;
00308 if (m_eleIDSwitches.m_useDeltaEta) _EEgt15lh->addPdf ("hadrons", "dEta", splitBackgroundPdfs) ;
00309 if (m_eleIDSwitches.m_useEoverP) _EEgt15lh->addPdf ("hadrons", "EoP", splitBackgroundPdfs) ;
00310 if (m_eleIDSwitches.m_useHoverE) _EEgt15lh->addPdf ("hadrons", "HoE", splitBackgroundPdfs) ;
00311 if (m_eleIDSwitches.m_useSigmaEtaEta) _EEgt15lh->addPdf ("hadrons", "sigmaIEtaIEta", splitBackgroundPdfs) ;
00312 if (m_eleIDSwitches.m_useSigmaPhiPhi) _EEgt15lh->addPdf ("hadrons", "sigmaIPhiIPhi", splitBackgroundPdfs) ;
00313 if (m_eleIDSwitches.m_useFBrem) _EEgt15lh->addPdf ("hadrons", "fBrem", splitBackgroundPdfs) ;
00314 if (m_eleIDSwitches.m_useOneOverEMinusOneOverP) _EEgt15lh->addPdf ("hadrons", "OneOverEMinusOneOverP", splitBackgroundPdfs) ;
00315 }
00316
00317
00318
00319
00320
00321
00322
00323 void
00324 ElectronLikelihood::getInputVar (const reco::GsfElectron &electron,
00325 std::vector<float> &measurements,
00326 EcalClusterLazyTools myEcalCluster) const
00327 {
00328
00329
00330 if (m_eleIDSwitches.m_useDeltaPhi) measurements.push_back ( electron.deltaPhiSuperClusterTrackAtVtx () ) ;
00331 if (m_eleIDSwitches.m_useDeltaEta) measurements.push_back ( electron.deltaEtaSuperClusterTrackAtVtx () ) ;
00332 if (m_eleIDSwitches.m_useEoverP) measurements.push_back ( electron.eSuperClusterOverP () ) ;
00333 if (m_eleIDSwitches.m_useHoverE) measurements.push_back ( electron.hadronicOverEm () ) ;
00334 std::vector<float> vCov = myEcalCluster.localCovariances(*(electron.superCluster()->seed())) ;
00335 if (m_eleIDSwitches.m_useSigmaEtaEta) measurements.push_back ( sqrt (vCov[0]) );
00336 if (m_eleIDSwitches.m_useSigmaPhiPhi) measurements.push_back ( sqrt (vCov[2]) );
00337 if(m_eleIDSwitches.m_useFBrem) measurements.push_back( electron.fbrem() );
00338
00339 reco::GsfTrackRef trkRef = electron.get<reco::GsfTrackRef>();
00340 float OneOverEMinusOneOverP = 1.0/(electron.eSuperClusterOverP() * trkRef->p()) - 1.0/trkRef->p();
00341 if(m_eleIDSwitches.m_useOneOverEMinusOneOverP) measurements.push_back( OneOverEMinusOneOverP );
00342
00343 }
00344
00345
00346
00347
00348
00349
00350
00351 float
00352 ElectronLikelihood::result (const reco::GsfElectron &electron,
00353 EcalClusterLazyTools myEcalCluster) const
00354 {
00355
00356
00357
00358
00359
00360
00361
00362 std::vector<float> measurements ;
00363 getInputVar (electron, measurements, myEcalCluster) ;
00364
00365
00366 int bitVal=(electron.numberOfBrems()==0) ? 0 : 1 ;
00367
00368 char className[20];
00369 if(m_signalWeightSplitting.compare("class")==0) {
00370 snprintf(className, 20, "class%d", bitVal);
00371 } else {
00372 throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
00373 << " splitting is implemented right now";
00374 }
00375
00376 reco::SuperClusterRef sclusRef = electron.superCluster() ;
00377 EcalSubdetector subdet = EcalSubdetector (sclusRef->hitsAndFractions()[0].first.subdetId ()) ;
00378 float thisPt = electron.pt();
00379
00380 if (subdet==EcalBarrel && fabs(electron.eta())<=1.0 && thisPt<15.)
00381 return _EB0lt15lh->getRatio ("electrons",measurements,std::string (className)) ;
00382 else if (subdet==EcalBarrel && fabs(electron.eta())<=1.0 && thisPt>=15.)
00383 return _EB0gt15lh->getRatio ("electrons",measurements,std::string (className)) ;
00384 else if (subdet==EcalBarrel && fabs(electron.eta())>1.0 && thisPt<15.)
00385 return _EB1lt15lh->getRatio ("electrons",measurements,std::string (className)) ;
00386 else if (subdet==EcalBarrel && fabs(electron.eta())>1.0 && thisPt>=15.)
00387 return _EB1gt15lh->getRatio ("electrons",measurements,std::string (className)) ;
00388 else if (subdet==EcalEndcap && thisPt<15.)
00389 return _EElt15lh->getRatio ("electrons",measurements,std::string (className)) ;
00390 else if (subdet==EcalEndcap && thisPt>=15.)
00391 return _EEgt15lh->getRatio ("electrons",measurements,std::string (className)) ;
00392 else return -999. ;
00393 }
00394
00395 float
00396 ElectronLikelihood::resultLog (const reco::GsfElectron &electron,
00397 EcalClusterLazyTools myEcalCluster) const
00398 {
00399
00400
00401
00402
00403
00404
00405
00406 std::vector<float> measurements ;
00407 getInputVar (electron, measurements, myEcalCluster) ;
00408
00409
00410 int bitVal=(electron.numberOfBrems()==0) ? 0 : 1 ;
00411
00412 char className[20];
00413 if(m_signalWeightSplitting.compare("class")==0) {
00414 snprintf(className, 20, "class%d", bitVal);
00415 } else {
00416 throw cms::Exception("BadConfig") << "Only class (0 brem clusters / >=1 brem clusters)"
00417 << " splitting is implemented right now";
00418 }
00419
00420 reco::SuperClusterRef sclusRef = electron.superCluster() ;
00421 EcalSubdetector subdet = EcalSubdetector (sclusRef->hitsAndFractions()[0].first.subdetId ()) ;
00422 float thisPt = electron.pt();
00423
00424 float lh=-999.;
00425
00426 if (subdet==EcalBarrel && fabs(electron.eta())<=1.0 && thisPt<15.)
00427 lh = _EB0lt15lh->getRatio ("electrons",measurements,std::string (className)) ;
00428 else if (subdet==EcalBarrel && fabs(electron.eta())<=1.0 && thisPt>=15.)
00429 lh = _EB0gt15lh->getRatio ("electrons",measurements,std::string (className)) ;
00430 else if (subdet==EcalBarrel && fabs(electron.eta())>1.0 && thisPt<15.)
00431 lh = _EB1lt15lh->getRatio ("electrons",measurements,std::string (className)) ;
00432 else if (subdet==EcalBarrel && fabs(electron.eta())>1.0 && thisPt>=15.)
00433 lh = _EB1gt15lh->getRatio ("electrons",measurements,std::string (className)) ;
00434 else if (subdet==EcalEndcap && thisPt<15.)
00435 lh = _EElt15lh->getRatio ("electrons",measurements,std::string (className)) ;
00436 else if (subdet==EcalEndcap && thisPt>=15.)
00437 lh = _EEgt15lh->getRatio ("electrons",measurements,std::string (className)) ;
00438 else lh = -999. ;
00439
00440 if(lh<=0) return -20.;
00441 else if(lh==1) return 20.;
00442 else return log(lh/(1.0-lh));
00443
00444 }
00445
1.7.3