ba61480216030c4de355aa9ecc022acd59736aca
[u/mrichter/AliRoot.git] / TRD / AliTRDrawFastStream.cxx
1 /**************************************************************************\r
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
3 *                                                                        *\r
4 * Author: The ALICE Off-line Project.                                    *\r
5 * Contributors are mentioned in the code where appropriate.              *\r
6 *                                                                        *\r
7 * Permission to use, copy, modify and distribute this software and its   *\r
8 * documentation strictly for non-commercial purposes is hereby granted   *\r
9 * without fee, provided that the above copyright notice appears in all   *\r
10 * copies and that both the copyright notice and this permission notice   *\r
11 * appear in the supporting documentation. The authors make no claims     *\r
12 * about the suitability of this software for any purpose. It is          *\r
13 * provided "as is" without express or implied warranty.                  *\r
14 **************************************************************************/\r
15 \r
16 /* $Id: AliTRDrawFastStream.cxx 27797 2008-08-05 14:37:22Z cblume $ */\r
17 \r
18 ////////////////////////////////////////////////////////////////////////////////\r
19 //                                                                            //\r
20 // This class provides access to TRD digits in raw data in a way of streaming //\r
21 //                                                                            //\r
22 // It loops over all TRD digits in the raw data given by the AliRawReader.    //\r
23 // The Next method goes to the next digit. If there are no digits left        //\r
24 // it returns kFALSE.                                                         //\r
25 // Several getters provide information about the current digit.               //\r
26 //                                                                            //\r
27 // Author: M. Ploskon (ploskon@ikf.uni-frankfurt.de)                          //  \r
28 // Author: MinJung Kweon (minjung@physi.uni-heidelberg.de)                    //\r
29 //                                                                            //\r
30 ////////////////////////////////////////////////////////////////////////////////\r
31 \r
32 #include "TFile.h"\r
33 \r
34 #include "AliTRDrawFastStream.h"\r
35 #include "AliTRDgeometry.h"\r
36 #include "AliTRDfeeParam.h"\r
37 #include "AliTRDdigitsManager.h"\r
38 #include "AliTRDarrayDictionary.h"\r
39 #include "AliTRDarrayADC.h"\r
40 #include "AliTRDSignalIndex.h"\r
41 #include "AliTRDdigitsParam.h"\r
42 #include "AliTRDrawTPStream.h"\r
43 \r
44 #include "AliRawReader.h"\r
45 \r
46 #define END_OF_TRACKLET_MARKEROLD 0xaaaaaaaa\r
47 #define END_OF_TRACKLET_MARKERNEW 0x10001000\r
48 #define ENDOFRAWDATAMARKER 0x00000000\r
49 #define WORD_SIZE sizeof(UInt_t)           // size of a word in bytes\r
50 #define EXTRA_LEAD_WORDS 24\r
51 #define CDH_WORDS 8\r
52 \r
53 #define IS_BIT_SET(w,b) ( ((w) >> (b)) & 0x1 ) // 1 if bit b is set in word w\r
54 #define GET_VALUE_AT(w,m,s) (( (w) >> (s)) & (m) )      // get value of word w rshifted by s and mask with m\r
55 \r
56 // SM index word masks:\r
57 #define SM_HEADER_SIZE(w) GET_VALUE_AT(w,0xffff,16) \r
58 #define TRACKLETS_ENABLED(w) IS_BIT_SET(w,5)\r
59 #define STACK_MASK(w) ((w) & 0x1f)\r
60 \r
61 // Stack word masks\r
62 #define STACK_HEADER_SIZE(w) GET_VALUE_AT(w,0xffff,16)\r
63 #define STACK_LINK_WORD(w) ((w) & 0xfff)\r
64 #define LINK0_DATA_TYPE_FLAG(w) (GET_VALUE_AT(w,0x3,4) == (0x0) ? 0 : 1) // 0 if physics data\r
65 #define LINK1_DATA_TYPE_FLAG(w) (GET_VALUE_AT(w,0x3,20) == (0x0) ? 0 : 1) // 0 if physics data\r
66 #define LINK0_MONITOR_FLAG(w) (GET_VALUE_AT(w,0xf,0) == (0x0) ? 0 : 1) // 0 if OK\r
67 #define LINK1_MONITOR_FLAG(w) (GET_VALUE_AT(w,0xf,16) == (0x0) ? 0 : 1) // 0 if OK\r
68 \r
69 // HC word masks\r
70 //#define HC_HEADER_MASK_ERR(w) ( ((w) & (0x80000003)) == (0x80000001) ? 0 : 1) // 0 if OK!!!\r
71 #define HC_HEADER_MASK_ERR(w) ( ((w) & (0x3)) == (0x1) ? 0 : 1) // 0 if OK!!!\r
72 \r
73 // HC word 0\r
74 #define HC_SPECIAL_RAW_VERSION(w) IS_BIT_SET(w,31)\r
75 #define HC_MAJOR_RAW_VERSION(w) GET_VALUE_AT(w,0x7f,24)\r
76 #define HC_MAJOR_RAW_VERSION_OPT(w) GET_VALUE_AT(w,0x7,24)\r
77 #define HC_MINOR_RAW_VERSION(w) GET_VALUE_AT(w,0x7f,17)\r
78 #define HC_EXTRA_WORDS(w) GET_VALUE_AT(w,0x7,14)\r
79 #define HC_DCS_BOARD(w) GET_VALUE_AT(w,0xfff<<20,20)\r
80 #define HC_SM_NUMBER(w) GET_VALUE_AT(w,0x1f,9)\r
81 #define HC_LAYER_NUMBER(w) GET_VALUE_AT(w,0x7,6)\r
82 #define HC_STACK_NUMBER(w) GET_VALUE_AT(w,0x7,3)\r
83 #define HC_SIDE_NUMBER(w) IS_BIT_SET(w,2)\r
84 \r
85 // HC word 1\r
86 #define HC_NTIMEBINS(w) GET_VALUE_AT(w,0x3f,26)\r
87 #define HC_BUNCH_CROSS_COUNTER(w) GET_VALUE_AT(w,0xffff,10)\r
88 #define HC_PRETRIGGER_COUNTER(w) GET_VALUE_AT(w,0xf,6)\r
89 #define HC_PRETRIGGER_PHASE(w) GET_VALUE_AT(w,0xf,2)\r
90 \r
91 // MCM word and ADC mask\r
92 #define MCM_HEADER_MASK_ERR(w) ( ((w) & (0xf)) == (0xc) ? 0 : 1) // 0 if OK!!!\r
93 #define MCM_ADCMASK_MASK_ERR(w) ( ((w) & (0xf)) == (0xc) ? 0 : 1) // 0 if OK!!!\r
94 #define MCM_MCM_NUMBER(w) GET_VALUE_AT(w,0x0f,24)\r
95 #define MCM_ROB_NUMBER(w) GET_VALUE_AT(w,0x7,28)\r
96 #define MCM_EVENT_COUNTER(w) GET_VALUE_AT(w,0x00fffff,4)\r
97 #define MCM_ADCMASK_VAL(w) GET_VALUE_AT(w,0x1fffff,4)\r
98 #define MCM_ADCMASK_NADC(w) GET_VALUE_AT(w,0x1f,25)\r
99 \r
100 #define MCM_DUMMY_ADCMASK_VAL 0x015fffffc  // updated \r
101 #define ADCDATA_VAL1 0x2  // updated \r
102 #define ADCDATA_VAL2 0x3  // updated \r
103 \r
104 //--------------------------------------------------------\r
105 #define ADC_WORD_MASK(w) ((w) & 0x3)\r
106 //--------------------------------------------------------\r
107 ClassImp(AliTRDrawFastStream)\r
108 \r
109 Bool_t AliTRDrawFastStream::fgExtraSkip = kFALSE;\r
110 Bool_t AliTRDrawFastStream::fgSkipCDH = kFALSE;\r
111 Bool_t AliTRDrawFastStream::fgWarnError = kTRUE;\r
112 Bool_t AliTRDrawFastStream::fgCleanDataOnly = kFALSE;\r
113 Bool_t AliTRDrawFastStream::fgDebugFlag = kTRUE;\r
114 Bool_t AliTRDrawFastStream::fgEnableMemoryReset = kTRUE;\r
115 Bool_t AliTRDrawFastStream::fgStackNumberChecker = kTRUE;\r
116 Bool_t AliTRDrawFastStream::fgStackLinkNumberChecker = kFALSE;\r
117 Bool_t AliTRDrawFastStream::fgSkipData = kTRUE;\r
118 Bool_t AliTRDrawFastStream::fgEnableDecodeConfigData = kFALSE;\r
119 Int_t AliTRDrawFastStream::fgDumpHead = -1;\r
120 Short_t AliTRDrawFastStream::fgMCMordering[] =\r
121   {\r
122     12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3 \r
123   };\r
124 Short_t AliTRDrawFastStream::fgROBordering[] =\r
125   {\r
126     0, 1, 2, 3\r
127   };\r
128 \r
129 Int_t  AliTRDrawFastStream::fgLastHC = -1;\r
130 Int_t  AliTRDrawFastStream::fgLastROB = -1;\r
131 Int_t  AliTRDrawFastStream::fgLastIndex = -1;\r
132 \r
133 //--------------------------------------------------------\r
134 AliTRDrawFastStream::AliTRDrawFastStream()\r
135   : AliTRDrawStreamBase()\r
136   , fSM()\r
137   , fStack(0)\r
138   , fHC(0)\r
139   , fLastHC(0)\r
140   , fMCM()\r
141   , fpPos(0)\r
142   , fpBegin(0)\r
143   , fpEnd(0)\r
144   , fWordLength(0)\r
145   , fpPosTemp(0)\r
146   , fGlobalNTimeBins(0)\r
147   , fIsTimeBinSet(kFALSE)\r
148   , fIsGlobalDigitsParamSet(kFALSE)\r
149   , fStackNumber(-1)\r
150   , fStackLinkNumber(-1)\r
151   , fLinkTrackletCounter(-1)\r
152   , fEndOfTrackletCount(-1)\r
153   , fNWordsCounter(-1)\r
154   , fMaskADCword(0)\r
155   , fTbinADC(0)\r
156   , fEventCounter(0)\r
157   , fLastEventCounter(0)\r
158   , fSharedPadsOn(kTRUE)\r
159   , fMaxADCgeom(0)\r
160   , fADCnumber(0)\r
161   , fCOL(0)\r
162   , fExtendedCOL(0)\r
163   , fIsShared(0)\r
164   , fBufferRead(0)\r
165   , fGeometry(0)\r
166   , fRawReader(0)\r
167   , fTRDfeeParam(0)\r
168   , fCommonAdditive(0)\r
169 {\r
170   //\r
171   // default constructor\r
172   //\r
173 \r
174   if (Init() == kFALSE) {\r
175     AliWarning("Unable to Init.");        \r
176   }\r
177 }\r
178 \r
179 //--------------------------------------------------------\r
180 AliTRDrawFastStream::AliTRDrawFastStream(AliRawReader *rawReader)\r
181   : AliTRDrawStreamBase(rawReader)\r
182   , fSM()\r
183   , fStack(0)\r
184   , fHC(0)\r
185   , fLastHC(0)\r
186   , fMCM()\r
187   , fpPos(0)\r
188   , fpBegin(0)\r
189   , fpEnd(0)\r
190   , fWordLength(0)\r
191   , fpPosTemp(0)\r
192   , fGlobalNTimeBins(0)\r
193   , fIsTimeBinSet(kFALSE)\r
194   , fIsGlobalDigitsParamSet(kFALSE)\r
195   , fStackNumber(-1)\r
196   , fStackLinkNumber(-1)\r
197   , fLinkTrackletCounter(-1)\r
198   , fEndOfTrackletCount(-1)\r
199   , fNWordsCounter(-1)\r
200   , fMaskADCword(0)\r
201   , fTbinADC(0)\r
202   , fEventCounter(0)\r
203   , fLastEventCounter(0)\r
204   , fSharedPadsOn(kTRUE)\r
205   , fMaxADCgeom(0)\r
206   , fADCnumber(0)\r
207   , fCOL(0)\r
208   , fExtendedCOL(0)\r
209   , fIsShared(0)\r
210   , fBufferRead(0)\r
211   , fGeometry(0)\r
212   , fRawReader(rawReader)\r
213   , fTRDfeeParam(0)\r
214   , fCommonAdditive(0)\r
215 {\r
216   //\r
217   // default constructor\r
218   //\r
219   if (fRawReader) {\r
220     if (Init() == kFALSE) {\r
221       AliWarning("Unable to Init. Try setting up the reader with SetReader or buffer with Init(void *, UInt_t )");        \r
222     }\r
223   }\r
224   else {\r
225     AliWarning("Unable to setup reader. Use SetReader(AliRawReader*).");\r
226   }\r
227 }\r
228 \r
229 //------------------------------------------------------------\r
230 AliTRDrawFastStream::AliTRDrawFastStream(const AliTRDrawFastStream& /*st*/)\r
231   : AliTRDrawStreamBase()\r
232   , fSM()\r
233   , fStack(0)\r
234   , fHC(0)\r
235   , fLastHC(0)\r
236   , fMCM()\r
237   , fpPos(0)\r
238   , fpBegin(0)\r
239   , fpEnd(0)\r
240   , fWordLength(0)\r
241   , fpPosTemp(0)\r
242   , fGlobalNTimeBins(0)\r
243   , fIsTimeBinSet(kFALSE)\r
244   , fIsGlobalDigitsParamSet(kFALSE)\r
245   , fStackNumber(-1)\r
246   , fStackLinkNumber(-1)\r
247   , fLinkTrackletCounter(-1)\r
248   , fEndOfTrackletCount(-1)\r
249   , fNWordsCounter(-1)\r
250   , fMaskADCword(0)\r
251   , fTbinADC(0)\r
252   , fEventCounter(0)\r
253   , fLastEventCounter(0)\r
254   , fSharedPadsOn(kTRUE)\r
255   , fMaxADCgeom(0)\r
256   , fADCnumber(0)\r
257   , fCOL(0)\r
258   , fExtendedCOL(0)\r
259   , fIsShared(0)\r
260   , fBufferRead(0)\r
261   , fGeometry(0)\r
262   , fRawReader(0)\r
263   , fTRDfeeParam(0)\r
264   , fCommonAdditive(0)\r
265 {\r
266   //\r
267   // Copy constructor\r
268   // \r
269   AliError("Not implemeneted.");\r
270 }\r
271 \r
272 //------------------------------------------------------------\r
273 Bool_t AliTRDrawFastStream::SetRawVersion(Int_t fraw)\r
274 {\r
275   //\r
276   // function provided for backward compatibility\r
277   //\r
278   AliWarning("Raw data version is read from raw data stream! No point of setting it in here.");\r
279   fraw = 0; // avoid warnings\r
280   return kFALSE;\r
281 }\r
282 \r
283 //------------------------------------------------------------\r
284 AliTRDrawFastStream::~AliTRDrawFastStream()\r
285 {\r
286   //\r
287   // destructor\r
288   //\r
289   delete fGeometry;\r
290 }\r
291 \r
292 //------------------------------------------------------------\r
293 \r
294 AliTRDrawFastStream &\r
295 AliTRDrawFastStream::operator=(const AliTRDrawFastStream &)\r
296 {\r
297   //\r
298   // we are not using this functionality\r
299   //\r
300   AliFatal("May not use.");\r
301   return *this;\r
302 }\r
303 \r
304 //___________________________________________________________\r
305 void AliTRDrawFastStream::SwapOnEndian()\r
306 {\r
307   //\r
308   // Check the endian and swap if needed\r
309   //\r
310   int itemp = 1;\r
311   char* ptemp = (char*) &itemp;\r
312   if (ptemp[0] != 1)\r
313     {\r
314       if (fgDebugFlag) AliDebug(8, "Swapping.");\r
315 \r
316       fpPos = fpBegin;\r
317       UInt_t iutmp = 0;\r
318       while (fpPos < fpEnd)\r
319            {\r
320              fpPos += 1;\r
321              iutmp = (((*fpPos & 0x000000ffU) << 24) | ((*fpPos & 0x0000ff00U) <<  8) |\r
322              ((*fpPos & 0x00ff0000U) >>  8) | ((*fpPos & 0xff000000U) >> 24));\r
323              // here we override the value in the buffer!\r
324              *fpPos = iutmp;      \r
325            }\r
326       fpPos = fpBegin;\r
327     }\r
328 }\r
329 \r
330 //------------------------------------------------------------\r
331 Bool_t AliTRDrawFastStream::SkipWords(UInt_t iw)\r
332 {\r
333   //\r
334   // Skip words corresponding to iw\r
335   //\r
336   if ( fpPos + iw < fpEnd ) {\r
337     fpPos += iw;\r
338     return kTRUE;\r
339   }\r
340   else {\r
341     if (fgWarnError) AliWarning(Form("Skip %d words failed. %d available", iw, fpEnd - fpPos - 1));\r
342     return kFALSE;\r
343   }\r
344 \r
345   return kTRUE;\r
346 }\r
347 \r
348 //------------------------------------------------------------\r
349 Bool_t AliTRDrawFastStream::SetReader(AliRawReader *reader)\r
350 {\r
351   // \r
352   // set raw reader pointer\r
353   // \r
354   if (reader != 0) {\r
355     fRawReader = reader;\r
356     if (fRawReader) {\r
357       return Init();\r
358     }\r
359     else {\r
360       AliWarning("Unable to setup reader.");\r
361       return kFALSE;\r
362     }\r
363   }\r
364   else {\r
365     AliWarning("AliRawReader argument is 0.");\r
366     fRawReader = 0;\r
367   }\r
368 \r
369   return kFALSE;\r
370 }\r
371 \r
372 //------------------------------------------------------------\r
373 Int_t AliTRDrawFastStream::NextBuffer()\r
374 {\r
375   //\r
376   // return -1 if no more buffers available\r
377   // return  0 if SMHeader decoding failed \r
378   // return  1 if SMHeader dedoding is OK\r
379   // \r
380   if (fRawReader != 0) {\r
381     UChar_t *buffer = 0;\r
382     UInt_t length = 0;\r
383     Bool_t kBufferSet = fRawReader->ReadNextData(buffer);\r
384     if (kBufferSet == kTRUE) {\r
385       if (fgDebugFlag)  AliDebug(9, "Buffer is set.");\r
386       length = fRawReader->GetDataSize();\r
387       if (fgExtraSkip == kTRUE) {\r
388         buffer += EXTRA_LEAD_WORDS * WORD_SIZE;\r
389         length -= EXTRA_LEAD_WORDS * WORD_SIZE;\r
390       }\r
391 \r
392       if (fgSkipCDH == kTRUE) {\r
393         buffer += CDH_WORDS * WORD_SIZE;\r
394         length -= CDH_WORDS * WORD_SIZE;              \r
395       }\r
396 \r
397       if (length > 0) {\r
398         if (fgDebugFlag)  AliDebug(9, Form("Buffer length : %d", length));\r
399         if (fgEnableMemoryReset) ResetMemory(); \r
400         if (DecodeSMHeader((void*)buffer, length) == kTRUE)\r
401           return 1;\r
402         else\r
403           return 0;\r
404       }\r
405     }\r
406     else {\r
407       return -1;\r
408     }\r
409   }\r
410 \r
411   return -1;\r
412 }\r
413 \r
414 //------------------------------------------------------------\r
415 void AliTRDrawFastStream::ResetCounters()\r
416 {\r
417   //\r
418   // reset some global counters\r
419   //\r
420   fBufferRead = kFALSE; // kFALSE if no buffer read\r
421 \r
422   fSM.fActiveStacks = 0;\r
423   fSM.fNexpectedHalfChambers = 0;\r
424 \r
425   fLastEventCounter = 0;\r
426   fEventCounter = 0;\r
427 \r
428   ResetIterators();\r
429 }\r
430 \r
431 //------------------------------------------------------------\r
432 void AliTRDrawFastStream::ResetIterators()\r
433 {\r
434   //\r
435   // reset data which should be reset every sm\r
436   //\r
437   fStackNumber = 0;     \r
438   fStackLinkNumber = 0; \r
439 }\r
440 \r
441 //------------------------------------------------------------\r
442 void AliTRDrawFastStream::ResetPerSM()\r
443 {\r
444   //\r
445   // reset every SM\r
446   //\r
447   fSM.fHeaderSize = 0;\r
448   fSM.fTrackletEnable = kFALSE;\r
449   fSM.fCorrupted = 0;\r
450   fSM.fNexpectedHalfChambers = 0;\r
451   fSM.fNexpectedHalfChambers = 0;\r
452   fSM.fPos = NULL;\r
453   for (Int_t i=0; i<5; i++) {\r
454      fSM.fStackActive[i] = kFALSE;\r
455   }\r
456 }\r
457 \r
458 //------------------------------------------------------------\r
459 void AliTRDrawFastStream::ResetPerStack()\r
460 {\r
461   //\r
462   // reset every Stack\r
463   //\r
464   fStack->fHeaderSize = 0;\r
465   fStack->fActiveLinks = 0;\r
466   fStack->fPos = NULL;\r
467   for (Int_t i=0; i<12; i++) {\r
468      fStack->fLinksActive[i] = kFALSE;\r
469      fStack->fLinksDataType[i] = 0;\r
470      fStack->fLinksMonitor[i] = 0;\r
471      fStack->fLinkMonitorError[i] = 0;\r
472   }\r
473 }\r
474 \r
475 //------------------------------------------------------------\r
476 void AliTRDrawFastStream::ResetPerHC()\r
477 {\r
478   //\r
479   // reset every HC\r
480   //\r
481   fEventCounter = 0;\r
482   fHC->fNTracklets = 0;\r
483   fHC->fSpecialRawV = 0;\r
484   fHC->fRawVMajor = 0;\r
485   fHC->fRawVMajorOpt = 0;\r
486   fHC->fRawVMinor = 0;\r
487   fHC->fNExtraWords = 0;\r
488   fHC->fDCSboard = 0;\r
489   fHC->fTimeBins = 0;\r
490   fHC->fBunchCrossCounter = 0;\r
491   fHC->fPreTriggerCounter = 0;\r
492   fHC->fPreTriggerPhase = 0;\r
493   fHC->fMCMmax = 0;\r
494 \r
495   fHC->fSM = 0;\r
496   fHC->fStack = 0;\r
497   fHC->fStackHCheader = 0;\r
498   fHC->fLayer = 0;\r
499   fHC->fLayerHCheader = 0;\r
500   fHC->fSide = 0;\r
501   fHC->fSideHCheader = 0;\r
502   fHC->fDET = 0;\r
503   fHC->fROC = 0;\r
504   fHC->fRowMax = 0;\r
505   fHC->fColMax = 0;\r
506 \r
507   fHC->fH0Corrupted = 0;\r
508   fHC->fH1Corrupted = 0;\r
509   fHC->fCorrupted = 0;\r
510   fHC->fEOTECorrupted = kFALSE;\r
511   fHC->fBufferCorrupted = kFALSE;\r
512   fHC->fDataCorrupted = kFALSE;\r
513 \r
514   fHC->fNErrors= 0;\r
515   memset(fHC->fErrorCodes, 0, 1411*sizeof(UShort_t)); // initialize error container\r
516   memset(fHC->fTrackletWords, 0, MAXTRACKLETSPERHC*sizeof(UInt_t)); // initialize tracklet container\r
517 }\r
518 \r
519 //------------------------------------------------------------\r
520 void AliTRDrawFastStream::ResetPerMCM()\r
521 {\r
522   //\r
523   // reset every MCM\r
524   //\r
525   fMCM.fROB = 0;\r
526   fMCM.fMCM = 0;\r
527   fMCM.fROW = 0;\r
528   fMCM.fEvCounter = 0;\r
529   fMCM.fADCMask = 0;\r
530   fMCM.fADCMaskWord = 0;\r
531   fMCM.fADCmax = 0;\r
532   fMCM.fADCcount = 0;\r
533   fMCM.fMCMADCWords = 0;\r
534   fMCM.fSingleADCwords = 0;\r
535   fMCM.fMCMhdCorrupted = 0;\r
536   fMCM.fADCmaskCorrupted = 0;\r
537   fMCM.fDataCorrupted = kFALSE;\r
538   fMCM.fPos = NULL;\r
539   fMCM.fAdcDataPos = NULL;\r
540   fMCM.fADCcounter = 0;\r
541 \r
542   memset(fMCM.fADCchannel, 0, TRDMAXADC*sizeof(UInt_t));\r
543 }\r
544 \r
545 //------------------------------------------------------------\r
546 void AliTRDrawFastStream::ResetMemory()\r
547 {\r
548   //\r
549   // initialize all the data members to prevent read data\r
550   // from previous buffer\r
551   //\r
552   ResetPerSM();\r
553   for (Int_t istack=0; istack<5; istack++) {\r
554      fStack = &fSM.fStacks[istack];\r
555      ResetPerStack();\r
556      for (Int_t ilink=0; ilink<12; ilink++) {\r
557         fHC = &fStack->fHalfChambers[ilink];\r
558         ResetPerHC();\r
559      }\r
560   }\r
561 }\r
562 \r
563 //------------------------------------------------------------\r
564 Bool_t AliTRDrawFastStream::Next()\r
565 {\r
566   //\r
567   // returns with true on next adc read, returns false on errors and end of buffer\r
568   // \r
569   if (fBufferRead) {\r
570     while (fStackNumber < 5 && fSM.fActiveStacks > 0) {\r
571       if (fSM.fStackActive[fStackNumber] == kTRUE) {\r
572         fStack = &fSM.fStacks[fStackNumber];\r
573         while (fStackLinkNumber < 12) {\r
574           if (fStack->fLinksActive[fStackLinkNumber] == kTRUE) {\r
575           //if (fStack->fLinksActive[fStackLinkNumber] == kTRUE && fStack->fLinksMonitor[fStackLinkNumber] == 0)\r
576             fHC = &fStack->fHalfChambers[fStackLinkNumber];\r
577                         //ResetPerHC(); // [mj - you don't need to do? ]\r
578             if (!fHC) {\r
579               AliError(Form("HC missing at stack %d link %d", fStackNumber, fStackLinkNumber));\r
580               return kFALSE;\r
581             }\r
582             fStackLinkNumber++;\r
583             return kTRUE;\r
584           } //link active ?\r
585           else fStackLinkNumber++;\r
586         } //stack link number loop \r
587       } //stack active ?\r
588       fStackNumber++;\r
589       fStackLinkNumber = 0;\r
590     } //stack number loop\r
591   } //fBufferRead\r
592 \r
593   // go for the next buffer \r
594   if (fRawReader) {\r
595     Int_t nextBuff = NextBuffer();\r
596     while (nextBuff != -1) {\r
597       if (nextBuff > 0) {\r
598         fBufferRead = kTRUE;\r
599         return Next();            \r
600       }\r
601       nextBuff = NextBuffer();\r
602     }\r
603   }\r
604 \r
605   return kFALSE;\r
606 }\r
607 \r
608 //------------------------------------------------------------\r
609 Int_t AliTRDrawFastStream::NextChamber(AliTRDdigitsManager *digitsManager, UInt_t **trackletContainer, UShort_t **errorCodeContainer) \r
610 {\r
611   \r
612   //\r
613   // Fills single chamber digit array \r
614   // Return value is the detector number\r
615   //\r
616   // first of all, you do the SM header decoding only at the beginning of the SM data reading\r
617   // then, every HC, you call Next() which points next HC. then, there you decode the given HC \r
618   // and at the same time, put the digit into digitmanager \r
619   //\r
620   AliTRDarrayADC *digits = 0;\r
621   AliTRDarrayDictionary *track0 = 0;\r
622   AliTRDarrayDictionary *track1 = 0;\r
623   AliTRDarrayDictionary *track2 = 0; \r
624   AliTRDSignalIndex *indexes = 0;\r
625   AliTRDdigitsParam *digitsparam = 0;\r
626 \r
627   Int_t lastdet = -1;\r
628   Int_t det     = -1;\r
629   Int_t side    = -1;\r
630   //Int_t it = 0;\r
631   Int_t ntracklets = 0;\r
632   Int_t nErrors = 0;\r
633 \r
634   if (trackletContainer){\r
635     for (Int_t i = 0; i < 2; i++)\r
636        memset(trackletContainer[i], 0, MAXTRACKLETSPERHC*sizeof(UInt_t));\r
637   }\r
638 \r
639   if (errorCodeContainer){\r
640     for (Int_t i = 0; i < 2; i++)\r
641        memset(errorCodeContainer[i], 0, 1411*sizeof(UShort_t));\r
642   }\r
643 \r
644   while ( Next() ) { // loop over HC \r
645 \r
646     // get this information from the GTU header\r
647     det    = GetDet();\r
648     side   = GetSide();\r
649 \r
650     if (det != lastdet) {\r
651       // If new detector found\r
652       if (lastdet == -1) {lastdet = det; fLastHC = fHC;}\r
653       else {fStackLinkNumber--; fHC = fLastHC ; return lastdet;}\r
654 \r
655       if (det < 0 || det >= AliTRDgeometry::kNdet) continue;\r
656 \r
657       // Add a container for the digits of this detector\r
658       digits = (AliTRDarrayADC *) digitsManager->GetDigits(det);\r
659 \r
660       if (digitsManager->UsesDictionaries()) {\r
661         track0 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,0);\r
662         track1 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,1);\r
663         track2 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,2);\r
664       }\r
665 \r
666       if (!digits) return -1;\r
667 \r
668       //Int_t rowMax = GetRowMax();\r
669       Int_t rowMax = fGeometry->RowmaxC1(); // we use maximum row number among all detectors to reuse memory\r
670       Int_t colMax = GetColMax();\r
671       Int_t ntbins = GetGlobalNTimeBins(); \r
672 \r
673       // Set digitparam variables\r
674       digitsparam = (AliTRDdigitsParam *) digitsManager->GetDigitsParam();\r
675       if (!fIsGlobalDigitsParamSet){\r
676         digitsparam->SetCheckOCDB(kFALSE);\r
677         digitsparam->SetNTimeBins(ntbins);\r
678         fCommonAdditive=10;\r
679         digitsparam->SetADCbaseline(fCommonAdditive);\r
680         fIsGlobalDigitsParamSet = kTRUE;\r
681       } \r
682 \r
683       // Allocate memory space for the digits buffer\r
684       if (digits->GetNtime() == 0) {\r
685         digits->Allocate(rowMax, colMax, ntbins);\r
686         if (digitsManager->UsesDictionaries()) {\r
687           track0->Allocate(rowMax, colMax, ntbins);\r
688           track1->Allocate(rowMax, colMax, ntbins);\r
689           track2->Allocate(rowMax, colMax, ntbins);\r
690         }\r
691       }\r
692 \r
693       indexes = digitsManager->GetIndexes(det);\r
694       indexes->SetSM(GetSM());\r
695       indexes->SetStack(GetStack());\r
696       indexes->SetLayer(GetLayer());\r
697       indexes->SetDetNumber(det);\r
698       if (indexes->IsAllocated() == kFALSE)\r
699         indexes->Allocate(rowMax, colMax, ntbins);\r
700     }\r
701 \r
702     if (fSM.fTrackletEnable == kTRUE) { \r
703       if (DecodeTracklets() == kFALSE) {\r
704         SeekEndOfData();\r
705 \r
706         if (fgWarnError) AliError(Form("Tracklet decoding failed stack %d link %d", GetStack(), fStackLinkNumber));\r
707 \r
708         // copy error codes in memory into error container\r
709         if (errorCodeContainer) {\r
710           nErrors = GetNErrors();\r
711           if(nErrors > 0) memcpy(errorCodeContainer[side], GetErrorCodes(), sizeof(UShort_t) * 1411); // [mj temp - optimize] \r
712         }\r
713         \r
714         continue; // if it fails to decode tracklets of this HC, it skips further decoding and goes to next HC  \r
715       }     \r
716     }   \r
717 \r
718     // decode hc data\r
719     fgLastROB   = -1; // to check mcm number odering \r
720     fgLastIndex = -1 ; // to check mcm number odering \r
721     if (DecodeHC(digitsManager, digits, track0, track1, track2, indexes) == kFALSE) {\r
722       // encode HC error code\r
723       fHC->fErrorCodes[2] += fHC->fH0Corrupted;\r
724       fHC->fErrorCodes[2] += (fHC->fH1Corrupted << 2);\r
725       fHC->fErrorCodes[2] += (fHC->fCorrupted << 3);\r
726       fHC->fErrorCodes[2] += ((fHC->fBufferCorrupted & 1) << 6);  \r
727       fHC->fErrorCodes[2] += ((fHC->fEOTECorrupted & 1) << 7);  \r
728       fHC->fErrorCodes[2] += ((fHC->fDataCorrupted & 1) << 8);  \r
729 \r
730             if (fHC->fEOTECorrupted != kTRUE)  SeekEndOfData();\r
731 \r
732 /*\r
733       if (fgWarnError) {\r
734         AliError(Form("Failed HC : %s", DumpHCinfoH0(fHC)));\r
735         AliError(Form("Failed HC : %s", DumpHCinfoH1(fHC)));\r
736       }\r
737 */ // [mj temp]\r
738           }\r
739     else SeekEndOfData(); // make sure that finish off with the end of data markers\r
740 \r
741     // set pritrigger phase since it is only avaliable after decoding HC header \r
742     digitsparam->SetPretiggerPhase(det,GetPreTriggerPhase());\r
743 \r
744     // copy tracklets in memory into tracklet container\r
745     if (trackletContainer) {\r
746       ntracklets = GetNTracklets();\r
747       // copy tracklet words to trackletContainer array \r
748       if(ntracklets > 0) memcpy(trackletContainer[side], GetTrackletWords(), sizeof(UInt_t) * ntracklets); \r
749     }\r
750 \r
751     // copy error codes in memory into error container\r
752     if (errorCodeContainer) {\r
753       nErrors = GetNErrors();\r
754       if(nErrors > 0) memcpy(errorCodeContainer[side], GetErrorCodes(), sizeof(UShort_t) * 1411); \r
755     }\r
756 \r
757   }// end of while \r
758 \r
759   return det;\r
760 }\r
761 \r
762 //------------------------------------------------------------\r
763 Bool_t AliTRDrawFastStream::Init()\r
764 {\r
765   //\r
766   // Initialize geometry and fee parameters \r
767   //\r
768   TDirectory *saveDir = gDirectory; \r
769   \r
770   if (!fGeometry) {\r
771     fGeometry = new AliTRDgeometry();\r
772   }\r
773   \r
774   if (!fGeometry) {\r
775     AliError("Geometry FAILED!");\r
776     return kFALSE;\r
777   }\r
778 \r
779   fTRDfeeParam = AliTRDfeeParam::Instance();\r
780   if (!fTRDfeeParam) {\r
781     AliError("AliTRDfeeParam FAILED!");\r
782     return kFALSE;\r
783   }\r
784 \r
785   fMaxADCgeom = (Int_t)fGeometry->ADCmax();\r
786 \r
787   ResetCounters(); // fBufferRead is set to kFALSE - important\r
788 \r
789   saveDir->cd();\r
790 \r
791   return kTRUE;\r
792 }\r
793 \r
794 //------------------------------------------------------------\r
795 Bool_t AliTRDrawFastStream::InitBuffer(void *buffer, UInt_t length)\r
796 {\r
797   // \r
798   // set initial information about the buffer\r
799   //\r
800   if (fgDebugFlag)  AliDebug(5, Form("Equipment ID: %d",fRawReader->GetEquipmentId()));\r
801   if (fRawReader->GetEquipmentId()<1024 || fRawReader->GetEquipmentId()>1041) \r
802     return kFALSE; \r
803 \r
804   ResetCounters();\r
805 \r
806   fpBegin = (UInt_t *)buffer;\r
807 \r
808   if (WORD_SIZE == 0) {\r
809     AliFatal("Strange word size. size of UInt_t == 0");\r
810     return kFALSE;\r
811   }\r
812 \r
813   fWordLength = length/WORD_SIZE;\r
814   fpEnd = fpBegin + fWordLength;\r
815   fpPos = fpBegin;\r
816 \r
817   if (fpBegin == 0 || length <= 0) {\r
818     AliError(Form("Buffer size or pointer is strange. pointer to the buffer is 0x%08x of size %d", fpBegin, length));\r
819     return kFALSE;\r
820   }\r
821 \r
822   SwapOnEndian();\r
823 \r
824   if (fgDumpHead >= 0) {\r
825     if ( fgDumpHead == 0 ) { // dump all words\r
826       AliInfo(Form("---------- Dumping all words from the beginnig of the buffer ----------"));\r
827       if (DumpWords(fpBegin, fWordLength) == kFALSE) AliError("Dump failed. Not enough data.");\r
828     } \r
829     else { \r
830       AliInfo(Form("---------- Dumping %u words from the beginnig of the buffer ----------",fgDumpHead));\r
831       if (DumpWords(fpBegin, fgDumpHead) == kFALSE) AliError("Dump failed. Not enough data.");\r
832     }\r
833     AliInfo(Form("---------- Dumping ended ----------------------------------------------"));\r
834   }\r
835 \r
836   return kTRUE;\r
837 }\r
838 \r
839 //------------------------------------------------------------\r
840 Bool_t AliTRDrawFastStream::DecodeSMHeader(void *buffer, UInt_t length)\r
841 {\r
842   // \r
843   // decode one sm data in buffer\r
844   // \r
845   ResetIterators(); \r
846 \r
847   if (InitBuffer(buffer, length) == kFALSE) {\r
848     if (fgWarnError) AliError("InitBuffer failed.");      \r
849     return kFALSE;\r
850   }\r
851 \r
852   if (DecodeGTUheader()== kFALSE)\r
853     return kFALSE;\r
854 \r
855   for (Int_t istack = 0; istack < 5; istack++) {\r
856      fStackNumber = istack; \r
857      if (fSM.fStackActive[istack] == kFALSE) continue;\r
858       \r
859      fStack = &fSM.fStacks[istack];\r
860      \r
861      fgLastHC  = -1; // to check rob number odering \r
862      for (Int_t ilink = 0; ilink < 12; ilink++) {\r
863         fStackLinkNumber = ilink; \r
864         if (fStack->fLinksActive[ilink] == kFALSE) continue;\r
865     \r
866         // check GTU link monitor \r
867         if (!(fStack->fLinksDataType[ilink] == 0 && fStack->fLinksMonitor[ilink] == 0)) {\r
868           fStack->fLinkMonitorError[ilink] = 1;\r
869           fStack->fLinkMonitorError[ilink] += fNWordsCounter; // counts words of given hc having link monitor error\r
870           //continue;\r
871         }\r
872 \r
873             if (fpPos >= fpEnd) {\r
874           if (fRawReader) fRawReader->AddMajorErrorLog(kLinkDataMissing, "Link data missing");          \r
875           if (fgWarnError) AliError("Link data missing.");\r
876           break;\r
877         }\r
878 \r
879               // HLT streamer set det number using SM header \r
880         fHC = &fStack->fHalfChambers[ilink];\r
881               fHC->fSM = fRawReader->GetEquipmentId() - 1024;\r
882               fHC->fStack = fStackNumber;\r
883               fHC->fLayer = Int_t(fStackLinkNumber/2.);\r
884               fHC->fSide = fStackLinkNumber%2;\r
885               fHC->fDET = fGeometry->GetDetector(fHC->fLayer, fHC->fStack, fHC->fSM);\r
886               fHC->fRowMax = fGeometry->GetRowMax(fHC->fLayer, fHC->fStack, fHC->fSM);\r
887               fHC->fROC    = fGeometry->GetDetectorSec(fHC->fLayer, fHC->fStack);\r
888               fHC->fColMax = fGeometry->GetColMax(fHC->fROC);\r
889            }\r
890   }     \r
891 \r
892   // set number of timebin to be used in the digit container \r
893   if (!fIsTimeBinSet) {\r
894     fpPosTemp = fpPos;\r
895     SetGlobalNTimebins();\r
896     fIsTimeBinSet = kTRUE;\r
897   }\r
898 \r
899   ResetIterators(); // need to do it again for Next() function\r
900 \r
901   return kTRUE;\r
902 }\r
903 \r
904 //------------------------------------------------------------\r
905 Bool_t AliTRDrawFastStream::DecodeGTUheader()\r
906 {\r
907   //\r
908   // decode Supermodule Index Word\r
909   //\r
910   DecodeSMInfo(fpPos, &fSM);\r
911 \r
912   if (fgDebugFlag)  AliDebug(5, DumpSMInfo(&fSM));\r
913 \r
914   fpPos++;\r
915   if (fpPos < fpEnd) {\r
916     // fSM.fHeaderSize represent additional Supermodule header size which contains additional information regarding hardware design.\r
917     // For the moment, we skip decoding these words \r
918     if (SkipWords(fSM.fHeaderSize) == kTRUE) {\r
919       for (Int_t istack = 0; istack < 5; istack++) {\r
920          if (fSM.fStackActive[istack] == kFALSE)\r
921            continue;\r
922 \r
923          fStack = &fSM.fStacks[istack];\r
924 \r
925          // Decode Stack Index Word of given stack\r
926          DecodeStackInfo(fpPos, fStack);\r
927          fpPos++;\r
928 \r
929          fSM.fNexpectedHalfChambers += fStack->fActiveLinks;\r
930         \r
931          if (fgDebugFlag)  AliDebug(5, DumpStackInfo(fStack));\r
932         \r
933          if (SkipWords(fStack->fHeaderSize-6) == kFALSE) { // 6 is the 6 stack header words for 12 links \r
934            if (fRawReader) fRawReader->AddMajorErrorLog(kDecodeStackInfo, "Stack header words missing");\r
935            return kFALSE;\r
936          }\r
937          for (Int_t iword=0; iword<6; iword++) { // decode 6 stack header words\r
938             // Decode Stack Header Word of given stack\r
939             DecodeStackHeader(fpPos, fStack, iword); \r
940             fpPos++;\r
941          } // iword\r
942       } // istack\r
943     }\r
944     else {\r
945       return kFALSE;\r
946     }\r
947   }\r
948   else {\r
949     if (fgWarnError) AliWarning("No additional sm headers and stack index words present.");\r
950     if (fRawReader) fRawReader->AddMajorErrorLog(kDecodeStackInfo, "Stack info missing");\r
951     return kFALSE;\r
952   }\r
953 \r
954   if (fpPos < fpEnd) {\r
955     if (fgDebugFlag)  AliDebug(5, "GTU headers are OK.");\r
956   }\r
957   else {\r
958     if (fgWarnError) AliWarning("No data just after GTU headers.");\r
959     if (fRawReader) fRawReader->AddMajorErrorLog(kMissingData, "Missing sm data");\r
960     return kFALSE;\r
961   }\r
962 \r
963   if (fgDebugFlag)  AliDebug(5, Form("Expected half chambers from GTU header: %d", fSM.fNexpectedHalfChambers));\r
964 \r
965   return kTRUE;\r
966 }\r
967 \r
968 //--------------------------------------------------------\r
969 void AliTRDrawFastStream::DecodeStackInfo(const UInt_t *word, struct AliTRDrawStack *st) const\r
970 {\r
971   //\r
972   // decode Stack #i Index Word\r
973   // The Stack #i Index Word is a 32-Bit word with following structure\r
974   // ssssssss ssssssss vvvv mmmm mmmmmmmm\r
975   // s: Size of the Stack #i Header, v: Supermodule Header Version, m: Link Mask\r
976   //\r
977   st->fPos = (UInt_t*)word;\r
978 \r
979   UInt_t vword = *word;\r
980   st->fHeaderSize = STACK_HEADER_SIZE(vword);\r
981 \r
982   UInt_t linkMask = STACK_LINK_WORD(vword);\r
983   st->fActiveLinks = 0;\r
984   for (Int_t i = 0; i < 12; i++) {\r
985      if (IS_BIT_SET(linkMask,i) > 0) {\r
986        st->fLinksActive[i] = kTRUE;\r
987        st->fActiveLinks++;\r
988      }\r
989      else {\r
990        st->fLinksActive[i] = kFALSE;\r
991      }\r
992   }\r
993 }\r
994 \r
995 //--------------------------------------------------------\r
996 void AliTRDrawFastStream::DecodeStackHeader(const UInt_t *word, struct AliTRDrawStack *st, Int_t iword) const\r
997 {\r
998   //\r
999   // decode stack header\r
1000   //\r
1001   st->fPos = (UInt_t*)word;\r
1002 \r
1003   UInt_t vword = *word;\r
1004   st->fLinksDataType[2*iword]    = LINK0_DATA_TYPE_FLAG(vword);\r
1005   st->fLinksMonitor[2*iword]     = LINK0_MONITOR_FLAG(vword);\r
1006   st->fLinksDataType[2*iword+1]  = LINK1_DATA_TYPE_FLAG(vword);\r
1007   st->fLinksMonitor[2*iword+1]   = LINK1_MONITOR_FLAG(vword);\r
1008 }\r
1009 \r
1010 //------------------------------------------------------------\r
1011 Bool_t AliTRDrawFastStream::DecodeTracklets()\r
1012 {\r
1013   //\r
1014   // decode tracklets\r
1015   //\r
1016   fLinkTrackletCounter = 0; // tracklet counter of this link \r
1017   fEndOfTrackletCount = 0;  // tracklet endmarker counter of this link\r
1018   fHC->fNTracklets = 0;     // number of tracklet of this link, should be less than 256\r
1019 \r
1020   if (fgDebugFlag)  AliDebug(10, Form("Decode tracklets at 0x%08x : 0x%08x", fpPos, *fpPos));\r
1021 \r
1022   while (!(*fpPos == END_OF_TRACKLET_MARKEROLD || *fpPos == END_OF_TRACKLET_MARKERNEW) && fpPos < fpEnd) {\r
1023     if (fgDebugFlag)  AliDebug(10, Form("Tracklet found at 0x%08x : 0x%08x", fpPos, *fpPos));\r
1024 \r
1025     fLinkTrackletCounter++;\r
1026 \r
1027     if (fLinkTrackletCounter > MAXTRACKLETSPERHC) {\r
1028       if (fgDebugFlag) AliDebug(11,Form("Max number of tracklets exceeded %d > %d. Tracklets are wrong either GTU header has problem",\r
1029                                         fLinkTrackletCounter, MAXTRACKLETSPERHC));\r
1030       if (fRawReader) fRawReader->AddMajorErrorLog(kTrackletOverflow,"Too many tracklets"); \r
1031       fHC->fErrorCodes[1] = 1;          \r
1032       return kFALSE;\r
1033     }\r
1034 \r
1035     fHC->fTrackletWords[fLinkTrackletCounter-1] = UInt_t(*fpPos); //store tracklet words into memory \r
1036     fpPos++;\r
1037   }\r
1038 \r
1039   fHC->fNTracklets = fLinkTrackletCounter;\r
1040 \r
1041   while ((*fpPos == END_OF_TRACKLET_MARKEROLD || *fpPos == END_OF_TRACKLET_MARKERNEW) && fpPos < fpEnd) {\r
1042     if (fgDebugFlag)  AliDebug(10, Form("EoTracklets found at 0x%08x : 0x%08x", fpPos, *fpPos));\r
1043 \r
1044     fEndOfTrackletCount++;\r
1045     fpPos++;\r
1046   }\r
1047 \r
1048   if (fEndOfTrackletCount < 2) {\r
1049     if (fgDebugFlag) AliDebug(11,"End of tracklets word missing"); \r
1050     if (fRawReader) fRawReader->AddMajorErrorLog(kEOTrackeltsMissing, "End of tracklets word missing"); \r
1051     fHC->fErrorCodes[1] += 2;          \r
1052     return kFALSE;\r
1053   }\r
1054 \r
1055   return kTRUE;\r
1056 }\r
1057 \r
1058 //--------------------------------------------------------\r
1059 void AliTRDrawFastStream::DecodeSMInfo(const UInt_t *word, struct AliTRDrawSM *sm) const\r
1060 {\r
1061   //\r
1062   // decode Supermodule Index Word\r
1063   // The Supermodule Index Word is a 32-Bit word wit following structure\r
1064   // ssssssss ssssssss vvvv rrrr r d t mmmm\r
1065   // s: Size of the Supermodule Header, v: Supermodule Header Version, r: Reserved for future use\r
1066   // d: Track Data Enabled Bit, t: Tracklet Data Enabled Bit, m: Stack Mask \r
1067   //\r
1068   sm->fPos = (UInt_t*)word; \r
1069 \r
1070   UInt_t vword = *word;\r
1071   sm->fHeaderSize = SM_HEADER_SIZE(vword);\r
1072     \r
1073   if (TRACKLETS_ENABLED(vword) > 0)\r
1074     sm->fTrackletEnable = kTRUE;\r
1075   else\r
1076     sm->fTrackletEnable = kFALSE;\r
1077     \r
1078   UInt_t stackMask = STACK_MASK(vword);\r
1079   sm->fActiveStacks = 0;\r
1080   for (Int_t i = 0; i < 5; i++)\r
1081     {\r
1082       if (IS_BIT_SET(stackMask,i) > 0)\r
1083         {\r
1084           sm->fStackActive[i] = kTRUE;\r
1085           sm->fActiveStacks++;\r
1086         }\r
1087       else\r
1088         {\r
1089           sm->fStackActive[i] = kFALSE;\r
1090         }\r
1091     }\r
1092 }\r
1093 \r
1094 //------------------------------------------------------------\r
1095 Bool_t AliTRDrawFastStream::DecodeHC(AliTRDdigitsManager *digitsManager, AliTRDarrayADC *digits, \r
1096                              AliTRDarrayDictionary *track0, AliTRDarrayDictionary *track1, AliTRDarrayDictionary *track2, \r
1097                              AliTRDSignalIndex *indexes)\r
1098 {\r
1099   //\r
1100   // decode hc header and data\r
1101   //\r
1102   if (fpPos >= fpEnd) {\r
1103     fHC->fCorrupted += 1; \r
1104     if (fgWarnError) AliError("No data(including HC header) in the buffer");\r
1105     return kFALSE;;\r
1106   }\r
1107 \r
1108   if (DecodeHCheader() == kFALSE) {\r
1109     if (fgWarnError) AliWarning(Form("HC Header decode failed. H0 Error: %d H1 Error: %d",fHC->fH0Corrupted,fHC->fH1Corrupted));\r
1110     return kFALSE;\r
1111   }\r
1112   else {\r
1113     fpPos++;\r
1114     if (fpPos >= fpEnd) {\r
1115       fHC->fCorrupted += 2; \r
1116       if (fgWarnError) AliError("No data right after HC header in the buffer");\r
1117       return kFALSE;\r
1118     }\r
1119   }\r
1120 \r
1121   if ((fHC->fRawVMajor & 64) == 64) { // test pattern data\r
1122     AliTRDrawTPStream *tpStream = new AliTRDrawTPStream(fHC->fRawVMajorOpt, fpPos);\r
1123     if (tpStream->DecodeTPdata() == kFALSE) {\r
1124       if (fgWarnError) AliError("Failed to decode test pattern data");\r
1125       return kFALSE;\r
1126     }\r
1127     return kTRUE;\r
1128   }\r
1129 \r
1130   fHC->fMCMmax = 0; // count number of mcms in a hc \r
1131   while (*fpPos != ENDOFRAWDATAMARKER && fpPos < fpEnd) {\r
1132 \r
1133     ResetPerMCM(); // reset for every mcm \r
1134 \r
1135     if (fHC->fMCMmax > TRDMAXMCM) {\r
1136       fHC->fCorrupted += 4; \r
1137       if (fgDebugFlag) AliDebug(11,"More mcm data than expected");\r
1138       return kFALSE;\r
1139     }\r
1140 \r
1141     if (DecodeMCMheader() == kFALSE) {\r
1142 \r
1143       // encode mcm level error codes\r
1144       fHC->fErrorCodes[fHC->fMCMmax+2] += fMCM.fMCMhdCorrupted;\r
1145       fHC->fErrorCodes[fHC->fMCMmax+2] += (fMCM.fADCmaskCorrupted << 4);\r
1146       fHC->fErrorCodes[fHC->fMCMmax+2] += ((fMCM.fDataCorrupted & 1) << 6);\r
1147       fHC->fErrorCodes[fHC->fMCMmax+2] += (fMCM.fMCM << 7);  // encode MCM number\r
1148       fHC->fErrorCodes[fHC->fMCMmax+2] += (fMCM.fROB << 11); // encode ROB number\r
1149 \r
1150       fHC->fMCMmax++; // increase mcm counter to match with expected rob/mcm number\r
1151 \r
1152       // in case we decide to keep reading data, skip this mcm data and find next mcm header\r
1153       if (fMCM.fADCmaskCorrupted < 2) {\r
1154         if (SkipMCMdata(fMCM.fADCcount*fMCM.fSingleADCwords) == kFALSE)\r
1155           return kFALSE;\r
1156         continue;\r
1157       }\r
1158       else {\r
1159         if (SeekNextMCMheader() == kFALSE)\r
1160           return kFALSE;\r
1161         continue;\r
1162       }\r
1163           }\r
1164 \r
1165     fHC->fMCMmax++;\r
1166 \r
1167     if (fMCM.fADCmax > 0) {\r
1168       fpPos++;\r
1169       if (fpPos >= fpEnd) {\r
1170         fHC->fBufferCorrupted = kTRUE; \r
1171         if (fgDebugFlag)  AliDebug(11, Form("Buffer ends in the middle of data"));\r
1172         return kFALSE;\r
1173       }\r
1174 \r
1175       fADCnumber = 0;\r
1176       for (Int_t iadc = 0; iadc < fMCM.fADCmax; iadc++) {\r
1177          fADCnumber = fMCM.fADCchannel[iadc];\r
1178            fExtendedCOL = fTRDfeeParam->GetExtendedPadColFromADC(fMCM.fROB, fMCM.fMCM, fADCnumber);\r
1179            fCOL = fTRDfeeParam->GetPadColFromADC(fMCM.fROB, fMCM.fMCM, fADCnumber);\r
1180 \r
1181          if (fADCnumber <= 1 || fADCnumber == fMaxADCgeom - 1)  // if adc number = 0, 1, 20\r
1182                        fIsShared = kTRUE;\r
1183                else \r
1184            fIsShared = kFALSE;\r
1185 \r
1186          if (fpPos + fMCM.fSingleADCwords >= fpEnd) {\r
1187            fHC->fBufferCorrupted = kTRUE;\r
1188            if (fgDebugFlag) AliDebug(11,"ADC (10 words) expected. Not enough data in the buffer.");\r
1189            return kFALSE;\r
1190          }\r
1191 \r
1192          //if (GetGlobalNTimeBins() < 31){\r
1193          if (fHC->fTimeBins < 31){\r
1194            if (DecodeADC(digitsManager, digits, track0, track1, track2, indexes) == kFALSE) {\r
1195              return kFALSE;\r
1196            }\r
1197          }\r
1198          //else if (GetGlobalNTimeBins() > 32) {\r
1199          else if (fHC->fTimeBins > 32) {\r
1200            if (DecodeADCExtended(digitsManager, digits, track0, track1, track2, indexes) == kFALSE) {\r
1201              return kFALSE;\r
1202            }\r
1203          }\r
1204          else { // nsamples = 31, 32 are not implemented in the TRAP and should never happen  \r
1205            if (fgWarnError) AliError("nsamples are 31 or 32. These are not implemented in the TRAP and should never happen!");\r
1206          }\r
1207 \r
1208       } // iadc\r
1209     }\r
1210     else { // if there is no adc activated\r
1211       fpPos++;\r
1212     }\r
1213   } // mcm loop\r
1214 \r
1215   if (fpPos >= fpEnd) {\r
1216     fHC->fBufferCorrupted = kTRUE; \r
1217     if (fgDebugFlag) AliDebug(11,"We are at the end of buffer. Not enough data in the buffer.");\r
1218     return kFALSE;\r
1219   }\r
1220 \r
1221   return kTRUE;\r
1222 }\r
1223 \r
1224 //------------------------------------------------------------\r
1225 Bool_t AliTRDrawFastStream::DecodeHCheader()\r
1226 {\r
1227   //\r
1228   // decode the half chamber header\r
1229   // if it fails to decode HC header for both H0 and H1, return kFALSE\r
1230   //\r
1231   if (DecodeHCwordH0(fpPos, fHC) == kFALSE)\r
1232     return kFALSE;\r
1233 \r
1234   if (fHC->fNExtraWords > 0) {\r
1235     fpPos++;\r
1236     if (fpPos < fpEnd) {\r
1237       if (DecodeHCwordH1(fpPos, fHC) == kFALSE)\r
1238         return kFALSE;\r
1239     }\r
1240     else {\r
1241       fHC->fBufferCorrupted = kTRUE;\r
1242       if (fgDebugFlag) AliDebug(11,"Expected HC header word H1. Fail due to buffer END.");\r
1243       return kFALSE;\r
1244     }\r
1245   }\r
1246 \r
1247   if (fgDebugFlag)  AliDebug(5, DumpHCinfoH0(fHC));\r
1248   if (fgDebugFlag)  AliDebug(5, DumpHCinfoH1(fHC));\r
1249 \r
1250   if (IsHCheaderOK() == kFALSE) {\r
1251     fHC->fH0Corrupted += 2;\r
1252     if (fgDebugFlag) AliDebug(11,Form("H0 Header Insane. Word 0x%08x", *fHC->fPos));\r
1253     return kFALSE;\r
1254   }\r
1255 \r
1256   return kTRUE;\r
1257 }\r
1258 \r
1259 //--------------------------------------------------------\r
1260 Bool_t AliTRDrawFastStream::DecodeHCwordH0(const UInt_t *word, struct AliTRDrawHC *hc) const\r
1261 {\r
1262   //\r
1263   // decode the hc header word 0\r
1264   //\r
1265   UInt_t vword = *word;\r
1266   hc->fPos[0] = (UInt_t*)word;\r
1267 \r
1268   hc->fH0Corrupted = HC_HEADER_MASK_ERR(vword);\r
1269   if (hc->fH0Corrupted > 0) {\r
1270     if (fgDebugFlag) AliDebug(11,Form("H0 Header Mask Error. Word 0x%08x",*fHC->fPos ));\r
1271     return kFALSE;\r
1272   }\r
1273   hc->fSpecialRawV =  HC_SPECIAL_RAW_VERSION(vword);\r
1274   hc->fRawVMajor = HC_MAJOR_RAW_VERSION(vword);\r
1275   hc->fRawVMajorOpt = HC_MAJOR_RAW_VERSION_OPT(vword);\r
1276   hc->fRawVMinor = HC_MINOR_RAW_VERSION(vword);\r
1277   hc->fNExtraWords = HC_EXTRA_WORDS(vword);\r
1278   hc->fDCSboard = HC_DCS_BOARD(vword);\r
1279   hc->fSMHCheader = HC_SM_NUMBER(vword);\r
1280   hc->fStackHCheader = HC_STACK_NUMBER(vword);\r
1281   hc->fLayerHCheader = HC_LAYER_NUMBER(vword);\r
1282   hc->fSideHCheader = HC_SIDE_NUMBER(vword);\r
1283 \r
1284   return kTRUE;\r
1285 }\r
1286 \r
1287 //--------------------------------------------------------\r
1288 Bool_t AliTRDrawFastStream::DecodeHCwordH1(const UInt_t *word, struct AliTRDrawHC *hc) const\r
1289 {\r
1290   //\r
1291   // decode the hc header word 1\r
1292   //\r
1293   UInt_t vword = *word;\r
1294   hc->fPos[1] = (UInt_t*)word;\r
1295 \r
1296   hc->fH1Corrupted = HC_HEADER_MASK_ERR(vword);\r
1297   if (hc->fH1Corrupted > 0) {\r
1298     if (fgDebugFlag) AliDebug(11,Form("H1 Header Mask Error. Word 0x%08x", *(fHC->fPos+1) ));\r
1299     return kFALSE;\r
1300   }\r
1301   hc->fTimeBins = HC_NTIMEBINS(vword);\r
1302   hc->fBunchCrossCounter = HC_BUNCH_CROSS_COUNTER(vword);\r
1303   hc->fPreTriggerCounter = HC_PRETRIGGER_COUNTER(vword);\r
1304   hc->fPreTriggerPhase = HC_PRETRIGGER_PHASE(vword);\r
1305 \r
1306   return kTRUE;\r
1307 }\r
1308 \r
1309 //------------------------------------------------------------\r
1310 Bool_t AliTRDrawFastStream::IsHCheaderOK()\r
1311 {\r
1312   //\r
1313   // check insanity of half chamber header\r
1314   //\r
1315   if (fHC->fStackHCheader < 0 || fHC->fStackHCheader > 4) {\r
1316     if (fgDebugFlag) AliDebug(11,Form("Wrong Stack %d", fHC->fStackHCheader));\r
1317       return kFALSE;\r
1318   }\r
1319 \r
1320   if (fHC->fLayerHCheader < 0 || fHC->fLayerHCheader >= AliTRDgeometry::kNlayer) {\r
1321     if (fgDebugFlag) AliDebug(11,Form("Wrong layer %d", fHC->fLayerHCheader));\r
1322       return kFALSE;\r
1323   }\r
1324 \r
1325   if (fHC->fSideHCheader < 0 || fHC->fSideHCheader > 1) {\r
1326     if (fgDebugFlag) AliDebug(11,Form("Wrong Side %d", fHC->fSideHCheader));\r
1327       return kFALSE;\r
1328   } \r
1329     \r
1330   if (fHC->fSMHCheader != fHC->fSM) {\r
1331     if (fgDebugFlag) AliDebug(11,Form("Missmatch: SM number between HC header %d and GTU link mask %d",\r
1332                                       fHC->fSMHCheader, fHC->fSM));\r
1333     return kFALSE;\r
1334   }\r
1335 \r
1336   if (fgStackNumberChecker) {\r
1337     if (fHC->fStackHCheader != fHC->fStack) {\r
1338       if (fgDebugFlag) AliDebug(11,Form("Missmatch: Stack number between HC header %d and GTU link mask %d",\r
1339                                         fHC->fStackHCheader, fHC->fStack));\r
1340       return kFALSE;\r
1341     }\r
1342   }\r
1343 \r
1344   if (fgStackLinkNumberChecker) {\r
1345     if (fHC->fLayerHCheader * 2 + fHC->fSideHCheader != fHC->fLayer * 2 + fHC->fSide) {\r
1346       if (fgDebugFlag) AliDebug(11,Form("Missmatch: Layer number between HC header %d and GTU link mask %d | %s",\r
1347                                         fHC->fLayerHCheader, fHC->fLayer, DumpStackInfo(fStack)));\r
1348       return kFALSE;\r
1349     }\r
1350   }\r
1351 \r
1352   // SLOW GEOM : consistancy check with geometry\r
1353   if (fHC->fDET < 0 || fHC->fDET >= AliTRDgeometry::kNdet) {\r
1354     if (fgDebugFlag) AliDebug(11,Form("Wrong detector %d", fHC->fDET));\r
1355     if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongDet, "Wrong Det");\r
1356     return kFALSE;\r
1357   }\r
1358 \r
1359   if (fHC->fSM != fGeometry->GetSector(fHC->fDET) || fHC->fSM <0 || fHC->fSM >= AliTRDgeometry::kNsector) {\r
1360     if (fgDebugFlag) AliDebug(11,Form("Wrong SM(sector) %d (Geometry says: %d) Stack=%d Layer=%d Det=%d",\r
1361                                       fHC->fSM, fGeometry->GetSector(fHC->fDET), fHC->fStack, fHC->fLayer, fHC->fDET));\r
1362     if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongSM, "Wrong SM");\r
1363     return kFALSE;\r
1364   }\r
1365 \r
1366   if (fHC->fROC < 0) {\r
1367     if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongROC, "Wrong ROC");\r
1368     return kFALSE;\r
1369   }\r
1370 \r
1371   if (fHC->fRowMax < 1) {\r
1372     if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongROC, "Wrong ROC Row Max");\r
1373     return kFALSE;\r
1374   }\r
1375 \r
1376   if (fHC->fColMax < 1) {\r
1377     if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongROC, "Wrong ROC Col Max");\r
1378     return kFALSE;\r
1379   }\r
1380 \r
1381   return kTRUE;\r
1382 }\r
1383 \r
1384 //------------------------------------------------------------\r
1385 Bool_t AliTRDrawFastStream::DecodeMCMheader()\r
1386 {   \r
1387   //\r
1388   // decode the mcm header\r
1389   //\r
1390   DecodeMCMheader(fpPos, &fMCM);\r
1391 \r
1392   if (fHC->fEOTECorrupted == kTRUE) {\r
1393     fpPos--;\r
1394     return kFALSE;\r
1395   }\r
1396 \r
1397   fMCM.fROW = fTRDfeeParam->GetPadRowFromMCM(fMCM.fROB, fMCM.fMCM);\r
1398 \r
1399   if ((fHC->fRawVMajor > 2 && fHC->fRawVMajor <5) || ((fHC->fRawVMajor & 32) == 32)) { //cover old and new version definition of ZS data\r
1400     fpPos++;\r
1401     if ( fpPos < fpEnd ) {\r
1402       DecodeMask(fpPos, &fMCM);\r
1403       if (fHC->fEOTECorrupted == kTRUE) {\r
1404         fpPos--;\r
1405         return kFALSE;\r
1406       }\r
1407       MCMADCwordsWithTbins(fHC->fTimeBins, &fMCM);\r
1408       fMCM.fAdcDataPos = fpPos + 1;\r
1409     }\r
1410     else {\r
1411       if (fgDebugFlag) AliDebug(11,"Expected ADC mask word. Fail due to buffer END.");\r
1412       if (fRawReader) fRawReader->AddMajorErrorLog(kMCMADCMaskMissing,"Missing");\r
1413       fHC->fBufferCorrupted = kTRUE;\r
1414       return kFALSE;\r
1415     }\r
1416   }\r
1417   else {\r
1418     UInt_t dummyMask = MCM_DUMMY_ADCMASK_VAL;\r
1419     DecodeMask(&dummyMask, &fMCM);\r
1420     MCMADCwordsWithTbins(fHC->fTimeBins, &fMCM);\r
1421     fMCM.fAdcDataPos = fpPos + 1;\r
1422   }\r
1423   if (IsMCMheaderOK() == kFALSE)\r
1424       return kFALSE;\r
1425 \r
1426   return kTRUE;\r
1427 }\r
1428 \r
1429 //--------------------------------------------------------\r
1430 void AliTRDrawFastStream::DecodeMCMheader(const UInt_t *word, struct AliTRDrawMCM *mcm) const\r
1431 {\r
1432   //\r
1433   // decode the mcm header\r
1434   //\r
1435   UInt_t vword = *word;\r
1436 \r
1437   if (vword == END_OF_TRACKLET_MARKERNEW) {\r
1438     if (fgWarnError) AliError(Form("There should be MCM header. We meet END_OF_TRACKLET_MARKER 0x%08x",vword));\r
1439     fHC->fEOTECorrupted = kTRUE; //to finish data reading of this HC\r
1440   }\r
1441 \r
1442   mcm->fMCMhdCorrupted = MCM_HEADER_MASK_ERR(vword); //if MCM header mask has error\r
1443   if (fgDebugFlag && mcm->fMCMhdCorrupted != 0) { \r
1444     fHC->fDataCorrupted = kTRUE;\r
1445     AliDebug(11,Form("Wrong MCM header mask 0x%08x.\n", *fpPos));\r
1446   }\r
1447 \r
1448   mcm->fROB = MCM_ROB_NUMBER(vword);\r
1449   mcm->fMCM = MCM_MCM_NUMBER(vword);\r
1450   mcm->fEvCounter = MCM_EVENT_COUNTER(vword);\r
1451   mcm->fPos = (UInt_t*)word;\r
1452 }\r
1453 \r
1454 //--------------------------------------------------------\r
1455 UInt_t AliTRDrawFastStream::GetMCMadcMask(const UInt_t *word, struct AliTRDrawMCM *mcm) const\r
1456 {\r
1457   //\r
1458   // get the adc mask\r
1459   //\r
1460   UInt_t vword = *word;\r
1461 \r
1462   mcm->fADCMask   = 0;\r
1463   mcm->fADCcount  = 0;\r
1464   mcm->fADCMaskWord = vword;\r
1465 \r
1466   if (vword == END_OF_TRACKLET_MARKERNEW) {\r
1467     if (fgWarnError) AliError(Form("There should be MCMadcMask. We meet END_OF_TRACKLET_MARKER 0x%08x",vword));\r
1468     fHC->fEOTECorrupted = kTRUE; //to finish data reading of this HC\r
1469   }\r
1470 \r
1471   if ( MCM_ADCMASK_MASK_ERR(vword) == 0 ) {\r
1472     mcm->fADCMask  = MCM_ADCMASK_VAL(vword);\r
1473     mcm->fADCcount = MCM_ADCMASK_NADC(~vword);\r
1474   }\r
1475   else {\r
1476     mcm->fADCMask = 0xffffffff;\r
1477     mcm->fADCmaskCorrupted = 1; // mcm adc mask error\r
1478     fHC->fDataCorrupted = kTRUE;\r
1479     if (fgDebugFlag) AliDebug(11,Form("Wrong ADC Mask word 0x%08x.\n", *fpPos));\r
1480   }\r
1481 \r
1482   return mcm->fADCMask;\r
1483 }\r
1484 \r
1485 //--------------------------------------------------------\r
1486 void AliTRDrawFastStream::DecodeMask(const UInt_t *word, struct AliTRDrawMCM *mcm) const\r
1487 {\r
1488   //\r
1489   // decode the adc mask - adcs to be read out\r
1490   //\r
1491   mcm->fMCMADCWords = 0;\r
1492   mcm->fSingleADCwords = 0;\r
1493   mcm->fADCmax = 0;\r
1494   mcm->fADCMask = GetMCMadcMask(word, mcm);\r
1495 \r
1496   if (mcm->fADCMask > 0) {\r
1497     for (Int_t i = 0; i < TRDMAXADC; i++) {\r
1498        mcm->fADCchannel[mcm->fADCmax] = 0;\r
1499        if ( IS_BIT_SET(mcm->fADCMask,i) ) {\r
1500          mcm->fADCchannel[mcm->fADCmax] = i;\r
1501          mcm->fADCmax++;\r
1502        }\r
1503     }\r
1504   }\r
1505   if (mcm->fADCcount != mcm->fADCmax && fHC->fRawVMajor >= 32) { // backward compatibility\r
1506     mcm->fADCmaskCorrupted += 2;\r
1507     fHC->fDataCorrupted = kTRUE;\r
1508     if (fgDebugFlag) AliDebug(11,Form("ADC counts from ADCMask are different %d %d : ADCMask word 0x%08x\n", \r
1509                                       mcm->fADCcount, mcm->fADCmax, *fMCM.fPos));\r
1510   }\r
1511 }\r
1512 \r
1513 //--------------------------------------------------------\r
1514 void AliTRDrawFastStream::MCMADCwordsWithTbins(UInt_t fTbins, struct AliTRDrawMCM *mcm) const\r
1515 {\r
1516   //\r
1517   //  count the expected mcm words for a given tbins\r
1518   //\r
1519   mcm->fMCMADCWords = ( mcm->fADCmax ) * ( fTbins / 3 );\r
1520   mcm->fSingleADCwords = 0;\r
1521   if (mcm->fADCmax > 0) {\r
1522     mcm->fSingleADCwords = mcm->fMCMADCWords/mcm->fADCmax;\r
1523   }\r
1524   if (fTbins > 32) mcm->fSingleADCwords = 10; // if the timebin is more than 30, then fix the number of adc words to 10\r
1525 }\r
1526 \r
1527 //------------------------------------------------------------\r
1528 Bool_t AliTRDrawFastStream::IsMCMheaderOK()\r
1529 {\r
1530   //\r
1531   // check the mcm header\r
1532   //\r
1533   if (fgLastROB != fMCM.fROB) {\r
1534     fgLastIndex = 0;\r
1535     if (fgLastROB== -1) fgLastROB = fMCM.fROB;\r
1536   }\r
1537   else {\r
1538     Int_t matchingcounter = 0; \r
1539     for (Int_t i=fgLastIndex+1; i<16; i++) {\r
1540        if ( fMCM.fMCM == fgMCMordering[i] ) {\r
1541          fgLastIndex = i;\r
1542          matchingcounter++;\r
1543          break;\r
1544        }\r
1545     }\r
1546     if (matchingcounter == 0) {\r
1547       fMCM.fMCMhdCorrupted += 2;\r
1548       AliDebug(11,Form("MCM number from last MCM is larger: MCM # from current MCM %d \n", fMCM.fMCM));\r
1549     }\r
1550   } \r
1551   \r
1552   if ( fgLastHC == fHC->fLayer*2 + fHC->fSide ) {\r
1553     if ( fMCM.fROB < fgLastROB ) {\r
1554       if((fMCM.fMCMhdCorrupted & 2) == 0) fMCM.fMCMhdCorrupted += 2;\r
1555       AliDebug(11,Form("ROB number from last MCM is larger: ROB # from current MCM %d \n", fMCM.fROB));\r
1556     }\r
1557     else fgLastROB = fMCM.fROB;\r
1558   }\r
1559 \r
1560   fgLastHC = fHC->fLayer*2 + fHC->fSide;\r
1561 \r
1562   if (fEventCounter == 0) {\r
1563     fEventCounter = fMCM.fEvCounter;\r
1564   }\r
1565 \r
1566   if (fEventCounter != fMCM.fEvCounter) {\r
1567     fMCM.fMCMhdCorrupted += 4;\r
1568     if (fgDebugFlag) AliDebug(11,Form("Event number(%d) of current MCM is different from that(%d) of reference MCM %s.\n"\r
1569                                       , fMCM.fEvCounter, fEventCounter, DumpMCMinfo(&fMCM)));\r
1570   }\r
1571 \r
1572   if (fEventCounter < fLastEventCounter) {\r
1573     fMCM.fMCMhdCorrupted += 8;\r
1574     if (fgDebugFlag) AliDebug(11,Form("Event from the past? Current %d Last %d %s.\n", fEventCounter, fLastEventCounter, DumpMCMinfo(&fMCM)));\r
1575   }\r
1576 \r
1577   if ( fMCM.fADCmaskCorrupted > 0 )\r
1578     return kFALSE;\r
1579 \r
1580   if ( fMCM.fMCMhdCorrupted > 0 )\r
1581     return kFALSE;\r
1582 \r
1583   return kTRUE;\r
1584 }\r
1585 \r
1586 //------------------------------------------------------------\r
1587 Bool_t AliTRDrawFastStream::DecodeADC(AliTRDdigitsManager *digitsManager, AliTRDarrayADC *digits, \r
1588                               AliTRDarrayDictionary *track0, AliTRDarrayDictionary *track1, AliTRDarrayDictionary *track2, \r
1589                               AliTRDSignalIndex *indexes)\r
1590 {\r
1591   //\r
1592   // decode single ADC channel\r
1593   //\r
1594   if(fADCnumber%2==1) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL1);\r
1595   if(fADCnumber%2==0) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL2);\r
1596 \r
1597   fTbinADC = 0;\r
1598   Bool_t isWritten = kFALSE;\r
1599 \r
1600   for (Int_t iw = 0; iw < fMCM.fSingleADCwords; iw++) {\r
1601      if (HC_HEADER_MASK_ERR(*fpPos) == 0 || *fpPos == END_OF_TRACKLET_MARKERNEW) {\r
1602        if (fgWarnError) AliError(Form("There should be ADC data. We meet HC header or END_OF_TRACKLET_MARKER 0x%08x",*fpPos));\r
1603        fHC->fEOTECorrupted = kTRUE; \r
1604        fpPos--;\r
1605        return kFALSE;\r
1606      }\r
1607      if (fMaskADCword != ADC_WORD_MASK(*fpPos)) {\r
1608        if (fgDebugFlag) AliDebug(11,Form("Wrong ADC data mask! [Expected mask: 0x%08x  Current mask: 0x%08x] ADC channel number: %02d MCM= %s ",\r
1609                                          fMaskADCword, ADC_WORD_MASK(*fpPos), fADCnumber, DumpMCMinfo(&fMCM)));\r
1610       // encode adc level error codes\r
1611        Int_t index = 21*(fMCM.fMCM + 16*int(fMCM.fROB/2)) + fADCnumber;\r
1612        fHC->fErrorCodes[index+66] += 1; \r
1613        if (!isWritten) { \r
1614          fHC->fErrorCodes[index+66] += (fADCnumber << 4);; \r
1615          fHC->fErrorCodes[index+66] += (fMCM.fMCM << 9);; \r
1616          fHC->fErrorCodes[index+66] += (fMCM.fROB << 13);; \r
1617          isWritten = kTRUE; \r
1618        }\r
1619        fMCM.fDataCorrupted = kTRUE;\r
1620        fHC->fDataCorrupted = kTRUE;\r
1621        fpPos++;\r
1622        continue;\r
1623      }\r
1624      // decode and put into the digit container\r
1625      Int_t adcSignals[3];\r
1626      adcSignals[0] = ((*fpPos & 0x00000ffc) >>  2);\r
1627      adcSignals[1] = ((*fpPos & 0x003ff000) >> 12);\r
1628      adcSignals[2] = ((*fpPos & 0xffc00000) >> 22);\r
1629 \r
1630      if(GetCol() < 0 || (!fSharedPadsOn & fIsShared)) {fpPos++; continue;};     \r
1631 \r
1632      for (Int_t i = 0; i < 3; i++) {\r
1633         digits->SetDataByAdcCol(GetRow(), GetExtendedCol(), fTbinADC + i, adcSignals[i]);\r
1634         indexes->AddIndexRC(GetRow(), GetCol());\r
1635         if (digitsManager->UsesDictionaries()) {\r
1636           track0->SetData(GetRow(), GetCol(), fTbinADC + i, 0);\r
1637           track1->SetData(GetRow(), GetCol(), fTbinADC + i, 0);\r
1638           track2->SetData(GetRow(), GetCol(), fTbinADC + i, 0);\r
1639         }\r
1640      } // i\r
1641      fTbinADC += 3;\r
1642      fpPos++;\r
1643   } // iw\r
1644 \r
1645   return kTRUE;\r
1646 }\r
1647 \r
1648 //------------------------------------------------------------\r
1649 Bool_t AliTRDrawFastStream::DecodeADCExtended(AliTRDdigitsManager *digitsManager, AliTRDarrayADC *digits, \r
1650                               AliTRDarrayDictionary *track0, AliTRDarrayDictionary *track1, AliTRDarrayDictionary *track2, \r
1651                               AliTRDSignalIndex *indexes)\r
1652 {\r
1653   //\r
1654   // decode single ADC channel\r
1655   //\r
1656   if(fADCnumber%2==1) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL1);\r
1657   if(fADCnumber%2==0) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL2);\r
1658 \r
1659   Bool_t isWritten = kFALSE; //for error code recording\r
1660 \r
1661   fTbinADC = ((*fpPos & 0x000000fc) >>  2);\r
1662   fMCM.fSingleADCwords  = ((*fpPos & 0x00000f00) >>  8);\r
1663   \r
1664   Int_t adcFirst2Signals[2];\r
1665   adcFirst2Signals[0] = ((*fpPos & 0x003ff000) >> 12);\r
1666   adcFirst2Signals[1] = ((*fpPos & 0xffc00000) >> 22);\r
1667 \r
1668   for (Int_t i = 0; i < 2; i++) {\r
1669      digits->SetDataByAdcCol(GetRow(), GetExtendedCol(), fTbinADC + i, adcFirst2Signals[i]);\r
1670      indexes->AddIndexRC(GetRow(), GetCol());\r
1671      if (digitsManager->UsesDictionaries()) {\r
1672        track0->SetData(GetRow(), GetCol(), fTbinADC + i, 0);\r
1673        track1->SetData(GetRow(), GetCol(), fTbinADC + i, 0);\r
1674        track2->SetData(GetRow(), GetCol(), fTbinADC + i, 0);\r
1675      }\r
1676   } // i\r
1677 \r
1678   fpPos++;\r
1679   for (Int_t iw = 0; iw < fMCM.fSingleADCwords-1; iw++) {\r
1680      if (HC_HEADER_MASK_ERR(*fpPos) == 0 || *fpPos == END_OF_TRACKLET_MARKERNEW) {\r
1681        if (fgWarnError) AliError(Form("There should be ADC data. We meet HC header or END_OF_TRACKLET_MARKER 0x%08x",*fpPos));\r
1682        fHC->fEOTECorrupted = kTRUE; \r
1683        fpPos--;\r
1684        return kFALSE;\r
1685      }\r
1686      if (fMaskADCword != ADC_WORD_MASK(*fpPos)) {\r
1687        if (fgDebugFlag) AliDebug(11,Form("Wrong ADC data mask! [Expected mask: 0x%08x  Current mask: 0x%08x] ADC channel number: %02d MCM= %s ",\r
1688                                          fMaskADCword, ADC_WORD_MASK(*fpPos), fADCnumber, DumpMCMinfo(&fMCM)));\r
1689       // encode adc level error codes\r
1690        Int_t index = 21*(fMCM.fMCM + 16*int(fMCM.fROB/2)) + fADCnumber;\r
1691        fHC->fErrorCodes[index+66] += 1; \r
1692        if (!isWritten) { \r
1693          fHC->fErrorCodes[index+66] += (fADCnumber << 4);; \r
1694          fHC->fErrorCodes[index+66] += (fMCM.fMCM << 9);; \r
1695          fHC->fErrorCodes[index+66] += (fMCM.fROB << 13);; \r
1696          isWritten = kTRUE; \r
1697        }\r
1698        fMCM.fDataCorrupted = kTRUE;\r
1699        fHC->fDataCorrupted = kTRUE;\r
1700        fpPos++;\r
1701        continue;\r
1702      }\r
1703      // decode and put into the digit container\r
1704      Int_t adcSignals[3];\r
1705      adcSignals[0] = ((*fpPos & 0x00000ffc) >>  2);\r
1706      adcSignals[1] = ((*fpPos & 0x003ff000) >> 12);\r
1707      adcSignals[2] = ((*fpPos & 0xffc00000) >> 22);\r
1708 \r
1709      if(GetCol() < 0 || (!fSharedPadsOn & fIsShared)) {fpPos++; continue;};     \r
1710      for (Int_t i = 0; i < 3; i++) {\r
1711         digits->SetDataByAdcCol(GetRow(), GetExtendedCol(), fTbinADC + 2 + i, adcSignals[i]);\r
1712         indexes->AddIndexRC(GetRow(), GetCol());\r
1713         if (digitsManager->UsesDictionaries()) {\r
1714           track0->SetData(GetRow(), GetCol(), fTbinADC + 2 + i, 0);\r
1715           track1->SetData(GetRow(), GetCol(), fTbinADC + 2 + i, 0);\r
1716           track2->SetData(GetRow(), GetCol(), fTbinADC + 2 + i, 0);\r
1717         }\r
1718      } // i\r
1719      fTbinADC += 3;\r
1720      fpPos++;\r
1721   } // iw\r
1722 \r
1723   return kTRUE;\r
1724 }\r
1725 \r
1726 //------------------------------------------------------------\r
1727 Bool_t AliTRDrawFastStream::SeekEndOfData()\r
1728 {\r
1729   //\r
1730   // go to end of data marker\r
1731   //\r
1732   Int_t fEndOfDataCount = 0;\r
1733   fNWordsCounter = 0;\r
1734 \r
1735   while ( *fpPos != ENDOFRAWDATAMARKER && fpPos < fpEnd ) {\r
1736     fpPos++;\r
1737     fNWordsCounter++;\r
1738   }\r
1739   while (*fpPos == ENDOFRAWDATAMARKER && fpPos < fpEnd ) {\r
1740     fEndOfDataCount++;\r
1741     fpPos++;\r
1742   }\r
1743 \r
1744   return kTRUE;\r
1745 }\r
1746 \r
1747 //------------------------------------------------------------\r
1748 Bool_t AliTRDrawFastStream::SeekNextMCMheader()\r
1749 {\r
1750   //\r
1751   // go to mcm marker\r
1752   //\r
1753   fpPos++;\r
1754 \r
1755   while ( *fpPos != ENDOFRAWDATAMARKER && fpPos < fpEnd ) {\r
1756     if (MCM_HEADER_MASK_ERR(*fpPos) == 0 && MCM_HEADER_MASK_ERR(*(fpPos+1)) == 0) {\r
1757       if (fgDebugFlag) AliDebug(11,Form("Found : Pos 0x%08x : Val 0x%08x", fpPos, *fpPos));\r
1758       return kTRUE;\r
1759     }\r
1760     if ( *fpPos == END_OF_TRACKLET_MARKERNEW) {\r
1761       fHC->fEOTECorrupted = kTRUE;\r
1762       return kFALSE;\r
1763     }\r
1764     fpPos++;\r
1765   }\r
1766 \r
1767   SeekEndOfData();\r
1768   return kFALSE;\r
1769 }\r
1770 \r
1771 //------------------------------------------------------------\r
1772 Bool_t AliTRDrawFastStream::SkipMCMdata(UInt_t iw)\r
1773 {\r
1774   //\r
1775   // skip mcm data words due to corruption\r
1776   //\r
1777   if (fgDebugFlag) AliDebug(11,Form("Skip %d words due to MCM header corruption.",iw));\r
1778   UInt_t iwcounter = 0;\r
1779   while ( *fpPos != ENDOFRAWDATAMARKER && iwcounter < iw) {\r
1780     if ( *fpPos == END_OF_TRACKLET_MARKERNEW) {\r
1781       if (fgDebugFlag) AliDebug(11,"Met END_OF_TRACKLET_MARKERNEW");\r
1782       fHC->fEOTECorrupted = kTRUE;\r
1783       return kFALSE;\r
1784     }\r
1785     fpPos++;\r
1786     iwcounter++;\r
1787   } // while\r
1788 \r
1789   if (iwcounter == iw) {\r
1790     fpPos++;\r
1791     return kTRUE;\r
1792   }\r
1793 \r
1794   if (fgDebugFlag) AliDebug(11,"Met ENDOFRAWDATAMARKER");\r
1795   return kFALSE;\r
1796 }\r
1797 \r
1798 //------------------------------------------------------------\r
1799 Bool_t AliTRDrawFastStream::SetGlobalNTimebins()\r
1800 {\r
1801   // get number of time bin info from HC headers then set \r
1802   Int_t nHCs=0;\r
1803   while (SetNTimebins()==kFALSE){\r
1804     if (fgDebugFlag) AliDebug(11,Form("Failed to get number of time bin information from the %sth HC",nHCs));\r
1805     nHCs++;\r
1806   }\r
1807 \r
1808   return kTRUE;\r
1809 }\r
1810 \r
1811 //------------------------------------------------------------\r
1812 Bool_t AliTRDrawFastStream::SetNTimebins()\r
1813 {\r
1814   // goes to the HC header position\r
1815   while (!(*fpPosTemp == END_OF_TRACKLET_MARKERNEW) && fpPosTemp < fpEnd) {\r
1816     fpPosTemp++;\r
1817   }\r
1818   while (*fpPosTemp == END_OF_TRACKLET_MARKERNEW) {\r
1819     fpPosTemp++;\r
1820   }\r
1821   // skip H0 \r
1822   fpPosTemp++;\r
1823 \r
1824   UInt_t vword = *fpPosTemp;\r
1825 \r
1826   // get the number of time bins \r
1827   if (HC_HEADER_MASK_ERR(vword) == 0) {\r
1828     fGlobalNTimeBins = HC_NTIMEBINS(vword);\r
1829     if (fGlobalNTimeBins > 64 || fGlobalNTimeBins < 10) return kFALSE; // minimal protection\r
1830   }\r
1831   else\r
1832     return kFALSE;\r
1833 \r
1834   return kTRUE;\r
1835 }\r
1836 \r
1837 //------------------------------------------------------------\r
1838 Bool_t AliTRDrawFastStream::DumpWords(UInt_t *px, UInt_t iw, UInt_t marker)\r
1839 {\r
1840   //\r
1841   // dump given number of words for debugging\r
1842   //\r
1843   TString tsreturn = Form("\n[ Dump Sequence at 0x%08x ] : ", px);\r
1844   for (UInt_t i = 0; i < iw; i++) {\r
1845      if ( iw != 0 && px + iw > fpEnd) \r
1846        return kFALSE;\r
1847      if (i % 8 == 0) tsreturn += "\n                              ";\r
1848      if (marker != 0 && marker == px[i]) tsreturn += Form(" *>0x%08x<* ", px[i]);\r
1849      else tsreturn += Form("0x%08x ", px[i]);\r
1850   }\r
1851   tsreturn += "\n";\r
1852 \r
1853   AliInfo(tsreturn.Data());\r
1854 \r
1855   return kTRUE;\r
1856 }\r
1857 \r
1858 //--------------------------------------------------------\r
1859 const char *AliTRDrawFastStream::DumpSMInfo(const struct AliTRDrawSM *sm)\r
1860 {\r
1861   //\r
1862   // format the string with the sm info\r
1863   //\r
1864   return Form("[ SM Info 0x%08x] : Hsize %d TrackletEnable %d Stacks %d %d %d %d %d",\r
1865               *sm->fPos, sm->fHeaderSize, sm->fTrackletEnable,\r
1866               sm->fStackActive[0], sm->fStackActive[1], sm->fStackActive[2],\r
1867               sm->fStackActive[3], sm->fStackActive[4]);      \r
1868 }\r
1869 \r
1870 //--------------------------------------------------------\r
1871 const char *AliTRDrawFastStream::DumpStackInfo(const struct AliTRDrawStack *st)\r
1872 {\r
1873   //\r
1874   // format the string with the stack info\r
1875   //\r
1876   return Form("[ Stack Info 0x%08x ] : Hsize %d Links Active %d %d %d %d %d %d %d %d %d %d %d %d",\r
1877               *st->fPos, st->fHeaderSize,\r
1878               st->fLinksActive[0], st->fLinksActive[1], st->fLinksActive[2], st->fLinksActive[3],\r
1879               st->fLinksActive[4], st->fLinksActive[5], st->fLinksActive[6], st->fLinksActive[7],\r
1880               st->fLinksActive[8], st->fLinksActive[9], st->fLinksActive[10], st->fLinksActive[11]);\r
1881 \r
1882 }\r
1883 //--------------------------------------------------------\r
1884 const char *AliTRDrawFastStream::DumpHCinfoH0(const struct AliTRDrawHC *hc)\r
1885 {\r
1886   //\r
1887   // dump the hc header word 0 in strings\r
1888   //\r
1889   if (!hc)\r
1890     return Form("Unable to dump. Null received as parameter!?!");\r
1891   else\r
1892     return Form("[ HC[0] at 0x%08x ] : 0x%08x Info is : RawV %d SM %d Stack %d Layer %d Side %d DCSboard %d",\r
1893                 hc->fPos[0], *(hc->fPos[0]), hc->fRawVMajor, hc->fSM, hc->fStack, hc->fLayer, hc->fSide, hc->fDCSboard);\r
1894 }\r
1895 \r
1896 //--------------------------------------------------------\r
1897 const char *AliTRDrawFastStream::DumpHCinfoH1(const struct AliTRDrawHC *hc)\r
1898 {\r
1899   //\r
1900   // dump the hc header word 1 in strings\r
1901   //\r
1902   if (!hc)\r
1903     return Form("Unable to dump. Null received as parameter!?!");\r
1904   else\r
1905     return Form("[ HC[1] at 0x%08x ] : 0x%08x Info is : TBins %d BCcount %d PreTrigCount %d PreTrigPhase %d",\r
1906                 hc->fPos[1], *(hc->fPos[1]), hc->fTimeBins, hc->fBunchCrossCounter, hc->fPreTriggerCounter, hc->fPreTriggerPhase);\r
1907 }\r
1908 \r
1909 //--------------------------------------------------------\r
1910 const char *AliTRDrawFastStream::DumpMCMinfo(const struct AliTRDrawMCM *mcm)\r
1911 {\r
1912   //\r
1913   // dump mcm info in strings\r
1914   //\r
1915   if (!mcm)\r
1916     return Form("Unable to dump. Null received as parameter!?!");\r
1917   else\r
1918     return Form("[ MCM 0x%08x ] : ROB %d MCM %d EvCounter %d", *(mcm->fPos), mcm->fROB, mcm->fMCM, mcm->fEvCounter);\r
1919 }\r
1920 \r
1921 //--------------------------------------------------------\r
1922 const char *AliTRDrawFastStream::DumpMCMadcMask(const struct AliTRDrawMCM *mcm)\r
1923 {\r
1924   //\r
1925   // mcm adc mask in strings\r
1926   //\r
1927   if (!mcm)\r
1928     return Form("Unable to dump. Null received as parameter!?!");\r
1929 \r
1930   TString tsreturn = Form("[Word] : 0x%08x => [Mask] : 0x%08x : ", mcm->fADCMaskWord, mcm->fADCMask);\r
1931   for (Int_t i = 0; i < TRDMAXADC; i++) {\r
1932      tsreturn += Form("%d ", mcm->fADCchannel[i]);\r
1933   }\r
1934   tsreturn += "";\r
1935   return tsreturn.Data();\r
1936 }\r
1937 \r
1938 \r