ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitPhysics/Utils/src/MuonTools.cc

Comparing UserCode/MitPhysics/Utils/src/MuonTools.cc (file contents):
Revision 1.1 by pharris, Mon Nov 3 13:19:19 2008 UTC vs.
Revision 1.9 by loizides, Tue Apr 7 15:37:10 2009 UTC

#	Line 1 | Line 1
1	<	#include "MitWlnu/MuonTools/interface/MuonTools.hh"
1	>	// $Id$
2	>
3	>	#include "MitPhysics/Utils/interface/MuonTools.h"
4	>	#include <TFile.h>
5	>
6		using namespace mithep;
7
8	<	MuonTools::MuonTools() :
9	<	fpion_em_etaEmi(0),
10	<	fpion_had_etaEmi(0),
7	<	fpion_had_etaTmi(0),
8	<	fpion_em_etaB(0),
9	<	fpion_had_etaB(0),
10	<	fpion_ho_etaB(0),
11	<	fpion_had_etaTpl(0),
12	<	fpion_em_etaEpl(0),
13	<	fpion_had_etaEpl(0),
8	>	//--------------------------------------------------------------------------------------------------
9	>	MuonTools::MuonTools(const char *mutemp, const char *pitemp) :
10	>	fIsInit(kFALSE),
11		fmuon_em_etaEmi(0),
12		fmuon_had_etaEmi(0),
13		fmuon_had_etaTmi(0),
#	Line 19 | Line 16 | MuonTools::MuonTools() :
16		fmuon_ho_etaB(0),
17		fmuon_had_etaTpl(0),
18		fmuon_em_etaEpl(0),
19	<	fmuon_had_etaEpl(0) {}
20	<	MuonTools::~MuonTools() {
21	<	fPion_templates->Close();
22	<	fMuon_templates->Close();
23	<	delete fpion_em_etaEmi;
24	<	delete fpion_had_etaEmi;
25	<	delete fpion_had_etaTmi;
26	<	delete fpion_em_etaB;
27	<	delete fpion_had_etaB;
28	<	delete fpion_ho_etaB;
29	<	delete fpion_had_etaTpl;
30	<	delete fpion_em_etaEpl;
31	<	delete fpion_had_etaEpl;
32	<	delete fmuon_em_etaEmi;
33	<	delete fmuon_had_etaEmi;
34	<	delete fmuon_had_etaTmi;
35	<	delete fmuon_em_etaB;
36	<	delete fmuon_had_etaB;
37	<	delete fmuon_ho_etaB;
38	<	delete fmuon_had_etaTpl;
39	<	delete fmuon_em_etaEpl;
40	<	delete fmuon_had_etaEpl;
41	<	}
42	<
43	<	double MuonTools::getCaloCompatability(mithep::Muon* iMuon,bool iEMSpecial, bool iCorrectedHCAL) {
44	<	if(fpion_em_etaEmi == 0) {
45	<	TFile* fPion_templates = new TFile("../../data/PionCaloTemplate.root","READ");
46	<	TFile* fMuon_templates = new TFile("../../data/MuonCaloTemplate.root","READ");
47	<	fpion_em_etaEmi  = (TH2D*) fPion_templates->Get("em_etaEmi");
48	<	fpion_had_etaEmi = (TH2D*) fPion_templates->Get("had_etaEmi");
49	<	fpion_had_etaTmi = (TH2D*) fPion_templates->Get("had_etaTmi");
50	<	fpion_em_etaB    = (TH2D*) fPion_templates->Get("em_etaB")   ;
51	<	fpion_had_etaB   = (TH2D*) fPion_templates->Get("had_etaB")  ;
52	<	fpion_ho_etaB    = (TH2D*) fPion_templates->Get("ho_etaB")   ;
53	<	fpion_had_etaTpl = (TH2D*) fPion_templates->Get("had_etaTpl");
54	<	fpion_em_etaEpl  = (TH2D*) fPion_templates->Get("em_etaEpl") ;
55	<	fpion_had_etaEpl = (TH2D*) fPion_templates->Get("had_etaEpl");
56	<	fmuon_em_etaEmi  = (TH2D*) fMuon_templates->Get("em_etaEmi") ;
57	<	fmuon_had_etaEmi = (TH2D*) fMuon_templates->Get("had_etaEmi");
58	<	fmuon_had_etaTmi = (TH2D*) fMuon_templates->Get("had_etaTmi");
59	<	fmuon_em_etaB    = (TH2D*) fMuon_templates->Get("em_etaB")   ;
60	<	fmuon_had_etaB   = (TH2D*) fMuon_templates->Get("had_etaB")  ;
61	<	fmuon_ho_etaB    = (TH2D*) fMuon_templates->Get("ho_etaB")   ;
62	<	fmuon_had_etaTpl = (TH2D*) fMuon_templates->Get("had_etaTpl");
63	<	fmuon_em_etaEpl  = (TH2D*) fMuon_templates->Get("em_etaEpl");
64	<	fmuon_had_etaEpl = (TH2D*) fMuon_templates->Get("had_etaEpl");
65	<	}
66	<	double lEta = -1.; double lP = -1;
67	<	double lEM  = -5.;      double lHad = 0;      double lHO = 0;
68	<	lEta = iMuon->Eta();
69	<	lP   = iMuon->P();
70	<	if(lP >= 2000.) lP = 1999.9;
71	<	if(!iEMSpecial || iMuon->EmEnergy() != 0.) lEM  = iMuon->EmEnergy();
72	<	lHad = iMuon->HadEnergy();
73	<	lHO  = iMuon->HoEnergy();
74	<	if(lP < 0. )           return 0.5;
75	<	if(fabs(lEta) >  2.5 ) return 0.5;
76	<	TH2D* lTMuonHad = NULL;
77	<	TH2D* lTPionHad = NULL;
78	<	TH2D* lTMuonHo  = NULL;
79	<	TH2D* lTPionHo  = NULL;
80	<	TH2D* lTMuonEm  = NULL;
81	<	TH2D* lTPionEm  = NULL;
82	<
83	<	if(fabs(lEta) >=  1.27) {
84	<	if(iCorrectedHCAL) lHad *= 1.8/2.2;
85	<	if(lEta > 0) {
19	>	fmuon_had_etaEpl(0),
20	>	fpion_em_etaEmi(0),
21	>	fpion_had_etaEmi(0),
22	>	fpion_had_etaTmi(0),
23	>	fpion_em_etaB(0),
24	>	fpion_had_etaB(0),
25	>	fpion_ho_etaB(0),
26	>	fpion_had_etaTpl(0),
27	>	fpion_em_etaEpl(0),
28	>	fpion_had_etaEpl(0)
29	>	{
30	>	// Constructor.
31	>
32	>	if (mutemp && pitemp)
33	>	Init(mutemp, pitemp);
34	>	}
35	>
36	>	//--------------------------------------------------------------------------------------------------
37	>	MuonTools::~MuonTools()
38	>	{
39	>	// Destructor.
40	>
41	>	DeleteHistos();
42	>	}
43	>
44	>	//--------------------------------------------------------------------------------------------------
45	>	void MuonTools::DeleteHistos()
46	>	{
47	>	// Delete histograms.
48	>
49	>	if (fIsInit) {
50	>	delete fpion_em_etaEmi;
51	>	delete fpion_had_etaEmi;
52	>	delete fpion_had_etaTmi;
53	>	delete fpion_em_etaB;
54	>	delete fpion_had_etaB;
55	>	delete fpion_ho_etaB;
56	>	delete fpion_had_etaTpl;
57	>	delete fpion_em_etaEpl;
58	>	delete fpion_had_etaEpl;
59	>	delete fmuon_em_etaEmi;
60	>	delete fmuon_had_etaEmi;
61	>	delete fmuon_had_etaTmi;
62	>	delete fmuon_em_etaB;
63	>	delete fmuon_had_etaB;
64	>	delete fmuon_ho_etaB;
65	>	delete fmuon_had_etaTpl;
66	>	delete fmuon_em_etaEpl;
67	>	delete fmuon_had_etaEpl;
68	>	fpion_em_etaEmi  = 0;
69	>	fpion_had_etaEmi = 0;
70	>	fpion_had_etaTmi = 0;
71	>	fpion_em_etaB    = 0;
72	>	fpion_had_etaB   = 0;
73	>	fpion_ho_etaB    = 0;
74	>	fpion_had_etaTpl = 0;
75	>	fpion_em_etaEpl  = 0;
76	>	fpion_had_etaEpl = 0;
77	>	fmuon_em_etaEmi  = 0;
78	>	fmuon_had_etaEmi = 0;
79	>	fmuon_had_etaTmi = 0;
80	>	fmuon_em_etaB    = 0;
81	>	fmuon_had_etaB   = 0;
82	>	fmuon_ho_etaB    = 0;
83	>	fmuon_had_etaTpl = 0;
84	>	fmuon_em_etaEpl  = 0;
85	>	fmuon_had_etaEpl = 0;
86	>	fIsInit = kFALSE;
87	>	}
88	>	}
89	>
90	>	//--------------------------------------------------------------------------------------------------
91	>	Double_t MuonTools::GetCaloCompatability(const Muon *iMuon,
92	>	Bool_t iEMSpecial, Bool_t iCorrectedHCAL) const
93	>	{
94	>	// Get calo compatibility value for given muon based on calorimeter templates.
95	>	// If iEMSpecial is true, then a use different arrangement of ECAL for compatibility.
96	>
97	>	Double_t lEta = iMuon->Eta();
98	>	Double_t aEta = TMath::Abs(lEta);
99	>	if (aEta > 2.5)
100	>	return 0.5;
101	>
102	>	Double_t lP = iMuon->P();
103	>	if (lP >= 2000.)
104	>	lP = 1999.9;
105	>	if(lP < 0. )
106	>	return 0.5;
107	>
108	>	Double_t lEM  = -5.;
109	>	if (!iEMSpecial || iMuon->EmEnergy() != 0.)
110	>	lEM  = iMuon->EmEnergy();
111	>
112	>	Double_t lHad = iMuon->HadEnergy();
113	>	Double_t lHO = iMuon->HoEnergy();;
114	>
115	>	TH2D *lTMuonHad = 0;
116	>	TH2D *lTPionHad = 0;
117	>	TH2D *lTMuonHo  = 0;
118	>	TH2D *lTPionHo  = 0;
119	>	TH2D *lTMuonEm  = 0;
120	>	TH2D *lTPionEm  = 0;
121	>
122	>	if (aEta >= 1.27) {
123	>	if (iCorrectedHCAL)
124	>	lHad *= 1.8/2.2;
125	>	if (lEta > 0) {
126		lTPionHad = fpion_had_etaEpl;
127		lTMuonHad = fmuon_had_etaEpl;
128		} else {
#	Line 93 | Line 130 | double MuonTools::getCaloCompatability(m
130		lTMuonHad = fmuon_had_etaEmi;
131		}
132		}
133	<	if(fabs(lEta) <  1.27  && fabs(lEta) >=  1.1 ) {
134	<	if(iCorrectedHCAL)    lHad *= (1.8/(-2.2*fabs(lEta)+5.5));
135	<	if(lEta > 0) {
133	>
134	>	if (aEta < 1.27 && aEta >= 1.1) {
135	>	if (iCorrectedHCAL)
136	>	lHad *= (1.8/(-2.2*aEta+5.5));
137	>	if (lEta > 0) {
138		lTPionHad  = fpion_had_etaTpl;
139		lTMuonHad  = fmuon_had_etaTpl;
140		} else {
#	Line 103 | Line 142 | double MuonTools::getCaloCompatability(m
142		lTMuonHad  = fmuon_had_etaTmi;
143		}
144		}
145	<	if(fabs(lEta) <  1.1) {
146	<	if(iCorrectedHCAL)    lHad *= sin(2*atan(exp(iMuon->Eta())));
145	>
146	>	if (aEta < 1.1) {
147	>	if(iCorrectedHCAL)
148	>	lHad *= TMath::Sin(2*TMath::ATan(TMath::Exp(lEta)));
149		lTPionHad  = fpion_had_etaB;
150		lTMuonHad  = fmuon_had_etaB;
151		}
152	<	if(lEta >  1.479  ) {
153	<	lTPionEm  = fpion_em_etaEpl;
154	<	lTMuonEm  = fmuon_em_etaEpl;
152	>	if (lEta > 1.479) {
153	>	lTPionEm = fpion_em_etaEpl;
154	>	lTMuonEm = fmuon_em_etaEpl;
155		}
156	<	if(fabs(lEta) <=  1.479) {
156	>	if (aEta <= 1.479) {
157		lTPionEm  = fpion_em_etaB;
158		lTMuonEm  = fmuon_em_etaB;
159		}
160	<	if(lEta < -1.479 ) {
160	>	if (lEta < -1.479) {
161		lTPionEm  = fpion_em_etaEmi;
162		lTMuonEm  = fmuon_em_etaEmi;
163		}
164	<	if(fabs(lEta) < 1.28) {
164	>	if (aEta < 1.28) {
165		lTPionHo  = fpion_ho_etaB;
166		lTMuonHo  = fmuon_ho_etaB;
167		}
168
169	<	double lPBX = 1.;     double lPSX = 1.;
170	<	double lPBY = 1.;     double lPSY = 1.;
171	<	double lPBZ = 1.;     double lPSZ = 1.;
172	<	if(!overflow(lTPionEm, lP,lEM))  lPBX =  lTPionEm ->GetBinContent(lTPionEm ->GetXaxis()->FindBin(lP),lTPionEm ->GetYaxis()->FindBin(lEM) );
173	<	if(!overflow(lTPionHad,lP,lHad)) lPBY =  lTPionHad->GetBinContent(lTPionHad->GetXaxis()->FindBin(lP),lTPionHad->GetYaxis()->FindBin(lHad));
174	<	if(!overflow(lTPionHo, lP,lHO))  lPBZ =  lTPionHo ->GetBinContent(lTPionHo ->GetXaxis()->FindBin(lP),lTPionHo ->GetYaxis()->FindBin(lHO) );
175	<	if(!overflow(lTMuonEm, lP,lEM )) lPSX =  lTMuonEm ->GetBinContent(lTMuonEm ->GetXaxis()->FindBin(lP),lTMuonEm ->GetYaxis()->FindBin(lEM) );
176	<	if(!overflow(lTMuonHad,lP,lHad)) lPSY =  lTMuonHad->GetBinContent(lTMuonHad->GetXaxis()->FindBin(lP),lTMuonHad->GetYaxis()->FindBin(lHad));
177	<	if(!overflow(lTMuonHo ,lP,lHO))  lPSZ =  lTMuonHo ->GetBinContent(lTMuonHo ->GetXaxis()->FindBin(lP),lTMuonHo ->GetYaxis()->FindBin(lHO) );
169	>	Double_t lPBX = 1.;
170	>	Double_t lPSX = 1.;
171	>	Double_t lPBY = 1.;
172	>	Double_t lPSY = 1.;
173	>	Double_t lPBZ = 1.;
174	>	Double_t lPSZ = 1.;
175	>	if (!Overflow(lTPionEm, lP,lEM))
176	>	lPBX = lTPionEm ->GetBinContent(lTPionEm ->GetXaxis()->FindBin(lP),
177	>	lTPionEm ->GetYaxis()->FindBin(lEM));
178	>	if (!Overflow(lTPionHad,lP,lHad))
179	>	lPBY = lTPionHad->GetBinContent(lTPionHad->GetXaxis()->FindBin(lP),
180	>	lTPionHad->GetYaxis()->FindBin(lHad));
181	>	if (!Overflow(lTPionHo, lP,lHO))
182	>	lPBZ = lTPionHo ->GetBinContent(lTPionHo ->GetXaxis()->FindBin(lP),
183	>	lTPionHo ->GetYaxis()->FindBin(lHO));
184	>	if (!Overflow(lTMuonEm, lP,lEM ))
185	>	lPSX = lTMuonEm ->GetBinContent(lTMuonEm ->GetXaxis()->FindBin(lP),
186	>	lTMuonEm ->GetYaxis()->FindBin(lEM));
187	>	if (!Overflow(lTMuonHad,lP,lHad))
188	>	lPSY = lTMuonHad->GetBinContent(lTMuonHad->GetXaxis()->FindBin(lP),
189	>	lTMuonHad->GetYaxis()->FindBin(lHad));
190	>	if (!Overflow(lTMuonHo ,lP,lHO))
191	>	lPSZ =  lTMuonHo ->GetBinContent(lTMuonHo ->GetXaxis()->FindBin(lP),
192	>	lTMuonHo ->GetYaxis()->FindBin(lHO));
193
194	<	if(lPSX == 0. || lPBX == 0. || (lEM <= 0. && !iEMSpecial)) {lPSX = 1.; lPBX = 1.;}
195	<	if(lPSY == 0. || lPBY == 0. || lHad == 0.) {lPSY = 1.; lPBY = 1.;}
196	<	if(lPSZ == 0. || lPBZ == 0. || lHO  == 0.) {lPSZ = 1.; lPBZ = 1.;}
197	<	if((lPSX*lPSY*lPSZ+lPBX*lPBY*lPBZ) > 0.) return lPSX*lPSY*lPSZ/(lPSX*lPSY*lPSZ+lPBX*lPBY*lPBZ);
194	>	if (lPSX == 0. || lPBX == 0. || (lEM <= 0. && !iEMSpecial)) {
195	>	lPSX = 1.;
196	>	lPBX = 1.;
197	>	}
198	>	if (lPSY == 0. || lPBY == 0. || lHad == 0.) {
199	>	lPSY = 1.;
200	>	lPBY = 1.;
201	>	}
202	>	if (lPSZ == 0. || lPBZ == 0. || lHO  == 0.) {
203	>	lPSZ = 1.;
204	>	lPBZ = 1.;
205	>	}
206	>	if ((lPSX*lPSY*lPSZ+lPBX*lPBY*lPBZ) > 0.)
207	>	return lPSX*lPSY*lPSZ/(lPSX*lPSY*lPSZ+lPBX*lPBY*lPBZ);
208	>
209		return 0.5;
210		}
211
212	<	bool MuonTools::isGood(mithep::Muon *iMuon,selection iSelection) {
213	<	double lVal = 0;
214	<	switch(iSelection) {
215	<	case AllArbitrated:
216	<	if(iMuon->StandaloneTrk() != 0 || iMuon->GlobalTrk()!= 0)  return true;
217	<	if(iMuon->NSegments() > 0) return true;
218	<	return false;
219	<	break;
220	<	case PromptTight:
221	<	return promptTight(-1,iMuon);
222	<	break;
223	<	case TMOneStationLoose:
224	<	return TMOneStation(iMuon,99999,999999);
225	<	break;
226	<	case TMOneStationTight:
227	<	return TMOneStation(iMuon);
228	<	break;
229	<	case TMLastStationLoose:
230	<	return TMLastStation(iMuon,999999,999999);
231	<	break;
232	<	case TMLastStationTight:
233	<	return TMLastStation(iMuon);
234	<	break;
235	<	case TM2DCompatibilityLoose:
236	<	lVal             = 1.2*getSegmentCompatability(iMuon);
237	<	if(lVal/1.2 == 0.5) return false;
238	<	lVal += 0.8*getCaloCompatability(iMuon,true,true);
239	<	if(lVal > 0.7) return true;
240	<	return false;
241	<	break;
242	<	case TM2DCompatibilityTight:
243	<	lVal             = 1.2*getSegmentCompatability(iMuon);
244	<	if(lVal/1.2 == 0.5) return false;
245	<	lVal += 0.8*getCaloCompatability(iMuon,true,true);
246	<	if(lVal > 1.0) return true;
247	<	return false;
248	<	break;
249	<	default:
250	<	return false;
212	>	//--------------------------------------------------------------------------------------------------
213	>	Bool_t MuonTools::Init(const char *mutemp, const char *pitemp)
214	>	{
215	>	// Read histograms from given files.
216	>
217	>	if (fIsInit) {
218	>	DeleteHistos();
219	>	}
220	>
221	>	TDirectory::TContext context(0);
222	>
223	>	TFile *muon_templates = TFile::Open(mutemp);
224	>	if (!muon_templates) {
225	>	Fatal("Init", "Could not open file %s", mutemp);
226	>	return kFALSE;
227	>	}
228	>	fmuon_em_etaEmi  = LoadHisto("em_etaEmi",  muon_templates);
229	>	fmuon_had_etaEmi = LoadHisto("had_etaEmi", muon_templates);
230	>	fmuon_had_etaTmi = LoadHisto("had_etaTmi", muon_templates);
231	>	fmuon_em_etaB    = LoadHisto("em_etaB",    muon_templates);
232	>	fmuon_had_etaB   = LoadHisto("had_etaB",   muon_templates);
233	>	fmuon_ho_etaB    = LoadHisto("ho_etaB",    muon_templates);
234	>	fmuon_had_etaTpl = LoadHisto("had_etaTpl", muon_templates);
235	>	fmuon_em_etaEpl  = LoadHisto("em_etaEpl",  muon_templates);
236	>	fmuon_had_etaEpl = LoadHisto("had_etaEpl", muon_templates);
237	>	muon_templates->Close();
238	>	delete muon_templates;
239	>
240	>	TFile *pion_templates = TFile::Open(pitemp);
241	>	if (!pion_templates) {
242	>	Fatal("Init", "Could not open file %s", pitemp);
243	>	return kFALSE;
244	>	}
245	>
246	>	fpion_em_etaEmi  = LoadHisto("em_etaEmi",  pion_templates);
247	>	fpion_had_etaEmi = LoadHisto("had_etaEmi", pion_templates);
248	>	fpion_had_etaTmi = LoadHisto("had_etaTmi", pion_templates);
249	>	fpion_em_etaB    = LoadHisto("em_etaB",    pion_templates);
250	>	fpion_had_etaB   = LoadHisto("had_etaB",   pion_templates);
251	>	fpion_ho_etaB    = LoadHisto("ho_etaB",    pion_templates);
252	>	fpion_had_etaTpl = LoadHisto("had_etaTpl", pion_templates);
253	>	fpion_em_etaEpl  = LoadHisto("em_etaEpl",  pion_templates);
254	>	fpion_had_etaEpl = LoadHisto("had_etaEpl", pion_templates);
255	>	pion_templates->Close();
256	>	delete pion_templates;
257	>
258	>	fIsInit = kTRUE;
259	>	return kTRUE;
260	>	}
261	>
262	>	//--------------------------------------------------------------------------------------------------
263	>	Bool_t MuonTools::IsGood(const mithep::Muon *iMuon, ESelType iSel) const
264	>	{
265	>	// Return true if given muon qualifies given selection criterium.
266	>
267	>	Double_t tm2dcut = 0.;
268	>
269	>	switch(iSel) {
270	>	case kAllArbitrated:
271	>	if (iMuon->StandaloneTrk() != 0 || iMuon->GlobalTrk()!= 0)
272	>	return kTRUE;
273	>	if (iMuon->NSegments() > 0)
274	>	return kTRUE;
275	>	break;
276	>	case kPromptTight:
277	>	return iMuon->PromptTight(Muon::kAny);
278	>	break;
279	>	case kTMOneStationLoose:
280	>	return iMuon->TMOneStation(999999,999999);
281	>	break;
282	>	case kTMOneStationTight:
283	>	return iMuon->TMOneStation();
284	>	break;
285	>	case kTMLastStationLoose:
286	>	return iMuon->TMLastStation(999999,999999);
287	>	break;
288	>	case kTMLastStationTight:
289	>	return iMuon->TMLastStation();
290	>	break;
291	>	case kTM2DCompatibilityLoose:
292	>	tm2dcut = 0.7;
293	>	break;
294	>	case kTM2DCompatibilityTight:
295	>	tm2dcut = 1.0;
296	>	break;
297	>	default:
298	>	return kFALSE;
299	>	break;
300	>	}
301	>
302	>	Double_t lVal = GetSegmentCompatability(iMuon);
303	>	if (lVal == 0.5) // exclude this border case
304	>	return kFALSE;
305	>
306	>	lVal *= 1.2;
307	>	lVal += 0.8*GetCaloCompatability(iMuon,kTRUE,kTRUE);
308	>	if (lVal > tm2dcut)
309	>	return kTRUE;
310	>
311	>	return kFALSE;
312	>	}
313	>
314	>	//--------------------------------------------------------------------------------------------------
315	>	Double_t MuonTools::GetSegmentCompatability(const mithep::Muon *iMuon) const
316	>	{
317	>	// Get segment compatability for given muon based on likelihood of well defined
318	>	// track through chambers.
319	>
320	>	Int_t lNStationsCrossed = 0;
321	>	Int_t lNStationsSegment = 0;
322	>
323	>	Int_t lStSegmentmatch[8];
324	>	Int_t lStCrossed[8];
325	>	Double_t lStBoundary[8];
326	>
327	>	Double_t lWeight  = 0.;
328	>	Bool_t lAdjust    = kTRUE;
329	>	for (Int_t i0 = 0; i0 < 8; ++i0) {
330	>	lStBoundary[i0] = 0.;
331	>	if(iMuon->GetTrackDist(i0) < 999999. ) {
332	>	lNStationsCrossed++;
333	>	lStCrossed[i0]  = 1;
334	>	if (iMuon->GetTrackDist(i0) > -10. )
335	>	lStBoundary[i0] = iMuon->GetTrackDist(i0);
336	>	} else
337	>	lStCrossed[i0]  = 0;
338	>
339	>	if(iMuon->GetDX(i0) < 999999.) {
340	>	lNStationsSegment++;
341	>	lStSegmentmatch[i0] = 1;
342	>	} else
343	>	lStSegmentmatch[i0] = 0;
344	>
345	>	if(iMuon->GetDY(i0) < 999999.)
346	>	lAdjust = kFALSE;
347	>	}
348	>
349	>	if (lNStationsCrossed == 0)
350	>	return 0.5;
351	>
352	>	Double_t lStWeight[8];
353	>	Int_t lPCross = -1;
354	>	const Double_t lAtWeight = 0.5;
355	>	for (Int_t i0 = 0; i0< 8; ++i0) {
356	>	lStWeight[i0] = 0;
357	>	if (lStCrossed[i0] > 0) {
358	>	lPCross++;
359	>
360	>	switch (lNStationsCrossed) {
361	>	case 1 :
362	>	lStWeight[i0] =  1.;
363	>	break;
364	>	case 2 :
365	>	if (lPCross == 0 )
366	>	lStWeight[i0] = 0.33;
367	>	else
368	>	lStWeight[i0] = 0.67;
369	>	break;
370	>	case 3 :
371	>	if (lPCross == 0)
372	>	lStWeight[i0] = 0.23;
373	>	else if (lPCross == 1)
374	>	lStWeight[i0] = 0.33;
375	>	else
376	>	lStWeight[i0] = 0.44;
377	>	break;
378	>	case 4 :
379	>	if (lPCross == 0)
380	>	lStWeight[i0] = 0.10;
381	>	else if (lPCross == 1)
382	>	lStWeight[i0] = 0.20;
383	>	else if (lPCross == 2)
384	>	lStWeight[i0] = 0.30;
385	>	else
386	>	lStWeight[i0] = 0.40;
387	>	break;
388	>	default :
389	>	lStWeight[i0] = 1./lNStationsCrossed;
390	>	}
391	>
392	>	if (lStSegmentmatch[i0] <= 0 && lStBoundary[i0] != 0.)
393	>	lStWeight[i0] *= lAtWeight*0.5*(TMath::Erf(lStBoundary[i0]/6.)+1.);
394	>	else if (lStSegmentmatch[i0] <= 0 && lStBoundary[i0] == 0)
395	>	lStWeight[i0] = 0.;
396	>
397	>	if (lStSegmentmatch[i0] > 0) {
398	>	Double_t lP2X = TMath::Power(iMuon->GetPullX(i0),2.);
399	>	Double_t lP2Y = TMath::Power(iMuon->GetPullY(i0),2.);
400	>	Double_t lD2X = TMath::Power(iMuon->GetDX(i0),2.);
401	>	Double_t lD2Y = TMath::Power(iMuon->GetDY(i0),2.);
402	>	if (iMuon->GetDY(i0) < 999999 && iMuon->GetDX(i0) < 999999)
403	>	lStWeight[i0] *= SigWeight(TMath::Sqrt(lD2X+lD2Y),TMath::Sqrt(lP2X+lP2Y));
404	>	else if (iMuon->GetDY(i0) >= 999999 && i0 < 4)
405	>	lStWeight[i0] *= SigWeight(iMuon->GetDX(i0),iMuon->GetPullX(i0));
406	>	else if(i0 < 4)
407	>	lStWeight[i0] *= SigWeight(iMuon->GetDY(i0),iMuon->GetPullY(i0));
408	>	}
409	>	}
410	>	lWeight += lStWeight[i0];
411	>	}
412	>
413	>	return lWeight;
414	>	}
415	>
416	>	//--------------------------------------------------------------------------------------------------
417	>	TH2D *MuonTools::LoadHisto(const char *name, TFile *file) const
418	>	{
419	>	// Load histogram with given name from given file and return it.
420	>
421	>	TH2D *ret = dynamic_cast<TH2D*>(file->Get(name));
422	>	if (!ret) {
423	>	Fatal("LoadHisto", "Could not load histogram %s from file %s", name, file->GetName());
424	>	return 0;
425		}
426	<	return false;
426	>	ret->SetDirectory(0);
427	>	return ret;
428		}
429	+

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines