Mods/src/MuonIDMod.cc

// $Id: MuonIDMod.cc,v 1.8 2008/11/28 09:56:42 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),  
  fMuonIDType("Loose"),
  fMuonIsoType("TrackCaloSliding"),  
  fMuonClassType("Global"),  
  fTrackIsolationCut(3.0),
  fCaloIsolationCut(3.0),
  fCombIsolationCut(5.0),
  fMuonPtMin(10),
  fMuons(0)
{
  // Constructor.
}


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

  LoadBranch(fMuonBranchName);

  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 = -1; // make sure pt is taken from the correct track!
    switch (fMuClassType) {
      case kAll:
        pass = kTRUE;
        pt = mu->Pt();
        break;
      case kGlobal:
        pass = (mu->GlobalTrk() != 0);
        if (pass) 
          pt = mu->GlobalTrk()->Pt();
        break;
      case kSta:
        pass = (mu->StandaloneTrk() != 0);
        if (pass) 
          pt = mu->StandaloneTrk()->Pt();
        break;
      case kTrackerOnly:
        pass = (mu->TrackerTrk() != 0);
        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;
      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 < (mu->Pt()-10.0)*5.0/15.0 && mu->Pt() <= 25) ||
              (totalIso < 5.0 && mu->Pt() > 25) ||
               totalIso <= 0) 
            isopass = kTRUE;
        }
        break;
        case kNoIso:
          isopass = kTRUE;
          break;
      case kCustomIso:
      default:
        break;
    }

    if (!isopass)
      continue;

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

  // 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);

  fMuonTools = new MuonTools;

  if (fMuonIDType.CompareTo("Tight") == 0) 
    fMuIDType = kTight;
  else if (fMuonIDType.CompareTo("Loose") == 0) 
    fMuIDType = kLoose;
  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.9
Committed:	Fri Nov 28 10:31:38 2008 UTC (16 years, 5 months ago) by ceballos
Content type:	text/plain
Branch:	MAIN
Changes since 1.8:	+4 -3 lines
Log Message:	fixing isolation
#	User	Rev	Content
1	ceballos	1.9	// $Id: MuonIDMod.cc,v 1.8 2008/11/28 09:56:42 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.8	fMuonIDType("Loose"),
17			fMuonIsoType("TrackCaloSliding"),
18	loizides	1.6	fMuonClassType("Global"),
19	ceballos	1.2	fTrackIsolationCut(3.0),
20			fCaloIsolationCut(3.0),
21	loizides	1.8	fCombIsolationCut(5.0),
22	ceballos	1.3	fMuonPtMin(10),
23	loizides	1.6	fMuons(0)
24	loizides	1.1	{
25			// Constructor.
26			}
27
28
29			//--------------------------------------------------------------------------------------------------
30			void MuonIDMod::Process()
31			{
32			// Process entries of the tree.
33
34	loizides	1.6	LoadBranch(fMuonBranchName);
35	loizides	1.1
36	loizides	1.7	MuonOArr *CleanMuons = new MuonOArr;
37			CleanMuons->SetName(fCleanMuonsName);
38	loizides	1.1
39			for (UInt_t i=0; i<fMuons->GetEntries(); ++i) {
40	loizides	1.8	const Muon *mu = fMuons->At(i);
41	loizides	1.6
42			Bool_t pass = kFALSE;
43			Double_t pt = -1; // make sure pt is taken from the correct track!
44			switch (fMuClassType) {
45			case kAll:
46			pass = kTRUE;
47			pt = mu->Pt();
48			break;
49			case kGlobal:
50			pass = (mu->GlobalTrk() != 0);
51			if (pass)
52			pt = mu->GlobalTrk()->Pt();
53			break;
54			case kSta:
55			pass = (mu->StandaloneTrk() != 0);
56			if (pass)
57			pt = mu->StandaloneTrk()->Pt();
58			break;
59			case kTrackerOnly:
60			pass = (mu->TrackerTrk() != 0);
61			if (pass)
62			pt = mu->TrackerTrk()->Pt();
63			break;
64			default:
65			break;
66	ceballos	1.5	}
67	loizides	1.6
68			if (!pass)
69			continue;
70
71			if (pt <= fMuonPtMin)
72			continue;
73
74			Bool_t idpass = kFALSE;
75			switch (fMuIDType) {
76			case kLoose:
77			idpass = fMuonTools->IsGood(mu, MuonTools::kTMOneStationLoose) &&
78			fMuonTools->IsGood(mu, MuonTools::kTM2DCompatibilityLoose);
79			break;
80			case kTight:
81			idpass = fMuonTools->IsGood(mu, MuonTools::kTMOneStationTight) &&
82			fMuonTools->IsGood(mu, MuonTools::kTM2DCompatibilityTight);
83			break;
84			default:
85			break;
86	ceballos	1.4	}
87	loizides	1.6
88			if (!idpass)
89			continue;
90
91			Bool_t isopass = kFALSE;
92			switch (fMuIsoType) {
93			case kTrackCalo:
94			isopass = (mu->IsoR03SumPt() < fTrackIsolationCut) &&
95			(mu->IsoR03EmEt() + mu->IsoR03HadEt() < fCaloIsolationCut);
96			break;
97			case kTrackCaloCombined:
98			isopass = (1.0 * mu->IsoR03SumPt() + 1.0 * mu->IsoR03EmEt() +
99			1.0 * mu->IsoR03HadEt() < fCombIsolationCut);
100			break;
101			case kTrackCaloSliding:
102			{
103			Double_t totalIso = 1.0 * mu->IsoR03SumPt() +
104			1.0 * mu->IsoR03EmEt() +
105			1.0 * mu->IsoR03HadEt();
106	ceballos	1.9	if ((totalIso < (mu->Pt()-10.0)*5.0/15.0 && mu->Pt() <= 25) \|\|
107			(totalIso < 5.0 && mu->Pt() > 25) \|\|
108			totalIso <= 0)
109	loizides	1.6	isopass = kTRUE;
110			}
111			break;
112			case kNoIso:
113			isopass = kTRUE;
114			break;
115			case kCustomIso:
116			default:
117			break;
118	ceballos	1.4	}
119	ceballos	1.3
120	loizides	1.6	if (!isopass)
121			continue;
122
123			// add good muon
124			CleanMuons->Add(mu);
125	loizides	1.1	}
126
127	loizides	1.6	// add objects for other modules to use
128	loizides	1.7	AddObjThisEvt(CleanMuons);
129	loizides	1.1	}
130
131
132			//--------------------------------------------------------------------------------------------------
133			void MuonIDMod::SlaveBegin()
134			{
135			// Run startup code on the computer (slave) doing the actual analysis. Here,
136	loizides	1.6	// we just request the muon collection branch.
137
138			ReqBranch(fMuonBranchName, fMuons);
139	loizides	1.1
140	loizides	1.6	fMuonTools = new MuonTools;
141	loizides	1.1
142	loizides	1.6	if (fMuonIDType.CompareTo("Tight") == 0)
143			fMuIDType = kTight;
144			else if (fMuonIDType.CompareTo("Loose") == 0)
145			fMuIDType = kLoose;
146			else if (fMuonIDType.CompareTo("Custom") == 0) {
147			fMuIDType = kCustomId;
148			SendError(kWarning, "SlaveBegin",
149			"Custom muon identification is not yet implemented.");
150			} else {
151			SendError(kAbortAnalysis, "SlaveBegin",
152			"The specified muon identification %s is not defined.",
153			fMuonIDType.Data());
154			return;
155			}
156	loizides	1.1
157	loizides	1.6	if (fMuonIsoType.CompareTo("TrackCalo") == 0)
158			fMuIsoType = kTrackCalo;
159			else if (fMuonIsoType.CompareTo("TrackCaloCombined") == 0)
160			fMuIsoType = kTrackCaloCombined;
161			else if (fMuonIsoType.CompareTo("TrackCaloSliding") == 0)
162			fMuIsoType = kTrackCaloSliding;
163			else if (fMuonIsoType.CompareTo("NoIso") == 0)
164			fMuIsoType = kNoIso;
165			else if (fMuonIsoType.CompareTo("Custom") == 0) {
166			fMuIsoType = kCustomIso;
167			SendError(kWarning, "SlaveBegin",
168			"Custom muon isolation is not yet implemented.");
169			} else {
170			SendError(kAbortAnalysis, "SlaveBegin",
171			"The specified muon isolation %s is not defined.",
172			fMuonIsoType.Data());
173			return;
174			}
175	loizides	1.1
176	loizides	1.6	if (fMuonClassType.CompareTo("All") == 0)
177			fMuClassType = kAll;
178			else if (fMuonClassType.CompareTo("Global") == 0)
179			fMuClassType = kGlobal;
180			else if (fMuonClassType.CompareTo("Standalone") == 0)
181			fMuClassType = kSta;
182			else if (fMuonClassType.CompareTo("TrackerOnly") == 0)
183			fMuClassType = kTrackerOnly;
184			else {
185			SendError(kAbortAnalysis, "SlaveBegin",
186			"The specified muon class %s is not defined.",
187			fMuonClassType.Data());
188			return;
189			}
190	loizides	1.1	}