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

// XEmacs -*-C++-*-
// @(#) $Id: AliHLTTPCClusterFinderComponent.h 23318 2008-01-14 12:43:28Z hristov $

#ifndef ALIHLTTPCZEROSUPPRESSIONCOMPONENT_H
#define ALIHLTTPCZEROSUPPRESSIONCOMPONENT_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   AliHLTTPCZeroSuppressionComponent.h
    @author Kenneth Aamodt
    @date   
    @brief  Component for ZeroSuppression
*/

// see below for class documentation
// or
// refer to README to build package
// or
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt

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

class AliHLTTPCDigitReader;

/**
 * @class AliHLTTPCZeroSuppressionComponent
 * Implementation of the zero suppression component.
 * The component implements the interface methods of the @ref AliHLTProcessor.
 * It reads the data pad by pad and zerosuppress the data. The output is unpacked which is 
 * sent to the clulsterfinder.
 * 
 * The component has the following component arguments:
 * - adc-threshold   ADC count threshold for zero suppression.
 *
 * - rms-threshold   RMS threshold for zero suppression.
 *          
 * - first-timebin   The first timebin for zero suppression
 *
 * - last-timebin    The last timebin for zero suppression
 *
 * - occupancy-limit Minimum number of timebins with signal
 *
 * - sort-pads Flag to switch on pad sorting(needed by the SORTED clusterfinder)
 *
 * @ingroup alihlt_tpc
 */
class AliHLTTPCZeroSuppressionComponent : public AliHLTProcessor
    {
    public:
        /** constructor */
	AliHLTTPCZeroSuppressionComponent();
	/** destructor */
	virtual ~AliHLTTPCZeroSuppressionComponent();

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

  /** interface function, see @ref AliHLTComponent for description */
  const char* GetComponentID();
  /** interface function, see @ref AliHLTComponent for description */
  void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
  /** interface function, see @ref AliHLTComponent for description */
  AliHLTComponentDataType GetOutputDataType();
  /** interface function, see @ref AliHLTComponent for description */
  int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
  /** interface function, see @ref AliHLTComponent for description */
  virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
  /** interface function, see @ref 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 */
      AliHLTTPCZeroSuppressionComponent(const AliHLTTPCZeroSuppressionComponent&);
	
      /** assignment operator prohibited */
      AliHLTTPCZeroSuppressionComponent& operator=(const AliHLTTPCZeroSuppressionComponent&);
	
      /** 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
      
      /** 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
      
      /** First timebin to include in zerosuppression */
      Int_t fStartTimeBin;                                             //! transient

      /** Lasr timebin to include in zerosuppression */
      Int_t fEndTimeBin;                                               //! transient

      /** Number of timebins */
      Int_t fNTimeBins;                                                //! transient

      /** Number of RMS the signal has to be larger than */
      Double_t fNRMSThreshold;                                         //! transient

      /** Signal threshold (signal has to be greater than average + this number) */
      Int_t fSignalThreshold;                                          //! transient

      /** Minimum number of signals to do zerosuppression */
      Int_t fMinimumNumberOfSignals;                                   //! transient

      /** OldRCUFormat flag */
      UInt_t fOldRCUFormat;                                            //! transient

      /** Sort pads flag */
      Bool_t fSortPads;                                                //! transient

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

      /** Value below average (useful for noisy pads to get the tails of a signal) */
      Int_t fValueBelowAverage;                                        //! transient

      /** Number of timebins to look left(decreasing time direction) for tails */
      Int_t fLeftTimeBin;                                              //! transient

      /** Number of timebins to look right(increasing time direction) for tails */
      Int_t fRightTimeBin;                                             //! transient

      /** Flag to switch on active pads selection */
      Bool_t fGetActivePads;                                           //! transient

      /** Vector of active pad hardware addresses */
      vector<Int_t> fHwAddressList;                                    //! transient

      ClassDef(AliHLTTPCZeroSuppressionComponent, 0)  
    };
#endif
Commit	Line	Data
afa4418c	1	// XEmacs --C++--
	2	// @(#) $Id: AliHLTTPCClusterFinderComponent.h 23318 2008-01-14 12:43:28Z hristov $
	3
	4	#ifndef ALIHLTTPCZEROSUPPRESSIONCOMPONENT_H
	5	#define ALIHLTTPCZEROSUPPRESSIONCOMPONENT_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 AliHLTTPCZeroSuppressionComponent.h
	12	@author Kenneth Aamodt
	13	@date
	14	@brief Component for ZeroSuppression
	15	*/
	16
	17	// see below for class documentation
	18	// or
	19	// refer to README to build package
	20	// or
	21	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	22
	23	#include "AliHLTProcessor.h"
	24	#include "AliHLTTPCPad.h"
a74855c2	25	#include "AliHLTDataTypes.h"
afa4418c	26
	27	class AliHLTTPCDigitReader;
	28
	29	/**
	30	* @class AliHLTTPCZeroSuppressionComponent
	31	* Implementation of the zero suppression component.
	32	* The component implements the interface methods of the @ref AliHLTProcessor.
	33	* It reads the data pad by pad and zerosuppress the data. The output is unpacked which is
	34	* sent to the clulsterfinder.
	35	*
	36	* The component has the following component arguments:
	37	* - adc-threshold ADC count threshold for zero suppression.
	38	*
	39	* - rms-threshold RMS threshold for zero suppression.
	40	*
	41	* - first-timebin The first timebin for zero suppression
	42	*
	43	* - last-timebin The last timebin for zero suppression
	44	*
	45	* - occupancy-limit Minimum number of timebins with signal
	46	*
	47	* - sort-pads Flag to switch on pad sorting(needed by the SORTED clusterfinder)
	48	*
	49	* @ingroup alihlt_tpc
	50	*/
	51	class AliHLTTPCZeroSuppressionComponent : public AliHLTProcessor
	52	{
	53	public:
	54	/** constructor */
	55	AliHLTTPCZeroSuppressionComponent();
	56	/** destructor */
	57	virtual ~AliHLTTPCZeroSuppressionComponent();
	58
	59	// Public functions to implement AliHLTComponent's interface.
	60	// These functions are required for the registration process
	61
	62	/** interface function, see @ref AliHLTComponent for description */
	63	const char* GetComponentID();
	64	/** interface function, see @ref AliHLTComponent for description */
	65	void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
	66	/** interface function, see @ref AliHLTComponent for description */
	67	AliHLTComponentDataType GetOutputDataType();
	68	/** interface function, see @ref AliHLTComponent for description */
	69	int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
	70	/** interface function, see @ref AliHLTComponent for description */
	71	virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
	72	/** interface function, see @ref AliHLTComponent for description */
	73	AliHLTComponent* Spawn();
	74
	75	Int_t DeInitializePadArray();
	76	void InitializePadArray();
	77	protected:
	78
	79	// Protected functions to implement AliHLTComponent's interface.
	80	// These functions provide initialization as well as the actual processing
	81	// capabilities of the component.
	82
	83	int DoInit( int argc, const char** argv );
	84	int DoDeinit();
	85	int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
	86	AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
	87	AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
	88
	89	using AliHLTProcessor::DoEvent;
90
91	private:
92
a74855c2	93	/** copy constructor prohibited */
a74855c2	94	AliHLTTPCZeroSuppressionComponent(const AliHLTTPCZeroSuppressionComponent&);
afa4418c	95
a74855c2	96	/** assignment operator prohibited */
a74855c2	97	AliHLTTPCZeroSuppressionComponent& operator=(const AliHLTTPCZeroSuppressionComponent&);
afa4418c	98
a74855c2	99	/** the reader object for data decoding */
a74855c2	100	AliHLTTPCDigitReader* fDigitReader; //!transient
afa4418c	101
a74855c2	102	/** Vector of pointers to pad objects */
	103	typedef vector<AliHLTTPCPad*> AliHLTTPCPadVector;
	104
	105	/** 2D vector of pointers to pad objects (vector of vectors)*/
afa4418c	106	vector<AliHLTTPCPadVector> fRowPadVector; //! transient
afa4418c	107
a74855c2	108	/** Array containing number of pads in the different rows */
a74855c2	109	Int_t* fNumberOfPadsInRow; //! transient
afa4418c	110
a74855c2	111	/** Number of rows the patch has */
a74855c2	112	Int_t fNumberOfRows; //! transient
afa4418c	113
a74855c2	114	/** Current patch number */
afa4418c	115	UInt_t fCurrentPatch; //! transient
a74855c2	116
a74855c2	117	/** First row in patch */
afa4418c	118	UInt_t fFirstRow; //! transient
a74855c2	119
a74855c2	120	/** Last row in patch */
afa4418c	121	UInt_t fLastRow; //! transient
afa4418c	122
a74855c2	123	/** First timebin to include in zerosuppression */
	124	Int_t fStartTimeBin; //! transient
	125
	126	/** Lasr timebin to include in zerosuppression */
	127	Int_t fEndTimeBin; //! transient
	128
	129	/** Number of timebins */
	130	Int_t fNTimeBins; //! transient
	131
	132	/** Number of RMS the signal has to be larger than */
	133	Double_t fNRMSThreshold; //! transient
afa4418c	134
a74855c2	135	/** Signal threshold (signal has to be greater than average + this number) */
	136	Int_t fSignalThreshold; //! transient
	137
	138	/** Minimum number of signals to do zerosuppression */
	139	Int_t fMinimumNumberOfSignals; //! transient
	140
	141	/** OldRCUFormat flag */
afa4418c	142	UInt_t fOldRCUFormat; //! transient
a74855c2	143
a74855c2	144	/** Sort pads flag */
afa4418c	145	Bool_t fSortPads; //! transient
a74855c2	146
a74855c2	147	/** Flag to check if the 2d vector is initialized */
afa4418c	148	Bool_t fVectorInitialized; //! transient
afa4418c	149
a74855c2	150	/** Value below average (useful for noisy pads to get the tails of a signal) */
afa4418c	151	Int_t fValueBelowAverage; //! transient
a74855c2	152
a74855c2	153	/** Number of timebins to look left(decreasing time direction) for tails */
afa4418c	154	Int_t fLeftTimeBin; //! transient
a74855c2	155
a74855c2	156	/** Number of timebins to look right(increasing time direction) for tails */
afa4418c	157	Int_t fRightTimeBin; //! transient
a74855c2	158
	159	/** Flag to switch on active pads selection */
	160	Bool_t fGetActivePads; //! transient
	161
	162	/** Vector of active pad hardware addresses */
	163	vector<Int_t> fHwAddressList; //! transient
	164
afa4418c	165	ClassDef(AliHLTTPCZeroSuppressionComponent, 0)
	166	};
	167	#endif