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.4 by sixie, Mon Oct 3 16:32:09 2011 UTC vs.
Revision 1.15 by ksung, Mon Apr 16 11:59:53 2012 UTC

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

Diff Legend

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