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.23 by ceballos, Sat May 12 07:03:53 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 == kIDHWW2012TrigV0) {
105		ExpectedNBins = 6;
106		} else if (type == kIsoRingsV0) {
107		ExpectedNBins = 4;
#	Line 183 | Line 189 | void ElectronIDMVA::Initialize(  std::st
189
190		}
191
192	<	if (type == kIDEGamma2012TrigV0 || type == kIDEGamma2012NonTrigV0 ) {
192	>	if (type == kIDEGamma2012TrigV0 || type == kIDHWW2012TrigV0) {
193		// Pure tracking variables
194		tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
195		tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
196	<	tmpTMVAReader->AddVariable("kfhits",          &fMVAVar_EleKFTrkNHits);  //Don't have this in BAMBU
197	<	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
196	>	tmpTMVAReader->AddVariable("kfhits",          &fMVAVar_EleKFTrkNLayers);  //Don't have this in (BAMBU <= 025)
197	>	if(type == kIDEGamma2012TrigV0)
198	>	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
199		tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
200		tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
201		tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
#	Line 202 | Line 209 | void ElectronIDMVA::Initialize(  std::st
209		tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
210		tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
211		tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
212	<	tmpTMVAReader->AddVariable("eleEoPout",       &fMVAVar_EleEEleClusterOverPout);
213	<	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout); //we have this only in BAMBU
214	<	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
212	>	tmpTMVAReader->AddVariable("eleEoPout",       &fMVAVar_EleEEleClusterOverPout); //Don't have this in (BAMBU <= 025)
213	>	if(type == kIDEGamma2012TrigV0)
214	>	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout);
215	>	if (i == 2 || i == 5) {
216	>	tmpTMVAReader->AddVariable( "PreShowerOverRaw",      &fMVAVar_ElePreShowerOverRaw       );
217	>	}
218	>	tmpTMVAReader->AddVariable( "d0",             &fMVAVar_EleD0);
219	>	tmpTMVAReader->AddVariable( "ip3d",           &fMVAVar_EleIP3d);
220
221		tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
222		tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
223		}
224	<
224	>
225	>	if (type == kIDEGamma2012NonTrigV0 ) {
226	>	// Pure tracking variables
227	>	tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
228	>	tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
229	>	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
230	>	tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
231	>	tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
232	>	tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
233	>	tmpTMVAReader->AddVariable("detacalo",        &fMVAVar_EledEtaCalo);
234	>	tmpTMVAReader->AddVariable("see",             &fMVAVar_EleSigmaIEtaIEta);
235	>	tmpTMVAReader->AddVariable("spp",             &fMVAVar_EleSigmaIPhiIPhi);
236	>	tmpTMVAReader->AddVariable("etawidth",        &fMVAVar_EleSCEtaWidth);
237	>	tmpTMVAReader->AddVariable("phiwidth",        &fMVAVar_EleSCPhiWidth);
238	>	tmpTMVAReader->AddVariable("e1x5e5x5",        &fMVAVar_EleE1x5OverE5x5);
239	>	tmpTMVAReader->AddVariable("R9",              &fMVAVar_EleR9);
240	>	tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
241	>	tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
242	>	tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
243	>	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout);
244	>	if (i==2 || i==5) {
245	>	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
246	>	}
247	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
248	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
249	>	}
250	>
251		if (type == kIsoRingsV0) {
252		tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1",         &fMVAVar_ChargedIso_DR0p0To0p1        );
253		tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2",         &fMVAVar_ChargedIso_DR0p1To0p2        );
#	Line 248 | Line 286 | UInt_t ElectronIDMVA::GetMVABin( double
286		//Default is to return the first bin
287		uint bin = 0;
288
289	+	//return the first bin if not using binned version
290	+	if (!fUseBinnedVersion) return 0;
291	+
292		if (fMVAType == ElectronIDMVA::kBaseline
293		||fMVAType == ElectronIDMVA::kNoIPInfo
294		||fMVAType == ElectronIDMVA::kWithIPInfo
#	Line 267 | Line 308 | UInt_t ElectronIDMVA::GetMVABin( double
308		if (pt >= 10 && fabs(eta) >= 1.479) bin = 3;
309		}
310
311	<	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
271	<	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ) {
311	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0) {
312		bin = 0;
313		if (pt < 10 && fabs(eta) < 0.8) bin = 0;
314		if (pt < 10 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 1;
#	Line 278 | Line 318 | UInt_t ElectronIDMVA::GetMVABin( double
318		if (pt >= 10 && fabs(eta) >= 1.479) bin = 5;
319		}
320
321	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
322	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
323	+	bin = 0;
324	+	if (pt < 20 && fabs(eta) < 0.8) bin = 0;
325	+	if (pt < 20 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 1;
326	+	if (pt < 20 && fabs(eta) >= 1.479) bin = 2;
327	+	if (pt >= 20 && fabs(eta) < 0.8) bin = 3;
328	+	if (pt >= 20 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 4;
329	+	if (pt >= 20 && fabs(eta) >= 1.479) bin = 5;
330	+	}
331	+
332		return bin;
333		}
334
#	Line 307 | Line 358 | Double_t ElectronIDMVA::MVAValue(Double_
358		return -9999;
359		}
360
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	–
361		//set all input variables
362		fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
363		fMVAVar_EleDEtaIn = EleDEtaIn;
#	Line 333 | Line 377 | Double_t ElectronIDMVA::MVAValue(Double_
377
378		Double_t mva = -9999;
379		TMVA::Reader *reader = 0;
380	<	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];
380	>	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
381
382		mva = reader->EvaluateMVA( fMethodname );
383
#	Line 390 | Line 426 | Double_t ElectronIDMVA::MVAValue(Double_
426		Double_t Rho = 0;
427		if (!(TMath::IsNaN(PileupEnergyDensity) || isinf(PileupEnergyDensity))) Rho = PileupEnergyDensity;
428
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	–
429		//set all input variables
430		fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
431		fMVAVar_EleDEtaIn = EleDEtaIn;
#	Line 449 | Line 478 | Double_t ElectronIDMVA::MVAValue(Double_
478
479		Double_t mva = -9999;
480		TMVA::Reader *reader = 0;
481	<	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	<
481	>	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
482		mva = reader->EvaluateMVA( fMethodname );
483
484		if (printDebug == kTRUE) {
485		std::cout << "Debug Electron MVA: "
486	<	<< ElePt << " " << EleEta << " " << " --> MVABin " << MVABin << " : "
486	>	<< ElePt << " " << EleEta << " " << " --> MVABin " << GetMVABin( EleEta, ElePt) << " : "
487		<< fMVAVar_EleSigmaIEtaIEta << " "
488		<< fMVAVar_EleDEtaIn << " "
489		<< fMVAVar_EleDPhiIn << " "
#	Line 501 | Line 521 | Double_t ElectronIDMVA::MVAValue(Double_
521		return mva;
522		}
523
524	+	Double_t ElectronIDMVA::MVAValue_IsoRings( Double_t ElePt,
525	+	Double_t EleSCEta,
526	+	Double_t ChargedIso_DR0p0To0p1,
527	+	Double_t ChargedIso_DR0p1To0p2,
528	+	Double_t ChargedIso_DR0p2To0p3,
529	+	Double_t ChargedIso_DR0p3To0p4,
530	+	Double_t ChargedIso_DR0p4To0p5,
531	+	Double_t GammaIso_DR0p0To0p1,
532	+	Double_t GammaIso_DR0p1To0p2,
533	+	Double_t GammaIso_DR0p2To0p3,
534	+	Double_t GammaIso_DR0p3To0p4,
535	+	Double_t GammaIso_DR0p4To0p5,
536	+	Double_t NeutralHadronIso_DR0p0To0p1,
537	+	Double_t NeutralHadronIso_DR0p1To0p2,
538	+	Double_t NeutralHadronIso_DR0p2To0p3,
539	+	Double_t NeutralHadronIso_DR0p3To0p4,
540	+	Double_t NeutralHadronIso_DR0p4To0p5,
541	+	Bool_t printDebug) {
542	+
543	+	if (fMVAType != ElectronIDMVA::kIsoRingsV0) {
544	+	std::cout << "Error: This function is only supported for MVAType == kIsoRingsV0.\n" << std::endl;
545	+	assert(kFALSE);
546	+	}
547	+
548	+	fMVAVar_ElePt = ElePt;
549	+	fMVAVar_EleEta = EleSCEta;
550	+	fMVAVar_ChargedIso_DR0p0To0p1 = ChargedIso_DR0p0To0p1;
551	+	fMVAVar_ChargedIso_DR0p1To0p2 = ChargedIso_DR0p1To0p2;
552	+	fMVAVar_ChargedIso_DR0p2To0p3 = ChargedIso_DR0p2To0p3;
553	+	fMVAVar_ChargedIso_DR0p3To0p4 = ChargedIso_DR0p3To0p4;
554	+	fMVAVar_ChargedIso_DR0p4To0p5 = ChargedIso_DR0p4To0p5;
555	+	fMVAVar_GammaIso_DR0p0To0p1 = GammaIso_DR0p0To0p1;
556	+	fMVAVar_GammaIso_DR0p1To0p2 = GammaIso_DR0p1To0p2;
557	+	fMVAVar_GammaIso_DR0p2To0p3 = GammaIso_DR0p2To0p3;
558	+	fMVAVar_GammaIso_DR0p3To0p4 = GammaIso_DR0p3To0p4;
559	+	fMVAVar_GammaIso_DR0p4To0p5 = GammaIso_DR0p4To0p5;
560	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = NeutralHadronIso_DR0p0To0p1;
561	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = NeutralHadronIso_DR0p1To0p2;
562	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = NeutralHadronIso_DR0p2To0p3;
563	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = NeutralHadronIso_DR0p3To0p4;
564	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = NeutralHadronIso_DR0p4To0p5;
565	+
566	+	Double_t mva = -9999;
567	+	TMVA::Reader *reader = 0;
568	+
569	+	if (printDebug == kTRUE) {
570	+	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << std::endl;
571	+	}
572	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
573	+	mva = reader->EvaluateMVA( fMethodname );
574	+
575	+	if (printDebug == kTRUE) {
576	+
577	+	std::cout << "Debug Electron MVA-ISO: ";
578	+	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
579	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
580	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
581	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
582	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
583	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
584	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
585	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
586	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
587	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
588	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
589	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
590	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
591	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
592	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
593	+	<< std::endl;
594	+	std::cout << "MVA: " << mva << " "
595	+	<< std::endl;
596	+	}
597	+	return mva;
598	+	}
599	+
600	+	Double_t ElectronIDMVA::MVAValue_IDNonTrig( Double_t ElePt,
601	+	Double_t EleSCEta,
602	+	Double_t EleFBrem,
603	+	Double_t EleKFTrkChiSqr,
604	+	Double_t EleKFTrkNHits,
605	+	Double_t EleGsfTrackChi2OverNdof,
606	+	Double_t EleDEtaIn,
607	+	Double_t EleDPhiIn,
608	+	Double_t EledEtaCalo,
609	+	Double_t EleSigmaIEtaIEta,
610	+	Double_t EleSigmaIPhiIPhi,
611	+	Double_t EleSCEtaWidth,
612	+	Double_t EleSCPhiWidth,
613	+	Double_t EleE1x5OverE5x5,
614	+	Double_t EleR9,
615	+	Double_t EleHoverE,
616	+	Double_t EleEOverP,
617	+	Double_t EleOneOverEMinusOneOverP,
618	+	Double_t EleESeedClusterOverPout,
619	+	Double_t ElePreShowerOverRaw,
620	+	Bool_t printDebug) {
621	+
622	+	if (fMVAType != ElectronIDMVA::kIDEGamma2012NonTrigV0) {
623	+	std::cout << "Error: This function is only supported for MVAType == kIDEGamma2012NonTrigV0.\n" << std::endl;
624	+	assert(kFALSE);
625	+	}
626	+
627	+	fMVAVar_ElePt = ElePt;
628	+	fMVAVar_EleEta = EleSCEta;
629	+	fMVAVar_EleFBrem = EleFBrem;
630	+	fMVAVar_EleKFTrkChiSqr = EleKFTrkChiSqr;
631	+	fMVAVar_EleKFTrkNHits = EleKFTrkNHits;
632	+	fMVAVar_EleGsfTrackChi2OverNdof = EleGsfTrackChi2OverNdof;
633	+	fMVAVar_EleDEtaIn = EleDEtaIn;
634	+	fMVAVar_EleDPhiIn = EleDPhiIn;
635	+	fMVAVar_EledEtaCalo = EledEtaCalo;
636	+	fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
637	+	fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
638	+	fMVAVar_EleSCEtaWidth = EleSCEtaWidth;
639	+	fMVAVar_EleSCPhiWidth = EleSCPhiWidth;
640	+	fMVAVar_EleE1x5OverE5x5 = EleE1x5OverE5x5;
641	+	fMVAVar_EleR9 = EleR9;
642	+	fMVAVar_EleHoverE = EleHoverE;
643	+	fMVAVar_EleEOverP = EleEOverP;
644	+	fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
645	+	fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
646	+	fMVAVar_ElePreShowerOverRaw = ElePreShowerOverRaw;
647	+
648	+	Double_t mva = -9999;
649	+	TMVA::Reader *reader = 0;
650	+
651	+	if (printDebug == kTRUE) {
652	+	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << std::endl;
653	+	}
654	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
655	+	mva = reader->EvaluateMVA( fMethodname );
656	+
657	+	if (printDebug == kTRUE) {
658	+	std::cout << "Debug Electron MVA: ";
659	+	std::cout << " fbrem " <<  fMVAVar_EleFBrem
660	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
661	+	<< " kfhits " << fMVAVar_EleKFTrkNLayers
662	+	<< " kfhitsall " <<  fMVAVar_EleKFTrkNHits
663	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
664	+	<< " deta " <<  fMVAVar_EleDEtaIn
665	+	<< " dphi " << fMVAVar_EleDPhiIn
666	+	<< " detacalo " << fMVAVar_EledEtaCalo
667	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
668	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
669	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
670	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
671	+	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
672	+	<< " R9 " << fMVAVar_EleR9
673	+	<< " HoE " << fMVAVar_EleHoverE
674	+	<< " EoP " << fMVAVar_EleEOverP
675	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
676	+	<< " eleEoPout " << fMVAVar_EleESeedClusterOverPout
677	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
678	+	<< " d0 " << fMVAVar_EleD0
679	+	<< " ip3d " << fMVAVar_EleIP3d
680	+	<< " eta " << fMVAVar_EleEta
681	+	<< " pt " << fMVAVar_ElePt << std::endl;
682	+	std::cout << "MVA: " << mva << " "
683	+	<< std::endl;
684	+	}
685	+	return mva;
686	+	}
687
688		//--------------------------------------------------------------------------------------------------
689		Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
#	Line 514 | Line 697 | Double_t ElectronIDMVA::MVAValue(const E
697		return -9999;
698		}
699
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	–
700		Double_t Rho = 0;
701	<	if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
701	>	switch(fTheRhoType) {
702	>	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
703	>	Rho = PileupEnergyDensity->At(0)->Rho();
704	>	break;
705	>	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
706	>	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
707	>	break;
708	>	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
709	>	Rho = PileupEnergyDensity->At(0)->RhoRandom();
710	>	break;
711	>	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
712	>	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
713	>	break;
714	>	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
715	>	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
716	>	break;
717	>	default:
718	>	// use the old default
719	>	Rho = PileupEnergyDensity->At(0)->Rho();
720	>	break;
721	>	}
722
723		//set all input variables
724		fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
#	Line 537 | Line 733 | Double_t ElectronIDMVA::MVAValue(const E
733		if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
734		else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
735		fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
736	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
736	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->CorrectedEcalEnergy())) - 1.0 / ele->BestTrk()->P();
737		fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
738		fMVAVar_EleIP3d = ele->Ip3dPV();
739		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
#	Line 573 | Line 769 | Double_t ElectronIDMVA::MVAValue(const E
769		+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,ele->SCluster()->Eta())) / ele->Pt();
770
771		//Additional vars
772	<	fMVAVar_EleEEleClusterOverPout = 0;
773	<	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
774	<	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
772	>	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
773	>	if (ele->TrackerTrk()) {
774	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
775	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
776	>	} else {
777	>	fMVAVar_EleKFTrkChiSqr = -1;
778	>	fMVAVar_EleKFTrkNHits = 0;
779	>	}
780		fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
781
782
582	–
583	–
783		Double_t mva = -9999;
784		TMVA::Reader *reader = 0;
785	<	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	<
785	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
786		mva = reader->EvaluateMVA( fMethodname );
787
788		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;
789		std::cout << "Debug Electron MVA: "
790		<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
791	<	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << MVABin << " : "
791	>	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
792		<< fMVAVar_EleSigmaIEtaIEta << " "
793		<< fMVAVar_EleDEtaIn << " "
794		<< fMVAVar_EleDPhiIn << " "
#	Line 680 | Line 835 | Double_t ElectronIDMVA::MVAValue(const E
835		return -9999;
836		}
837
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	–
838		fMVAVar_ElePt = ele->Pt();
839		fMVAVar_EleEta = ele->Eta();
840
#	Line 703 | Line 851 | Double_t ElectronIDMVA::MVAValue(const E
851		if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
852		else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
853		fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
854	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
854	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->CorrectedEcalEnergy())) - 1.0 / ele->BestTrk()->P();
855		fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
856		fMVAVar_EleIP3d = ele->Ip3dPV();
857		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
858
859
860	<	fMVAVar_EleEEleClusterOverPout = 0;
861	<	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
862	<	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
860	>	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
861	>	if (ele->TrackerTrk()) {
862	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
863	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
864	>	} else {
865	>	fMVAVar_EleKFTrkChiSqr = -1;
866	>	fMVAVar_EleKFTrkNHits = 0;
867	>	}
868		fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
869		fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
870		fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
#	Line 720 | Line 873 | Double_t ElectronIDMVA::MVAValue(const E
873		fMVAVar_EleR9 = ele->SCluster()->R9();
874		fMVAVar_EleHoverE = ele->HadronicOverEm();
875		fMVAVar_EleEOverP = ele->ESuperClusterOverP();
876	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
876	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->CorrectedEcalEnergy())) - 1.0 / ele->BestTrk()->P();
877		fMVAVar_EleR9 = ele->SCluster()->R9();
878		fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
879
880
881		Double_t mva = -9999;
882		TMVA::Reader *reader = 0;
883	<	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	<
883	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
884		mva = reader->EvaluateMVA( fMethodname );
885
886		if (printDebug == kTRUE) {
887		std::cout << "Debug Electron MVA: "
888		<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
889	<	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << MVABin << " : "
889	>	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
890		<< fMVAVar_EleSigmaIEtaIEta << " "
891		<< fMVAVar_EleDEtaIn << " "
892		<< fMVAVar_EleDPhiIn << " "
#	Line 800 | Line 944 | Double_t ElectronIDMVA::MVAValue(const E
944		}
945
946		Double_t Rho = 0;
947	<	if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
947	>	switch(fTheRhoType) {
948	>	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
949	>	Rho = PileupEnergyDensity->At(0)->Rho();
950	>	break;
951	>	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
952	>	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
953	>	break;
954	>	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
955	>	Rho = PileupEnergyDensity->At(0)->RhoRandom();
956	>	break;
957	>	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
958	>	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
959	>	break;
960	>	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
961	>	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
962	>	break;
963	>	default:
964	>	// use the old default
965	>	Rho = PileupEnergyDensity->At(0)->Rho();
966	>	break;
967	>	}
968
969		//set all input variables
970		fMVAVar_ElePt = ele->Pt();
971		fMVAVar_EleEta = ele->SCluster()->Eta();
972	<	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
973	<	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
974	<	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
972	>	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
973	>
974	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
975	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
976	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
977	>	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
978	>	fMVAVar_EleDPhiIn = TMath::Min(fabs(double(ele->DeltaPhiSuperClusterTrackAtVtx())),0.6);
979	>	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
980	>	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
981	>	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
982	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->CorrectedEcalEnergy())) - 1.0 / ele->P();
983	>	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
984	>	fMVAVar_EledEtaCalo =  TMath::Min(fabs(double(ele->DeltaEtaSeedClusterTrackAtCalo())),0.2);
985	>	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
986	>	} else {
987	>	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
988	>	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
989	>	fMVAVar_EleFBrem = ele->FBrem();
990	>	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
991	>	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
992	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->CorrectedEcalEnergy())) - 1.0 / ele->BestTrk()->P();
993	>	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
994	>	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
995	>	fMVAVar_EleR9 = ele->SCluster()->R9();
996	>	}
997	>
998		fMVAVar_EleHoverE = ele->HadronicOverEm();
999		fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
1000		fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
814	–	fMVAVar_EleFBrem = ele->FBrem();
815	–	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
816	–	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
1001		if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
1002		else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
1003		fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
820	–
821	–	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
822	–	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
823	–	|| 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();
827	–	}
828	–
1004		fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
1005		fMVAVar_EleIP3d = ele->Ip3dPV();
1006		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
832	–	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
833	–	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1007		fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
835	–	fMVAVar_EleR9 = ele->SCluster()->R9();
1008		fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
1009		fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
1010		fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
1011		fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
1012
1013		//Additional vars
1014	<	fMVAVar_EleEEleClusterOverPout = 0;
1014	>	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
1015		if (ele->TrackerTrk()) {
1016	<	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
1016	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1017	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1018	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
1019	>	fMVAVar_EleKFTrkChiSqr = TMath::Min(double(ele->TrackerTrk()->RChi2()),10.0);
1020	>	} else {
1021	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
1022	>	}
1023		fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
1024	+	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
1025		} else {
1026		fMVAVar_EleKFTrkChiSqr = 0;
1027		fMVAVar_EleKFTrkNHits = -1;
1028	+	fMVAVar_EleKFTrkNLayers = -1;
1029		}
1030
1031	<	fMVAVar_EleE1x5OverE5x5 = (ele->SCluster()->Seed()->E5x5() > 0.0) ? 1.0-ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5() : -1. ;
1031	>	if( ele->SCluster()->Seed()->E5x5() > 0.0 ) {
1032	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1033	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1034	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
1035	>	fMVAVar_EleE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1036	>	} else {
1037	>	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5();
1038	>	}
1039	>	} else {
1040	>	fMVAVar_EleE1x5OverE5x5 = -1.0;
1041	>	}
1042	>
1043
1044		Double_t tmpChargedIso_DR0p0To0p1  = 0;
1045		Double_t tmpChargedIso_DR0p1To0p2  = 0;
#	Line 885 | Line 1076 | Double_t ElectronIDMVA::MVAValue(const E
1076		//************************************************************
1077		// Lepton Footprint Removal
1078		//************************************************************
1079	<	for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) {
1080	<	//if pf candidate matches an electron passing ID cuts, then veto it
1081	<	if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() &&
1082	<	pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE;
1083	<	if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() &&
1084	<	pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1085	<	//if pf candidate lies in veto regions of electron passing ID cuts, then veto it
1086	<	if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479
1087	<	&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE;
1088	<	if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 &&
1089	<	MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE;
1079	>	if(goodElectrons) {
1080	>	for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) {
1081	>	//if pf candidate matches an electron passing ID cuts, then veto it
1082	>	if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() &&
1083	>	pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE;
1084	>	if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() &&
1085	>	pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1086	>	//if pf candidate lies in veto regions of electron passing ID cuts, then veto it
1087	>	if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479
1088	>	&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE;
1089	>	if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 &&
1090	>	MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE;
1091	>	}
1092		}
1093	<	for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) {
1094	<	//if pf candidate matches an muon passing ID cuts, then veto it
1095	<	if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() &&
1096	<	pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1097	<	//if pf candidate lies in veto regions of muon passing ID cuts, then veto it
1098	<	if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE;
1093	>	if(goodMuons) {
1094	>	for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) {
1095	>	//if pf candidate matches an muon passing ID cuts, then veto it
1096	>	if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() &&
1097	>	pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1098	>	//if pf candidate lies in veto regions of muon passing ID cuts, then veto it
1099	>	if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE;
1100	>	}
1101		}
1102
1103		if (!IsLeptonFootprint) {
#	Line 956 | Line 1151 | Double_t ElectronIDMVA::MVAValue(const E
1151		} //in 1.0 dr cone
1152		} //loop over PF candidates
1153
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	–
1154		fMVAVar_ChargedIso_DR0p0To0p1   = TMath::Min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1155		fMVAVar_ChargedIso_DR0p1To0p2   = TMath::Min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1156		fMVAVar_ChargedIso_DR0p2To0p3 = TMath::Min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
#	Line 986 | Line 1165 | Double_t ElectronIDMVA::MVAValue(const E
1165		fMVAVar_NeutralHadronIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1166		fMVAVar_NeutralHadronIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1167		fMVAVar_NeutralHadronIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1168	<	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;
1168	>	fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1169
1170		//Do Binding of MVA input variables
1171	<	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1171	>	if (   fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1172		|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
1173	<	|| fMVAType == ElectronIDMVA::kIsoRingsV0) {
1173	>	|| fMVAType == ElectronIDMVA::kIsoRingsV0
1174	>	|| fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
1175		bindVariables();
1176		}
1177
1178		Double_t mva = -9999;
1179		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;
1180
1181	<	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << MVABin << std::endl;
1010	<
1011	<	if (!fUseBinnedVersion) {
1012	<	reader = fTMVAReader[0];
1013	<	} else {
1014	<	reader = fTMVAReader[MVABin];
1015	<	}
1016	<
1017	<
1181	>	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
1182		mva = reader->EvaluateMVA( fMethodname );
1183
1184		if (printDebug == kTRUE) {
1185
1186	<	std::cout << "Debug Electron MVA: \n";
1187	<	std::cout << " fbrem " <<  fMVAVar_EleFBrem
1186	>	std::cout << "Debug Electron MVA-ID: "
1187	>	<< fMVAVar_ElePt<< " " << fMVAVar_EleEta << " "
1188	>	<< " --> MVABin " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << " : "
1189	>	<< " fbrem " <<  fMVAVar_EleFBrem
1190		<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
1191	<	<< " kfhits " << fMVAVar_EleKFTrkNHits
1192	<	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1191	>	<< " kfhits " << fMVAVar_EleKFTrkNLayers
1192	>	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1193		<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
1194		<< " deta " <<  fMVAVar_EleDEtaIn
1195		<< " dphi " << fMVAVar_EleDPhiIn
#	Line 1037 | Line 1203 | Double_t ElectronIDMVA::MVAValue(const E
1203		<< " HoE " << fMVAVar_EleHoverE
1204		<< " EoP " << fMVAVar_EleEOverP
1205		<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
1206	<	<< " eleEoPout " << fMVAVar_EleESeedClusterOverPout
1206	>	<< " eleEoPout " << fMVAVar_EleEEleClusterOverPout
1207		<< " EoPout " << fMVAVar_EleESeedClusterOverPout
1208	+	<< " PreShowerOverRaw" << fMVAVar_ElePreShowerOverRaw
1209		<< " d0 " << fMVAVar_EleD0
1210		<< " ip3d " << fMVAVar_EleIP3d
1211		<< " eta " << fMVAVar_EleEta
1212	<	<< " pt " << fMVAVar_ElePt << std::endl;
1213	<
1214	<	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
1212	>	<< " pt " << fMVAVar_ElePt
1213	>	<< " === : === "
1214	>	<< mva << " "
1215	>	<< std::endl;
1216	>	std::cout << "Debug Electron MVA-ISO: "
1217	>	<< fMVAVar_ChargedIso_DR0p0To0p1 << " "
1218		<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1219		<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1220		<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
#	Line 1060 | Line 1230 | Double_t ElectronIDMVA::MVAValue(const E
1230		<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1231		<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
1232		<< std::endl;
1063	–	std::cout << "MVA: " << mva << " "
1064	–	<< std::endl;
1233		}
1234
1235		return mva;

Diff Legend

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