development version of the TPC track model data compression, further development...
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 8 Jun 2011 11:51:41 +0000 (11:51 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 8 Jun 2011 11:51:41 +0000 (11:51 +0000)
HLT/TPCLib/comp/AliHLTTPCCompModelAnalysis.cxx
HLT/TPCLib/comp/AliHLTTPCCompModelConverter.cxx
HLT/TPCLib/comp/AliHLTTPCCompModelConverter.h
HLT/TPCLib/comp/AliHLTTPCCompModelConverterComponent.cxx
HLT/TPCLib/comp/AliHLTTPCCompModelConverterComponent.h
HLT/TPCLib/comp/AliHLTTPCCompModelDeflaterComponent.cxx

index 1fdbefb..429e35a 100644 (file)
@@ -515,7 +515,7 @@ Int_t AliHLTTPCCompModelAnalysis::CompareClusters(Bool_t relativedifferences)
                {
                  // if fTrackN != -1 -> draw histograms out of used clusters
                  // if fTrackN == -1 -> draw histograms out of unused clusters
-                 if (fSecondaryClusters[slicecntr][patchcntr]->fSpacePoints[jj].fTrackN == -1)
+                 if (fSecondaryClusters[slicecntr][patchcntr]->fSpacePoints[jj].GetTrackNumber() == -1)
                    {
                      if((fOriginalClusters[slicecntr][patchcntr]->fSpacePoints[ii].fCharge == fSecondaryClusters[slicecntr][patchcntr]->fSpacePoints[jj].fCharge) && (fOriginalClusters[slicecntr][patchcntr]->fSpacePoints[ii].fPadRow == fSecondaryClusters[slicecntr][patchcntr]->fSpacePoints[jj].fPadRow) )
                        {
@@ -609,7 +609,7 @@ Int_t AliHLTTPCCompModelAnalysis::CompareClusters(Bool_t relativedifferences)
 
              ++totalsecondary;
 
-             if(fSecondaryClusters[slicecount][patchcount]->fSpacePoints[count].fTrackN != -1)
+             if(fSecondaryClusters[slicecount][patchcount]->fSpacePoints[count].GetTrackNumber() != -1)
                {
                  ++usedclusters;
                };
index ca61681..298e022 100644 (file)
@@ -31,13 +31,15 @@ using namespace std;
 #include "AliHLTTPCTrack.h"
 #include "AliHLTTPCModelTrack.h"
 #include "AliHLTTPCCompDataCompressorHelper.h"
+#include "AliHLTTPCSpacePointContainer.h"
 #include <cerrno>
 
-AliHLTTPCCompModelConverter::AliHLTTPCCompModelConverter():
-  fInputTrackArray(),
-  fOutputTrackArray("AliHLTTPCModelTrack"),
-  fModelAnalysisInstance(NULL),
-  fMinHits(0)
+AliHLTTPCCompModelConverter::AliHLTTPCCompModelConverter()
+  : AliHLTLogging()
+  , fInputTrackArray()
+  , fOutputTrackArray("AliHLTTPCModelTrack")
+  , fModelAnalysisInstance(NULL)
+  , fMinHits(0)
     {
       // see header file for class documentation
       for ( UInt_t slice=0; slice<36; slice++ )
@@ -50,11 +52,12 @@ AliHLTTPCCompModelConverter::AliHLTTPCCompModelConverter():
       fMinHits = 5;
     }
 
-AliHLTTPCCompModelConverter::AliHLTTPCCompModelConverter(AliHLTTPCCompModelAnalysis* modelanalysis):
-  fInputTrackArray(),
-  fOutputTrackArray("AliHLTTPCModelTrack"),
-  fModelAnalysisInstance(modelanalysis),
-  fMinHits(0)
+AliHLTTPCCompModelConverter::AliHLTTPCCompModelConverter(AliHLTTPCCompModelAnalysis* modelanalysis)
+  : AliHLTLogging()
+  , fInputTrackArray()
+  , fOutputTrackArray("AliHLTTPCModelTrack")
+  , fModelAnalysisInstance(modelanalysis)
+  , fMinHits(0)
     {
       // see header file for class documentation
       for ( UInt_t slice=0; slice<36; slice++ )
@@ -79,12 +82,13 @@ AliHLTTPCCompModelConverter::~AliHLTTPCCompModelConverter()
                fClusterUsed[slice][patch] = NULL;
              }
          }
+
     }
 
 int AliHLTTPCCompModelConverter::Init()
     {
       // see header file for class documentation
-      fInputTrackArray.Reset();
+      fInputTrackArray.clear();
       fOutputTrackArray.Reset();
       for ( UInt_t slice=0; slice<36; slice++ )
        for ( UInt_t patch=0; patch<6; patch++ )
@@ -93,21 +97,20 @@ int AliHLTTPCCompModelConverter::Init()
       return 0;
     }
 
-int AliHLTTPCCompModelConverter::SetInputTracks( AliHLTTPCTrackletData* tracklets )
+int AliHLTTPCCompModelConverter::SetInputTracks( const AliHLTTracksData* pTracks, unsigned sizeInByte )
     {
       // see header file for class documentation
-      HLTDebug( "Filling %u tracks", (unsigned)tracklets->fTrackletCnt );
-      fInputTrackArray.FillTracks( tracklets->fTrackletCnt, tracklets->fTracklets );
-      return 0;
+      HLTDebug( "Filling %u tracks", (unsigned)pTracks->fCount );
+      return AliHLTGlobalBarrelTrack::ConvertTrackDataArray(pTracks, sizeInByte, fInputTrackArray);
     }
 
 int AliHLTTPCCompModelConverter::SetInputClusters( AliHLTTPCClusterData* clusters, UInt_t slice, UInt_t patch )
     {
-      // see header file for class documentation
+      // set input clusters for a partition
       if ( slice>=36 || patch>=6 )
-       return EINVAL;
+       return -EINVAL;
       if ( fClusters[slice][patch] )
-       return EBUSY;
+       return -EBUSY;
       fClusters[slice][patch] = clusters;
       if ( fClusterUsedSizes[slice][patch]<clusters->fSpacePointCnt ||
           fClusterUsedSizes[slice][patch]>clusters->fSpacePointCnt*8 )
@@ -120,62 +123,68 @@ int AliHLTTPCCompModelConverter::SetInputClusters( AliHLTTPCClusterData* cluster
          fClusterUsed[slice][patch] = new bool[clusters->fSpacePointCnt];
          if ( !fClusterUsed[slice][patch] )
            {
-             HLTDebug( "Out of memory trying to allocate usage data for  %u clusters", (unsigned)clusters->fSpacePointCnt );
-             return ENOMEM;
+             return -ENOMEM;
            }
        }
       for ( unsigned long nn=0; nn<clusters->fSpacePointCnt; nn++ )
        fClusterUsed[slice][patch][nn]=false;
-      HLTDebug( "Filling %u clusters", (unsigned)clusters->fSpacePointCnt );
+
       return 0;
     }
 
 void AliHLTTPCCompModelConverter::Convert()
     {
-      // see header file for class documentation
-      fInputTrackArray.QSort();
-      for(Int_t i=0; i<fInputTrackArray.GetNTracks(); i++)
+      // convert tracks to the track model
+
+      // FIXME: the tracks have supposedly been sorted according to momentum to
+      // process the high momentum tracks first, QSort however builds upon
+      // AliTPCtrack::Compare, it's implementation has been changed
+      //fInputTrackArray.QSort();
+
+      for(unsigned i=0; i<fInputTrackArray.size(); i++)
        {
-         AliHLTTPCTrack *intrack = fInputTrackArray.GetCheckedTrack(i);
-         
-         // NO WARNING IF intrack = NULL!
+         AliHLTGlobalBarrelTrack *intrack = &(fInputTrackArray[i]);
          if(!intrack) continue;
          
-         if((unsigned)intrack->GetNHits()<fMinHits) 
+         if(intrack->GetNumberOfPoints()<fMinHits) 
            {
              HLTDebug("Track %d with %d clusters is below minimum of %d clusters",i,intrack->GetNHits(),fMinHits);
-             break;
+             continue;
            };
          
          // LOSS OF TRACKS due to following statement possible!
-         if(intrack->GetPt()<0.1)
+         // FIXME: make this configurable
+         if(intrack->Pt()<0.1)
            {
              HLTDebug("Discarding track with low pt.");
              if(fModelAnalysisInstance)
                {
                  if(fModelAnalysisInstance->GetfModelAnalysis()) // analysis of model
                    {
-                     fModelAnalysisInstance->MarkTrashTrack(intrack);
+                     HLTError("FIXME: correct parameter");
+                     //fModelAnalysisInstance->MarkTrashTrack(intrack);
                    }
                }
              
              continue;
            }
          
-         intrack->CalculateHelix();
+         // check if this is necessary
+         //intrack->CalculateHelix();
          
          AliHLTTPCModelTrack *outtrack = (AliHLTTPCModelTrack*)fOutputTrackArray.NextTrack();
-         outtrack->SetNHits(intrack->GetNHits());
-         outtrack->SetRowRange(intrack->GetFirstRow(),intrack->GetLastRow());
-         outtrack->SetFirstPoint(intrack->GetFirstPointX(),intrack->GetFirstPointY(),intrack->GetFirstPointZ());
-         outtrack->SetLastPoint(intrack->GetLastPointX(),intrack->GetLastPointY(),intrack->GetLastPointZ());
-         outtrack->SetPt(intrack->GetPt());
-         outtrack->SetPsi(intrack->GetPsi());
+         outtrack->SetNHits(intrack->GetNumberOfPoints());
+         //outtrack->SetRowRange(intrack->GetFirstRow(),intrack->GetLastRow());
+         //outtrack->SetFirstPoint(intrack->GetFirstPointX(),intrack->GetFirstPointY(),intrack->GetFirstPointZ());
+         //outtrack->SetLastPoint(intrack->GetLastPointX(),intrack->GetLastPointY(),intrack->GetLastPointZ());
+         outtrack->SetPt(intrack->Pt());
+         outtrack->SetPsi(intrack->GetSnp());
          outtrack->SetTgl(intrack->GetTgl());
-         outtrack->SetCharge(intrack->GetCharge());
+         // FIXME: charge is not propagated with AliHLTExternalTrackParam, check if it is needed
+         //outtrack->SetCharge(intrack->GetCharge());
          outtrack->CalculateHelix();
-         Int_t nhits = intrack->GetNHits();
-         UInt_t *hitids = intrack->GetHitNumbers();
+         Int_t nhits = intrack->GetNumberOfPoints();
+         const UInt_t *hitids = intrack->GetPoints();
          Int_t origslice = AliHLTTPCSpacePointData::GetSlice(hitids[nhits-1]);
          outtrack->Init(origslice,-1);
          
@@ -208,19 +217,21 @@ void AliHLTTPCCompModelConverter::Convert()
            bool* clustersUsed = fClusterUsed[slice][patch];
            Float_t xyz[3] = {points[pos].fX,points[pos].fY,points[pos].fZ};
            Int_t padrow = points[pos].fPadRow;
+           //HLTInfo("track %d cluster %d: slice %d part %d nr %d:\n\t x=%f y=%f z=%f padrow=%d", i, j, slice, patch, pos, xyz[0], xyz[1], xyz[2], padrow);
            
            //Calculate the crossing point between track and padrow
            Float_t angle = 0; //Perpendicular to padrow in local coordinates
            AliHLTTPCTransform::Local2GlobalAngle(&angle,slice);
-           if(!intrack->CalculateReferencePoint(angle,AliHLTTPCTransform::Row2X(padrow)))
-             {
-               HLTError( "AliHLTDataCompressor::FillData : Error in crossing point calc on slice %d, padrow %d", slice, padrow );
-               break;
-               //outtrack->Print(kFALSE);
-               //exit(5);
-             }
+           // FIXME: CalculateReferencePoint not available
+           // if(!intrack->CalculateReferencePoint(angle,AliHLTTPCTransform::Row2X(padrow)))
+           //   {
+           //  HLTError( "AliHLTDataCompressor::FillData : Error in crossing point calc on slice %d, padrow %d", slice, padrow );
+           //  break;
+           //  //outtrack->Print(kFALSE);
+           //  //exit(5);
+           //   }
            
-           Float_t xyzCross[3] = {intrack->GetPointX(),intrack->GetPointY(),intrack->GetPointZ()};
+           Float_t xyzCross[3] = {intrack->GetX(),intrack->GetY(),intrack->GetZ()};
            
            Int_t sector,row;
            AliHLTTPCTransform::Slice2Sector(slice,padrow,sector,row);
@@ -233,8 +244,10 @@ void AliHLTTPCCompModelConverter::Convert()
            
            outtrack->SetPadHit(padrow,xyzCross[1]);
            outtrack->SetTimeHit(padrow,xyzCross[2]);
+           //HLTInfo("track %d cluster %d: xyzCross={%f,%f,%f}", i, j, xyzCross[0], xyzCross[1], xyzCross[2]);
+           //HLTInfo("track %d cluster %d:      xyz={%f,%f,%f}", i, j, xyz[0], xyz[1], xyz[2]);
 
-           outtrack->SetCrossingAngleLUT(padrow,intrack->GetCrossingAngle(padrow,slice));
+           //outtrack->SetCrossingAngleLUT(padrow,intrack->GetCrossingAngle(padrow,slice));
            outtrack->CalculateClusterWidths(padrow,kTRUE); // calculates parSigmas (with parametrisation) in raw coordinates
            //HLTInfo("angle %f", outtrack->GetCrossingAngleLUT(padrow));
            //HLTInfo("parsigma %f",outtrack->GetParSigmaY2(padrow));
@@ -432,7 +445,7 @@ void AliHLTTPCCompModelConverter::ExpandTrackData()
   
     }
 
-unsigned long AliHLTTPCCompModelConverter::GetOutputModelDataSize()
+unsigned long AliHLTTPCCompModelConverter::GetOutputModelDataSize() const
     {
       // see header file for class documentation
       unsigned long dataSize=0;
@@ -451,7 +464,7 @@ unsigned long AliHLTTPCCompModelConverter::GetOutputModelDataSize()
       return dataSize;
     }
 
-int AliHLTTPCCompModelConverter::OutputModelData( AliHLTUInt8_t* data )
+int AliHLTTPCCompModelConverter::OutputModelData( AliHLTUInt8_t* data, unsigned long& /*dataSize*/ ) const
     {
       // see header file for class documentation 
       unsigned long dataOffset=0;
@@ -560,7 +573,7 @@ void AliHLTTPCCompModelConverter::SelectRemainingClusters()
       
     }
 
-unsigned long AliHLTTPCCompModelConverter::GetRemainingClustersOutputDataSize()
+unsigned long AliHLTTPCCompModelConverter::GetRemainingClustersOutputDataSize() const
     {
       // see header file for class documentation
       int iResult=0;
@@ -683,7 +696,7 @@ unsigned long AliHLTTPCCompModelConverter::GetRemainingClustersOutputDataSize()
 #endif
     }
 
-int AliHLTTPCCompModelConverter::GetRemainingClusters( AliHLTUInt8_t* const pTgt, unsigned long& dataSize )
+int AliHLTTPCCompModelConverter::GetRemainingClusters( AliHLTUInt8_t* const pTgt, unsigned long& dataSize ) const
     { 
       // see header file for class documentation
       int iResult=0;
index 1979644..6e06588 100644 (file)
 #include "AliHLTTPCClusterDataFormat.h"
 #include "AliHLTTPCCompModelAnalysis.h"
 #include "AliHLTLogging.h"
+#include "AliHLTGlobalBarrelTrack.h"
+#include <vector>
+
+class AliHLTSpacePointContainer;
 
 /**
  * @class AliHLTTPCCompModelConverter
- * @brief A dummy HLT processing component. 
+ * @brief
  *
- * An implementiation of a copy component that just copies its input data
- * to debug a components input data
- * @ingroup alihlt_tpc
  */
 class AliHLTTPCCompModelConverter: public AliHLTLogging
     {
@@ -44,10 +45,11 @@ class AliHLTTPCCompModelConverter: public AliHLTLogging
       int Init();
       
       /** function to set input tracks
-       * @param tracklets pointer to AliHLTTPCTrackletData
+       * @param tracklets pointer to AliHLTTracksData
+       * @param size of the buffer in byte
        * @return zero upon success
        */
-      int SetInputTracks( AliHLTTPCTrackletData* tracklets );
+      int SetInputTracks( const AliHLTTracksData* pTracks, unsigned sizeInByte );
 
       /** function to set input tracks
        * @param clusters pointer to AliHLTTPCClusterData
@@ -63,13 +65,14 @@ class AliHLTTPCCompModelConverter: public AliHLTLogging
       /** function to get output model data size
        * @return unsigned long value of output model data size
        */
-      unsigned long GetOutputModelDataSize();
+      unsigned long GetOutputModelDataSize() const;
       
       /** function to output model data
-       * @param data AliHLTUInt8_t* pointer to ouptut data
+       * @param data       pointer to target buffer
+       * @param dataSize   [in] size of buffer, [out] size of data
        * @return zero upon success
        */
-      int OutputModelData( AliHLTUInt8_t* data );
+      int OutputModelData( AliHLTUInt8_t* data, unsigned long& dataSize ) const;
       
       /** function to select remaining clusters */
       void SelectRemainingClusters();
@@ -77,13 +80,13 @@ class AliHLTTPCCompModelConverter: public AliHLTLogging
       /** function to get remaining clusters output data size
        * @return unsigned long value = size
        */
-      unsigned long GetRemainingClustersOutputDataSize();
+      unsigned long GetRemainingClustersOutputDataSize() const;
 
       /** function to get remaining clusters
-       * @param data     AliHLTUInt8_t* const
-       * @param dataSize unsigned long& 
+       * @param data       pointer to target buffer
+       * @param dataSize   [in] size of buffer, [out] size of data
        */
-      int GetRemainingClusters( AliHLTUInt8_t* const data, unsigned long& dataSize );
+      int GetRemainingClusters( AliHLTUInt8_t* const data, unsigned long& dataSize ) const;
       
       /** function to define minimal hits for one track
        * @param minHits unsigned
@@ -99,7 +102,7 @@ class AliHLTTPCCompModelConverter: public AliHLTLogging
       void ExpandTrackData();
 
       /** member variable input track array */
-      AliHLTTPCTrackArray fInputTrackArray;
+      vector<AliHLTGlobalBarrelTrack> fInputTrackArray;
       /** member variable output track array */
       AliHLTTPCTrackArray fOutputTrackArray;
       
@@ -122,7 +125,7 @@ class AliHLTTPCCompModelConverter: public AliHLTLogging
       /** assignment operator prohibited */
       AliHLTTPCCompModelConverter& operator=(const AliHLTTPCCompModelConverter&);
      
-      ClassDef(AliHLTTPCCompModelConverter, 1)
+      ClassDef(AliHLTTPCCompModelConverter, 0)
 
     };
 #endif
index 01d61be..c31ef01 100644 (file)
@@ -27,9 +27,14 @@ using namespace std;
 #endif
 
 #include "AliHLTTPCCompModelConverterComponent.h"
+#include "AliHLTGlobalBarrelTrack.h"
+#include "AliHLTTPCSpacePointContainer.h"
 #include "AliHLTTPCDefinitions.h"
+#include "AliHLTComponentBenchmark.h"
 //#include "AliHLTTPCCompModelAnalysis.h"
 #include <errno.h>
+#include <vector>
+
 /** An implementiation of a converter component that
  * takes in clusters and tracks in the standard HLT format
  * and converts them into the Vestbo-format
@@ -40,57 +45,58 @@ using namespace std;
 /** ROOT macro for the implementation of ROOT specific class methods */
 ClassImp(AliHLTTPCCompModelConverterComponent)
     
-  AliHLTTPCCompModelConverterComponent::AliHLTTPCCompModelConverterComponent() :
-    fConverter(NULL),
-    fModelAnalysisInstance(NULL),
-    fDumpFileName(),
-    fGraphFileName(),
-    fModelAnalysis(0),
-    fTrackAnalysis(0),
-    fFillingFirstTrackArray(0)
-    {
-      // see header file for class documentation
-    }
+AliHLTTPCCompModelConverterComponent::AliHLTTPCCompModelConverterComponent()
+  : AliHLTProcessor()
+  , fConverter(NULL)
+  , fModelAnalysisInstance(NULL)
+  , fDumpFileName()
+  , fGraphFileName()
+  , fModelAnalysis(0)
+  , fTrackAnalysis(0)
+  , fFillingFirstTrackArray(0)
+  , fInputClusters(NULL)
+  , fpBenchmark(NULL)
+{
+  // constructor
+}
 
 AliHLTTPCCompModelConverterComponent::~AliHLTTPCCompModelConverterComponent()
-    {
-      // see header file for class documentation
-    }
+{
+  // destructor
+}
 
 const char* AliHLTTPCCompModelConverterComponent::GetComponentID()
-    {
-      // see header file for class documentation
-      return "TPCCompModelConverter"; // The ID of this component
-    }
+{
+  // AliHLTComponent interface function: return component id
+  return "TPCCompModelConverter";
+}
 
 void AliHLTTPCCompModelConverterComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
-    {
-      // see header file for class documentation
-      list.clear(); // We do not have any requirements for our input data type(s).
-      list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
-      list.push_back( AliHLTTPCDefinitions::fgkTracksDataType );
-    }
+{
+  // AliHLTComponent interface function: get list of input data types
+  list.clear(); // We do not have any requirements for our input data type(s).
+  list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
+  list.push_back( kAliHLTDataTypeTrack|kAliHLTDataOriginTPC );
+}
 
 AliHLTComponent_DataType AliHLTTPCCompModelConverterComponent::GetOutputDataType()
-    {
-      // see header file for class documentation
-      return AliHLTTPCDefinitions::fgkClusterTracksModelDataType;
-    }
+{
+  // AliHLTComponent interface function: get output data type
+  return AliHLTTPCDefinitions::fgkClusterTracksModelDataType;
+}
 
 void AliHLTTPCCompModelConverterComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
-    {
-      // see header file for class documentation
-      constBase = 4+4+216; // Format versions + 1 byte per patch
-      inputMultiplier = 4.;
-      //#warning Adapt input Multiplier to something more realistic
-    }
+{
+  // AliHLTComponent interface function: output data size estimator
+  constBase = 4+4+216; // Format versions + 1 byte per patch
+  inputMultiplier = 4.;
+}
 
-// Spawn function, return new instance of this class
 AliHLTComponent* AliHLTTPCCompModelConverterComponent::Spawn()
-    {
-      // see header file for class documentation
-      return new AliHLTTPCCompModelConverterComponent;
-    };
+{
+  // AliHLTComponent interface function: return new instance of this class
+  return new AliHLTTPCCompModelConverterComponent;
+}
 
 int AliHLTTPCCompModelConverterComponent::DoInit( int argc, const char** argv )
 {
@@ -199,6 +205,13 @@ int AliHLTTPCCompModelConverterComponent::DoInit( int argc, const char** argv )
     return EINVAL;
     }*/
   
+  fpBenchmark=new AliHLTComponentBenchmark;
+  if (GetBenchmarkInstance()) {
+    GetBenchmarkInstance()->SetTimer(0,"total");
+    GetBenchmarkInstance()->SetTimer(1,"clusterinput");
+    GetBenchmarkInstance()->SetTimer(2,"trackinput");
+  }
+
   return 0;
 }
 
@@ -228,10 +241,104 @@ int AliHLTTPCCompModelConverterComponent::DoEvent( const AliHLTComponent_EventDa
                                      AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
     {
       // see header file for class documentation
+      int iResult=0;
+      AliHLTUInt32_t capacity=size;
+      size=0;
+      if (!IsDataEvent()) return 0;
+
+      if (GetBenchmarkInstance()) {
+       GetBenchmarkInstance()->StartNewEvent();
+       GetBenchmarkInstance()->Start(0);
+      }
+
       fConverter->Init();
       // Process an event
       // Loop over all input blocks in the event
       AliHLTUInt8_t minSlice=0xFF, maxSlice=0xFF, minPatch=0xFF, maxPatch=0xFF;
+      const AliHLTComponentBlockData* pDesc=NULL;
+
+      /// input track array
+      vector<AliHLTGlobalBarrelTrack> inputTrackArray;
+
+      if (GetBenchmarkInstance()) {
+       GetBenchmarkInstance()->Start(1);
+      }
+      for (pDesc=GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType);
+          pDesc!=NULL; pDesc=GetNextInputBlock()) {
+       if (GetBenchmarkInstance()) {
+         GetBenchmarkInstance()->AddInput(pDesc->fSize);
+       }
+       AliHLTUInt8_t slice = 0;
+       AliHLTUInt8_t patch = 0;
+       slice = AliHLTTPCDefinitions::GetMinSliceNr( pDesc->fSpecification );
+       patch = AliHLTTPCDefinitions::GetMinPatchNr( pDesc->fSpecification );
+       if ( minSlice==0xFF || slice<minSlice ) minSlice = slice;
+       if ( maxSlice==0xFF || slice>maxSlice ) maxSlice = slice;
+       if ( minPatch==0xFF || patch<minPatch ) minPatch = patch;
+       if ( maxPatch==0xFF || patch>maxPatch ) maxPatch = patch;
+       if (!fInputClusters) {
+         fInputClusters=new AliHLTTPCSpacePointContainer;        
+         if (!fInputClusters) return -ENOMEM;
+       }
+       if (fInputClusters) {
+         fInputClusters->AddInputBlock(pDesc);
+       }
+      }
+      if (GetBenchmarkInstance()) {
+       GetBenchmarkInstance()->Stop(1);
+       GetBenchmarkInstance()->Start(2);
+      }
+
+      for (pDesc=GetFirstInputBlock(kAliHLTDataTypeTrack|kAliHLTDataOriginTPC);
+          pDesc!=NULL; pDesc=GetNextInputBlock()) {
+       if (GetBenchmarkInstance()) {
+         GetBenchmarkInstance()->AddInput(pDesc->fSize);
+       }
+       AliHLTUInt8_t slice = 0;
+       AliHLTUInt8_t patch = 0;
+       slice = AliHLTTPCDefinitions::GetMinSliceNr( pDesc->fSpecification );
+       patch = AliHLTTPCDefinitions::GetMinPatchNr( pDesc->fSpecification );
+       if ( minSlice==0xFF || slice<minSlice ) minSlice = slice;
+       if ( maxSlice==0xFF || slice>maxSlice ) maxSlice = slice;
+       if ( minPatch==0xFF || patch<minPatch ) minPatch = patch;
+       if ( maxPatch==0xFF || patch>maxPatch ) maxPatch = patch;
+       const AliHLTTracksData* pTracks=reinterpret_cast<const AliHLTTracksData*>(pDesc->fPtr);
+       if ((iResult=AliHLTGlobalBarrelTrack::ConvertTrackDataArray(pTracks, pDesc->fSize, inputTrackArray))<0) {
+         return iResult;
+       }
+       for (vector<AliHLTGlobalBarrelTrack>::const_iterator track=inputTrackArray.begin();
+            track!=inputTrackArray.end();
+            track++) {
+         if (!fInputClusters) continue;
+         int trackID=track->GetID();
+         if (trackID<0) {
+           // FIXME: error guard
+           HLTError("invalid track ID");
+           continue;
+         }
+         if ((iResult=fInputClusters->SetTrackID(trackID, track->GetPoints(), track->GetNumberOfPoints()))<0) {
+           HLTError("failed to set cluster id for track %d: error %d", trackID, iResult);
+           iResult=0;
+           continue;
+         }
+       }
+       // for (vector<AliHLTGlobalBarrelTrack>::const_iterator track=inputTrackArray.begin();
+       //      track!=inputTrackArray.end();
+       //      track++) {
+       //   AliHLTSpacePointContainer* trackClusters=fInputClusters->SelectByTrack(track->GetID());
+       //   if (!trackClusters) {
+       //     HLTError("failed to select clusters assigned to track %d", track->GetID());
+       //     continue;
+       //   }
+       //   track->Print();
+       //   trackClusters->Print();
+       // }
+      }
+
+      if (GetBenchmarkInstance()) {
+       GetBenchmarkInstance()->Stop(2);
+      }
+
       for ( unsigned long n = 0; n < evtData.fBlockCnt; n++ )
        {
          AliHLTUInt8_t slice = 0;
@@ -255,9 +362,9 @@ int AliHLTTPCCompModelConverterComponent::DoEvent( const AliHLTComponent_EventDa
            {
              fConverter->SetInputClusters( (AliHLTTPCClusterData*)blocks[n].fPtr, slice, patch );
            }
-         if ( blocks[n].fDataType == AliHLTTPCDefinitions::fgkTracksDataType )
+         if ( blocks[n].fDataType == kAliHLTDataTypeTrack )
            {
-             fConverter->SetInputTracks( (AliHLTTPCTrackletData*)blocks[n].fPtr );
+             fConverter->SetInputTracks( reinterpret_cast<AliHLTTracksData*>(blocks[n].fPtr), blocks[n].fSize );
              
              // if track analysis is desired, fill tracklets into track arrays of ModelAnalysis class to be compared
              if(fTrackAnalysis)
@@ -278,15 +385,16 @@ int AliHLTTPCCompModelConverterComponent::DoEvent( const AliHLTComponent_EventDa
       
       fConverter->Convert();
       
+      unsigned long dataSize=0;
       unsigned long outputSize = fConverter->GetOutputModelDataSize();
-      if ( outputSize> size )
+      if ( outputSize+dataSize> capacity )
        {
          HLTError( "Not enough output memory size for clusters&tracks model data. %lu needed",
                    outputSize );
-         return ENOBUFS;
+         return -ENOSPC;
        }
-      
-      fConverter->OutputModelData( outputPtr );
+
+      fConverter->OutputModelData( outputPtr, outputSize );
       
       AliHLTComponent_BlockData ob;
       // Let the structure be filled with the default values.
@@ -294,7 +402,7 @@ int AliHLTTPCCompModelConverterComponent::DoEvent( const AliHLTComponent_EventDa
       // so that they can be filled in by the calling code.
       FillBlockData( ob );
       // This block's start (offset) is after all other blocks written so far
-      ob.fOffset = 0;
+      ob.fOffset = dataSize;
       // the size of this block's data.
       ob.fSize = outputSize;
       // The specification of the data is copied from the input block.
@@ -305,23 +413,22 @@ int AliHLTTPCCompModelConverterComponent::DoEvent( const AliHLTComponent_EventDa
       outputBlocks.push_back( ob );
       
       outputPtr += ob.fSize;
+      dataSize += ob.fSize;
       
-      if ( outputSize+fConverter->GetRemainingClustersOutputDataSize()>size )
+      if ( dataSize+fConverter->GetRemainingClustersOutputDataSize()>capacity )
        {
          HLTError( "Not enough output memory size for remaining clusters model data. %lu needed in total (clusters&tracks + rem. clusters)",
-                   outputSize+fConverter->GetRemainingClustersOutputDataSize() );
-         return ENOBUFS;
+                   dataSize+fConverter->GetRemainingClustersOutputDataSize() );
+         return -ENOSPC;
        }
-      unsigned long clusterSize = size-outputSize;
-      printf( "clusterSize0: %lu\n", clusterSize );
-      fConverter->GetRemainingClusters( outputPtr, clusterSize );
-      printf( "clusterSize1: %lu\n", clusterSize );
+      fConverter->GetRemainingClusters( outputPtr, outputSize );
+      printf( "clusterSize1: %lu\n", outputSize );
       
       FillBlockData( ob );
       // This block's start (offset) is after all other blocks written so far
-      ob.fOffset = outputSize;
+      ob.fOffset = dataSize;
       // the size of this block's data.
-      ob.fSize = clusterSize;
+      ob.fSize = outputSize;
       // The specification of the data is copied from the input block.
       ob.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( minSlice, maxSlice, minPatch, maxPatch );
       // The type of the data is copied from the input block.
@@ -329,9 +436,15 @@ int AliHLTTPCCompModelConverterComponent::DoEvent( const AliHLTComponent_EventDa
       // Place this block into the list of output blocks
       outputBlocks.push_back( ob );
       
-      outputSize += ob.fSize;
+      outputPtr += ob.fSize;
+      dataSize += ob.fSize;
+
+      if (GetBenchmarkInstance()) {
+       GetBenchmarkInstance()->Stop(0);
+       HLTBenchmark(GetBenchmarkInstance()->GetStatistics());
+      }
       
       // Finally we set the total size of output memory we consumed.
-      size = outputSize;
+      size = dataSize;
       return 0;
     }
index a6d1c84..6334ef0 100644 (file)
@@ -18,6 +18,9 @@
 #include "AliHLTTPCCompModelConverter.h"
 #include "AliHLTStdIncludes.h"
 
+class AliHLTSpacePointContainer;
+class AliHLTComponentBenchmark;
+
 /**
  * @class AliHLTTPCCompModelConverterComponent
  * @brief A dummy HLT processing component. 
@@ -113,6 +116,8 @@ private:
   /** assignment operator prohibited */
   AliHLTTPCCompModelConverterComponent& operator=(const AliHLTTPCCompModelConverterComponent&);
 
+  AliHLTComponentBenchmark* GetBenchmarkInstance() const {return fpBenchmark;}
+
   /** flags to decide wheter to do track or model loss analysis */
   /** switch on model analysis */
   Bool_t fModelAnalysis;            // switch on model analysis
@@ -120,7 +125,13 @@ private:
   Bool_t fTrackAnalysis;           // switch on track analysis
   /** flag to check if first or second array is filled */
   Bool_t fFillingFirstTrackArray;  // 1 if first array is processed, 0 for second filling process
-  
+
+  /// input cluster handler
+  AliHLTSpacePointContainer* fInputClusters; //! input cluster handler
+
+  /// benchmark
+  AliHLTComponentBenchmark* fpBenchmark; //! benchmark instance
+
   ClassDef(AliHLTTPCCompModelConverterComponent, 0)
     
     };
index 1141c56..9737ae7 100644 (file)
@@ -197,9 +197,9 @@ int AliHLTTPCCompModelDeflaterComponent::DoEvent( const AliHLTComponent_EventDat
            {
            fConverter.SetInputClusters( (AliHLTTPCClusterData*)blocks[n].fPtr, slice, patch );
            }
-         if ( blocks[n].fDataType == AliHLTTPCDefinitions::fgkTracksDataType )
+         if ( blocks[n].fDataType == (kAliHLTDataTypeTrack|kAliHLTDataOriginTPC) )
            {
-             fConverter.SetInputTracks( (AliHLTTPCTrackletData*)blocks[n].fPtr );
+             fConverter.SetInputTracks( (AliHLTTracksData*)blocks[n].fPtr, blocks[n].fSize );
            }
          
        }
@@ -216,7 +216,7 @@ int AliHLTTPCCompModelDeflaterComponent::DoEvent( const AliHLTComponent_EventDat
              return ENOMEM;
            }
          
-         fConverter.OutputModelData( trackModelData );
+         fConverter.OutputModelData( trackModelData, trackSize );
          
          unsigned long clusterSize = fConverter.GetRemainingClustersOutputDataSize();
          AliHLTUInt8_t* remainingClustersModelData = new AliHLTUInt8_t[ clusterSize ];