output of the slice tracker optimised
authorsgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 18 Feb 2010 19:19:02 +0000 (19:19 +0000)
committersgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 18 Feb 2010 19:19:02 +0000 (19:19 +0000)
HLT/TPCLib/tracking-ca/AliHLTTPCCAMerger.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAPerformance.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutCluster.h [new file with mode: 0644]
HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutTrack.h [moved from HLT/TPCLib/tracking-ca/AliHLTTPCCASliceTrack.h with 58% similarity]
HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutput.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutput.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.cxx

index ad388ff..00fd044 100644 (file)
@@ -18,7 +18,7 @@
 //***************************************************************************
 
 #include <stdio.h>
-#include "AliHLTTPCCASliceTrack.h"
+#include "AliHLTTPCCASliceOutTrack.h"
 #include "AliHLTTPCCATracker.h"
 #include "AliHLTTPCCATrackParam.h"
 
@@ -28,7 +28,6 @@
 #include "TStopwatch.h"
 
 #include "AliHLTTPCCATrackParam.h"
-#include "AliHLTTPCCASliceTrack.h"
 #include "AliHLTTPCCASliceOutput.h"
 #include "AliHLTTPCCAMergedTrack.h"
 #include "AliHLTTPCCAMergerOutput.h"
@@ -227,28 +226,28 @@ void AliHLTTPCCAMerger::UnpackSlices()
 
     const AliHLTTPCCASliceOutput &slice = *( fkSlices[iSlice] );
 
+    const AliHLTTPCCASliceOutTrack *sliceTr = slice.GetFirstTrack();
+    
     for ( int itr = 0; itr < slice.NTracks(); itr++ ) {
 
-      const AliHLTTPCCASliceTrack &sTrack = slice.Track( itr );
       AliHLTTPCCATrackParam t0;
-         t0.InitParam();
-         t0.SetParam(sTrack.Param());
+      t0.InitParam();
+      t0.SetParam(sliceTr->Param());
       int nCluNew = 0;
-
-      for ( int iTrClu = 0; iTrClu < sTrack.NClusters(); iTrClu++ ) {
-
+      int nCluOld = sliceTr->NClusters();
+      for ( int iTrClu = 0; iTrClu < nCluOld; iTrClu++ ) {
+       
         // unpack cluster information
 
         AliHLTTPCCAClusterInfo &clu = fClusterInfos[nClustersCurrent + nCluNew];
-        int ic = sTrack.FirstClusterRef() + iTrClu;
-
+       int id, row;
+       float x,y,z;
+       sliceTr->Cluster( iTrClu ).Get(id,row,x,y,z);
+       
         clu.SetISlice( iSlice );
-        clu.SetIRow( slice.ClusterRow( ic ) );
-        clu.SetId( slice.ClusterId( ic ) );
+        clu.SetIRow( row );
+        clu.SetId( id );
         clu.SetPackedAmp( 0 );
-       float x,y,z;
-       AliHLTTPCCADataCompressor::UnpackXYZ( clu.IRow(), slice.ClusterPackedXYZ(ic), x, y, z );
-        
         clu.SetX( x );
         clu.SetY( y );
         clu.SetZ( z );
@@ -263,8 +262,6 @@ void AliHLTTPCCAMerger::UnpackSlices()
         nCluNew++ ;
       }
 
-      if ( nCluNew < .8*sTrack.NClusters() ) continue;
-
       // refit the track
 
       int hits[1000];
@@ -272,11 +269,15 @@ void AliHLTTPCCAMerger::UnpackSlices()
       for ( int i = 0; i < nHits; i++ ) hits[i] = nClustersCurrent + i;
 
       AliHLTTPCCATrackParam startPoint;
-         startPoint.InitParam();
-         startPoint.SetParam(sTrack.Param());
+      startPoint.InitParam();
+      startPoint.SetParam(sliceTr->Param());
       AliHLTTPCCATrackParam endPoint = startPoint;
       float startAlpha = fSliceParam.Alpha( iSlice );
       float endAlpha = startAlpha;
+  
+      sliceTr = sliceTr->GetNextTrack();
+      
+      if ( nCluNew < .8*nCluOld ) continue;
 
       if ( !FitTrack( endPoint, endAlpha, startPoint, startAlpha, hits, nHits, 0 ) ) continue;
 
@@ -284,7 +285,7 @@ void AliHLTTPCCAMerger::UnpackSlices()
       startAlpha = endAlpha;
       if ( !FitTrack( startPoint, startAlpha, endPoint, endAlpha, hits, nHits, 1 ) ) continue;
 
-      if ( nHits < .8*sTrack.NClusters() ) continue;
+      if ( nHits < .8*nCluOld ) continue;
 
       // store the track
 
index c4d8ce8..f9c7aa1 100644 (file)
@@ -24,7 +24,7 @@
 #include "AliHLTTPCCATracker.h"
 #include "AliHLTTPCCATracklet.h"
 #include "AliHLTTPCCAStandaloneFramework.h"
-#include "AliHLTTPCCASliceTrack.h"
+#include "AliHLTTPCCASliceOutTrack.h"
 #include "AliHLTTPCCASliceOutput.h"
 #include "AliHLTTPCCAMergerOutput.h"
 #include "AliHLTTPCCAMergedTrack.h"
@@ -1226,13 +1226,18 @@ void AliHLTTPCCAPerformance::SlicePerformance( int iSlice, bool PrintFlag )
 
   nRecTot += traN;
 
-  for ( int itr = 0; itr < traN; itr++ ) {
+  const AliHLTTPCCASliceOutTrack *tCA = output.GetFirstTrack();
 
-    const AliHLTTPCCASliceTrack &tCA = output.Track( itr );
+  for ( int itr = 0; itr < traN; itr++ ) {
+    
     std::vector<int> clusterIDs;
-    for ( int i = 0; i < tCA.NClusters(); i++ ) {
-      clusterIDs.push_back( output.ClusterId( tCA.FirstClusterRef() + i ) );
+    for ( int i = 0; i < tCA->NClusters(); i++ ) {
+      int id, row;
+      float x,y,z;
+      tCA->Cluster(i).Get(id,row,x,y,z);
+      clusterIDs.push_back( id );
     }
+    tCA = tCA->GetNextTrack();
     int label;
     float purity;
     GetMCLabel( clusterIDs, label, purity );
diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutCluster.h b/HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutCluster.h
new file mode 100644 (file)
index 0000000..5e0f074
--- /dev/null
@@ -0,0 +1,41 @@
+//-*- Mode: C++ -*-
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        *
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
+
+
+#ifndef ALIHLTTPCCASLICEOUTCLUSTER_H
+#define ALIHLTTPCCASLICEOUTCLUSTER_H
+
+#include "AliHLTTPCCACompressedInputData.h"
+#include "AliHLTTPCCADataCompressor.h"
+
+/**
+ * @class AliHLTTPCCASliceOutCluster
+ * AliHLTTPCCASliceOutCluster class contains clusters which are assigned to slice tracks.
+ * It is used to send the data from TPC slice trackers to the GlobalMerger
+ */
+class AliHLTTPCCASliceOutCluster
+{
+  public:
+
+  GPUhd() void Set( int Id, int row, float x, float y, float z ){
+    fId = Id;  fRow = (UChar_t) row; 
+    fXYZp = AliHLTTPCCADataCompressor::PackXYZ( row, x, y, z );
+  }
+
+  GPUhd() void Get( int &Id, int &row, float &x, float &y, float &z ) const{
+    Id = fId;  row = fRow;
+    AliHLTTPCCADataCompressor::UnpackXYZ( fRow, fXYZp, x, y, z  );
+  }  
+    
+  private:
+    Int_t fId; // Id ( slice, patch, cluster )
+    UChar_t fRow; // row number
+    AliHLTTPCCACompressedCluster fXYZp;// packed coordinates
+};
+
+#endif 
@@ -7,43 +7,53 @@
 //*************************************************************************
 
 
-#ifndef ALIHLTTPCCASLICETRACK_H
-#define ALIHLTTPCCASLICETRACK_H
+#ifndef ALIHLTTPCCASLICEOUTTRACK_H
+#define ALIHLTTPCCASLICEOUTTRACK_H
 
 #include "AliHLTTPCCABaseTrackParam.h"
+#include "AliHLTTPCCASliceOutCluster.h"
 
 /**
- * @class AliHLTTPCCASliceTrack
- * AliHLTTPCCASliceTrack class is used to store TPC tracks,
+ * @class AliHLTTPCCASliceOutTrack
+ * AliHLTTPCCASliceOutTrack class is used to store TPC tracks,
  * which are reconstructed by the TPCCATracker slice tracker.
  *
  * The class contains:
  * - fitted track parameters at its first row, the covariance matrix, \Chi^2, NDF (number of degrees of freedom )
  * - n of clusters assigned to the track
- * - index of its first cluster in corresponding cluster arrays
+ * - clusters in corresponding cluster arrays
  *
  * The class is used to transport the data between AliHLTTPCCATracker{Component} and AliHLTTPCCAGBMerger{Component}
  *
  */
-class AliHLTTPCCASliceTrack
+class AliHLTTPCCASliceOutTrack
 {
   public:
 
     GPUhd() int NClusters()                    const { return fNClusters;       }
-    GPUhd() int FirstClusterRef()              const { return fFirstClusterRef; }
     GPUhd() const AliHLTTPCCABaseTrackParam &Param() const { return fParam;           }
+    GPUhd() const AliHLTTPCCASliceOutCluster &Cluster( int i ) const { return fClusters[i];           }
 
     GPUhd() void SetNClusters( int v )                   { fNClusters = v;       }
-    GPUhd() void SetFirstClusterRef( int v )              { fFirstClusterRef = v; }
     GPUhd() void SetParam( const AliHLTTPCCABaseTrackParam &v ) { fParam = v;           }
+    GPUhd() void SetCluster( int i, const AliHLTTPCCASliceOutCluster &v ) { fClusters[i] = v;           }
+    
+    GPUhd() static int GetSize( int nClust )  { return sizeof(AliHLTTPCCASliceOutTrack)+nClust*sizeof(AliHLTTPCCASliceOutCluster) ;}
+
+    GPUhd() AliHLTTPCCASliceOutTrack *NextTrack(){
+      return ( AliHLTTPCCASliceOutTrack*)( ((char*)this) + GetSize( fNClusters ) );
+    }
+
+    GPUhd() const AliHLTTPCCASliceOutTrack *GetNextTrack() const{
+      return ( AliHLTTPCCASliceOutTrack*)( ((char*)this) + GetSize( fNClusters ) );
+    }
 
   private:
 
     AliHLTTPCCABaseTrackParam fParam; //* fitted track parameters at its innermost cluster
-    int fFirstClusterRef;       //* index of the index of the first track cluster in corresponding cluster arrays
     int fNClusters;             //* number of track clusters
-
+    AliHLTTPCCASliceOutCluster fClusters[0]; //* track clusters
 };
 
 
-#endif //ALIHLTTPCCASLICETRACK_H
+#endif
index c725d3e..231c67d 100644 (file)
@@ -25,9 +25,7 @@ GPUhd() int AliHLTTPCCASliceOutput::EstimateSize( int nOfTracks, int nOfTrackClu
 {
   // calculate the amount of memory [bytes] needed for the event
 
-  const int kClusterDataSize = sizeof(  int ) + sizeof( unsigned short ) + sizeof( float2 ) + sizeof( float ) + sizeof( UChar_t ) + sizeof( UChar_t );
-
-  return sizeof( AliHLTTPCCASliceOutput ) + sizeof( AliHLTTPCCASliceTrack )*nOfTracks + kClusterDataSize*nOfTrackClusters;
+  return sizeof( AliHLTTPCCASliceOutput ) + sizeof( AliHLTTPCCASliceOutTrack )*nOfTracks + sizeof(AliHLTTPCCASliceOutCluster)*nOfTrackClusters;
 }
 
 #ifndef HLTCA_GPUCODE
@@ -39,29 +37,6 @@ inline void AssignNoAlignment( int &dst, int &size, int count )
   size = dst + count ;
 }
 
-void AliHLTTPCCASliceOutput::SetPointers(int nTracks, int nTrackClusters, const outputControlStruct* outputControl)
-{
-  // set all pointers
-       if (nTracks == -1) nTracks = fNTracks;
-       if (nTrackClusters == -1) nTrackClusters = fNTrackClusters;
-
-  int size = 0;
-
-  {
-    AssignNoAlignment( fTracksOffset,            size, nTracks*sizeof(AliHLTTPCCASliceTrack) );
-    AssignNoAlignment( fClusterIdOffset,         size, nTrackClusters*sizeof(int) );
-    AssignNoAlignment( fClusterRowOffset,        size, nTrackClusters*sizeof(float) );
-    AssignNoAlignment( fClusterPackedXYZOffset, size, nTrackClusters*sizeof(AliHLTTPCCACompressedCluster) );
-  }
-  
-  char *mem = fMemory + size;
-
-  if ((size_t) (mem - fMemory) + sizeof(AliHLTTPCCASliceOutput) > fMemorySize)
-  {
-    fMemorySize = NULL;
-    //printf("\nINTERNAL ERROR IN AliHLTTPCCASliceOutput MEMORY MANAGEMENT req: %d avail: %d\n", (int) ((size_t) (mem - fMemory) + sizeof(AliHLTTPCCASliceOutput)), (int) fMemorySize);
-  }
-}
 
 void AliHLTTPCCASliceOutput::Allocate(AliHLTTPCCASliceOutput* &ptrOutput, int nTracks, int nTrackHits, outputControlStruct* outputControl)
 {
@@ -70,22 +45,21 @@ void AliHLTTPCCASliceOutput::Allocate(AliHLTTPCCASliceOutput* &ptrOutput, int nT
 
   if (outputControl->fOutputPtr)
   {
-         if (outputControl->fOutputMaxSize < memsize)
-         {
-                  outputControl->fEndOfSpace = 1;
-                 ptrOutput = NULL;
-                 return;
-         }
-       ptrOutput = (AliHLTTPCCASliceOutput*) outputControl->fOutputPtr;
-       outputControl->fOutputPtr += memsize;
-       outputControl->fOutputMaxSize -= memsize;
+    if (outputControl->fOutputMaxSize < memsize)
+      {
+       outputControl->fEndOfSpace = 1;
+       ptrOutput = NULL;
+       return;
+      }
+    ptrOutput = (AliHLTTPCCASliceOutput*) outputControl->fOutputPtr;
+    outputControl->fOutputPtr += memsize;
+    outputControl->fOutputMaxSize -= memsize;
   }
   else
-  {
-    if (ptrOutput) free(ptrOutput);
-       ptrOutput = (AliHLTTPCCASliceOutput*) malloc(memsize);
-  }
+    {
+      if (ptrOutput) free(ptrOutput);
+      ptrOutput = (AliHLTTPCCASliceOutput*) malloc(memsize);
+    }
   ptrOutput->SetMemorySize(memsize);
-  ptrOutput->SetPointers(nTracks, nTrackHits, outputControl); // set pointers
 }
 #endif
index 49cb779..80b0dc9 100644 (file)
@@ -12,8 +12,8 @@
 
 #include "AliHLTTPCCADef.h"
 #include <cstdlib>
-#include "AliHLTTPCCASliceTrack.h"
-#include "AliHLTTPCCACompressedInputData.h"
+#include "AliHLTTPCCASliceOutTrack.h"
+
 
 /**
  * @class AliHLTTPCCASliceOutput
@@ -39,32 +39,21 @@ class AliHLTTPCCASliceOutput
   };
 
   GPUhd() int NTracks()                    const { return fNTracks;              }
-  GPUhd() int NTrackClusters()             const { return fNTrackClusters;       }
-  
-  GPUhd() const AliHLTTPCCASliceTrack &Track( int i ) const { return TracksP()[i]; }
-  GPUhd() unsigned char   ClusterRow     ( int i )  const { return ClusterRowP()[i]; }
-  GPUhd()  int   ClusterId     ( int i )  const { return ClusterIdP()[i]; }
-  GPUhd() const AliHLTTPCCACompressedCluster &ClusterPackedXYZ ( int i )  const { return ClusterPackedXYZP()[i]; }
+  GPUhd() int NTrackClusters()             const { return fNTrackClusters;       }  
+  GPUhd() const AliHLTTPCCASliceOutTrack *GetFirstTrack() const { return fMemory; }
+  GPUhd() AliHLTTPCCASliceOutTrack *FirstTrack(){ return fMemory; }
+  GPUhd() size_t Size() const { return(fMemorySize); }
 
   GPUhd() static int EstimateSize( int nOfTracks, int nOfTrackClusters );
-  void SetPointers(int nTracks = -1, int nTrackClusters = -1, const outputControlStruct* outputControl = NULL);
   static void Allocate(AliHLTTPCCASliceOutput* &ptrOutput, int nTracks, int nTrackHits, outputControlStruct* outputControl);
 
   GPUhd() void SetNTracks       ( int v )  { fNTracks = v;        }
   GPUhd() void SetNTrackClusters( int v )  { fNTrackClusters = v; }
-  
-  GPUhd() void SetTrack( int i, const AliHLTTPCCASliceTrack &v ) {  TracksP()[i] = v; }
-  GPUhd() void SetClusterRow( int i, unsigned char v ) {  ClusterRowP()[i] = v; }
-  GPUhd() void SetClusterId( int i, int v ) {  ClusterIdP()[i] = v; }
-  GPUhd() void SetClusterPackedXYZ( int i, AliHLTTPCCACompressedCluster v ) {  ClusterPackedXYZP()[i] = v; }
-
-  GPUhd() size_t OutputMemorySize() const { return(fMemorySize); }
-
 
   private:
+
   AliHLTTPCCASliceOutput()
-    : fNTracks( 0 ), fNTrackClusters( 0 ), fTracksOffset( 0 ),  fClusterIdOffset( 0 ), fClusterRowOffset( 0 ), fClusterPackedXYZOffset( 0 ),
-      fMemorySize( 0 ){}
+    : fNTracks( 0 ), fNTrackClusters( 0 ), fMemorySize( 0 ){}
   
   ~AliHLTTPCCASliceOutput() {}
   const AliHLTTPCCASliceOutput& operator=( const AliHLTTPCCASliceOutput& ) const { return *this; }
@@ -72,23 +61,15 @@ class AliHLTTPCCASliceOutput
 
   GPUh() void SetMemorySize(size_t val) { fMemorySize = val; }
 
-  GPUh() AliHLTTPCCASliceTrack *TracksP() const { return (AliHLTTPCCASliceTrack*)(fMemory+fTracksOffset); }
-  GPUh() int *ClusterIdP() const { return (int*)(fMemory+fClusterIdOffset); }
-  GPUh() UChar_t *ClusterRowP() const { return (UChar_t *)(fMemory+fClusterRowOffset); }
-  GPUh() AliHLTTPCCACompressedCluster *ClusterPackedXYZP() const { return (AliHLTTPCCACompressedCluster *)(fMemory+fClusterPackedXYZOffset); }
-
   int fNTracks;                   // number of reconstructed tracks
   int fNTrackClusters;            // total number of track clusters
-  int fTracksOffset; // pointer to reconstructed tracks
-  int fClusterIdOffset;              // pointer to cluster Id's ( packed slice, patch, cluster )
-  int fClusterRowOffset;     // pointer to cluster row numbers
-  int fClusterPackedXYZOffset;    // pointer to cluster coordinates 
-  size_t fMemorySize;                          // Amount of memory really used
+  size_t fMemorySize;          // Amount of memory really used
 
   //Must be last element of this class, user has to make sure to allocate anough memory consecutive to class memory!
   //This way the whole Slice Output is one consecutive Memory Segment
-    char fMemory[1]; // the memory where the pointers above point into
+
+  AliHLTTPCCASliceOutTrack fMemory[0]; // the memory where the pointers above point into
 
 };
 
-#endif //ALIHLTTPCCASLICEOUTPUT_H
+#endif 
index f8fed37..78ec953 100644 (file)
@@ -32,7 +32,7 @@
 #include "AliHLTTPCCATrackletConstructor.h"
 #include "AliHLTTPCCATrackletSelector.h"
 #include "AliHLTTPCCAProcess.h"
-#include "AliHLTTPCCASliceTrack.h"
+#include "AliHLTTPCCASliceOutTrack.h"
 #include "AliHLTTPCCASliceOutput.h"
 #include "AliHLTTPCCAClusterData.h"
 #include "AliHLTTPCCADataCompressor.h"
@@ -643,17 +643,16 @@ GPUh() void AliHLTTPCCATracker::WriteOutput()
   useOutput->SetNTrackClusters( fCommonMem->fNTrackHits );
 
   int nStoredHits = 0;
+  
+  AliHLTTPCCASliceOutTrack *out = useOutput->FirstTrack();
 
   for ( int iTr = 0; iTr < fCommonMem->fNTracks; iTr++ ) {
-    AliHLTTPCCATrack &iTrack = fTracks[iTr];
-    AliHLTTPCCASliceTrack out;
-    out.SetFirstClusterRef( nStoredHits );
-    out.SetNClusters( iTrack.NHits() );
-    out.SetParam( iTrack.Param() );
-   
-    useOutput->SetTrack( iTr, out );
-   
+    AliHLTTPCCATrack &iTrack = fTracks[iTr];    
+
+    out->SetParam( iTrack.Param() );
+    int nClu = 0;
     int iID = iTrack.FirstHitID();
+
     for ( int ith = 0; ith < iTrack.NHits(); ith++ ) {
       const AliHLTTPCCAHitId &ic = fTrackHits[iID + ith];
       int iRow = ic.RowIndex();
@@ -661,18 +660,6 @@ GPUh() void AliHLTTPCCATracker::WriteOutput()
       
       const AliHLTTPCCARow &row = fData.Row( iRow );
       
-      //float y0 = row.Grid().YMin();
-      //float z0 = row.Grid().ZMin();
-      //float stepY = row.HstepY();
-      //float stepZ = row.HstepZ();
-      //float x = row.X();
-      
-      //const uint4 *tmpint4 = RowData() + row.FullOffset();
-      //const ushort2 *hits = reinterpret_cast<const ushort2*>(tmpint4);
-      //ushort2 hh = hits[ih];
-      //float y = y0 + hh.x*stepY;
-      //float z = z0 + hh.y*stepZ;
-      
       int clusterIndex = fData.ClusterDataIndex( row, ih );
       int clusterRowIndex = clusterIndex - fClusterData->RowOffset( iRow );
       
@@ -691,21 +678,17 @@ GPUh() void AliHLTTPCCATracker::WriteOutput()
       
       float origX = fClusterData->X( clusterIndex );
       float origY = fClusterData->Y( clusterIndex );
-      float origZ = fClusterData->Z( clusterIndex );
-      
+      float origZ = fClusterData->Z( clusterIndex );      
       int id = fClusterData->Id( clusterIndex );
-      AliHLTTPCCACompressedCluster cXYZ = AliHLTTPCCADataCompressor::PackXYZ( iRow, origX, origY, origZ );
-      
-      //float2 hUnpackedYZ;
-      //hUnpackedYZ.x = origY;
-      //hUnpackedYZ.y = origZ;
-      //float hUnpackedX = origX;
-      
-      useOutput->SetClusterId( nStoredHits, id  );
-      useOutput->SetClusterRow( nStoredHits, ( unsigned char ) iRow  );
-      useOutput->SetClusterPackedXYZ( nStoredHits, cXYZ );
+      AliHLTTPCCASliceOutCluster c;
+      c.Set( id, iRow, origX, origY, origZ );
+      out->SetCluster( nClu, c );
+      nClu++;
       nStoredHits++;
     }
+
+    out->SetNClusters( nClu );
+    out = out->NextTrack();    
   }
 
   timer.Stop();
index 488f016..46dabc3 100644 (file)
@@ -443,7 +443,6 @@ int AliHLTTPCCATrackerComponent::DoEvent
       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 );
-      unsigned maxCntSlice = 0;
       slCntIter = sliceCnts.begin();
       for ( slIter = slices.begin(); slIter != slices.end(); slIter++, slCntIter++ ) {
         Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
@@ -696,7 +695,7 @@ int AliHLTTPCCATrackerComponent::DoEvent
        Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reconstruct",
                 "%d tracks found for slice %d", sliceOutput[islice]->NTracks(), slice );
        
-       mySize += sliceOutput[islice]->OutputMemorySize();
+       mySize += sliceOutput[islice]->Size();
        ntracks += sliceOutput[islice]->NTracks();        
       }
     else
@@ -716,7 +715,7 @@ int AliHLTTPCCATrackerComponent::DoEvent
     for (int islice = 0;islice < slicecount;islice++)
       {
        slice = minslice + islice;
-       mySize = sliceOutput[islice]->OutputMemorySize();
+       mySize = sliceOutput[islice]->Size();
        if (mySize > 0)
          {
            AliHLTComponentBlockData bd;