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