Removed completelly high noise at channel > 700 (Marian)
[u/mrichter/AliRoot.git] / TPC / AliTPCtracker.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 tracker
20 //
21 //   Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch 
22 //-------------------------------------------------------
23 #include <TObjArray.h>
24 #include <TError.h>
25 #include <TFile.h>
26 #include <TTree.h>
27
28 #include "AliESDEvent.h"
29 #include "AliESDtrack.h"
30
31 #include "AliTPCtracker.h"
32 #include "AliTPCcluster.h"
33 #include "AliTPCParam.h"
34 #include "AliClusters.h"
35
36 ClassImp(AliTPCtracker)
37
38 //_____________________________________________________________________________
39 AliTPCtracker::AliTPCtracker(): 
40   AliTracker(), 
41   fkNIS(0), 
42   fInnerSec(0),         
43   fkNOS(0),
44   fOuterSec(0),
45   fN(0),
46   fSectors(0),
47   fParam(0),
48   fSeeds(0)
49 {
50   //
51   // The default TPC tracker constructor
52   //
53 }
54
55 //_____________________________________________________________________________
56 AliTPCtracker::AliTPCtracker(const AliTPCParam *par): 
57   AliTracker(), 
58   fkNIS(par->GetNInnerSector()/2), 
59   fInnerSec(new AliTPCSector[fkNIS]),         
60   fkNOS(par->GetNOuterSector()/2),
61   fOuterSec(new AliTPCSector[fkNOS]),
62   fN(0),
63   fSectors(0),
64   fParam((AliTPCParam*) par),
65   fSeeds(0)
66 {
67   //---------------------------------------------------------------------
68   // The main TPC tracker constructor
69   //---------------------------------------------------------------------
70
71   Int_t i;
72   for (i=0; i<fkNIS; i++) fInnerSec[i].Setup(par,0);
73   for (i=0; i<fkNOS; i++) fOuterSec[i].Setup(par,1);
74
75 }
76
77 //_____________________________________________________________________________
78 AliTPCtracker::~AliTPCtracker() {
79   //------------------------------------------------------------------
80   // TPC tracker destructor
81   //------------------------------------------------------------------
82   delete[] fInnerSec;
83   delete[] fOuterSec;
84   if (fSeeds) {
85     fSeeds->Delete(); 
86     delete fSeeds;
87   }
88 }
89
90 //_____________________________________________________________________________
91 Double_t f1(Double_t x1,Double_t y1,
92                    Double_t x2,Double_t y2,
93                    Double_t x3,Double_t y3) 
94 {
95   //-----------------------------------------------------------------
96   // Initial approximation of the track curvature
97   //-----------------------------------------------------------------
98   Double_t d=(x2-x1)*(y3-y2)-(x3-x2)*(y2-y1);
99   Double_t a=0.5*((y3-y2)*(y2*y2-y1*y1+x2*x2-x1*x1)-
100                   (y2-y1)*(y3*y3-y2*y2+x3*x3-x2*x2));
101   Double_t b=0.5*((x2-x1)*(y3*y3-y2*y2+x3*x3-x2*x2)-
102                   (x3-x2)*(y2*y2-y1*y1+x2*x2-x1*x1));
103
104   Double_t xr=TMath::Abs(d/(d*x1-a)), yr=d/(d*y1-b);
105
106   return -xr*yr/sqrt(xr*xr+yr*yr); 
107 }
108
109
110 //_____________________________________________________________________________
111 Double_t f2(Double_t x1,Double_t y1,
112                    Double_t x2,Double_t y2,
113                    Double_t x3,Double_t y3) 
114 {
115   //-----------------------------------------------------------------
116   // Initial approximation of the track curvature times center of curvature
117   //-----------------------------------------------------------------
118   Double_t d=(x2-x1)*(y3-y2)-(x3-x2)*(y2-y1);
119   Double_t a=0.5*((y3-y2)*(y2*y2-y1*y1+x2*x2-x1*x1)-
120                   (y2-y1)*(y3*y3-y2*y2+x3*x3-x2*x2));
121   Double_t b=0.5*((x2-x1)*(y3*y3-y2*y2+x3*x3-x2*x2)-
122                   (x3-x2)*(y2*y2-y1*y1+x2*x2-x1*x1));
123
124   Double_t xr=TMath::Abs(d/(d*x1-a)), yr=d/(d*y1-b);
125   
126   return -a/(d*y1-b)*xr/sqrt(xr*xr+yr*yr);
127 }
128
129 //_____________________________________________________________________________
130 Double_t f3(Double_t x1,Double_t y1, 
131                    Double_t x2,Double_t y2,
132                    Double_t z1,Double_t z2) 
133 {
134   //-----------------------------------------------------------------
135   // Initial approximation of the tangent of the track dip angle
136   //-----------------------------------------------------------------
137   return (z1 - z2)/sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
138 }
139
140 //_____________________________________________________________________________
141 Int_t AliTPCtracker::LoadClusters(TTree *cTree) {
142   //-----------------------------------------------------------------
143   // This function loads TPC clusters.
144   //-----------------------------------------------------------------
145   TBranch *branch=cTree->GetBranch("Segment");
146   if (!branch) {
147      Error("LoadClusters","Can't get the branch !");
148      return 1;
149   }
150
151   AliClusters carray, *addr=&carray;
152   carray.SetClass("AliTPCcluster");
153   carray.SetArray(0);
154   branch->SetAddress(&addr);
155
156   Int_t nentr=(Int_t)cTree->GetEntries();
157
158   for (Int_t i=0; i<nentr; i++) {
159       cTree->GetEvent(i);
160
161       Int_t ncl=carray.GetArray()->GetEntriesFast();
162
163       Int_t nir=fInnerSec->GetNRows(), nor=fOuterSec->GetNRows();
164       Int_t id=carray.GetID();
165       if ((id<0) || (id>2*(fkNIS*nir + fkNOS*nor))) {
166          Fatal("LoadClusters","Wrong index !");
167       }
168       Int_t outindex = 2*fkNIS*nir;
169       if (id<outindex) {
170          Int_t sec = id/nir;
171          Int_t row = id - sec*nir;
172          sec %= fkNIS;
173          AliTPCRow &padrow=fInnerSec[sec][row];
174          while (ncl--) {
175            AliTPCcluster *c=(AliTPCcluster*)carray[ncl];
176            padrow.InsertCluster(c,sec,row);
177          }
178       } else {
179          id -= outindex;
180          Int_t sec = id/nor;
181          Int_t row = id - sec*nor;
182          sec %= fkNOS;
183          AliTPCRow &padrow=fOuterSec[sec][row];
184          while (ncl--) {
185            AliTPCcluster *c=(AliTPCcluster*)carray[ncl];
186            padrow.InsertCluster(c,sec+fkNIS,row);
187          }
188       }
189       carray.GetArray()->Clear();
190   }
191
192   return 0;
193 }
194
195 //_____________________________________________________________________________
196 void AliTPCtracker::UnloadClusters() {
197   //-----------------------------------------------------------------
198   // This function unloads TPC clusters.
199   //-----------------------------------------------------------------
200   Int_t i;
201   for (i=0; i<fkNIS; i++) {
202     Int_t nr=fInnerSec->GetNRows();
203     for (Int_t n=0; n<nr; n++) fInnerSec[i][n].ResetClusters();
204   }
205   for (i=0; i<fkNOS; i++) {
206     Int_t nr=fOuterSec->GetNRows();
207     for (Int_t n=0; n<nr; n++) fOuterSec[i][n].ResetClusters();
208   }
209 }
210
211 //_____________________________________________________________________________
212 Int_t AliTPCtracker::FollowProlongation(AliTPCseed& t, Int_t rf) {
213   //-----------------------------------------------------------------
214   // This function tries to find a track prolongation.
215   //-----------------------------------------------------------------
216   Double_t xt=t.GetX();
217   const Int_t kSKIP=(t.GetNumberOfClusters()<10) ? kRowsToSkip : 
218                     Int_t(0.5*fSectors->GetNRows());
219   Int_t tryAgain=kSKIP;
220
221   Double_t alpha=t.GetAlpha() - fSectors->GetAlphaShift();
222   if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();  
223   if (alpha < 0.            ) alpha += 2.*TMath::Pi();  
224   Int_t s=Int_t(alpha/fSectors->GetAlpha())%fN;
225
226   Int_t nrows=fSectors->GetRowNumber(xt)-1;
227   for (Int_t nr=nrows; nr>=rf; nr--) {
228     Double_t x=fSectors->GetX(nr), ymax=fSectors->GetMaxY(nr);
229     if (!t.PropagateTo(x)) return 0;
230
231     AliTPCcluster *cl=0;
232     UInt_t index=0;
233     Double_t maxchi2=kMaxCHI2;
234     const AliTPCRow &krow=fSectors[s][nr];
235     Double_t pt=t.GetSignedPt();
236     Double_t sy2=AliTPCcluster::SigmaY2(t.GetX(),t.GetTgl(),pt);
237     Double_t sz2=AliTPCcluster::SigmaZ2(t.GetX(),t.GetTgl());
238     Double_t road=4.*sqrt(t.GetSigmaY2() + sy2), y=t.GetY(), z=t.GetZ();
239
240     if (road>kMaxROAD) {
241       if (t.GetNumberOfClusters()>4) 
242          Warning("FindProlongation","Too broad road !"); 
243       return 0;
244     }
245
246     if (krow) {
247       for (Int_t i=krow.Find(y-road); i<krow; i++) {
248         AliTPCcluster *c=(AliTPCcluster*)(krow[i]);
249         if (c->GetY() > y+road) break;
250         if (c->IsUsed()) continue;
251         if ((c->GetZ()-z)*(c->GetZ()-z) > 16.*(t.GetSigmaZ2()+sz2)) continue;
252         Double_t chi2=t.GetPredictedChi2(c);
253         if (chi2 > maxchi2) continue;
254         maxchi2=chi2;
255         cl=c;
256         index=krow.GetIndex(i);       
257       }
258     }
259     if (cl) {
260       Float_t l=fSectors->GetPadPitchWidth();
261       Float_t corr=1.; if (nr>63) corr=0.67; // new (third) pad response !
262       t.SetSampledEdx(cl->GetQ()/l*corr,t.GetNumberOfClusters());
263       if (!t.Update(cl,maxchi2,index)) {
264          if (!tryAgain--) return 0;
265       } else tryAgain=kSKIP;
266     } else {
267       if (tryAgain==0) break;
268       if (y > ymax) {
269          s = (s+1) % fN;
270          if (!t.Rotate(fSectors->GetAlpha())) return 0;
271       } else if (y <-ymax) {
272          s = (s-1+fN) % fN;
273          if (!t.Rotate(-fSectors->GetAlpha())) return 0;
274       }
275       tryAgain--;
276     }
277   }
278
279   return 1;
280 }
281 //_____________________________________________________________________________
282
283 Int_t AliTPCtracker::FollowRefitInward(AliTPCseed *seed, AliTPCtrack *track) {
284   //
285   // This function propagates seed inward TPC using old clusters
286   // from the track.
287   // 
288   // Sylwester Radomski, GSI
289   // 26.02.2003
290   //
291
292   // loop over rows
293
294   Int_t nRows = fSectors->GetNRows();
295   for (Int_t iRow = nRows-1; iRow >= 0; iRow--) {
296
297     Double_t x = fSectors->GetX(iRow);
298     if (!seed->PropagateTo(x)) return 0;
299
300     // try to find an assigned cluster in this row
301
302     AliTPCcluster* cluster = NULL;
303     Int_t idx = -1;
304     Int_t sec = -1;
305     for (Int_t iCluster = 0; iCluster < track->GetNumberOfClusters(); iCluster++) {
306       idx = track->GetClusterIndex(iCluster); 
307       sec = (idx&0xff000000)>>24; 
308       Int_t row = (idx&0x00ff0000)>>16;
309       if (((fSectors == fInnerSec) && (sec >= fkNIS)) ||
310           ((fSectors == fOuterSec) && (sec < fkNIS))) continue;
311       if (row == iRow) {
312         cluster = (AliTPCcluster*) GetCluster(idx);
313         break;
314       }
315     }
316
317     // update the track seed with the found cluster
318
319     if (cluster) {
320       Double_t dAlpha = fParam->GetAngle(sec) - seed->GetAlpha();
321       if (TMath::Abs(dAlpha) > 0.0001) {
322         if (!seed->Rotate(dAlpha)) return 0;
323         if (!seed->PropagateTo(x)) return 0;
324       }
325
326       seed->Update(cluster, seed->GetPredictedChi2(cluster), idx);
327     }
328   }
329
330   return 1;
331 }
332
333 //_____________________________________________________________________________
334 Int_t AliTPCtracker::FollowBackProlongation
335 (AliTPCseed& seed, const AliTPCtrack &track) {
336   //-----------------------------------------------------------------
337   // This function propagates tracks back through the TPC
338   //-----------------------------------------------------------------
339   Double_t alpha=seed.GetAlpha() - fSectors->GetAlphaShift();
340   if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();  
341   if (alpha < 0.            ) alpha += 2.*TMath::Pi();  
342   Int_t s=Int_t(alpha/fSectors->GetAlpha())%fN;
343
344   Int_t idx=-1, sec=-1, row=-1;
345   Int_t nc=track.GetNumberOfClusters();
346
347   if (nc--) {
348      idx=track.GetClusterIndex(nc);
349      sec=(idx&0xff000000)>>24; row=(idx&0x00ff0000)>>16;
350   }
351   if (fSectors==fInnerSec) { if (sec >= fkNIS) row=-1; } 
352   else { if (sec <  fkNIS) row=-1; }   
353
354   Int_t nr=fSectors->GetNRows();
355   for (Int_t i=0; i<nr; i++) {
356     Double_t x=fSectors->GetX(i), ymax=fSectors->GetMaxY(i);
357     Double_t y;
358     if (!seed.GetYAt(x,GetBz(),y)) return 0;
359  
360     if (y > ymax) {
361        s = (s+1) % fN;
362        if (!seed.Rotate(fSectors->GetAlpha())) return 0;
363     } else if (y <-ymax) {
364        s = (s-1+fN) % fN;
365        if (!seed.Rotate(-fSectors->GetAlpha())) return 0;
366     }
367
368     if (!seed.PropagateTo(x)) return 0;
369
370     AliTPCcluster *cl=0;
371     Int_t index=0;
372     Double_t maxchi2=kMaxCHI2;
373     Double_t pt=seed.GetSignedPt();
374     Double_t sy2=AliTPCcluster::SigmaY2(seed.GetX(),seed.GetTgl(),pt);
375     Double_t sz2=AliTPCcluster::SigmaZ2(seed.GetX(),seed.GetTgl());
376     Double_t road=4.*sqrt(seed.GetSigmaY2() + sy2), z=seed.GetZ();
377     if (road>kMaxROAD) {
378       Warning("FollowBackProlongation","Too broad road !"); 
379       return 0;
380     }
381
382     Int_t accepted=seed.GetNumberOfClusters();
383     if (row==i) {
384        //try to accept already found cluster
385        AliTPCcluster *c=(AliTPCcluster*)GetCluster(idx);
386        Double_t chi2;
387        if ((chi2=seed.GetPredictedChi2(c))<maxchi2 || accepted<27) { 
388           index=idx; cl=c; maxchi2=chi2;
389        } //else cerr<<"AliTPCtracker::FollowBackProlongation: oulier !\n";
390           
391        if (nc--) {
392           idx=track.GetClusterIndex(nc); 
393           sec=(idx&0xff000000)>>24; row=(idx&0x00ff0000)>>16;
394        } 
395        if (fSectors==fInnerSec) { if (sec >= fkNIS) row=-1; }
396        else { if (sec < fkNIS) row=-1; }   
397
398     }
399     if (!cl) {
400        //try to fill the gap
401        const AliTPCRow &krow=fSectors[s][i];
402        if (accepted>27)
403        if (krow) {
404           for (Int_t i=krow.Find(y-road); i<krow; i++) {
405             AliTPCcluster *c=(AliTPCcluster*)(krow[i]);
406             if (c->GetY() > y+road) break;
407             if (c->IsUsed()) continue;
408          if ((c->GetZ()-z)*(c->GetZ()-z)>16.*(seed.GetSigmaZ2()+sz2)) continue;
409             Double_t chi2=seed.GetPredictedChi2(c);
410             if (chi2 > maxchi2) continue;
411             maxchi2=chi2;
412             cl=c;
413             index=krow.GetIndex(i);
414           }
415        }
416     }
417
418     if (cl) {
419       Float_t l=fSectors->GetPadPitchWidth();
420       Float_t corr=1.; if (i>63) corr=0.67; // new (third) pad response !
421       seed.SetSampledEdx(cl->GetQ()/l*corr,seed.GetNumberOfClusters());
422       seed.Update(cl,maxchi2,index);
423     }
424
425   }
426
427   return 1;
428 }
429
430 //_____________________________________________________________________________
431 void AliTPCtracker::MakeSeeds(Int_t i1, Int_t i2) {
432   //-----------------------------------------------------------------
433   // This function creates track seeds.
434   //-----------------------------------------------------------------
435   Double_t x[5], c[15];
436
437   Double_t alpha=fSectors->GetAlpha(), shift=fSectors->GetAlphaShift();
438   Double_t cs=cos(alpha), sn=sin(alpha);
439
440   Double_t x1 =fSectors->GetX(i1);
441   Double_t xx2=fSectors->GetX(i2);
442
443   for (Int_t ns=0; ns<fN; ns++) {
444     Int_t nl=fSectors[(ns-1+fN)%fN][i2];
445     Int_t nm=fSectors[ns][i2];
446     Int_t nu=fSectors[(ns+1)%fN][i2];
447     const AliTPCRow& kr1=fSectors[ns][i1];
448     for (Int_t is=0; is < kr1; is++) {
449       Double_t y1=kr1[is]->GetY(), z1=kr1[is]->GetZ();
450       for (Int_t js=0; js < nl+nm+nu; js++) {
451         const AliTPCcluster *kcl;
452         Double_t x2,   y2,   z2;
453         Double_t x3=GetX(), y3=GetY(), z3=GetZ();
454
455         if (js<nl) {
456           const AliTPCRow& kr2=fSectors[(ns-1+fN)%fN][i2];
457           kcl=kr2[js];
458           y2=kcl->GetY(); z2=kcl->GetZ();
459           x2= xx2*cs+y2*sn;
460           y2=-xx2*sn+y2*cs;
461         } else 
462           if (js<nl+nm) {
463             const AliTPCRow& kr2=fSectors[ns][i2];
464             kcl=kr2[js-nl];
465             x2=xx2; y2=kcl->GetY(); z2=kcl->GetZ();
466           } else {
467             const AliTPCRow& kr2=fSectors[(ns+1)%fN][i2];
468             kcl=kr2[js-nl-nm];
469             y2=kcl->GetY(); z2=kcl->GetZ();
470             x2=xx2*cs-y2*sn;
471             y2=xx2*sn+y2*cs;
472           }
473
474         Double_t zz=z1 - (z1-z3)/(x1-x3)*(x1-x2); 
475         if (TMath::Abs(zz-z2)>5.) continue;
476
477         Double_t d=(x2-x1)*(0.-y2)-(0.-x2)*(y2-y1);
478         if (d==0.) {
479            Warning("MakeSeeds","Straight seed !"); 
480            continue;
481         }
482         x[0]=y1;
483         x[1]=z1;
484         x[4]=f1(x1,y1,x2,y2,x3,y3);
485         if (TMath::Abs(x[4]) >= 0.0066) continue;
486         x[2]=f2(x1,y1,x2,y2,x3,y3);
487         //if (TMath::Abs(x[4]*x1-x[2]) >= 0.99999) continue;
488         x[3]=f3(x1,y1,x2,y2,z1,z2);
489         if (TMath::Abs(x[3]) > 1.2) continue;
490         Double_t a=asin(x[2]);
491         Double_t zv=z1 - x[3]/x[4]*(a+asin(x[4]*x1-x[2]));
492         if (TMath::Abs(zv-z3)>10.) continue; 
493
494         Double_t sy1=kr1[is]->GetSigmaY2(), sz1=kr1[is]->GetSigmaZ2();
495         Double_t sy2=kcl->GetSigmaY2(),     sz2=kcl->GetSigmaZ2();
496         //Double_t sy3=400*3./12., sy=0.1, sz=0.1;
497         Double_t sy3=25000*x[4]*x[4]+0.1, sy=0.1, sz=0.1;
498
499         Double_t f40=(f1(x1,y1+sy,x2,y2,x3,y3)-x[4])/sy;
500         Double_t f42=(f1(x1,y1,x2,y2+sy,x3,y3)-x[4])/sy;
501         Double_t f43=(f1(x1,y1,x2,y2,x3,y3+sy)-x[4])/sy;
502         Double_t f20=(f2(x1,y1+sy,x2,y2,x3,y3)-x[2])/sy;
503         Double_t f22=(f2(x1,y1,x2,y2+sy,x3,y3)-x[2])/sy;
504         Double_t f23=(f2(x1,y1,x2,y2,x3,y3+sy)-x[2])/sy;
505         Double_t f30=(f3(x1,y1+sy,x2,y2,z1,z2)-x[3])/sy;
506         Double_t f31=(f3(x1,y1,x2,y2,z1+sz,z2)-x[3])/sz;
507         Double_t f32=(f3(x1,y1,x2,y2+sy,z1,z2)-x[3])/sy;
508         Double_t f34=(f3(x1,y1,x2,y2,z1,z2+sz)-x[3])/sz;
509
510         c[0]=sy1;
511         c[1]=0.;       c[2]=sz1;
512         c[3]=f20*sy1;  c[4]=0.;       c[5]=f20*sy1*f20+f22*sy2*f22+f23*sy3*f23;
513         c[6]=f30*sy1;  c[7]=f31*sz1;  c[8]=f30*sy1*f20+f32*sy2*f22;
514                        c[9]=f30*sy1*f30+f31*sz1*f31+f32*sy2*f32+f34*sz2*f34;
515         c[10]=f40*sy1; c[11]=0.; c[12]=f40*sy1*f20+f42*sy2*f22+f43*sy3*f23;
516         c[13]=f30*sy1*f40+f32*sy2*f42;
517         c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
518
519         Int_t index=kr1.GetIndex(is);
520         AliTPCseed *track=new AliTPCseed(x1, ns*alpha+shift, x, c, index);
521         Float_t l=fSectors->GetPadPitchWidth();
522         track->SetSampledEdx(kr1[is]->GetQ()/l,0);
523
524         Int_t rc=FollowProlongation(*track, i2);
525         if (rc==0 || track->GetNumberOfClusters()<(i1-i2)/2) delete track;
526         else fSeeds->AddLast(track); 
527       }
528     }
529   }
530 }
531
532 //_____________________________________________________________________________
533 Int_t AliTPCtracker::ReadSeeds(const TFile *inp) {
534   //-----------------------------------------------------------------
535   // This function reades track seeds.
536   //-----------------------------------------------------------------
537   TDirectory *savedir=gDirectory; 
538
539   TFile *in=(TFile*)inp;
540   if (!in->IsOpen()) {
541      Error("ReadSeeds","Input file has not been open !");
542      return 1;
543   }
544
545   in->cd();
546   TTree *seedTree=(TTree*)in->Get("Seeds");
547   if (!seedTree) {
548      Error("ReadSeeds","Can't get a tree with track seeds !");
549      return 2;
550   }
551   AliTPCtrack *seed=new AliTPCtrack; 
552   seedTree->SetBranchAddress("tracks",&seed);
553   
554   if (fSeeds==0) fSeeds=new TObjArray(15000);
555
556   Int_t n=(Int_t)seedTree->GetEntries();
557   for (Int_t i=0; i<n; i++) {
558      seedTree->GetEvent(i);
559      seed->ResetClusters();
560      fSeeds->AddLast(new AliTPCseed(*seed));
561   }
562   
563   delete seed;
564
565   delete seedTree; //Thanks to Mariana Bondila
566
567   savedir->cd();
568
569   return 0;
570 }
571
572 //_____________________________________________________________________________
573 Int_t AliTPCtracker::Clusters2Tracks(AliESDEvent *event) {
574   //-----------------------------------------------------------------
575   // This is a track finder.
576   // The clusters must be already loaded ! 
577   //-----------------------------------------------------------------
578
579   //find track seeds
580   Int_t nup=fOuterSec->GetNRows(), nlow=fInnerSec->GetNRows();
581   Int_t nrows=nlow+nup;
582   if (fSeeds==0) {
583      Int_t gap=Int_t(0.125*nrows), shift=Int_t(0.5*gap);
584      fSectors=fOuterSec; fN=fkNOS;
585      fSeeds=new TObjArray(15000);
586      MakeSeeds(nup-1, nup-1-gap);
587      MakeSeeds(nup-1-shift, nup-1-shift-gap);
588   }
589   fSeeds->Sort();
590
591   Int_t nseed=fSeeds->GetEntriesFast();
592   for (Int_t i=0; i<nseed; i++) {
593     //tracking in the outer sectors
594     fSectors=fOuterSec; fN=fkNOS;
595
596     AliTPCseed *pt=(AliTPCseed*)fSeeds->UncheckedAt(i), &t=*pt;
597     if (!FollowProlongation(t)) {
598        delete fSeeds->RemoveAt(i);
599        continue;
600     }
601
602     //tracking in the inner sectors
603     fSectors=fInnerSec; fN=fkNIS;
604
605     Double_t alpha=t.GetAlpha() - fInnerSec->GetAlphaShift();
606     if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
607     if (alpha < 0.            ) alpha += 2.*TMath::Pi();
608     Int_t ns=Int_t(alpha/fInnerSec->GetAlpha())%fkNIS;
609
610     alpha=ns*fInnerSec->GetAlpha()+fInnerSec->GetAlphaShift()-t.GetAlpha();
611
612     if (t.Rotate(alpha)) {
613       if (FollowProlongation(t)) {
614         if (t.GetNumberOfClusters() >= Int_t(0.4*nrows)) {
615           t.CookdEdx();
616           CookLabel(pt,0.1); //For comparison only
617           pt->PropagateTo(fParam->GetInnerRadiusLow());
618           AliESDtrack iotrack;
619           iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin);
620
621           event->AddTrack(&iotrack);
622
623           UseClusters(&t);
624         }
625       }
626     }
627     delete fSeeds->RemoveAt(i);
628   }
629
630   Info("Clusters2Tracks","Number of found tracks : %d",
631        event->GetNumberOfTracks());
632
633   fSeeds->Clear(); delete fSeeds; fSeeds=0;
634
635   return 0;
636 }
637
638 //_____________________________________________________________________________
639 Int_t AliTPCtracker::RefitInward(AliESDEvent* event) {
640   //
641   // The function propagates tracks throught TPC inward
642   // using already associated clusters.
643   // The clusters must be already loaded !
644   //
645
646   Int_t nTracks = event->GetNumberOfTracks();
647   Int_t nRefited = 0;
648
649   for (Int_t i = 0; i < nTracks; i++) {
650     AliESDtrack* track = event->GetTrack(i);
651     ULong_t status = track->GetStatus();
652
653     if ( (status & AliESDtrack::kTPCrefit) != 0 ) continue;    
654     if ( (status & AliESDtrack::kTPCout ) == 0 ) continue;
655
656     if ( (status & AliESDtrack::kTRDout ) != 0 ) 
657       if ( (status & AliESDtrack::kTRDrefit ) == 0 ) continue;
658
659     AliTPCtrack* tpcTrack = new AliTPCtrack(*track);
660     AliTPCseed* seed=new AliTPCseed(*tpcTrack); seed->ResetClusters(); 
661
662     if ( (status & AliESDtrack::kTRDrefit) == 0 ) seed->ResetCovariance(10.);
663
664     fSectors = fOuterSec;
665
666     Int_t res = FollowRefitInward(seed, tpcTrack);
667     UseClusters(seed);
668     Int_t nc = seed->GetNumberOfClusters();
669
670     fSectors = fInnerSec;
671
672     res = FollowRefitInward(seed, tpcTrack);
673     UseClusters(seed, nc);
674
675     if (res) {
676       seed->PropagateTo(fParam->GetInnerRadiusLow());
677       seed->SetLabel(tpcTrack->GetLabel());
678       seed->SetdEdx(tpcTrack->GetdEdx());
679       track->UpdateTrackParams(seed, AliESDtrack::kTPCrefit);
680       nRefited++;
681     }
682
683     delete seed;
684     delete tpcTrack;
685   }
686
687   Info("RefitInward","Number of refitted tracks : %d",nRefited);
688
689   return 0;
690 }
691
692 Int_t AliTPCtracker::PropagateBack(AliESDEvent *event) {
693   //-----------------------------------------------------------------
694   // This function propagates tracks back through the TPC.
695   // The clusters must be already loaded !
696   //-----------------------------------------------------------------
697   Int_t nentr=event->GetNumberOfTracks();
698   Info("PropagateBack", "Number of ESD tracks: %d\n", nentr);
699
700   Int_t ntrk=0;
701   for (Int_t i=0; i<nentr; i++) {
702     AliESDtrack *esd=event->GetTrack(i);
703     ULong_t status=esd->GetStatus();
704
705     if ( (status & AliESDtrack::kTPCin ) == 0 ) continue;
706     if ( (status & AliESDtrack::kTPCout) != 0 ) continue;
707     if ( (status & AliESDtrack::kITSin) != 0 )
708        if ( (status & AliESDtrack::kITSout) == 0 ) continue;
709
710     const AliTPCtrack t(*esd);
711     AliTPCseed s(t); s.ResetClusters();
712
713     if ( (status & AliESDtrack::kITSout) == 0 ) s.ResetCovariance(10.);
714
715     //inner sectors
716     fSectors=fInnerSec; fN=fkNIS;
717
718     Double_t alpha=s.GetAlpha() - fSectors->GetAlphaShift();
719     if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
720     if (alpha < 0.            ) alpha += 2.*TMath::Pi();
721     Int_t ns=Int_t(alpha/fSectors->GetAlpha())%fN;
722     alpha =ns*fSectors->GetAlpha() + fSectors->GetAlphaShift();
723     alpha-=s.GetAlpha();
724
725     if (!s.Rotate(alpha)) continue;
726     if (!FollowBackProlongation(s,t)) continue;
727
728     UseClusters(&s);
729
730     //outer sectors
731     fSectors=fOuterSec; fN=fkNOS;
732
733     Int_t nc=s.GetNumberOfClusters();
734
735     alpha=s.GetAlpha() - fSectors->GetAlphaShift();
736     if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
737     if (alpha < 0.            ) alpha += 2.*TMath::Pi();
738     ns=Int_t(alpha/fSectors->GetAlpha())%fN;
739
740     alpha =ns*fSectors->GetAlpha() + fSectors->GetAlphaShift();
741     alpha-=s.GetAlpha();
742
743     if (!s.Rotate(alpha)) continue;
744     if (!FollowBackProlongation(s,t)) continue;
745     {
746     Int_t nrows=fOuterSec->GetNRows()+fInnerSec->GetNRows();
747     if (s.GetNumberOfClusters() < Int_t(0.4*nrows)) continue;
748     }
749     s.PropagateTo(fParam->GetOuterRadiusUp());
750     s.CookdEdx();
751     CookLabel(&s,0.1); //For comparison only
752     UseClusters(&s,nc);
753     esd->UpdateTrackParams(&s,AliESDtrack::kTPCout);
754     ntrk++;
755   }
756   Info("PropagateBack","Number of back propagated tracks: %d",ntrk);
757
758   return 0;
759 }
760
761 //_________________________________________________________________________
762 AliCluster *AliTPCtracker::GetCluster(Int_t index) const {
763   //--------------------------------------------------------------------
764   //       Return pointer to a given cluster
765   //--------------------------------------------------------------------
766   Int_t sec=(index&0xff000000)>>24; 
767   Int_t row=(index&0x00ff0000)>>16; 
768   Int_t ncl=(index&0x0000ffff)>>00;
769
770   const AliTPCcluster *cl=0;
771
772   if (sec<fkNIS) {
773     cl=fInnerSec[sec][row].GetUnsortedCluster(ncl); 
774   } else {
775     sec-=fkNIS;
776     cl=fOuterSec[sec][row].GetUnsortedCluster(ncl);
777   }
778
779   return (AliCluster*)cl;      
780 }
781
782 //__________________________________________________________________________
783 void AliTPCtracker::CookLabel(AliKalmanTrack *t, Float_t wrong) const {
784   //--------------------------------------------------------------------
785   //This function "cooks" a track label. If label<0, this track is fake.
786   //--------------------------------------------------------------------
787   Int_t noc=t->GetNumberOfClusters();
788   Int_t *lb=new Int_t[noc];
789   Int_t *mx=new Int_t[noc];
790   AliCluster **clusters=new AliCluster*[noc];
791
792   Int_t i;
793   for (i=0; i<noc; i++) {
794      lb[i]=mx[i]=0;
795      Int_t index=t->GetClusterIndex(i);
796      clusters[i]=GetCluster(index);
797   }
798
799   Int_t lab=123456789;
800   for (i=0; i<noc; i++) {
801     AliCluster *c=clusters[i];
802     lab=TMath::Abs(c->GetLabel(0));
803     Int_t j;
804     for (j=0; j<noc; j++) if (lb[j]==lab || mx[j]==0) break;
805     lb[j]=lab;
806     (mx[j])++;
807   }
808
809   Int_t max=0;
810   for (i=0; i<noc; i++) if (mx[i]>max) {max=mx[i]; lab=lb[i];}
811     
812   for (i=0; i<noc; i++) {
813     AliCluster *c=clusters[i];
814     if (TMath::Abs(c->GetLabel(1)) == lab ||
815         TMath::Abs(c->GetLabel(2)) == lab ) max++;
816   }
817
818   if ((1.- Float_t(max)/noc) > wrong) lab=-lab;
819
820   else {
821      Int_t tail=Int_t(0.10*noc);
822      max=0;
823      for (i=1; i<=tail; i++) {
824        AliCluster *c=clusters[noc-i];
825        if (lab == TMath::Abs(c->GetLabel(0)) ||
826            lab == TMath::Abs(c->GetLabel(1)) ||
827            lab == TMath::Abs(c->GetLabel(2))) max++;
828      }
829      if (max < Int_t(0.5*tail)) lab=-lab;
830   }
831
832   t->SetLabel(lab);
833
834   delete[] lb;
835   delete[] mx;
836   delete[] clusters;
837 }
838
839 //_________________________________________________________________________
840 void AliTPCtracker::AliTPCSector::Setup(const AliTPCParam *par, Int_t f) {
841   //-----------------------------------------------------------------------
842   // Setup inner sector
843   //-----------------------------------------------------------------------
844   if (f==0) {
845      fAlpha=par->GetInnerAngle();
846      fAlphaShift=par->GetInnerAngleShift();
847      fPadPitchWidth=par->GetInnerPadPitchWidth();
848      f1PadPitchLength=par->GetInnerPadPitchLength();
849      f2PadPitchLength=f1PadPitchLength;
850
851      fN=par->GetNRowLow();
852      fRow=new AliTPCRow[fN];
853      for (Int_t i=0; i<fN; i++) fRow[i].SetX(par->GetPadRowRadiiLow(i));
854   } else {
855      fAlpha=par->GetOuterAngle();
856      fAlphaShift=par->GetOuterAngleShift();
857      fPadPitchWidth=par->GetOuterPadPitchWidth();
858      f1PadPitchLength=par->GetOuter1PadPitchLength();
859      f2PadPitchLength=par->GetOuter2PadPitchLength();
860
861      fN=par->GetNRowUp();
862      fRow=new AliTPCRow[fN];
863      for (Int_t i=0; i<fN; i++){ 
864      fRow[i].SetX(par->GetPadRowRadiiUp(i));
865      }
866   } 
867 }
868
869 //_________________________________________________________________________
870 void AliTPCtracker::
871 AliTPCRow::InsertCluster(const AliTPCcluster* c, Int_t sec, Int_t row) {
872   //-----------------------------------------------------------------------
873   // Insert a cluster into this pad row in accordence with its y-coordinate
874   //-----------------------------------------------------------------------
875   if (fN==kMaxClusterPerRow) {
876      ::Error("InsertCluster","Too many clusters !"); 
877      return;
878   }
879
880   Int_t index=(((sec<<8)+row)<<16)+fN;
881
882   if (fN==0) {
883      fSize=kMaxClusterPerRow/8;
884      fClusterArray=new AliTPCcluster[fSize];
885      fIndex[0]=index;
886      fClusterArray[0]=*c; fClusters[fN++]=fClusterArray; 
887      return;
888   }
889
890   if (fN==fSize) {
891      Int_t size=fSize*2;
892      AliTPCcluster *buff=new AliTPCcluster[size];
893      memcpy(buff,fClusterArray,fSize*sizeof(AliTPCcluster));
894      for (Int_t i=0; i<fN; i++) 
895         fClusters[i]=buff+(fClusters[i]-fClusterArray);
896      delete[] fClusterArray;
897      fClusterArray=buff;
898      fSize=size;
899   }
900
901   Int_t i=Find(c->GetY());
902   memmove(fClusters+i+1 ,fClusters+i,(fN-i)*sizeof(AliTPCcluster*));
903   memmove(fIndex   +i+1 ,fIndex   +i,(fN-i)*sizeof(UInt_t));
904   fIndex[i]=index; 
905   fClusters[i]=fClusterArray+fN; fClusterArray[fN++]=*c;
906 }
907
908 //___________________________________________________________________
909 Int_t AliTPCtracker::AliTPCRow::Find(Double_t y) const {
910   //-----------------------------------------------------------------------
911   // Return the index of the nearest cluster 
912   //-----------------------------------------------------------------------
913   if(fN<=0) return 0;
914   if (y <= fClusters[0]->GetY()) return 0;
915   if (y > fClusters[fN-1]->GetY()) return fN;
916   Int_t b=0, e=fN-1, m=(b+e)/2;
917   for (; b<e; m=(b+e)/2) {
918     if (y > fClusters[m]->GetY()) b=m+1;
919     else e=m; 
920   }
921   return m;
922 }
923
924 //_____________________________________________________________________________
925 void AliTPCtracker::AliTPCseed::CookdEdx(Double_t low, Double_t up) {
926   //-----------------------------------------------------------------
927   // This funtion calculates dE/dX within the "low" and "up" cuts.
928   //-----------------------------------------------------------------
929   Int_t i;
930   Int_t nc=GetNumberOfClusters();
931
932   Int_t swap;//stupid sorting
933   do {
934     swap=0;
935     for (i=0; i<nc-1; i++) {
936       if (fdEdxSample[i]<=fdEdxSample[i+1]) continue;
937       Float_t tmp=fdEdxSample[i];
938       fdEdxSample[i]=fdEdxSample[i+1]; fdEdxSample[i+1]=tmp;
939       swap++;
940     }
941   } while (swap);
942
943   Int_t nl=Int_t(low*nc), nu=Int_t(up*nc);
944   Float_t dedx=0;
945   for (i=nl; i<=nu; i++) dedx += fdEdxSample[i];
946   dedx /= (nu-nl+1);
947   SetdEdx(dedx);
948
949   return;
950 }
951
952
953