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.62 by sixie, Wed Jan 4 16:31:00 2012 UTC vs.
Revision 1.92 by ceballos, Fri Oct 18 14:09:34 2013 UTC

#	Line 14 | Line 14 | ClassImp(mithep::MuonIDMod)
14		//--------------------------------------------------------------------------------------------------
15		MuonIDMod::MuonIDMod(const char *name, const char *title) :
16		BaseMod(name,title),
17	+	fPrintMVADebugInfo(kFALSE),
18		fMuonBranchName(Names::gkMuonBrn),
19		fCleanMuonsName(ModNames::gkCleanMuonsName),
20		fNonIsolatedMuonsName("random"),
#	Line 22 | Line 23 | ClassImp(mithep::MuonIDMod)
23		fBeamSpotName(Names::gkBeamSpotBrn),
24		fTrackName(Names::gkTrackBrn),
25		fPFCandidatesName(Names::gkPFCandidatesBrn),
26	<	fMuonIDType("WWMuIdV3"),
26	>	fPFNoPileUpName("PFNoPileUp"),
27	>	fPFPileUpName("PFPileUp"),
28	>	fMuonIDType("NoId"),
29		fMuonIsoType("PFIso"),
30	<	fMuonClassType("Global"),
30	>	fMuonClassType("GlobalorTracker"),
31		fTrackIsolationCut(3.0),
32		fCaloIsolationCut(3.0),
33		fCombIsolationCut(0.15),
34		fCombRelativeIsolationCut(0.15),
35	<	fPFIsolationCut(-1.0),
36	<	fMuonPtMin(10),
35	>	fPFIsolationCut(-999.0),
36	>	fMuonPtMin(10.),
37		fApplyD0Cut(kTRUE),
38		fApplyDZCut(kTRUE),
39		fD0Cut(0.020),
#	Line 45 | Line 48 | ClassImp(mithep::MuonIDMod)
48		fBeamSpot(0),
49		fTracks(0),
50		fPFCandidates(0),
51	+	fPFNoPileUpCands(0),
52	+	fPFPileUpCands(0),
53		fIntRadius(0.0),
54		fNonIsolatedMuons(0),
55		fNonIsolatedElectrons(0),
#	Line 52 | Line 57 | ClassImp(mithep::MuonIDMod)
57		fPileupEnergyDensity(0),
58		fMuonTools(0),
59		fMuonIDMVA(0),
60	<	fMuonMVAWeights_Subdet0Pt10To14p5(""),
61	<	fMuonMVAWeights_Subdet1Pt10To14p5(""),
57	<	fMuonMVAWeights_Subdet0Pt14p5To20(""),
58	<	fMuonMVAWeights_Subdet1Pt14p5To20(""),
59	<	fMuonMVAWeights_Subdet0Pt20ToInf(""),
60	<	fMuonMVAWeights_Subdet1Pt20ToInf("")
60	>	fPVName(Names::gkPVBeamSpotBrn),
61	>	fTheRhoType(RhoUtilities::DEFAULT)
62		{
63		// Constructor.
64		}
#	Line 67 | 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 77 | 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 || 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
105	<	fVertices = GetObjThisEvt<VertexOArr>(fVertexName);
91	<
92	<	for (UInt_t i=0; i<fMuons->GetEntries(); ++i) {
105	>	for (UInt_t i=0; i<fMuons->GetEntries() && fVertices->GetEntries() > 0 ; ++i) {
106		const Muon *mu = fMuons->At(i);
107
108		Bool_t pass = kFALSE;
#	Line 114 | Line 127 | void MuonIDMod::Process()
127		eta = TMath::Abs(mu->Eta());
128		}
129		break;
130	+	case kGlobalorTracker:
131	+	pass = mu->HasGlobalTrk() || mu->IsTrackerMuon();
132	+	if (pass && mu->TrackerTrk()) {
133	+	pt = mu->TrackerTrk()->Pt();
134	+	eta = TMath::Abs(mu->TrackerTrk()->Eta());
135	+	}
136	+	else{
137	+	pt = mu->Pt();
138	+	eta = TMath::Abs(mu->Eta());
139	+	}
140		case kGlobalTracker:
141		pass = (mu->HasGlobalTrk() && mu->GlobalTrk()->Chi2()/mu->GlobalTrk()->Ndof() < 10 &&
142		(mu->NSegments() > 1 || mu->NMatches() > 1) && mu->NValidHits() > 0) ||
#	Line 157 | Line 180 | void MuonIDMod::Process()
180		eta = TMath::Abs(mu->TrackerTrk()->Eta());
181		}
182		break;
183	+	case kGlobalOnly:
184	+	pass = mu->HasGlobalTrk();
185	+	if (pass && mu->TrackerTrk()) {
186	+	pt  = mu->TrackerTrk()->Pt();
187	+	eta = TMath::Abs(mu->TrackerTrk()->Eta());
188	+	}
189	+	else {
190	+	pt  = mu->Pt();
191	+	eta = TMath::Abs(mu->Eta());
192	+	}
193	+	break;
194		default:
195		break;
196		}
#	Line 164 | Line 198 | void MuonIDMod::Process()
198		if (!pass)
199		continue;
200
201	<	if (pt <= fMuonPtMin)
168	<	continue;
201	>	if (pt <= fMuonPtMin) continue;
202
203	<	if (eta >= fEtaCut)
171	<	continue;
203	>	if (eta >= fEtaCut) continue;
204
205		Double_t RChi2 = 0.0;
206		if     (mu->HasGlobalTrk()) {
#	Line 178 | Line 210 | void MuonIDMod::Process()
210		RChi2 = mu->BestTrk()->Chi2()/mu->BestTrk()->Ndof();
211		}
212		Bool_t idpass = kFALSE;
213	+
214	+
215	+
216		switch (fMuIDType) {
217	+
218		case kWMuId:
219		idpass = mu->BestTrk() != 0 &&
220		mu->BestTrk()->NHits() > 10 &&
#	Line 203 | Line 239 | void MuonIDMod::Process()
239		mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
240		break;
241		case kTight:
242	<	idpass = mu->BestTrk() !=  0 &&
243	<	mu->Quality().Quality(MuonQuality::TMOneStationTight) &&
244	<	mu->Quality().Quality(MuonQuality::TM2DCompatibilityTight) &&
245	<	mu->BestTrk()->NHits() > 10 &&
246	<	RChi2 < 10.0 &&
211	<	mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
242	>	idpass = mu->BestTrk() != 0 &&
243	>	mu->NTrkLayersHit() > 5 &&
244	>	mu->IsPFMuon() == kTRUE &&
245	>	mu->BestTrk()->NPixelHits() > 0 &&
246	>	RChi2 < 10.0;
247		break;
248	+	case kmuonPOG2012CutBasedIDTight:
249	+	idpass = mu->IsGlobalMuon() &&
250	+	mu->IsPFMuon() &&
251	+	mu->GlobalTrk()->RChi2() < 10 &&
252	+	mu->NValidHits() != 0 &&
253	+	mu->NMatches() > 1    &&
254	+	mu->BestTrk()->NPixelHits() != 0 &&
255	+	mu->NTrkLayersHit() > 5;
256	+	break;
257	+	// 2012 WW analysis for 42x (there is no PFMuon link)
258		case kWWMuIdV1:
259		idpass = mu->BestTrk() != 0 &&
260	<	mu->BestTrk()->NHits() > 10 &&
260	>	mu->NTrkLayersHit() > 5 &&
261		mu->BestTrk()->NPixelHits() > 0 &&
262		mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1 &&
263	<	RChi2 < 10.0 &&
219	<	(mu->NSegments() > 1 || mu->NMatches() > 1) &&
220	<	mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
263	>	mu->TrkKink() < 20.0;
264		break;
265	+	// 2010 WW analysis
266		case kWWMuIdV2:
267		idpass = mu->BestTrk() != 0 &&
268		mu->BestTrk()->NHits() > 10 &&
269		mu->BestTrk()->NPixelHits() > 0 &&
270		mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1;
271		break;
272	+	// 2011 WW analysis
273		case kWWMuIdV3:
274		idpass = mu->BestTrk() != 0 &&
275		mu->BestTrk()->NHits() > 10 &&
#	Line 232 | Line 277 | void MuonIDMod::Process()
277		mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1 &&
278		mu->TrkKink() < 20.0;
279		break;
280	+	// 2012 WW analysis
281	+	case kWWMuIdV4:
282	+	idpass = mu->BestTrk() != 0 &&
283	+	mu->NTrkLayersHit() > 5 &&
284	+	mu->IsPFMuon() == kTRUE &&
285	+	mu->BestTrk()->NPixelHits() > 0 &&
286	+	mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1 &&
287	+	mu->TrkKink() < 20.0;
288	+	break;
289		case kMVAID_BDTG_IDIso:
290		{
291		Bool_t passDenominatorM2 = (mu->BestTrk() != 0 &&
#	Line 240 | Line 294 | void MuonIDMod::Process()
294		mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1 &&
295		MuonTools::PassD0Cut(mu, fVertices, 0.20, 0) &&
296		MuonTools::PassDZCut(mu, fVertices, 0.10, 0) &&
297	<	mu->TrkKink() < 20.0 &&
298	<	( IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius)
299	<	- fPileupEnergyDensity->At(0)->Rho() * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta())
246	<	) < (mu->Pt()* 0.40)
247	<	);
248	<
249	<	idpass = passDenominatorM2;
297	>	mu->TrkKink() < 20.0
298	>	);
299	>	idpass =  passDenominatorM2;
300		//only evaluate MVA if muon passes M2 denominator to save time
301		if (idpass) idpass = PassMuonMVA_BDTG_IdIso(mu, fVertices->At(0), fPileupEnergyDensity);
302		}
303		break;
304		case kNoId:
305	+	{
306		idpass = kTRUE;
307	+	}
308		break;
309		default:
310		break;
#	Line 261 | Line 313 | void MuonIDMod::Process()
313		if (!idpass)
314		continue;
315
316	+	Double_t Rho = 0.;
317	+	if(fPileupEnergyDensity){
318	+	const PileupEnergyDensity *rho =  fPileupEnergyDensity->At(0);
319	+
320	+	switch (fTheRhoType) {
321	+	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
322	+	Rho = rho->RhoLowEta();
323	+	break;
324	+	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
325	+	Rho = rho->Rho();
326	+	break;
327	+	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
328	+	Rho = rho->RhoRandomLowEta();
329	+	break;
330	+	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
331	+	Rho = rho->RhoRandom();
332	+	break;
333	+	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
334	+	Rho = rho->RhoKt6PFJets();
335	+	break;
336	+	default:
337	+	Rho = rho->Rho();
338	+	}
339	+
340	+	if ((TMath::IsNaN(fPileupEnergyDensity->At(0)->Rho()) || std::isinf(fPileupEnergyDensity->At(0)->Rho()))) Rho = 0.;
341	+	}
342	+
343		Bool_t isocut = kFALSE;
344		switch (fMuIsoType) {
345		case kTrackCalo:
#	Line 274 | Line 353 | void MuonIDMod::Process()
353		break;
354		case kTrackCaloSliding:
355		{
356	<	const PileupEnergyDensity *rho =  fPileupEnergyDensity->At(0);
278	<	Double_t totalIso =  mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt() - rho->Rho() * TMath::Pi() * 0.3 * 0.3 ;
356	>	Double_t totalIso =  mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt() - Rho * TMath::Pi() * 0.3 * 0.3 ;
357		// trick to change the signal region cut
358		double theIsoCut = fCombIsolationCut;
359		if(theIsoCut < 0.20){
#	Line 285 | Line 363 | void MuonIDMod::Process()
363		if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
364		}
365		break;
366	<	case kTrackCaloSlidingNoCorrection:
366	>	case kTrackCaloSlidingNoCorrection:
367		{
368		Double_t totalIso =  1.0 * mu->IsoR03SumPt() +
369		1.0 * mu->IsoR03EmEt()  +
#	Line 299 | Line 377 | void MuonIDMod::Process()
377		if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
378		}
379		break;
380	<	case kCombinedRelativeConeAreaCorrected:
381	<	{
382	<	const PileupEnergyDensity *rho =  fPileupEnergyDensity->At(0);
383	<	Double_t totalIso =  mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt() - rho->Rho() * TMath::Pi() * 0.3 * 0.3 ;
384	<	double theIsoCut = fCombRelativeIsolationCut;
385	<	if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
386	<	}
387	<	break;
388	<	case kPFIso:
389	<	{
390	<	Double_t pfIsoCutValue = 9999;
391	<	if(fPFIsolationCut > 0){
392	<	pfIsoCutValue = fPFIsolationCut;
393	<	} else {
394	<	if (mu->AbsEta() < 1.479) {
395	<	if (mu->Pt() > 20) {
396	<	pfIsoCutValue = 0.13;
397	<	} else {
398	<	pfIsoCutValue = 0.06;
399	<	}
400	<	} else {
401	<	if (mu->Pt() > 20) {
402	<	pfIsoCutValue = 0.09;
403	<	} else {
404	<	pfIsoCutValue = 0.05;
405	<	}
380	>	case kCombinedRelativeConeAreaCorrected:
381	>	{
382	>	//const PileupEnergyDensity *rho =  fPileupEnergyDensity->At(0); // Fabian: made Rho customable
383	>	Double_t totalIso =  mu->IsoR03SumPt() + TMath::Max(mu->IsoR03EmEt() + mu->IsoR03HadEt() - Rho * TMath::Pi() * 0.3 * 0.3, 0.0);
384	>	double theIsoCut = fCombRelativeIsolationCut;
385	>	if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
386	>	}
387	>	break;
388	>	case kCombinedRelativeEffectiveAreaCorrected:
389	>	{
390	>	Double_t tmpRho = Rho;   // Fabian: made the Rho type customable.
391	>	//if (!(TMath::IsNaN(fPileupEnergyDensity->At(0)->Rho()) || std::isinf(fPileupEnergyDensity->At(0)->Rho())))
392	>	//tmpRho = fPileupEnergyDensity->At(0)->Rho();
393	>
394	>	isocut = ( mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt()
395	>	-  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03, mu->Eta())
396	>	-  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03, mu->Eta())
397	>	) < (mu->Pt()* 0.40);
398	>	}
399	>	break;
400	>	case kPFIso:
401	>	{
402	>	Double_t pfIsoCutValue = 9999;
403	>	if(fPFIsolationCut > 0){
404	>	pfIsoCutValue = fPFIsolationCut;
405	>	} else {
406	>	if (mu->AbsEta() < 1.479) {
407	>	if (mu->Pt() > 20) {
408	>	pfIsoCutValue = 0.13;
409	>	} else {
410	>	pfIsoCutValue = 0.06;
411		}
412	+	} else {
413	+	if (mu->Pt() > 20) {
414	+	pfIsoCutValue = 0.09;
415	+	} else {
416	+	pfIsoCutValue = 0.05;
417	+	}
418	+	}
419	+	}
420	+	Double_t totalIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius);
421	+	if (totalIso < (mu->Pt()*pfIsoCutValue) )
422	+	isocut = kTRUE;
423	+	}
424	+	break;
425	+	case kPFRadialIso:
426	+	{
427	+	Double_t pfIsoCutValue = 9999;
428	+	if(fPFIsolationCut > 0){
429	+	pfIsoCutValue = fPFIsolationCut;
430	+	} else {
431	+	if (mu->Pt() > 20) {
432	+	pfIsoCutValue = 0.10;
433	+	} else {
434	+	pfIsoCutValue = 0.05;
435	+	}
436		}
437	<	Double_t totalIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius);
437	>	Double_t totalIso =  IsolationTools::PFRadialMuonIsolation(mu, fPFNoPileUpCands, 1.0, 0.3);
438		if (totalIso < (mu->Pt()*pfIsoCutValue) )
439		isocut = kTRUE;
440	+	}
441	+	break;
442	+	case kPFIsoBetaPUCorrected:
443	+	{
444	+	Double_t pfIsoCutValue = 9999;
445	+	if(fPFIsolationCut > 0){
446	+	pfIsoCutValue = fPFIsolationCut;
447	+	} else {
448	+	if (mu->Pt() > 20) {
449	+	pfIsoCutValue = 0.2;
450	+	} else {
451	+	pfIsoCutValue = 0.2;
452	+	}
453		}
454	<	break;
455	<	case kPFIsoEffectiveAreaCorrected:
456	<	{
457	<	Double_t pfIsoCutValue = 9999;
458	<	if(fPFIsolationCut > 0){
459	<	pfIsoCutValue = fPFIsolationCut;
460	<	} else {
461	<	pfIsoCutValue = fPFIsolationCut; //leave it like this for now
462	<	}
463	<	Double_t EffectiveAreaCorrectedPFIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius)
464	<	- fPileupEnergyDensity->At(0)->Rho() * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());
465	<	isocut = EffectiveAreaCorrectedPFIso < (mu->Pt() * pfIsoCutValue);
466	<	break;
467	<	}
468	<	case kPFIsoNoL:
454	>	Double_t totalIso =  IsolationTools::BetaMwithPUCorrection(fPFNoPileUpCands, fPFPileUpCands, mu, 0.4);
455	>
456	>	if (totalIso < (mu->Pt()*pfIsoCutValue) )
457	>	isocut = kTRUE;
458	>	}
459	>	break;
460	>	case kPFIsoEffectiveAreaCorrected:
461	>	{
462	>	Double_t pfIsoCutValue = 9999;
463	>	if(fPFIsolationCut > 0){
464	>	pfIsoCutValue = fPFIsolationCut;
465	>	} else {
466	>	pfIsoCutValue = fPFIsolationCut; //leave it like this for now
467	>	}
468	>	Double_t EffectiveAreaCorrectedPFIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius)
469	>	- Rho * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());
470	>	//- fPileupEnergyDensity->At(0)->Rho() * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());  // Fabian: made Rho-type customable
471	>	isocut = EffectiveAreaCorrectedPFIso < (mu->Pt() * pfIsoCutValue);
472	>	break;
473	>	}
474	>
475	>
476	>	case kPFIsoNoL:
477		{
478		fNonIsolatedMuons     = GetObjThisEvt<MuonCol>(fNonIsolatedMuonsName);
479		fNonIsolatedElectrons = GetObjThisEvt<ElectronCol>(fNonIsolatedElectronsName);
#	Line 374 | Line 502 | void MuonIDMod::Process()
502		}
503		break;
504		case kMVAIso_BDTG_IDIso:
505	<	isocut = ( IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius)
506	<	- fPileupEnergyDensity->At(0)->Rho() * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta())
507	<	) < (mu->Pt()* 0.40);
505	>	{
506	>
507	>	Double_t totalIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius);
508	>	isocut = (totalIso < (mu->Pt()*0.4));
509	>
510	>	}
511	>	break;
512	>	case kIsoRingsV0_BDTG_Iso:
513	>	{
514	>
515	>	isocut = PassMuonIsoRingsV0_BDTG_Iso(mu, fVertices->At(0), fPileupEnergyDensity);
516	>
517	>	}
518	>	break;
519	>	case kIsoDeltaR:
520	>	{
521	>
522	>	isocut = PassMuonIsoDeltaR(mu, fVertices->At(0), fPileupEnergyDensity);
523	>
524	>	}
525		break;
526		case kNoIso:
527		isocut = kTRUE;
#	Line 426 | Line 571 | void MuonIDMod::SlaveBegin()
571		// Run startup code on the computer (slave) doing the actual analysis. Here,
572		// we just request the muon collection branch.
573
574	+	if(fCleanMuonsName.CompareTo("HggLeptonTagMuons") == 0 ){
575	+	ReqEventObject(fPVName,fVertices,true);
576	+	}
577	+
578		// In this case we cannot have a branch
579		if (fMuonIsoType.CompareTo("PFIsoNoL") != 0) {
580		ReqEventObject(fMuonBranchName, fMuons, kTRUE);
#	Line 434 | Line 583 | void MuonIDMod::SlaveBegin()
583		ReqEventObject(fTrackName, fTracks, kTRUE);
584		ReqEventObject(fPFCandidatesName, fPFCandidates, kTRUE);
585		if (fMuonIsoType.CompareTo("TrackCaloSliding") == 0
586	<	|| fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0
586	>	|| fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0
587	>	|| fMuonIsoType.CompareTo("CombinedRelativeEffectiveAreaCorrected") == 0
588		|| fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0
589		|| fMuonIsoType.CompareTo("MVA_BDTG_IDIso") == 0
590	<	) {
590	>	|| fMuonIsoType.CompareTo("IsoRingsV0_BDTG_Iso") == 0
591	>	|| fMuonIsoType.CompareTo("IsoDeltaR") == 0
592	>	) {
593		ReqEventObject(fPileupEnergyDensityName, fPileupEnergyDensity, kTRUE);
594		}
595
#	Line 448 | Line 600 | void MuonIDMod::SlaveBegin()
600		fMuIDType = kZMuId;
601		else if (fMuonIDType.CompareTo("Tight") == 0)
602		fMuIDType = kTight;
603	+	else if (fMuonIDType.CompareTo("muonPOG2012CutBasedIDTight") == 0)
604	+	fMuIDType = kmuonPOG2012CutBasedIDTight;
605		else if (fMuonIDType.CompareTo("Loose") == 0)
606		fMuIDType = kLoose;
607		else if (fMuonIDType.CompareTo("WWMuIdV1") == 0)
#	Line 456 | Line 610 | void MuonIDMod::SlaveBegin()
610		fMuIDType = kWWMuIdV2;
611		else if (fMuonIDType.CompareTo("WWMuIdV3") == 0)
612		fMuIDType = kWWMuIdV3;
613	+	else if (fMuonIDType.CompareTo("WWMuIdV4") == 0)
614	+	fMuIDType = kWWMuIdV4;
615		else if (fMuonIDType.CompareTo("NoId") == 0)
616		fMuIDType = kNoId;
617		else if (fMuonIDType.CompareTo("Custom") == 0) {
#	Line 479 | Line 635 | void MuonIDMod::SlaveBegin()
635		fMuIsoType = kTrackCaloSliding;
636		else if (fMuonIsoType.CompareTo("TrackCaloSlidingNoCorrection") == 0)
637		fMuIsoType = kTrackCaloSlidingNoCorrection;
638	<	else if (fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0)
639	<	fMuIsoType = kCombinedRelativeConeAreaCorrected;
638	>	else if (fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0)
639	>	fMuIsoType = kCombinedRelativeConeAreaCorrected;
640	>	else if (fMuonIsoType.CompareTo("CombinedRelativeEffectiveAreaCorrected") == 0)
641	>	fMuIsoType = kCombinedRelativeEffectiveAreaCorrected;
642		else if (fMuonIsoType.CompareTo("PFIso") == 0)
643		fMuIsoType = kPFIso;
644	<	else if (fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0)
644	>	else if (fMuonIsoType.CompareTo("PFRadialIso") == 0)
645	>	fMuIsoType = kPFRadialIso;
646	>	else if (fMuonIsoType.CompareTo("PFIsoBetaPUCorrected") == 0)
647	>	fMuIsoType = kPFIsoBetaPUCorrected;
648	>	else if (fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0)
649		fMuIsoType = kPFIsoEffectiveAreaCorrected;
650		else if (fMuonIsoType.CompareTo("PFIsoNoL") == 0)
651		fMuIsoType = kPFIsoNoL;
#	Line 493 | Line 655 | void MuonIDMod::SlaveBegin()
655		fMuIsoType = kCustomIso;
656		SendError(kWarning, "SlaveBegin",
657		"Custom muon isolation is not yet implemented.");
658	<	} else if (fMuonIDType.CompareTo("MVA_BDTG_IDIso") == 0) {
658	>	} else if (fMuonIsoType.CompareTo("MVA_BDTG_IDIso") == 0) {
659		fMuIsoType = kMVAIso_BDTG_IDIso;
660	+	} else if (fMuonIsoType.CompareTo("IsoRingsV0_BDTG_Iso") == 0) {
661	+	fMuIsoType = kIsoRingsV0_BDTG_Iso;
662	+	} else if (fMuonIsoType.CompareTo("IsoDeltaR") == 0) {
663	+	fMuIsoType = kIsoDeltaR;
664		} else {
665		SendError(kAbortAnalysis, "SlaveBegin",
666		"The specified muon isolation %s is not defined.",
667		fMuonIsoType.Data());
668		return;
669		}
670	<
670	>
671		if (fMuonClassType.CompareTo("All") == 0)
672		fMuClassType = kAll;
673		else if (fMuonClassType.CompareTo("Global") == 0)
#	Line 516 | Line 682 | void MuonIDMod::SlaveBegin()
682		fMuClassType = kCaloMuon;
683		else if (fMuonClassType.CompareTo("TrackerBased") == 0)
684		fMuClassType = kTrackerBased;
685	+	else if (fMuonClassType.CompareTo("GlobalOnly") == 0)
686	+	fMuClassType = kGlobalOnly;
687	+	else if (fMuonClassType.CompareTo("GlobalorTracker") == 0)
688	+	fMuClassType = kGlobalorTracker;
689		else {
690		SendError(kAbortAnalysis, "SlaveBegin",
691		"The specified muon class %s is not defined.",
#	Line 525 | Line 695 | void MuonIDMod::SlaveBegin()
695
696
697		//If we use MVA ID, need to load MVA weights
698	<	if(fMuIsoType == kMVAIso_BDTG_IDIso || fMuIDType == kMVAID_BDTG_IDIso) {
698	>	if     (fMuIsoType == kMVAIso_BDTG_IDIso || fMuIDType == kMVAID_BDTG_IDIso) {
699		fMuonTools = new MuonTools();
700		fMuonIDMVA = new MuonIDMVA();
701		fMuonIDMVA->Initialize("BDTG method",
702	<	fMuonMVAWeights_Subdet0Pt10To14p5,
703	<	fMuonMVAWeights_Subdet1Pt10To14p5,
704	<	fMuonMVAWeights_Subdet0Pt14p5To20,
705	<	fMuonMVAWeights_Subdet1Pt14p5To20,
706	<	fMuonMVAWeights_Subdet0Pt20ToInf,
707	<	fMuonMVAWeights_Subdet1Pt20ToInf,
708	<	MuonIDMVA::kV8);
702	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/BarrelPtBin0_IDIsoCombined_BDTG.weights.xml"))),
703	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/EndcapPtBin0_IDIsoCombined_BDTG.weights.xml"))),
704	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/BarrelPtBin1_IDIsoCombined_BDTG.weights.xml"))),
705	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/EndcapPtBin1_IDIsoCombined_BDTG.weights.xml"))),
706	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/BarrelPtBin2_IDIsoCombined_BDTG.weights.xml"))),
707	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/EndcapPtBin2_IDIsoCombined_BDTG.weights.xml"))),
708	>	MuonIDMVA::kIDIsoCombinedDetIso,
709	>	fTheRhoType);
710	>	}
711	>	else if(fMuIsoType == kIsoRingsV0_BDTG_Iso) {
712	>	std::vector<std::string> muonidiso_weightfiles;
713	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml"))));
714	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml"))));
715	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml"))));
716	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml"))));
717	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml"))));
718	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml"))));
719	>	fMuonTools = new MuonTools();
720	>	fMuonIDMVA = new MuonIDMVA();
721	>	fMuonIDMVA->Initialize("MuonIso_BDTG_IsoRings",
722	>	MuonIDMVA::kIsoRingsV0,
723	>	kTRUE,
724	>	muonidiso_weightfiles,
725	>	fTheRhoType);
726	>	}
727	>	else if(fMuIsoType == kIsoDeltaR) {
728	>	std::vector<std::string> muonidiso_weightfiles;
729	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_LB_BDT.weights.xml"))));
730	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_LE_BDT.weights.xml"))));
731	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_HB_BDT.weights.xml"))));
732	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_HE_BDT.weights.xml"))));
733	>	fMuonTools = new MuonTools();
734	>	fMuonIDMVA = new MuonIDMVA();
735	>	fMuonIDMVA->Initialize("muonHZZ2012IsoDRMVA",
736	>	MuonIDMVA::kIsoDeltaR,
737	>	kTRUE,
738	>	muonidiso_weightfiles,
739	>	fTheRhoType);
740		}
741
742		}
#	Line 549 | Line 750 | Bool_t MuonIDMod::PassMuonMVA_BDTG_IdIso
750		const Track *muTrk=0;
751		if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
752		else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
753	<
753	>
754		Double_t MVAValue = fMuonIDMVA->MVAValue(mu,vertex,fMuonTools,fPFCandidates,PileupEnergyDensity);
755
756		Int_t subdet = 0;
#	Line 560 | Line 761 | Bool_t MuonIDMod::PassMuonMVA_BDTG_IdIso
761		if (muTrk->Pt() > 20.0) ptBin = 2;
762
763		Int_t MVABin = -1;
764	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
765	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
766	<	if (subdet == 0 && ptBin == 1) MVABin = 2;
767	<	if (subdet == 1 && ptBin == 1) MVABin = 3;
768	<	if (subdet == 0 && ptBin == 2) MVABin = 4;
769	<	if (subdet == 1 && ptBin == 2) MVABin = 5;
764	>	if      (subdet == 0 && ptBin == 0) MVABin = 0;
765	>	else if (subdet == 1 && ptBin == 0) MVABin = 1;
766	>	else if (subdet == 0 && ptBin == 1) MVABin = 2;
767	>	else if (subdet == 1 && ptBin == 1) MVABin = 3;
768	>	else if (subdet == 0 && ptBin == 2) MVABin = 4;
769	>	else if (subdet == 1 && ptBin == 2) MVABin = 5;
770	>
771	>	Double_t MVACut = -999;
772	>	if      (MVABin == 0) MVACut = -0.5618;
773	>	else if (MVABin == 1) MVACut = -0.3002;
774	>	else if (MVABin == 2) MVACut = -0.4642;
775	>	else if (MVABin == 3) MVACut = -0.2478;
776	>	else if (MVABin == 4) MVACut =  0.1706;
777	>	else if (MVABin == 5) MVACut =  0.8146;
778	>
779	>	if (MVAValue > MVACut) return kTRUE;
780	>	return kFALSE;
781	>	}
782	>
783	>	//--------------------------------------------------------------------------------------------------
784	>	Bool_t MuonIDMod::PassMuonIsoRingsV0_BDTG_Iso(const Muon *mu, const Vertex *vertex,
785	>	const PileupEnergyDensityCol *PileupEnergyDensity) const
786	>	{
787	>
788	>	Bool_t isDebug = kFALSE;
789	>	const Track *muTrk=0;
790	>	if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
791	>	else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
792	>
793	>	ElectronOArr *tempElectrons = new  ElectronOArr;
794	>	MuonOArr     *tempMuons     = new  MuonOArr;
795	>	Double_t MVAValue = fMuonIDMVA->MVAValue(mu,vertex,fMuonTools,fPFCandidates,
796	>	PileupEnergyDensity,MuonTools::kMuEAFall11MC,tempElectrons,tempMuons,isDebug);
797	>	delete tempElectrons;
798	>	delete tempMuons;
799	>
800	>	Int_t MVABin = fMuonIDMVA->GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon());
801	>
802	>	Double_t MVACut = -1.0;
803	>	Double_t eta = mu->AbsEta();
804	>	if     (mu->Pt() <  20 && eta <  1.479) MVACut = 0.86;
805	>	else if(mu->Pt() <  20 && eta >= 1.479) MVACut = 0.82;
806	>	else if(mu->Pt() >= 20 && eta <  1.479) MVACut = 0.82;
807	>	else if(mu->Pt() >= 20 && eta >= 1.479) MVACut = 0.86;
808	>
809	>	if(fPFIsolationCut > -1.0) MVACut = fPFIsolationCut;
810	>
811	>	if(isDebug == kTRUE){
812	>	printf("PassMuonIsoRingsV0_BDTG_IsoDebug: %d, pt, eta = %f, %f, rho = %f(%f) : RingsMVA = %f, bin: %d\n",
813	>	GetEventHeader()->EvtNum(),mu->Pt(), mu->Eta(),
814	>	fPileupEnergyDensity->At(0)->Rho(),fPileupEnergyDensity->At(0)->RhoKt6PFJets(),MVAValue,MVABin);
815	>	}
816	>
817	>	if (MVAValue > MVACut) return kTRUE;
818	>	return kFALSE;
819	>	}
820	>
821	>	//--------------------------------------------------------------------------------------------------
822	>	Bool_t MuonIDMod::PassMuonIsoDeltaR(const Muon *mu, const Vertex *vertex,
823	>	const PileupEnergyDensityCol *PileupEnergyDensity) const
824	>	{
825	>
826	>	const Track *muTrk=0;
827	>	if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
828	>	else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
829	>
830	>	ElectronOArr *tempElectrons = new  ElectronOArr;
831	>	MuonOArr     *tempMuons     = new  MuonOArr;
832	>	Double_t MVAValue = fMuonIDMVA->MVAValue(mu,vertex,fMuonTools,fPFNoPileUpCands,
833	>	PileupEnergyDensity,MuonTools::kMuEAFall11MC,tempElectrons,tempMuons,kFALSE);
834	>	delete tempElectrons;
835	>	delete tempMuons;
836	>
837	>	Int_t MVABin = fMuonIDMVA->GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon());
838
839		Double_t MVACut = -999;
840	<	if (MVABin == 0) MVACut = -0.377;
841	<	if (MVABin == 1) MVACut = -0.0902;
842	<	if (MVABin == 2) MVACut = -0.221;
843	<	if (MVABin == 3) MVACut = -0.0154;
575	<	if (MVABin == 4) MVACut = 0.459;
576	<	if (MVABin == 5) MVACut = 0.9158;
840	>	if      (MVABin == 0) MVACut =  0.000;
841	>	else if (MVABin == 1) MVACut =  0.000;
842	>	else if (MVABin == 2) MVACut =  0.000;
843	>	else if (MVABin == 3) MVACut =  0.000;
844
845		if (MVAValue > MVACut) return kTRUE;
846		return kFALSE;
847		}
848	+
849	+	//--------------------------------------------------------------------------------------------------
850	+	void MuonIDMod::Terminate()
851	+	{
852	+	// Run finishing code on the computer (slave) that did the analysis
853	+	delete fMuonIDMVA;
854	+
855	+	delete fMuonTools;
856	+	}

Diff Legend

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