Move cluster sorting from CA tracker component inside CA tracker and pipeline with...
authordrohr <drohr@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 28 Jun 2012 13:28:40 +0000 (13:28 +0000)
committerdrohr <drohr@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 28 Jun 2012 13:28:40 +0000 (13:28 +0000)
HLT/TPCLib/tracking-ca/AliHLTTPCCAClusterData.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAClusterData.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUConfig.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.h
HLT/TPCLib/tracking-ca/AliHLTTPCCASliceData.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCASliceData.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAStandaloneFramework.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.h

index f505622..e59abb3 100644 (file)
 #include "AliHLTArray.h"
 #include "AliHLTTPCCAGPUConfig.h"
 
-void AliHLTTPCCAClusterData::StartReading( int sliceIndex, int guessForNumberOfClusters )
+AliHLTTPCCAClusterData::~AliHLTTPCCAClusterData()
 {
-  // Start reading of event - initialisation
-
-  fSliceIndex = sliceIndex;
-  fFirstRow = 0;
-  fLastRow = 0;
-  fData.clear();
-  fNumberOfClusters.reserve( HLTCA_ROW_COUNT + 1 );
-  fRowOffset.reserve( HLTCA_ROW_COUNT + 1 );
-  fData.reserve( CAMath::Max( 64, guessForNumberOfClusters ) );
+       if(fAllocated) free(fData);
 }
 
-
-void AliHLTTPCCAClusterData::FinishReading()
+void AliHLTTPCCAClusterData::StartReading( int sliceIndex, int guessForNumberOfClusters )
 {
-  // finish event reading - data sorting, etc.
-
-  std::sort( fData.begin(), fData.end(), CompareClusters );
-  if ( fData.size() ) fFirstRow = fData[0].fRow;
-
-  fNumberOfClusters.clear();
-  fRowOffset.clear();
-
-  int row = fFirstRow;
-  for ( int i = 0; i < row; ++i ) {
-    fNumberOfClusters.push_back( 0 );
-    fRowOffset.push_back( 0 );
-  }
-  fRowOffset.push_back( 0 );
-  for ( unsigned int ic = 0; ic < fData.size(); ++ic ) {
-    Data &cluster = fData[ic];
-    while ( row < cluster.fRow ) {
-      fNumberOfClusters.push_back( ic - fRowOffset.back() );
-      fRowOffset.push_back( ic );
-      ++row;
-    }
-  }
-  fNumberOfClusters.push_back( fData.size() - fRowOffset.back() );
-  fLastRow = row; // the last seen row is the last row in this slice
+  // Start reading of event - initialisation
+  fSliceIndex = sliceIndex;
+  fNumberOfClusters = 0;
+  Allocate(CAMath::Max( 64, guessForNumberOfClusters ));
 }
 
-template <class T> void AliHLTTPCCAClusterData::WriteEventVector(const std::vector<T> &data, std::ostream &out) const
+template <class T> void AliHLTTPCCAClusterData::WriteEventVector(const T* const &data, std::ostream &out) const
 {
-       AliHLTResizableArray<T> tmpData(data.size());
        unsigned i;
-       for (i = 0;i < data.size();i++)
-       {
-               tmpData[i] = data[i];
-       }
-       i = data.size();
+       i = fNumberOfClusters;
        out.write((char*) &i, sizeof(i));
-       out.write((char*) &tmpData[0], i * sizeof(T));
+       out.write((char*) data, i * sizeof(T));
 }
 
-template <class T> void AliHLTTPCCAClusterData::ReadEventVector(std::vector<T> &data, std::istream &in, int MinSize)
+template <class T> void AliHLTTPCCAClusterData::ReadEventVector(T* &data, std::istream &in, int MinSize)
 {
        int i;
        in.read((char*) &i, sizeof(i));
-       data.reserve(AliHLTTPCCAMath::Max(MinSize, i));
-       data.resize(i);
-       AliHLTResizableArray<T> tmpData(i);
-       in.read((char*) &tmpData[0], i * sizeof(T));
-       for (int j = 0;j < i;j++)
-       {
-#ifdef HLTCA_STANDALONE
-               if (tmpData[j].fRow < 0 || tmpData[j].fRow >= HLTCA_ROW_COUNT)
-               {
-                       exit(1);
-               }
-#endif
-               data[j] = tmpData[j];
-       }
+       fNumberOfClusters = i;
+       Allocate(CAMath::Max(MinSize, fNumberOfClusters));
+       in.read((char*) data, i * sizeof(T));
 }
 
 void AliHLTTPCCAClusterData::WriteEvent(std::ostream &out) const
@@ -102,7 +57,22 @@ void AliHLTTPCCAClusterData::WriteEvent(std::ostream &out) const
 
 void AliHLTTPCCAClusterData::ReadEvent(std::istream &in)
 {
-    fData.clear();
        ReadEventVector<Data>(fData, in, 64);
 }
 
+void AliHLTTPCCAClusterData::Allocate(int number)
+{
+       int newnumber;
+       if (fAllocated)
+       {
+               if (number < fAllocated) return;
+               newnumber = CAMath::Max(number, 2 * fAllocated);
+               fData = (Data*) realloc(fData, newnumber * sizeof(Data));
+       }
+       else
+       {
+               fData = (Data*) malloc(number * sizeof(Data));
+               newnumber = number;
+       }
+       fAllocated = newnumber;
+}
index 68bccce..8c1a9be 100644 (file)
@@ -30,8 +30,17 @@ class AliHLTTPCCAClusterData
 {
   public:
 
-    AliHLTTPCCAClusterData(): fSliceIndex( 0 ), fFirstRow( 0 ), fLastRow( -1 ), fNumberOfClusters(), fRowOffset(), fData() {}
-    ~AliHLTTPCCAClusterData() { }
+    AliHLTTPCCAClusterData(): fSliceIndex( 0 ), fData( NULL ), fNumberOfClusters(0), fAllocated(0) {}
+    ~AliHLTTPCCAClusterData();
+
+    struct Data {
+      int fId;
+      int fRow;
+      float fX;
+      float fY;
+      float fZ;
+      float fAmp;
+    };
 
     /**
      * prepare for the reading of event
@@ -42,22 +51,21 @@ class AliHLTTPCCAClusterData
      *  read next cluster
      */
     void ReadCluster( int id, int iRow, float x, float y, float z, float amp ) {
+      if (fNumberOfClusters >= fAllocated) Allocate(fNumberOfClusters + 64);
       Data d = { id, iRow, x, y, z, amp};
-      fData.push_back( d );
+      fData[fNumberOfClusters++] = d;
     }
 
-    /**
-     * finish the reading of event
-     */
-    void FinishReading();
+    Data* Clusters() { return(fData); }
+    void SetNumberOfClusters(int number) {fNumberOfClusters = number;}
 
     /**
      * Read/Write Events from/to file
      */
     void ReadEvent(std::istream &in);
     void WriteEvent(std::ostream &out) const;
-       template <class T> void ReadEventVector(std::vector<T> &data, std::istream &in, int MinSize = 0);
-    template <class T> void WriteEventVector(const std::vector<T> &data, std::ostream &out) const;
+    template <class T> void ReadEventVector(T* &data, std::istream &in, int MinSize = 0);
+    template <class T> void WriteEventVector(const T* const &data, std::ostream &out) const;
 
     /**
      * "remove" one cluster and "add" two new ones, keeping history.
@@ -72,39 +80,9 @@ class AliHLTTPCCAClusterData
     int SliceIndex() const { return fSliceIndex; }
 
     /**
-     * The first row index that contains a cluster.
-     */
-    int FirstRow() const { return fFirstRow; }
-
-    /**
-     * The last row index that contains a cluster.
-     */
-    int LastRow() const { return fLastRow; }
-
-    /**
      * Return the number of clusters in this slice.
      */
-    int NumberOfClusters() const { return (int) fData.size(); }
-
-    /**
-     * Return the number of clusters in the given row, for this slice.
-     */
-    int NumberOfClusters( unsigned int rowIndex ) const { return rowIndex < fNumberOfClusters.size() ? fNumberOfClusters[rowIndex] : 0; }
-
-    /**
-     * Return the index of the first cluster in the given row.
-     *
-     * Supports calls with rowIndex greater than the available number of rows. In that case it
-     * returns NumberOfClusters.
-     *
-     * To iterate over the clusters in one row do:
-     * \code
-     * AliHLTTPCCAClusterData cd;
-     * const int lastClusterIndex = cd.RowOffset( rowIndex + 1 );
-     * for ( int hitIndex = cd.RowOffset( rowIndex ); hitIndex < lastClusterIndex; ++hitIndex )
-     * \endcode
-     */
-    int RowOffset( unsigned int rowIndex ) const { return rowIndex < fRowOffset.size() ? fRowOffset[rowIndex] : (int) fData.size(); }
+    int NumberOfClusters() const { return (int) fNumberOfClusters; }
 
     /**
      * Return the x coordinate of the given cluster.
@@ -136,31 +114,24 @@ class AliHLTTPCCAClusterData
      */
     int RowNumber( int index ) const { return fData[index].fRow; }
 
-    struct Data {
-      int fId;
-      int fRow;
-      float fX;
-      float fY;
-      float fZ;
-      float fAmp;
-    };
-
     Data *GetClusterData( int index ) { return &( fData[index] ); }
 
   private:
+    AliHLTTPCCAClusterData(AliHLTTPCCAClusterData&): fSliceIndex( 0 ), fData( NULL ), fNumberOfClusters(0), fAllocated(0) {}
+    AliHLTTPCCAClusterData& operator=( const AliHLTTPCCAClusterData& );
+
     /** TODO
      * "remove" two clusters and "add" a new one, keeping history.
      */
     void Merge( int index1, int index2 );
 
-       static bool CompareClusters( const Data &a, const Data &b ) { return ( a.fRow == b.fRow ? (a.fY < b.fY) : (a.fRow < b.fRow) ); }
+    void Allocate( int number);
+    static bool CompareClusters( const Data &a, const Data &b ) { return ( a.fRow == b.fRow ? (a.fY < b.fY) : (a.fRow < b.fRow) ); }
 
     int fSliceIndex;  // the slice index this data belongs to
-    int fFirstRow; // see FirstRow()
-    int fLastRow;  // see LastRow()
-    std::vector<int> fNumberOfClusters; // list of NumberOfClusters per row for NumberOfClusters(int)
-    std::vector<int> fRowOffset;        // see RowOffset()
-    std::vector<Data> fData; // list of data of clusters
+    Data* fData; // list of data of clusters
+    int fNumberOfClusters;     //Current number of clusters stored in fData
+    int fAllocated; //Number of clusters that can be stored in fData
 };
 
 typedef AliHLTTPCCAClusterData ClusterData;
index 126e723..2f79409 100644 (file)
@@ -27,7 +27,9 @@
 #define HLTCA_GPU_WARP_SIZE 32
 #define HLTCA_GPU_REGS 64
 
-//#define HLTCA_GPU_MERGER                                                             //Use GPU Merger
+#ifdef HLTCA_STANDALONE
+#define HLTCA_GPU_MERGER                                                               //Use GPU Merger
+#endif
 
 //Detector Parameters
 #define HLTCA_ROW_COUNT 159
index 5632b48..a359aeb 100644 (file)
@@ -22,6 +22,7 @@
 
 AliHLTTPCCAGPUTracker::AliHLTTPCCAGPUTracker() {}
 AliHLTTPCCAGPUTracker::~AliHLTTPCCAGPUTracker() {}
+int AliHLTTPCCAGPUTracker::IsInitialized() {return(0);}
 int AliHLTTPCCAGPUTracker::InitGPU(int /*sliceCount*/, int /*forceDeviceID*/) { return(1); }
 void AliHLTTPCCAGPUTracker::SetDebugLevel(int /*dwLevel*/, std::ostream* /*NewOutFile*/) {}
 int AliHLTTPCCAGPUTracker::SetGPUTrackerOption(char* /*OptionName*/, int /*OptionValue*/) {return(1);}
index 1b8c1d3..19af632 100644 (file)
@@ -25,6 +25,7 @@ public:
        virtual ~AliHLTTPCCAGPUTracker();
 
        virtual int InitGPU(int sliceCount = -1, int forceDeviceID = -1);
+       virtual int IsInitialized();
        virtual int Reconstruct(AliHLTTPCCASliceOutput** pOutput, AliHLTTPCCAClusterData* pClusterData, int fFirstSlice, int fSliceCount = -1);
        virtual int ExitGPU();
 
@@ -40,7 +41,6 @@ public:
        virtual int GetSliceCount() const;
 
        virtual int RefitMergedTracks(AliHLTTPCGMMerger* Merger);
-
        virtual char* MergerBaseMemory();
 
 private:
index ed878da..9928696 100644 (file)
@@ -24,6 +24,7 @@
 #include "AliHLTTPCCAGPUTracker.h"
 #include "MemoryAssignmentHelpers.h"
 #include <iostream>
+#include <string.h>
 
 // calculates an approximation for 1/sqrt(x)
 // Google for 0x5f3759df :)
@@ -38,7 +39,7 @@ static inline float fastInvSqrt( float _x )
   return x.f;
 }
 
-inline void AliHLTTPCCASliceData::CreateGrid( AliHLTTPCCARow *row, const AliHLTTPCCAClusterData &data, int ClusterDataHitNumberOffset )
+inline void AliHLTTPCCASliceData::CreateGrid( AliHLTTPCCARow *row, const float2* data, int ClusterDataHitNumberOffset )
 {
   // grid creation
 
@@ -53,8 +54,8 @@ inline void AliHLTTPCCASliceData::CreateGrid( AliHLTTPCCARow *row, const AliHLTT
   float zMin =  1.e3f;
   float zMax = -1.e3f;
   for ( int i = ClusterDataHitNumberOffset; i < ClusterDataHitNumberOffset + row->fNHits; ++i ) {
-    const float y = data.Y( i );
-    const float z = data.Z( i );
+    const float y = data[i].x;
+    const float z = data[i].y;
     if ( yMax < y ) yMax = y;
     if ( yMin > y ) yMin = y;
     if ( zMax < z ) zMax = z;
@@ -89,15 +90,15 @@ inline void AliHLTTPCCASliceData::PackHitData( AliHLTTPCCARow* const row, const
   for ( int hitIndex = 0; hitIndex < row->fNHits; ++hitIndex ) {
     // bin sorted index!
     const int globalHitIndex = row->fHitNumberOffset + hitIndex;
-    const AliHLTTPCCAHit &hh = binSortedHits[globalHitIndex];
+    const AliHLTTPCCAHit &hh = binSortedHits[hitIndex];
     const float xx = ( ( hh.Y() - y0 ) * stepYi ) + .5 ;
     const float yy = ( ( hh.Z() - z0 ) * stepZi ) + .5 ;
     if ( xx < 0 || yy < 0 || xx >= 65536  || yy >= 65536 ) {
       std::cout << "!!!! hit packing error!!! " << xx << " " << yy << " " << std::endl;
     }
     // HitData is bin sorted
-    fHitData[row->fHitNumberOffset + hitIndex].x = (unsigned short) xx;
-    fHitData[row->fHitNumberOffset + hitIndex].y = (unsigned short) yy;
+    fHitData[globalHitIndex].x = (unsigned short) xx;
+    fHitData[globalHitIndex].y = (unsigned short) yy;
   }
 }
 
@@ -143,20 +144,16 @@ GPUh() void AliHLTTPCCASliceData::SetGPUSliceDataMemory(void* const pSliceMemory
 
 size_t AliHLTTPCCASliceData::SetPointers(const AliHLTTPCCAClusterData *data, bool allocate)
 {
-       //Set slice data internal pointers
-  int hitMemCount = 0;
-  for ( int rowIndex = data->FirstRow(); rowIndex <= data->LastRow(); ++rowIndex )
-  {
-       hitMemCount += NextMultipleOf<sizeof(HLTCA_GPU_ROWALIGNMENT) / sizeof(ushort_v)>(data->NumberOfClusters( rowIndex ));
-  }
-       //Calculate Memory needed to store hits in rows
+  //Set slice data internal pointers
+
+  int hitMemCount = HLTCA_ROW_COUNT * (sizeof(HLTCA_GPU_ROWALIGNMENT) / sizeof(ushort_v) - 1) + data->NumberOfClusters();
+  //Calculate Memory needed to store hits in rows
 
-  const int numberOfRows = data->LastRow() - data->FirstRow() + 1;
   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.
+  const int firstHitInBinSize = (23 + sizeof(HLTCA_GPU_ROWALIGNMENT) / sizeof(int)) * HLTCA_ROW_COUNT + 4 * fNumberOfHits + 3;
+  //FIXME: sizeof(HLTCA_GPU_ROWALIGNMENT) / sizeof(int) * HLTCA_ROW_COUNT is way to big and only to ensure to reserve enough memory for GPU Alignment.
   //Might be replaced by correct value
 
   const int memorySize =
@@ -208,25 +205,67 @@ void AliHLTTPCCASliceData::InitFromClusterData( const AliHLTTPCCAClusterData &da
   // initialisation from cluster data
 
   ////////////////////////////////////
-  // 1. prepare arrays
+  // 0. sort rows
   ////////////////////////////////////
 
-  const int numberOfRows = data.LastRow() - data.FirstRow() + 1;
   fNumberOfHits = data.NumberOfClusters();
 
-  /* TODO Vectorization
-  for ( int rowIndex = data.FirstRow(); rowIndex <= data.LastRow(); ++rowIndex ) {
-    int NumberOfClusters( int rowIndex ) const;
+  float2* YZData = new float2[fNumberOfHits];
+  int* tmpHitIndex = new int[fNumberOfHits];
+
+  int RowOffset[HLTCA_ROW_COUNT];
+  int NumberOfClustersInRow[HLTCA_ROW_COUNT];
+  memset(NumberOfClustersInRow, 0, HLTCA_ROW_COUNT * sizeof(int));
+  fFirstRow = HLTCA_ROW_COUNT;
+  fLastRow = 0;
+
+  for (int i = 0;i < fNumberOfHits;i++)
+  {
+    const int tmpRow = data.RowNumber(i);
+       NumberOfClustersInRow[tmpRow]++;
+       if (tmpRow > fLastRow) fLastRow = tmpRow;
+       if (tmpRow < fFirstRow) fFirstRow = tmpRow;
+  }
+  int tmpOffset = 0;
+  for (int i = fFirstRow;i <= fLastRow;i++)
+  {
+         RowOffset[i] = tmpOffset;
+         tmpOffset += NumberOfClustersInRow[i];
+  }
+  {
+         int RowsFilled[HLTCA_ROW_COUNT];
+         memset(RowsFilled, 0, HLTCA_ROW_COUNT * sizeof(int));
+         for (int i = 0;i < fNumberOfHits;i++)
+         {
+               float2 tmp;
+               tmp.x = data.Y(i);
+               tmp.y = data.Z(i);
+               int tmpRow = data.RowNumber(i);
+               int newIndex = RowOffset[tmpRow] + (RowsFilled[tmpRow])++;
+               YZData[newIndex] = tmp;
+               tmpHitIndex[newIndex] = i;
+         }
+  }
+  if (fFirstRow == HLTCA_ROW_COUNT) fFirstRow = 0;
+
+  ////////////////////////////////////
+  // 1. prepare arrays
+  ////////////////////////////////////
+
+  const int numberOfRows = fLastRow - fFirstRow + 1;
+
+  if (SetPointers(&data, true) == 0)
+  {
+       delete[] YZData;
+       delete[] tmpHitIndex;
+       return;
   }
-  const int memorySize = fNumberOfHits * sizeof( short_v::Type )
-  */
-  if (SetPointers(&data, true) == 0) return;
 
   ////////////////////////////////////
   // 2. fill HitData and FirstHitInBin
   ////////////////////////////////////
 
-  for ( int rowIndex = 0; rowIndex < data.FirstRow(); ++rowIndex ) {
+  for ( int rowIndex = 0; rowIndex < fFirstRow; ++rowIndex ) {
     AliHLTTPCCARow &row = fRows[rowIndex];
     row.fGrid.CreateEmpty();
     row.fNHits = 0;
@@ -241,7 +280,7 @@ void AliHLTTPCCASliceData::InitFromClusterData( const AliHLTTPCCAClusterData &da
     row.fHstepYi = 1.f;
     row.fHstepZi = 1.f;
   }
-  for ( int rowIndex = data.LastRow() + 1; rowIndex < HLTCA_ROW_COUNT + 1; ++rowIndex ) {
+  for ( int rowIndex = fLastRow + 1; rowIndex < HLTCA_ROW_COUNT + 1; ++rowIndex ) {
     AliHLTTPCCARow &row = fRows[rowIndex];
     row.fGrid.CreateEmpty();
     row.fNHits = 0;
@@ -258,7 +297,7 @@ void AliHLTTPCCASliceData::InitFromClusterData( const AliHLTTPCCAClusterData &da
   }
 
 
-  AliHLTResizableArray<AliHLTTPCCAHit> binSortedHits( fNumberOfHits + sizeof(HLTCA_GPU_ROWALIGNMENT) / sizeof(ushort_v) * numberOfRows + 1 );
+  AliHLTResizableArray<AliHLTTPCCAHit> binSortedHits( fNumberOfHits + sizeof(HLTCA_GPU_ROWALIGNMENT) / sizeof(ushort_v));
 
   int gridContentOffset = 0;
   int hitOffset = 0;
@@ -268,16 +307,16 @@ void AliHLTTPCCASliceData::InitFromClusterData( const AliHLTTPCCAClusterData &da
 
   fGPUSharedDataReq = 0;
 
-  for ( int rowIndex = data.FirstRow(); rowIndex <= data.LastRow(); ++rowIndex ) {
+  for ( int rowIndex = fFirstRow; rowIndex <= fLastRow; ++rowIndex ) {
     AliHLTTPCCARow &row = fRows[rowIndex];
-    row.fNHits = data.NumberOfClusters( rowIndex );
+       row.fNHits = NumberOfClustersInRow[rowIndex];
     assert( row.fNHits < ( 1 << sizeof( unsigned short ) * 8 ) );
        row.fHitNumberOffset = hitOffset;
-       hitOffset += NextMultipleOf<sizeof(HLTCA_GPU_ROWALIGNMENT) / sizeof(ushort_v)>(data.NumberOfClusters( rowIndex ));
+       hitOffset += NextMultipleOf<sizeof(HLTCA_GPU_ROWALIGNMENT) / sizeof(ushort_v)>(NumberOfClustersInRow[rowIndex]);
 
     row.fFirstHitInBinOffset = gridContentOffset;
 
-    CreateGrid( &row, data, data.RowOffset( rowIndex ) );
+    CreateGrid( &row, YZData, RowOffset[rowIndex] );
     const AliHLTTPCCAGrid &grid = row.fGrid;
     const int numberOfBins = grid.N();
 
@@ -296,8 +335,8 @@ void AliHLTTPCCASliceData::InitFromClusterData( const AliHLTTPCCAClusterData &da
     }
 
     for ( int hitIndex = 0; hitIndex < row.fNHits; ++hitIndex ) {
-      const int globalHitIndex = data.RowOffset( rowIndex ) + hitIndex;
-      const unsigned short bin = row.fGrid.GetBin( data.Y( globalHitIndex ), data.Z( globalHitIndex ) );
+      const int globalHitIndex = RowOffset[rowIndex] + hitIndex;
+      const unsigned short bin = row.fGrid.GetBin( YZData[globalHitIndex].x, YZData[globalHitIndex].y );
 
       bins[hitIndex] = bin;
       ++filled[bin];
@@ -314,12 +353,12 @@ void AliHLTTPCCASliceData::InitFromClusterData( const AliHLTTPCCAClusterData &da
       --filled[bin];
       const unsigned short ind = c[bin] + filled[bin]; // generate an index for this hit that is >= c[bin] and < c[bin + 1]
       const int globalBinsortedIndex = row.fHitNumberOffset + ind;
-      const int globalHitIndex = data.RowOffset( rowIndex ) + hitIndex;
+      const int globalHitIndex = RowOffset[rowIndex] + hitIndex;
 
       // allows to find the global hit index / coordinates from a global bin sorted hit index
-      fClusterDataIndex[globalBinsortedIndex] = globalHitIndex;
-      binSortedHits[globalBinsortedIndex].SetY( data.Y( globalHitIndex ) );
-      binSortedHits[globalBinsortedIndex].SetZ( data.Z( globalHitIndex ) );
+      fClusterDataIndex[globalBinsortedIndex] = tmpHitIndex[globalHitIndex];
+      binSortedHits[ind].SetY( YZData[globalHitIndex].x );
+      binSortedHits[ind].SetZ( YZData[globalHitIndex].y );
     }
 
     PackHitData( &row, binSortedHits );
@@ -345,6 +384,9 @@ void AliHLTTPCCASliceData::InitFromClusterData( const AliHLTTPCCAClusterData &da
        gridContentOffset = NextMultipleOf<sizeof(HLTCA_GPU_ROWALIGNMENT) / sizeof(ushort_v)>(gridContentOffset);
   }
 
+  delete[] YZData;
+  delete[] tmpHitIndex;
+
 #if 0
   //SG cell finder - test code
 
index fd40e1e..43881b3 100644 (file)
@@ -44,15 +44,15 @@ class AliHLTTPCCASliceData
 {
   public:
     AliHLTTPCCASliceData()
-        : 
-               fIsGpuSliceData(0), fGPUSharedDataReq(0), fNumberOfHits( 0 ), fNumberOfHitsPlusAlign( 0 ), fMemorySize( 0 ), fGpuMemorySize( 0 ), fMemory( 0 ), fGPUTextureBase( 0 )
-               ,fRows( NULL ), fLinkUpData( 0 ), fLinkDownData( 0 ), fHitData( 0 ), fClusterDataIndex( 0 )
-        , fFirstHitInBin( 0 ), fHitWeights( 0 )
-       {
-       }
+      : 
+      fIsGpuSliceData(0), fGPUSharedDataReq(0), fFirstRow( 0 ), fLastRow( HLTCA_ROW_COUNT - 1), fNumberOfHits( 0 ), fNumberOfHitsPlusAlign( 0 ), fMemorySize( 0 ), fGpuMemorySize( 0 ), fMemory( 0 ), fGPUTextureBase( 0 )
+      ,fRows( NULL ), fLinkUpData( 0 ), fLinkDownData( 0 ), fHitData( 0 ), fClusterDataIndex( 0 )
+      , fFirstHitInBin( 0 ), fHitWeights( 0 )
+    {
+    }
 
 #ifndef HLTCA_GPUCODE
-       ~AliHLTTPCCASliceData();
+    ~AliHLTTPCCASliceData();
 #endif //!HLTCA_GPUCODE
 
     void InitializeRows( const AliHLTTPCCAParam &parameters );
@@ -62,8 +62,8 @@ class AliHLTTPCCASliceData
      * data.
      */
 
-       void SetGPUSliceDataMemory(void* const pSliceMemory, void* const pRowMemory);
-       size_t SetPointers(const AliHLTTPCCAClusterData *data, bool allocate = false);
+    void SetGPUSliceDataMemory(void* const pSliceMemory, void* const pRowMemory);
+    size_t SetPointers(const AliHLTTPCCAClusterData *data, bool allocate = false);
     void InitFromClusterData( const AliHLTTPCCAClusterData &data );
 
     /**
@@ -75,7 +75,7 @@ class AliHLTTPCCASliceData
      * Return the number of hits in this slice.
      */
     GPUhd() int NumberOfHits() const { return fNumberOfHits; }
-       GPUhd() int NumberOfHitsPlusAlign() const { return fNumberOfHitsPlusAlign; }
+    GPUhd() int NumberOfHitsPlusAlign() const { return fNumberOfHitsPlusAlign; }
 
     /**
      * Access to the hit links.
@@ -84,9 +84,9 @@ class AliHLTTPCCASliceData
      */
     short_v HitLinkUpData  ( const AliHLTTPCCARow &row, const short_v &hitIndex ) const;
     short_v HitLinkDownData( const AliHLTTPCCARow &row, const short_v &hitIndex ) const;
-    
-       GPUhd() const ushort2 *HitData( const AliHLTTPCCARow &row ) const;
-       GPUhd() const ushort2 *HitData() const { return(fHitData); }
+
+    GPUhd() const ushort2 *HitData( const AliHLTTPCCARow &row ) const;
+    GPUhd() const ushort2 *HitData() const { return(fHitData); }
     GPUd() const short_v *HitLinkUpData  ( const AliHLTTPCCARow &row ) const;
     GPUd() const short_v *HitLinkDownData( const AliHLTTPCCARow &row ) const;
     GPUd() const ushort_v *FirstHitInBin( const AliHLTTPCCARow &row ) const;
@@ -107,7 +107,7 @@ class AliHLTTPCCASliceData
     // TODO return float_v
     ushort_v HitDataY( const AliHLTTPCCARow &row, const uint_v &hitIndex ) const;
     ushort_v HitDataZ( const AliHLTTPCCARow &row, const uint_v &hitIndex ) const;
-       ushort2 HitData( const AliHLTTPCCARow &row, const uint_v &hitIndex ) const;
+    ushort2 HitData( const AliHLTTPCCARow &row, const uint_v &hitIndex ) const;
 
     /**
      * For a given bin index, content tells how many hits there are in the preceding bins. This maps
@@ -142,50 +142,53 @@ class AliHLTTPCCASliceData
      * Return the row object for the given row index.
      */
     const AliHLTTPCCARow &Row( int rowIndex ) const;
-       GPUhd() AliHLTTPCCARow* Rows() const {return fRows;}
+    GPUhd() AliHLTTPCCARow* Rows() const {return fRows;}
 
-       GPUh() char *Memory() const {return(fMemory); }
-       GPUh() size_t MemorySize() const {return(fMemorySize); }
-       GPUh() size_t GpuMemorySize() const {return(fGpuMemorySize); }
-       GPUhd() int* HitWeights() const {return(fHitWeights); }
+    GPUh() char *Memory() const {return(fMemory); }
+    GPUh() size_t MemorySize() const {return(fMemorySize); }
+    GPUh() size_t GpuMemorySize() const {return(fGpuMemorySize); }
+    GPUhd() int* HitWeights() const {return(fHitWeights); }
 
-       GPUhd() void SetGPUTextureBase(char* const val) {fGPUTextureBase = val;}
-       GPUhd() char* GPUTextureBase() const { return(fGPUTextureBase); }
-       GPUhd() char* GPUTextureBaseConst() const { return(fGPUTextureBase); }
+    GPUhd() void SetGPUTextureBase(char* const val) {fGPUTextureBase = val;}
+    GPUhd() char* GPUTextureBase() const { return(fGPUTextureBase); }
+    GPUhd() char* GPUTextureBaseConst() const { return(fGPUTextureBase); }
 
-       GPUh() int GPUSharedDataReq() const { return fGPUSharedDataReq; }
+    GPUh() int GPUSharedDataReq() const { return fGPUSharedDataReq; }
 
-       void SetGpuSliceData() { fIsGpuSliceData = 1; }
+    void SetGpuSliceData() { fIsGpuSliceData = 1; }
 
   private:
     AliHLTTPCCASliceData( const AliHLTTPCCASliceData & )
-        : 
-               fIsGpuSliceData(0), fGPUSharedDataReq(0), fNumberOfHits( 0 ), fNumberOfHitsPlusAlign( 0 ), fMemorySize( 0 ), fGpuMemorySize( 0 ), fMemory( 0 ), fGPUTextureBase( 0 )
-               ,fRows( NULL ), fLinkUpData( 0 ), fLinkDownData( 0 ), fHitData( 0 ), fClusterDataIndex( 0 )
-        , fFirstHitInBin( 0 ), fHitWeights( 0 )
-       {
-       }
+      : 
+      fIsGpuSliceData(0), fGPUSharedDataReq(0), fFirstRow(0), fLastRow(HLTCA_ROW_COUNT - 1), fNumberOfHits( 0 ), fNumberOfHitsPlusAlign( 0 ), fMemorySize( 0 ), fGpuMemorySize( 0 ), fMemory( 0 ), fGPUTextureBase( 0 )
+      ,fRows( NULL ), fLinkUpData( 0 ), fLinkDownData( 0 ), fHitData( 0 ), fClusterDataIndex( 0 )
+      , fFirstHitInBin( 0 ), fHitWeights( 0 )
+    {
+    }
     AliHLTTPCCASliceData& operator=( const AliHLTTPCCASliceData & ) {
       return *this;
     }
 
-    void CreateGrid( AliHLTTPCCARow *row, const AliHLTTPCCAClusterData &data, int ClusterDataHitNumberOffset );
+    void CreateGrid( AliHLTTPCCARow *row, const float2* data, int ClusterDataHitNumberOffset );
     void PackHitData( AliHLTTPCCARow *row, const AliHLTArray<AliHLTTPCCAHit, 1> &binSortedHits );
 
-       int fIsGpuSliceData;            //Slice Data for GPU Tracker?
-       int fGPUSharedDataReq;          //Size of shared memory required for GPU Reconstruction
+    int fIsGpuSliceData;       //Slice Data for GPU Tracker?
+    int fGPUSharedDataReq;     //Size of shared memory required for GPU Reconstruction
+
+    int fFirstRow;             //First non-empty row
+    int fLastRow;              //Last non-empty row
 
     int fNumberOfHits;         // the number of hits in this slice
-       int fNumberOfHitsPlusAlign;
+    int fNumberOfHitsPlusAlign;
 
     int fMemorySize;           // size of the allocated memory in bytes
-       int fGpuMemorySize;                // size of Memory needed to be transfered to GPU
+    int fGpuMemorySize;        // size of Memory needed to be transfered to GPU
     char *fMemory;             // pointer to the allocated memory where all the following arrays reside in
-       char *fGPUTextureBase;          // pointer to start of GPU texture
+    char *fGPUTextureBase;     // pointer to start of GPU texture
 
-    AliHLTTPCCARow *fRows; // The row objects needed for most accessor functions
+    AliHLTTPCCARow *fRows;     // The row objects needed for most accessor functions
 
-       short *fLinkUpData;        // hit index in the row above which is linked to the given (global) hit index
+    short *fLinkUpData;        // hit index in the row above which is linked to the given (global) hit index
     short *fLinkDownData;      // hit index in the row below which is linked to the given (global) hit index
 
     ushort2 *fHitData;         // packed y,z coordinate of the given (global) hit index
index ac27faa..370dc30 100644 (file)
@@ -126,7 +126,7 @@ void AliHLTTPCCAStandaloneFramework::FinishDataReading()
   infile.close();*/
 
   for ( int i = 0; i < fgkNSlices; i++ ) {
-    fClusterData[i].FinishReading();
+    //fClusterData[i].FinishReading();                 //No longer needed
   }
 }
 
index 753bd94..a45fe3c 100644 (file)
@@ -753,20 +753,6 @@ GPUh() void AliHLTTPCCATracker::WriteOutput()
                        const AliHLTTPCCARow &row = fData.Row( iRow );
 
                        int clusterIndex = fData.ClusterDataIndex( row, ih );
-                       int clusterRowIndex = clusterIndex - fClusterData->RowOffset( iRow );
-
-                       if ( clusterIndex < 0 || clusterIndex >= fClusterData->NumberOfClusters() ) {
-                               //std::cout << inpIDtot << ", " << fClusterData->NumberOfClusters()
-                               //<< "; " << inpID << ", " << fClusterData->NumberOfClusters( iRow ) << std::endl;
-                               //abort();
-                               continue;
-                       }
-                       if ( clusterRowIndex < 0 || clusterRowIndex >= fClusterData->NumberOfClusters( iRow ) ) {
-                               //std::cout << inpIDtot << ", " << fClusterData->NumberOfClusters()
-                               //<< "; " << inpID << ", " << fClusterData->NumberOfClusters( iRow ) << std::endl;
-                               //abort();
-                               continue;
-                       }
 
                        float origX = fClusterData->X( clusterIndex );
                        float origY = fClusterData->Y( clusterIndex );
index bd3e6e6..1ea5853 100644 (file)
@@ -54,21 +54,24 @@ const AliHLTComponentDataType AliHLTTPCCADefinitions::fgkTrackletsDataType = Ali
 /** ROOT macro for the implementation of ROOT specific class methods */
 ClassImp( AliHLTTPCCATrackerComponent )
 
-AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent()
-    :
-    fTracker( NULL ),
-    fSolenoidBz( 0 ),
-    fMinNTrackClusters( 30 ),
-    fMinTrackPt(0.2),
-    fClusterZCut( 500. ),
-    fNeighboursSearchArea( 0 ), 
-    fClusterErrorCorrectionY(0), 
-    fClusterErrorCorrectionZ(0),
-    fBenchmark("CATracker"), 
-    fAllowGPU( 0),
-       fGPUHelperThreads(-1),
-       fCPUTrackers(0),
-       fGlobalTracking(0)
+  AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent()
+  :
+  fTracker( NULL ),
+  fClusterData( NULL ),
+  fMinSlice( 0 ),
+  fSliceCount( fgkNSlices ),
+  fSolenoidBz( 0 ),
+  fMinNTrackClusters( 30 ),
+  fMinTrackPt(0.2),
+  fClusterZCut( 500. ),
+  fNeighboursSearchArea( 0 ), 
+  fClusterErrorCorrectionY(0), 
+  fClusterErrorCorrectionZ(0),
+  fBenchmark("CATracker"), 
+  fAllowGPU( 0),
+  fGPUHelperThreads(-1),
+  fCPUTrackers(0),
+  fGlobalTracking(0)
 {
   // see header file for class documentation
   // or
@@ -78,21 +81,24 @@ AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent()
 }
 
 AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent( const AliHLTTPCCATrackerComponent& )
-    :
-    AliHLTProcessor(),
-    fTracker( NULL ),
-    fSolenoidBz( 0 ),
-    fMinNTrackClusters( 30 ),
-    fMinTrackPt( 0.2 ),
-    fClusterZCut( 500. ),
-    fNeighboursSearchArea(0),
-    fClusterErrorCorrectionY(0), 
-    fClusterErrorCorrectionZ(0),
-    fBenchmark("CATracker"),
-    fAllowGPU( 0),
-       fGPUHelperThreads(-1),
-       fCPUTrackers(0),
-       fGlobalTracking(0)
+  :
+AliHLTProcessor(),
+  fTracker( NULL ),
+  fClusterData( NULL ),
+  fMinSlice( 0 ),
+  fSliceCount( fgkNSlices ),
+  fSolenoidBz( 0 ),
+  fMinNTrackClusters( 30 ),
+  fMinTrackPt( 0.2 ),
+  fClusterZCut( 500. ),
+  fNeighboursSearchArea(0),
+  fClusterErrorCorrectionY(0), 
+  fClusterErrorCorrectionZ(0),
+  fBenchmark("CATracker"),
+  fAllowGPU( 0),
+  fGPUHelperThreads(-1),
+  fCPUTrackers(0),
+  fGlobalTracking(0)
 {
   // see header file for class documentation
   HLTFatal( "copy constructor untested" );
@@ -109,6 +115,7 @@ AliHLTTPCCATrackerComponent::~AliHLTTPCCATrackerComponent()
 {
   // see header file for class documentation
   if (fTracker) delete fTracker;
+  if (fClusterData) delete[] fClusterData;
 }
 
 //
@@ -211,27 +218,27 @@ int AliHLTTPCCATrackerComponent::ReadConfigurationString(  const char* arguments
       HLTInfo( "ClusterZCut set to: %f", fClusterZCut );
       continue;
     }
-   if ( argument.CompareTo( "-neighboursSearchArea" ) == 0 ) {
+
+    if ( argument.CompareTo( "-neighboursSearchArea" ) == 0 ) {
       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
       fNeighboursSearchArea = TMath::Abs( ( ( TObjString* )pTokens->At( i ) )->GetString().Atof() );
       HLTInfo( "NeighboursSearchArea set to: %f", fNeighboursSearchArea );
       continue;
     }
 
-   if ( argument.CompareTo( "-errorCorrectionY" ) == 0 ) {
-     if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
-     fClusterErrorCorrectionY = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
-     HLTInfo( "Cluster Y error correction factor set to: %f", fClusterErrorCorrectionY );
-     continue;
-   }
-   
-   if ( argument.CompareTo( "-errorCorrectionZ" ) == 0 ) {
-     if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
-     fClusterErrorCorrectionZ = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
-     HLTInfo( "Cluster Z error correction factor set to: %f", fClusterErrorCorrectionZ );
-     continue;
-   }
+    if ( argument.CompareTo( "-errorCorrectionY" ) == 0 ) {
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      fClusterErrorCorrectionY = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      HLTInfo( "Cluster Y error correction factor set to: %f", fClusterErrorCorrectionY );
+      continue;
+    }
+
+    if ( argument.CompareTo( "-errorCorrectionZ" ) == 0 ) {
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      fClusterErrorCorrectionZ = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      HLTInfo( "Cluster Z error correction factor set to: %f", fClusterErrorCorrectionZ );
+      continue;
+    }
 
     if (argument.CompareTo( "-allowGPU" ) == 0) {
       fAllowGPU = 1;
@@ -244,8 +251,8 @@ int AliHLTTPCCATrackerComponent::ReadConfigurationString(  const char* arguments
       HLTImportant( "Global Tracking Activated" );
       continue;
     }
-       
-       if ( argument.CompareTo( "-GPUHelperThreads" ) == 0 ) {
+
+    if ( argument.CompareTo( "-GPUHelperThreads" ) == 0 ) {
       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
       fGPUHelperThreads = ( ( TObjString* )pTokens->At( i ) )->GetString().Atoi();
       HLTInfo( "Number of GPU Helper Threads set to: %d", fGPUHelperThreads );
@@ -259,7 +266,7 @@ int AliHLTTPCCATrackerComponent::ReadConfigurationString(  const char* arguments
       continue;
     }
 
-       HLTError( "Unknown option \"%s\"", argument.Data() );
+    HLTError( "Unknown option \"%s\"", argument.Data() );
     iResult = -EINVAL;
   }
   delete pTokens;
@@ -313,23 +320,18 @@ int AliHLTTPCCATrackerComponent::Configure( const char* cdbEntry, const char* ch
   // parameters which are set on one step can be overwritten on the next step
 
   //* read hard-coded values
-
   SetDefaultConfiguration();
 
   //* read the default CDB entry
-
   int iResult1 = ReadCDBEntry( NULL, chainId );
 
   //* read magnetic field
-  
   fSolenoidBz = GetBz();
 
   //* read the actual CDB entry if required
-
   int iResult2 = ( cdbEntry ) ? ReadCDBEntry( cdbEntry, chainId ) : 0;
 
   //* read extra parameters from input (if they are)
-
   int iResult3 = 0;
 
   if ( commandLine && commandLine[0] != '\0' ) {
@@ -337,17 +339,66 @@ int AliHLTTPCCATrackerComponent::Configure( const char* cdbEntry, const char* ch
     iResult3 = ReadConfigurationString( commandLine );
   }
 
-  // Initialise the tracker here
+  if (fTracker) ConfigureSlices();
 
   return iResult1 ? iResult1 : ( iResult2 ? iResult2 :  iResult3  );
 }
 
-int AliHLTTPCCATrackerComponent::DoInit( int argc, const char** argv )
+void AliHLTTPCCATrackerComponent::ConfigureSlices()
 {
-  // Configure the CA tracker component
+  // Initialize the tracker slices
+  for (int slice = 0;slice < fgkNSlices;slice++)
+  {
+    int iSec = slice;
+    float inRmin = 83.65;
+    //    float inRmax = 133.3;
+    //    float outRmin = 133.5;
+    float outRmax = 247.7;
+    float plusZmin = 0.0529937;
+    float plusZmax = 249.778;
+    float minusZmin = -249.645;
+    float minusZmax = -0.0799937;
+    float dalpha = 0.349066;
+    float alpha = 0.174533 + dalpha * iSec;
+
+    bool zPlus = ( iSec < 18 );
+    float zMin =  zPlus ? plusZmin : minusZmin;
+    float zMax =  zPlus ? plusZmax : minusZmax;
+    //TPCZmin = -249.645, ZMax = 249.778
+    //    float rMin =  inRmin;
+    //    float rMax =  outRmax;
+    int nRows = AliHLTTPCTransform::GetNRows();
+
+    float padPitch = 0.4;
+    float sigmaZ = 0.228808;
+
+    float *rowX = new float [nRows];
+    for ( int irow = 0; irow < nRows; irow++ ) {
+      rowX[irow] = AliHLTTPCTransform::Row2X( irow );
+    }
+
+    AliHLTTPCCAParam param;
+
+    param.Initialize( iSec, nRows, rowX, alpha, dalpha,
+      inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, fSolenoidBz );
+    param.SetHitPickUpFactor( 2 );
+    if( fNeighboursSearchArea>0 ) param.SetNeighboursSearchArea( fNeighboursSearchArea );
+    if( fClusterErrorCorrectionY>1.e-4 ) param.SetClusterError2CorrectionY( fClusterErrorCorrectionY*fClusterErrorCorrectionY );
+    if( fClusterErrorCorrectionZ>1.e-4 ) param.SetClusterError2CorrectionZ( fClusterErrorCorrectionZ*fClusterErrorCorrectionZ );
+    param.SetMinNTrackClusters( fMinNTrackClusters );
+    param.SetMinTrackPt( fMinTrackPt );
 
+    param.Update();
+    fTracker->InitializeSliceParam( slice, param );
+    delete[] rowX;
+  }
+}
+
+int AliHLTTPCCATrackerComponent::DoInit( int argc, const char** argv )
+{
   if ( fTracker ) return EINPROGRESS;
 
+  // Configure the CA tracker component
   TString arguments = "";
   for ( int i = 0; i < argc; i++ ) {
     if ( !arguments.IsNull() ) arguments += " ";
@@ -355,22 +406,31 @@ int AliHLTTPCCATrackerComponent::DoInit( int argc, const char** argv )
   }
 
   int retVal = Configure( NULL, NULL, arguments.Data() );
-  if (retVal == 0) fTracker = new AliHLTTPCCATrackerFramework(fAllowGPU);
-  if (fGPUHelperThreads != -1)
+  if (retVal == 0)
   {
-    char cc[256] = "HelperThreads";
-       fTracker->SetGPUTrackerOption(cc, fGPUHelperThreads);
-  }
-  {
-    char cc[256] = "CPUTrackers";
-       fTracker->SetGPUTrackerOption(cc, fCPUTrackers);
-       char cc2[256] = "SlicesPerCPUTracker";
-       fTracker->SetGPUTrackerOption(cc2, 1);
-  }
-  if (fGlobalTracking)
-  {
-    char cc[256] = "GlobalTracking";
-       fTracker->SetGPUTrackerOption(cc, 1);
+    fMinSlice = 0;
+    fSliceCount = fgkNSlices;
+    //Create tracker instance and set parameters
+    fTracker = new AliHLTTPCCATrackerFramework(fAllowGPU);
+    fClusterData = new AliHLTTPCCAClusterData[fgkNSlices];
+    if (fGPUHelperThreads != -1)
+    {
+      char cc[256] = "HelperThreads";
+      fTracker->SetGPUTrackerOption(cc, fGPUHelperThreads);
+    }
+    {
+      char cc[256] = "CPUTrackers";
+      fTracker->SetGPUTrackerOption(cc, fCPUTrackers);
+      char cc2[256] = "SlicesPerCPUTracker";
+      fTracker->SetGPUTrackerOption(cc2, 1);
+    }
+    if (fGlobalTracking)
+    {
+      char cc[256] = "GlobalTracking";
+      fTracker->SetGPUTrackerOption(cc, 1);
+    }
+
+    ConfigureSlices();
   }
 
   return(retVal);
@@ -381,29 +441,19 @@ int AliHLTTPCCATrackerComponent::DoDeinit()
   // see header file for class documentation
   if (fTracker) delete fTracker;
   fTracker = NULL;
+  if (fClusterData) delete[] fClusterData;
+  fClusterData = NULL;
   return 0;
 }
 
 int AliHLTTPCCATrackerComponent::Reconfigure( const char* cdbEntry, const char* chainId )
 {
   // Reconfigure the component from OCDB .
-
   return Configure( cdbEntry, chainId, NULL );
 }
 
-bool AliHLTTPCCATrackerComponent::CompareClusters( AliHLTTPCSpacePointData *a, AliHLTTPCSpacePointData *b )
-{
-  //* Comparison function for sort clusters
-
-  if ( a->fPadRow < b->fPadRow ) return 1;
-  if ( a->fPadRow > b->fPadRow ) return 0;
-  return ( a->fZ < b->fZ );
-}
-
-
-
 int AliHLTTPCCATrackerComponent::DoEvent
-(
+  (
   const AliHLTComponentEventData& evtData,
   const AliHLTComponentBlockData* blocks,
   AliHLTComponentTriggerData& /*trigData*/,
@@ -412,6 +462,11 @@ int AliHLTTPCCATrackerComponent::DoEvent
   vector<AliHLTComponentBlockData>& outputBlocks )
 {
   //* process event
+  if (!fTracker)
+  {
+    HLTError( "CATracker not initialized properly" );
+    return -ENOENT;
+  }
 
   AliHLTUInt32_t maxBufferSize = size;
   size = 0; // output size
@@ -423,8 +478,6 @@ int AliHLTTPCCATrackerComponent::DoEvent
   fBenchmark.StartNewEvent();
   fBenchmark.Start(0);
 
-  // Event reconstruction in one TPC slice with CA Tracker
-
   //Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "DoEvent", "CA::DoEvent()" );
   if ( evtData.fBlockCnt <= 0 ) {
     HLTWarning( "no blocks in event" );
@@ -434,381 +487,231 @@ int AliHLTTPCCATrackerComponent::DoEvent
   const AliHLTComponentBlockData* iter = NULL;
   unsigned long ndx;
 
-  // Determine the slice number
+  // min and max patch numbers and row numbers
+  int sliceminPatch[fgkNSlices];
+  int slicemaxPatch[fgkNSlices];
+  for (int i = 0;i < fSliceCount;i++)
+  {
+    sliceminPatch[i] = 100;
+    slicemaxPatch[i] = -1;
+  }
 
-  //Find min and max slice number with now slice missing in between (for default output)
-  int minslice = -1, maxslice = -1;
-  int slice = -1;
+  //Prepare everything for all slices
+
+  for (int islice = 0;islice < fSliceCount;islice++)
   {
-    std::vector<int> slices;
-    std::vector<int>::iterator slIter;
-    std::vector<unsigned> sliceCnts;
-    std::vector<unsigned>::iterator slCntIter;
+    int slice = fMinSlice + islice;
+
+    // total n Hits
+    int nClustersTotal = 0;
+
+    // sort patches
+    std::vector<unsigned long> patchIndices;
 
     for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ ) {
       iter = blocks + ndx;
-      if ( iter->fDataType != AliHLTTPCDefinitions::fgkClustersDataType &&
-          iter->fDataType != AliHLTTPCCADefinitions::fgkCompressedInputDataType
-          ) continue;
-
-      slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
-         if (slice < minslice || minslice == -1) minslice = slice;
-         if (slice > maxslice) maxslice = slice;
-
-      bool found = 0;
-      slCntIter = sliceCnts.begin();
-      for ( slIter = slices.begin(); slIter != slices.end(); slIter++, slCntIter++ ) {
-        if ( *slIter == slice ) {
-          found = kTRUE;
-          break;
+      if ( slice != AliHLTTPCDefinitions::GetMinSliceNr( *iter ) ) continue;
+      if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType ){
+        AliHLTTPCClusterData* inPtrSP = ( AliHLTTPCClusterData* )( iter->fPtr );
+        nClustersTotal += inPtrSP->fSpacePointCnt;
+        fBenchmark.AddInput(iter->fSize);
+      } else 
+        if ( iter->fDataType == AliHLTTPCCADefinitions::fgkCompressedInputDataType){
+          fBenchmark.AddInput(iter->fSize);
+          const AliHLTUInt8_t * inPtr =  (const AliHLTUInt8_t *)iter->fPtr;
+          while( inPtr< ((const AliHLTUInt8_t *) iter->fPtr) + iter->fSize ){
+            AliHLTTPCCACompressedClusterRow *row = (AliHLTTPCCACompressedClusterRow*)inPtr;
+            nClustersTotal+= row->fNClusters;    
+            inPtr = (const AliHLTUInt8_t *)(row->fClusters+row->fNClusters);
+          }
         }
-      }
-      if ( !found ) {
-        slices.push_back( slice );
-        sliceCnts.push_back( 1 );
-      } else (*slCntIter)++;
-    }
+        else continue;
 
-         if ( slices.size() == 0 ) {
-               HLTWarning( "no slices found in event" );
-               return 0;
-         }
-
-
-    // Determine slice number to really use. (for obsolete output)
-    if ( slices.size() > 1 ) {
-      Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
-               "Multiple slice numbers found in event 0x%08lX (%lu). Determining maximum occuring slice number...",
-               evtData.fEventID, evtData.fEventID );
-      slCntIter = sliceCnts.begin();
-      for ( slIter = slices.begin(); slIter != slices.end(); slIter++, slCntIter++ ) {
-        Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
-                 "Slice %lu found %lu times.", *slIter, *slCntIter );
-      }
-    } else if ( slices.size() > 0 ) {
-      slice = *( slices.begin() );
+        int patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
+        if ( sliceminPatch[islice] > patch ) {
+          sliceminPatch[islice] = patch;
+        }
+        if ( slicemaxPatch[islice] < patch ) {
+          slicemaxPatch[islice] = patch;
+        }
+        std::vector<unsigned long>::iterator pIter = patchIndices.begin();
+        while ( pIter != patchIndices.end() && AliHLTTPCDefinitions::GetMinPatchNr( blocks[*pIter] ) < patch ) {
+          pIter++;
+        }
+        patchIndices.insert( pIter, ndx );
     }
 
 
-    for (int islice = minslice;islice <= maxslice;islice++)
-      {
-       bool found = false;
-       for(slIter = slices.begin(); slIter != slices.end();slIter++)
-         {
-           if (*slIter == islice)
-             {
-               found = true;
-               break;
-             }
-         }
-       if (!found)
-         {
-           maxslice = islice - 1;
-           break;
-         }
-      }
-  }
-
-  if ( !fTracker ) fTracker = new AliHLTTPCCATrackerFramework(fAllowGPU);
-
-  int slicecount = maxslice + 1 - minslice;
-  if (slicecount > fTracker->MaxSliceCount())
-  {
-       maxslice = minslice + (slicecount = fTracker->MaxSliceCount()) - 1;
-  }
-  int nClustersTotalSum = 0;
-  AliHLTTPCCAClusterData* clusterData = new AliHLTTPCCAClusterData[slicecount];
-
+    // pass event to CA Tracker
 
-  // min and max patch numbers and row numbers
-  int* slicerow = new int[slicecount * 2];
-  int* sliceminPatch = new int[slicecount];
-  int* slicemaxPatch = new int[slicecount];
-  memset(slicerow, 0, slicecount * 2 * sizeof(int));
-  for (int i = 0;i < slicecount;i++)
-  {
-         sliceminPatch[i] = 100;
-         slicemaxPatch[i] = -1;
-  }
 
-  //Prepare everything for all slices
+    Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reading hits",
+      "Total %d hits to read for slice %d", nClustersTotal, slice );
 
-  for (int islice = 0;islice < slicecount;islice++)
-  {
-         slice = minslice + islice;
-
-         // Initialize the tracker slice
-         {
-               int iSec = slice;
-               float inRmin = 83.65;
-               //    float inRmax = 133.3;
-               //    float outRmin = 133.5;
-               float outRmax = 247.7;
-               float plusZmin = 0.0529937;
-               float plusZmax = 249.778;
-               float minusZmin = -249.645;
-               float minusZmax = -0.0799937;
-               float dalpha = 0.349066;
-               float alpha = 0.174533 + dalpha * iSec;
-
-               bool zPlus = ( iSec < 18 );
-               float zMin =  zPlus ? plusZmin : minusZmin;
-               float zMax =  zPlus ? plusZmax : minusZmax;
-               //TPCZmin = -249.645, ZMax = 249.778
-               //    float rMin =  inRmin;
-               //    float rMax =  outRmax;
-               int nRows = AliHLTTPCTransform::GetNRows();
-
-               float padPitch = 0.4;
-               float sigmaZ = 0.228808;
-
-               float *rowX = new float [nRows];
-               for ( int irow = 0; irow < nRows; irow++ ) {
-                 rowX[irow] = AliHLTTPCTransform::Row2X( irow );
-               }
-
-               AliHLTTPCCAParam param;
-
-               param.Initialize( iSec, nRows, rowX, alpha, dalpha,
-                                                 inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, fSolenoidBz );
-               param.SetHitPickUpFactor( 2 );
-               if( fNeighboursSearchArea>0 ) param.SetNeighboursSearchArea( fNeighboursSearchArea );
-               if( fClusterErrorCorrectionY>1.e-4 ) param.SetClusterError2CorrectionY( fClusterErrorCorrectionY*fClusterErrorCorrectionY );
-               if( fClusterErrorCorrectionZ>1.e-4 ) param.SetClusterError2CorrectionZ( fClusterErrorCorrectionZ*fClusterErrorCorrectionZ );
-               param.SetMinNTrackClusters( fMinNTrackClusters );
-               param.SetMinTrackPt( fMinTrackPt );
-
-               param.Update();
-               fTracker->InitializeSliceParam( slice, param );
-               delete[] rowX;
-         }
-
-         // total n Hits
-         int nClustersTotal = 0;
-
-         // sort patches
-         std::vector<unsigned long> patchIndices;
-
-         for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ ) {
-               iter = blocks + ndx;
-               if ( slice != AliHLTTPCDefinitions::GetMinSliceNr( *iter ) ) continue;
-               if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType ){
-                 AliHLTTPCClusterData* inPtrSP = ( AliHLTTPCClusterData* )( iter->fPtr );
-                 nClustersTotal += inPtrSP->fSpacePointCnt;
-                 fBenchmark.AddInput(iter->fSize);
-               } else 
-               if ( iter->fDataType == AliHLTTPCCADefinitions::fgkCompressedInputDataType){
-                 fBenchmark.AddInput(iter->fSize);
-                 const AliHLTUInt8_t * inPtr =  (const AliHLTUInt8_t *)iter->fPtr;
-                 while( inPtr< ((const AliHLTUInt8_t *) iter->fPtr) + iter->fSize ){
-                   AliHLTTPCCACompressedClusterRow *row = (AliHLTTPCCACompressedClusterRow*)inPtr;
-                   nClustersTotal+= row->fNClusters;     
-                   inPtr = (const AliHLTUInt8_t *)(row->fClusters+row->fNClusters);
-                 }
-               }
-               else continue;
-
-               int patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
-               if ( sliceminPatch[islice] > patch ) {
-                 sliceminPatch[islice] = patch;
-                 slicerow[2 * islice + 0] = AliHLTTPCTransform::GetFirstRow( patch );
-               }
-               if ( slicemaxPatch[islice] < patch ) {
-                 slicemaxPatch[islice] = patch;
-                 slicerow[2 * islice + 1] = AliHLTTPCTransform::GetLastRow( patch );
-               }
-               std::vector<unsigned long>::iterator pIter = patchIndices.begin();
-               while ( pIter != patchIndices.end() && AliHLTTPCDefinitions::GetMinPatchNr( blocks[*pIter] ) < patch ) {
-                 pIter++;
-               }
-               patchIndices.insert( pIter, ndx );
-         }
-
-
-         // pass event to CA Tracker
-
-
-         Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reading hits",
-                          "Total %d hits to read for slice %d", nClustersTotal, slice );
-
-         if (nClustersTotal > 500000)
-         {
-                 HLTWarning( "Too many clusters in tracker input: Slice %d, Number of Clusters %d, some clusters are droped", slice, nClustersTotal );
-                 nClustersTotal = 500000;
-         }
-
-
-         clusterData[islice].StartReading( slice, nClustersTotal );
-         int nSliceClust = 0;
-
-         for ( std::vector<unsigned long>::iterator pIter = patchIndices.begin(); pIter != patchIndices.end(); pIter++ ) {
-               ndx = *pIter;
-               iter = blocks + ndx;
-               int patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
-               int nPatchClust = 0;
-              
-               if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType ){
-                 AliHLTTPCClusterData* inPtrSP = ( AliHLTTPCClusterData* )( iter->fPtr );
-                 nPatchClust = inPtrSP->fSpacePointCnt;
-                 for ( unsigned int i = 0; i < inPtrSP->fSpacePointCnt; i++ ) {
-                   AliHLTTPCSpacePointData *c = &( inPtrSP->fSpacePoints[i] );
-                   if ( CAMath::Abs( c->fZ ) > fClusterZCut ) continue;
-                   if ( c->fPadRow > 159 ) {
-                     HLTError( "Wrong TPC cluster with row number %d received", c->fPadRow );
-                     continue;
-                   }
-                       if (nSliceClust < nClustersTotal)
-                       {
-                     clusterData[islice].ReadCluster( c->fID, c->fPadRow, c->fX, c->fY, c->fZ, c->fCharge );
-                         nSliceClust++;
-                       }
-                 }           
-               } else         
-               if ( iter->fDataType == AliHLTTPCCADefinitions::fgkCompressedInputDataType){
-                 const AliHLTUInt8_t * inPtr = (const AliHLTUInt8_t *)iter->fPtr;
-                 nPatchClust=0;
-                 while( inPtr< ((const AliHLTUInt8_t *)iter->fPtr) + iter->fSize ){
-                   AliHLTTPCCACompressedClusterRow *row = (AliHLTTPCCACompressedClusterRow*)inPtr;
-                   UInt_t id = row->fSlicePatchRowID;
-                   UInt_t jslice = id>>10;       
-                   UInt_t jpatch = (id>>6) & 0x7;
-                   UInt_t jrow   =  id     & 0x3F;     
-                   jrow+= AliHLTTPCTransform::GetFirstRow( jpatch );
-                   Double_t rowX = AliHLTTPCTransform::Row2X( jrow );
-                   //cout<<"Read row: s "<<jslice<<" p "<<jpatch<<" r "<<jrow<<" x "<<row->fX<<" nclu "<<row->fNClusters<<" :"<<endl;
-                   if( jrow > 159 ) {
-                     HLTError( "Wrong TPC cluster with row number %d received", jrow );
-                     continue;
-                   }
-                   for ( unsigned int i = 0; i < row->fNClusters; i++ ) {
-                     AliHLTTPCCACompressedCluster *c = &( row->fClusters[i] );
-                     
-                     UInt_t ix0 = c->fP0 >>24;
-                     UInt_t ix1 = c->fP1 >>24;
-                     Double_t x = (ix1<<8) + ix0;
-                     Double_t y = c->fP0 & 0x00FFFFFF;
-                     Double_t z = c->fP1 & 0x00FFFFFF;
-                     x = (x - 32768.)*1.e-4 + rowX;
-                     y = (y - 8388608.)*1.e-4;
-                     z = (z - 8388608.)*1.e-4;
-                     
-                     UInt_t cluId = AliHLTTPCSpacePointData::GetID( jslice, jpatch, nPatchClust );
-                     //cout<<"clu "<<i<<": "<<x<<" "<<y<<" "<<z<<" "<<cluId<<endl;
-                     if ( CAMath::Abs( z ) <= fClusterZCut && nSliceClust < nClustersTotal){
-                       clusterData[islice].ReadCluster( cluId, jrow, x, y, z, 0 );
-                       nSliceClust++;
-                     }
-                     nPatchClust++;              
-                   }
-                   inPtr = (const AliHLTUInt8_t *)(row->fClusters+row->fNClusters);
-                 }
-               }
-               Logging( kHLTLogInfo, "HLT::TPCCATracker::DoEvent", "Reading hits",
-                        "Read %d hits for slice %d - patch %d", nPatchClust, slice, patch );
-         }
-
-         clusterData[islice].FinishReading();
-         nClustersTotalSum += nClustersTotal;
+    if (nClustersTotal > 500000)
+    {
+      HLTWarning( "Too many clusters in tracker input: Slice %d, Number of Clusters %d, slice not included in tracking", slice, nClustersTotal );
+      fClusterData[islice].StartReading( slice, 0 );
+    }
+    else
+    {
+      fClusterData[islice].StartReading( slice, nClustersTotal );
+
+      for ( std::vector<unsigned long>::iterator pIter = patchIndices.begin(); pIter != patchIndices.end(); pIter++ ) {
+        ndx = *pIter;
+        iter = blocks + ndx;
+        int patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
+        int nPatchClust = 0;
+
+        if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType ) {
+          AliHLTTPCCAClusterData::Data* pCluster = &fClusterData[islice].Clusters()[fClusterData[islice].NumberOfClusters()];
+          AliHLTTPCClusterData* inPtrSP = ( AliHLTTPCClusterData* )( iter->fPtr );
+          nPatchClust = inPtrSP->fSpacePointCnt;
+          const AliHLTTPCSpacePointData* pLastSpacePoint = &inPtrSP->fSpacePoints[inPtrSP->fSpacePointCnt];
+          for ( const AliHLTTPCSpacePointData* pSpacePoint = inPtrSP->fSpacePoints; pSpacePoint < pLastSpacePoint; pSpacePoint++ ) {
+            if ( pSpacePoint->fZ > fClusterZCut || pSpacePoint->fZ < -fClusterZCut) continue;
+            pCluster->fId = pSpacePoint->fID;
+            pCluster->fRow = pSpacePoint->fPadRow;
+            pCluster->fX = pSpacePoint->fX;
+            pCluster->fY = pSpacePoint->fY;
+            pCluster->fZ = pSpacePoint->fZ;
+            pCluster->fAmp = pSpacePoint->fCharge;
+            pCluster++;
+          }
+          fClusterData[islice].SetNumberOfClusters(pCluster - fClusterData[islice].Clusters());
+        }
+        else if ( iter->fDataType == AliHLTTPCCADefinitions::fgkCompressedInputDataType)
+        {
+          const AliHLTUInt8_t * inPtr = (const AliHLTUInt8_t *)iter->fPtr;
+          nPatchClust=0;
+          while( inPtr< ((const AliHLTUInt8_t *)iter->fPtr) + iter->fSize ){
+            AliHLTTPCCACompressedClusterRow *row = (AliHLTTPCCACompressedClusterRow*)inPtr;
+            UInt_t id = row->fSlicePatchRowID;
+            UInt_t jslice = id>>10;    
+            UInt_t jpatch = (id>>6) & 0x7;
+            UInt_t jrow   =  id     & 0x3F;     
+            jrow+= AliHLTTPCTransform::GetFirstRow( jpatch );
+            Double_t rowX = AliHLTTPCTransform::Row2X( jrow );
+            //cout<<"Read row: s "<<jslice<<" p "<<jpatch<<" r "<<jrow<<" x "<<row->fX<<" nclu "<<row->fNClusters<<" :"<<endl;
+            if( jrow > 159 ) {
+              HLTError( "Wrong TPC cluster with row number %d received", jrow );
+              continue;
+            }
+            for ( unsigned int i = 0; i < row->fNClusters; i++ ) {
+              AliHLTTPCCACompressedCluster *c = &( row->fClusters[i] );
+
+              UInt_t ix0 = c->fP0 >>24;
+              UInt_t ix1 = c->fP1 >>24;
+              Double_t x = (ix1<<8) + ix0;
+              Double_t y = c->fP0 & 0x00FFFFFF;
+              Double_t z = c->fP1 & 0x00FFFFFF;
+              x = (x - 32768.)*1.e-4 + rowX;
+              y = (y - 8388608.)*1.e-4;
+              z = (z - 8388608.)*1.e-4;
+
+              UInt_t cluId = AliHLTTPCSpacePointData::GetID( jslice, jpatch, nPatchClust );
+              //cout<<"clu "<<i<<": "<<x<<" "<<y<<" "<<z<<" "<<cluId<<endl;
+              if ( CAMath::Abs( z ) <= fClusterZCut){
+                fClusterData[islice].ReadCluster( cluId, jrow, x, y, z, 0 );
+              }
+              nPatchClust++;      
+            }
+            inPtr = (const AliHLTUInt8_t *)(row->fClusters+row->fNClusters);
+          }
+        }
+        Logging( kHLTLogInfo, "HLT::TPCCATracker::DoEvent", "Reading hits",
+          "Read %d hits for slice %d - patch %d", nPatchClust, slice, patch );
+      }
+    }
   }
 
   //Prepare Output
   AliHLTTPCCASliceOutput::outputControlStruct outputControl;
-  //Set tracker output so tracker does not have to output both formats!
   outputControl.fEndOfSpace = 0;
-
-  //For new output we can write directly to output buffer
   outputControl.fOutputPtr =  (char*) outputPtr;
   outputControl.fOutputMaxSize = maxBufferSize;
+  fTracker->SetOutputControl(&outputControl);
 
-  AliHLTTPCCASliceOutput** sliceOutput = new AliHLTTPCCASliceOutput*[slicecount];
-  memset(sliceOutput, 0, slicecount * sizeof(AliHLTTPCCASliceOutput*));
+  memset(fSliceOutput, 0, fSliceCount * sizeof(AliHLTTPCCASliceOutput*));
 
   // reconstruct the event
-
   fBenchmark.Start(1);
-  fTracker->SetOutputControl(&outputControl);
-  fTracker->ProcessSlices(minslice, slicecount, clusterData, sliceOutput);
+  fTracker->ProcessSlices(fMinSlice, fSliceCount, fClusterData, fSliceOutput);
   fBenchmark.Stop(1);
-  
+
   int ret = 0;
   unsigned int mySize = 0;
   int ntracks = 0;
   int error = 0;
 
-  for (int islice = 0;islice < slicecount;islice++)
+  for (int islice = 0;islice < fSliceCount;islice++)
   {
+    if (slicemaxPatch[islice] == -1) continue;
+    int slice = fMinSlice + islice;
+
     if( outputControl.fEndOfSpace ){
-      HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), tracks are not stored", maxBufferSize, mySize );
+      HLTWarning( "Output buffer size exceeded (buffer size %d, required size %d), tracks are not stored", maxBufferSize, mySize );
       ret = -ENOSPC;
       error = 1;
       break;     
     }
-    slice = minslice + islice;
-    
-    if (sliceOutput[islice])
-      {
-       // write reconstructed tracks
-       Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reconstruct",
-                "%d tracks found for slice %d", sliceOutput[islice]->NTracks(), slice );
-       
-       mySize += sliceOutput[islice]->Size();
-       ntracks += sliceOutput[islice]->NTracks();        
-      }
+
+    if (fSliceOutput[islice])
+    {
+      // write reconstructed tracks
+      Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reconstruct", "%d tracks found for slice %d", fSliceOutput[islice]->NTracks(), slice );
+
+      mySize += fSliceOutput[islice]->Size();
+      ntracks += fSliceOutput[islice]->NTracks();    
+    }
     else
-      {
-       HLTWarning( "Error during Tracking, no tracks stored" );
-       mySize = 0;
-       ret = -ENOSPC;
-       ntracks = 0;
-       error = 1;
-       break;
-      }
+    {
+      HLTWarning( "Error during Tracking, no tracks stored" );
+      mySize = 0;
+      ret = -ENOSPC;
+      ntracks = 0;
+      error = 1;
+      break;
+    }
   }
-  
+
   size = 0;
   if (error == 0)
   {
-    for (int islice = 0;islice < slicecount;islice++)
+    for (int islice = 0;islice < fSliceCount;islice++)
+    {
+      if (slicemaxPatch[islice] == -1) continue;
+      int slice = fMinSlice + islice;
+
+      mySize = fSliceOutput[islice]->Size();
+      if (mySize > 0)
       {
-       slice = minslice + islice;
-       mySize = sliceOutput[islice]->Size();
-       if (mySize > 0)
-         {
-           AliHLTComponentBlockData bd;
-           FillBlockData( bd );
-           bd.fOffset = ((char*) sliceOutput[islice] - (char*) outputPtr);
-           bd.fSize = mySize;
-           bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, sliceminPatch[islice], slicemaxPatch[islice] );
-           bd.fDataType = GetOutputDataType();
-           outputBlocks.push_back( bd );
-           size += mySize;
-           fBenchmark.AddOutput(bd.fSize);
-         }
+        AliHLTComponentBlockData bd;
+        FillBlockData( bd );
+        bd.fOffset = ((char*) fSliceOutput[islice] - (char*) outputPtr);
+        bd.fSize = mySize;
+        bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, sliceminPatch[islice], slicemaxPatch[islice] );
+        bd.fDataType = GetOutputDataType();
+        outputBlocks.push_back( bd );
+        size += mySize;
+        fBenchmark.AddOutput(bd.fSize);
       }
+    }
   }
 
-
   //No longer needed
 
-  delete[] clusterData;
-  delete[] sliceOutput;
-
   fBenchmark.Stop(0);
 
   // Set log level to "Warning" for on-line system monitoring
 
   //Min and Max Patch are taken for first slice processed...
 
-  if( minslice==maxslice ) fBenchmark.SetName(Form("CATracker slice %d",minslice));
-  else fBenchmark.SetName(Form("CATracker slices %d-%d",minslice,maxslice));
+  fBenchmark.SetName(Form("CATracker"));
 
   HLTInfo(fBenchmark.GetStatistics());
   //No longer needed
 
-  delete[] slicerow;
-  delete[] sliceminPatch;
-  delete[] slicemaxPatch;
-
   return ret;
 }
 
index 7365953..724c84f 100644 (file)
@@ -15,6 +15,7 @@
 
 class AliHLTTPCCATrackerFramework;
 class AliHLTTPCCASliceOutput;
+class AliHLTTPCCAClusterData;
 class AliHLTTPCSpacePointData;
 
 /**
@@ -76,31 +77,39 @@ class AliHLTTPCCATrackerComponent : public AliHLTProcessor
 
   private:
 
+    static const int fgkNSlices = 36;       //* N slices
+
     /** the tracker object */
-    AliHLTTPCCATrackerFramework* fTracker;                                //! transient
+    AliHLTTPCCATrackerFramework* fTracker;                      //! transient
+    AliHLTTPCCAClusterData* fClusterData;                       //Storage classes for cluser data in slice
+    AliHLTTPCCASliceOutput* fSliceOutput[fgkNSlices];           //Pointers to slice tracker output structures
+
+    //The following parameters are maintained for compatibility to be able to change the component
+    //such to process less than all 36 slices. Currently, fMinSlice is always 0 and fSliceCount is 36
+    int fMinSlice;                                              //minimum slice number to be processed
+    int fSliceCount;                                            //Number of slices to be processed
 
     /** magnetic field */
-    double fSolenoidBz;                                            // see above
-    int fMinNTrackClusters; //* required min number of clusters on the track
-    double fMinTrackPt;    //* required min Pt of tracks
-    double fClusterZCut;  //* cut on cluster Z position (for noise rejection at the age of TPC)
-       double fNeighboursSearchArea; //* area in cm for the neighbour search algorithm
-    double fClusterErrorCorrectionY; // correction for the cluster errors
-    double fClusterErrorCorrectionZ; // correction for the cluster errors
+    double fSolenoidBz;               // see above
+    int fMinNTrackClusters;           //* required min number of clusters on the track
+    double fMinTrackPt;               //* required min Pt of tracks
+    double fClusterZCut;              //* cut on cluster Z position (for noise rejection at the age of TPC)
+    double fNeighboursSearchArea;     //* area in cm for the neighbour search algorithm
+    double fClusterErrorCorrectionY;  // correction for the cluster errors
+    double fClusterErrorCorrectionZ;  // correction for the cluster errors
 
     AliHLTComponentBenchmark fBenchmark; // benchmarks
-    bool fAllowGPU;    //* Allow this tracker to run on GPU
-       int fGPUHelperThreads;          // Number of helper threads for GPU tracker, set to -1 to use default number
-       int fCPUTrackers;  //Number of CPU trackers to run in addition to GPU tracker
-       bool fGlobalTracking;   //Activate global tracking feature
-
-    static bool CompareClusters( AliHLTTPCSpacePointData *a, AliHLTTPCSpacePointData *b );
+    bool fAllowGPU;                   //* Allow this tracker to run on GPU
+    int fGPUHelperThreads;            // Number of helper threads for GPU tracker, set to -1 to use default number
+    int fCPUTrackers;                 //Number of CPU trackers to run in addition to GPU tracker
+    bool fGlobalTracking;             //Activate global tracking feature
 
     /** set configuration parameters **/
     void SetDefaultConfiguration();
     int ReadConfigurationString(  const char* arguments );
     int ReadCDBEntry( const char* cdbEntry, const char* chainId );
-    int Configure( const char* cdbEntry, const char* chainId, const char *commandLine  );
+    int Configure( const char* cdbEntry, const char* chainId, const char *commandLine );
+    void ConfigureSlices();
 
     ClassDef( AliHLTTPCCATrackerComponent, 0 );