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.3 by sixie, Sun Sep 25 15:59:20 2011 UTC vs.
Revision 1.8 by sixie, Wed Jan 4 13:37:14 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 91 | 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 106 | Line 158 | Double_t ElectronIDMVA::MVAValue(Double_
158		Double_t EleOneOverEMinusOneOverP,
159		Double_t EleESeedClusterOverPIn,
160		Double_t EleIP3d,
161	<	Double_t EleIP3dSig,
110	<	Double_t EleStandardLikelihood
161	>	Double_t EleIP3dSig
162		) {
163
164		if (!fIsInitialized) {
#	Line 116 | 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 138 | Line 189 | Double_t ElectronIDMVA::MVAValue(Double_
189		fMVAVar_EleESeedClusterOverPIn = EleESeedClusterOverPIn;
190		fMVAVar_EleIP3d = EleIP3d;
191		fMVAVar_EleIP3dSig = EleIP3dSig;
141	–	fMVAVar_EleStandardLikelihood = EleStandardLikelihood;
192
193		Double_t mva = -9999;
194		TMVA::Reader *reader = 0;
#	Line 157 | 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	+	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 = kTRUE;
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 = kTRUE;
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 187 | 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();
194	–	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