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.84 by ceballos, Fri Jun 15 11:58:54 2012 UTC

#	Line 30 | Line 30 | ClassImp(mithep::MuonIDMod)
30		fCaloIsolationCut(3.0),
31		fCombIsolationCut(0.15),
32		fCombRelativeIsolationCut(0.15),
33	<	fPFIsolationCut(-1.0),
33	>	fPFIsolationCut(-999.0),
34		fMuonPtMin(10),
35		fApplyD0Cut(kTRUE),
36		fApplyDZCut(kTRUE),
#	Line 54 | Line 54 | ClassImp(mithep::MuonIDMod)
54		fPileupEnergyDensity(0),
55		fMuonTools(0),
56		fMuonIDMVA(0),
57	–	fMuonMVAWeights_Subdet0Pt10To14p5(""),
58	–	fMuonMVAWeights_Subdet1Pt10To14p5(""),
59	–	fMuonMVAWeights_Subdet0Pt14p5To20(""),
60	–	fMuonMVAWeights_Subdet1Pt14p5To20(""),
61	–	fMuonMVAWeights_Subdet0Pt20ToInf(""),
62	–	fMuonMVAWeights_Subdet1Pt20ToInf(""),
57		fTheRhoType(RhoUtilities::DEFAULT)
58		{
59		// Constructor.
#	Line 80 | Line 74 | void MuonIDMod::Process()
74		LoadEventObject(fTrackName, fTracks);
75		LoadEventObject(fPFCandidatesName, fPFCandidates);
76		if(fMuIsoType == kTrackCaloSliding ||
77	<	fMuIsoType == kCombinedRelativeConeAreaCorrected ||
78	<	fMuIsoType == kPFIsoEffectiveAreaCorrected ||
79	<	fMuIsoType == kMVAIso_BDTG_IDIso
77	>	fMuIsoType == kCombinedRelativeConeAreaCorrected ||
78	>	fMuIsoType == kPFIsoEffectiveAreaCorrected ||
79	>	fMuIsoType == kMVAIso_BDTG_IDIso ||
80	>	fMuIsoType == kIsoRingsV0_BDTG_Iso ||
81	>	fMuIsoType == kIsoDeltaR
82		) {
83		LoadEventObject(fPileupEnergyDensityName, fPileupEnergyDensity);
84		}
85	<	if(fMuIsoType == kPFRadialIso){
85	>	if(fMuIsoType == kPFRadialIso || fMuIsoType == kIsoDeltaR){
86		// Name is hardcoded, can be changed if someone feels to do it
87		fPFNoPileUpCands = GetObjThisEvt<PFCandidateCol>("PFNoPileUp");
88		}
#	Line 164 | Line 160 | void MuonIDMod::Process()
160		eta = TMath::Abs(mu->TrackerTrk()->Eta());
161		}
162		break;
163	+	case kGlobalOnly:
164	+	pass = mu->HasGlobalTrk();
165	+	if (pass && mu->TrackerTrk()) {
166	+	pt  = mu->TrackerTrk()->Pt();
167	+	eta = TMath::Abs(mu->TrackerTrk()->Eta());
168	+	}
169	+	else {
170	+	pt  = mu->Pt();
171	+	eta = TMath::Abs(mu->Eta());
172	+	}
173	+	break;
174		default:
175		break;
176		}
#	Line 177 | Line 184 | void MuonIDMod::Process()
184		if (eta >= fEtaCut)
185		continue;
186
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	–
187		Double_t RChi2 = 0.0;
188		if     (mu->HasGlobalTrk()) {
189		RChi2 = mu->GlobalTrk()->Chi2()/mu->GlobalTrk()->Ndof();
#	Line 226 | Line 217 | void MuonIDMod::Process()
217		mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
218		break;
219		case kTight:
220	<	idpass = mu->BestTrk() !=  0 &&
221	<	mu->Quality().Quality(MuonQuality::TMOneStationTight) &&
222	<	mu->Quality().Quality(MuonQuality::TM2DCompatibilityTight) &&
223	<	mu->BestTrk()->NHits() > 10 &&
224	<	RChi2 < 10.0 &&
234	<	mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
220	>	idpass = mu->BestTrk() != 0 &&
221	>	mu->NTrkLayersHit() > 5 &&
222	>	mu->IsPFMuon() == kTRUE &&
223	>	mu->BestTrk()->NPixelHits() > 0 &&
224	>	RChi2 < 10.0;
225		break;
226	+	// 2012 WW analysis for 42x (there is no PFMuon link)
227		case kWWMuIdV1:
228		idpass = mu->BestTrk() != 0 &&
229	<	mu->BestTrk()->NHits() > 10 &&
229	>	mu->NTrkLayersHit() > 5 &&
230		mu->BestTrk()->NPixelHits() > 0 &&
231		mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1 &&
232	<	RChi2 < 10.0 &&
242	<	(mu->NSegments() > 1 || mu->NMatches() > 1) &&
243	<	mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
232	>	mu->TrkKink() < 20.0;
233		break;
234	+	// 2010 WW analysis
235		case kWWMuIdV2:
236		idpass = mu->BestTrk() != 0 &&
237		mu->BestTrk()->NHits() > 10 &&
238		mu->BestTrk()->NPixelHits() > 0 &&
239		mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1;
240		break;
241	+	// 2011 WW analysis
242		case kWWMuIdV3:
243		idpass = mu->BestTrk() != 0 &&
244		mu->BestTrk()->NHits() > 10 &&
#	Line 255 | Line 246 | void MuonIDMod::Process()
246		mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1 &&
247		mu->TrkKink() < 20.0;
248		break;
249	+	// 2012 WW analysis
250	+	case kWWMuIdV4:
251	+	idpass = mu->BestTrk() != 0 &&
252	+	mu->NTrkLayersHit() > 5 &&
253	+	mu->IsPFMuon() == kTRUE &&
254	+	mu->BestTrk()->NPixelHits() > 0 &&
255	+	mu->BestTrk()->PtErr()/mu->BestTrk()->Pt() < 0.1 &&
256	+	mu->TrkKink() < 20.0;
257	+	break;
258		case kMVAID_BDTG_IDIso:
259		{
260		Bool_t passDenominatorM2 = (mu->BestTrk() != 0 &&
#	Line 297 | Line 297 | void MuonIDMod::Process()
297		case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
298		Rho = rho->RhoRandom();
299		break;
300	+	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
301	+	Rho = rho->RhoKt6PFJets();
302	+	break;
303		default:
304		Rho = rho->Rho();
305		}
#	Line 327 | Line 330 | void MuonIDMod::Process()
330		if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
331		}
332		break;
333	<	case kTrackCaloSlidingNoCorrection:
333	>	case kTrackCaloSlidingNoCorrection:
334		{
335		Double_t totalIso =  1.0 * mu->IsoR03SumPt() +
336		1.0 * mu->IsoR03EmEt()  +
#	Line 341 | Line 344 | void MuonIDMod::Process()
344		if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
345		}
346		break;
347	<	case kCombinedRelativeConeAreaCorrected:
348	<	{
349	<	//const PileupEnergyDensity *rho =  fPileupEnergyDensity->At(0); // Fabian: made Rho customable
350	<	Double_t totalIso =  mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt() - Rho * TMath::Pi() * 0.3 * 0.3 ;
351	<	double theIsoCut = fCombRelativeIsolationCut;
352	<	if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
353	<	}
354	<	break;
355	<	case kCombinedRelativeEffectiveAreaCorrected:
356	<	{
357	<	Double_t tmpRho = Rho;   // Fabian: made the Rho type customable.
358	<	//if (!(TMath::IsNaN(fPileupEnergyDensity->At(0)->Rho()) || std::isinf(fPileupEnergyDensity->At(0)->Rho())))
359	<	//tmpRho = fPileupEnergyDensity->At(0)->Rho();
347	>	case kCombinedRelativeConeAreaCorrected:
348	>	{
349	>	//const PileupEnergyDensity *rho =  fPileupEnergyDensity->At(0); // Fabian: made Rho customable
350	>	Double_t totalIso =  mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt() - Rho * TMath::Pi() * 0.3 * 0.3 ;
351	>	double theIsoCut = fCombRelativeIsolationCut;
352	>	if (totalIso < (mu->Pt()*theIsoCut)) isocut = kTRUE;
353	>	}
354	>	break;
355	>	case kCombinedRelativeEffectiveAreaCorrected:
356	>	{
357	>	Double_t tmpRho = Rho;   // Fabian: made the Rho type customable.
358	>	//if (!(TMath::IsNaN(fPileupEnergyDensity->At(0)->Rho()) || std::isinf(fPileupEnergyDensity->At(0)->Rho())))
359	>	//tmpRho = fPileupEnergyDensity->At(0)->Rho();
360
361	<	isocut = ( mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt()
362	<	-  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03, mu->Eta())
363	<	-  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03, mu->Eta())
364	<	) < (mu->Pt()* 0.40);
365	<	}
366	<	break;
367	<	case kPFIso:
368	<	{
369	<	Double_t pfIsoCutValue = 9999;
370	<	if(fPFIsolationCut > 0){
371	<	pfIsoCutValue = fPFIsolationCut;
372	<	} else {
373	<	if (mu->AbsEta() < 1.479) {
374	<	if (mu->Pt() > 20) {
375	<	pfIsoCutValue = 0.13;
376	<	} else {
377	<	pfIsoCutValue = 0.06;
375	<	}
376	<	} else {
377	<	if (mu->Pt() > 20) {
378	<	pfIsoCutValue = 0.09;
379	<	} else {
380	<	pfIsoCutValue = 0.05;
381	<	}
361	>	isocut = ( mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt()
362	>	-  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03, mu->Eta())
363	>	-  tmpRho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03, mu->Eta())
364	>	) < (mu->Pt()* 0.40);
365	>	}
366	>	break;
367	>	case kPFIso:
368	>	{
369	>	Double_t pfIsoCutValue = 9999;
370	>	if(fPFIsolationCut > 0){
371	>	pfIsoCutValue = fPFIsolationCut;
372	>	} else {
373	>	if (mu->AbsEta() < 1.479) {
374	>	if (mu->Pt() > 20) {
375	>	pfIsoCutValue = 0.13;
376	>	} else {
377	>	pfIsoCutValue = 0.06;
378		}
379	<	}
380	<	Double_t totalIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius);
381	<	if (totalIso < (mu->Pt()*pfIsoCutValue) )
382	<	isocut = kTRUE;
379	>	} else {
380	>	if (mu->Pt() > 20) {
381	>	pfIsoCutValue = 0.09;
382	>	} else {
383	>	pfIsoCutValue = 0.05;
384	>	}
385	>	}
386		}
387	<	break;
388	<	case kPFRadialIso:
389	<	{
390	<	Double_t pfIsoCutValue = 9999;
391	<	if(fPFIsolationCut > 0){
392	<	pfIsoCutValue = fPFIsolationCut;
393	<	} else {
394	<	if (mu->Pt() > 20) {
395	<	pfIsoCutValue = 0.10;
396	<	} else {
387	>	Double_t totalIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius);
388	>	if (totalIso < (mu->Pt()*pfIsoCutValue) )
389	>	isocut = kTRUE;
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 {
401		pfIsoCutValue = 0.05;
402		}
403		}
#	Line 402 | Line 405 | void MuonIDMod::Process()
405		if (totalIso < (mu->Pt()*pfIsoCutValue) )
406		isocut = kTRUE;
407		}
408	<	break;
409	<	case kPFIsoEffectiveAreaCorrected:
410	<	{
411	<	Double_t pfIsoCutValue = 9999;
412	<	if(fPFIsolationCut > 0){
413	<	pfIsoCutValue = fPFIsolationCut;
414	<	} else {
415	<	pfIsoCutValue = fPFIsolationCut; //leave it like this for now
416	<	}
417	<	Double_t EffectiveAreaCorrectedPFIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius)
418	<	- Rho * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());
419	<	//- fPileupEnergyDensity->At(0)->Rho() * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());  // Fabian: made Rho-type customable
420	<	isocut = EffectiveAreaCorrectedPFIso < (mu->Pt() * pfIsoCutValue);
421	<	break;
422	<	}
423	<	case kPFIsoNoL:
408	>	break;
409	>	case kPFIsoEffectiveAreaCorrected:
410	>	{
411	>	Double_t pfIsoCutValue = 9999;
412	>	if(fPFIsolationCut > 0){
413	>	pfIsoCutValue = fPFIsolationCut;
414	>	} else {
415	>	pfIsoCutValue = fPFIsolationCut; //leave it like this for now
416	>	}
417	>	Double_t EffectiveAreaCorrectedPFIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius)
418	>	- Rho * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());
419	>	//- fPileupEnergyDensity->At(0)->Rho() * MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03, mu->Eta());  // Fabian: made Rho-type customable
420	>	isocut = EffectiveAreaCorrectedPFIso < (mu->Pt() * pfIsoCutValue);
421	>	break;
422	>	}
423	>
424	>
425	>	case kPFIsoNoL:
426		{
427		fNonIsolatedMuons     = GetObjThisEvt<MuonCol>(fNonIsolatedMuonsName);
428		fNonIsolatedElectrons = GetObjThisEvt<ElectronCol>(fNonIsolatedElectronsName);
#	Line 448 | Line 453 | void MuonIDMod::Process()
453		case kMVAIso_BDTG_IDIso:
454		{
455
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	–
456		Double_t totalIso =  IsolationTools::PFMuonIsolation(mu, fPFCandidates, fVertices->At(0), 0.1, 1.0, 0.3, 0.0, fIntRadius);
457		isocut = (totalIso < (mu->Pt()*0.4));
458
459		}
460		break;
461	+	case kIsoRingsV0_BDTG_Iso:
462	+	{
463	+
464	+	isocut = PassMuonIsoRingsV0_BDTG_Iso(mu, fVertices->At(0), fPileupEnergyDensity);
465	+
466	+	}
467	+	break;
468	+	case kIsoDeltaR:
469	+	{
470	+
471	+	isocut = PassMuonIsoDeltaR(mu, fVertices->At(0), fPileupEnergyDensity);
472	+
473	+	}
474	+	break;
475		case kNoIso:
476		isocut = kTRUE;
477		break;
#	Line 522 | Line 528 | void MuonIDMod::SlaveBegin()
528		ReqEventObject(fTrackName, fTracks, kTRUE);
529		ReqEventObject(fPFCandidatesName, fPFCandidates, kTRUE);
530		if (fMuonIsoType.CompareTo("TrackCaloSliding") == 0
531	<	|| fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0
532	<	|| fMuonIsoType.CompareTo("CombinedRelativeEffectiveAreaCorrected") == 0
533	<	|| fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0
531	>	|| fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0
532	>	|| fMuonIsoType.CompareTo("CombinedRelativeEffectiveAreaCorrected") == 0
533	>	|| fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0
534		|| fMuonIsoType.CompareTo("MVA_BDTG_IDIso") == 0
535	+	|| fMuonIsoType.CompareTo("IsoRingsV0_BDTG_Iso") == 0
536	+	|| fMuonIsoType.CompareTo("IsoDeltaR") == 0
537		) {
538		ReqEventObject(fPileupEnergyDensityName, fPileupEnergyDensity, kTRUE);
539		}
#	Line 545 | Line 553 | void MuonIDMod::SlaveBegin()
553		fMuIDType = kWWMuIdV2;
554		else if (fMuonIDType.CompareTo("WWMuIdV3") == 0)
555		fMuIDType = kWWMuIdV3;
556	+	else if (fMuonIDType.CompareTo("WWMuIdV4") == 0)
557	+	fMuIDType = kWWMuIdV4;
558		else if (fMuonIDType.CompareTo("NoId") == 0)
559		fMuIDType = kNoId;
560		else if (fMuonIDType.CompareTo("Custom") == 0) {
#	Line 568 | Line 578 | void MuonIDMod::SlaveBegin()
578		fMuIsoType = kTrackCaloSliding;
579		else if (fMuonIsoType.CompareTo("TrackCaloSlidingNoCorrection") == 0)
580		fMuIsoType = kTrackCaloSlidingNoCorrection;
581	<	else if (fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0)
582	<	fMuIsoType = kCombinedRelativeConeAreaCorrected;
583	<	else if (fMuonIsoType.CompareTo("CombinedRelativeEffectiveAreaCorrected") == 0)
581	>	else if (fMuonIsoType.CompareTo("CombinedRelativeConeAreaCorrected") == 0)
582	>	fMuIsoType = kCombinedRelativeConeAreaCorrected;
583	>	else if (fMuonIsoType.CompareTo("CombinedRelativeEffectiveAreaCorrected") == 0)
584		fMuIsoType = kCombinedRelativeEffectiveAreaCorrected;
585		else if (fMuonIsoType.CompareTo("PFIso") == 0)
586		fMuIsoType = kPFIso;
587		else if (fMuonIsoType.CompareTo("PFRadialIso") == 0)
588		fMuIsoType = kPFRadialIso;
589	<	else if (fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0)
589	>	else if (fMuonIsoType.CompareTo("PFIsoEffectiveAreaCorrected") == 0)
590		fMuIsoType = kPFIsoEffectiveAreaCorrected;
591		else if (fMuonIsoType.CompareTo("PFIsoNoL") == 0)
592		fMuIsoType = kPFIsoNoL;
#	Line 586 | Line 596 | void MuonIDMod::SlaveBegin()
596		fMuIsoType = kCustomIso;
597		SendError(kWarning, "SlaveBegin",
598		"Custom muon isolation is not yet implemented.");
599	<	} else if (fMuonIDType.CompareTo("MVA_BDTG_IDIso") == 0) {
599	>	} else if (fMuonIsoType.CompareTo("MVA_BDTG_IDIso") == 0) {
600		fMuIsoType = kMVAIso_BDTG_IDIso;
601	+	} else if (fMuonIsoType.CompareTo("IsoRingsV0_BDTG_Iso") == 0) {
602	+	fMuIsoType = kIsoRingsV0_BDTG_Iso;
603	+	} else if (fMuonIsoType.CompareTo("IsoDeltaR") == 0) {
604	+	fMuIsoType = kIsoDeltaR;
605		} else {
606		SendError(kAbortAnalysis, "SlaveBegin",
607		"The specified muon isolation %s is not defined.",
#	Line 609 | Line 623 | void MuonIDMod::SlaveBegin()
623		fMuClassType = kCaloMuon;
624		else if (fMuonClassType.CompareTo("TrackerBased") == 0)
625		fMuClassType = kTrackerBased;
626	+	else if (fMuonClassType.CompareTo("GlobalOnly") == 0)
627	+	fMuClassType = kGlobalOnly;
628		else {
629		SendError(kAbortAnalysis, "SlaveBegin",
630		"The specified muon class %s is not defined.",
#	Line 618 | Line 634 | void MuonIDMod::SlaveBegin()
634
635
636		//If we use MVA ID, need to load MVA weights
637	<	if(fMuIsoType == kMVAIso_BDTG_IDIso || fMuIDType == kMVAID_BDTG_IDIso) {
637	>	if     (fMuIsoType == kMVAIso_BDTG_IDIso || fMuIDType == kMVAID_BDTG_IDIso) {
638		fMuonTools = new MuonTools();
639		fMuonIDMVA = new MuonIDMVA();
640		fMuonIDMVA->Initialize("BDTG method",
641	<	fMuonMVAWeights_Subdet0Pt10To14p5,
642	<	fMuonMVAWeights_Subdet1Pt10To14p5,
643	<	fMuonMVAWeights_Subdet0Pt14p5To20,
644	<	fMuonMVAWeights_Subdet1Pt14p5To20,
645	<	fMuonMVAWeights_Subdet0Pt20ToInf,
646	<	fMuonMVAWeights_Subdet1Pt20ToInf,
647	<	MuonIDMVA::kIDIsoCombinedDetIso);
641	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/BarrelPtBin0_IDIsoCombined_BDTG.weights.xml"))),
642	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/EndcapPtBin0_IDIsoCombined_BDTG.weights.xml"))),
643	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/BarrelPtBin1_IDIsoCombined_BDTG.weights.xml"))),
644	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/EndcapPtBin1_IDIsoCombined_BDTG.weights.xml"))),
645	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/BarrelPtBin2_IDIsoCombined_BDTG.weights.xml"))),
646	>	string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/EndcapPtBin2_IDIsoCombined_BDTG.weights.xml"))),
647	>	MuonIDMVA::kIDIsoCombinedDetIso,
648	>	fTheRhoType);
649	>	}
650	>	else if(fMuIsoType == kIsoRingsV0_BDTG_Iso) {
651	>	std::vector<std::string> muonidiso_weightfiles;
652	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml"))));
653	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml"))));
654	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml"))));
655	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml"))));
656	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml"))));
657	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml"))));
658	>	fMuonTools = new MuonTools();
659	>	fMuonIDMVA = new MuonIDMVA();
660	>	fMuonIDMVA->Initialize("MuonIso_BDTG_IsoRings",
661	>	MuonIDMVA::kIsoRingsV0,
662	>	kTRUE,
663	>	muonidiso_weightfiles,
664	>	fTheRhoType);
665	>	}
666	>	else if(fMuIsoType == kIsoDeltaR) {
667	>	std::vector<std::string> muonidiso_weightfiles;
668	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_LB_BDT.weights.xml"))));
669	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_LE_BDT.weights.xml"))));
670	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_HB_BDT.weights.xml"))));
671	>	muonidiso_weightfiles.push_back(string((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/MuonMVAWeights/MuonIsoMVA_santi-V1_HE_BDT.weights.xml"))));
672	>	fMuonTools = new MuonTools();
673	>	fMuonIDMVA = new MuonIDMVA();
674	>	fMuonIDMVA->Initialize("muonHZZ2012IsoDRMVA",
675	>	MuonIDMVA::kIsoDeltaR,
676	>	kTRUE,
677	>	muonidiso_weightfiles,
678	>	fTheRhoType);
679		}
680
681		}
#	Line 671 | Line 718 | Bool_t MuonIDMod::PassMuonMVA_BDTG_IdIso
718		if (MVAValue > MVACut) return kTRUE;
719		return kFALSE;
720		}
721	+
722	+	//--------------------------------------------------------------------------------------------------
723	+	Bool_t MuonIDMod::PassMuonIsoRingsV0_BDTG_Iso(const Muon *mu, const Vertex *vertex,
724	+	const PileupEnergyDensityCol *PileupEnergyDensity) const
725	+	{
726	+
727	+	Bool_t isDebug = kFALSE;
728	+	const Track *muTrk=0;
729	+	if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
730	+	else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
731	+
732	+	ElectronOArr *tempElectrons = new  ElectronOArr;
733	+	MuonOArr     *tempMuons     = new  MuonOArr;
734	+	Double_t MVAValue = fMuonIDMVA->MVAValue(mu,vertex,fMuonTools,fPFCandidates,
735	+	PileupEnergyDensity,MuonTools::kMuEAFall11MC,tempElectrons,tempMuons,isDebug);
736	+	delete tempElectrons;
737	+	delete tempMuons;
738	+
739	+	Int_t MVABin = fMuonIDMVA->GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon());
740	+
741	+	Double_t MVACut = -1.0;
742	+	Double_t eta = mu->AbsEta();
743	+	if     (mu->Pt() <  20 && eta <  1.479) MVACut = 0.86;
744	+	else if(mu->Pt() <  20 && eta >= 1.479) MVACut = 0.82;
745	+	else if(mu->Pt() >= 20 && eta <  1.479) MVACut = 0.82;
746	+	else if(mu->Pt() >= 20 && eta >= 1.479) MVACut = 0.86;
747	+
748	+	if(fPFIsolationCut > -1.0) MVACut = fPFIsolationCut;
749	+
750	+	if(isDebug == kTRUE){
751	+	printf("PassMuonIsoRingsV0_BDTG_IsoDebug: %d, pt, eta = %f, %f, rho = %f(%f) : RingsMVA = %f, bin: %d\n",
752	+	GetEventHeader()->EvtNum(),mu->Pt(), mu->Eta(),
753	+	fPileupEnergyDensity->At(0)->Rho(),fPileupEnergyDensity->At(0)->RhoKt6PFJets(),MVAValue,MVABin);
754	+	}
755	+
756	+	if (MVAValue > MVACut) return kTRUE;
757	+	return kFALSE;
758	+	}
759	+
760	+	//--------------------------------------------------------------------------------------------------
761	+	Bool_t MuonIDMod::PassMuonIsoDeltaR(const Muon *mu, const Vertex *vertex,
762	+	const PileupEnergyDensityCol *PileupEnergyDensity) const
763	+	{
764	+
765	+	const Track *muTrk=0;
766	+	if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
767	+	else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
768	+
769	+	ElectronOArr *tempElectrons = new  ElectronOArr;
770	+	MuonOArr     *tempMuons     = new  MuonOArr;
771	+	Double_t MVAValue = fMuonIDMVA->MVAValue(mu,vertex,fMuonTools,fPFNoPileUpCands,
772	+	PileupEnergyDensity,MuonTools::kMuEAFall11MC,tempElectrons,tempMuons,kFALSE);
773	+	delete tempElectrons;
774	+	delete tempMuons;
775	+
776	+	Int_t MVABin = fMuonIDMVA->GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon());
777	+
778	+	Double_t MVACut = -999;
779	+	if      (MVABin == 0) MVACut =  0.000;
780	+	else if (MVABin == 1) MVACut =  0.000;
781	+	else if (MVABin == 2) MVACut =  0.000;
782	+	else if (MVABin == 3) MVACut =  0.000;
783	+
784	+	if (MVAValue > MVACut) return kTRUE;
785	+	return kFALSE;
786	+	}
787	+
788	+	//--------------------------------------------------------------------------------------------------
789	+	void MuonIDMod::Terminate()
790	+	{
791	+	// Run finishing code on the computer (slave) that did the analysis
792	+	delete fMuonIDMVA;
793	+
794	+	delete fMuonTools;
795	+	}

Diff Legend

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