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

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