ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitPhysics/Utils/src/ElectronIDMVA.cc

Comparing UserCode/MitPhysics/Utils/src/ElectronIDMVA.cc (file contents):
Revision 1.2 by sixie, Sun Sep 25 15:03:41 2011 UTC vs.
Revision 1.16 by sixie, Tue Apr 24 12:48:30 2012 UTC

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

Diff Legend

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