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.23 by ceballos, Sat May 12 07:03:53 2012 UTC vs.
Revision 1.26 by sixie, Sun Jul 22 20:33:27 2012 UTC

#	Line 101 | Line 101 | void ElectronIDMVA::Initialize( std::str
101		ExpectedNBins = 6;
102		} else if (type == kIDEGamma2012TrigV0 ||
103		type == kIDEGamma2012NonTrigV0 ||
104	<	type == kIDHWW2012TrigV0) {
104	>	type == kIDEGamma2012NonTrigV1 ||
105	>	type == kIDHWW2012TrigV0 ||
106	>	type == kIDIsoCombinedHWW2012TrigV4
107	>
108	>	) {
109		ExpectedNBins = 6;
110		} else if (type == kIsoRingsV0) {
111		ExpectedNBins = 4;
#	Line 248 | Line 252 | void ElectronIDMVA::Initialize( std::str
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	+	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	+
281		if (type == kIsoRingsV0) {
282		tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1",         &fMVAVar_ChargedIso_DR0p0To0p1        );
283		tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2",         &fMVAVar_ChargedIso_DR0p1To0p2        );
#	Line 268 | Line 298 | void ElectronIDMVA::Initialize( std::str
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 308 | Line 397 | UInt_t ElectronIDMVA::GetMVABin( double
397		if (pt >= 10 && fabs(eta) >= 1.479) bin = 3;
398		}
399
400	<	if (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 319 | Line 409 | UInt_t ElectronIDMVA::GetMVABin( double
409		}
410
411		if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
412	<	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
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;
#	Line 733 | 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->CorrectedEcalEnergy())) - 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 851 | Line 943 | Double_t ElectronIDMVA::MVAValue(const E
943		if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
944		else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
945		fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
946	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->CorrectedEcalEnergy())) - 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();
#	Line 873 | Line 965 | Double_t ElectronIDMVA::MVAValue(const E
965		fMVAVar_EleR9 = ele->SCluster()->R9();
966		fMVAVar_EleHoverE = ele->HadronicOverEm();
967		fMVAVar_EleEOverP = ele->ESuperClusterOverP();
968	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->CorrectedEcalEnergy())) - 1.0 / ele->BestTrk()->P();
968	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
969		fMVAVar_EleR9 = ele->SCluster()->R9();
970		fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
971
#	Line 925 | Line 1017 | Double_t ElectronIDMVA::MVAValue(const E
1017		}
1018
1019
928	–
929	–
1020		//--------------------------------------------------------------------------------------------------
1021		//MVA Includes Isolation with removal of other leptons
1022		//
#	Line 973 | Line 1063 | Double_t ElectronIDMVA::MVAValue(const E
1063
1064		if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1065		fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1066	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1067		fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
1068		fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
1069		fMVAVar_EleDPhiIn = TMath::Min(fabs(double(ele->DeltaPhiSuperClusterTrackAtVtx())),0.6);
1070		fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
1071		fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
1072		fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
1073	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->CorrectedEcalEnergy())) - 1.0 / ele->P();
1073	>	fMVAVar_EleEEleClusterOverPout = TMath::Min(double(ele->EEleClusterOverPout()),20.0);
1074	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->P();
1075		fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
1076		fMVAVar_EledEtaCalo =  TMath::Min(fabs(double(ele->DeltaEtaSeedClusterTrackAtCalo())),0.2);
1077		fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
#	Line 989 | Line 1081 | Double_t ElectronIDMVA::MVAValue(const E
1081		fMVAVar_EleFBrem = ele->FBrem();
1082		fMVAVar_EleEOverP = ele->ESuperClusterOverP();
1083		fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
1084	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->CorrectedEcalEnergy())) - 1.0 / ele->BestTrk()->P();
1084	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
1085		fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
1086		fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1087		fMVAVar_EleR9 = ele->SCluster()->R9();
#	Line 999 | Line 1091 | Double_t ElectronIDMVA::MVAValue(const E
1091		fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
1092		fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
1093		if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
1094	<	else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
1094	>	else {
1095	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1) {
1096	>	fMVAVar_EleSigmaIPhiIPhi = 0;
1097	>	} else {
1098	>	fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
1099	>	}
1100	>	}
1101	>
1102		fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
1103		fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
1104		fMVAVar_EleIP3d = ele->Ip3dPV();
#	Line 1011 | Line 1110 | Double_t ElectronIDMVA::MVAValue(const E
1110		fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
1111
1112		//Additional vars
1014	–	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
1113		if (ele->TrackerTrk()) {
1114		if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1115		fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1116	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1117		fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
1118		fMVAVar_EleKFTrkChiSqr = TMath::Min(double(ele->TrackerTrk()->RChi2()),10.0);
1119		} else {
#	Line 1031 | Line 1130 | Double_t ElectronIDMVA::MVAValue(const E
1130		if( ele->SCluster()->Seed()->E5x5() > 0.0 ) {
1131		if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1132		fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1133	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1134		fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
1135		fMVAVar_EleE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1136		} else {
#	Line 1232 | Line 1332 | Double_t ElectronIDMVA::MVAValue(const E
1332		<< std::endl;
1333		}
1334
1335	+	return mva;
1336	+	}
1337	+
1338	+
1339	+	//--------------------------------------------------------------------------------------------------
1340	+	//MVA Includes Isolation
1341	+	//
1342	+	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
1343	+	const VertexCol *primaryVertices,
1344	+	const PFCandidateCol *PFCands,
1345	+	const PileupEnergyDensityCol *PileupEnergyDensity,
1346	+	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaTarget,
1347	+	Bool_t printDebug) {
1348	+
1349	+	if (!fIsInitialized) {
1350	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
1351	+	return -9999;
1352	+	}
1353	+
1354	+	Double_t Rho = 0;
1355	+	switch(fTheRhoType) {
1356	+	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
1357	+	Rho = PileupEnergyDensity->At(0)->Rho();
1358	+	break;
1359	+	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
1360	+	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
1361	+	break;
1362	+	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
1363	+	Rho = PileupEnergyDensity->At(0)->RhoRandom();
1364	+	break;
1365	+	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
1366	+	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
1367	+	break;
1368	+	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
1369	+	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
1370	+	break;
1371	+	default:
1372	+	// use the old default
1373	+	Rho = PileupEnergyDensity->At(0)->Rho();
1374	+	break;
1375	+	}
1376	+
1377	+	//set all input variables
1378	+	fMVAVar_ElePt = ele->Pt();
1379	+	fMVAVar_EleEta = ele->SCluster()->Eta();
1380	+	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
1381	+
1382	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1383	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1384	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1385	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ||
1386	+	fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
1387	+	) {
1388	+	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
1389	+	fMVAVar_EleDPhiIn = TMath::Min(fabs(double(ele->DeltaPhiSuperClusterTrackAtVtx())),0.6);
1390	+	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
1391	+	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
1392	+	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
1393	+	fMVAVar_EleEEleClusterOverPout = TMath::Min(double(ele->EEleClusterOverPout()),20.0);
1394	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->P();
1395	+	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
1396	+	fMVAVar_EledEtaCalo =  TMath::Min(fabs(double(ele->DeltaEtaSeedClusterTrackAtCalo())),0.2);
1397	+	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
1398	+	} else {
1399	+	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
1400	+	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
1401	+	fMVAVar_EleFBrem = ele->FBrem();
1402	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
1403	+	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
1404	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
1405	+	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
1406	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1407	+	fMVAVar_EleR9 = ele->SCluster()->R9();
1408	+	}
1409	+
1410	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
1411	+	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
1412	+	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
1413	+	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
1414	+	else {
1415	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ) {
1416	+	fMVAVar_EleSigmaIPhiIPhi = 0;
1417	+	} else {
1418	+	fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
1419	+	}
1420	+	}
1421	+
1422	+	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
1423	+	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
1424	+	fMVAVar_EleIP3d = ele->Ip3dPV();
1425	+	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
1426	+	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
1427	+	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
1428	+	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
1429	+	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
1430	+	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
1431	+
1432	+	//Additional vars
1433	+	if (ele->TrackerTrk()) {
1434	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1435	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1436	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1437	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ||
1438	+	fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
1439	+	) {
1440	+	fMVAVar_EleKFTrkChiSqr = TMath::Min(double(ele->TrackerTrk()->RChi2()),10.0);
1441	+	} else {
1442	+	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
1443	+	}
1444	+	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
1445	+	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
1446	+	} else {
1447	+	fMVAVar_EleKFTrkChiSqr = 0;
1448	+	fMVAVar_EleKFTrkNHits = -1;
1449	+	fMVAVar_EleKFTrkNLayers = -1;
1450	+	}
1451	+
1452	+	if( ele->SCluster()->Seed()->E5x5() > 0.0 ) {
1453	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1454	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1455	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1456	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ||
1457	+	fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
1458	+	) {
1459	+	fMVAVar_EleE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1460	+	fMVAVar_EleOneMinusE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1461	+	} else {
1462	+	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5();
1463	+	}
1464	+	} else {
1465	+	fMVAVar_EleE1x5OverE5x5 = -1.0;
1466	+	}
1467	+
1468	+
1469	+	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1470	+	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1471	+	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1472	+	Double_t tmpChargedIso_DR0p3To0p4  = 0;
1473	+	Double_t tmpChargedIso_DR0p4To0p5  = 0;
1474	+	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1475	+	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1476	+	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1477	+	Double_t tmpGammaIso_DR0p3To0p4  = 0;
1478	+	Double_t tmpGammaIso_DR0p4To0p5  = 0;
1479	+	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1480	+	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1481	+	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1482	+	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1483	+	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1484	+
1485	+	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
1486	+	const PFCandidate *pf = PFCands->At(p);
1487	+
1488	+	//************************************************************
1489	+	// New Isolation Calculations
1490	+	//************************************************************
1491	+	Double_t dr = MathUtils::DeltaR(ele->Mom(), pf->Mom());
1492	+
1493	+	if (dr < 0.5) {
1494	+
1495	+	Bool_t passVeto = kTRUE;
1496	+	//Charged
1497	+	if(pf->BestTrk()) {
1498	+
1499	+	//*************************************************
1500	+	//Use only PFNoPU
1501	+	//*************************************************
1502	+	Bool_t isPFNoPU = kFALSE;
1503	+	if(pf->PFType() == PFCandidate::eHadron) {
1504	+	if(pf->HasTrackerTrk() &&
1505	+	primaryVertices->At(0)->HasTrack(pf->TrackerTrk()) &&
1506	+	primaryVertices->At(0)->TrackWeight(pf->TrackerTrk()) > 0) {
1507	+	isPFNoPU = kTRUE;
1508	+	} else {
1509	+
1510	+	Bool_t vertexFound = kFALSE;
1511	+	const Vertex *closestVtx = 0;
1512	+	Double_t dzmin = 10000;
1513	+
1514	+	// loop over vertices
1515	+	for(UInt_t j = 0; j < primaryVertices->GetEntries(); j++) {
1516	+	const Vertex *vtx = primaryVertices->At(j);
1517	+	assert(vtx);
1518	+
1519	+	if(pf->HasTrackerTrk() &&
1520	+	vtx->HasTrack(pf->TrackerTrk()) &&
1521	+	vtx->TrackWeight(pf->TrackerTrk()) > 0) {
1522	+	vertexFound = kTRUE;
1523	+	closestVtx = vtx;
1524	+	break;
1525	+	}
1526	+	Double_t dz = fabs(pf->SourceVertex().Z() - vtx->Z());
1527	+	if(dz < dzmin) {
1528	+	closestVtx = vtx;
1529	+	dzmin = dz;
1530	+	}
1531	+	}
1532	+
1533	+	Bool_t fCheckClosestZVertex = kTRUE; //we use option 1
1534	+	if(fCheckClosestZVertex) {
1535	+	// Fallback: if track is not associated with any vertex,
1536	+	// associate it with the vertex closest in z
1537	+	if(vertexFound || closestVtx != vertex) {
1538	+	isPFNoPU = kFALSE;
1539	+	} else {
1540	+	isPFNoPU = kTRUE;
1541	+	}
1542	+	} else {
1543	+	if(vertexFound && closestVtx != vertex) {
1544	+	isPFNoPU = kFALSE;
1545	+	} else {
1546	+	isPFNoPU = kTRUE;
1547	+	}
1548	+	}
1549	+	} //hadron & trk stuff
1550	+	} else { // hadron
1551	+	//
1552	+	isPFNoPU = kTRUE;
1553	+	}
1554	+	if (!isPFNoPU) continue;
1555	+
1556	+	//************************************************************
1557	+	// Veto any PFmuon, or PFEle
1558	+	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
1559	+	//************************************************************
1560	+	//************************************************************
1561	+	// Footprint Veto
1562	+	if (fabs(ele->SCluster()->Eta()) >= 1.479 && dr < 0.015) passVeto = kFALSE;
1563	+	//************************************************************
1564	+	if (passVeto) {
1565	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1566	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1567	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1568	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1569	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1570	+	} //pass veto
1571	+
1572	+	}
1573	+	//Gamma
1574	+	else if (pf->PFType() == PFCandidate::eGamma) {
1575	+	//************************************************************
1576	+	// Footprint Veto
1577	+	if (fabs(ele->SCluster()->Eta()) >= 1.479) {
1578	+	if (dr < 0.08) passVeto = kFALSE;
1579	+	}
1580	+	//************************************************************
1581	+
1582	+	if (passVeto) {
1583	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1584	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1585	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1586	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1587	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1588	+	}
1589	+	}
1590	+	//NeutralHadron
1591	+	else {
1592	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1593	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1594	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1595	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1596	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1597	+	}
1598	+	} //in 1.0 dr cone
1599	+	} //loop over PF candidates
1600	+
1601	+	fMVAVar_ChargedIso_DR0p0To0p1   = tmpChargedIso_DR0p0To0p1/ele->Pt();
1602	+	fMVAVar_ChargedIso_DR0p1To0p2   = tmpChargedIso_DR0p1To0p2/ele->Pt();
1603	+	fMVAVar_ChargedIso_DR0p2To0p3 = tmpChargedIso_DR0p2To0p3/ele->Pt();
1604	+	fMVAVar_ChargedIso_DR0p3To0p4 = tmpChargedIso_DR0p3To0p4/ele->Pt();
1605	+	fMVAVar_ChargedIso_DR0p4To0p5 = tmpChargedIso_DR0p4To0p5/ele->Pt();
1606	+	fMVAVar_GammaIso_DR0p0To0p1 = tmpGammaIso_DR0p0To0p1/ele->Pt();
1607	+	fMVAVar_GammaIso_DR0p1To0p2 = tmpGammaIso_DR0p1To0p2/ele->Pt();
1608	+	fMVAVar_GammaIso_DR0p2To0p3 = tmpGammaIso_DR0p2To0p3/ele->Pt();
1609	+	fMVAVar_GammaIso_DR0p3To0p4 = tmpGammaIso_DR0p3To0p4/ele->Pt();
1610	+	fMVAVar_GammaIso_DR0p4To0p5 = tmpGammaIso_DR0p4To0p5/ele->Pt();
1611	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = tmpNeutralHadronIso_DR0p0To0p1/ele->Pt();
1612	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = tmpNeutralHadronIso_DR0p1To0p2/ele->Pt();
1613	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = tmpNeutralHadronIso_DR0p2To0p3/ele->Pt();
1614	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = tmpNeutralHadronIso_DR0p3To0p4/ele->Pt();
1615	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = tmpNeutralHadronIso_DR0p4To0p5/ele->Pt();
1616	+	fMVAVar_Rho = Rho;
1617	+
1618	+	//Do Binding of MVA input variables
1619	+	if (   fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1620	+	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
1621	+	|| fMVAType == ElectronIDMVA::kIsoRingsV0
1622	+	|| fMVAType == ElectronIDMVA::kIDHWW2012TrigV0
1623	+	|| fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
1624	+	) {
1625	+	bindVariables();
1626	+	}
1627	+
1628	+	Double_t mva = -9999;
1629	+	TMVA::Reader *reader = 0;
1630	+
1631	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
1632	+	mva = reader->EvaluateMVA( fMethodname );
1633	+
1634	+	if (printDebug == kTRUE) {
1635	+
1636	+	std::cout << "Debug Electron MVA-ID: "
1637	+	<< fMVAVar_ElePt<< " " << fMVAVar_EleEta << " "
1638	+	<< " --> MVABin " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << " : "
1639	+	<< " fbrem " <<  fMVAVar_EleFBrem
1640	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
1641	+	<< " kfhits " << fMVAVar_EleKFTrkNLayers
1642	+	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1643	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
1644	+	<< " deta " <<  fMVAVar_EleDEtaIn
1645	+	<< " dphi " << fMVAVar_EleDPhiIn
1646	+	<< " detacalo " << fMVAVar_EledEtaCalo
1647	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
1648	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
1649	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
1650	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
1651	+	<< " e1x5e5x5 " << fMVAVar_EleOneMinusE1x5OverE5x5
1652	+	<< " R9 " << fMVAVar_EleR9
1653	+	<< " HoE " << fMVAVar_EleHoverE
1654	+	<< " EoP " << fMVAVar_EleEOverP
1655	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
1656	+	<< " eleEoPout " << fMVAVar_EleEEleClusterOverPout
1657	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
1658	+	<< " PreShowerOverRaw" << fMVAVar_ElePreShowerOverRaw
1659	+	<< " d0 " << fMVAVar_EleD0
1660	+	<< " ip3d " << fMVAVar_EleIP3d
1661	+	<< " eta " << fMVAVar_EleEta
1662	+	<< " pt " << fMVAVar_ElePt
1663	+	<< " === : === "
1664	+	<< mva << " "
1665	+	<< std::endl;
1666	+	std::cout << "Debug Electron MVA-ISO: "
1667	+	<< fMVAVar_ChargedIso_DR0p0To0p1 << " "
1668	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1669	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1670	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
1671	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
1672	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
1673	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
1674	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
1675	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
1676	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
1677	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
1678	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
1679	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
1680	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1681	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
1682	+	<< fMVAVar_Rho << " "
1683	+	<< std::endl;
1684	+	}
1685	+
1686		return mva;
1687		}
1688

Diff Legend

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