cosmetic changes
authorsgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 16 Oct 2009 04:22:39 +0000 (04:22 +0000)
committersgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 16 Oct 2009 04:22:39 +0000 (04:22 +0000)
13 files changed:
HLT/ITS/tracking/AliITStrackerHLT.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUConfig.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.h
HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursFinder.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCASliceData.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAStandaloneFramework.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerFramework.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerFramework.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackletConstructor.cxx

index ed2bbe2..c4628a2 100644 (file)
@@ -808,10 +808,10 @@ void AliITStrackerHLT::FollowProlongationTree(AliHLTITSTrack * track )
      Bool_t deadzoneSPD=kFALSE;
 
      // check if the road contains a dead zone 
-     Bool_t noClusters = !layer.GetNextCluster(clidx,kTRUE);
+     //Bool_t noClusters = !layer.GetNextCluster(clidx,kTRUE);
      
-     Double_t dz=0.5*(zmax-zmin);
-     Double_t dy=0.5*(ymax-ymin);
+     //Double_t dz=0.5*(zmax-zmin);
+     //Double_t dy=0.5*(ymax-ymin);
      
      Int_t dead = 0;//CheckDeadZone(track,ilayer,idet,dz,dy,noClusters); 
 
index 55becd4..47da945 100644 (file)
@@ -1,15 +1,15 @@
-#ifndef ALIHLTTPCCAGPUCONFIG_H\r
-#define ALIHLTTPCCAGPUCONFIG_H\r
-\r
-#define HLTCA_GPU_BLOCK_COUNT 30\r
-#define HLTCA_GPU_THREAD_COUNT 256\r
-\r
-#define HLTCA_GPU_WARP_SIZE 32\r
-#define HLTCA_GPU_REGS 64\r
-#define HLTCA_ROW_COUNT 159\r
-\r
-#define HLTCA_GPU_ROWALIGNMENT uint4\r
-#define HLTCA_GPU_ROWCOPY int\r
+#ifndef ALIHLTTPCCAGPUCONFIG_H
+#define ALIHLTTPCCAGPUCONFIG_H
+
+#define HLTCA_GPU_BLOCK_COUNT 30
+#define HLTCA_GPU_THREAD_COUNT 256
+
+#define HLTCA_GPU_WARP_SIZE 32
+#define HLTCA_GPU_REGS 64
+#define HLTCA_ROW_COUNT 159
+
+#define HLTCA_GPU_ROWALIGNMENT uint4
+#define HLTCA_GPU_ROWCOPY int
 #define HLTCA_GPU_TRACKLET_CONSTRUCTOR_NMEMTHREDS 32
 //#define HLTCA_GPU_PREFETCHDATA
 //#define HLTCA_GPU_PREFETCH_ROWBLOCK_ONLY
@@ -30,7 +30,7 @@
 #define HLTCA_GPU_SORT_DUMPDATA
 
 #define HLTCA_GPU_MAX_TRACKLETS 12288                                  //Should be divisible by 16 at least
-#define HLTCA_GPU_MAX_TRACKS 3072\r
+#define HLTCA_GPU_MAX_TRACKS 3072
 
 //#define HLTCA_GPU_EMULATION_SINGLE_TRACKLET 1313
 //#define HLTCA_GPU_EMULATION_DEBUG_TRACKLET 1313
@@ -67,8 +67,9 @@
 
 #define HLTCA_GPU_ERROR_NONE 0
 #define HLTCA_GPU_ERROR_ROWBLOCK_TRACKLET_OVERFLOW 1
-#define HLTCA_GPU_ERROR_TRACKLET_OVERFLOW 2\r
-#define HLTCA_GPU_ERROR_TRACK_OVERFLOW 3\r
-#define HLTCA_GPU_ERROR_SCHEDULE_COLLISION 4\r
+#define HLTCA_GPU_ERROR_TRACKLET_OVERFLOW 2
+#define HLTCA_GPU_ERROR_TRACK_OVERFLOW 3
+#define HLTCA_GPU_ERROR_SCHEDULE_COLLISION 4
+
+#endif
 
-#endif
\ No newline at end of file
index deb6aaf..6d68410 100644 (file)
@@ -35,6 +35,6 @@ void AliHLTTPCCAGPUTracker::SetDebugLevel(int /*dwLevel*/, std::ostream* /*NewOu
 int AliHLTTPCCAGPUTracker::SetGPUTrackerOption(char* /*OptionName*/, int /*OptionValue*/) {return(1);}
 int AliHLTTPCCAGPUTracker::Reconstruct(AliHLTTPCCASliceOutput** /*pTracker*/, AliHLTTPCCAClusterData* /*pClusterData*/, int /*fFirstSlice*/, int /*fSliceCount*/) {return(1);}
 int AliHLTTPCCAGPUTracker::ExitGPU() {return(0);}
-int AliHLTTPCCAGPUTracker::InitializeSliceParam(int /*iSlice*/, AliHLTTPCCAParam& /*param*/) {}
+int AliHLTTPCCAGPUTracker::InitializeSliceParam(int /*iSlice*/, AliHLTTPCCAParam& /*param*/) { return 1; }
 void AliHLTTPCCAGPUTracker::SetOutputControl( AliHLTTPCCASliceOutput::outputControlStruct* /*val*/) {};
 #endif
index 3d3f007..7a88954 100644 (file)
@@ -91,4 +91,4 @@ private:
        ClassDef( AliHLTTPCCAGPUTracker, 0 )
 };
 
-#endif
\ No newline at end of file
+#endif
index 715754f..b9cb284 100644 (file)
@@ -21,6 +21,7 @@
 #include "AliHLTTPCCAMath.h"
 #include "AliHLTTPCCAHitArea.h"
 #include "AliHLTTPCCATracker.h"
+#include "AliHLTTPCCAHit.h"
 
 //#define DRAW
 
index 5dd8e67..3175bae 100644 (file)
@@ -152,8 +152,8 @@ size_t AliHLTTPCCASliceData::SetPointers(const AliHLTTPCCAClusterData *data, boo
        //Calculate Memory needed to store hits in rows
 
   const int numberOfRows = data->LastRow() - data->FirstRow() + 1;
-  enum { kVectorAlignment = 256 /*sizeof( uint4 )*/ };
-  fNumberOfHitsPlusAlign = NextMultipleOf < (kVectorAlignment > sizeof(HLTCA_GPU_ROWALIGNMENT) ? kVectorAlignment : sizeof(HLTCA_GPU_ROWALIGNMENT)) / sizeof( int ) > ( hitMemCount );
+  const unsigned int kVectorAlignment = 256 /*sizeof( uint4 )*/ ;
+  fNumberOfHitsPlusAlign = NextMultipleOf < ( kVectorAlignment > sizeof(HLTCA_GPU_ROWALIGNMENT) ? kVectorAlignment : sizeof(HLTCA_GPU_ROWALIGNMENT)) / sizeof( int ) > ( hitMemCount );
   fNumberOfHits = data->NumberOfClusters();
   const int firstHitInBinSize = (23 + sizeof(HLTCA_GPU_ROWALIGNMENT) / sizeof(int)) * numberOfRows + 4 * fNumberOfHits + 3;
   //FIXME: sizeof(HLTCA_GPU_ROWALIGNMENT) / sizeof(int) * numberOfRows is way to big and only to ensure to reserve enough memory for GPU Alignment.
index 2bca15a..e0e3b7f 100644 (file)
@@ -277,4 +277,4 @@ void AliHLTTPCCAStandaloneFramework::ReadTracks( std::istream &in )
     fStatTime[i] += fLastTime[i];
   }
   //fMerger.Output()->Read( in );
-}
\ No newline at end of file
+}
index 1ad004a..ea4dcd9 100644 (file)
 
 #include "AliHLTTPCCATracker.h"
 #include "AliHLTTPCCAOutTrack.h"
-#include "AliHLTTPCCAGrid.h"
 #include "AliHLTTPCCARow.h"
 #include "AliHLTTPCCATrack.h"
 #include "AliHLTTPCCATracklet.h"
 #include "AliHLTTPCCAMath.h"
-#include "AliHLTTPCCAHit.h"
 #include "MemoryAssignmentHelpers.h"
 
 #include "TStopwatch.h"
 #include "AliHLTTPCCAProcess.h"
 #include "AliHLTTPCCASliceTrack.h"
 #include "AliHLTTPCCASliceOutput.h"
-#include "AliHLTTPCCADataCompressor.h"
 #include "AliHLTTPCCAClusterData.h"
 
 #include "AliHLTTPCCATrackParam.h"
 
 #include "AliHLTTPCCAGPUConfig.h"
-#include "AliHLTTPCCAGPUTracker.h"
 
 #if !defined(HLTCA_GPUCODE)
 #include <iostream>
+#include <iomanip>
 #include <string.h>
 #endif
 
@@ -57,7 +54,7 @@
 #endif //DRAW
 
 #ifdef HLTCA_INTERNAL_PERFORMANCE
-#include "AliHLTTPCCAPerformance.h"
+//#include "AliHLTTPCCAPerformance.h"
 #endif
 
 #ifdef HLTCA_STANDALONE
@@ -109,8 +106,8 @@ void AliHLTTPCCATracker::SetGPUTracker()
 
 char* AliHLTTPCCATracker::SetGPUTrackerCommonMemory(char* pGPUMemory)
 {
-       fCommonMem = (commonMemoryStruct*) pGPUMemory;
-       return(pGPUMemory + sizeof(commonMemoryStruct));
+  fCommonMem = (commonMemoryStruct*) pGPUMemory;
+  return(pGPUMemory + sizeof(commonMemoryStruct));
 }
 
 
@@ -192,7 +189,7 @@ void AliHLTTPCCATracker::DumpHitWeights(std::ostream &out)
     }
 }
 
-int AliHLTTPCCATracker::starthitSortComparison(const void*a, const void* b)
+int AliHLTTPCCATracker::StarthitSortComparison(const void*a, const void* b)
 {
        AliHLTTPCCAHitId* aa = (AliHLTTPCCAHitId*) a;
        AliHLTTPCCAHitId* bb = (AliHLTTPCCAHitId*) b;
@@ -205,7 +202,7 @@ void AliHLTTPCCATracker::DumpStartHits(std::ostream &out)
 {
        out << "Start Hits: (" << *NTracklets() << ")" << endl;
 #ifdef HLTCA_GPU_SORT_DUMPDATA
-       qsort(TrackletStartHits(), *NTracklets(), sizeof(AliHLTTPCCAHitId), starthitSortComparison);
+       qsort(TrackletStartHits(), *NTracklets(), sizeof(AliHLTTPCCAHitId), StarthitSortComparison);
 #endif
        for (int i = 0;i < *NTracklets();i++)
        {
@@ -257,7 +254,7 @@ void AliHLTTPCCATracker::DumpTrackletHits(std::ostream &out)
        int* tmpHits = new int[*NTracklets() * Param().NRows()];
        memcpy(tmpHits, TrackletRowHits(), *NTracklets() * Param().NRows() * sizeof(int));
 #endif
-       qsort(TrackletStartHits(), *NTracklets(), sizeof(AliHLTTPCCAHitId), starthitSortComparison);
+       qsort(TrackletStartHits(), *NTracklets(), sizeof(AliHLTTPCCAHitId), StarthitSortComparison);
        for (int i = 0;i < *NTracklets();i++)
        {
                for (int j = 0;j < *NTracklets();j++)
@@ -406,17 +403,17 @@ GPUhd() void  AliHLTTPCCATracker::SetPointersTracks( int MaxNTracks, int MaxNHit
   fTrackMemorySize = mem - fTrackMemory;
 }
 
-GPUh() int AliHLTTPCCATracker::CheckEmptySlice()
+GPUh() int AliHLTTPCCATracker::CheckEmptySlice() const
 {
   if ( NHitsTotal() < 1 ) {
     {
-         AliHLTTPCCASliceOutput::Allocate(*fOutput, 0, 0, fOutputControl);
-         AliHLTTPCCASliceOutput* useOutput = *fOutput;
-         if (fOutput == NULL) return(1);
+      AliHLTTPCCASliceOutput::Allocate(*fOutput, 0, 0, fOutputControl);
+      AliHLTTPCCASliceOutput* useOutput = *fOutput;
+      if (fOutput == NULL) return(1);
       useOutput->SetNTracks( 0 );
       useOutput->SetNTrackClusters( 0 );
-         useOutput->SetNOutTracks(0);
-         useOutput->SetNOutTrackHits(0);
+      useOutput->SetNOutTracks(0);
+      useOutput->SetNOutTrackHits(0);
     }
 
     return 1;
@@ -441,7 +438,7 @@ void AliHLTTPCCATracker::RunStartHitsFinder()
 
 void AliHLTTPCCATracker::RunTrackletConstructor()
 {
-    AliHLTTPCCATrackletConstructor::AliHLTTPCCATrackletConstructorNewCPU(*this);
+  AliHLTTPCCATrackletConstructor::AliHLTTPCCATrackletConstructorNewCPU(*this);
 }
 
 void AliHLTTPCCATracker::RunTrackletSelector()
@@ -454,7 +451,7 @@ void AliHLTTPCCATracker::StandalonePerfTime(int i)
 {
   if (fGPUDebugLevel >= 1)
   {
-         AliHLTTPCCAStandaloneFramework::StandaloneQueryTime(&fPerfTimers[i]);
+    AliHLTTPCCAStandaloneFramework::StandaloneQueryTime(&fPerfTimers[i]);
   }
 }
 #else
index a894c6d..0468d5f 100644 (file)
 #include "AliHLTTPCCADef.h"
 #include "AliHLTTPCCAGPUConfig.h"
 #include "AliHLTTPCCAParam.h"
-#include "AliHLTTPCCARow.h"
-#include "AliHLTTPCCAHit.h"
 #include <iostream>
-#include "AliHLTArray.h"
 #include "AliHLTTPCCAHitId.h"
 #include "AliHLTTPCCASliceData.h"
-#include "AliHLTTPCCATracklet.h"
-#include "AliHLTTPCCAOutTrack.h"
 #include "AliHLTTPCCASliceOutput.h"
 #include "AliHLTTPCCATrackletConstructor.h"
+#include "AliHLTTPCCATracklet.h"
 
 class AliHLTTPCCATrack;
 class AliHLTTPCCATrackParam;
 class AliHLTTPCCAClusterData;
+class AliHLTTPCCARow;
 
 /**
  * @class AliHLTTPCCATracker
@@ -48,282 +45,283 @@ class AliHLTTPCCATracker
 {
   public:
 
-       AliHLTTPCCATracker()
-               : fParam(),
-               fOutputControl(),
-               fClusterData( 0 ),
-               fData(),
-               fIsGPUTracker( false ),
-               fGPUDebugLevel( 0 ),
-               fGPUDebugOut( 0 ),
-               fRowStartHitCountOffset( NULL ),
-               fTrackletTmpStartHits( NULL ),
-               fGPUTrackletTemp( NULL ),
-               fRowBlockTracklets( NULL ),
-               fRowBlockPos( NULL ),
-               fBlockStartingTracklet( NULL ),
-               fGPUParametersConst(),
-               fCommonMem( 0 ),
-               fHitMemory( 0 ),
-               fHitMemorySize( 0 ),
-               fTrackletMemory( 0 ),
-               fTrackletMemorySize( 0 ),
-               fTrackMemory( 0 ),
-               fTrackMemorySize( 0 ),
-               fTrackletStartHits( 0 ),
-               fTracklets( 0 ),
-               fTrackletRowHits( NULL ),
-               fTracks( 0 ),
-               fTrackHits( 0 ),
-               fOutput( 0 )
-       {
-         // constructor
-       }
-    ~AliHLTTPCCATracker();
-
-       struct StructGPUParameters
-       {
-               StructGPUParameters() : fScheduleFirstDynamicTracklet( 0 ), fGPUError( 0 ) {}
-               int fScheduleFirstDynamicTracklet;              //Last Tracklet with fixed position in sheduling
-               int fGPUError;                                                  //Signalizes error on GPU during GPU Reconstruction, kind of return value
-       };
-
-       struct StructGPUParametersConst
-       {
-               StructGPUParametersConst() : fGPUFixedBlockCount( 0 ), fGPUiSlice( 0 ), fGPUnSlices( 0 ) {}
-               int fGPUFixedBlockCount;                                //Count of blocks that is used for this tracker in fixed schedule situations
-               int fGPUiSlice;
-               int fGPUnSlices;
-       };
-
-       struct commonMemoryStruct
-       {
-               commonMemoryStruct() : fNTracklets( 0 ), fNTracks( 0 ), fNTrackHits( 0 ), fGPUParameters() {}
-           int fNTracklets;     // number of tracklets
-           int fNTracks;            // number of reconstructed tracks
-           int fNTrackHits;           // number of track hits
-               StructGPUParameters fGPUParameters;
-       };
-
-    void Initialize( const AliHLTTPCCAParam &param );
-
-    void StartEvent();
-
-       int CheckEmptySlice();
-       void WriteOutput();
-
+  AliHLTTPCCATracker()
+    : fParam(),
+      fOutputControl(),
+      fClusterData( 0 ),
+      fData(),
+      fIsGPUTracker( false ),
+      fGPUDebugLevel( 0 ),
+      fGPUDebugOut( 0 ),
+      fRowStartHitCountOffset( NULL ),
+      fTrackletTmpStartHits( NULL ),
+      fGPUTrackletTemp( NULL ),
+      fRowBlockTracklets( NULL ),
+      fRowBlockPos( NULL ),
+      fBlockStartingTracklet( NULL ),
+      fGPUParametersConst(),
+      fCommonMem( 0 ),
+      fHitMemory( 0 ),
+      fHitMemorySize( 0 ),
+      fTrackletMemory( 0 ),
+      fTrackletMemorySize( 0 ),
+      fTrackMemory( 0 ),
+      fTrackMemorySize( 0 ),
+      fTrackletStartHits( 0 ),
+      fTracklets( 0 ),
+      fTrackletRowHits( NULL ),
+      fTracks( 0 ),
+      fTrackHits( 0 ),
+      fOutput( 0 )
+  {
+    // constructor
+  }
+  ~AliHLTTPCCATracker();
+  
+  struct StructGPUParameters
+  {
+    StructGPUParameters() : fScheduleFirstDynamicTracklet( 0 ), fGPUError( 0 ) {}
+    int fScheduleFirstDynamicTracklet;         //Last Tracklet with fixed position in sheduling
+    int fGPUError;                                                     //Signalizes error on GPU during GPU Reconstruction, kind of return value
+  };
+  
+  struct StructGPUParametersConst
+  {
+    StructGPUParametersConst() : fGPUFixedBlockCount( 0 ), fGPUiSlice( 0 ), fGPUnSlices( 0 ) {}
+    int fGPUFixedBlockCount;                           //Count of blocks that is used for this tracker in fixed schedule situations
+    int fGPUiSlice; // slice number
+    int fGPUnSlices; // n of slices
+  };
+  
+  struct commonMemoryStruct
+  {
+    commonMemoryStruct() : fNTracklets( 0 ), fNTracks( 0 ), fNTrackHits( 0 ), fGPUParameters() {}
+    int fNTracklets;     // number of tracklets
+    int fNTracks;            // number of reconstructed tracks
+    int fNTrackHits;           // number of track hits
+    StructGPUParameters fGPUParameters; // GPU parameters
+  };
+  
+  void Initialize( const AliHLTTPCCAParam &param );
+  
+  void StartEvent();
+  
+  int CheckEmptySlice() const;
+  void WriteOutput();
+  
 #if !defined(HLTCA_GPUCODE)
-    void Reconstruct();
+  void Reconstruct();
 #endif
-
-       //Make Reconstruction steps directly callable (Used for GPU debugging)
-       void RunNeighboursFinder();
-       void RunNeighboursCleaner();
-       void RunStartHitsFinder();
-       void RunTrackletConstructor();
-       void RunTrackletSelector();
-
-       //GPU Tracker Interface
-       void SetGPUTracker();
-       void SetGPUDebugLevel(int Level, std::ostream *NewDebugOut = NULL) {fGPUDebugLevel = Level;if (NewDebugOut) fGPUDebugOut = NewDebugOut;}
-
-       char* SetGPUTrackerCommonMemory(char* pGPUMemory);
-       char* SetGPUTrackerHitsMemory(char* pGPUMemory, int MaxNHits);
-       char* SetGPUTrackerTrackletsMemory(char* pGPUMemory, int MaxNTracklets);
-       char* SetGPUTrackerTracksMemory(char* pGPUMemory, int MaxNTracks, int MaxNHits );
-
-       //Debugging Stuff
-       void DumpSliceData(std::ostream &out);  //Dump Input Slice Data
-       void DumpLinks(std::ostream &out);              //Dump all links to file (for comparison after NeighboursFinder/Cleaner)
-       void DumpStartHits(std::ostream &out);  //Same for Start Hits
-       void DumpHitWeights(std::ostream &out); //....
-       void DumpTrackHits(std::ostream &out);  //Same for Track Hits
-       void DumpTrackletHits(std::ostream &out);       //Same for Track Hits
-
-    GPUd() void GetErrors2( int iRow,  const AliHLTTPCCATrackParam &t, float &Err2Y, float &Err2Z ) const;
-    GPUd() void GetErrors2( int iRow, float z, float sinPhi, float cosPhi, float DzDs, float &Err2Y, float &Err2Z ) const;
-
-    void FitTrack( const AliHLTTPCCATrack &track, float *t0 = 0 ) const;
-    void FitTrackFull( const AliHLTTPCCATrack &track, float *t0 = 0 ) const;
-
-    void SetupCommonMemory();
-    void SetPointersHits( int MaxNHits );
-       void SetPointersTracklets ( int MaxNTracklets );
-    void SetPointersTracks( int MaxNTracks, int MaxNHits );
-
-       void SetOutput( AliHLTTPCCASliceOutput** out ) { fOutput = out; }
-
-    void ReadEvent( AliHLTTPCCAClusterData *clusterData );
-
+  
+  //Make Reconstruction steps directly callable (Used for GPU debugging)
+  void RunNeighboursFinder();
+  void RunNeighboursCleaner();
+  void RunStartHitsFinder();
+  void RunTrackletConstructor() ;
+  void RunTrackletSelector();
+  
+  //GPU Tracker Interface
+  void SetGPUTracker();
+  void SetGPUDebugLevel(int Level, std::ostream *NewDebugOut = NULL) {fGPUDebugLevel = Level;if (NewDebugOut) fGPUDebugOut = NewDebugOut;}
+  
+  char* SetGPUTrackerCommonMemory(char* pGPUMemory);
+  char* SetGPUTrackerHitsMemory(char* pGPUMemory, int MaxNHits);
+  char* SetGPUTrackerTrackletsMemory(char* pGPUMemory, int MaxNTracklets);
+  char* SetGPUTrackerTracksMemory(char* pGPUMemory, int MaxNTracks, int MaxNHits );
+  
+  //Debugging Stuff
+  void DumpSliceData(std::ostream &out);       //Dump Input Slice Data
+  void DumpLinks(std::ostream &out);           //Dump all links to file (for comparison after NeighboursFinder/Cleaner)
+  void DumpStartHits(std::ostream &out);       //Same for Start Hits
+  void DumpHitWeights(std::ostream &out); //....
+  void DumpTrackHits(std::ostream &out);       //Same for Track Hits
+  void DumpTrackletHits(std::ostream &out);    //Same for Track Hits
+  
+  GPUd() void GetErrors2( int iRow,  const AliHLTTPCCATrackParam &t, float &Err2Y, float &Err2Z ) const;
+  GPUd() void GetErrors2( int iRow, float z, float sinPhi, float cosPhi, float DzDs, float &Err2Y, float &Err2Z ) const;
+  
+  void FitTrack( const AliHLTTPCCATrack &track, float *t0 = 0 ) const;
+  void FitTrackFull( const AliHLTTPCCATrack &track, float *t0 = 0 ) const;
+  
+  void SetupCommonMemory();
+  void SetPointersHits( int MaxNHits );
+  void SetPointersTracklets ( int MaxNTracklets );
+  void SetPointersTracks( int MaxNTracks, int MaxNHits );
+  
+  void SetOutput( AliHLTTPCCASliceOutput** out ) { fOutput = out; }
+  
+  void ReadEvent( AliHLTTPCCAClusterData *clusterData );
+  
 #if !defined(HLTCA_GPUCODE)
-    GPUh() void WriteEvent( std::ostream &out );
-    GPUh() void WriteTracks( std::ostream &out ) ;
-    GPUh() void ReadTracks( std::istream &in );
+  GPUh() void WriteEvent( std::ostream &out );
+  GPUh() void WriteTracks( std::ostream &out ) ;
+  GPUh() void ReadTracks( std::istream &in );
 #endif
-
-    GPUhd() const AliHLTTPCCAParam &Param() const { return fParam; }
-    GPUhd() void SetParam( const AliHLTTPCCAParam &v ) { fParam = v; }
-
-       GPUhd() const AliHLTTPCCASliceOutput::outputControlStruct* OutputControl() const { return fOutputControl; }
-       GPUh() void SetOutputControl( AliHLTTPCCASliceOutput::outputControlStruct* val) { fOutputControl = val; }
-
-    GPUhd() AliHLTTPCCAClusterData *ClusterData() const { return fClusterData; }
-    GPUhd() const AliHLTTPCCASliceData &Data() const { return fData; }
-       GPUhd() AliHLTTPCCASliceData *pData() {return &fData; }
-
-       GPUh() void ClearSliceDataHitWeights() {fData.ClearHitWeights();}
-
-    GPUhd() const AliHLTTPCCARow &Row( int rowIndex ) const { return fData.Row( rowIndex ); }
-    GPUh() const AliHLTTPCCARow &Row( const AliHLTTPCCAHitId &HitId ) const { return fData.Row( HitId.RowIndex() ); }
-
-    GPUhd() double Timer( int i ) const { return fTimers[i]; }
-    GPUhd() void SetTimer( int i, double v ) { fTimers[i] = v; }
-
-    GPUhd() int NHitsTotal() const { return fData.NumberOfHits(); }
-
-    GPUd() void SetHitLinkUpData( const AliHLTTPCCARow &row, int hitIndex, short v ) { fData.SetHitLinkUpData( row, hitIndex, v ); }
-    GPUd() void SetHitLinkDownData( const AliHLTTPCCARow &row, int hitIndex, short v ) { fData.SetHitLinkDownData( row, hitIndex, v ); }
-    GPUd() short HitLinkUpData( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.HitLinkUpData( row, hitIndex ); }
-    GPUd() short HitLinkDownData( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.HitLinkDownData( row, hitIndex ); }
-
-       GPUd() const ushort2 *HitData( const AliHLTTPCCARow &row ) const { return fData.HitData(row); }
-       GPUd() const short_v *HitLinkUpData  ( const AliHLTTPCCARow &row ) const { return fData.HitLinkUpData(row); }
-       GPUd() const short_v *HitLinkDownData( const AliHLTTPCCARow &row ) const { return fData.HitLinkDownData(row); }
-       GPUd() const ushort_v *FirstHitInBin( const AliHLTTPCCARow &row ) const { return fData.FirstHitInBin(row); }
-       
-       GPUd() int FirstHitInBin( const AliHLTTPCCARow &row, int binIndex ) const { return fData.FirstHitInBin( row, binIndex ); }
-
-    GPUd() unsigned short HitDataY( const AliHLTTPCCARow &row, int hitIndex ) const {
-      return fData.HitDataY( row, hitIndex );
-    }
-    GPUd() unsigned short HitDataZ( const AliHLTTPCCARow &row, int hitIndex ) const {
-      return fData.HitDataZ( row, hitIndex );
-    }
-    GPUd() ushort2 HitData( const AliHLTTPCCARow &row, int hitIndex ) const {
-      return fData.HitData( row, hitIndex );
-    }
-
-    GPUhd() int HitInputID( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.ClusterDataIndex( row, hitIndex ); }
-
-    /**
-     * The hit weight is used to determine whether a hit belongs to a certain tracklet or another one
-     * competing for the same hit. The tracklet that has a higher weight wins. Comparison is done
-     * using the the number of hits in the tracklet (the more hits it has the more it keeps). If
-     * tracklets have the same number of hits then it doesn't matter who gets it, but it should be
-     * only one. So a unique number (row index is good) is added in the least significant part of
-     * the weight
-     */
-    static int CalculateHitWeight( int NHits, int unique ) {
-      return ( NHits << 16 ) + unique;
-    }
-    GPUd() void MaximizeHitWeight( const AliHLTTPCCARow &row, int hitIndex, int weight ) {
-      fData.MaximizeHitWeight( row, hitIndex, weight );
-    }
-    GPUd() int HitWeight( const AliHLTTPCCARow &row, int hitIndex ) const {
-      return fData.HitWeight( row, hitIndex );
-    }
-
-    GPUhd() int NTracklets() const { return fCommonMem->fNTracklets; }
-    GPUhd() int  *NTracklets() { return &fCommonMem->fNTracklets; }
-
-    GPUhd() const AliHLTTPCCAHitId &TrackletStartHit( int i ) const { return fTrackletStartHits[i]; }
-    GPUhd() AliHLTTPCCAHitId *TrackletStartHits() const { return fTrackletStartHits; }
-    GPUhd() AliHLTTPCCAHitId *TrackletTmpStartHits() const { return fTrackletTmpStartHits; }
-    GPUhd() const AliHLTTPCCATracklet &Tracklet( int i ) const { return fTracklets[i]; }
-    GPUhd() AliHLTTPCCATracklet  *Tracklets() const { return fTracklets;}
-       GPUhd() int* TrackletRowHits() { return fTrackletRowHits; }
-
-    GPUhd() int *NTracks()  const { return &fCommonMem->fNTracks; }
-    GPUhd() AliHLTTPCCATrack *Tracks() const { return  fTracks; }
-    GPUhd() int *NTrackHits()  const { return &fCommonMem->fNTrackHits; }
-    GPUhd() AliHLTTPCCAHitId *TrackHits() const { return fTrackHits; }
-
-    GPUhd() AliHLTTPCCASliceOutput** Output() const { return fOutput; }
-
-       GPUh() commonMemoryStruct *CommonMemory() {return(fCommonMem); }
-       static GPUh() size_t CommonMemorySize() { return(sizeof(AliHLTTPCCATracker::commonMemoryStruct)); }
-       GPUh() char* &HitMemory() {return(fHitMemory); }
-       GPUh() size_t HitMemorySize() const {return(fHitMemorySize); }
-       GPUh() char* &TrackletMemory() {return(fTrackletMemory); }
-       GPUh() size_t TrackletMemorySize() const {return(fTrackletMemorySize); }
-       GPUh() char* &TrackMemory() {return(fTrackMemory); }
-       GPUh() size_t TrackMemorySize() const {return(fTrackMemorySize); }
-       GPUhd() AliHLTTPCCARow* SliceDataRows() {return(fData.Rows()); }
-
-       GPUhd() uint3* RowStartHitCountOffset() const {return(fRowStartHitCountOffset);}
-       GPUhd() AliHLTTPCCATrackletConstructor::AliHLTTPCCAGPUTempMemory* GPUTrackletTemp() const {return(fGPUTrackletTemp);}
-       GPUhd() int* RowBlockTracklets(int reverse, int iRowBlock) const {return(&fRowBlockTracklets[(reverse * ((fParam.NRows() / HLTCA_GPU_SCHED_ROW_STEP) + 1) + iRowBlock) * fCommonMem->fNTracklets]);}
-       GPUhd() int* RowBlockTracklets() const {return(fRowBlockTracklets);}
-       GPUhd() int4* RowBlockPos(int reverse, int iRowBlock) const {return(&fRowBlockPos[reverse * ((fParam.NRows() / HLTCA_GPU_SCHED_ROW_STEP) + 1) + iRowBlock]);}
-       GPUhd() int4* RowBlockPos() const {return(fRowBlockPos);}
-       GPUhd() uint2* BlockStartingTracklet() const {return(fBlockStartingTracklet);}
-       GPUhd() StructGPUParameters* GPUParameters() const {return(&fCommonMem->fGPUParameters);}
-       GPUhd() StructGPUParametersConst* GPUParametersConst() {return(&fGPUParametersConst);}
-       
-       GPUh() unsigned long long int* PerfTimer(unsigned int i) {return &fPerfTimers[i]; }
-
+  
+  GPUhd() const AliHLTTPCCAParam &Param() const { return fParam; }
+  GPUhd() void SetParam( const AliHLTTPCCAParam &v ) { fParam = v; }
+  
+  GPUhd() const AliHLTTPCCASliceOutput::outputControlStruct* OutputControl() const { return fOutputControl; }
+  GPUh() void SetOutputControl( AliHLTTPCCASliceOutput::outputControlStruct* val)      { fOutputControl = val; }
+  
+  GPUhd() AliHLTTPCCAClusterData *ClusterData() const { return fClusterData; }
+  GPUhd() const AliHLTTPCCASliceData &Data() const { return fData; }
+  GPUhd() AliHLTTPCCASliceData *PData() {return &fData; }
+  
+  GPUh() void ClearSliceDataHitWeights() {fData.ClearHitWeights();}
+  
+  GPUhd() const AliHLTTPCCARow &Row( int rowIndex ) const { return fData.Row( rowIndex ); }
+  GPUh() const AliHLTTPCCARow &Row( const AliHLTTPCCAHitId &HitId ) const { return fData.Row( HitId.RowIndex() ); }
+  
+  GPUhd() double Timer( int i ) const { return fTimers[i]; }
+  GPUhd() void SetTimer( int i, double v ) { fTimers[i] = v; }
+  
+  GPUhd() int NHitsTotal() const { return fData.NumberOfHits(); }
+  
+  GPUd() void SetHitLinkUpData( const AliHLTTPCCARow &row, int hitIndex, short v ) { fData.SetHitLinkUpData( row, hitIndex, v ); }
+  GPUd() void SetHitLinkDownData( const AliHLTTPCCARow &row, int hitIndex, short v ) { fData.SetHitLinkDownData( row, hitIndex, v ); }
+  GPUd() short HitLinkUpData( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.HitLinkUpData( row, hitIndex ); }
+  GPUd() short HitLinkDownData( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.HitLinkDownData( row, hitIndex ); }
+  
+  GPUd() const ushort2 *HitData( const AliHLTTPCCARow &row ) const { return fData.HitData(row); }
+  GPUd() const short_v *HitLinkUpData  ( const AliHLTTPCCARow &row ) const { return fData.HitLinkUpData(row); }
+  GPUd() const short_v *HitLinkDownData( const AliHLTTPCCARow &row ) const { return fData.HitLinkDownData(row); }
+  GPUd() const ushort_v *FirstHitInBin( const AliHLTTPCCARow &row ) const { return fData.FirstHitInBin(row); }
+  
+  GPUd() int FirstHitInBin( const AliHLTTPCCARow &row, int binIndex ) const { return fData.FirstHitInBin( row, binIndex ); }
+  
+  GPUd() unsigned short HitDataY( const AliHLTTPCCARow &row, int hitIndex ) const {
+    return fData.HitDataY( row, hitIndex );
+  }
+  GPUd() unsigned short HitDataZ( const AliHLTTPCCARow &row, int hitIndex ) const {
+    return fData.HitDataZ( row, hitIndex );
+  }
+  GPUd() ushort2 HitData( const AliHLTTPCCARow &row, int hitIndex ) const {
+    return fData.HitData( row, hitIndex );
+  }
+  
+  GPUhd() int HitInputID( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.ClusterDataIndex( row, hitIndex ); }
+  
+  /**
+   * The hit weight is used to determine whether a hit belongs to a certain tracklet or another one
+   * competing for the same hit. The tracklet that has a higher weight wins. Comparison is done
+   * using the the number of hits in the tracklet (the more hits it has the more it keeps). If
+   * tracklets have the same number of hits then it doesn't matter who gets it, but it should be
+   * only one. So a unique number (row index is good) is added in the least significant part of
+   * the weight
+   */
+  static int CalculateHitWeight( int NHits, int unique ) {
+    return ( NHits << 16 ) + unique;
+  }
+  GPUd() void MaximizeHitWeight( const AliHLTTPCCARow &row, int hitIndex, int weight ) {
+    fData.MaximizeHitWeight( row, hitIndex, weight );
+  }
+  GPUd() int HitWeight( const AliHLTTPCCARow &row, int hitIndex ) const {
+    return fData.HitWeight( row, hitIndex );
+  }
+  
+  GPUhd() int NTracklets() const { return fCommonMem->fNTracklets; }
+  GPUhd() int  *NTracklets() { return &fCommonMem->fNTracklets; }
+  
+  GPUhd() const AliHLTTPCCAHitId &TrackletStartHit( int i ) const { return fTrackletStartHits[i]; }
+  GPUhd() AliHLTTPCCAHitId *TrackletStartHits() const { return fTrackletStartHits; }
+  GPUhd() AliHLTTPCCAHitId *TrackletTmpStartHits() const { return fTrackletTmpStartHits; }
+  GPUhd() const AliHLTTPCCATracklet &Tracklet( int i ) const { return fTracklets[i]; }
+  GPUhd() AliHLTTPCCATracklet  *Tracklets() const { return fTracklets;}
+  GPUhd() int* TrackletRowHits() { return fTrackletRowHits; }
+
+  GPUhd() int *NTracks()  const { return &fCommonMem->fNTracks; }
+  GPUhd() AliHLTTPCCATrack *Tracks() const { return  fTracks; }
+  GPUhd() int *NTrackHits()  const { return &fCommonMem->fNTrackHits; }
+  GPUhd() AliHLTTPCCAHitId *TrackHits() const { return fTrackHits; }
+  
+  GPUhd() AliHLTTPCCASliceOutput** Output() const { return fOutput; }
+  
+  GPUh() commonMemoryStruct *CommonMemory() {return(fCommonMem); }
+  GPUh() static  size_t CommonMemorySize() { return(sizeof(AliHLTTPCCATracker::commonMemoryStruct)); }
+  GPUh() char* &HitMemory() {return(fHitMemory); }
+  GPUh() size_t HitMemorySize() const {return(fHitMemorySize); }
+  GPUh() char* &TrackletMemory() {return(fTrackletMemory); }
+  GPUh() size_t TrackletMemorySize() const {return(fTrackletMemorySize); }
+  GPUh() char* &TrackMemory() {return(fTrackMemory); }
+  GPUh() size_t TrackMemorySize() const {return(fTrackMemorySize); }
+  GPUhd() AliHLTTPCCARow* SliceDataRows() {return(fData.Rows()); }
+  
+  GPUhd() uint3* RowStartHitCountOffset() const {return(fRowStartHitCountOffset);}
+  GPUhd() AliHLTTPCCATrackletConstructor::AliHLTTPCCAGPUTempMemory* GPUTrackletTemp() const {return(fGPUTrackletTemp);}
+  GPUhd() int* RowBlockTracklets(int reverse, int iRowBlock) const {return(&fRowBlockTracklets[(reverse * ((fParam.NRows() / HLTCA_GPU_SCHED_ROW_STEP) + 1) + iRowBlock) * fCommonMem->fNTracklets]);}
+  GPUhd() int* RowBlockTracklets() const {return(fRowBlockTracklets);}
+  GPUhd() int4* RowBlockPos(int reverse, int iRowBlock) const {return(&fRowBlockPos[reverse * ((fParam.NRows() / HLTCA_GPU_SCHED_ROW_STEP) + 1) + iRowBlock]);}
+  GPUhd() int4* RowBlockPos() const {return(fRowBlockPos);}
+  GPUhd() uint2* BlockStartingTracklet() const {return(fBlockStartingTracklet);}
+  GPUhd() StructGPUParameters* GPUParameters() const {return(&fCommonMem->fGPUParameters);}
+  GPUhd() StructGPUParametersConst* GPUParametersConst() {return(&fGPUParametersConst);}
+  
+  GPUh() unsigned long long int* PerfTimer(unsigned int i) {return &fPerfTimers[i]; }
+  
+private:
+  
 #ifdef HLTCA_GPU_TRACKLET_CONSTRUCTOR_DO_PROFILE
-       char* fStageAtSync;                             //Pointer to array storing current stage for every thread at every sync point
-       int* fThreadTimes;
+  char* fStageAtSync;                          //Pointer to array storing current stage for every thread at every sync point
+  int* fThreadTimes; // n of times
 #endif
-
-  private:
-    AliHLTTPCCAParam fParam; // parameters
-       double fTimers[10];
-    unsigned long long int fPerfTimers[16]; // running CPU time for different parts of the algorithm
-       void StandalonePerfTime(int i);
-
-       AliHLTTPCCASliceOutput::outputControlStruct* fOutputControl;
-
-    /** A pointer to the ClusterData object that the SliceData was created from. This can be used to
-     * merge clusters from inside the SliceTracker code and recreate the SliceData. */
-    AliHLTTPCCAClusterData *fClusterData; // ^
-    AliHLTTPCCASliceData fData; // The SliceData object. It is used to encapsulate the storage in memory from the access
-
-       bool fIsGPUTracker; // is it GPU tracker object
-       int fGPUDebugLevel; // debug level
-       std::ostream *fGPUDebugOut; // debug stream
-
-       //GPU Temp Arrays
-       uint3* fRowStartHitCountOffset;                         //Offset, length and new offset of start hits in row
-       AliHLTTPCCAHitId *fTrackletTmpStartHits;        //Unsorted start hits
-       AliHLTTPCCATrackletConstructor::AliHLTTPCCAGPUTempMemory *fGPUTrackletTemp;     //Temp Memory for GPU Tracklet Constructor
-       int* fRowBlockTracklets;                                        //Reference which tracklet is processed in which rowblock next
-       int4* fRowBlockPos;                                                     //x is last tracklet to be processed, y is last tracklet already processed, z is last tracklet to be processed in next iteration, w is initial x value to check if tracklet must be initialized
-       uint2* fBlockStartingTracklet;
-
-       StructGPUParametersConst fGPUParametersConst;
-
-       // event
-
-       commonMemoryStruct *fCommonMem; // common event memory
-
-    char *fHitMemory; // event memory for hits
-    size_t   fHitMemorySize; // size of the event memory [bytes]
-
-       char *fTrackletMemory;
-       size_t fTrackletMemorySize;
-
-    char *fTrackMemory; // event memory for tracks
-    size_t   fTrackMemorySize; // size of the event memory [bytes]
-
-    AliHLTTPCCAHitId *fTrackletStartHits;   // start hits for the tracklets
-    AliHLTTPCCATracklet *fTracklets; // tracklets
-       int *fTrackletRowHits;
-
-    //
-    AliHLTTPCCATrack *fTracks;  // reconstructed tracks
-    AliHLTTPCCAHitId *fTrackHits;          // array of track hit numbers
-
-    // output
-
-    AliHLTTPCCASliceOutput **fOutput;
-
-    // disable copy
-    AliHLTTPCCATracker( const AliHLTTPCCATracker& );
-    AliHLTTPCCATracker &operator=( const AliHLTTPCCATracker& );
-
-       static int starthitSortComparison(const void*a, const void* b);
+  
+  AliHLTTPCCAParam fParam; // parameters
+  double fTimers[10]; // timers
+  unsigned long long int fPerfTimers[16]; // running CPU time for different parts of the algorithm
+  void StandalonePerfTime(int i);
+  
+  AliHLTTPCCASliceOutput::outputControlStruct* fOutputControl; // output control
+  
+  /** A pointer to the ClusterData object that the SliceData was created from. This can be used to
+   * merge clusters from inside the SliceTracker code and recreate the SliceData. */
+  AliHLTTPCCAClusterData *fClusterData; // ^
+  AliHLTTPCCASliceData fData; // The SliceData object. It is used to encapsulate the storage in memory from the access
+  
+  bool fIsGPUTracker; // is it GPU tracker object
+  int fGPUDebugLevel; // debug level
+  std::ostream *fGPUDebugOut; // debug stream
+  
+  //GPU Temp Arrays
+  uint3* fRowStartHitCountOffset;                              //Offset, length and new offset of start hits in row
+  AliHLTTPCCAHitId *fTrackletTmpStartHits;     //Unsorted start hits
+  AliHLTTPCCATrackletConstructor::AliHLTTPCCAGPUTempMemory *fGPUTrackletTemp;  //Temp Memory for GPU Tracklet Constructor
+  int* fRowBlockTracklets;                                     //Reference which tracklet is processed in which rowblock next
+  int4* fRowBlockPos;                                                  //x is last tracklet to be processed, y is last tracklet already processed, z is last tracklet to be processed in next iteration, w is initial x value to check if tracklet must be initialized
+  uint2* fBlockStartingTracklet; // tracklet which starts the block
+  
+  StructGPUParametersConst fGPUParametersConst; // 
+  
+  // event
+  
+  commonMemoryStruct *fCommonMem; // common event memory
+  
+  char *fHitMemory; // event memory for hits
+  size_t   fHitMemorySize; // size of the event memory [bytes]
+  
+  char *fTrackletMemory;
+  size_t fTrackletMemorySize;
+  
+  char *fTrackMemory; // event memory for tracks
+  size_t   fTrackMemorySize; // size of the event memory [bytes]
+  
+  AliHLTTPCCAHitId *fTrackletStartHits;   // start hits for the tracklets
+  AliHLTTPCCATracklet *fTracklets; // tracklets
+  int *fTrackletRowHits;
+  
+  //
+  AliHLTTPCCATrack *fTracks;  // reconstructed tracks
+  AliHLTTPCCAHitId *fTrackHits;          // array of track hit numbers
+  
+  // output
+  
+  AliHLTTPCCASliceOutput **fOutput;
+  
+  // disable copy
+  AliHLTTPCCATracker( const AliHLTTPCCATracker& );
+  AliHLTTPCCATracker &operator=( const AliHLTTPCCATracker& );
+  
+  static int StarthitSortComparison(const void*a, const void* b);
 };
 
 
index 74de222..fc01311 100644 (file)
@@ -642,7 +642,7 @@ int AliHLTTPCCATrackerComponent::DoEvent
   
   int ret = 0;
   unsigned int mySize = 0;
-  int ntracks;
+  int ntracks = 0;
   int error = 0;
 
   for (int islice = 0;islice < slicecount;islice++)
index 9313dc5..491c9cf 100644 (file)
@@ -132,4 +132,4 @@ int AliHLTTPCCATrackerFramework::InitializeSliceParam(int iSlice, AliHLTTPCCAPar
        if (fGPUTrackerAvailable && fGPUTracker.InitializeSliceParam(iSlice, param)) return(1);
        fCPUTrackers[iSlice].Initialize(param);
        return(0);
-}
\ No newline at end of file
+}
index 420d387..ec088c4 100644 (file)
@@ -162,7 +162,7 @@ GPUd() void AliHLTTPCCATrackletConstructor::ReadData
 
 GPUd() void AliHLTTPCCATrackletConstructor::StoreTracklet
 ( int /*nBlocks*/, int /*nThreads*/, int /*iBlock*/, int /*iThread*/,
-  AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam )
+  AliHLTTPCCASharedMemory &/*s*/, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam )
 {
   // reconstruction of tracklets, tracklet store step
 
@@ -242,7 +242,7 @@ GPUd() void AliHLTTPCCATrackletConstructor::StoreTracklet
 
 GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
 ( int /*nBlocks*/, int /*nThreads*/, int /*iBlock*/, int /*iThread*/,
-  AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam, int iRow )
+  AliHLTTPCCASharedMemory &/*s*/, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam, int iRow )
 {
   // reconstruction of tracklets, tracklets update step