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.6 by sixie, Wed Jan 4 16:28:17 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 (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To14p5Weights );
118		if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To14p5Weights );
#	Line 99 | Line 136 | void MuonIDMVA::Initialize( TString meth
136
137		//--------------------------------------------------------------------------------------------------
138		Double_t MuonIDMVA::MVAValue(Double_t MuPt , Double_t MuEta,
139	<	Double_t                   MuTkNchi2,
140	<	Double_t                   MuGlobalNchi2,
141	<	Double_t                   MuNValidHits,
142	<	Double_t                   MuNTrackerHits,
143	<	Double_t                   MuNPixelHits,
144	<	Double_t                   MuNMatches,
145	<	Double_t                   MuD0,
146	<	Double_t                   MuIP3d,
147	<	Double_t                   MuIP3dSig,
148	<	Double_t                   MuTrkKink,
149	<	Double_t                   MuSegmentCompatibility,
150	<	Double_t                   MuCaloCompatibility,
151	<	Double_t                   MuHadEnergyOverPt,
152	<	Double_t                   MuHoEnergyOverPt,
153	<	Double_t                   MuEmEnergyOverPt,
154	<	Double_t                   MuHadS9EnergyOverPt,
155	<	Double_t                   MuHoS9EnergyOverPt,
156	<	Double_t                   MuEmS9EnergyOverPt
139	>	Double_t                   MuTkNchi2,
140	>	Double_t                   MuGlobalNchi2,
141	>	Double_t                   MuNValidHits,
142	>	Double_t                   MuNTrackerHits,
143	>	Double_t                   MuNPixelHits,
144	>	Double_t                   MuNMatches,
145	>	Double_t                   MuD0,
146	>	Double_t                   MuIP3d,
147	>	Double_t                   MuIP3dSig,
148	>	Double_t                   MuTrkKink,
149	>	Double_t                   MuSegmentCompatibility,
150	>	Double_t                   MuCaloCompatibility,
151	>	Double_t                   MuHadEnergyOverPt,
152	>	Double_t                   MuHoEnergyOverPt,
153	>	Double_t                   MuEmEnergyOverPt,
154	>	Double_t                   MuHadS9EnergyOverPt,
155	>	Double_t                   MuHoS9EnergyOverPt,
156	>	Double_t                   MuEmS9EnergyOverPt,
157	>	Double_t                   MuChargedIso03OverPt,
158	>	Double_t                   MuNeutralIso03OverPt,
159	>	Double_t                   MuChargedIso04OverPt,
160	>	Double_t                   MuNeutralIso04OverPt,
161	>	Bool_t                     printDebug
162		) {
163
164		if (!fIsInitialized) {
#	Line 151 | Line 193 | Double_t MuonIDMVA::MVAValue(Double_t Mu
193		fMVAVar_MuHadS9EnergyOverPt    = MuHadS9EnergyOverPt;
194		fMVAVar_MuHoS9EnergyOverPt     = MuHoS9EnergyOverPt;
195		fMVAVar_MuEmS9EnergyOverPt     = MuEmS9EnergyOverPt;
196	<
196	>	fMVAVar_MuChargedIso03OverPt   = MuChargedIso03OverPt;
197	>	fMVAVar_MuNeutralIso03OverPt   = MuNeutralIso03OverPt;
198	>	fMVAVar_MuChargedIso04OverPt   = MuChargedIso04OverPt;
199	>	fMVAVar_MuNeutralIso04OverPt   = MuNeutralIso04OverPt;
200
201		Double_t mva = -9999;
202		TMVA::Reader *reader = 0;
#	Line 168 | Line 213 | Double_t MuonIDMVA::MVAValue(Double_t Mu
213
214		mva = reader->EvaluateMVA( fMethodname );
215
216	+	if (printDebug) {
217	+	std::cout << "Debug Muon MVA: "
218	+	<< MuPt << " " << MuEta << " --> MVABin " << MVABin << " : "
219	+	<< fMVAVar_MuTkNchi2              << " "
220	+	<< fMVAVar_MuGlobalNchi2          << " "
221	+	<< fMVAVar_MuNValidHits           << " "
222	+	<< fMVAVar_MuNTrackerHits         << " "
223	+	<< fMVAVar_MuNPixelHits           << " "
224	+	<< fMVAVar_MuNMatches             << " "
225	+	<< fMVAVar_MuD0                   << " "
226	+	<< fMVAVar_MuIP3d                 << " "
227	+	<< fMVAVar_MuIP3dSig              << " "
228	+	<< fMVAVar_MuTrkKink              << " "
229	+	<< fMVAVar_MuSegmentCompatibility << " "
230	+	<< fMVAVar_MuCaloCompatibility    << " "
231	+	<< fMVAVar_MuHadEnergyOverPt      << " "
232	+	<< fMVAVar_MuHoEnergyOverPt       << " "
233	+	<< fMVAVar_MuEmEnergyOverPt       << " "
234	+	<< fMVAVar_MuHadS9EnergyOverPt    << " "
235	+	<< fMVAVar_MuHoS9EnergyOverPt     << " "
236	+	<< fMVAVar_MuEmS9EnergyOverPt     << " "
237	+	<< fMVAVar_MuChargedIso03OverPt   << " "
238	+	<< fMVAVar_MuNeutralIso03OverPt   << " "
239	+	<< fMVAVar_MuChargedIso04OverPt   << " "
240	+	<< fMVAVar_MuNeutralIso04OverPt   << " "
241	+	<< " === : === "
242	+	<< mva
243	+	<< std::endl;
244	+	}
245	+
246		return mva;
247		}
248
249
250
251	<	// //--------------------------------------------------------------------------------------------------
252	<	// Double_t MuonIDMVA::MVAValue(const Muon *ele, const Vertex *vertex) {
251	>	//--------------------------------------------------------------------------------------------------
252	>	Double_t MuonIDMVA::MVAValue(const Muon *mu, const Vertex *vertex, MuonTools *fMuonTools,
253	>	const PFCandidateCol *PFCands,
254	>	const PileupEnergyDensityCol *PileupEnergyDensity,
255	>	Bool_t printDebug) {
256
257	<	//   if (!fIsInitialized) {
258	<	//     std::cout << "Error: MuonIDMVA not properly initialized.\n";
259	<	//     return -9999;
260	<	//   }
261	<
262	<	//   Int_t subdet = 0;
263	<	//   if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
264	<	//   else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
187	<	//   else subdet = 2;
188	<	//   Int_t ptBin = 0;
189	<	//   if (ele->Pt() > 20.0) ptBin = 1;
257	>	if (!fIsInitialized) {
258	>	std::cout << "Error: MuonIDMVA not properly initialized.\n";
259	>	return -9999;
260	>	}
261	>
262	>	const Track *muTrk=0;
263	>	if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
264	>	else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
265
266	<	//   //set all input variables
267	<	//   fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
268	<	//   fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
269	<	//   fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
270	<	//   fMVAVar_EleHoverE = ele->HadronicOverEm();
271	<	//   fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
272	<	//   fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
273	<	//   fMVAVar_EleFBrem = ele->FBrem();
274	<	//   fMVAVar_EleEOverP = ele->ESuperClusterOverP();
275	<	//   fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
276	<	//   if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
277	<	//   else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
278	<	//   fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
279	<	//   fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
280	<	//   fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
281	<	//   fMVAVar_EleIP3d = ele->Ip3dPV();
282	<	//   fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
283	<
284	<	//   Double_t mva = -9999;
285	<	//   TMVA::Reader *reader = 0;
286	<	//   Int_t MVABin = -1;
287	<	//   if (subdet == 0 && ptBin == 0) MVABin = 0;
288	<	//   if (subdet == 1 && ptBin == 0) MVABin = 1;
289	<	//   if (subdet == 2 && ptBin == 0) MVABin = 2;
290	<	//   if (subdet == 0 && ptBin == 1) MVABin = 3;
291	<	//   if (subdet == 1 && ptBin == 1) MVABin = 4;
292	<	//   if (subdet == 2 && ptBin == 1) MVABin = 5;
293	<	//   assert(MVABin >= 0 && MVABin <= 5);
294	<	//   reader = fTMVAReader[MVABin];
266	>	Double_t muNchi2 = 0.0;
267	>	if(mu->HasGlobalTrk())          { muNchi2 = mu->GlobalTrk()->RChi2();     }
268	>	else if(mu->HasStandaloneTrk()) { muNchi2 = mu->StandaloneTrk()->RChi2(); }
269	>	else if(mu->HasTrackerTrk())    { muNchi2 = mu->TrackerTrk()->RChi2();    }
270	>
271	>	Double_t ChargedIso03 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.3, 0.0, 0.0);
272	>	Double_t NeutralIso03_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.3, 0.0, 0.0);
273	>	Double_t ChargedIso04 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.4, 0.0, 0.0);
274	>	Double_t NeutralIso04_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.4, 0.0, 0.0);
275	>
276	>	Double_t Rho = 0;
277	>	if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
278	>
279	>	Int_t subdet = 0;
280	>	if (fabs(muTrk->Eta()) < 1.479) subdet = 0;
281	>	else subdet = 1;
282	>	Int_t ptBin = 0;
283	>	if (muTrk->Pt() > 14.5) ptBin = 1;
284	>	if (muTrk->Pt() > 20.0) ptBin = 2;
285	>
286	>	//set all input variables
287	>	fMVAVar_MuTkNchi2              = muTrk->RChi2();
288	>	fMVAVar_MuGlobalNchi2          = muNchi2;
289	>	fMVAVar_MuNValidHits           = mu->NValidHits();
290	>	fMVAVar_MuNTrackerHits         = muTrk->NHits();
291	>	fMVAVar_MuNPixelHits           = muTrk->NPixelHits();
292	>	fMVAVar_MuNMatches             = mu->NMatches();
293	>	fMVAVar_MuD0                   = muTrk->D0Corrected(*vertex);
294	>	fMVAVar_MuIP3d                 = mu->Ip3dPV();
295	>	fMVAVar_MuIP3dSig              = mu->Ip3dPVSignificance();
296	>	fMVAVar_MuTrkKink              = mu->TrkKink();
297	>	fMVAVar_MuSegmentCompatibility = fMuonTools->GetSegmentCompatability(mu);
298	>	fMVAVar_MuCaloCompatibility    = fMuonTools->GetCaloCompatability(mu, kTRUE, kTRUE);
299	>	fMVAVar_MuHadEnergyOverPt      = (mu->HadEnergy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadEnergy,muTrk->Eta()))/muTrk->Pt();
300	>	fMVAVar_MuHoEnergyOverPt       = (mu->HoEnergy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHoEnergy,muTrk->Eta()))/muTrk->Pt();
301	>	fMVAVar_MuEmEnergyOverPt       = (mu->EmEnergy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEmEnergy,muTrk->Eta()))/muTrk->Pt();
302	>	fMVAVar_MuHadS9EnergyOverPt    = (mu->HadS9Energy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadS9Energy,muTrk->Eta()))/muTrk->Pt();
303	>	fMVAVar_MuHoS9EnergyOverPt     = (mu->HoS9Energy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHoS9Energy,muTrk->Eta()))/muTrk->Pt();
304	>	fMVAVar_MuEmS9EnergyOverPt     = (mu->EmS9Energy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEmS9Energy,muTrk->Eta()))/muTrk->Pt();
305	>	fMVAVar_MuChargedIso03OverPt   = (ChargedIso03 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso03,muTrk->Eta()))/muTrk->Pt();
306	>	fMVAVar_MuNeutralIso03OverPt   = (NeutralIso03_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03,muTrk->Eta()))/muTrk->Pt();
307	>	fMVAVar_MuChargedIso04OverPt   = (ChargedIso04 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso04,muTrk->Eta()))/muTrk->Pt();
308	>	fMVAVar_MuNeutralIso04OverPt   = (NeutralIso04_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso04,muTrk->Eta()))/muTrk->Pt();
309	>
310	>	Double_t mva = -9999;
311	>	TMVA::Reader *reader = 0;
312	>
313	>	Int_t MVABin = -1;
314	>	if (subdet == 0 && ptBin == 0) MVABin = 0;
315	>	if (subdet == 1 && ptBin == 0) MVABin = 1;
316	>	if (subdet == 0 && ptBin == 1) MVABin = 2;
317	>	if (subdet == 1 && ptBin == 1) MVABin = 3;
318	>	if (subdet == 0 && ptBin == 2) MVABin = 4;
319	>	if (subdet == 1 && ptBin == 2) MVABin = 5;
320	>	assert(MVABin >= 0 && MVABin <= 5);
321	>	reader = fTMVAReader[MVABin];
322
323	<	//   mva = reader->EvaluateMVA( fMethodname );
323	>	mva = reader->EvaluateMVA( fMethodname );
324
325	<	//   return mva;
326	<	// }
325	>	if (printDebug) {
326	>	std::cout << "Debug Muon MVA: "
327	>	<< mu->Pt() << " " << mu->Eta() << " " << mu->Phi() << " : "
328	>	<< muTrk->Pt() << " " << muTrk->Eta() << " --> MVABin " << MVABin << " : "
329	>	<< fMVAVar_MuTkNchi2              << " "
330	>	<< fMVAVar_MuGlobalNchi2          << " "
331	>	<< fMVAVar_MuNValidHits           << " "
332	>	<< fMVAVar_MuNTrackerHits         << " "
333	>	<< fMVAVar_MuNPixelHits           << " "
334	>	<< fMVAVar_MuNMatches             << " "
335	>	<< fMVAVar_MuD0                   << " "
336	>	<< fMVAVar_MuIP3d                 << " "
337	>	<< fMVAVar_MuIP3dSig              << " "
338	>	<< fMVAVar_MuTrkKink              << " "
339	>	<< fMVAVar_MuSegmentCompatibility << " "
340	>	<< fMVAVar_MuCaloCompatibility    << " "
341	>	<< fMVAVar_MuHadEnergyOverPt      << " "
342	>	<< fMVAVar_MuHoEnergyOverPt       << " "
343	>	<< fMVAVar_MuEmEnergyOverPt       << " "
344	>	<< fMVAVar_MuHadS9EnergyOverPt    << " "
345	>	<< fMVAVar_MuHoS9EnergyOverPt     << " "
346	>	<< fMVAVar_MuEmS9EnergyOverPt     << " "
347	>	<< fMVAVar_MuChargedIso03OverPt   << " "
348	>	<< fMVAVar_MuNeutralIso03OverPt   << " "
349	>	<< fMVAVar_MuChargedIso04OverPt   << " "
350	>	<< fMVAVar_MuNeutralIso04OverPt   << " "
351	>	<< " === : === "
352	>	<< mva
353	>	<< std::endl;
354	>	}
355	>
356	>	return mva;
357	>	}

Diff Legend

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