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.26 by sixie, Sun Jul 22 20:33:27 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	<	fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );
336	<	fTMVAReader[i]->SetVerbose(kTRUE);
337	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
338	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
339	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
340	<	fTMVAReader[i]->AddVariable( "HoverE",                &fMVAVar_EleHoverE                );
341	<	fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                    );
342	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
343	<	fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                );
344	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout  );
345	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
346	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
347	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );
348	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn   );
349	<	fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                  );
350	<	fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig               );
351	<	fTMVAReader[i]->AddVariable( "StandardLikelihood",    &fMVAVar_EleStandardLikelihood    );
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	<	if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To20Weights );
354	<	if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To20Weights );
355	<	if (i==2) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt10To20Weights );
356	<	if (i==3) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt20ToInfWeights );
357	<	if (i==4) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt20ToInfWeights );
358	<	if (i==5) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt20ToInfWeights );
353	>	//spectators
354	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
355	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
356	>
357	>	}
358	>
359	>
360	>	tmpTMVAReader->BookMVA(fMethodname , weightsfiles[i] );
361	>	std::cout << "MVABin " << i << " : MethodName = " << fMethodname
362	>	<< " , type == " << type << " , "
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	<	std::cout << "Electron ID MVA Initialization\n";
382	<	std::cout << "MethodName : " << fMethodname << std::endl;
383	<	std::cout << "Load weights file : " << Subdet0Pt10To20Weights << std::endl;
384	<	std::cout << "Load weights file : " << Subdet1Pt10To20Weights << std::endl;
385	<	std::cout << "Load weights file : " << Subdet2Pt10To20Weights << std::endl;
386	<	std::cout << "Load weights file : " << Subdet0Pt20ToInfWeights << std::endl;
387	<	std::cout << "Load weights file : " << Subdet1Pt20ToInfWeights << std::endl;
388	<	std::cout << "Load weights file : " << Subdet2Pt20ToInfWeights << std::endl;
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	+	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(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	+	//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(const Electron *ele, const Vertex *vertex) {
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	<	Int_t subdet = 0;
519	<	if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
520	<	else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
521	<	else subdet = 2;
522	<	Int_t ptBin = 0;
523	<	if (ele->Pt() > 20.0) ptBin = 1;
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 = ele->CoviEtaiEta();
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	+	} else {
957	+	fMVAVar_EleKFTrkChiSqr = -1;
958	+	fMVAVar_EleKFTrkNHits = 0;
959	+	}
960	+	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
961	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
962	+	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
963	+	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
964	+	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
965	+	fMVAVar_EleR9 = ele->SCluster()->R9();
966	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
967	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
968	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
969	+	fMVAVar_EleR9 = ele->SCluster()->R9();
970	+	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
971	+
972	+
973	+	Double_t mva = -9999;
974	+	TMVA::Reader *reader = 0;
975	+	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
976	+	mva = reader->EvaluateMVA( fMethodname );
977	+
978	+	if (printDebug == kTRUE) {
979	+	std::cout << "Debug Electron MVA: "
980	+	<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
981	+	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
982	+	<< fMVAVar_EleSigmaIEtaIEta << " "
983	+	<< fMVAVar_EleDEtaIn << " "
984	+	<< fMVAVar_EleDPhiIn << " "
985	+	<< fMVAVar_EleHoverE << " "
986	+	<< fMVAVar_EleD0 << " "
987	+	<< fMVAVar_EleDZ << " "
988	+	<< fMVAVar_EleFBrem << " "
989	+	<< fMVAVar_EleEOverP << " "
990	+	<< fMVAVar_EleESeedClusterOverPout << " "
991	+	<< fMVAVar_EleSigmaIPhiIPhi << " "
992	+	<< fMVAVar_EleNBrem << " "
993	+	<< fMVAVar_EleOneOverEMinusOneOverP << " "
994	+	<< fMVAVar_EleESeedClusterOverPIn << " "
995	+	<< fMVAVar_EleIP3d << " "
996	+	<< fMVAVar_EleIP3dSig << " "
997	+	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
998	+	<< fMVAVar_EledEtaCalo << " "
999	+	<< fMVAVar_EledPhiCalo << " "
1000	+	<< fMVAVar_EleR9 << " "
1001	+	<< fMVAVar_EleSCEtaWidth << " "
1002	+	<< fMVAVar_EleSCPhiWidth << " "
1003	+	<< fMVAVar_EleCovIEtaIPhi << " "
1004	+	<< fMVAVar_ElePreShowerOverRaw << " "
1005	+	<< fMVAVar_EleKFTrkChiSqr  << " "
1006	+	<< fMVAVar_EleKFTrkNHits  << " "
1007	+	<< fMVAVar_EleE1x5OverE5x5  << " "
1008	+	<< " === : === "
1009	+	<< mva << " "
1010	+	<< std::endl;
1011	+
1012	+	}
1013	+
1014	+
1015	+
1016	+	return mva;
1017	+	}
1018	+
1019	+
1020	+	//--------------------------------------------------------------------------------------------------
1021	+	//MVA Includes Isolation with removal of other leptons
1022	+	//
1023	+	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
1024	+	const PFCandidateCol *PFCands,
1025	+	const PileupEnergyDensityCol *PileupEnergyDensity,
1026	+	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaTarget,
1027	+	const ElectronCol *goodElectrons,
1028	+	const MuonCol *goodMuons,
1029	+	Bool_t printDebug) {
1030	+
1031	+	if (!fIsInitialized) {
1032	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
1033	+	return -9999;
1034	+	}
1035	+
1036	+	Double_t Rho = 0;
1037	+	switch(fTheRhoType) {
1038	+	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
1039	+	Rho = PileupEnergyDensity->At(0)->Rho();
1040	+	break;
1041	+	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
1042	+	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
1043	+	break;
1044	+	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
1045	+	Rho = PileupEnergyDensity->At(0)->RhoRandom();
1046	+	break;
1047	+	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
1048	+	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
1049	+	break;
1050	+	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
1051	+	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
1052	+	break;
1053	+	default:
1054	+	// use the old default
1055	+	Rho = PileupEnergyDensity->At(0)->Rho();
1056	+	break;
1057	+	}
1058	+
1059	+	//set all input variables
1060	+	fMVAVar_ElePt = ele->Pt();
1061	+	fMVAVar_EleEta = ele->SCluster()->Eta();
1062	+	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
1063	+
1064	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1065	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1066	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1067	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
1068	+	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
1069	+	fMVAVar_EleDPhiIn = TMath::Min(fabs(double(ele->DeltaPhiSuperClusterTrackAtVtx())),0.6);
1070	+	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
1071	+	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
1072	+	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
1073	+	fMVAVar_EleEEleClusterOverPout = TMath::Min(double(ele->EEleClusterOverPout()),20.0);
1074	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->P();
1075	+	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
1076	+	fMVAVar_EledEtaCalo =  TMath::Min(fabs(double(ele->DeltaEtaSeedClusterTrackAtCalo())),0.2);
1077	+	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
1078	+	} else {
1079	+	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
1080	+	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
1081	+	fMVAVar_EleFBrem = ele->FBrem();
1082	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
1083	+	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
1084	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
1085	+	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
1086	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1087	+	fMVAVar_EleR9 = ele->SCluster()->R9();
1088	+	}
1089	+
1090	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
1091	+	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
1092	+	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
1093	+	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
1094	+	else {
1095	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1) {
1096	+	fMVAVar_EleSigmaIPhiIPhi = 0;
1097	+	} else {
1098	+	fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
1099	+	}
1100	+	}
1101	+
1102	+	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
1103	+	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
1104	+	fMVAVar_EleIP3d = ele->Ip3dPV();
1105	+	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
1106	+	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
1107	+	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
1108	+	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
1109	+	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
1110	+	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
1111	+
1112	+	//Additional vars
1113	+	if (ele->TrackerTrk()) {
1114	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1115	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1116	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1117	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
1118	+	fMVAVar_EleKFTrkChiSqr = TMath::Min(double(ele->TrackerTrk()->RChi2()),10.0);
1119	+	} else {
1120	+	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
1121	+	}
1122	+	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
1123	+	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
1124	+	} else {
1125	+	fMVAVar_EleKFTrkChiSqr = 0;
1126	+	fMVAVar_EleKFTrkNHits = -1;
1127	+	fMVAVar_EleKFTrkNLayers = -1;
1128	+	}
1129	+
1130	+	if( ele->SCluster()->Seed()->E5x5() > 0.0 ) {
1131	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1132	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1133	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1134	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
1135	+	fMVAVar_EleE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1136	+	} else {
1137	+	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5();
1138	+	}
1139	+	} else {
1140	+	fMVAVar_EleE1x5OverE5x5 = -1.0;
1141	+	}
1142	+
1143	+
1144	+	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1145	+	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1146	+	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1147	+	Double_t tmpChargedIso_DR0p3To0p4  = 0;
1148	+	Double_t tmpChargedIso_DR0p4To0p5  = 0;
1149	+	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1150	+	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1151	+	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1152	+	Double_t tmpGammaIso_DR0p3To0p4  = 0;
1153	+	Double_t tmpGammaIso_DR0p4To0p5  = 0;
1154	+	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1155	+	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1156	+	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1157	+	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1158	+	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1159	+
1160	+	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
1161	+	const PFCandidate *pf = PFCands->At(p);
1162	+
1163	+	//exclude the electron itself
1164	+	if(pf->GsfTrk() && ele->GsfTrk() &&
1165	+	pf->GsfTrk() == ele->GsfTrk()) continue;
1166	+	if(pf->TrackerTrk() && ele->TrackerTrk() &&
1167	+	pf->TrackerTrk() == ele->TrackerTrk()) continue;
1168	+
1169	+	//************************************************************
1170	+	// New Isolation Calculations
1171	+	//************************************************************
1172	+	Double_t dr = MathUtils::DeltaR(ele->Mom(), pf->Mom());
1173	+
1174	+	if (dr < 1.0) {
1175	+	Bool_t IsLeptonFootprint = kFALSE;
1176	+	//************************************************************
1177	+	// Lepton Footprint Removal
1178	+	//************************************************************
1179	+	if(goodElectrons) {
1180	+	for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) {
1181	+	//if pf candidate matches an electron passing ID cuts, then veto it
1182	+	if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() &&
1183	+	pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE;
1184	+	if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() &&
1185	+	pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1186	+	//if pf candidate lies in veto regions of electron passing ID cuts, then veto it
1187	+	if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479
1188	+	&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE;
1189	+	if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 &&
1190	+	MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE;
1191	+	}
1192	+	}
1193	+	if(goodMuons) {
1194	+	for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) {
1195	+	//if pf candidate matches an muon passing ID cuts, then veto it
1196	+	if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() &&
1197	+	pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1198	+	//if pf candidate lies in veto regions of muon passing ID cuts, then veto it
1199	+	if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE;
1200	+	}
1201	+	}
1202	+
1203	+	if (!IsLeptonFootprint) {
1204	+	Bool_t passVeto = kTRUE;
1205	+	//Charged
1206	+	if(pf->BestTrk()) {
1207	+	if (!(fabs(pf->BestTrk()->DzCorrected(*vertex) - ele->BestTrk()->DzCorrected(*vertex)) < 0.2)) passVeto = kFALSE;
1208	+	//************************************************************
1209	+	// Veto any PFmuon, or PFEle
1210	+	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
1211	+	//************************************************************
1212	+	//************************************************************
1213	+	// Footprint Veto
1214	+	if (fabs(ele->SCluster()->Eta()) >= 1.479 && dr < 0.015) passVeto = kFALSE;
1215	+	//************************************************************
1216	+	if (passVeto) {
1217	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1218	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1219	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1220	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1221	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1222	+	} //pass veto
1223	+
1224	+	}
1225	+	//Gamma
1226	+	else if (pf->PFType() == PFCandidate::eGamma) {
1227	+	//************************************************************
1228	+	// Footprint Veto
1229	+	if (fabs(ele->SCluster()->Eta()) >= 1.479) {
1230	+	if (dr < 0.08) passVeto = kFALSE;
1231	+	}
1232	+	//************************************************************
1233	+
1234	+	if (passVeto) {
1235	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1236	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1237	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1238	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1239	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1240	+	}
1241	+	}
1242	+	//NeutralHadron
1243	+	else {
1244	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1245	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1246	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1247	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1248	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1249	+	}
1250	+	} //not lepton footprint
1251	+	} //in 1.0 dr cone
1252	+	} //loop over PF candidates
1253	+
1254	+	fMVAVar_ChargedIso_DR0p0To0p1   = TMath::Min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1255	+	fMVAVar_ChargedIso_DR0p1To0p2   = TMath::Min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1256	+	fMVAVar_ChargedIso_DR0p2To0p3 = TMath::Min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1257	+	fMVAVar_ChargedIso_DR0p3To0p4 = TMath::Min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1258	+	fMVAVar_ChargedIso_DR0p4To0p5 = TMath::Min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1259	+	fMVAVar_GammaIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpGammaIso_DR0p0To0p1 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p0To0p1, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1260	+	fMVAVar_GammaIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpGammaIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1261	+	fMVAVar_GammaIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpGammaIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1262	+	fMVAVar_GammaIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpGammaIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1263	+	fMVAVar_GammaIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpGammaIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1264	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p0To0p1 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p0To0p1, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1265	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1266	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1267	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1268	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1269	+
1270	+	//Do Binding of MVA input variables
1271	+	if (   fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1272	+	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
1273	+	|| fMVAType == ElectronIDMVA::kIsoRingsV0
1274	+	|| fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
1275	+	bindVariables();
1276	+	}
1277	+
1278	+	Double_t mva = -9999;
1279	+	TMVA::Reader *reader = 0;
1280	+
1281	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
1282	+	mva = reader->EvaluateMVA( fMethodname );
1283	+
1284	+	if (printDebug == kTRUE) {
1285	+
1286	+	std::cout << "Debug Electron MVA-ID: "
1287	+	<< fMVAVar_ElePt<< " " << fMVAVar_EleEta << " "
1288	+	<< " --> MVABin " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << " : "
1289	+	<< " fbrem " <<  fMVAVar_EleFBrem
1290	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
1291	+	<< " kfhits " << fMVAVar_EleKFTrkNLayers
1292	+	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1293	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
1294	+	<< " deta " <<  fMVAVar_EleDEtaIn
1295	+	<< " dphi " << fMVAVar_EleDPhiIn
1296	+	<< " detacalo " << fMVAVar_EledEtaCalo
1297	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
1298	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
1299	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
1300	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
1301	+	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
1302	+	<< " R9 " << fMVAVar_EleR9
1303	+	<< " HoE " << fMVAVar_EleHoverE
1304	+	<< " EoP " << fMVAVar_EleEOverP
1305	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
1306	+	<< " eleEoPout " << fMVAVar_EleEEleClusterOverPout
1307	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
1308	+	<< " PreShowerOverRaw" << fMVAVar_ElePreShowerOverRaw
1309	+	<< " d0 " << fMVAVar_EleD0
1310	+	<< " ip3d " << fMVAVar_EleIP3d
1311	+	<< " eta " << fMVAVar_EleEta
1312	+	<< " pt " << fMVAVar_ElePt
1313	+	<< " === : === "
1314	+	<< mva << " "
1315	+	<< std::endl;
1316	+	std::cout << "Debug Electron MVA-ISO: "
1317	+	<< fMVAVar_ChargedIso_DR0p0To0p1 << " "
1318	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1319	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1320	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
1321	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
1322	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
1323	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
1324	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
1325	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
1326	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
1327	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
1328	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
1329	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
1330	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1331	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
1332	+	<< std::endl;
1333	+	}
1334	+
1335	+	return mva;
1336	+	}
1337	+
1338	+
1339	+	//--------------------------------------------------------------------------------------------------
1340	+	//MVA Includes Isolation
1341	+	//
1342	+	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
1343	+	const VertexCol *primaryVertices,
1344	+	const PFCandidateCol *PFCands,
1345	+	const PileupEnergyDensityCol *PileupEnergyDensity,
1346	+	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaTarget,
1347	+	Bool_t printDebug) {
1348	+
1349	+	if (!fIsInitialized) {
1350	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
1351	+	return -9999;
1352	+	}
1353	+
1354	+	Double_t Rho = 0;
1355	+	switch(fTheRhoType) {
1356	+	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
1357	+	Rho = PileupEnergyDensity->At(0)->Rho();
1358	+	break;
1359	+	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
1360	+	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
1361	+	break;
1362	+	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
1363	+	Rho = PileupEnergyDensity->At(0)->RhoRandom();
1364	+	break;
1365	+	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
1366	+	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
1367	+	break;
1368	+	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
1369	+	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
1370	+	break;
1371	+	default:
1372	+	// use the old default
1373	+	Rho = PileupEnergyDensity->At(0)->Rho();
1374	+	break;
1375	+	}
1376	+
1377	+	//set all input variables
1378	+	fMVAVar_ElePt = ele->Pt();
1379	+	fMVAVar_EleEta = ele->SCluster()->Eta();
1380	+	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
1381	+
1382	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1383	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1384	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1385	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ||
1386	+	fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
1387	+	) {
1388	+	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
1389	+	fMVAVar_EleDPhiIn = TMath::Min(fabs(double(ele->DeltaPhiSuperClusterTrackAtVtx())),0.6);
1390	+	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
1391	+	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
1392	+	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
1393	+	fMVAVar_EleEEleClusterOverPout = TMath::Min(double(ele->EEleClusterOverPout()),20.0);
1394	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->P();
1395	+	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
1396	+	fMVAVar_EledEtaCalo =  TMath::Min(fabs(double(ele->DeltaEtaSeedClusterTrackAtCalo())),0.2);
1397	+	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
1398	+	} else {
1399	+	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
1400	+	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
1401	+	fMVAVar_EleFBrem = ele->FBrem();
1402	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
1403	+	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
1404	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
1405	+	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
1406	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1407	+	fMVAVar_EleR9 = ele->SCluster()->R9();
1408	+	}
1409	+
1410	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
1411	+	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
1412	+	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
1413	+	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
1414	+	else {
1415	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ) {
1416	+	fMVAVar_EleSigmaIPhiIPhi = 0;
1417	+	} else {
1418	+	fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
1419	+	}
1420	+	}
1421	+
1422	+	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
1423	+	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
1424	+	fMVAVar_EleIP3d = ele->Ip3dPV();
1425	+	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
1426	+	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
1427	+	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
1428	+	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
1429	+	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
1430	+	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
1431	+
1432	+	//Additional vars
1433	+	if (ele->TrackerTrk()) {
1434	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1435	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1436	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1437	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ||
1438	+	fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
1439	+	) {
1440	+	fMVAVar_EleKFTrkChiSqr = TMath::Min(double(ele->TrackerTrk()->RChi2()),10.0);
1441	+	} else {
1442	+	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
1443	+	}
1444	+	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
1445	+	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
1446	+	} else {
1447	+	fMVAVar_EleKFTrkChiSqr = 0;
1448	+	fMVAVar_EleKFTrkNHits = -1;
1449	+	fMVAVar_EleKFTrkNLayers = -1;
1450	+	}
1451	+
1452	+	if( ele->SCluster()->Seed()->E5x5() > 0.0 ) {
1453	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1454	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1455	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1456	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ||
1457	+	fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
1458	+	) {
1459	+	fMVAVar_EleE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1460	+	fMVAVar_EleOneMinusE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1461	+	} else {
1462	+	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5();
1463	+	}
1464	+	} else {
1465	+	fMVAVar_EleE1x5OverE5x5 = -1.0;
1466	+	}
1467	+
1468	+
1469	+	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1470	+	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1471	+	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1472	+	Double_t tmpChargedIso_DR0p3To0p4  = 0;
1473	+	Double_t tmpChargedIso_DR0p4To0p5  = 0;
1474	+	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1475	+	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1476	+	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1477	+	Double_t tmpGammaIso_DR0p3To0p4  = 0;
1478	+	Double_t tmpGammaIso_DR0p4To0p5  = 0;
1479	+	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1480	+	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1481	+	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1482	+	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1483	+	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1484	+
1485	+	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
1486	+	const PFCandidate *pf = PFCands->At(p);
1487	+
1488	+	//************************************************************
1489	+	// New Isolation Calculations
1490	+	//************************************************************
1491	+	Double_t dr = MathUtils::DeltaR(ele->Mom(), pf->Mom());
1492	+
1493	+	if (dr < 0.5) {
1494	+
1495	+	Bool_t passVeto = kTRUE;
1496	+	//Charged
1497	+	if(pf->BestTrk()) {
1498	+
1499	+	//*************************************************
1500	+	//Use only PFNoPU
1501	+	//*************************************************
1502	+	Bool_t isPFNoPU = kFALSE;
1503	+	if(pf->PFType() == PFCandidate::eHadron) {
1504	+	if(pf->HasTrackerTrk() &&
1505	+	primaryVertices->At(0)->HasTrack(pf->TrackerTrk()) &&
1506	+	primaryVertices->At(0)->TrackWeight(pf->TrackerTrk()) > 0) {
1507	+	isPFNoPU = kTRUE;
1508	+	} else {
1509	+
1510	+	Bool_t vertexFound = kFALSE;
1511	+	const Vertex *closestVtx = 0;
1512	+	Double_t dzmin = 10000;
1513	+
1514	+	// loop over vertices
1515	+	for(UInt_t j = 0; j < primaryVertices->GetEntries(); j++) {
1516	+	const Vertex *vtx = primaryVertices->At(j);
1517	+	assert(vtx);
1518	+
1519	+	if(pf->HasTrackerTrk() &&
1520	+	vtx->HasTrack(pf->TrackerTrk()) &&
1521	+	vtx->TrackWeight(pf->TrackerTrk()) > 0) {
1522	+	vertexFound = kTRUE;
1523	+	closestVtx = vtx;
1524	+	break;
1525	+	}
1526	+	Double_t dz = fabs(pf->SourceVertex().Z() - vtx->Z());
1527	+	if(dz < dzmin) {
1528	+	closestVtx = vtx;
1529	+	dzmin = dz;
1530	+	}
1531	+	}
1532	+
1533	+	Bool_t fCheckClosestZVertex = kTRUE; //we use option 1
1534	+	if(fCheckClosestZVertex) {
1535	+	// Fallback: if track is not associated with any vertex,
1536	+	// associate it with the vertex closest in z
1537	+	if(vertexFound || closestVtx != vertex) {
1538	+	isPFNoPU = kFALSE;
1539	+	} else {
1540	+	isPFNoPU = kTRUE;
1541	+	}
1542	+	} else {
1543	+	if(vertexFound && closestVtx != vertex) {
1544	+	isPFNoPU = kFALSE;
1545	+	} else {
1546	+	isPFNoPU = kTRUE;
1547	+	}
1548	+	}
1549	+	} //hadron & trk stuff
1550	+	} else { // hadron
1551	+	//
1552	+	isPFNoPU = kTRUE;
1553	+	}
1554	+	if (!isPFNoPU) continue;
1555	+
1556	+	//************************************************************
1557	+	// Veto any PFmuon, or PFEle
1558	+	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
1559	+	//************************************************************
1560	+	//************************************************************
1561	+	// Footprint Veto
1562	+	if (fabs(ele->SCluster()->Eta()) >= 1.479 && dr < 0.015) passVeto = kFALSE;
1563	+	//************************************************************
1564	+	if (passVeto) {
1565	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1566	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1567	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1568	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1569	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1570	+	} //pass veto
1571	+
1572	+	}
1573	+	//Gamma
1574	+	else if (pf->PFType() == PFCandidate::eGamma) {
1575	+	//************************************************************
1576	+	// Footprint Veto
1577	+	if (fabs(ele->SCluster()->Eta()) >= 1.479) {
1578	+	if (dr < 0.08) passVeto = kFALSE;
1579	+	}
1580	+	//************************************************************
1581	+
1582	+	if (passVeto) {
1583	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1584	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1585	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1586	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1587	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1588	+	}
1589	+	}
1590	+	//NeutralHadron
1591	+	else {
1592	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1593	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1594	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1595	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1596	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1597	+	}
1598	+	} //in 1.0 dr cone
1599	+	} //loop over PF candidates
1600	+
1601	+	fMVAVar_ChargedIso_DR0p0To0p1   = tmpChargedIso_DR0p0To0p1/ele->Pt();
1602	+	fMVAVar_ChargedIso_DR0p1To0p2   = tmpChargedIso_DR0p1To0p2/ele->Pt();
1603	+	fMVAVar_ChargedIso_DR0p2To0p3 = tmpChargedIso_DR0p2To0p3/ele->Pt();
1604	+	fMVAVar_ChargedIso_DR0p3To0p4 = tmpChargedIso_DR0p3To0p4/ele->Pt();
1605	+	fMVAVar_ChargedIso_DR0p4To0p5 = tmpChargedIso_DR0p4To0p5/ele->Pt();
1606	+	fMVAVar_GammaIso_DR0p0To0p1 = tmpGammaIso_DR0p0To0p1/ele->Pt();
1607	+	fMVAVar_GammaIso_DR0p1To0p2 = tmpGammaIso_DR0p1To0p2/ele->Pt();
1608	+	fMVAVar_GammaIso_DR0p2To0p3 = tmpGammaIso_DR0p2To0p3/ele->Pt();
1609	+	fMVAVar_GammaIso_DR0p3To0p4 = tmpGammaIso_DR0p3To0p4/ele->Pt();
1610	+	fMVAVar_GammaIso_DR0p4To0p5 = tmpGammaIso_DR0p4To0p5/ele->Pt();
1611	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = tmpNeutralHadronIso_DR0p0To0p1/ele->Pt();
1612	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = tmpNeutralHadronIso_DR0p1To0p2/ele->Pt();
1613	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = tmpNeutralHadronIso_DR0p2To0p3/ele->Pt();
1614	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = tmpNeutralHadronIso_DR0p3To0p4/ele->Pt();
1615	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = tmpNeutralHadronIso_DR0p4To0p5/ele->Pt();
1616	+	fMVAVar_Rho = Rho;
1617	+
1618	+	//Do Binding of MVA input variables
1619	+	if (   fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1620	+	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
1621	+	|| fMVAType == ElectronIDMVA::kIsoRingsV0
1622	+	|| fMVAType == ElectronIDMVA::kIDHWW2012TrigV0
1623	+	|| fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
1624	+	) {
1625	+	bindVariables();
1626	+	}
1627	+
1628	+	Double_t mva = -9999;
1629	+	TMVA::Reader *reader = 0;
1630	+
1631	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
1632	+	mva = reader->EvaluateMVA( fMethodname );
1633	+
1634	+	if (printDebug == kTRUE) {
1635	+
1636	+	std::cout << "Debug Electron MVA-ID: "
1637	+	<< fMVAVar_ElePt<< " " << fMVAVar_EleEta << " "
1638	+	<< " --> MVABin " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << " : "
1639	+	<< " fbrem " <<  fMVAVar_EleFBrem
1640	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
1641	+	<< " kfhits " << fMVAVar_EleKFTrkNLayers
1642	+	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1643	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
1644	+	<< " deta " <<  fMVAVar_EleDEtaIn
1645	+	<< " dphi " << fMVAVar_EleDPhiIn
1646	+	<< " detacalo " << fMVAVar_EledEtaCalo
1647	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
1648	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
1649	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
1650	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
1651	+	<< " e1x5e5x5 " << fMVAVar_EleOneMinusE1x5OverE5x5
1652	+	<< " R9 " << fMVAVar_EleR9
1653	+	<< " HoE " << fMVAVar_EleHoverE
1654	+	<< " EoP " << fMVAVar_EleEOverP
1655	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
1656	+	<< " eleEoPout " << fMVAVar_EleEEleClusterOverPout
1657	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
1658	+	<< " PreShowerOverRaw" << fMVAVar_ElePreShowerOverRaw
1659	+	<< " d0 " << fMVAVar_EleD0
1660	+	<< " ip3d " << fMVAVar_EleIP3d
1661	+	<< " eta " << fMVAVar_EleEta
1662	+	<< " pt " << fMVAVar_ElePt
1663	+	<< " === : === "
1664	+	<< mva << " "
1665	+	<< std::endl;
1666	+	std::cout << "Debug Electron MVA-ISO: "
1667	+	<< fMVAVar_ChargedIso_DR0p0To0p1 << " "
1668	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1669	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1670	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
1671	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
1672	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
1673	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
1674	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
1675	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
1676	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
1677	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
1678	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
1679	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
1680	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1681	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
1682	+	<< fMVAVar_Rho << " "
1683	+	<< std::endl;
1684	+	}
1685	+
1686	+	return mva;
1687	+	}
1688	+
1689	+
1690	+	void ElectronIDMVA::bindVariables() {
1691	+
1692	+	// this binding is needed for variables that sometime diverge.
1693	+
1694	+	if(fMVAVar_EleFBrem < -1.)
1695	+	fMVAVar_EleFBrem = -1.;
1696	+
1697	+	fMVAVar_EleDEtaIn = fabs(fMVAVar_EleDEtaIn);
1698	+	if(fMVAVar_EleDEtaIn > 0.06)
1699	+	fMVAVar_EleDEtaIn = 0.06;
1700	+
1701	+
1702	+	fMVAVar_EleDPhiIn = fabs(fMVAVar_EleDPhiIn);
1703	+	if(fMVAVar_EleDPhiIn > 0.6)
1704	+	fMVAVar_EleDPhiIn = 0.6;
1705	+
1706	+
1707	+	if(fMVAVar_EleESeedClusterOverPout > 20.)
1708	+	fMVAVar_EleESeedClusterOverPout = 20.;
1709	+
1710	+	if(fMVAVar_EleEOverP > 20.)
1711	+	fMVAVar_EleEOverP = 20.;
1712	+
1713	+	if(fMVAVar_EleEEleClusterOverPout > 20.)
1714	+	fMVAVar_EleEEleClusterOverPout = 20.;
1715	+
1716	+
1717	+	fMVAVar_EledEtaCalo = fabs(fMVAVar_EledEtaCalo);
1718	+	if(fMVAVar_EledEtaCalo > 0.2)
1719	+	fMVAVar_EledEtaCalo = 0.2;
1720	+
1721	+
1722	+	if(fMVAVar_EleE1x5OverE5x5 < -1.)
1723	+	fMVAVar_EleE1x5OverE5x5 = -1;
1724	+
1725	+	if(fMVAVar_EleE1x5OverE5x5 > 2.)
1726	+	fMVAVar_EleE1x5OverE5x5 = 2.;
1727	+
1728	+
1729	+
1730	+	if(fMVAVar_EleR9 > 5)
1731	+	fMVAVar_EleR9 = 5;
1732	+
1733	+	if(fMVAVar_EleGsfTrackChi2OverNdof > 200.)
1734	+	fMVAVar_EleGsfTrackChi2OverNdof = 200;
1735	+
1736	+
1737	+	if(fMVAVar_EleKFTrkChiSqr > 10.)
1738	+	fMVAVar_EleKFTrkChiSqr = 10.;
1739	+
1740	+	// Needed for a bug in CMSSW_420, fixed in more recent CMSSW versions
1741	+	if(std::isnan(fMVAVar_EleSigmaIPhiIPhi))
1742	+	fMVAVar_EleSigmaIPhiIPhi = 0.;
1743	+
1744	+
1745	+	return;
1746	+	}

Diff Legend

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