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