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

// XEmacs -*-C++-*-
// @(#) $Id$

#ifndef ALIHLTTPCDEFINITIONS_H
#define ALIHLTTPCDEFINITIONS_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                               *

#include "AliHLTDataTypes.h"
#include "Rtypes.h"

/**
 * @class AliHLTTPCDefinitions
 * Data type definitions for the libAliHLTTPC library.
 * 
 * @ingroup alihlt_tpc
 */
class AliHLTTPCDefinitions
{
public:

	static AliHLTUInt8_t GetMinSliceNr( const AliHLTComponentBlockData& block )
		{
		return (AliHLTUInt8_t)( (block.fSpecification & 0x00FF0000) >> 16 );
		}
	static AliHLTUInt8_t GetMinSliceNr( ULong_t spec )
		{
		return (AliHLTUInt8_t)( (spec & 0x00FF0000) >> 16 );
		}
	static AliHLTUInt8_t GetMaxSliceNr( const AliHLTComponentBlockData& block )
		{
		return (AliHLTUInt8_t)( (block.fSpecification & 0xFF000000) >> 24 );
		}
	static AliHLTUInt8_t GetMaxSliceNr( ULong_t spec )
		{
		return (AliHLTUInt8_t)( (spec & 0xFF000000) >> 24 );
		}
	static Int_t GetSingleSliceNr( const AliHLTComponentBlockData& block )
		{
		return GetSingleSliceNr(block.fSpecification);
		}
	static Int_t GetSingleSliceNr( ULong_t spec );
	static AliHLTUInt8_t GetMinPatchNr( const AliHLTComponentBlockData& block )
		{
		return (AliHLTUInt8_t)( (block.fSpecification & 0x000000FF) );
		}
	static AliHLTUInt8_t GetMinPatchNr( ULong_t spec )
		{
		return (AliHLTUInt8_t)( (spec & 0x000000FF) );
		}
	static AliHLTUInt8_t GetMaxPatchNr( const AliHLTComponentBlockData& block )
		{
		return (AliHLTUInt8_t)( (block.fSpecification & 0x0000FF00) >> 8 );
		}
	static AliHLTUInt8_t GetMaxPatchNr( ULong_t spec )
		{
		return (AliHLTUInt8_t)( (spec & 0x0000FF00) >> 8 );
		}
	static Int_t GetSinglePatchNr( const AliHLTComponentBlockData& block )
		{
		return GetSinglePatchNr(block.fSpecification);
		}
	static Int_t GetSinglePatchNr( ULong_t spec );
	static AliHLTUInt32_t EncodeDataSpecification( AliHLTUInt8_t minSliceNr, 
						AliHLTUInt8_t maxSliceNr,
						AliHLTUInt8_t minPatchNr,
						AliHLTUInt8_t maxPatchNr )
		{
		return ((maxSliceNr & 0xFF) << 24) | ((minSliceNr & 0xFF) << 16) | ((maxPatchNr & 0xFF) << 8) | ((minPatchNr & 0xFF));
		}
	
	/**
	 * Converts a slice and patch number to a DDL ID number for TPC.
	 * \param slice  The slice number in the range [0..35] (0..17 for A side and 18..35 for C side).
	 * \param patch  The patch number in the range [0..5].
	 * \returns the DDL ID number of TPC or -1 if the slice or patch was invalid.
	 * \note A side is in the -z axis direction (same side as the muon spectrometer)
	 *       and C side is in the +z axis direction.
	 */
	static AliHLTInt32_t SlicePatchToDDLId(AliHLTUInt8_t slice, AliHLTUInt8_t patch)
		{
		if (slice > 35 or patch > 5) return -1;
		return 768 + (patch > 1 ? 72 + 4*slice + patch - 2 : 2*slice + patch);
		}
		
	/**
	 * Converts a DDL ID number for the TPC to a slice and patch number.
	 * \param [in] ddlid  The DDL ID number to convert.
	 * \param [out] slice  The resultant slice number in the range [0..35].
	 * \param [out] patch  The resultant patch number in the range [0..5].
	 * \returns true if the DDL ID number was valid and slice and patch were set,
	 *     otherwise false for an invalid DDL ID.
	 */
	static bool DDLIdToSlicePatch(AliHLTInt32_t ddlid, AliHLTUInt8_t& slice, AliHLTUInt8_t& patch);

  /** DDL entropy encoded data */
  static const AliHLTComponentDataType fgkDDLEncodedEntropyRawDataType; // see above
  static const AliHLTComponentDataType& DDLEncodedEntropyRawDataType();
  /** packed RAW data */
  static const AliHLTComponentDataType fgkPackedRawDataType;            // see above
  static const AliHLTComponentDataType& PackedRawDataType();
  /** unpacked RAW data */
  static const AliHLTComponentDataType fgkUnpackedRawDataType;          // see above
  static const AliHLTComponentDataType& UnpackedRawDataType();
  /** cluster data */
  static const AliHLTComponentDataType fgkClustersDataType;             // see above
  static const AliHLTComponentDataType& ClustersDataType();
  /** raw cluster data (not transformed) */
  static const AliHLTComponentDataType fgkRawClustersDataType;          // see above
  static const AliHLTComponentDataType& RawClustersDataType();
  /** raw cluster data descriptor*/
  static const AliHLTComponentDataType fgkRawClustersDescriptorDataType;          // see above
  static const AliHLTComponentDataType& RawClustersDescriptorDataType();
  /** HW cluster data */
  static const AliHLTComponentDataType fgkHWClustersDataType;           // see above
  static const AliHLTComponentDataType& HWClustersDataType();
  /** HW alternative output cluster data */
  static const AliHLTComponentDataType fgkAlterClustersDataType;        // see above
  static const AliHLTComponentDataType& AlterClustersDataType();
  /** track segments in local coordinates */
  static const AliHLTComponentDataType fgkTrackSegmentsDataType;        // see above
  static const AliHLTComponentDataType& TrackSegmentsDataType();
  /** tracks in global koordinates */
  static const AliHLTComponentDataType fgkTracksDataType;               // see above
  static const AliHLTComponentDataType& TracksDataType();
  /** vertex data structure */
  static const AliHLTComponentDataType fgkVertexDataType;               // see above
  static const AliHLTComponentDataType& VertexDataType();

  // Cluster & Tracks model data
  /** data compression descriptor*/
  static const AliHLTComponentDataType fgkDataCompressionDescriptorDataType;          // see above
  static const AliHLTComponentDataType& DataCompressionDescriptorDataType();
  /** cluster tracks model data type */
  static const AliHLTComponentDataType fgkClusterTracksModelDataType;          // see above
  static const AliHLTComponentDataType& ClusterTracksModelDataType();
  /** remaining clusters model data type */
  static const AliHLTComponentDataType fgkRemainingClustersModelDataType;      // see above
  static const AliHLTComponentDataType& RemainingClustersModelDataType();
  /** track clusters compressed data type */
  static const AliHLTComponentDataType fgkClusterTracksCompressedDataType;     // see above
  static const AliHLTComponentDataType& ClusterTracksCompressedDataType();
  /** track cluster ids data type */
  static const AliHLTComponentDataType& ClusterIdTracksDataType();
  /** compressed cluster ids data type */
  static const AliHLTComponentDataType& CompressedClusterIdDataType();
  /** remaining clusters compressed data type */
  static const AliHLTComponentDataType fgkRemainingClustersCompressedDataType; // see above
  static const AliHLTComponentDataType& RemainingClustersCompressedDataType();
  /** remaining clusters ids data type */
  static const AliHLTComponentDataType& RemainingClusterIdsDataType();

  // Calibration data
  /** pedestal calibration data */
  static const AliHLTComponentDataType& CalibPedestalDataType();
  /** signal calibration data */
  static const AliHLTComponentDataType& CalibPulserDataType();
  /** central electrode calibration data */
  static const AliHLTComponentDataType& CalibCEDataType();

  // offline calbration components

  /** alignment calibration data */
  static const AliHLTComponentDataType& OfflineCalibAlignDataType();
  /** track calibration data */
  static const AliHLTComponentDataType& OfflineCalibTracksDataType();
  /** gain calibration data */
  static const AliHLTComponentDataType& OfflineCalibTracksGainDataType();
  /** cluster monte carlo information */
  static const AliHLTComponentDataType fgkAliHLTDataTypeClusterMCInfo;    // see above
  static const AliHLTComponentDataType& AliHLTDataTypeClusterMCInfo();

  // ids for the different parameters of a cluster
  enum AliClusterParameterId_t {
    kPadRow = 0,
    kPad,
    kTime,
    kSigmaY2,
    kSigmaZ2,
    kCharge,
    kQMax,
    kResidualPad,
    kResidualTime,
    kClusterCount,
    kLast = kQMax
  };

  // helper struct for the definition of cluster parameters
  struct AliClusterParameter {
    AliClusterParameterId_t fId; //! id of the parameter
    const char* fName;           //! name of the parameter
    int fBitLength;              //! bit length
    int fOptional;               //! optional parameter
    int fScale;                  //! scale for conversion to int number
  };

  static const AliClusterParameter fgkClusterParameterDefinitions[];
  static unsigned GetNumberOfClusterParameterDefinitions();
  static const unsigned fgkMaxClusterDeltaPad;
  static unsigned GetMaxClusterDeltaPad() {return fgkMaxClusterDeltaPad;}
  static const unsigned fgkMaxClusterDeltaTime;
  static unsigned GetMaxClusterDeltaTime() {return fgkMaxClusterDeltaTime;}

private:

  /// Do not allow creation of this class since everything is static.
  AliHLTTPCDefinitions();
  virtual ~AliHLTTPCDefinitions();

  ClassDef(AliHLTTPCDefinitions, 0)  // Useful static definitions and methods for TPC
};

#endif
Commit	Line	Data
71d7c760	1	// XEmacs --C++--
	2	// @(#) $Id$
	3
	4	#ifndef ALIHLTTPCDEFINITIONS_H
	5	#define ALIHLTTPCDEFINITIONS_H
13398559	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 *
71d7c760	9
71d7c760	10	#include "AliHLTDataTypes.h"
96bda103	11	#include "Rtypes.h"
71d7c760	12
13398559	13	/**
	14	* @class AliHLTTPCDefinitions
	15	* Data type definitions for the libAliHLTTPC library.
297174de	16	*
297174de	17	* @ingroup alihlt_tpc
13398559	18	*/
71d7c760	19	class AliHLTTPCDefinitions
96bda103	20	{
96bda103	21	public:
71d7c760	22
8ede8717	23	static AliHLTUInt8_t GetMinSliceNr( const AliHLTComponentBlockData& block )
71d7c760	24	{
	25	return (AliHLTUInt8_t)( (block.fSpecification & 0x00FF0000) >> 16 );
	26	}
a6c02c85	27	static AliHLTUInt8_t GetMinSliceNr( ULong_t spec )
	28	{
	29	return (AliHLTUInt8_t)( (spec & 0x00FF0000) >> 16 );
	30	}
8ede8717	31	static AliHLTUInt8_t GetMaxSliceNr( const AliHLTComponentBlockData& block )
71d7c760	32	{
	33	return (AliHLTUInt8_t)( (block.fSpecification & 0xFF000000) >> 24 );
	34	}
a6c02c85	35	static AliHLTUInt8_t GetMaxSliceNr( ULong_t spec )
	36	{
	37	return (AliHLTUInt8_t)( (spec & 0xFF000000) >> 24 );
	38	}
333d8597	39	static Int_t GetSingleSliceNr( const AliHLTComponentBlockData& block )
	40	{
	41	return GetSingleSliceNr(block.fSpecification);
	42	}
	43	static Int_t GetSingleSliceNr( ULong_t spec );
8ede8717	44	static AliHLTUInt8_t GetMinPatchNr( const AliHLTComponentBlockData& block )
71d7c760	45	{
	46	return (AliHLTUInt8_t)( (block.fSpecification & 0x000000FF) );
	47	}
a6c02c85	48	static AliHLTUInt8_t GetMinPatchNr( ULong_t spec )
	49	{
	50	return (AliHLTUInt8_t)( (spec & 0x000000FF) );
	51	}
8ede8717	52	static AliHLTUInt8_t GetMaxPatchNr( const AliHLTComponentBlockData& block )
71d7c760	53	{
	54	return (AliHLTUInt8_t)( (block.fSpecification & 0x0000FF00) >> 8 );
	55	}
a6c02c85	56	static AliHLTUInt8_t GetMaxPatchNr( ULong_t spec )
	57	{
	58	return (AliHLTUInt8_t)( (spec & 0x0000FF00) >> 8 );
	59	}
333d8597	60	static Int_t GetSinglePatchNr( const AliHLTComponentBlockData& block )
	61	{
	62	return GetSinglePatchNr(block.fSpecification);
	63	}
	64	static Int_t GetSinglePatchNr( ULong_t spec );
71d7c760	65	static AliHLTUInt32_t EncodeDataSpecification( AliHLTUInt8_t minSliceNr,
	66	AliHLTUInt8_t maxSliceNr,
	67	AliHLTUInt8_t minPatchNr,
	68	AliHLTUInt8_t maxPatchNr )
	69	{
	70	return ((maxSliceNr & 0xFF) << 24) \| ((minSliceNr & 0xFF) << 16) \| ((maxPatchNr & 0xFF) << 8) \| ((minPatchNr & 0xFF));
	71	}
625b072f	72
	73	/**
	74	* Converts a slice and patch number to a DDL ID number for TPC.
	75	* \param slice The slice number in the range [0..35] (0..17 for A side and 18..35 for C side).
	76	* \param patch The patch number in the range [0..5].
	77	* \returns the DDL ID number of TPC or -1 if the slice or patch was invalid.
	78	* \note A side is in the -z axis direction (same side as the muon spectrometer)
	79	* and C side is in the +z axis direction.
	80	*/
	81	static AliHLTInt32_t SlicePatchToDDLId(AliHLTUInt8_t slice, AliHLTUInt8_t patch)
	82	{
	83	if (slice > 35 or patch > 5) return -1;
	84	return 768 + (patch > 1 ? 72 + 4slice + patch - 2 : 2slice + patch);
	85	}
	86
	87	/**
	88	* Converts a DDL ID number for the TPC to a slice and patch number.
f08578f1	89	* \param [in] ddlid The DDL ID number to convert.
	90	* \param [out] slice The resultant slice number in the range [0..35].
	91	* \param [out] patch The resultant patch number in the range [0..5].
625b072f	92	* \returns true if the DDL ID number was valid and slice and patch were set,
	93	* otherwise false for an invalid DDL ID.
	94	*/
	95	static bool DDLIdToSlicePatch(AliHLTInt32_t ddlid, AliHLTUInt8_t& slice, AliHLTUInt8_t& patch);
71d7c760	96
9ae1d7d8	97	/** DDL entropy encoded data */
9ae1d7d8	98	static const AliHLTComponentDataType fgkDDLEncodedEntropyRawDataType; // see above
4f82526d	99	static const AliHLTComponentDataType& DDLEncodedEntropyRawDataType();
96bda103	100	/** packed RAW data */
28355ac2	101	static const AliHLTComponentDataType fgkPackedRawDataType; // see above
4f82526d	102	static const AliHLTComponentDataType& PackedRawDataType();
96bda103	103	/** unpacked RAW data */
28355ac2	104	static const AliHLTComponentDataType fgkUnpackedRawDataType; // see above
4f82526d	105	static const AliHLTComponentDataType& UnpackedRawDataType();
96bda103	106	/** cluster data */
28355ac2	107	static const AliHLTComponentDataType fgkClustersDataType; // see above
4f82526d	108	static const AliHLTComponentDataType& ClustersDataType();
5e75f4e0	109	/** raw cluster data (not transformed) */
5e75f4e0	110	static const AliHLTComponentDataType fgkRawClustersDataType; // see above
4f82526d	111	static const AliHLTComponentDataType& RawClustersDataType();
3ba734d3	112	/** raw cluster data descriptor*/
	113	static const AliHLTComponentDataType fgkRawClustersDescriptorDataType; // see above
	114	static const AliHLTComponentDataType& RawClustersDescriptorDataType();
6af4f584	115	/** HW cluster data */
6af4f584	116	static const AliHLTComponentDataType fgkHWClustersDataType; // see above
4f82526d	117	static const AliHLTComponentDataType& HWClustersDataType();
491d6af5	118	/** HW alternative output cluster data */
491d6af5	119	static const AliHLTComponentDataType fgkAlterClustersDataType; // see above
4f82526d	120	static const AliHLTComponentDataType& AlterClustersDataType();
96bda103	121	/** track segments in local coordinates */
28355ac2	122	static const AliHLTComponentDataType fgkTrackSegmentsDataType; // see above
4f82526d	123	static const AliHLTComponentDataType& TrackSegmentsDataType();
96bda103	124	/** tracks in global koordinates */
28355ac2	125	static const AliHLTComponentDataType fgkTracksDataType; // see above
4f82526d	126	static const AliHLTComponentDataType& TracksDataType();
96bda103	127	/** vertex data structure */
28355ac2	128	static const AliHLTComponentDataType fgkVertexDataType; // see above
4f82526d	129	static const AliHLTComponentDataType& VertexDataType();
ff2f0f94	130
ff2f0f94	131	// Cluster & Tracks model data
124b5fc8	132	/** data compression descriptor*/
	133	static const AliHLTComponentDataType fgkDataCompressionDescriptorDataType; // see above
	134	static const AliHLTComponentDataType& DataCompressionDescriptorDataType();
ff2f0f94	135	/** cluster tracks model data type */
28355ac2	136	static const AliHLTComponentDataType fgkClusterTracksModelDataType; // see above
4f82526d	137	static const AliHLTComponentDataType& ClusterTracksModelDataType();
ff2f0f94	138	/** remaining clusters model data type */
28355ac2	139	static const AliHLTComponentDataType fgkRemainingClustersModelDataType; // see above
4f82526d	140	static const AliHLTComponentDataType& RemainingClustersModelDataType();
29a647c6	141	/** track clusters compressed data type */
28355ac2	142	static const AliHLTComponentDataType fgkClusterTracksCompressedDataType; // see above
4f82526d	143	static const AliHLTComponentDataType& ClusterTracksCompressedDataType();
29a647c6	144	/** track cluster ids data type */
29a647c6	145	static const AliHLTComponentDataType& ClusterIdTracksDataType();
9c559c4d	146	/** compressed cluster ids data type */
9c559c4d	147	static const AliHLTComponentDataType& CompressedClusterIdDataType();
ff2f0f94	148	/** remaining clusters compressed data type */
ff2f0f94	149	static const AliHLTComponentDataType fgkRemainingClustersCompressedDataType; // see above
4f82526d	150	static const AliHLTComponentDataType& RemainingClustersCompressedDataType();
29a647c6	151	/** remaining clusters ids data type */
29a647c6	152	static const AliHLTComponentDataType& RemainingClusterIdsDataType();
ff2f0f94	153
ff2f0f94	154	// Calibration data
02d01bbf	155	/** pedestal calibration data */
d3dbc486	156	static const AliHLTComponentDataType& CalibPedestalDataType();
02d01bbf	157	/** signal calibration data */
d3dbc486	158	static const AliHLTComponentDataType& CalibPulserDataType();
28355ac2	159	/** central electrode calibration data */
d3dbc486	160	static const AliHLTComponentDataType& CalibCEDataType();
71d7c760	161
e642ae99	162	// offline calbration components
	163
	164	/** alignment calibration data */
d3dbc486	165	static const AliHLTComponentDataType& OfflineCalibAlignDataType();
e642ae99	166	/** track calibration data */
d3dbc486	167	static const AliHLTComponentDataType& OfflineCalibTracksDataType();
e642ae99	168	/** gain calibration data */
d3dbc486	169	static const AliHLTComponentDataType& OfflineCalibTracksGainDataType();
deba5d85	170	/** cluster monte carlo information */
deba5d85	171	static const AliHLTComponentDataType fgkAliHLTDataTypeClusterMCInfo; // see above
4f82526d	172	static const AliHLTComponentDataType& AliHLTDataTypeClusterMCInfo();
e642ae99	173
71300445	174	// ids for the different parameters of a cluster
	175	enum AliClusterParameterId_t {
	176	kPadRow = 0,
	177	kPad,
	178	kTime,
	179	kSigmaY2,
	180	kSigmaZ2,
	181	kCharge,
	182	kQMax,
b97434b7	183	kResidualPad,
b97434b7	184	kResidualTime,
b97434b7	185	kClusterCount,
71300445	186	kLast = kQMax
	187	};
	188
	189	// helper struct for the definition of cluster parameters
	190	struct AliClusterParameter {
	191	AliClusterParameterId_t fId; //! id of the parameter
	192	const char* fName; //! name of the parameter
	193	int fBitLength; //! bit length
	194	int fOptional; //! optional parameter
	195	int fScale; //! scale for conversion to int number
	196	};
	197
	198	static const AliClusterParameter fgkClusterParameterDefinitions[];
	199	static unsigned GetNumberOfClusterParameterDefinitions();
b97434b7	200	static const unsigned fgkMaxClusterDeltaPad;
	201	static unsigned GetMaxClusterDeltaPad() {return fgkMaxClusterDeltaPad;}
	202	static const unsigned fgkMaxClusterDeltaTime;
	203	static unsigned GetMaxClusterDeltaTime() {return fgkMaxClusterDeltaTime;}
71300445	204
625b072f	205	private:
	206
	207	/// Do not allow creation of this class since everything is static.
	208	AliHLTTPCDefinitions();
	209	virtual ~AliHLTTPCDefinitions();
	210
	211	ClassDef(AliHLTTPCDefinitions, 0) // Useful static definitions and methods for TPC
96bda103	212	};
71d7c760	213
71d7c760	214	#endif