Mods/src/MuonIDMod.cc

// $Id: MuonIDMod.cc,v 1.21 2009/05/19 11:42:20 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),
  fApplyD0Cut(kTRUE),
  fD0Cut(0.025),
  fReverseIsoCut(kFALSE),
  fReverseD0Cut(kFALSE),
  fMuIDType(kIdUndef),
  fMuIsoType(kIsoUndef),
  fMuClassType(kClassUndef),
  fMuons(0),
  fVertices(0),
  fMuonTools(0)
{
  // Constructor.
}

//--------------------------------------------------------------------------------------------------
void MuonIDMod::Process()
{
  // Process entries of the tree. 

  LoadEventObject(fMuonBranchName, fMuons);
  LoadEventObject(fVertexName,     fVertices);

  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 = 0; // make sure pt is taken from the correct track!
    switch (fMuClassType) {
      case kAll:
        pass = kTRUE;
        if (mu->HasTrk())
          pt = mu->Pt();
        break;
      case kGlobal:
        pass = mu->HasGlobalTrk();
        if (pass) 
          pt = mu->GlobalTrk()->Pt();
        break;
      case kSta:
        pass = mu->HasStandaloneTrk();
        if (pass) 
          pt = mu->StandaloneTrk()->Pt();
        break;
      case kTrackerOnly:
        pass = mu->HasTrackerTrk();
        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 isocut = kFALSE;
    switch (fMuIsoType) {
      case kTrackCalo:
        isocut = (mu->IsoR03SumPt() < fTrackIsolationCut) &&
          (mu->IsoR03EmEt() + mu->IsoR03HadEt() < fCaloIsolationCut);
        break;
      case kTrackCaloCombined:
        isocut = (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 < (pt-10.0)*5.0/15.0 && pt <= 25) ||
              (totalIso < 5.0 && mu->Pt() > 25) ||
               totalIso <= 0) 
            isocut = kTRUE;

          if     (fReverseIsoCut == kTRUE &&
                  isocut == kFALSE && totalIso < 10)
            isocut = kTRUE;
          else if(fReverseIsoCut == kTRUE)
            isocut = kFALSE;
        }
        break;
      case kNoIso:
        isocut = kTRUE;
        break;
      case kCustomIso:
      default:
        break;
    }

    if (isocut == kFALSE)
      continue;

    if (fApplyD0Cut) {
      Bool_t d0cut = kFALSE;
      const Track *mt = mu->BestTrk();
      if (!mt)
        continue;
      Double_t d0_real = 1e30;
      for(UInt_t i0 = 0; i0 < fVertices->GetEntries(); i0++) {
        Double_t pD0 = mt->D0Corrected(*fVertices->At(i0));
        if(TMath::Abs(pD0) < TMath::Abs(d0_real)) 
          d0_real = TMath::Abs(pD0);
      }
      if(d0_real < fD0Cut) d0cut = kTRUE;

      if     (fReverseD0Cut == kTRUE &&
              d0cut == kFALSE && d0_real < 0.05)
        d0cut = kTRUE;
      else if(fReverseD0Cut == kTRUE)
        d0cut = kFALSE;

      if (d0cut == kFALSE)
        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.

  ReqEventObject(fMuonBranchName, fMuons, kTRUE);

  if (fApplyD0Cut)
    ReqEventObject(fVertexName, fVertices, kTRUE);

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