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.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	<	fIsInitialized(kFALSE)
18	>	fIsInitialized(kFALSE),
19	>	fMVAType(ElectronIDMVA::kUninitialized),
20	>	fUseBinnedVersion(kTRUE),
21	>	fNMVABins(0),
22	>	fTheRhoType(RhoUtilities::DEFAULT)
23		{
24		// Constructor.
21	–	for(UInt_t i=0; i<6; ++i) {
22	–	fTMVAReader[i] = 0;
23	–	}
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 40 | Line 53 | void ElectronIDMVA::Initialize( TString
53		TString Subdet0Pt20ToInfWeights,
54		TString Subdet1Pt20ToInfWeights,
55		TString Subdet2Pt20ToInfWeights,
56	<	ElectronIDMVA::MVAType type) {
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;
46	–
88		fMethodname = methodName;
89	<
90	<	for(UInt_t i=0; i<6; ++i) {
91	<	if (fTMVAReader[i]) delete fTMVAReader[i];
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	<	fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );
116	<	fTMVAReader[i]->SetVerbose(kTRUE);
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	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
129	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
130	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
131	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
132	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
133	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
134	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );
135	<	}
136	<
137	<	if (type == kV1) {
138	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
139	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
140	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
141	<	fTMVAReader[i]->AddVariable( "HoverE",                &fMVAVar_EleHoverE                );
142	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
143	<	fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                );
144	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout  );
145	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
146	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
147	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );
148	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn   );
149	<	}
150	<	if (type == kV2) {
151	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
152	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
153	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
154	<	fTMVAReader[i]->AddVariable( "HoverE",                &fMVAVar_EleHoverE                );
155	<	fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                    );
156	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
157	<	fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                );
158	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout  );
159	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
160	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
161	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );
162	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn   );
163	<	fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                  );
164	<	fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig               );
165	<	}
166	<
167	<	if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To20Weights );
168	<	if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To20Weights );
169	<	if (i==2) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt10To20Weights );
170	<	if (i==3) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt20ToInfWeights );
171	<	if (i==4) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt20ToInfWeights );
172	<	if (i==5) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt20ToInfWeights );
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	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
226	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
227	>	}
228	>
229	>	if (type == kIDEGamma2012NonTrigV0 ) {
230	>	// Pure tracking variables
231	>	tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
232	>	tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
233	>	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
234	>	tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
235	>	tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
236	>	tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
237	>	tmpTMVAReader->AddVariable("detacalo",        &fMVAVar_EledEtaCalo);
238	>	tmpTMVAReader->AddVariable("see",             &fMVAVar_EleSigmaIEtaIEta);
239	>	tmpTMVAReader->AddVariable("spp",             &fMVAVar_EleSigmaIPhiIPhi);
240	>	tmpTMVAReader->AddVariable("etawidth",        &fMVAVar_EleSCEtaWidth);
241	>	tmpTMVAReader->AddVariable("phiwidth",        &fMVAVar_EleSCPhiWidth);
242	>	tmpTMVAReader->AddVariable("e1x5e5x5",        &fMVAVar_EleE1x5OverE5x5);
243	>	tmpTMVAReader->AddVariable("R9",              &fMVAVar_EleR9);
244	>	tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
245	>	tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
246	>	tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
247	>	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout);
248	>	if (i==2 || i==5) {
249	>	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
250	>	}
251	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
252	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
253	>	}
254	>
255	>	if (type == kIDEGamma2012NonTrigV1 ) {
256	>	// Pure tracking variables
257	>	tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
258	>	tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
259	>	tmpTMVAReader->AddVariable("kfhits",          &fMVAVar_EleKFTrkNLayers);
260	>	tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
261	>	tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
262	>	tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
263	>	tmpTMVAReader->AddVariable("detacalo",        &fMVAVar_EledEtaCalo);
264	>	tmpTMVAReader->AddVariable("see",             &fMVAVar_EleSigmaIEtaIEta);
265	>	tmpTMVAReader->AddVariable("spp",             &fMVAVar_EleSigmaIPhiIPhi);
266	>	tmpTMVAReader->AddVariable("etawidth",        &fMVAVar_EleSCEtaWidth);
267	>	tmpTMVAReader->AddVariable("phiwidth",        &fMVAVar_EleSCPhiWidth);
268	>	tmpTMVAReader->AddVariable("e1x5e5x5",        &fMVAVar_EleE1x5OverE5x5);
269	>	tmpTMVAReader->AddVariable("R9",              &fMVAVar_EleR9);
270	>	tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
271	>	tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
272	>	tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
273	>	tmpTMVAReader->AddVariable("eleEoPout",       &fMVAVar_EleEEleClusterOverPout);
274	>	if (i==2 || i==5) {
275	>	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
276	>	}
277	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
278	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
279	>	}
280	>
281	>	if (type == kIsoRingsV0) {
282	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1",         &fMVAVar_ChargedIso_DR0p0To0p1        );
283	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2",         &fMVAVar_ChargedIso_DR0p1To0p2        );
284	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p2To0p3",         &fMVAVar_ChargedIso_DR0p2To0p3        );
285	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p3To0p4",         &fMVAVar_ChargedIso_DR0p3To0p4        );
286	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p4To0p5",         &fMVAVar_ChargedIso_DR0p4To0p5        );
287	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p0To0p1",           &fMVAVar_GammaIso_DR0p0To0p1          );
288	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p1To0p2",           &fMVAVar_GammaIso_DR0p1To0p2          );
289	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p2To0p3",           &fMVAVar_GammaIso_DR0p2To0p3          );
290	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p3To0p4",           &fMVAVar_GammaIso_DR0p3To0p4          );
291	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p4To0p5",           &fMVAVar_GammaIso_DR0p4To0p5          );
292	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p0To0p1",   &fMVAVar_NeutralHadronIso_DR0p0To0p1  );
293	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p1To0p2",   &fMVAVar_NeutralHadronIso_DR0p1To0p2  );
294	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p2To0p3",   &fMVAVar_NeutralHadronIso_DR0p2To0p3  );
295	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p3To0p4",   &fMVAVar_NeutralHadronIso_DR0p3To0p4  );
296	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p4To0p5",   &fMVAVar_NeutralHadronIso_DR0p4To0p5  );
297	>	tmpTMVAReader->AddSpectator( "eta",   &fMVAVar_EleEta );
298	>	tmpTMVAReader->AddSpectator( "pt" ,   &fMVAVar_ElePt  );
299	>	}
300	>
301	>	if (type == kIDIsoCombinedHWW2012TrigV4) {
302	>
303	>	// Pure tracking variables
304	>	tmpTMVAReader->AddVariable("fbrem",                      &fMVAVar_EleFBrem);
305	>	tmpTMVAReader->AddVariable("kfchi2",                     &fMVAVar_EleKFTrkChiSqr);
306	>	tmpTMVAReader->AddVariable("kflayers",                   &fMVAVar_EleKFTrkNLayers);
307	>	tmpTMVAReader->AddVariable("gsfchi2",                    &fMVAVar_EleGsfTrackChi2OverNdof);
308	>
309	>	// Geometrical matchings
310	>	tmpTMVAReader->AddVariable("deta",                       &fMVAVar_EleDEtaIn);
311	>	tmpTMVAReader->AddVariable("dphi",                       &fMVAVar_EleDPhiIn);
312	>	tmpTMVAReader->AddVariable("detacalo",                   &fMVAVar_EledEtaCalo);
313	>
314	>	// Pure ECAL -> shower shapes
315	>	tmpTMVAReader->AddVariable("see",                        &fMVAVar_EleSigmaIEtaIEta);
316	>	tmpTMVAReader->AddVariable("spp",                        &fMVAVar_EleSigmaIPhiIPhi);
317	>	tmpTMVAReader->AddVariable("etawidth",                   &fMVAVar_EleSCEtaWidth);
318	>	tmpTMVAReader->AddVariable("phiwidth",                   &fMVAVar_EleSCPhiWidth);
319	>	tmpTMVAReader->AddVariable("OneMinusSeedE1x5OverE5x5",   &fMVAVar_EleOneMinusE1x5OverE5x5);
320	>	tmpTMVAReader->AddVariable("R9",                         &fMVAVar_EleR9);
321	>
322	>	// Energy matching
323	>	tmpTMVAReader->AddVariable("HoE",                        &fMVAVar_EleHoverE);
324	>	tmpTMVAReader->AddVariable("EoP",                        &fMVAVar_EleEOverP);
325	>	tmpTMVAReader->AddVariable("IoEmIoP",                    &fMVAVar_EleOneOverEMinusOneOverP);
326	>	tmpTMVAReader->AddVariable("EEleoPout",                  &fMVAVar_EleEEleClusterOverPout);
327	>	if(i == 2 || i == 5) {
328	>	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
329	>	}
330	>
331	>	// IP
332	>	tmpTMVAReader->AddVariable("d0",              &fMVAVar_EleD0);
333	>	tmpTMVAReader->AddVariable("ip3d",            &fMVAVar_EleIP3d);
334	>
335	>	//isolation variables
336	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1",         &fMVAVar_ChargedIso_DR0p0To0p1        );
337	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2",         &fMVAVar_ChargedIso_DR0p1To0p2        );
338	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p2To0p3",         &fMVAVar_ChargedIso_DR0p2To0p3        );
339	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p3To0p4",         &fMVAVar_ChargedIso_DR0p3To0p4        );
340	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p4To0p5",         &fMVAVar_ChargedIso_DR0p4To0p5        );
341	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p0To0p1",           &fMVAVar_GammaIso_DR0p0To0p1          );
342	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p1To0p2",           &fMVAVar_GammaIso_DR0p1To0p2          );
343	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p2To0p3",           &fMVAVar_GammaIso_DR0p2To0p3          );
344	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p3To0p4",           &fMVAVar_GammaIso_DR0p3To0p4          );
345	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p4To0p5",           &fMVAVar_GammaIso_DR0p4To0p5          );
346	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p0To0p1",   &fMVAVar_NeutralHadronIso_DR0p0To0p1  );
347	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p1To0p2",   &fMVAVar_NeutralHadronIso_DR0p1To0p2  );
348	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p2To0p3",   &fMVAVar_NeutralHadronIso_DR0p2To0p3  );
349	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p3To0p4",   &fMVAVar_NeutralHadronIso_DR0p3To0p4  );
350	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p4To0p5",   &fMVAVar_NeutralHadronIso_DR0p4To0p5  );
351	>	tmpTMVAReader->AddVariable( "rho",                           &fMVAVar_Rho );
352	>
353	>	//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	+	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	<	std::cout << "Electron ID MVA Initialization\n";
412	<	std::cout << "MethodName : " << fMethodname << " , type == " << type << std::endl;
413	<	std::cout << "Load weights file : " << Subdet0Pt10To20Weights << std::endl;
414	<	std::cout << "Load weights file : " << Subdet1Pt10To20Weights << std::endl;
415	<	std::cout << "Load weights file : " << Subdet2Pt10To20Weights << std::endl;
416	<	std::cout << "Load weights file : " << Subdet0Pt20ToInfWeights << std::endl;
417	<	std::cout << "Load weights file : " << Subdet1Pt20ToInfWeights << std::endl;
418	<	std::cout << "Load weights file : " << Subdet2Pt20ToInfWeights << std::endl;
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 EleSCEta,
430	>	Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleEta,
431		Double_t EleSigmaIEtaIEta,
432		Double_t EleDEtaIn,
433		Double_t EleDPhiIn,
#	Line 136 | Line 450 | Double_t ElectronIDMVA::MVAValue(Double_
450		return -9999;
451		}
452
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	–
453		//set all input variables
454		fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
455		fMVAVar_EleDEtaIn = EleDEtaIn;
#	Line 162 | Line 469 | Double_t ElectronIDMVA::MVAValue(Double_
469
470		Double_t mva = -9999;
471		TMVA::Reader *reader = 0;
472	<	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];
472	>	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
473
474		mva = reader->EvaluateMVA( fMethodname );
475
476		return mva;
477		}
478
479	+	//--------------------------------------------------------------------------------------------------
480	+	Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleEta, Double_t PileupEnergyDensity,
481	+	Double_t EleSigmaIEtaIEta,
482	+	Double_t EleDEtaIn,
483	+	Double_t EleDPhiIn,
484	+	Double_t EleHoverE,
485	+	Double_t EleD0,
486	+	Double_t EleDZ,
487	+	Double_t EleFBrem,
488	+	Double_t EleEOverP,
489	+	Double_t EleESeedClusterOverPout,
490	+	Double_t EleSigmaIPhiIPhi,
491	+	Double_t EleNBrem,
492	+	Double_t EleOneOverEMinusOneOverP,
493	+	Double_t EleESeedClusterOverPIn,
494	+	Double_t EleIP3d,
495	+	Double_t EleIP3dSig,
496	+	Double_t EleGsfTrackChi2OverNdof,
497	+	Double_t EledEtaCalo,
498	+	Double_t EledPhiCalo,
499	+	Double_t EleR9,
500	+	Double_t EleSCEtaWidth,
501	+	Double_t EleSCPhiWidth,
502	+	Double_t EleCovIEtaIPhi,
503	+	Double_t ElePreShowerOverRaw,
504	+	Double_t EleChargedIso03,
505	+	Double_t EleNeutralHadronIso03,
506	+	Double_t EleGammaIso03,
507	+	Double_t EleChargedIso04,
508	+	Double_t EleNeutralHadronIso04,
509	+	Double_t EleGammaIso04,
510	+	Bool_t printDebug
511	+	) {
512	+
513	+	if (!fIsInitialized) {
514	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
515	+	return -9999;
516	+	}
517	+
518	+	Double_t Rho = 0;
519	+	if (!(TMath::IsNaN(PileupEnergyDensity) || isinf(PileupEnergyDensity))) Rho = PileupEnergyDensity;
520	+
521	+	//set all input variables
522	+	fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
523	+	fMVAVar_EleDEtaIn = EleDEtaIn;
524	+	fMVAVar_EleDPhiIn = EleDPhiIn;
525	+	fMVAVar_EleHoverE = EleHoverE;
526	+	fMVAVar_EleD0 = EleD0;
527	+	fMVAVar_EleDZ = EleDZ;
528	+	fMVAVar_EleFBrem = EleFBrem;
529	+	fMVAVar_EleEOverP = EleEOverP;
530	+	fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
531	+	fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
532	+	fMVAVar_EleNBrem = EleNBrem;
533	+	fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
534	+	fMVAVar_EleESeedClusterOverPIn = EleESeedClusterOverPIn;
535	+	fMVAVar_EleIP3d = EleIP3d;
536	+	fMVAVar_EleIP3dSig = EleIP3dSig;
537	+	fMVAVar_EleGsfTrackChi2OverNdof = EleGsfTrackChi2OverNdof;
538	+	fMVAVar_EledEtaCalo = EledEtaCalo;
539	+	fMVAVar_EledPhiCalo = EledPhiCalo;
540	+	fMVAVar_EleR9 = EleR9;
541	+	fMVAVar_EleSCEtaWidth = EleSCEtaWidth;
542	+	fMVAVar_EleSCPhiWidth = EleSCPhiWidth;
543	+	fMVAVar_EleCovIEtaIPhi = EleCovIEtaIPhi;
544	+	fMVAVar_ElePreShowerOverRaw = ElePreShowerOverRaw;
545	+	fMVAVar_EleChargedIso03OverPt
546	+	= (EleChargedIso03
547	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, EleEta)) / ElePt;
548	+	fMVAVar_EleNeutralHadronIso03OverPt
549	+	= (EleNeutralHadronIso03
550	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, EleEta)
551	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,EleEta)) / ElePt;
552	+	fMVAVar_EleGammaIso03OverPt
553	+	= (EleGammaIso03
554	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, EleEta)
555	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,EleEta))/ElePt;
556	+	fMVAVar_EleChargedIso04OverPt
557	+	= (EleChargedIso04
558	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso04, EleEta))/ElePt;
559	+	fMVAVar_EleNeutralHadronIso04OverPt
560	+	= (EleNeutralHadronIso04
561	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso04, EleEta)
562	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,EleEta))/ElePt;
563	+	fMVAVar_EleGammaIso04OverPt
564	+	= (EleGammaIso04
565	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, EleEta)
566	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,EleEta))/ElePt;
567	+
568	+
569	+
570	+
571	+	Double_t mva = -9999;
572	+	TMVA::Reader *reader = 0;
573	+	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
574	+	mva = reader->EvaluateMVA( fMethodname );
575	+
576	+	if (printDebug == kTRUE) {
577	+	std::cout << "Debug Electron MVA: "
578	+	<< ElePt << " " << EleEta << " " << " --> MVABin " << GetMVABin( EleEta, ElePt) << " : "
579	+	<< fMVAVar_EleSigmaIEtaIEta << " "
580	+	<< fMVAVar_EleDEtaIn << " "
581	+	<< fMVAVar_EleDPhiIn << " "
582	+	<< fMVAVar_EleHoverE << " "
583	+	<< fMVAVar_EleD0 << " "
584	+	<< fMVAVar_EleDZ << " "
585	+	<< fMVAVar_EleFBrem << " "
586	+	<< fMVAVar_EleEOverP << " "
587	+	<< fMVAVar_EleESeedClusterOverPout << " "
588	+	<< fMVAVar_EleSigmaIPhiIPhi << " "
589	+	<< fMVAVar_EleNBrem << " "
590	+	<< fMVAVar_EleOneOverEMinusOneOverP << " "
591	+	<< fMVAVar_EleESeedClusterOverPIn << " "
592	+	<< fMVAVar_EleIP3d << " "
593	+	<< fMVAVar_EleIP3dSig << " "
594	+	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
595	+	<< fMVAVar_EledEtaCalo << " "
596	+	<< fMVAVar_EledPhiCalo << " "
597	+	<< fMVAVar_EleR9 << " "
598	+	<< fMVAVar_EleSCEtaWidth << " "
599	+	<< fMVAVar_EleSCPhiWidth << " "
600	+	<< fMVAVar_EleCovIEtaIPhi << " "
601	+	<< fMVAVar_ElePreShowerOverRaw << " "
602	+	<< fMVAVar_EleChargedIso03OverPt  << " "
603	+	<< fMVAVar_EleNeutralHadronIso03OverPt  << " "
604	+	<< fMVAVar_EleGammaIso03OverPt  << " "
605	+	<< fMVAVar_EleChargedIso04OverPt  << " "
606	+	<< fMVAVar_EleNeutralHadronIso04OverPt  << " "
607	+	<< fMVAVar_EleGammaIso04OverPt  << " "
608	+	<< " === : === "
609	+	<< mva
610	+	<< std::endl;
611	+	}
612	+
613	+	return mva;
614	+	}
615	+
616	+	Double_t ElectronIDMVA::MVAValue_IsoRings( Double_t ElePt,
617	+	Double_t EleSCEta,
618	+	Double_t ChargedIso_DR0p0To0p1,
619	+	Double_t ChargedIso_DR0p1To0p2,
620	+	Double_t ChargedIso_DR0p2To0p3,
621	+	Double_t ChargedIso_DR0p3To0p4,
622	+	Double_t ChargedIso_DR0p4To0p5,
623	+	Double_t GammaIso_DR0p0To0p1,
624	+	Double_t GammaIso_DR0p1To0p2,
625	+	Double_t GammaIso_DR0p2To0p3,
626	+	Double_t GammaIso_DR0p3To0p4,
627	+	Double_t GammaIso_DR0p4To0p5,
628	+	Double_t NeutralHadronIso_DR0p0To0p1,
629	+	Double_t NeutralHadronIso_DR0p1To0p2,
630	+	Double_t NeutralHadronIso_DR0p2To0p3,
631	+	Double_t NeutralHadronIso_DR0p3To0p4,
632	+	Double_t NeutralHadronIso_DR0p4To0p5,
633	+	Bool_t printDebug) {
634	+
635	+	if (fMVAType != ElectronIDMVA::kIsoRingsV0) {
636	+	std::cout << "Error: This function is only supported for MVAType == kIsoRingsV0.\n" << std::endl;
637	+	assert(kFALSE);
638	+	}
639	+
640	+	fMVAVar_ElePt = ElePt;
641	+	fMVAVar_EleEta = EleSCEta;
642	+	fMVAVar_ChargedIso_DR0p0To0p1 = ChargedIso_DR0p0To0p1;
643	+	fMVAVar_ChargedIso_DR0p1To0p2 = ChargedIso_DR0p1To0p2;
644	+	fMVAVar_ChargedIso_DR0p2To0p3 = ChargedIso_DR0p2To0p3;
645	+	fMVAVar_ChargedIso_DR0p3To0p4 = ChargedIso_DR0p3To0p4;
646	+	fMVAVar_ChargedIso_DR0p4To0p5 = ChargedIso_DR0p4To0p5;
647	+	fMVAVar_GammaIso_DR0p0To0p1 = GammaIso_DR0p0To0p1;
648	+	fMVAVar_GammaIso_DR0p1To0p2 = GammaIso_DR0p1To0p2;
649	+	fMVAVar_GammaIso_DR0p2To0p3 = GammaIso_DR0p2To0p3;
650	+	fMVAVar_GammaIso_DR0p3To0p4 = GammaIso_DR0p3To0p4;
651	+	fMVAVar_GammaIso_DR0p4To0p5 = GammaIso_DR0p4To0p5;
652	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = NeutralHadronIso_DR0p0To0p1;
653	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = NeutralHadronIso_DR0p1To0p2;
654	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = NeutralHadronIso_DR0p2To0p3;
655	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = NeutralHadronIso_DR0p3To0p4;
656	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = NeutralHadronIso_DR0p4To0p5;
657	+
658	+	Double_t mva = -9999;
659	+	TMVA::Reader *reader = 0;
660	+
661	+	if (printDebug == kTRUE) {
662	+	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << std::endl;
663	+	}
664	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
665	+	mva = reader->EvaluateMVA( fMethodname );
666	+
667	+	if (printDebug == kTRUE) {
668	+
669	+	std::cout << "Debug Electron MVA-ISO: ";
670	+	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
671	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
672	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
673	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
674	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
675	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
676	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
677	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
678	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
679	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
680	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
681	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
682	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
683	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
684	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
685	+	<< std::endl;
686	+	std::cout << "MVA: " << mva << " "
687	+	<< std::endl;
688	+	}
689	+	return mva;
690	+	}
691	+
692	+	Double_t ElectronIDMVA::MVAValue_IDNonTrig( Double_t ElePt,
693	+	Double_t EleSCEta,
694	+	Double_t EleFBrem,
695	+	Double_t EleKFTrkChiSqr,
696	+	Double_t EleKFTrkNHits,
697	+	Double_t EleGsfTrackChi2OverNdof,
698	+	Double_t EleDEtaIn,
699	+	Double_t EleDPhiIn,
700	+	Double_t EledEtaCalo,
701	+	Double_t EleSigmaIEtaIEta,
702	+	Double_t EleSigmaIPhiIPhi,
703	+	Double_t EleSCEtaWidth,
704	+	Double_t EleSCPhiWidth,
705	+	Double_t EleE1x5OverE5x5,
706	+	Double_t EleR9,
707	+	Double_t EleHoverE,
708	+	Double_t EleEOverP,
709	+	Double_t EleOneOverEMinusOneOverP,
710	+	Double_t EleESeedClusterOverPout,
711	+	Double_t ElePreShowerOverRaw,
712	+	Bool_t printDebug) {
713	+
714	+	if (fMVAType != ElectronIDMVA::kIDEGamma2012NonTrigV0) {
715	+	std::cout << "Error: This function is only supported for MVAType == kIDEGamma2012NonTrigV0.\n" << std::endl;
716	+	assert(kFALSE);
717	+	}
718	+
719	+	fMVAVar_ElePt = ElePt;
720	+	fMVAVar_EleEta = EleSCEta;
721	+	fMVAVar_EleFBrem = EleFBrem;
722	+	fMVAVar_EleKFTrkChiSqr = EleKFTrkChiSqr;
723	+	fMVAVar_EleKFTrkNHits = EleKFTrkNHits;
724	+	fMVAVar_EleGsfTrackChi2OverNdof = EleGsfTrackChi2OverNdof;
725	+	fMVAVar_EleDEtaIn = EleDEtaIn;
726	+	fMVAVar_EleDPhiIn = EleDPhiIn;
727	+	fMVAVar_EledEtaCalo = EledEtaCalo;
728	+	fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
729	+	fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
730	+	fMVAVar_EleSCEtaWidth = EleSCEtaWidth;
731	+	fMVAVar_EleSCPhiWidth = EleSCPhiWidth;
732	+	fMVAVar_EleE1x5OverE5x5 = EleE1x5OverE5x5;
733	+	fMVAVar_EleR9 = EleR9;
734	+	fMVAVar_EleHoverE = EleHoverE;
735	+	fMVAVar_EleEOverP = EleEOverP;
736	+	fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
737	+	fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
738	+	fMVAVar_ElePreShowerOverRaw = ElePreShowerOverRaw;
739	+
740	+	Double_t mva = -9999;
741	+	TMVA::Reader *reader = 0;
742	+
743	+	if (printDebug == kTRUE) {
744	+	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << std::endl;
745	+	}
746	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
747	+	mva = reader->EvaluateMVA( fMethodname );
748
749	+	if (printDebug == kTRUE) {
750	+	std::cout << "Debug Electron MVA: ";
751	+	std::cout << " fbrem " <<  fMVAVar_EleFBrem
752	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
753	+	<< " kfhits " << fMVAVar_EleKFTrkNLayers
754	+	<< " kfhitsall " <<  fMVAVar_EleKFTrkNHits
755	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
756	+	<< " deta " <<  fMVAVar_EleDEtaIn
757	+	<< " dphi " << fMVAVar_EleDPhiIn
758	+	<< " detacalo " << fMVAVar_EledEtaCalo
759	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
760	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
761	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
762	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
763	+	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
764	+	<< " R9 " << fMVAVar_EleR9
765	+	<< " HoE " << fMVAVar_EleHoverE
766	+	<< " EoP " << fMVAVar_EleEOverP
767	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
768	+	<< " eleEoPout " << fMVAVar_EleESeedClusterOverPout
769	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
770	+	<< " d0 " << fMVAVar_EleD0
771	+	<< " ip3d " << fMVAVar_EleIP3d
772	+	<< " eta " << fMVAVar_EleEta
773	+	<< " pt " << fMVAVar_ElePt << std::endl;
774	+	std::cout << "MVA: " << mva << " "
775	+	<< std::endl;
776	+	}
777	+	return mva;
778	+	}
779
780		//--------------------------------------------------------------------------------------------------
781	<	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex) {
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	<	Int_t subdet = 0;
793	<	if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
794	<	else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
795	<	else subdet = 2;
796	<	Int_t ptBin = 0;
797	<	if (ele->Pt() > 20.0) ptBin = 1;
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();
818	>	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
819	>	fMVAVar_EleHoverE = ele->HadronicOverEm();
820	>	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
821	>	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
822	>	fMVAVar_EleFBrem = ele->FBrem();
823	>	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
824	>	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
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->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
829	>	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
830	>	fMVAVar_EleIP3d = ele->Ip3dPV();
831	>	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
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	>	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();
#	Line 207 | Line 943 | Double_t ElectronIDMVA::MVAValue(const E
943		if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
944		else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
945		fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
946	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->ESuperClusterOverP()*ele->BestTrk()->P())) - 1.0 / ele->BestTrk()->P();
946	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
947		fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
948		fMVAVar_EleIP3d = ele->Ip3dPV();
949		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
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	<	Int_t MVABin = -1;
976	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
977	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
978	<	if (subdet == 2 && ptBin == 0) MVABin = 2;
979	<	if (subdet == 0 && ptBin == 1) MVABin = 3;
980	<	if (subdet == 1 && ptBin == 1) MVABin = 4;
981	<	if (subdet == 2 && ptBin == 1) MVABin = 5;
982	<	assert(MVABin >= 0 && MVABin <= 5);
983	<	reader = fTMVAReader[MVABin];
984	<
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