ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitPhysics/Mods/src/MuonIDMod.cc

Comparing UserCode/MitPhysics/Mods/src/MuonIDMod.cc (file contents):
Revision 1.72 by fabstoec, Thu May 3 08:45:28 2012 UTC vs.
Revision 1.86 by ceballos, Wed Dec 5 19:06:07 2012 UTC

#	Line 23 | Line 23 | ClassImp(mithep::MuonIDMod)
23		fBeamSpotName(Names::gkBeamSpotBrn),
24		fTrackName(Names::gkTrackBrn),
25		fPFCandidatesName(Names::gkPFCandidatesBrn),
26	+	fPFNoPileUpName("PFNoPileUp"),
27	+	fPFPileUpName("PFPileUp"),
28		fMuonIDType("WWMuIdV3"),
29		fMuonIsoType("PFIso"),
30		fMuonClassType("Global"),
#	Line 30 | Line 32 | ClassImp(mithep::MuonIDMod)
32		fCaloIsolationCut(3.0),
33		fCombIsolationCut(0.15),
34		fCombRelativeIsolationCut(0.15),
35	<	fPFIsolationCut(-1.0),
35	>	fPFIsolationCut(-999.0),
36		fMuonPtMin(10),
37		fApplyD0Cut(kTRUE),
38		fApplyDZCut(kTRUE),
#	Line 47 | Line 49 | ClassImp(mithep::MuonIDMod)
49		fTracks(0),
50		fPFCandidates(0),
51		fPFNoPileUpCands(0),
52	+	fPFPileUpCands(0),
53		fIntRadius(0.0),
54		fNonIsolatedMuons(0),
55		fNonIsolatedElectrons(0),
#	Line 54 | Line 57 | ClassImp(mithep::MuonIDMod)
57		fPileupEnergyDensity(0),
58		fMuonTools(0),
59		fMuonIDMVA(0),
57	–	fMuonMVAWeights_Subdet0Pt10To14p5(""),
58	–	fMuonMVAWeights_Subdet1Pt10To14p5(""),
59	–	fMuonMVAWeights_Subdet0Pt14p5To20(""),
60	–	fMuonMVAWeights_Subdet1Pt14p5To20(""),
61	–	fMuonMVAWeights_Subdet0Pt20ToInf(""),
62	–	fMuonMVAWeights_Subdet1Pt20ToInf(""),
63	–
60		fTheRhoType(RhoUtilities::DEFAULT)
61		{
62		// Constructor.
#	Line 81 | Line 77 | void MuonIDMod::Process()
77		LoadEventObject(fTrackName, fTracks);
78		LoadEventObject(fPFCandidatesName, fPFCandidates);
79		if(fMuIsoType == kTrackCaloSliding ||
80	<	fMuIsoType == kCombinedRelativeConeAreaCorrected ||
81	<	fMuIsoType == kPFIsoEffectiveAreaCorrected ||
82	<	fMuIsoType == kMVAIso_BDTG_IDIso
80	>	fMuIsoType == kCombinedRelativeConeAreaCorrected ||
81	>	fMuIsoType == kPFIsoEffectiveAreaCorrected ||
82	>	fMuIsoType == kMVAIso_BDTG_IDIso ||
83	>	fMuIsoType == kIsoRingsV0_BDTG_Iso ||
84	>	fMuIsoType == kIsoDeltaR
85		) {
86		LoadEventObject(fPileupEnergyDensityName, fPileupEnergyDensity);
87		}
88	<	if(fMuIsoType == kPFRadialIso){
89	<	// Name is hardcoded, can be changed if someone feels to do it
90	<	fPFNoPileUpCands = GetObjThisEvt<PFCandidateCol>("PFNoPileUp");
88	>	if(fMuIsoType == kPFRadialIso || fMuIsoType == kIsoDeltaR || fMuIsoType == kPFIsoBetaPUCorrected){
89	>	// Name is hardcoded, can be changed if someone feels to do it *** did it--Heng
90	>	fPFNoPileUpCands = GetObjThisEvt<PFCandidateCol>(fPFNoPileUpName);
91	>	fPFPileUpCands = GetObjThisEvt<PFCandidateCol>(fPFPileUpName);
92		}
93
94		MuonOArr *CleanMuons = new MuonOArr;
#	Line 165 | Line 164 | void MuonIDMod::Process()
164		eta = TMath::Abs(mu->TrackerTrk()->Eta());
165		}
166		break;
167	+	case kGlobalOnly:
168	+	pass = mu->HasGlobalTrk();
169	+	if (pass && mu->TrackerTrk()) {
170	+	pt  = mu->TrackerTrk()->Pt();
171	+	eta = TMath::Abs(mu->TrackerTrk()->Eta());
172	+	}
173	+	else {
174	+	pt  = mu->Pt();
175	+	eta = TMath::Abs(mu->Eta());
176	+	}
177	+	break;
178		default:
179		break;
180		}
#	Line 178 | Line 188 | void MuonIDMod::Process()
188		if (eta >= fEtaCut)
189		continue;
190
181	–
182	–	//***********************************************************************************************
183	–	//Debug Info For Lepton MVA
184	–	//***********************************************************************************************
185	–	if( fPrintMVADebugInfo &&
186	–	(fMuIsoType == kMVAIso_BDTG_IDIso || fMuIDType == kMVAID_BDTG_IDIso)
187	–	) {
188	–	cout << "Event: " << GetEventHeader()->RunNum() << " " << GetEventHeader()->LumiSec() << " "
189	–	<< GetEventHeader()->EvtNum() << " : Rho = " << fPileupEnergyDensity->At(0)->Rho()
190	–	<< " : Muon " << i << " "
191	–	<< endl;
192	–	fMuonIDMVA->MVAValue(mu,fVertices->At(0),fMuonTools,fPFCandidates,fPileupEnergyDensity,kTRUE);
193	–	}
194	–	//***********************************************************************************************
195	–
196	–
191		Double_t RChi2 = 0.0;
192		if     (mu->HasGlobalTrk()) {
193		RChi2 = mu->GlobalTrk()->Chi2()/mu->GlobalTrk()->Ndof();
#	Line 227 | Line 221 | void MuonIDMod::Process()
221		mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
222		break;
223		case kTight:
224	<	idpass = mu->BestTrk() !=  0 &&
225	<	mu->Quality().Quality(MuonQuality::TMOneStationTight) &&
226	<	mu->Quality().Quality(MuonQuality::TM2DCompatibilityTight) &&
227	<	mu->BestTrk()->NHits() > 10 &&
228	<	RChi2 < 10.0 &&
235	<	mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
224	>	idpass = mu->BestTrk() != 0 &&
225	>	mu->NTrkLayersHit() > 5 &&
226	>	mu->IsPFMuon() == kTRUE &&
227	>	mu->BestTrk()->NPixelHits() > 0 &&
228	>	RChi2 < 10.0;
229		break;
230	+	// 2012 WW analysis for 42x (there is no PFMuon link)
231		case kWWMuIdV1:
232		idpass = mu->BestTrk() != 0 &&
233	<	mu->BestTrk()->NHits() > 10 &&
233	>	mu->NTrkLayersHit() > 5 &&
234		mu->BestTrk()->NPixelHits() > 0 &&
235		mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1 &&
236	<	RChi2 < 10.0 &&
243	<	(mu->NSegments() > 1 || mu->NMatches() > 1) &&
244	<	mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
236	>	mu->TrkKink() < 20.0;
237		break;
238	+	// 2010 WW analysis
239		case kWWMuIdV2:
240		idpass = mu->BestTrk() != 0 &&
241		mu->BestTrk()->NHits() > 10 &&
242		mu->BestTrk()->NPixelHits() > 0 &&
243		mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1;
244		break;
245	+	// 2011 WW analysis
246		case kWWMuIdV3:
247		idpass = mu->BestTrk() != 0 &&
248		mu->BestTrk()->NHits() > 10 &&
#	Line 256 | Line 250 | void MuonIDMod::Process()
250		mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1 &&
251		mu->TrkKink() < 20.0;
252		break;
253	+	// 2012 WW analysis
254	+	case kWWMuIdV4:
255	+	idpass = mu->BestTrk() != 0 &&
256	+	mu->NTrkLayersHit() > 5 &&
257	+	mu->IsPFMuon() == kTRUE &&
258	+	mu->BestTrk()->NPixelHits() > 0 &&
259	+	mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1 &&
260	+	mu->TrkKink() < 20.0;
261	+	break;
262		case kMVAID_BDTG_IDIso:
263		{
264		Bool_t passDenominatorM2 = (mu->BestTrk() != 0 &&
#	Line 282 | Line 285 | void MuonIDMod::Process()
285		continue;
286
287		Double_t Rho = 0.;
288	<	const PileupEnergyDensity *rho =  fPileupEnergyDensity->At(0);
289	<
290	<	switch (fTheRhoType) {
291	<	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
292	<	Rho = rho->RhoLowEta();
293	<	break;
294	<	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
295	<	Rho = rho->Rho();
296	<	break;
297	<	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
298	<	Rho = rho->RhoRandomLowEta();
299	<	break;
300	<	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
301	<	Rho = rho->RhoRandom();
302	<	break;
303	<	default:
304	<	Rho = rho->Rho();
288	>	if(fPileupEnergyDensity){
289	>	const PileupEnergyDensity *rho =  fPileupEnergyDensity->At(0);
290	>
291	>	switch (fTheRhoType) {
292	>	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
293	>	Rho = rho->RhoLowEta();
294	>	break;
295	>	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
296	>	Rho = rho->Rho();
297	>	break;
298	>	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
299	>	Rho = rho->RhoRandomLowEta();
300	>	break;
301	>	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
302	>	Rho = rho->RhoRandom();
303	>	break;
304	>	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
305	>	Rho = rho->RhoKt6PFJets();
306	>	break;
307	>	default:
308	>	Rho = rho->Rho();
309	>	}
310	>
311	>	if ((TMath::IsNaN(fPileupEnergyDensity->At(0)->Rho()) || std::isinf(fPileupEnergyDensity->At(0)->Rho()))) Rho = 0.;
312		}
313
304	–	if ((TMath::IsNaN(fPileupEnergyDensity->At(0)->Rho()) || std::isinf(fPileupEnergyDensity->At(0)->Rho()))) Rho = 0.;
305	–
314		Bool_t isocut = kFALSE;
315		switch (fMuIsoType) {
316		case kTrackCalo:
#	Line 326 | Line 334 | void MuonIDMod::Process()
334		if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
335		}
336		break;
337	<	case kTrackCaloSlidingNoCorrection:
337	>	case kTrackCaloSlidingNoCorrection:
338		{
339		Double_t totalIso =  1.0 * mu->IsoR03SumPt() +
340		1.0 * mu->IsoR03EmEt()  +
#	Line 340 | Line 348 | void MuonIDMod::Process()
348		if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
349		}
350		break;
351	<	case kCombinedRelativeConeAreaCorrected:
352	<	{
353	<	//const PileupEnergyDensity *rho =  fPileupEnergyDensity->At(0); // Fabian: made Rho customable
354	<	Double_t totalIso =  mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt() - Rho * TMath::Pi() * 0.3 * 0.3 ;
355	<	double theIsoCut = fCombRelativeIsolationCut;
356	<	if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
357	<	}
358	<	break;
359	<	case kCombinedRelativeEffectiveAreaCorrected:
360	<	{
361	<	Double_t tmpRho = Rho;   // Fabian: made the Rho type customable.
362	<	//if (!(TMath::IsNaN(fPileupEnergyDensity->At(0)->Rho()) || std::isinf(fPileupEnergyDensity->At(0)->Rho())))
363	<	//tmpRho = fPileupEnergyDensity->At(0)->Rho();
351	>	case kCombinedRelativeConeAreaCorrected:
352	>	{
353	>	//const PileupEnergyDensity *rho =  fPileupEnergyDensity->At(0); // Fabian: made Rho customable
354	>	Double_t totalIso =  mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt() - Rho * TMath::Pi() * 0.3 * 0.3 ;
355	>	double theIsoCut = fCombRelativeIsolationCut;
356	>	if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
357	>	}
358	>	break;
359	>	case kCombinedRelativeEffectiveAreaCorrected:
360	>	{
361	>	Double_t tmpRho = Rho;   // Fabian: made the Rho type customable.
362	>	//if (!(TMath::IsNaN(fPileupEnergyDensity->At(0)->Rho()) || std::isinf(fPileupEnergyDensity->At(0)->Rho())))
363	>	//tmpRho = fPileupEnergyDensity->At(0)->Rho();
364
365	<	isocut = ( mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt()
366	<	-  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03, mu->Eta())
367	<	-  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03, mu->Eta())
368	<	) < (mu->Pt()* 0.40);
369	<	}
370	<	break;
371	<	case kPFIso:
372	<	{
373	<	Double_t pfIsoCutValue = 9999;
374	<	if(fPFIsolationCut > 0){
375	<	pfIsoCutValue = fPFIsolationCut;
376	<	} else {
377	<	if (mu->AbsEta() < 1.479) {
378	<	if (mu->Pt() > 20) {
379	<	pfIsoCutValue = 0.13;
380	<	} else {
381	<	pfIsoCutValue = 0.06;
374	<	}
375	<	} else {
376	<	if (mu->Pt() > 20) {
377	<	pfIsoCutValue = 0.09;
378	<	} else {
379	<	pfIsoCutValue = 0.05;
380	<	}
365	>	isocut = ( mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt()
366	>	-  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03, mu->Eta())
367	>	-  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03, mu->Eta())
368	>	) < (mu->Pt()* 0.40);
369	>	}
370	>	break;
371	>	case kPFIso:
372	>	{
373	>	Double_t pfIsoCutValue = 9999;
374	>	if(fPFIsolationCut > 0){
375	>	pfIsoCutValue = fPFIsolationCut;
376	>	} else {
377	>	if (mu->AbsEta() < 1.479) {
378	>	if (mu->Pt() > 20) {
379	>	pfIsoCutValue = 0.13;
380	>	} else {
381	>	pfIsoCutValue = 0.06;
382		}
383	<	}
384	<	Double_t totalIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius);
385	<	if (totalIso < (mu->Pt()*pfIsoCutValue) )
386	<	isocut = kTRUE;
383	>	} else {
384	>	if (mu->Pt() > 20) {
385	>	pfIsoCutValue = 0.09;
386	>	} else {
387	>	pfIsoCutValue = 0.05;
388	>	}
389	>	}
390		}
391	<	break;
392	<	case kPFRadialIso:
393	<	{
394	<	Double_t pfIsoCutValue = 9999;
395	<	if(fPFIsolationCut > 0){
396	<	pfIsoCutValue = fPFIsolationCut;
397	<	} else {
398	<	if (mu->Pt() > 20) {
399	<	pfIsoCutValue = 0.10;
400	<	} else {
391	>	Double_t totalIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius);
392	>	if (totalIso < (mu->Pt()*pfIsoCutValue) )
393	>	isocut = kTRUE;
394	>	}
395	>	break;
396	>	case kPFRadialIso:
397	>	{
398	>	Double_t pfIsoCutValue = 9999;
399	>	if(fPFIsolationCut > 0){
400	>	pfIsoCutValue = fPFIsolationCut;
401	>	} else {
402	>	if (mu->Pt() > 20) {
403	>	pfIsoCutValue = 0.10;
404	>	} else {
405		pfIsoCutValue = 0.05;
406		}
407		}
408		Double_t totalIso =  IsolationTools::PFRadialMuonIsolation(mu, fPFNoPileUpCands, 1.0, 0.3);
409		if (totalIso < (mu->Pt()*pfIsoCutValue) )
410		isocut = kTRUE;
411	+	}
412	+	break;
413	+	case kPFIsoBetaPUCorrected:
414	+	{
415	+	Double_t pfIsoCutValue = 9999;
416	+	if(fPFIsolationCut > 0){
417	+	pfIsoCutValue = fPFIsolationCut;
418	+	} else {
419	+	if (mu->Pt() > 20) {
420	+	pfIsoCutValue = 0.2;
421	+	} else {
422	+	pfIsoCutValue = 0.2;
423	+	}
424		}
425	<	break;
426	<	case kPFIsoEffectiveAreaCorrected:
427	<	{
428	<	Double_t pfIsoCutValue = 9999;
429	<	if(fPFIsolationCut > 0){
430	<	pfIsoCutValue = fPFIsolationCut;
431	<	} else {
432	<	pfIsoCutValue = fPFIsolationCut; //leave it like this for now
433	<	}
434	<	Double_t EffectiveAreaCorrectedPFIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius)
435	<	- Rho * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());
436	<	//- fPileupEnergyDensity->At(0)->Rho() * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());  // Fabian: made Rho-type customable
437	<	isocut = EffectiveAreaCorrectedPFIso < (mu->Pt() * pfIsoCutValue);
438	<	break;
439	<	}
440	<	case kPFIsoNoL:
425	>	Double_t totalIso =  IsolationTools::BetaMwithPUCorrection(fPFNoPileUpCands, fPFPileUpCands, mu, 0.4);
426	>	if (totalIso < (mu->Pt()*pfIsoCutValue) )
427	>	isocut = kTRUE;
428	>	}
429	>	break;
430	>	case kPFIsoEffectiveAreaCorrected:
431	>	{
432	>	Double_t pfIsoCutValue = 9999;
433	>	if(fPFIsolationCut > 0){
434	>	pfIsoCutValue = fPFIsolationCut;
435	>	} else {
436	>	pfIsoCutValue = fPFIsolationCut; //leave it like this for now
437	>	}
438	>	Double_t EffectiveAreaCorrectedPFIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius)
439	>	- Rho * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());
440	>	//- fPileupEnergyDensity->At(0)->Rho() * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());  // Fabian: made Rho-type customable
441	>	isocut = EffectiveAreaCorrectedPFIso < (mu->Pt() * pfIsoCutValue);
442	>	break;
443	>	}
444	>
445	>
446	>	case kPFIsoNoL:
447		{
448		fNonIsolatedMuons     = GetObjThisEvt<MuonCol>(fNonIsolatedMuonsName);
449		fNonIsolatedElectrons = GetObjThisEvt<ElectronCol>(fNonIsolatedElectronsName);
#	Line 447 | Line 474 | void MuonIDMod::Process()
474		case kMVAIso_BDTG_IDIso:
475		{
476
450	–	// **************************************************************************
451	–	// Don't use effective area correction denominator. Instead use the old one.
452	–	// **************************************************************************
453	–
454	–	//         Double_t tmpRho = 0;
455	–	//         if (!(TMath::IsNaN(fPileupEnergyDensity->At(0)->Rho()) || isinf(fPileupEnergyDensity->At(0)->Rho())))
456	–	//           tmpRho = fPileupEnergyDensity->At(0)->Rho();
457	–
458	–	//         isocut = ( mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt()
459	–	//                    -  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03, mu->Eta())
460	–	//                    -  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03, mu->Eta())
461	–	//           ) < (mu->Pt()* 0.40);
462	–
477		Double_t totalIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius);
478		isocut = (totalIso < (mu->Pt()*0.4));
479
480		}
481		break;
482	+	case kIsoRingsV0_BDTG_Iso:
483	+	{
484	+
485	+	isocut = PassMuonIsoRingsV0_BDTG_Iso(mu, fVertices->At(0), fPileupEnergyDensity);
486	+
487	+	}
488	+	break;
489	+	case kIsoDeltaR:
490	+	{
491	+
492	+	isocut = PassMuonIsoDeltaR(mu, fVertices->At(0), fPileupEnergyDensity);
493	+
494	+	}
495	+	break;
496		case kNoIso:
497		isocut = kTRUE;
498		break;
#	Line 521 | Line 549 | void MuonIDMod::SlaveBegin()
549		ReqEventObject(fTrackName, fTracks, kTRUE);
550		ReqEventObject(fPFCandidatesName, fPFCandidates, kTRUE);
551		if (fMuonIsoType.CompareTo("TrackCaloSliding") == 0
552	<	|| fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0
553	<	|| fMuonIsoType.CompareTo("CombinedRelativeEffectiveAreaCorrected") == 0
554	<	|| fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0
552	>	|| fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0
553	>	|| fMuonIsoType.CompareTo("CombinedRelativeEffectiveAreaCorrected") == 0
554	>	|| fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0
555		|| fMuonIsoType.CompareTo("MVA_BDTG_IDIso") == 0
556	+	|| fMuonIsoType.CompareTo("IsoRingsV0_BDTG_Iso") == 0
557	+	|| fMuonIsoType.CompareTo("IsoDeltaR") == 0
558		) {
559		ReqEventObject(fPileupEnergyDensityName, fPileupEnergyDensity, kTRUE);
560		}
#	Line 544 | Line 574 | void MuonIDMod::SlaveBegin()
574		fMuIDType = kWWMuIdV2;
575		else if (fMuonIDType.CompareTo("WWMuIdV3") == 0)
576		fMuIDType = kWWMuIdV3;
577	+	else if (fMuonIDType.CompareTo("WWMuIdV4") == 0)
578	+	fMuIDType = kWWMuIdV4;
579		else if (fMuonIDType.CompareTo("NoId") == 0)
580		fMuIDType = kNoId;
581		else if (fMuonIDType.CompareTo("Custom") == 0) {
#	Line 567 | Line 599 | void MuonIDMod::SlaveBegin()
599		fMuIsoType = kTrackCaloSliding;
600		else if (fMuonIsoType.CompareTo("TrackCaloSlidingNoCorrection") == 0)
601		fMuIsoType = kTrackCaloSlidingNoCorrection;
602	<	else if (fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0)
603	<	fMuIsoType = kCombinedRelativeConeAreaCorrected;
604	<	else if (fMuonIsoType.CompareTo("CombinedRelativeEffectiveAreaCorrected") == 0)
602	>	else if (fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0)
603	>	fMuIsoType = kCombinedRelativeConeAreaCorrected;
604	>	else if (fMuonIsoType.CompareTo("CombinedRelativeEffectiveAreaCorrected") == 0)
605		fMuIsoType = kCombinedRelativeEffectiveAreaCorrected;
606		else if (fMuonIsoType.CompareTo("PFIso") == 0)
607		fMuIsoType = kPFIso;
608		else if (fMuonIsoType.CompareTo("PFRadialIso") == 0)
609		fMuIsoType = kPFRadialIso;
610	<	else if (fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0)
610	>	else if (fMuonIsoType.CompareTo("PFIsoBetaPUCorrected") == 0)
611	>	fMuIsoType = kPFIsoBetaPUCorrected;
612	>	else if (fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0)
613		fMuIsoType = kPFIsoEffectiveAreaCorrected;
614		else if (fMuonIsoType.CompareTo("PFIsoNoL") == 0)
615		fMuIsoType = kPFIsoNoL;
#	Line 585 | Line 619 | void MuonIDMod::SlaveBegin()
619		fMuIsoType = kCustomIso;
620		SendError(kWarning, "SlaveBegin",
621		"Custom muon isolation is not yet implemented.");
622	<	} else if (fMuonIDType.CompareTo("MVA_BDTG_IDIso") == 0) {
622	>	} else if (fMuonIsoType.CompareTo("MVA_BDTG_IDIso") == 0) {
623		fMuIsoType = kMVAIso_BDTG_IDIso;
624	+	} else if (fMuonIsoType.CompareTo("IsoRingsV0_BDTG_Iso") == 0) {
625	+	fMuIsoType = kIsoRingsV0_BDTG_Iso;
626	+	} else if (fMuonIsoType.CompareTo("IsoDeltaR") == 0) {
627	+	fMuIsoType = kIsoDeltaR;
628		} else {
629		SendError(kAbortAnalysis, "SlaveBegin",
630		"The specified muon isolation %s is not defined.",
#	Line 608 | Line 646 | void MuonIDMod::SlaveBegin()
646		fMuClassType = kCaloMuon;
647		else if (fMuonClassType.CompareTo("TrackerBased") == 0)
648		fMuClassType = kTrackerBased;
649	+	else if (fMuonClassType.CompareTo("GlobalOnly") == 0)
650	+	fMuClassType = kGlobalOnly;
651		else {
652		SendError(kAbortAnalysis, "SlaveBegin",
653		"The specified muon class %s is not defined.",
#	Line 617 | Line 657 | void MuonIDMod::SlaveBegin()
657
658
659		//If we use MVA ID, need to load MVA weights
660	<	if(fMuIsoType == kMVAIso_BDTG_IDIso || fMuIDType == kMVAID_BDTG_IDIso) {
660	>	if     (fMuIsoType == kMVAIso_BDTG_IDIso || fMuIDType == kMVAID_BDTG_IDIso) {
661		fMuonTools = new MuonTools();
662		fMuonIDMVA = new MuonIDMVA();
663		fMuonIDMVA->Initialize("BDTG method",
664	<	fMuonMVAWeights_Subdet0Pt10To14p5,
665	<	fMuonMVAWeights_Subdet1Pt10To14p5,
666	<	fMuonMVAWeights_Subdet0Pt14p5To20,
667	<	fMuonMVAWeights_Subdet1Pt14p5To20,
668	<	fMuonMVAWeights_Subdet0Pt20ToInf,
669	<	fMuonMVAWeights_Subdet1Pt20ToInf,
670	<	MuonIDMVA::kIDIsoCombinedDetIso);
664	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/BarrelPtBin0_IDIsoCombined_BDTG.weights.xml"))),
665	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/EndcapPtBin0_IDIsoCombined_BDTG.weights.xml"))),
666	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/BarrelPtBin1_IDIsoCombined_BDTG.weights.xml"))),
667	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/EndcapPtBin1_IDIsoCombined_BDTG.weights.xml"))),
668	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/BarrelPtBin2_IDIsoCombined_BDTG.weights.xml"))),
669	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/EndcapPtBin2_IDIsoCombined_BDTG.weights.xml"))),
670	>	MuonIDMVA::kIDIsoCombinedDetIso,
671	>	fTheRhoType);
672	>	}
673	>	else if(fMuIsoType == kIsoRingsV0_BDTG_Iso) {
674	>	std::vector<std::string> muonidiso_weightfiles;
675	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml"))));
676	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml"))));
677	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml"))));
678	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml"))));
679	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml"))));
680	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml"))));
681	>	fMuonTools = new MuonTools();
682	>	fMuonIDMVA = new MuonIDMVA();
683	>	fMuonIDMVA->Initialize("MuonIso_BDTG_IsoRings",
684	>	MuonIDMVA::kIsoRingsV0,
685	>	kTRUE,
686	>	muonidiso_weightfiles,
687	>	fTheRhoType);
688	>	}
689	>	else if(fMuIsoType == kIsoDeltaR) {
690	>	std::vector<std::string> muonidiso_weightfiles;
691	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_LB_BDT.weights.xml"))));
692	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_LE_BDT.weights.xml"))));
693	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_HB_BDT.weights.xml"))));
694	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_HE_BDT.weights.xml"))));
695	>	fMuonTools = new MuonTools();
696	>	fMuonIDMVA = new MuonIDMVA();
697	>	fMuonIDMVA->Initialize("muonHZZ2012IsoDRMVA",
698	>	MuonIDMVA::kIsoDeltaR,
699	>	kTRUE,
700	>	muonidiso_weightfiles,
701	>	fTheRhoType);
702		}
703
704		}
#	Line 670 | Line 741 | Bool_t MuonIDMod::PassMuonMVA_BDTG_IdIso
741		if (MVAValue > MVACut) return kTRUE;
742		return kFALSE;
743		}
744	+
745	+	//--------------------------------------------------------------------------------------------------
746	+	Bool_t MuonIDMod::PassMuonIsoRingsV0_BDTG_Iso(const Muon *mu, const Vertex *vertex,
747	+	const PileupEnergyDensityCol *PileupEnergyDensity) const
748	+	{
749	+
750	+	Bool_t isDebug = kFALSE;
751	+	const Track *muTrk=0;
752	+	if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
753	+	else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
754	+
755	+	ElectronOArr *tempElectrons = new  ElectronOArr;
756	+	MuonOArr     *tempMuons     = new  MuonOArr;
757	+	Double_t MVAValue = fMuonIDMVA->MVAValue(mu,vertex,fMuonTools,fPFCandidates,
758	+	PileupEnergyDensity,MuonTools::kMuEAFall11MC,tempElectrons,tempMuons,isDebug);
759	+	delete tempElectrons;
760	+	delete tempMuons;
761	+
762	+	Int_t MVABin = fMuonIDMVA->GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon());
763	+
764	+	Double_t MVACut = -1.0;
765	+	Double_t eta = mu->AbsEta();
766	+	if     (mu->Pt() <  20 && eta <  1.479) MVACut = 0.86;
767	+	else if(mu->Pt() <  20 && eta >= 1.479) MVACut = 0.82;
768	+	else if(mu->Pt() >= 20 && eta <  1.479) MVACut = 0.82;
769	+	else if(mu->Pt() >= 20 && eta >= 1.479) MVACut = 0.86;
770	+
771	+	if(fPFIsolationCut > -1.0) MVACut = fPFIsolationCut;
772	+
773	+	if(isDebug == kTRUE){
774	+	printf("PassMuonIsoRingsV0_BDTG_IsoDebug: %d, pt, eta = %f, %f, rho = %f(%f) : RingsMVA = %f, bin: %d\n",
775	+	GetEventHeader()->EvtNum(),mu->Pt(), mu->Eta(),
776	+	fPileupEnergyDensity->At(0)->Rho(),fPileupEnergyDensity->At(0)->RhoKt6PFJets(),MVAValue,MVABin);
777	+	}
778	+
779	+	if (MVAValue > MVACut) return kTRUE;
780	+	return kFALSE;
781	+	}
782	+
783	+	//--------------------------------------------------------------------------------------------------
784	+	Bool_t MuonIDMod::PassMuonIsoDeltaR(const Muon *mu, const Vertex *vertex,
785	+	const PileupEnergyDensityCol *PileupEnergyDensity) const
786	+	{
787	+
788	+	const Track *muTrk=0;
789	+	if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
790	+	else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
791	+
792	+	ElectronOArr *tempElectrons = new  ElectronOArr;
793	+	MuonOArr     *tempMuons     = new  MuonOArr;
794	+	Double_t MVAValue = fMuonIDMVA->MVAValue(mu,vertex,fMuonTools,fPFNoPileUpCands,
795	+	PileupEnergyDensity,MuonTools::kMuEAFall11MC,tempElectrons,tempMuons,kFALSE);
796	+	delete tempElectrons;
797	+	delete tempMuons;
798	+
799	+	Int_t MVABin = fMuonIDMVA->GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon());
800	+
801	+	Double_t MVACut = -999;
802	+	if      (MVABin == 0) MVACut =  0.000;
803	+	else if (MVABin == 1) MVACut =  0.000;
804	+	else if (MVABin == 2) MVACut =  0.000;
805	+	else if (MVABin == 3) MVACut =  0.000;
806	+
807	+	if (MVAValue > MVACut) return kTRUE;
808	+	return kFALSE;
809	+	}
810	+
811	+	//--------------------------------------------------------------------------------------------------
812	+	void MuonIDMod::Terminate()
813	+	{
814	+	// Run finishing code on the computer (slave) that did the analysis
815	+	delete fMuonIDMVA;
816	+
817	+	delete fMuonTools;
818	+	}

Diff Legend

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