ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitPhysics/Utils/src/ElectronIDMVA.cc

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.7 by sixie, Wed Jan 4 10:31:24 2012 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	+	Bool_t printdebug = kTRUE;
317	+	if (printdebug == kTRUE) {
318	+	std::cout << "Debug Electron MVA: "
319	+	<< ElePt << " " << EleEta << " " << " --> MVABin " << MVABin << " : "
320	+	<< fMVAVar_EleSigmaIEtaIEta << " "
321	+	<< fMVAVar_EleDEtaIn << " "
322	+	<< fMVAVar_EleDPhiIn << " "
323	+	<< fMVAVar_EleHoverE << " "
324	+	<< fMVAVar_EleD0 << " "
325	+	<< fMVAVar_EleDZ << " "
326	+	<< fMVAVar_EleFBrem << " "
327	+	<< fMVAVar_EleEOverP << " "
328	+	<< fMVAVar_EleESeedClusterOverPout << " "
329	+	<< fMVAVar_EleSigmaIPhiIPhi << " "
330	+	<< fMVAVar_EleNBrem << " "
331	+	<< fMVAVar_EleOneOverEMinusOneOverP << " "
332	+	<< fMVAVar_EleESeedClusterOverPIn << " "
333	+	<< fMVAVar_EleIP3d << " "
334	+	<< fMVAVar_EleIP3dSig << " "
335	+	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
336	+	<< fMVAVar_EledEtaCalo << " "
337	+	<< fMVAVar_EledPhiCalo << " "
338	+	<< fMVAVar_EleR9 << " "
339	+	<< fMVAVar_EleSCEtaWidth << " "
340	+	<< fMVAVar_EleSCPhiWidth << " "
341	+	<< fMVAVar_EleCovIEtaIPhi << " "
342	+	<< fMVAVar_ElePreShowerOverRaw << " "
343	+	<< fMVAVar_EleChargedIso03OverPt  << " "
344	+	<< fMVAVar_EleNeutralHadronIso03OverPt  << " "
345	+	<< fMVAVar_EleGammaIso03OverPt  << " "
346	+	<< fMVAVar_EleChargedIso04OverPt  << " "
347	+	<< fMVAVar_EleNeutralHadronIso04OverPt  << " "
348	+	<< fMVAVar_EleGammaIso04OverPt  << " "
349	+	<< " === : === "
350	+	<< mva
351	+	<< std::endl;
352	+	}
353	+
354	+	return mva;
355	+	}
356	+
357	+
358	+	//--------------------------------------------------------------------------------------------------
359	+	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
360	+	const PFCandidateCol *PFCands,
361	+	const PileupEnergyDensityCol *PileupEnergyDensity) {
362	+
363	+	if (!fIsInitialized) {
364	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
365	+	return -9999;
366	+	}
367	+
368	+	Int_t subdet = 0;
369	+	if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
370	+	else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
371	+	else subdet = 2;
372	+	Int_t ptBin = 0;
373	+	if (ele->Pt() > 20.0) ptBin = 1;
374	+
375	+	//set all input variables
376	+	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
377	+	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
378	+	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
379	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
380	+	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
381	+	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
382	+	fMVAVar_EleFBrem = ele->FBrem();
383	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
384	+	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
385	+	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
386	+	else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
387	+	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
388	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
389	+	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
390	+	fMVAVar_EleIP3d = ele->Ip3dPV();
391	+	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
392	+	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
393	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
394	+	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
395	+	fMVAVar_EleR9 = ele->SCluster()->R9();
396	+	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
397	+	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
398	+	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
399	+	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
400	+	fMVAVar_EleChargedIso03OverPt
401	+	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.3, 0.0)
402	+	- PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, ele->SCluster()->Eta())) / ele->Pt();
403	+	fMVAVar_EleNeutralHadronIso03OverPt
404	+	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, 0.0, PFCandidate::eNeutralHadron)
405	+	- PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, ele->SCluster()->Eta())
406	+	+ PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt();
407	+	fMVAVar_EleGammaIso03OverPt
408	+	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, 0.0, PFCandidate::eGamma)
409	+	- PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, ele->SCluster()->Eta())
410	+	+ PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,ele->SCluster()->Eta())) / ele->Pt();
411	+	fMVAVar_EleChargedIso04OverPt
412	+	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.4, 0.0)
413	+	- PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso04, ele->SCluster()->Eta())) / ele->Pt();
414	+	fMVAVar_EleNeutralHadronIso04OverPt
415	+	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, 0.0, PFCandidate::eNeutralHadron)
416	+	- PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso04, ele->SCluster()->Eta())
417	+	+ PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt() ;
418	+	fMVAVar_EleGammaIso04OverPt
419	+	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, 0.0, PFCandidate::eGamma)
420	+	- PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, ele->SCluster()->Eta())
421	+	+ PileupEnergyDensity->At(0)->Rho() * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,ele->SCluster()->Eta())) / ele->Pt();
422	+
423	+	Double_t mva = -9999;
424	+	TMVA::Reader *reader = 0;
425	+	Int_t MVABin = -1;
426	+	if (subdet == 0 && ptBin == 0) MVABin = 0;
427	+	if (subdet == 1 && ptBin == 0) MVABin = 1;
428	+	if (subdet == 2 && ptBin == 0) MVABin = 2;
429	+	if (subdet == 0 && ptBin == 1) MVABin = 3;
430	+	if (subdet == 1 && ptBin == 1) MVABin = 4;
431	+	if (subdet == 2 && ptBin == 1) MVABin = 5;
432	+	assert(MVABin >= 0 && MVABin <= 5);
433	+	reader = fTMVAReader[MVABin];
434	+
435	+	mva = reader->EvaluateMVA( fMethodname );
436	+
437	+	Bool_t printdebug = kFALSE;
438	+	if (printdebug == kTRUE) {
439	+	std::cout << "Debug Electron MVA: "
440	+	<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
441	+	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << MVABin << " : "
442	+	<< fMVAVar_EleSigmaIEtaIEta << " "
443	+	<< fMVAVar_EleDEtaIn << " "
444	+	<< fMVAVar_EleDPhiIn << " "
445	+	<< fMVAVar_EleHoverE << " "
446	+	<< fMVAVar_EleD0 << " "
447	+	<< fMVAVar_EleDZ << " "
448	+	<< fMVAVar_EleFBrem << " "
449	+	<< fMVAVar_EleEOverP << " "
450	+	<< fMVAVar_EleESeedClusterOverPout << " "
451	+	<< fMVAVar_EleSigmaIPhiIPhi << " "
452	+	<< fMVAVar_EleNBrem << " "
453	+	<< fMVAVar_EleOneOverEMinusOneOverP << " "
454	+	<< fMVAVar_EleESeedClusterOverPIn << " "
455	+	<< fMVAVar_EleIP3d << " "
456	+	<< fMVAVar_EleIP3dSig << " "
457	+	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
458	+	<< fMVAVar_EledEtaCalo << " "
459	+	<< fMVAVar_EledPhiCalo << " "
460	+	<< fMVAVar_EleR9 << " "
461	+	<< fMVAVar_EleSCEtaWidth << " "
462	+	<< fMVAVar_EleSCPhiWidth << " "
463	+	<< fMVAVar_EleCovIEtaIPhi << " "
464	+	<< fMVAVar_ElePreShowerOverRaw << " "
465	+	<< fMVAVar_EleChargedIso03OverPt  << " "
466	+	<< fMVAVar_EleNeutralHadronIso03OverPt  << " "
467	+	<< fMVAVar_EleGammaIso03OverPt  << " "
468	+	<< fMVAVar_EleChargedIso04OverPt  << " "
469	+	<< fMVAVar_EleNeutralHadronIso04OverPt  << " "
470	+	<< fMVAVar_EleGammaIso04OverPt  << " "
471	+	<< " === : === "
472	+	<< mva << " "
473	+	<< std::endl;
474	+
475	+	}
476	+
477	+	return mva;
478	+	}
479
480		//--------------------------------------------------------------------------------------------------
481		Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex) {
#	Line 207 | Line 505 | Double_t ElectronIDMVA::MVAValue(const E
505		if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
506		else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
507		fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
508	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->ESuperClusterOverP()*ele->BestTrk()->P())) - 1.0 / ele->BestTrk()->P();
508	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
509		fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
510		fMVAVar_EleIP3d = ele->Ip3dPV();
511		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();

Diff Legend

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