]> git.uio.no Git - u/mrichter/AliRoot.git/blob - TRD/AliTRDRawStreamTB.h
Splitted calibration object -> PARAMETERS FOR CENTRALITY RECONSTRUCTION
[u/mrichter/AliRoot.git] / TRD / AliTRDRawStreamTB.h
1 #ifndef ALITRDRAWSTREAMTB_H
2 #define ALITRDRAWSTREAMTB_H
3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4  * See cxx source for full Copyright notice                               */
5
6 /* $Id$ */
7
8 ///////////////////////////////////////////////////////////////////////////////
9 //                                                                           //
10 // This class provides access to TRD digits in raw data.                     //
11 //                                                                           //
12 ///////////////////////////////////////////////////////////////////////////////
13
14 #include <TObject.h>
15
16 class AliTRDgeometry;
17 class AliRawReader;
18 class AliTRDdigitsManager;
19
20 namespace AliTRDrawDataUtilsTB
21 {
22   //--------------------------------------------------------
23   // Some constants:
24   //static const UInt_t kEndoftrackletmarker = 0xAAAAAAAA; /*This marks the end of tracklet data words*/
25   //static const UInt_t kEndOfTrackletMarker = 0x10001000; /*This marks the end of tracklet data words*/
26   static const UInt_t kEndOfTrackletMarker = 0xaaaaaaaa; /*This marks the end of tracklet data words*/
27   //static const UInt_t kEndofrawdatamarker  = 0x00000000; /*This marks the end of half-chamber-data*/
28   static const UInt_t kEndOfRawDataMarker  = 0x00000000; /*This marks the end of half-chamber-data*/
29   static const UInt_t kSizeWord = sizeof(UInt_t); // size of a word in bytes
30
31   //--------------------------------------------------------
32   // SM index word masks
33   static const UInt_t skSMheaderSizeBits = 0xffff0000;
34   static const UInt_t skTrackletsEnableBits = 0x1 << 5;
35   static const UInt_t skStackMasksBits = 0x1f;
36
37   static UInt_t GetSMheaderSize(UInt_t *word)
38   {
39     return (*word & skSMheaderSizeBits) >> 16;
40   }
41
42   static UInt_t GetTrackletEnable(UInt_t *word)
43   {
44     return (*word & skTrackletsEnableBits) >> 5;    
45   }
46   
47   static UInt_t GetStackMask(UInt_t *word)
48   {
49     return (*word & skStackMasksBits);    
50   }
51
52 /*   static UInt_t GetStackStatus(UInt_t *word, Int_t istack) */
53 /*   { */
54 /*     return (*word & (0x1 << istack)); */
55 /*   } */
56
57   //--------------------------------------------------------
58   struct AliTRDrawSMinfo
59   {
60     UInt_t fHeaderSize;
61     Bool_t fTrackletEnable;
62     Bool_t fStackActive[5];
63     Int_t  fActiveStacks;
64
65     void Decode(UInt_t *word)
66     {
67       fHeaderSize = GetSMheaderSize(word);
68
69       if (GetTrackletEnable(word) > 0)
70         fTrackletEnable = kTRUE;
71       else
72         fTrackletEnable = kFALSE;
73
74       UInt_t stackMask = GetStackMask(word);
75       fActiveStacks = 0;
76       for (Int_t i = 0; i < 5; i++)
77         {
78           //if (stackMask & (0x1 << i) > 0)
79           if ((stackMask >> i) & 0x1 > 0)
80             {
81               fStackActive[i] = kTRUE;
82               fActiveStacks++;
83             }
84           else
85             {
86               fStackActive[i] = kFALSE;
87             }
88         }
89     }
90     
91     void Dump()
92     {
93       printf("[I] SM Info is : Hsize %d TrackletEnable %d Stacks %d %d %d %d %d\n",
94              fHeaderSize, fTrackletEnable, 
95              fStackActive[0], fStackActive[1], fStackActive[2], 
96              fStackActive[3], fStackActive[4]); 
97       
98     }
99   };
100
101   //--------------------------------------------------------
102   // Stack word masks
103   static const UInt_t skStackHeaderSizeBits = 0xffff0000;
104   static const UInt_t skStackLinkMaskBits = 0xfff;
105
106   static UInt_t GetStackHeaderSize(UInt_t *word)
107     {
108       return (*word & skStackHeaderSizeBits) >> 16;
109     }
110
111   static UInt_t GetStackLinkWord(UInt_t *word)
112     {
113       return (*word & skStackLinkMaskBits);
114     }
115
116   static UInt_t GetStackHeaderSizeBug(UInt_t *word)
117     {
118       return (*word & 0x0000ffff);
119     }
120
121   static UInt_t GetStackLinkWordBug(UInt_t *word)
122     {
123       return (*word & 0x0fff) >> 16;
124     }
125
126   struct AliTRDrawStackInfo
127   {
128     UInt_t fHeaderSize;
129     Bool_t fLinksActive[12];
130     Int_t  fActiveLinks;
131
132     void Decode(UInt_t *word)
133     {
134       fHeaderSize = GetStackHeaderSize(word);
135
136       UInt_t linkMask = GetStackLinkWord(word);
137       fActiveLinks = 0;
138       for (Int_t i = 0; i < 12; i++)
139         {
140           if (linkMask & (0x1 << i) > 0)
141             {
142               fLinksActive[i] = kTRUE;
143               fActiveLinks++;
144             }
145           else
146             {
147               fLinksActive[i] = kFALSE;
148             }
149         }
150     }
151
152     void DecodeBug(UInt_t *word)
153     {
154       fHeaderSize = GetStackHeaderSizeBug(word);
155
156       UInt_t linkMask = GetStackLinkWordBug(word);
157       for (Int_t i = 0; i < 12; i++)
158         {
159           if (linkMask & (0x1 << i) > 0)
160             fLinksActive[i] = kTRUE;
161           else
162             fLinksActive[i] = kFALSE;
163         }
164     }
165     
166     void Dump()
167       {
168         printf("[I] Stack Info is : Hsize %d Links Active %d %d %d %d %d %d %d %d %d %d %d %d\n",
169                fHeaderSize,
170                fLinksActive[0], fLinksActive[1], fLinksActive[2], fLinksActive[3], 
171                fLinksActive[4], fLinksActive[5], fLinksActive[6], fLinksActive[7], 
172                fLinksActive[8], fLinksActive[9], fLinksActive[10], fLinksActive[11]);
173       }
174   };
175
176   //--------------------------------------------------------
177   // HC word masks
178   // word 0
179   static const UInt_t skSpecialRawVBits = 0x1 << 31;
180   static const UInt_t skRawVMajorBits = 0x7f << 24;
181   static const UInt_t skRawVMinorBits = 0x7f << 17;
182   static const UInt_t skHCExtraWordsBits = 0x7 << 14;
183   static const UInt_t skHCSMBits = 0x1f << 9;
184   static const UInt_t skHCLayerBits = 0x7 << 6;
185   static const UInt_t skHCStackBits = 0x7 << 3;
186   static const UInt_t skHCSideBits = 0x1 << 2;
187
188   static const UInt_t skDCSBoardBits = 0xfff << 20;
189
190   static UInt_t GetSpecialRawV(UInt_t *word)
191     {
192       return (*word & skSpecialRawVBits) >> 31;
193     }
194
195   static UInt_t GetRawVMajor(UInt_t *word)
196     {
197       return (*word & skRawVMajorBits) >> 24;
198     }
199
200   static UInt_t GetRawVMinor(UInt_t *word)
201     {
202       return (*word & skRawVMinorBits) >> 31;
203     }
204
205   static UInt_t GetDCSBoard(UInt_t *word)
206     {
207       return (*word & skDCSBoardBits) >> 20;
208     }
209
210   static UInt_t GetSM(UInt_t *word)
211     {
212       return (*word & skHCSMBits) >> 9;
213     }
214
215   static UInt_t GetStack(UInt_t *word)
216     {
217       return (*word & skHCStackBits) >> 3;
218     }
219
220   static UInt_t GetLayer(UInt_t *word)
221     {
222       return (*word & skHCLayerBits) >> 6;
223     }
224
225   static UInt_t GetSide(UInt_t *word)
226     {
227       return (*word & skHCSideBits) >> 2;
228     }
229
230   static UInt_t GetExtraWords(UInt_t *word)
231     {
232       return (*word & skHCExtraWordsBits) >> 14;
233       //fHCHWords = (*fDataWord >> 14) & 0x7;
234     }
235
236   // word 1
237   //static const UInt_t skTimeBinsBits = 0xfc << 26;
238   static const UInt_t skTimeBinsBits = 0x3f << 26;
239   static const UInt_t skBunchCrossCounterBits = 0xffff << 10;
240   static const UInt_t skPreTriggerCounterBits = 0xf << 6;
241   static const UInt_t skPreTriggerPhase = 0xf << 2;
242   
243   static UInt_t GetTimeBins(UInt_t *word)
244     {
245       return (*word & skTimeBinsBits) >> 26;
246     }
247
248   static UInt_t GetBunchCrossCounter(UInt_t *word)
249     {
250       return (*word & skBunchCrossCounterBits) >> 10;
251     }
252
253   static UInt_t GetPreTriggerCounter(UInt_t *word)
254     {
255       return (*word & skPreTriggerCounterBits) >> 6;
256     }
257
258   static UInt_t GetPreTriggerPhase(UInt_t *word)
259     {
260       return (*word & skPreTriggerPhase) >> 2;
261     }
262
263   struct AliTRDrawHCInfo
264   {
265     UInt_t fSpecialRawV;
266     UInt_t fRawVMajor;
267     UInt_t fRawVMinor;
268     UInt_t fNExtraWords;
269     UInt_t fDCSboard;
270     UInt_t fSM;
271     UInt_t fStack;
272     UInt_t fLayer;
273     UInt_t fSide;
274
275 /*     fBCctr   =  (*fDataWord >> 16); */
276 /*     fPTctr   =  (*fDataWord >> 12) & 0xf; */
277 /*     fPTphase =  (*fDataWord >>  8) & 0xf; */
278 /*     fTBins   = ((*fDataWord >>  2) & 0x3f) + 1; */
279 /*     fTimeWords = (fTBins - 1)/3 + 1;  */
280
281     UInt_t fTimeBins;
282     UInt_t fBunchCrossCounter;
283     UInt_t fPreTriggerCounter;
284     UInt_t fPreTriggerPhase;
285
286     void DecodeH0(UInt_t *word)
287     {
288       fSpecialRawV = GetSpecialRawV(word);
289       fRawVMajor = GetRawVMajor(word);
290       fRawVMinor = GetRawVMinor(word);
291       fNExtraWords = GetExtraWords(word);
292       fDCSboard = GetDCSBoard(word);
293       fSM = GetSM(word);
294       fStack = GetStack(word);
295       fLayer = GetLayer(word);
296       fSide = GetSide(word);
297     }
298
299     void DecodeH1(UInt_t *word)
300     {
301       fTimeBins = GetTimeBins(word);
302       fBunchCrossCounter = GetBunchCrossCounter(word);
303       fPreTriggerCounter = GetPreTriggerCounter(word);
304       fPreTriggerPhase = GetPreTriggerPhase(word);
305     }
306
307     void Dump()
308     {
309 /*       printf("[I] HC Info is : DCSboard %d SM %d Stack %d Layer %d Side %d \n", */
310 /*           fDCSboard, fSM, fStack, fLayer, fSide);          */
311       printf("[I] HC Info is : RawV %d SM %d Stack %d Layer %d Side %d \n",
312              fRawVMajor, fSM, fStack, fLayer, fSide);        
313     }
314   };
315
316   //--------------------------------------------------------
317   // MCM word masks
318   static const UInt_t skROBBits = 0x70000000; // 0x7 << 28
319   static const UInt_t skMCMBits = 0x0f000000; // 0xf << 24
320   static const UInt_t skHCEvCounterBits = 0x00fffff0; //0x00fffff << 4
321
322   static UInt_t GetROB(UInt_t *word)
323     {
324       return (*word & skROBBits) >> 28;
325     }
326
327   static UInt_t GetMCM(UInt_t *word)
328     {
329       return (*word & skMCMBits) >> 24;
330     }
331
332   static UInt_t GetEvCounter(UInt_t *word)
333     {
334       return (*word & skHCEvCounterBits) >> 4;
335     }
336
337   struct AliTRDrawMCMInfo
338   {
339     UInt_t fROB;
340     UInt_t fMCM;
341     UInt_t fEvCounter;
342
343     void Decode(UInt_t *word)
344     {
345       fROB = GetROB(word);
346       fMCM = GetMCM(word);
347       fEvCounter = GetEvCounter(word);
348     }
349
350     void Dump()
351     {
352       printf("[I] MCM Info is : ROB %d MCM %d EvCounter %d\n", fROB, fMCM, fEvCounter);
353     }
354   };
355
356 }
357
358 class AliTRDRawStreamTB: public TObject {
359
360   public :
361
362     AliTRDRawStreamTB();
363     AliTRDRawStreamTB(AliRawReader *rawReader);
364     virtual ~AliTRDRawStreamTB();
365
366     virtual Bool_t       Next();              // Read the next data
367     virtual Int_t NextChamber(AliTRDdigitsManager *man); // read next chamber data
368     virtual Int_t        Init();              // Init for the fRawVersion > 1
369
370     enum { kDDLOffset = 0x400 };              // Offset for DDL numbers
371
372     Bool_t               SetRawVersion(Int_t rv);
373     Int_t                GetRawVersion() const                      { return fRawVersion;     };
374     void                 SetRawReader(AliRawReader *rawReader);
375
376     // Get Filter settings (does not make a lot of sense):
377     Int_t                TRAPfilterTCon() const                     { return fTCon;           };
378     Int_t                TRAPfilterPEDon() const                    { return fPEDon;          };
379     Int_t                TRAPfilterGAINon() const                   { return fGAINon;         };
380     Int_t                TRAPsendsUnfilteredData() const            { return fBypass;         };
381
382     // Get Tracklet parameters (does not make a lot of sense):
383     Float_t              GetTrackletPID() const                     { return fTracklPID;      };
384     Float_t              GetTrackletDeflLength() const              { return fTracklDefL;     };
385     Float_t              GetTrackletPadPos() const                  { return fTracklPadPos;   };
386     Int_t                GetTrackletPadRow() const                  { return fTracklPadRow;   };
387
388     // Check if the link has optical power (HC sends data)
389     Bool_t               IsGTULinkActive(Int_t sm, Int_t la, Int_t sta, Int_t side)
390       { return ( ((fGTUlinkMask[sm][sta]) >> (2*la+side)) & 0x1 ); };
391
392     static void SetStackIndexBug(Bool_t val) {fgStackIndexBug = val;}
393     static void SetForceRawVersion(Int_t val) {fgForceRawVersion = val;}
394     static void SupressWarnings(Bool_t val) {fgSupressWarnings = val;}
395     static void ExtraDebug(Bool_t val) {fgExtraDebug = val;}
396     static void RawBufferMissAligned(Bool_t val) {fgRawDataHack = val;}
397
398     Int_t *GetSignals() { return fSig;}                         //  Signals in the three time bins from Data Word
399     Int_t GetADC() const { return fADC;}                            //  MCM ADC channel and Time Bin of word 1
400     Int_t GetTimeBin() const { return fTB - 3;}                             //  MCM ADC channel and Time Bin of word 1
401     Int_t GetEventNumber() const { return fEv;}                             //  MCM Event number and position of current MCM on TRD chamber
402     Int_t GetROB() const { return fROB;}                            //  MCM Event number and position of current MCM on TRD chamber
403     Int_t GetMCM() const { return fMCM;}                           //  MCM Event number and position of current MCM on TRD chamber
404     Int_t GetSM() const { return fSM;}                             //  Position of CURRENT half chamber in full TRD
405     Int_t GetLayer() const { return fLAYER;}                          //  PLANE = Position of CURRENT half chamber in full TRD
406     Int_t GetStack() const { return fSTACK;}                          //  CHAMBER = Position of CURRENT half chamber in full TRD
407     Int_t GetROC() const { return fROC;}                            //  Position of CURRENT half chamber in full TRD
408     Int_t GetSide() const { return fSIDE;}                           //  Position of CURRENT half chamber in full TRD
409     Int_t GetDCS() const { return fDCS;}                            //  DCS board number read from data (HC header)
410     Int_t GetRow() const { return fROW;}
411     Int_t GetCol() const { return fCOL;}                            //  Detector Pad coordinates
412     Int_t GetDet() const { return fDET;} // helper
413     Int_t GetLastDet() const { return fLastDET;} // helper
414     Int_t GetMaxRow() const { return fRowMax;}
415     Int_t GetMaxCol() const { return fColMax;}
416     Int_t GetNumberOfTimeBins() const {return fTBins;}
417
418     Int_t  GetCommonAdditive() const {return fCommonAdditive;}
419     Bool_t IsCurrentPadShared() const {return fIsPadShared;}
420     void   SetSharedPadReadout(Bool_t fv) {fSharedPadsOn = fv;}
421     Bool_t IsDataZeroSuppressed() const {return fZeroSuppressed;}
422       
423   private :
424
425     Int_t    fSig[3];                         //  Signals in the three time bins from Data Word
426     Int_t    fADC;                            //  MCM ADC channel and Time Bin of word 1
427     Int_t    fMaxADCgeom;                     //  Max ADC number as returned by AliTRDgeometry::ADCmax()
428     Int_t    fTB;                             //  MCM ADC channel and Time Bin of word 1
429     Int_t    fEv;                             //  MCM Event number and position of current MCM on TRD chamber
430     Int_t    fROB;                            //  MCM Event number and position of current MCM on TRD chamber
431     Int_t    fMCM;                            //  MCM Event number and position of current MCM on TRD chamber
432     Int_t    fSM;                             //  Position of CURRENT half chamber in full TRD
433     Int_t    fLAYER;                          //  Position of CURRENT half chamber in full TRD
434     Int_t    fSTACK;                          //  Position of CURRENT half chamber in full TRD
435     Int_t    fROC;                            //  Position of CURRENT half chamber in full TRD
436     Int_t    fSIDE;                           //  Position of CURRENT half chamber in full TRD
437     Int_t    fDCS;                            //  DCS board number read from data (HC header)
438     Int_t    fROW;                            //  Detector Row coordinates
439     Int_t    fCOL;                            //  Detector Pad coordinates
440     Int_t    fDET;                            //  Current detector - version > 1
441     Int_t    fLastDET;                        //  Previous detector - version > 1
442
443     Int_t    fBCctr;                          //  Counters from HC header (>=V2)
444     Int_t    fPTctr;                          //  Counters from HC header (>=V2)
445     Int_t    fPTphase;                        //  Counters from HC header (>=V2)
446     Int_t    fRVmajor;                        //  Raw version numbers and number of additional HC headerwords (>=V2)
447     Int_t    fRVminor;                        //  Raw version numbers and number of additional HC headerwords (>=V2)
448     Int_t    fHCHWords;                       //  Raw version numbers and number of additional HC headerwords (>=V2)
449     Int_t    fTBins;                          //  Number of time bins read from HC header (>=V2)
450     Bool_t   fTCon;                           //  Filter settings read from HC header (>=V2)
451     Bool_t   fPEDon;                          //  Filter settings read from HC header (>=V2)
452     Bool_t   fGAINon;                         //  Filter settings read from HC header (>=V2)
453     Bool_t   fXTon;                           //  Filter settings read from HC header (>=V2)
454     Bool_t   fNonLinOn;                       //  Filter settings read from HC header (>=V2)
455     Bool_t   fBypass;                         //  Filter settings read from HC header (>=V2)
456     Int_t    fCommonAdditive;                 //  Common baseline additive read from HC header (>=V2)
457
458     Bool_t   fZeroSuppressed;                 // Data is zero suppressed
459
460     Int_t    fHCHctr1;                        //  HC and MCM Header counter
461     Int_t    fHCHctr2;                        //  HC and MCM Header counter
462     Int_t    fMCMHctr1;                       //  HC and MCM Header counter
463     Int_t    fMCMHctr2;                       //  HC and MCM Header counter
464     Int_t    fGTUctr1;                        //  GTU LinkMask Counter
465     Int_t    fGTUctr2;                        //  GTU LinkMask Counter
466     Int_t    fHCdataCtr;                      //  Data Counter for half chamber
467     
468     Float_t  fTracklPID;                      //  Tracklet parameters
469     Float_t  fTracklDefL;                     //  Tracklet parameters
470     Float_t  fTracklPadPos;                   //  Tracklet parameters
471     Int_t    fTracklPadRow;                   //  Tracklet parameters
472
473     UShort_t fGTUlinkMask[18][5];             //  Mask with active links
474
475     Int_t    fMCMWordCrt;                     //  Word Counter for a single MCM
476     Int_t    fMCMWordsExpected;                //  Expected Words from MCM 
477
478     AliTRDRawStreamTB(const AliTRDRawStreamTB &stream);
479     AliTRDRawStreamTB &operator=(const AliTRDRawStreamTB &stream);
480     void SwapOnEndian();
481
482     AliRawReader *fRawReader;              //  Object for reading the raw data
483
484     Int_t    fRawVersion;                  //  Which version of raw data decoding is used
485     Int_t    fRawDigitThreshold;           //  Naive "zero"(threshold) supression. Usefull for Raw Data ver 2.
486
487     Int_t    fNextStatus;                  //  Navigation in raw versions > 1
488     Int_t    fLastStatus;                  //  Navigation in raw versions > 1
489     UInt_t   fTbSwitch;                    //  Time Bin Switch for internal use
490     UInt_t   fTbSwitchCtr;                 //  Counter for internal use
491     UInt_t   fTimeWords;                   //  Number of Words needed to store the data of 1 ADC ch.
492     UInt_t   fWordCtr;                     //  Word Counter
493
494     Int_t    fRowMax;                      //  Maximum number of pad rows and columns
495     Int_t    fColMax;                      //  Maximum number of pad rows and columns
496
497     Bool_t   fADCmask[21];                 //  Mask of active ADCs for zero suppression
498     UInt_t   fLastADCmask;                 //  Last ADC read out
499
500     Int_t    fChamberDone[540];            //  Chamber was processed already (1=1HC, 2=full chamber)
501
502     Int_t    fRetVal;                      //  Datadecode return
503     Int_t    fEqID;                        //  Equipment id
504     UInt_t   fDataSize;                    //  Size of the data available in the current buffer
505     Bool_t   fSizeOK;                      //  Did we read anything
506     UInt_t   fCountBytes;                  //  Bytes traversed in the buffer
507     UInt_t   fBufSize;                     //  Size of the current RawReader buffer
508     Bool_t   fkBufferSet;                  //  Is the RawReader buffer available
509     UChar_t *fPos;                         //  Position in the buffer of the RawReader
510     UInt_t  *fDataWord;                    //  The pointer to the current 32 bit data word
511     UInt_t   fTimeBinsCalib;               //  N of time bins retrieved from calibration
512
513     Int_t    fADClookup[32];               //  Lookup for version 3 (1[entries]+1[index]+30[fADC channels] = 32)
514     Int_t    fNActiveADCs;                 //  Number of active ADC channels
515     Bool_t   fEndOfDataFlag;               //  End of data flag
516
517     AliTRDrawDataUtilsTB::AliTRDrawSMinfo    fSMinfo[18];            // Super module info
518     AliTRDrawDataUtilsTB::AliTRDrawStackInfo fStackInfo[18][5];      // Stack info
519     AliTRDrawDataUtilsTB::AliTRDrawHCInfo    fHCInfo;                // Half chamber info
520     AliTRDrawDataUtilsTB::AliTRDrawMCMInfo   fMCMInfo;               // MCM info
521
522     Int_t    fiSMx;                        //  Position of CURRENT half chamber in full TRD
523     static Bool_t   fgStackIndexBug;        //  Buggy index word flag
524
525     Bool_t   fSharedPadsOn;                // Should we return on shared pad readout
526     Bool_t   fIsPadShared;                 // Set if the current pad is shared
527     static Int_t   fgForceRawVersion;             // Force the raw version specified
528     static Bool_t  fgSupressWarnings;       // Superss warnings (raw data version and TB missmatch)
529     static Bool_t  fgExtraDebug;           // Extra info on the screen
530     static Bool_t  fgRawDataHack;          // skip 23 words - a hack for the DATE raw format
531     enum ETRDzRawStreamError {
532        kHCWordMissing = 1                  //
533       ,kMCMADCMaskMissing = 2              //
534       ,kWrongMCMorROB = 3                  //
535       ,kGTULinkMaskMissing = 4             //
536       ,kHCHeaderCorrupt = 5                //
537       ,kHCHeaderMissing = 6                //
538       ,kROBSideMismatch = 7                //
539       ,kWrongPadrow = 8                    //
540       ,kWrongPadcolumn = 9                 //
541       ,kTrackletRowMismatch = 10           //
542       ,kDataMaskError = 11                 //
543       ,kADCNumberOverflow = 12             //
544       ,kADCChannelOverflow = 13            //
545     };
546
547  protected:
548
549     AliTRDgeometry *fGeo;                  //  TRD geometry
550
551     Bool_t DecodeGTUlinkMask();
552     Bool_t DecodeADCWord();
553     Bool_t DecodeNextRawWord();
554     Bool_t DecodeMCM();
555     Bool_t DecodeHC();
556     Bool_t DecodeSM();
557     inline void  ChangeStatus(Int_t kstat);
558
559     void  DecodeHCheader(Int_t timeBins = 0);
560     void  DecodeMCMheader();
561     void  DecodeTracklet();
562
563     void  SetRawDigitThreshold (Int_t ith) {fRawDigitThreshold = ith;} // set the naive zero suppression threshold
564
565     Int_t NextData(); // get the next piece of memory
566     Int_t RewindWord(); //go back one word
567
568     Int_t ChannelsToRead(Int_t ADCmask); // Get the active ADC channels from the mask (V3 and 2)
569
570     Int_t SkipWords(UInt_t iw);
571     Int_t DecodeHeadingInfo();
572
573     enum { kStart
574          , kStop
575          , kWordOK
576          , kNoMoreData
577          , kNextSM
578          , kNextHC
579          , kSeekNonEoTracklet
580          , kDecodeHC
581          , kNextMCM
582          , kNextData
583          , kReading };
584     
585     ClassDef(AliTRDRawStreamTB, 1)               // Class for reading TRD raw digits
586
587 };
588 #endif