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 (firstRow < 0 || lastRow > tracker.Param().NRows() || tracklet.NHits() < 0)
  66                         {
  67 #ifdef HLTCA_GPU_ALTERNATIVE_SCHEDULER
  68                                 //tracker.GPUParameters()->fGPUError = HLTCA_GPU_ERROR_WRONG_ROW;
  69                                 //return;
  70 #else
  71                                 continue;
  72 #endif
  73                         }
  74
  75                         const int w = tracklet.HitWeight();
  76
  77                         //int w = (tNHits<<16)+itr;
  78                         //int nRows = tracker.Param().NRows();
  79                         //std::cout<<" store tracklet: "<<firstRow<<" "<<lastRow<<std::endl;
  80
  81                         int irow = firstRow;
  82
  83                         int gap = 0;
  84                         int nShared = 0;
  85                         nHits = 0;
  86
  87                         for (irow = firstRow; irow <= lastRow && lastRow - irow + nHits >= TRACKLET_SELECTOR_MIN_HITS; irow++ )
  88                         {
  89                                 gap++;
  90 #ifdef EXTERN_ROW_HITS
  91                                 int ih = tracker.TrackletRowHits()[irow * s.fNTracklets + itr];
  92 #else
  93                                 int ih = tracklet.RowHit( irow );
  94 #endif //EXTERN_ROW_HITS
  95                                 if ( ih >= 0 ) {
  96                                         const AliHLTTPCCARow &row = tracker.Row( irow );
  97 #ifdef GLOBAL_TRACKING_ONLY_UNASSIGNED_HITS
  98                                         bool own = ( abs(tracker.HitWeight( row, ih )) <= w );
  99 #else
 100                                         bool own = ( tracker.HitWeight( row, ih ) <= w );
 101 #endif
 102                                         bool sharedOK = ( ( nShared < nHits * kMaxShared ) );
 103                                         if ( own || sharedOK ) {//SG!!!
 104                                                 gap = 0;
 105 #if HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
 106                                                 if (nHits < HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE)
 107                                                         s.fHits[iThread][nHits].Set( irow, ih );
 108                                                 else
 109 #endif //HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
 110                                                         trackHits[nHits - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE].Set( irow, ih );
 111                                                 nHits++;
 112                                                 if ( !own ) nShared++;
 113                                         }
 114                                 }
 115
 116                                 if ( gap > kMaxRowGap || irow == lastRow ) { // store
 117                                         if ( nHits >= TRACKLET_SELECTOR_MIN_HITS ) { //SG!!!
 118                                                 int itrout = CAMath::AtomicAdd( tracker.NTracks(), 1 );
 119 #ifdef HLTCA_GPUCODE
 120                                                 if (itrout >= HLTCA_GPU_MAX_TRACKS)
 121                                                 {
 122                                                         tracker.GPUParameters()->fGPUError = HLTCA_GPU_ERROR_TRACK_OVERFLOW;
 123                                                         CAMath::AtomicExch( tracker.NTracks(), 0 );
 124                                                         return;
 125                                                 }
 126 #endif //HLTCA_GPUCODE
 127                                                 nFirstTrackHit = CAMath::AtomicAdd( tracker.NTrackHits(), nHits );
 128                                                 tracker.Tracks()[itrout].SetAlive(1);
 129                                                 tracker.Tracks()[itrout].SetLocalTrackId(itrout);
 130                                                 tracker.Tracks()[itrout].SetParam(tracklet.Param());
 131                                                 tracker.Tracks()[itrout].SetFirstHitID(nFirstTrackHit);
 132                                                 tracker.Tracks()[itrout].SetNHits(nHits);
 133                                                 for ( int jh = 0; jh < nHits; jh++ ) {
 134 #if HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
 135                                                         if (jh < HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE)
 136                                                         {
 137                                                                 tracker.TrackHits()[nFirstTrackHit + jh] = s.fHits[iThread][jh];
 138 #ifdef GLOBAL_TRACKING_ONLY_UNASSIGNED_HITS
 139                                                             tracker.SetHitWeight( tracker.Row( s.fHits[iThread][jh].RowIndex() ), s.fHits[iThread][jh].HitIndex(), -w );
 140 #endif
 141                                                         }
 142                                                         else
 143 #endif //HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
 144                                                         {
 145                                                                 tracker.TrackHits()[nFirstTrackHit + jh] = trackHits[jh - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE];
 146 #ifdef GLOBAL_TRACKING_ONLY_UNASSIGNED_HITS
 147                                                                 tracker.SetHitWeight( tracker.Row( trackHits[jh - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE].RowIndex() ), trackHits[jh - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE].HitIndex(), -w );
 148 #endif
 149                                                         }
 150                                                 }
 151                                         }
 152                                         nHits = 0;
 153                                         gap = 0;
 154                                         nShared = 0;
 155                                 }
 156                         }
 157                 }
 158         }
 159 }