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.20 by ceballos, Tue May 1 14:10:51 2012 UTC

#	Line 95 | Line 95 | void ElectronIDMVA::Initialize(  std::st
95		||type == kIDIsoCombined) {
96		ExpectedNBins = 6;
97		} else if (type == kIDEGamma2012TrigV0 ||
98	<	type == kIDEGamma2012NonTrigV0) {
98	>	type == kIDEGamma2012NonTrigV0 ||
99	>	type == kIDHWW2012TrigV0) {
100		ExpectedNBins = 6;
101		} else if (type == kIsoRingsV0) {
102		ExpectedNBins = 4;
#	Line 183 | Line 184 | void ElectronIDMVA::Initialize(  std::st
184
185		}
186
187	<	if (type == kIDEGamma2012TrigV0 || type == kIDEGamma2012NonTrigV0 ) {
187	>	if (type == kIDEGamma2012TrigV0 || type == kIDHWW2012TrigV0) {
188		// Pure tracking variables
189		tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
190		tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
191	<	tmpTMVAReader->AddVariable("kfhits",          &fMVAVar_EleKFTrkNHits);  //Don't have this in BAMBU
192	<	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
191	>	tmpTMVAReader->AddVariable("kfhits",          &fMVAVar_EleKFTrkNLayers);  //Don't have this in (BAMBU <= 025)
192	>	if(type == kIDEGamma2012TrigV0)
193	>	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
194		tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
195		tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
196		tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
#	Line 202 | Line 204 | void ElectronIDMVA::Initialize(  std::st
204		tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
205		tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
206		tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
207	<	tmpTMVAReader->AddVariable("eleEoPout",       &fMVAVar_EleEEleClusterOverPout);
208	<	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout); //we have this only in BAMBU
209	<	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
207	>	tmpTMVAReader->AddVariable("eleEoPout",       &fMVAVar_EleEEleClusterOverPout); //Don't have this in (BAMBU <= 025)
208	>	if(type == kIDEGamma2012TrigV0)
209	>	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout);
210	>	if (i == 2 || i == 5) {
211	>	tmpTMVAReader->AddVariable( "PreShowerOverRaw",      &fMVAVar_ElePreShowerOverRaw       );
212	>	}
213	>	tmpTMVAReader->AddVariable( "d0",             &fMVAVar_EleD0);
214	>	tmpTMVAReader->AddVariable( "ip3d",           &fMVAVar_EleIP3d);
215
216		tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
217		tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
218		}
219	<
219	>
220	>	if (type == kIDEGamma2012NonTrigV0 ) {
221	>	// Pure tracking variables
222	>	tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
223	>	tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
224	>	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
225	>	tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
226	>	tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
227	>	tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
228	>	tmpTMVAReader->AddVariable("detacalo",        &fMVAVar_EledEtaCalo);
229	>	tmpTMVAReader->AddVariable("see",             &fMVAVar_EleSigmaIEtaIEta);
230	>	tmpTMVAReader->AddVariable("spp",             &fMVAVar_EleSigmaIPhiIPhi);
231	>	tmpTMVAReader->AddVariable("etawidth",        &fMVAVar_EleSCEtaWidth);
232	>	tmpTMVAReader->AddVariable("phiwidth",        &fMVAVar_EleSCPhiWidth);
233	>	tmpTMVAReader->AddVariable("e1x5e5x5",        &fMVAVar_EleE1x5OverE5x5);
234	>	tmpTMVAReader->AddVariable("R9",              &fMVAVar_EleR9);
235	>	tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
236	>	tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
237	>	tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
238	>	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout);
239	>	if (i==2 || i==5) {
240	>	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
241	>	}
242	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
243	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
244	>	}
245	>
246		if (type == kIsoRingsV0) {
247		tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1",         &fMVAVar_ChargedIso_DR0p0To0p1        );
248		tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2",         &fMVAVar_ChargedIso_DR0p1To0p2        );
#	Line 248 | Line 281 | UInt_t ElectronIDMVA::GetMVABin( double
281		//Default is to return the first bin
282		uint bin = 0;
283
284	+	//return the first bin if not using binned version
285	+	if (!fUseBinnedVersion) return 0;
286	+
287		if (fMVAType == ElectronIDMVA::kBaseline
288		||fMVAType == ElectronIDMVA::kNoIPInfo
289		||fMVAType == ElectronIDMVA::kWithIPInfo
#	Line 267 | Line 303 | UInt_t ElectronIDMVA::GetMVABin( double
303		if (pt >= 10 && fabs(eta) >= 1.479) bin = 3;
304		}
305
306	<	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
271	<	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ) {
306	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0) {
307		bin = 0;
308		if (pt < 10 && fabs(eta) < 0.8) bin = 0;
309		if (pt < 10 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 1;
#	Line 278 | Line 313 | UInt_t ElectronIDMVA::GetMVABin( double
313		if (pt >= 10 && fabs(eta) >= 1.479) bin = 5;
314		}
315
316	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
317	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
318	+	bin = 0;
319	+	if (pt < 20 && fabs(eta) < 0.8) bin = 0;
320	+	if (pt < 20 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 1;
321	+	if (pt < 20 && fabs(eta) >= 1.479) bin = 2;
322	+	if (pt >= 20 && fabs(eta) < 0.8) bin = 3;
323	+	if (pt >= 20 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 4;
324	+	if (pt >= 20 && fabs(eta) >= 1.479) bin = 5;
325	+	}
326	+
327		return bin;
328		}
329
#	Line 307 | Line 353 | Double_t ElectronIDMVA::MVAValue(Double_
353		return -9999;
354		}
355
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	–
356		//set all input variables
357		fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
358		fMVAVar_EleDEtaIn = EleDEtaIn;
#	Line 333 | Line 372 | Double_t ElectronIDMVA::MVAValue(Double_
372
373		Double_t mva = -9999;
374		TMVA::Reader *reader = 0;
375	<	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];
375	>	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
376
377		mva = reader->EvaluateMVA( fMethodname );
378
#	Line 390 | Line 421 | Double_t ElectronIDMVA::MVAValue(Double_
421		Double_t Rho = 0;
422		if (!(TMath::IsNaN(PileupEnergyDensity) || isinf(PileupEnergyDensity))) Rho = PileupEnergyDensity;
423
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	–
424		//set all input variables
425		fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
426		fMVAVar_EleDEtaIn = EleDEtaIn;
#	Line 449 | Line 473 | Double_t ElectronIDMVA::MVAValue(Double_
473
474		Double_t mva = -9999;
475		TMVA::Reader *reader = 0;
476	<	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	<
476	>	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
477		mva = reader->EvaluateMVA( fMethodname );
478
479		if (printDebug == kTRUE) {
480		std::cout << "Debug Electron MVA: "
481	<	<< ElePt << " " << EleEta << " " << " --> MVABin " << MVABin << " : "
481	>	<< ElePt << " " << EleEta << " " << " --> MVABin " << GetMVABin( EleEta, ElePt) << " : "
482		<< fMVAVar_EleSigmaIEtaIEta << " "
483		<< fMVAVar_EleDEtaIn << " "
484		<< fMVAVar_EleDPhiIn << " "
#	Line 501 | Line 516 | Double_t ElectronIDMVA::MVAValue(Double_
516		return mva;
517		}
518
519	+	Double_t ElectronIDMVA::MVAValue_IsoRings( Double_t ElePt,
520	+	Double_t EleSCEta,
521	+	Double_t ChargedIso_DR0p0To0p1,
522	+	Double_t ChargedIso_DR0p1To0p2,
523	+	Double_t ChargedIso_DR0p2To0p3,
524	+	Double_t ChargedIso_DR0p3To0p4,
525	+	Double_t ChargedIso_DR0p4To0p5,
526	+	Double_t GammaIso_DR0p0To0p1,
527	+	Double_t GammaIso_DR0p1To0p2,
528	+	Double_t GammaIso_DR0p2To0p3,
529	+	Double_t GammaIso_DR0p3To0p4,
530	+	Double_t GammaIso_DR0p4To0p5,
531	+	Double_t NeutralHadronIso_DR0p0To0p1,
532	+	Double_t NeutralHadronIso_DR0p1To0p2,
533	+	Double_t NeutralHadronIso_DR0p2To0p3,
534	+	Double_t NeutralHadronIso_DR0p3To0p4,
535	+	Double_t NeutralHadronIso_DR0p4To0p5,
536	+	Bool_t printDebug) {
537	+
538	+	if (fMVAType != ElectronIDMVA::kIsoRingsV0) {
539	+	std::cout << "Error: This function is only supported for MVAType == kIsoRingsV0.\n" << std::endl;
540	+	assert(kFALSE);
541	+	}
542	+
543	+	fMVAVar_ElePt = ElePt;
544	+	fMVAVar_EleEta = EleSCEta;
545	+	fMVAVar_ChargedIso_DR0p0To0p1 = ChargedIso_DR0p0To0p1;
546	+	fMVAVar_ChargedIso_DR0p1To0p2 = ChargedIso_DR0p1To0p2;
547	+	fMVAVar_ChargedIso_DR0p2To0p3 = ChargedIso_DR0p2To0p3;
548	+	fMVAVar_ChargedIso_DR0p3To0p4 = ChargedIso_DR0p3To0p4;
549	+	fMVAVar_ChargedIso_DR0p4To0p5 = ChargedIso_DR0p4To0p5;
550	+	fMVAVar_GammaIso_DR0p0To0p1 = GammaIso_DR0p0To0p1;
551	+	fMVAVar_GammaIso_DR0p1To0p2 = GammaIso_DR0p1To0p2;
552	+	fMVAVar_GammaIso_DR0p2To0p3 = GammaIso_DR0p2To0p3;
553	+	fMVAVar_GammaIso_DR0p3To0p4 = GammaIso_DR0p3To0p4;
554	+	fMVAVar_GammaIso_DR0p4To0p5 = GammaIso_DR0p4To0p5;
555	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = NeutralHadronIso_DR0p0To0p1;
556	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = NeutralHadronIso_DR0p1To0p2;
557	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = NeutralHadronIso_DR0p2To0p3;
558	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = NeutralHadronIso_DR0p3To0p4;
559	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = NeutralHadronIso_DR0p4To0p5;
560	+
561	+	Double_t mva = -9999;
562	+	TMVA::Reader *reader = 0;
563	+
564	+	if (printDebug == kTRUE) {
565	+	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << std::endl;
566	+	}
567	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
568	+	mva = reader->EvaluateMVA( fMethodname );
569	+
570	+	if (printDebug == kTRUE) {
571	+
572	+	std::cout << "Debug Electron MVA-ISO: ";
573	+	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
574	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
575	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
576	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
577	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
578	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
579	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
580	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
581	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
582	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
583	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
584	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
585	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
586	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
587	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
588	+	<< std::endl;
589	+	std::cout << "MVA: " << mva << " "
590	+	<< std::endl;
591	+	}
592	+	return mva;
593	+	}
594	+
595	+	Double_t ElectronIDMVA::MVAValue_IDNonTrig( Double_t ElePt,
596	+	Double_t EleSCEta,
597	+	Double_t EleFBrem,
598	+	Double_t EleKFTrkChiSqr,
599	+	Double_t EleKFTrkNHits,
600	+	Double_t EleGsfTrackChi2OverNdof,
601	+	Double_t EleDEtaIn,
602	+	Double_t EleDPhiIn,
603	+	Double_t EledEtaCalo,
604	+	Double_t EleSigmaIEtaIEta,
605	+	Double_t EleSigmaIPhiIPhi,
606	+	Double_t EleSCEtaWidth,
607	+	Double_t EleSCPhiWidth,
608	+	Double_t EleE1x5OverE5x5,
609	+	Double_t EleR9,
610	+	Double_t EleHoverE,
611	+	Double_t EleEOverP,
612	+	Double_t EleOneOverEMinusOneOverP,
613	+	Double_t EleESeedClusterOverPout,
614	+	Double_t ElePreShowerOverRaw,
615	+	Bool_t printDebug) {
616	+
617	+	if (fMVAType != ElectronIDMVA::kIDEGamma2012NonTrigV0) {
618	+	std::cout << "Error: This function is only supported for MVAType == kIDEGamma2012NonTrigV0.\n" << std::endl;
619	+	assert(kFALSE);
620	+	}
621	+
622	+	fMVAVar_ElePt = ElePt;
623	+	fMVAVar_EleEta = EleSCEta;
624	+	fMVAVar_EleFBrem = EleFBrem;
625	+	fMVAVar_EleKFTrkChiSqr = EleKFTrkChiSqr;
626	+	fMVAVar_EleKFTrkNHits = EleKFTrkNHits;
627	+	fMVAVar_EleGsfTrackChi2OverNdof = EleGsfTrackChi2OverNdof;
628	+	fMVAVar_EleDEtaIn = EleDEtaIn;
629	+	fMVAVar_EleDPhiIn = EleDPhiIn;
630	+	fMVAVar_EledEtaCalo = EledEtaCalo;
631	+	fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
632	+	fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
633	+	fMVAVar_EleSCEtaWidth = EleSCEtaWidth;
634	+	fMVAVar_EleSCPhiWidth = EleSCPhiWidth;
635	+	fMVAVar_EleE1x5OverE5x5 = EleE1x5OverE5x5;
636	+	fMVAVar_EleR9 = EleR9;
637	+	fMVAVar_EleHoverE = EleHoverE;
638	+	fMVAVar_EleEOverP = EleEOverP;
639	+	fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
640	+	fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
641	+	fMVAVar_ElePreShowerOverRaw = ElePreShowerOverRaw;
642	+
643	+	Double_t mva = -9999;
644	+	TMVA::Reader *reader = 0;
645	+
646	+	if (printDebug == kTRUE) {
647	+	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << std::endl;
648	+	}
649	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
650	+	mva = reader->EvaluateMVA( fMethodname );
651	+
652	+	if (printDebug == kTRUE) {
653	+	std::cout << "Debug Electron MVA: ";
654	+	std::cout << " fbrem " <<  fMVAVar_EleFBrem
655	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
656	+	<< " kfhits " << fMVAVar_EleKFTrkNHits
657	+	<< " kfhitsall " << fMVAVar_EleKFTrkNLayers
658	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
659	+	<< " deta " <<  fMVAVar_EleDEtaIn
660	+	<< " dphi " << fMVAVar_EleDPhiIn
661	+	<< " detacalo " << fMVAVar_EledEtaCalo
662	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
663	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
664	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
665	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
666	+	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
667	+	<< " R9 " << fMVAVar_EleR9
668	+	<< " HoE " << fMVAVar_EleHoverE
669	+	<< " EoP " << fMVAVar_EleEOverP
670	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
671	+	<< " eleEoPout " << fMVAVar_EleESeedClusterOverPout
672	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
673	+	<< " d0 " << fMVAVar_EleD0
674	+	<< " ip3d " << fMVAVar_EleIP3d
675	+	<< " eta " << fMVAVar_EleEta
676	+	<< " pt " << fMVAVar_ElePt << std::endl;
677	+	std::cout << "MVA: " << mva << " "
678	+	<< std::endl;
679	+	}
680	+	return mva;
681	+	}
682	+
683
684		//--------------------------------------------------------------------------------------------------
685		Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
#	Line 514 | Line 693 | Double_t ElectronIDMVA::MVAValue(const E
693		return -9999;
694		}
695
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	–
696		Double_t Rho = 0;
697		if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
698
#	Line 573 | Line 745 | Double_t ElectronIDMVA::MVAValue(const E
745		+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,ele->SCluster()->Eta())) / ele->Pt();
746
747		//Additional vars
748	<	fMVAVar_EleEEleClusterOverPout = 0;
749	<	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
750	<	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
748	>	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
749	>	if (ele->TrackerTrk()) {
750	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
751	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
752	>	} else {
753	>	fMVAVar_EleKFTrkChiSqr = -1;
754	>	fMVAVar_EleKFTrkNHits = 0;
755	>	}
756		fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
757
758
582	–
583	–
759		Double_t mva = -9999;
760		TMVA::Reader *reader = 0;
761	<	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	<
761	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
762		mva = reader->EvaluateMVA( fMethodname );
763
764		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;
765		std::cout << "Debug Electron MVA: "
766		<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
767	<	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << MVABin << " : "
767	>	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
768		<< fMVAVar_EleSigmaIEtaIEta << " "
769		<< fMVAVar_EleDEtaIn << " "
770		<< fMVAVar_EleDPhiIn << " "
#	Line 680 | Line 811 | Double_t ElectronIDMVA::MVAValue(const E
811		return -9999;
812		}
813
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	–
814		fMVAVar_ElePt = ele->Pt();
815		fMVAVar_EleEta = ele->Eta();
816
#	Line 710 | Line 834 | Double_t ElectronIDMVA::MVAValue(const E
834
835
836		fMVAVar_EleEEleClusterOverPout = 0;
837	<	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
838	<	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
837	>	if (ele->TrackerTrk()) {
838	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
839	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
840	>	} else {
841	>	fMVAVar_EleKFTrkChiSqr = -1;
842	>	fMVAVar_EleKFTrkNHits = 0;
843	>	}
844		fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
845		fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
846		fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
#	Line 727 | Line 856 | Double_t ElectronIDMVA::MVAValue(const E
856
857		Double_t mva = -9999;
858		TMVA::Reader *reader = 0;
859	<	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	<
859	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
860		mva = reader->EvaluateMVA( fMethodname );
861
862		if (printDebug == kTRUE) {
863		std::cout << "Debug Electron MVA: "
864		<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
865	<	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << MVABin << " : "
865	>	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
866		<< fMVAVar_EleSigmaIEtaIEta << " "
867		<< fMVAVar_EleDEtaIn << " "
868		<< fMVAVar_EleDPhiIn << " "
#	Line 805 | Line 925 | Double_t ElectronIDMVA::MVAValue(const E
925		//set all input variables
926		fMVAVar_ElePt = ele->Pt();
927		fMVAVar_EleEta = ele->SCluster()->Eta();
928	<	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
929	<	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
930	<	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
928	>	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
929	>
930	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
931	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
932	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
933	>	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
934	>	fMVAVar_EleDPhiIn = TMath::Min(fabs(double(ele->DeltaPhiSuperClusterTrackAtVtx())),0.6);
935	>	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
936	>	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
937	>	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
938	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->P();
939	>	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
940	>	fMVAVar_EledEtaCalo =  TMath::Min(fabs(double(ele->DeltaEtaSeedClusterTrackAtCalo())),0.2);
941	>	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
942	>	} else {
943	>	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
944	>	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
945	>	fMVAVar_EleFBrem = ele->FBrem();
946	>	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
947	>	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
948	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
949	>	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
950	>	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
951	>	fMVAVar_EleR9 = ele->SCluster()->R9();
952	>	}
953	>
954		fMVAVar_EleHoverE = ele->HadronicOverEm();
955		fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
956		fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
814	–	fMVAVar_EleFBrem = ele->FBrem();
815	–	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
816	–	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
957		if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
958		else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
959		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	–
960		fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
961		fMVAVar_EleIP3d = ele->Ip3dPV();
962		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
832	–	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
833	–	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
963		fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
835	–	fMVAVar_EleR9 = ele->SCluster()->R9();
964		fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
965		fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
966		fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
#	Line 841 | Line 969 | Double_t ElectronIDMVA::MVAValue(const E
969		//Additional vars
970		fMVAVar_EleEEleClusterOverPout = 0;
971		if (ele->TrackerTrk()) {
972	<	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
972	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
973	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
974	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
975	>	fMVAVar_EleKFTrkChiSqr = TMath::Min(double(ele->TrackerTrk()->RChi2()),10.0);
976	>	} else {
977	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
978	>	}
979		fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
980	+	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
981		} else {
982	<	fMVAVar_EleKFTrkChiSqr = 0;
983	<	fMVAVar_EleKFTrkNHits = -1;
982	>	fMVAVar_EleKFTrkChiSqr = -1;
983	>	fMVAVar_EleKFTrkNHits = 0;
984	>	fMVAVar_EleKFTrkNLayers = 0;
985		}
986
987	<	fMVAVar_EleE1x5OverE5x5 = (ele->SCluster()->Seed()->E5x5() > 0.0) ? 1.0-ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5() : -1. ;
987	>	if( ele->SCluster()->Seed()->E5x5() > 0.0 ) {
988	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
989	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
990	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
991	>	fMVAVar_EleE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
992	>	} else {
993	>	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5();
994	>	}
995	>	} else {
996	>	fMVAVar_EleE1x5OverE5x5 = -1.0;
997	>	}
998	>
999
1000		Double_t tmpChargedIso_DR0p0To0p1  = 0;
1001		Double_t tmpChargedIso_DR0p1To0p2  = 0;
#	Line 986 | Line 1133 | Double_t ElectronIDMVA::MVAValue(const E
1133		fMVAVar_NeutralHadronIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1134		fMVAVar_NeutralHadronIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1135		fMVAVar_NeutralHadronIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1136	<	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;
1136	>	fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1137
1138		//Do Binding of MVA input variables
1139	<	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1139	>	if (   fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1140		|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
1141	<	|| fMVAType == ElectronIDMVA::kIsoRingsV0) {
1141	>	|| fMVAType == ElectronIDMVA::kIsoRingsV0
1142	>	|| fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
1143		bindVariables();
1144		}
1145
1146		Double_t mva = -9999;
1147		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;
1148
1149	<	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	<
1149	>	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
1150		mva = reader->EvaluateMVA( fMethodname );
1151
1152		if (printDebug == kTRUE) {
1153
1154	<	std::cout << "Debug Electron MVA: \n";
1155	<	std::cout << " fbrem " <<  fMVAVar_EleFBrem
1154	>	std::cout << "Debug Electron MVA-ID: "
1155	>	<< fMVAVar_ElePt<< " " << fMVAVar_EleEta << " "
1156	>	<< " --> MVABin " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << " : "
1157	>	<< " fbrem " <<  fMVAVar_EleFBrem
1158		<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
1159		<< " kfhits " << fMVAVar_EleKFTrkNHits
1160	<	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1160	>	<< " kfhitsall " << fMVAVar_EleKFTrkNLayers
1161		<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
1162		<< " deta " <<  fMVAVar_EleDEtaIn
1163		<< " dphi " << fMVAVar_EleDPhiIn
#	Line 1042 | Line 1176 | Double_t ElectronIDMVA::MVAValue(const E
1176		<< " d0 " << fMVAVar_EleD0
1177		<< " ip3d " << fMVAVar_EleIP3d
1178		<< " eta " << fMVAVar_EleEta
1179	<	<< " pt " << fMVAVar_ElePt << std::endl;
1180	<
1181	<	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
1179	>	<< " pt " << fMVAVar_ElePt
1180	>	<< " === : === "
1181	>	<< mva << " "
1182	>	<< std::endl;
1183	>	std::cout << "Debug Electron MVA-ISO: "
1184	>	<< fMVAVar_ChargedIso_DR0p0To0p1 << " "
1185		<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1186		<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1187		<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
#	Line 1060 | Line 1197 | Double_t ElectronIDMVA::MVAValue(const E
1197		<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1198		<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
1199		<< std::endl;
1063	–	std::cout << "MVA: " << mva << " "
1064	–	<< std::endl;
1200		}
1201
1202		return mva;

Diff Legend

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