bug fix
[u/mrichter/AliRoot.git] / HLT / TPCLib / tracking-ca / AliTPCtrackerCA.cxx
1 // $Id$
2 // **************************************************************************
3 // This file is property of and copyright by the ALICE HLT Project          * 
4 // ALICE Experiment at CERN, All rights reserved.                           *
5 //                                                                          *
6 // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
7 //                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
8 //                  for The ALICE HLT Project.                              *
9 //                                                                          *
10 // Permission to use, copy, modify and distribute this software and its     *
11 // documentation strictly for non-commercial purposes is hereby granted     *
12 // without fee, provided that the above copyright notice appears in all     *
13 // copies and that both the copyright notice and this permission notice     *
14 // appear in the supporting documentation. The authors make no claims       *
15 // about the suitability of this software for any purpose. It is            *
16 // provided "as is" without express or implied warranty.                    *
17 //                                                                          *
18 //***************************************************************************
19
20 #include "AliTPCtrackerCA.h"
21
22 #include "TTree.h"
23 #include "Riostream.h"
24 //#include "AliCluster.h"
25 #include "AliTPCClustersRow.h"
26 #include "AliTPCParam.h"
27 #include "AliTPCClusterParam.h"
28
29 #include "AliRun.h"
30 #include "AliRunLoader.h"
31 #include "AliStack.h"
32
33 #include "AliHLTTPCCAGBTracker.h"
34 #include "AliHLTTPCCAGBHit.h"
35 #include "AliHLTTPCCAGBTrack.h"
36 #include "AliHLTTPCCAPerformance.h"
37 #include "AliHLTTPCCAParam.h"
38 #include "AliHLTTPCCATrackConvertor.h"
39 #include "AliHLTTPCCATracker.h"
40
41 #include "TMath.h"
42 #include "AliTPCLoader.h"
43 #include "AliTPC.h"
44 #include "AliTPCclusterMI.h"
45 #include "AliTPCTransform.h"
46 #include "AliTPCcalibDB.h"
47 #include "AliTPCtrack.h"
48 #include "AliTPCseed.h"
49 #include "AliESDtrack.h"
50 #include "AliESDEvent.h"
51 #include "AliTrackReference.h"
52 #include "TStopwatch.h"
53
54 //#include <fstream.h>
55
56 ClassImp(AliTPCtrackerCA)
57
58 AliTPCtrackerCA::AliTPCtrackerCA()
59   :AliTracker(),fkParam(0), fClusters(0), fNClusters(0), fHLTTracker(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
60 {
61   //* default constructor
62 }
63
64 AliTPCtrackerCA::AliTPCtrackerCA(const AliTPCtrackerCA &):
65   AliTracker(),fkParam(0), fClusters(0), fNClusters(0), fHLTTracker(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
66 {
67   //* dummy
68 }
69
70 const AliTPCtrackerCA & AliTPCtrackerCA::operator=(const AliTPCtrackerCA& ) const
71 {
72   //* dummy 
73   return *this;
74 }
75
76
77 AliTPCtrackerCA::~AliTPCtrackerCA() 
78 {
79   //* destructor
80   if( fClusters ) delete[] fClusters;
81   if( fHLTTracker ) delete fHLTTracker;
82 }
83
84 //#include "AliHLTTPCCADisplay.h"
85
86 AliTPCtrackerCA::AliTPCtrackerCA(const AliTPCParam *par): 
87   AliTracker(),fkParam(par), fClusters(0), fNClusters(0), fHLTTracker(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
88 {
89   //* constructor
90  
91   fDoHLTPerformance = 0;
92   fDoHLTPerformanceClusters = 0;
93
94   fHLTTracker = new AliHLTTPCCAGBTracker;
95   fHLTTracker->SetNSlices( fkParam->GetNSector()/2 );
96
97   if( fDoHLTPerformance ){
98     AliHLTTPCCAPerformance::Instance().SetTracker( fHLTTracker );
99   }
100
101   for( Int_t iSlice=0; iSlice<fHLTTracker->NSlices(); iSlice++ ){
102   
103     Float_t bz = AliTracker::GetBz();
104
105     Float_t inRmin = fkParam->GetInnerRadiusLow();
106     //Float_t inRmax = fkParam->GetInnerRadiusUp();
107     //Float_t outRmin = fkParam->GetOuterRadiusLow(); 
108     Float_t outRmax = fkParam->GetOuterRadiusUp();
109     Float_t plusZmin = 0.0529937; 
110     Float_t plusZmax = 249.778; 
111     Float_t minusZmin = -249.645; 
112     Float_t minusZmax = -0.0799937; 
113     Float_t dalpha = 0.349066;
114     Float_t alpha = 0.174533 + dalpha*iSlice;
115     
116     Bool_t zPlus = (iSlice<18 );
117     Float_t zMin =  zPlus ?plusZmin :minusZmin;
118     Float_t zMax =  zPlus ?plusZmax :minusZmax;
119     //TPCZmin = -249.645, ZMax = 249.778    
120     //Float_t rMin =  inRmin;
121     //Float_t rMax =  outRmax;
122         
123     Float_t padPitch = 0.4;
124     Float_t sigmaZ = 0.228808;
125
126     Int_t nRows = fkParam->GetNRowLow()+fkParam->GetNRowUp();
127     Float_t rowX[200];
128     for( Int_t irow=0; irow<fkParam->GetNRowLow(); irow++){
129       rowX[irow] = fkParam->GetPadRowRadiiLow(irow);
130     }     
131     for( Int_t irow=0; irow<fkParam->GetNRowUp(); irow++){
132       rowX[fkParam->GetNRowLow()+irow] = fkParam->GetPadRowRadiiUp(irow);
133     }
134     AliHLTTPCCAParam param;
135     param.Initialize( iSlice, nRows, rowX, alpha, dalpha,
136                       inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, bz );
137     param.SetHitPickUpFactor( 1. );
138     param.SetMaxTrackMatchDRow( 5 );
139     param.SetTrackConnectionFactor( 3.5 );
140
141     AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam();
142     for( Int_t iRow=0; iRow<nRows; iRow++ ){
143       Int_t    type = (iRow<63) ? 0: ( (iRow>126) ? 1:2 );
144       for( int iyz=0; iyz<2; iyz++ ){
145         for( int k=0; k<7; k++ ){
146           //std::cout<<param.fParamS0Par[iyz][type][k]<<" "<<clparam->fParamS0Par[iyz][type][k] - param.fParamS0Par[iyz][type][k]<<std::endl;
147           param.SetParamS0Par(iyz,type,k,clparam->fParamS0Par[iyz][type][k]);
148         }
149       }
150     }
151     fHLTTracker->Slices()[iSlice].Initialize( param ); 
152   }
153 }
154
155
156
157 Int_t AliTPCtrackerCA::LoadClusters (TTree * fromTree)
158
159   // load clusters to the local arrays
160   fNClusters = 0;
161   if( fClusters ) delete[] fClusters;
162
163   fHLTTracker->StartEvent();
164   if( fDoHLTPerformance ) AliHLTTPCCAPerformance::Instance().StartEvent();
165
166   if( !fkParam ) return 1;
167
168   // load mc tracks
169   while( fDoHLTPerformance ){
170     if( !gAlice ) break;
171     AliRunLoader *rl = AliRunLoader::Instance();//gAlice->GetRunLoader(); 
172     if( !rl ) break;
173     rl->LoadKinematics();
174     AliStack *stack = rl->Stack();
175     if( !stack ) break;
176
177     AliHLTTPCCAPerformance::Instance().SetNMCTracks( stack->GetNtrack() );
178     
179     for( Int_t itr=0; itr<stack->GetNtrack(); itr++ ){
180       TParticle *part = stack->Particle(itr);
181       AliHLTTPCCAPerformance::Instance().ReadMCTrack( itr, part );
182     }
183
184     { // check for MC tracks at the TPC entrance
185
186       Bool_t *isTPC = 0;
187       isTPC = new Bool_t [stack->GetNtrack()];
188       for( Int_t i=0; i<stack->GetNtrack(); i++ ) isTPC[i] = 0;
189       rl->LoadTrackRefs();
190       TTree *mcTree = rl->TreeTR();
191       if( !mcTree ) break;
192       TBranch *branch=mcTree->GetBranch("TrackReferences");
193       if (!branch ) break;      
194       TClonesArray tpcdummy("AliTrackReference",1000), *tpcRefs=&tpcdummy;
195       branch->SetAddress(&tpcRefs);
196       Int_t nr=(Int_t)mcTree->GetEntries();
197       for (Int_t r=0; r<nr; r++) {
198         mcTree->GetEvent(r);
199         Int_t nref = tpcRefs->GetEntriesFast();
200         if (!nref) continue;
201         AliTrackReference *tpcRef= 0x0;  
202         for (Int_t iref=0; iref<nref; ++iref) {
203           tpcRef = (AliTrackReference*)tpcRefs->UncheckedAt(iref);
204           if (tpcRef->DetectorId() == AliTrackReference::kTPC) break;
205           tpcRef = 0x0;
206         }
207         if (!tpcRef) continue;
208
209         if( isTPC[tpcRef->Label()] ) continue;  
210
211         AliHLTTPCCAPerformance::Instance().ReadMCTPCTrack(tpcRef->Label(),
212                                         tpcRef->X(),tpcRef->Y(),tpcRef->Z(),
213                                         tpcRef->Px(),tpcRef->Py(),tpcRef->Pz() );
214         isTPC[tpcRef->Label()] = 1;
215         tpcRefs->Clear();
216       } 
217       if( isTPC ) delete[] isTPC;
218     }
219
220     while( fDoHLTPerformanceClusters ){
221       AliTPCLoader *tpcl = (AliTPCLoader*) rl->GetDetectorLoader("TPC");
222       if( !tpcl ) break;
223       if( tpcl->TreeH() == 0x0 ){
224         if( tpcl->LoadHits() ) break;
225       }
226       if( tpcl->TreeH() == 0x0 ) break;
227       
228       AliTPC *tpc = (AliTPC*) gAlice->GetDetector("TPC");
229       Int_t nEnt=(Int_t)tpcl->TreeH()->GetEntries();
230       Int_t nPoints = 0;
231       for (Int_t iEnt=0; iEnt<nEnt; iEnt++) {    
232         tpc->ResetHits();
233         tpcl->TreeH()->GetEvent(iEnt);
234         AliTPChit *phit = (AliTPChit*)tpc->FirstHit(-1);
235         for ( ; phit; phit=(AliTPChit*)tpc->NextHit() ) nPoints++;
236       }
237       AliHLTTPCCAPerformance::Instance().SetNMCPoints( nPoints );
238
239       for (Int_t iEnt=0; iEnt<nEnt; iEnt++) {    
240         tpc->ResetHits();
241         tpcl->TreeH()->GetEvent(iEnt);
242         AliTPChit *phit = (AliTPChit*)tpc->FirstHit(-1);
243         for ( ; phit; phit=(AliTPChit*)tpc->NextHit() ){
244           AliHLTTPCCAPerformance::Instance().ReadMCPoint( phit->GetTrack(),phit->X(), phit->Y(),phit->Z(),phit->Time(), phit->fSector%36);
245         }      
246       }
247       break;
248     }
249     break;
250   }
251   
252   TBranch * br = fromTree->GetBranch("Segment");
253   if( !br ) return 1;
254
255   AliTPCClustersRow *clrow = new AliTPCClustersRow;
256   clrow->SetClass("AliTPCclusterMI");
257   clrow->SetArray(0);
258   clrow->GetArray()->ExpandCreateFast(10000);
259   
260   br->SetAddress(&clrow);
261   
262   //
263   Int_t nEnt=Int_t(fromTree->GetEntries());
264
265   fNClusters = 0;
266   for (Int_t i=0; i<nEnt; i++) {
267     br->GetEntry(i);
268     Int_t sec,row;
269     fkParam->AdjustSectorRow(clrow->GetID(),sec,row);
270     fNClusters += clrow->GetArray()->GetEntriesFast();
271   }
272
273   fClusters = new AliTPCclusterMI [fNClusters];
274   fHLTTracker->SetNHits( fNClusters );
275   if( fDoHLTPerformance ) AliHLTTPCCAPerformance::Instance().SetNHits( fNClusters );
276   Int_t ind=0;
277   for (Int_t i=0; i<nEnt; i++) {
278     br->GetEntry(i);
279     Int_t sec,row;
280     fkParam->AdjustSectorRow(clrow->GetID(),sec,row);
281     Int_t nClu = clrow->GetArray()->GetEntriesFast();
282     Float_t x = fkParam->GetPadRowRadii(sec,row);
283     for (Int_t icl=0; icl<nClu; icl++){
284       Int_t lab0 = -1;
285       Int_t lab1 = -1;
286       Int_t lab2 = -1;
287       AliTPCclusterMI* cluster = (AliTPCclusterMI*)(clrow->GetArray()->At(icl));
288       if( !cluster ) continue;
289       lab0 = cluster->GetLabel(0);
290       lab1 = cluster->GetLabel(1);
291       lab2 = cluster->GetLabel(2);
292
293       AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
294       if (!transform) {
295         AliFatal("Tranformations not in calibDB");
296       }
297       Double_t xx[3]={cluster->GetRow(),cluster->GetPad(),cluster->GetTimeBin()};
298       Int_t id[1]={cluster->GetDetector()};
299       transform->Transform(xx,id,0,1);  
300       //if (!AliTPCReconstructor::GetRecoParam()->GetBYMirror()){
301       //if (cluster->GetDetector()%36>17){
302       //xx[1]*=-1;
303       //}
304       //}
305
306       cluster->SetX(xx[0]);
307       cluster->SetY(xx[1]);
308       cluster->SetZ(xx[2]);
309
310       TGeoHMatrix  *mat = fkParam->GetClusterMatrix(cluster->GetDetector());
311       Double_t pos[3]= {cluster->GetX(),cluster->GetY(),cluster->GetZ()};
312       Double_t posC[3]={cluster->GetX(),cluster->GetY(),cluster->GetZ()};
313       if (mat) mat->LocalToMaster(pos,posC);
314       else{
315         // chack Loading of Geo matrices from GeoManager - TEMPORARY FIX
316       }
317       cluster->SetX(posC[0]);
318       cluster->SetY(posC[1]);
319       cluster->SetZ(posC[2]);
320
321       Float_t y = cluster->GetY();
322       Float_t z = cluster->GetZ();        
323
324       if( sec>=36 ){
325         sec = sec - 36;
326         row = row + fkParam->GetNRowLow(); 
327       }
328       
329       Int_t index = ind++;
330       fClusters[index] = *cluster;
331       fHLTTracker->ReadHit( x, y, z, 
332                             TMath::Sqrt(cluster->GetSigmaY2()), TMath::Sqrt(cluster->GetSigmaZ2()),                         
333                             cluster->GetMax(), index, sec, row );
334       if( fDoHLTPerformance ) AliHLTTPCCAPerformance::Instance().ReadHitLabel(index, lab0, lab1, lab2 );
335     }
336   }
337   delete clrow;
338   return 0;
339 }
340
341 AliCluster * AliTPCtrackerCA::GetCluster(Int_t index) const
342 {
343   return &(fClusters[index]);
344 }
345
346 Int_t AliTPCtrackerCA::Clusters2Tracks( AliESDEvent *event )
347 {
348   // reconstruction
349   //cout<<"Start of AliTPCtrackerCA"<<endl;
350   TStopwatch timer;
351
352   fHLTTracker->FindTracks();
353   //cout<<"Do performance.."<<endl;
354   if( fDoHLTPerformance ) AliHLTTPCCAPerformance::Instance().Performance();
355
356   if( 0 ) {// Write Event    
357     if( fStatNEvents == 0 ){
358       fstream geo;
359       geo.open("CAEvents/settings.dat", ios::out);
360       if( geo.is_open() ){
361         fHLTTracker->WriteSettings(geo);        
362       }
363       geo.close();
364     }
365
366     fstream hits;
367     char name[255];
368     sprintf( name,"CAEvents/%i.event.dat",fStatNEvents ); 
369     hits.open(name, ios::out);
370     if( hits.is_open() ){
371       fHLTTracker->WriteEvent(hits);    
372       fstream tracks;
373       sprintf( name,"CAEvents/%i.tracks.dat",fStatNEvents ); 
374       tracks.open(name, ios::out);
375       fHLTTracker->WriteTracks(tracks); 
376     }
377     hits.close();   
378     if( fDoHLTPerformance ){
379       fstream mcevent, mcpoints;
380       char mcname[255];
381       sprintf( mcname,"CAEvents/%i.mcevent.dat",fStatNEvents ); 
382       mcevent.open(mcname, ios::out);
383       if( mcevent.is_open() ){      
384         AliHLTTPCCAPerformance::Instance().WriteMCEvent(mcevent);
385       }
386       if(1 && fDoHLTPerformanceClusters ){
387         sprintf( mcname,"CAEvents/%i.mcpoints.dat",fStatNEvents ); 
388         mcpoints.open(mcname, ios::out);
389         if( mcpoints.is_open() ){      
390           AliHLTTPCCAPerformance::Instance().WriteMCPoints(mcpoints);
391         }
392         mcpoints.close();
393       }
394       mcevent.close();   
395     }
396   }
397   fStatNEvents++;
398
399   if( event ){
400    
401     Float_t bz = fHLTTracker->Slices()[0].Param().Bz();
402
403     for( Int_t itr=0; itr<fHLTTracker->NTracks(); itr++ ){
404       //AliTPCtrack tTPC;
405       AliTPCseed tTPC;
406       AliHLTTPCCAGBTrack &tCA = fHLTTracker->Tracks()[itr];
407       AliHLTTPCCATrackParam par = tCA.Param();  
408       AliHLTTPCCATrackConvertor::GetExtParam( par, tTPC, tCA.Alpha(), bz );
409       tTPC.SetMass(0.13957);
410       tTPC.SetdEdx( tCA.DeDx() );
411       if( TMath::Abs(tTPC.GetSigned1Pt())>1./0.02 ) continue;
412       Int_t nhits = tCA.NHits();
413       Int_t firstHit=0;
414       if( nhits>160 ){
415         firstHit = nhits-160;
416         nhits=160;
417       }
418
419       tTPC.SetNumberOfClusters(nhits);
420  
421       Float_t alpha = tCA.Alpha();      
422       AliHLTTPCCATrackParam t0 = par;
423       for( Int_t ih=0; ih<nhits; ih++ ){
424         Int_t index = fHLTTracker->TrackHits()[tCA.FirstHitRef()+firstHit+ih];
425         AliHLTTPCCAGBHit &h = fHLTTracker->Hits()[index];
426         Int_t extIndex = h.ID();
427         tTPC.SetClusterIndex(ih, extIndex);
428                 
429           AliTPCclusterMI *c = &(fClusters[extIndex]);
430           tTPC.SetClusterPointer(h.IRow(), c );
431           AliTPCTrackerPoint &point = *(tTPC.GetTrackPoint(h.IRow()));
432           {
433             Int_t iSlice = h.ISlice();
434             AliHLTTPCCATracker &slice = fHLTTracker->Slices()[iSlice];
435             if( slice.Param().Alpha()!=alpha ){
436               if( ! t0.Rotate(  slice.Param().Alpha() - alpha, .999 ) ) continue;
437               alpha = slice.Param().Alpha();
438             }
439             Float_t x = slice.Row(h.IRow()).X();
440             if( !t0.TransportToX( x, .999 ) ) continue;
441             Float_t sy2, sz2;
442             slice.GetErrors2( h.IRow(), t0, sy2, sz2 );
443             point.SetSigmaY(c->GetSigmaY2()/sy2);
444             point.SetSigmaZ(c->GetSigmaZ2()/sz2);
445             point.SetAngleY(TMath::Abs(t0.GetSinPhi()/t0.GetCosPhi()));
446             point.SetAngleZ(TMath::Abs(t0.GetDzDs()));  
447           }
448         
449         }
450       tTPC.CookdEdx(0.02,0.6);
451
452       CookLabel(&tTPC,0.1);           
453
454       AliESDtrack tESD;
455       tESD.UpdateTrackParams( &(tTPC),AliESDtrack::kTPCin);
456       //tESD.SetStatus( AliESDtrack::kTPCrefit );
457       //tESD.SetTPCPoints(tTPC.GetPoints());
458       Int_t   ndedx = tTPC.GetNCDEDX(0);
459       Float_t sdedx = tTPC.GetSDEDX(0);
460       Float_t dedx  = tTPC.GetdEdx();
461       tESD.SetTPCsignal(dedx, sdedx, ndedx); 
462       //tESD.myTPC = tTPC;            
463
464       event->AddTrack(&tESD);
465     }
466   }
467   timer.Stop();
468   static double time=0, time1 = 0;
469   static Int_t ncalls = 0;
470   time+=timer.CpuTime();
471   time1+=timer.RealTime();
472   ncalls++;
473   //cout<<"\n\nCA tracker speed: cpu = "<<time/ncalls*1.e3<<" [ms/ev], real = "<<time1/ncalls*1.e3<<" [ms/ev], n calls = "<<ncalls<<endl<<endl;
474
475   //cout<<"End of AliTPCtrackerCA"<<endl;
476   return 0;
477 }
478
479
480 Int_t AliTPCtrackerCA::RefitInward (AliESDEvent *event)
481
482   //* forward propagation of ESD tracks 
483
484   Float_t bz = fHLTTracker->Slices()[0].Param().Bz();
485   Float_t xTPC = fkParam->GetInnerRadiusLow();
486   Float_t dAlpha = fkParam->GetInnerAngle()/180.*TMath::Pi();
487   Float_t yMax = xTPC*TMath::Tan(dAlpha/2.); 
488
489   Int_t nentr=event->GetNumberOfTracks();
490      
491   for (Int_t itr=0; itr<nentr; itr++) {
492     AliESDtrack *esd=event->GetTrack(itr);
493     ULong_t status=esd->GetStatus(); 
494     if (!(status&AliESDtrack::kTPCin)) continue;
495     AliHLTTPCCATrackParam t0;
496     AliHLTTPCCATrackConvertor::SetExtParam(t0,*esd, bz );
497     AliHLTTPCCATrackParam t = t0;
498     Float_t alpha = esd->GetAlpha();
499     Float_t dEdX=0;    
500     Int_t hits[1000];
501     Int_t nHits = esd->GetTPCclusters(hits);
502     
503     // convert clluster indices to AliHLTTPCCAGBHit indices
504
505     for( Int_t i=0; i<nHits; i++ ) hits[i] = fHLTTracker->Ext2IntHitID(hits[i]);
506    
507     Bool_t ok = fHLTTracker->FitTrack( t, t0, alpha, hits, nHits, dEdX, 0 );
508     if( ok &&  nHits>15){
509       if( t.TransportToXWithMaterial( xTPC, bz) ){
510         if (t.GetY() > yMax) {
511           if (t.Rotate(dAlpha)){ 
512             alpha+=dAlpha;  
513             t.TransportToXWithMaterial( xTPC, bz);
514           }
515         } else if (t.GetY() <-yMax) {
516           if (t.Rotate(-dAlpha)){
517             alpha+=-dAlpha;
518             t.TransportToXWithMaterial( xTPC, bz);
519           }
520         }    
521       }
522     
523       AliTPCtrack tt(*esd);
524       AliHLTTPCCATrackConvertor::GetExtParam(t,tt,alpha,bz);
525       esd->UpdateTrackParams( &tt,AliESDtrack::kTPCrefit); 
526     }
527   }
528   return 0;
529 }
530
531 Int_t AliTPCtrackerCA::PropagateBack(AliESDEvent *event)
532
533
534   //* backward propagation of ESD tracks 
535
536   Float_t bz = fHLTTracker->Slices()[0].Param().Bz();
537   Int_t nentr=event->GetNumberOfTracks();
538      
539   for (Int_t itr=0; itr<nentr; itr++) {
540
541     AliESDtrack *esd=event->GetTrack(itr);
542     ULong_t status=esd->GetStatus(); 
543     if (!(status&AliESDtrack::kTPCin)) continue;
544
545     AliHLTTPCCATrackParam t0;
546     AliHLTTPCCATrackConvertor::SetExtParam(t0,*esd, bz );
547     AliHLTTPCCATrackParam t = t0;
548     Float_t alpha = esd->GetAlpha();
549     Float_t dEdX=0;    
550     Int_t hits[1000];
551     Int_t nHits = esd->GetTPCclusters(hits);
552     
553     // convert clluster indices to AliHLTTPCCAGBHit indices
554
555     for( Int_t i=0; i<nHits; i++ ) hits[i] = fHLTTracker->Ext2IntHitID(hits[i]);
556    
557     Bool_t ok = fHLTTracker->FitTrack( t, t0, alpha, hits, nHits, dEdX, 1 );
558     if( ok &&  nHits>15){
559       AliTPCtrack tt(*esd);
560       AliHLTTPCCATrackConvertor::GetExtParam(t,tt,alpha,bz);
561       esd->UpdateTrackParams( &tt,AliESDtrack::kTPCout); 
562     }
563   }
564   return 0;
565 }