ae982df3 |
1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * |
3 | * * |
4 | * Author: The ALICE Off-line Project. * |
5 | * Contributors are mentioned in the code where appropriate. * |
6 | * * |
7 | * Permission to use, copy, modify and distribute this software and its * |
8 | * documentation strictly for non-commercial purposes is hereby granted * |
9 | * without fee, provided that the above copyright notice appears in all * |
10 | * copies and that both the copyright notice and this permission notice * |
11 | * appear in the supporting documentation. The authors make no claims * |
12 | * about the suitability of this software for any purpose. It is * |
13 | * provided "as is" without express or implied warranty. * |
14 | **************************************************************************/ |
15 | |
16 | //----------------------------------------------------------------- |
17 | // Implementation of the ESD track class |
18 | // This is the class to deal with during the phisical analysis of data |
19 | // |
20 | // Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch |
21 | //----------------------------------------------------------------- |
22 | |
23 | #include "TMath.h" |
24 | |
25 | #include "AliESDtrack.h" |
26 | #include "AliKalmanTrack.h" |
27 | |
28 | ClassImp(AliESDtrack) |
29 | |
30 | //_______________________________________________________________________ |
31 | AliESDtrack::AliESDtrack() : |
32 | fFlags(0), |
33 | fITSncls(0), |
34 | fTPCncls(0) |
35 | { |
36 | // |
37 | // The default ESD constructor |
38 | // |
39 | for (Int_t i=0; i<kSPECIES; i++) fR[i]=0.; |
40 | } |
41 | |
42 | //_______________________________________________________________________ |
43 | Float_t AliESDtrack::GetMass() const { |
44 | Float_t max=0.; |
45 | Int_t k=-1; |
46 | for (Int_t i=0; i<kSPECIES; i++) { |
47 | if (fR[i]>max) {k=i; max=fR[i];} |
48 | } |
49 | if (k==0) return 0.00051; |
50 | if (k==1) return 0.10566; |
51 | if (k==2||k==-1) return 0.13957; |
52 | if (k==3) return 0.49368; |
53 | if (k==4) return 0.93827; |
54 | Warning("GetMass()","Undefined mass !"); |
55 | return 0.13957; |
56 | } |
57 | |
58 | //_______________________________________________________________________ |
59 | Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags) { |
60 | // |
61 | // This function updates track's running parameters |
62 | // |
63 | switch (flags) { |
64 | case kITSin: case kITSout: case kITSrefit: |
65 | fITSncls=t->GetNumberOfClusters(); |
66 | fITSchi2=t->GetChi2(); |
67 | for (Int_t i=0;i<fITSncls;i++) fITSindex[i]=t->GetClusterIndex(i); |
68 | fITSsignal=t->GetPIDsignal(); |
69 | break; |
70 | case kTPCin: case kTPCout: case kTPCrefit: |
71 | fTPCncls=t->GetNumberOfClusters(); |
72 | fTPCchi2=t->GetChi2(); |
73 | for (Int_t i=0;i<fTPCncls;i++) fTPCindex[i]=t->GetClusterIndex(i); |
74 | fTPCsignal=t->GetPIDsignal(); |
75 | {Double_t mass=t->GetMass(); // preliminary mass setting |
76 | if (mass>0.5) fR[4]=1.; // used by |
77 | else if (mass<0.4) fR[2]=1.; // the ITS reconstruction |
78 | else fR[3]=1.;} // |
79 | break; |
79e94bf8 |
80 | case kTRDin: case kTRDout: case kTRDrefit: |
81 | fTRDncls=t->GetNumberOfClusters(); |
82 | fTRDchi2=t->GetChi2(); |
83 | fTRDsignal=t->GetPIDsignal(); |
84 | break; |
ae982df3 |
85 | default: |
86 | Error("UpdateTrackParams()","Wrong flag !\n"); |
87 | return kFALSE; |
88 | } |
89 | |
90 | SetStatus(flags); |
91 | fLabel=t->GetLabel(); |
92 | |
93 | if (t->IsStartedTimeIntegral()) { |
94 | SetStatus(kTIME); |
95 | Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times); |
96 | SetIntegratedLength(t->GetIntegratedLength()); |
97 | } |
98 | |
99 | fRalpha=t->GetAlpha(); |
100 | t->GetExternalParameters(fRx,fRp); |
101 | t->GetExternalCovariance(fRc); |
102 | return kTRUE; |
103 | } |
104 | |
105 | //_______________________________________________________________________ |
106 | void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const { |
107 | //--------------------------------------------------------------------- |
108 | // This function returns external representation of the track parameters |
109 | //--------------------------------------------------------------------- |
110 | x=fRx; |
111 | for (Int_t i=0; i<5; i++) p[i]=fRp[i]; |
112 | } |
113 | |
114 | Double_t AliESDtrack::GetP() const { |
115 | //--------------------------------------------------------------------- |
116 | // This function returns the track momentum |
117 | //--------------------------------------------------------------------- |
118 | Double_t lam=TMath::ATan(fRp[3]); |
119 | Double_t pt=1./TMath::Abs(fRp[4]); |
120 | return pt/TMath::Cos(lam); |
121 | } |
122 | |
123 | void AliESDtrack::GetPxPyPz(Double_t *p) const { |
124 | //--------------------------------------------------------------------- |
125 | // This function returns the global track momentum components |
126 | //--------------------------------------------------------------------- |
127 | Double_t phi=TMath::ASin(fRp[2]) + fRalpha; |
128 | Double_t pt=1./TMath::Abs(fRp[4]); |
129 | p[0]=pt*TMath::Cos(phi); p[1]=pt*TMath::Sin(phi); p[2]=pt*fRp[3]; |
130 | } |
131 | |
132 | void AliESDtrack::GetXYZ(Double_t *xyz) const { |
133 | //--------------------------------------------------------------------- |
134 | // This function returns the global track position |
135 | //--------------------------------------------------------------------- |
136 | Double_t phi=TMath::ASin(fRp[2]) + fRalpha; |
137 | Double_t r=TMath::Sqrt(fRx*fRx + fRp[0]*fRp[0]); |
138 | xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fRp[1]; |
139 | } |
140 | |
141 | //_______________________________________________________________________ |
142 | void AliESDtrack::GetExternalCovariance(Double_t c[15]) const { |
143 | //--------------------------------------------------------------------- |
144 | // This function returns external representation of the cov. matrix |
145 | //--------------------------------------------------------------------- |
146 | for (Int_t i=0; i<15; i++) c[i]=fRc[i]; |
147 | } |
148 | |
149 | //_______________________________________________________________________ |
150 | void AliESDtrack::GetIntegratedTimes(Double_t *times) const { |
151 | for (Int_t i=0; i<kSPECIES; i++) times[i]=fTrackTime[i]; |
152 | } |
153 | |
154 | //_______________________________________________________________________ |
155 | void AliESDtrack::SetIntegratedTimes(const Double_t *times) { |
156 | for (Int_t i=0; i<kSPECIES; i++) fTrackTime[i]=times[i]; |
157 | } |
158 | |
c630aafd |
159 | //_______________________________________________________________________ |
160 | void AliESDtrack::SetITSpid(const Double_t *p) { |
161 | for (Int_t i=0; i<kSPECIES; i++) fITSr[i]=p[i]; |
162 | SetStatus(AliESDtrack::kITSpid); |
163 | } |
164 | |
165 | //_______________________________________________________________________ |
166 | void AliESDtrack::GetITSpid(Double_t *p) const { |
167 | for (Int_t i=0; i<kSPECIES; i++) p[i]=fITSr[i]; |
168 | } |
169 | |
ae982df3 |
170 | //_______________________________________________________________________ |
171 | Int_t AliESDtrack::GetITSclusters(UInt_t *idx) const { |
172 | //--------------------------------------------------------------------- |
173 | // This function returns indices of the assgined ITS clusters |
174 | //--------------------------------------------------------------------- |
175 | for (Int_t i=0; i<fITSncls; i++) idx[i]=fITSindex[i]; |
176 | return fITSncls; |
177 | } |
178 | |
179 | //_______________________________________________________________________ |
180 | Int_t AliESDtrack::GetTPCclusters(UInt_t *idx) const { |
181 | //--------------------------------------------------------------------- |
182 | // This function returns indices of the assgined ITS clusters |
183 | //--------------------------------------------------------------------- |
184 | for (Int_t i=0; i<fTPCncls; i++) idx[i]=fTPCindex[i]; |
185 | return fTPCncls; |
186 | } |
8c6a71ab |
187 | |
188 | //_______________________________________________________________________ |
189 | void AliESDtrack::SetTPCpid(const Double_t *p) { |
190 | for (Int_t i=0; i<kSPECIES; i++) fTPCr[i]=p[i]; |
191 | SetStatus(AliESDtrack::kTPCpid); |
192 | } |
193 | |
194 | //_______________________________________________________________________ |
195 | void AliESDtrack::GetTPCpid(Double_t *p) const { |
196 | for (Int_t i=0; i<kSPECIES; i++) p[i]=fTPCr[i]; |
197 | } |
198 | |
c630aafd |
199 | //_______________________________________________________________________ |
200 | void AliESDtrack::SetTRDpid(const Double_t *p) { |
201 | for (Int_t i=0; i<kSPECIES; i++) fTRDr[i]=p[i]; |
202 | SetStatus(AliESDtrack::kTRDpid); |
203 | } |
204 | |
205 | //_______________________________________________________________________ |
206 | void AliESDtrack::GetTRDpid(Double_t *p) const { |
207 | for (Int_t i=0; i<kSPECIES; i++) p[i]=fTRDr[i]; |
208 | } |
209 | |
79e94bf8 |
210 | //_______________________________________________________________________ |
211 | void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p) |
212 | { |
213 | fTRDr[iSpecies] = p; |
214 | } |
215 | |
216 | Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const |
217 | { |
218 | return fTRDr[iSpecies]; |
219 | } |
220 | |
c630aafd |
221 | //_______________________________________________________________________ |
222 | void AliESDtrack::SetTOFpid(const Double_t *p) { |
223 | for (Int_t i=0; i<kSPECIES; i++) fTOFr[i]=p[i]; |
224 | SetStatus(AliESDtrack::kTOFpid); |
225 | } |
226 | |
227 | //_______________________________________________________________________ |
228 | void AliESDtrack::GetTOFpid(Double_t *p) const { |
229 | for (Int_t i=0; i<kSPECIES; i++) p[i]=fTOFr[i]; |
230 | } |
231 | |
8c6a71ab |
232 | //_______________________________________________________________________ |
233 | void AliESDtrack::SetESDpid(const Double_t *p) { |
234 | for (Int_t i=0; i<kSPECIES; i++) fR[i]=p[i]; |
235 | SetStatus(AliESDtrack::kESDpid); |
236 | } |
237 | |
238 | //_______________________________________________________________________ |
239 | void AliESDtrack::GetESDpid(Double_t *p) const { |
240 | for (Int_t i=0; i<kSPECIES; i++) p[i]=fR[i]; |
241 | } |
242 | |