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 }