Mods/src/MuonIDMod.cc

// $Id: MuonIDMod.cc,v 1.17 2009/04/30 08:10:11 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),
  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 = -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;
      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 < (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 == kFALSE && fReverseIsoCut == kFALSE) ||
        (isopass == kTRUE  && fReverseIsoCut == kTRUE))
      continue;

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