Mods/src/MuonIDMod.cc

// $Id: MuonIDMod.cc,v 1.15 2009/04/05 18:36:26 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),  
  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(kTRUE)
{
  // 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 == kFALSE && fReverseIsoCut == kFALSE) ||
        (isopass == kTRUE  && fReverseIsoCut == kTRUE))
      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.16
Committed:	Thu Apr 30 06:34:09 2009 UTC (16 years ago) by ceballos
Content type:	text/plain
Branch:	MAIN
Changes since 1.15:	+5 -3 lines
Log Message:	allow reversing isolation cut
#	User	Rev	Content
1	ceballos	1.16	// $Id: MuonIDMod.cc,v 1.15 2009/04/05 18:36:26 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.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			fReverseIsoCut(kTRUE)
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			default:
93			break;
94	ceballos	1.4	}
95	loizides	1.6
96			if (!idpass)
97			continue;
98
99			Bool_t isopass = kFALSE;
100			switch (fMuIsoType) {
101			case kTrackCalo:
102			isopass = (mu->IsoR03SumPt() < fTrackIsolationCut) &&
103			(mu->IsoR03EmEt() + mu->IsoR03HadEt() < fCaloIsolationCut);
104			break;
105			case kTrackCaloCombined:
106			isopass = (1.0 * mu->IsoR03SumPt() + 1.0 * mu->IsoR03EmEt() +
107			1.0 * mu->IsoR03HadEt() < fCombIsolationCut);
108			break;
109			case kTrackCaloSliding:
110			{
111			Double_t totalIso = 1.0 * mu->IsoR03SumPt() +
112			1.0 * mu->IsoR03EmEt() +
113			1.0 * mu->IsoR03HadEt();
114	ceballos	1.9	if ((totalIso < (mu->Pt()-10.0)*5.0/15.0 && mu->Pt() <= 25) \|\|
115			(totalIso < 5.0 && mu->Pt() > 25) \|\|
116			totalIso <= 0)
117	loizides	1.6	isopass = kTRUE;
118			}
119			break;
120	loizides	1.13	case kNoIso:
121			isopass = kTRUE;
122			break;
123	loizides	1.6	case kCustomIso:
124			default:
125			break;
126	ceballos	1.4	}
127	ceballos	1.3
128	ceballos	1.16	if ((isopass == kFALSE && fReverseIsoCut == kFALSE) \|\|
129			(isopass == kTRUE && fReverseIsoCut == kTRUE))
130	loizides	1.6	continue;
131
132	ceballos	1.14	// d0 cut
133			double d0_real = 99999;
134			for(uint i0 = 0; i0 < fVertices->GetEntries(); i0++) {
135			double pD0 = mu->GlobalTrk()->D0Corrected(*fVertices->At(i0));
136			if(TMath::Abs(pD0) < TMath::Abs(d0_real)) d0_real = TMath::Abs(pD0);
137			}
138			if(d0_real >= fD0Cut) continue;
139
140	loizides	1.6	// add good muon
141			CleanMuons->Add(mu);
142	loizides	1.1	}
143
144	loizides	1.10	// sort according to pt
145			CleanMuons->Sort();
146
147	loizides	1.6	// add objects for other modules to use
148	loizides	1.7	AddObjThisEvt(CleanMuons);
149	loizides	1.1	}
150
151			//--------------------------------------------------------------------------------------------------
152			void MuonIDMod::SlaveBegin()
153			{
154			// Run startup code on the computer (slave) doing the actual analysis. Here,
155	loizides	1.6	// we just request the muon collection branch.
156
157			ReqBranch(fMuonBranchName, fMuons);
158	ceballos	1.14	ReqBranch(fVertexName, fVertices);
159	loizides	1.1
160	loizides	1.6	fMuonTools = new MuonTools;
161	loizides	1.1
162	loizides	1.6	if (fMuonIDType.CompareTo("Tight") == 0)
163			fMuIDType = kTight;
164			else if (fMuonIDType.CompareTo("Loose") == 0)
165			fMuIDType = kLoose;
166	loizides	1.12	else if (fMuonIDType.CompareTo("NoId") == 0)
167			fMuIDType = kNoId;
168	loizides	1.6	else if (fMuonIDType.CompareTo("Custom") == 0) {
169			fMuIDType = kCustomId;
170			SendError(kWarning, "SlaveBegin",
171			"Custom muon identification is not yet implemented.");
172			} else {
173			SendError(kAbortAnalysis, "SlaveBegin",
174			"The specified muon identification %s is not defined.",
175			fMuonIDType.Data());
176			return;
177			}
178	loizides	1.1
179	loizides	1.6	if (fMuonIsoType.CompareTo("TrackCalo") == 0)
180			fMuIsoType = kTrackCalo;
181			else if (fMuonIsoType.CompareTo("TrackCaloCombined") == 0)
182			fMuIsoType = kTrackCaloCombined;
183			else if (fMuonIsoType.CompareTo("TrackCaloSliding") == 0)
184			fMuIsoType = kTrackCaloSliding;
185			else if (fMuonIsoType.CompareTo("NoIso") == 0)
186			fMuIsoType = kNoIso;
187			else if (fMuonIsoType.CompareTo("Custom") == 0) {
188			fMuIsoType = kCustomIso;
189			SendError(kWarning, "SlaveBegin",
190			"Custom muon isolation is not yet implemented.");
191			} else {
192			SendError(kAbortAnalysis, "SlaveBegin",
193			"The specified muon isolation %s is not defined.",
194			fMuonIsoType.Data());
195			return;
196			}
197	loizides	1.1
198	loizides	1.6	if (fMuonClassType.CompareTo("All") == 0)
199			fMuClassType = kAll;
200			else if (fMuonClassType.CompareTo("Global") == 0)
201			fMuClassType = kGlobal;
202			else if (fMuonClassType.CompareTo("Standalone") == 0)
203			fMuClassType = kSta;
204			else if (fMuonClassType.CompareTo("TrackerOnly") == 0)
205			fMuClassType = kTrackerOnly;
206			else {
207			SendError(kAbortAnalysis, "SlaveBegin",
208			"The specified muon class %s is not defined.",
209			fMuonClassType.Data());
210			return;
211			}
212	loizides	1.1	}