Line data    Source code

       1             : //-*- Mode: C++ -*-
       2             : // @(#) $Id: AliHLTTPCCATracker.h 33907 2009-07-23 13:52:49Z sgorbuno $
       3             : // ************************************************************************
       4             : // This file is property of and copyright by the ALICE HLT Project        *
       5             : // ALICE Experiment at CERN, All rights reserved.                         *
       6             : // See cxx source for full Copyright notice                               *
       7             : //                                                                        *
       8             : //*************************************************************************
       9             : 
      10             : #ifndef ALIHLTTPCCATRACKERFRAMEWORK_H
      11             : #define ALIHLTTPCCATRACKERFRAMEWORK_H
      12             : 
      13             : #include "AliHLTTPCCATracker.h"
      14             : #include "AliHLTTPCCAGPUTracker.h"
      15             : #include "AliHLTTPCCAParam.h"
      16             : #include "AliHLTTPCCASliceOutput.h"
      17             : #include "AliHLTLogging.h"
      18             : #include <iostream>
      19             : #include <string.h>
      20             : 
      21             : class AliHLTTPCCASliceOutput;
      22             : class AliHLTTPCCAClusterData;
      23             : 
      24             : class AliHLTTPCCATrackerFramework : AliHLTLogging
      25             : {
      26             : #ifdef HLTCA_STANDALONE
      27             :         friend int DrawGLScene(bool DoAnimation);
      28             : #endif
      29             : 
      30             : public:
      31             :         AliHLTTPCCATrackerFramework(int allowGPU = 1, const char* GPU_Library = NULL, int GPUDeviceNum = -1);
      32             :         ~AliHLTTPCCATrackerFramework();
      33             : 
      34             :         int InitGPU(int sliceCount = 1, int forceDeviceID = -1);
      35             :         int ExitGPU();
      36             :         void SetGPUDebugLevel(int Level, std::ostream *OutFile = NULL, std::ostream *GPUOutFile = NULL);
      37           0 :         int SetGPUTrackerOption(char* OptionName, int OptionValue) {if (strcmp(OptionName, "GlobalTracking") == 0) fGlobalTracking = OptionValue;return(fGPUTracker->SetGPUTrackerOption(OptionName, OptionValue));}
      38             :         int SetGPUTracker(bool enable);
      39             : 
      40             :         int InitializeSliceParam(int iSlice, AliHLTTPCCAParam &param);
      41             : 
      42           0 :         GPUhd() const AliHLTTPCCASliceOutput::outputControlStruct* OutputControl() const { return fOutputControl; }
      43             :         GPUhd() void SetOutputControl( AliHLTTPCCASliceOutput::outputControlStruct* val);
      44             : 
      45             :         int ProcessSlices(int firstSlice, int sliceCount, AliHLTTPCCAClusterData* pClusterData, AliHLTTPCCASliceOutput** pOutput);
      46             :         unsigned long long int* PerfTimer(int GPU, int iSlice, int iTimer);
      47             : 
      48           0 :         int MaxSliceCount() const { return(fUseGPUTracker ? (fGPUTrackerAvailable ? fGPUTracker->GetSliceCount() : 0) : fCPUSliceCount); }
      49           0 :         int GetGPUStatus() const { return(fGPUTrackerAvailable + fUseGPUTracker); }
      50             : 
      51           0 :         const AliHLTTPCCAParam& Param(int iSlice) const { return(fCPUTrackers[iSlice].Param()); }
      52           0 :         const AliHLTTPCCARow& Row(int iSlice, int iRow) const { return(fCPUTrackers[iSlice].Row(iRow)); }  //TODO: Should be changed to return only row parameters
      53             : 
      54           0 :         void SetKeepData(bool v) {fKeepData = v;}
      55             : 
      56           0 :         AliHLTTPCCAGPUTracker* GetGPUTracker() {return(fGPUTracker);}
      57             : 
      58             : private:
      59             :   static const int fgkNSlices = 36;       //* N slices
      60             : 
      61             :   bool fGPULibAvailable;        //Is the Library with the GPU code available at all?
      62             :   bool fGPUTrackerAvailable; // Is the GPU Tracker Available?
      63             :   bool fUseGPUTracker; // use the GPU tracker 
      64             :   int fGPUDebugLevel;  // debug level for the GPU code
      65             :   AliHLTTPCCAGPUTracker* fGPUTracker;   //Pointer to GPU Tracker Object
      66             :   void* fGPULib;                //Pointer to GPU Library
      67             : 
      68             :   AliHLTTPCCASliceOutput::outputControlStruct* fOutputControl;
      69             : 
      70             :   AliHLTTPCCATracker fCPUTrackers[fgkNSlices];
      71             :   static const int fCPUSliceCount = 36;
      72             : 
      73             :   bool fKeepData;               //Keep temporary data and do not free memory imediately, used for Standalone Debug Event Display
      74             :   bool fGlobalTracking; //Use global tracking
      75             : 
      76             :   AliHLTTPCCATrackerFramework( const AliHLTTPCCATrackerFramework& );
      77             :   AliHLTTPCCATrackerFramework &operator=( const AliHLTTPCCATrackerFramework& );
      78             : 
      79           6 :   ClassDef( AliHLTTPCCATrackerFramework, 0 )
      80             : 
      81             : };
      82             : 
      83             : #endif //ALIHLTTPCCATRACKERFRAMEWORK_H