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.14 by sixie, Mon Apr 16 11:05:29 2012 UTC

#	Line 15 | Line 15 | using namespace mithep;
15		//--------------------------------------------------------------------------------------------------
16		ElectronIDMVA::ElectronIDMVA() :
17		fMethodname("BDTG method"),
18	<	fLH(0),
19	<	fIsInitialized(kFALSE)
18	>	fIsInitialized(kFALSE),
19	>	fMVAType(ElectronIDMVA::kUninitialized),
20	>	fUseBinnedVersion(kTRUE),
21	>	fNMVABins(0)
22		{
23		// Constructor.
22	–	for(UInt_t i=0; i<6; ++i) {
23	–	fTMVAReader[i] = 0;
24	–	}
24		}
25
26
27		//--------------------------------------------------------------------------------------------------
28		ElectronIDMVA::~ElectronIDMVA()
29		{
30	<	for(UInt_t i=0; i<6; ++i) {
30	>	for(UInt_t i=0; i<fTMVAReader.size(); ++i) {
31		if (fTMVAReader[i]) delete fTMVAReader[i];
32		}
33		}
34
35		//--------------------------------------------------------------------------------------------------
36	+	void ElectronIDMVA::Initialize( std::string methodName,
37	+	std::string weightsfile,
38	+	ElectronIDMVA::MVAType type)
39	+	{
40	+
41	+	std::vector<std::string> tempWeightFileVector;
42	+	tempWeightFileVector.push_back(weightsfile);
43	+	Initialize(methodName,type,kFALSE,tempWeightFileVector);
44	+	}
45	+
46	+	//--------------------------------------------------------------------------------------------------
47		void ElectronIDMVA::Initialize( TString methodName,
48		TString Subdet0Pt10To20Weights ,
49		TString Subdet1Pt10To20Weights ,
#	Line 41 | Line 51 | void ElectronIDMVA::Initialize( TString
51		TString Subdet0Pt20ToInfWeights,
52		TString Subdet1Pt20ToInfWeights,
53		TString Subdet2Pt20ToInfWeights,
54	<	ElectronLikelihood *LH) {
54	>	ElectronIDMVA::MVAType type) {
55	>
56	>	std::vector<std::string> tempWeightFileVector;
57	>	tempWeightFileVector.push_back(std::string(Subdet0Pt10To20Weights.Data()));
58	>	tempWeightFileVector.push_back(std::string(Subdet1Pt10To20Weights.Data()));
59	>	tempWeightFileVector.push_back(std::string(Subdet2Pt10To20Weights.Data()));
60	>	tempWeightFileVector.push_back(std::string(Subdet0Pt20ToInfWeights.Data()));
61	>	tempWeightFileVector.push_back(std::string(Subdet1Pt20ToInfWeights.Data()));
62	>	tempWeightFileVector.push_back(std::string(Subdet2Pt20ToInfWeights.Data()));
63	>	Initialize(std::string(methodName.Data()),type,kTRUE,tempWeightFileVector);
64	>
65	>	}
66	>
67	>
68	>	//--------------------------------------------------------------------------------------------------
69	>	void ElectronIDMVA::Initialize(  std::string methodName,
70	>	ElectronIDMVA::MVAType type,
71	>	Bool_t useBinnedVersion,
72	>	std::vector<std::string> weightsfiles
73	>
74	>	) {
75
76	+	//clean up first
77	+	for (uint i=0;i<fTMVAReader.size(); ++i) {
78	+	if (fTMVAReader[i]) delete fTMVAReader[i];
79	+	}
80	+	fTMVAReader.clear();
81	+
82	+	//initialize
83		fIsInitialized = kTRUE;
47	–
84		fMethodname = methodName;
85	<	fLH = LH;
86	<	if (!fLH) { std::cout << "Error: Likelihood is not properly initialized.\n"; assert(fLH); }
85	>	fMVAType = type;
86	>	fUseBinnedVersion = useBinnedVersion;
87	>
88	>	//Define expected number of bins
89	>	UInt_t ExpectedNBins = 0;
90	>	if (!fUseBinnedVersion) {
91	>	ExpectedNBins = 1;
92	>	} else if (type == kBaseline
93	>	||type == kNoIPInfo
94	>	||type == kWithIPInfo
95	>	||type == kIDIsoCombined) {
96	>	ExpectedNBins = 6;
97	>	} else if (type == kIDEGamma2012TrigV0 ||
98	>	type == kIDEGamma2012NonTrigV0) {
99	>	ExpectedNBins = 6;
100	>	} else if (type == kIsoRingsV0) {
101	>	ExpectedNBins = 4;
102	>	}
103	>	fNMVABins = ExpectedNBins;
104	>
105	>	//Check number of weight files given
106	>	if (fNMVABins != weightsfiles.size() ) {
107	>	std::cout << "Error: Expected Number of bins = " << fNMVABins << " does not equal to weightsfiles.size() = "
108	>	<< weightsfiles.size() << std::endl;
109	>	assert(fNMVABins == weightsfiles.size());
110	>	}
111	>
112	>
113	>	for(UInt_t i=0; i<fNMVABins; ++i) {
114	>	TMVA::Reader *tmpTMVAReader = new TMVA::Reader( "!Color:!Silent:Error" );
115	>	tmpTMVAReader->SetVerbose(kTRUE);
116	>
117	>	if (type == kBaseline) {
118	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
119	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
120	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
121	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
122	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
123	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
124	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
125	>	}
126	>	if (type == kNoIPInfo) {
127	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
128	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
129	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
130	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
131	>	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
132	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
133	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
134	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
135	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
136	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
137	>	}
138	>	if (type == kWithIPInfo) {
139	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
140	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
141	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
142	>	tmpTMVAReader->AddVariable( "D0",                    &fMVAVar_EleD0                       );
143	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
144	>	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
145	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
146	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
147	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
148	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
149	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
150	>	tmpTMVAReader->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
151	>	tmpTMVAReader->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
152	>	}
153	>	if (type == kIDIsoCombined) {
154	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
155	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
156	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
157	>	tmpTMVAReader->AddVariable( "D0",                    &fMVAVar_EleD0                       );
158	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
159	>	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
160	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
161	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
162	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
163	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
164	>	tmpTMVAReader->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
165	>	tmpTMVAReader->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
166	>
167	>	tmpTMVAReader->AddVariable( "GsfTrackChi2OverNdof",  &fMVAVar_EleGsfTrackChi2OverNdof     );
168	>	tmpTMVAReader->AddVariable( "dEtaCalo",              &fMVAVar_EledEtaCalo                 );
169	>	tmpTMVAReader->AddVariable( "dPhiCalo",              &fMVAVar_EledPhiCalo                 );
170	>	tmpTMVAReader->AddVariable( "R9",                    &fMVAVar_EleR9                       );
171	>	tmpTMVAReader->AddVariable( "SCEtaWidth",            &fMVAVar_EleSCEtaWidth               );
172	>	tmpTMVAReader->AddVariable( "SCPhiWidth",            &fMVAVar_EleSCPhiWidth               );
173	>	tmpTMVAReader->AddVariable( "CovIEtaIPhi",           &fMVAVar_EleCovIEtaIPhi              );
174	>	if (i == 2 || i == 5) {
175	>	tmpTMVAReader->AddVariable( "PreShowerOverRaw",      &fMVAVar_ElePreShowerOverRaw       );
176	>	}
177	>	tmpTMVAReader->AddVariable( "ChargedIso03",          &fMVAVar_EleChargedIso03OverPt       );
178	>	tmpTMVAReader->AddVariable( "NeutralHadronIso03",    &fMVAVar_EleNeutralHadronIso03OverPt );
179	>	tmpTMVAReader->AddVariable( "GammaIso03",            &fMVAVar_EleGammaIso03OverPt         );
180	>	tmpTMVAReader->AddVariable( "ChargedIso04",          &fMVAVar_EleChargedIso04OverPt       );
181	>	tmpTMVAReader->AddVariable( "NeutralHadronIso04",    &fMVAVar_EleNeutralHadronIso04OverPt );
182	>	tmpTMVAReader->AddVariable( "GammaIso04",            &fMVAVar_EleGammaIso04OverPt         );
183	>
184	>	}
185	>
186	>	if (type == kIDEGamma2012TrigV0 || type == kIDEGamma2012NonTrigV0 ) {
187	>	// Pure tracking variables
188	>	tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
189	>	tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
190	>	tmpTMVAReader->AddVariable("kfhits",          &fMVAVar_EleKFTrkNLayers);  //Don't have this in (BAMBU <= 025)
191	>	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
192	>	tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
193	>	tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
194	>	tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
195	>	tmpTMVAReader->AddVariable("detacalo",        &fMVAVar_EledEtaCalo);
196	>	tmpTMVAReader->AddVariable("see",             &fMVAVar_EleSigmaIEtaIEta);
197	>	tmpTMVAReader->AddVariable("spp",             &fMVAVar_EleSigmaIPhiIPhi);
198	>	tmpTMVAReader->AddVariable("etawidth",        &fMVAVar_EleSCEtaWidth);
199	>	tmpTMVAReader->AddVariable("phiwidth",        &fMVAVar_EleSCPhiWidth);
200	>	tmpTMVAReader->AddVariable("e1x5e5x5",        &fMVAVar_EleE1x5OverE5x5);
201	>	tmpTMVAReader->AddVariable("R9",              &fMVAVar_EleR9);
202	>	tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
203	>	tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
204	>	tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
205	>	tmpTMVAReader->AddVariable("eleEoPout",       &fMVAVar_EleEEleClusterOverPout); //Don't have this in (BAMBU <= 025)
206	>	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout);
207	>	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
208
209	<	for(UInt_t i=0; i<6; ++i) {
210	<	if (fTMVAReader[i]) delete fTMVAReader[i];
209	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
210	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
211	>	}
212	>
213	>	if (type == kIsoRingsV0) {
214	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1",         &fMVAVar_ChargedIso_DR0p0To0p1        );
215	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2",         &fMVAVar_ChargedIso_DR0p1To0p2        );
216	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p2To0p3",         &fMVAVar_ChargedIso_DR0p2To0p3        );
217	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p3To0p4",         &fMVAVar_ChargedIso_DR0p3To0p4        );
218	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p4To0p5",         &fMVAVar_ChargedIso_DR0p4To0p5        );
219	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p0To0p1",           &fMVAVar_GammaIso_DR0p0To0p1          );
220	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p1To0p2",           &fMVAVar_GammaIso_DR0p1To0p2          );
221	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p2To0p3",           &fMVAVar_GammaIso_DR0p2To0p3          );
222	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p3To0p4",           &fMVAVar_GammaIso_DR0p3To0p4          );
223	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p4To0p5",           &fMVAVar_GammaIso_DR0p4To0p5          );
224	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p0To0p1",   &fMVAVar_NeutralHadronIso_DR0p0To0p1  );
225	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p1To0p2",   &fMVAVar_NeutralHadronIso_DR0p1To0p2  );
226	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p2To0p3",   &fMVAVar_NeutralHadronIso_DR0p2To0p3  );
227	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p3To0p4",   &fMVAVar_NeutralHadronIso_DR0p3To0p4  );
228	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p4To0p5",   &fMVAVar_NeutralHadronIso_DR0p4To0p5  );
229	>	tmpTMVAReader->AddSpectator( "eta",   &fMVAVar_EleEta );
230	>	tmpTMVAReader->AddSpectator( "pt" ,   &fMVAVar_ElePt  );
231	>	}
232	>
233	>	tmpTMVAReader->BookMVA(fMethodname , weightsfiles[i] );
234	>	std::cout << "MVABin " << i << " : MethodName = " << fMethodname
235	>	<< " , type == " << type << " , "
236	>	<< "Load weights file : " << weightsfiles[i]
237	>	<< std::endl;
238	>	fTMVAReader.push_back(tmpTMVAReader);
239	>
240	>	}
241	>	std::cout << "Electron ID MVA Completed\n";
242	>	}
243	>
244	>
245	>	//--------------------------------------------------------------------------------------------------
246	>	UInt_t ElectronIDMVA::GetMVABin( double eta, double pt) const {
247	>
248	>	//Default is to return the first bin
249	>	uint bin = 0;
250	>
251	>	//return the first bin if not using binned version
252	>	if (!fUseBinnedVersion) return 0;
253	>
254	>	if (fMVAType == ElectronIDMVA::kBaseline
255	>	||fMVAType == ElectronIDMVA::kNoIPInfo
256	>	||fMVAType == ElectronIDMVA::kWithIPInfo
257	>	||fMVAType == ElectronIDMVA::kIDIsoCombined) {
258	>	if (pt < 20 && fabs(eta) < 1.0) bin = 0;
259	>	if (pt < 20 && fabs(eta) >= 1.0 && fabs(eta) < 1.479) bin = 1;
260	>	if (pt < 20 && fabs(eta) >= 1.479) bin = 2;
261	>	if (pt >= 20 && fabs(eta) < 1.0) bin = 3;
262	>	if (pt >= 20 && fabs(eta) >= 1.0 && fabs(eta) < 1.479) bin = 4;
263	>	if (pt >= 20 && fabs(eta) >= 1.479) bin = 5;
264	>	}
265	>
266	>	if (fMVAType == ElectronIDMVA::kIsoRingsV0) {
267	>	if (pt < 10 && fabs(eta) < 1.479) bin = 0;
268	>	if (pt < 10 && fabs(eta) >= 1.479) bin = 1;
269	>	if (pt >= 10 && fabs(eta) < 1.479) bin = 2;
270	>	if (pt >= 10 && fabs(eta) >= 1.479) bin = 3;
271	>	}
272	>
273	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
274	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ) {
275	>	bin = 0;
276	>	if (pt < 10 && fabs(eta) < 0.8) bin = 0;
277	>	if (pt < 10 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 1;
278	>	if (pt < 10 && fabs(eta) >= 1.479) bin = 2;
279	>	if (pt >= 10 && fabs(eta) < 0.8) bin = 3;
280	>	if (pt >= 10 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 4;
281	>	if (pt >= 10 && fabs(eta) >= 1.479) bin = 5;
282	>	}
283	>
284	>	return bin;
285	>	}
286	>
287	>
288	>
289	>	//--------------------------------------------------------------------------------------------------
290	>	Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleEta,
291	>	Double_t EleSigmaIEtaIEta,
292	>	Double_t EleDEtaIn,
293	>	Double_t EleDPhiIn,
294	>	Double_t EleHoverE,
295	>	Double_t EleD0,
296	>	Double_t EleDZ,
297	>	Double_t EleFBrem,
298	>	Double_t EleEOverP,
299	>	Double_t EleESeedClusterOverPout,
300	>	Double_t EleSigmaIPhiIPhi,
301	>	Double_t EleNBrem,
302	>	Double_t EleOneOverEMinusOneOverP,
303	>	Double_t EleESeedClusterOverPIn,
304	>	Double_t EleIP3d,
305	>	Double_t EleIP3dSig
306	>	) {
307	>
308	>	if (!fIsInitialized) {
309	>	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
310	>	return -9999;
311	>	}
312	>
313	>	//set all input variables
314	>	fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
315	>	fMVAVar_EleDEtaIn = EleDEtaIn;
316	>	fMVAVar_EleDPhiIn = EleDPhiIn;
317	>	fMVAVar_EleHoverE = EleHoverE;
318	>	fMVAVar_EleD0 = EleD0;
319	>	fMVAVar_EleDZ = EleDZ;
320	>	fMVAVar_EleFBrem = EleFBrem;
321	>	fMVAVar_EleEOverP = EleEOverP;
322	>	fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
323	>	fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
324	>	fMVAVar_EleNBrem = EleNBrem;
325	>	fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
326	>	fMVAVar_EleESeedClusterOverPIn = EleESeedClusterOverPIn;
327	>	fMVAVar_EleIP3d = EleIP3d;
328	>	fMVAVar_EleIP3dSig = EleIP3dSig;
329	>
330	>	Double_t mva = -9999;
331	>	TMVA::Reader *reader = 0;
332	>	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
333	>
334	>	mva = reader->EvaluateMVA( fMethodname );
335
336	<	fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );
337	<	fTMVAReader[i]->SetVerbose(kTRUE);
57	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
58	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
59	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
60	<	fTMVAReader[i]->AddVariable( "HoverE",                &fMVAVar_EleHoverE                );
61	<	fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                    );
62	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
63	<	fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                );
64	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout  );
65	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
66	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
67	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );
68	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn   );
69	<	fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                  );
70	<	fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig               );
71	<	fTMVAReader[i]->AddVariable( "StandardLikelihood",    &fMVAVar_EleStandardLikelihood    );
72	<
73	<	if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To20Weights );
74	<	if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To20Weights );
75	<	if (i==2) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt10To20Weights );
76	<	if (i==3) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt20ToInfWeights );
77	<	if (i==4) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt20ToInfWeights );
78	<	if (i==5) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt20ToInfWeights );
336	>	return mva;
337	>	}
338
339	+	//--------------------------------------------------------------------------------------------------
340	+	Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleEta, Double_t PileupEnergyDensity,
341	+	Double_t EleSigmaIEtaIEta,
342	+	Double_t EleDEtaIn,
343	+	Double_t EleDPhiIn,
344	+	Double_t EleHoverE,
345	+	Double_t EleD0,
346	+	Double_t EleDZ,
347	+	Double_t EleFBrem,
348	+	Double_t EleEOverP,
349	+	Double_t EleESeedClusterOverPout,
350	+	Double_t EleSigmaIPhiIPhi,
351	+	Double_t EleNBrem,
352	+	Double_t EleOneOverEMinusOneOverP,
353	+	Double_t EleESeedClusterOverPIn,
354	+	Double_t EleIP3d,
355	+	Double_t EleIP3dSig,
356	+	Double_t EleGsfTrackChi2OverNdof,
357	+	Double_t EledEtaCalo,
358	+	Double_t EledPhiCalo,
359	+	Double_t EleR9,
360	+	Double_t EleSCEtaWidth,
361	+	Double_t EleSCPhiWidth,
362	+	Double_t EleCovIEtaIPhi,
363	+	Double_t ElePreShowerOverRaw,
364	+	Double_t EleChargedIso03,
365	+	Double_t EleNeutralHadronIso03,
366	+	Double_t EleGammaIso03,
367	+	Double_t EleChargedIso04,
368	+	Double_t EleNeutralHadronIso04,
369	+	Double_t EleGammaIso04,
370	+	Bool_t printDebug
371	+	) {
372	+
373	+	if (!fIsInitialized) {
374	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
375	+	return -9999;
376		}
377
378	<	std::cout << "Electron ID MVA Initialization\n";
379	<	std::cout << "MethodName : " << fMethodname << std::endl;
380	<	std::cout << "Load weights file : " << Subdet0Pt10To20Weights << std::endl;
381	<	std::cout << "Load weights file : " << Subdet1Pt10To20Weights << std::endl;
382	<	std::cout << "Load weights file : " << Subdet2Pt10To20Weights << std::endl;
383	<	std::cout << "Load weights file : " << Subdet0Pt20ToInfWeights << std::endl;
384	<	std::cout << "Load weights file : " << Subdet1Pt20ToInfWeights << std::endl;
385	<	std::cout << "Load weights file : " << Subdet2Pt20ToInfWeights << std::endl;
378	>	Double_t Rho = 0;
379	>	if (!(TMath::IsNaN(PileupEnergyDensity) || isinf(PileupEnergyDensity))) Rho = PileupEnergyDensity;
380	>
381	>	//set all input variables
382	>	fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
383	>	fMVAVar_EleDEtaIn = EleDEtaIn;
384	>	fMVAVar_EleDPhiIn = EleDPhiIn;
385	>	fMVAVar_EleHoverE = EleHoverE;
386	>	fMVAVar_EleD0 = EleD0;
387	>	fMVAVar_EleDZ = EleDZ;
388	>	fMVAVar_EleFBrem = EleFBrem;
389	>	fMVAVar_EleEOverP = EleEOverP;
390	>	fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
391	>	fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
392	>	fMVAVar_EleNBrem = EleNBrem;
393	>	fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
394	>	fMVAVar_EleESeedClusterOverPIn = EleESeedClusterOverPIn;
395	>	fMVAVar_EleIP3d = EleIP3d;
396	>	fMVAVar_EleIP3dSig = EleIP3dSig;
397	>	fMVAVar_EleGsfTrackChi2OverNdof = EleGsfTrackChi2OverNdof;
398	>	fMVAVar_EledEtaCalo = EledEtaCalo;
399	>	fMVAVar_EledPhiCalo = EledPhiCalo;
400	>	fMVAVar_EleR9 = EleR9;
401	>	fMVAVar_EleSCEtaWidth = EleSCEtaWidth;
402	>	fMVAVar_EleSCPhiWidth = EleSCPhiWidth;
403	>	fMVAVar_EleCovIEtaIPhi = EleCovIEtaIPhi;
404	>	fMVAVar_ElePreShowerOverRaw = ElePreShowerOverRaw;
405	>	fMVAVar_EleChargedIso03OverPt
406	>	= (EleChargedIso03
407	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, EleEta)) / ElePt;
408	>	fMVAVar_EleNeutralHadronIso03OverPt
409	>	= (EleNeutralHadronIso03
410	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, EleEta)
411	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,EleEta)) / ElePt;
412	>	fMVAVar_EleGammaIso03OverPt
413	>	= (EleGammaIso03
414	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, EleEta)
415	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,EleEta))/ElePt;
416	>	fMVAVar_EleChargedIso04OverPt
417	>	= (EleChargedIso04
418	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso04, EleEta))/ElePt;
419	>	fMVAVar_EleNeutralHadronIso04OverPt
420	>	= (EleNeutralHadronIso04
421	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso04, EleEta)
422	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,EleEta))/ElePt;
423	>	fMVAVar_EleGammaIso04OverPt
424	>	= (EleGammaIso04
425	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, EleEta)
426	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,EleEta))/ElePt;
427	>
428	>
429	>
430	>
431	>	Double_t mva = -9999;
432	>	TMVA::Reader *reader = 0;
433	>	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
434	>	mva = reader->EvaluateMVA( fMethodname );
435	>
436	>	if (printDebug == kTRUE) {
437	>	std::cout << "Debug Electron MVA: "
438	>	<< ElePt << " " << EleEta << " " << " --> MVABin " << GetMVABin( EleEta, ElePt) << " : "
439	>	<< fMVAVar_EleSigmaIEtaIEta << " "
440	>	<< fMVAVar_EleDEtaIn << " "
441	>	<< fMVAVar_EleDPhiIn << " "
442	>	<< fMVAVar_EleHoverE << " "
443	>	<< fMVAVar_EleD0 << " "
444	>	<< fMVAVar_EleDZ << " "
445	>	<< fMVAVar_EleFBrem << " "
446	>	<< fMVAVar_EleEOverP << " "
447	>	<< fMVAVar_EleESeedClusterOverPout << " "
448	>	<< fMVAVar_EleSigmaIPhiIPhi << " "
449	>	<< fMVAVar_EleNBrem << " "
450	>	<< fMVAVar_EleOneOverEMinusOneOverP << " "
451	>	<< fMVAVar_EleESeedClusterOverPIn << " "
452	>	<< fMVAVar_EleIP3d << " "
453	>	<< fMVAVar_EleIP3dSig << " "
454	>	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
455	>	<< fMVAVar_EledEtaCalo << " "
456	>	<< fMVAVar_EledPhiCalo << " "
457	>	<< fMVAVar_EleR9 << " "
458	>	<< fMVAVar_EleSCEtaWidth << " "
459	>	<< fMVAVar_EleSCPhiWidth << " "
460	>	<< fMVAVar_EleCovIEtaIPhi << " "
461	>	<< fMVAVar_ElePreShowerOverRaw << " "
462	>	<< fMVAVar_EleChargedIso03OverPt  << " "
463	>	<< fMVAVar_EleNeutralHadronIso03OverPt  << " "
464	>	<< fMVAVar_EleGammaIso03OverPt  << " "
465	>	<< fMVAVar_EleChargedIso04OverPt  << " "
466	>	<< fMVAVar_EleNeutralHadronIso04OverPt  << " "
467	>	<< fMVAVar_EleGammaIso04OverPt  << " "
468	>	<< " === : === "
469	>	<< mva
470	>	<< std::endl;
471	>	}
472
473	+	return mva;
474		}
475
476
477		//--------------------------------------------------------------------------------------------------
478	<	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex) {
478	>	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
479	>	const PFCandidateCol *PFCands,
480	>	const PileupEnergyDensityCol *PileupEnergyDensity,
481	>	Double_t intRadius,
482	>	Bool_t printDebug) {
483	>
484	>	if (!fIsInitialized) {
485	>	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
486	>	return -9999;
487	>	}
488	>
489	>	Double_t Rho = 0;
490	>	if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
491	>
492	>	//set all input variables
493	>	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
494	>	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
495	>	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
496	>	fMVAVar_EleHoverE = ele->HadronicOverEm();
497	>	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
498	>	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
499	>	fMVAVar_EleFBrem = ele->FBrem();
500	>	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
501	>	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
502	>	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
503	>	else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
504	>	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
505	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
506	>	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
507	>	fMVAVar_EleIP3d = ele->Ip3dPV();
508	>	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
509	>	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
510	>	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
511	>	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
512	>	fMVAVar_EleR9 = ele->SCluster()->R9();
513	>	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
514	>	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
515	>	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
516	>	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
517	>	fMVAVar_EleChargedIso03OverPt
518	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.3, intRadius)
519	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, ele->SCluster()->Eta())) / ele->Pt();
520	>	fMVAVar_EleNeutralHadronIso03OverPt
521	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, intRadius, PFCandidate::eNeutralHadron)
522	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, ele->SCluster()->Eta())
523	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt();
524	>	fMVAVar_EleGammaIso03OverPt
525	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, intRadius, PFCandidate::eGamma)
526	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, ele->SCluster()->Eta())
527	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,ele->SCluster()->Eta())) / ele->Pt();
528	>	fMVAVar_EleChargedIso04OverPt
529	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.4, intRadius)
530	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso04, ele->SCluster()->Eta())) / ele->Pt();
531	>	fMVAVar_EleNeutralHadronIso04OverPt
532	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, intRadius, PFCandidate::eNeutralHadron)
533	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso04, ele->SCluster()->Eta())
534	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt() ;
535	>	fMVAVar_EleGammaIso04OverPt
536	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, intRadius, PFCandidate::eGamma)
537	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, ele->SCluster()->Eta())
538	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,ele->SCluster()->Eta())) / ele->Pt();
539	>
540	>	//Additional vars
541	>	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
542	>	if (ele->TrackerTrk()) {
543	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
544	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
545	>	} else {
546	>	fMVAVar_EleKFTrkChiSqr = -1;
547	>	fMVAVar_EleKFTrkNHits = 0;
548	>	}
549	>	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
550	>
551	>
552	>	Double_t mva = -9999;
553	>	TMVA::Reader *reader = 0;
554	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
555	>	mva = reader->EvaluateMVA( fMethodname );
556	>
557	>	if (printDebug == kTRUE) {
558	>	std::cout << "Debug Electron MVA: "
559	>	<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
560	>	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
561	>	<< fMVAVar_EleSigmaIEtaIEta << " "
562	>	<< fMVAVar_EleDEtaIn << " "
563	>	<< fMVAVar_EleDPhiIn << " "
564	>	<< fMVAVar_EleHoverE << " "
565	>	<< fMVAVar_EleD0 << " "
566	>	<< fMVAVar_EleDZ << " "
567	>	<< fMVAVar_EleFBrem << " "
568	>	<< fMVAVar_EleEOverP << " "
569	>	<< fMVAVar_EleESeedClusterOverPout << " "
570	>	<< fMVAVar_EleSigmaIPhiIPhi << " "
571	>	<< fMVAVar_EleNBrem << " "
572	>	<< fMVAVar_EleOneOverEMinusOneOverP << " "
573	>	<< fMVAVar_EleESeedClusterOverPIn << " "
574	>	<< fMVAVar_EleIP3d << " "
575	>	<< fMVAVar_EleIP3dSig << " "
576	>	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
577	>	<< fMVAVar_EledEtaCalo << " "
578	>	<< fMVAVar_EledPhiCalo << " "
579	>	<< fMVAVar_EleR9 << " "
580	>	<< fMVAVar_EleSCEtaWidth << " "
581	>	<< fMVAVar_EleSCPhiWidth << " "
582	>	<< fMVAVar_EleCovIEtaIPhi << " "
583	>	<< fMVAVar_ElePreShowerOverRaw << " "
584	>	<< fMVAVar_EleKFTrkChiSqr  << " "
585	>	<< fMVAVar_EleKFTrkNHits  << " "
586	>	<< fMVAVar_EleE1x5OverE5x5  << " "
587	>	<< " ::: "
588	>
589	>	<< " === : === "
590	>	<< mva << " "
591	>	<< std::endl;
592	>
593	>	}
594	>
595	>	return mva;
596	>	}
597	>
598	>	//--------------------------------------------------------------------------------------------------
599	>	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
600	>	Bool_t printDebug) {
601
602		if (!fIsInitialized) {
603		std::cout << "Error: ElectronIDMVA not properly initialized.\n";
604		return -9999;
605		}
606
607	<	Int_t subdet = 0;
608	<	if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
609	<	else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
610	<	else subdet = 2;
611	<	Int_t ptBin = 0;
612	<	if (ele->Pt() > 20.0) ptBin = 1;
607	>	fMVAVar_ElePt = ele->Pt();
608	>	fMVAVar_EleEta = ele->Eta();
609	>
610	>	//set all input variables
611	>	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
612	>	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
613	>	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
614	>	fMVAVar_EleHoverE = ele->HadronicOverEm();
615	>	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
616	>	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
617	>	fMVAVar_EleFBrem = ele->FBrem();
618	>	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
619	>	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
620	>	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
621	>	else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
622	>	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
623	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
624	>	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
625	>	fMVAVar_EleIP3d = ele->Ip3dPV();
626	>	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
627	>
628	>
629	>	fMVAVar_EleEEleClusterOverPout = 0;
630	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
631	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
632	>	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
633	>	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
634	>	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
635	>	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
636	>	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
637	>	fMVAVar_EleR9 = ele->SCluster()->R9();
638	>	fMVAVar_EleHoverE = ele->HadronicOverEm();
639	>	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
640	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
641	>	fMVAVar_EleR9 = ele->SCluster()->R9();
642	>	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
643	>
644	>
645	>	Double_t mva = -9999;
646	>	TMVA::Reader *reader = 0;
647	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
648	>	mva = reader->EvaluateMVA( fMethodname );
649	>
650	>	if (printDebug == kTRUE) {
651	>	std::cout << "Debug Electron MVA: "
652	>	<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
653	>	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
654	>	<< fMVAVar_EleSigmaIEtaIEta << " "
655	>	<< fMVAVar_EleDEtaIn << " "
656	>	<< fMVAVar_EleDPhiIn << " "
657	>	<< fMVAVar_EleHoverE << " "
658	>	<< fMVAVar_EleD0 << " "
659	>	<< fMVAVar_EleDZ << " "
660	>	<< fMVAVar_EleFBrem << " "
661	>	<< fMVAVar_EleEOverP << " "
662	>	<< fMVAVar_EleESeedClusterOverPout << " "
663	>	<< fMVAVar_EleSigmaIPhiIPhi << " "
664	>	<< fMVAVar_EleNBrem << " "
665	>	<< fMVAVar_EleOneOverEMinusOneOverP << " "
666	>	<< fMVAVar_EleESeedClusterOverPIn << " "
667	>	<< fMVAVar_EleIP3d << " "
668	>	<< fMVAVar_EleIP3dSig << " "
669	>	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
670	>	<< fMVAVar_EledEtaCalo << " "
671	>	<< fMVAVar_EledPhiCalo << " "
672	>	<< fMVAVar_EleR9 << " "
673	>	<< fMVAVar_EleSCEtaWidth << " "
674	>	<< fMVAVar_EleSCPhiWidth << " "
675	>	<< fMVAVar_EleCovIEtaIPhi << " "
676	>	<< fMVAVar_ElePreShowerOverRaw << " "
677	>	<< fMVAVar_EleKFTrkChiSqr  << " "
678	>	<< fMVAVar_EleKFTrkNHits  << " "
679	>	<< fMVAVar_EleE1x5OverE5x5  << " "
680	>	<< " === : === "
681	>	<< mva << " "
682	>	<< std::endl;
683	>
684	>	}
685	>
686	>
687	>
688	>	return mva;
689	>	}
690	>
691	>
692	>
693	>
694	>	//--------------------------------------------------------------------------------------------------
695	>	//MVA Includes Isolation with removal of other leptons
696	>	//
697	>	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
698	>	const PFCandidateCol *PFCands,
699	>	const PileupEnergyDensityCol *PileupEnergyDensity,
700	>	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaTarget,
701	>	const ElectronCol *goodElectrons,
702	>	const MuonCol *goodMuons,
703	>	Bool_t printDebug) {
704
705	+	if (!fIsInitialized) {
706	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
707	+	return -9999;
708	+	}
709	+
710	+	Double_t Rho = 0;
711	+	if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
712	+
713		//set all input variables
714	+	fMVAVar_ElePt = ele->Pt();
715	+	fMVAVar_EleEta = ele->SCluster()->Eta();
716		fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
717		fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
718		fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
#	Line 119 | Line 725 | Double_t ElectronIDMVA::MVAValue(const E
725		if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
726		else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
727		fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
728	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->ESuperClusterOverP()*ele->BestTrk()->P())) - 1.0 / ele->BestTrk()->P();
728	>
729	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
730	>	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
731	>	|| fMVAType == ElectronIDMVA::kIsoRingsV0) {
732	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->P();
733	>	} else {
734	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
735	>	}
736	>
737		fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
738		fMVAVar_EleIP3d = ele->Ip3dPV();
739		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
740	<	fMVAVar_EleStandardLikelihood = ElectronTools::Likelihood(fLH, ele);
740	>	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
741	>	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
742	>	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
743	>	fMVAVar_EleR9 = ele->SCluster()->R9();
744	>	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
745	>	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
746	>	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
747	>	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
748	>
749	>	//Additional vars
750	>	fMVAVar_EleEEleClusterOverPout = 0;
751	>	if (ele->TrackerTrk()) {
752	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
753	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
754	>	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
755	>	} else {
756	>	fMVAVar_EleKFTrkChiSqr = -1;
757	>	fMVAVar_EleKFTrkNHits = 0;
758	>	fMVAVar_EleKFTrkNLayers = 0;
759	>	}
760	>
761	>	fMVAVar_EleE1x5OverE5x5 = (ele->SCluster()->Seed()->E5x5() > 0.0) ? 1.0-ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5() : -1. ;
762	>
763	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
764	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
765	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
766	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
767	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
768	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
769	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
770	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
771	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
772	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
773	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
774	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
775	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
776	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
777	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
778	>
779	>	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
780	>	const PFCandidate *pf = PFCands->At(p);
781	>
782	>	//exclude the electron itself
783	>	if(pf->GsfTrk() && ele->GsfTrk() &&
784	>	pf->GsfTrk() == ele->GsfTrk()) continue;
785	>	if(pf->TrackerTrk() && ele->TrackerTrk() &&
786	>	pf->TrackerTrk() == ele->TrackerTrk()) continue;
787	>
788	>	//************************************************************
789	>	// New Isolation Calculations
790	>	//************************************************************
791	>	Double_t dr = MathUtils::DeltaR(ele->Mom(), pf->Mom());
792	>
793	>	if (dr < 1.0) {
794	>	Bool_t IsLeptonFootprint = kFALSE;
795	>	//************************************************************
796	>	// Lepton Footprint Removal
797	>	//************************************************************
798	>	for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) {
799	>	//if pf candidate matches an electron passing ID cuts, then veto it
800	>	if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() &&
801	>	pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE;
802	>	if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() &&
803	>	pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
804	>	//if pf candidate lies in veto regions of electron passing ID cuts, then veto it
805	>	if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479
806	>	&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE;
807	>	if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 &&
808	>	MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE;
809	>	}
810	>	for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) {
811	>	//if pf candidate matches an muon passing ID cuts, then veto it
812	>	if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() &&
813	>	pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
814	>	//if pf candidate lies in veto regions of muon passing ID cuts, then veto it
815	>	if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE;
816	>	}
817	>
818	>	if (!IsLeptonFootprint) {
819	>	Bool_t passVeto = kTRUE;
820	>	//Charged
821	>	if(pf->BestTrk()) {
822	>	if (!(fabs(pf->BestTrk()->DzCorrected(*vertex) - ele->BestTrk()->DzCorrected(*vertex)) < 0.2)) passVeto = kFALSE;
823	>	//************************************************************
824	>	// Veto any PFmuon, or PFEle
825	>	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
826	>	//************************************************************
827	>	//************************************************************
828	>	// Footprint Veto
829	>	if (fabs(ele->SCluster()->Eta()) >= 1.479 && dr < 0.015) passVeto = kFALSE;
830	>	//************************************************************
831	>	if (passVeto) {
832	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
833	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
834	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
835	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
836	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
837	>	} //pass veto
838	>
839	>	}
840	>	//Gamma
841	>	else if (pf->PFType() == PFCandidate::eGamma) {
842	>	//************************************************************
843	>	// Footprint Veto
844	>	if (fabs(ele->SCluster()->Eta()) >= 1.479) {
845	>	if (dr < 0.08) passVeto = kFALSE;
846	>	}
847	>	//************************************************************
848	>
849	>	if (passVeto) {
850	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
851	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
852	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
853	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
854	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
855	>	}
856	>	}
857	>	//NeutralHadron
858	>	else {
859	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
860	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
861	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
862	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
863	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
864	>	}
865	>	} //not lepton footprint
866	>	} //in 1.0 dr cone
867	>	} //loop over PF candidates
868	>
869	>	Double_t fMVAVar_ChargedIso_DR0p0To0p1  = 0;
870	>	Double_t fMVAVar_ChargedIso_DR0p1To0p2  = 0;
871	>	Double_t fMVAVar_ChargedIso_DR0p2To0p3  = 0;
872	>	Double_t fMVAVar_ChargedIso_DR0p3To0p4  = 0;
873	>	Double_t fMVAVar_ChargedIso_DR0p4To0p5  = 0;
874	>	Double_t fMVAVar_GammaIso_DR0p0To0p1  = 0;
875	>	Double_t fMVAVar_GammaIso_DR0p1To0p2  = 0;
876	>	Double_t fMVAVar_GammaIso_DR0p2To0p3  = 0;
877	>	Double_t fMVAVar_GammaIso_DR0p3To0p4  = 0;
878	>	Double_t fMVAVar_GammaIso_DR0p4To0p5  = 0;
879	>	Double_t fMVAVar_NeutralHadronIso_DR0p0To0p1  = 0;
880	>	Double_t fMVAVar_NeutralHadronIso_DR0p1To0p2  = 0;
881	>	Double_t fMVAVar_NeutralHadronIso_DR0p2To0p3  = 0;
882	>	Double_t fMVAVar_NeutralHadronIso_DR0p3To0p4  = 0;
883	>	Double_t fMVAVar_NeutralHadronIso_DR0p4To0p5  = 0;
884	>
885	>	fMVAVar_ChargedIso_DR0p0To0p1   = TMath::Min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
886	>	fMVAVar_ChargedIso_DR0p1To0p2   = TMath::Min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
887	>	fMVAVar_ChargedIso_DR0p2To0p3 = TMath::Min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
888	>	fMVAVar_ChargedIso_DR0p3To0p4 = TMath::Min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
889	>	fMVAVar_ChargedIso_DR0p4To0p5 = TMath::Min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
890	>	fMVAVar_GammaIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpGammaIso_DR0p0To0p1 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p0To0p1, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
891	>	fMVAVar_GammaIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpGammaIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
892	>	fMVAVar_GammaIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpGammaIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
893	>	fMVAVar_GammaIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpGammaIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
894	>	fMVAVar_GammaIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpGammaIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
895	>	fMVAVar_NeutralHadronIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p0To0p1 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p0To0p1, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
896	>	fMVAVar_NeutralHadronIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
897	>	fMVAVar_NeutralHadronIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
898	>	fMVAVar_NeutralHadronIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
899	>	fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
900	>
901	>	//Do Binding of MVA input variables
902	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
903	>	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
904	>	|| fMVAType == ElectronIDMVA::kIsoRingsV0) {
905	>	bindVariables();
906	>	}
907
908		Double_t mva = -9999;
909		TMVA::Reader *reader = 0;
910	<	Int_t MVABin = -1;
911	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
912	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
913	<	if (subdet == 2 && ptBin == 0) MVABin = 2;
914	<	if (subdet == 0 && ptBin == 1) MVABin = 3;
135	<	if (subdet == 1 && ptBin == 1) MVABin = 4;
136	<	if (subdet == 2 && ptBin == 1) MVABin = 5;
137	<	assert(MVABin >= 0 && MVABin <= 5);
138	<	reader = fTMVAReader[MVABin];
139	<
910	>
911	>	if (printDebug == kTRUE) {
912	>	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << std::endl;
913	>	}
914	>	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
915		mva = reader->EvaluateMVA( fMethodname );
916
917	+	if (printDebug == kTRUE) {
918	+
919	+	std::cout << "Debug Electron MVA: \n";
920	+	std::cout << " fbrem " <<  fMVAVar_EleFBrem
921	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
922	+	<< " kfhits " << fMVAVar_EleKFTrkNHits
923	+	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
924	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
925	+	<< " deta " <<  fMVAVar_EleDEtaIn
926	+	<< " dphi " << fMVAVar_EleDPhiIn
927	+	<< " detacalo " << fMVAVar_EledEtaCalo
928	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
929	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
930	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
931	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
932	+	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
933	+	<< " R9 " << fMVAVar_EleR9
934	+	<< " HoE " << fMVAVar_EleHoverE
935	+	<< " EoP " << fMVAVar_EleEOverP
936	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
937	+	<< " eleEoPout " << fMVAVar_EleESeedClusterOverPout
938	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
939	+	<< " d0 " << fMVAVar_EleD0
940	+	<< " ip3d " << fMVAVar_EleIP3d
941	+	<< " eta " << fMVAVar_EleEta
942	+	<< " pt " << fMVAVar_ElePt << std::endl;
943	+
944	+	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
945	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
946	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
947	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
948	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
949	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
950	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
951	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
952	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
953	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
954	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
955	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
956	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
957	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
958	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
959	+	<< std::endl;
960	+	std::cout << "MVA: " << mva << " "
961	+	<< std::endl;
962	+	}
963	+
964		return mva;
965		}
966	+
967	+
968	+	void ElectronIDMVA::bindVariables() {
969	+
970	+	// this binding is needed for variables that sometime diverge.
971	+
972	+	if(fMVAVar_EleFBrem < -1.)
973	+	fMVAVar_EleFBrem = -1.;
974	+
975	+	fMVAVar_EleDEtaIn = fabs(fMVAVar_EleDEtaIn);
976	+	if(fMVAVar_EleDEtaIn > 0.06)
977	+	fMVAVar_EleDEtaIn = 0.06;
978	+
979	+
980	+	fMVAVar_EleDPhiIn = fabs(fMVAVar_EleDPhiIn);
981	+	if(fMVAVar_EleDPhiIn > 0.6)
982	+	fMVAVar_EleDPhiIn = 0.6;
983	+
984	+
985	+	if(fMVAVar_EleESeedClusterOverPout > 20.)
986	+	fMVAVar_EleESeedClusterOverPout = 20.;
987	+
988	+	if(fMVAVar_EleEOverP > 20.)
989	+	fMVAVar_EleEOverP = 20.;
990	+
991	+	if(fMVAVar_EleEEleClusterOverPout > 20.)
992	+	fMVAVar_EleEEleClusterOverPout = 20.;
993	+
994	+
995	+	fMVAVar_EledEtaCalo = fabs(fMVAVar_EledEtaCalo);
996	+	if(fMVAVar_EledEtaCalo > 0.2)
997	+	fMVAVar_EledEtaCalo = 0.2;
998	+
999	+
1000	+	if(fMVAVar_EleE1x5OverE5x5 < -1.)
1001	+	fMVAVar_EleE1x5OverE5x5 = -1;
1002	+
1003	+	if(fMVAVar_EleE1x5OverE5x5 > 2.)
1004	+	fMVAVar_EleE1x5OverE5x5 = 2.;
1005	+
1006	+
1007	+
1008	+	if(fMVAVar_EleR9 > 5)
1009	+	fMVAVar_EleR9 = 5;
1010	+
1011	+	if(fMVAVar_EleGsfTrackChi2OverNdof > 200.)
1012	+	fMVAVar_EleGsfTrackChi2OverNdof = 200;
1013	+
1014	+
1015	+	if(fMVAVar_EleKFTrkChiSqr > 10.)
1016	+	fMVAVar_EleKFTrkChiSqr = 10.;
1017	+
1018	+	// Needed for a bug in CMSSW_420, fixed in more recent CMSSW versions
1019	+	if(std::isnan(fMVAVar_EleSigmaIPhiIPhi))
1020	+	fMVAVar_EleSigmaIPhiIPhi = 0.;
1021	+
1022	+
1023	+	return;
1024	+	}

Diff Legend

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