Updated SNM Glauber fit
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCDefinitions.h
1 // XEmacs -*-C++-*-
2 // @(#) $Id$
3
4 #ifndef ALIHLTTPCDEFINITIONS_H
5 #define ALIHLTTPCDEFINITIONS_H
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 #include "AliHLTDataTypes.h"
11 #include "Rtypes.h"
12
13 /**
14  * @class AliHLTTPCDefinitions
15  * Data type definitions for the libAliHLTTPC library.
16  * 
17  * @ingroup alihlt_tpc
18  */
19 class AliHLTTPCDefinitions
20 {
21 public:
22
23         static AliHLTUInt8_t GetMinSliceNr( const AliHLTComponentBlockData& block )
24                 {
25                 return (AliHLTUInt8_t)( (block.fSpecification & 0x00FF0000) >> 16 );
26                 }
27         static AliHLTUInt8_t GetMinSliceNr( ULong_t spec )
28                 {
29                 return (AliHLTUInt8_t)( (spec & 0x00FF0000) >> 16 );
30                 }
31         static AliHLTUInt8_t GetMaxSliceNr( const AliHLTComponentBlockData& block )
32                 {
33                 return (AliHLTUInt8_t)( (block.fSpecification & 0xFF000000) >> 24 );
34                 }
35         static AliHLTUInt8_t GetMaxSliceNr( ULong_t spec )
36                 {
37                 return (AliHLTUInt8_t)( (spec & 0xFF000000) >> 24 );
38                 }
39         static Int_t GetSingleSliceNr( const AliHLTComponentBlockData& block )
40                 {
41                 return GetSingleSliceNr(block.fSpecification);
42                 }
43         static Int_t GetSingleSliceNr( ULong_t spec );
44         static AliHLTUInt8_t GetMinPatchNr( const AliHLTComponentBlockData& block )
45                 {
46                 return (AliHLTUInt8_t)( (block.fSpecification & 0x000000FF) );
47                 }
48         static AliHLTUInt8_t GetMinPatchNr( ULong_t spec )
49                 {
50                 return (AliHLTUInt8_t)( (spec & 0x000000FF) );
51                 }
52         static AliHLTUInt8_t GetMaxPatchNr( const AliHLTComponentBlockData& block )
53                 {
54                 return (AliHLTUInt8_t)( (block.fSpecification & 0x0000FF00) >> 8 );
55                 }
56         static AliHLTUInt8_t GetMaxPatchNr( ULong_t spec )
57                 {
58                 return (AliHLTUInt8_t)( (spec & 0x0000FF00) >> 8 );
59                 }
60         static Int_t GetSinglePatchNr( const AliHLTComponentBlockData& block )
61                 {
62                 return GetSinglePatchNr(block.fSpecification);
63                 }
64         static Int_t GetSinglePatchNr( ULong_t spec );
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                 }
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 + 4*slice + patch - 2 : 2*slice + patch);
85                 }
86                 
87         /**
88          * Converts a DDL ID number for the TPC to a slice and patch number.
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].
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);
96
97   /** DDL entropy encoded data */
98   static const AliHLTComponentDataType fgkDDLEncodedEntropyRawDataType; // see above
99   static const AliHLTComponentDataType& DDLEncodedEntropyRawDataType();
100   /** packed RAW data */
101   static const AliHLTComponentDataType fgkPackedRawDataType;            // see above
102   static const AliHLTComponentDataType& PackedRawDataType();
103   /** unpacked RAW data */
104   static const AliHLTComponentDataType fgkUnpackedRawDataType;          // see above
105   static const AliHLTComponentDataType& UnpackedRawDataType();
106   /** cluster data */
107   static const AliHLTComponentDataType fgkClustersDataType;             // see above
108   static const AliHLTComponentDataType& ClustersDataType();
109   /** raw cluster data (not transformed) */
110   static const AliHLTComponentDataType fgkRawClustersDataType;          // see above
111   static const AliHLTComponentDataType& RawClustersDataType();
112   /** raw cluster data descriptor*/
113   static const AliHLTComponentDataType fgkRawClustersDescriptorDataType;          // see above
114   static const AliHLTComponentDataType& RawClustersDescriptorDataType();
115   /** HW cluster data */
116   static const AliHLTComponentDataType fgkHWClustersDataType;           // see above
117   static const AliHLTComponentDataType& HWClustersDataType();
118   /** HW alternative output cluster data */
119   static const AliHLTComponentDataType fgkAlterClustersDataType;        // see above
120   static const AliHLTComponentDataType& AlterClustersDataType();
121   /** track segments in local coordinates */
122   static const AliHLTComponentDataType fgkTrackSegmentsDataType;        // see above
123   static const AliHLTComponentDataType& TrackSegmentsDataType();
124   /** tracks in global koordinates */
125   static const AliHLTComponentDataType fgkTracksDataType;               // see above
126   static const AliHLTComponentDataType& TracksDataType();
127   /** vertex data structure */
128   static const AliHLTComponentDataType fgkVertexDataType;               // see above
129   static const AliHLTComponentDataType& VertexDataType();
130
131   // Cluster & Tracks model data
132   /** data compression descriptor*/
133   static const AliHLTComponentDataType fgkDataCompressionDescriptorDataType;          // see above
134   static const AliHLTComponentDataType& DataCompressionDescriptorDataType();
135   /** cluster tracks model data type */
136   static const AliHLTComponentDataType fgkClusterTracksModelDataType;          // see above
137   static const AliHLTComponentDataType& ClusterTracksModelDataType();
138   /** remaining clusters model data type */
139   static const AliHLTComponentDataType fgkRemainingClustersModelDataType;      // see above
140   static const AliHLTComponentDataType& RemainingClustersModelDataType();
141   /** track clusters compressed data type */
142   static const AliHLTComponentDataType fgkClusterTracksCompressedDataType;     // see above
143   static const AliHLTComponentDataType& ClusterTracksCompressedDataType();
144   /** track cluster ids data type */
145   static const AliHLTComponentDataType& ClusterIdTracksDataType();
146   /** compressed cluster ids data type */
147   static const AliHLTComponentDataType& CompressedClusterIdDataType();
148   /** remaining clusters compressed data type */
149   static const AliHLTComponentDataType fgkRemainingClustersCompressedDataType; // see above
150   static const AliHLTComponentDataType& RemainingClustersCompressedDataType();
151   /** remaining clusters ids data type */
152   static const AliHLTComponentDataType& RemainingClusterIdsDataType();
153
154   // Calibration data
155   /** pedestal calibration data */
156   static const AliHLTComponentDataType& CalibPedestalDataType();
157   /** signal calibration data */
158   static const AliHLTComponentDataType& CalibPulserDataType();
159   /** central electrode calibration data */
160   static const AliHLTComponentDataType& CalibCEDataType();
161
162   // offline calbration components
163
164   /** alignment calibration data */
165   static const AliHLTComponentDataType& OfflineCalibAlignDataType();
166   /** track calibration data */
167   static const AliHLTComponentDataType& OfflineCalibTracksDataType();
168   /** gain calibration data */
169   static const AliHLTComponentDataType& OfflineCalibTracksGainDataType();
170   /** cluster monte carlo information */
171   static const AliHLTComponentDataType fgkAliHLTDataTypeClusterMCInfo;    // see above
172   static const AliHLTComponentDataType& AliHLTDataTypeClusterMCInfo();
173
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,
183     kResidualPad,
184     kResidualTime,
185     kClusterCount,
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();
200   static const unsigned fgkMaxClusterDeltaPad;
201   static unsigned GetMaxClusterDeltaPad() {return fgkMaxClusterDeltaPad;}
202   static const unsigned fgkMaxClusterDeltaTime;
203   static unsigned GetMaxClusterDeltaTime() {return fgkMaxClusterDeltaTime;}
204
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
212 };
213
214 #endif