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 GPUd() 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 tNHits = tracklet.NHits();
  61
  62       const int kMaxRowGap = 4;
  63       const float kMaxShared = .1;
  64
  65       int firstRow = tracklet.FirstRow();
  66       int lastRow = tracklet.LastRow();
  67
  68       int kind = 0;
  69       if ( 0 ) {
  70         if ( tNHits >= 10 && 1. / .5 >= CAMath::Abs( tracklet.Param().QPt() ) ) { //SG!!!
  71           kind = 1;
  72         }
  73       }
  74
  75       int w = ( kind << 29 ) + ( tNHits << 16 ) + itr;
  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         gap++;
  89 #ifdef EXTERN_ROW_HITS
  90         int ih = tracker.TrackletRowHits()[irow * s.fNTracklets + itr];
  91 #else
  92                 int ih = tracklet.RowHit( irow );
  93 #endif //EXTERN_ROW_HITS
  94         if ( ih >= 0 ) {
  95           const AliHLTTPCCARow &row = tracker.Row( irow );
  96           bool own = ( tracker.HitWeight( row, ih ) <= w );
  97           bool sharedOK = ( ( nShared < nHits * kMaxShared ) );
  98           if ( own || sharedOK ) {//SG!!!
  99             gap = 0;
 100 #if HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
 101                         if (nHits < HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE)
 102                                 s.fHits[iThread][nHits].Set( irow, ih );
 103                         else
 104 #endif //HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
 105                                 trackHits[nHits - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE].Set( irow, ih );
 106             nHits++;
 107             if ( !own ) nShared++;
 108           }
 109         }
 110
 111         if ( gap > kMaxRowGap || irow == lastRow ) { // store
 112           if ( nHits >= TRACKLET_SELECTOR_MIN_HITS ) { //SG!!!
 113             int itrout = CAMath::AtomicAdd( tracker.NTracks(), 1 );
 114 #ifdef HLTCA_GPUCODE
 115                         if (itrout >= HLTCA_GPU_MAX_TRACKS)
 116                         {
 117                                 tracker.GPUParameters()->fGPUError = HLTCA_GPU_ERROR_TRACK_OVERFLOW;
 118                                 CAMath::AtomicExch( tracker.NTracks(), 0 );
 119                                 return;
 120                         }
 121 #endif //HLTCA_GPUCODE
 122             nFirstTrackHit = CAMath::AtomicAdd( tracker.NTrackHits(), nHits );
 123                         tracker.Tracks()[itrout].SetAlive(1);
 124                         tracker.Tracks()[itrout].SetParam(tracklet.Param());
 125                         tracker.Tracks()[itrout].SetFirstHitID(nFirstTrackHit);
 126                         tracker.Tracks()[itrout].SetNHits(nHits);
 127             for ( int jh = 0; jh < nHits; jh++ ) {
 128 #if HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
 129                                 if (jh < HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE)
 130                                         tracker.TrackHits()[nFirstTrackHit + jh] = s.fHits[iThread][jh];
 131                                 else
 132 #endif //HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
 133                                         tracker.TrackHits()[nFirstTrackHit + jh] = trackHits[jh - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE];
 134             }
 135           }
 136           nHits = 0;
 137           gap = 0;
 138           nShared = 0;
 139         }
 140       }
 141
 142
 143     }
 144   }
 145 }