Mods/src/MuonIDMod.cc

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