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.13 by sixie, Sun Apr 15 12:27:34 2012 UTC vs.
Revision 1.29 by sixie, Fri Oct 26 18:34:21 2012 UTC

#	Line 18 | Line 18 | fMethodname("BDTG method"),
18		fIsInitialized(kFALSE),
19		fMVAType(ElectronIDMVA::kUninitialized),
20		fUseBinnedVersion(kTRUE),
21	<	fNMVABins(0)
21	>	fNMVABins(0),
22	>	fTheRhoType(RhoUtilities::DEFAULT)
23		{
24		// Constructor.
25		}
#	Line 35 | Line 36 | ElectronIDMVA::~ElectronIDMVA()
36		//--------------------------------------------------------------------------------------------------
37		void ElectronIDMVA::Initialize( std::string methodName,
38		std::string weightsfile,
39	<	ElectronIDMVA::MVAType type)
39	>	ElectronIDMVA::MVAType type,
40	>	RhoUtilities::RhoType theRhoType)
41		{
42
43		std::vector<std::string> tempWeightFileVector;
44		tempWeightFileVector.push_back(weightsfile);
45	<	Initialize(methodName,type,kFALSE,tempWeightFileVector);
45	>	Initialize(methodName,type,kFALSE,tempWeightFileVector,theRhoType);
46		}
47
48		//--------------------------------------------------------------------------------------------------
#	Line 51 | Line 53 | void ElectronIDMVA::Initialize( TString
53		TString Subdet0Pt20ToInfWeights,
54		TString Subdet1Pt20ToInfWeights,
55		TString Subdet2Pt20ToInfWeights,
56	<	ElectronIDMVA::MVAType type) {
56	>	ElectronIDMVA::MVAType type,
57	>	RhoUtilities::RhoType theRhoType) {
58
59		std::vector<std::string> tempWeightFileVector;
60		tempWeightFileVector.push_back(std::string(Subdet0Pt10To20Weights.Data()));
#	Line 60 | Line 63 | void ElectronIDMVA::Initialize( TString
63		tempWeightFileVector.push_back(std::string(Subdet0Pt20ToInfWeights.Data()));
64		tempWeightFileVector.push_back(std::string(Subdet1Pt20ToInfWeights.Data()));
65		tempWeightFileVector.push_back(std::string(Subdet2Pt20ToInfWeights.Data()));
66	<	Initialize(std::string(methodName.Data()),type,kTRUE,tempWeightFileVector);
66	>	Initialize(std::string(methodName.Data()),type,kTRUE,tempWeightFileVector,theRhoType);
67
68		}
69
70
71		//--------------------------------------------------------------------------------------------------
72	<	void ElectronIDMVA::Initialize(  std::string methodName,
73	<	ElectronIDMVA::MVAType type,
74	<	Bool_t useBinnedVersion,
75	<	std::vector<std::string> weightsfiles
72	>	void ElectronIDMVA::Initialize( std::string methodName,
73	>	ElectronIDMVA::MVAType type,
74	>	Bool_t useBinnedVersion,
75	>	std::vector<std::string> weightsfiles,
76	>	RhoUtilities::RhoType theRhoType
77
78		) {
79
#	Line 84 | Line 88 | void ElectronIDMVA::Initialize(  std::st
88		fMethodname = methodName;
89		fMVAType = type;
90		fUseBinnedVersion = useBinnedVersion;
91	+	fTheRhoType = theRhoType;
92
93		//Define expected number of bins
94		UInt_t ExpectedNBins = 0;
#	Line 95 | Line 100 | void ElectronIDMVA::Initialize(  std::st
100		||type == kIDIsoCombined) {
101		ExpectedNBins = 6;
102		} else if (type == kIDEGamma2012TrigV0 ||
103	<	type == kIDEGamma2012NonTrigV0) {
103	>	type == kIDEGamma2012NonTrigV0 ||
104	>	type == kIDEGamma2012NonTrigV1 ||
105	>	type == kIDHWW2012TrigV0 ||
106	>	type == kIDIsoCombinedHWW2012TrigV4
107	>
108	>	) {
109		ExpectedNBins = 6;
110		} else if (type == kIsoRingsV0) {
111		ExpectedNBins = 4;
#	Line 183 | Line 193 | void ElectronIDMVA::Initialize(  std::st
193
194		}
195
196	<	if (type == kIDEGamma2012TrigV0 || type == kIDEGamma2012NonTrigV0 ) {
196	>	if (type == kIDEGamma2012TrigV0 || type == kIDHWW2012TrigV0) {
197		// Pure tracking variables
198		tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
199		tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
200	<	tmpTMVAReader->AddVariable("kfhits",          &fMVAVar_EleKFTrkNHits);  //Don't have this in BAMBU
200	>	tmpTMVAReader->AddVariable("kfhits",          &fMVAVar_EleKFTrkNLayers);  //Don't have this in (BAMBU <= 025)
201	>	if(type == kIDEGamma2012TrigV0)
202	>	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
203	>	tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
204	>	tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
205	>	tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
206	>	tmpTMVAReader->AddVariable("detacalo",        &fMVAVar_EledEtaCalo);
207	>	tmpTMVAReader->AddVariable("see",             &fMVAVar_EleSigmaIEtaIEta);
208	>	tmpTMVAReader->AddVariable("spp",             &fMVAVar_EleSigmaIPhiIPhi);
209	>	tmpTMVAReader->AddVariable("etawidth",        &fMVAVar_EleSCEtaWidth);
210	>	tmpTMVAReader->AddVariable("phiwidth",        &fMVAVar_EleSCPhiWidth);
211	>	tmpTMVAReader->AddVariable("e1x5e5x5",        &fMVAVar_EleE1x5OverE5x5);
212	>	tmpTMVAReader->AddVariable("R9",              &fMVAVar_EleR9);
213	>	tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
214	>	tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
215	>	tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
216	>	tmpTMVAReader->AddVariable("eleEoPout",       &fMVAVar_EleEEleClusterOverPout); //Don't have this in (BAMBU <= 025)
217	>	if(type == kIDEGamma2012TrigV0)
218	>	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout);
219	>	if (i == 2 || i == 5) {
220	>	tmpTMVAReader->AddVariable( "PreShowerOverRaw",      &fMVAVar_ElePreShowerOverRaw       );
221	>	}
222	>	tmpTMVAReader->AddVariable( "d0",             &fMVAVar_EleD0);
223	>	tmpTMVAReader->AddVariable( "ip3d",           &fMVAVar_EleIP3d);
224	>
225	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
226	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
227	>	}
228	>
229	>	if (type == kIDEGamma2012NonTrigV0 ) {
230	>	// Pure tracking variables
231	>	tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
232	>	tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
233		tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
234		tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
235		tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
#	Line 202 | Line 244 | void ElectronIDMVA::Initialize(  std::st
244		tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
245		tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
246		tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
247	+	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout);
248	+	if (i==2 || i==5) {
249	+	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
250	+	}
251	+	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
252	+	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
253	+	}
254	+
255	+	if (type == kIDEGamma2012NonTrigV1 ) {
256	+	// Pure tracking variables
257	+	tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
258	+	tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
259	+	tmpTMVAReader->AddVariable("kfhits",          &fMVAVar_EleKFTrkNLayers);
260	+	tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
261	+	tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
262	+	tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
263	+	tmpTMVAReader->AddVariable("detacalo",        &fMVAVar_EledEtaCalo);
264	+	tmpTMVAReader->AddVariable("see",             &fMVAVar_EleSigmaIEtaIEta);
265	+	tmpTMVAReader->AddVariable("spp",             &fMVAVar_EleSigmaIPhiIPhi);
266	+	tmpTMVAReader->AddVariable("etawidth",        &fMVAVar_EleSCEtaWidth);
267	+	tmpTMVAReader->AddVariable("phiwidth",        &fMVAVar_EleSCPhiWidth);
268	+	tmpTMVAReader->AddVariable("e1x5e5x5",        &fMVAVar_EleE1x5OverE5x5);
269	+	tmpTMVAReader->AddVariable("R9",              &fMVAVar_EleR9);
270	+	tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
271	+	tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
272	+	tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
273		tmpTMVAReader->AddVariable("eleEoPout",       &fMVAVar_EleEEleClusterOverPout);
274	<	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout); //we have this only in BAMBU
275	<	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
276	<
274	>	if (i==2 || i==5) {
275	>	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
276	>	}
277		tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
278		tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
279		}
280	<
280	>
281		if (type == kIsoRingsV0) {
282		tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1",         &fMVAVar_ChargedIso_DR0p0To0p1        );
283		tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2",         &fMVAVar_ChargedIso_DR0p1To0p2        );
#	Line 230 | Line 298 | void ElectronIDMVA::Initialize(  std::st
298		tmpTMVAReader->AddSpectator( "pt" ,   &fMVAVar_ElePt  );
299		}
300
301	+	if (type == kIDIsoCombinedHWW2012TrigV4) {
302	+
303	+	// Pure tracking variables
304	+	tmpTMVAReader->AddVariable("fbrem",                      &fMVAVar_EleFBrem);
305	+	tmpTMVAReader->AddVariable("kfchi2",                     &fMVAVar_EleKFTrkChiSqr);
306	+	tmpTMVAReader->AddVariable("kflayers",                   &fMVAVar_EleKFTrkNLayers);
307	+	tmpTMVAReader->AddVariable("gsfchi2",                    &fMVAVar_EleGsfTrackChi2OverNdof);
308	+
309	+	// Geometrical matchings
310	+	tmpTMVAReader->AddVariable("deta",                       &fMVAVar_EleDEtaIn);
311	+	tmpTMVAReader->AddVariable("dphi",                       &fMVAVar_EleDPhiIn);
312	+	tmpTMVAReader->AddVariable("detacalo",                   &fMVAVar_EledEtaCalo);
313	+
314	+	// Pure ECAL -> shower shapes
315	+	tmpTMVAReader->AddVariable("see",                        &fMVAVar_EleSigmaIEtaIEta);
316	+	tmpTMVAReader->AddVariable("spp",                        &fMVAVar_EleSigmaIPhiIPhi);
317	+	tmpTMVAReader->AddVariable("etawidth",                   &fMVAVar_EleSCEtaWidth);
318	+	tmpTMVAReader->AddVariable("phiwidth",                   &fMVAVar_EleSCPhiWidth);
319	+	tmpTMVAReader->AddVariable("OneMinusSeedE1x5OverE5x5",   &fMVAVar_EleOneMinusE1x5OverE5x5);
320	+	tmpTMVAReader->AddVariable("R9",                         &fMVAVar_EleR9);
321	+
322	+	// Energy matching
323	+	tmpTMVAReader->AddVariable("HoE",                        &fMVAVar_EleHoverE);
324	+	tmpTMVAReader->AddVariable("EoP",                        &fMVAVar_EleEOverP);
325	+	tmpTMVAReader->AddVariable("IoEmIoP",                    &fMVAVar_EleOneOverEMinusOneOverP);
326	+	tmpTMVAReader->AddVariable("EEleoPout",                  &fMVAVar_EleEEleClusterOverPout);
327	+	if(i == 2 || i == 5) {
328	+	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
329	+	}
330	+
331	+	// IP
332	+	tmpTMVAReader->AddVariable("d0",              &fMVAVar_EleD0);
333	+	tmpTMVAReader->AddVariable("ip3d",            &fMVAVar_EleIP3d);
334	+
335	+	//isolation variables
336	+	tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1",         &fMVAVar_ChargedIso_DR0p0To0p1        );
337	+	tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2",         &fMVAVar_ChargedIso_DR0p1To0p2        );
338	+	tmpTMVAReader->AddVariable( "ChargedIso_DR0p2To0p3",         &fMVAVar_ChargedIso_DR0p2To0p3        );
339	+	tmpTMVAReader->AddVariable( "ChargedIso_DR0p3To0p4",         &fMVAVar_ChargedIso_DR0p3To0p4        );
340	+	tmpTMVAReader->AddVariable( "ChargedIso_DR0p4To0p5",         &fMVAVar_ChargedIso_DR0p4To0p5        );
341	+	tmpTMVAReader->AddVariable( "GammaIso_DR0p0To0p1",           &fMVAVar_GammaIso_DR0p0To0p1          );
342	+	tmpTMVAReader->AddVariable( "GammaIso_DR0p1To0p2",           &fMVAVar_GammaIso_DR0p1To0p2          );
343	+	tmpTMVAReader->AddVariable( "GammaIso_DR0p2To0p3",           &fMVAVar_GammaIso_DR0p2To0p3          );
344	+	tmpTMVAReader->AddVariable( "GammaIso_DR0p3To0p4",           &fMVAVar_GammaIso_DR0p3To0p4          );
345	+	tmpTMVAReader->AddVariable( "GammaIso_DR0p4To0p5",           &fMVAVar_GammaIso_DR0p4To0p5          );
346	+	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p0To0p1",   &fMVAVar_NeutralHadronIso_DR0p0To0p1  );
347	+	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p1To0p2",   &fMVAVar_NeutralHadronIso_DR0p1To0p2  );
348	+	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p2To0p3",   &fMVAVar_NeutralHadronIso_DR0p2To0p3  );
349	+	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p3To0p4",   &fMVAVar_NeutralHadronIso_DR0p3To0p4  );
350	+	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p4To0p5",   &fMVAVar_NeutralHadronIso_DR0p4To0p5  );
351	+	tmpTMVAReader->AddVariable( "rho",                           &fMVAVar_Rho );
352	+
353	+	//spectators
354	+	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
355	+	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
356	+
357	+	}
358	+
359	+
360		tmpTMVAReader->BookMVA(fMethodname , weightsfiles[i] );
361		std::cout << "MVABin " << i << " : MethodName = " << fMethodname
362		<< " , type == " << type << " , "
#	Line 248 | Line 375 | UInt_t ElectronIDMVA::GetMVABin( double
375		//Default is to return the first bin
376		uint bin = 0;
377
378	+	//return the first bin if not using binned version
379	+	if (!fUseBinnedVersion) return 0;
380	+
381		if (fMVAType == ElectronIDMVA::kBaseline
382		||fMVAType == ElectronIDMVA::kNoIPInfo
383		||fMVAType == ElectronIDMVA::kWithIPInfo
#	Line 267 | Line 397 | UInt_t ElectronIDMVA::GetMVABin( double
397		if (pt >= 10 && fabs(eta) >= 1.479) bin = 3;
398		}
399
400	<	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
401	<	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ) {
400	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
401	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1) {
402		bin = 0;
403		if (pt < 10 && fabs(eta) < 0.8) bin = 0;
404		if (pt < 10 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 1;
#	Line 278 | Line 408 | UInt_t ElectronIDMVA::GetMVABin( double
408		if (pt >= 10 && fabs(eta) >= 1.479) bin = 5;
409		}
410
411	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
412	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ||
413	+	fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
414	+	) {
415	+	bin = 0;
416	+	if (pt < 20 && fabs(eta) < 0.8) bin = 0;
417	+	if (pt < 20 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 1;
418	+	if (pt < 20 && fabs(eta) >= 1.479) bin = 2;
419	+	if (pt >= 20 && fabs(eta) < 0.8) bin = 3;
420	+	if (pt >= 20 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 4;
421	+	if (pt >= 20 && fabs(eta) >= 1.479) bin = 5;
422	+	}
423	+
424		return bin;
425		}
426
#	Line 307 | Line 450 | Double_t ElectronIDMVA::MVAValue(Double_
450		return -9999;
451		}
452
310	–	Int_t subdet = 0;
311	–	if (fabs(EleEta) < 1.0) subdet = 0;
312	–	else if (fabs(EleEta) < 1.479) subdet = 1;
313	–	else subdet = 2;
314	–	Int_t ptBin = 0;
315	–	if (ElePt > 20.0) ptBin = 1;
316	–
453		//set all input variables
454		fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
455		fMVAVar_EleDEtaIn = EleDEtaIn;
#	Line 333 | Line 469 | Double_t ElectronIDMVA::MVAValue(Double_
469
470		Double_t mva = -9999;
471		TMVA::Reader *reader = 0;
472	<	Int_t MVABin = -1;
337	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
338	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
339	<	if (subdet == 2 && ptBin == 0) MVABin = 2;
340	<	if (subdet == 0 && ptBin == 1) MVABin = 3;
341	<	if (subdet == 1 && ptBin == 1) MVABin = 4;
342	<	if (subdet == 2 && ptBin == 1) MVABin = 5;
343	<	assert(MVABin >= 0 && MVABin <= 5);
344	<	reader = fTMVAReader[MVABin];
472	>	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
473
474		mva = reader->EvaluateMVA( fMethodname );
475
#	Line 390 | Line 518 | Double_t ElectronIDMVA::MVAValue(Double_
518		Double_t Rho = 0;
519		if (!(TMath::IsNaN(PileupEnergyDensity) || isinf(PileupEnergyDensity))) Rho = PileupEnergyDensity;
520
393	–	Int_t subdet = 0;
394	–	if (fabs(EleEta) < 1.0) subdet = 0;
395	–	else if (fabs(EleEta) < 1.479) subdet = 1;
396	–	else subdet = 2;
397	–	Int_t ptBin = 0;
398	–	if (ElePt > 20.0) ptBin = 1;
399	–
521		//set all input variables
522		fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
523		fMVAVar_EleDEtaIn = EleDEtaIn;
#	Line 449 | Line 570 | Double_t ElectronIDMVA::MVAValue(Double_
570
571		Double_t mva = -9999;
572		TMVA::Reader *reader = 0;
573	<	Int_t MVABin = -1;
453	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
454	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
455	<	if (subdet == 2 && ptBin == 0) MVABin = 2;
456	<	if (subdet == 0 && ptBin == 1) MVABin = 3;
457	<	if (subdet == 1 && ptBin == 1) MVABin = 4;
458	<	if (subdet == 2 && ptBin == 1) MVABin = 5;
459	<	assert(MVABin >= 0 && MVABin <= 5);
460	<	reader = fTMVAReader[MVABin];
461	<
573	>	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
574		mva = reader->EvaluateMVA( fMethodname );
575
576		if (printDebug == kTRUE) {
577		std::cout << "Debug Electron MVA: "
578	<	<< ElePt << " " << EleEta << " " << " --> MVABin " << MVABin << " : "
578	>	<< ElePt << " " << EleEta << " " << " --> MVABin " << GetMVABin( EleEta, ElePt) << " : "
579		<< fMVAVar_EleSigmaIEtaIEta << " "
580		<< fMVAVar_EleDEtaIn << " "
581		<< fMVAVar_EleDPhiIn << " "
#	Line 501 | Line 613 | Double_t ElectronIDMVA::MVAValue(Double_
613		return mva;
614		}
615
616	+	Double_t ElectronIDMVA::MVAValue_IsoRings( Double_t ElePt,
617	+	Double_t EleSCEta,
618	+	Double_t ChargedIso_DR0p0To0p1,
619	+	Double_t ChargedIso_DR0p1To0p2,
620	+	Double_t ChargedIso_DR0p2To0p3,
621	+	Double_t ChargedIso_DR0p3To0p4,
622	+	Double_t ChargedIso_DR0p4To0p5,
623	+	Double_t GammaIso_DR0p0To0p1,
624	+	Double_t GammaIso_DR0p1To0p2,
625	+	Double_t GammaIso_DR0p2To0p3,
626	+	Double_t GammaIso_DR0p3To0p4,
627	+	Double_t GammaIso_DR0p4To0p5,
628	+	Double_t NeutralHadronIso_DR0p0To0p1,
629	+	Double_t NeutralHadronIso_DR0p1To0p2,
630	+	Double_t NeutralHadronIso_DR0p2To0p3,
631	+	Double_t NeutralHadronIso_DR0p3To0p4,
632	+	Double_t NeutralHadronIso_DR0p4To0p5,
633	+	Bool_t printDebug) {
634	+
635	+	if (fMVAType != ElectronIDMVA::kIsoRingsV0) {
636	+	std::cout << "Error: This function is only supported for MVAType == kIsoRingsV0.\n" << std::endl;
637	+	assert(kFALSE);
638	+	}
639	+
640	+	fMVAVar_ElePt = ElePt;
641	+	fMVAVar_EleEta = EleSCEta;
642	+	fMVAVar_ChargedIso_DR0p0To0p1 = ChargedIso_DR0p0To0p1;
643	+	fMVAVar_ChargedIso_DR0p1To0p2 = ChargedIso_DR0p1To0p2;
644	+	fMVAVar_ChargedIso_DR0p2To0p3 = ChargedIso_DR0p2To0p3;
645	+	fMVAVar_ChargedIso_DR0p3To0p4 = ChargedIso_DR0p3To0p4;
646	+	fMVAVar_ChargedIso_DR0p4To0p5 = ChargedIso_DR0p4To0p5;
647	+	fMVAVar_GammaIso_DR0p0To0p1 = GammaIso_DR0p0To0p1;
648	+	fMVAVar_GammaIso_DR0p1To0p2 = GammaIso_DR0p1To0p2;
649	+	fMVAVar_GammaIso_DR0p2To0p3 = GammaIso_DR0p2To0p3;
650	+	fMVAVar_GammaIso_DR0p3To0p4 = GammaIso_DR0p3To0p4;
651	+	fMVAVar_GammaIso_DR0p4To0p5 = GammaIso_DR0p4To0p5;
652	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = NeutralHadronIso_DR0p0To0p1;
653	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = NeutralHadronIso_DR0p1To0p2;
654	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = NeutralHadronIso_DR0p2To0p3;
655	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = NeutralHadronIso_DR0p3To0p4;
656	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = NeutralHadronIso_DR0p4To0p5;
657	+
658	+	Double_t mva = -9999;
659	+	TMVA::Reader *reader = 0;
660	+
661	+	if (printDebug == kTRUE) {
662	+	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << std::endl;
663	+	}
664	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
665	+	mva = reader->EvaluateMVA( fMethodname );
666	+
667	+	if (printDebug == kTRUE) {
668	+
669	+	std::cout << "Debug Electron MVA-ISO: ";
670	+	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
671	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
672	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
673	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
674	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
675	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
676	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
677	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
678	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
679	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
680	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
681	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
682	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
683	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
684	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
685	+	<< std::endl;
686	+	std::cout << "MVA: " << mva << " "
687	+	<< std::endl;
688	+	}
689	+	return mva;
690	+	}
691	+
692	+	Double_t ElectronIDMVA::MVAValue_IDNonTrig( Double_t ElePt,
693	+	Double_t EleSCEta,
694	+	Double_t EleFBrem,
695	+	Double_t EleKFTrkChiSqr,
696	+	Double_t EleKFTrkNHits,
697	+	Double_t EleGsfTrackChi2OverNdof,
698	+	Double_t EleDEtaIn,
699	+	Double_t EleDPhiIn,
700	+	Double_t EledEtaCalo,
701	+	Double_t EleSigmaIEtaIEta,
702	+	Double_t EleSigmaIPhiIPhi,
703	+	Double_t EleSCEtaWidth,
704	+	Double_t EleSCPhiWidth,
705	+	Double_t EleE1x5OverE5x5,
706	+	Double_t EleR9,
707	+	Double_t EleHoverE,
708	+	Double_t EleEOverP,
709	+	Double_t EleOneOverEMinusOneOverP,
710	+	Double_t EleESeedClusterOverPout,
711	+	Double_t ElePreShowerOverRaw,
712	+	Bool_t printDebug) {
713	+
714	+	if (fMVAType != ElectronIDMVA::kIDEGamma2012NonTrigV0) {
715	+	std::cout << "Error: This function is only supported for MVAType == kIDEGamma2012NonTrigV0.\n" << std::endl;
716	+	assert(kFALSE);
717	+	}
718	+
719	+	fMVAVar_ElePt = ElePt;
720	+	fMVAVar_EleEta = EleSCEta;
721	+	fMVAVar_EleFBrem = EleFBrem;
722	+	fMVAVar_EleKFTrkChiSqr = EleKFTrkChiSqr;
723	+	fMVAVar_EleKFTrkNHits = EleKFTrkNHits;
724	+	fMVAVar_EleGsfTrackChi2OverNdof = EleGsfTrackChi2OverNdof;
725	+	fMVAVar_EleDEtaIn = EleDEtaIn;
726	+	fMVAVar_EleDPhiIn = EleDPhiIn;
727	+	fMVAVar_EledEtaCalo = EledEtaCalo;
728	+	fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
729	+	fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
730	+	fMVAVar_EleSCEtaWidth = EleSCEtaWidth;
731	+	fMVAVar_EleSCPhiWidth = EleSCPhiWidth;
732	+	fMVAVar_EleE1x5OverE5x5 = EleE1x5OverE5x5;
733	+	fMVAVar_EleR9 = EleR9;
734	+	fMVAVar_EleHoverE = EleHoverE;
735	+	fMVAVar_EleEOverP = EleEOverP;
736	+	fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
737	+	fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
738	+	fMVAVar_ElePreShowerOverRaw = ElePreShowerOverRaw;
739	+
740	+	Double_t mva = -9999;
741	+	TMVA::Reader *reader = 0;
742	+
743	+	if (printDebug == kTRUE) {
744	+	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << std::endl;
745	+	}
746	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
747	+	mva = reader->EvaluateMVA( fMethodname );
748	+
749	+	if (printDebug == kTRUE) {
750	+	std::cout << "Debug Electron MVA: ";
751	+	std::cout << " fbrem " <<  fMVAVar_EleFBrem
752	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
753	+	<< " kfhits " << fMVAVar_EleKFTrkNLayers
754	+	<< " kfhitsall " <<  fMVAVar_EleKFTrkNHits
755	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
756	+	<< " deta " <<  fMVAVar_EleDEtaIn
757	+	<< " dphi " << fMVAVar_EleDPhiIn
758	+	<< " detacalo " << fMVAVar_EledEtaCalo
759	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
760	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
761	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
762	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
763	+	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
764	+	<< " R9 " << fMVAVar_EleR9
765	+	<< " HoE " << fMVAVar_EleHoverE
766	+	<< " EoP " << fMVAVar_EleEOverP
767	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
768	+	<< " eleEoPout " << fMVAVar_EleESeedClusterOverPout
769	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
770	+	<< " d0 " << fMVAVar_EleD0
771	+	<< " ip3d " << fMVAVar_EleIP3d
772	+	<< " eta " << fMVAVar_EleEta
773	+	<< " pt " << fMVAVar_ElePt << std::endl;
774	+	std::cout << "MVA: " << mva << " "
775	+	<< std::endl;
776	+	}
777	+	return mva;
778	+	}
779
780		//--------------------------------------------------------------------------------------------------
781		Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
#	Line 514 | Line 789 | Double_t ElectronIDMVA::MVAValue(const E
789		return -9999;
790		}
791
517	–	Int_t subdet = 0;
518	–	if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
519	–	else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
520	–	else subdet = 2;
521	–	Int_t ptBin = 0;
522	–	if (ele->Pt() > 20.0) ptBin = 1;
523	–
792		Double_t Rho = 0;
793	<	if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
793	>	switch(fTheRhoType) {
794	>	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
795	>	Rho = PileupEnergyDensity->At(0)->Rho();
796	>	break;
797	>	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
798	>	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
799	>	break;
800	>	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
801	>	Rho = PileupEnergyDensity->At(0)->RhoRandom();
802	>	break;
803	>	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
804	>	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
805	>	break;
806	>	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
807	>	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
808	>	break;
809	>	default:
810	>	// use the old default
811	>	Rho = PileupEnergyDensity->At(0)->Rho();
812	>	break;
813	>	}
814
815		//set all input variables
816		fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
#	Line 537 | Line 825 | Double_t ElectronIDMVA::MVAValue(const E
825		if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
826		else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
827		fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
828	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
828	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
829		fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
830		fMVAVar_EleIP3d = ele->Ip3dPV();
831		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
#	Line 573 | Line 861 | Double_t ElectronIDMVA::MVAValue(const E
861		+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,ele->SCluster()->Eta())) / ele->Pt();
862
863		//Additional vars
864	<	fMVAVar_EleEEleClusterOverPout = 0;
865	<	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
866	<	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
864	>	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
865	>	if (ele->TrackerTrk()) {
866	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
867	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
868	>	} else {
869	>	fMVAVar_EleKFTrkChiSqr = -1;
870	>	fMVAVar_EleKFTrkNHits = 0;
871	>	}
872		fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
873
874
582	–
583	–
875		Double_t mva = -9999;
876		TMVA::Reader *reader = 0;
877	<	Int_t MVABin = -1;
587	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
588	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
589	<	if (subdet == 2 && ptBin == 0) MVABin = 2;
590	<	if (subdet == 0 && ptBin == 1) MVABin = 3;
591	<	if (subdet == 1 && ptBin == 1) MVABin = 4;
592	<	if (subdet == 2 && ptBin == 1) MVABin = 5;
593	<	assert(MVABin >= 0 && MVABin <= 5);
594	<	reader = fTMVAReader[MVABin];
595	<
877	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
878		mva = reader->EvaluateMVA( fMethodname );
879
880		if (printDebug == kTRUE) {
599	–	//     std::cout << "Debug Electron MVA: "
600	–	//               << ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
601	–	//               << ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << MVABin << " : "
602	–	//               << fMVAVar_EleSigmaIEtaIEta << " "
603	–	//               << fMVAVar_EleDEtaIn << " "
604	–	//               << fMVAVar_EleDPhiIn << " "
605	–	//               << fMVAVar_EleHoverE << " "
606	–	//               << fMVAVar_EleD0 << " "
607	–	//               << fMVAVar_EleDZ << " "
608	–	//               << fMVAVar_EleFBrem << " "
609	–	//               << fMVAVar_EleEOverP << " "
610	–	//               << fMVAVar_EleESeedClusterOverPout << " "
611	–	//               << fMVAVar_EleSigmaIPhiIPhi << " "
612	–	//               << fMVAVar_EleNBrem << " "
613	–	//               << fMVAVar_EleOneOverEMinusOneOverP << " "
614	–	//               << fMVAVar_EleESeedClusterOverPIn << " "
615	–	//               << fMVAVar_EleIP3d << " "
616	–	//               << fMVAVar_EleIP3dSig << " "
617	–	//               << fMVAVar_EleGsfTrackChi2OverNdof << " "
618	–	//               << fMVAVar_EledEtaCalo << " "
619	–	//               << fMVAVar_EledPhiCalo << " "
620	–	//               << fMVAVar_EleR9 << " "
621	–	//               << fMVAVar_EleSCEtaWidth << " "
622	–	//               << fMVAVar_EleSCPhiWidth << " "
623	–	//               << fMVAVar_EleCovIEtaIPhi << " "
624	–	//               << fMVAVar_ElePreShowerOverRaw << " "
625	–	//               << fMVAVar_EleChargedIso03OverPt  << " "
626	–	//               << fMVAVar_EleNeutralHadronIso03OverPt  << " "
627	–	//               << fMVAVar_EleGammaIso03OverPt  << " "
628	–	//               << fMVAVar_EleChargedIso04OverPt  << " "
629	–	//               << fMVAVar_EleNeutralHadronIso04OverPt  << " "
630	–	//               << fMVAVar_EleGammaIso04OverPt  << " "
631	–	//               << " === : === "
632	–	//               << mva << " "
633	–	//               << std::endl;
881		std::cout << "Debug Electron MVA: "
882		<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
883	<	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << MVABin << " : "
883	>	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
884		<< fMVAVar_EleSigmaIEtaIEta << " "
885		<< fMVAVar_EleDEtaIn << " "
886		<< fMVAVar_EleDPhiIn << " "
#	Line 680 | Line 927 | Double_t ElectronIDMVA::MVAValue(const E
927		return -9999;
928		}
929
683	–	Int_t subdet = 0;
684	–	if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
685	–	else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
686	–	else subdet = 2;
687	–	Int_t ptBin = 0;
688	–	if (ele->Pt() > 20.0) ptBin = 1;
689	–
930		fMVAVar_ElePt = ele->Pt();
931		fMVAVar_EleEta = ele->Eta();
932
#	Line 701 | Line 941 | Double_t ElectronIDMVA::MVAValue(const E
941		fMVAVar_EleEOverP = ele->ESuperClusterOverP();
942		fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
943		if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
944	<	else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
944	>	else fMVAVar_EleSigmaIPhiIPhi = 0;
945		fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
946	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
946	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
947		fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
948		fMVAVar_EleIP3d = ele->Ip3dPV();
949		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
950
951
952	<	fMVAVar_EleEEleClusterOverPout = 0;
953	<	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
954	<	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
952	>	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
953	>	if (ele->TrackerTrk()) {
954	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
955	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
956	>	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
957	>	} else {
958	>	fMVAVar_EleKFTrkChiSqr = -1;
959	>	fMVAVar_EleKFTrkNHits = 0;
960	>	fMVAVar_EleKFTrkNLayers = 0;
961	>	}
962		fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
963		fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
964		fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
#	Line 720 | Line 967 | Double_t ElectronIDMVA::MVAValue(const E
967		fMVAVar_EleR9 = ele->SCluster()->R9();
968		fMVAVar_EleHoverE = ele->HadronicOverEm();
969		fMVAVar_EleEOverP = ele->ESuperClusterOverP();
970	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
970	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
971		fMVAVar_EleR9 = ele->SCluster()->R9();
972		fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
973
974
975		Double_t mva = -9999;
976		TMVA::Reader *reader = 0;
977	<	Int_t MVABin = -1;
731	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
732	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
733	<	if (subdet == 2 && ptBin == 0) MVABin = 2;
734	<	if (subdet == 0 && ptBin == 1) MVABin = 3;
735	<	if (subdet == 1 && ptBin == 1) MVABin = 4;
736	<	if (subdet == 2 && ptBin == 1) MVABin = 5;
737	<	assert(MVABin >= 0 && MVABin <= 5);
738	<	reader = fTMVAReader[MVABin];
739	<
977	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
978		mva = reader->EvaluateMVA( fMethodname );
979
980		if (printDebug == kTRUE) {
981		std::cout << "Debug Electron MVA: "
982		<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
983	<	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << MVABin << " : "
983	>	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
984		<< fMVAVar_EleSigmaIEtaIEta << " "
985		<< fMVAVar_EleDEtaIn << " "
986		<< fMVAVar_EleDPhiIn << " "
#	Line 781 | Line 1019 | Double_t ElectronIDMVA::MVAValue(const E
1019		}
1020
1021
784	–
785	–
1022		//--------------------------------------------------------------------------------------------------
1023		//MVA Includes Isolation with removal of other leptons
1024		//
#	Line 800 | Line 1036 | Double_t ElectronIDMVA::MVAValue(const E
1036		}
1037
1038		Double_t Rho = 0;
1039	<	if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
1039	>	switch(fTheRhoType) {
1040	>	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
1041	>	Rho = PileupEnergyDensity->At(0)->Rho();
1042	>	break;
1043	>	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
1044	>	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
1045	>	break;
1046	>	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
1047	>	Rho = PileupEnergyDensity->At(0)->RhoRandom();
1048	>	break;
1049	>	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
1050	>	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
1051	>	break;
1052	>	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
1053	>	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
1054	>	break;
1055	>	default:
1056	>	// use the old default
1057	>	Rho = PileupEnergyDensity->At(0)->Rho();
1058	>	break;
1059	>	}
1060
1061		//set all input variables
1062		fMVAVar_ElePt = ele->Pt();
1063		fMVAVar_EleEta = ele->SCluster()->Eta();
1064	<	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
1065	<	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
1066	<	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
1064	>	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
1065	>
1066	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1067	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1068	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1069	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
1070	>	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
1071	>	fMVAVar_EleDPhiIn = TMath::Min(fabs(double(ele->DeltaPhiSuperClusterTrackAtVtx())),0.6);
1072	>	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
1073	>	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
1074	>	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
1075	>	fMVAVar_EleEEleClusterOverPout = TMath::Min(double(ele->EEleClusterOverPout()),20.0);
1076	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->P();
1077	>	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
1078	>	fMVAVar_EledEtaCalo =  TMath::Min(fabs(double(ele->DeltaEtaSeedClusterTrackAtCalo())),0.2);
1079	>	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
1080	>	} else {
1081	>	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
1082	>	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
1083	>	fMVAVar_EleFBrem = ele->FBrem();
1084	>	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
1085	>	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
1086	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
1087	>	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
1088	>	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1089	>	fMVAVar_EleR9 = ele->SCluster()->R9();
1090	>	}
1091	>
1092		fMVAVar_EleHoverE = ele->HadronicOverEm();
1093		fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
1094		fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
814	–	fMVAVar_EleFBrem = ele->FBrem();
815	–	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
816	–	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
1095		if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
1096	<	else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
1097	<	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
1098	<
1099	<	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1100	<	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
1101	<	|| fMVAType == ElectronIDMVA::kIsoRingsV0) {
824	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->P();
825	<	} else {
826	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
1096	>	else {
1097	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1) {
1098	>	fMVAVar_EleSigmaIPhiIPhi = 0;
1099	>	} else {
1100	>	fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
1101	>	}
1102		}
1103
1104	+	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
1105		fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
1106		fMVAVar_EleIP3d = ele->Ip3dPV();
1107		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
832	–	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
833	–	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1108		fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
835	–	fMVAVar_EleR9 = ele->SCluster()->R9();
1109		fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
1110		fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
1111		fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
1112		fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
1113
1114		//Additional vars
842	–	fMVAVar_EleEEleClusterOverPout = 0;
1115		if (ele->TrackerTrk()) {
1116	<	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
1116	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1117	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1118	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1119	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
1120	>	fMVAVar_EleKFTrkChiSqr = TMath::Min(double(ele->TrackerTrk()->RChi2()),10.0);
1121	>	} else {
1122	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
1123	>	}
1124		fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
1125	+	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
1126		} else {
1127		fMVAVar_EleKFTrkChiSqr = 0;
1128		fMVAVar_EleKFTrkNHits = -1;
1129	+	fMVAVar_EleKFTrkNLayers = -1;
1130		}
1131
1132	<	fMVAVar_EleE1x5OverE5x5 = (ele->SCluster()->Seed()->E5x5() > 0.0) ? 1.0-ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5() : -1. ;
1132	>	if( ele->SCluster()->Seed()->E5x5() > 0.0 ) {
1133	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1134	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1135	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1136	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
1137	>	fMVAVar_EleE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1138	>	} else {
1139	>	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5();
1140	>	}
1141	>	} else {
1142	>	fMVAVar_EleE1x5OverE5x5 = -1.0;
1143	>	}
1144	>
1145
1146		Double_t tmpChargedIso_DR0p0To0p1  = 0;
1147		Double_t tmpChargedIso_DR0p1To0p2  = 0;
#	Line 885 | Line 1178 | Double_t ElectronIDMVA::MVAValue(const E
1178		//************************************************************
1179		// Lepton Footprint Removal
1180		//************************************************************
1181	<	for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) {
1182	<	//if pf candidate matches an electron passing ID cuts, then veto it
1183	<	if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() &&
1184	<	pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE;
1185	<	if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() &&
1186	<	pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1187	<	//if pf candidate lies in veto regions of electron passing ID cuts, then veto it
1188	<	if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479
1189	<	&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE;
1190	<	if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 &&
1191	<	MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE;
1181	>	if(goodElectrons) {
1182	>	for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) {
1183	>	//if pf candidate matches an electron passing ID cuts, then veto it
1184	>	if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() &&
1185	>	pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE;
1186	>	if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() &&
1187	>	pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1188	>	//if pf candidate lies in veto regions of electron passing ID cuts, then veto it
1189	>	if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479
1190	>	&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE;
1191	>	if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 &&
1192	>	MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE;
1193	>	}
1194		}
1195	<	for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) {
1196	<	//if pf candidate matches an muon passing ID cuts, then veto it
1197	<	if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() &&
1198	<	pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1199	<	//if pf candidate lies in veto regions of muon passing ID cuts, then veto it
1200	<	if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE;
1195	>	if(goodMuons) {
1196	>	for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) {
1197	>	//if pf candidate matches an muon passing ID cuts, then veto it
1198	>	if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() &&
1199	>	pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1200	>	//if pf candidate lies in veto regions of muon passing ID cuts, then veto it
1201	>	if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE;
1202	>	}
1203		}
1204
1205		if (!IsLeptonFootprint) {
#	Line 956 | Line 1253 | Double_t ElectronIDMVA::MVAValue(const E
1253		} //in 1.0 dr cone
1254		} //loop over PF candidates
1255
959	–	Double_t fMVAVar_ChargedIso_DR0p0To0p1  = 0;
960	–	Double_t fMVAVar_ChargedIso_DR0p1To0p2  = 0;
961	–	Double_t fMVAVar_ChargedIso_DR0p2To0p3  = 0;
962	–	Double_t fMVAVar_ChargedIso_DR0p3To0p4  = 0;
963	–	Double_t fMVAVar_ChargedIso_DR0p4To0p5  = 0;
964	–	Double_t fMVAVar_GammaIso_DR0p0To0p1  = 0;
965	–	Double_t fMVAVar_GammaIso_DR0p1To0p2  = 0;
966	–	Double_t fMVAVar_GammaIso_DR0p2To0p3  = 0;
967	–	Double_t fMVAVar_GammaIso_DR0p3To0p4  = 0;
968	–	Double_t fMVAVar_GammaIso_DR0p4To0p5  = 0;
969	–	Double_t fMVAVar_NeutralHadronIso_DR0p0To0p1  = 0;
970	–	Double_t fMVAVar_NeutralHadronIso_DR0p1To0p2  = 0;
971	–	Double_t fMVAVar_NeutralHadronIso_DR0p2To0p3  = 0;
972	–	Double_t fMVAVar_NeutralHadronIso_DR0p3To0p4  = 0;
973	–	Double_t fMVAVar_NeutralHadronIso_DR0p4To0p5  = 0;
974	–
1256		fMVAVar_ChargedIso_DR0p0To0p1   = TMath::Min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1257		fMVAVar_ChargedIso_DR0p1To0p2   = TMath::Min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1258		fMVAVar_ChargedIso_DR0p2To0p3 = TMath::Min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
#	Line 986 | Line 1267 | Double_t ElectronIDMVA::MVAValue(const E
1267		fMVAVar_NeutralHadronIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1268		fMVAVar_NeutralHadronIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1269		fMVAVar_NeutralHadronIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1270	<	fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
990	<
991	<	//   cout << "gg: " << tmpGammaIso_DR0p4To0p5 << " : " << ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget) << " " << EffectiveAreaTarget << endl;
1270	>	fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1271
1272		//Do Binding of MVA input variables
1273	<	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1273	>	if (   fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1274		|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
1275	<	|| fMVAType == ElectronIDMVA::kIsoRingsV0) {
1275	>	|| fMVAType == ElectronIDMVA::kIsoRingsV0
1276	>	|| fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
1277		bindVariables();
1278		}
1279
1280		Double_t mva = -9999;
1281		TMVA::Reader *reader = 0;
1002	–	Int_t MVABin = -1;
1003	–
1004	–	if (fMVAVar_ElePt < 10 && fabs(fMVAVar_EleEta) < 1.479) MVABin = 0;
1005	–	if (fMVAVar_ElePt < 10 && fabs(fMVAVar_EleEta) >= 1.479) MVABin = 1;
1006	–	if (fMVAVar_ElePt > 10 && fabs(fMVAVar_EleEta) < 1.479) MVABin = 2;
1007	–	if (fMVAVar_ElePt > 10 && fabs(fMVAVar_EleEta) >= 1.479) MVABin = 3;
1282
1283	<	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << MVABin << std::endl;
1283	>	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
1284	>	mva = reader->EvaluateMVA( fMethodname );
1285
1286	<	if (!fUseBinnedVersion) {
1287	<	reader = fTMVAReader[0];
1286	>	if (printDebug == kTRUE) {
1287	>
1288	>	std::cout << "Debug Electron MVA-ID: "
1289	>	<< fMVAVar_ElePt<< " " << fMVAVar_EleEta << " "
1290	>	<< " --> MVABin " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << " : "
1291	>	<< " fbrem " <<  fMVAVar_EleFBrem
1292	>	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
1293	>	<< " kfhits " << fMVAVar_EleKFTrkNLayers
1294	>	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1295	>	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
1296	>	<< " deta " <<  fMVAVar_EleDEtaIn
1297	>	<< " dphi " << fMVAVar_EleDPhiIn
1298	>	<< " detacalo " << fMVAVar_EledEtaCalo
1299	>	<< " see " << fMVAVar_EleSigmaIEtaIEta
1300	>	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
1301	>	<< " etawidth " << fMVAVar_EleSCEtaWidth
1302	>	<< " phiwidth " << fMVAVar_EleSCPhiWidth
1303	>	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
1304	>	<< " R9 " << fMVAVar_EleR9
1305	>	<< " HoE " << fMVAVar_EleHoverE
1306	>	<< " EoP " << fMVAVar_EleEOverP
1307	>	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
1308	>	<< " eleEoPout " << fMVAVar_EleEEleClusterOverPout
1309	>	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
1310	>	<< " PreShowerOverRaw" << fMVAVar_ElePreShowerOverRaw
1311	>	<< " d0 " << fMVAVar_EleD0
1312	>	<< " ip3d " << fMVAVar_EleIP3d
1313	>	<< " eta " << fMVAVar_EleEta
1314	>	<< " pt " << fMVAVar_ElePt
1315	>	<< " === : === "
1316	>	<< mva << " "
1317	>	<< std::endl;
1318	>	std::cout << "Debug Electron MVA-ISO: "
1319	>	<< fMVAVar_ChargedIso_DR0p0To0p1 << " "
1320	>	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1321	>	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1322	>	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
1323	>	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
1324	>	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
1325	>	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
1326	>	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
1327	>	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
1328	>	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
1329	>	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
1330	>	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
1331	>	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
1332	>	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1333	>	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
1334	>	<< std::endl;
1335	>	}
1336	>
1337	>	return mva;
1338	>	}
1339	>
1340	>
1341	>	//--------------------------------------------------------------------------------------------------
1342	>	//MVA Includes Isolation
1343	>	//
1344	>	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
1345	>	const VertexCol *primaryVertices,
1346	>	const PFCandidateCol *PFCands,
1347	>	const PileupEnergyDensityCol *PileupEnergyDensity,
1348	>	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaTarget,
1349	>	Bool_t printDebug) {
1350	>
1351	>	if (!fIsInitialized) {
1352	>	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
1353	>	return -9999;
1354	>	}
1355	>
1356	>	Double_t Rho = 0;
1357	>	switch(fTheRhoType) {
1358	>	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
1359	>	Rho = PileupEnergyDensity->At(0)->Rho();
1360	>	break;
1361	>	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
1362	>	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
1363	>	break;
1364	>	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
1365	>	Rho = PileupEnergyDensity->At(0)->RhoRandom();
1366	>	break;
1367	>	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
1368	>	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
1369	>	break;
1370	>	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
1371	>	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
1372	>	break;
1373	>	default:
1374	>	// use the old default
1375	>	Rho = PileupEnergyDensity->At(0)->Rho();
1376	>	break;
1377	>	}
1378	>
1379	>	//set all input variables
1380	>	fMVAVar_ElePt = ele->Pt();
1381	>	fMVAVar_EleEta = ele->SCluster()->Eta();
1382	>	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
1383	>
1384	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1385	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1386	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1387	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0
1388	>	) {
1389	>	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
1390	>	fMVAVar_EleDPhiIn = TMath::Min(fabs(double(ele->DeltaPhiSuperClusterTrackAtVtx())),0.6);
1391	>	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
1392	>	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
1393	>	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
1394	>	fMVAVar_EleEEleClusterOverPout = TMath::Min(double(ele->EEleClusterOverPout()),20.0);
1395	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->P();
1396	>	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
1397	>	fMVAVar_EledEtaCalo =  TMath::Min(fabs(double(ele->DeltaEtaSeedClusterTrackAtCalo())),0.2);
1398	>	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
1399	>	}
1400	>	else if (fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4) {
1401	>	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
1402	>	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
1403	>	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
1404	>	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
1405	>	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
1406	>	fMVAVar_EleEEleClusterOverPout = TMath::Min(double(ele->EEleClusterOverPout()),20.0);
1407	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->PIn();
1408	>	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
1409	>	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1410	>	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
1411	>	}
1412	>	else {
1413	>	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
1414	>	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
1415	>	fMVAVar_EleFBrem = ele->FBrem();
1416	>	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
1417	>	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
1418	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
1419	>	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
1420	>	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1421	>	fMVAVar_EleR9 = ele->SCluster()->R9();
1422	>	}
1423	>
1424	>	fMVAVar_EleHoverE = ele->HadronicOverEm();
1425	>	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
1426	>	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
1427	>	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
1428	>	else {
1429	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ) {
1430	>	fMVAVar_EleSigmaIPhiIPhi = 0;
1431	>	} else {
1432	>	fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
1433	>	}
1434	>	}
1435	>
1436	>	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
1437	>	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
1438	>	fMVAVar_EleIP3d = ele->Ip3dPV();
1439	>	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
1440	>	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
1441	>	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
1442	>	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
1443	>	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
1444	>	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
1445	>
1446	>	//Additional vars
1447	>	if (ele->TrackerTrk()) {
1448	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1449	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1450	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1451	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ||
1452	>	fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
1453	>	) {
1454	>	fMVAVar_EleKFTrkChiSqr = TMath::Min(double(ele->TrackerTrk()->RChi2()),10.0);
1455	>	} else {
1456	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
1457	>	}
1458	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
1459	>	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
1460	>	} else {
1461	>	fMVAVar_EleKFTrkChiSqr = 0;
1462	>	fMVAVar_EleKFTrkNHits = -1;
1463	>	fMVAVar_EleKFTrkNLayers = -1;
1464	>	}
1465	>
1466	>	if( ele->SCluster()->Seed()->E5x5() > 0.0 ) {
1467	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1468	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1469	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1470	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ||
1471	>	fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
1472	>	) {
1473	>	fMVAVar_EleE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1474	>	fMVAVar_EleOneMinusE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1475	>	} else {
1476	>	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5();
1477	>	}
1478		} else {
1479	<	reader = fTMVAReader[MVABin];
1479	>	fMVAVar_EleE1x5OverE5x5 = -1.0;
1480	>	}
1481	>
1482	>
1483	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1484	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1485	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1486	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
1487	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
1488	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1489	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1490	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1491	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
1492	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
1493	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1494	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1495	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1496	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1497	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1498	>
1499	>	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
1500	>	const PFCandidate *pf = PFCands->At(p);
1501	>
1502	>	//************************************************************
1503	>	// New Isolation Calculations
1504	>	//************************************************************
1505	>	Double_t dr = MathUtils::DeltaR(ele->Mom(), pf->Mom());
1506	>
1507	>	if (dr < 0.5) {
1508	>
1509	>	Bool_t passVeto = kTRUE;
1510	>	//Charged
1511	>	if(pf->BestTrk()) {
1512	>
1513	>	//*************************************************
1514	>	//Use only PFNoPU
1515	>	//*************************************************
1516	>	Bool_t isPFNoPU = kFALSE;
1517	>	if(pf->PFType() == PFCandidate::eHadron) {
1518	>	if(pf->HasTrackerTrk() &&
1519	>	primaryVertices->At(0)->HasTrack(pf->TrackerTrk()) &&
1520	>	primaryVertices->At(0)->TrackWeight(pf->TrackerTrk()) > 0) {
1521	>	isPFNoPU = kTRUE;
1522	>	} else {
1523	>
1524	>	Bool_t vertexFound = kFALSE;
1525	>	const Vertex *closestVtx = 0;
1526	>	Double_t dzmin = 10000;
1527	>
1528	>	// loop over vertices
1529	>	for(UInt_t j = 0; j < primaryVertices->GetEntries(); j++) {
1530	>	const Vertex *vtx = primaryVertices->At(j);
1531	>	assert(vtx);
1532	>
1533	>	if(pf->HasTrackerTrk() &&
1534	>	vtx->HasTrack(pf->TrackerTrk()) &&
1535	>	vtx->TrackWeight(pf->TrackerTrk()) > 0) {
1536	>	vertexFound = kTRUE;
1537	>	closestVtx = vtx;
1538	>	break;
1539	>	}
1540	>	Double_t dz = fabs(pf->SourceVertex().Z() - vtx->Z());
1541	>	if(dz < dzmin) {
1542	>	closestVtx = vtx;
1543	>	dzmin = dz;
1544	>	}
1545	>	}
1546	>
1547	>	Bool_t fCheckClosestZVertex = kTRUE; //we use option 1
1548	>	if(fCheckClosestZVertex) {
1549	>	// Fallback: if track is not associated with any vertex,
1550	>	// associate it with the vertex closest in z
1551	>	if(vertexFound || closestVtx != vertex) {
1552	>	isPFNoPU = kFALSE;
1553	>	} else {
1554	>	isPFNoPU = kTRUE;
1555	>	}
1556	>	} else {
1557	>	if(vertexFound && closestVtx != vertex) {
1558	>	isPFNoPU = kFALSE;
1559	>	} else {
1560	>	isPFNoPU = kTRUE;
1561	>	}
1562	>	}
1563	>	} //hadron & trk stuff
1564	>	} else { // hadron
1565	>	//
1566	>	isPFNoPU = kTRUE;
1567	>	}
1568	>	if (!isPFNoPU) continue;
1569	>
1570	>	//************************************************************
1571	>	// Veto any PFmuon, or PFEle
1572	>	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
1573	>	//************************************************************
1574	>	//************************************************************
1575	>	// Footprint Veto
1576	>	if (fabs(ele->SCluster()->Eta()) >= 1.479 && dr < 0.015) passVeto = kFALSE;
1577	>	//************************************************************
1578	>	if (passVeto) {
1579	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1580	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1581	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1582	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1583	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1584	>	} //pass veto
1585	>
1586	>	}
1587	>	//Gamma
1588	>	else if (pf->PFType() == PFCandidate::eGamma) {
1589	>	//************************************************************
1590	>	// Footprint Veto
1591	>	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1592	>	if (dr < 0.08) passVeto = kFALSE;
1593	>	}
1594	>	//************************************************************
1595	>
1596	>	if (passVeto) {
1597	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1598	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1599	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1600	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1601	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1602	>	}
1603	>	}
1604	>	//NeutralHadron
1605	>	else {
1606	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1607	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1608	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1609	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1610	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1611	>	}
1612	>	} //in 1.0 dr cone
1613	>	} //loop over PF candidates
1614	>
1615	>	fMVAVar_ChargedIso_DR0p0To0p1   = tmpChargedIso_DR0p0To0p1/ele->Pt();
1616	>	fMVAVar_ChargedIso_DR0p1To0p2   = tmpChargedIso_DR0p1To0p2/ele->Pt();
1617	>	fMVAVar_ChargedIso_DR0p2To0p3 = tmpChargedIso_DR0p2To0p3/ele->Pt();
1618	>	fMVAVar_ChargedIso_DR0p3To0p4 = tmpChargedIso_DR0p3To0p4/ele->Pt();
1619	>	fMVAVar_ChargedIso_DR0p4To0p5 = tmpChargedIso_DR0p4To0p5/ele->Pt();
1620	>	fMVAVar_GammaIso_DR0p0To0p1 = tmpGammaIso_DR0p0To0p1/ele->Pt();
1621	>	fMVAVar_GammaIso_DR0p1To0p2 = tmpGammaIso_DR0p1To0p2/ele->Pt();
1622	>	fMVAVar_GammaIso_DR0p2To0p3 = tmpGammaIso_DR0p2To0p3/ele->Pt();
1623	>	fMVAVar_GammaIso_DR0p3To0p4 = tmpGammaIso_DR0p3To0p4/ele->Pt();
1624	>	fMVAVar_GammaIso_DR0p4To0p5 = tmpGammaIso_DR0p4To0p5/ele->Pt();
1625	>	fMVAVar_NeutralHadronIso_DR0p0To0p1 = tmpNeutralHadronIso_DR0p0To0p1/ele->Pt();
1626	>	fMVAVar_NeutralHadronIso_DR0p1To0p2 = tmpNeutralHadronIso_DR0p1To0p2/ele->Pt();
1627	>	fMVAVar_NeutralHadronIso_DR0p2To0p3 = tmpNeutralHadronIso_DR0p2To0p3/ele->Pt();
1628	>	fMVAVar_NeutralHadronIso_DR0p3To0p4 = tmpNeutralHadronIso_DR0p3To0p4/ele->Pt();
1629	>	fMVAVar_NeutralHadronIso_DR0p4To0p5 = tmpNeutralHadronIso_DR0p4To0p5/ele->Pt();
1630	>	fMVAVar_Rho = Rho;
1631	>
1632	>	//Do Binding of MVA input variables
1633	>	if (   fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1634	>	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
1635	>	|| fMVAType == ElectronIDMVA::kIsoRingsV0
1636	>	|| fMVAType == ElectronIDMVA::kIDHWW2012TrigV0
1637	>	) {
1638	>	bindVariables();
1639		}
1640
1641	<
1641	>	Double_t mva = -9999;
1642	>	TMVA::Reader *reader = 0;
1643	>
1644	>	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
1645		mva = reader->EvaluateMVA( fMethodname );
1646
1647		if (printDebug == kTRUE) {
1648
1649	<	std::cout << "Debug Electron MVA: \n";
1650	<	std::cout << " fbrem " <<  fMVAVar_EleFBrem
1649	>	std::cout << "Debug Electron MVA-ID: "
1650	>	<< fMVAVar_ElePt<< " " << fMVAVar_EleEta << " "
1651	>	<< " --> MVABin " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << " : "
1652	>	<< " fbrem " <<  fMVAVar_EleFBrem
1653		<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
1654	<	<< " kfhits " << fMVAVar_EleKFTrkNHits
1655	<	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1654	>	<< " kfhits " << fMVAVar_EleKFTrkNLayers
1655	>	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1656		<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
1657		<< " deta " <<  fMVAVar_EleDEtaIn
1658		<< " dphi " << fMVAVar_EleDPhiIn
#	Line 1032 | Line 1661 | Double_t ElectronIDMVA::MVAValue(const E
1661		<< " spp " << fMVAVar_EleSigmaIPhiIPhi
1662		<< " etawidth " << fMVAVar_EleSCEtaWidth
1663		<< " phiwidth " << fMVAVar_EleSCPhiWidth
1664	<	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
1664	>	<< " e1x5e5x5 " << fMVAVar_EleOneMinusE1x5OverE5x5
1665		<< " R9 " << fMVAVar_EleR9
1666		<< " HoE " << fMVAVar_EleHoverE
1667		<< " EoP " << fMVAVar_EleEOverP
1668		<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
1669	<	<< " eleEoPout " << fMVAVar_EleESeedClusterOverPout
1669	>	<< " eleEoPout " << fMVAVar_EleEEleClusterOverPout
1670		<< " EoPout " << fMVAVar_EleESeedClusterOverPout
1671	+	<< " PreShowerOverRaw" << fMVAVar_ElePreShowerOverRaw
1672		<< " d0 " << fMVAVar_EleD0
1673		<< " ip3d " << fMVAVar_EleIP3d
1674		<< " eta " << fMVAVar_EleEta
1675	<	<< " pt " << fMVAVar_ElePt << std::endl;
1676	<
1677	<	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
1675	>	<< " pt " << fMVAVar_ElePt
1676	>	<< " === : === "
1677	>	<< mva << " "
1678	>	<< std::endl;
1679	>	std::cout << "Debug Electron MVA-ISO: "
1680	>	<< fMVAVar_ChargedIso_DR0p0To0p1 << " "
1681		<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1682		<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1683		<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
#	Line 1059 | Line 1692 | Double_t ElectronIDMVA::MVAValue(const E
1692		<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
1693		<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1694		<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
1695	+	<< fMVAVar_Rho << " "
1696		<< std::endl;
1063	–	std::cout << "MVA: " << mva << " "
1064	–	<< std::endl;
1697		}
1698
1699		return mva;

Diff Legend

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