[u/mrichter/AliRoot.git] / HLT / TPCLib / tracking-ca / AliHLTTPCCATrackletConstructor.cxx

// @(#) $Id: AliHLTTPCCATrackletConstructor.cxx 27042 2008-07-02 12:06:02Z richterm $
// **************************************************************************
// This file is property of and copyright by the ALICE HLT Project          *
// ALICE Experiment at CERN, All rights reserved.                           *
//                                                                          *
// Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
//                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
//                  for The ALICE HLT Project.                              *
//                                                                          *
// Permission to use, copy, modify and distribute this software and its     *
// documentation strictly for non-commercial purposes is hereby granted     *
// without fee, provided that the above copyright notice appears in all     *
// copies and that both the copyright notice and this permission notice     *
// appear in the supporting documentation. The authors make no claims       *
// about the suitability of this software for any purpose. It is            *
// provided "as is" without express or implied warranty.                    *
//                                                                          *
//***************************************************************************

#include "AliHLTTPCCATracker.h"
#include "AliHLTTPCCATrackParam.h"
#include "AliHLTTPCCATrackParam.h"
#include "AliHLTTPCCAGrid.h"
#include "AliHLTTPCCAMath.h"
#include "AliHLTTPCCADef.h"
#include "AliHLTTPCCATracklet.h"
#include "AliHLTTPCCATrackletConstructor.h"

#define kMaxRowGap 4

MEM_CLASS_PRE2() GPUdi() void AliHLTTPCCATrackletConstructor::InitTracklet( MEM_LG2(AliHLTTPCCATrackParam) &tParam )
{
  //Initialize Tracklet Parameters using default values
  tParam.InitParam();
}

MEM_CLASS_PRE2() GPUdi() bool AliHLTTPCCATrackletConstructor::CheckCov(MEM_LG2(AliHLTTPCCATrackParam) &tParam)
{
      bool ok = 1;
      const float *c = tParam.Cov();
      for ( int i = 0; i < 15; i++ ) ok = ok && CAMath::Finite( c[i] );
      for ( int i = 0; i < 5; i++ ) ok = ok && CAMath::Finite( tParam.Par()[i] );
      ok = ok && ( tParam.X() > 50 );
	  if ( c[0] <= 0 || c[2] <= 0 || c[5] <= 0 || c[9] <= 0 || c[14] <= 0 ) ok = 0;
	  return(ok);
}


MEM_CLASS_PRE23() GPUdi() void AliHLTTPCCATrackletConstructor::StoreTracklet
( int /*nBlocks*/, int /*nThreads*/, int /*iBlock*/, int /*iThread*/,
  GPUsharedref() MEM_LOCAL(AliHLTTPCCASharedMemory)
#if defined(HLTCA_GPUCODE) | defined(EXTERN_ROW_HITS)
  &s
#else
  &/*s*/
#endif  //!HLTCA_GPUCODE
  , AliHLTTPCCAThreadMemory &r, GPUconstant() MEM_LG2(AliHLTTPCCATracker) &tracker, MEM_LG3(AliHLTTPCCATrackParam) &tParam )
{
  // reconstruction of tracklets, tracklet store step

  do {
    if ( r.fNHits < TRACKLET_SELECTOR_MIN_HITS ) {
      r.fNHits = 0;
      break;
    }

    if ( 0 ) {
      if ( 1. / .5 < CAMath::Abs( tParam.QPt() ) ) { //SG!!!
        r.fNHits = 0;
        break;
      }
    }

    {
	  bool ok = CheckCov(tParam);

      if ( !ok ) {
        r.fNHits = 0;
        break;
      }
    }
  } while ( 0 );

  if ( !SAVE() ) return;

/*#ifndef HLTCA_GPUCODE
  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(),
	  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], 
	  tParam.Cov()[10], tParam.Cov()[11], tParam.Cov()[12], tParam.Cov()[13], tParam.Cov()[14]);
#endif*/

  GPUglobalref() MEM_GLOBAL(AliHLTTPCCATracklet) &tracklet = tracker.Tracklets()[r.fItr];

  tracklet.SetNHits( r.fNHits );

  if ( r.fNHits > 0 ) {
    if ( CAMath::Abs( tParam.Par()[4] ) < 1.e-4 ) tParam.SetPar( 4, 1.e-4 );
	if (r.fStartRow < r.fFirstRow) r.fFirstRow = r.fStartRow;
	tracklet.SetFirstRow( r.fFirstRow );
    tracklet.SetLastRow( r.fLastRow );
#ifdef HLTCA_GPUCODE
    tracklet.SetParam( tParam.fParam );
#else
    tracklet.SetParam( tParam.GetParam() );
#endif //HLTCA_GPUCODE
    int w = tracker.CalculateHitWeight(r.fNHits, tParam.GetChi2(), r.fItr);
    tracklet.SetHitWeight(w);
    for ( int iRow = r.fFirstRow; iRow <= r.fLastRow; iRow++ ) {
#ifdef EXTERN_ROW_HITS
      int ih = tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr];
#else
	  int ih = tracklet.RowHit( iRow );
#endif //EXTERN_ROW_HITS
      if ( ih >= 0 ) {
#if defined(HLTCA_GPUCODE)
   	    tracker.MaximizeHitWeight( s.fRows[ iRow ], ih, w );
#else
	    tracker.MaximizeHitWeight( tracker.Row( iRow ), ih, w );
#endif //HLTCA_GPUCODE
      }
    }
  }

}

MEM_CLASS_PRE2() GPUdi() void AliHLTTPCCATrackletConstructor::UpdateTracklet
( int /*nBlocks*/, int /*nThreads*/, int /*iBlock*/, int /*iThread*/,
  GPUsharedref() MEM_LOCAL(AliHLTTPCCASharedMemory)
#if defined(HLTCA_GPUCODE) | defined(EXTERN_ROW_HITS)
  &s
#else
  &/*s*/
#endif //HLTCA_GPUCODE
  , AliHLTTPCCAThreadMemory &r, GPUconstant() MEM_CONSTANT(AliHLTTPCCATracker) &tracker, MEM_LG2(AliHLTTPCCATrackParam) &tParam, int iRow )
{
  // reconstruction of tracklets, tracklets update step

  if ( !r.fGo ) return;

#ifndef EXTERN_ROW_HITS
  AliHLTTPCCATracklet &tracklet = tracker.Tracklets()[r.fItr];
#endif //EXTERN_ROW_HITS

#if defined(HLTCA_GPUCODE)
  const GPUsharedref() MEM_LOCAL(AliHLTTPCCARow) &row = s.fRows[iRow];
#else
  const GPUglobalref() MEM_GLOBAL(AliHLTTPCCARow) &row = tracker.Row( iRow );
#endif //HLTCA_GPUCODE

  float y0 = row.Grid().YMin();
  float stepY = row.HstepY();
  float z0 = row.Grid().ZMin();
  float stepZ = row.HstepZ();
  float stepYi = row.HstepYi();
  float stepZi = row.HstepZi();

  if ( r.fStage == 0 ) { // fitting part
    do {

      if ( iRow < r.fStartRow || r.fCurrIH < 0  ) break;
      if ( ( iRow - r.fStartRow ) % 2 != 0 )
	  {
#ifndef EXTERN_ROW_HITS
		  tracklet.SetRowHit(iRow, -1);
#else
		  tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
#endif //EXTERN_ROW_HITS
		  break; // SG!!! - jump over the row
	  }


	  ushort2 hh;
#if defined(HLTCA_GPU_TEXTURE_FETCH)
	  hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + r.fCurrIH);
#else
	  hh = tracker.HitData(row)[r.fCurrIH];
#endif //HLTCA_GPU_TEXTURE_FETCH

      int oldIH = r.fCurrIH;
#if defined(HLTCA_GPU_TEXTURE_FETCH)
	  r.fCurrIH = tex1Dfetch(gAliTexRefs, ((char*) tracker.Data().HitLinkUpData(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + r.fCurrIH);
#else
	  r.fCurrIH = tracker.HitLinkUpData(row)[r.fCurrIH]; // read from linkup data
#endif //HLTCA_GPU_TEXTURE_FETCH

      float x = row.X();
      float y = y0 + hh.x * stepY;
      float z = z0 + hh.y * stepZ;

      if ( iRow == r.fStartRow ) {
        tParam.SetX( x );
        tParam.SetY( y );
        tParam.SetZ( z );
        r.fLastY = y;
        r.fLastZ = z;
      } else {

        float err2Y, err2Z;
        float dx = x - tParam.X();
        float dy = y - r.fLastY;//tParam.Y();
        float dz = z - r.fLastZ;//tParam.Z();
        r.fLastY = y;
        r.fLastZ = z;

        float ri = 1. / CAMath::Sqrt( dx * dx + dy * dy );
        if ( iRow == r.fStartRow + 2 ) { //SG!!! important - thanks to Matthias
          tParam.SetSinPhi( dy*ri );
          tParam.SetSignCosPhi( dx );
          tParam.SetDzDs( dz*ri );
          //std::cout << "Init. errors... " << r.fItr << std::endl;
          tracker.GetErrors2( iRow, tParam, err2Y, err2Z );
          //std::cout << "Init. errors = " << err2Y << " " << err2Z << std::endl;
          tParam.SetCov( 0, err2Y );
          tParam.SetCov( 2, err2Z );
        }
        float sinPhi, cosPhi;
        if ( r.fNHits >= 10 && CAMath::Abs( tParam.SinPhi() ) < .99 ) {
          sinPhi = tParam.SinPhi();
          cosPhi = CAMath::Sqrt( 1 - sinPhi * sinPhi );
        } else {
          sinPhi = dy * ri;
          cosPhi = dx * ri;
        }
        if ( !tParam.TransportToX( x, sinPhi, cosPhi, tracker.Param().ConstBz(), -1 ) ) {
#ifndef EXTERN_ROW_HITS
          tracklet.SetRowHit( iRow, -1 );
#else
		  tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
#endif //EXTERN_ROW_HITS
          break;
        }
        tracker.GetErrors2( iRow, tParam.GetZ(), sinPhi, cosPhi, tParam.GetDzDs(), err2Y, err2Z );

        if ( !tParam.Filter( y, z, err2Y, err2Z, .99 ) ) {
#ifndef EXTERN_ROW_HITS
          tracklet.SetRowHit( iRow, -1 );
#else
		  tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
#endif //EXTERN_ROW_HITS
          break;
        }
      }
#ifndef EXTERN_ROW_HITS
      tracklet.SetRowHit( iRow, oldIH );
#else
	  tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = oldIH;
#endif //!EXTERN_ROW_HITS
      r.fNHits++;
      r.fLastRow = iRow;
      r.fEndRow = iRow;
      break;
    } while ( 0 );

    if ( r.fCurrIH < 0 ) {
      r.fStage = 1;
      if ( CAMath::Abs( tParam.SinPhi() ) > .999 ) {
        r.fNHits = 0; r.fGo = 0;
      } else {
        //tParam.SetCosPhi( CAMath::Sqrt(1-tParam.SinPhi()*tParam.SinPhi()) );
      }
    }
  } else { // forward/backward searching part
    do {
      if ( r.fStage == 2 && ( ( iRow >= r.fEndRow ) ||
                              ( iRow >= r.fStartRow && ( iRow - r.fStartRow ) % 2 == 0 )
                            ) ) break;
      if ( r.fNMissed > kMaxRowGap  ) {
        break;
      }

      r.fNMissed++;

      float x = row.X();
      float err2Y, err2Z;
      if ( !tParam.TransportToX( x, tParam.SinPhi(), tParam.GetCosPhi(), tracker.Param().ConstBz(), .99 ) ) {
#ifndef EXTERN_ROW_HITS
		tracklet.SetRowHit(iRow, -1);
#else
		tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
#endif //!EXTERN_ROW_HITS
        break;
      }
      if ( row.NHits() < 1 ) {
        // skip empty row
#ifndef EXTERN_ROW_HITS
		  tracklet.SetRowHit(iRow, -1);
#else
		  tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
#endif //!EXTERN_ROW_HITS
        break;
      }

#ifndef HLTCA_GPU_TEXTURE_FETCH
	  GPUglobalref() const ushort2 *hits = tracker.HitData(row);
#endif //!HLTCA_GPU_TEXTURE_FETCH

      float fY = tParam.GetY();
      float fZ = tParam.GetZ();
      int best = -1;

      { // search for the closest hit
        const int fIndYmin = row.Grid().GetBinBounded( fY - 1.f, fZ - 1.f );
        assert( fIndYmin >= 0 );

        int ds;
        int fY0 = ( int ) ( ( fY - y0 ) * stepYi );
        int fZ0 = ( int ) ( ( fZ - z0 ) * stepZi );
        int ds0 = ( ( ( int )1 ) << 30 );
        ds = ds0;

        unsigned int fHitYfst = 1, fHitYlst = 0, fHitYfst1 = 1, fHitYlst1 = 0;

        {
          int nY = row.Grid().Ny();

#ifndef HLTCA_GPU_TEXTURE_FETCH
		  GPUglobalref()  const unsigned short *sGridP = tracker.FirstHitInBin(row);
#endif //!HLTCA_GPU_TEXTURE_FETCH

#ifdef HLTCA_GPU_TEXTURE_FETCH
		  fHitYfst = tex1Dfetch(gAliTexRefu, ((char*) tracker.Data().FirstHitInBin(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + fIndYmin);
		  fHitYlst = tex1Dfetch(gAliTexRefu, ((char*) tracker.Data().FirstHitInBin(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + fIndYmin+2);
		  fHitYfst1 = tex1Dfetch(gAliTexRefu, ((char*) tracker.Data().FirstHitInBin(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + fIndYmin+nY);
		  fHitYlst1 = tex1Dfetch(gAliTexRefu, ((char*) tracker.Data().FirstHitInBin(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + fIndYmin+nY+2);
#else
          fHitYfst = sGridP[fIndYmin];
          fHitYlst = sGridP[fIndYmin+2];
          fHitYfst1 = sGridP[fIndYmin+nY];
          fHitYlst1 = sGridP[fIndYmin+nY+2];
#endif //HLTCA_GPU_TEXTURE_FETCH
          assert( (signed) fHitYfst <= row.NHits() );
          assert( (signed) fHitYlst <= row.NHits() );
          assert( (signed) fHitYfst1 <= row.NHits() );
          assert( (signed) fHitYlst1 <= row.NHits() );
        }

		for ( unsigned int fIh = fHitYfst; fIh < fHitYlst; fIh++ ) {
          assert( (signed) fIh < row.NHits() );
          ushort2 hh;
		  if (r.fStage <= 2 || tracker.HitWeight(row, fIh) >= 0)
		  {

#if defined(HLTCA_GPU_TEXTURE_FETCH)
			hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + fIh);
#else
			hh = hits[fIh];
#endif //HLTCA_GPU_TEXTURE_FETCH
			int ddy = ( int )( hh.x ) - fY0;
			int ddz = ( int )( hh.y ) - fZ0;
			int dds = CAMath::Abs( ddy ) + CAMath::Abs( ddz );
			if ( dds < ds ) {
				ds = dds;
				best = fIh;
			}
          }
        }

		for ( unsigned int fIh = fHitYfst1; fIh < fHitYlst1; fIh++ ) {
          ushort2 hh;
#if defined(HLTCA_GPU_TEXTURE_FETCH)
		  hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + fIh);
#else
		  hh = hits[fIh];
#endif //HLTCA_GPU_TEXTURE_FETCH
          int ddy = ( int )( hh.x ) - fY0;
          int ddz = ( int )( hh.y ) - fZ0;
          int dds = CAMath::Abs( ddy ) + CAMath::Abs( ddz );
          if ( dds < ds ) {
            ds = dds;
            best = fIh;
          }
        }
      }// end of search for the closest hit

      if ( best < 0 )
	  {
#ifndef EXTERN_ROW_HITS
		  tracklet.SetRowHit(iRow, -1);
#else
		  tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
#endif //!EXTERN_ROW_HITS
		  break;
	  }

      ushort2 hh;
#if defined(HLTCA_GPU_TEXTURE_FETCH)
		 hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + best);
#else
		  hh = hits[best];
#endif //HLTCA_GPU_TEXTURE_FETCH

      tracker.GetErrors2( iRow, *( ( MEM_LG2(AliHLTTPCCATrackParam)* )&tParam ), err2Y, err2Z );

      float y = y0 + hh.x * stepY;
      float z = z0 + hh.y * stepZ;
      float dy = y - fY;
      float dz = z - fZ;

      const float kFactor = tracker.Param().HitPickUpFactor() * tracker.Param().HitPickUpFactor() * 3.5 * 3.5;
      float sy2 = kFactor * ( tParam.GetErr2Y() +  err2Y );
      float sz2 = kFactor * ( tParam.GetErr2Z() +  err2Z );
      if ( sy2 > 2. ) sy2 = 2.;
      if ( sz2 > 2. ) sz2 = 2.;

      if ( CAMath::FMulRZ( dy, dy ) > sy2 || CAMath::FMulRZ( dz, dz ) > sz2  ) {
#ifndef EXTERN_ROW_HITS
		tracklet.SetRowHit(iRow, -1);
#else
		tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
#endif //!EXTERN_ROW_HITS
        break;
      }
#ifdef GLOBAL_TRACKING_EXTRAPOLATE_ONLY
      if ( r.fStage <= 2)
#endif
		  if (!tParam.Filter( y, z, err2Y, err2Z, .99 ) ) {
			break;
		  }
#ifndef EXTERN_ROW_HITS
	  tracklet.SetRowHit( iRow, best );
#else
	  tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = best;
#endif //!EXTERN_ROW_HITS
      r.fNHits++;
      r.fNMissed = 0;
      if ( r.fStage == 1 ) r.fLastRow = iRow;
      else r.fFirstRow = iRow;
    } while ( 0 );
  }
}

#ifdef HLTCA_GPUCODE

#include "AliHLTTPCCATrackletConstructorGPU.h"

#else //HLTCA_GPUCODE

GPUdi() void AliHLTTPCCATrackletConstructor::AliHLTTPCCATrackletConstructorCPU(AliHLTTPCCATracker &tracker)
{
	//Tracklet constructor simple CPU Function that does not neew a scheduler
	GPUshared() AliHLTTPCCASharedMemory sMem;
	sMem.fNTracklets = *tracker.NTracklets();
	for (int iTracklet = 0;iTracklet < *tracker.NTracklets();iTracklet++)
	{
		AliHLTTPCCATrackParam tParam;
		AliHLTTPCCAThreadMemory rMem;
		
		AliHLTTPCCAHitId id = tracker.TrackletStartHits()[iTracklet];

		rMem.fStartRow = rMem.fEndRow = rMem.fFirstRow = rMem.fLastRow = id.RowIndex();
		rMem.fCurrIH = id.HitIndex();
		rMem.fStage = 0;
		rMem.fNHits = 0;
		rMem.fNMissed = 0;

		AliHLTTPCCATrackletConstructor::InitTracklet(tParam);

		rMem.fItr = iTracklet;
		rMem.fGo = 1;

		for (int j = rMem.fStartRow;j < tracker.Param().NRows();j++)
		{
			UpdateTracklet(1, 1, 0, iTracklet, sMem, rMem, tracker, tParam, j);
			if (!rMem.fGo) break;
		}

		rMem.fNMissed = 0;
		rMem.fStage = 2;
		if ( rMem.fGo )
		{
			if ( !tParam.TransportToX( tracker.Row( rMem.fEndRow ).X(), tracker.Param().ConstBz(), .999 ) ) rMem.fGo = 0;
		}

		for (int j = rMem.fEndRow;j >= 0;j--)
		{
			if (!rMem.fGo) break;
			UpdateTracklet( 1, 1, 0, iTracklet, sMem, rMem, tracker, tParam, j);
		}

		StoreTracklet( 1, 1, 0, iTracklet, sMem, rMem, tracker, tParam );
	}
}

GPUdi() int AliHLTTPCCATrackletConstructor::AliHLTTPCCATrackletConstructorGlobalTracking(AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam& tParam, int row, int increment)
{
	AliHLTTPCCAThreadMemory rMem;	
	GPUshared() AliHLTTPCCASharedMemory sMem;
	sMem.fNTracklets = *tracker.NTracklets();
	rMem.fItr = 0;
	rMem.fStage = 3;
	rMem.fNHits = rMem.fNMissed = 0;
	rMem.fGo = 1;
	while (rMem.fGo && row >= 0 && row < tracker.Param().NRows())
	{
		UpdateTracklet(1, 1, 0, 0, sMem, rMem, tracker, tParam, row);
		row += increment;
	}
	if (!CheckCov(tParam)) rMem.fNHits = 0;
	return(rMem.fNHits);
}

#endif //HLTCA_GPUCODE
Commit	Line	Data
00d07bcd	1	// @(#) $Id: AliHLTTPCCATrackletConstructor.cxx 27042 2008-07-02 12:06:02Z richterm $
ce565086	2	// **************************************************************************
fbb9b71b	3	// This file is property of and copyright by the ALICE HLT Project *
00d07bcd	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. *
ce565086	17	// *
00d07bcd	18	//***************************************************************************
	19
	20	#include "AliHLTTPCCATracker.h"
	21	#include "AliHLTTPCCATrackParam.h"
4687b8fc	22	#include "AliHLTTPCCATrackParam.h"
00d07bcd	23	#include "AliHLTTPCCAGrid.h"
00d07bcd	24	#include "AliHLTTPCCAMath.h"
00d07bcd	25	#include "AliHLTTPCCADef.h"
ce565086	26	#include "AliHLTTPCCATracklet.h"
00d07bcd	27	#include "AliHLTTPCCATrackletConstructor.h"
00d07bcd	28
b22af1bf	29	#define kMaxRowGap 4
00d07bcd	30
43422963	31	MEM_CLASS_PRE2() GPUdi() void AliHLTTPCCATrackletConstructor::InitTracklet( MEM_LG2(AliHLTTPCCATrackParam) &tParam )
00d07bcd	32	{
73a33d2e	33	//Initialize Tracklet Parameters using default values
73a33d2e	34	tParam.InitParam();
00d07bcd	35	}
00d07bcd	36
43422963	37	MEM_CLASS_PRE2() GPUdi() bool AliHLTTPCCATrackletConstructor::CheckCov(MEM_LG2(AliHLTTPCCATrackParam) &tParam)
e4818148	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
00d07bcd	48
43422963	49	MEM_CLASS_PRE23() GPUdi() void AliHLTTPCCATrackletConstructor::StoreTracklet
fbb9b71b	50	( int /nBlocks/, int /nThreads/, int /iBlock/, int /iThread/,
43422963	51	GPUsharedref() MEM_LOCAL(AliHLTTPCCASharedMemory)
f0bada7f	52	#if defined(HLTCA_GPUCODE) \| defined(EXTERN_ROW_HITS)
8566066c	53	&s
	54	#else
	55	&/s/
31649d4b	56	#endif //!HLTCA_GPUCODE
43422963	57	, AliHLTTPCCAThreadMemory &r, GPUconstant() MEM_LG2(AliHLTTPCCATracker) &tracker, MEM_LG3(AliHLTTPCCATrackParam) &tParam )
fbb9b71b	58	{
00d07bcd	59	// reconstruction of tracklets, tracklet store step
fbb9b71b	60
fbb9b71b	61	do {
b22af1bf	62	if ( r.fNHits < TRACKLET_SELECTOR_MIN_HITS ) {
00d07bcd	63	r.fNHits = 0;
	64	break;
	65	}
ce565086	66
fbb9b71b	67	if ( 0 ) {
	68	if ( 1. / .5 < CAMath::Abs( tParam.QPt() ) ) { //SG!!!
	69	r.fNHits = 0;
	70	break;
ce565086	71	}
ce565086	72	}
fbb9b71b	73
fbb9b71b	74	{
e4818148	75	bool ok = CheckCov(tParam);
fbb9b71b	76
	77	if ( !ok ) {
	78	r.fNHits = 0;
	79	break;
00d07bcd	80	}
fbb9b71b	81	}
	82	} while ( 0 );
	83
	84	if ( !SAVE() ) return;
	85
e4818148	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
43422963	92	GPUglobalref() MEM_GLOBAL(AliHLTTPCCATracklet) &tracklet = tracker.Tracklets()[r.fItr];
ce565086	93
fbb9b71b	94	tracklet.SetNHits( r.fNHits );
	95
	96	if ( r.fNHits > 0 ) {
91794c67	97	if ( CAMath::Abs( tParam.Par()[4] ) < 1.e-4 ) tParam.SetPar( 4, 1.e-4 );
b22af1bf	98	if (r.fStartRow < r.fFirstRow) r.fFirstRow = r.fStartRow;
b22af1bf	99	tracklet.SetFirstRow( r.fFirstRow );
ce565086	100	tracklet.SetLastRow( r.fLastRow );
444e5682	101	#ifdef HLTCA_GPUCODE
73a33d2e	102	tracklet.SetParam( tParam.fParam );
444e5682	103	#else
444e5682	104	tracklet.SetParam( tParam.GetParam() );
31649d4b	105	#endif //HLTCA_GPUCODE
6f0cdd46	106	int w = tracker.CalculateHitWeight(r.fNHits, tParam.GetChi2(), r.fItr);
6f0cdd46	107	tracklet.SetHitWeight(w);
b22af1bf	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 );
31649d4b	113	#endif //EXTERN_ROW_HITS
fbb9b71b	114	if ( ih >= 0 ) {
1e63725a	115	#if defined(HLTCA_GPUCODE)
f0bada7f	116	tracker.MaximizeHitWeight( s.fRows[ iRow ], ih, w );
b22af1bf	117	#else
b22af1bf	118	tracker.MaximizeHitWeight( tracker.Row( iRow ), ih, w );
1e63725a	119	#endif //HLTCA_GPUCODE
00d07bcd	120	}
00d07bcd	121	}
fbb9b71b	122	}
b22af1bf	123
00d07bcd	124	}
00d07bcd	125
43422963	126	MEM_CLASS_PRE2() GPUdi() void AliHLTTPCCATrackletConstructor::UpdateTracklet
fbb9b71b	127	( int /nBlocks/, int /nThreads/, int /iBlock/, int /iThread/,
43422963	128	GPUsharedref() MEM_LOCAL(AliHLTTPCCASharedMemory)
f0bada7f	129	#if defined(HLTCA_GPUCODE) \| defined(EXTERN_ROW_HITS)
8566066c	130	&s
	131	#else
	132	&/s/
31649d4b	133	#endif //HLTCA_GPUCODE
43422963	134	, AliHLTTPCCAThreadMemory &r, GPUconstant() MEM_CONSTANT(AliHLTTPCCATracker) &tracker, MEM_LG2(AliHLTTPCCATrackParam) &tParam, int iRow )
fbb9b71b	135	{
00d07bcd	136	// reconstruction of tracklets, tracklets update step
00d07bcd	137
fbb9b71b	138	if ( !r.fGo ) return;
fbb9b71b	139
b22af1bf	140	#ifndef EXTERN_ROW_HITS
ce565086	141	AliHLTTPCCATracklet &tracklet = tracker.Tracklets()[r.fItr];
31649d4b	142	#endif //EXTERN_ROW_HITS
ce565086	143
1e63725a	144	#if defined(HLTCA_GPUCODE)
43422963	145	const GPUsharedref() MEM_LOCAL(AliHLTTPCCARow) &row = s.fRows[iRow];
b22af1bf	146	#else
43422963	147	const GPUglobalref() MEM_GLOBAL(AliHLTTPCCARow) &row = tracker.Row( iRow );
1e63725a	148	#endif //HLTCA_GPUCODE
fbb9b71b	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;
b22af1bf	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;
31649d4b	167	#endif //EXTERN_ROW_HITS
b22af1bf	168	break; // SG!!! - jump over the row
	169	}
	170
f0bada7f	171
b22af1bf	172	ushort2 hh;
b22af1bf	173	#if defined(HLTCA_GPU_TEXTURE_FETCH)
8566066c	174	hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + r.fCurrIH);
b22af1bf	175	#else
b22af1bf	176	hh = tracker.HitData(row)[r.fCurrIH];
31649d4b	177	#endif //HLTCA_GPU_TEXTURE_FETCH
fbb9b71b	178
fbb9b71b	179	int oldIH = r.fCurrIH;
b22af1bf	180	#if defined(HLTCA_GPU_TEXTURE_FETCH)
8566066c	181	r.fCurrIH = tex1Dfetch(gAliTexRefs, ((char*) tracker.Data().HitLinkUpData(row) - tracker.Data().GPUTextureBase()) / sizeof(unsigned short) + r.fCurrIH);
b22af1bf	182	#else
b22af1bf	183	r.fCurrIH = tracker.HitLinkUpData(row)[r.fCurrIH]; // read from linkup data
31649d4b	184	#endif //HLTCA_GPU_TEXTURE_FETCH
fbb9b71b	185
	186	float x = row.X();
	187	float y = y0 + hh.x * stepY;
	188	float z = z0 + hh.y * stepZ;
fbb9b71b	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;
fbb9b71b	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 );
5abba7a4	206	if ( iRow == r.fStartRow + 2 ) { //SG!!! important - thanks to Matthias
fbb9b71b	207	tParam.SetSinPhi( dy*ri );
	208	tParam.SetSignCosPhi( dx );
	209	tParam.SetDzDs( dz*ri );
4acc2401	210	//std::cout << "Init. errors... " << r.fItr << std::endl;
fbb9b71b	211	tracker.GetErrors2( iRow, tParam, err2Y, err2Z );
4acc2401	212	//std::cout << "Init. errors = " << err2Y << " " << err2Z << std::endl;
fbb9b71b	213	tParam.SetCov( 0, err2Y );
	214	tParam.SetCov( 2, err2Z );
	215	}
fbb9b71b	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	}
91794c67	224	if ( !tParam.TransportToX( x, sinPhi, cosPhi, tracker.Param().ConstBz(), -1 ) ) {
b22af1bf	225	#ifndef EXTERN_ROW_HITS
	226	tracklet.SetRowHit( iRow, -1 );
	227	#else
	228	tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
31649d4b	229	#endif //EXTERN_ROW_HITS
fbb9b71b	230	break;
fbb9b71b	231	}
fbb9b71b	232	tracker.GetErrors2( iRow, tParam.GetZ(), sinPhi, cosPhi, tParam.GetDzDs(), err2Y, err2Z );
1e63725a	233
fbb9b71b	234	if ( !tParam.Filter( y, z, err2Y, err2Z, .99 ) ) {
b22af1bf	235	#ifndef EXTERN_ROW_HITS
	236	tracklet.SetRowHit( iRow, -1 );
	237	#else
	238	tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
31649d4b	239	#endif //EXTERN_ROW_HITS
fbb9b71b	240	break;
fbb9b71b	241	}
00d07bcd	242	}
b22af1bf	243	#ifndef EXTERN_ROW_HITS
	244	tracklet.SetRowHit( iRow, oldIH );
	245	#else
	246	tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = oldIH;
31649d4b	247	#endif //!EXTERN_ROW_HITS
00d07bcd	248	r.fNHits++;
00d07bcd	249	r.fLastRow = iRow;
ce565086	250	r.fEndRow = iRow;
00d07bcd	251	break;
fbb9b71b	252	} while ( 0 );
	253
	254	if ( r.fCurrIH < 0 ) {
693d2443	255	r.fStage = 1;
fbb9b71b	256	if ( CAMath::Abs( tParam.SinPhi() ) > .999 ) {
fbb9b71b	257	r.fNHits = 0; r.fGo = 0;
	258	} else {
	259	//tParam.SetCosPhi( CAMath::Sqrt(1-tParam.SinPhi()*tParam.SinPhi()) );
693d2443	260	}
fbb9b71b	261	}
	262	} else { // forward/backward searching part
	263	do {
fbb9b71b	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;
91794c67	275	if ( !tParam.TransportToX( x, tParam.SinPhi(), tParam.GetCosPhi(), tracker.Param().ConstBz(), .99 ) ) {
b22af1bf	276	#ifndef EXTERN_ROW_HITS
	277	tracklet.SetRowHit(iRow, -1);
	278	#else
	279	tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
31649d4b	280	#endif //!EXTERN_ROW_HITS
fbb9b71b	281	break;
fbb9b71b	282	}
4acc2401	283	if ( row.NHits() < 1 ) {
4acc2401	284	// skip empty row
b22af1bf	285	#ifndef EXTERN_ROW_HITS
	286	tracklet.SetRowHit(iRow, -1);
	287	#else
	288	tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
31649d4b	289	#endif //!EXTERN_ROW_HITS
4acc2401	290	break;
4acc2401	291	}
1e63725a	292
b22af1bf	293	#ifndef HLTCA_GPU_TEXTURE_FETCH
43422963	294	GPUglobalref() const ushort2 *hits = tracker.HitData(row);
31649d4b	295	#endif //!HLTCA_GPU_TEXTURE_FETCH
fbb9b71b	296
	297	float fY = tParam.GetY();
	298	float fZ = tParam.GetZ();
	299	int best = -1;
	300
	301	{ // search for the closest hit
4acc2401	302	const int fIndYmin = row.Grid().GetBinBounded( fY - 1.f, fZ - 1.f );
4acc2401	303	assert( fIndYmin >= 0 );
fbb9b71b	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
fbb9b71b	311	unsigned int fHitYfst = 1, fHitYlst = 0, fHitYfst1 = 1, fHitYlst1 = 0;
fbb9b71b	312
fbb9b71b	313	{
	314	int nY = row.Grid().Ny();
	315
b22af1bf	316	#ifndef HLTCA_GPU_TEXTURE_FETCH
43422963	317	GPUglobalref() const unsigned short *sGridP = tracker.FirstHitInBin(row);
31649d4b	318	#endif //!HLTCA_GPU_TEXTURE_FETCH
b22af1bf	319
b22af1bf	320	#ifdef HLTCA_GPU_TEXTURE_FETCH
8566066c	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);
b22af1bf	325	#else
fbb9b71b	326	fHitYfst = sGridP[fIndYmin];
	327	fHitYlst = sGridP[fIndYmin+2];
	328	fHitYfst1 = sGridP[fIndYmin+nY];
	329	fHitYlst1 = sGridP[fIndYmin+nY+2];
31649d4b	330	#endif //HLTCA_GPU_TEXTURE_FETCH
b22af1bf	331	assert( (signed) fHitYfst <= row.NHits() );
	332	assert( (signed) fHitYlst <= row.NHits() );
	333	assert( (signed) fHitYfst1 <= row.NHits() );
	334	assert( (signed) fHitYlst1 <= row.NHits() );
fbb9b71b	335	}
1e63725a	336
1e63725a	337	for ( unsigned int fIh = fHitYfst; fIh < fHitYlst; fIh++ ) {
b22af1bf	338	assert( (signed) fIh < row.NHits() );
b22af1bf	339	ushort2 hh;
e4818148	340	if (r.fStage <= 2 \|\| tracker.HitWeight(row, fIh) >= 0)
	341	{
	342
b22af1bf	343	#if defined(HLTCA_GPU_TEXTURE_FETCH)
e4818148	344	hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + fIh);
b22af1bf	345	#else
e4818148	346	hh = hits[fIh];
31649d4b	347	#endif //HLTCA_GPU_TEXTURE_FETCH
e4818148	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	}
fbb9b71b	355	}
	356	}
	357
b22af1bf	358	for ( unsigned int fIh = fHitYfst1; fIh < fHitYlst1; fIh++ ) {
	359	ushort2 hh;
	360	#if defined(HLTCA_GPU_TEXTURE_FETCH)
8566066c	361	hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + fIh);
b22af1bf	362	#else
b22af1bf	363	hh = hits[fIh];
31649d4b	364	#endif //HLTCA_GPU_TEXTURE_FETCH
fbb9b71b	365	int ddy = ( int )( hh.x ) - fY0;
	366	int ddz = ( int )( hh.y ) - fZ0;
	367	int dds = CAMath::Abs( ddy ) + CAMath::Abs( ddz );
fbb9b71b	368	if ( dds < ds ) {
	369	ds = dds;
	370	best = fIh;
	371	}
	372	}
	373	}// end of search for the closest hit
	374
b22af1bf	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;
31649d4b	381	#endif //!EXTERN_ROW_HITS
b22af1bf	382	break;
b22af1bf	383	}
fbb9b71b	384
b22af1bf	385	ushort2 hh;
b22af1bf	386	#if defined(HLTCA_GPU_TEXTURE_FETCH)
8566066c	387	hh = tex1Dfetch(gAliTexRefu2, ((char*) tracker.Data().HitData() - tracker.Data().GPUTextureBase()) / sizeof(ushort2) + row.HitNumberOffset() + best);
b22af1bf	388	#else
b22af1bf	389	hh = hits[best];
31649d4b	390	#endif //HLTCA_GPU_TEXTURE_FETCH
fbb9b71b	391
43422963	392	tracker.GetErrors2( iRow, ( ( MEM_LG2(AliHLTTPCCATrackParam) )&tParam ), err2Y, err2Z );
fbb9b71b	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
fbb9b71b	405	if ( CAMath::FMulRZ( dy, dy ) > sy2 \|\| CAMath::FMulRZ( dz, dz ) > sz2 ) {
b22af1bf	406	#ifndef EXTERN_ROW_HITS
	407	tracklet.SetRowHit(iRow, -1);
	408	#else
	409	tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = -1;
31649d4b	410	#endif //!EXTERN_ROW_HITS
fbb9b71b	411	break;
fbb9b71b	412	}
e4818148	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	}
b22af1bf	419	#ifndef EXTERN_ROW_HITS
	420	tracklet.SetRowHit( iRow, best );
	421	#else
	422	tracker.TrackletRowHits()[iRow * s.fNTracklets + r.fItr] = best;
31649d4b	423	#endif //!EXTERN_ROW_HITS
fbb9b71b	424	r.fNHits++;
	425	r.fNMissed = 0;
	426	if ( r.fStage == 1 ) r.fLastRow = iRow;
	427	else r.fFirstRow = iRow;
	428	} while ( 0 );
	429	}
00d07bcd	430	}
00d07bcd	431
b22af1bf	432	#ifdef HLTCA_GPUCODE
b22af1bf	433
2fba026d	434	#include "AliHLTTPCCATrackletConstructorGPU.h"
b22af1bf	435
31649d4b	436	#else //HLTCA_GPUCODE
31649d4b	437
f0bada7f	438	GPUdi() void AliHLTTPCCATrackletConstructor::AliHLTTPCCATrackletConstructorCPU(AliHLTTPCCATracker &tracker)
b22af1bf	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
8566066c	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
b22af1bf	480	StoreTracklet( 1, 1, 0, iTracklet, sMem, rMem, tracker, tParam );
	481	}
	482	}
e4818148	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
31649d4b	502	#endif //HLTCA_GPUCODE