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.73 by ceballos, Thu May 3 10:22:10 2012 UTC vs.
Revision 1.87 by mingyang, Mon Jan 7 22:14:56 2013 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),
60	<	fMuonMVAWeights_Subdet0Pt10To14p5(""),
61	<	fMuonMVAWeights_Subdet1Pt10To14p5(""),
59	<	fMuonMVAWeights_Subdet0Pt14p5To20(""),
60	<	fMuonMVAWeights_Subdet1Pt14p5To20(""),
61	<	fMuonMVAWeights_Subdet0Pt20ToInf(""),
62	<	fMuonMVAWeights_Subdet1Pt20ToInf(""),
63	<	fTheRhoType(RhoUtilities::DEFAULT)
60	>	fTheRhoType(RhoUtilities::DEFAULT),
61	>	fPVName(Names::gkPVBeamSpotBrn)
62		{
63		// Constructor.
64		}
#	Line 70 | Line 68 | void MuonIDMod::Process()
68		{
69		// Process entries of the tree.
70
71	+	if(fCleanMuonsName.CompareTo("HggLeptonTagMuons") == 0 ){
72	+	LoadEventObject(fPVName,fVertices);
73	+	}
74	+	else{
75	+	fVertices = GetObjThisEvt<VertexOArr>(fVertexName);
76	+	}
77	+
78		if(fMuIsoType != kPFIsoNoL) {
79		LoadEventObject(fMuonBranchName, fMuons);
80		}
#	Line 80 | Line 85 | void MuonIDMod::Process()
85		LoadEventObject(fTrackName, fTracks);
86		LoadEventObject(fPFCandidatesName, fPFCandidates);
87		if(fMuIsoType == kTrackCaloSliding ||
88	<	fMuIsoType == kCombinedRelativeConeAreaCorrected ||
89	<	fMuIsoType == kPFIsoEffectiveAreaCorrected ||
90	<	fMuIsoType == kMVAIso_BDTG_IDIso
88	>	fMuIsoType == kCombinedRelativeConeAreaCorrected ||
89	>	fMuIsoType == kPFIsoEffectiveAreaCorrected ||
90	>	fMuIsoType == kMVAIso_BDTG_IDIso ||
91	>	fMuIsoType == kIsoRingsV0_BDTG_Iso ||
92	>	fMuIsoType == kIsoDeltaR
93		) {
94		LoadEventObject(fPileupEnergyDensityName, fPileupEnergyDensity);
95		}
96	<	if(fMuIsoType == kPFRadialIso){
97	<	// Name is hardcoded, can be changed if someone feels to do it
98	<	fPFNoPileUpCands = GetObjThisEvt<PFCandidateCol>("PFNoPileUp");
96	>	if(fMuIsoType == kPFRadialIso || fMuIsoType == kIsoDeltaR || fMuIsoType == kPFIsoBetaPUCorrected){
97	>	// Name is hardcoded, can be changed if someone feels to do it *** did it--Heng
98	>	fPFNoPileUpCands = GetObjThisEvt<PFCandidateCol>(fPFNoPileUpName);
99	>	fPFPileUpCands = GetObjThisEvt<PFCandidateCol>(fPFPileUpName);
100		}
101
102		MuonOArr *CleanMuons = new MuonOArr;
103		CleanMuons->SetName(fCleanMuonsName);
104
97	–	fVertices = GetObjThisEvt<VertexOArr>(fVertexName);
98	–
105		for (UInt_t i=0; i<fMuons->GetEntries() && fVertices->GetEntries() > 0 ; ++i) {
106		const Muon *mu = fMuons->At(i);
107
#	Line 164 | Line 170 | void MuonIDMod::Process()
170		eta = TMath::Abs(mu->TrackerTrk()->Eta());
171		}
172		break;
173	+	case kGlobalOnly:
174	+	pass = mu->HasGlobalTrk();
175	+	if (pass && mu->TrackerTrk()) {
176	+	pt  = mu->TrackerTrk()->Pt();
177	+	eta = TMath::Abs(mu->TrackerTrk()->Eta());
178	+	}
179	+	else {
180	+	pt  = mu->Pt();
181	+	eta = TMath::Abs(mu->Eta());
182	+	}
183	+	break;
184		default:
185		break;
186		}
#	Line 177 | Line 194 | void MuonIDMod::Process()
194		if (eta >= fEtaCut)
195		continue;
196
180	–
181	–	//***********************************************************************************************
182	–	//Debug Info For Lepton MVA
183	–	//***********************************************************************************************
184	–	if( fPrintMVADebugInfo &&
185	–	(fMuIsoType == kMVAIso_BDTG_IDIso || fMuIDType == kMVAID_BDTG_IDIso)
186	–	) {
187	–	cout << "Event: " << GetEventHeader()->RunNum() << " " << GetEventHeader()->LumiSec() << " "
188	–	<< GetEventHeader()->EvtNum() << " : Rho = " << fPileupEnergyDensity->At(0)->Rho()
189	–	<< " : Muon " << i << " "
190	–	<< endl;
191	–	fMuonIDMVA->MVAValue(mu,fVertices->At(0),fMuonTools,fPFCandidates,fPileupEnergyDensity,kTRUE);
192	–	}
193	–	//***********************************************************************************************
194	–
195	–
197		Double_t RChi2 = 0.0;
198		if     (mu->HasGlobalTrk()) {
199		RChi2 = mu->GlobalTrk()->Chi2()/mu->GlobalTrk()->Ndof();
#	Line 226 | Line 227 | void MuonIDMod::Process()
227		mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
228		break;
229		case kTight:
230	<	idpass = mu->BestTrk() !=  0 &&
231	<	mu->Quality().Quality(MuonQuality::TMOneStationTight) &&
232	<	mu->Quality().Quality(MuonQuality::TM2DCompatibilityTight) &&
233	<	mu->BestTrk()->NHits() > 10 &&
234	<	RChi2 < 10.0 &&
234	<	mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
230	>	idpass = mu->BestTrk() != 0 &&
231	>	mu->NTrkLayersHit() > 5 &&
232	>	mu->IsPFMuon() == kTRUE &&
233	>	mu->BestTrk()->NPixelHits() > 0 &&
234	>	RChi2 < 10.0;
235		break;
236	+	// 2012 WW analysis for 42x (there is no PFMuon link)
237		case kWWMuIdV1:
238		idpass = mu->BestTrk() != 0 &&
239	<	mu->BestTrk()->NHits() > 10 &&
239	>	mu->NTrkLayersHit() > 5 &&
240		mu->BestTrk()->NPixelHits() > 0 &&
241		mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1 &&
242	<	RChi2 < 10.0 &&
242	<	(mu->NSegments() > 1 || mu->NMatches() > 1) &&
243	<	mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
242	>	mu->TrkKink() < 20.0;
243		break;
244	+	// 2010 WW analysis
245		case kWWMuIdV2:
246		idpass = mu->BestTrk() != 0 &&
247		mu->BestTrk()->NHits() > 10 &&
248		mu->BestTrk()->NPixelHits() > 0 &&
249		mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1;
250		break;
251	+	// 2011 WW analysis
252		case kWWMuIdV3:
253		idpass = mu->BestTrk() != 0 &&
254		mu->BestTrk()->NHits() > 10 &&
#	Line 255 | Line 256 | void MuonIDMod::Process()
256		mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1 &&
257		mu->TrkKink() < 20.0;
258		break;
259	+	// 2012 WW analysis
260	+	case kWWMuIdV4:
261	+	idpass = mu->BestTrk() != 0 &&
262	+	mu->NTrkLayersHit() > 5 &&
263	+	mu->IsPFMuon() == kTRUE &&
264	+	mu->BestTrk()->NPixelHits() > 0 &&
265	+	mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1 &&
266	+	mu->TrkKink() < 20.0;
267	+	break;
268		case kMVAID_BDTG_IDIso:
269		{
270		Bool_t passDenominatorM2 = (mu->BestTrk() != 0 &&
#	Line 297 | Line 307 | void MuonIDMod::Process()
307		case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
308		Rho = rho->RhoRandom();
309		break;
310	+	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
311	+	Rho = rho->RhoKt6PFJets();
312	+	break;
313		default:
314		Rho = rho->Rho();
315		}
#	Line 327 | Line 340 | void MuonIDMod::Process()
340		if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
341		}
342		break;
343	<	case kTrackCaloSlidingNoCorrection:
343	>	case kTrackCaloSlidingNoCorrection:
344		{
345		Double_t totalIso =  1.0 * mu->IsoR03SumPt() +
346		1.0 * mu->IsoR03EmEt()  +
#	Line 341 | Line 354 | void MuonIDMod::Process()
354		if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
355		}
356		break;
357	<	case kCombinedRelativeConeAreaCorrected:
358	<	{
359	<	//const PileupEnergyDensity *rho =  fPileupEnergyDensity->At(0); // Fabian: made Rho customable
360	<	Double_t totalIso =  mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt() - Rho * TMath::Pi() * 0.3 * 0.3 ;
361	<	double theIsoCut = fCombRelativeIsolationCut;
362	<	if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
363	<	}
364	<	break;
365	<	case kCombinedRelativeEffectiveAreaCorrected:
366	<	{
367	<	Double_t tmpRho = Rho;   // Fabian: made the Rho type customable.
368	<	//if (!(TMath::IsNaN(fPileupEnergyDensity->At(0)->Rho()) || std::isinf(fPileupEnergyDensity->At(0)->Rho())))
369	<	//tmpRho = fPileupEnergyDensity->At(0)->Rho();
357	>	case kCombinedRelativeConeAreaCorrected:
358	>	{
359	>	//const PileupEnergyDensity *rho =  fPileupEnergyDensity->At(0); // Fabian: made Rho customable
360	>	Double_t totalIso =  mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt() - Rho * TMath::Pi() * 0.3 * 0.3 ;
361	>	double theIsoCut = fCombRelativeIsolationCut;
362	>	if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
363	>	}
364	>	break;
365	>	case kCombinedRelativeEffectiveAreaCorrected:
366	>	{
367	>	Double_t tmpRho = Rho;   // Fabian: made the Rho type customable.
368	>	//if (!(TMath::IsNaN(fPileupEnergyDensity->At(0)->Rho()) || std::isinf(fPileupEnergyDensity->At(0)->Rho())))
369	>	//tmpRho = fPileupEnergyDensity->At(0)->Rho();
370
371	<	isocut = ( mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt()
372	<	-  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03, mu->Eta())
373	<	-  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03, mu->Eta())
374	<	) < (mu->Pt()* 0.40);
375	<	}
376	<	break;
377	<	case kPFIso:
378	<	{
379	<	Double_t pfIsoCutValue = 9999;
380	<	if(fPFIsolationCut > 0){
381	<	pfIsoCutValue = fPFIsolationCut;
382	<	} else {
383	<	if (mu->AbsEta() < 1.479) {
384	<	if (mu->Pt() > 20) {
385	<	pfIsoCutValue = 0.13;
386	<	} else {
387	<	pfIsoCutValue = 0.06;
375	<	}
376	<	} else {
377	<	if (mu->Pt() > 20) {
378	<	pfIsoCutValue = 0.09;
379	<	} else {
380	<	pfIsoCutValue = 0.05;
381	<	}
371	>	isocut = ( mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt()
372	>	-  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03, mu->Eta())
373	>	-  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03, mu->Eta())
374	>	) < (mu->Pt()* 0.40);
375	>	}
376	>	break;
377	>	case kPFIso:
378	>	{
379	>	Double_t pfIsoCutValue = 9999;
380	>	if(fPFIsolationCut > 0){
381	>	pfIsoCutValue = fPFIsolationCut;
382	>	} else {
383	>	if (mu->AbsEta() < 1.479) {
384	>	if (mu->Pt() > 20) {
385	>	pfIsoCutValue = 0.13;
386	>	} else {
387	>	pfIsoCutValue = 0.06;
388		}
389	<	}
390	<	Double_t totalIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius);
391	<	if (totalIso < (mu->Pt()*pfIsoCutValue) )
392	<	isocut = kTRUE;
389	>	} else {
390	>	if (mu->Pt() > 20) {
391	>	pfIsoCutValue = 0.09;
392	>	} else {
393	>	pfIsoCutValue = 0.05;
394	>	}
395	>	}
396		}
397	<	break;
398	<	case kPFRadialIso:
399	<	{
400	<	Double_t pfIsoCutValue = 9999;
401	<	if(fPFIsolationCut > 0){
402	<	pfIsoCutValue = fPFIsolationCut;
403	<	} else {
404	<	if (mu->Pt() > 20) {
405	<	pfIsoCutValue = 0.10;
406	<	} else {
397	>	Double_t totalIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius);
398	>	if (totalIso < (mu->Pt()*pfIsoCutValue) )
399	>	isocut = kTRUE;
400	>	}
401	>	break;
402	>	case kPFRadialIso:
403	>	{
404	>	Double_t pfIsoCutValue = 9999;
405	>	if(fPFIsolationCut > 0){
406	>	pfIsoCutValue = fPFIsolationCut;
407	>	} else {
408	>	if (mu->Pt() > 20) {
409	>	pfIsoCutValue = 0.10;
410	>	} else {
411		pfIsoCutValue = 0.05;
412		}
413		}
414		Double_t totalIso =  IsolationTools::PFRadialMuonIsolation(mu, fPFNoPileUpCands, 1.0, 0.3);
415		if (totalIso < (mu->Pt()*pfIsoCutValue) )
416		isocut = kTRUE;
417	+	}
418	+	break;
419	+	case kPFIsoBetaPUCorrected:
420	+	{
421	+	Double_t pfIsoCutValue = 9999;
422	+	if(fPFIsolationCut > 0){
423	+	pfIsoCutValue = fPFIsolationCut;
424	+	} else {
425	+	if (mu->Pt() > 20) {
426	+	pfIsoCutValue = 0.2;
427	+	} else {
428	+	pfIsoCutValue = 0.2;
429	+	}
430		}
431	<	break;
432	<	case kPFIsoEffectiveAreaCorrected:
433	<	{
434	<	Double_t pfIsoCutValue = 9999;
435	<	if(fPFIsolationCut > 0){
436	<	pfIsoCutValue = fPFIsolationCut;
437	<	} else {
438	<	pfIsoCutValue = fPFIsolationCut; //leave it like this for now
439	<	}
440	<	Double_t EffectiveAreaCorrectedPFIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius)
441	<	- Rho * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());
442	<	//- fPileupEnergyDensity->At(0)->Rho() * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());  // Fabian: made Rho-type customable
443	<	isocut = EffectiveAreaCorrectedPFIso < (mu->Pt() * pfIsoCutValue);
444	<	break;
445	<	}
446	<	case kPFIsoNoL:
431	>	Double_t totalIso =  IsolationTools::BetaMwithPUCorrection(fPFNoPileUpCands, fPFPileUpCands, mu, 0.4);
432	>	if (totalIso < (mu->Pt()*pfIsoCutValue) )
433	>	isocut = kTRUE;
434	>	}
435	>	break;
436	>	case kPFIsoEffectiveAreaCorrected:
437	>	{
438	>	Double_t pfIsoCutValue = 9999;
439	>	if(fPFIsolationCut > 0){
440	>	pfIsoCutValue = fPFIsolationCut;
441	>	} else {
442	>	pfIsoCutValue = fPFIsolationCut; //leave it like this for now
443	>	}
444	>	Double_t EffectiveAreaCorrectedPFIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius)
445	>	- Rho * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());
446	>	//- fPileupEnergyDensity->At(0)->Rho() * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());  // Fabian: made Rho-type customable
447	>	isocut = EffectiveAreaCorrectedPFIso < (mu->Pt() * pfIsoCutValue);
448	>	break;
449	>	}
450	>
451	>
452	>	case kPFIsoNoL:
453		{
454		fNonIsolatedMuons     = GetObjThisEvt<MuonCol>(fNonIsolatedMuonsName);
455		fNonIsolatedElectrons = GetObjThisEvt<ElectronCol>(fNonIsolatedElectronsName);
#	Line 448 | Line 480 | void MuonIDMod::Process()
480		case kMVAIso_BDTG_IDIso:
481		{
482
451	–	// **************************************************************************
452	–	// Don't use effective area correction denominator. Instead use the old one.
453	–	// **************************************************************************
454	–
455	–	//         Double_t tmpRho = 0;
456	–	//         if (!(TMath::IsNaN(fPileupEnergyDensity->At(0)->Rho()) || isinf(fPileupEnergyDensity->At(0)->Rho())))
457	–	//           tmpRho = fPileupEnergyDensity->At(0)->Rho();
458	–
459	–	//         isocut = ( mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt()
460	–	//                    -  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03, mu->Eta())
461	–	//                    -  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03, mu->Eta())
462	–	//           ) < (mu->Pt()* 0.40);
463	–
483		Double_t totalIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius);
484		isocut = (totalIso < (mu->Pt()*0.4));
485
486		}
487		break;
488	+	case kIsoRingsV0_BDTG_Iso:
489	+	{
490	+
491	+	isocut = PassMuonIsoRingsV0_BDTG_Iso(mu, fVertices->At(0), fPileupEnergyDensity);
492	+
493	+	}
494	+	break;
495	+	case kIsoDeltaR:
496	+	{
497	+
498	+	isocut = PassMuonIsoDeltaR(mu, fVertices->At(0), fPileupEnergyDensity);
499	+
500	+	}
501	+	break;
502		case kNoIso:
503		isocut = kTRUE;
504		break;
#	Line 514 | Line 547 | void MuonIDMod::SlaveBegin()
547		// Run startup code on the computer (slave) doing the actual analysis. Here,
548		// we just request the muon collection branch.
549
550	+	if(fCleanMuonsName.CompareTo("HggLeptonTagMuons") == 0 ){
551	+	ReqEventObject(fPVName,fVertices,true);
552	+	}
553	+
554		// In this case we cannot have a branch
555		if (fMuonIsoType.CompareTo("PFIsoNoL") != 0) {
556		ReqEventObject(fMuonBranchName, fMuons, kTRUE);
#	Line 522 | Line 559 | void MuonIDMod::SlaveBegin()
559		ReqEventObject(fTrackName, fTracks, kTRUE);
560		ReqEventObject(fPFCandidatesName, fPFCandidates, kTRUE);
561		if (fMuonIsoType.CompareTo("TrackCaloSliding") == 0
562	<	|| fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0
563	<	|| fMuonIsoType.CompareTo("CombinedRelativeEffectiveAreaCorrected") == 0
564	<	|| fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0
562	>	|| fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0
563	>	|| fMuonIsoType.CompareTo("CombinedRelativeEffectiveAreaCorrected") == 0
564	>	|| fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0
565		|| fMuonIsoType.CompareTo("MVA_BDTG_IDIso") == 0
566	<	) {
566	>	|| fMuonIsoType.CompareTo("IsoRingsV0_BDTG_Iso") == 0
567	>	|| fMuonIsoType.CompareTo("IsoDeltaR") == 0
568	>	) {
569		ReqEventObject(fPileupEnergyDensityName, fPileupEnergyDensity, kTRUE);
570		}
571
#	Line 545 | Line 584 | void MuonIDMod::SlaveBegin()
584		fMuIDType = kWWMuIdV2;
585		else if (fMuonIDType.CompareTo("WWMuIdV3") == 0)
586		fMuIDType = kWWMuIdV3;
587	+	else if (fMuonIDType.CompareTo("WWMuIdV4") == 0)
588	+	fMuIDType = kWWMuIdV4;
589		else if (fMuonIDType.CompareTo("NoId") == 0)
590		fMuIDType = kNoId;
591		else if (fMuonIDType.CompareTo("Custom") == 0) {
#	Line 568 | Line 609 | void MuonIDMod::SlaveBegin()
609		fMuIsoType = kTrackCaloSliding;
610		else if (fMuonIsoType.CompareTo("TrackCaloSlidingNoCorrection") == 0)
611		fMuIsoType = kTrackCaloSlidingNoCorrection;
612	<	else if (fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0)
613	<	fMuIsoType = kCombinedRelativeConeAreaCorrected;
614	<	else if (fMuonIsoType.CompareTo("CombinedRelativeEffectiveAreaCorrected") == 0)
612	>	else if (fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0)
613	>	fMuIsoType = kCombinedRelativeConeAreaCorrected;
614	>	else if (fMuonIsoType.CompareTo("CombinedRelativeEffectiveAreaCorrected") == 0)
615		fMuIsoType = kCombinedRelativeEffectiveAreaCorrected;
616		else if (fMuonIsoType.CompareTo("PFIso") == 0)
617		fMuIsoType = kPFIso;
618		else if (fMuonIsoType.CompareTo("PFRadialIso") == 0)
619		fMuIsoType = kPFRadialIso;
620	<	else if (fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0)
620	>	else if (fMuonIsoType.CompareTo("PFIsoBetaPUCorrected") == 0)
621	>	fMuIsoType = kPFIsoBetaPUCorrected;
622	>	else if (fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0)
623		fMuIsoType = kPFIsoEffectiveAreaCorrected;
624		else if (fMuonIsoType.CompareTo("PFIsoNoL") == 0)
625		fMuIsoType = kPFIsoNoL;
#	Line 586 | Line 629 | void MuonIDMod::SlaveBegin()
629		fMuIsoType = kCustomIso;
630		SendError(kWarning, "SlaveBegin",
631		"Custom muon isolation is not yet implemented.");
632	<	} else if (fMuonIDType.CompareTo("MVA_BDTG_IDIso") == 0) {
632	>	} else if (fMuonIsoType.CompareTo("MVA_BDTG_IDIso") == 0) {
633		fMuIsoType = kMVAIso_BDTG_IDIso;
634	+	} else if (fMuonIsoType.CompareTo("IsoRingsV0_BDTG_Iso") == 0) {
635	+	fMuIsoType = kIsoRingsV0_BDTG_Iso;
636	+	} else if (fMuonIsoType.CompareTo("IsoDeltaR") == 0) {
637	+	fMuIsoType = kIsoDeltaR;
638		} else {
639		SendError(kAbortAnalysis, "SlaveBegin",
640		"The specified muon isolation %s is not defined.",
#	Line 609 | Line 656 | void MuonIDMod::SlaveBegin()
656		fMuClassType = kCaloMuon;
657		else if (fMuonClassType.CompareTo("TrackerBased") == 0)
658		fMuClassType = kTrackerBased;
659	+	else if (fMuonClassType.CompareTo("GlobalOnly") == 0)
660	+	fMuClassType = kGlobalOnly;
661		else {
662		SendError(kAbortAnalysis, "SlaveBegin",
663		"The specified muon class %s is not defined.",
#	Line 618 | Line 667 | void MuonIDMod::SlaveBegin()
667
668
669		//If we use MVA ID, need to load MVA weights
670	<	if(fMuIsoType == kMVAIso_BDTG_IDIso || fMuIDType == kMVAID_BDTG_IDIso) {
670	>	if     (fMuIsoType == kMVAIso_BDTG_IDIso || fMuIDType == kMVAID_BDTG_IDIso) {
671		fMuonTools = new MuonTools();
672		fMuonIDMVA = new MuonIDMVA();
673		fMuonIDMVA->Initialize("BDTG method",
674	<	fMuonMVAWeights_Subdet0Pt10To14p5,
675	<	fMuonMVAWeights_Subdet1Pt10To14p5,
676	<	fMuonMVAWeights_Subdet0Pt14p5To20,
677	<	fMuonMVAWeights_Subdet1Pt14p5To20,
678	<	fMuonMVAWeights_Subdet0Pt20ToInf,
679	<	fMuonMVAWeights_Subdet1Pt20ToInf,
680	<	MuonIDMVA::kIDIsoCombinedDetIso);
674	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/BarrelPtBin0_IDIsoCombined_BDTG.weights.xml"))),
675	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/EndcapPtBin0_IDIsoCombined_BDTG.weights.xml"))),
676	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/BarrelPtBin1_IDIsoCombined_BDTG.weights.xml"))),
677	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/EndcapPtBin1_IDIsoCombined_BDTG.weights.xml"))),
678	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/BarrelPtBin2_IDIsoCombined_BDTG.weights.xml"))),
679	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/EndcapPtBin2_IDIsoCombined_BDTG.weights.xml"))),
680	>	MuonIDMVA::kIDIsoCombinedDetIso,
681	>	fTheRhoType);
682	>	}
683	>	else if(fMuIsoType == kIsoRingsV0_BDTG_Iso) {
684	>	std::vector<std::string> muonidiso_weightfiles;
685	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml"))));
686	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml"))));
687	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml"))));
688	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml"))));
689	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml"))));
690	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml"))));
691	>	fMuonTools = new MuonTools();
692	>	fMuonIDMVA = new MuonIDMVA();
693	>	fMuonIDMVA->Initialize("MuonIso_BDTG_IsoRings",
694	>	MuonIDMVA::kIsoRingsV0,
695	>	kTRUE,
696	>	muonidiso_weightfiles,
697	>	fTheRhoType);
698	>	}
699	>	else if(fMuIsoType == kIsoDeltaR) {
700	>	std::vector<std::string> muonidiso_weightfiles;
701	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_LB_BDT.weights.xml"))));
702	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_LE_BDT.weights.xml"))));
703	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_HB_BDT.weights.xml"))));
704	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_HE_BDT.weights.xml"))));
705	>	fMuonTools = new MuonTools();
706	>	fMuonIDMVA = new MuonIDMVA();
707	>	fMuonIDMVA->Initialize("muonHZZ2012IsoDRMVA",
708	>	MuonIDMVA::kIsoDeltaR,
709	>	kTRUE,
710	>	muonidiso_weightfiles,
711	>	fTheRhoType);
712		}
713
714		}
#	Line 671 | Line 751 | Bool_t MuonIDMod::PassMuonMVA_BDTG_IdIso
751		if (MVAValue > MVACut) return kTRUE;
752		return kFALSE;
753		}
754	+
755	+	//--------------------------------------------------------------------------------------------------
756	+	Bool_t MuonIDMod::PassMuonIsoRingsV0_BDTG_Iso(const Muon *mu, const Vertex *vertex,
757	+	const PileupEnergyDensityCol *PileupEnergyDensity) const
758	+	{
759	+
760	+	Bool_t isDebug = kFALSE;
761	+	const Track *muTrk=0;
762	+	if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
763	+	else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
764	+
765	+	ElectronOArr *tempElectrons = new  ElectronOArr;
766	+	MuonOArr     *tempMuons     = new  MuonOArr;
767	+	Double_t MVAValue = fMuonIDMVA->MVAValue(mu,vertex,fMuonTools,fPFCandidates,
768	+	PileupEnergyDensity,MuonTools::kMuEAFall11MC,tempElectrons,tempMuons,isDebug);
769	+	delete tempElectrons;
770	+	delete tempMuons;
771	+
772	+	Int_t MVABin = fMuonIDMVA->GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon());
773	+
774	+	Double_t MVACut = -1.0;
775	+	Double_t eta = mu->AbsEta();
776	+	if     (mu->Pt() <  20 && eta <  1.479) MVACut = 0.86;
777	+	else if(mu->Pt() <  20 && eta >= 1.479) MVACut = 0.82;
778	+	else if(mu->Pt() >= 20 && eta <  1.479) MVACut = 0.82;
779	+	else if(mu->Pt() >= 20 && eta >= 1.479) MVACut = 0.86;
780	+
781	+	if(fPFIsolationCut > -1.0) MVACut = fPFIsolationCut;
782	+
783	+	if(isDebug == kTRUE){
784	+	printf("PassMuonIsoRingsV0_BDTG_IsoDebug: %d, pt, eta = %f, %f, rho = %f(%f) : RingsMVA = %f, bin: %d\n",
785	+	GetEventHeader()->EvtNum(),mu->Pt(), mu->Eta(),
786	+	fPileupEnergyDensity->At(0)->Rho(),fPileupEnergyDensity->At(0)->RhoKt6PFJets(),MVAValue,MVABin);
787	+	}
788	+
789	+	if (MVAValue > MVACut) return kTRUE;
790	+	return kFALSE;
791	+	}
792	+
793	+	//--------------------------------------------------------------------------------------------------
794	+	Bool_t MuonIDMod::PassMuonIsoDeltaR(const Muon *mu, const Vertex *vertex,
795	+	const PileupEnergyDensityCol *PileupEnergyDensity) const
796	+	{
797	+
798	+	const Track *muTrk=0;
799	+	if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
800	+	else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
801	+
802	+	ElectronOArr *tempElectrons = new  ElectronOArr;
803	+	MuonOArr     *tempMuons     = new  MuonOArr;
804	+	Double_t MVAValue = fMuonIDMVA->MVAValue(mu,vertex,fMuonTools,fPFNoPileUpCands,
805	+	PileupEnergyDensity,MuonTools::kMuEAFall11MC,tempElectrons,tempMuons,kFALSE);
806	+	delete tempElectrons;
807	+	delete tempMuons;
808	+
809	+	Int_t MVABin = fMuonIDMVA->GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon());
810	+
811	+	Double_t MVACut = -999;
812	+	if      (MVABin == 0) MVACut =  0.000;
813	+	else if (MVABin == 1) MVACut =  0.000;
814	+	else if (MVABin == 2) MVACut =  0.000;
815	+	else if (MVABin == 3) MVACut =  0.000;
816	+
817	+	if (MVAValue > MVACut) return kTRUE;
818	+	return kFALSE;
819	+	}
820	+
821	+	//--------------------------------------------------------------------------------------------------
822	+	void MuonIDMod::Terminate()
823	+	{
824	+	// Run finishing code on the computer (slave) that did the analysis
825	+	delete fMuonIDMVA;
826	+
827	+	delete fMuonTools;
828	+	}

Diff Legend

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