[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCHWCFDataReverterComponent.h

// $Id$
// XEmacs -*-C++-*-

#ifndef ALIHLTTPCHWCFDATAREVERTERCOMPONENT_H
#define ALIHLTTPCHWCFDATAREVERTERCOMPONENT_H

//* 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                               *

/// @file   AliHLTTPCHWCFDataReverterComponent.h
/// @author Kenneth Aamodt
/// @date   
/// @brief  Component for reverting data for the HW clusterfinder
///

#include "AliHLTProcessor.h"
#include "AliHLTTPCPad.h"
#include "AliHLTDataTypes.h"

class AliHLTTPCDigitReader;
class AliHLTTPCMapping;

/**
 * @class AliHLTTPCHWCFDataReverterComponent
 * Implementation of the zero suppression component.
 * The component implements the interface methods of the @ref AliHLTProcessor.
 *
 * The component orders the data in the format the Hardware ClusterFinder 
 * expects, and revert the 40 bit altro words.
 * 
 * The component has the following component arguments:
 *
 * @ingroup alihlt_tpc_components
 */
class AliHLTTPCHWCFDataReverterComponent : public AliHLTProcessor
    {
    public:
        /** constructor */
	AliHLTTPCHWCFDataReverterComponent();
	/** destructor */
	virtual ~AliHLTTPCHWCFDataReverterComponent();

	// Public functions to implement AliHLTComponent's interface.
	// These functions are required for the registration process

  /** interface function, see AliHLTComponent for description */
  const char* GetComponentID();
  /** interface function, see AliHLTComponent for description */
  void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
  /** interface function, see AliHLTComponent for description */
  AliHLTComponentDataType GetOutputDataType();
  /** interface function, see AliHLTComponent for description */
  int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
  /** interface function, see AliHLTComponent for description */
  virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
  /** interface function, see AliHLTComponent for description */
  AliHLTComponent* Spawn();

      Int_t DeInitializePadArray();
      void InitializePadArray();
      
    protected:
	
	// Protected functions to implement AliHLTComponent's interface.
	// These functions provide initialization as well as the actual processing
	// capabilities of the component. 

	int DoInit( int argc, const char** argv );
	int DoDeinit();
        int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
		     AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
		     AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
	using AliHLTProcessor::DoEvent;

    private:

      /** copy constructor prohibited */
      AliHLTTPCHWCFDataReverterComponent(const AliHLTTPCHWCFDataReverterComponent&);
	
      /** assignment operator prohibited */
      AliHLTTPCHWCFDataReverterComponent& operator=(const AliHLTTPCHWCFDataReverterComponent&);
	
      /** the reader object for data decoding */
      AliHLTTPCDigitReader* fDigitReader;                              //!transient

      /** Vector of pointers to pad objects */
      typedef vector<AliHLTTPCPad*> AliHLTTPCPadVector;
      
      /** 2D vector of pointers to pad objects (vector of vectors)*/
      vector<AliHLTTPCPadVector> fRowPadVector;                        //! transient
      
      /** Array containing number of pads in the different rows */
      Int_t* fNumberOfPadsInRow;                                      //! transient
      
      /** Array containing the index f forst pad on row with hwaddress > 2048 */
      Int_t* fFirstPadHigh;                                      //! transient

      /** Number of rows the patch has */
      Int_t fNumberOfRows;                                            //! transient

      /** Current patch number */
      UInt_t fCurrentPatch;                                            //! transient

      /** First row in patch */
      UInt_t fFirstRow;                                                //! transient

      /** Last row in patch */
      UInt_t fLastRow;                                                 //! transient
      
      /** Number of timebins */
      Int_t fNTimeBins;                                                //! transient

      /** Flag to check if the 2d vector is initialized */
      Bool_t fVectorInitialized;                                       //! transient

      /** pointer to mapping object */
      AliHLTTPCMapping *fMapping;

      /** Flag to check if one should interleave the data */
      Bool_t fInterleave;

      ClassDef(AliHLTTPCHWCFDataReverterComponent, 0)
};
#endif
Commit	Line	Data
5c15b943	1	// $Id$
a912b63b	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
5c15b943	11	/// @file AliHLTTPCHWCFDataReverterComponent.h
	12	/// @author Kenneth Aamodt
	13	/// @date
	14	/// @brief Component for reverting data for the HW clusterfinder
	15	///
a912b63b	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
8e69f9ad	120	/** Flag to check if one should interleave the data */
	121	Bool_t fInterleave;
	122
22240104	123	ClassDef(AliHLTTPCHWCFDataReverterComponent, 0)
8e69f9ad	124	};
a912b63b	125	#endif