Mods/src/MuonIDMod.cc

        // $Id: MuonIDMod.cc,v 1.34 2010/10/09 18:42:16 ceballos Exp $

#include "MitPhysics/Mods/interface/MuonIDMod.h"
#include "MitCommon/MathTools/interface/MathUtils.h"
#include "MitAna/DataTree/interface/MuonCol.h"
#include "MitAna/DataTree/interface/VertexCol.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(ModNames::gkGoodVertexesName),
  fMuonIDType("Minimal"),
  fMuonIsoType("TrackCaloSliding"),  
  fMuonClassType("Global"),  
  fTrackIsolationCut(3.0),
  fCaloIsolationCut(3.0),
  fCombIsolationCut(5.0),
  fMuonPtMin(10),
  fApplyD0Cut(kTRUE),
  fD0Cut(0.020),
  fEtaCut(2.4),
  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);

  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!
    Double_t eta = 0; // make sure eta is taken from the correct track!
    switch (fMuClassType) {
      case kAll:
        pass = kTRUE;
        if (mu->HasTrk()) {
          pt  = mu->Pt();
          eta = TMath::Abs(mu->Eta());
        }
        break;
      case kGlobal:
        pass = mu->HasGlobalTrk() && mu->IsTrackerMuon();
        if (pass && mu->TrackerTrk()) {
          pt  = mu->TrackerTrk()->Pt();
          eta = TMath::Abs(mu->TrackerTrk()->Eta());
        }
        else {
          pt  = mu->Pt();
          eta = TMath::Abs(mu->Eta());
        }
        break;
      case kSta:
        pass = mu->HasStandaloneTrk();
        if (pass) {
          pt  = mu->StandaloneTrk()->Pt();
          eta = TMath::Abs(mu->StandaloneTrk()->Eta());
        }
        break;
      case kTrackerMuon:
        pass = mu->HasTrackerTrk() && mu->IsTrackerMuon() &&
               mu->Quality().Quality(MuonQuality::TrackerMuonArbitrated);
        if (pass) {
          pt  = mu->TrackerTrk()->Pt();
          eta = TMath::Abs(mu->TrackerTrk()->Eta());
        }
        break;
      case kCaloMuon:
        pass = mu->HasTrackerTrk() && mu->IsCaloMuon();
        if (pass) {
          pt  = mu->TrackerTrk()->Pt();
          eta = TMath::Abs(mu->TrackerTrk()->Eta());
        }
        break;
      case kTrackerBased:
        pass = mu->HasTrackerTrk();
        if (pass) {
          pt  = mu->TrackerTrk()->Pt();
          eta = TMath::Abs(mu->TrackerTrk()->Eta());
        }
        break;
      default:
        break;
    }

    if (!pass)
      continue;

    if (pt <= fMuonPtMin) 
      continue;

    if (eta >= fEtaCut) 
      continue;

    Double_t RChi2 = 0.0;
    if     (mu->HasGlobalTrk()) {
      RChi2 = mu->GlobalTrk()->Chi2()/mu->GlobalTrk()->Ndof();
    }
    else if(mu->BestTrk() != 0){
      RChi2 = mu->BestTrk()->Chi2()/mu->BestTrk()->Ndof();
    }
    Bool_t idpass = kFALSE;
    switch (fMuIDType) {
      case kWMuId:
        idpass = mu->BestTrk() != 0 &&
                 mu->BestTrk()->NHits() > 10 &&
                 RChi2 < 10.0 &&
                 mu->NSegments() > 1 &&
                 mu->BestTrk()->NPixelHits() > 0 &&
                 mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
        break;
      case kZMuId:
        idpass = mu->BestTrk() != 0 &&
                 mu->BestTrk()->NHits() > 10 &&
                 mu->NSegments() > 1 &&
                 mu->BestTrk()->NPixelHits() > 0 &&
                 mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
        break;
      case kLoose:
        idpass = mu->BestTrk() != 0 &&
                 mu->Quality().Quality(MuonQuality::TMOneStationLoose) &&
                 mu->Quality().Quality(MuonQuality::TM2DCompatibilityLoose) &&
                 mu->BestTrk()->NHits() > 10 &&
                 RChi2 < 10.0 &&
                 mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
        break;
      case kTight:
        idpass = mu->BestTrk() !=  0 &&
                 mu->Quality().Quality(MuonQuality::TMOneStationTight) &&
                 mu->Quality().Quality(MuonQuality::TM2DCompatibilityTight) &&
                 mu->BestTrk()->NHits() > 10 &&
                 RChi2 < 10.0 &&
                 mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
        break;
      case kMinimal:
        idpass = mu->BestTrk() != 0 &&
                 mu->BestTrk()->NHits() > 10 &&
                 RChi2 < 10.0 &&
                 mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
        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 < (mu->Pt()*0.15) )
            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) {
      fVertices = GetObjThisEvt<VertexOArr>(fVertexName);
      Bool_t passD0cut = MuonTools::PassD0Cut(mu, fVertices, fD0Cut, fReverseD0Cut);
      if (!passD0cut)
        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);

  fMuonTools = new MuonTools;

  if (fMuonIDType.CompareTo("WMuId") == 0) 
    fMuIDType = kWMuId;
  else if (fMuonIDType.CompareTo("ZMuId") == 0) 
    fMuIDType = kZMuId;
  else if (fMuonIDType.CompareTo("Tight") == 0) 
    fMuIDType = kTight;
  else if (fMuonIDType.CompareTo("Loose") == 0) 
    fMuIDType = kLoose;
  else if (fMuonIDType.CompareTo("Minimal") == 0) 
    fMuIDType = kMinimal;
  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("TrackerMuon") == 0) 
    fMuClassType = kTrackerMuon;
  else if (fMuonClassType.CompareTo("CaloMuon") == 0) 
    fMuClassType = kCaloMuon;
  else if (fMuonClassType.CompareTo("TrackerBased") == 0) 
    fMuClassType = kTrackerBased;
  else {
    SendError(kAbortAnalysis, "SlaveBegin",
              "The specified muon class %s is not defined.",
              fMuonClassType.Data());
    return;
  }
}
Revision:	1.35
Committed:	Wed Oct 20 02:44:16 2010 UTC (14 years, 6 months ago) by ceballos
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_015b, Mit_015a
Changes since 1.34:	+3 -8 lines
Log Message:	fixing vertex issues
#	User	Rev	Content
1	ceballos	1.35	// $Id: MuonIDMod.cc,v 1.34 2010/10/09 18:42:16 ceballos Exp $
2	loizides	1.1
3			#include "MitPhysics/Mods/interface/MuonIDMod.h"
4	loizides	1.6	#include "MitCommon/MathTools/interface/MathUtils.h"
5	loizides	1.23	#include "MitAna/DataTree/interface/MuonCol.h"
6			#include "MitAna/DataTree/interface/VertexCol.h"
7	loizides	1.6	#include "MitPhysics/Init/interface/ModNames.h"
8	loizides	1.1
9			using namespace mithep;
10
11			ClassImp(mithep::MuonIDMod)
12
13			//--------------------------------------------------------------------------------------------------
14			MuonIDMod::MuonIDMod(const char name, const char title) :
15			BaseMod(name,title),
16	loizides	1.6	fMuonBranchName(Names::gkMuonBrn),
17			fCleanMuonsName(ModNames::gkCleanMuonsName),
18	ceballos	1.35	fVertexName(ModNames::gkGoodVertexesName),
19	ceballos	1.30	fMuonIDType("Minimal"),
20	loizides	1.8	fMuonIsoType("TrackCaloSliding"),
21	loizides	1.6	fMuonClassType("Global"),
22	ceballos	1.2	fTrackIsolationCut(3.0),
23			fCaloIsolationCut(3.0),
24	loizides	1.8	fCombIsolationCut(5.0),
25	ceballos	1.3	fMuonPtMin(10),
26	loizides	1.21	fApplyD0Cut(kTRUE),
27	ceballos	1.30	fD0Cut(0.020),
28			fEtaCut(2.4),
29	loizides	1.20	fReverseIsoCut(kFALSE),
30	ceballos	1.22	fReverseD0Cut(kFALSE),
31	loizides	1.15	fMuIDType(kIdUndef),
32			fMuIsoType(kIsoUndef),
33			fMuClassType(kClassUndef),
34	ceballos	1.14	fMuons(0),
35	loizides	1.15	fVertices(0),
36	loizides	1.20	fMuonTools(0)
37	loizides	1.1	{
38			// Constructor.
39			}
40
41			//--------------------------------------------------------------------------------------------------
42			void MuonIDMod::Process()
43			{
44			// Process entries of the tree.
45
46	loizides	1.21	LoadEventObject(fMuonBranchName, fMuons);
47	loizides	1.1
48	loizides	1.7	MuonOArr *CleanMuons = new MuonOArr;
49			CleanMuons->SetName(fCleanMuonsName);
50	loizides	1.1
51			for (UInt_t i=0; i<fMuons->GetEntries(); ++i) {
52	loizides	1.8	const Muon *mu = fMuons->At(i);
53	loizides	1.6
54			Bool_t pass = kFALSE;
55	ceballos	1.30	Double_t pt = 0; // make sure pt is taken from the correct track!
56			Double_t eta = 0; // make sure eta is taken from the correct track!
57	loizides	1.6	switch (fMuClassType) {
58			case kAll:
59			pass = kTRUE;
60	ceballos	1.30	if (mu->HasTrk()) {
61			pt = mu->Pt();
62			eta = TMath::Abs(mu->Eta());
63			}
64	loizides	1.6	break;
65			case kGlobal:
66	ceballos	1.31	pass = mu->HasGlobalTrk() && mu->IsTrackerMuon();
67	ceballos	1.32	if (pass && mu->TrackerTrk()) {
68	ceballos	1.30	pt = mu->TrackerTrk()->Pt();
69			eta = TMath::Abs(mu->TrackerTrk()->Eta());
70			}
71	ceballos	1.32	else {
72			pt = mu->Pt();
73			eta = TMath::Abs(mu->Eta());
74			}
75	ceballos	1.30	break;
76	loizides	1.6	case kSta:
77	loizides	1.19	pass = mu->HasStandaloneTrk();
78	ceballos	1.30	if (pass) {
79			pt = mu->StandaloneTrk()->Pt();
80			eta = TMath::Abs(mu->StandaloneTrk()->Eta());
81			}
82	loizides	1.6	break;
83	loizides	1.24	case kTrackerMuon:
84	ceballos	1.28	pass = mu->HasTrackerTrk() && mu->IsTrackerMuon() &&
85			mu->Quality().Quality(MuonQuality::TrackerMuonArbitrated);
86	ceballos	1.30	if (pass) {
87			pt = mu->TrackerTrk()->Pt();
88			eta = TMath::Abs(mu->TrackerTrk()->Eta());
89			}
90	loizides	1.24	break;
91			case kCaloMuon:
92			pass = mu->HasTrackerTrk() && mu->IsCaloMuon();
93	ceballos	1.30	if (pass) {
94			pt = mu->TrackerTrk()->Pt();
95			eta = TMath::Abs(mu->TrackerTrk()->Eta());
96			}
97	loizides	1.24	break;
98			case kTrackerBased:
99	loizides	1.19	pass = mu->HasTrackerTrk();
100	ceballos	1.30	if (pass) {
101			pt = mu->TrackerTrk()->Pt();
102			eta = TMath::Abs(mu->TrackerTrk()->Eta());
103			}
104	loizides	1.6	break;
105			default:
106			break;
107	ceballos	1.5	}
108	loizides	1.6
109			if (!pass)
110			continue;
111
112			if (pt <= fMuonPtMin)
113			continue;
114
115	ceballos	1.30	if (eta >= fEtaCut)
116			continue;
117
118	ceballos	1.34	Double_t RChi2 = 0.0;
119			if (mu->HasGlobalTrk()) {
120			RChi2 = mu->GlobalTrk()->Chi2()/mu->GlobalTrk()->Ndof();
121			}
122			else if(mu->BestTrk() != 0){
123			RChi2 = mu->BestTrk()->Chi2()/mu->BestTrk()->Ndof();
124			}
125	loizides	1.6	Bool_t idpass = kFALSE;
126			switch (fMuIDType) {
127	ceballos	1.34	case kWMuId:
128			idpass = mu->BestTrk() != 0 &&
129			mu->BestTrk()->NHits() > 10 &&
130			RChi2 < 10.0 &&
131			mu->NSegments() > 1 &&
132			mu->BestTrk()->NPixelHits() > 0 &&
133			mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
134			break;
135			case kZMuId:
136			idpass = mu->BestTrk() != 0 &&
137			mu->BestTrk()->NHits() > 10 &&
138			mu->NSegments() > 1 &&
139			mu->BestTrk()->NPixelHits() > 0 &&
140			mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
141			break;
142	loizides	1.6	case kLoose:
143	ceballos	1.32	idpass = mu->BestTrk() != 0 &&
144			mu->Quality().Quality(MuonQuality::TMOneStationLoose) &&
145	ceballos	1.28	mu->Quality().Quality(MuonQuality::TM2DCompatibilityLoose) &&
146	ceballos	1.29	mu->BestTrk()->NHits() > 10 &&
147	ceballos	1.34	RChi2 < 10.0 &&
148	ceballos	1.30	mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
149	loizides	1.6	break;
150			case kTight:
151	ceballos	1.32	idpass = mu->BestTrk() != 0 &&
152			mu->Quality().Quality(MuonQuality::TMOneStationTight) &&
153	ceballos	1.28	mu->Quality().Quality(MuonQuality::TM2DCompatibilityTight) &&
154	ceballos	1.29	mu->BestTrk()->NHits() > 10 &&
155	ceballos	1.34	RChi2 < 10.0 &&
156	ceballos	1.30	mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
157	ceballos	1.28	break;
158			case kMinimal:
159	ceballos	1.32	idpass = mu->BestTrk() != 0 &&
160			mu->BestTrk()->NHits() > 10 &&
161	ceballos	1.34	RChi2 < 10.0 &&
162	ceballos	1.30	mu->Quality().Quality(MuonQuality::GlobalMuonPromptTight);
163	loizides	1.6	break;
164	loizides	1.18	case kNoId:
165			idpass = kTRUE;
166			break;
167	loizides	1.6	default:
168			break;
169	ceballos	1.4	}
170	loizides	1.6
171			if (!idpass)
172			continue;
173
174	ceballos	1.22	Bool_t isocut = kFALSE;
175	loizides	1.6	switch (fMuIsoType) {
176			case kTrackCalo:
177	ceballos	1.22	isocut = (mu->IsoR03SumPt() < fTrackIsolationCut) &&
178	loizides	1.6	(mu->IsoR03EmEt() + mu->IsoR03HadEt() < fCaloIsolationCut);
179			break;
180			case kTrackCaloCombined:
181	ceballos	1.22	isocut = (1.0 * mu->IsoR03SumPt() + 1.0 * mu->IsoR03EmEt() +
182	ceballos	1.28	1.0 * mu->IsoR03HadEt() < fCombIsolationCut);
183	loizides	1.6	break;
184			case kTrackCaloSliding:
185			{
186			Double_t totalIso = 1.0 * mu->IsoR03SumPt() +
187			1.0 * mu->IsoR03EmEt() +
188			1.0 * mu->IsoR03HadEt();
189	ceballos	1.29	if (totalIso < (mu->Pt()*0.15) )
190	ceballos	1.22	isocut = kTRUE;
191
192			if (fReverseIsoCut == kTRUE &&
193			isocut == kFALSE && totalIso < 10)
194			isocut = kTRUE;
195			else if(fReverseIsoCut == kTRUE)
196			isocut = kFALSE;
197			}
198	loizides	1.6	break;
199	loizides	1.13	case kNoIso:
200	ceballos	1.22	isocut = kTRUE;
201	loizides	1.13	break;
202	loizides	1.6	case kCustomIso:
203			default:
204			break;
205	ceballos	1.4	}
206	ceballos	1.3
207	ceballos	1.22	if (isocut == kFALSE)
208	loizides	1.6	continue;
209
210	loizides	1.21	if (fApplyD0Cut) {
211	ceballos	1.35	fVertices = GetObjThisEvt<VertexOArr>(fVertexName);
212	ceballos	1.31	Bool_t passD0cut = MuonTools::PassD0Cut(mu, fVertices, fD0Cut, fReverseD0Cut);
213			if (!passD0cut)
214	loizides	1.21	continue;
215	ceballos	1.14	}
216
217	loizides	1.6	// add good muon
218			CleanMuons->Add(mu);
219	loizides	1.1	}
220
221	loizides	1.10	// sort according to pt
222			CleanMuons->Sort();
223
224	loizides	1.6	// add objects for other modules to use
225	loizides	1.7	AddObjThisEvt(CleanMuons);
226	loizides	1.1	}
227
228			//--------------------------------------------------------------------------------------------------
229			void MuonIDMod::SlaveBegin()
230			{
231			// Run startup code on the computer (slave) doing the actual analysis. Here,
232	loizides	1.6	// we just request the muon collection branch.
233
234	loizides	1.21	ReqEventObject(fMuonBranchName, fMuons, kTRUE);
235
236	loizides	1.6	fMuonTools = new MuonTools;
237	loizides	1.1
238	ceballos	1.34	if (fMuonIDType.CompareTo("WMuId") == 0)
239			fMuIDType = kWMuId;
240			else if (fMuonIDType.CompareTo("ZMuId") == 0)
241			fMuIDType = kZMuId;
242			else if (fMuonIDType.CompareTo("Tight") == 0)
243	loizides	1.6	fMuIDType = kTight;
244			else if (fMuonIDType.CompareTo("Loose") == 0)
245			fMuIDType = kLoose;
246	ceballos	1.28	else if (fMuonIDType.CompareTo("Minimal") == 0)
247			fMuIDType = kMinimal;
248	loizides	1.12	else if (fMuonIDType.CompareTo("NoId") == 0)
249			fMuIDType = kNoId;
250	loizides	1.6	else if (fMuonIDType.CompareTo("Custom") == 0) {
251			fMuIDType = kCustomId;
252			SendError(kWarning, "SlaveBegin",
253			"Custom muon identification is not yet implemented.");
254			} else {
255			SendError(kAbortAnalysis, "SlaveBegin",
256			"The specified muon identification %s is not defined.",
257			fMuonIDType.Data());
258			return;
259			}
260	loizides	1.1
261	loizides	1.6	if (fMuonIsoType.CompareTo("TrackCalo") == 0)
262			fMuIsoType = kTrackCalo;
263			else if (fMuonIsoType.CompareTo("TrackCaloCombined") == 0)
264			fMuIsoType = kTrackCaloCombined;
265			else if (fMuonIsoType.CompareTo("TrackCaloSliding") == 0)
266			fMuIsoType = kTrackCaloSliding;
267			else if (fMuonIsoType.CompareTo("NoIso") == 0)
268			fMuIsoType = kNoIso;
269			else if (fMuonIsoType.CompareTo("Custom") == 0) {
270			fMuIsoType = kCustomIso;
271			SendError(kWarning, "SlaveBegin",
272			"Custom muon isolation is not yet implemented.");
273			} else {
274			SendError(kAbortAnalysis, "SlaveBegin",
275			"The specified muon isolation %s is not defined.",
276			fMuonIsoType.Data());
277			return;
278			}
279	loizides	1.1
280	loizides	1.6	if (fMuonClassType.CompareTo("All") == 0)
281			fMuClassType = kAll;
282			else if (fMuonClassType.CompareTo("Global") == 0)
283			fMuClassType = kGlobal;
284			else if (fMuonClassType.CompareTo("Standalone") == 0)
285			fMuClassType = kSta;
286	loizides	1.24	else if (fMuonClassType.CompareTo("TrackerMuon") == 0)
287			fMuClassType = kTrackerMuon;
288			else if (fMuonClassType.CompareTo("CaloMuon") == 0)
289			fMuClassType = kCaloMuon;
290			else if (fMuonClassType.CompareTo("TrackerBased") == 0)
291			fMuClassType = kTrackerBased;
292	loizides	1.6	else {
293			SendError(kAbortAnalysis, "SlaveBegin",
294			"The specified muon class %s is not defined.",
295			fMuonClassType.Data());
296			return;
297			}
298	loizides	1.1	}