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.29 by sixie, Fri Oct 26 18:34:21 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	>	fTheRhoType(RhoUtilities::DEFAULT)
23		{
24		// Constructor.
22	–	for(UInt_t i=0; i<6; ++i) {
23	–	fTMVAReader[i] = 0;
24	–	}
25		}
26
27
28		//--------------------------------------------------------------------------------------------------
29		ElectronIDMVA::~ElectronIDMVA()
30		{
31	<	for(UInt_t i=0; i<6; ++i) {
31	>	for(UInt_t i=0; i<fTMVAReader.size(); ++i) {
32		if (fTMVAReader[i]) delete fTMVAReader[i];
33		}
34		}
35
36		//--------------------------------------------------------------------------------------------------
37	+	void ElectronIDMVA::Initialize( std::string methodName,
38	+	std::string weightsfile,
39	+	ElectronIDMVA::MVAType type,
40	+	RhoUtilities::RhoType theRhoType)
41	+	{
42	+
43	+	std::vector<std::string> tempWeightFileVector;
44	+	tempWeightFileVector.push_back(weightsfile);
45	+	Initialize(methodName,type,kFALSE,tempWeightFileVector,theRhoType);
46	+	}
47	+
48	+	//--------------------------------------------------------------------------------------------------
49		void ElectronIDMVA::Initialize( TString methodName,
50		TString Subdet0Pt10To20Weights ,
51		TString Subdet1Pt10To20Weights ,
#	Line 41 | Line 53 | void ElectronIDMVA::Initialize( TString
53		TString Subdet0Pt20ToInfWeights,
54		TString Subdet1Pt20ToInfWeights,
55		TString Subdet2Pt20ToInfWeights,
56	<	ElectronLikelihood *LH) {
56	>	ElectronIDMVA::MVAType type,
57	>	RhoUtilities::RhoType theRhoType) {
58	>
59	>	std::vector<std::string> tempWeightFileVector;
60	>	tempWeightFileVector.push_back(std::string(Subdet0Pt10To20Weights.Data()));
61	>	tempWeightFileVector.push_back(std::string(Subdet1Pt10To20Weights.Data()));
62	>	tempWeightFileVector.push_back(std::string(Subdet2Pt10To20Weights.Data()));
63	>	tempWeightFileVector.push_back(std::string(Subdet0Pt20ToInfWeights.Data()));
64	>	tempWeightFileVector.push_back(std::string(Subdet1Pt20ToInfWeights.Data()));
65	>	tempWeightFileVector.push_back(std::string(Subdet2Pt20ToInfWeights.Data()));
66	>	Initialize(std::string(methodName.Data()),type,kTRUE,tempWeightFileVector,theRhoType);
67	>
68	>	}
69	>
70
71	+	//--------------------------------------------------------------------------------------------------
72	+	void ElectronIDMVA::Initialize( std::string methodName,
73	+	ElectronIDMVA::MVAType type,
74	+	Bool_t useBinnedVersion,
75	+	std::vector<std::string> weightsfiles,
76	+	RhoUtilities::RhoType theRhoType
77	+
78	+	) {
79	+
80	+	//clean up first
81	+	for (uint i=0;i<fTMVAReader.size(); ++i) {
82	+	if (fTMVAReader[i]) delete fTMVAReader[i];
83	+	}
84	+	fTMVAReader.clear();
85	+
86	+	//initialize
87		fIsInitialized = kTRUE;
47	–
88		fMethodname = methodName;
89	<	fLH = LH;
90	<	if (!fLH) { std::cout << "Error: Likelihood is not properly initialized.\n"; assert(fLH); }
89	>	fMVAType = type;
90	>	fUseBinnedVersion = useBinnedVersion;
91	>	fTheRhoType = theRhoType;
92	>
93	>	//Define expected number of bins
94	>	UInt_t ExpectedNBins = 0;
95	>	if (!fUseBinnedVersion) {
96	>	ExpectedNBins = 1;
97	>	} else if (type == kBaseline
98	>	||type == kNoIPInfo
99	>	||type == kWithIPInfo
100	>	||type == kIDIsoCombined) {
101	>	ExpectedNBins = 6;
102	>	} else if (type == kIDEGamma2012TrigV0 ||
103	>	type == kIDEGamma2012NonTrigV0 ||
104	>	type == kIDEGamma2012NonTrigV1 ||
105	>	type == kIDHWW2012TrigV0 ||
106	>	type == kIDIsoCombinedHWW2012TrigV4
107	>
108	>	) {
109	>	ExpectedNBins = 6;
110	>	} else if (type == kIsoRingsV0) {
111	>	ExpectedNBins = 4;
112	>	}
113	>	fNMVABins = ExpectedNBins;
114	>
115	>	//Check number of weight files given
116	>	if (fNMVABins != weightsfiles.size() ) {
117	>	std::cout << "Error: Expected Number of bins = " << fNMVABins << " does not equal to weightsfiles.size() = "
118	>	<< weightsfiles.size() << std::endl;
119	>	assert(fNMVABins == weightsfiles.size());
120	>	}
121	>
122	>
123	>	for(UInt_t i=0; i<fNMVABins; ++i) {
124	>	TMVA::Reader *tmpTMVAReader = new TMVA::Reader( "!Color:!Silent:Error" );
125	>	tmpTMVAReader->SetVerbose(kTRUE);
126	>
127	>	if (type == kBaseline) {
128	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
129	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
130	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
131	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
132	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
133	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
134	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
135	>	}
136	>	if (type == kNoIPInfo) {
137	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
138	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
139	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
140	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
141	>	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
142	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
143	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
144	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
145	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
146	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
147	>	}
148	>	if (type == kWithIPInfo) {
149	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
150	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
151	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
152	>	tmpTMVAReader->AddVariable( "D0",                    &fMVAVar_EleD0                       );
153	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
154	>	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
155	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
156	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
157	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
158	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
159	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
160	>	tmpTMVAReader->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
161	>	tmpTMVAReader->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
162	>	}
163	>	if (type == kIDIsoCombined) {
164	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
165	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
166	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
167	>	tmpTMVAReader->AddVariable( "D0",                    &fMVAVar_EleD0                       );
168	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
169	>	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
170	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
171	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
172	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
173	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
174	>	tmpTMVAReader->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
175	>	tmpTMVAReader->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
176	>
177	>	tmpTMVAReader->AddVariable( "GsfTrackChi2OverNdof",  &fMVAVar_EleGsfTrackChi2OverNdof     );
178	>	tmpTMVAReader->AddVariable( "dEtaCalo",              &fMVAVar_EledEtaCalo                 );
179	>	tmpTMVAReader->AddVariable( "dPhiCalo",              &fMVAVar_EledPhiCalo                 );
180	>	tmpTMVAReader->AddVariable( "R9",                    &fMVAVar_EleR9                       );
181	>	tmpTMVAReader->AddVariable( "SCEtaWidth",            &fMVAVar_EleSCEtaWidth               );
182	>	tmpTMVAReader->AddVariable( "SCPhiWidth",            &fMVAVar_EleSCPhiWidth               );
183	>	tmpTMVAReader->AddVariable( "CovIEtaIPhi",           &fMVAVar_EleCovIEtaIPhi              );
184	>	if (i == 2 || i == 5) {
185	>	tmpTMVAReader->AddVariable( "PreShowerOverRaw",      &fMVAVar_ElePreShowerOverRaw       );
186	>	}
187	>	tmpTMVAReader->AddVariable( "ChargedIso03",          &fMVAVar_EleChargedIso03OverPt       );
188	>	tmpTMVAReader->AddVariable( "NeutralHadronIso03",    &fMVAVar_EleNeutralHadronIso03OverPt );
189	>	tmpTMVAReader->AddVariable( "GammaIso03",            &fMVAVar_EleGammaIso03OverPt         );
190	>	tmpTMVAReader->AddVariable( "ChargedIso04",          &fMVAVar_EleChargedIso04OverPt       );
191	>	tmpTMVAReader->AddVariable( "NeutralHadronIso04",    &fMVAVar_EleNeutralHadronIso04OverPt );
192	>	tmpTMVAReader->AddVariable( "GammaIso04",            &fMVAVar_EleGammaIso04OverPt         );
193	>
194	>	}
195	>
196	>	if (type == kIDEGamma2012TrigV0 || type == kIDHWW2012TrigV0) {
197	>	// Pure tracking variables
198	>	tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
199	>	tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
200	>	tmpTMVAReader->AddVariable("kfhits",          &fMVAVar_EleKFTrkNLayers);  //Don't have this in (BAMBU <= 025)
201	>	if(type == kIDEGamma2012TrigV0)
202	>	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
203	>	tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
204	>	tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
205	>	tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
206	>	tmpTMVAReader->AddVariable("detacalo",        &fMVAVar_EledEtaCalo);
207	>	tmpTMVAReader->AddVariable("see",             &fMVAVar_EleSigmaIEtaIEta);
208	>	tmpTMVAReader->AddVariable("spp",             &fMVAVar_EleSigmaIPhiIPhi);
209	>	tmpTMVAReader->AddVariable("etawidth",        &fMVAVar_EleSCEtaWidth);
210	>	tmpTMVAReader->AddVariable("phiwidth",        &fMVAVar_EleSCPhiWidth);
211	>	tmpTMVAReader->AddVariable("e1x5e5x5",        &fMVAVar_EleE1x5OverE5x5);
212	>	tmpTMVAReader->AddVariable("R9",              &fMVAVar_EleR9);
213	>	tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
214	>	tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
215	>	tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
216	>	tmpTMVAReader->AddVariable("eleEoPout",       &fMVAVar_EleEEleClusterOverPout); //Don't have this in (BAMBU <= 025)
217	>	if(type == kIDEGamma2012TrigV0)
218	>	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout);
219	>	if (i == 2 || i == 5) {
220	>	tmpTMVAReader->AddVariable( "PreShowerOverRaw",      &fMVAVar_ElePreShowerOverRaw       );
221	>	}
222	>	tmpTMVAReader->AddVariable( "d0",             &fMVAVar_EleD0);
223	>	tmpTMVAReader->AddVariable( "ip3d",           &fMVAVar_EleIP3d);
224
225	<	for(UInt_t i=0; i<6; ++i) {
226	<	if (fTMVAReader[i]) delete fTMVAReader[i];
225	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
226	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
227	>	}
228	>
229	>	if (type == kIDEGamma2012NonTrigV0 ) {
230	>	// Pure tracking variables
231	>	tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
232	>	tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
233	>	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
234	>	tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
235	>	tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
236	>	tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
237	>	tmpTMVAReader->AddVariable("detacalo",        &fMVAVar_EledEtaCalo);
238	>	tmpTMVAReader->AddVariable("see",             &fMVAVar_EleSigmaIEtaIEta);
239	>	tmpTMVAReader->AddVariable("spp",             &fMVAVar_EleSigmaIPhiIPhi);
240	>	tmpTMVAReader->AddVariable("etawidth",        &fMVAVar_EleSCEtaWidth);
241	>	tmpTMVAReader->AddVariable("phiwidth",        &fMVAVar_EleSCPhiWidth);
242	>	tmpTMVAReader->AddVariable("e1x5e5x5",        &fMVAVar_EleE1x5OverE5x5);
243	>	tmpTMVAReader->AddVariable("R9",              &fMVAVar_EleR9);
244	>	tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
245	>	tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
246	>	tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
247	>	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout);
248	>	if (i==2 || i==5) {
249	>	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
250	>	}
251	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
252	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
253	>	}
254	>
255	>	if (type == kIDEGamma2012NonTrigV1 ) {
256	>	// Pure tracking variables
257	>	tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
258	>	tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
259	>	tmpTMVAReader->AddVariable("kfhits",          &fMVAVar_EleKFTrkNLayers);
260	>	tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
261	>	tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
262	>	tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
263	>	tmpTMVAReader->AddVariable("detacalo",        &fMVAVar_EledEtaCalo);
264	>	tmpTMVAReader->AddVariable("see",             &fMVAVar_EleSigmaIEtaIEta);
265	>	tmpTMVAReader->AddVariable("spp",             &fMVAVar_EleSigmaIPhiIPhi);
266	>	tmpTMVAReader->AddVariable("etawidth",        &fMVAVar_EleSCEtaWidth);
267	>	tmpTMVAReader->AddVariable("phiwidth",        &fMVAVar_EleSCPhiWidth);
268	>	tmpTMVAReader->AddVariable("e1x5e5x5",        &fMVAVar_EleE1x5OverE5x5);
269	>	tmpTMVAReader->AddVariable("R9",              &fMVAVar_EleR9);
270	>	tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
271	>	tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
272	>	tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
273	>	tmpTMVAReader->AddVariable("eleEoPout",       &fMVAVar_EleEEleClusterOverPout);
274	>	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        );
284	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p2To0p3",         &fMVAVar_ChargedIso_DR0p2To0p3        );
285	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p3To0p4",         &fMVAVar_ChargedIso_DR0p3To0p4        );
286	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p4To0p5",         &fMVAVar_ChargedIso_DR0p4To0p5        );
287	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p0To0p1",           &fMVAVar_GammaIso_DR0p0To0p1          );
288	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p1To0p2",           &fMVAVar_GammaIso_DR0p1To0p2          );
289	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p2To0p3",           &fMVAVar_GammaIso_DR0p2To0p3          );
290	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p3To0p4",           &fMVAVar_GammaIso_DR0p3To0p4          );
291	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p4To0p5",           &fMVAVar_GammaIso_DR0p4To0p5          );
292	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p0To0p1",   &fMVAVar_NeutralHadronIso_DR0p0To0p1  );
293	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p1To0p2",   &fMVAVar_NeutralHadronIso_DR0p1To0p2  );
294	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p2To0p3",   &fMVAVar_NeutralHadronIso_DR0p2To0p3  );
295	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p3To0p4",   &fMVAVar_NeutralHadronIso_DR0p3To0p4  );
296	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p4To0p5",   &fMVAVar_NeutralHadronIso_DR0p4To0p5  );
297	>	tmpTMVAReader->AddSpectator( "eta",   &fMVAVar_EleEta );
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	<	fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );
354	<	fTMVAReader[i]->SetVerbose(kTRUE);
355	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
58	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
59	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
60	<	fTMVAReader[i]->AddVariable( "HoverE",                &fMVAVar_EleHoverE                );
61	<	fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                    );
62	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
63	<	fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                );
64	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout  );
65	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
66	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
67	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );
68	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn   );
69	<	fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                  );
70	<	fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig               );
71	<	fTMVAReader[i]->AddVariable( "StandardLikelihood",    &fMVAVar_EleStandardLikelihood    );
353	>	//spectators
354	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
355	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
356
357	<	if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To20Weights );
358	<	if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To20Weights );
359	<	if (i==2) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt10To20Weights );
360	<	if (i==3) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt20ToInfWeights );
361	<	if (i==4) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt20ToInfWeights );
362	<	if (i==5) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt20ToInfWeights );
357	>	}
358	>
359	>
360	>	tmpTMVAReader->BookMVA(fMethodname , weightsfiles[i] );
361	>	std::cout << "MVABin " << i << " : MethodName = " << fMethodname
362	>	<< " , type == " << type << " , "
363	>	<< "Load weights file : " << weightsfiles[i]
364	>	<< std::endl;
365	>	fTMVAReader.push_back(tmpTMVAReader);
366
367		}
368	+	std::cout << "Electron ID MVA Completed\n";
369	+	}
370	+
371	+
372	+	//--------------------------------------------------------------------------------------------------
373	+	UInt_t ElectronIDMVA::GetMVABin( double eta, double pt) const {
374	+
375	+	//Default is to return the first bin
376	+	uint bin = 0;
377	+
378	+	//return the first bin if not using binned version
379	+	if (!fUseBinnedVersion) return 0;
380	+
381	+	if (fMVAType == ElectronIDMVA::kBaseline
382	+	||fMVAType == ElectronIDMVA::kNoIPInfo
383	+	||fMVAType == ElectronIDMVA::kWithIPInfo
384	+	||fMVAType == ElectronIDMVA::kIDIsoCombined) {
385	+	if (pt < 20 && fabs(eta) < 1.0) bin = 0;
386	+	if (pt < 20 && fabs(eta) >= 1.0 && fabs(eta) < 1.479) bin = 1;
387	+	if (pt < 20 && fabs(eta) >= 1.479) bin = 2;
388	+	if (pt >= 20 && fabs(eta) < 1.0) bin = 3;
389	+	if (pt >= 20 && fabs(eta) >= 1.0 && fabs(eta) < 1.479) bin = 4;
390	+	if (pt >= 20 && fabs(eta) >= 1.479) bin = 5;
391	+	}
392
393	<	std::cout << "Electron ID MVA Initialization\n";
394	<	std::cout << "MethodName : " << fMethodname << std::endl;
395	<	std::cout << "Load weights file : " << Subdet0Pt10To20Weights << std::endl;
396	<	std::cout << "Load weights file : " << Subdet1Pt10To20Weights << std::endl;
397	<	std::cout << "Load weights file : " << Subdet2Pt10To20Weights << std::endl;
398	<	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;
393	>	if (fMVAType == ElectronIDMVA::kIsoRingsV0) {
394	>	if (pt < 10 && fabs(eta) < 1.479) bin = 0;
395	>	if (pt < 10 && fabs(eta) >= 1.479) bin = 1;
396	>	if (pt >= 10 && fabs(eta) < 1.479) bin = 2;
397	>	if (pt >= 10 && fabs(eta) >= 1.479) bin = 3;
398	>	}
399
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;
405	+	if (pt < 10 && fabs(eta) >= 1.479) bin = 2;
406	+	if (pt >= 10 && fabs(eta) < 0.8) bin = 3;
407	+	if (pt >= 10 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 4;
408	+	if (pt >= 10 && fabs(eta) >= 1.479) bin = 5;
409	+	}
410	+
411	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
412	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ||
413	+	fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
414	+	) {
415	+	bin = 0;
416	+	if (pt < 20 && fabs(eta) < 0.8) bin = 0;
417	+	if (pt < 20 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 1;
418	+	if (pt < 20 && fabs(eta) >= 1.479) bin = 2;
419	+	if (pt >= 20 && fabs(eta) < 0.8) bin = 3;
420	+	if (pt >= 20 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 4;
421	+	if (pt >= 20 && fabs(eta) >= 1.479) bin = 5;
422	+	}
423	+
424	+	return bin;
425		}
426
427
428	+
429		//--------------------------------------------------------------------------------------------------
430	<	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex) {
430	>	Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleEta,
431	>	Double_t EleSigmaIEtaIEta,
432	>	Double_t EleDEtaIn,
433	>	Double_t EleDPhiIn,
434	>	Double_t EleHoverE,
435	>	Double_t EleD0,
436	>	Double_t EleDZ,
437	>	Double_t EleFBrem,
438	>	Double_t EleEOverP,
439	>	Double_t EleESeedClusterOverPout,
440	>	Double_t EleSigmaIPhiIPhi,
441	>	Double_t EleNBrem,
442	>	Double_t EleOneOverEMinusOneOverP,
443	>	Double_t EleESeedClusterOverPIn,
444	>	Double_t EleIP3d,
445	>	Double_t EleIP3dSig
446	>	) {
447
448		if (!fIsInitialized) {
449		std::cout << "Error: ElectronIDMVA not properly initialized.\n";
450		return -9999;
451		}
452
453	<	Int_t subdet = 0;
454	<	if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
455	<	else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
456	<	else subdet = 2;
457	<	Int_t ptBin = 0;
458	<	if (ele->Pt() > 20.0) ptBin = 1;
453	>	//set all input variables
454	>	fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
455	>	fMVAVar_EleDEtaIn = EleDEtaIn;
456	>	fMVAVar_EleDPhiIn = EleDPhiIn;
457	>	fMVAVar_EleHoverE = EleHoverE;
458	>	fMVAVar_EleD0 = EleD0;
459	>	fMVAVar_EleDZ = EleDZ;
460	>	fMVAVar_EleFBrem = EleFBrem;
461	>	fMVAVar_EleEOverP = EleEOverP;
462	>	fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
463	>	fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
464	>	fMVAVar_EleNBrem = EleNBrem;
465	>	fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
466	>	fMVAVar_EleESeedClusterOverPIn = EleESeedClusterOverPIn;
467	>	fMVAVar_EleIP3d = EleIP3d;
468	>	fMVAVar_EleIP3dSig = EleIP3dSig;
469	>
470	>	Double_t mva = -9999;
471	>	TMVA::Reader *reader = 0;
472	>	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
473	>
474	>	mva = reader->EvaluateMVA( fMethodname );
475	>
476	>	return mva;
477	>	}
478	>
479	>	//--------------------------------------------------------------------------------------------------
480	>	Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleEta, Double_t PileupEnergyDensity,
481	>	Double_t EleSigmaIEtaIEta,
482	>	Double_t EleDEtaIn,
483	>	Double_t EleDPhiIn,
484	>	Double_t EleHoverE,
485	>	Double_t EleD0,
486	>	Double_t EleDZ,
487	>	Double_t EleFBrem,
488	>	Double_t EleEOverP,
489	>	Double_t EleESeedClusterOverPout,
490	>	Double_t EleSigmaIPhiIPhi,
491	>	Double_t EleNBrem,
492	>	Double_t EleOneOverEMinusOneOverP,
493	>	Double_t EleESeedClusterOverPIn,
494	>	Double_t EleIP3d,
495	>	Double_t EleIP3dSig,
496	>	Double_t EleGsfTrackChi2OverNdof,
497	>	Double_t EledEtaCalo,
498	>	Double_t EledPhiCalo,
499	>	Double_t EleR9,
500	>	Double_t EleSCEtaWidth,
501	>	Double_t EleSCPhiWidth,
502	>	Double_t EleCovIEtaIPhi,
503	>	Double_t ElePreShowerOverRaw,
504	>	Double_t EleChargedIso03,
505	>	Double_t EleNeutralHadronIso03,
506	>	Double_t EleGammaIso03,
507	>	Double_t EleChargedIso04,
508	>	Double_t EleNeutralHadronIso04,
509	>	Double_t EleGammaIso04,
510	>	Bool_t printDebug
511	>	) {
512
513	+	if (!fIsInitialized) {
514	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
515	+	return -9999;
516	+	}
517	+
518	+	Double_t Rho = 0;
519	+	if (!(TMath::IsNaN(PileupEnergyDensity) || isinf(PileupEnergyDensity))) Rho = PileupEnergyDensity;
520	+
521	+	//set all input variables
522	+	fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
523	+	fMVAVar_EleDEtaIn = EleDEtaIn;
524	+	fMVAVar_EleDPhiIn = EleDPhiIn;
525	+	fMVAVar_EleHoverE = EleHoverE;
526	+	fMVAVar_EleD0 = EleD0;
527	+	fMVAVar_EleDZ = EleDZ;
528	+	fMVAVar_EleFBrem = EleFBrem;
529	+	fMVAVar_EleEOverP = EleEOverP;
530	+	fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
531	+	fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
532	+	fMVAVar_EleNBrem = EleNBrem;
533	+	fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
534	+	fMVAVar_EleESeedClusterOverPIn = EleESeedClusterOverPIn;
535	+	fMVAVar_EleIP3d = EleIP3d;
536	+	fMVAVar_EleIP3dSig = EleIP3dSig;
537	+	fMVAVar_EleGsfTrackChi2OverNdof = EleGsfTrackChi2OverNdof;
538	+	fMVAVar_EledEtaCalo = EledEtaCalo;
539	+	fMVAVar_EledPhiCalo = EledPhiCalo;
540	+	fMVAVar_EleR9 = EleR9;
541	+	fMVAVar_EleSCEtaWidth = EleSCEtaWidth;
542	+	fMVAVar_EleSCPhiWidth = EleSCPhiWidth;
543	+	fMVAVar_EleCovIEtaIPhi = EleCovIEtaIPhi;
544	+	fMVAVar_ElePreShowerOverRaw = ElePreShowerOverRaw;
545	+	fMVAVar_EleChargedIso03OverPt
546	+	= (EleChargedIso03
547	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, EleEta)) / ElePt;
548	+	fMVAVar_EleNeutralHadronIso03OverPt
549	+	= (EleNeutralHadronIso03
550	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, EleEta)
551	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,EleEta)) / ElePt;
552	+	fMVAVar_EleGammaIso03OverPt
553	+	= (EleGammaIso03
554	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, EleEta)
555	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,EleEta))/ElePt;
556	+	fMVAVar_EleChargedIso04OverPt
557	+	= (EleChargedIso04
558	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso04, EleEta))/ElePt;
559	+	fMVAVar_EleNeutralHadronIso04OverPt
560	+	= (EleNeutralHadronIso04
561	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso04, EleEta)
562	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,EleEta))/ElePt;
563	+	fMVAVar_EleGammaIso04OverPt
564	+	= (EleGammaIso04
565	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, EleEta)
566	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,EleEta))/ElePt;
567	+
568	+
569	+
570	+
571	+	Double_t mva = -9999;
572	+	TMVA::Reader *reader = 0;
573	+	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
574	+	mva = reader->EvaluateMVA( fMethodname );
575	+
576	+	if (printDebug == kTRUE) {
577	+	std::cout << "Debug Electron MVA: "
578	+	<< ElePt << " " << EleEta << " " << " --> MVABin " << GetMVABin( EleEta, ElePt) << " : "
579	+	<< fMVAVar_EleSigmaIEtaIEta << " "
580	+	<< fMVAVar_EleDEtaIn << " "
581	+	<< fMVAVar_EleDPhiIn << " "
582	+	<< fMVAVar_EleHoverE << " "
583	+	<< fMVAVar_EleD0 << " "
584	+	<< fMVAVar_EleDZ << " "
585	+	<< fMVAVar_EleFBrem << " "
586	+	<< fMVAVar_EleEOverP << " "
587	+	<< fMVAVar_EleESeedClusterOverPout << " "
588	+	<< fMVAVar_EleSigmaIPhiIPhi << " "
589	+	<< fMVAVar_EleNBrem << " "
590	+	<< fMVAVar_EleOneOverEMinusOneOverP << " "
591	+	<< fMVAVar_EleESeedClusterOverPIn << " "
592	+	<< fMVAVar_EleIP3d << " "
593	+	<< fMVAVar_EleIP3dSig << " "
594	+	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
595	+	<< fMVAVar_EledEtaCalo << " "
596	+	<< fMVAVar_EledPhiCalo << " "
597	+	<< fMVAVar_EleR9 << " "
598	+	<< fMVAVar_EleSCEtaWidth << " "
599	+	<< fMVAVar_EleSCPhiWidth << " "
600	+	<< fMVAVar_EleCovIEtaIPhi << " "
601	+	<< fMVAVar_ElePreShowerOverRaw << " "
602	+	<< fMVAVar_EleChargedIso03OverPt  << " "
603	+	<< fMVAVar_EleNeutralHadronIso03OverPt  << " "
604	+	<< fMVAVar_EleGammaIso03OverPt  << " "
605	+	<< fMVAVar_EleChargedIso04OverPt  << " "
606	+	<< fMVAVar_EleNeutralHadronIso04OverPt  << " "
607	+	<< fMVAVar_EleGammaIso04OverPt  << " "
608	+	<< " === : === "
609	+	<< mva
610	+	<< std::endl;
611	+	}
612	+
613	+	return mva;
614	+	}
615	+
616	+	Double_t ElectronIDMVA::MVAValue_IsoRings( Double_t ElePt,
617	+	Double_t EleSCEta,
618	+	Double_t ChargedIso_DR0p0To0p1,
619	+	Double_t ChargedIso_DR0p1To0p2,
620	+	Double_t ChargedIso_DR0p2To0p3,
621	+	Double_t ChargedIso_DR0p3To0p4,
622	+	Double_t ChargedIso_DR0p4To0p5,
623	+	Double_t GammaIso_DR0p0To0p1,
624	+	Double_t GammaIso_DR0p1To0p2,
625	+	Double_t GammaIso_DR0p2To0p3,
626	+	Double_t GammaIso_DR0p3To0p4,
627	+	Double_t GammaIso_DR0p4To0p5,
628	+	Double_t NeutralHadronIso_DR0p0To0p1,
629	+	Double_t NeutralHadronIso_DR0p1To0p2,
630	+	Double_t NeutralHadronIso_DR0p2To0p3,
631	+	Double_t NeutralHadronIso_DR0p3To0p4,
632	+	Double_t NeutralHadronIso_DR0p4To0p5,
633	+	Bool_t printDebug) {
634	+
635	+	if (fMVAType != ElectronIDMVA::kIsoRingsV0) {
636	+	std::cout << "Error: This function is only supported for MVAType == kIsoRingsV0.\n" << std::endl;
637	+	assert(kFALSE);
638	+	}
639	+
640	+	fMVAVar_ElePt = ElePt;
641	+	fMVAVar_EleEta = EleSCEta;
642	+	fMVAVar_ChargedIso_DR0p0To0p1 = ChargedIso_DR0p0To0p1;
643	+	fMVAVar_ChargedIso_DR0p1To0p2 = ChargedIso_DR0p1To0p2;
644	+	fMVAVar_ChargedIso_DR0p2To0p3 = ChargedIso_DR0p2To0p3;
645	+	fMVAVar_ChargedIso_DR0p3To0p4 = ChargedIso_DR0p3To0p4;
646	+	fMVAVar_ChargedIso_DR0p4To0p5 = ChargedIso_DR0p4To0p5;
647	+	fMVAVar_GammaIso_DR0p0To0p1 = GammaIso_DR0p0To0p1;
648	+	fMVAVar_GammaIso_DR0p1To0p2 = GammaIso_DR0p1To0p2;
649	+	fMVAVar_GammaIso_DR0p2To0p3 = GammaIso_DR0p2To0p3;
650	+	fMVAVar_GammaIso_DR0p3To0p4 = GammaIso_DR0p3To0p4;
651	+	fMVAVar_GammaIso_DR0p4To0p5 = GammaIso_DR0p4To0p5;
652	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = NeutralHadronIso_DR0p0To0p1;
653	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = NeutralHadronIso_DR0p1To0p2;
654	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = NeutralHadronIso_DR0p2To0p3;
655	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = NeutralHadronIso_DR0p3To0p4;
656	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = NeutralHadronIso_DR0p4To0p5;
657	+
658	+	Double_t mva = -9999;
659	+	TMVA::Reader *reader = 0;
660	+
661	+	if (printDebug == kTRUE) {
662	+	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << std::endl;
663	+	}
664	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
665	+	mva = reader->EvaluateMVA( fMethodname );
666	+
667	+	if (printDebug == kTRUE) {
668	+
669	+	std::cout << "Debug Electron MVA-ISO: ";
670	+	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
671	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
672	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
673	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
674	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
675	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
676	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
677	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
678	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
679	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
680	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
681	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
682	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
683	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
684	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
685	+	<< std::endl;
686	+	std::cout << "MVA: " << mva << " "
687	+	<< std::endl;
688	+	}
689	+	return mva;
690	+	}
691	+
692	+	Double_t ElectronIDMVA::MVAValue_IDNonTrig( Double_t ElePt,
693	+	Double_t EleSCEta,
694	+	Double_t EleFBrem,
695	+	Double_t EleKFTrkChiSqr,
696	+	Double_t EleKFTrkNHits,
697	+	Double_t EleGsfTrackChi2OverNdof,
698	+	Double_t EleDEtaIn,
699	+	Double_t EleDPhiIn,
700	+	Double_t EledEtaCalo,
701	+	Double_t EleSigmaIEtaIEta,
702	+	Double_t EleSigmaIPhiIPhi,
703	+	Double_t EleSCEtaWidth,
704	+	Double_t EleSCPhiWidth,
705	+	Double_t EleE1x5OverE5x5,
706	+	Double_t EleR9,
707	+	Double_t EleHoverE,
708	+	Double_t EleEOverP,
709	+	Double_t EleOneOverEMinusOneOverP,
710	+	Double_t EleESeedClusterOverPout,
711	+	Double_t ElePreShowerOverRaw,
712	+	Bool_t printDebug) {
713	+
714	+	if (fMVAType != ElectronIDMVA::kIDEGamma2012NonTrigV0) {
715	+	std::cout << "Error: This function is only supported for MVAType == kIDEGamma2012NonTrigV0.\n" << std::endl;
716	+	assert(kFALSE);
717	+	}
718	+
719	+	fMVAVar_ElePt = ElePt;
720	+	fMVAVar_EleEta = EleSCEta;
721	+	fMVAVar_EleFBrem = EleFBrem;
722	+	fMVAVar_EleKFTrkChiSqr = EleKFTrkChiSqr;
723	+	fMVAVar_EleKFTrkNHits = EleKFTrkNHits;
724	+	fMVAVar_EleGsfTrackChi2OverNdof = EleGsfTrackChi2OverNdof;
725	+	fMVAVar_EleDEtaIn = EleDEtaIn;
726	+	fMVAVar_EleDPhiIn = EleDPhiIn;
727	+	fMVAVar_EledEtaCalo = EledEtaCalo;
728	+	fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
729	+	fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
730	+	fMVAVar_EleSCEtaWidth = EleSCEtaWidth;
731	+	fMVAVar_EleSCPhiWidth = EleSCPhiWidth;
732	+	fMVAVar_EleE1x5OverE5x5 = EleE1x5OverE5x5;
733	+	fMVAVar_EleR9 = EleR9;
734	+	fMVAVar_EleHoverE = EleHoverE;
735	+	fMVAVar_EleEOverP = EleEOverP;
736	+	fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
737	+	fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
738	+	fMVAVar_ElePreShowerOverRaw = ElePreShowerOverRaw;
739	+
740	+	Double_t mva = -9999;
741	+	TMVA::Reader *reader = 0;
742	+
743	+	if (printDebug == kTRUE) {
744	+	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << std::endl;
745	+	}
746	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
747	+	mva = reader->EvaluateMVA( fMethodname );
748	+
749	+	if (printDebug == kTRUE) {
750	+	std::cout << "Debug Electron MVA: ";
751	+	std::cout << " fbrem " <<  fMVAVar_EleFBrem
752	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
753	+	<< " kfhits " << fMVAVar_EleKFTrkNLayers
754	+	<< " kfhitsall " <<  fMVAVar_EleKFTrkNHits
755	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
756	+	<< " deta " <<  fMVAVar_EleDEtaIn
757	+	<< " dphi " << fMVAVar_EleDPhiIn
758	+	<< " detacalo " << fMVAVar_EledEtaCalo
759	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
760	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
761	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
762	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
763	+	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
764	+	<< " R9 " << fMVAVar_EleR9
765	+	<< " HoE " << fMVAVar_EleHoverE
766	+	<< " EoP " << fMVAVar_EleEOverP
767	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
768	+	<< " eleEoPout " << fMVAVar_EleESeedClusterOverPout
769	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
770	+	<< " d0 " << fMVAVar_EleD0
771	+	<< " ip3d " << fMVAVar_EleIP3d
772	+	<< " eta " << fMVAVar_EleEta
773	+	<< " pt " << fMVAVar_ElePt << std::endl;
774	+	std::cout << "MVA: " << mva << " "
775	+	<< std::endl;
776	+	}
777	+	return mva;
778	+	}
779	+
780	+	//--------------------------------------------------------------------------------------------------
781	+	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
782	+	const PFCandidateCol *PFCands,
783	+	const PileupEnergyDensityCol *PileupEnergyDensity,
784	+	Double_t intRadius,
785	+	Bool_t printDebug) {
786	+
787	+	if (!fIsInitialized) {
788	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
789	+	return -9999;
790	+	}
791	+
792	+	Double_t Rho = 0;
793	+	switch(fTheRhoType) {
794	+	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
795	+	Rho = PileupEnergyDensity->At(0)->Rho();
796	+	break;
797	+	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
798	+	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
799	+	break;
800	+	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
801	+	Rho = PileupEnergyDensity->At(0)->RhoRandom();
802	+	break;
803	+	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
804	+	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
805	+	break;
806	+	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
807	+	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
808	+	break;
809	+	default:
810	+	// use the old default
811	+	Rho = PileupEnergyDensity->At(0)->Rho();
812	+	break;
813	+	}
814	+
815		//set all input variables
816		fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
817		fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
#	Line 119 | 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->ESuperClusterOverP()*ele->BestTrk()->P())) - 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();
832	<	fMVAVar_EleStandardLikelihood = ElectronTools::Likelihood(fLH, ele);
832	>	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
833	>	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
834	>	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
835	>	fMVAVar_EleR9 = ele->SCluster()->R9();
836	>	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
837	>	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
838	>	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
839	>	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
840	>	fMVAVar_EleChargedIso03OverPt
841	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.3, intRadius)
842	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, ele->SCluster()->Eta())) / ele->Pt();
843	>	fMVAVar_EleNeutralHadronIso03OverPt
844	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, intRadius, PFCandidate::eNeutralHadron)
845	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, ele->SCluster()->Eta())
846	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt();
847	>	fMVAVar_EleGammaIso03OverPt
848	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, intRadius, PFCandidate::eGamma)
849	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, ele->SCluster()->Eta())
850	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,ele->SCluster()->Eta())) / ele->Pt();
851	>	fMVAVar_EleChargedIso04OverPt
852	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.4, intRadius)
853	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso04, ele->SCluster()->Eta())) / ele->Pt();
854	>	fMVAVar_EleNeutralHadronIso04OverPt
855	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, intRadius, PFCandidate::eNeutralHadron)
856	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso04, ele->SCluster()->Eta())
857	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt() ;
858	>	fMVAVar_EleGammaIso04OverPt
859	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, intRadius, PFCandidate::eGamma)
860	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, ele->SCluster()->Eta())
861	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,ele->SCluster()->Eta())) / ele->Pt();
862	>
863	>	//Additional vars
864	>	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
865	>	if (ele->TrackerTrk()) {
866	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
867	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
868	>	} else {
869	>	fMVAVar_EleKFTrkChiSqr = -1;
870	>	fMVAVar_EleKFTrkNHits = 0;
871	>	}
872	>	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
873	>
874
875		Double_t mva = -9999;
876		TMVA::Reader *reader = 0;
877	<	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	<
877	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
878		mva = reader->EvaluateMVA( fMethodname );
879
880	+	if (printDebug == kTRUE) {
881	+	std::cout << "Debug Electron MVA: "
882	+	<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
883	+	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
884	+	<< fMVAVar_EleSigmaIEtaIEta << " "
885	+	<< fMVAVar_EleDEtaIn << " "
886	+	<< fMVAVar_EleDPhiIn << " "
887	+	<< fMVAVar_EleHoverE << " "
888	+	<< fMVAVar_EleD0 << " "
889	+	<< fMVAVar_EleDZ << " "
890	+	<< fMVAVar_EleFBrem << " "
891	+	<< fMVAVar_EleEOverP << " "
892	+	<< fMVAVar_EleESeedClusterOverPout << " "
893	+	<< fMVAVar_EleSigmaIPhiIPhi << " "
894	+	<< fMVAVar_EleNBrem << " "
895	+	<< fMVAVar_EleOneOverEMinusOneOverP << " "
896	+	<< fMVAVar_EleESeedClusterOverPIn << " "
897	+	<< fMVAVar_EleIP3d << " "
898	+	<< fMVAVar_EleIP3dSig << " "
899	+	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
900	+	<< fMVAVar_EledEtaCalo << " "
901	+	<< fMVAVar_EledPhiCalo << " "
902	+	<< fMVAVar_EleR9 << " "
903	+	<< fMVAVar_EleSCEtaWidth << " "
904	+	<< fMVAVar_EleSCPhiWidth << " "
905	+	<< fMVAVar_EleCovIEtaIPhi << " "
906	+	<< fMVAVar_ElePreShowerOverRaw << " "
907	+	<< fMVAVar_EleKFTrkChiSqr  << " "
908	+	<< fMVAVar_EleKFTrkNHits  << " "
909	+	<< fMVAVar_EleE1x5OverE5x5  << " "
910	+	<< " ::: "
911	+
912	+	<< " === : === "
913	+	<< mva << " "
914	+	<< std::endl;
915	+
916	+	}
917	+
918		return mva;
919		}
920	+
921	+	//--------------------------------------------------------------------------------------------------
922	+	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
923	+	Bool_t printDebug) {
924	+
925	+	if (!fIsInitialized) {
926	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
927	+	return -9999;
928	+	}
929	+
930	+	fMVAVar_ElePt = ele->Pt();
931	+	fMVAVar_EleEta = ele->Eta();
932	+
933	+	//set all input variables
934	+	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
935	+	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
936	+	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
937	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
938	+	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
939	+	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
940	+	fMVAVar_EleFBrem = ele->FBrem();
941	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
942	+	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
943	+	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
944	+	else fMVAVar_EleSigmaIPhiIPhi = 0;
945	+	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
946	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
947	+	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
948	+	fMVAVar_EleIP3d = ele->Ip3dPV();
949	+	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
950	+
951	+
952	+	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
953	+	if (ele->TrackerTrk()) {
954	+	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
955	+	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
956	+	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
957	+	} else {
958	+	fMVAVar_EleKFTrkChiSqr = -1;
959	+	fMVAVar_EleKFTrkNHits = 0;
960	+	fMVAVar_EleKFTrkNLayers = 0;
961	+	}
962	+	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
963	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
964	+	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
965	+	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
966	+	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
967	+	fMVAVar_EleR9 = ele->SCluster()->R9();
968	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
969	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
970	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
971	+	fMVAVar_EleR9 = ele->SCluster()->R9();
972	+	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
973	+
974	+
975	+	Double_t mva = -9999;
976	+	TMVA::Reader *reader = 0;
977	+	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
978	+	mva = reader->EvaluateMVA( fMethodname );
979	+
980	+	if (printDebug == kTRUE) {
981	+	std::cout << "Debug Electron MVA: "
982	+	<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
983	+	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
984	+	<< fMVAVar_EleSigmaIEtaIEta << " "
985	+	<< fMVAVar_EleDEtaIn << " "
986	+	<< fMVAVar_EleDPhiIn << " "
987	+	<< fMVAVar_EleHoverE << " "
988	+	<< fMVAVar_EleD0 << " "
989	+	<< fMVAVar_EleDZ << " "
990	+	<< fMVAVar_EleFBrem << " "
991	+	<< fMVAVar_EleEOverP << " "
992	+	<< fMVAVar_EleESeedClusterOverPout << " "
993	+	<< fMVAVar_EleSigmaIPhiIPhi << " "
994	+	<< fMVAVar_EleNBrem << " "
995	+	<< fMVAVar_EleOneOverEMinusOneOverP << " "
996	+	<< fMVAVar_EleESeedClusterOverPIn << " "
997	+	<< fMVAVar_EleIP3d << " "
998	+	<< fMVAVar_EleIP3dSig << " "
999	+	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
1000	+	<< fMVAVar_EledEtaCalo << " "
1001	+	<< fMVAVar_EledPhiCalo << " "
1002	+	<< fMVAVar_EleR9 << " "
1003	+	<< fMVAVar_EleSCEtaWidth << " "
1004	+	<< fMVAVar_EleSCPhiWidth << " "
1005	+	<< fMVAVar_EleCovIEtaIPhi << " "
1006	+	<< fMVAVar_ElePreShowerOverRaw << " "
1007	+	<< fMVAVar_EleKFTrkChiSqr  << " "
1008	+	<< fMVAVar_EleKFTrkNHits  << " "
1009	+	<< fMVAVar_EleE1x5OverE5x5  << " "
1010	+	<< " === : === "
1011	+	<< mva << " "
1012	+	<< std::endl;
1013	+
1014	+	}
1015	+
1016	+
1017	+
1018	+	return mva;
1019	+	}
1020	+
1021	+
1022	+	//--------------------------------------------------------------------------------------------------
1023	+	//MVA Includes Isolation with removal of other leptons
1024	+	//
1025	+	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
1026	+	const PFCandidateCol *PFCands,
1027	+	const PileupEnergyDensityCol *PileupEnergyDensity,
1028	+	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaTarget,
1029	+	const ElectronCol *goodElectrons,
1030	+	const MuonCol *goodMuons,
1031	+	Bool_t printDebug) {
1032	+
1033	+	if (!fIsInitialized) {
1034	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
1035	+	return -9999;
1036	+	}
1037	+
1038	+	Double_t Rho = 0;
1039	+	switch(fTheRhoType) {
1040	+	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
1041	+	Rho = PileupEnergyDensity->At(0)->Rho();
1042	+	break;
1043	+	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
1044	+	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
1045	+	break;
1046	+	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
1047	+	Rho = PileupEnergyDensity->At(0)->RhoRandom();
1048	+	break;
1049	+	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
1050	+	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
1051	+	break;
1052	+	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
1053	+	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
1054	+	break;
1055	+	default:
1056	+	// use the old default
1057	+	Rho = PileupEnergyDensity->At(0)->Rho();
1058	+	break;
1059	+	}
1060	+
1061	+	//set all input variables
1062	+	fMVAVar_ElePt = ele->Pt();
1063	+	fMVAVar_EleEta = ele->SCluster()->Eta();
1064	+	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
1065	+
1066	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1067	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1068	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1069	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
1070	+	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
1071	+	fMVAVar_EleDPhiIn = TMath::Min(fabs(double(ele->DeltaPhiSuperClusterTrackAtVtx())),0.6);
1072	+	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
1073	+	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
1074	+	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
1075	+	fMVAVar_EleEEleClusterOverPout = TMath::Min(double(ele->EEleClusterOverPout()),20.0);
1076	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->P();
1077	+	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
1078	+	fMVAVar_EledEtaCalo =  TMath::Min(fabs(double(ele->DeltaEtaSeedClusterTrackAtCalo())),0.2);
1079	+	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
1080	+	} else {
1081	+	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
1082	+	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
1083	+	fMVAVar_EleFBrem = ele->FBrem();
1084	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
1085	+	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
1086	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
1087	+	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
1088	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1089	+	fMVAVar_EleR9 = ele->SCluster()->R9();
1090	+	}
1091	+
1092	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
1093	+	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
1094	+	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
1095	+	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
1096	+	else {
1097	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1) {
1098	+	fMVAVar_EleSigmaIPhiIPhi = 0;
1099	+	} else {
1100	+	fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
1101	+	}
1102	+	}
1103	+
1104	+	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
1105	+	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
1106	+	fMVAVar_EleIP3d = ele->Ip3dPV();
1107	+	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
1108	+	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
1109	+	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
1110	+	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
1111	+	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
1112	+	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
1113	+
1114	+	//Additional vars
1115	+	if (ele->TrackerTrk()) {
1116	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1117	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1118	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1119	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
1120	+	fMVAVar_EleKFTrkChiSqr = TMath::Min(double(ele->TrackerTrk()->RChi2()),10.0);
1121	+	} else {
1122	+	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
1123	+	}
1124	+	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
1125	+	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
1126	+	} else {
1127	+	fMVAVar_EleKFTrkChiSqr = 0;
1128	+	fMVAVar_EleKFTrkNHits = -1;
1129	+	fMVAVar_EleKFTrkNLayers = -1;
1130	+	}
1131	+
1132	+	if( ele->SCluster()->Seed()->E5x5() > 0.0 ) {
1133	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1134	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1135	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1136	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
1137	+	fMVAVar_EleE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1138	+	} else {
1139	+	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5();
1140	+	}
1141	+	} else {
1142	+	fMVAVar_EleE1x5OverE5x5 = -1.0;
1143	+	}
1144	+
1145	+
1146	+	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1147	+	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1148	+	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1149	+	Double_t tmpChargedIso_DR0p3To0p4  = 0;
1150	+	Double_t tmpChargedIso_DR0p4To0p5  = 0;
1151	+	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1152	+	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1153	+	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1154	+	Double_t tmpGammaIso_DR0p3To0p4  = 0;
1155	+	Double_t tmpGammaIso_DR0p4To0p5  = 0;
1156	+	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1157	+	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1158	+	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1159	+	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1160	+	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1161	+
1162	+	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
1163	+	const PFCandidate *pf = PFCands->At(p);
1164	+
1165	+	//exclude the electron itself
1166	+	if(pf->GsfTrk() && ele->GsfTrk() &&
1167	+	pf->GsfTrk() == ele->GsfTrk()) continue;
1168	+	if(pf->TrackerTrk() && ele->TrackerTrk() &&
1169	+	pf->TrackerTrk() == ele->TrackerTrk()) continue;
1170	+
1171	+	//************************************************************
1172	+	// New Isolation Calculations
1173	+	//************************************************************
1174	+	Double_t dr = MathUtils::DeltaR(ele->Mom(), pf->Mom());
1175	+
1176	+	if (dr < 1.0) {
1177	+	Bool_t IsLeptonFootprint = kFALSE;
1178	+	//************************************************************
1179	+	// Lepton Footprint Removal
1180	+	//************************************************************
1181	+	if(goodElectrons) {
1182	+	for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) {
1183	+	//if pf candidate matches an electron passing ID cuts, then veto it
1184	+	if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() &&
1185	+	pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE;
1186	+	if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() &&
1187	+	pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1188	+	//if pf candidate lies in veto regions of electron passing ID cuts, then veto it
1189	+	if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479
1190	+	&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE;
1191	+	if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 &&
1192	+	MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE;
1193	+	}
1194	+	}
1195	+	if(goodMuons) {
1196	+	for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) {
1197	+	//if pf candidate matches an muon passing ID cuts, then veto it
1198	+	if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() &&
1199	+	pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1200	+	//if pf candidate lies in veto regions of muon passing ID cuts, then veto it
1201	+	if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE;
1202	+	}
1203	+	}
1204	+
1205	+	if (!IsLeptonFootprint) {
1206	+	Bool_t passVeto = kTRUE;
1207	+	//Charged
1208	+	if(pf->BestTrk()) {
1209	+	if (!(fabs(pf->BestTrk()->DzCorrected(*vertex) - ele->BestTrk()->DzCorrected(*vertex)) < 0.2)) passVeto = kFALSE;
1210	+	//************************************************************
1211	+	// Veto any PFmuon, or PFEle
1212	+	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
1213	+	//************************************************************
1214	+	//************************************************************
1215	+	// Footprint Veto
1216	+	if (fabs(ele->SCluster()->Eta()) >= 1.479 && dr < 0.015) passVeto = kFALSE;
1217	+	//************************************************************
1218	+	if (passVeto) {
1219	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1220	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1221	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1222	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1223	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1224	+	} //pass veto
1225	+
1226	+	}
1227	+	//Gamma
1228	+	else if (pf->PFType() == PFCandidate::eGamma) {
1229	+	//************************************************************
1230	+	// Footprint Veto
1231	+	if (fabs(ele->SCluster()->Eta()) >= 1.479) {
1232	+	if (dr < 0.08) passVeto = kFALSE;
1233	+	}
1234	+	//************************************************************
1235	+
1236	+	if (passVeto) {
1237	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1238	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1239	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1240	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1241	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1242	+	}
1243	+	}
1244	+	//NeutralHadron
1245	+	else {
1246	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1247	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1248	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1249	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1250	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1251	+	}
1252	+	} //not lepton footprint
1253	+	} //in 1.0 dr cone
1254	+	} //loop over PF candidates
1255	+
1256	+	fMVAVar_ChargedIso_DR0p0To0p1   = TMath::Min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1257	+	fMVAVar_ChargedIso_DR0p1To0p2   = TMath::Min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1258	+	fMVAVar_ChargedIso_DR0p2To0p3 = TMath::Min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1259	+	fMVAVar_ChargedIso_DR0p3To0p4 = TMath::Min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1260	+	fMVAVar_ChargedIso_DR0p4To0p5 = TMath::Min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1261	+	fMVAVar_GammaIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpGammaIso_DR0p0To0p1 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p0To0p1, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1262	+	fMVAVar_GammaIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpGammaIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1263	+	fMVAVar_GammaIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpGammaIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1264	+	fMVAVar_GammaIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpGammaIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1265	+	fMVAVar_GammaIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpGammaIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1266	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p0To0p1 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p0To0p1, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1267	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1268	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1269	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1270	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1271	+
1272	+	//Do Binding of MVA input variables
1273	+	if (   fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1274	+	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
1275	+	|| fMVAType == ElectronIDMVA::kIsoRingsV0
1276	+	|| fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
1277	+	bindVariables();
1278	+	}
1279	+
1280	+	Double_t mva = -9999;
1281	+	TMVA::Reader *reader = 0;
1282	+
1283	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
1284	+	mva = reader->EvaluateMVA( fMethodname );
1285	+
1286	+	if (printDebug == kTRUE) {
1287	+
1288	+	std::cout << "Debug Electron MVA-ID: "
1289	+	<< fMVAVar_ElePt<< " " << fMVAVar_EleEta << " "
1290	+	<< " --> MVABin " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << " : "
1291	+	<< " fbrem " <<  fMVAVar_EleFBrem
1292	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
1293	+	<< " kfhits " << fMVAVar_EleKFTrkNLayers
1294	+	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1295	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
1296	+	<< " deta " <<  fMVAVar_EleDEtaIn
1297	+	<< " dphi " << fMVAVar_EleDPhiIn
1298	+	<< " detacalo " << fMVAVar_EledEtaCalo
1299	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
1300	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
1301	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
1302	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
1303	+	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
1304	+	<< " R9 " << fMVAVar_EleR9
1305	+	<< " HoE " << fMVAVar_EleHoverE
1306	+	<< " EoP " << fMVAVar_EleEOverP
1307	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
1308	+	<< " eleEoPout " << fMVAVar_EleEEleClusterOverPout
1309	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
1310	+	<< " PreShowerOverRaw" << fMVAVar_ElePreShowerOverRaw
1311	+	<< " d0 " << fMVAVar_EleD0
1312	+	<< " ip3d " << fMVAVar_EleIP3d
1313	+	<< " eta " << fMVAVar_EleEta
1314	+	<< " pt " << fMVAVar_ElePt
1315	+	<< " === : === "
1316	+	<< mva << " "
1317	+	<< std::endl;
1318	+	std::cout << "Debug Electron MVA-ISO: "
1319	+	<< fMVAVar_ChargedIso_DR0p0To0p1 << " "
1320	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1321	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1322	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
1323	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
1324	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
1325	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
1326	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
1327	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
1328	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
1329	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
1330	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
1331	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
1332	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1333	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
1334	+	<< std::endl;
1335	+	}
1336	+
1337	+	return mva;
1338	+	}
1339	+
1340	+
1341	+	//--------------------------------------------------------------------------------------------------
1342	+	//MVA Includes Isolation
1343	+	//
1344	+	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
1345	+	const VertexCol *primaryVertices,
1346	+	const PFCandidateCol *PFCands,
1347	+	const PileupEnergyDensityCol *PileupEnergyDensity,
1348	+	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaTarget,
1349	+	Bool_t printDebug) {
1350	+
1351	+	if (!fIsInitialized) {
1352	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
1353	+	return -9999;
1354	+	}
1355	+
1356	+	Double_t Rho = 0;
1357	+	switch(fTheRhoType) {
1358	+	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
1359	+	Rho = PileupEnergyDensity->At(0)->Rho();
1360	+	break;
1361	+	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
1362	+	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
1363	+	break;
1364	+	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
1365	+	Rho = PileupEnergyDensity->At(0)->RhoRandom();
1366	+	break;
1367	+	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
1368	+	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
1369	+	break;
1370	+	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
1371	+	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
1372	+	break;
1373	+	default:
1374	+	// use the old default
1375	+	Rho = PileupEnergyDensity->At(0)->Rho();
1376	+	break;
1377	+	}
1378	+
1379	+	//set all input variables
1380	+	fMVAVar_ElePt = ele->Pt();
1381	+	fMVAVar_EleEta = ele->SCluster()->Eta();
1382	+	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
1383	+
1384	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1385	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1386	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1387	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0
1388	+	) {
1389	+	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
1390	+	fMVAVar_EleDPhiIn = TMath::Min(fabs(double(ele->DeltaPhiSuperClusterTrackAtVtx())),0.6);
1391	+	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
1392	+	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
1393	+	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
1394	+	fMVAVar_EleEEleClusterOverPout = TMath::Min(double(ele->EEleClusterOverPout()),20.0);
1395	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->P();
1396	+	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
1397	+	fMVAVar_EledEtaCalo =  TMath::Min(fabs(double(ele->DeltaEtaSeedClusterTrackAtCalo())),0.2);
1398	+	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
1399	+	}
1400	+	else if (fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4) {
1401	+	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
1402	+	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
1403	+	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
1404	+	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
1405	+	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
1406	+	fMVAVar_EleEEleClusterOverPout = TMath::Min(double(ele->EEleClusterOverPout()),20.0);
1407	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->PIn();
1408	+	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
1409	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1410	+	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
1411	+	}
1412	+	else {
1413	+	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
1414	+	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
1415	+	fMVAVar_EleFBrem = ele->FBrem();
1416	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
1417	+	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
1418	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
1419	+	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
1420	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1421	+	fMVAVar_EleR9 = ele->SCluster()->R9();
1422	+	}
1423	+
1424	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
1425	+	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
1426	+	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
1427	+	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
1428	+	else {
1429	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ) {
1430	+	fMVAVar_EleSigmaIPhiIPhi = 0;
1431	+	} else {
1432	+	fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
1433	+	}
1434	+	}
1435	+
1436	+	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
1437	+	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
1438	+	fMVAVar_EleIP3d = ele->Ip3dPV();
1439	+	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
1440	+	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
1441	+	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
1442	+	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
1443	+	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
1444	+	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
1445	+
1446	+	//Additional vars
1447	+	if (ele->TrackerTrk()) {
1448	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1449	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1450	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1451	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ||
1452	+	fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
1453	+	) {
1454	+	fMVAVar_EleKFTrkChiSqr = TMath::Min(double(ele->TrackerTrk()->RChi2()),10.0);
1455	+	} else {
1456	+	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
1457	+	}
1458	+	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
1459	+	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
1460	+	} else {
1461	+	fMVAVar_EleKFTrkChiSqr = 0;
1462	+	fMVAVar_EleKFTrkNHits = -1;
1463	+	fMVAVar_EleKFTrkNLayers = -1;
1464	+	}
1465	+
1466	+	if( ele->SCluster()->Seed()->E5x5() > 0.0 ) {
1467	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1468	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1469	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1470	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ||
1471	+	fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
1472	+	) {
1473	+	fMVAVar_EleE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1474	+	fMVAVar_EleOneMinusE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1475	+	} else {
1476	+	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5();
1477	+	}
1478	+	} else {
1479	+	fMVAVar_EleE1x5OverE5x5 = -1.0;
1480	+	}
1481	+
1482	+
1483	+	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1484	+	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1485	+	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1486	+	Double_t tmpChargedIso_DR0p3To0p4  = 0;
1487	+	Double_t tmpChargedIso_DR0p4To0p5  = 0;
1488	+	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1489	+	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1490	+	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1491	+	Double_t tmpGammaIso_DR0p3To0p4  = 0;
1492	+	Double_t tmpGammaIso_DR0p4To0p5  = 0;
1493	+	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1494	+	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1495	+	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1496	+	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1497	+	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1498	+
1499	+	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
1500	+	const PFCandidate *pf = PFCands->At(p);
1501	+
1502	+	//************************************************************
1503	+	// New Isolation Calculations
1504	+	//************************************************************
1505	+	Double_t dr = MathUtils::DeltaR(ele->Mom(), pf->Mom());
1506	+
1507	+	if (dr < 0.5) {
1508	+
1509	+	Bool_t passVeto = kTRUE;
1510	+	//Charged
1511	+	if(pf->BestTrk()) {
1512	+
1513	+	//*************************************************
1514	+	//Use only PFNoPU
1515	+	//*************************************************
1516	+	Bool_t isPFNoPU = kFALSE;
1517	+	if(pf->PFType() == PFCandidate::eHadron) {
1518	+	if(pf->HasTrackerTrk() &&
1519	+	primaryVertices->At(0)->HasTrack(pf->TrackerTrk()) &&
1520	+	primaryVertices->At(0)->TrackWeight(pf->TrackerTrk()) > 0) {
1521	+	isPFNoPU = kTRUE;
1522	+	} else {
1523	+
1524	+	Bool_t vertexFound = kFALSE;
1525	+	const Vertex *closestVtx = 0;
1526	+	Double_t dzmin = 10000;
1527	+
1528	+	// loop over vertices
1529	+	for(UInt_t j = 0; j < primaryVertices->GetEntries(); j++) {
1530	+	const Vertex *vtx = primaryVertices->At(j);
1531	+	assert(vtx);
1532	+
1533	+	if(pf->HasTrackerTrk() &&
1534	+	vtx->HasTrack(pf->TrackerTrk()) &&
1535	+	vtx->TrackWeight(pf->TrackerTrk()) > 0) {
1536	+	vertexFound = kTRUE;
1537	+	closestVtx = vtx;
1538	+	break;
1539	+	}
1540	+	Double_t dz = fabs(pf->SourceVertex().Z() - vtx->Z());
1541	+	if(dz < dzmin) {
1542	+	closestVtx = vtx;
1543	+	dzmin = dz;
1544	+	}
1545	+	}
1546	+
1547	+	Bool_t fCheckClosestZVertex = kTRUE; //we use option 1
1548	+	if(fCheckClosestZVertex) {
1549	+	// Fallback: if track is not associated with any vertex,
1550	+	// associate it with the vertex closest in z
1551	+	if(vertexFound || closestVtx != vertex) {
1552	+	isPFNoPU = kFALSE;
1553	+	} else {
1554	+	isPFNoPU = kTRUE;
1555	+	}
1556	+	} else {
1557	+	if(vertexFound && closestVtx != vertex) {
1558	+	isPFNoPU = kFALSE;
1559	+	} else {
1560	+	isPFNoPU = kTRUE;
1561	+	}
1562	+	}
1563	+	} //hadron & trk stuff
1564	+	} else { // hadron
1565	+	//
1566	+	isPFNoPU = kTRUE;
1567	+	}
1568	+	if (!isPFNoPU) continue;
1569	+
1570	+	//************************************************************
1571	+	// Veto any PFmuon, or PFEle
1572	+	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
1573	+	//************************************************************
1574	+	//************************************************************
1575	+	// Footprint Veto
1576	+	if (fabs(ele->SCluster()->Eta()) >= 1.479 && dr < 0.015) passVeto = kFALSE;
1577	+	//************************************************************
1578	+	if (passVeto) {
1579	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1580	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1581	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1582	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1583	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1584	+	} //pass veto
1585	+
1586	+	}
1587	+	//Gamma
1588	+	else if (pf->PFType() == PFCandidate::eGamma) {
1589	+	//************************************************************
1590	+	// Footprint Veto
1591	+	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1592	+	if (dr < 0.08) passVeto = kFALSE;
1593	+	}
1594	+	//************************************************************
1595	+
1596	+	if (passVeto) {
1597	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1598	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1599	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1600	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1601	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1602	+	}
1603	+	}
1604	+	//NeutralHadron
1605	+	else {
1606	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1607	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1608	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1609	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1610	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1611	+	}
1612	+	} //in 1.0 dr cone
1613	+	} //loop over PF candidates
1614	+
1615	+	fMVAVar_ChargedIso_DR0p0To0p1   = tmpChargedIso_DR0p0To0p1/ele->Pt();
1616	+	fMVAVar_ChargedIso_DR0p1To0p2   = tmpChargedIso_DR0p1To0p2/ele->Pt();
1617	+	fMVAVar_ChargedIso_DR0p2To0p3 = tmpChargedIso_DR0p2To0p3/ele->Pt();
1618	+	fMVAVar_ChargedIso_DR0p3To0p4 = tmpChargedIso_DR0p3To0p4/ele->Pt();
1619	+	fMVAVar_ChargedIso_DR0p4To0p5 = tmpChargedIso_DR0p4To0p5/ele->Pt();
1620	+	fMVAVar_GammaIso_DR0p0To0p1 = tmpGammaIso_DR0p0To0p1/ele->Pt();
1621	+	fMVAVar_GammaIso_DR0p1To0p2 = tmpGammaIso_DR0p1To0p2/ele->Pt();
1622	+	fMVAVar_GammaIso_DR0p2To0p3 = tmpGammaIso_DR0p2To0p3/ele->Pt();
1623	+	fMVAVar_GammaIso_DR0p3To0p4 = tmpGammaIso_DR0p3To0p4/ele->Pt();
1624	+	fMVAVar_GammaIso_DR0p4To0p5 = tmpGammaIso_DR0p4To0p5/ele->Pt();
1625	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = tmpNeutralHadronIso_DR0p0To0p1/ele->Pt();
1626	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = tmpNeutralHadronIso_DR0p1To0p2/ele->Pt();
1627	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = tmpNeutralHadronIso_DR0p2To0p3/ele->Pt();
1628	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = tmpNeutralHadronIso_DR0p3To0p4/ele->Pt();
1629	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = tmpNeutralHadronIso_DR0p4To0p5/ele->Pt();
1630	+	fMVAVar_Rho = Rho;
1631	+
1632	+	//Do Binding of MVA input variables
1633	+	if (   fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1634	+	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
1635	+	|| fMVAType == ElectronIDMVA::kIsoRingsV0
1636	+	|| fMVAType == ElectronIDMVA::kIDHWW2012TrigV0
1637	+	) {
1638	+	bindVariables();
1639	+	}
1640	+
1641	+	Double_t mva = -9999;
1642	+	TMVA::Reader *reader = 0;
1643	+
1644	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
1645	+	mva = reader->EvaluateMVA( fMethodname );
1646	+
1647	+	if (printDebug == kTRUE) {
1648	+
1649	+	std::cout << "Debug Electron MVA-ID: "
1650	+	<< fMVAVar_ElePt<< " " << fMVAVar_EleEta << " "
1651	+	<< " --> MVABin " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << " : "
1652	+	<< " fbrem " <<  fMVAVar_EleFBrem
1653	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
1654	+	<< " kfhits " << fMVAVar_EleKFTrkNLayers
1655	+	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1656	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
1657	+	<< " deta " <<  fMVAVar_EleDEtaIn
1658	+	<< " dphi " << fMVAVar_EleDPhiIn
1659	+	<< " detacalo " << fMVAVar_EledEtaCalo
1660	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
1661	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
1662	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
1663	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
1664	+	<< " e1x5e5x5 " << fMVAVar_EleOneMinusE1x5OverE5x5
1665	+	<< " R9 " << fMVAVar_EleR9
1666	+	<< " HoE " << fMVAVar_EleHoverE
1667	+	<< " EoP " << fMVAVar_EleEOverP
1668	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
1669	+	<< " eleEoPout " << fMVAVar_EleEEleClusterOverPout
1670	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
1671	+	<< " PreShowerOverRaw" << fMVAVar_ElePreShowerOverRaw
1672	+	<< " d0 " << fMVAVar_EleD0
1673	+	<< " ip3d " << fMVAVar_EleIP3d
1674	+	<< " eta " << fMVAVar_EleEta
1675	+	<< " pt " << fMVAVar_ElePt
1676	+	<< " === : === "
1677	+	<< mva << " "
1678	+	<< std::endl;
1679	+	std::cout << "Debug Electron MVA-ISO: "
1680	+	<< fMVAVar_ChargedIso_DR0p0To0p1 << " "
1681	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1682	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1683	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
1684	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
1685	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
1686	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
1687	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
1688	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
1689	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
1690	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
1691	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
1692	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
1693	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1694	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
1695	+	<< fMVAVar_Rho << " "
1696	+	<< std::endl;
1697	+	}
1698	+
1699	+	return mva;
1700	+	}
1701	+
1702	+
1703	+	void ElectronIDMVA::bindVariables() {
1704	+
1705	+	// this binding is needed for variables that sometime diverge.
1706	+
1707	+	if(fMVAVar_EleFBrem < -1.)
1708	+	fMVAVar_EleFBrem = -1.;
1709	+
1710	+	fMVAVar_EleDEtaIn = fabs(fMVAVar_EleDEtaIn);
1711	+	if(fMVAVar_EleDEtaIn > 0.06)
1712	+	fMVAVar_EleDEtaIn = 0.06;
1713	+
1714	+
1715	+	fMVAVar_EleDPhiIn = fabs(fMVAVar_EleDPhiIn);
1716	+	if(fMVAVar_EleDPhiIn > 0.6)
1717	+	fMVAVar_EleDPhiIn = 0.6;
1718	+
1719	+
1720	+	if(fMVAVar_EleESeedClusterOverPout > 20.)
1721	+	fMVAVar_EleESeedClusterOverPout = 20.;
1722	+
1723	+	if(fMVAVar_EleEOverP > 20.)
1724	+	fMVAVar_EleEOverP = 20.;
1725	+
1726	+	if(fMVAVar_EleEEleClusterOverPout > 20.)
1727	+	fMVAVar_EleEEleClusterOverPout = 20.;
1728	+
1729	+
1730	+	fMVAVar_EledEtaCalo = fabs(fMVAVar_EledEtaCalo);
1731	+	if(fMVAVar_EledEtaCalo > 0.2)
1732	+	fMVAVar_EledEtaCalo = 0.2;
1733	+
1734	+
1735	+	if(fMVAVar_EleE1x5OverE5x5 < -1.)
1736	+	fMVAVar_EleE1x5OverE5x5 = -1;
1737	+
1738	+	if(fMVAVar_EleE1x5OverE5x5 > 2.)
1739	+	fMVAVar_EleE1x5OverE5x5 = 2.;
1740	+
1741	+
1742	+
1743	+	if(fMVAVar_EleR9 > 5)
1744	+	fMVAVar_EleR9 = 5;
1745	+
1746	+	if(fMVAVar_EleGsfTrackChi2OverNdof > 200.)
1747	+	fMVAVar_EleGsfTrackChi2OverNdof = 200;
1748	+
1749	+
1750	+	if(fMVAVar_EleKFTrkChiSqr > 10.)
1751	+	fMVAVar_EleKFTrkChiSqr = 10.;
1752	+
1753	+	// Needed for a bug in CMSSW_420, fixed in more recent CMSSW versions
1754	+	if(std::isnan(fMVAVar_EleSigmaIPhiIPhi))
1755	+	fMVAVar_EleSigmaIPhiIPhi = 0.;
1756	+
1757	+
1758	+	return;
1759	+	}

Diff Legend

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