Mods/src/MuonIDMod.cc

// $Id: MuonIDMod.cc,v 1.18 2009/05/07 20:27:07 loizides Exp $

#include "MitPhysics/Mods/interface/MuonIDMod.h"
#include "MitCommon/MathTools/interface/MathUtils.h"
#include "MitPhysics/Init/interface/ModNames.h"

using namespace mithep;

ClassImp(mithep::MuonIDMod)

//--------------------------------------------------------------------------------------------------
  MuonIDMod::MuonIDMod(const char *name, const char *title) : 
  BaseMod(name,title),
  fMuonBranchName(Names::gkMuonBrn),
  fCleanMuonsName(ModNames::gkCleanMuonsName),  
  fVertexName("PrimaryVertexesBeamSpot"),
  fMuonIDType("Loose"),
  fMuonIsoType("TrackCaloSliding"),  
  fMuonClassType("Global"),  
  fTrackIsolationCut(3.0),
  fCaloIsolationCut(3.0),
  fCombIsolationCut(5.0),
  fMuonPtMin(10),
  fD0Cut(0.025),
  fMuIDType(kIdUndef),
  fMuIsoType(kIsoUndef),
  fMuClassType(kClassUndef),
  fMuons(0),
  fVertices(0),
  fMuonTools(0),
  fReverseIsoCut(kFALSE)
{
  // Constructor.
}

//--------------------------------------------------------------------------------------------------
void MuonIDMod::Process()
{
  // Process entries of the tree. 

  LoadBranch(fMuonBranchName);
  LoadBranch(fVertexName);

  MuonOArr *CleanMuons = new MuonOArr;
  CleanMuons->SetName(fCleanMuonsName);

  for (UInt_t i=0; i<fMuons->GetEntries(); ++i) {
    const Muon *mu = fMuons->At(i);

    Bool_t pass = kFALSE;
    Double_t pt = 0; // make sure pt is taken from the correct track!
    switch (fMuClassType) {
      case kAll:
        pass = kTRUE;
        if (mu->HasTrk())
          pt = mu->Pt();
        break;
      case kGlobal:
        pass = mu->HasGlobalTrk();
        if (pass) 
          pt = mu->GlobalTrk()->Pt();
        break;
      case kSta:
        pass = mu->HasStandaloneTrk();
        if (pass) 
          pt = mu->StandaloneTrk()->Pt();
        break;
      case kTrackerOnly:
        pass = mu->HasTrackerTrk();
        if (pass) 
          pt = mu->TrackerTrk()->Pt();
        break;
      default:
        break;
    }

    if (!pass)
      continue;

    if (pt <= fMuonPtMin) 
      continue;

    Bool_t idpass = kFALSE;
    switch (fMuIDType) {
      case kLoose:
        idpass = fMuonTools->IsGood(mu, MuonTools::kTMOneStationLoose) &&
                 fMuonTools->IsGood(mu, MuonTools::kTM2DCompatibilityLoose);
        break;
      case kTight:
        idpass = fMuonTools->IsGood(mu, MuonTools::kTMOneStationTight) &&
                 fMuonTools->IsGood(mu, MuonTools::kTM2DCompatibilityTight);
        break;
      case kNoId:
        idpass = kTRUE;
        break;
      default:
        break;
    }

    if (!idpass)
      continue;

    Bool_t isopass = kFALSE;
    switch (fMuIsoType) {
      case kTrackCalo:
        isopass = (mu->IsoR03SumPt() < fTrackIsolationCut) &&
          (mu->IsoR03EmEt() + mu->IsoR03HadEt() < fCaloIsolationCut);
        break;
      case kTrackCaloCombined:
        isopass = (1.0 * mu->IsoR03SumPt() + 1.0 * mu->IsoR03EmEt() + 
                   1.0 * mu->IsoR03HadEt() < fCombIsolationCut);
        break;
      case kTrackCaloSliding:
        { 
          Double_t totalIso = 1.0 * mu->IsoR03SumPt() + 
                              1.0 * mu->IsoR03EmEt() + 
                              1.0 * mu->IsoR03HadEt();
          if ((totalIso < (pt-10.0)*5.0/15.0 && pt <= 25) ||
              (totalIso < 5.0 && mu->Pt() > 25) ||
               totalIso <= 0) 
            isopass = kTRUE;
        }
        break;
      case kNoIso:
        isopass = kTRUE;
        break;
      case kCustomIso:
      default:
        break;
    }

    if ((isopass == kFALSE && fReverseIsoCut == kFALSE) ||
        (isopass == kTRUE  && fReverseIsoCut == kTRUE))
      continue;

    // d0 cut only for global muons
    if (fMuClassType == kGlobal) {
      Double_t d0_real = 1e30;
      for(UInt_t i0 = 0; i0 < fVertices->GetEntries(); i0++) {
        Double_t pD0 = mu->GlobalTrk()->D0Corrected(*fVertices->At(i0));
        if(TMath::Abs(pD0) < TMath::Abs(d0_real)) 
          d0_real = TMath::Abs(pD0);
      }
      if(d0_real >= fD0Cut) 
        continue;
    }

    // add good muon
    CleanMuons->Add(mu);
  }

  // sort according to pt
  CleanMuons->Sort();

  // add objects for other modules to use
  AddObjThisEvt(CleanMuons);  
}

//--------------------------------------------------------------------------------------------------
void MuonIDMod::SlaveBegin()
{
  // Run startup code on the computer (slave) doing the actual analysis. Here,
  // we just request the muon collection branch.

  ReqBranch(fMuonBranchName, fMuons);
  ReqBranch(fVertexName, fVertices);

  fMuonTools = new MuonTools;

  if (fMuonIDType.CompareTo("Tight") == 0) 
    fMuIDType = kTight;
  else if (fMuonIDType.CompareTo("Loose") == 0) 
    fMuIDType = kLoose;
  else if (fMuonIDType.CompareTo("NoId") == 0) 
    fMuIDType = kNoId;
  else if (fMuonIDType.CompareTo("Custom") == 0) {
    fMuIDType = kCustomId;
    SendError(kWarning, "SlaveBegin",
              "Custom muon identification is not yet implemented.");
  } else {
    SendError(kAbortAnalysis, "SlaveBegin",
              "The specified muon identification %s is not defined.",
              fMuonIDType.Data());
    return;
  }

  if (fMuonIsoType.CompareTo("TrackCalo") == 0)
    fMuIsoType = kTrackCalo;
  else if (fMuonIsoType.CompareTo("TrackCaloCombined") == 0)
    fMuIsoType = kTrackCaloCombined;
  else if (fMuonIsoType.CompareTo("TrackCaloSliding") == 0)
    fMuIsoType = kTrackCaloSliding;
  else if (fMuonIsoType.CompareTo("NoIso") == 0)
    fMuIsoType = kNoIso;
  else if (fMuonIsoType.CompareTo("Custom") == 0) {
    fMuIsoType = kCustomIso;
    SendError(kWarning, "SlaveBegin",
              "Custom muon isolation is not yet implemented.");
  } else {
    SendError(kAbortAnalysis, "SlaveBegin",
              "The specified muon isolation %s is not defined.",
              fMuonIsoType.Data());
    return;
  }

  if (fMuonClassType.CompareTo("All") == 0) 
    fMuClassType = kAll;
  else if (fMuonClassType.CompareTo("Global") == 0) 
    fMuClassType = kGlobal;
  else if (fMuonClassType.CompareTo("Standalone") == 0) 
    fMuClassType = kSta;
  else if (fMuonClassType.CompareTo("TrackerOnly") == 0) 
    fMuClassType = kTrackerOnly;
  else {
    SendError(kAbortAnalysis, "SlaveBegin",
              "The specified muon class %s is not defined.",
              fMuonClassType.Data());
    return;
  }
}
Revision:	1.19
Committed:	Fri May 8 11:53:04 2009 UTC (16 years ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.18:	+18 -14 lines
Log Message:	Bugfix for non-global muons.
#	User	Rev	Content
1	loizides	1.19	// $Id: MuonIDMod.cc,v 1.18 2009/05/07 20:27:07 loizides Exp $
2	loizides	1.1
3			#include "MitPhysics/Mods/interface/MuonIDMod.h"
4	loizides	1.6	#include "MitCommon/MathTools/interface/MathUtils.h"
5			#include "MitPhysics/Init/interface/ModNames.h"
6	loizides	1.1
7			using namespace mithep;
8
9			ClassImp(mithep::MuonIDMod)
10
11			//--------------------------------------------------------------------------------------------------
12			MuonIDMod::MuonIDMod(const char name, const char title) :
13			BaseMod(name,title),
14	loizides	1.6	fMuonBranchName(Names::gkMuonBrn),
15			fCleanMuonsName(ModNames::gkCleanMuonsName),
16	loizides	1.15	fVertexName("PrimaryVertexesBeamSpot"),
17	loizides	1.8	fMuonIDType("Loose"),
18			fMuonIsoType("TrackCaloSliding"),
19	loizides	1.6	fMuonClassType("Global"),
20	ceballos	1.2	fTrackIsolationCut(3.0),
21			fCaloIsolationCut(3.0),
22	loizides	1.8	fCombIsolationCut(5.0),
23	ceballos	1.3	fMuonPtMin(10),
24	loizides	1.15	fD0Cut(0.025),
25			fMuIDType(kIdUndef),
26			fMuIsoType(kIsoUndef),
27			fMuClassType(kClassUndef),
28	ceballos	1.14	fMuons(0),
29	loizides	1.15	fVertices(0),
30	ceballos	1.16	fMuonTools(0),
31	ceballos	1.17	fReverseIsoCut(kFALSE)
32	loizides	1.1	{
33			// Constructor.
34			}
35
36			//--------------------------------------------------------------------------------------------------
37			void MuonIDMod::Process()
38			{
39			// Process entries of the tree.
40
41	loizides	1.6	LoadBranch(fMuonBranchName);
42	ceballos	1.14	LoadBranch(fVertexName);
43	loizides	1.1
44	loizides	1.7	MuonOArr *CleanMuons = new MuonOArr;
45			CleanMuons->SetName(fCleanMuonsName);
46	loizides	1.1
47			for (UInt_t i=0; i<fMuons->GetEntries(); ++i) {
48	loizides	1.8	const Muon *mu = fMuons->At(i);
49	loizides	1.6
50			Bool_t pass = kFALSE;
51	loizides	1.19	Double_t pt = 0; // make sure pt is taken from the correct track!
52	loizides	1.6	switch (fMuClassType) {
53			case kAll:
54			pass = kTRUE;
55	loizides	1.19	if (mu->HasTrk())
56			pt = mu->Pt();
57	loizides	1.6	break;
58			case kGlobal:
59	loizides	1.19	pass = mu->HasGlobalTrk();
60	loizides	1.6	if (pass)
61			pt = mu->GlobalTrk()->Pt();
62			break;
63			case kSta:
64	loizides	1.19	pass = mu->HasStandaloneTrk();
65	loizides	1.6	if (pass)
66			pt = mu->StandaloneTrk()->Pt();
67			break;
68			case kTrackerOnly:
69	loizides	1.19	pass = mu->HasTrackerTrk();
70	loizides	1.6	if (pass)
71			pt = mu->TrackerTrk()->Pt();
72			break;
73			default:
74			break;
75	ceballos	1.5	}
76	loizides	1.6
77			if (!pass)
78			continue;
79
80			if (pt <= fMuonPtMin)
81			continue;
82
83			Bool_t idpass = kFALSE;
84			switch (fMuIDType) {
85			case kLoose:
86			idpass = fMuonTools->IsGood(mu, MuonTools::kTMOneStationLoose) &&
87			fMuonTools->IsGood(mu, MuonTools::kTM2DCompatibilityLoose);
88			break;
89			case kTight:
90			idpass = fMuonTools->IsGood(mu, MuonTools::kTMOneStationTight) &&
91			fMuonTools->IsGood(mu, MuonTools::kTM2DCompatibilityTight);
92			break;
93	loizides	1.18	case kNoId:
94			idpass = kTRUE;
95			break;
96	loizides	1.6	default:
97			break;
98	ceballos	1.4	}
99	loizides	1.6
100			if (!idpass)
101			continue;
102
103			Bool_t isopass = kFALSE;
104			switch (fMuIsoType) {
105			case kTrackCalo:
106			isopass = (mu->IsoR03SumPt() < fTrackIsolationCut) &&
107			(mu->IsoR03EmEt() + mu->IsoR03HadEt() < fCaloIsolationCut);
108			break;
109			case kTrackCaloCombined:
110			isopass = (1.0 * mu->IsoR03SumPt() + 1.0 * mu->IsoR03EmEt() +
111			1.0 * mu->IsoR03HadEt() < fCombIsolationCut);
112			break;
113			case kTrackCaloSliding:
114			{
115			Double_t totalIso = 1.0 * mu->IsoR03SumPt() +
116			1.0 * mu->IsoR03EmEt() +
117			1.0 * mu->IsoR03HadEt();
118	loizides	1.19	if ((totalIso < (pt-10.0)*5.0/15.0 && pt <= 25) \|\|
119	ceballos	1.9	(totalIso < 5.0 && mu->Pt() > 25) \|\|
120			totalIso <= 0)
121	loizides	1.6	isopass = kTRUE;
122			}
123			break;
124	loizides	1.13	case kNoIso:
125			isopass = kTRUE;
126			break;
127	loizides	1.6	case kCustomIso:
128			default:
129			break;
130	ceballos	1.4	}
131	ceballos	1.3
132	ceballos	1.16	if ((isopass == kFALSE && fReverseIsoCut == kFALSE) \|\|
133			(isopass == kTRUE && fReverseIsoCut == kTRUE))
134	loizides	1.6	continue;
135
136	loizides	1.19	// d0 cut only for global muons
137			if (fMuClassType == kGlobal) {
138			Double_t d0_real = 1e30;
139			for(UInt_t i0 = 0; i0 < fVertices->GetEntries(); i0++) {
140			Double_t pD0 = mu->GlobalTrk()->D0Corrected(*fVertices->At(i0));
141			if(TMath::Abs(pD0) < TMath::Abs(d0_real))
142			d0_real = TMath::Abs(pD0);
143			}
144			if(d0_real >= fD0Cut)
145			continue;
146	ceballos	1.14	}
147
148	loizides	1.6	// add good muon
149			CleanMuons->Add(mu);
150	loizides	1.1	}
151
152	loizides	1.10	// sort according to pt
153			CleanMuons->Sort();
154
155	loizides	1.6	// add objects for other modules to use
156	loizides	1.7	AddObjThisEvt(CleanMuons);
157	loizides	1.1	}
158
159			//--------------------------------------------------------------------------------------------------
160			void MuonIDMod::SlaveBegin()
161			{
162			// Run startup code on the computer (slave) doing the actual analysis. Here,
163	loizides	1.6	// we just request the muon collection branch.
164
165			ReqBranch(fMuonBranchName, fMuons);
166	ceballos	1.14	ReqBranch(fVertexName, fVertices);
167	loizides	1.1
168	loizides	1.6	fMuonTools = new MuonTools;
169	loizides	1.1
170	loizides	1.6	if (fMuonIDType.CompareTo("Tight") == 0)
171			fMuIDType = kTight;
172			else if (fMuonIDType.CompareTo("Loose") == 0)
173			fMuIDType = kLoose;
174	loizides	1.12	else if (fMuonIDType.CompareTo("NoId") == 0)
175			fMuIDType = kNoId;
176	loizides	1.6	else if (fMuonIDType.CompareTo("Custom") == 0) {
177			fMuIDType = kCustomId;
178			SendError(kWarning, "SlaveBegin",
179			"Custom muon identification is not yet implemented.");
180			} else {
181			SendError(kAbortAnalysis, "SlaveBegin",
182			"The specified muon identification %s is not defined.",
183			fMuonIDType.Data());
184			return;
185			}
186	loizides	1.1
187	loizides	1.6	if (fMuonIsoType.CompareTo("TrackCalo") == 0)
188			fMuIsoType = kTrackCalo;
189			else if (fMuonIsoType.CompareTo("TrackCaloCombined") == 0)
190			fMuIsoType = kTrackCaloCombined;
191			else if (fMuonIsoType.CompareTo("TrackCaloSliding") == 0)
192			fMuIsoType = kTrackCaloSliding;
193			else if (fMuonIsoType.CompareTo("NoIso") == 0)
194			fMuIsoType = kNoIso;
195			else if (fMuonIsoType.CompareTo("Custom") == 0) {
196			fMuIsoType = kCustomIso;
197			SendError(kWarning, "SlaveBegin",
198			"Custom muon isolation is not yet implemented.");
199			} else {
200			SendError(kAbortAnalysis, "SlaveBegin",
201			"The specified muon isolation %s is not defined.",
202			fMuonIsoType.Data());
203			return;
204			}
205	loizides	1.1
206	loizides	1.6	if (fMuonClassType.CompareTo("All") == 0)
207			fMuClassType = kAll;
208			else if (fMuonClassType.CompareTo("Global") == 0)
209			fMuClassType = kGlobal;
210			else if (fMuonClassType.CompareTo("Standalone") == 0)
211			fMuClassType = kSta;
212			else if (fMuonClassType.CompareTo("TrackerOnly") == 0)
213			fMuClassType = kTrackerOnly;
214			else {
215			SendError(kAbortAnalysis, "SlaveBegin",
216			"The specified muon class %s is not defined.",
217			fMuonClassType.Data());
218			return;
219			}
220	loizides	1.1	}