Mods/src/MuonIDMod.cc

// $Id: MuonIDMod.cc,v 1.14 2009/04/02 09:20:53 ceballos 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)
{
  // 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 = -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;

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