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