HLT/TPCLib/tracking-ca/AliHLTTPCCATrackletConstructor.cxx

   1 // @(#) $Id: AliHLTTPCCATrackletConstructor.cxx 27042 2008-07-02 12:06:02Z richterm $
   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 "AliHLTTPCCATracker.h"
  21 #include "AliHLTTPCCATrackParam.h"
  22 #include "AliHLTTPCCATrackParam.h"
  23 #include "AliHLTTPCCAGrid.h"
  24 #include "AliHLTTPCCAMath.h"
  25 #include "AliHLTTPCCADef.h"
  26 #include "AliHLTTPCCATracklet.h"
  27 #include "AliHLTTPCCATrackletConstructor.h"
  28
  29 #define kMaxRowGap 4
  30
  31 GPUdi() void AliHLTTPCCATrackletConstructor::InitTracklet( AliHLTTPCCATrackParam &tParam )
  32 {
  33   //Initialize Tracklet Parameters using default values
  34   tParam.InitParam();
  35 }
  36
  37 GPUdi() bool AliHLTTPCCATrackletConstructor::CheckCov(AliHLTTPCCATrackParam &tParam)
  38 {
  39       bool ok = 1;
  40       const float *c = tParam.Cov();
  41       for ( int i = 0; i < 15; i++ ) ok = ok && CAMath::Finite( c[i] );
  42       for ( int i = 0; i < 5; i++ ) ok = ok && CAMath::Finite( tParam.Par()[i] );
  43       ok = ok && ( tParam.X() > 50 );
  44           if ( c[0] <= 0 || c[2] <= 0 || c[5] <= 0 || c[9] <= 0 || c[14] <= 0 ) ok = 0;
  45           return(ok);
  46 }
  47
  48
  49 GPUdi() void AliHLTTPCCATrackletConstructor::StoreTracklet
  50 ( int /*nBlocks*/, int /*nThreads*/, int /*iBlock*/, int /*iThread*/,
  51   AliHLTTPCCASharedMemory
  52 #if defined(HLTCA_GPUCODE) | defined(EXTERN_ROW_HITS)
  53   &s
  54 #else
  55   &/*s*/
  56 #endif  //!HLTCA_GPUCODE
  57   , AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam )
  58 {
  59   // reconstruction of tracklets, tracklet store step
  60
  61   do {
  62     if ( r.fNHits < TRACKLET_SELECTOR_MIN_HITS ) {
  63       r.fNHits = 0;
  64       break;
  65     }
  66
  67     if ( 0 ) {
  68       if ( 1. / .5 < CAMath::Abs( tParam.QPt() ) ) { //SG!!!
  69         r.fNHits = 0;
  70         break;
  71       }
  72     }
  73
  74     {
  75           bool ok = CheckCov(tParam);
  76
  77       if ( !ok ) {
  78         r.fNHits = 0;
  79         break;
  80       }
  81     }
  82   } while ( 0 );
  83
  84   if ( !SAVE() ) return;
  85
  86 /*#ifndef HLTCA_GPUCODE
  87   printf("Tracklet %d: Hits %3d NDF %3d Chi %8.4f Sign %f Cov: %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f %2.4f\n", r.fItr, r.fNHits, tParam.GetNDF(), tParam.GetChi2(), tParam.GetSignCosPhi(),
  88           tParam.Cov()[0], tParam.Cov()[1], tParam.Cov()[2], tParam.Cov()[3], tParam.Cov()[4], tParam.Cov()[5], tParam.Cov()[6], tParam.Cov()[7], tParam.Cov()[8], tParam.Cov()[9],
  89           tParam.Cov()[10], tParam.Cov()[11], tParam.Cov()[12], tParam.Cov()[13], tParam.Cov()[14]);
  90 #endif*/
  91
  92   AliHLTTPCCATracklet &tracklet = tracker.Tracklets()[r.fItr];
  93
  94   tracklet.SetNHits( r.fNHits );
  95
  96   if ( r.fNHits > 0 ) {
  97     if ( CAMath::Abs( tParam.Par()[4] ) < 1.e-4 ) tParam.SetPar( 4, 1.e-4 );
  98         if (r.fStartRow < r.fFirstRow) r.fFirstRow = r.fStartRow;
  99         tracklet.SetFirstRow( r.fFirstRow );
 100     tracklet.SetLastRow( r.fLastRow );
 101 #ifdef HLTCA_GPUCODE
 102     tracklet.SetParam( tParam.fParam );
 103 #else
 104     tracklet.SetParam( tParam.GetParam() );
 105 #endif //HLTCA_GPUCODE
 106     int w = tracker.CalculateHitWeight(r.fNHits, tParam.GetChi2(), r.fItr);
 107     tracklet.SetHitWeight(w);
 108     for ( int iRow = r.fFirstRow; iRow <= r.fLastRow; iRow++ ) {
 109 #ifdef EXTERN_ROW_HITS
 110       int ih = tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr];
 111 #else
 112           int ih = tracklet.RowHit( iRow );
 113 #endif //EXTERN_ROW_HITS
 114       if ( ih >= 0 ) {
 115 #if defined(HLTCA_GPUCODE)
 116             tracker.MaximizeHitWeight( s.fRows[ iRow ], ih, w );
 117 #else
 118             tracker.MaximizeHitWeight( tracker.Row( iRow ), ih, w );
 119 #endif //HLTCA_GPUCODE
 120       }
 121     }
 122   }
 123
 124 }
 125
 126 GPUdi() void AliHLTTPCCATrackletConstructor::UpdateTracklet
 127 ( int /*nBlocks*/, int /*nThreads*/, int /*iBlock*/, int /*iThread*/,
 128   AliHLTTPCCASharedMemory
 129 #if defined(HLTCA_GPUCODE) | defined(EXTERN_ROW_HITS)
 130   &s
 131 #else
 132   &/*s*/
 133 #endif //HLTCA_GPUCODE
 134   , AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam, int iRow )
 135 {
 136   // reconstruction of tracklets, tracklets update step
 137
 138   if ( !r.fGo ) return;
 139
 140 #ifndef EXTERN_ROW_HITS
 141   AliHLTTPCCATracklet &tracklet = tracker.Tracklets()[r.fItr];
 142 #endif //EXTERN_ROW_HITS
 143
 144 #if defined(HLTCA_GPUCODE)
 145   const AliHLTTPCCARow &row = s.fRows[iRow];
 146 #else
 147   const AliHLTTPCCARow &row = tracker.Row( iRow );
 148 #endif //HLTCA_GPUCODE
 149
 150   float y0 = row.Grid().YMin();
 151   float stepY = row.HstepY();
 152   float z0 = row.Grid().ZMin();
 153   float stepZ = row.HstepZ();
 154   float stepYi = row.HstepYi();
 155   float stepZi = row.HstepZi();
 156
 157   if ( r.fStage == 0 ) { // fitting part
 158     do {
 159
 160       if ( iRow < r.fStartRow || r.fCurrIH < 0  ) break;
 161       if ( ( iRow - r.fStartRow ) % 2 != 0 )
 162           {
 163 #ifndef EXTERN_ROW_HITS
 164                   tracklet.SetRowHit(iRow, -1);
 165 #else
 166                   tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
 167 #endif //EXTERN_ROW_HITS
 168                   break; // SG!!! - jump over the row
 169           }
 170
 171
 172           ushort2 hh;
 173 #if defined(HLTCA_GPU_TEXTURE_FETCH)
 174           hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + r.fCurrIH);
 175 #else
 176           hh = tracker.HitData(row)[r.fCurrIH];
 177 #endif //HLTCA_GPU_TEXTURE_FETCH
 178
 179       int oldIH = r.fCurrIH;
 180 #if defined(HLTCA_GPU_TEXTURE_FETCH)
 181           r.fCurrIH = tex1Dfetch(gAliTexRefs, ((char*) tracker.Data().HitLinkUpData(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + r.fCurrIH);
 182 #else
 183           r.fCurrIH = tracker.HitLinkUpData(row)[r.fCurrIH]; // read from linkup data
 184 #endif //HLTCA_GPU_TEXTURE_FETCH
 185
 186       float x = row.X();
 187       float y = y0 + hh.x * stepY;
 188       float z = z0 + hh.y * stepZ;
 189
 190       if ( iRow == r.fStartRow ) {
 191         tParam.SetX( x );
 192         tParam.SetY( y );
 193         tParam.SetZ( z );
 194         r.fLastY = y;
 195         r.fLastZ = z;
 196       } else {
 197
 198         float err2Y, err2Z;
 199         float dx = x - tParam.X();
 200         float dy = y - r.fLastY;//tParam.Y();
 201         float dz = z - r.fLastZ;//tParam.Z();
 202         r.fLastY = y;
 203         r.fLastZ = z;
 204
 205         float ri = 1. / CAMath::Sqrt( dx * dx + dy * dy );
 206         if ( iRow == r.fStartRow + 2 ) { //SG!!! important - thanks to Matthias
 207           tParam.SetSinPhi( dy*ri );
 208           tParam.SetSignCosPhi( dx );
 209           tParam.SetDzDs( dz*ri );
 210           //std::cout << "Init. errors... " << r.fItr << std::endl;
 211           tracker.GetErrors2( iRow, tParam, err2Y, err2Z );
 212           //std::cout << "Init. errors = " << err2Y << " " << err2Z << std::endl;
 213           tParam.SetCov( 0, err2Y );
 214           tParam.SetCov( 2, err2Z );
 215         }
 216         float sinPhi, cosPhi;
 217         if ( r.fNHits >= 10 && CAMath::Abs( tParam.SinPhi() ) < .99 ) {
 218           sinPhi = tParam.SinPhi();
 219           cosPhi = CAMath::Sqrt( 1 - sinPhi * sinPhi );
 220         } else {
 221           sinPhi = dy * ri;
 222           cosPhi = dx * ri;
 223         }
 224         if ( !tParam.TransportToX( x, sinPhi, cosPhi, tracker.Param().ConstBz(), -1 ) ) {
 225 #ifndef EXTERN_ROW_HITS
 226           tracklet.SetRowHit( iRow, -1 );
 227 #else
 228                   tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
 229 #endif //EXTERN_ROW_HITS
 230           break;
 231         }
 232         tracker.GetErrors2( iRow, tParam.GetZ(), sinPhi, cosPhi, tParam.GetDzDs(), err2Y, err2Z );
 233
 234         if ( !tParam.Filter( y, z, err2Y, err2Z, .99 ) ) {
 235 #ifndef EXTERN_ROW_HITS
 236           tracklet.SetRowHit( iRow, -1 );
 237 #else
 238                   tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
 239 #endif //EXTERN_ROW_HITS
 240           break;
 241         }
 242       }
 243 #ifndef EXTERN_ROW_HITS
 244       tracklet.SetRowHit( iRow, oldIH );
 245 #else
 246           tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = oldIH;
 247 #endif //!EXTERN_ROW_HITS
 248       r.fNHits++;
 249       r.fLastRow = iRow;
 250       r.fEndRow = iRow;
 251       break;
 252     } while ( 0 );
 253
 254     if ( r.fCurrIH < 0 ) {
 255       r.fStage = 1;
 256       if ( CAMath::Abs( tParam.SinPhi() ) > .999 ) {
 257         r.fNHits = 0; r.fGo = 0;
 258       } else {
 259         //tParam.SetCosPhi( CAMath::Sqrt(1-tParam.SinPhi()*tParam.SinPhi()) );
 260       }
 261     }
 262   } else { // forward/backward searching part
 263     do {
 264       if ( r.fStage == 2 && ( ( iRow >= r.fEndRow ) ||
 265                               ( iRow >= r.fStartRow && ( iRow - r.fStartRow ) % 2 == 0 )
 266                             ) ) break;
 267       if ( r.fNMissed > kMaxRowGap  ) {
 268         break;
 269       }
 270
 271       r.fNMissed++;
 272
 273       float x = row.X();
 274       float err2Y, err2Z;
 275       if ( !tParam.TransportToX( x, tParam.SinPhi(), tParam.GetCosPhi(), tracker.Param().ConstBz(), .99 ) ) {
 276 #ifndef EXTERN_ROW_HITS
 277                 tracklet.SetRowHit(iRow, -1);
 278 #else
 279                 tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
 280 #endif //!EXTERN_ROW_HITS
 281         break;
 282       }
 283       if ( row.NHits() < 1 ) {
 284         // skip empty row
 285 #ifndef EXTERN_ROW_HITS
 286                   tracklet.SetRowHit(iRow, -1);
 287 #else
 288                   tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
 289 #endif //!EXTERN_ROW_HITS
 290         break;
 291       }
 292
 293 #ifndef HLTCA_GPU_TEXTURE_FETCH
 294           const ushort2 *hits = tracker.HitData(row);
 295 #endif //!HLTCA_GPU_TEXTURE_FETCH
 296
 297       float fY = tParam.GetY();
 298       float fZ = tParam.GetZ();
 299       int best = -1;
 300
 301       { // search for the closest hit
 302         const int fIndYmin = row.Grid().GetBinBounded( fY - 1.f, fZ - 1.f );
 303         assert( fIndYmin >= 0 );
 304
 305         int ds;
 306         int fY0 = ( int ) ( ( fY - y0 ) * stepYi );
 307         int fZ0 = ( int ) ( ( fZ - z0 ) * stepZi );
 308         int ds0 = ( ( ( int )1 ) << 30 );
 309         ds = ds0;
 310
 311         unsigned int fHitYfst = 1, fHitYlst = 0, fHitYfst1 = 1, fHitYlst1 = 0;
 312
 313         {
 314           int nY = row.Grid().Ny();
 315
 316 #ifndef HLTCA_GPU_TEXTURE_FETCH
 317                   const unsigned short *sGridP = tracker.FirstHitInBin(row);
 318 #endif //!HLTCA_GPU_TEXTURE_FETCH
 319
 320 #ifdef HLTCA_GPU_TEXTURE_FETCH
 321                   fHitYfst = tex1Dfetch(gAliTexRefu, ((char*) tracker.Data().FirstHitInBin(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + fIndYmin);
 322                   fHitYlst = tex1Dfetch(gAliTexRefu, ((char*) tracker.Data().FirstHitInBin(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + fIndYmin+2);
 323                   fHitYfst1 = tex1Dfetch(gAliTexRefu, ((char*) tracker.Data().FirstHitInBin(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + fIndYmin+nY);
 324                   fHitYlst1 = tex1Dfetch(gAliTexRefu, ((char*) tracker.Data().FirstHitInBin(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + fIndYmin+nY+2);
 325 #else
 326           fHitYfst = sGridP[fIndYmin];
 327           fHitYlst = sGridP[fIndYmin+2];
 328           fHitYfst1 = sGridP[fIndYmin+nY];
 329           fHitYlst1 = sGridP[fIndYmin+nY+2];
 330 #endif //HLTCA_GPU_TEXTURE_FETCH
 331           assert( (signed) fHitYfst <= row.NHits() );
 332           assert( (signed) fHitYlst <= row.NHits() );
 333           assert( (signed) fHitYfst1 <= row.NHits() );
 334           assert( (signed) fHitYlst1 <= row.NHits() );
 335         }
 336
 337                 for ( unsigned int fIh = fHitYfst; fIh < fHitYlst; fIh++ ) {
 338           assert( (signed) fIh < row.NHits() );
 339           ushort2 hh;
 340                   if (r.fStage <= 2 || tracker.HitWeight(row, fIh) >= 0)
 341                   {
 342
 343 #if defined(HLTCA_GPU_TEXTURE_FETCH)
 344                         hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + fIh);
 345 #else
 346                         hh = hits[fIh];
 347 #endif //HLTCA_GPU_TEXTURE_FETCH
 348                         int ddy = ( int )( hh.x ) - fY0;
 349                         int ddz = ( int )( hh.y ) - fZ0;
 350                         int dds = CAMath::Abs( ddy ) + CAMath::Abs( ddz );
 351                         if ( dds < ds ) {
 352                                 ds = dds;
 353                                 best = fIh;
 354                         }
 355           }
 356         }
 357
 358                 for ( unsigned int fIh = fHitYfst1; fIh < fHitYlst1; fIh++ ) {
 359           ushort2 hh;
 360 #if defined(HLTCA_GPU_TEXTURE_FETCH)
 361                   hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + fIh);
 362 #else
 363                   hh = hits[fIh];
 364 #endif //HLTCA_GPU_TEXTURE_FETCH
 365           int ddy = ( int )( hh.x ) - fY0;
 366           int ddz = ( int )( hh.y ) - fZ0;
 367           int dds = CAMath::Abs( ddy ) + CAMath::Abs( ddz );
 368           if ( dds < ds ) {
 369             ds = dds;
 370             best = fIh;
 371           }
 372         }
 373       }// end of search for the closest hit
 374
 375       if ( best < 0 )
 376           {
 377 #ifndef EXTERN_ROW_HITS
 378                   tracklet.SetRowHit(iRow, -1);
 379 #else
 380                   tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
 381 #endif //!EXTERN_ROW_HITS
 382                   break;
 383           }
 384
 385       ushort2 hh;
 386 #if defined(HLTCA_GPU_TEXTURE_FETCH)
 387                  hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + best);
 388 #else
 389                   hh = hits[best];
 390 #endif //HLTCA_GPU_TEXTURE_FETCH
 391
 392       tracker.GetErrors2( iRow, *( ( AliHLTTPCCATrackParam* )&tParam ), err2Y, err2Z );
 393
 394       float y = y0 + hh.x * stepY;
 395       float z = z0 + hh.y * stepZ;
 396       float dy = y - fY;
 397       float dz = z - fZ;
 398
 399       const float kFactor = tracker.Param().HitPickUpFactor() * tracker.Param().HitPickUpFactor() * 3.5 * 3.5;
 400       float sy2 = kFactor * ( tParam.GetErr2Y() +  err2Y );
 401       float sz2 = kFactor * ( tParam.GetErr2Z() +  err2Z );
 402       if ( sy2 > 2. ) sy2 = 2.;
 403       if ( sz2 > 2. ) sz2 = 2.;
 404
 405       if ( CAMath::FMulRZ( dy, dy ) > sy2 || CAMath::FMulRZ( dz, dz ) > sz2  ) {
 406 #ifndef EXTERN_ROW_HITS
 407                 tracklet.SetRowHit(iRow, -1);
 408 #else
 409                 tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
 410 #endif //!EXTERN_ROW_HITS
 411         break;
 412       }
 413 #ifdef GLOBAL_TRACKING_EXTRAPOLATE_ONLY
 414       if ( r.fStage <= 2)
 415 #endif
 416                   if (!tParam.Filter( y, z, err2Y, err2Z, .99 ) ) {
 417                         break;
 418                   }
 419 #ifndef EXTERN_ROW_HITS
 420           tracklet.SetRowHit( iRow, best );
 421 #else
 422           tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = best;
 423 #endif //!EXTERN_ROW_HITS
 424       r.fNHits++;
 425       r.fNMissed = 0;
 426       if ( r.fStage == 1 ) r.fLastRow = iRow;
 427       else r.fFirstRow = iRow;
 428     } while ( 0 );
 429   }
 430 }
 431
 432 #ifdef HLTCA_GPUCODE
 433
 434 #include "AliHLTTPCCATrackletConstructorGPU.h"
 435
 436 #else //HLTCA_GPUCODE
 437
 438 GPUdi() void AliHLTTPCCATrackletConstructor::AliHLTTPCCATrackletConstructorCPU(AliHLTTPCCATracker &tracker)
 439 {
 440         //Tracklet constructor simple CPU Function that does not neew a scheduler
 441         GPUshared() AliHLTTPCCASharedMemory sMem;
 442         sMem.fNTracklets = *tracker.NTracklets();
 443         for (int iTracklet = 0;iTracklet < *tracker.NTracklets();iTracklet++)
 444         {
 445                 AliHLTTPCCATrackParam tParam;
 446                 AliHLTTPCCAThreadMemory rMem;
 447
 448                 AliHLTTPCCAHitId id = tracker.TrackletStartHits()[iTracklet];
 449
 450                 rMem.fStartRow = rMem.fEndRow = rMem.fFirstRow = rMem.fLastRow = id.RowIndex();
 451                 rMem.fCurrIH = id.HitIndex();
 452                 rMem.fStage = 0;
 453                 rMem.fNHits = 0;
 454                 rMem.fNMissed = 0;
 455
 456                 AliHLTTPCCATrackletConstructor::InitTracklet(tParam);
 457
 458                 rMem.fItr = iTracklet;
 459                 rMem.fGo = 1;
 460
 461                 for (int j = rMem.fStartRow;j < tracker.Param().NRows();j++)
 462                 {
 463                         UpdateTracklet(1, 1, 0, iTracklet, sMem, rMem, tracker, tParam, j);
 464                         if (!rMem.fGo) break;
 465                 }
 466
 467                 rMem.fNMissed = 0;
 468                 rMem.fStage = 2;
 469                 if ( rMem.fGo )
 470                 {
 471                         if ( !tParam.TransportToX( tracker.Row( rMem.fEndRow ).X(), tracker.Param().ConstBz(), .999 ) ) rMem.fGo = 0;
 472                 }
 473
 474                 for (int j = rMem.fEndRow;j >= 0;j--)
 475                 {
 476                         if (!rMem.fGo) break;
 477                         UpdateTracklet( 1, 1, 0, iTracklet, sMem, rMem, tracker, tParam, j);
 478                 }
 479
 480                 StoreTracklet( 1, 1, 0, iTracklet, sMem, rMem, tracker, tParam );
 481         }
 482 }
 483
 484 GPUdi() int AliHLTTPCCATrackletConstructor::AliHLTTPCCATrackletConstructorGlobalTracking(AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam& tParam, int row, int increment)
 485 {
 486         AliHLTTPCCAThreadMemory rMem;
 487         GPUshared() AliHLTTPCCASharedMemory sMem;
 488         sMem.fNTracklets = *tracker.NTracklets();
 489         rMem.fItr = 0;
 490         rMem.fStage = 3;
 491         rMem.fNHits = rMem.fNMissed = 0;
 492         rMem.fGo = 1;
 493         while (rMem.fGo && row >= 0 && row < tracker.Param().NRows())
 494         {
 495                 UpdateTracklet(1, 1, 0, 0, sMem, rMem, tracker, tParam, row);
 496                 row += increment;
 497         }
 498         if (!CheckCov(tParam)) rMem.fNHits = 0;
 499         return(rMem.fNHits);
 500 }
 501
 502 #endif //HLTCA_GPUCODE