]> 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
re-introducing AliAnalysisTaskPerformanceStrange (H.Ricaud)
[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
e4ce0105 535 fMCM.fSingleADCwords = 0;\r
536 fMCM.fMCMhdCorrupted = 0;\r
537 fMCM.fADCmaskCorrupted = 0;\r
538 fMCM.fDataCorrupted = kFALSE;\r
539 fMCM.fPos = NULL;\r
540 fMCM.fAdcDataPos = NULL;\r
541 fMCM.fADCcounter = 0;\r
542\r
543 memset(fMCM.fADCchannel, 0, TRDMAXADC*sizeof(UInt_t));\r
544}\r
545\r
546//------------------------------------------------------------\r
547void AliTRDrawFastStream::ResetMemory()\r
548{\r
549 //\r
550 // initialize all the data members to prevent read data\r
551 // from previous buffer\r
552 //\r
553 ResetPerSM();\r
554 for (Int_t istack=0; istack<5; istack++) {\r
555 fStack = &fSM.fStacks[istack];\r
556 ResetPerStack();\r
557 for (Int_t ilink=0; ilink<12; ilink++) {\r
558 fHC = &fStack->fHalfChambers[ilink];\r
559 ResetPerHC();\r
560 }\r
561 }\r
562}\r
563\r
564//------------------------------------------------------------\r
565Bool_t AliTRDrawFastStream::Next()\r
566{\r
567 //\r
568 // returns with true on next adc read, returns false on errors and end of buffer\r
569 // \r
570 if (fBufferRead) {\r
571 while (fStackNumber < 5 && fSM.fActiveStacks > 0) {\r
572 if (fSM.fStackActive[fStackNumber] == kTRUE) {\r
573 fStack = &fSM.fStacks[fStackNumber];\r
574 while (fStackLinkNumber < 12) {\r
575 if (fStack->fLinksActive[fStackLinkNumber] == kTRUE) {\r
576 //if (fStack->fLinksActive[fStackLinkNumber] == kTRUE && fStack->fLinksMonitor[fStackLinkNumber] == 0)\r
577 fHC = &fStack->fHalfChambers[fStackLinkNumber];\r
578 //ResetPerHC(); // [mj - you don't need to do? ]\r
579 if (!fHC) {\r
580 AliError(Form("HC missing at stack %d link %d", fStackNumber, fStackLinkNumber));\r
581 return kFALSE;\r
582 }\r
583 fStackLinkNumber++;\r
584 return kTRUE;\r
585 } //link active ?\r
586 else fStackLinkNumber++;\r
587 } //stack link number loop \r
588 } //stack active ?\r
589 fStackNumber++;\r
590 fStackLinkNumber = 0;\r
591 } //stack number loop\r
592 } //fBufferRead\r
593\r
594 // go for the next buffer \r
595 if (fRawReader) {\r
596 Int_t nextBuff = NextBuffer();\r
597 while (nextBuff != -1) {\r
598 if (nextBuff > 0) {\r
599 fBufferRead = kTRUE;\r
600 return Next(); \r
601 }\r
602 nextBuff = NextBuffer();\r
603 }\r
604 }\r
605\r
606 return kFALSE;\r
607}\r
608\r
609//------------------------------------------------------------\r
610Int_t AliTRDrawFastStream::NextChamber(AliTRDdigitsManager *digitsManager, UInt_t **trackletContainer, UShort_t **errorCodeContainer) \r
611{\r
612 \r
613 //\r
614 // Fills single chamber digit array \r
615 // Return value is the detector number\r
616 //\r
617 // first of all, you do the SM header decoding only at the beginning of the SM data reading\r
618 // then, every HC, you call Next() which points next HC. then, there you decode the given HC \r
619 // and at the same time, put the digit into digitmanager \r
620 //\r
621 AliTRDarrayADC *digits = 0;\r
622 AliTRDarrayDictionary *track0 = 0;\r
623 AliTRDarrayDictionary *track1 = 0;\r
624 AliTRDarrayDictionary *track2 = 0; \r
625 AliTRDSignalIndex *indexes = 0;\r
626 AliTRDdigitsParam *digitsparam = 0;\r
627\r
628 Int_t lastdet = -1;\r
629 Int_t det = -1;\r
630 Int_t side = -1;\r
631 //Int_t it = 0;\r
632 Int_t ntracklets = 0;\r
633 Int_t nErrors = 0;\r
634\r
635 if (trackletContainer){\r
636 for (Int_t i = 0; i < 2; i++)\r
637 memset(trackletContainer[i], 0, MAXTRACKLETSPERHC*sizeof(UInt_t));\r
638 }\r
639\r
640 if (errorCodeContainer){\r
641 for (Int_t i = 0; i < 2; i++)\r
642 memset(errorCodeContainer[i], 0, 1411*sizeof(UShort_t));\r
643 }\r
644\r
645 while ( Next() ) { // loop over HC \r
646\r
647 // get this information from the GTU header\r
648 det = GetDet();\r
649 side = GetSide();\r
650\r
651 if (det != lastdet) {\r
652 // If new detector found\r
653 if (lastdet == -1) {lastdet = det; fLastHC = fHC;}\r
654 else {fStackLinkNumber--; fHC = fLastHC ; return lastdet;}\r
655\r
656 if (det < 0 || det >= AliTRDgeometry::kNdet) continue;\r
657\r
658 // Add a container for the digits of this detector\r
659 digits = (AliTRDarrayADC *) digitsManager->GetDigits(det);\r
660\r
661 if (digitsManager->UsesDictionaries()) {\r
662 track0 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,0);\r
663 track1 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,1);\r
664 track2 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,2);\r
665 }\r
666\r
667 if (!digits) return -1;\r
668\r
669 //Int_t rowMax = GetRowMax();\r
670 Int_t rowMax = fGeometry->RowmaxC1(); // we use maximum row number among all detectors to reuse memory\r
671 Int_t colMax = GetColMax();\r
672 Int_t ntbins = GetGlobalNTimeBins(); \r
673\r
674 // Set digitparam variables\r
675 digitsparam = (AliTRDdigitsParam *) digitsManager->GetDigitsParam();\r
676 if (!fIsGlobalDigitsParamSet){\r
e4ce0105 677 digitsparam->SetNTimeBins(ntbins);\r
678 fCommonAdditive=10;\r
679 digitsparam->SetADCbaseline(fCommonAdditive);\r
680 fIsGlobalDigitsParamSet = kTRUE;\r
681 } \r
682\r
683 // Allocate memory space for the digits buffer\r
684 if (digits->GetNtime() == 0) {\r
685 digits->Allocate(rowMax, colMax, ntbins);\r
686 if (digitsManager->UsesDictionaries()) {\r
687 track0->Allocate(rowMax, colMax, ntbins);\r
688 track1->Allocate(rowMax, colMax, ntbins);\r
689 track2->Allocate(rowMax, colMax, ntbins);\r
690 }\r
691 }\r
692\r
693 indexes = digitsManager->GetIndexes(det);\r
694 indexes->SetSM(GetSM());\r
695 indexes->SetStack(GetStack());\r
696 indexes->SetLayer(GetLayer());\r
697 indexes->SetDetNumber(det);\r
698 if (indexes->IsAllocated() == kFALSE)\r
699 indexes->Allocate(rowMax, colMax, ntbins);\r
700 }\r
701\r
702 if (fSM.fTrackletEnable == kTRUE) { \r
703 if (DecodeTracklets() == kFALSE) {\r
704 SeekEndOfData();\r
705\r
faad97e3 706 if (fWarnError) AliError(Form("Tracklet decoding failed stack %d link %d", GetStack(), fStackLinkNumber));\r
e4ce0105 707\r
708 // copy error codes in memory into error container\r
709 if (errorCodeContainer) {\r
710 nErrors = GetNErrors();\r
711 if(nErrors > 0) memcpy(errorCodeContainer[side], GetErrorCodes(), sizeof(UShort_t) * 1411); // [mj temp - optimize] \r
712 }\r
713 \r
714 continue; // if it fails to decode tracklets of this HC, it skips further decoding and goes to next HC \r
715 } \r
716 } \r
717\r
718 // decode hc data\r
719 fgLastROB = -1; // to check mcm number odering \r
720 fgLastIndex = -1 ; // to check mcm number odering \r
721 if (DecodeHC(digitsManager, digits, track0, track1, track2, indexes) == kFALSE) {\r
722 // encode HC error code\r
723 fHC->fErrorCodes[2] += fHC->fH0Corrupted;\r
724 fHC->fErrorCodes[2] += (fHC->fH1Corrupted << 2);\r
725 fHC->fErrorCodes[2] += (fHC->fCorrupted << 3);\r
726 fHC->fErrorCodes[2] += ((fHC->fBufferCorrupted & 1) << 6); \r
727 fHC->fErrorCodes[2] += ((fHC->fEOTECorrupted & 1) << 7); \r
728 fHC->fErrorCodes[2] += ((fHC->fDataCorrupted & 1) << 8); \r
729\r
730 if (fHC->fEOTECorrupted != kTRUE) SeekEndOfData();\r
731\r
732/*\r
faad97e3 733 if (fWarnError) {\r
e4ce0105 734 AliError(Form("Failed HC : %s", DumpHCinfoH0(fHC)));\r
735 AliError(Form("Failed HC : %s", DumpHCinfoH1(fHC)));\r
736 }\r
737*/ // [mj temp]\r
738 }\r
739 else SeekEndOfData(); // make sure that finish off with the end of data markers\r
740\r
741 // set pritrigger phase since it is only avaliable after decoding HC header \r
742 digitsparam->SetPretiggerPhase(det,GetPreTriggerPhase());\r
743\r
744 // copy tracklets in memory into tracklet container\r
745 if (trackletContainer) {\r
746 ntracklets = GetNTracklets();\r
747 // copy tracklet words to trackletContainer array \r
748 if(ntracklets > 0) memcpy(trackletContainer[side], GetTrackletWords(), sizeof(UInt_t) * ntracklets); \r
749 }\r
750\r
751 // copy error codes in memory into error container\r
752 if (errorCodeContainer) {\r
753 nErrors = GetNErrors();\r
754 if(nErrors > 0) memcpy(errorCodeContainer[side], GetErrorCodes(), sizeof(UShort_t) * 1411); \r
755 }\r
756\r
757 }// end of while \r
758\r
759 return det;\r
760}\r
761\r
762//------------------------------------------------------------\r
763Bool_t AliTRDrawFastStream::Init()\r
764{\r
765 //\r
766 // Initialize geometry and fee parameters \r
767 //\r
768 TDirectory *saveDir = gDirectory; \r
769 \r
770 if (!fGeometry) {\r
771 fGeometry = new AliTRDgeometry();\r
772 }\r
773 \r
774 if (!fGeometry) {\r
775 AliError("Geometry FAILED!");\r
776 return kFALSE;\r
777 }\r
778\r
779 fTRDfeeParam = AliTRDfeeParam::Instance();\r
780 if (!fTRDfeeParam) {\r
781 AliError("AliTRDfeeParam FAILED!");\r
782 return kFALSE;\r
783 }\r
784\r
785 fMaxADCgeom = (Int_t)fGeometry->ADCmax();\r
786\r
787 ResetCounters(); // fBufferRead is set to kFALSE - important\r
788\r
789 saveDir->cd();\r
790\r
791 return kTRUE;\r
792}\r
793\r
794//------------------------------------------------------------\r
795Bool_t AliTRDrawFastStream::InitBuffer(void *buffer, UInt_t length)\r
796{\r
797 // \r
798 // set initial information about the buffer\r
799 //\r
800 if (fgDebugFlag) AliDebug(5, Form("Equipment ID: %d",fRawReader->GetEquipmentId()));\r
801 if (fRawReader->GetEquipmentId()<1024 || fRawReader->GetEquipmentId()>1041) \r
802 return kFALSE; \r
803\r
804 ResetCounters();\r
805\r
806 fpBegin = (UInt_t *)buffer;\r
807\r
808 if (WORD_SIZE == 0) {\r
809 AliFatal("Strange word size. size of UInt_t == 0");\r
810 return kFALSE;\r
811 }\r
812\r
813 fWordLength = length/WORD_SIZE;\r
814 fpEnd = fpBegin + fWordLength;\r
815 fpPos = fpBegin;\r
816\r
817 if (fpBegin == 0 || length <= 0) {\r
818 AliError(Form("Buffer size or pointer is strange. pointer to the buffer is 0x%08x of size %d", fpBegin, length));\r
819 return kFALSE;\r
820 }\r
821\r
822 SwapOnEndian();\r
823\r
824 if (fgDumpHead >= 0) {\r
825 if ( fgDumpHead == 0 ) { // dump all words\r
826 AliInfo(Form("---------- Dumping all words from the beginnig of the buffer ----------"));\r
827 if (DumpWords(fpBegin, fWordLength) == kFALSE) AliError("Dump failed. Not enough data.");\r
828 } \r
829 else { \r
830 AliInfo(Form("---------- Dumping %u words from the beginnig of the buffer ----------",fgDumpHead));\r
831 if (DumpWords(fpBegin, fgDumpHead) == kFALSE) AliError("Dump failed. Not enough data.");\r
832 }\r
833 AliInfo(Form("---------- Dumping ended ----------------------------------------------"));\r
834 }\r
835\r
836 return kTRUE;\r
837}\r
838\r
839//------------------------------------------------------------\r
840Bool_t AliTRDrawFastStream::DecodeSMHeader(void *buffer, UInt_t length)\r
841{\r
842 // \r
843 // decode one sm data in buffer\r
844 // \r
845 ResetIterators(); \r
846\r
847 if (InitBuffer(buffer, length) == kFALSE) {\r
faad97e3 848 if (fWarnError) AliError("InitBuffer failed."); \r
e4ce0105 849 return kFALSE;\r
850 }\r
851\r
852 if (DecodeGTUheader()== kFALSE)\r
853 return kFALSE;\r
854\r
855 for (Int_t istack = 0; istack < 5; istack++) {\r
856 fStackNumber = istack; \r
857 if (fSM.fStackActive[istack] == kFALSE) continue;\r
858 \r
859 fStack = &fSM.fStacks[istack];\r
860 \r
861 fgLastHC = -1; // to check rob number odering \r
862 for (Int_t ilink = 0; ilink < 12; ilink++) {\r
863 fStackLinkNumber = ilink; \r
864 if (fStack->fLinksActive[ilink] == kFALSE) continue;\r
865 \r
866 // check GTU link monitor \r
867 if (!(fStack->fLinksDataType[ilink] == 0 && fStack->fLinksMonitor[ilink] == 0)) {\r
868 fStack->fLinkMonitorError[ilink] = 1;\r
869 fStack->fLinkMonitorError[ilink] += fNWordsCounter; // counts words of given hc having link monitor error\r
870 //continue;\r
871 }\r
872\r
873 if (fpPos >= fpEnd) {\r
874 if (fRawReader) fRawReader->AddMajorErrorLog(kLinkDataMissing, "Link data missing"); \r
faad97e3 875 if (fWarnError) AliError("Link data missing.");\r
e4ce0105 876 break;\r
877 }\r
878\r
879 // HLT streamer set det number using SM header \r
880 fHC = &fStack->fHalfChambers[ilink];\r
881 fHC->fSM = fRawReader->GetEquipmentId() - 1024;\r
882 fHC->fStack = fStackNumber;\r
883 fHC->fLayer = Int_t(fStackLinkNumber/2.);\r
884 fHC->fSide = fStackLinkNumber%2;\r
885 fHC->fDET = fGeometry->GetDetector(fHC->fLayer, fHC->fStack, fHC->fSM);\r
886 fHC->fRowMax = fGeometry->GetRowMax(fHC->fLayer, fHC->fStack, fHC->fSM);\r
887 fHC->fROC = fGeometry->GetDetectorSec(fHC->fLayer, fHC->fStack);\r
888 fHC->fColMax = fGeometry->GetColMax(fHC->fROC);\r
889 }\r
890 } \r
891\r
892 // set number of timebin to be used in the digit container \r
893 if (!fIsTimeBinSet) {\r
894 fpPosTemp = fpPos;\r
895 SetGlobalNTimebins();\r
896 fIsTimeBinSet = kTRUE;\r
897 }\r
898\r
899 ResetIterators(); // need to do it again for Next() function\r
900\r
901 return kTRUE;\r
902}\r
903\r
904//------------------------------------------------------------\r
905Bool_t AliTRDrawFastStream::DecodeGTUheader()\r
906{\r
907 //\r
908 // decode Supermodule Index Word\r
909 //\r
910 DecodeSMInfo(fpPos, &fSM);\r
911\r
912 if (fgDebugFlag) AliDebug(5, DumpSMInfo(&fSM));\r
913\r
914 fpPos++;\r
915 if (fpPos < fpEnd) {\r
916 // fSM.fHeaderSize represent additional Supermodule header size which contains additional information regarding hardware design.\r
917 // For the moment, we skip decoding these words \r
918 if (SkipWords(fSM.fHeaderSize) == kTRUE) {\r
919 for (Int_t istack = 0; istack < 5; istack++) {\r
920 if (fSM.fStackActive[istack] == kFALSE)\r
921 continue;\r
922\r
923 fStack = &fSM.fStacks[istack];\r
924\r
925 // Decode Stack Index Word of given stack\r
926 DecodeStackInfo(fpPos, fStack);\r
927 fpPos++;\r
928\r
929 fSM.fNexpectedHalfChambers += fStack->fActiveLinks;\r
930 \r
931 if (fgDebugFlag) AliDebug(5, DumpStackInfo(fStack));\r
932 \r
933 if (SkipWords(fStack->fHeaderSize-6) == kFALSE) { // 6 is the 6 stack header words for 12 links \r
934 if (fRawReader) fRawReader->AddMajorErrorLog(kDecodeStackInfo, "Stack header words missing");\r
935 return kFALSE;\r
936 }\r
937 for (Int_t iword=0; iword<6; iword++) { // decode 6 stack header words\r
938 // Decode Stack Header Word of given stack\r
939 DecodeStackHeader(fpPos, fStack, iword); \r
940 fpPos++;\r
941 } // iword\r
942 } // istack\r
943 }\r
944 else {\r
945 return kFALSE;\r
946 }\r
947 }\r
948 else {\r
faad97e3 949 if (fWarnError) AliWarning("No additional sm headers and stack index words present.");\r
e4ce0105 950 if (fRawReader) fRawReader->AddMajorErrorLog(kDecodeStackInfo, "Stack info missing");\r
951 return kFALSE;\r
952 }\r
953\r
954 if (fpPos < fpEnd) {\r
955 if (fgDebugFlag) AliDebug(5, "GTU headers are OK.");\r
956 }\r
957 else {\r
faad97e3 958 if (fWarnError) AliWarning("No data just after GTU headers.");\r
e4ce0105 959 if (fRawReader) fRawReader->AddMajorErrorLog(kMissingData, "Missing sm data");\r
960 return kFALSE;\r
961 }\r
962\r
963 if (fgDebugFlag) AliDebug(5, Form("Expected half chambers from GTU header: %d", fSM.fNexpectedHalfChambers));\r
964\r
965 return kTRUE;\r
966}\r
967\r
968//--------------------------------------------------------\r
969void AliTRDrawFastStream::DecodeStackInfo(const UInt_t *word, struct AliTRDrawStack *st) const\r
970{\r
971 //\r
972 // decode Stack #i Index Word\r
973 // The Stack #i Index Word is a 32-Bit word with following structure\r
974 // ssssssss ssssssss vvvv mmmm mmmmmmmm\r
975 // s: Size of the Stack #i Header, v: Supermodule Header Version, m: Link Mask\r
976 //\r
977 st->fPos = (UInt_t*)word;\r
978\r
979 UInt_t vword = *word;\r
980 st->fHeaderSize = STACK_HEADER_SIZE(vword);\r
981\r
982 UInt_t linkMask = STACK_LINK_WORD(vword);\r
983 st->fActiveLinks = 0;\r
984 for (Int_t i = 0; i < 12; i++) {\r
985 if (IS_BIT_SET(linkMask,i) > 0) {\r
986 st->fLinksActive[i] = kTRUE;\r
987 st->fActiveLinks++;\r
988 }\r
989 else {\r
990 st->fLinksActive[i] = kFALSE;\r
991 }\r
992 }\r
993}\r
994\r
995//--------------------------------------------------------\r
996void AliTRDrawFastStream::DecodeStackHeader(const UInt_t *word, struct AliTRDrawStack *st, Int_t iword) const\r
997{\r
998 //\r
999 // decode stack header\r
1000 //\r
1001 st->fPos = (UInt_t*)word;\r
1002\r
1003 UInt_t vword = *word;\r
1004 st->fLinksDataType[2*iword] = LINK0_DATA_TYPE_FLAG(vword);\r
1005 st->fLinksMonitor[2*iword] = LINK0_MONITOR_FLAG(vword);\r
1006 st->fLinksDataType[2*iword+1] = LINK1_DATA_TYPE_FLAG(vword);\r
1007 st->fLinksMonitor[2*iword+1] = LINK1_MONITOR_FLAG(vword);\r
1008}\r
1009\r
1010//------------------------------------------------------------\r
1011Bool_t AliTRDrawFastStream::DecodeTracklets()\r
1012{\r
1013 //\r
1014 // decode tracklets\r
1015 //\r
1016 fLinkTrackletCounter = 0; // tracklet counter of this link \r
1017 fEndOfTrackletCount = 0; // tracklet endmarker counter of this link\r
1018 fHC->fNTracklets = 0; // number of tracklet of this link, should be less than 256\r
1019\r
1020 if (fgDebugFlag) AliDebug(10, Form("Decode tracklets at 0x%08x : 0x%08x", fpPos, *fpPos));\r
1021\r
1022 while (!(*fpPos == END_OF_TRACKLET_MARKEROLD || *fpPos == END_OF_TRACKLET_MARKERNEW) && fpPos < fpEnd) {\r
1023 if (fgDebugFlag) AliDebug(10, Form("Tracklet found at 0x%08x : 0x%08x", fpPos, *fpPos));\r
1024\r
1025 fLinkTrackletCounter++;\r
1026\r
1027 if (fLinkTrackletCounter > MAXTRACKLETSPERHC) {\r
1028 if (fgDebugFlag) AliDebug(11,Form("Max number of tracklets exceeded %d > %d. Tracklets are wrong either GTU header has problem",\r
1029 fLinkTrackletCounter, MAXTRACKLETSPERHC));\r
1030 if (fRawReader) fRawReader->AddMajorErrorLog(kTrackletOverflow,"Too many tracklets"); \r
1031 fHC->fErrorCodes[1] = 1; \r
1032 return kFALSE;\r
1033 }\r
1034\r
1035 fHC->fTrackletWords[fLinkTrackletCounter-1] = UInt_t(*fpPos); //store tracklet words into memory \r
1036 fpPos++;\r
1037 }\r
1038\r
1039 fHC->fNTracklets = fLinkTrackletCounter;\r
1040\r
1041 while ((*fpPos == END_OF_TRACKLET_MARKEROLD || *fpPos == END_OF_TRACKLET_MARKERNEW) && fpPos < fpEnd) {\r
1042 if (fgDebugFlag) AliDebug(10, Form("EoTracklets found at 0x%08x : 0x%08x", fpPos, *fpPos));\r
1043\r
1044 fEndOfTrackletCount++;\r
1045 fpPos++;\r
1046 }\r
1047\r
1048 if (fEndOfTrackletCount < 2) {\r
1049 if (fgDebugFlag) AliDebug(11,"End of tracklets word missing"); \r
1050 if (fRawReader) fRawReader->AddMajorErrorLog(kEOTrackeltsMissing, "End of tracklets word missing"); \r
1051 fHC->fErrorCodes[1] += 2; \r
1052 return kFALSE;\r
1053 }\r
1054\r
1055 return kTRUE;\r
1056}\r
1057\r
1058//--------------------------------------------------------\r
1059void AliTRDrawFastStream::DecodeSMInfo(const UInt_t *word, struct AliTRDrawSM *sm) const\r
1060{\r
1061 //\r
1062 // decode Supermodule Index Word\r
1063 // The Supermodule Index Word is a 32-Bit word wit following structure\r
1064 // ssssssss ssssssss vvvv rrrr r d t mmmm\r
1065 // s: Size of the Supermodule Header, v: Supermodule Header Version, r: Reserved for future use\r
1066 // d: Track Data Enabled Bit, t: Tracklet Data Enabled Bit, m: Stack Mask \r
1067 //\r
1068 sm->fPos = (UInt_t*)word; \r
1069\r
1070 UInt_t vword = *word;\r
1071 sm->fHeaderSize = SM_HEADER_SIZE(vword);\r
1072 \r
1073 if (TRACKLETS_ENABLED(vword) > 0)\r
1074 sm->fTrackletEnable = kTRUE;\r
1075 else\r
1076 sm->fTrackletEnable = kFALSE;\r
1077 \r
1078 UInt_t stackMask = STACK_MASK(vword);\r
1079 sm->fActiveStacks = 0;\r
1080 for (Int_t i = 0; i < 5; i++)\r
1081 {\r
1082 if (IS_BIT_SET(stackMask,i) > 0)\r
1083 {\r
1084 sm->fStackActive[i] = kTRUE;\r
1085 sm->fActiveStacks++;\r
1086 }\r
1087 else\r
1088 {\r
1089 sm->fStackActive[i] = kFALSE;\r
1090 }\r
1091 }\r
1092}\r
1093\r
1094//------------------------------------------------------------\r
1095Bool_t AliTRDrawFastStream::DecodeHC(AliTRDdigitsManager *digitsManager, AliTRDarrayADC *digits, \r
1096 AliTRDarrayDictionary *track0, AliTRDarrayDictionary *track1, AliTRDarrayDictionary *track2, \r
1097 AliTRDSignalIndex *indexes)\r
1098{\r
1099 //\r
1100 // decode hc header and data\r
1101 //\r
1102 if (fpPos >= fpEnd) {\r
1103 fHC->fCorrupted += 1; \r
faad97e3 1104 if (fWarnError) AliError("No data(including HC header) in the buffer");\r
e4ce0105 1105 return kFALSE;;\r
1106 }\r
1107\r
1108 if (DecodeHCheader() == kFALSE) {\r
faad97e3 1109 if (fWarnError) AliWarning(Form("HC Header decode failed. H0 Error: %d H1 Error: %d",fHC->fH0Corrupted,fHC->fH1Corrupted));\r
e4ce0105 1110 return kFALSE;\r
1111 }\r
1112 else {\r
1113 fpPos++;\r
1114 if (fpPos >= fpEnd) {\r
1115 fHC->fCorrupted += 2; \r
faad97e3 1116 if (fWarnError) AliError("No data right after HC header in the buffer");\r
e4ce0105 1117 return kFALSE;\r
1118 }\r
1119 }\r
1120\r
1121 if ((fHC->fRawVMajor & 64) == 64) { // test pattern data\r
1122 AliTRDrawTPStream *tpStream = new AliTRDrawTPStream(fHC->fRawVMajorOpt, fpPos);\r
1123 if (tpStream->DecodeTPdata() == kFALSE) {\r
faad97e3 1124 if (fWarnError) AliError("Failed to decode test pattern data");\r
e4ce0105 1125 return kFALSE;\r
1126 }\r
1127 return kTRUE;\r
1128 }\r
1129\r
1130 fHC->fMCMmax = 0; // count number of mcms in a hc \r
1131 while (*fpPos != ENDOFRAWDATAMARKER && fpPos < fpEnd) {\r
1132\r
1133 ResetPerMCM(); // reset for every mcm \r
1134\r
1135 if (fHC->fMCMmax > TRDMAXMCM) {\r
1136 fHC->fCorrupted += 4; \r
1137 if (fgDebugFlag) AliDebug(11,"More mcm data than expected");\r
1138 return kFALSE;\r
1139 }\r
1140\r
1141 if (DecodeMCMheader() == kFALSE) {\r
1142\r
1143 // encode mcm level error codes\r
1144 fHC->fErrorCodes[fHC->fMCMmax+2] += fMCM.fMCMhdCorrupted;\r
1145 fHC->fErrorCodes[fHC->fMCMmax+2] += (fMCM.fADCmaskCorrupted << 4);\r
1146 fHC->fErrorCodes[fHC->fMCMmax+2] += ((fMCM.fDataCorrupted & 1) << 6);\r
1147 fHC->fErrorCodes[fHC->fMCMmax+2] += (fMCM.fMCM << 7); // encode MCM number\r
1148 fHC->fErrorCodes[fHC->fMCMmax+2] += (fMCM.fROB << 11); // encode ROB number\r
1149\r
1150 fHC->fMCMmax++; // increase mcm counter to match with expected rob/mcm number\r
1151\r
1152 // in case we decide to keep reading data, skip this mcm data and find next mcm header\r
1153 if (fMCM.fADCmaskCorrupted < 2) {\r
1154 if (SkipMCMdata(fMCM.fADCcount*fMCM.fSingleADCwords) == kFALSE)\r
1155 return kFALSE;\r
1156 continue;\r
1157 }\r
1158 else {\r
1159 if (SeekNextMCMheader() == kFALSE)\r
1160 return kFALSE;\r
1161 continue;\r
1162 }\r
1163 }\r
1164\r
1165 fHC->fMCMmax++;\r
1166\r
1167 if (fMCM.fADCmax > 0) {\r
1168 fpPos++;\r
1169 if (fpPos >= fpEnd) {\r
1170 fHC->fBufferCorrupted = kTRUE; \r
1171 if (fgDebugFlag) AliDebug(11, Form("Buffer ends in the middle of data"));\r
1172 return kFALSE;\r
1173 }\r
1174\r
1175 fADCnumber = 0;\r
1176 for (Int_t iadc = 0; iadc < fMCM.fADCmax; iadc++) {\r
1177 fADCnumber = fMCM.fADCchannel[iadc];\r
1178 fExtendedCOL = fTRDfeeParam->GetExtendedPadColFromADC(fMCM.fROB, fMCM.fMCM, fADCnumber);\r
1179 fCOL = fTRDfeeParam->GetPadColFromADC(fMCM.fROB, fMCM.fMCM, fADCnumber);\r
1180\r
1181 if (fADCnumber <= 1 || fADCnumber == fMaxADCgeom - 1) // if adc number = 0, 1, 20\r
1182 fIsShared = kTRUE;\r
1183 else \r
1184 fIsShared = kFALSE;\r
1185\r
1186 if (fpPos + fMCM.fSingleADCwords >= fpEnd) {\r
1187 fHC->fBufferCorrupted = kTRUE;\r
1188 if (fgDebugFlag) AliDebug(11,"ADC (10 words) expected. Not enough data in the buffer.");\r
1189 return kFALSE;\r
1190 }\r
1191\r
1192 //if (GetGlobalNTimeBins() < 31){\r
1193 if (fHC->fTimeBins < 31){\r
1194 if (DecodeADC(digitsManager, digits, track0, track1, track2, indexes) == kFALSE) {\r
1195 return kFALSE;\r
1196 }\r
1197 }\r
1198 //else if (GetGlobalNTimeBins() > 32) {\r
1199 else if (fHC->fTimeBins > 32) {\r
1200 if (DecodeADCExtended(digitsManager, digits, track0, track1, track2, indexes) == kFALSE) {\r
1201 return kFALSE;\r
1202 }\r
1203 }\r
1204 else { // nsamples = 31, 32 are not implemented in the TRAP and should never happen \r
faad97e3 1205 if (fWarnError) AliError("nsamples are 31 or 32. These are not implemented in the TRAP and should never happen!");\r
e4ce0105 1206 }\r
1207\r
1208 } // iadc\r
1209 }\r
1210 else { // if there is no adc activated\r
1211 fpPos++;\r
1212 }\r
1213 } // mcm loop\r
1214\r
1215 if (fpPos >= fpEnd) {\r
1216 fHC->fBufferCorrupted = kTRUE; \r
1217 if (fgDebugFlag) AliDebug(11,"We are at the end of buffer. Not enough data in the buffer.");\r
1218 return kFALSE;\r
1219 }\r
1220\r
1221 return kTRUE;\r
1222}\r
1223\r
1224//------------------------------------------------------------\r
1225Bool_t AliTRDrawFastStream::DecodeHCheader()\r
1226{\r
1227 //\r
1228 // decode the half chamber header\r
1229 // if it fails to decode HC header for both H0 and H1, return kFALSE\r
1230 //\r
1231 if (DecodeHCwordH0(fpPos, fHC) == kFALSE)\r
1232 return kFALSE;\r
1233\r
1234 if (fHC->fNExtraWords > 0) {\r
1235 fpPos++;\r
1236 if (fpPos < fpEnd) {\r
1237 if (DecodeHCwordH1(fpPos, fHC) == kFALSE)\r
1238 return kFALSE;\r
1239 }\r
1240 else {\r
1241 fHC->fBufferCorrupted = kTRUE;\r
1242 if (fgDebugFlag) AliDebug(11,"Expected HC header word H1. Fail due to buffer END.");\r
1243 return kFALSE;\r
1244 }\r
1245 }\r
1246\r
1247 if (fgDebugFlag) AliDebug(5, DumpHCinfoH0(fHC));\r
1248 if (fgDebugFlag) AliDebug(5, DumpHCinfoH1(fHC));\r
1249\r
1250 if (IsHCheaderOK() == kFALSE) {\r
1251 fHC->fH0Corrupted += 2;\r
1252 if (fgDebugFlag) AliDebug(11,Form("H0 Header Insane. Word 0x%08x", *fHC->fPos));\r
1253 return kFALSE;\r
1254 }\r
1255\r
1256 return kTRUE;\r
1257}\r
1258\r
1259//--------------------------------------------------------\r
1260Bool_t AliTRDrawFastStream::DecodeHCwordH0(const UInt_t *word, struct AliTRDrawHC *hc) const\r
1261{\r
1262 //\r
1263 // decode the hc header word 0\r
1264 //\r
1265 UInt_t vword = *word;\r
1266 hc->fPos[0] = (UInt_t*)word;\r
1267\r
1268 hc->fH0Corrupted = HC_HEADER_MASK_ERR(vword);\r
1269 if (hc->fH0Corrupted > 0) {\r
1270 if (fgDebugFlag) AliDebug(11,Form("H0 Header Mask Error. Word 0x%08x",*fHC->fPos ));\r
1271 return kFALSE;\r
1272 }\r
1273 hc->fSpecialRawV = HC_SPECIAL_RAW_VERSION(vword);\r
1274 hc->fRawVMajor = HC_MAJOR_RAW_VERSION(vword);\r
1275 hc->fRawVMajorOpt = HC_MAJOR_RAW_VERSION_OPT(vword);\r
1276 hc->fRawVMinor = HC_MINOR_RAW_VERSION(vword);\r
1277 hc->fNExtraWords = HC_EXTRA_WORDS(vword);\r
1278 hc->fDCSboard = HC_DCS_BOARD(vword);\r
1279 hc->fSMHCheader = HC_SM_NUMBER(vword);\r
1280 hc->fStackHCheader = HC_STACK_NUMBER(vword);\r
1281 hc->fLayerHCheader = HC_LAYER_NUMBER(vword);\r
1282 hc->fSideHCheader = HC_SIDE_NUMBER(vword);\r
1283\r
1284 return kTRUE;\r
1285}\r
1286\r
1287//--------------------------------------------------------\r
1288Bool_t AliTRDrawFastStream::DecodeHCwordH1(const UInt_t *word, struct AliTRDrawHC *hc) const\r
1289{\r
1290 //\r
1291 // decode the hc header word 1\r
1292 //\r
1293 UInt_t vword = *word;\r
1294 hc->fPos[1] = (UInt_t*)word;\r
1295\r
1296 hc->fH1Corrupted = HC_HEADER_MASK_ERR(vword);\r
1297 if (hc->fH1Corrupted > 0) {\r
1298 if (fgDebugFlag) AliDebug(11,Form("H1 Header Mask Error. Word 0x%08x", *(fHC->fPos+1) ));\r
1299 return kFALSE;\r
1300 }\r
1301 hc->fTimeBins = HC_NTIMEBINS(vword);\r
1302 hc->fBunchCrossCounter = HC_BUNCH_CROSS_COUNTER(vword);\r
1303 hc->fPreTriggerCounter = HC_PRETRIGGER_COUNTER(vword);\r
1304 hc->fPreTriggerPhase = HC_PRETRIGGER_PHASE(vword);\r
1305\r
1306 return kTRUE;\r
1307}\r
1308\r
1309//------------------------------------------------------------\r
1310Bool_t AliTRDrawFastStream::IsHCheaderOK()\r
1311{\r
1312 //\r
1313 // check insanity of half chamber header\r
1314 //\r
1315 if (fHC->fStackHCheader < 0 || fHC->fStackHCheader > 4) {\r
1316 if (fgDebugFlag) AliDebug(11,Form("Wrong Stack %d", fHC->fStackHCheader));\r
1317 return kFALSE;\r
1318 }\r
1319\r
1320 if (fHC->fLayerHCheader < 0 || fHC->fLayerHCheader >= AliTRDgeometry::kNlayer) {\r
1321 if (fgDebugFlag) AliDebug(11,Form("Wrong layer %d", fHC->fLayerHCheader));\r
1322 return kFALSE;\r
1323 }\r
1324\r
1325 if (fHC->fSideHCheader < 0 || fHC->fSideHCheader > 1) {\r
1326 if (fgDebugFlag) AliDebug(11,Form("Wrong Side %d", fHC->fSideHCheader));\r
1327 return kFALSE;\r
1328 } \r
1329 \r
1330 if (fHC->fSMHCheader != fHC->fSM) {\r
1331 if (fgDebugFlag) AliDebug(11,Form("Missmatch: SM number between HC header %d and GTU link mask %d",\r
1332 fHC->fSMHCheader, fHC->fSM));\r
1333 return kFALSE;\r
1334 }\r
1335\r
1336 if (fgStackNumberChecker) {\r
1337 if (fHC->fStackHCheader != fHC->fStack) {\r
1338 if (fgDebugFlag) AliDebug(11,Form("Missmatch: Stack number between HC header %d and GTU link mask %d",\r
1339 fHC->fStackHCheader, fHC->fStack));\r
1340 return kFALSE;\r
1341 }\r
1342 }\r
1343\r
1344 if (fgStackLinkNumberChecker) {\r
1345 if (fHC->fLayerHCheader * 2 + fHC->fSideHCheader != fHC->fLayer * 2 + fHC->fSide) {\r
1346 if (fgDebugFlag) AliDebug(11,Form("Missmatch: Layer number between HC header %d and GTU link mask %d | %s",\r
1347 fHC->fLayerHCheader, fHC->fLayer, DumpStackInfo(fStack)));\r
1348 return kFALSE;\r
1349 }\r
1350 }\r
1351\r
1352 // SLOW GEOM : consistancy check with geometry\r
1353 if (fHC->fDET < 0 || fHC->fDET >= AliTRDgeometry::kNdet) {\r
1354 if (fgDebugFlag) AliDebug(11,Form("Wrong detector %d", fHC->fDET));\r
1355 if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongDet, "Wrong Det");\r
1356 return kFALSE;\r
1357 }\r
1358\r
1359 if (fHC->fSM != fGeometry->GetSector(fHC->fDET) || fHC->fSM <0 || fHC->fSM >= AliTRDgeometry::kNsector) {\r
1360 if (fgDebugFlag) AliDebug(11,Form("Wrong SM(sector) %d (Geometry says: %d) Stack=%d Layer=%d Det=%d",\r
1361 fHC->fSM, fGeometry->GetSector(fHC->fDET), fHC->fStack, fHC->fLayer, fHC->fDET));\r
1362 if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongSM, "Wrong SM");\r
1363 return kFALSE;\r
1364 }\r
1365\r
1366 if (fHC->fROC < 0) {\r
1367 if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongROC, "Wrong ROC");\r
1368 return kFALSE;\r
1369 }\r
1370\r
1371 if (fHC->fRowMax < 1) {\r
1372 if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongROC, "Wrong ROC Row Max");\r
1373 return kFALSE;\r
1374 }\r
1375\r
1376 if (fHC->fColMax < 1) {\r
1377 if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongROC, "Wrong ROC Col Max");\r
1378 return kFALSE;\r
1379 }\r
1380\r
1381 return kTRUE;\r
1382}\r
1383\r
1384//------------------------------------------------------------\r
1385Bool_t AliTRDrawFastStream::DecodeMCMheader()\r
1386{ \r
1387 //\r
1388 // decode the mcm header\r
1389 //\r
1390 DecodeMCMheader(fpPos, &fMCM);\r
1391\r
1392 if (fHC->fEOTECorrupted == kTRUE) {\r
1393 fpPos--;\r
1394 return kFALSE;\r
1395 }\r
1396\r
1397 fMCM.fROW = fTRDfeeParam->GetPadRowFromMCM(fMCM.fROB, fMCM.fMCM);\r
1398\r
1399 if ((fHC->fRawVMajor > 2 && fHC->fRawVMajor <5) || ((fHC->fRawVMajor & 32) == 32)) { //cover old and new version definition of ZS data\r
1400 fpPos++;\r
1401 if ( fpPos < fpEnd ) {\r
1402 DecodeMask(fpPos, &fMCM);\r
1403 if (fHC->fEOTECorrupted == kTRUE) {\r
1404 fpPos--;\r
1405 return kFALSE;\r
1406 }\r
1407 MCMADCwordsWithTbins(fHC->fTimeBins, &fMCM);\r
1408 fMCM.fAdcDataPos = fpPos + 1;\r
1409 }\r
1410 else {\r
1411 if (fgDebugFlag) AliDebug(11,"Expected ADC mask word. Fail due to buffer END.");\r
1412 if (fRawReader) fRawReader->AddMajorErrorLog(kMCMADCMaskMissing,"Missing");\r
1413 fHC->fBufferCorrupted = kTRUE;\r
1414 return kFALSE;\r
1415 }\r
1416 }\r
1417 else {\r
1418 UInt_t dummyMask = MCM_DUMMY_ADCMASK_VAL;\r
1419 DecodeMask(&dummyMask, &fMCM);\r
1420 MCMADCwordsWithTbins(fHC->fTimeBins, &fMCM);\r
1421 fMCM.fAdcDataPos = fpPos + 1;\r
1422 }\r
1423 if (IsMCMheaderOK() == kFALSE)\r
1424 return kFALSE;\r
1425\r
1426 return kTRUE;\r
1427}\r
1428\r
1429//--------------------------------------------------------\r
1430void AliTRDrawFastStream::DecodeMCMheader(const UInt_t *word, struct AliTRDrawMCM *mcm) const\r
1431{\r
1432 //\r
1433 // decode the mcm header\r
1434 //\r
1435 UInt_t vword = *word;\r
1436\r
1437 if (vword == END_OF_TRACKLET_MARKERNEW) {\r
faad97e3 1438 if (fWarnError) AliError(Form("There should be MCM header. We meet END_OF_TRACKLET_MARKER 0x%08x",vword));\r
e4ce0105 1439 fHC->fEOTECorrupted = kTRUE; //to finish data reading of this HC\r
1440 }\r
1441\r
1442 mcm->fMCMhdCorrupted = MCM_HEADER_MASK_ERR(vword); //if MCM header mask has error\r
1443 if (fgDebugFlag && mcm->fMCMhdCorrupted != 0) { \r
1444 fHC->fDataCorrupted = kTRUE;\r
1445 AliDebug(11,Form("Wrong MCM header mask 0x%08x.\n", *fpPos));\r
1446 }\r
1447\r
1448 mcm->fROB = MCM_ROB_NUMBER(vword);\r
1449 mcm->fMCM = MCM_MCM_NUMBER(vword);\r
1450 mcm->fEvCounter = MCM_EVENT_COUNTER(vword);\r
1451 mcm->fPos = (UInt_t*)word;\r
1452}\r
1453\r
1454//--------------------------------------------------------\r
1455UInt_t AliTRDrawFastStream::GetMCMadcMask(const UInt_t *word, struct AliTRDrawMCM *mcm) const\r
1456{\r
1457 //\r
1458 // get the adc mask\r
1459 //\r
1460 UInt_t vword = *word;\r
1461\r
1462 mcm->fADCMask = 0;\r
1463 mcm->fADCcount = 0;\r
1464 mcm->fADCMaskWord = vword;\r
1465\r
1466 if (vword == END_OF_TRACKLET_MARKERNEW) {\r
faad97e3 1467 if (fWarnError) AliError(Form("There should be MCMadcMask. We meet END_OF_TRACKLET_MARKER 0x%08x",vword));\r
e4ce0105 1468 fHC->fEOTECorrupted = kTRUE; //to finish data reading of this HC\r
1469 }\r
1470\r
1471 if ( MCM_ADCMASK_MASK_ERR(vword) == 0 ) {\r
1472 mcm->fADCMask = MCM_ADCMASK_VAL(vword);\r
1473 mcm->fADCcount = MCM_ADCMASK_NADC(~vword);\r
1474 }\r
1475 else {\r
1476 mcm->fADCMask = 0xffffffff;\r
1477 mcm->fADCmaskCorrupted = 1; // mcm adc mask error\r
1478 fHC->fDataCorrupted = kTRUE;\r
1479 if (fgDebugFlag) AliDebug(11,Form("Wrong ADC Mask word 0x%08x.\n", *fpPos));\r
1480 }\r
1481\r
1482 return mcm->fADCMask;\r
1483}\r
1484\r
1485//--------------------------------------------------------\r
1486void AliTRDrawFastStream::DecodeMask(const UInt_t *word, struct AliTRDrawMCM *mcm) const\r
1487{\r
1488 //\r
1489 // decode the adc mask - adcs to be read out\r
1490 //\r
e4ce0105 1491 mcm->fSingleADCwords = 0;\r
1492 mcm->fADCmax = 0;\r
1493 mcm->fADCMask = GetMCMadcMask(word, mcm);\r
1494\r
1495 if (mcm->fADCMask > 0) {\r
1496 for (Int_t i = 0; i < TRDMAXADC; i++) {\r
1497 mcm->fADCchannel[mcm->fADCmax] = 0;\r
1498 if ( IS_BIT_SET(mcm->fADCMask,i) ) {\r
1499 mcm->fADCchannel[mcm->fADCmax] = i;\r
1500 mcm->fADCmax++;\r
1501 }\r
1502 }\r
1503 }\r
1504 if (mcm->fADCcount != mcm->fADCmax && fHC->fRawVMajor >= 32) { // backward compatibility\r
1505 mcm->fADCmaskCorrupted += 2;\r
1506 fHC->fDataCorrupted = kTRUE;\r
1507 if (fgDebugFlag) AliDebug(11,Form("ADC counts from ADCMask are different %d %d : ADCMask word 0x%08x\n", \r
1508 mcm->fADCcount, mcm->fADCmax, *fMCM.fPos));\r
1509 }\r
1510}\r
1511\r
1512//--------------------------------------------------------\r
1513void AliTRDrawFastStream::MCMADCwordsWithTbins(UInt_t fTbins, struct AliTRDrawMCM *mcm) const\r
1514{\r
1515 //\r
1516 // count the expected mcm words for a given tbins\r
1517 //\r
e4ce0105 1518 mcm->fSingleADCwords = 0;\r
4a9532ea 1519 mcm->fSingleADCwords = (fTbins-1)/3+1;\r
e4ce0105 1520 if (fTbins > 32) mcm->fSingleADCwords = 10; // if the timebin is more than 30, then fix the number of adc words to 10\r
1521}\r
1522\r
1523//------------------------------------------------------------\r
1524Bool_t AliTRDrawFastStream::IsMCMheaderOK()\r
1525{\r
1526 //\r
1527 // check the mcm header\r
1528 //\r
1529 if (fgLastROB != fMCM.fROB) {\r
1530 fgLastIndex = 0;\r
1531 if (fgLastROB== -1) fgLastROB = fMCM.fROB;\r
1532 }\r
1533 else {\r
1534 Int_t matchingcounter = 0; \r
1535 for (Int_t i=fgLastIndex+1; i<16; i++) {\r
1536 if ( fMCM.fMCM == fgMCMordering[i] ) {\r
1537 fgLastIndex = i;\r
1538 matchingcounter++;\r
1539 break;\r
1540 }\r
1541 }\r
1542 if (matchingcounter == 0) {\r
1543 fMCM.fMCMhdCorrupted += 2;\r
1544 AliDebug(11,Form("MCM number from last MCM is larger: MCM # from current MCM %d \n", fMCM.fMCM));\r
1545 }\r
1546 } \r
1547 \r
1548 if ( fgLastHC == fHC->fLayer*2 + fHC->fSide ) {\r
1549 if ( fMCM.fROB < fgLastROB ) {\r
1550 if((fMCM.fMCMhdCorrupted & 2) == 0) fMCM.fMCMhdCorrupted += 2;\r
1551 AliDebug(11,Form("ROB number from last MCM is larger: ROB # from current MCM %d \n", fMCM.fROB));\r
1552 }\r
1553 else fgLastROB = fMCM.fROB;\r
1554 }\r
1555\r
1556 fgLastHC = fHC->fLayer*2 + fHC->fSide;\r
1557\r
1558 if (fEventCounter == 0) {\r
1559 fEventCounter = fMCM.fEvCounter;\r
1560 }\r
1561\r
1562 if (fEventCounter != fMCM.fEvCounter) {\r
1563 fMCM.fMCMhdCorrupted += 4;\r
1564 if (fgDebugFlag) AliDebug(11,Form("Event number(%d) of current MCM is different from that(%d) of reference MCM %s.\n"\r
1565 , fMCM.fEvCounter, fEventCounter, DumpMCMinfo(&fMCM)));\r
1566 }\r
1567\r
1568 if (fEventCounter < fLastEventCounter) {\r
1569 fMCM.fMCMhdCorrupted += 8;\r
1570 if (fgDebugFlag) AliDebug(11,Form("Event from the past? Current %d Last %d %s.\n", fEventCounter, fLastEventCounter, DumpMCMinfo(&fMCM)));\r
1571 }\r
1572\r
1573 if ( fMCM.fADCmaskCorrupted > 0 )\r
1574 return kFALSE;\r
1575\r
1576 if ( fMCM.fMCMhdCorrupted > 0 )\r
1577 return kFALSE;\r
1578\r
1579 return kTRUE;\r
1580}\r
1581\r
1582//------------------------------------------------------------\r
1583Bool_t AliTRDrawFastStream::DecodeADC(AliTRDdigitsManager *digitsManager, AliTRDarrayADC *digits, \r
1584 AliTRDarrayDictionary *track0, AliTRDarrayDictionary *track1, AliTRDarrayDictionary *track2, \r
1585 AliTRDSignalIndex *indexes)\r
1586{\r
1587 //\r
1588 // decode single ADC channel\r
1589 //\r
1590 if(fADCnumber%2==1) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL1);\r
1591 if(fADCnumber%2==0) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL2);\r
1592\r
1593 fTbinADC = 0;\r
1594 Bool_t isWritten = kFALSE;\r
1595\r
1596 for (Int_t iw = 0; iw < fMCM.fSingleADCwords; iw++) {\r
1597 if (HC_HEADER_MASK_ERR(*fpPos) == 0 || *fpPos == END_OF_TRACKLET_MARKERNEW) {\r
faad97e3 1598 if (fWarnError) AliError(Form("There should be ADC data. We meet HC header or END_OF_TRACKLET_MARKER 0x%08x",*fpPos));\r
e4ce0105 1599 fHC->fEOTECorrupted = kTRUE; \r
1600 fpPos--;\r
1601 return kFALSE;\r
1602 }\r
1603 if (fMaskADCword != ADC_WORD_MASK(*fpPos)) {\r
1604 if (fgDebugFlag) AliDebug(11,Form("Wrong ADC data mask! [Expected mask: 0x%08x Current mask: 0x%08x] ADC channel number: %02d MCM= %s ",\r
1605 fMaskADCword, ADC_WORD_MASK(*fpPos), fADCnumber, DumpMCMinfo(&fMCM)));\r
1606 // encode adc level error codes\r
1607 Int_t index = 21*(fMCM.fMCM + 16*int(fMCM.fROB/2)) + fADCnumber;\r
1608 fHC->fErrorCodes[index+66] += 1; \r
1609 if (!isWritten) { \r
1610 fHC->fErrorCodes[index+66] += (fADCnumber << 4);; \r
1611 fHC->fErrorCodes[index+66] += (fMCM.fMCM << 9);; \r
1612 fHC->fErrorCodes[index+66] += (fMCM.fROB << 13);; \r
1613 isWritten = kTRUE; \r
1614 }\r
1615 fMCM.fDataCorrupted = kTRUE;\r
1616 fHC->fDataCorrupted = kTRUE;\r
1617 fpPos++;\r
1618 continue;\r
1619 }\r
1620 // decode and put into the digit container\r
1621 Int_t adcSignals[3];\r
1622 adcSignals[0] = ((*fpPos & 0x00000ffc) >> 2);\r
1623 adcSignals[1] = ((*fpPos & 0x003ff000) >> 12);\r
1624 adcSignals[2] = ((*fpPos & 0xffc00000) >> 22);\r
1625\r
1626 if(GetCol() < 0 || (!fSharedPadsOn & fIsShared)) {fpPos++; continue;}; \r
38cb2aa7 1627\r
e4ce0105 1628 for (Int_t i = 0; i < 3; i++) {\r
38cb2aa7 1629 digits->SetDataByAdcCol(GetRow(), GetExtendedCol(), fTbinADC + i, adcSignals[i]);\r
1630 indexes->AddIndexRC(GetRow(), GetCol());\r
1631 if (digitsManager->UsesDictionaries()) {\r
1632 track0->SetData(GetRow(), GetCol(), fTbinADC + i, 0);\r
1633 track1->SetData(GetRow(), GetCol(), fTbinADC + i, 0);\r
1634 track2->SetData(GetRow(), GetCol(), fTbinADC + i, 0);\r
1635 }\r
e4ce0105 1636 } // i\r
1637 fTbinADC += 3;\r
1638 fpPos++;\r
1639 } // iw\r
1640\r
1641 return kTRUE;\r
1642}\r
1643\r
1644//------------------------------------------------------------\r
1645Bool_t AliTRDrawFastStream::DecodeADCExtended(AliTRDdigitsManager *digitsManager, AliTRDarrayADC *digits, \r
1646 AliTRDarrayDictionary *track0, AliTRDarrayDictionary *track1, AliTRDarrayDictionary *track2, \r
1647 AliTRDSignalIndex *indexes)\r
1648{\r
1649 //\r
1650 // decode single ADC channel\r
1651 //\r
1652 if(fADCnumber%2==1) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL1);\r
1653 if(fADCnumber%2==0) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL2);\r
1654\r
1655 Bool_t isWritten = kFALSE; //for error code recording\r
1656\r
1657 fTbinADC = ((*fpPos & 0x000000fc) >> 2);\r
1658 fMCM.fSingleADCwords = ((*fpPos & 0x00000f00) >> 8);\r
1659 \r
1660 Int_t adcFirst2Signals[2];\r
1661 adcFirst2Signals[0] = ((*fpPos & 0x003ff000) >> 12);\r
1662 adcFirst2Signals[1] = ((*fpPos & 0xffc00000) >> 22);\r
1663\r
1664 for (Int_t i = 0; i < 2; i++) {\r
38cb2aa7 1665 digits->SetDataByAdcCol(GetRow(), GetExtendedCol(), fTbinADC + i, adcFirst2Signals[i]);\r
1666 indexes->AddIndexRC(GetRow(), GetCol());\r
e4ce0105 1667 if (digitsManager->UsesDictionaries()) {\r
1668 track0->SetData(GetRow(), GetCol(), fTbinADC + i, 0);\r
1669 track1->SetData(GetRow(), GetCol(), fTbinADC + i, 0);\r
1670 track2->SetData(GetRow(), GetCol(), fTbinADC + i, 0);\r
1671 }\r
1672 } // i\r
1673\r
1674 fpPos++;\r
1675 for (Int_t iw = 0; iw < fMCM.fSingleADCwords-1; iw++) {\r
1676 if (HC_HEADER_MASK_ERR(*fpPos) == 0 || *fpPos == END_OF_TRACKLET_MARKERNEW) {\r
faad97e3 1677 if (fWarnError) AliError(Form("There should be ADC data. We meet HC header or END_OF_TRACKLET_MARKER 0x%08x",*fpPos));\r
e4ce0105 1678 fHC->fEOTECorrupted = kTRUE; \r
1679 fpPos--;\r
1680 return kFALSE;\r
1681 }\r
1682 if (fMaskADCword != ADC_WORD_MASK(*fpPos)) {\r
1683 if (fgDebugFlag) AliDebug(11,Form("Wrong ADC data mask! [Expected mask: 0x%08x Current mask: 0x%08x] ADC channel number: %02d MCM= %s ",\r
1684 fMaskADCword, ADC_WORD_MASK(*fpPos), fADCnumber, DumpMCMinfo(&fMCM)));\r
1685 // encode adc level error codes\r
1686 Int_t index = 21*(fMCM.fMCM + 16*int(fMCM.fROB/2)) + fADCnumber;\r
1687 fHC->fErrorCodes[index+66] += 1; \r
1688 if (!isWritten) { \r
1689 fHC->fErrorCodes[index+66] += (fADCnumber << 4);; \r
1690 fHC->fErrorCodes[index+66] += (fMCM.fMCM << 9);; \r
1691 fHC->fErrorCodes[index+66] += (fMCM.fROB << 13);; \r
1692 isWritten = kTRUE; \r
1693 }\r
1694 fMCM.fDataCorrupted = kTRUE;\r
1695 fHC->fDataCorrupted = kTRUE;\r
1696 fpPos++;\r
1697 continue;\r
1698 }\r
1699 // decode and put into the digit container\r
1700 Int_t adcSignals[3];\r
1701 adcSignals[0] = ((*fpPos & 0x00000ffc) >> 2);\r
1702 adcSignals[1] = ((*fpPos & 0x003ff000) >> 12);\r
1703 adcSignals[2] = ((*fpPos & 0xffc00000) >> 22);\r
1704\r
1705 if(GetCol() < 0 || (!fSharedPadsOn & fIsShared)) {fpPos++; continue;}; \r
1706 for (Int_t i = 0; i < 3; i++) {\r
38cb2aa7 1707 digits->SetDataByAdcCol(GetRow(), GetExtendedCol(), fTbinADC + 2 + i, adcSignals[i]);\r
1708 indexes->AddIndexRC(GetRow(), GetCol());\r
1709 if (digitsManager->UsesDictionaries()) {\r
1710 track0->SetData(GetRow(), GetCol(), fTbinADC + 2 + i, 0);\r
1711 track1->SetData(GetRow(), GetCol(), fTbinADC + 2 + i, 0);\r
1712 track2->SetData(GetRow(), GetCol(), fTbinADC + 2 + i, 0);\r
1713 }\r
e4ce0105 1714 } // i\r
1715 fTbinADC += 3;\r
1716 fpPos++;\r
1717 } // iw\r
1718\r
1719 return kTRUE;\r
1720}\r
1721\r
1722//------------------------------------------------------------\r
1723Bool_t AliTRDrawFastStream::SeekEndOfData()\r
1724{\r
1725 //\r
1726 // go to end of data marker\r
1727 //\r
1728 Int_t fEndOfDataCount = 0;\r
1729 fNWordsCounter = 0;\r
1730\r
1731 while ( *fpPos != ENDOFRAWDATAMARKER && fpPos < fpEnd ) {\r
1732 fpPos++;\r
1733 fNWordsCounter++;\r
1734 }\r
1735 while (*fpPos == ENDOFRAWDATAMARKER && fpPos < fpEnd ) {\r
1736 fEndOfDataCount++;\r
1737 fpPos++;\r
1738 }\r
1739\r
1740 return kTRUE;\r
1741}\r
1742\r
1743//------------------------------------------------------------\r
1744Bool_t AliTRDrawFastStream::SeekNextMCMheader()\r
1745{\r
1746 //\r
1747 // go to mcm marker\r
1748 //\r
1749 fpPos++;\r
1750\r
1751 while ( *fpPos != ENDOFRAWDATAMARKER && fpPos < fpEnd ) {\r
1752 if (MCM_HEADER_MASK_ERR(*fpPos) == 0 && MCM_HEADER_MASK_ERR(*(fpPos+1)) == 0) {\r
1753 if (fgDebugFlag) AliDebug(11,Form("Found : Pos 0x%08x : Val 0x%08x", fpPos, *fpPos));\r
1754 return kTRUE;\r
1755 }\r
1756 if ( *fpPos == END_OF_TRACKLET_MARKERNEW) {\r
1757 fHC->fEOTECorrupted = kTRUE;\r
1758 return kFALSE;\r
1759 }\r
1760 fpPos++;\r
1761 }\r
1762\r
1763 SeekEndOfData();\r
1764 return kFALSE;\r
1765}\r
1766\r
1767//------------------------------------------------------------\r
1768Bool_t AliTRDrawFastStream::SkipMCMdata(UInt_t iw)\r
1769{\r
1770 //\r
1771 // skip mcm data words due to corruption\r
1772 //\r
1773 if (fgDebugFlag) AliDebug(11,Form("Skip %d words due to MCM header corruption.",iw));\r
1774 UInt_t iwcounter = 0;\r
1775 while ( *fpPos != ENDOFRAWDATAMARKER && iwcounter < iw) {\r
1776 if ( *fpPos == END_OF_TRACKLET_MARKERNEW) {\r
1777 if (fgDebugFlag) AliDebug(11,"Met END_OF_TRACKLET_MARKERNEW");\r
1778 fHC->fEOTECorrupted = kTRUE;\r
1779 return kFALSE;\r
1780 }\r
1781 fpPos++;\r
1782 iwcounter++;\r
1783 } // while\r
1784\r
1785 if (iwcounter == iw) {\r
1786 fpPos++;\r
1787 return kTRUE;\r
1788 }\r
1789\r
1790 if (fgDebugFlag) AliDebug(11,"Met ENDOFRAWDATAMARKER");\r
1791 return kFALSE;\r
1792}\r
1793\r
1794//------------------------------------------------------------\r
1795Bool_t AliTRDrawFastStream::SetGlobalNTimebins()\r
1796{\r
b48576ab 1797 // get number of time bin info from HC headers then set \r
e4ce0105 1798 Int_t nHCs=0;\r
1799 while (SetNTimebins()==kFALSE){\r
1800 if (fgDebugFlag) AliDebug(11,Form("Failed to get number of time bin information from the %sth HC",nHCs));\r
1801 nHCs++;\r
1802 }\r
1803\r
1804 return kTRUE;\r
1805}\r
1806\r
1807//------------------------------------------------------------\r
1808Bool_t AliTRDrawFastStream::SetNTimebins()\r
1809{\r
1810 // goes to the HC header position\r
1811 while (!(*fpPosTemp == END_OF_TRACKLET_MARKERNEW) && fpPosTemp < fpEnd) {\r
1812 fpPosTemp++;\r
1813 }\r
1814 while (*fpPosTemp == END_OF_TRACKLET_MARKERNEW) {\r
1815 fpPosTemp++;\r
1816 }\r
1817 // skip H0 \r
1818 fpPosTemp++;\r
1819\r
1820 UInt_t vword = *fpPosTemp;\r
1821\r
1822 // get the number of time bins \r
1823 if (HC_HEADER_MASK_ERR(vword) == 0) {\r
1824 fGlobalNTimeBins = HC_NTIMEBINS(vword);\r
1825 if (fGlobalNTimeBins > 64 || fGlobalNTimeBins < 10) return kFALSE; // minimal protection\r
1826 }\r
1827 else\r
1828 return kFALSE;\r
1829\r
1830 return kTRUE;\r
1831}\r
1832\r
1833//------------------------------------------------------------\r
1834Bool_t AliTRDrawFastStream::DumpWords(UInt_t *px, UInt_t iw, UInt_t marker)\r
1835{\r
1836 //\r
1837 // dump given number of words for debugging\r
1838 //\r
1839 TString tsreturn = Form("\n[ Dump Sequence at 0x%08x ] : ", px);\r
1840 for (UInt_t i = 0; i < iw; i++) {\r
1841 if ( iw != 0 && px + iw > fpEnd) \r
1842 return kFALSE;\r
1843 if (i % 8 == 0) tsreturn += "\n ";\r
1844 if (marker != 0 && marker == px[i]) tsreturn += Form(" *>0x%08x<* ", px[i]);\r
1845 else tsreturn += Form("0x%08x ", px[i]);\r
1846 }\r
1847 tsreturn += "\n";\r
1848\r
1849 AliInfo(tsreturn.Data());\r
1850\r
1851 return kTRUE;\r
1852}\r
1853\r
1854//--------------------------------------------------------\r
1855const char *AliTRDrawFastStream::DumpSMInfo(const struct AliTRDrawSM *sm)\r
1856{\r
1857 //\r
1858 // format the string with the sm info\r
1859 //\r
1860 return Form("[ SM Info 0x%08x] : Hsize %d TrackletEnable %d Stacks %d %d %d %d %d",\r
1861 *sm->fPos, sm->fHeaderSize, sm->fTrackletEnable,\r
1862 sm->fStackActive[0], sm->fStackActive[1], sm->fStackActive[2],\r
1863 sm->fStackActive[3], sm->fStackActive[4]); \r
1864}\r
1865\r
1866//--------------------------------------------------------\r
1867const char *AliTRDrawFastStream::DumpStackInfo(const struct AliTRDrawStack *st)\r
1868{\r
1869 //\r
1870 // format the string with the stack info\r
1871 //\r
1872 return Form("[ Stack Info 0x%08x ] : Hsize %d Links Active %d %d %d %d %d %d %d %d %d %d %d %d",\r
1873 *st->fPos, st->fHeaderSize,\r
1874 st->fLinksActive[0], st->fLinksActive[1], st->fLinksActive[2], st->fLinksActive[3],\r
1875 st->fLinksActive[4], st->fLinksActive[5], st->fLinksActive[6], st->fLinksActive[7],\r
1876 st->fLinksActive[8], st->fLinksActive[9], st->fLinksActive[10], st->fLinksActive[11]);\r
1877\r
1878}\r
1879//--------------------------------------------------------\r
1880const char *AliTRDrawFastStream::DumpHCinfoH0(const struct AliTRDrawHC *hc)\r
1881{\r
1882 //\r
1883 // dump the hc header word 0 in strings\r
1884 //\r
1885 if (!hc)\r
1886 return Form("Unable to dump. Null received as parameter!?!");\r
1887 else\r
1888 return Form("[ HC[0] at 0x%08x ] : 0x%08x Info is : RawV %d SM %d Stack %d Layer %d Side %d DCSboard %d",\r
1889 hc->fPos[0], *(hc->fPos[0]), hc->fRawVMajor, hc->fSM, hc->fStack, hc->fLayer, hc->fSide, hc->fDCSboard);\r
1890}\r
1891\r
1892//--------------------------------------------------------\r
1893const char *AliTRDrawFastStream::DumpHCinfoH1(const struct AliTRDrawHC *hc)\r
1894{\r
1895 //\r
1896 // dump the hc header word 1 in strings\r
1897 //\r
1898 if (!hc)\r
1899 return Form("Unable to dump. Null received as parameter!?!");\r
1900 else\r
1901 return Form("[ HC[1] at 0x%08x ] : 0x%08x Info is : TBins %d BCcount %d PreTrigCount %d PreTrigPhase %d",\r
1902 hc->fPos[1], *(hc->fPos[1]), hc->fTimeBins, hc->fBunchCrossCounter, hc->fPreTriggerCounter, hc->fPreTriggerPhase);\r
1903}\r
1904\r
1905//--------------------------------------------------------\r
1906const char *AliTRDrawFastStream::DumpMCMinfo(const struct AliTRDrawMCM *mcm)\r
1907{\r
1908 //\r
1909 // dump mcm info in strings\r
1910 //\r
1911 if (!mcm)\r
1912 return Form("Unable to dump. Null received as parameter!?!");\r
1913 else\r
1914 return Form("[ MCM 0x%08x ] : ROB %d MCM %d EvCounter %d", *(mcm->fPos), mcm->fROB, mcm->fMCM, mcm->fEvCounter);\r
1915}\r
1916\r
1917//--------------------------------------------------------\r
1918const char *AliTRDrawFastStream::DumpMCMadcMask(const struct AliTRDrawMCM *mcm)\r
1919{\r
1920 //\r
1921 // mcm adc mask in strings\r
1922 //\r
1923 if (!mcm)\r
1924 return Form("Unable to dump. Null received as parameter!?!");\r
1925\r
1926 TString tsreturn = Form("[Word] : 0x%08x => [Mask] : 0x%08x : ", mcm->fADCMaskWord, mcm->fADCMask);\r
1927 for (Int_t i = 0; i < TRDMAXADC; i++) {\r
1928 tsreturn += Form("%d ", mcm->fADCchannel[i]);\r
1929 }\r
1930 tsreturn += "";\r
1931 return tsreturn.Data();\r
1932}\r
1933\r
1934\r