ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitPhysics/Utils/src/ElectronIDMVA.cc
(Generate patch)

Comparing UserCode/MitPhysics/Utils/src/ElectronIDMVA.cc (file contents):
Revision 1.2 by sixie, Sun Sep 25 15:03:41 2011 UTC vs.
Revision 1.9 by sixie, Wed Jan 4 14:39:16 2012 UTC

# Line 15 | Line 15 | using namespace mithep;
15   //--------------------------------------------------------------------------------------------------
16   ElectronIDMVA::ElectronIDMVA() :
17   fMethodname("BDTG method"),
18 – fLH(0),
18   fIsInitialized(kFALSE)
19   {
20    // Constructor.
# Line 41 | Line 40 | void ElectronIDMVA::Initialize( TString
40                                  TString Subdet0Pt20ToInfWeights,
41                                  TString Subdet1Pt20ToInfWeights,
42                                  TString Subdet2Pt20ToInfWeights,
43 <                                ElectronLikelihood *LH) {
43 >                                ElectronIDMVA::MVAType type) {
44  
45    fIsInitialized = kTRUE;
46    
47    fMethodname = methodName;
49 –  fLH = LH;    
50 –  if (!fLH) { std::cout << "Error: Likelihood is not properly initialized.\n"; assert(fLH); }
48      
49    for(UInt_t i=0; i<6; ++i) {
50      if (fTMVAReader[i]) delete fTMVAReader[i];
51  
52      fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );  
53      fTMVAReader[i]->SetVerbose(kTRUE);
54 <    fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
55 <    fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
56 <    fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
57 <    fTMVAReader[i]->AddVariable( "HoverE",                &fMVAVar_EleHoverE                );
58 <    fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                    );
59 <    fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
60 <    fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                );
61 <    fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout  );
62 <    fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
63 <    fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
64 <    fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );
65 <    fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn   );
66 <    fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                  );
67 <    fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig               );
68 <    fTMVAReader[i]->AddVariable( "StandardLikelihood",    &fMVAVar_EleStandardLikelihood    );
54 >
55 >    if (type == kBaseline) {
56 >      fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
57 >      fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
58 >      fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
59 >      fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
60 >      fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
61 >      fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
62 >      fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );      
63 >    }
64 >    
65 >    if (type == kNoIPInfo) {
66 >      fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
67 >      fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
68 >      fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
69 >      fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
70 >      fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
71 >      fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
72 >      fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
73 >      fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
74 >      fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );      
75 >      fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
76 >    }
77 >    if (type == kWithIPInfo) {
78 >      fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
79 >      fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
80 >      fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
81 >      fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                       );
82 >      fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
83 >      fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
84 >      fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
85 >      fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
86 >      fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
87 >      fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );      
88 >      fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
89 >      fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
90 >      fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
91 >    }
92 >    if (type == kIDIsoCombined) {
93 >      fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
94 >      fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
95 >      fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
96 >      fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                       );
97 >      fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
98 >      fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
99 >      fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
100 >      fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
101 >      fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );      
102 >      fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
103 >      fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
104 >      fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
105 >
106 >      fTMVAReader[i]->AddVariable( "GsfTrackChi2OverNdof",  &fMVAVar_EleGsfTrackChi2OverNdof     );
107 >      fTMVAReader[i]->AddVariable( "dEtaCalo",              &fMVAVar_EledEtaCalo                 );
108 >      fTMVAReader[i]->AddVariable( "dPhiCalo",              &fMVAVar_EledPhiCalo                 );
109 >      fTMVAReader[i]->AddVariable( "R9",                    &fMVAVar_EleR9                       );
110 >      fTMVAReader[i]->AddVariable( "SCEtaWidth",            &fMVAVar_EleSCEtaWidth               );
111 >      fTMVAReader[i]->AddVariable( "SCPhiWidth",            &fMVAVar_EleSCPhiWidth               );
112 >      fTMVAReader[i]->AddVariable( "CovIEtaIPhi",           &fMVAVar_EleCovIEtaIPhi              );
113 >      if (i == 2 || i == 5) {
114 >        fTMVAReader[i]->AddVariable( "PreShowerOverRaw",      &fMVAVar_ElePreShowerOverRaw       );
115 >      }
116 >      fTMVAReader[i]->AddVariable( "ChargedIso03",          &fMVAVar_EleChargedIso03OverPt       );
117 >      fTMVAReader[i]->AddVariable( "NeutralHadronIso03",    &fMVAVar_EleNeutralHadronIso03OverPt );
118 >      fTMVAReader[i]->AddVariable( "GammaIso03",            &fMVAVar_EleGammaIso03OverPt         );
119 >      fTMVAReader[i]->AddVariable( "ChargedIso04",          &fMVAVar_EleChargedIso04OverPt       );
120 >      fTMVAReader[i]->AddVariable( "NeutralHadronIso04",    &fMVAVar_EleNeutralHadronIso04OverPt );
121 >      fTMVAReader[i]->AddVariable( "GammaIso04",            &fMVAVar_EleGammaIso04OverPt         );
122 >
123 >    }
124  
125      if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To20Weights );
126      if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To20Weights );
# Line 80 | Line 132 | void ElectronIDMVA::Initialize( TString
132    }
133  
134    std::cout << "Electron ID MVA Initialization\n";
135 <  std::cout << "MethodName : " << fMethodname << std::endl;
135 >  std::cout << "MethodName : " << fMethodname << " , type == " << type << std::endl;
136    std::cout << "Load weights file : " << Subdet0Pt10To20Weights << std::endl;
137    std::cout << "Load weights file : " << Subdet1Pt10To20Weights << std::endl;
138    std::cout << "Load weights file : " << Subdet2Pt10To20Weights << std::endl;
# Line 90 | Line 142 | void ElectronIDMVA::Initialize( TString
142  
143   }
144  
145 + //--------------------------------------------------------------------------------------------------
146 + Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleEta,
147 +                                 Double_t EleSigmaIEtaIEta,
148 +                                 Double_t EleDEtaIn,
149 +                                 Double_t EleDPhiIn,
150 +                                 Double_t EleHoverE,
151 +                                 Double_t EleD0,
152 +                                 Double_t EleDZ,
153 +                                 Double_t EleFBrem,
154 +                                 Double_t EleEOverP,
155 +                                 Double_t EleESeedClusterOverPout,
156 +                                 Double_t EleSigmaIPhiIPhi,
157 +                                 Double_t EleNBrem,
158 +                                 Double_t EleOneOverEMinusOneOverP,
159 +                                 Double_t EleESeedClusterOverPIn,
160 +                                 Double_t EleIP3d,
161 +                                 Double_t EleIP3dSig
162 +  ) {
163 +  
164 +  if (!fIsInitialized) {
165 +    std::cout << "Error: ElectronIDMVA not properly initialized.\n";
166 +    return -9999;
167 +  }
168 +
169 +  Int_t subdet = 0;
170 +  if (fabs(EleEta) < 1.0) subdet = 0;
171 +  else if (fabs(EleEta) < 1.479) subdet = 1;
172 +  else subdet = 2;
173 +  Int_t ptBin = 0;
174 +  if (ElePt > 20.0) ptBin = 1;
175 +  
176 +  //set all input variables
177 +  fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
178 +  fMVAVar_EleDEtaIn = EleDEtaIn;
179 +  fMVAVar_EleDPhiIn = EleDPhiIn;
180 +  fMVAVar_EleHoverE = EleHoverE;
181 +  fMVAVar_EleD0 = EleD0;
182 +  fMVAVar_EleDZ = EleDZ;
183 +  fMVAVar_EleFBrem = EleFBrem;
184 +  fMVAVar_EleEOverP = EleEOverP;
185 +  fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
186 +  fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
187 +  fMVAVar_EleNBrem = EleNBrem;
188 +  fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
189 +  fMVAVar_EleESeedClusterOverPIn = EleESeedClusterOverPIn;
190 +  fMVAVar_EleIP3d = EleIP3d;
191 +  fMVAVar_EleIP3dSig = EleIP3dSig;
192 +
193 +  Double_t mva = -9999;  
194 +  TMVA::Reader *reader = 0;
195 +  Int_t MVABin = -1;
196 +  if (subdet == 0 && ptBin == 0) MVABin = 0;
197 +  if (subdet == 1 && ptBin == 0) MVABin = 1;
198 +  if (subdet == 2 && ptBin == 0) MVABin = 2;
199 +  if (subdet == 0 && ptBin == 1) MVABin = 3;
200 +  if (subdet == 1 && ptBin == 1) MVABin = 4;
201 +  if (subdet == 2 && ptBin == 1) MVABin = 5;
202 +  assert(MVABin >= 0 && MVABin <= 5);
203 +  reader = fTMVAReader[MVABin];
204 +                                                
205 +  mva = reader->EvaluateMVA( fMethodname );
206 +
207 +  return mva;
208 + }
209 +
210 + //--------------------------------------------------------------------------------------------------
211 + Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleEta, Double_t PileupEnergyDensity,
212 +                                 Double_t EleSigmaIEtaIEta,
213 +                                 Double_t EleDEtaIn,
214 +                                 Double_t EleDPhiIn,
215 +                                 Double_t EleHoverE,
216 +                                 Double_t EleD0,
217 +                                 Double_t EleDZ,
218 +                                 Double_t EleFBrem,
219 +                                 Double_t EleEOverP,
220 +                                 Double_t EleESeedClusterOverPout,
221 +                                 Double_t EleSigmaIPhiIPhi,
222 +                                 Double_t EleNBrem,
223 +                                 Double_t EleOneOverEMinusOneOverP,
224 +                                 Double_t EleESeedClusterOverPIn,
225 +                                 Double_t EleIP3d,
226 +                                 Double_t EleIP3dSig,
227 +                                 Double_t EleGsfTrackChi2OverNdof,
228 +                                 Double_t EledEtaCalo,
229 +                                 Double_t EledPhiCalo,
230 +                                 Double_t EleR9,
231 +                                 Double_t EleSCEtaWidth,
232 +                                 Double_t EleSCPhiWidth,
233 +                                 Double_t EleCovIEtaIPhi,
234 +                                 Double_t ElePreShowerOverRaw,
235 +                                 Double_t EleChargedIso03,
236 +                                 Double_t EleNeutralHadronIso03,
237 +                                 Double_t EleGammaIso03,
238 +                                 Double_t EleChargedIso04,
239 +                                 Double_t EleNeutralHadronIso04,
240 +                                 Double_t EleGammaIso04
241 +  ) {
242 +  
243 +  if (!fIsInitialized) {
244 +    std::cout << "Error: ElectronIDMVA not properly initialized.\n";
245 +    return -9999;
246 +  }
247 +
248 +  Double_t Rho = 0;
249 +  if (!(TMath::IsNaN(PileupEnergyDensity) || isinf(PileupEnergyDensity))) Rho = PileupEnergyDensity;
250 +
251 +  Int_t subdet = 0;
252 +  if (fabs(EleEta) < 1.0) subdet = 0;
253 +  else if (fabs(EleEta) < 1.479) subdet = 1;
254 +  else subdet = 2;
255 +  Int_t ptBin = 0;
256 +  if (ElePt > 20.0) ptBin = 1;
257 +  
258 +  //set all input variables
259 +  fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
260 +  fMVAVar_EleDEtaIn = EleDEtaIn;
261 +  fMVAVar_EleDPhiIn = EleDPhiIn;
262 +  fMVAVar_EleHoverE = EleHoverE;
263 +  fMVAVar_EleD0 = EleD0;
264 +  fMVAVar_EleDZ = EleDZ;
265 +  fMVAVar_EleFBrem = EleFBrem;
266 +  fMVAVar_EleEOverP = EleEOverP;
267 +  fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
268 +  fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
269 +  fMVAVar_EleNBrem = EleNBrem;
270 +  fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
271 +  fMVAVar_EleESeedClusterOverPIn = EleESeedClusterOverPIn;
272 +  fMVAVar_EleIP3d = EleIP3d;
273 +  fMVAVar_EleIP3dSig = EleIP3dSig;
274 +  fMVAVar_EleGsfTrackChi2OverNdof = EleGsfTrackChi2OverNdof;
275 +  fMVAVar_EledEtaCalo = EledEtaCalo;
276 +  fMVAVar_EledPhiCalo = EledPhiCalo;
277 +  fMVAVar_EleR9 = EleR9;
278 +  fMVAVar_EleSCEtaWidth = EleSCEtaWidth;
279 +  fMVAVar_EleSCPhiWidth = EleSCPhiWidth;
280 +  fMVAVar_EleCovIEtaIPhi = EleCovIEtaIPhi;
281 +  fMVAVar_ElePreShowerOverRaw = ElePreShowerOverRaw;
282 +  fMVAVar_EleChargedIso03OverPt
283 +    = (EleChargedIso03
284 +       - Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, EleEta)) / ElePt;
285 +  fMVAVar_EleNeutralHadronIso03OverPt
286 +    = (EleNeutralHadronIso03
287 +       - Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, EleEta)
288 +       + Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,EleEta)) / ElePt;
289 +  fMVAVar_EleGammaIso03OverPt
290 +    = (EleGammaIso03
291 +       - Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, EleEta)
292 +       + Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,EleEta))/ElePt;
293 +  fMVAVar_EleChargedIso04OverPt
294 +    = (EleChargedIso04
295 +       - Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso04, EleEta))/ElePt;
296 +  fMVAVar_EleNeutralHadronIso04OverPt
297 +    = (EleNeutralHadronIso04
298 +       - Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso04, EleEta)
299 +       + Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,EleEta))/ElePt;
300 +  fMVAVar_EleGammaIso04OverPt
301 +    = (EleGammaIso04
302 +       - Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, EleEta)
303 +       + Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,EleEta))/ElePt;
304 +  
305 +  Double_t mva = -9999;  
306 +  TMVA::Reader *reader = 0;
307 +  Int_t MVABin = -1;
308 +  if (subdet == 0 && ptBin == 0) MVABin = 0;
309 +  if (subdet == 1 && ptBin == 0) MVABin = 1;
310 +  if (subdet == 2 && ptBin == 0) MVABin = 2;
311 +  if (subdet == 0 && ptBin == 1) MVABin = 3;
312 +  if (subdet == 1 && ptBin == 1) MVABin = 4;
313 +  if (subdet == 2 && ptBin == 1) MVABin = 5;
314 +  assert(MVABin >= 0 && MVABin <= 5);
315 +  reader = fTMVAReader[MVABin];
316 +                                                
317 +  mva = reader->EvaluateMVA( fMethodname );
318 +
319 +  Bool_t printdebug = kFALSE;
320 +  if (printdebug == kTRUE) {
321 +    std::cout << "Debug Electron MVA: "
322 +         << ElePt << " " << EleEta << " " << " --> MVABin " << MVABin << " : "    
323 +         << fMVAVar_EleSigmaIEtaIEta << " "
324 +         << fMVAVar_EleDEtaIn << " "
325 +         << fMVAVar_EleDPhiIn << " "
326 +         << fMVAVar_EleHoverE << " "
327 +         << fMVAVar_EleD0 << " "
328 +         << fMVAVar_EleDZ << " "
329 +         << fMVAVar_EleFBrem << " "
330 +         << fMVAVar_EleEOverP << " "
331 +         << fMVAVar_EleESeedClusterOverPout << " "
332 +         << fMVAVar_EleSigmaIPhiIPhi << " "
333 +         << fMVAVar_EleNBrem << " "
334 +         << fMVAVar_EleOneOverEMinusOneOverP << " "
335 +         << fMVAVar_EleESeedClusterOverPIn << " "
336 +         << fMVAVar_EleIP3d << " "
337 +         << fMVAVar_EleIP3dSig << " "
338 +         << fMVAVar_EleGsfTrackChi2OverNdof << " "
339 +         << fMVAVar_EledEtaCalo << " "
340 +         << fMVAVar_EledPhiCalo << " "
341 +         << fMVAVar_EleR9 << " "
342 +         << fMVAVar_EleSCEtaWidth << " "
343 +         << fMVAVar_EleSCPhiWidth << " "
344 +         << fMVAVar_EleCovIEtaIPhi << " "
345 +         << fMVAVar_ElePreShowerOverRaw << " "
346 +         << fMVAVar_EleChargedIso03OverPt  << " "
347 +         << fMVAVar_EleNeutralHadronIso03OverPt  << " "
348 +         << fMVAVar_EleGammaIso03OverPt  << " "
349 +         << fMVAVar_EleChargedIso04OverPt  << " "
350 +         << fMVAVar_EleNeutralHadronIso04OverPt  << " "
351 +         << fMVAVar_EleGammaIso04OverPt  << " "
352 +         << " === : === "
353 +         << mva
354 +         << std::endl;
355 +  }
356 +
357 +  return mva;
358 + }
359 +
360 +
361 + //--------------------------------------------------------------------------------------------------
362 + Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
363 +                                 const PFCandidateCol *PFCands,
364 +                                 const PileupEnergyDensityCol *PileupEnergyDensity) {
365 +  
366 +  if (!fIsInitialized) {
367 +    std::cout << "Error: ElectronIDMVA not properly initialized.\n";
368 +    return -9999;
369 +  }
370 +
371 +  Int_t subdet = 0;
372 +  if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
373 +  else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
374 +  else subdet = 2;
375 +  Int_t ptBin = 0;
376 +  if (ele->Pt() > 20.0) ptBin = 1;
377 +
378 +  Double_t Rho = 0;
379 +  if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
380 +
381 +  //set all input variables
382 +  fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
383 +  fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
384 +  fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
385 +  fMVAVar_EleHoverE = ele->HadronicOverEm();
386 +  fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
387 +  fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
388 +  fMVAVar_EleFBrem = ele->FBrem();
389 +  fMVAVar_EleEOverP = ele->ESuperClusterOverP();
390 +  fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
391 +  if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
392 +  else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
393 +  fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
394 +  fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
395 +  fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
396 +  fMVAVar_EleIP3d = ele->Ip3dPV();
397 +  fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
398 +  fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
399 +  fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
400 +  fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
401 +  fMVAVar_EleR9 = ele->SCluster()->R9();
402 +  fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
403 +  fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
404 +  fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
405 +  fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
406 +  fMVAVar_EleChargedIso03OverPt
407 +    = (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.3, 0.0)
408 +       - Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, ele->SCluster()->Eta())) / ele->Pt();
409 +  fMVAVar_EleNeutralHadronIso03OverPt
410 +    = (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, 0.0, PFCandidate::eNeutralHadron)
411 +       - Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, ele->SCluster()->Eta())
412 +       + Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt();
413 +  fMVAVar_EleGammaIso03OverPt
414 +    = (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, 0.0, PFCandidate::eGamma)
415 +       - Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, ele->SCluster()->Eta())
416 +       + Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,ele->SCluster()->Eta())) / ele->Pt();
417 +  fMVAVar_EleChargedIso04OverPt
418 +    = (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.4, 0.0)
419 +       - Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso04, ele->SCluster()->Eta())) / ele->Pt();
420 +  fMVAVar_EleNeutralHadronIso04OverPt
421 +    = (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, 0.0, PFCandidate::eNeutralHadron)
422 +       - Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso04, ele->SCluster()->Eta())
423 +       + Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt() ;
424 +  fMVAVar_EleGammaIso04OverPt
425 +    = (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, 0.0, PFCandidate::eGamma)
426 +       - Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, ele->SCluster()->Eta())
427 +       + Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,ele->SCluster()->Eta())) / ele->Pt();
428 +  
429 +  Double_t mva = -9999;  
430 +  TMVA::Reader *reader = 0;
431 +  Int_t MVABin = -1;
432 +  if (subdet == 0 && ptBin == 0) MVABin = 0;
433 +  if (subdet == 1 && ptBin == 0) MVABin = 1;
434 +  if (subdet == 2 && ptBin == 0) MVABin = 2;
435 +  if (subdet == 0 && ptBin == 1) MVABin = 3;
436 +  if (subdet == 1 && ptBin == 1) MVABin = 4;
437 +  if (subdet == 2 && ptBin == 1) MVABin = 5;
438 +  assert(MVABin >= 0 && MVABin <= 5);
439 +  reader = fTMVAReader[MVABin];
440 +                                                
441 +  mva = reader->EvaluateMVA( fMethodname );
442 +
443 +  Bool_t printdebug = kFALSE;
444 +  if (printdebug == kTRUE) {
445 +    std::cout << "Debug Electron MVA: "
446 +              << ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
447 +              << ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << MVABin << " : "    
448 +              << fMVAVar_EleSigmaIEtaIEta << " "
449 +              << fMVAVar_EleDEtaIn << " "
450 +              << fMVAVar_EleDPhiIn << " "
451 +              << fMVAVar_EleHoverE << " "
452 +              << fMVAVar_EleD0 << " "
453 +              << fMVAVar_EleDZ << " "
454 +              << fMVAVar_EleFBrem << " "
455 +              << fMVAVar_EleEOverP << " "
456 +              << fMVAVar_EleESeedClusterOverPout << " "
457 +              << fMVAVar_EleSigmaIPhiIPhi << " "
458 +              << fMVAVar_EleNBrem << " "
459 +              << fMVAVar_EleOneOverEMinusOneOverP << " "
460 +              << fMVAVar_EleESeedClusterOverPIn << " "
461 +              << fMVAVar_EleIP3d << " "
462 +              << fMVAVar_EleIP3dSig << " "
463 +              << fMVAVar_EleGsfTrackChi2OverNdof << " "
464 +              << fMVAVar_EledEtaCalo << " "
465 +              << fMVAVar_EledPhiCalo << " "
466 +              << fMVAVar_EleR9 << " "
467 +              << fMVAVar_EleSCEtaWidth << " "
468 +              << fMVAVar_EleSCPhiWidth << " "
469 +              << fMVAVar_EleCovIEtaIPhi << " "
470 +              << fMVAVar_ElePreShowerOverRaw << " "
471 +              << fMVAVar_EleChargedIso03OverPt  << " "
472 +              << fMVAVar_EleNeutralHadronIso03OverPt  << " "
473 +              << fMVAVar_EleGammaIso03OverPt  << " "
474 +              << fMVAVar_EleChargedIso04OverPt  << " "
475 +              << fMVAVar_EleNeutralHadronIso04OverPt  << " "
476 +              << fMVAVar_EleGammaIso04OverPt  << " "
477 +              << " === : === "
478 +              << mva << " "    
479 +              << std::endl;
480 +    
481 +  }
482 +
483 +  return mva;
484 + }
485  
486   //--------------------------------------------------------------------------------------------------
487   Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex) {
# Line 119 | Line 511 | Double_t ElectronIDMVA::MVAValue(const E
511    if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
512    else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
513    fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
514 <  fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->ESuperClusterOverP()*ele->BestTrk()->P())) - 1.0 / ele->BestTrk()->P();
514 >  fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
515    fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
516    fMVAVar_EleIP3d = ele->Ip3dPV();
517    fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
126 –  fMVAVar_EleStandardLikelihood = ElectronTools::Likelihood(fLH, ele);
518  
519    Double_t mva = -9999;  
520    TMVA::Reader *reader = 0;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines