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.4 by sixie, Mon Oct 3 16:32:09 2011 UTC vs.
Revision 1.6 by sixie, Sat Dec 31 23:21:22 2011 UTC

# Line 53 | Line 53 | void ElectronIDMVA::Initialize( TString
53      fTMVAReader[i]->SetVerbose(kTRUE);
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 );      
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 == kV1) {
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( "HoverE",                &fMVAVar_EleHoverE                );
70 <      fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
71 <      fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                );
72 <      fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout  );
73 <      fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
74 <      fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
75 <      fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );      
76 <      fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn   );
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 == kV2) {
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( "HoverE",                &fMVAVar_EleHoverE                );
82 <      fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                    );
83 <      fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
84 <      fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                );
85 <      fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout  );
86 <      fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
87 <      fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
88 <      fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );      
89 <      fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn   );
90 <      fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                  );
91 <      fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig               );
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 );
# Line 113 | Line 143 | void ElectronIDMVA::Initialize( TString
143   }
144  
145   //--------------------------------------------------------------------------------------------------
146 < Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleSCEta,
146 > Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleEta,
147                                   Double_t EleSigmaIEtaIEta,
148                                   Double_t EleDEtaIn,
149                                   Double_t EleDPhiIn,
# Line 137 | Line 167 | Double_t ElectronIDMVA::MVAValue(Double_
167    }
168  
169    Int_t subdet = 0;
170 <  if (fabs(EleSCEta) < 1.0) subdet = 0;
171 <  else if (fabs(EleSCEta) < 1.479) subdet = 1;
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;
# Line 177 | Line 207 | Double_t ElectronIDMVA::MVAValue(Double_
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 +  Int_t subdet = 0;
249 +  if (fabs(EleEta) < 1.0) subdet = 0;
250 +  else if (fabs(EleEta) < 1.479) subdet = 1;
251 +  else subdet = 2;
252 +  Int_t ptBin = 0;
253 +  if (ElePt > 20.0) ptBin = 1;
254 +  
255 +  //set all input variables
256 +  fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
257 +  fMVAVar_EleDEtaIn = EleDEtaIn;
258 +  fMVAVar_EleDPhiIn = EleDPhiIn;
259 +  fMVAVar_EleHoverE = EleHoverE;
260 +  fMVAVar_EleD0 = EleD0;
261 +  fMVAVar_EleDZ = EleDZ;
262 +  fMVAVar_EleFBrem = EleFBrem;
263 +  fMVAVar_EleEOverP = EleEOverP;
264 +  fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
265 +  fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
266 +  fMVAVar_EleNBrem = EleNBrem;
267 +  fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
268 +  fMVAVar_EleESeedClusterOverPIn = EleESeedClusterOverPIn;
269 +  fMVAVar_EleIP3d = EleIP3d;
270 +  fMVAVar_EleIP3dSig = EleIP3dSig;
271 +  fMVAVar_EleGsfTrackChi2OverNdof = EleGsfTrackChi2OverNdof;
272 +  fMVAVar_EledEtaCalo = EledEtaCalo;
273 +  fMVAVar_EledPhiCalo = EledPhiCalo;
274 +  fMVAVar_EleR9 = EleR9;
275 +  fMVAVar_EleSCEtaWidth = EleSCEtaWidth;
276 +  fMVAVar_EleSCPhiWidth = EleSCPhiWidth;
277 +  fMVAVar_EleCovIEtaIPhi = EleCovIEtaIPhi;
278 +  fMVAVar_ElePreShowerOverRaw = ElePreShowerOverRaw;
279 +  fMVAVar_EleChargedIso03OverPt
280 +    = (EleChargedIso03
281 +       - PileupEnergyDensity * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, EleEta)) / ElePt;
282 +  fMVAVar_EleNeutralHadronIso03OverPt
283 +    = (EleNeutralHadronIso03
284 +       - PileupEnergyDensity * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, EleEta)
285 +       + PileupEnergyDensity * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,EleEta)) / ElePt;
286 +  fMVAVar_EleGammaIso03OverPt
287 +    = (EleGammaIso03
288 +       - PileupEnergyDensity * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, EleEta)
289 +       + PileupEnergyDensity * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,EleEta))/ElePt;
290 +  fMVAVar_EleChargedIso04OverPt
291 +    = (EleChargedIso04
292 +       - PileupEnergyDensity * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso04, EleEta))/ElePt;
293 +  fMVAVar_EleNeutralHadronIso04OverPt
294 +    = (EleNeutralHadronIso04
295 +       - PileupEnergyDensity * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso04, EleEta)
296 +       + PileupEnergyDensity * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,EleEta))/ElePt;
297 +  fMVAVar_EleGammaIso04OverPt
298 +    = (EleGammaIso04
299 +       - PileupEnergyDensity * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, EleEta)
300 +       + PileupEnergyDensity * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,EleEta))/ElePt;
301 +  
302 +  Double_t mva = -9999;  
303 +  TMVA::Reader *reader = 0;
304 +  Int_t MVABin = -1;
305 +  if (subdet == 0 && ptBin == 0) MVABin = 0;
306 +  if (subdet == 1 && ptBin == 0) MVABin = 1;
307 +  if (subdet == 2 && ptBin == 0) MVABin = 2;
308 +  if (subdet == 0 && ptBin == 1) MVABin = 3;
309 +  if (subdet == 1 && ptBin == 1) MVABin = 4;
310 +  if (subdet == 2 && ptBin == 1) MVABin = 5;
311 +  assert(MVABin >= 0 && MVABin <= 5);
312 +  reader = fTMVAReader[MVABin];
313 +                                                
314 +  mva = reader->EvaluateMVA( fMethodname );
315 +
316 +  return mva;
317 + }
318 +
319 +
320 + //--------------------------------------------------------------------------------------------------
321 + Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
322 +                                 const PFCandidateCol *PFCands,
323 +                                 const PileupEnergyDensityCol *PileupEnergyDensity) {
324 +  
325 +  if (!fIsInitialized) {
326 +    std::cout << "Error: ElectronIDMVA not properly initialized.\n";
327 +    return -9999;
328 +  }
329  
330 +  Int_t subdet = 0;
331 +  if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
332 +  else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
333 +  else subdet = 2;
334 +  Int_t ptBin = 0;
335 +  if (ele->Pt() > 20.0) ptBin = 1;
336 +  
337 +  //set all input variables
338 +  fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
339 +  fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
340 +  fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
341 +  fMVAVar_EleHoverE = ele->HadronicOverEm();
342 +  fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
343 +  fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
344 +  fMVAVar_EleFBrem = ele->FBrem();
345 +  fMVAVar_EleEOverP = ele->ESuperClusterOverP();
346 +  fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
347 +  if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
348 +  else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
349 +  fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
350 +  fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
351 +  fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
352 +  fMVAVar_EleIP3d = ele->Ip3dPV();
353 +  fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
354 +  fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
355 +  fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
356 +  fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
357 +  fMVAVar_EleR9 = ele->SCluster()->R9();
358 +  fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
359 +  fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
360 +  fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
361 +  fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
362 +  fMVAVar_EleChargedIso03OverPt
363 +    = (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.3, 0.0)
364 +       - PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, ele->Eta())) / ele->Pt();
365 +  fMVAVar_EleNeutralHadronIso03OverPt
366 +    = (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, 0.0, PFCandidate::eNeutralHadron)
367 +       - PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, ele->Eta())
368 +       + PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->Eta())) / ele->Pt();
369 +  fMVAVar_EleGammaIso03OverPt
370 +    = (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, 0.0, PFCandidate::eGamma)
371 +       - PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, ele->Eta())
372 +       + PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,ele->Eta())) / ele->Pt();
373 +  fMVAVar_EleChargedIso04OverPt
374 +    = (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.4, 0.0)
375 +       - PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, ele->Eta())) / ele->Pt();
376 +  fMVAVar_EleNeutralHadronIso04OverPt
377 +    = (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, 0.0, PFCandidate::eNeutralHadron)
378 +       - PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, ele->Eta())
379 +       + PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->Eta())) / ele->Pt() ;
380 +  fMVAVar_EleGammaIso04OverPt
381 +    = (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, 0.0, PFCandidate::eGamma)
382 +       - PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, ele->Eta())
383 +       + PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,ele->Eta())) / ele->Pt();
384 +  
385 +  Double_t mva = -9999;  
386 +  TMVA::Reader *reader = 0;
387 +  Int_t MVABin = -1;
388 +  if (subdet == 0 && ptBin == 0) MVABin = 0;
389 +  if (subdet == 1 && ptBin == 0) MVABin = 1;
390 +  if (subdet == 2 && ptBin == 0) MVABin = 2;
391 +  if (subdet == 0 && ptBin == 1) MVABin = 3;
392 +  if (subdet == 1 && ptBin == 1) MVABin = 4;
393 +  if (subdet == 2 && ptBin == 1) MVABin = 5;
394 +  assert(MVABin >= 0 && MVABin <= 5);
395 +  reader = fTMVAReader[MVABin];
396 +                                                
397 +  mva = reader->EvaluateMVA( fMethodname );
398 +
399 +  return mva;
400 + }
401  
402   //--------------------------------------------------------------------------------------------------
403   Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex) {
# Line 207 | Line 427 | Double_t ElectronIDMVA::MVAValue(const E
427    if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
428    else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
429    fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
430 <  fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->ESuperClusterOverP()*ele->BestTrk()->P())) - 1.0 / ele->BestTrk()->P();
430 >  fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
431    fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
432    fMVAVar_EleIP3d = ele->Ip3dPV();
433    fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();

Diff Legend

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