]>
Commit | Line | Data |
---|---|---|
73042f01 | 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 | ||
803d1ab0 | 16 | /* $Id$ */ |
0938c7d3 | 17 | |
73042f01 | 18 | //----------------------------------------------------------------- |
19 | // Implementation of the TPC track class | |
7c27857f | 20 | // This class is used by the AliTPCtracker class |
21 | // Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch | |
73042f01 | 22 | //----------------------------------------------------------------- |
23 | ||
19364939 | 24 | #include <Riostream.h> |
b19a0509 | 25 | |
73042f01 | 26 | #include "AliTPCtrack.h" |
7c27857f | 27 | #include "AliCluster.h" |
6c94f330 | 28 | #include "AliTracker.h" |
83d73500 | 29 | #include "AliESDtrack.h" |
73042f01 | 30 | |
31 | ClassImp(AliTPCtrack) | |
b9de75e1 | 32 | |
e3f7105e | 33 | //_________________________________________________________________________ |
e13cc304 | 34 | AliTPCtrack::AliTPCtrack(): |
35 | AliKalmanTrack(), | |
e13cc304 | 36 | fdEdx(0), |
e13cc304 | 37 | fSdEdx(1e10), |
38 | fNFoundable(0), | |
39 | fBConstrain(kFALSE), | |
40 | fLastPoint(-1), | |
41 | fFirstPoint(-1), | |
42 | fRemoval(0), | |
43 | fTrackType(0), | |
44 | fLab2(-1), | |
45 | fNShared(0), | |
46 | fReference() | |
e3f7105e | 47 | { |
2fc0c115 | 48 | //------------------------------------------------- |
49 | // default constructor | |
50 | //------------------------------------------------- | |
e13cc304 | 51 | for (Int_t i=0; i<kMaxRow;i++) fIndex[i]=-2; |
52 | for (Int_t i=0; i<4;i++) fPoints[i]=0.; | |
53 | for (Int_t i=0; i<12;i++) fKinkPoint[i]=0.; | |
c84a5e9e | 54 | for (Int_t i=0; i<3;i++) fKinkIndexes[i]=0; |
e13cc304 | 55 | for (Int_t i=0; i<3;i++) fV0Indexes[i]=0; |
e3f7105e | 56 | } |
57 | ||
73042f01 | 58 | //_________________________________________________________________________ |
51ad6848 | 59 | |
60 | ||
61 | ||
6c94f330 | 62 | AliTPCtrack::AliTPCtrack(Double_t x, Double_t alpha, const Double_t p[5], |
63 | const Double_t cov[15], Int_t index) : | |
e13cc304 | 64 | AliKalmanTrack(), |
e13cc304 | 65 | fdEdx(0), |
e13cc304 | 66 | fSdEdx(1e10), |
67 | fNFoundable(0), | |
68 | fBConstrain(kFALSE), | |
69 | fLastPoint(0), | |
70 | fFirstPoint(0), | |
71 | fRemoval(0), | |
72 | fTrackType(0), | |
73 | fLab2(0), | |
74 | fNShared(0), | |
75 | fReference() | |
76 | { | |
73042f01 | 77 | //----------------------------------------------------------------- |
78 | // This is the main track constructor. | |
79 | //----------------------------------------------------------------- | |
beceeaec | 80 | Double_t cnv=1./(AliTracker::GetBz()*kB2C); |
6c94f330 | 81 | |
82 | Double_t pp[5]={ | |
83 | p[0], | |
84 | p[1], | |
85 | x*p[4] - p[2], | |
86 | p[3], | |
87 | p[4]*cnv | |
88 | }; | |
89 | ||
90 | Double_t c22 = x*x*cov[14] - 2*x*cov[12] + cov[5]; | |
91 | Double_t c32 = x*cov[13] - cov[8]; | |
92 | Double_t c20 = x*cov[10] - cov[3], | |
93 | c21 = x*cov[11] - cov[4], c42 = x*cov[14] - cov[12]; | |
94 | ||
95 | Double_t cc[15]={ | |
96 | cov[0 ], | |
97 | cov[1 ], cov[2 ], | |
98 | c20, c21, c22, | |
99 | cov[6 ], cov[7 ], c32, cov[9 ], | |
100 | cov[10]*cnv, cov[11]*cnv, c42*cnv, cov[13]*cnv, cov[14]*cnv*cnv | |
101 | }; | |
102 | ||
86fc30dc | 103 | Double_t mostProbablePt=AliExternalTrackParam::GetMostProbablePt(); |
104 | Double_t p0=TMath::Sign(1/mostProbablePt,pp[4]); | |
beceeaec | 105 | Double_t w0=cc[14]/(cc[14] + p0*p0), w1=p0*p0/(cc[14] + p0*p0); |
106 | pp[4] = w0*p0 + w1*pp[4]; | |
107 | cc[10]*=w1; cc[11]*=w1; cc[12]*=w1; cc[13]*=w1; cc[14]*=w1; | |
108 | ||
6c94f330 | 109 | Set(x,alpha,pp,cc); |
c84a5e9e | 110 | |
be9c5115 | 111 | SetNumberOfClusters(1); |
e13cc304 | 112 | |
113 | fIndex[0]=index; | |
9fe5b2ff | 114 | for (Int_t i=1; i<kMaxRow;i++) fIndex[i]=-2; |
115 | for (Int_t i=0; i<4;i++) fPoints[i]=0.; | |
116 | for (Int_t i=0; i<12;i++) fKinkPoint[i]=0.; | |
51ad6848 | 117 | for (Int_t i=0; i<3;i++) fKinkIndexes[i]=0; |
81e97e0d | 118 | for (Int_t i=0; i<3;i++) fV0Indexes[i]=0; |
b9de75e1 | 119 | } |
120 | ||
83d73500 | 121 | //_____________________________________________________________________________ |
e13cc304 | 122 | AliTPCtrack::AliTPCtrack(const AliESDtrack& t) : |
123 | AliKalmanTrack(), | |
6c94f330 | 124 | fdEdx(t.GetTPCsignal()), |
e13cc304 | 125 | fSdEdx(1e10), |
126 | fNFoundable(0), | |
127 | fBConstrain(kFALSE), | |
128 | fLastPoint(0), | |
129 | fFirstPoint(0), | |
130 | fRemoval(0), | |
131 | fTrackType(0), | |
132 | fLab2(0), | |
133 | fNShared(0), | |
134 | fReference() | |
135 | { | |
83d73500 | 136 | //----------------------------------------------------------------- |
137 | // Conversion AliESDtrack -> AliTPCtrack. | |
138 | //----------------------------------------------------------------- | |
139 | SetNumberOfClusters(t.GetTPCclusters(fIndex)); | |
140 | SetLabel(t.GetLabel()); | |
141 | SetMass(t.GetMass()); | |
9fe5b2ff | 142 | for (Int_t i=0; i<4;i++) fPoints[i]=0.; |
143 | for (Int_t i=0; i<12;i++) fKinkPoint[i]=0.; | |
144 | for (Int_t i=0; i<3;i++) fKinkIndexes[i]=0; | |
145 | for (Int_t i=0; i<3;i++) fV0Indexes[i]=0; | |
83d73500 | 146 | |
6c94f330 | 147 | Set(t.GetX(),t.GetAlpha(),t.GetParameter(),t.GetCovariance()); |
83d73500 | 148 | |
0798b21e | 149 | if ((t.GetStatus()&AliESDtrack::kTIME) == 0) return; |
83d73500 | 150 | StartTimeIntegral(); |
151 | Double_t times[10]; t.GetIntegratedTimes(times); SetIntegratedTimes(times); | |
152 | SetIntegratedLength(t.GetIntegratedLength()); | |
153 | } | |
154 | ||
73042f01 | 155 | //_____________________________________________________________________________ |
e13cc304 | 156 | AliTPCtrack::AliTPCtrack(const AliTPCtrack& t) : |
157 | AliKalmanTrack(t), | |
e13cc304 | 158 | fdEdx(t.fdEdx), |
e13cc304 | 159 | fSdEdx(t.fSdEdx), |
160 | fNFoundable(t.fNFoundable), | |
161 | fBConstrain(t.fBConstrain), | |
162 | fLastPoint(t.fLastPoint), | |
163 | fFirstPoint(t.fFirstPoint), | |
164 | fRemoval(t.fRemoval), | |
165 | fTrackType(t.fTrackType), | |
166 | fLab2(t.fLab2), | |
167 | fNShared(t.fNShared), | |
168 | fReference(t.fReference) | |
169 | ||
170 | { | |
73042f01 | 171 | //----------------------------------------------------------------- |
172 | // This is a track copy constructor. | |
173 | //----------------------------------------------------------------- | |
6c94f330 | 174 | Set(t.GetX(),t.GetAlpha(),t.GetParameter(),t.GetCovariance()); |
175 | ||
51584047 | 176 | for (Int_t i=0; i<kMaxRow; i++) fIndex[i]=t.fIndex[i]; |
9fe5b2ff | 177 | for (Int_t i=0; i<4;i++) fPoints[i]=t.fPoints[i]; |
178 | for (Int_t i=0; i<12;i++) fKinkPoint[i]=t.fKinkPoint[i]; | |
51ad6848 | 179 | for (Int_t i=0; i<3;i++) fKinkIndexes[i]=t.fKinkIndexes[i]; |
81e97e0d | 180 | for (Int_t i=0; i<3;i++) fV0Indexes[i]=t.fV0Indexes[i]; |
be9c5115 | 181 | } |
182 | ||
183 | //_____________________________________________________________________________ | |
184 | Int_t AliTPCtrack::Compare(const TObject *o) const { | |
185 | //----------------------------------------------------------------- | |
186 | // This function compares tracks according to the their curvature | |
187 | //----------------------------------------------------------------- | |
188 | AliTPCtrack *t=(AliTPCtrack*)o; | |
024a7fe9 | 189 | //Double_t co=TMath::Abs(t->Get1Pt()); |
190 | //Double_t c =TMath::Abs(Get1Pt()); | |
191 | Double_t co=t->GetSigmaY2()*t->GetSigmaZ2(); | |
192 | Double_t c =GetSigmaY2()*GetSigmaZ2(); | |
be9c5115 | 193 | if (c>co) return 1; |
194 | else if (c<co) return -1; | |
195 | return 0; | |
196 | } | |
197 | ||
6c94f330 | 198 | Double_t AliTPCtrack::GetPredictedChi2(const AliCluster *c) const { |
be9c5115 | 199 | //----------------------------------------------------------------- |
200 | // This function calculates a predicted chi2 increment. | |
201 | //----------------------------------------------------------------- | |
6c94f330 | 202 | Double_t p[2]={c->GetY(), c->GetZ()}; |
203 | Double_t cov[3]={c->GetSigmaY2(), 0., c->GetSigmaZ2()}; | |
204 | return AliExternalTrackParam::GetPredictedChi2(p,cov); | |
c630aafd | 205 | } |
206 | ||
73042f01 | 207 | //_____________________________________________________________________________ |
6c94f330 | 208 | Bool_t AliTPCtrack::PropagateTo(Double_t xk,Double_t rho,Double_t x0) { |
73042f01 | 209 | //----------------------------------------------------------------- |
6c94f330 | 210 | // This function propagates a track to a reference plane x=xk. |
211 | // rho - density of the crossed matrial (g/cm^3) | |
212 | // x0 - radiation length of the crossed material (g/cm^2) | |
73042f01 | 213 | //----------------------------------------------------------------- |
6c94f330 | 214 | Double_t oldX=GetX(), oldY=GetY(), oldZ=GetZ(); |
c84a5e9e | 215 | |
6c94f330 | 216 | Double_t bz=GetBz(); |
217 | if (!AliExternalTrackParam::PropagateTo(xk,bz)) return kFALSE; | |
73042f01 | 218 | |
6c94f330 | 219 | Double_t d = TMath::Sqrt((GetX()-oldX)*(GetX()-oldX) + |
220 | (GetY()-oldY)*(GetY()-oldY) + | |
221 | (GetZ()-oldZ)*(GetZ()-oldZ)); | |
222 | if (IsStartedTimeIntegral() && GetX()>oldX) AddTimeStep(d); | |
223 | ||
224 | if (oldX < xk) d = -d; | |
225 | if (!AliExternalTrackParam::CorrectForMaterial(d*rho/x0,x0,GetMass())) | |
226 | return kFALSE; | |
e3f7105e | 227 | |
6c94f330 | 228 | return kTRUE; |
73042f01 | 229 | } |
230 | ||
231 | //_____________________________________________________________________________ | |
6c94f330 | 232 | Bool_t |
233 | AliTPCtrack::PropagateToVertex(const AliESDVertex *v,Double_t d,Double_t x0) | |
73042f01 | 234 | { |
235 | //----------------------------------------------------------------- | |
6c94f330 | 236 | // This function propagates tracks to the vertex. |
73042f01 | 237 | //----------------------------------------------------------------- |
6c94f330 | 238 | Double_t bz=GetBz(); |
239 | if (PropagateToDCA(v,bz,kVeryBig)) | |
240 | if (AliExternalTrackParam::CorrectForMaterial(d,x0,GetMass())) return kTRUE; | |
241 | return kFALSE; | |
73042f01 | 242 | } |
243 | ||
244 | //_____________________________________________________________________________ | |
6c94f330 | 245 | Bool_t AliTPCtrack::Update(const AliCluster *c, Double_t chisq, Int_t index) { |
73042f01 | 246 | //----------------------------------------------------------------- |
247 | // This function associates a cluster with this track. | |
248 | //----------------------------------------------------------------- | |
6c94f330 | 249 | Double_t p[2]={c->GetY(), c->GetZ()}; |
250 | Double_t cov[3]={c->GetSigmaY2(), 0., c->GetSigmaZ2()}; | |
73042f01 | 251 | |
6c94f330 | 252 | if (!AliExternalTrackParam::Update(p,cov)) return kFALSE; |
73042f01 | 253 | |
be9c5115 | 254 | Int_t n=GetNumberOfClusters(); |
255 | fIndex[n]=index; | |
256 | SetNumberOfClusters(n+1); | |
257 | SetChi2(GetChi2()+chisq); | |
258 | ||
6c94f330 | 259 | return kTRUE; |
73042f01 | 260 | } |
261 | ||
51584047 | 262 | //////////////////////////////////////////////////////////////////////// |
263 | // MI ADDITION | |
264 | ||
265 | Float_t AliTPCtrack::Density(Int_t row0, Int_t row1) | |
266 | { | |
267 | // | |
268 | // calculate cluster density | |
269 | Int_t good = 0; | |
270 | Int_t found = 0; | |
271 | //if (row0<fFirstPoint) row0 = fFirstPoint; | |
272 | if (row1>fLastPoint) row1 = fLastPoint; | |
273 | ||
274 | ||
275 | for (Int_t i=row0;i<=row1;i++){ | |
276 | // Int_t index = fClusterIndex[i]; | |
277 | Int_t index = fIndex[i]; | |
278 | if (index!=-1) good++; | |
279 | if (index>0) found++; | |
280 | } | |
281 | Float_t density=0; | |
282 | if (good>0) density = Float_t(found)/Float_t(good); | |
283 | return density; | |
284 | } | |
285 | ||
286 | ||
287 | Float_t AliTPCtrack::Density2(Int_t row0, Int_t row1) | |
288 | { | |
289 | // | |
290 | // calculate cluster density | |
291 | Int_t good = 0; | |
292 | Int_t found = 0; | |
293 | // | |
294 | for (Int_t i=row0;i<=row1;i++){ | |
295 | Int_t index = fIndex[i]; | |
296 | if (index!=-1) good++; | |
297 | if (index>0) found++; | |
298 | } | |
299 | Float_t density=0; | |
300 | if (good>0) density = Float_t(found)/Float_t(good); | |
301 | return density; | |
302 | } | |
303 | ||
51ad6848 | 304 | void AliTPCtrack::UpdatePoints() |
305 | { | |
306 | //-------------------------------------------------- | |
307 | //calculates first ,amx dens and last points | |
308 | //-------------------------------------------------- | |
309 | Float_t density[160]; | |
310 | for (Int_t i=0;i<160;i++) density[i]=-1.; | |
311 | fPoints[0]= 160; | |
312 | fPoints[1] = -1; | |
313 | // | |
314 | Int_t ngood=0; | |
315 | Int_t undeff=0; | |
316 | Int_t nall =0; | |
317 | Int_t range=20; | |
318 | for (Int_t i=0;i<160;i++){ | |
319 | Int_t last = i-range; | |
320 | if (nall<range) nall++; | |
321 | if (last>=0){ | |
322 | if (fIndex[last]>0&& (fIndex[last]&0x8000)==0) ngood--; | |
323 | if (fIndex[last]==-1) undeff--; | |
324 | } | |
325 | if (fIndex[i]>0&& (fIndex[i]&0x8000)==0) ngood++; | |
326 | if (fIndex[i]==-1) undeff++; | |
327 | if (nall==range &&undeff<range/2) density[i-range/2] = Float_t(ngood)/Float_t(nall-undeff); | |
328 | } | |
329 | Float_t maxdens=0; | |
330 | Int_t indexmax =0; | |
331 | for (Int_t i=0;i<160;i++){ | |
332 | if (density[i]<0) continue; | |
333 | if (density[i]>maxdens){ | |
334 | maxdens=density[i]; | |
335 | indexmax=i; | |
336 | } | |
337 | } | |
338 | // | |
339 | //max dens point | |
340 | fPoints[3] = maxdens; | |
341 | fPoints[1] = indexmax; | |
342 | // | |
343 | // last point | |
344 | for (Int_t i=indexmax;i<160;i++){ | |
345 | if (density[i]<0) continue; | |
346 | if (density[i]<maxdens/2.) { | |
347 | break; | |
348 | } | |
349 | fPoints[2]=i; | |
350 | } | |
351 | // | |
352 | // first point | |
353 | for (Int_t i=indexmax;i>0;i--){ | |
354 | if (density[i]<0) continue; | |
355 | if (density[i]<maxdens/2.) { | |
356 | break; | |
357 | } | |
358 | fPoints[0]=i; | |
359 | } | |
360 | // | |
361 | } | |
5773defd | 362 | |
6c94f330 | 363 | Double_t AliTPCtrack::GetBz() const { |
364 | // | |
365 | // returns Bz component of the magnetic field (kG) | |
366 | // | |
367 | if (AliTracker::UniformField()) return AliTracker::GetBz(); | |
368 | Double_t r[3]; GetXYZ(r); | |
369 | return AliTracker::GetBz(r); | |
5773defd | 370 | } |
6c94f330 | 371 |