Mods/src/MuonIDMod.cc

// $Id: MuonIDMod.cc,v 1.5 2008/11/26 10:55:51 ceballos Exp $

#include "MitPhysics/Mods/interface/MuonIDMod.h"
#include "MitCommon/MathTools/interface/MathUtils.h"
#include "MitPhysics/Init/interface/ModNames.h"
#include "MitPhysics/Utils/interface/IsolationTools.h"
#include "MitPhysics/Utils/interface/MuonTools.h"
#include "MitCommon/MathTools/interface/MathUtils.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);

  ObjArray<Muon> *CleanMuons = new ObjArray<Muon>; 

  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, fCleanMuonsName);  
}


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