Mods/src/MuonIDMod.cc

// $Id: MuonIDMod.cc,v 1.6 2008/11/27 16:30:27 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("Tight"),
  fMuonIsoType("TrackCalo"),  
  fMuonClassType("Global"),  
  fTrackIsolationCut(3.0),
  fCaloIsolationCut(3.0),
  fCombIsolationCut(-1.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);
    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) ||
              (totalIso < 5.0 && mu->Pt() > 25)) 
            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.7
Committed:	Fri Nov 28 09:13:50 2008 UTC (16 years, 5 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.6:	+4 -6 lines
Log Message:	Finished refurbishing
#	User	Rev	Content
1	loizides	1.7	// $Id: MuonIDMod.cc,v 1.6 2008/11/27 16:30:27 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			fMuonIDType("Tight"),
17			fMuonIsoType("TrackCalo"),
18			fMuonClassType("Global"),
19	ceballos	1.2	fTrackIsolationCut(3.0),
20			fCaloIsolationCut(3.0),
21	ceballos	1.4	fCombIsolationCut(-1.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.6	//const Muon *mu = fMuons->At(i);
41	loizides	1.1	Muon *mu = fMuons->At(i);
42	loizides	1.6
43			Bool_t pass = kFALSE;
44			Double_t pt = -1; // make sure pt is taken from the correct track!
45			switch (fMuClassType) {
46			case kAll:
47			pass = kTRUE;
48			pt = mu->Pt();
49			break;
50			case kGlobal:
51			pass = (mu->GlobalTrk() != 0);
52			if (pass)
53			pt = mu->GlobalTrk()->Pt();
54			break;
55			case kSta:
56			pass = (mu->StandaloneTrk() != 0);
57			if (pass)
58			pt = mu->StandaloneTrk()->Pt();
59			break;
60			case kTrackerOnly:
61			pass = (mu->TrackerTrk() != 0);
62			if (pass)
63			pt = mu->TrackerTrk()->Pt();
64			break;
65			default:
66			break;
67	ceballos	1.5	}
68	loizides	1.6
69			if (!pass)
70			continue;
71
72			if (pt <= fMuonPtMin)
73			continue;
74
75			Bool_t idpass = kFALSE;
76			switch (fMuIDType) {
77			case kLoose:
78			idpass = fMuonTools->IsGood(mu, MuonTools::kTMOneStationLoose) &&
79			fMuonTools->IsGood(mu, MuonTools::kTM2DCompatibilityLoose);
80			break;
81			case kTight:
82			idpass = fMuonTools->IsGood(mu, MuonTools::kTMOneStationTight) &&
83			fMuonTools->IsGood(mu, MuonTools::kTM2DCompatibilityTight);
84			break;
85			default:
86			break;
87	ceballos	1.4	}
88	loizides	1.6
89			if (!idpass)
90			continue;
91
92			Bool_t isopass = kFALSE;
93			switch (fMuIsoType) {
94			case kTrackCalo:
95			isopass = (mu->IsoR03SumPt() < fTrackIsolationCut) &&
96			(mu->IsoR03EmEt() + mu->IsoR03HadEt() < fCaloIsolationCut);
97			break;
98			case kTrackCaloCombined:
99			isopass = (1.0 * mu->IsoR03SumPt() + 1.0 * mu->IsoR03EmEt() +
100			1.0 * mu->IsoR03HadEt() < fCombIsolationCut);
101			break;
102			case kTrackCaloSliding:
103			{
104			Double_t totalIso = 1.0 * mu->IsoR03SumPt() +
105			1.0 * mu->IsoR03EmEt() +
106			1.0 * mu->IsoR03HadEt();
107			if ((totalIso < (mu->Pt()-10.0)*5.0/15.0) \|\|
108			(totalIso < 5.0 && mu->Pt() > 25))
109			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	}