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.21 by vdutta, Thu May 3 16:42:56 2012 UTC

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

Diff Legend

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