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.29 by sixie, Fri Oct 26 18:34:21 2012 UTC

#	Line 15 | Line 15 | using namespace mithep;
15		//--------------------------------------------------------------------------------------------------
16		ElectronIDMVA::ElectronIDMVA() :
17		fMethodname("BDTG method"),
18	<	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	<	fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );
94	<	fTMVAReader[i]->SetVerbose(kTRUE);
93	>	//Define expected number of bins
94	>	UInt_t ExpectedNBins = 0;
95	>	if (!fUseBinnedVersion) {
96	>	ExpectedNBins = 1;
97	>	} else if (type == kBaseline
98	>	||type == kNoIPInfo
99	>	||type == kWithIPInfo
100	>	||type == kIDIsoCombined) {
101	>	ExpectedNBins = 6;
102	>	} else if (type == kIDEGamma2012TrigV0 ||
103	>	type == kIDEGamma2012NonTrigV0 ||
104	>	type == kIDEGamma2012NonTrigV1 ||
105	>	type == kIDHWW2012TrigV0 ||
106	>	type == kIDIsoCombinedHWW2012TrigV4
107	>
108	>	) {
109	>	ExpectedNBins = 6;
110	>	} else if (type == kIsoRingsV0) {
111	>	ExpectedNBins = 4;
112	>	}
113	>	fNMVABins = ExpectedNBins;
114	>
115	>	//Check number of weight files given
116	>	if (fNMVABins != weightsfiles.size() ) {
117	>	std::cout << "Error: Expected Number of bins = " << fNMVABins << " does not equal to weightsfiles.size() = "
118	>	<< weightsfiles.size() << std::endl;
119	>	assert(fNMVABins == weightsfiles.size());
120	>	}
121	>
122	>
123	>	for(UInt_t i=0; i<fNMVABins; ++i) {
124	>	TMVA::Reader *tmpTMVAReader = new TMVA::Reader( "!Color:!Silent:Error" );
125	>	tmpTMVAReader->SetVerbose(kTRUE);
126
127		if (type == kBaseline) {
128	<	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;
798	<
792	>	Double_t Rho = 0;
793	>	switch(fTheRhoType) {
794	>	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
795	>	Rho = PileupEnergyDensity->At(0)->Rho();
796	>	break;
797	>	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
798	>	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
799	>	break;
800	>	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
801	>	Rho = PileupEnergyDensity->At(0)->RhoRandom();
802	>	break;
803	>	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
804	>	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
805	>	break;
806	>	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
807	>	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
808	>	break;
809	>	default:
810	>	// use the old default
811	>	Rho = PileupEnergyDensity->At(0)->Rho();
812	>	break;
813	>	}
814	>
815		//set all input variables
816		fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
817		fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
#	Line 207 | Line 825 | Double_t ElectronIDMVA::MVAValue(const E
825		if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
826		else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
827		fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
828	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->ESuperClusterOverP()*ele->BestTrk()->P())) - 1.0 / ele->BestTrk()->P();
828	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
829		fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
830		fMVAVar_EleIP3d = ele->Ip3dPV();
831		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
832	+	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
833	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
834	+	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
835	+	fMVAVar_EleR9 = ele->SCluster()->R9();
836	+	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
837	+	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
838	+	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
839	+	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
840	+	fMVAVar_EleChargedIso03OverPt
841	+	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.3, intRadius)
842	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, ele->SCluster()->Eta())) / ele->Pt();
843	+	fMVAVar_EleNeutralHadronIso03OverPt
844	+	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, intRadius, PFCandidate::eNeutralHadron)
845	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, ele->SCluster()->Eta())
846	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt();
847	+	fMVAVar_EleGammaIso03OverPt
848	+	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, intRadius, PFCandidate::eGamma)
849	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, ele->SCluster()->Eta())
850	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,ele->SCluster()->Eta())) / ele->Pt();
851	+	fMVAVar_EleChargedIso04OverPt
852	+	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.4, intRadius)
853	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso04, ele->SCluster()->Eta())) / ele->Pt();
854	+	fMVAVar_EleNeutralHadronIso04OverPt
855	+	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, intRadius, PFCandidate::eNeutralHadron)
856	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso04, ele->SCluster()->Eta())
857	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt() ;
858	+	fMVAVar_EleGammaIso04OverPt
859	+	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, intRadius, PFCandidate::eGamma)
860	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, ele->SCluster()->Eta())
861	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,ele->SCluster()->Eta())) / ele->Pt();
862	+
863	+	//Additional vars
864	+	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
865	+	if (ele->TrackerTrk()) {
866	+	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
867	+	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
868	+	} else {
869	+	fMVAVar_EleKFTrkChiSqr = -1;
870	+	fMVAVar_EleKFTrkNHits = 0;
871	+	}
872	+	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
873	+
874
875		Double_t mva = -9999;
876		TMVA::Reader *reader = 0;
877	<	Int_t MVABin = -1;
878	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
879	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
880	<	if (subdet == 2 && ptBin == 0) MVABin = 2;
881	<	if (subdet == 0 && ptBin == 1) MVABin = 3;
882	<	if (subdet == 1 && ptBin == 1) MVABin = 4;
883	<	if (subdet == 2 && ptBin == 1) MVABin = 5;
884	<	assert(MVABin >= 0 && MVABin <= 5);
885	<	reader = fTMVAReader[MVABin];
886	<
877	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
878	>	mva = reader->EvaluateMVA( fMethodname );
879	>
880	>	if (printDebug == kTRUE) {
881	>	std::cout << "Debug Electron MVA: "
882	>	<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
883	>	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
884	>	<< fMVAVar_EleSigmaIEtaIEta << " "
885	>	<< fMVAVar_EleDEtaIn << " "
886	>	<< fMVAVar_EleDPhiIn << " "
887	>	<< fMVAVar_EleHoverE << " "
888	>	<< fMVAVar_EleD0 << " "
889	>	<< fMVAVar_EleDZ << " "
890	>	<< fMVAVar_EleFBrem << " "
891	>	<< fMVAVar_EleEOverP << " "
892	>	<< fMVAVar_EleESeedClusterOverPout << " "
893	>	<< fMVAVar_EleSigmaIPhiIPhi << " "
894	>	<< fMVAVar_EleNBrem << " "
895	>	<< fMVAVar_EleOneOverEMinusOneOverP << " "
896	>	<< fMVAVar_EleESeedClusterOverPIn << " "
897	>	<< fMVAVar_EleIP3d << " "
898	>	<< fMVAVar_EleIP3dSig << " "
899	>	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
900	>	<< fMVAVar_EledEtaCalo << " "
901	>	<< fMVAVar_EledPhiCalo << " "
902	>	<< fMVAVar_EleR9 << " "
903	>	<< fMVAVar_EleSCEtaWidth << " "
904	>	<< fMVAVar_EleSCPhiWidth << " "
905	>	<< fMVAVar_EleCovIEtaIPhi << " "
906	>	<< fMVAVar_ElePreShowerOverRaw << " "
907	>	<< fMVAVar_EleKFTrkChiSqr  << " "
908	>	<< fMVAVar_EleKFTrkNHits  << " "
909	>	<< fMVAVar_EleE1x5OverE5x5  << " "
910	>	<< " ::: "
911	>
912	>	<< " === : === "
913	>	<< mva << " "
914	>	<< std::endl;
915	>
916	>	}
917	>
918	>	return mva;
919	>	}
920	>
921	>	//--------------------------------------------------------------------------------------------------
922	>	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
923	>	Bool_t printDebug) {
924	>
925	>	if (!fIsInitialized) {
926	>	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
927	>	return -9999;
928	>	}
929	>
930	>	fMVAVar_ElePt = ele->Pt();
931	>	fMVAVar_EleEta = ele->Eta();
932	>
933	>	//set all input variables
934	>	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
935	>	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
936	>	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
937	>	fMVAVar_EleHoverE = ele->HadronicOverEm();
938	>	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
939	>	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
940	>	fMVAVar_EleFBrem = ele->FBrem();
941	>	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
942	>	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
943	>	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
944	>	else fMVAVar_EleSigmaIPhiIPhi = 0;
945	>	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
946	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
947	>	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
948	>	fMVAVar_EleIP3d = ele->Ip3dPV();
949	>	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
950	>
951	>
952	>	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
953	>	if (ele->TrackerTrk()) {
954	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
955	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
956	>	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
957	>	} else {
958	>	fMVAVar_EleKFTrkChiSqr = -1;
959	>	fMVAVar_EleKFTrkNHits = 0;
960	>	fMVAVar_EleKFTrkNLayers = 0;
961	>	}
962	>	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
963	>	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
964	>	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
965	>	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
966	>	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
967	>	fMVAVar_EleR9 = ele->SCluster()->R9();
968	>	fMVAVar_EleHoverE = ele->HadronicOverEm();
969	>	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
970	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
971	>	fMVAVar_EleR9 = ele->SCluster()->R9();
972	>	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
973	>
974	>
975	>	Double_t mva = -9999;
976	>	TMVA::Reader *reader = 0;
977	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
978	>	mva = reader->EvaluateMVA( fMethodname );
979	>
980	>	if (printDebug == kTRUE) {
981	>	std::cout << "Debug Electron MVA: "
982	>	<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
983	>	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
984	>	<< fMVAVar_EleSigmaIEtaIEta << " "
985	>	<< fMVAVar_EleDEtaIn << " "
986	>	<< fMVAVar_EleDPhiIn << " "
987	>	<< fMVAVar_EleHoverE << " "
988	>	<< fMVAVar_EleD0 << " "
989	>	<< fMVAVar_EleDZ << " "
990	>	<< fMVAVar_EleFBrem << " "
991	>	<< fMVAVar_EleEOverP << " "
992	>	<< fMVAVar_EleESeedClusterOverPout << " "
993	>	<< fMVAVar_EleSigmaIPhiIPhi << " "
994	>	<< fMVAVar_EleNBrem << " "
995	>	<< fMVAVar_EleOneOverEMinusOneOverP << " "
996	>	<< fMVAVar_EleESeedClusterOverPIn << " "
997	>	<< fMVAVar_EleIP3d << " "
998	>	<< fMVAVar_EleIP3dSig << " "
999	>	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
1000	>	<< fMVAVar_EledEtaCalo << " "
1001	>	<< fMVAVar_EledPhiCalo << " "
1002	>	<< fMVAVar_EleR9 << " "
1003	>	<< fMVAVar_EleSCEtaWidth << " "
1004	>	<< fMVAVar_EleSCPhiWidth << " "
1005	>	<< fMVAVar_EleCovIEtaIPhi << " "
1006	>	<< fMVAVar_ElePreShowerOverRaw << " "
1007	>	<< fMVAVar_EleKFTrkChiSqr  << " "
1008	>	<< fMVAVar_EleKFTrkNHits  << " "
1009	>	<< fMVAVar_EleE1x5OverE5x5  << " "
1010	>	<< " === : === "
1011	>	<< mva << " "
1012	>	<< std::endl;
1013	>
1014	>	}
1015	>
1016	>
1017	>
1018	>	return mva;
1019	>	}
1020	>
1021	>
1022	>	//--------------------------------------------------------------------------------------------------
1023	>	//MVA Includes Isolation with removal of other leptons
1024	>	//
1025	>	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
1026	>	const PFCandidateCol *PFCands,
1027	>	const PileupEnergyDensityCol *PileupEnergyDensity,
1028	>	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaTarget,
1029	>	const ElectronCol *goodElectrons,
1030	>	const MuonCol *goodMuons,
1031	>	Bool_t printDebug) {
1032	>
1033	>	if (!fIsInitialized) {
1034	>	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
1035	>	return -9999;
1036	>	}
1037	>
1038	>	Double_t Rho = 0;
1039	>	switch(fTheRhoType) {
1040	>	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
1041	>	Rho = PileupEnergyDensity->At(0)->Rho();
1042	>	break;
1043	>	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
1044	>	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
1045	>	break;
1046	>	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
1047	>	Rho = PileupEnergyDensity->At(0)->RhoRandom();
1048	>	break;
1049	>	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
1050	>	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
1051	>	break;
1052	>	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
1053	>	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
1054	>	break;
1055	>	default:
1056	>	// use the old default
1057	>	Rho = PileupEnergyDensity->At(0)->Rho();
1058	>	break;
1059	>	}
1060	>
1061	>	//set all input variables
1062	>	fMVAVar_ElePt = ele->Pt();
1063	>	fMVAVar_EleEta = ele->SCluster()->Eta();
1064	>	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
1065	>
1066	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1067	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1068	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1069	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
1070	>	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
1071	>	fMVAVar_EleDPhiIn = TMath::Min(fabs(double(ele->DeltaPhiSuperClusterTrackAtVtx())),0.6);
1072	>	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
1073	>	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
1074	>	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
1075	>	fMVAVar_EleEEleClusterOverPout = TMath::Min(double(ele->EEleClusterOverPout()),20.0);
1076	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->P();
1077	>	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
1078	>	fMVAVar_EledEtaCalo =  TMath::Min(fabs(double(ele->DeltaEtaSeedClusterTrackAtCalo())),0.2);
1079	>	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
1080	>	} else {
1081	>	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
1082	>	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
1083	>	fMVAVar_EleFBrem = ele->FBrem();
1084	>	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
1085	>	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
1086	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
1087	>	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
1088	>	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1089	>	fMVAVar_EleR9 = ele->SCluster()->R9();
1090	>	}
1091	>
1092	>	fMVAVar_EleHoverE = ele->HadronicOverEm();
1093	>	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
1094	>	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
1095	>	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
1096	>	else {
1097	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1) {
1098	>	fMVAVar_EleSigmaIPhiIPhi = 0;
1099	>	} else {
1100	>	fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
1101	>	}
1102	>	}
1103	>
1104	>	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
1105	>	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
1106	>	fMVAVar_EleIP3d = ele->Ip3dPV();
1107	>	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
1108	>	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
1109	>	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
1110	>	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
1111	>	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
1112	>	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
1113	>
1114	>	//Additional vars
1115	>	if (ele->TrackerTrk()) {
1116	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1117	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1118	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1119	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
1120	>	fMVAVar_EleKFTrkChiSqr = TMath::Min(double(ele->TrackerTrk()->RChi2()),10.0);
1121	>	} else {
1122	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
1123	>	}
1124	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
1125	>	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
1126	>	} else {
1127	>	fMVAVar_EleKFTrkChiSqr = 0;
1128	>	fMVAVar_EleKFTrkNHits = -1;
1129	>	fMVAVar_EleKFTrkNLayers = -1;
1130	>	}
1131	>
1132	>	if( ele->SCluster()->Seed()->E5x5() > 0.0 ) {
1133	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1134	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1135	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1136	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
1137	>	fMVAVar_EleE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1138	>	} else {
1139	>	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5();
1140	>	}
1141	>	} else {
1142	>	fMVAVar_EleE1x5OverE5x5 = -1.0;
1143	>	}
1144	>
1145	>
1146	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1147	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1148	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1149	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
1150	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
1151	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1152	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1153	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1154	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
1155	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
1156	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1157	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1158	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1159	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1160	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1161	>
1162	>	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
1163	>	const PFCandidate *pf = PFCands->At(p);
1164	>
1165	>	//exclude the electron itself
1166	>	if(pf->GsfTrk() && ele->GsfTrk() &&
1167	>	pf->GsfTrk() == ele->GsfTrk()) continue;
1168	>	if(pf->TrackerTrk() && ele->TrackerTrk() &&
1169	>	pf->TrackerTrk() == ele->TrackerTrk()) continue;
1170	>
1171	>	//************************************************************
1172	>	// New Isolation Calculations
1173	>	//************************************************************
1174	>	Double_t dr = MathUtils::DeltaR(ele->Mom(), pf->Mom());
1175	>
1176	>	if (dr < 1.0) {
1177	>	Bool_t IsLeptonFootprint = kFALSE;
1178	>	//************************************************************
1179	>	// Lepton Footprint Removal
1180	>	//************************************************************
1181	>	if(goodElectrons) {
1182	>	for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) {
1183	>	//if pf candidate matches an electron passing ID cuts, then veto it
1184	>	if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() &&
1185	>	pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE;
1186	>	if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() &&
1187	>	pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1188	>	//if pf candidate lies in veto regions of electron passing ID cuts, then veto it
1189	>	if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479
1190	>	&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE;
1191	>	if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 &&
1192	>	MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE;
1193	>	}
1194	>	}
1195	>	if(goodMuons) {
1196	>	for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) {
1197	>	//if pf candidate matches an muon passing ID cuts, then veto it
1198	>	if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() &&
1199	>	pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1200	>	//if pf candidate lies in veto regions of muon passing ID cuts, then veto it
1201	>	if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE;
1202	>	}
1203	>	}
1204	>
1205	>	if (!IsLeptonFootprint) {
1206	>	Bool_t passVeto = kTRUE;
1207	>	//Charged
1208	>	if(pf->BestTrk()) {
1209	>	if (!(fabs(pf->BestTrk()->DzCorrected(*vertex) - ele->BestTrk()->DzCorrected(*vertex)) < 0.2)) passVeto = kFALSE;
1210	>	//************************************************************
1211	>	// Veto any PFmuon, or PFEle
1212	>	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
1213	>	//************************************************************
1214	>	//************************************************************
1215	>	// Footprint Veto
1216	>	if (fabs(ele->SCluster()->Eta()) >= 1.479 && dr < 0.015) passVeto = kFALSE;
1217	>	//************************************************************
1218	>	if (passVeto) {
1219	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1220	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1221	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1222	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1223	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1224	>	} //pass veto
1225	>
1226	>	}
1227	>	//Gamma
1228	>	else if (pf->PFType() == PFCandidate::eGamma) {
1229	>	//************************************************************
1230	>	// Footprint Veto
1231	>	if (fabs(ele->SCluster()->Eta()) >= 1.479) {
1232	>	if (dr < 0.08) passVeto = kFALSE;
1233	>	}
1234	>	//************************************************************
1235	>
1236	>	if (passVeto) {
1237	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1238	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1239	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1240	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1241	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1242	>	}
1243	>	}
1244	>	//NeutralHadron
1245	>	else {
1246	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1247	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1248	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1249	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1250	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1251	>	}
1252	>	} //not lepton footprint
1253	>	} //in 1.0 dr cone
1254	>	} //loop over PF candidates
1255	>
1256	>	fMVAVar_ChargedIso_DR0p0To0p1   = TMath::Min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1257	>	fMVAVar_ChargedIso_DR0p1To0p2   = TMath::Min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1258	>	fMVAVar_ChargedIso_DR0p2To0p3 = TMath::Min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1259	>	fMVAVar_ChargedIso_DR0p3To0p4 = TMath::Min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1260	>	fMVAVar_ChargedIso_DR0p4To0p5 = TMath::Min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1261	>	fMVAVar_GammaIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpGammaIso_DR0p0To0p1 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p0To0p1, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1262	>	fMVAVar_GammaIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpGammaIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1263	>	fMVAVar_GammaIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpGammaIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1264	>	fMVAVar_GammaIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpGammaIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1265	>	fMVAVar_GammaIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpGammaIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1266	>	fMVAVar_NeutralHadronIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p0To0p1 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p0To0p1, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1267	>	fMVAVar_NeutralHadronIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1268	>	fMVAVar_NeutralHadronIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1269	>	fMVAVar_NeutralHadronIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1270	>	fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1271	>
1272	>	//Do Binding of MVA input variables
1273	>	if (   fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1274	>	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
1275	>	|| fMVAType == ElectronIDMVA::kIsoRingsV0
1276	>	|| fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
1277	>	bindVariables();
1278	>	}
1279	>
1280	>	Double_t mva = -9999;
1281	>	TMVA::Reader *reader = 0;
1282	>
1283	>	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
1284	>	mva = reader->EvaluateMVA( fMethodname );
1285	>
1286	>	if (printDebug == kTRUE) {
1287	>
1288	>	std::cout << "Debug Electron MVA-ID: "
1289	>	<< fMVAVar_ElePt<< " " << fMVAVar_EleEta << " "
1290	>	<< " --> MVABin " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << " : "
1291	>	<< " fbrem " <<  fMVAVar_EleFBrem
1292	>	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
1293	>	<< " kfhits " << fMVAVar_EleKFTrkNLayers
1294	>	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1295	>	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
1296	>	<< " deta " <<  fMVAVar_EleDEtaIn
1297	>	<< " dphi " << fMVAVar_EleDPhiIn
1298	>	<< " detacalo " << fMVAVar_EledEtaCalo
1299	>	<< " see " << fMVAVar_EleSigmaIEtaIEta
1300	>	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
1301	>	<< " etawidth " << fMVAVar_EleSCEtaWidth
1302	>	<< " phiwidth " << fMVAVar_EleSCPhiWidth
1303	>	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
1304	>	<< " R9 " << fMVAVar_EleR9
1305	>	<< " HoE " << fMVAVar_EleHoverE
1306	>	<< " EoP " << fMVAVar_EleEOverP
1307	>	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
1308	>	<< " eleEoPout " << fMVAVar_EleEEleClusterOverPout
1309	>	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
1310	>	<< " PreShowerOverRaw" << fMVAVar_ElePreShowerOverRaw
1311	>	<< " d0 " << fMVAVar_EleD0
1312	>	<< " ip3d " << fMVAVar_EleIP3d
1313	>	<< " eta " << fMVAVar_EleEta
1314	>	<< " pt " << fMVAVar_ElePt
1315	>	<< " === : === "
1316	>	<< mva << " "
1317	>	<< std::endl;
1318	>	std::cout << "Debug Electron MVA-ISO: "
1319	>	<< fMVAVar_ChargedIso_DR0p0To0p1 << " "
1320	>	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1321	>	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1322	>	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
1323	>	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
1324	>	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
1325	>	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
1326	>	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
1327	>	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
1328	>	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
1329	>	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
1330	>	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
1331	>	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
1332	>	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1333	>	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
1334	>	<< std::endl;
1335	>	}
1336	>
1337	>	return mva;
1338	>	}
1339	>
1340	>
1341	>	//--------------------------------------------------------------------------------------------------
1342	>	//MVA Includes Isolation
1343	>	//
1344	>	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
1345	>	const VertexCol *primaryVertices,
1346	>	const PFCandidateCol *PFCands,
1347	>	const PileupEnergyDensityCol *PileupEnergyDensity,
1348	>	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaTarget,
1349	>	Bool_t printDebug) {
1350	>
1351	>	if (!fIsInitialized) {
1352	>	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
1353	>	return -9999;
1354	>	}
1355	>
1356	>	Double_t Rho = 0;
1357	>	switch(fTheRhoType) {
1358	>	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
1359	>	Rho = PileupEnergyDensity->At(0)->Rho();
1360	>	break;
1361	>	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
1362	>	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
1363	>	break;
1364	>	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
1365	>	Rho = PileupEnergyDensity->At(0)->RhoRandom();
1366	>	break;
1367	>	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
1368	>	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
1369	>	break;
1370	>	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
1371	>	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
1372	>	break;
1373	>	default:
1374	>	// use the old default
1375	>	Rho = PileupEnergyDensity->At(0)->Rho();
1376	>	break;
1377	>	}
1378	>
1379	>	//set all input variables
1380	>	fMVAVar_ElePt = ele->Pt();
1381	>	fMVAVar_EleEta = ele->SCluster()->Eta();
1382	>	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
1383	>
1384	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1385	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1386	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1387	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0
1388	>	) {
1389	>	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
1390	>	fMVAVar_EleDPhiIn = TMath::Min(fabs(double(ele->DeltaPhiSuperClusterTrackAtVtx())),0.6);
1391	>	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
1392	>	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
1393	>	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
1394	>	fMVAVar_EleEEleClusterOverPout = TMath::Min(double(ele->EEleClusterOverPout()),20.0);
1395	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->P();
1396	>	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
1397	>	fMVAVar_EledEtaCalo =  TMath::Min(fabs(double(ele->DeltaEtaSeedClusterTrackAtCalo())),0.2);
1398	>	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
1399	>	}
1400	>	else if (fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4) {
1401	>	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
1402	>	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
1403	>	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
1404	>	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
1405	>	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
1406	>	fMVAVar_EleEEleClusterOverPout = TMath::Min(double(ele->EEleClusterOverPout()),20.0);
1407	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->PIn();
1408	>	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
1409	>	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1410	>	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
1411	>	}
1412	>	else {
1413	>	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
1414	>	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
1415	>	fMVAVar_EleFBrem = ele->FBrem();
1416	>	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
1417	>	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
1418	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
1419	>	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
1420	>	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
1421	>	fMVAVar_EleR9 = ele->SCluster()->R9();
1422	>	}
1423	>
1424	>	fMVAVar_EleHoverE = ele->HadronicOverEm();
1425	>	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
1426	>	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
1427	>	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
1428	>	else {
1429	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ) {
1430	>	fMVAVar_EleSigmaIPhiIPhi = 0;
1431	>	} else {
1432	>	fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
1433	>	}
1434	>	}
1435	>
1436	>	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
1437	>	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
1438	>	fMVAVar_EleIP3d = ele->Ip3dPV();
1439	>	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
1440	>	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
1441	>	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
1442	>	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
1443	>	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
1444	>	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
1445	>
1446	>	//Additional vars
1447	>	if (ele->TrackerTrk()) {
1448	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1449	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1450	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1451	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ||
1452	>	fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
1453	>	) {
1454	>	fMVAVar_EleKFTrkChiSqr = TMath::Min(double(ele->TrackerTrk()->RChi2()),10.0);
1455	>	} else {
1456	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
1457	>	}
1458	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
1459	>	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
1460	>	} else {
1461	>	fMVAVar_EleKFTrkChiSqr = 0;
1462	>	fMVAVar_EleKFTrkNHits = -1;
1463	>	fMVAVar_EleKFTrkNLayers = -1;
1464	>	}
1465	>
1466	>	if( ele->SCluster()->Seed()->E5x5() > 0.0 ) {
1467	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1468	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1469	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV1 ||
1470	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ||
1471	>	fMVAType == ElectronIDMVA::kIDIsoCombinedHWW2012TrigV4
1472	>	) {
1473	>	fMVAVar_EleE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1474	>	fMVAVar_EleOneMinusE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1475	>	} else {
1476	>	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5();
1477	>	}
1478	>	} else {
1479	>	fMVAVar_EleE1x5OverE5x5 = -1.0;
1480	>	}
1481	>
1482	>
1483	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1484	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1485	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1486	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
1487	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
1488	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1489	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1490	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1491	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
1492	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
1493	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1494	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1495	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1496	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1497	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1498	>
1499	>	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
1500	>	const PFCandidate *pf = PFCands->At(p);
1501	>
1502	>	//************************************************************
1503	>	// New Isolation Calculations
1504	>	//************************************************************
1505	>	Double_t dr = MathUtils::DeltaR(ele->Mom(), pf->Mom());
1506	>
1507	>	if (dr < 0.5) {
1508	>
1509	>	Bool_t passVeto = kTRUE;
1510	>	//Charged
1511	>	if(pf->BestTrk()) {
1512	>
1513	>	//*************************************************
1514	>	//Use only PFNoPU
1515	>	//*************************************************
1516	>	Bool_t isPFNoPU = kFALSE;
1517	>	if(pf->PFType() == PFCandidate::eHadron) {
1518	>	if(pf->HasTrackerTrk() &&
1519	>	primaryVertices->At(0)->HasTrack(pf->TrackerTrk()) &&
1520	>	primaryVertices->At(0)->TrackWeight(pf->TrackerTrk()) > 0) {
1521	>	isPFNoPU = kTRUE;
1522	>	} else {
1523	>
1524	>	Bool_t vertexFound = kFALSE;
1525	>	const Vertex *closestVtx = 0;
1526	>	Double_t dzmin = 10000;
1527	>
1528	>	// loop over vertices
1529	>	for(UInt_t j = 0; j < primaryVertices->GetEntries(); j++) {
1530	>	const Vertex *vtx = primaryVertices->At(j);
1531	>	assert(vtx);
1532	>
1533	>	if(pf->HasTrackerTrk() &&
1534	>	vtx->HasTrack(pf->TrackerTrk()) &&
1535	>	vtx->TrackWeight(pf->TrackerTrk()) > 0) {
1536	>	vertexFound = kTRUE;
1537	>	closestVtx = vtx;
1538	>	break;
1539	>	}
1540	>	Double_t dz = fabs(pf->SourceVertex().Z() - vtx->Z());
1541	>	if(dz < dzmin) {
1542	>	closestVtx = vtx;
1543	>	dzmin = dz;
1544	>	}
1545	>	}
1546	>
1547	>	Bool_t fCheckClosestZVertex = kTRUE; //we use option 1
1548	>	if(fCheckClosestZVertex) {
1549	>	// Fallback: if track is not associated with any vertex,
1550	>	// associate it with the vertex closest in z
1551	>	if(vertexFound || closestVtx != vertex) {
1552	>	isPFNoPU = kFALSE;
1553	>	} else {
1554	>	isPFNoPU = kTRUE;
1555	>	}
1556	>	} else {
1557	>	if(vertexFound && closestVtx != vertex) {
1558	>	isPFNoPU = kFALSE;
1559	>	} else {
1560	>	isPFNoPU = kTRUE;
1561	>	}
1562	>	}
1563	>	} //hadron & trk stuff
1564	>	} else { // hadron
1565	>	//
1566	>	isPFNoPU = kTRUE;
1567	>	}
1568	>	if (!isPFNoPU) continue;
1569	>
1570	>	//************************************************************
1571	>	// Veto any PFmuon, or PFEle
1572	>	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
1573	>	//************************************************************
1574	>	//************************************************************
1575	>	// Footprint Veto
1576	>	if (fabs(ele->SCluster()->Eta()) >= 1.479 && dr < 0.015) passVeto = kFALSE;
1577	>	//************************************************************
1578	>	if (passVeto) {
1579	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1580	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1581	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1582	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1583	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1584	>	} //pass veto
1585	>
1586	>	}
1587	>	//Gamma
1588	>	else if (pf->PFType() == PFCandidate::eGamma) {
1589	>	//************************************************************
1590	>	// Footprint Veto
1591	>	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1592	>	if (dr < 0.08) passVeto = kFALSE;
1593	>	}
1594	>	//************************************************************
1595	>
1596	>	if (passVeto) {
1597	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1598	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1599	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1600	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1601	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1602	>	}
1603	>	}
1604	>	//NeutralHadron
1605	>	else {
1606	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1607	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1608	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1609	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1610	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1611	>	}
1612	>	} //in 1.0 dr cone
1613	>	} //loop over PF candidates
1614	>
1615	>	fMVAVar_ChargedIso_DR0p0To0p1   = tmpChargedIso_DR0p0To0p1/ele->Pt();
1616	>	fMVAVar_ChargedIso_DR0p1To0p2   = tmpChargedIso_DR0p1To0p2/ele->Pt();
1617	>	fMVAVar_ChargedIso_DR0p2To0p3 = tmpChargedIso_DR0p2To0p3/ele->Pt();
1618	>	fMVAVar_ChargedIso_DR0p3To0p4 = tmpChargedIso_DR0p3To0p4/ele->Pt();
1619	>	fMVAVar_ChargedIso_DR0p4To0p5 = tmpChargedIso_DR0p4To0p5/ele->Pt();
1620	>	fMVAVar_GammaIso_DR0p0To0p1 = tmpGammaIso_DR0p0To0p1/ele->Pt();
1621	>	fMVAVar_GammaIso_DR0p1To0p2 = tmpGammaIso_DR0p1To0p2/ele->Pt();
1622	>	fMVAVar_GammaIso_DR0p2To0p3 = tmpGammaIso_DR0p2To0p3/ele->Pt();
1623	>	fMVAVar_GammaIso_DR0p3To0p4 = tmpGammaIso_DR0p3To0p4/ele->Pt();
1624	>	fMVAVar_GammaIso_DR0p4To0p5 = tmpGammaIso_DR0p4To0p5/ele->Pt();
1625	>	fMVAVar_NeutralHadronIso_DR0p0To0p1 = tmpNeutralHadronIso_DR0p0To0p1/ele->Pt();
1626	>	fMVAVar_NeutralHadronIso_DR0p1To0p2 = tmpNeutralHadronIso_DR0p1To0p2/ele->Pt();
1627	>	fMVAVar_NeutralHadronIso_DR0p2To0p3 = tmpNeutralHadronIso_DR0p2To0p3/ele->Pt();
1628	>	fMVAVar_NeutralHadronIso_DR0p3To0p4 = tmpNeutralHadronIso_DR0p3To0p4/ele->Pt();
1629	>	fMVAVar_NeutralHadronIso_DR0p4To0p5 = tmpNeutralHadronIso_DR0p4To0p5/ele->Pt();
1630	>	fMVAVar_Rho = Rho;
1631	>
1632	>	//Do Binding of MVA input variables
1633	>	if (   fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1634	>	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
1635	>	|| fMVAType == ElectronIDMVA::kIsoRingsV0
1636	>	|| fMVAType == ElectronIDMVA::kIDHWW2012TrigV0
1637	>	) {
1638	>	bindVariables();
1639	>	}
1640	>
1641	>	Double_t mva = -9999;
1642	>	TMVA::Reader *reader = 0;
1643	>
1644	>	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
1645		mva = reader->EvaluateMVA( fMethodname );
1646
1647	+	if (printDebug == kTRUE) {
1648	+
1649	+	std::cout << "Debug Electron MVA-ID: "
1650	+	<< fMVAVar_ElePt<< " " << fMVAVar_EleEta << " "
1651	+	<< " --> MVABin " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << " : "
1652	+	<< " fbrem " <<  fMVAVar_EleFBrem
1653	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
1654	+	<< " kfhits " << fMVAVar_EleKFTrkNLayers
1655	+	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1656	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
1657	+	<< " deta " <<  fMVAVar_EleDEtaIn
1658	+	<< " dphi " << fMVAVar_EleDPhiIn
1659	+	<< " detacalo " << fMVAVar_EledEtaCalo
1660	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
1661	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
1662	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
1663	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
1664	+	<< " e1x5e5x5 " << fMVAVar_EleOneMinusE1x5OverE5x5
1665	+	<< " R9 " << fMVAVar_EleR9
1666	+	<< " HoE " << fMVAVar_EleHoverE
1667	+	<< " EoP " << fMVAVar_EleEOverP
1668	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
1669	+	<< " eleEoPout " << fMVAVar_EleEEleClusterOverPout
1670	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
1671	+	<< " PreShowerOverRaw" << fMVAVar_ElePreShowerOverRaw
1672	+	<< " d0 " << fMVAVar_EleD0
1673	+	<< " ip3d " << fMVAVar_EleIP3d
1674	+	<< " eta " << fMVAVar_EleEta
1675	+	<< " pt " << fMVAVar_ElePt
1676	+	<< " === : === "
1677	+	<< mva << " "
1678	+	<< std::endl;
1679	+	std::cout << "Debug Electron MVA-ISO: "
1680	+	<< fMVAVar_ChargedIso_DR0p0To0p1 << " "
1681	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1682	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1683	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
1684	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
1685	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
1686	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
1687	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
1688	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
1689	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
1690	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
1691	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
1692	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
1693	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1694	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
1695	+	<< fMVAVar_Rho << " "
1696	+	<< std::endl;
1697	+	}
1698	+
1699		return mva;
1700		}
1701	+
1702	+
1703	+	void ElectronIDMVA::bindVariables() {
1704	+
1705	+	// this binding is needed for variables that sometime diverge.
1706	+
1707	+	if(fMVAVar_EleFBrem < -1.)
1708	+	fMVAVar_EleFBrem = -1.;
1709	+
1710	+	fMVAVar_EleDEtaIn = fabs(fMVAVar_EleDEtaIn);
1711	+	if(fMVAVar_EleDEtaIn > 0.06)
1712	+	fMVAVar_EleDEtaIn = 0.06;
1713	+
1714	+
1715	+	fMVAVar_EleDPhiIn = fabs(fMVAVar_EleDPhiIn);
1716	+	if(fMVAVar_EleDPhiIn > 0.6)
1717	+	fMVAVar_EleDPhiIn = 0.6;
1718	+
1719	+
1720	+	if(fMVAVar_EleESeedClusterOverPout > 20.)
1721	+	fMVAVar_EleESeedClusterOverPout = 20.;
1722	+
1723	+	if(fMVAVar_EleEOverP > 20.)
1724	+	fMVAVar_EleEOverP = 20.;
1725	+
1726	+	if(fMVAVar_EleEEleClusterOverPout > 20.)
1727	+	fMVAVar_EleEEleClusterOverPout = 20.;
1728	+
1729	+
1730	+	fMVAVar_EledEtaCalo = fabs(fMVAVar_EledEtaCalo);
1731	+	if(fMVAVar_EledEtaCalo > 0.2)
1732	+	fMVAVar_EledEtaCalo = 0.2;
1733	+
1734	+
1735	+	if(fMVAVar_EleE1x5OverE5x5 < -1.)
1736	+	fMVAVar_EleE1x5OverE5x5 = -1;
1737	+
1738	+	if(fMVAVar_EleE1x5OverE5x5 > 2.)
1739	+	fMVAVar_EleE1x5OverE5x5 = 2.;
1740	+
1741	+
1742	+
1743	+	if(fMVAVar_EleR9 > 5)
1744	+	fMVAVar_EleR9 = 5;
1745	+
1746	+	if(fMVAVar_EleGsfTrackChi2OverNdof > 200.)
1747	+	fMVAVar_EleGsfTrackChi2OverNdof = 200;
1748	+
1749	+
1750	+	if(fMVAVar_EleKFTrkChiSqr > 10.)
1751	+	fMVAVar_EleKFTrkChiSqr = 10.;
1752	+
1753	+	// Needed for a bug in CMSSW_420, fixed in more recent CMSSW versions
1754	+	if(std::isnan(fMVAVar_EleSigmaIPhiIPhi))
1755	+	fMVAVar_EleSigmaIPhiIPhi = 0.;
1756	+
1757	+
1758	+	return;
1759	+	}

Diff Legend

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