HLT/TPCLib/AliHLTTPCDigitReaderRaw.h

   1 // XEmacs -*-C++-*-
   2 // @(#) $Id$
   3
   4 #ifndef ALIHLTTPCDIGITREADERRAW_H
   5 #define ALIHLTTPCDIGITREADERRAW_H
   6
   7 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   8  * See cxx source for full Copyright notice                               */
   9
  10 /** @file   AliHLTTPCDigitReaderRaw.h
  11     @author Timm Steinbeck, Jochen Thaeder, Matthias Richter
  12     @date
  13     @brief  A digit reader implementation for the RAW data coming from the RCU.
  14 */
  15
  16 #include "TObject.h"
  17
  18 #include "AliHLTTPCDigitReader.h"
  19 #include "AliHLTDataTypes.h"
  20
  21 /**
  22  * @class AliHLTTPCDigitReaderRaw
  23  * A digit reader implementation for the RAW data coming from the RCU.
  24  * The reader decodes the data package to the level of the ALtro 10 bit words.
  25  *
  26  * The reader supports the following data format modes:
  27  *  - 0: RCU Data format as delivered during TPC commissioning, pads/padrows
  28  *    are sorted, RCU trailer is one 32 bit word.
  29  *  - 1: As 0, but pads/padrows are delivered "as is", without sorting
  30  *  - 2: As 0, but RCU trailer is 3 32 bit words.
  31  *  - 3: As 1, but RCU trailer is 3 32 bit words.
  32  *  - 4: As 0, but RCU trailer is 2 32 bit words.
  33  *  - 5: As 1, but RCU trailer is 2 32 bit words.
  34  * @ingroup alihlt_tpc
  35  */
  36 class AliHLTTPCDigitReaderRaw : public AliHLTTPCDigitReader  {
  37 public:
  38
  39   /** decode mode of the reader */
  40   enum RawReaderMode {
  41     /** 0: RCU Data format as delivered during TPC commissioning, pads/padrows
  42      *  are sorted, RCU trailer is one 32 bit word. */
  43     kSorted1Trailerword=0,
  44     /** 1: As 0, but pads/padrows are delivered "as is", without sorting */
  45     kUnsorted1Trailerword,
  46     /** 2: As 0, but RCU trailer is 3 32 bit words. */
  47     kSorted3Trailerword,
  48     /** 3: As 1, but RCU trailer is 3 32 bit words. */
  49     kUnsorted3Trailerword,
  50     /** 4: As 0, but RCU trailer is 2 32 bit words. */
  51     kSorted2Trailerword,
  52     /** 5: As 1, but RCU trailer is 2 32 bit words. */
  53     kUnsorted2Trailerword,
  54     /** number of modes */
  55     kNofRawReaderModes
  56   };
  57
  58   /** standard constructor
  59    * @param formatVersion  Data Format version numbers:
  60    *  - 0: RCU Data format as delivered during TPC commissioning, pads/padrows
  61    *    are sorted, RCU trailer is one 32 bit word.
  62    *  - 1: As 0, but pads/padrows are delivered "as is", without sorting
  63    *  - 2: As 0, but RCU trailer is 3 32 bit words.
  64    *  - 3: As 1, but RCU trailer is 3 32 bit words.
  65    *  - 4: As 0, but RCU trailer is 2 32 bit words.
  66    *  - 5: As 1, but RCU trailer is 2 32 bit words.
  67    */
  68   AliHLTTPCDigitReaderRaw( unsigned formatVersion );
  69   /** destructor */
  70   virtual ~AliHLTTPCDigitReaderRaw();
  71
  72   /**
  73    * Init the reader with a data block.
  74    * The function fetches the first and last row for the readout partition
  75    * from @ref AliHLTTPCTransform.
  76    * @param ptr     pointer to data buffer
  77    * @param size    size of the data buffer
  78    * @param patch   patch (readout partition) number within the slice
  79    * @param slice   sector no (0 to 35)
  80    */
  81   virtual int InitBlock(void* ptr,unsigned long size, Int_t patch, Int_t slice);
  82
  83   /**
  84    * Old Init function.
  85    * <b>Note:</b> This method is for backward compatibility only, not for further
  86    * use. The <i>firstrow</i> and <i>lastrow</i> parameters are fetched from
  87    * @ref AliHLTTPCTransform. The method is implemented in the raw reader base class
  88    * but is defined here to keep the signature of the library interface.
  89    *
  90    * @param ptr       pointer to data buffer
  91    * @param size      size of the data buffer
  92    * @param firstrow  first row occuring in the data
  93    * @param lastrow   last row occuring in the data
  94    * @param patch     patch (readout partition) number within the slice
  95    * @param slice     sector no (0 to 35)
  96    */
  97   int InitBlock(void* ptr,unsigned long size,Int_t firstrow,Int_t lastrow, Int_t patch, Int_t slice);
  98
  99   // Deliver values sorted for format 0, otherwise pass through to corresponding *Real* method
 100   virtual bool NextSignal();
 101   virtual int GetRow();
 102   virtual int GetPad();
 103   virtual int GetSignal();
 104   virtual int GetTime();
 105
 106   bool Verify( bool verify )
 107   {
 108     bool old = fVerify;
 109     fVerify=verify;
 110     return old;
 111   }
 112
 113   bool GetVerify() const
 114   {
 115     return fVerify;
 116   }
 117
 118   //
 119   // Deliver values unsorted
 120   //
 121   /** unsorted next value */
 122   bool RealNext();
 123   /** row of current value */
 124   int GetRealRow() const;
 125   /** pad of current value */
 126   int GetRealPad() const;
 127   /** signal of current value */
 128   int GetRealSignal();
 129   /** time of current value */
 130   int GetRealTime() const;
 131
 132   //
 133   // Low level methods for accessing the data
 134   //
 135   /** get rcu trailer word of the raw data */
 136   AliHLTUInt32_t GetRCUTrailer( unsigned offset=0 ) const;
 137
 138   /** move to next altro block and set internal variables */
 139   bool NextAltroBlock();
 140
 141   /** hardware address of the current altro block */
 142   AliHLTUInt32_t GetAltroBlockHWaddr() const;
 143
 144   /** get no of 10bit words in the current altro block */
 145   unsigned GetAltroBlock10BitWordCnt() const;
 146
 147   /** ndx counts from end, 0 is last */
 148   AliHLTUInt64_t GetAltroBlock40BitWord( unsigned long ndx ) const;
 149
 150   /** ndx counts from end, 0 is last */
 151   AliHLTUInt16_t GetAltroBlock10BitWord( unsigned long ndx );
 152
 153   /** ndx counts from end, 0 is last */
 154   AliHLTUInt16_t GetAltroBlockReal10BitWord( unsigned long ndx );
 155
 156     unsigned GetAltroBlockPositionBytes() const
 157         {return fAltroBlockPositionBytes;}
 158     unsigned GetAltroBlockLengthBytes() const
 159         {return fAltroBlockLengthBytes;}
 160
 161     /** Return length of trailing RCU data block in bytes */
 162     unsigned GetRCUDataBlockLength() const;
 163     unsigned GetCommonDataHeaderSize() const;
 164
 165     Bool_t ApplyMapping();
 166
 167   Int_t GetRow( unsigned patch, unsigned hwAddr );
 168   Int_t GetPad( unsigned patch, unsigned hwAddr );
 169   unsigned GetMaxHWA( unsigned patch ) const;
 170
 171   /**
 172    * This function decodes the rawreadermode set in HLT***Components
 173    * or the AliHLTGUI and returns the integer value of @ref RawReaderMode.
 174    * @param mode const Char_t * argument <br>
 175    *    sorted_3_trailerword -> @ref kSorted3Trailerword <br>
 176    *    sorted_2_trailerword -> @ref kSorted2Trailerword <br>
 177    *    sorted_1_trailerword -> @ref kSorted1Trailerword <br>
 178    *    unsorted_3_trailerword -> @ref kUnsorted3Trailerword <br>
 179    *    unsorted_2_trailerword -> @ref kUnsorted2Trailerword <br>
 180    *    unsorted_1_trailerword -> @ref kUnsorted1Trailerword <br>
 181    * @return rawreadermode @ref RawReaderMode and -1 if decoding fails
 182    */
 183   static Int_t DecodeMode(const Char_t *mode);
 184
 185   /**
 186    * This function sets the rawreadermode from an enum.
 187    * The name was chosen in order to use the two methods with either
 188    * a Char_t array or an Int_t.
 189    * @param mode mode enum @ref RawReaderMode
 190    * @return rawreadermode @ref RawReaderMode and -1 if decoding fails
 191    */
 192   static Int_t DecodeMode(Int_t mode);
 193
 194 protected:
 195
 196   /** the raw data buffer (external buffer) */
 197   AliHLTUInt8_t* fBuffer;                                          //! transient
 198   /** size of the raw data buffer */
 199   unsigned long fBufferSize;                                       // see above
 200     /*
 201     Int_t fFirstRow;
 202     Int_t fLastRow;
 203     */
 204
 205   /** patch (readout partition) specification of the raw data buffer */
 206   Int_t fPatch;                                                    // see above
 207
 208   /** slice (sector) specification of the raw data buffer */
 209   Int_t fSlice;                                                    // see above
 210
 211   /** the current row no */
 212   Int_t fRow;                                                      // see above
 213
 214   /** the current pad no */
 215   Int_t fPad;                                                      // see above
 216
 217
 218   /** position of the current ALTRO block*/
 219   unsigned fAltroBlockPositionBytes;                               // see above
 220
 221   /** length of the current ALTRO block*/
 222   unsigned fAltroBlockLengthBytes;                                 // see above
 223
 224   /** hardware of the current ALTRO block*/
 225   AliHLTUInt16_t fAltroBlockHWAddress;                             // see above
 226
 227   /** no of 10 bit words in the current ALTRO block*/
 228   AliHLTUInt16_t fAltroBlock10BitWordCnt;                          // see above
 229
 230   /** no of additional 10 bit fill words in the current ALTRO block*/
 231   AliHLTUInt16_t fAltroBlock10BitFillWordCnt;                      // see above
 232
 233   /** version of data format */
 234   unsigned fDataFormatVersion;                                     // see above
 235
 236   /** position of the current bunch of timebins */
 237   unsigned fBunchPosition;                                         // see above
 238   /** first timebin of current bunch */
 239   unsigned fBunchTimebinStart;                                     // see above
 240   /** length of current bunch */
 241   unsigned fBunchLength;                                           // see above
 242   /** word counter in bunch */
 243   unsigned fWordInBunch;                                           // see above
 244
 245   /** verify the consistency of the Altro blocks */
 246   bool fVerify;                                                    // see above
 247
 248 private:
 249   /** copy constructor prohibited */
 250   AliHLTTPCDigitReaderRaw(const AliHLTTPCDigitReaderRaw& src);
 251   /** assignment operator prohibited */
 252   AliHLTTPCDigitReaderRaw& operator=(const AliHLTTPCDigitReaderRaw& src);
 253   /** number of patches */
 254   static const Int_t fgkNofPatches=6;                              // see above
 255   /** dimension of each mapping array */
 256   static const Int_t fgkMappingDimension=2;                        // see above
 257
 258   /** size of mapping arrays */
 259   static const Int_t fgkMapping0Size=3200;                         // see above
 260   /** size of mapping array for patch 1 */
 261   static const Int_t fgkMapping1Size=3584;                         // see above
 262   /** size of mapping array for patch 2 */
 263   static const Int_t fgkMapping2Size=3200;                         // see above
 264   /** size of mapping array for patch 3 */
 265   static const Int_t fgkMapping3Size=3328;                         // see above
 266   /** size of mapping array for patch 4 */
 267   static const Int_t fgkMapping4Size=3328;                         // see above
 268   /** size of mapping array for patch 5 */
 269   static const Int_t fgkMapping5Size=3328;                         // see above
 270
 271   /** mapping array for patch 0 */
 272   static Int_t fgMapping0[fgkMapping0Size][fgkMappingDimension];   // see above
 273   /** mapping array for patch 1 */
 274   static Int_t fgMapping1[fgkMapping1Size][fgkMappingDimension];   // see above
 275   /** mapping array for patch 2 */
 276   static Int_t fgMapping2[fgkMapping2Size][fgkMappingDimension];   // see above
 277   /** mapping array for patch 3 */
 278   static Int_t fgMapping3[fgkMapping3Size][fgkMappingDimension];   // see above
 279   /** mapping array for patch 4 */
 280   static Int_t fgMapping4[fgkMapping4Size][fgkMappingDimension];   // see above
 281   /** mapping array for patch 5 */
 282   static Int_t fgMapping5[fgkMapping5Size][fgkMappingDimension];   // see above
 283
 284   static unsigned fgMaxHWA[fgkNofPatches];                         // see above
 285
 286   // For reordering
 287   /** current row */
 288   Int_t fCurrentRow;                                               // see above
 289   /** current pad */
 290   Int_t fCurrentPad;                                               // see above
 291   /** current bin */
 292   Int_t fCurrentBin;                                               // see above
 293
 294   /** ofsset of the first row */
 295   Int_t fRowOffset;                                                // see above
 296   /** nimber of rows */
 297   Int_t fNRows;                                                    // see above
 298
 299   /** max number of rows */
 300   Int_t fNMaxRows;                                                 // see above
 301   /** max number of pads */
 302   Int_t fNMaxPads;                                                 // see above
 303   /** number of time bins */
 304   Int_t fNTimeBins;                                                // see above
 305
 306   Int_t *fData;                                                    //! transient
 307
 308   /** indicate a virgin object and throw the warnig only once */
 309   Int_t fMapErrThrown;                                             //! transient
 310
 311   ClassDef(AliHLTTPCDigitReaderRaw, 1)
 312
 313 };
 314
 315 #endif