HLT/TPCLib/tracking-ca/AliHLTTPCCATrackletSelector.cxx

   1 // @(#) $Id: AliHLTTPCCATrackletSelector.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
  21 #include "AliHLTTPCCATrackletSelector.h"
  22 #include "AliHLTTPCCATrack.h"
  23 #include "AliHLTTPCCATracker.h"
  24 #include "AliHLTTPCCATrackParam.h"
  25 #include "AliHLTTPCCATracklet.h"
  26 #include "AliHLTTPCCAMath.h"
  27
  28 GPUdi() void AliHLTTPCCATrackletSelector::Thread
  29 ( int nBlocks, int nThreads, int iBlock, int iThread, int iSync,
  30   AliHLTTPCCASharedMemory &s, AliHLTTPCCATracker &tracker )
  31 {
  32   // select best tracklets and kill clones
  33
  34   if ( iSync == 0 ) {
  35     if ( iThread == 0 ) {
  36       s.fNTracklets = *tracker.NTracklets();
  37       s.fNThreadsTotal = nThreads * nBlocks;
  38       s.fItr0 = nThreads * iBlock;
  39     }
  40   } else if ( iSync == 1 ) {
  41         int nHits, nFirstTrackHit;
  42         AliHLTTPCCAHitId trackHits[160 - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE];
  43
  44     for ( int itr = s.fItr0 + iThread; itr < s.fNTracklets; itr += s.fNThreadsTotal ) {
  45
  46 #ifdef HLTCA_GPU_EMULATION_DEBUG_TRACKLET
  47         if (itr == HLTCA_GPU_EMULATION_DEBUG_TRACKLET)
  48         {
  49                 tracker.GPUParameters()->fGPUError = 1;
  50         }
  51 #endif //HLTCA_GPU_EMULATION_DEBUG_TRACKLET
  52
  53           while (tracker.Tracklets()[itr].NHits() == 0)
  54           {
  55                   itr += s.fNThreadsTotal;
  56                   if (itr >= s.fNTracklets) return;
  57           }
  58
  59           AliHLTTPCCATracklet &tracklet = tracker.Tracklets()[itr];
  60       const int kMaxRowGap = 4;
  61       const float kMaxShared = .1;
  62
  63       int firstRow = tracklet.FirstRow();
  64       int lastRow = tracklet.LastRow();
  65           if (lastRow > tracker.Param().NRows())
  66           {
  67                         tracker.GPUParameters()->fGPUError = HLTCA_GPU_ERROR_WRONG_ROW;
  68                         return;
  69           }
  70
  71       const int w = tracklet.HitWeight();
  72
  73       //int w = (tNHits<<16)+itr;
  74       //int nRows = tracker.Param().NRows();
  75       //std::cout<<" store tracklet: "<<firstRow<<" "<<lastRow<<std::endl;
  76
  77           int irow = firstRow;
  78
  79       int gap = 0;
  80       int nShared = 0;
  81           nHits = 0;
  82
  83           for (irow = firstRow; irow <= lastRow && lastRow - irow + nHits >= TRACKLET_SELECTOR_MIN_HITS; irow++ ) {
  84         gap++;
  85 #ifdef EXTERN_ROW_HITS
  86         int ih = tracker.TrackletRowHits()[irow * s.fNTracklets + itr];
  87 #else
  88                 int ih = tracklet.RowHit( irow );
  89 #endif //EXTERN_ROW_HITS
  90         if ( ih >= 0 ) {
  91           const AliHLTTPCCARow &row = tracker.Row( irow );
  92           bool own = ( tracker.HitWeight( row, ih ) <= w );
  93           bool sharedOK = ( ( nShared < nHits * kMaxShared ) );
  94           if ( own || sharedOK ) {//SG!!!
  95             gap = 0;
  96 #if HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
  97                         if (nHits < HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE)
  98                                 s.fHits[iThread][nHits].Set( irow, ih );
  99                         else
 100 #endif //HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
 101                                 trackHits[nHits - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE].Set( irow, ih );
 102             nHits++;
 103             if ( !own ) nShared++;
 104           }
 105         }
 106
 107         if ( gap > kMaxRowGap || irow == lastRow ) { // store
 108           if ( nHits >= TRACKLET_SELECTOR_MIN_HITS ) { //SG!!!
 109             int itrout = CAMath::AtomicAdd( tracker.NTracks(), 1 );
 110 #ifdef HLTCA_GPUCODE
 111                         if (itrout >= HLTCA_GPU_MAX_TRACKS)
 112                         {
 113                                 tracker.GPUParameters()->fGPUError = HLTCA_GPU_ERROR_TRACK_OVERFLOW;
 114                                 CAMath::AtomicExch( tracker.NTracks(), 0 );
 115                                 return;
 116                         }
 117 #endif //HLTCA_GPUCODE
 118             nFirstTrackHit = CAMath::AtomicAdd( tracker.NTrackHits(), nHits );
 119                         tracker.Tracks()[itrout].SetAlive(1);
 120                         tracker.Tracks()[itrout].SetParam(tracklet.Param());
 121                         tracker.Tracks()[itrout].SetFirstHitID(nFirstTrackHit);
 122                         tracker.Tracks()[itrout].SetNHits(nHits);
 123             for ( int jh = 0; jh < nHits; jh++ ) {
 124 #if HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
 125                                 if (jh < HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE)
 126                                         tracker.TrackHits()[nFirstTrackHit + jh] = s.fHits[iThread][jh];
 127                                 else
 128 #endif //HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
 129                                         tracker.TrackHits()[nFirstTrackHit + jh] = trackHits[jh - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE];
 130             }
 131           }
 132           nHits = 0;
 133           gap = 0;
 134           nShared = 0;
 135         }
 136       }
 137
 138
 139     }
 140   }
 141 }