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.2 by sixie, Sun Sep 25 15:03:41 2011 UTC vs.
Revision 1.6 by sixie, Sat Dec 31 23:21:22 2011 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	+	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 119 | 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();
126	–	fMVAVar_EleStandardLikelihood = ElectronTools::Likelihood(fLH, ele);
434
435		Double_t mva = -9999;
436		TMVA::Reader *reader = 0;

Diff Legend

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