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