]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - HLT/TPCLib/tracking-ca/AliHLTTPCCATrackletSelector.cxx
fixing clang issues
[u/mrichter/AliRoot.git] / HLT / TPCLib / tracking-ca / AliHLTTPCCATrackletSelector.cxx
index 16608564d4d77ef71e849046ad03af2cd4f73a8c..61f52aadb0472b6219e4aaaa85d716a21ebf9ab1 100644 (file)
 #include "AliHLTTPCCATracklet.h"
 #include "AliHLTTPCCAMath.h"
 
-GPUd() void AliHLTTPCCATrackletSelector::Thread
+GPUdi() void AliHLTTPCCATrackletSelector::Thread
 ( int nBlocks, int nThreads, int iBlock, int iThread, int iSync,
 AliHLTTPCCASharedMemory &s, AliHLTTPCCATracker &tracker )
GPUsharedref() MEM_LOCAL(AliHLTTPCCASharedMemory) &s, GPUconstant() MEM_CONSTANT(AliHLTTPCCATracker) &tracker )
 {
-  // select best tracklets and kill clones
+       // select best tracklets and kill clones
 
-  if ( iSync == 0 ) {
-    if ( iThread == 0 ) {
-      s.fNTracklets = *tracker.NTracklets();
-      s.fNThreadsTotal = nThreads * nBlocks;
-      s.fItr0 = nThreads * iBlock;
-    }
-  } else if ( iSync == 1 ) {
-       int nHits, nFirstTrackHit;
-       AliHLTTPCCAHitId trackHits[160 - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE];
+       if ( iSync == 0 ) {
+               if ( iThread == 0 ) {
+                       s.fNTracklets = *tracker.NTracklets();
+                       s.fNThreadsTotal = nThreads * nBlocks;
+                       s.fItr0 = nThreads * iBlock;
+               }
+       } else if ( iSync == 1 ) {
+               int nHits, nFirstTrackHit;
+               AliHLTTPCCAHitId trackHits[160 - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE];
 
-    for ( int itr = s.fItr0 + iThread; itr < s.fNTracklets; itr += s.fNThreadsTotal ) {
+               for ( int itr = s.fItr0 + iThread; itr < s.fNTracklets; itr += s.fNThreadsTotal ) {
 
 #ifdef HLTCA_GPU_EMULATION_DEBUG_TRACKLET
-       if (itr == HLTCA_GPU_EMULATION_DEBUG_TRACKLET)
-       {
-               tracker.GPUParameters()->fGPUError = 1;
-       }
+                       if (itr == HLTCA_GPU_EMULATION_DEBUG_TRACKLET)
+                       {
+                               tracker.GPUParameters()->fGPUError = 1;
+                       }
+#endif //HLTCA_GPU_EMULATION_DEBUG_TRACKLET
+
+                       while (tracker.Tracklets()[itr].NHits() == 0)
+                       {
+                               itr += s.fNThreadsTotal;
+                               if (itr >= s.fNTracklets) return;
+                       }
+
+                       GPUglobalref() MEM_GLOBAL(AliHLTTPCCATracklet) &tracklet = tracker.Tracklets()[itr];
+                       const int kMaxRowGap = 4;
+                       const float kMaxShared = .1;
+
+                       int firstRow = tracklet.FirstRow();
+                       int lastRow = tracklet.LastRow();
+                       if (firstRow < 0 || lastRow > tracker.Param().NRows() || tracklet.NHits() < 0)
+                       {
+#ifdef HLTCA_GPU_ALTERNATIVE_SCHEDULER
+                               //tracker.GPUParameters()->fGPUError = HLTCA_GPU_ERROR_WRONG_ROW;
+                               //return;
+#else
+                               continue;
 #endif
+                       }
 
-         while (tracker.Tracklets()[itr].NHits() == 0)
-         {
-                 itr += s.fNThreadsTotal;
-                 if (itr >= s.fNTracklets) return;
-         }
-
-         AliHLTTPCCATracklet &tracklet = tracker.Tracklets()[itr];
-      const int tNHits = tracklet.NHits();
-
-      const int kMaxRowGap = 4;
-      const float kMaxShared = .1;
+                       const int w = tracklet.HitWeight();
 
-      int firstRow = tracklet.FirstRow();
-      int lastRow = tracklet.LastRow();
+                       //int w = (tNHits<<16)+itr;
+                       //int nRows = tracker.Param().NRows();
+                       //std::cout<<" store tracklet: "<<firstRow<<" "<<lastRow<<std::endl;
 
-      int kind = 0;
-      if ( 0 ) {
-        if ( tNHits >= 10 && 1. / .5 >= CAMath::Abs( tracklet.Param().QPt() ) ) { //SG!!!
-          kind = 1;
-        }
-      }
+                       int irow = firstRow;
 
-      int w = ( kind << 29 ) + ( tNHits << 16 ) + itr;
+                       int gap = 0;
+                       int nShared = 0;
+                       nHits = 0;
 
-      //int w = (tNHits<<16)+itr;
-      //int nRows = tracker.Param().NRows();
-      //std::cout<<" store tracklet: "<<firstRow<<" "<<lastRow<<std::endl;
-
-         int irow = firstRow;
-
-      int gap = 0;
-      int nShared = 0;
-         nHits = 0;
-
-         for (irow = firstRow; irow <= lastRow && lastRow - irow + nHits >= TRACKLET_SELECTOR_MIN_HITS; irow++ ) {
-        gap++;
+                       for (irow = firstRow; irow <= lastRow && lastRow - irow + nHits >= TRACKLET_SELECTOR_MIN_HITS; irow++ )
+                       {
+                               gap++;
 #ifdef EXTERN_ROW_HITS
-        int ih = tracker.TrackletRowHits()[irow * s.fNTracklets + itr];
+                               int ih = tracker.TrackletRowHits()[irow * s.fNTracklets + itr];
+#else
+                               int ih = tracklet.RowHit( irow );
+#endif //EXTERN_ROW_HITS
+                               if ( ih >= 0 ) {
+                                       GPUglobalref() const MEM_GLOBAL(AliHLTTPCCARow) &row = tracker.Row( irow );
+#ifdef GLOBAL_TRACKING_ONLY_UNASSIGNED_HITS
+                                       bool own = ( abs(tracker.HitWeight( row, ih )) <= w );
 #else
-               int ih = tracklet.RowHit( irow );
+                                       bool own = ( tracker.HitWeight( row, ih ) <= w );
 #endif
-        if ( ih >= 0 ) {
-          const AliHLTTPCCARow &row = tracker.Row( irow );
-          bool own = ( tracker.HitWeight( row, ih ) <= w );
-          bool sharedOK = ( ( nShared < nHits * kMaxShared ) );
-          if ( own || sharedOK ) {//SG!!!
-            gap = 0;
+                                       bool sharedOK = ( ( nShared < nHits * kMaxShared ) );
+                                       if ( own || sharedOK ) {//SG!!!
+                                               gap = 0;
 #if HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
-                       if (nHits < HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE)
-                               s.fHits[iThread][nHits].Set( irow, ih );
-                       else
-#endif
-                               trackHits[nHits - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE].Set( irow, ih );
-            nHits++;
-            if ( !own ) nShared++;
-          }
-        }
-
-        if ( gap > kMaxRowGap || irow == lastRow ) { // store
-          if ( nHits >= TRACKLET_SELECTOR_MIN_HITS ) { //SG!!!
-            int itrout = CAMath::AtomicAdd( tracker.NTracks(), 1 );
+                                               if (nHits < HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE)
+                                                       s.fHits[iThread][nHits].Set( irow, ih );
+                                               else
+#endif //HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
+                                                       trackHits[nHits - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE].Set( irow, ih );
+                                               nHits++;
+                                               if ( !own ) nShared++;
+                                       }
+                               }
+
+                               if ( gap > kMaxRowGap || irow == lastRow ) { // store
+                                       if ( nHits >= TRACKLET_SELECTOR_MIN_HITS ) { //SG!!!
+                                               int itrout = CAMath::AtomicAdd( tracker.NTracks(), 1 );
 #ifdef HLTCA_GPUCODE
-                       if (itrout >= HLTCA_GPU_MAX_TRACKS)\r
-                       {\r
-                               tracker.GPUParameters()->fGPUError = HLTCA_GPU_ERROR_TRACK_OVERFLOW;\r
-                               CAMath::AtomicExch( tracker.NTracks(), 0 );\r
-                               return;\r
-                       }\r
-#endif
-            nFirstTrackHit = CAMath::AtomicAdd( tracker.NTrackHits(), nHits );
-                       tracker.Tracks()[itrout].SetAlive(1);
-                       tracker.Tracks()[itrout].SetParam(tracklet.Param());
-                       tracker.Tracks()[itrout].SetFirstHitID(nFirstTrackHit);
-                       tracker.Tracks()[itrout].SetNHits(nHits);
-            for ( int jh = 0; jh < nHits; jh++ ) {
+                                               if (itrout >= HLTCA_GPU_MAX_TRACKS)
+                                               {
+                                                       tracker.GPUParameters()->fGPUError = HLTCA_GPU_ERROR_TRACK_OVERFLOW;
+                                                       CAMath::AtomicExch( tracker.NTracks(), 0 );
+                                                       return;
+                                               }
+#endif //HLTCA_GPUCODE
+                                               nFirstTrackHit = CAMath::AtomicAdd( tracker.NTrackHits(), nHits );
+                                               tracker.Tracks()[itrout].SetAlive(1);
+                                               tracker.Tracks()[itrout].SetLocalTrackId(itrout);
+                                               tracker.Tracks()[itrout].SetParam(tracklet.Param());
+                                               tracker.Tracks()[itrout].SetFirstHitID(nFirstTrackHit);
+                                               tracker.Tracks()[itrout].SetNHits(nHits);
+                                               for ( int jh = 0; jh < nHits; jh++ ) {
 #if HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
-                               if (jh < HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE)
-                                       tracker.TrackHits()[nFirstTrackHit + jh] = s.fHits[iThread][jh];
-                               else
+                                                       if (jh < HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE)
+                                                       {
+                                                               tracker.TrackHits()[nFirstTrackHit + jh] = s.fHits[iThread][jh];
+#ifdef GLOBAL_TRACKING_ONLY_UNASSIGNED_HITS
+                                                           tracker.SetHitWeight( tracker.Row( s.fHits[iThread][jh].RowIndex() ), s.fHits[iThread][jh].HitIndex(), -w );
 #endif
-                                       tracker.TrackHits()[nFirstTrackHit + jh] = trackHits[jh - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE];
-            }
-          }
-          nHits = 0;
-          gap = 0;
-          nShared = 0;
-        }
-      }
-
-
-    }
-  }
+                                                       }
+                                                       else
+#endif //HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
+                                                       {
+                                                               tracker.TrackHits()[nFirstTrackHit + jh] = trackHits[jh - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE];
+#ifdef GLOBAL_TRACKING_ONLY_UNASSIGNED_HITS
+                                                               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 );
+#endif
+                                                       }
+                                               }
+                                       }
+                                       nHits = 0;
+                                       gap = 0;
+                                       nShared = 0;
+                               }
+                       }
+               }
+       }
 }