ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitPhysics/Utils/src/MuonIDMVA.cc

Comparing UserCode/MitPhysics/Utils/src/MuonIDMVA.cc (file contents):
Revision 1.1 by sixie, Fri Dec 16 12:58:13 2011 UTC vs.
Revision 1.7 by sixie, Mon Jan 23 20:05:41 2012 UTC

#	Line 52 | Line 52 | void MuonIDMVA::Initialize( TString meth
52		fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );
53		fTMVAReader[i]->SetVerbose(kTRUE);
54
55	+	if (type == kV2) {
56	+	fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
57	+	fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
58	+	fTMVAReader[i]->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
59	+	fTMVAReader[i]->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
60	+	fTMVAReader[i]->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
61	+	fTMVAReader[i]->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
62	+	fTMVAReader[i]->AddVariable( "D0",                   &fMVAVar_MuD0                    );
63	+	fTMVAReader[i]->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
64	+	fTMVAReader[i]->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
65	+	fTMVAReader[i]->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
66	+	fTMVAReader[i]->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
67	+	}
68	+
69		if (type == kV3) {
70		fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
71		fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
#	Line 76 | Line 90 | void MuonIDMVA::Initialize( TString meth
90		}
91		fTMVAReader[i]->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
92		}
93	+
94	+	if (type == kV8) {
95	+	fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
96	+	fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
97	+	fTMVAReader[i]->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
98	+	fTMVAReader[i]->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
99	+	fTMVAReader[i]->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
100	+	fTMVAReader[i]->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
101	+	fTMVAReader[i]->AddVariable( "D0",                   &fMVAVar_MuD0                    );
102	+	fTMVAReader[i]->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
103	+	fTMVAReader[i]->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
104	+	fTMVAReader[i]->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
105	+	fTMVAReader[i]->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
106	+	fTMVAReader[i]->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
107	+	fTMVAReader[i]->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
108	+	fTMVAReader[i]->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
109	+	fTMVAReader[i]->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
110	+	fTMVAReader[i]->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
111	+	fTMVAReader[i]->AddVariable( "ChargedIso03OverPt",   &fMVAVar_MuChargedIso03OverPt    );
112	+	fTMVAReader[i]->AddVariable( "NeutralIso03OverPt",   &fMVAVar_MuNeutralIso03OverPt    );
113	+	fTMVAReader[i]->AddVariable( "ChargedIso04OverPt",   &fMVAVar_MuChargedIso04OverPt    );
114	+	fTMVAReader[i]->AddVariable( "NeutralIso04OverPt",   &fMVAVar_MuNeutralIso04OverPt    );
115	+	}
116	+
117	+	if (type == kIDIsoCombinedDetIso) {
118	+	fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
119	+	fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
120	+	fTMVAReader[i]->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
121	+	fTMVAReader[i]->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
122	+	fTMVAReader[i]->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
123	+	fTMVAReader[i]->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
124	+	fTMVAReader[i]->AddVariable( "D0",                   &fMVAVar_MuD0                    );
125	+	fTMVAReader[i]->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
126	+	fTMVAReader[i]->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
127	+	fTMVAReader[i]->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
128	+	fTMVAReader[i]->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
129	+	fTMVAReader[i]->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
130	+	fTMVAReader[i]->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
131	+	fTMVAReader[i]->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
132	+	fTMVAReader[i]->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
133	+	fTMVAReader[i]->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
134	+	fTMVAReader[i]->AddVariable( "TrkIso03OverPt",       &fMVAVar_MuTrkIso03OverPt        );
135	+	fTMVAReader[i]->AddVariable( "EMIso03OverPt",        &fMVAVar_MuEMIso03OverPt         );
136	+	fTMVAReader[i]->AddVariable( "HadIso03OverPt",       &fMVAVar_MuHadIso03OverPt        );
137	+	fTMVAReader[i]->AddVariable( "TrkIso05OverPt",       &fMVAVar_MuTrkIso05OverPt        );
138	+	fTMVAReader[i]->AddVariable( "EMIso05OverPt",        &fMVAVar_MuEMIso05OverPt         );
139	+	fTMVAReader[i]->AddVariable( "HadIso05OverPt",       &fMVAVar_MuHadIso05OverPt        );
140	+
141	+	}
142
143		if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To14p5Weights );
144		if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To14p5Weights );
#	Line 99 | Line 162 | void MuonIDMVA::Initialize( TString meth
162
163		//--------------------------------------------------------------------------------------------------
164		Double_t MuonIDMVA::MVAValue(Double_t MuPt , Double_t MuEta,
165	<	Double_t                   MuTkNchi2,
166	<	Double_t                   MuGlobalNchi2,
167	<	Double_t                   MuNValidHits,
168	<	Double_t                   MuNTrackerHits,
169	<	Double_t                   MuNPixelHits,
170	<	Double_t                   MuNMatches,
171	<	Double_t                   MuD0,
172	<	Double_t                   MuIP3d,
173	<	Double_t                   MuIP3dSig,
174	<	Double_t                   MuTrkKink,
175	<	Double_t                   MuSegmentCompatibility,
176	<	Double_t                   MuCaloCompatibility,
177	<	Double_t                   MuHadEnergyOverPt,
178	<	Double_t                   MuHoEnergyOverPt,
179	<	Double_t                   MuEmEnergyOverPt,
180	<	Double_t                   MuHadS9EnergyOverPt,
181	<	Double_t                   MuHoS9EnergyOverPt,
182	<	Double_t                   MuEmS9EnergyOverPt
165	>	Double_t                   MuTkNchi2,
166	>	Double_t                   MuGlobalNchi2,
167	>	Double_t                   MuNValidHits,
168	>	Double_t                   MuNTrackerHits,
169	>	Double_t                   MuNPixelHits,
170	>	Double_t                   MuNMatches,
171	>	Double_t                   MuD0,
172	>	Double_t                   MuIP3d,
173	>	Double_t                   MuIP3dSig,
174	>	Double_t                   MuTrkKink,
175	>	Double_t                   MuSegmentCompatibility,
176	>	Double_t                   MuCaloCompatibility,
177	>	Double_t                   MuHadEnergyOverPt,
178	>	Double_t                   MuHoEnergyOverPt,
179	>	Double_t                   MuEmEnergyOverPt,
180	>	Double_t                   MuHadS9EnergyOverPt,
181	>	Double_t                   MuHoS9EnergyOverPt,
182	>	Double_t                   MuEmS9EnergyOverPt,
183	>	Double_t                   MuChargedIso03OverPt,
184	>	Double_t                   MuNeutralIso03OverPt,
185	>	Double_t                   MuChargedIso04OverPt,
186	>	Double_t                   MuNeutralIso04OverPt,
187	>	Bool_t                     printDebug
188		) {
189
190		if (!fIsInitialized) {
#	Line 151 | Line 219 | Double_t MuonIDMVA::MVAValue(Double_t Mu
219		fMVAVar_MuHadS9EnergyOverPt    = MuHadS9EnergyOverPt;
220		fMVAVar_MuHoS9EnergyOverPt     = MuHoS9EnergyOverPt;
221		fMVAVar_MuEmS9EnergyOverPt     = MuEmS9EnergyOverPt;
222	+	fMVAVar_MuChargedIso03OverPt   = MuChargedIso03OverPt;
223	+	fMVAVar_MuNeutralIso03OverPt   = MuNeutralIso03OverPt;
224	+	fMVAVar_MuChargedIso04OverPt   = MuChargedIso04OverPt;
225	+	fMVAVar_MuNeutralIso04OverPt   = MuNeutralIso04OverPt;
226	+
227	+	Double_t mva = -9999;
228	+	TMVA::Reader *reader = 0;
229	+
230	+	Int_t MVABin = -1;
231	+	if (subdet == 0 && ptBin == 0) MVABin = 0;
232	+	if (subdet == 1 && ptBin == 0) MVABin = 1;
233	+	if (subdet == 0 && ptBin == 1) MVABin = 2;
234	+	if (subdet == 1 && ptBin == 1) MVABin = 3;
235	+	if (subdet == 0 && ptBin == 2) MVABin = 4;
236	+	if (subdet == 1 && ptBin == 2) MVABin = 5;
237	+	assert(MVABin >= 0 && MVABin <= 5);
238	+	reader = fTMVAReader[MVABin];
239	+
240	+	mva = reader->EvaluateMVA( fMethodname );
241	+
242	+	if (printDebug) {
243	+	std::cout << "Debug Muon MVA: "
244	+	<< MuPt << " " << MuEta << " --> MVABin " << MVABin << " : "
245	+	<< fMVAVar_MuTkNchi2              << " "
246	+	<< fMVAVar_MuGlobalNchi2          << " "
247	+	<< fMVAVar_MuNValidHits           << " "
248	+	<< fMVAVar_MuNTrackerHits         << " "
249	+	<< fMVAVar_MuNPixelHits           << " "
250	+	<< fMVAVar_MuNMatches             << " "
251	+	<< fMVAVar_MuD0                   << " "
252	+	<< fMVAVar_MuIP3d                 << " "
253	+	<< fMVAVar_MuIP3dSig              << " "
254	+	<< fMVAVar_MuTrkKink              << " "
255	+	<< fMVAVar_MuSegmentCompatibility << " "
256	+	<< fMVAVar_MuCaloCompatibility    << " "
257	+	<< fMVAVar_MuHadEnergyOverPt      << " "
258	+	<< fMVAVar_MuHoEnergyOverPt       << " "
259	+	<< fMVAVar_MuEmEnergyOverPt       << " "
260	+	<< fMVAVar_MuHadS9EnergyOverPt    << " "
261	+	<< fMVAVar_MuHoS9EnergyOverPt     << " "
262	+	<< fMVAVar_MuEmS9EnergyOverPt     << " "
263	+	<< fMVAVar_MuChargedIso03OverPt   << " "
264	+	<< fMVAVar_MuNeutralIso03OverPt   << " "
265	+	<< fMVAVar_MuChargedIso04OverPt   << " "
266	+	<< fMVAVar_MuNeutralIso04OverPt   << " "
267	+	<< " === : === "
268	+	<< mva
269	+	<< std::endl;
270	+	}
271	+
272	+	return mva;
273	+	}
274	+
275
276	+	//--------------------------------------------------------------------------------------------------
277	+	Double_t MuonIDMVA::MVAValue(Double_t MuPt , Double_t MuEta,
278	+	Double_t                   MuTkNchi2,
279	+	Double_t                   MuGlobalNchi2,
280	+	Double_t                   MuNValidHits,
281	+	Double_t                   MuNTrackerHits,
282	+	Double_t                   MuNPixelHits,
283	+	Double_t                   MuNMatches,
284	+	Double_t                   MuD0,
285	+	Double_t                   MuIP3d,
286	+	Double_t                   MuIP3dSig,
287	+	Double_t                   MuTrkKink,
288	+	Double_t                   MuSegmentCompatibility,
289	+	Double_t                   MuCaloCompatibility,
290	+	Double_t                   MuHadEnergyOverPt,
291	+	Double_t                   MuHoEnergyOverPt,
292	+	Double_t                   MuEmEnergyOverPt,
293	+	Double_t                   MuHadS9EnergyOverPt,
294	+	Double_t                   MuHoS9EnergyOverPt,
295	+	Double_t                   MuEmS9EnergyOverPt,
296	+	Double_t                   MuTrkIso03OverPt,
297	+	Double_t                   MuEMIso03OverPt,
298	+	Double_t                   MuHadIso03OverPt,
299	+	Double_t                   MuTrkIso05OverPt,
300	+	Double_t                   MuEMIso05OverPt,
301	+	Double_t                   MuHadIso05OverPt,
302	+	Bool_t                     printDebug
303	+	) {
304	+
305	+	if (!fIsInitialized) {
306	+	std::cout << "Error: MuonIDMVA not properly initialized.\n";
307	+	return -9999;
308	+	}
309	+
310	+	Int_t subdet = 0;
311	+	if (fabs(MuEta) < 1.479) subdet = 0;
312	+	else subdet = 1;
313	+	Int_t ptBin = 0;
314	+	if (MuPt > 14.5) ptBin = 1;
315	+	if (MuPt > 20.0) ptBin = 2;
316	+
317	+
318	+	//set all input variables
319	+	fMVAVar_MuTkNchi2              = MuTkNchi2;
320	+	fMVAVar_MuGlobalNchi2          = MuGlobalNchi2;
321	+	fMVAVar_MuNValidHits           = MuNValidHits;
322	+	fMVAVar_MuNTrackerHits         = MuNTrackerHits;
323	+	fMVAVar_MuNPixelHits           = MuNPixelHits;
324	+	fMVAVar_MuNMatches             = MuNMatches;
325	+	fMVAVar_MuD0                   = MuD0;
326	+	fMVAVar_MuIP3d                 = MuIP3d;
327	+	fMVAVar_MuIP3dSig              = MuIP3dSig;
328	+	fMVAVar_MuTrkKink              = MuTrkKink;
329	+	fMVAVar_MuSegmentCompatibility = MuSegmentCompatibility;
330	+	fMVAVar_MuCaloCompatibility    = MuCaloCompatibility;
331	+	fMVAVar_MuHadEnergyOverPt      = MuHadEnergyOverPt;
332	+	fMVAVar_MuHoEnergyOverPt       = MuHoEnergyOverPt;
333	+	fMVAVar_MuEmEnergyOverPt       = MuEmEnergyOverPt;
334	+	fMVAVar_MuHadS9EnergyOverPt    = MuHadS9EnergyOverPt;
335	+	fMVAVar_MuHoS9EnergyOverPt     = MuHoS9EnergyOverPt;
336	+	fMVAVar_MuEmS9EnergyOverPt     = MuEmS9EnergyOverPt;
337	+	fMVAVar_MuTrkIso03OverPt       = MuTrkIso03OverPt;
338	+	fMVAVar_MuEMIso03OverPt        = MuEMIso03OverPt;
339	+	fMVAVar_MuHadIso03OverPt       = MuHadIso03OverPt;
340	+	fMVAVar_MuTrkIso05OverPt       = MuTrkIso05OverPt;
341	+	fMVAVar_MuEMIso05OverPt        = MuEMIso05OverPt;
342	+	fMVAVar_MuHadIso05OverPt       = MuHadIso05OverPt;
343
344		Double_t mva = -9999;
345		TMVA::Reader *reader = 0;
#	Line 168 | Line 356 | Double_t MuonIDMVA::MVAValue(Double_t Mu
356
357		mva = reader->EvaluateMVA( fMethodname );
358
359	+	if (printDebug) {
360	+	std::cout << "Debug Muon MVA: "
361	+	<< MuPt << " " << MuEta << " --> MVABin " << MVABin << " : "
362	+	<< fMVAVar_MuTkNchi2              << " "
363	+	<< fMVAVar_MuGlobalNchi2          << " "
364	+	<< fMVAVar_MuNValidHits           << " "
365	+	<< fMVAVar_MuNTrackerHits         << " "
366	+	<< fMVAVar_MuNPixelHits           << " "
367	+	<< fMVAVar_MuNMatches             << " "
368	+	<< fMVAVar_MuD0                   << " "
369	+	<< fMVAVar_MuIP3d                 << " "
370	+	<< fMVAVar_MuIP3dSig              << " "
371	+	<< fMVAVar_MuTrkKink              << " "
372	+	<< fMVAVar_MuSegmentCompatibility << " "
373	+	<< fMVAVar_MuCaloCompatibility    << " "
374	+	<< fMVAVar_MuHadEnergyOverPt      << " "
375	+	<< fMVAVar_MuHoEnergyOverPt       << " "
376	+	<< fMVAVar_MuEmEnergyOverPt       << " "
377	+	<< fMVAVar_MuHadS9EnergyOverPt    << " "
378	+	<< fMVAVar_MuHoS9EnergyOverPt     << " "
379	+	<< fMVAVar_MuEmS9EnergyOverPt     << " "
380	+	<< fMVAVar_MuTrkIso03OverPt   << " "
381	+	<< fMVAVar_MuEMIso03OverPt   << " "
382	+	<< fMVAVar_MuHadIso03OverPt   << " "
383	+	<< fMVAVar_MuTrkIso05OverPt   << " "
384	+	<< fMVAVar_MuEMIso05OverPt   << " "
385	+	<< fMVAVar_MuHadIso05OverPt   << " "
386	+	<< " === : === "
387	+	<< mva
388	+	<< std::endl;
389	+	}
390	+
391		return mva;
392		}
393
394
395
396	<	// //--------------------------------------------------------------------------------------------------
397	<	// Double_t MuonIDMVA::MVAValue(const Muon *ele, const Vertex *vertex) {
396	>	//--------------------------------------------------------------------------------------------------
397	>	Double_t MuonIDMVA::MVAValue(const Muon *mu, const Vertex *vertex, MuonTools *fMuonTools,
398	>	const PFCandidateCol *PFCands,
399	>	const PileupEnergyDensityCol *PileupEnergyDensity,
400	>	Bool_t printDebug) {
401	>
402	>	if (!fIsInitialized) {
403	>	std::cout << "Error: MuonIDMVA not properly initialized.\n";
404	>	return -9999;
405	>	}
406	>
407	>	const Track *muTrk=0;
408	>	if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
409	>	else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
410	>
411	>	Double_t muNchi2 = 0.0;
412	>	if(mu->HasGlobalTrk())          { muNchi2 = mu->GlobalTrk()->RChi2();     }
413	>	else if(mu->HasStandaloneTrk()) { muNchi2 = mu->StandaloneTrk()->RChi2(); }
414	>	else if(mu->HasTrackerTrk())    { muNchi2 = mu->TrackerTrk()->RChi2();    }
415	>
416	>	Double_t ChargedIso03 = 0;
417	>	Double_t NeutralIso03_05Threshold = 0;
418	>	Double_t ChargedIso04 = 0;
419	>	Double_t NeutralIso04_05Threshold = 0;
420	>	ChargedIso03 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.3, 0.0, 0.0);
421	>	NeutralIso03_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.3, 0.0, 0.0);
422	>	ChargedIso04 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.4, 0.0, 0.0);
423	>	NeutralIso04_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.4, 0.0, 0.0);
424
425	<	//   if (!fIsInitialized) {
426	<	//     std::cout << "Error: MuonIDMVA not properly initialized.\n";
427	<	//     return -9999;
428	<	//   }
429	<
430	<	//   Int_t subdet = 0;
431	<	//   if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
432	<	//   else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
433	<	//   else subdet = 2;
434	<	//   Int_t ptBin = 0;
435	<	//   if (ele->Pt() > 20.0) ptBin = 1;
436	<
437	<	//   //set all input variables
438	<	//   fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
439	<	//   fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
440	<	//   fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
441	<	//   fMVAVar_EleHoverE = ele->HadronicOverEm();
442	<	//   fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
443	<	//   fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
444	<	//   fMVAVar_EleFBrem = ele->FBrem();
445	<	//   fMVAVar_EleEOverP = ele->ESuperClusterOverP();
446	<	//   fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
447	<	//   if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
448	<	//   else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
449	<	//   fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
450	<	//   fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
451	<	//   fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
452	<	//   fMVAVar_EleIP3d = ele->Ip3dPV();
453	<	//   fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
454	<
455	<	//   Double_t mva = -9999;
456	<	//   TMVA::Reader *reader = 0;
457	<	//   Int_t MVABin = -1;
458	<	//   if (subdet == 0 && ptBin == 0) MVABin = 0;
459	<	//   if (subdet == 1 && ptBin == 0) MVABin = 1;
460	<	//   if (subdet == 2 && ptBin == 0) MVABin = 2;
461	<	//   if (subdet == 0 && ptBin == 1) MVABin = 3;
462	<	//   if (subdet == 1 && ptBin == 1) MVABin = 4;
463	<	//   if (subdet == 2 && ptBin == 1) MVABin = 5;
464	<	//   assert(MVABin >= 0 && MVABin <= 5);
465	<	//   reader = fTMVAReader[MVABin];
425	>	Double_t Rho = 0;
426	>	if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
427	>
428	>	Int_t subdet = 0;
429	>	if (fabs(muTrk->Eta()) < 1.479) subdet = 0;
430	>	else subdet = 1;
431	>	Int_t ptBin = 0;
432	>	if (muTrk->Pt() > 14.5) ptBin = 1;
433	>	if (muTrk->Pt() > 20.0) ptBin = 2;
434	>
435	>	//set all input variables
436	>	fMVAVar_MuTkNchi2              = muTrk->RChi2();
437	>	fMVAVar_MuGlobalNchi2          = muNchi2;
438	>	fMVAVar_MuNValidHits           = mu->NValidHits();
439	>	fMVAVar_MuNTrackerHits         = muTrk->NHits();
440	>	fMVAVar_MuNPixelHits           = muTrk->NPixelHits();
441	>	fMVAVar_MuNMatches             = mu->NMatches();
442	>	fMVAVar_MuD0                   = muTrk->D0Corrected(*vertex);
443	>	fMVAVar_MuIP3d                 = mu->Ip3dPV();
444	>	fMVAVar_MuIP3dSig              = mu->Ip3dPVSignificance();
445	>	fMVAVar_MuTrkKink              = mu->TrkKink();
446	>	fMVAVar_MuSegmentCompatibility = fMuonTools->GetSegmentCompatability(mu);
447	>	fMVAVar_MuCaloCompatibility    = fMuonTools->GetCaloCompatability(mu, kTRUE, kTRUE);
448	>	fMVAVar_MuHadEnergyOverPt      = (mu->HadEnergy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadEnergy,muTrk->Eta()))/muTrk->Pt();
449	>	fMVAVar_MuHoEnergyOverPt       = (mu->HoEnergy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHoEnergy,muTrk->Eta()))/muTrk->Pt();
450	>	fMVAVar_MuEmEnergyOverPt       = (mu->EmEnergy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEmEnergy,muTrk->Eta()))/muTrk->Pt();
451	>	fMVAVar_MuHadS9EnergyOverPt    = (mu->HadS9Energy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadS9Energy,muTrk->Eta()))/muTrk->Pt();
452	>	fMVAVar_MuHoS9EnergyOverPt     = (mu->HoS9Energy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHoS9Energy,muTrk->Eta()))/muTrk->Pt();
453	>	fMVAVar_MuEmS9EnergyOverPt     = (mu->EmS9Energy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEmS9Energy,muTrk->Eta()))/muTrk->Pt();
454	>	fMVAVar_MuChargedIso03OverPt   = (ChargedIso03 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso03,muTrk->Eta()))/muTrk->Pt();
455	>	fMVAVar_MuNeutralIso03OverPt   = (NeutralIso03_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03,muTrk->Eta()))/muTrk->Pt();
456	>	fMVAVar_MuChargedIso04OverPt   = (ChargedIso04 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso04,muTrk->Eta()))/muTrk->Pt();
457	>	fMVAVar_MuNeutralIso04OverPt   = (NeutralIso04_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso04,muTrk->Eta()))/muTrk->Pt();
458	>	fMVAVar_MuTrkIso03OverPt       = (mu->IsoR03SumPt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuTrkIso03,muTrk->Eta()))/muTrk->Pt();
459	>	fMVAVar_MuEMIso03OverPt        = (mu->IsoR03EmEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03,muTrk->Eta()))/muTrk->Pt();
460	>	fMVAVar_MuHadIso03OverPt       = (mu->IsoR03HadEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03,muTrk->Eta()))/muTrk->Pt();
461	>	fMVAVar_MuTrkIso05OverPt       = (mu->IsoR05SumPt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuTrkIso05,muTrk->Eta()))/muTrk->Pt();
462	>	fMVAVar_MuEMIso05OverPt        = (mu->IsoR05EmEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso05,muTrk->Eta()))/muTrk->Pt();
463	>	fMVAVar_MuHadIso05OverPt       = (mu->IsoR05HadEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso05,muTrk->Eta()))/muTrk->Pt();
464	>
465	>	Double_t mva = -9999;
466	>	TMVA::Reader *reader = 0;
467	>
468	>	Int_t MVABin = -1;
469	>	if (subdet == 0 && ptBin == 0) MVABin = 0;
470	>	if (subdet == 1 && ptBin == 0) MVABin = 1;
471	>	if (subdet == 0 && ptBin == 1) MVABin = 2;
472	>	if (subdet == 1 && ptBin == 1) MVABin = 3;
473	>	if (subdet == 0 && ptBin == 2) MVABin = 4;
474	>	if (subdet == 1 && ptBin == 2) MVABin = 5;
475	>	assert(MVABin >= 0 && MVABin <= 5);
476	>	reader = fTMVAReader[MVABin];
477
478	<	//   mva = reader->EvaluateMVA( fMethodname );
478	>	mva = reader->EvaluateMVA( fMethodname );
479
480	<	//   return mva;
481	<	// }
480	>	if (printDebug) {
481	>	std::cout << "Debug Muon MVA: "
482	>	<< mu->Pt() << " " << mu->Eta() << " " << mu->Phi() << " : "
483	>	<< muTrk->Pt() << " " << muTrk->Eta() << " --> MVABin " << MVABin << " : "
484	>	<< fMVAVar_MuTkNchi2              << " "
485	>	<< fMVAVar_MuGlobalNchi2          << " "
486	>	<< fMVAVar_MuNValidHits           << " "
487	>	<< fMVAVar_MuNTrackerHits         << " "
488	>	<< fMVAVar_MuNPixelHits           << " "
489	>	<< fMVAVar_MuNMatches             << " "
490	>	<< fMVAVar_MuD0                   << " "
491	>	<< fMVAVar_MuIP3d                 << " "
492	>	<< fMVAVar_MuIP3dSig              << " "
493	>	<< fMVAVar_MuTrkKink              << " "
494	>	<< fMVAVar_MuSegmentCompatibility << " "
495	>	<< fMVAVar_MuCaloCompatibility    << " "
496	>	<< fMVAVar_MuHadEnergyOverPt      << " "
497	>	<< fMVAVar_MuHoEnergyOverPt       << " "
498	>	<< fMVAVar_MuEmEnergyOverPt       << " "
499	>	<< fMVAVar_MuHadS9EnergyOverPt    << " "
500	>	<< fMVAVar_MuHoS9EnergyOverPt     << " "
501	>	<< fMVAVar_MuEmS9EnergyOverPt     << " "
502	>	<< fMVAVar_MuChargedIso03OverPt   << " "
503	>	<< fMVAVar_MuNeutralIso03OverPt   << " "
504	>	<< fMVAVar_MuChargedIso04OverPt   << " "
505	>	<< fMVAVar_MuNeutralIso04OverPt   << " "
506	>	<< fMVAVar_MuTrkIso03OverPt   << " "
507	>	<< fMVAVar_MuEMIso03OverPt   << " "
508	>	<< fMVAVar_MuHadIso03OverPt   << " "
509	>	<< fMVAVar_MuTrkIso05OverPt   << " "
510	>	<< fMVAVar_MuEMIso05OverPt   << " "
511	>	<< fMVAVar_MuHadIso05OverPt   << " "
512	>	<< " === : === "
513	>	<< mva
514	>	<< std::endl;
515	>	}
516	>
517	>	return mva;
518	>	}

Diff Legend

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