Fixes for some mem-leaks: most changes where pretty basic (i.e. adding deletes).
[u/mrichter/AliRoot.git] / TPC / AliTPCtrack.cxx
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 /* $Id$ */
17
18 //-----------------------------------------------------------------
19 //           Implementation of the TPC track class
20 //        This class is used by the AliTPCtracker class
21 //      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
22 //-----------------------------------------------------------------
23
24 #include <Riostream.h>
25
26 #include "AliTPCtrack.h"
27 #include "AliCluster.h"
28 #include "AliTracker.h"
29 #include "AliESDtrack.h"
30
31 ClassImp(AliTPCtrack)
32
33 //_________________________________________________________________________
34 AliTPCtrack::AliTPCtrack(): 
35   AliKalmanTrack(),
36   fdEdx(0),
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()
47 {
48   //-------------------------------------------------
49   // default constructor
50   //-------------------------------------------------
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.;
54   for (Int_t i=0; i<3;i++) fKinkIndexes[i]=0;
55   for (Int_t i=0; i<3;i++) fV0Indexes[i]=0;
56 }
57
58 //_________________________________________________________________________
59
60
61
62 AliTPCtrack::AliTPCtrack(Double_t x, Double_t alpha, const Double_t p[5],
63                          const Double_t cov[15], Int_t index) :
64   AliKalmanTrack(),
65   fdEdx(0),
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 {
77   //-----------------------------------------------------------------
78   // This is the main track constructor.
79   //-----------------------------------------------------------------
80   Double_t cnv=1./(AliTracker::GetBz()*kB2C);
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
103   Double_t mostProbablePt=AliExternalTrackParam::GetMostProbablePt();
104   Double_t p0=TMath::Sign(1/mostProbablePt,pp[4]);
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
109   Set(x,alpha,pp,cc);
110
111   SetNumberOfClusters(1);
112   
113   fIndex[0]=index;
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.;
117   for (Int_t i=0; i<3;i++) fKinkIndexes[i]=0;
118   for (Int_t i=0; i<3;i++) fV0Indexes[i]=0;
119 }
120
121 //_____________________________________________________________________________
122 AliTPCtrack::AliTPCtrack(const AliESDtrack& t) :
123   AliKalmanTrack(),
124   fdEdx(t.GetTPCsignal()),
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 {
136   //-----------------------------------------------------------------
137   // Conversion AliESDtrack -> AliTPCtrack.
138   //-----------------------------------------------------------------
139   SetNumberOfClusters(t.GetTPCclusters(fIndex));
140   SetLabel(t.GetLabel());
141   SetMass(t.GetMass());
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;
146
147   Set(t.GetX(),t.GetAlpha(),t.GetParameter(),t.GetCovariance());
148
149   if ((t.GetStatus()&AliESDtrack::kTIME) == 0) return;
150   StartTimeIntegral();
151   Double_t times[10]; t.GetIntegratedTimes(times); SetIntegratedTimes(times);
152   SetIntegratedLength(t.GetIntegratedLength());
153 }
154
155 //_____________________________________________________________________________
156 AliTPCtrack::AliTPCtrack(const AliTPCtrack& t) :
157   AliKalmanTrack(t),
158   fdEdx(t.fdEdx),
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 {
171   //-----------------------------------------------------------------
172   // This is a track copy constructor.
173   //-----------------------------------------------------------------
174   Set(t.GetX(),t.GetAlpha(),t.GetParameter(),t.GetCovariance());
175
176   for (Int_t i=0; i<kMaxRow; i++) fIndex[i]=t.fIndex[i];
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];
179   for (Int_t i=0; i<3;i++) fKinkIndexes[i]=t.fKinkIndexes[i];
180   for (Int_t i=0; i<3;i++) fV0Indexes[i]=t.fV0Indexes[i];
181 }
182
183 AliTPCtrack& AliTPCtrack::operator=(const AliTPCtrack& o){
184   if(this!=&o){
185     AliKalmanTrack::operator=(o);
186     fdEdx = o.fdEdx;
187     for(Int_t i = 0;i<kMaxRow;++i)fIndex[i] = o.fIndex[i];
188     for(Int_t i = 0;i<4;++i)fPoints[i] = o.fPoints[i];
189     fSdEdx = o.fSdEdx;
190     fNFoundable = o.fNFoundable;
191     fBConstrain = o.fBConstrain;
192     fLastPoint  = o.fLastPoint;
193     fFirstPoint = o.fFirstPoint;
194     fTrackType  = o.fTrackType;
195     fLab2       = o.fLab2;
196     fNShared    = o.fNShared;
197     fReference  = o.fReference;
198     for(Int_t i = 0;i<12;++i) fKinkPoint[i] = o.fKinkPoint[i];
199
200     for(Int_t i = 0;i<3;++i){
201       fKinkIndexes[i] = o.fKinkIndexes[i];
202       fV0Indexes[i] = o.fV0Indexes[i];
203     }
204   }
205   return *this;
206
207 }
208
209
210 //_____________________________________________________________________________
211 Int_t AliTPCtrack::Compare(const TObject *o) const {
212   //-----------------------------------------------------------------
213   // This function compares tracks according to the their curvature
214   //-----------------------------------------------------------------
215   AliTPCtrack *t=(AliTPCtrack*)o;
216   //Double_t co=t->OneOverPt();
217   //Double_t c = OneOverPt();
218   Double_t co=t->GetSigmaY2()*t->GetSigmaZ2();
219   Double_t c =GetSigmaY2()*GetSigmaZ2();
220   if (c>co) return 1;
221   else if (c<co) return -1;
222   return 0;
223 }
224
225 Double_t AliTPCtrack::GetPredictedChi2(const AliCluster *c) const {
226   //-----------------------------------------------------------------
227   // This function calculates a predicted chi2 increment.
228   //-----------------------------------------------------------------
229   Double_t p[2]={c->GetY(), c->GetZ()};
230   Double_t cov[3]={c->GetSigmaY2(), 0., c->GetSigmaZ2()};
231   return AliExternalTrackParam::GetPredictedChi2(p,cov);
232 }
233
234 //_____________________________________________________________________________
235 Bool_t AliTPCtrack::PropagateTo(Double_t xk,Double_t rho,Double_t x0) {
236   //-----------------------------------------------------------------
237   //  This function propagates a track to a reference plane x=xk.
238   //  rho - density of the crossed matrial (g/cm^3)
239   //  x0  - radiation length of the crossed material (g/cm^2) 
240   //-----------------------------------------------------------------
241   Double_t oldX=GetX(), oldY=GetY(), oldZ=GetZ();
242
243   Double_t bz=GetBz();
244   if (!AliExternalTrackParam::PropagateTo(xk,bz)) return kFALSE;
245
246   Double_t d = TMath::Sqrt((GetX()-oldX)*(GetX()-oldX) + 
247                            (GetY()-oldY)*(GetY()-oldY) + 
248                            (GetZ()-oldZ)*(GetZ()-oldZ));
249   if (IsStartedTimeIntegral() && GetX()>oldX) AddTimeStep(d);
250
251   if (oldX < xk) d = -d;
252   if (!AliExternalTrackParam::CorrectForMaterial(d*rho/x0,x0,GetMass())) 
253      return kFALSE;
254
255   return kTRUE;
256 }
257
258 //_____________________________________________________________________________
259 Bool_t 
260 AliTPCtrack::PropagateToVertex(const AliESDVertex *v,Double_t d,Double_t x0) 
261 {
262   //-----------------------------------------------------------------
263   // This function propagates tracks to the vertex.
264   //-----------------------------------------------------------------
265   Double_t bz=GetBz();
266   if (PropagateToDCA(v,bz,kVeryBig))
267    if (AliExternalTrackParam::CorrectForMaterial(d,x0,GetMass())) return kTRUE;
268   return kFALSE;
269 }
270
271 //_____________________________________________________________________________
272 Bool_t AliTPCtrack::Update(const AliCluster *c, Double_t chisq, Int_t index) {
273   //-----------------------------------------------------------------
274   // This function associates a cluster with this track.
275   //-----------------------------------------------------------------
276   Double_t p[2]={c->GetY(), c->GetZ()};
277   Double_t cov[3]={c->GetSigmaY2(), 0., c->GetSigmaZ2()};
278
279   if (!AliExternalTrackParam::Update(p,cov)) return kFALSE;
280
281   Int_t n=GetNumberOfClusters();
282   fIndex[n]=index;
283   SetNumberOfClusters(n+1);
284   SetChi2(GetChi2()+chisq);
285
286   return kTRUE;
287 }
288
289 ////////////////////////////////////////////////////////////////////////
290 // MI ADDITION
291
292 Float_t AliTPCtrack::Density(Int_t row0, Int_t row1)
293 {
294   //
295   // calculate cluster density
296   Int_t good  = 0;
297   Int_t found = 0;
298   //if (row0<fFirstPoint) row0 = fFirstPoint;
299   if (row1>fLastPoint) row1 = fLastPoint;
300
301   
302   for (Int_t i=row0;i<=row1;i++){ 
303     //    Int_t index = fClusterIndex[i];
304     Int_t index = fIndex[i];
305     if (index!=-1)  good++;
306     if (index>0)    found++;
307   }
308   Float_t density=0;
309   if (good>0) density = Float_t(found)/Float_t(good);
310   return density;
311 }
312
313
314 Float_t AliTPCtrack::Density2(Int_t row0, Int_t row1)
315 {
316   //
317   // calculate cluster density
318   Int_t good  = 0;
319   Int_t found = 0;
320   //  
321   for (Int_t i=row0;i<=row1;i++){     
322     Int_t index = fIndex[i];
323     if (index!=-1)  good++;
324     if (index>0)    found++;
325   }
326   Float_t density=0;
327   if (good>0) density = Float_t(found)/Float_t(good);
328   return density;
329 }
330
331 void  AliTPCtrack::UpdatePoints()
332 {
333   //--------------------------------------------------
334   //calculates first ,amx dens and last points
335   //--------------------------------------------------
336   Float_t density[160];
337   for (Int_t i=0;i<160;i++) density[i]=-1.;
338   fPoints[0]= 160;
339   fPoints[1] = -1;
340   //
341   Int_t ngood=0;
342   Int_t undeff=0;
343   Int_t nall =0;
344   Int_t range=20;
345   for (Int_t i=0;i<160;i++){
346     Int_t last = i-range;
347     if (nall<range) nall++;
348     if (last>=0){
349       if (fIndex[last]>0&& (fIndex[last]&0x8000)==0) ngood--;
350       if (fIndex[last]==-1) undeff--;
351     }
352     if (fIndex[i]>0&& (fIndex[i]&0x8000)==0)   ngood++;
353     if (fIndex[i]==-1) undeff++;
354     if (nall==range &&undeff<range/2) density[i-range/2] = Float_t(ngood)/Float_t(nall-undeff);
355   }
356   Float_t maxdens=0;
357   Int_t indexmax =0;
358   for (Int_t i=0;i<160;i++){
359     if (density[i]<0) continue;
360     if (density[i]>maxdens){
361       maxdens=density[i];
362       indexmax=i;
363     }
364   }
365   //
366   //max dens point
367   fPoints[3] = maxdens;
368   fPoints[1] = indexmax;
369   //
370   // last point
371   for (Int_t i=indexmax;i<160;i++){
372     if (density[i]<0) continue;
373     if (density[i]<maxdens/2.) {
374       break;
375     }
376     fPoints[2]=i;
377   }
378   //
379   // first point
380   for (Int_t i=indexmax;i>0;i--){
381     if (density[i]<0) continue;
382     if (density[i]<maxdens/2.) {
383       break;
384     }
385     fPoints[0]=i;
386   }
387   //
388 }
389
390 Double_t AliTPCtrack::GetBz() const {
391   //
392   // returns Bz component of the magnetic field (kG)
393   //
394   if (AliTracker::UniformField()) return AliTracker::GetBz();
395   Double_t r[3]; GetXYZ(r);
396   return AliTracker::GetBz(r);
397 }
398