Line data    Source code

       1             : // $Id$
       2             : // XEmacs -*-C++-*-
       3             : 
       4             : #ifndef ALIHLTTPCHWCFDATAREVERTERCOMPONENT_H
       5             : #define ALIHLTTPCHWCFDATAREVERTERCOMPONENT_H
       6             : 
       7             : //* This file is property of and copyright by the ALICE HLT Project        * 
       8             : //* ALICE Experiment at CERN, All rights reserved.                         *
       9             : //* See cxx source for full Copyright notice                               *
      10             : 
      11             : /// @file   AliHLTTPCHWCFDataReverterComponent.h
      12             : /// @author Kenneth Aamodt
      13             : /// @date   
      14             : /// @brief  Component for reverting data for the HW clusterfinder
      15             : ///
      16             : 
      17             : #include "AliHLTProcessor.h"
      18             : #include "AliHLTTPCPad.h"
      19             : #include "AliHLTDataTypes.h"
      20             : 
      21             : class AliHLTTPCDigitReader;
      22             : class AliHLTTPCMapping;
      23             : 
      24             : /**
      25             :  * @class AliHLTTPCHWCFDataReverterComponent
      26             :  * Implementation of the zero suppression component.
      27             :  * The component implements the interface methods of the @ref AliHLTProcessor.
      28             :  *
      29             :  * The component orders the data in the format the Hardware ClusterFinder 
      30             :  * expects, and revert the 40 bit altro words.
      31             :  * 
      32             :  * The component has the following component arguments:
      33             :  *
      34             :  * @ingroup alihlt_tpc_components
      35             :  */
      36             : class AliHLTTPCHWCFDataReverterComponent : public AliHLTProcessor
      37             :     {
      38             :     public:
      39             :         /** constructor */
      40             :         AliHLTTPCHWCFDataReverterComponent();
      41             :         /** destructor */
      42             :         virtual ~AliHLTTPCHWCFDataReverterComponent();
      43             : 
      44             :         // Public functions to implement AliHLTComponent's interface.
      45             :         // These functions are required for the registration process
      46             : 
      47             :   /** interface function, see AliHLTComponent for description */
      48             :   const char* GetComponentID();
      49             :   /** interface function, see AliHLTComponent for description */
      50             :   void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
      51             :   /** interface function, see AliHLTComponent for description */
      52             :   AliHLTComponentDataType GetOutputDataType();
      53             :   /** interface function, see AliHLTComponent for description */
      54             :   int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
      55             :   /** interface function, see AliHLTComponent for description */
      56             :   virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
      57             :   /** interface function, see AliHLTComponent for description */
      58             :   AliHLTComponent* Spawn();
      59             : 
      60             :       Int_t DeInitializePadArray();
      61             :       void InitializePadArray();
      62             :       
      63             :     protected:
      64             :         
      65             :         // Protected functions to implement AliHLTComponent's interface.
      66             :         // These functions provide initialization as well as the actual processing
      67             :         // capabilities of the component. 
      68             : 
      69             :         int DoInit( int argc, const char** argv );
      70             :         int DoDeinit();
      71             :         int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
      72             :                      AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
      73             :                      AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
      74             :         using AliHLTProcessor::DoEvent;
      75             : 
      76             :     private:
      77             : 
      78             :       /** copy constructor prohibited */
      79             :       AliHLTTPCHWCFDataReverterComponent(const AliHLTTPCHWCFDataReverterComponent&);
      80             :         
      81             :       /** assignment operator prohibited */
      82             :       AliHLTTPCHWCFDataReverterComponent& operator=(const AliHLTTPCHWCFDataReverterComponent&);
      83             :         
      84             :       /** the reader object for data decoding */
      85             :       AliHLTTPCDigitReader* fDigitReader;                              //!transient
      86             : 
      87             :       /** Vector of pointers to pad objects */
      88             :       typedef vector<AliHLTTPCPad*> AliHLTTPCPadVector;
      89             :       
      90             :       /** 2D vector of pointers to pad objects (vector of vectors)*/
      91             :       vector<AliHLTTPCPadVector> fRowPadVector;                        //! transient
      92             :       
      93             :       /** Array containing number of pads in the different rows */
      94             :       Int_t* fNumberOfPadsInRow;                                      //! transient
      95             :       
      96             :       /** Array containing the index f forst pad on row with hwaddress > 2048 */
      97             :       Int_t* fFirstPadHigh;                                      //! transient
      98             : 
      99             :       /** Number of rows the patch has */
     100             :       Int_t fNumberOfRows;                                            //! transient
     101             : 
     102             :       /** Current patch number */
     103             :       UInt_t fCurrentPatch;                                            //! transient
     104             : 
     105             :       /** First row in patch */
     106             :       UInt_t fFirstRow;                                                //! transient
     107             : 
     108             :       /** Last row in patch */
     109             :       UInt_t fLastRow;                                                 //! transient
     110             :       
     111             :       /** Number of timebins */
     112             :       Int_t fNTimeBins;                                                //! transient
     113             : 
     114             :       /** Flag to check if the 2d vector is initialized */
     115             :       Bool_t fVectorInitialized;                                       //! transient
     116             : 
     117             :       /** pointer to mapping object */
     118             :       AliHLTTPCMapping *fMapping;
     119             : 
     120             :       /** Flag to check if one should interleave the data */
     121             :       Bool_t fInterleave;
     122             : 
     123           6 :       ClassDef(AliHLTTPCHWCFDataReverterComponent, 0)
     124             : };
     125             : #endif