Line data    Source code

       1             : //-*- Mode: C++ -*-
       2             : // @(#) $Id$
       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 ALIHLTTPCCATRACKERCOMPONENT_H
      11             : #define ALIHLTTPCCATRACKERCOMPONENT_H
      12             : 
      13             : #include "AliHLTProcessor.h"
      14             : #include "AliHLTComponentBenchmark.h"
      15             : 
      16             : class AliHLTTPCCATrackerFramework;
      17             : class AliHLTTPCCASliceOutput;
      18             : class AliHLTTPCCAClusterData;
      19             : struct AliHLTTPCSpacePointData;
      20             : 
      21             : /**
      22             :  * @class AliHLTTPCCATrackerComponent
      23             :  * The Cellular Automaton tracker component.
      24             :  */
      25             : class AliHLTTPCCATrackerComponent : public AliHLTProcessor
      26             : {
      27             :   public:
      28             :     /** standard constructor */
      29             :     AliHLTTPCCATrackerComponent();
      30             : 
      31             :     /** dummy copy constructor, defined according to effective C++ style */
      32             :     AliHLTTPCCATrackerComponent( const AliHLTTPCCATrackerComponent& );
      33             : 
      34             :     /** dummy assignment op, but defined according to effective C++ style */
      35             :     AliHLTTPCCATrackerComponent& operator=( const AliHLTTPCCATrackerComponent& );
      36             : 
      37             :     /** standard destructor */
      38             :     virtual ~AliHLTTPCCATrackerComponent();
      39             : 
      40             :     // Public functions to implement AliHLTComponent's interface.
      41             :     // These functions are required for the registration process
      42             : 
      43             :     /** @see component interface @ref AliHLTComponent::GetComponentID */
      44             :     const char* GetComponentID() ;
      45             : 
      46             :     /** @see component interface @ref AliHLTComponent::GetInputDataTypes */
      47             :     void GetInputDataTypes( vector<AliHLTComponentDataType>& list )  ;
      48             : 
      49             :     /** @see component interface @ref AliHLTComponent::GetOutputDataType */
      50             :     AliHLTComponentDataType GetOutputDataType() ;
      51             : 
      52             :     /** @see component interface @ref AliHLTComponent::GetOutputDataSize */
      53             :     virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) ;
      54             : 
      55             :     /** @see component interface @ref AliHLTComponent::Spawn */
      56             :     AliHLTComponent* Spawn() ;
      57             : 
      58             :   protected:
      59             : 
      60             :     // Protected functions to implement AliHLTComponent's interface.
      61             :     // These functions provide initialization as well as the actual processing
      62             :     // capabilities of the component.
      63             : 
      64             :     /** @see component interface @ref AliHLTComponent::DoInit */
      65             :     int DoInit( int argc, const char** argv );
      66             : 
      67             :     /** @see component interface @ref AliHLTComponent::DoDeinit */
      68             :     int DoDeinit();
      69             : 
      70             :     /** reconfigure **/
      71             :     int Reconfigure( const char* cdbEntry, const char* chainId );
      72             : 
      73             :     /** @see component interface @ref AliHLTProcessor::DoEvent */
      74             :     int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
      75             :                  AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
      76             :                  AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
      77             : 
      78             :   private:
      79             : 
      80             :     static const int fgkNSlices = 36;       //* N slices
      81             : 
      82             :     /** the tracker object */
      83             :     AliHLTTPCCATrackerFramework* fTracker;                      //! transient
      84             :     AliHLTTPCCAClusterData* fClusterData;                       //Storage classes for cluser data in slice
      85             :     AliHLTTPCCASliceOutput* fSliceOutput[fgkNSlices];           //Pointers to slice tracker output structures
      86             : 
      87             :     //The following parameters are maintained for compatibility to be able to change the component
      88             :     //such to process less than all 36 slices. Currently, fMinSlice is always 0 and fSliceCount is 36
      89             :     int fMinSlice;                                              //minimum slice number to be processed
      90             :     int fSliceCount;                                            //Number of slices to be processed
      91             : 
      92             :     /** magnetic field */
      93             :     double fSolenoidBz;               // see above
      94             :     int fMinNTrackClusters;           //* required min number of clusters on the track
      95             :     double fMinTrackPt;               //* required min Pt of tracks
      96             :     double fClusterZCut;              //* cut on cluster Z position (for noise rejection at the age of TPC)
      97             :     double fNeighboursSearchArea;     //* area in cm for the neighbour search algorithm
      98             :     double fClusterErrorCorrectionY;  // correction for the cluster errors
      99             :     double fClusterErrorCorrectionZ;  // correction for the cluster errors
     100             : 
     101             :     AliHLTComponentBenchmark fBenchmark; // benchmarks
     102             :     bool fAllowGPU;                   //* Allow this tracker to run on GPU
     103             :     int fGPUHelperThreads;            // Number of helper threads for GPU tracker, set to -1 to use default number
     104             :     int fCPUTrackers;                 //Number of CPU trackers to run in addition to GPU tracker
     105             :     bool fGlobalTracking;             //Activate global tracking feature
     106             :         int fGPUDeviceNum;                                //GPU Device to use, default -1 for auto detection
     107             :         TString fGPULibrary;                      //Name of the library file that provides the GPU tracker object
     108             : 
     109             :     /** set configuration parameters **/
     110             :     void SetDefaultConfiguration();
     111             :     int ReadConfigurationString(  const char* arguments );
     112             :     int ReadCDBEntry( const char* cdbEntry, const char* chainId );
     113             :     int Configure( const char* cdbEntry, const char* chainId, const char *commandLine );
     114             :     void ConfigureSlices();
     115             : 
     116           6 :     ClassDef( AliHLTTPCCATrackerComponent, 0 );
     117             : 
     118             : };
     119             : #endif //ALIHLTTPCCATRACKERCOMPONENT_H