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

// @(#) $Id$

#ifndef ALIHLTTPCCLUSTERFINDERCOMPONENT_H
#define ALIHLTTPCCLUSTERFINDERCOMPONENT_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   AliHLTTPCClusterFinderComponent.h
    @author Timm Steinbeck, Matthias Richter, Jochen Thaeder
    @date   
    @brief  The TPC cluster finder component.
*/

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

class AliHLTTPCClusterFinder;
class AliHLTTPCPadArray;
class AliHLTTPCDigitReader;

/**
 * @class AliHLTTPCClusterFinderComponent
 * Implementation of the cluster finder component.
 * The component implements the interface methods of the @ref AliHLTProcessor.
 * The actual cluster finding algorithm is implemented in @ref AliHLTTPCClusterFinder.
 * The component can handle unpacked and packed data of different formats via the
 * AliHLTTPCDigitReader implementations. Two components are registered, the
 * TPCClusterFinderUnpacked and the TPCClusterFinderPacked. The latter one can
 * instantiate different digit readers depending on the arguments.
 * 
 * The component has the following component arguments:
 * - rawreadermode   the mode for the @ref AliHLTTPCDigitReaderRaw, use -2 if using unsorted
 * - adc-threshold   ADC count threshold for zero suppression, if <0 the base line
 *                   calculation and subtraction is switched off
 * - pp-run          set parameters specific to a pp run; currently this switches
 *                   cluster deconvolution off for pp runs (not true for unsorted reading)
 * - unsorted        if 1 the data will be read unsorted in to a PadArray object. This should
 *                   only be done on patch level since it use a lot of memory
 * - patch           specify on which patch to resd the data unsorted
 *
 * @ingroup alihlt_tpc_components
 */
class AliHLTTPCClusterFinderComponent : public AliHLTProcessor
    {
    public:
      /**
       * Defines for the cluster finder type.
       * The cluster finders can work on different formats of input data,
       * the AliHLTTPCDigitReader interface provides a transparent way to
       * read the data.
       */
      enum {
	/** real data, offline AliAltroRawStream used for data decoding */
	kClusterFinderPacked,
	/** Unpacked data of format AliHLTTPCUnpackedRawData */
	kClusterFinderUnpacked,
	/** real data, fast AliAltroDecoder used for data decoding */
	kClusterFinderDecoder
      };

        /**
         * constructor 
         * @param mode    input type see e.g. @ref kClusterFinderUnpacked
         */
	AliHLTTPCClusterFinderComponent(int mode);
	/** destructor */
	virtual ~AliHLTTPCClusterFinderComponent();

	// 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();

    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 );
	int Reconfigure(const char* cdbEntry, const char* chainId);
	
	using AliHLTProcessor::DoEvent;

    private:
	/** standard constructor prohibited */
	AliHLTTPCClusterFinderComponent();
	/** copy constructor prohibited */
	AliHLTTPCClusterFinderComponent(const AliHLTTPCClusterFinderComponent&);
	/** assignment operator prohibited */
	AliHLTTPCClusterFinderComponent& operator=(const AliHLTTPCClusterFinderComponent&);
	/** the cluster finder object */
	AliHLTTPCClusterFinder* fClusterFinder;                                      //!transient
	/** the reader object for data decoding */
	AliHLTTPCDigitReader* fReader;                                               //!transient

	bool fClusterDeconv; //!transient
      float fXYClusterError; //!transient
      float fZClusterError; //!transient
      /**
       * switch to indicated the reader
       * use fModeSwitch = 0 for packed inputtype "gkDDLPackedRawDataType"
       * use fModeSwitch = 1 for unpacked inputtype "gkUnpackedRawDataType"
       * use fModeSwitch = 2 for packed inputtype "gkDDLPackedRawDataType" with new digit reader
       */
      Int_t fModeSwitch;                                                           // see above
      
      /*
       * Reads the data the new unsorted way if true
       *
       */
      Int_t fUnsorted;                                                               //!transient

      /*
       * Patch number to be read, currently given as component argument,
       * will be changed later.
       */
      Int_t fPatch;                                                                  //!transient

      /*
       * Switch to specify if one ship out a list of active pads.
       * Used for the 2007 December run. 
       */
      Int_t fGetActivePads;                                                          //!transient

      /*
       * Pointer to a PadArray object containing a double array of all the pads in
       * the current patch.
       */
      AliHLTTPCPadArray * fPadArray;                                                 //!transient

      ClassDef(AliHLTTPCClusterFinderComponent, 2)

    };
#endif
Commit	Line	Data
	1	// @(#) $Id$
	2
	3	#ifndef ALIHLTTPCCLUSTERFINDERCOMPONENT_H
	4	#define ALIHLTTPCCLUSTERFINDERCOMPONENT_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 AliHLTTPCClusterFinderComponent.h
	11	@author Timm Steinbeck, Matthias Richter, Jochen Thaeder
	12	@date
	13	@brief The TPC cluster finder component.
	14	*/
	15
	16	// see below for class documentation
	17	// or
	18	// refer to README to build package
	19	// or
	20	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	21
	22	#include "AliHLTProcessor.h"
	23
	24	class AliHLTTPCClusterFinder;
	25	class AliHLTTPCPadArray;
	26	class AliHLTTPCDigitReader;
	27
	28	/**
	29	* @class AliHLTTPCClusterFinderComponent
	30	* Implementation of the cluster finder component.
	31	* The component implements the interface methods of the @ref AliHLTProcessor.
	32	* The actual cluster finding algorithm is implemented in @ref AliHLTTPCClusterFinder.
	33	* The component can handle unpacked and packed data of different formats via the
	34	* AliHLTTPCDigitReader implementations. Two components are registered, the
	35	* TPCClusterFinderUnpacked and the TPCClusterFinderPacked. The latter one can
	36	* instantiate different digit readers depending on the arguments.
	37	*
	38	* The component has the following component arguments:
	39	* - rawreadermode the mode for the @ref AliHLTTPCDigitReaderRaw, use -2 if using unsorted
	40	* - adc-threshold ADC count threshold for zero suppression, if <0 the base line
	41	* calculation and subtraction is switched off
	42	* - pp-run set parameters specific to a pp run; currently this switches
	43	* cluster deconvolution off for pp runs (not true for unsorted reading)
	44	* - unsorted if 1 the data will be read unsorted in to a PadArray object. This should
	45	* only be done on patch level since it use a lot of memory
	46	* - patch specify on which patch to resd the data unsorted
	47	*
	48	* @ingroup alihlt_tpc_components
	49	*/
	50	class AliHLTTPCClusterFinderComponent : public AliHLTProcessor
	51	{
	52	public:
	53	/**
	54	* Defines for the cluster finder type.
	55	* The cluster finders can work on different formats of input data,
	56	* the AliHLTTPCDigitReader interface provides a transparent way to
	57	* read the data.
	58	*/
	59	enum {
	60	/** real data, offline AliAltroRawStream used for data decoding */
	61	kClusterFinderPacked,
	62	/** Unpacked data of format AliHLTTPCUnpackedRawData */
	63	kClusterFinderUnpacked,
	64	/** real data, fast AliAltroDecoder used for data decoding */
	65	kClusterFinderDecoder
	66	};
	67
	68	/**
	69	* constructor
	70	* @param mode input type see e.g. @ref kClusterFinderUnpacked
	71	*/
	72	AliHLTTPCClusterFinderComponent(int mode);
	73	/** destructor */
	74	virtual ~AliHLTTPCClusterFinderComponent();
	75
	76	// Public functions to implement AliHLTComponent's interface.
	77	// These functions are required for the registration process
	78
	79	/** interface function, see @ref AliHLTComponent for description */
	80	const char* GetComponentID();
	81	/** interface function, see @ref AliHLTComponent for description */
	82	void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
	83	/** interface function, see @ref AliHLTComponent for description */
	84	AliHLTComponentDataType GetOutputDataType();
	85	/** interface function, see @ref AliHLTComponent for description */
	86	int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
	87	/** interface function, see @ref AliHLTComponent for description */
	88	virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
	89	/** interface function, see @ref AliHLTComponent for description */
	90	AliHLTComponent* Spawn();
	91
	92	protected:
	93
	94	// Protected functions to implement AliHLTComponent's interface.
	95	// These functions provide initialization as well as the actual processing
	96	// capabilities of the component.
	97
	98	int DoInit( int argc, const char** argv );
	99	int DoDeinit();
	100	int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
	101	AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
	102	AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
	103	int Reconfigure(const char* cdbEntry, const char* chainId);
	104
	105	using AliHLTProcessor::DoEvent;
	106
	107	private:
	108	/** standard constructor prohibited */
	109	AliHLTTPCClusterFinderComponent();
	110	/** copy constructor prohibited */
	111	AliHLTTPCClusterFinderComponent(const AliHLTTPCClusterFinderComponent&);
	112	/** assignment operator prohibited */
	113	AliHLTTPCClusterFinderComponent& operator=(const AliHLTTPCClusterFinderComponent&);
	114	/** the cluster finder object */
	115	AliHLTTPCClusterFinder* fClusterFinder; //!transient
	116	/** the reader object for data decoding */
	117	AliHLTTPCDigitReader* fReader; //!transient
	118
	119	bool fClusterDeconv; //!transient
	120	float fXYClusterError; //!transient
	121	float fZClusterError; //!transient
	122	/**
	123	* switch to indicated the reader
	124	* use fModeSwitch = 0 for packed inputtype "gkDDLPackedRawDataType"
	125	* use fModeSwitch = 1 for unpacked inputtype "gkUnpackedRawDataType"
	126	* use fModeSwitch = 2 for packed inputtype "gkDDLPackedRawDataType" with new digit reader
	127	*/
	128	Int_t fModeSwitch; // see above
	129
	130	/*
	131	* Reads the data the new unsorted way if true
	132	*
	133	*/
	134	Int_t fUnsorted; //!transient
	135
	136	/*
	137	* Patch number to be read, currently given as component argument,
	138	* will be changed later.
	139	*/
	140	Int_t fPatch; //!transient
	141
	142	/*
	143	* Switch to specify if one ship out a list of active pads.
	144	* Used for the 2007 December run.
	145	*/
	146	Int_t fGetActivePads; //!transient
	147
	148	/*
	149	* Pointer to a PadArray object containing a double array of all the pads in
	150	* the current patch.
	151	*/
	152	AliHLTTPCPadArray * fPadArray; //!transient
	153
	154	ClassDef(AliHLTTPCClusterFinderComponent, 2)
	155
	156	};
	157	#endif