]> 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
Changed default values of cuts
[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
552 fMCM->fMCMADCWords = 0;\r
553 fMCM->fSingleADCwords = 0;\r
554 fMCM->fMCMhdCorrupted = 0;\r
555 fMCM->fADCmaskCorrupted = 0;\r
556 fMCM->fCorrupted = 0;\r
557 fMCM->fPos = NULL;\r
558 fMCM->fAdcDataPos = NULL;\r
559 fMCM->fADCcounter = 0;\r
560\r
561 memset(fMCM->fADCchannel, 0, TRDMAXADC*sizeof(UInt_t));\r
562}\r
563\r
564//------------------------------------------------------------\r
565void AliTRDrawStream::ResetPerADC()\r
566{\r
567 //\r
568 // reset every ADC \r
569 //\r
570 fADC->fPos = NULL;\r
571 fADC->fADCnumber = 0;\r
572 fADC->fExtendedCOL = 0;\r
573 fADC->fCOL = 0;\r
574 fADC->fIsShared = kTRUE;\r
575 fADC->fCorrupted = 0;\r
576\r
577 //memset(fADC->fSignals, 0, GetNumberOfTimeBins()*sizeof(Int_t));\r
578 memset(fADC->fSignals, 0, TRDMAXTBINS*sizeof(Int_t)); \r
579}\r
580\r
581//------------------------------------------------------------\r
582void AliTRDrawStream::ResetMemory()\r
583{ \r
584 // \r
585 // initialize all the data members to prevent read data from memory for previous buffer \r
586 // \r
587 ResetPerSM();\r
588 for (Int_t istack=0; istack<5; istack++){\r
589 fStack = &fSM.fStacks[istack];\r
590 ResetPerStack();\r
591 for (Int_t ilink=0; ilink<12; ilink++){\r
592 fHC = &fStack->fHalfChambers[ilink];\r
593 ResetPerHC();\r
594 for (Int_t imcm=0; imcm<TRDMAXMCM; imcm++){\r
595 fMCM = &fHC->fMCMs[imcm];\r
596 ResetPerMCM();\r
597 for (Int_t iadc=0; iadc<TRDMAXADC; iadc++){\r
598 fADC = &fMCM->fADCs[iadc];\r
599 ResetPerADC();\r
600 } // iadc\r
601 } // imcm\r
602 } // ilink \r
603 } // istack\r
604} \r
605\r
606//------------------------------------------------------------\r
607Bool_t AliTRDrawStream::Next()\r
608{\r
609 //\r
610 // returns with true on next adc read\r
611 // returns false on errors and end of buffer\r
612 // \r
613 if (fBufferRead) {\r
614 while (fStackNumber < 5 && fSM.fActiveStacks > 0) {\r
615 if (fSM.fStackActive[fStackNumber] == kTRUE) {\r
616 fStack = &fSM.fStacks[fStackNumber];\r
617 while (fStackLinkNumber < 12) {\r
618 if (fStack->fLinksActive[fStackLinkNumber] == kTRUE && fStack->fLinksMonitor[fStackLinkNumber] == 0) {\r
619 fHC = &fStack->fHalfChambers[fStackLinkNumber];\r
620 if (!fHC) {\r
621 AliError(Form("HC missing at stack %d link %d", fStackNumber, fStackLinkNumber));\r
622 return kFALSE;\r
623 }\r
624 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
625 while (fhcMCMcounter < fHC->fMCMmax) {\r
626 fMCM = &fHC->fMCMs[fhcMCMcounter];\r
627 if (!fMCM) {\r
628 AliError(Form("HC missing at stack %d link %d atMCMslot %d", \r
629 fStackNumber, fStackLinkNumber, fhcMCMcounter));\r
630 return kFALSE;\r
631 }\r
632 while(fmcmADCcounter < fMCM->fADCmax) {\r
633 fADC = &fMCM->fADCs[fmcmADCcounter];\r
634 if (!fADC) {\r
635 AliError(Form("ADC missing at stack %d link %d MCMslot %d ADCslot %d", \r
636 fStackNumber, fStackLinkNumber, fhcMCMcounter, fmcmADCcounter));\r
637 return kFALSE;\r
638 }\r
639 fmcmADCcounter++;\r
640 if (fSharedPadsOn) {\r
641 return kTRUE;\r
642 }\r
643 else {\r
644 if (fADC->fIsShared == kFALSE)\r
645 return kTRUE;\r
646 }\r
647 } // while fmcmADCcounter\r
648 fhcMCMcounter++;\r
649 fmcmADCcounter = 0; // next MCM should go through all active ADCs - start from 0\r
650 } // while fhcMCMcounter\r
651 } // if HC OK\r
652 } // if link active\r
653 fStackLinkNumber++;\r
654 fhcMCMcounter = 0; // next stack link (HC) should go through all active MCMs - start from 0\r
655 } // while fStackLinkNumber\r
656 } // if stack active\r
657 fStackNumber++;\r
658 fStackLinkNumber = 0; // next stack should go through all links - start from 0\r
659 } // while fStackNumber\r
660 } // if fBufferRead\r
661\r
662 // in case rawreader manages the mem buffers, go for the next buffer \r
663 if (fRawReader) {\r
664 Int_t nextBuff = NextBuffer();\r
665 while (nextBuff != -1) {\r
666 if (nextBuff > 0) {\r
667 fBufferRead = kTRUE;\r
668 return Next(); \r
669 }\r
670 nextBuff = NextBuffer();\r
671 }\r
672 }\r
673\r
674 return kFALSE;\r
675}\r
676\r
677//------------------------------------------------------------\r
4f9b0c90 678Int_t AliTRDrawStream::NextChamber(AliTRDdigitsManager *const digitsManager, UInt_t **trackletContainer, UShort_t **/*errorCodeContainer*/) \r
e4ce0105 679{\r
680 //\r
681 // Fills single chamber digit array \r
682 // Return value is the detector number\r
683 //\r
684 AliTRDarrayADC *digits = 0;\r
685 AliTRDarrayDictionary *track0 = 0;\r
686 AliTRDarrayDictionary *track1 = 0;\r
687 AliTRDarrayDictionary *track2 = 0; \r
688 AliTRDSignalIndex *indexes = 0;\r
689 AliTRDdigitsParam *digitsparam = 0;\r
690\r
691 // Loop through the digits\r
692 Int_t lastdet = -1;\r
693 Int_t det = -1;\r
694 Int_t lastside = -1; \r
695 Int_t side = -1;\r
696 Int_t it = 0;\r
697 Int_t ntracklets = 0;\r
698\r
699 if (trackletContainer) { \r
700 for (Int_t i = 0; i < 2; i++) \r
701 for (Int_t j = 0; j < MAXTRACKLETSPERHC; j++) \r
702 trackletContainer[i][j] = 0; \r
703 }\r
704\r
705 while (Next()) {\r
706 det = GetDet();\r
707 side = GetSide();\r
708\r
709 if (trackletContainer) {\r
710 if ((det + side*AliTRDgeometry::kNdet) != (lastdet + lastside*AliTRDgeometry::kNdet)) {\r
711 if (det != lastdet) {\r
712 if (lastdet != -1) {\r
713 fmcmADCcounter--; \r
714 return lastdet;\r
715 }\r
716 }\r
717 ntracklets = GetNTracklets();\r
718 if (ntracklets > 0) memcpy(trackletContainer[side], GetTrackletWords(), sizeof(UInt_t) * ntracklets); //copy tracklet words to trackletContainer array\r
719 lastside = side; \r
720 } \r
721 } \r
722\r
723 if (det != lastdet) {\r
724 // If new detector found\r
725 if (lastdet == -1) {\r
726 lastdet = det;\r
727 fLastHC = fHC;\r
728 }\r
729 else {\r
730 fmcmADCcounter--; \r
731 fHC = fLastHC ;\r
732 return lastdet;\r
733 }\r
734\r
735 if (det < 0 || det >= AliTRDgeometry::kNdet) {\r
736 if (fSM.fClean == kTRUE) {\r
737 AliError(Form("Strange Det Number %d BUT event buffer seems to be clean.", det));\r
738 }\r
739 else {\r
740 AliError(Form("Strange Det Number %d. Event buffer marked NOT clean!", det));\r
741 }\r
742 continue;\r
743 }\r
744\r
745 // Add a container for the digits of this detector\r
746 digits = (AliTRDarrayADC *) digitsManager->GetDigits(det);\r
747\r
748 if (digitsManager->UsesDictionaries()) {\r
749 track0 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,0);\r
750 track1 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,1);\r
751 track2 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,2);\r
752 }\r
753\r
754 if (!digits) {\r
755 if (fSM.fClean == kTRUE) {\r
756 AliError(Form("Unable to get digits for det %d BUT event buffer seems to be clean.", det));\r
757 }\r
758 else {\r
759 AliError(Form("Unable to get digits for det %d. Event buffer is NOT clean!", det));\r
760 }\r
761 return -1;\r
762 }\r
763\r
764 //Int_t rowMax = GetRowMax();\r
765 Int_t rowMax = fGeometry->RowmaxC1(); // we use maximum row number among all detectors to reuse memory\r
766 Int_t colMax = GetColMax();\r
767 Int_t ntbins = GetNumberOfTimeBins();\r
768\r
769 // Set digitparam variables\r
770 digitsparam = (AliTRDdigitsParam *) digitsManager->GetDigitsParam();\r
771 digitsparam->SetPretiggerPhase(det,GetPreTriggerPhase());\r
772 if (!fIsGlobalDigitsParamSet){\r
773 digitsparam->SetCheckOCDB(kFALSE);\r
774 digitsparam->SetNTimeBins(ntbins);\r
775 fCommonAdditive=10;\r
776 digitsparam->SetADCbaseline(fCommonAdditive);\r
777 fIsGlobalDigitsParamSet = kTRUE;\r
778 }\r
779\r
780 // Allocate memory space for the digits buffer\r
781 if (digits->GetNtime() == 0) {\r
782 digits->Allocate(rowMax, colMax, ntbins);\r
783 if (digitsManager->UsesDictionaries()) {\r
784 track0->Allocate(rowMax, colMax, ntbins);\r
785 track1->Allocate(rowMax, colMax, ntbins);\r
786 track2->Allocate(rowMax, colMax, ntbins);\r
787 }\r
788 }\r
789\r
790 indexes = digitsManager->GetIndexes(det);\r
791 indexes->SetSM(GetSM());\r
792 indexes->SetStack(GetStack());\r
793 indexes->SetLayer(GetLayer());\r
794 indexes->SetDetNumber(det);\r
795 if (indexes->IsAllocated() == kFALSE)\r
796 indexes->Allocate(rowMax, colMax, ntbins);\r
797 }\r
798\r
799 // ntimebins data are ready to read\r
800 for (it = 0; it < GetNumberOfTimeBins(); it++) {\r
38cb2aa7 801 digits->SetDataByAdcCol(GetRow(), GetExtendedCol(), it, GetSignals()[it]);\r
802 if (!(GetCol()<0)) indexes->AddIndexRC(GetRow(), GetCol());\r
803 if (digitsManager->UsesDictionaries()) {\r
804 track0->SetData(GetRow(), GetCol(), it, 0);\r
805 track1->SetData(GetRow(), GetCol(), it, 0);\r
806 track2->SetData(GetRow(), GetCol(), it, 0);\r
e4ce0105 807 }\r
808 } // it\r
809 } // while Next()\r
810\r
811 return det;\r
812}\r
813\r
814//------------------------------------------------------------\r
815Bool_t AliTRDrawStream::Init()\r
816{\r
817 //\r
818 // Initialize geometry and fee parameters \r
819 //\r
820 TDirectory *saveDir = gDirectory; \r
821 \r
822 if (!fGeometry) {\r
823 fGeometry = new AliTRDgeometry();\r
824 if (!fGeometry) {\r
825 AliError("Geometry FAILED!");\r
826 return kFALSE;\r
827 }\r
828 }\r
829\r
830 fTRDfeeParam = AliTRDfeeParam::Instance();\r
831 if (!fTRDfeeParam) {\r
832 AliError("AliTRDfeeParam FAILED!");\r
833 return kFALSE;\r
834 }\r
835\r
836 fMaxADCgeom = (Int_t)fGeometry->ADCmax();\r
837\r
838 ResetCounters(); // fBufferRead is set to kFALSE - important\r
839\r
840 saveDir->cd();\r
841\r
842 return kTRUE;\r
843}\r
844\r
845//------------------------------------------------------------\r
846Bool_t AliTRDrawStream::InitBuffer(void * const buffer, UInt_t length)\r
847{\r
848 // \r
849 // set initial information about the buffer\r
850 //\r
851 if (fgDebugFlag) AliDebug(5, Form("Equipment ID: %d",fRawReader->GetEquipmentId()));\r
852 if (fRawReader->GetEquipmentId()<1024 || fRawReader->GetEquipmentId()>1041) // tmp protection\r
853 return kFALSE; \r
854\r
855 if (WORD_SIZE == 0) {\r
856 AliFatal("Strange word size. size of UInt_t == 0");\r
857 return kFALSE;\r
858 }\r
859\r
860 ResetCounters();\r
861\r
862 fpBegin = (UInt_t *)buffer;\r
863 fWordLength = length/WORD_SIZE;\r
864 fpEnd = fpBegin + fWordLength;\r
865 fpPos = fpBegin;\r
866\r
867 if (fpBegin == 0 || length <= 0) {\r
868 AliError(Form("Buffer size or pointer is strange. pointer to the buffer is 0x%08x of size %d", fpBegin, length));\r
869 return kFALSE;\r
870 }\r
871\r
872 SwapOnEndian();\r
873\r
874 if (fgDumpHead >= 0) {\r
875 if ( fgDumpHead == 0 ) { // dump all words\r
876 AliInfo(Form("---------- Dumping all words from the beginnig of the buffer ----------"));\r
877 if (DumpWords(fpBegin, fWordLength) == kFALSE) AliError("Dump failed. Not enough data.");\r
878 } \r
879 else {\r
880 AliInfo(Form("---------- Dumping %u words from the beginnig of the buffer ----------",fgDumpHead));\r
881 if (DumpWords(fpBegin, fgDumpHead) == kFALSE) AliError("Dump failed. Not enough data.");\r
882 }\r
883 AliInfo(Form("---------- Dumping ended ----------------------------------------------"));\r
884 }\r
885\r
886 return kTRUE;\r
887}\r
888\r
889//------------------------------------------------------------\r
890Bool_t AliTRDrawStream::DecodeGTUheader()\r
891{\r
892 // Decode Supermodule Index Word\r
893 DecodeSMInfo(fpPos, &fSM);\r
894\r
895 if (fgDebugFlag) AliDebug(5, DumpSMInfo(&fSM));\r
896\r
897 fpPos++;\r
898 if (fpPos < fpEnd) {\r
899 // fSM.fHeaderSize represent additional Supermodule header size which contains additional information regarding hardware design.\r
900 // For the moment, we skip decoding these words \r
901 if (SkipWords(fSM.fHeaderSize) == kTRUE) {\r
902 for (Int_t istack = 0; istack < 5; istack++) {\r
903 if (fSM.fStackActive[istack] == kFALSE)\r
904 continue;\r
905\r
906 fStack = &fSM.fStacks[istack];\r
907\r
908 // Decode Stack Index Word of given stack\r
909 DecodeStackInfo(fpPos, fStack);\r
910 fpPos++;\r
911\r
912 fSM.fNexpectedHalfChambers += fStack->fActiveLinks;\r
913 \r
914 if (fgDebugFlag) AliDebug(5, DumpStackInfo(fStack));\r
915 \r
916 if (SkipWords(fStack->fHeaderSize-6) == kFALSE) { // 6 is the 6 stack header words for 12 links \r
917 if (fRawReader) fRawReader->AddMajorErrorLog(kDecodeStackInfo, "Stack header words missing");\r
918 return kFALSE;\r
919 }\r
920 for (Int_t iword=0; iword<6; iword++) { // decode 6 stack header words\r
921 // Decode Stack Header Word of given stack\r
922 DecodeStackHeader(fpPos, fStack, iword); \r
923 fpPos++;\r
924 }\r
925 }\r
926 }\r
927 else {\r
928 return kFALSE;\r
929 }\r
930 }\r
931 else {\r
faad97e3 932 if (fWarnError) AliWarning("No additional sm headers and stack index words present.");\r
e4ce0105 933 if (fRawReader) fRawReader->AddMajorErrorLog(kDecodeStackInfo, "Stack info missing");\r
934 return kFALSE;\r
935 }\r
936\r
937 if (fpPos < fpEnd) {\r
938 if (fgDebugFlag) AliDebug(5, "GTU headers are OK.");\r
939 }\r
940 else {\r
faad97e3 941 if (fWarnError) AliWarning("No data just after GTU headers.");\r
e4ce0105 942 if (fRawReader) fRawReader->AddMajorErrorLog(kMissingData, "Missing sm data");\r
943 return kFALSE;\r
944 }\r
945\r
946 if (fgDebugFlag) AliDebug(5, Form("Expected half chambers from GTU header: %d", fSM.fNexpectedHalfChambers));\r
947\r
948 return kTRUE;\r
949}\r
950\r
951//------------------------------------------------------------\r
952Bool_t AliTRDrawStream::DecodeSM(void * const buffer, UInt_t length)\r
953{\r
954 //\r
955 // decode one sm data in buffer\r
956 //\r
957 ResetIterators(); \r
958\r
959 fSM.fClean = kTRUE;\r
960 if (InitBuffer(buffer, length) == kFALSE) {\r
faad97e3 961 if (fWarnError) AliError("InitBuffer failed."); \r
e4ce0105 962 fSM.fClean = kFALSE;\r
963 return kFALSE;\r
964 }\r
965\r
966 if (DecodeGTUheader()== kFALSE)\r
967 return kFALSE;\r
968\r
969 for (Int_t istack = 0; istack < 5; istack++) {\r
970 fStackNumber = istack; \r
971 if (fSM.fStackActive[istack] == kFALSE)\r
972 continue;\r
973 \r
974 fStack = &fSM.fStacks[istack];\r
975\r
976 fgLastHC = -1; // to check rob number odering \r
977 for (Int_t ilink = 0; ilink < 12; ilink++) {\r
978 fStackLinkNumber = ilink; \r
979 if (fStack->fLinksActive[ilink] == kFALSE)\r
980 continue;\r
981\r
982 // check GTU link monitor \r
983 if (!(fStack->fLinksDataType[ilink] == 0 && fStack->fLinksMonitor[ilink] == 0)) {\r
984 fStack->fLinkMonitorError[ilink] = 1;\r
985 SeekEndOfData(); // skip this HC data if GTU link monitor report error\r
986 fStack->fLinkMonitorError[ilink] += fNWordsCounter; // counts words of given hc having link monitor error\r
987 continue; \r
988 }\r
989\r
990 if (fpPos >= fpEnd) {\r
991 if (fRawReader) fRawReader->AddMajorErrorLog(kLinkDataMissing, "Link data missing"); \r
faad97e3 992 if (fWarnError) AliError("Link data missing."); \r
e4ce0105 993 fSM.fClean = kFALSE;\r
994 break;\r
995 }\r
996\r
997 fHC = &fStack->fHalfChambers[ilink];\r
998 ResetPerHC();\r
999\r
1000 if (fSM.fTrackletEnable == kTRUE) {\r
1001 if (DecodeTracklets() == kFALSE) {\r
1002 fSM.fClean = kFALSE;\r
1003 SeekEndOfData();\r
1004\r
faad97e3 1005 if (fWarnError) {\r
e4ce0105 1006 AliError(Form("Tracklet decoding failed stack %d link %d", fStackNumber, fStackLinkNumber));\r
1007 }\r
1008 continue;\r
1009 }\r
1010 }\r
1011\r
1012 if (fpPos >= fpEnd) {\r
1013 if (fRawReader) fRawReader->AddMajorErrorLog(kHCdataMissing, "HC data missing"); \r
faad97e3 1014 if (fWarnError) AliError("HC data missing."); \r
e4ce0105 1015 fSM.fClean = kFALSE;\r
1016 break;\r
1017 }\r
1018 \r
1019 fgLastROB = -1; // to check mcm number odering \r
1020 fgLastIndex = -1 ; // to check mcm number odering \r
1021 if (DecodeHC() == kFALSE) {\r
1022 fSM.fClean = kFALSE;\r
1023 if (fHC->fCorrupted < 16) SeekEndOfData(); // In case that we meet END_OF_TRACKLET_MARKERNEW \r
1024 // during ADC data decoding or MCM header decoding\r
1025 // we don't seek ENDOFRAWDATAMARKER\r
faad97e3 1026 if (fWarnError) {\r
e4ce0105 1027 AliError(Form("Failed HC : %s", DumpHCinfoH0(fHC)));\r
1028 AliError(Form("Failed HC : %s", DumpHCinfoH1(fHC)));\r
1029 }\r
1030 \r
1031 continue;\r
1032 }\r
1033 else {\r
1034 SeekEndOfData(); // make sure that finish off with the end of data markers\r
1035 }\r
1036 } // ilink\r
1037 } // istack\r
1038\r
1039 ResetIterators(); // need to do it again for Next() function \r
1040\r
1041 if (fSM.fClean == kTRUE)\r
1042 return kTRUE;\r
1043 \r
1044 if (fgCleanDataOnly && (fSM.fClean == kFALSE)) {\r
faad97e3 1045 if (fWarnError) {\r
e4ce0105 1046 AliWarning("Buffer with errors. Returning FALSE.");\r
1047 AliWarning(Form("--- Failed SM : %s ---", DumpSMInfo(&fSM)));\r
1048 }\r
1049 fSM.fActiveStacks = 0; // Next() will not give data\r
1050 return kFALSE;\r
1051 }\r
1052\r
1053 return kTRUE;\r
1054}\r
1055\r
1056//------------------------------------------------------------\r
1057Int_t AliTRDrawStream::DecodeSM()\r
1058{\r
1059 //\r
1060 // decode SM data in case AliRawReader is in use\r
1061 // \r
1062 if (fRawReader) {\r
1063 Int_t nextBuff = NextBuffer();\r
1064 while (nextBuff != -1) {\r
1065 if (nextBuff > 0)\r
1066 return nextBuff; \r
1067 nextBuff = NextBuffer();\r
1068 }\r
1069 return -1;\r
1070 }\r
1071 else {\r
1072 AliWarning("AliRawReader not set.");\r
1073 }\r
1074\r
1075 return kFALSE;\r
1076}\r
1077\r
1078//------------------------------------------------------------\r
1079Int_t AliTRDrawStream::DecodeSM(AliRawReader *reader)\r
1080{\r
1081 //\r
1082 // decode SM with the AliRawReader\r
1083 //\r
1084 if (reader != 0) {\r
1085 fRawReader = reader;\r
1086 return DecodeSM();\r
1087 }\r
1088 else {\r
1089 AliWarning("Argument AliRawReader is 0.");\r
1090 }\r
1091\r
1092 return kFALSE;\r
1093}\r
1094\r
1095//------------------------------------------------------------\r
1096Bool_t AliTRDrawStream::SeekEndOfData()\r
1097{\r
1098 //\r
1099 // go to end of data marker\r
1100 //\r
1101 Int_t fEndOfDataCount = 0;\r
1102 fNWordsCounter = 0;\r
1103\r
1104 while ( *fpPos != ENDOFRAWDATAMARKER && fpPos < fpEnd ) {\r
1105 fpPos++;\r
1106 fNWordsCounter++;\r
1107 }\r
1108 while (*fpPos == ENDOFRAWDATAMARKER && fpPos < fpEnd ) {\r
1109 fEndOfDataCount++;\r
1110 fpPos++; \r
1111 }\r
1112 \r
1113 return kTRUE;\r
1114}\r
1115\r
1116//------------------------------------------------------------\r
1117Bool_t AliTRDrawStream::SkipMCMdata(UInt_t iw)\r
1118{\r
1119 //\r
1120 // skip mcm data words due to corruption \r
1121 //\r
1122 if (fgDebugFlag) AliDebug(11,Form("Skip %d words due to MCM header corruption.",iw));\r
1123 UInt_t iwcounter = 0; \r
1124 while ( *fpPos != ENDOFRAWDATAMARKER && iwcounter < iw) {\r
1125 if ( *fpPos == END_OF_TRACKLET_MARKERNEW) {\r
1126 if (fgDebugFlag) AliDebug(11,"Met END_OF_TRACKLET_MARKERNEW");\r
1127 fMCM->fCorrupted += 16;\r
1128 fHC->fCorrupted += 16;\r
1129 return kFALSE;\r
1130 } \r
1131 fpPos++;\r
1132 iwcounter++; \r
1133 }\r
1134\r
1135 if (iwcounter == iw) {\r
1136 fpPos++;\r
1137 return kTRUE;\r
1138 }\r
1139\r
1140 if (fgDebugFlag) AliDebug(11,"Met ENDOFRAWDATAMARKER");\r
1141\r
1142 return kFALSE;\r
1143}\r
1144\r
1145//------------------------------------------------------------\r
1146Bool_t AliTRDrawStream::SeekNextMCMheader()\r
1147{\r
1148 //\r
1149 // go to mcm marker\r
1150 //\r
1151 fpPos++;\r
1152\r
1153 while ( *fpPos != ENDOFRAWDATAMARKER && fpPos < fpEnd ) {\r
1154 if (MCM_HEADER_MASK_ERR(*fpPos) == 0 && MCM_HEADER_MASK_ERR(*(fpPos+1)) == 0) { \r
1155 if (fgDebugFlag) AliDebug(11,Form("^^^ Found : Pos 0x%08x : Val 0x%08x", fpPos, *fpPos));\r
1156 return kTRUE;\r
1157 }\r
1158 if ( *fpPos == END_OF_TRACKLET_MARKERNEW) {\r
1159 fMCM->fCorrupted += 16;\r
1160 fHC->fCorrupted += 16;\r
1161 return kFALSE;\r
1162 } \r
1163 fpPos++;\r
1164 }\r
1165\r
1166 SeekEndOfData();\r
1167\r
1168 return kFALSE;\r
1169}\r
1170\r
1171//------------------------------------------------------------\r
1172Bool_t AliTRDrawStream::DecodeTracklets()\r
1173{\r
1174 //\r
1175 // decode tracklets\r
1176 //\r
1177 fLinkTrackletCounter = 0;\r
1178 fEndOfTrackletCount = 0;\r
1179 fHC->fNTracklets = 0;\r
1180\r
1181 for (Int_t i = 0; i < MAXTRACKLETSPERHC; i++) \r
1182 fHC->fTrackletWords[i] = 0; \r
1183\r
1184 if (fgDebugFlag) AliDebug(10, Form("Decode tracklets at 0x%08x : 0x%08x", fpPos, *fpPos));\r
1185\r
1186 while ( *fpPos != END_OF_TRACKLET_MARKEROLD && *fpPos != END_OF_TRACKLET_MARKERNEW && fpPos < fpEnd ) {\r
1187 if (fgDebugFlag) AliDebug(10, Form("Tracklet found at 0x%08x : 0x%08x", fpPos, *fpPos));\r
1188\r
1189 fLinkTrackletCounter++;\r
1190\r
1191 if (fLinkTrackletCounter > MAXTRACKLETSPERHC) {\r
1192 if (fgDebugFlag) AliDebug(11,Form("Max number of tracklets exceeded %d > %d.", \r
1193 fLinkTrackletCounter, MAXTRACKLETSPERHC));\r
1194 if (fRawReader) fRawReader->AddMajorErrorLog(kTrackletOverflow,"Too many tracklets"); \r
1195 fHC->fTrackletError = 1;\r
1196 return kFALSE;\r
1197 }\r
1198\r
1199 fHC->fTrackletWords[fLinkTrackletCounter-1] = UInt_t(*fpPos); //store tracklet words into array \r
1200 fHC->fNTracklets = fLinkTrackletCounter;\r
1201 fpPos++;\r
1202 }\r
1203\r
1204 while ( ( *fpPos == END_OF_TRACKLET_MARKEROLD || *fpPos == END_OF_TRACKLET_MARKERNEW ) && fpPos < fpEnd ) {\r
1205 if (fgDebugFlag) AliDebug(10, Form("EoTracklets found at 0x%08x : 0x%08x", fpPos, *fpPos));\r
1206\r
1207 fEndOfTrackletCount++;\r
1208 fpPos++;\r
1209 }\r
1210\r
1211 if ( fEndOfTrackletCount < 2 ) {\r
1212 if (fgDebugFlag) AliDebug(11,"End of tracklets word missing"); \r
1213 if (fRawReader) fRawReader->AddMajorErrorLog(kEOTrackeltsMissing, "End of tracklets word missing"); \r
1214 fHC->fTrackletError += 2;\r
1215 return kFALSE;\r
1216 }\r
1217\r
1218 return kTRUE;\r
1219}\r
1220\r
1221//------------------------------------------------------------\r
1222Bool_t AliTRDrawStream::IsRowValid()\r
1223{\r
1224 //\r
1225 // check if the row number is in valid range\r
1226 //\r
1227 if ( (fHC->fStack == 2 && fMCM->fROW >= fGeometry->RowmaxC0()) ||\r
1228 (fHC->fStack != 2 && fMCM->fROW >= fGeometry->RowmaxC1()) || fMCM->fROW < 0 ) {\r
1229 if (fgDebugFlag) AliDebug(11,Form("SM%d L%dS%d: Wrong Padrow (%d) fROB=%d, fSIDE=%d, fMCM=%02d"\r
1230 , fHC->fSM, fHC->fLayer, fHC->fStack, fMCM->fROW, fMCM->fROB, fHC->fSide, fMCM->fMCM ));\r
1231 return kFALSE;\r
1232 }\r
1233\r
1234 return kTRUE;\r
1235}\r
1236\r
1237//------------------------------------------------------------\r
1238Bool_t AliTRDrawStream::IsMCMheaderOK()\r
1239{\r
1240 //\r
1241 // check the mcm header\r
1242 //\r
1243 if (fgLastROB != fMCM->fROB) {\r
1244 fgLastIndex = 0;\r
1245 if (fgLastROB== -1) fgLastROB = fMCM->fROB;\r
1246 }\r
1247 else {\r
1248 Int_t matchingcounter = 0; \r
1249 for (Int_t i=fgLastIndex+1; i<16; i++) {\r
1250 if ( fMCM->fMCM == fgMCMordering[i] ) {\r
1251 fgLastIndex = i;\r
1252 matchingcounter++;\r
1253 break;\r
1254 }\r
1255 }\r
1256 if (matchingcounter == 0) { \r
1257 fMCM->fMCMhdCorrupted += 2;\r
1258 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
1259 }\r
1260 }\r
1261\r
1262 if ( fgLastHC == fHC->fLayer*2 + fHC->fSide ) {\r
1263 if ( fMCM->fROB < (fMCM-1)->fROB ) {\r
1264 fMCM->fMCMhdCorrupted += 2;\r
1265 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
1266 }\r
1267 else fgLastROB = fMCM->fROB; \r
1268 }\r
1269\r
1270 fgLastHC = fHC->fLayer*2 + fHC->fSide; \r
1271\r
1272 /*\r
1273 // this check will come back later again when we have "patched MCM map"\r
1274 int expectedROB = -1;\r
1275 if(!fHC->fSide) expectedROB = int(fHC->fMCMmax/16)*2;\r
1276 else expectedROB = int(fHC->fMCMmax/16)*2 + 1;\r
1277 int expectedMCM = 4*(3-int((fHC->fMCMmax%16)/4)) + fHC->fMCMmax%4;\r
1278\r
1279 if ( expectedROB != fMCM->fROB || expectedMCM != fMCM->fMCM)\r
1280 {\r
1281 fMCM->fMCMhdCorrupted += 2;\r
1282 AliDebug(11,Form("ROB expected %d ROB read %d, MCM expected %d MCM read %d\n",expectedROB, fMCM->fROB, expectedMCM, fMCM->fMCM));\r
1283 }\r
1284 */\r
1285\r
1286 // below two conditions are redundant \r
1287 /*\r
1288 if ( fMCM->fMCM < 0 || fMCM->fMCM > 15 || fMCM->fROB < 0 || fMCM->fROB > 7 ) \r
1289 {\r
1290 fMCM->fMCMhdCorrupted += 8; // need to assign new number\r
1291 if (fgDebugFlag) AliDebug(11,Form("ROB or MCM number is out of range. %s\n", DumpMCMinfo(fMCM)));\r
1292 }\r
1293 if (IsRowValid() == kFALSE)\r
1294 {\r
1295 fMCM->fMCMhdCorrupted += 16; // need to assign new number\r
1296 }\r
1297 */ \r
1298 \r
1299 if (fEventCounter == 0) {\r
1300 fEventCounter = fMCM->fEvCounter;\r
1301 }\r
1302\r
1303 if (fEventCounter != fMCM->fEvCounter) {\r
1304 fMCM->fMCMhdCorrupted += 4; \r
1305 if (fgDebugFlag) AliDebug(11,Form("Event number(%d) of current MCM is different from that(%d) of reference MCM %s.\n"\r
1306 , fMCM->fEvCounter, fEventCounter, DumpMCMinfo(fMCM)));\r
1307 }\r
1308\r
1309 if (fEventCounter < fLastEventCounter) {\r
1310 fMCM->fMCMhdCorrupted += 8; \r
1311 if (fgDebugFlag) AliDebug(11,Form("Event from the past? Current %d Last %d %s.\n", fEventCounter, fLastEventCounter, DumpMCMinfo(fMCM)));\r
1312 }\r
1313\r
1314 if ( fMCM->fADCmaskCorrupted > 0 )\r
1315 return kFALSE;\r
1316\r
1317 if ( fMCM->fMCMhdCorrupted > 0 )\r
1318 return kFALSE;\r
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
1349\r
1350 fMCM->fROW = fTRDfeeParam->GetPadRowFromMCM(fMCM->fROB, fMCM->fMCM); \r
1351\r
1352 if ((fHC->fRawVMajor > 2 && fHC->fRawVMajor <5) || ((fHC->fRawVMajor & 32) == 32)) { //cover old and new version definition of ZS data\r
1353 fpPos++;\r
1354 if ( fpPos < fpEnd ) {\r
1355 DecodeMask(fpPos, fMCM); \r
1356 if (fHC->fCorrupted >= 16) {\r
1357 fpPos--; \r
1358 return kFALSE;\r
1359 }\r
1360 MCMADCwordsWithTbins(fHC->fTimeBins, fMCM);\r
1361 fMCM->fAdcDataPos = fpPos + 1;\r
1362 }\r
1363 else {\r
1364 if (fgDebugFlag) AliDebug(11,"Expected ADC mask word. Fail due to buffer END."); \r
1365 if (fRawReader) fRawReader->AddMajorErrorLog(kMCMADCMaskMissing,"Missing"); \r
1366 fHC->fCorrupted += 32;\r
1367 return kFALSE;\r
1368 }\r
1369 }\r
1370 else {\r
1371 UInt_t dummyMask = MCM_DUMMY_ADCMASK_VAL;\r
1372 DecodeMask(&dummyMask, fMCM); \r
1373 MCMADCwordsWithTbins(fHC->fTimeBins, fMCM);\r
1374 fMCM->fAdcDataPos = fpPos + 1;\r
1375 }\r
1376\r
1377 if (fgDebugFlag) { \r
1378 AliDebug(6, DumpMCMinfo(fMCM));\r
1379 AliDebug(7, DumpMCMadcMask(fMCM));\r
1380 }\r
1381\r
1382 if (IsMCMheaderOK() == kFALSE)\r
1383 return kFALSE;\r
1384 \r
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
1506 if (DecodeHCheader() == kFALSE) {\r
faad97e3 1507 if (fWarnError) AliWarning(Form("HC Header decode failed. H0 Error: %d H1 Error: %d",fHC->fH0Corrupted,fHC->fH1Corrupted));\r
e4ce0105 1508 if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderCorrupt, "HC header corrupted"); \r
1509 return kFALSE;\r
1510 }\r
1511 else {\r
1512 fpPos++;\r
1513 if (fpPos >= fpEnd) {\r
1514 fHC->fCorrupted += 1;\r
1515 if (fgDebugFlag) AliDebug(11,"No MCM data? Not enough data in the buffer.");\r
1516 if (fRawReader) fRawReader->AddMajorErrorLog(kMCMdataMissing, "MCM data missing"); \r
1517 return kFALSE;\r
1518 }\r
1519 }\r
1520\r
1521 if ((fHC->fRawVMajor & 64) == 64) { // test pattern data\r
1522 AliTRDrawTPStream *tpStream = new AliTRDrawTPStream(fHC->fRawVMajorOpt, fpPos);\r
1523 if (tpStream->DecodeTPdata() == kFALSE) {\r
faad97e3 1524 if (fWarnError) AliError("failed to decode test pattern data");\r
e4ce0105 1525 return kFALSE; \r
1526 }\r
1527 return kTRUE;\r
1528 } \r
1529\r
1530 fHC->fMCMmax = 0;\r
1531 while (*fpPos != ENDOFRAWDATAMARKER && fpPos < fpEnd) {\r
1532 if (fHC->fMCMmax > TRDMAXMCM) {\r
1533 fHC->fCorrupted += 2;\r
1534 if (fgDebugFlag) AliDebug(11,"More mcm data than expected!");\r
1535 if (fRawReader) fRawReader->AddMajorErrorLog(kMCMoverflow, "Too many mcms found!"); \r
1536 return kFALSE;\r
1537 }\r
1538\r
1539 fMCM = &fHC->fMCMs[fHC->fMCMmax];\r
1540\r
1541 if (DecodeMCMheader() == kFALSE) {\r
1542 if (fHC->fCorrupted < 4) fHC->fCorrupted += 4; // benchmark hc data corruption as 4\r
1543 \r
1544 if (fgSkipData == kTRUE || fHC->fCorrupted >= 16) { // stop HC data reading\r
1545 fHC->fMCMmax++; \r
1546 return kFALSE;\r
1547 } \r
1548 \r
1549 fHC->fMCMmax++; // increase mcm counter to match with expected rob/mcm number\r
1550\r
1551 // in case we decide to keep reading data, skip this mcm data and find next mcm header \r
1552 if (fMCM->fADCmaskCorrupted < 2) {\r
1553 if (SkipMCMdata(fMCM->fADCcount*fMCM->fSingleADCwords) == kFALSE)\r
1554 return kFALSE;\r
1555 continue;\r
1556 }\r
1557 else {\r
1558 if (SeekNextMCMheader() == kFALSE)\r
1559 return kFALSE;\r
1560 continue;\r
1561 }\r
1562 }\r
1563\r
1564 fHC->fMCMmax++;\r
1565\r
1566 if (fMCM->fADCmax > 0) {\r
1567 fpPos++;\r
1568 if (fpPos >= fpEnd) {\r
1569 fMCM->fCorrupted += 1;\r
1570 if (fHC->fCorrupted < 4) fHC->fCorrupted += 4; // benchmark hc data corruption as 4\r
1571 if (fgDebugFlag) AliDebug(9, Form("Buffer short of data. ADC data expected.")); \r
1572 return kFALSE;\r
1573 }\r
1574\r
1575 for (Int_t iadc = 0; iadc < fMCM->fADCmax; iadc++) {\r
1576 fADC = &fMCM->fADCs[iadc];\r
1577 fADC->fADCnumber = fMCM->fADCchannel[iadc];\r
1578 if (fgDebugFlag) AliDebug(9, Form("This is ADC %d of %d. ADC number is %d.", \r
1579 iadc+1, fMCM->fADCmax, fMCM->fADCchannel[iadc]));\r
1580 if (fpPos + fMCM->fSingleADCwords >= fpEnd) {\r
1581 fMCM->fCorrupted += 2;\r
1582 if (fHC->fCorrupted < 4) fHC->fCorrupted += 4; // benchmark hc data corruption as 4\r
1583 if (fgDebugFlag) AliDebug(11,"ADC (10 words) expected. Not enough data in the buffer.");\r
1584 return kFALSE;\r
1585 }\r
1586\r
1587 if (fHC->fRawVMajor < 64) { // normal(real) ADC data\r
1588 if (fHC->fTimeBins < 31) {\r
1589 if (DecodeADC() == kFALSE) {\r
1590 if (fMCM->fCorrupted < 4) fMCM->fCorrupted += 4; // benchmark mcm data corruption as 4\r
1591 if (fHC->fCorrupted < 4) fHC->fCorrupted += 4; // benchmark hc data corruption as 4\r
1592 if (fADC->fIsShared && fADC->fCorrupted == 32) { // check if we are out of the det when the pad is shared\r
1593 fADC->fExtendedCOL = -1;\r
1594 fADC->fCOL = -1;\r
1595 fpPos = fADC->fPos + fMCM->fSingleADCwords;\r
1596 }\r
1597 else {\r
1598 if (fgDebugFlag) AliDebug(11,Form("ADC decode failed."));\r
1599 if (fgSkipData == kTRUE || fHC->fCorrupted >= 16) \r
1600 return kFALSE; // stop HC data reading\r
1601 }\r
1602 }\r
1603 }\r
1604 else if (fHC->fTimeBins > 32) {\r
1605 if (DecodeADCExtended() == kFALSE) { // decoding TRAP data with ZS and more than 32 samples\r
1606 if (fMCM->fCorrupted < 4) fMCM->fCorrupted += 4; // benchmark mcm data corruption as 4\r
1607 if (fHC->fCorrupted < 4) fHC->fCorrupted += 4; // benchmark hc data corruption as 4\r
1608 if (fADC->fIsShared && fADC->fCorrupted == 32) { // check if we are out of the det when the pad is shared\r
1609 fADC->fExtendedCOL = -1;\r
1610 fADC->fCOL = -1;\r
1611 fpPos = fADC->fPos + fMCM->fSingleADCwords;\r
1612 }\r
1613 else {\r
1614 if (fgDebugFlag) AliDebug(11,Form("ADC decode failed."));\r
1615 if (fgSkipData == kTRUE || fHC->fCorrupted >= 16)\r
1616 return kFALSE; // stop HC data reading\r
1617 }\r
1618 }\r
1619 }\r
1620 else { // nsamples = 31, 32 are not implemented in the TRAP and should never happen \r
faad97e3 1621 if (fWarnError) AliError("nsamples are 31 or 32. These are not implemented in the TRAP and should never happen!"); \r
e4ce0105 1622 }\r
1623 } // if fHC->fRawVMajor\r
1624 else { // test pattern data\r
faad97e3 1625 if (fWarnError) AliError("These are test pattern data. You need other reader"); // will be served in other class\r
e4ce0105 1626 }\r
1627 } // for iadc \r
1628 } // if fMCM->fADCmax\r
1629 else {\r
1630 fpPos++;\r
1631 }\r
1632 }//while eof data\r
1633\r
1634 if (fpPos >= fpEnd) {\r
1635 if (fgDebugFlag) AliDebug(11,"We are at the end of buffer. There should be one more word left.");\r
1636 return kFALSE;\r
1637 }\r
1638\r
1639 return kTRUE;\r
1640}\r
1641\r
1642//------------------------------------------------------------\r
1643Bool_t AliTRDrawStream::DecodeADC()\r
1644{\r
1645 //\r
1646 // decode single ADC channel\r
1647 //\r
1648\r
1649 fADC->fCorrupted = 0;\r
1650 if(fADC->fADCnumber%2==1) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL1);\r
1651 if(fADC->fADCnumber%2==0) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL2);\r
1652\r
1653 fADC->fPos = fpPos;\r
1654 fTbinADC = 0;\r
1655\r
1656 for (Int_t i = 0; i < GetNumberOfTimeBins(); i++)\r
1657 //for (Int_t i = 0; i < TRDMAXTBINS; i++)\r
1658 fADC->fSignals[i] = 0;\r
1659\r
1660 for (Int_t iw = 0; iw < fMCM->fSingleADCwords; iw++) {\r
1661 if (HC_HEADER_MASK_ERR(*fpPos) == 0 || *fpPos == END_OF_TRACKLET_MARKERNEW) {\r
faad97e3 1662 if (fWarnError) AliError(Form("There should be ADC data. We meet HC header or END_OF_TRACKLET_MARKER 0x%08x",*fpPos));\r
e4ce0105 1663 fADC->fCorrupted += 16;\r
1664 fHC->fCorrupted += 16; \r
1665 fpPos--;\r
1666 return kFALSE;\r
1667 }\r
1668 if (fMaskADCword != ADC_WORD_MASK(*fpPos)) {\r
1669 fADC->fCorrupted += 1;\r
1670 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
1671 fADC->fADCnumber, fMaskADCword, ADC_WORD_MASK(*fpPos),DumpMCMinfo(fMCM),fADC->fCorrupted));\r
1672 fpPos++;\r
1673 continue;\r
1674 }\r
1675\r
1676 fADC->fSignals[fTbinADC + 0] = ((*fpPos & 0x00000ffc) >> 2);\r
1677 fADC->fSignals[fTbinADC + 1] = ((*fpPos & 0x003ff000) >> 12);\r
1678 fADC->fSignals[fTbinADC + 2] = ((*fpPos & 0xffc00000) >> 22);\r
1679\r
1680 fTbinADC += 3;\r
1681 fpPos++;\r
1682 } // iw\r
1683\r
1684 if (fADC->fADCnumber <= 1 || fADC->fADCnumber == fMaxADCgeom - 1) {\r
1685 fADC->fIsShared = kTRUE;\r
1686 }\r
1687 else {\r
1688 fADC->fIsShared = kFALSE;\r
1689 }\r
1690\r
1691 fADC->fExtendedCOL = fTRDfeeParam->GetExtendedPadColFromADC(fMCM->fROB, fMCM->fMCM, fADC->fADCnumber);\r
1692 fADC->fCOL = fTRDfeeParam->GetPadColFromADC(fMCM->fROB, fMCM->fMCM, fADC->fADCnumber);\r
1693\r
1694 if (fADC->fCOL >= fHC->fColMax || fADC->fCOL < 0) {\r
1695 if (fADC->fIsShared == kFALSE) {\r
1696 fADC->fCorrupted += 32;\r
1697 if (fgDebugFlag) AliDebug(11,Form("Wrong column! ADCnumber %d MaxIs %d Col %d MaxIs %d MCM= %s", \r
1698 fADC->fADCnumber, fMaxADCgeom, fADC->fCOL, fHC->fColMax, DumpMCMinfo(fMCM)));\r
1699 }\r
1700 //else {\r
1701 // we are out of the det when the pad is shared\r
1702 //if (fgDebugFlag) AliDebug(11, Form("Column out of the detector! ADCnumber %d MaxIs %d Col %d MaxIs %d MCM= %s", \r
1703 // fADC->fADCnumber, fMaxADCgeom, fADC->fCOL, fHC->fColMax, DumpMCMinfo(fMCM)));\r
1704 //fADC->fCorrupted += 32;\r
1705 //}\r
1706 }\r
1707\r
1708 if (fADC->fCorrupted > 0) {\r
1709 return kFALSE;\r
1710 }\r
1711\r
1712 fDecodedADCs++;\r
1713\r
1714 return kTRUE;\r
1715}\r
1716\r
1717//------------------------------------------------------------\r
1718Bool_t AliTRDrawStream::DecodeADCExtended()\r
1719{\r
1720 //\r
1721 // decode single ADC channel\r
1722 //\r
1723\r
1724 fADC->fCorrupted = 0;\r
1725 if(fADC->fADCnumber%2==1) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL1);\r
1726 if(fADC->fADCnumber%2==0) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL2);\r
1727\r
1728 fADC->fPos = fpPos;\r
1729\r
1730 fTbinADC = ((*fpPos & 0x000000fc) >> 2);\r
1731 fMCM->fSingleADCwords = ((*fpPos & 0x00000f00) >> 8);\r
1732 fADC->fSignals[fTbinADC] = ((*fpPos & 0x003ff000) >> 12);\r
1733 fADC->fSignals[fTbinADC+1] = ((*fpPos & 0xffc00000) >> 22);\r
1734\r
1735 fpPos++; \r
1736 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
1737 if (HC_HEADER_MASK_ERR(*fpPos) == 0 || *fpPos == END_OF_TRACKLET_MARKERNEW) {\r
faad97e3 1738 if (fWarnError) AliError(Form("There should be ADC data. We meet HC header or END_OF_TRACKLET_MARKER 0x%08x",*fpPos));\r
e4ce0105 1739 fADC->fCorrupted += 16;\r
1740 fHC->fCorrupted += 16; \r
1741 fpPos--;\r
1742 return kFALSE;\r
1743 }\r
1744 if (fMaskADCword != ADC_WORD_MASK(*fpPos)) {\r
1745 fADC->fCorrupted += 1;\r
1746 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
1747 fADC->fADCnumber, fMaskADCword, ADC_WORD_MASK(*fpPos),DumpMCMinfo(fMCM),fADC->fCorrupted));\r
1748 fpPos++;\r
1749 continue;\r
1750 }\r
1751\r
1752 fADC->fSignals[fTbinADC + 2] = ((*fpPos & 0x00000ffc) >> 2);\r
1753 fADC->fSignals[fTbinADC + 3] = ((*fpPos & 0x003ff000) >> 12);\r
1754 fADC->fSignals[fTbinADC + 4] = ((*fpPos & 0xffc00000) >> 22);\r
1755\r
1756 fTbinADC += 3;\r
1757 fpPos++;\r
1758 } // iw\r
1759\r
1760// for(int i=0; i )\r
1761// printf();\r
1762\r
1763\r
1764 if (fADC->fADCnumber <= 1 || fADC->fADCnumber == fMaxADCgeom - 1) {\r
1765 fADC->fIsShared = kTRUE;\r
1766 }\r
1767 else {\r
1768 fADC->fIsShared = kFALSE;\r
1769 }\r
1770\r
1771 fADC->fExtendedCOL = fTRDfeeParam->GetExtendedPadColFromADC(fMCM->fROB, fMCM->fMCM, fADC->fADCnumber);\r
1772 fADC->fCOL = fTRDfeeParam->GetPadColFromADC(fMCM->fROB, fMCM->fMCM, fADC->fADCnumber);\r
1773\r
1774 if (fADC->fCOL >= fHC->fColMax || fADC->fCOL < 0) {\r
1775 if (fADC->fIsShared == kFALSE) {\r
1776 fADC->fCorrupted += 32;\r
1777 if (fgDebugFlag) AliDebug(11,Form("Wrong column! ADCnumber %d MaxIs %d Col %d MaxIs %d MCM= %s", \r
1778 fADC->fADCnumber, fMaxADCgeom, fADC->fCOL, fHC->fColMax, DumpMCMinfo(fMCM)));\r
1779 }\r
1780 }\r
1781\r
1782 if (fADC->fCorrupted > 0) {\r
1783 return kFALSE;\r
1784 }\r
1785\r
1786 fDecodedADCs++;\r
1787\r
1788 return kTRUE;\r
1789}\r
1790\r
1791//--------------------------------------------------------\r
1792void AliTRDrawStream::DecodeSMInfo(const UInt_t *word, struct AliTRDrawSM *sm) const\r
1793{\r
1794 //\r
1795 // Decode Supermodule Index Word\r
1796 // The Supermodule Index Word is a 32-Bit word wit following structure\r
1797 // ssssssss ssssssss vvvv rrrr r d t mmmm\r
1798 // s: Size of the Supermodule Header, v: Supermodule Header Version, r: Reserved for future use\r
1799 // d: Track Data Enabled Bit, t: Tracklet Data Enabled Bit, m: Stack Mask \r
1800 //\r
1801 sm->fPos = (UInt_t*)word; \r
1802\r
1803 UInt_t vword = *word;\r
1804 sm->fHeaderSize = SM_HEADER_SIZE(vword);\r
1805 \r
1806 if (TRACKLETS_ENABLED(vword) > 0)\r
1807 sm->fTrackletEnable = kTRUE;\r
1808 else\r
1809 sm->fTrackletEnable = kFALSE;\r
1810 \r
1811 UInt_t stackMask = STACK_MASK(vword);\r
1812 sm->fActiveStacks = 0;\r
1813 for (Int_t i = 0; i < 5; i++) {\r
1814 if (IS_BIT_SET(stackMask,i) > 0) {\r
1815 sm->fStackActive[i] = kTRUE;\r
1816 sm->fActiveStacks++;\r
1817 }\r
1818 else {\r
1819 sm->fStackActive[i] = kFALSE;\r
1820 }\r
1821 }\r
1822}\r
1823\r
1824//--------------------------------------------------------\r
1825const char *AliTRDrawStream::DumpSMInfo(const struct AliTRDrawSM *sm)\r
1826{\r
1827 //\r
1828 // Get SM structure into a const char\r
1829 //\r
1830 return Form("[ SM Info 0x%08x] : Hsize %d TrackletEnable %d Stacks %d %d %d %d %d",\r
1831 *sm->fPos, sm->fHeaderSize, sm->fTrackletEnable,\r
1832 sm->fStackActive[0], sm->fStackActive[1], sm->fStackActive[2],\r
1833 sm->fStackActive[3], sm->fStackActive[4]); \r
1834}\r
1835\r
1836//--------------------------------------------------------\r
1837void AliTRDrawStream::DecodeStackInfo(const UInt_t *word, struct AliTRDrawStack *st) const\r
1838{\r
1839 //\r
1840 // Decode Stack #i Index Word\r
1841 // The Stack #i Index Word is a 32-Bit word wit following structure\r
1842 // ssssssss ssssssss vvvv mmmm mmmmmmmm\r
1843 // s: Size of the Stack #i Header, v: Supermodule Header Version, m: Link Mask\r
1844 //\r
1845 st->fPos = (UInt_t*)word;\r
1846 \r
1847 UInt_t vword = *word;\r
1848 st->fHeaderSize = STACK_HEADER_SIZE(vword);\r
1849\r
1850 UInt_t linkMask = STACK_LINK_WORD(vword);\r
1851 st->fActiveLinks = 0;\r
1852 for (Int_t i = 0; i < 12; i++) {\r
1853 if (IS_BIT_SET(linkMask,i) > 0) {\r
1854 st->fLinksActive[i] = kTRUE;\r
1855 st->fActiveLinks++;\r
1856 }\r
1857 else {\r
1858 st->fLinksActive[i] = kFALSE;\r
1859 }\r
1860 }\r
1861}\r
1862 \r
1863//--------------------------------------------------------\r
1864void AliTRDrawStream::DecodeStackHeader(const UInt_t *word, struct AliTRDrawStack *st, Int_t iword) const\r
1865{\r
1866 //\r
1867 // decode gtu header for stack info\r
1868 //\r
1869 st->fPos = (UInt_t*)word;\r
1870 \r
1871 UInt_t vword = *word;\r
1872 st->fLinksDataType[2*iword] = LINK0_DATA_TYPE_FLAG(vword);\r
1873 st->fLinksMonitor[2*iword] = LINK0_MONITOR_FLAG(vword);\r
1874 st->fLinksDataType[2*iword+1] = LINK1_DATA_TYPE_FLAG(vword);\r
1875 st->fLinksMonitor[2*iword+1] = LINK1_MONITOR_FLAG(vword);\r
1876}\r
1877\r
1878//--------------------------------------------------------\r
1879const char *AliTRDrawStream::DumpStackInfo(const struct AliTRDrawStack *st)\r
1880{\r
1881 //\r
1882 // format the string with the stack info\r
1883 //\r
1884\r
1885 return Form("[ Stack Info 0x%08x ] : Hsize %d Links Active %d %d %d %d %d %d %d %d %d %d %d %d",\r
1886 *st->fPos, st->fHeaderSize,\r
1887 st->fLinksActive[0], st->fLinksActive[1], st->fLinksActive[2], st->fLinksActive[3],\r
1888 st->fLinksActive[4], st->fLinksActive[5], st->fLinksActive[6], st->fLinksActive[7],\r
1889 st->fLinksActive[8], st->fLinksActive[9], st->fLinksActive[10], st->fLinksActive[11]);\r
1890}\r
1891\r
1892//--------------------------------------------------------\r
1893Bool_t AliTRDrawStream::DecodeHCwordH0(const UInt_t *word, struct AliTRDrawHC *hc) const\r
1894{\r
1895 //\r
1896 // decode the hc header word 0\r
1897 //\r
1898 UInt_t vword = *word;\r
1899 hc->fPos[0] = (UInt_t*)word;\r
1900\r
1901 hc->fH0Corrupted = HC_HEADER_MASK_ERR(vword);\r
1902 if (hc->fH0Corrupted > 0) {\r
1903 if (fgDebugFlag) AliDebug(11,Form("H0 Header Mask Error. Word 0x%08x", *fHC->fPos));\r
1904 return kFALSE;\r
1905 }\r
1906\r
1907 hc->fSpecialRawV = HC_SPECIAL_RAW_VERSION(vword);\r
1908 hc->fRawVMajor = HC_MAJOR_RAW_VERSION(vword);\r
1909 hc->fRawVMajorOpt = HC_MAJOR_RAW_VERSION_OPT(vword); \r
1910 hc->fRawVMinor = HC_MINOR_RAW_VERSION(vword);\r
1911 hc->fNExtraWords = HC_EXTRA_WORDS(vword);\r
1912 hc->fDCSboard = HC_DCS_BOARD(vword);\r
1913 hc->fSM = HC_SM_NUMBER(vword);\r
1914 hc->fStack = HC_STACK_NUMBER(vword);\r
1915 hc->fLayer = HC_LAYER_NUMBER(vword);\r
1916 hc->fSide = HC_SIDE_NUMBER(vword);\r
1917\r
1918\r
1919 return kTRUE;\r
1920}\r
1921\r
1922//--------------------------------------------------------\r
1923Bool_t AliTRDrawStream::DecodeHCwordH1(const UInt_t *word, struct AliTRDrawHC *hc) const\r
1924{\r
1925 //\r
1926 // decode the hc header word 1\r
1927 //\r
1928 UInt_t vword = *word;\r
1929\r
1930 hc->fH1Corrupted = HC_HEADER_MASK_ERR(vword);\r
1931 if (hc->fH1Corrupted > 0) {\r
1932 if (fgDebugFlag) AliDebug(11,Form("H1 Header Mask Error. Word 0x%08x", *fHC->fPos));\r
1933 return kFALSE;\r
1934 }\r
1935\r
1936 hc->fTimeBins = HC_NTIMEBINS(vword);\r
1937 hc->fBunchCrossCounter = HC_BUNCH_CROSS_COUNTER(vword);\r
1938 hc->fPreTriggerCounter = HC_PRETRIGGER_COUNTER(vword);\r
1939 hc->fPreTriggerPhase = HC_PRETRIGGER_PHASE(vword);\r
1940\r
1941 hc->fPos[1] = (UInt_t*)word;\r
1942\r
1943 return kTRUE;\r
1944}\r
1945 \r
1946//--------------------------------------------------------\r
1947const char *AliTRDrawStream::DumpHCinfoH0(const struct AliTRDrawHC *hc)\r
1948{\r
1949 //\r
1950 // dump the hc header word 0\r
1951 //\r
1952 if (!hc)\r
1953 return Form("Unable to dump. Null received as parameter!?!");\r
1954 else\r
1955 return Form("[ HC[0] at 0x%08x ] : 0x%08x Info is : RawV %d SM %d Stack %d Layer %d Side %d DCSboard %d",\r
1956 hc->fPos[0], (hc->fPos[0]) ? *(hc->fPos[0]) : 0, hc->fRawVMajor, hc->fSM, hc->fStack, hc->fLayer, hc->fSide, hc->fDCSboard);\r
1957}\r
1958\r
1959//--------------------------------------------------------\r
1960const char *AliTRDrawStream::DumpHCinfoH1(const struct AliTRDrawHC *hc)\r
1961{\r
1962 //\r
1963 // dump the hc header word 1\r
1964 //\r
1965 if (!hc)\r
1966 return Form("Unable to dump. Null received as parameter!?!");\r
1967 else\r
1968 return Form("[ HC[1] at 0x%08x ] : 0x%08x Info is : TBins %d BCcount %d PreTrigCount %d PreTrigPhase %d",\r
1969 hc->fPos[1], (hc->fPos[1]) ? *(hc->fPos[1]) : 0, hc->fTimeBins, hc->fBunchCrossCounter, hc->fPreTriggerCounter, hc->fPreTriggerPhase);\r
1970}\r
1971\r
1972//--------------------------------------------------------\r
1973void AliTRDrawStream::DecodeMCMheader(const UInt_t *word, struct AliTRDrawMCM *mcm) const\r
1974{\r
1975 //\r
1976 // decode the mcm header\r
1977 //\r
1978 UInt_t vword = *word;\r
1979\r
1980 if (vword == END_OF_TRACKLET_MARKERNEW) {\r
faad97e3 1981 if (fWarnError) AliError(Form("There should be MCM header. We meet END_OF_TRACKLET_MARKER 0x%08x",vword));\r
e4ce0105 1982 mcm->fMCMhdCorrupted += 16;\r
1983 fHC->fCorrupted += 16; //to finish data reading of this HC\r
1984 }\r
1985\r
1986 mcm->fMCMhdCorrupted = MCM_HEADER_MASK_ERR(vword); //if MCM header mask has error\r
1987 if (fgDebugFlag && mcm->fMCMhdCorrupted != 0) AliDebug(11,Form("Wrong MCM header mask 0x%08x.\n", *fpPos));\r
1988\r
1989 mcm->fROB = MCM_ROB_NUMBER(vword);\r
1990 mcm->fMCM = MCM_MCM_NUMBER(vword);\r
1991 mcm->fEvCounter = MCM_EVENT_COUNTER(vword);\r
1992 mcm->fPos = (UInt_t*)word;\r
1993}\r
1994\r
1995//--------------------------------------------------------\r
1996UInt_t AliTRDrawStream::GetMCMadcMask(const UInt_t *word, struct AliTRDrawMCM *mcm) const\r
1997{\r
1998 //\r
1999 // get the adc mask\r
2000 //\r
2001 UInt_t vword = *word;\r
2002\r
2003 mcm->fADCmax = 0;\r
2004 mcm->fADCMask = 0;\r
2005 mcm->fADCcount = 0;\r
2006 mcm->fADCMaskWord = vword;\r
2007\r
2008 if (vword == END_OF_TRACKLET_MARKERNEW) {\r
faad97e3 2009 if (fWarnError) AliError(Form("There should be MCMadcMask. We meet END_OF_TRACKLET_MARKER 0x%08x",vword));\r
e4ce0105 2010 mcm->fADCmaskCorrupted += 16;\r
2011 fHC->fCorrupted += 16; //to finish data reading of this HC\r
2012 }\r
2013\r
2014 if ( MCM_ADCMASK_MASK_ERR(vword) == 0 ) {\r
2015 mcm->fADCMask = MCM_ADCMASK_VAL(vword);\r
2016 mcm->fADCcount = MCM_ADCMASK_NADC(~vword);\r
2017 }\r
2018 else {\r
2019 mcm->fADCMask = 0xffffffff;\r
2020 mcm->fADCmaskCorrupted = 1; // mcm adc mask error\r
2021 if (fgDebugFlag) AliDebug(11,Form("Wrong ADC Mask word 0x%08x.\n", *fpPos));\r
2022 }\r
2023\r
2024 return mcm->fADCMask;\r
2025}\r
2026\r
2027//--------------------------------------------------------\r
2028void AliTRDrawStream::DecodeMask(const UInt_t *word, struct AliTRDrawMCM *mcm) const\r
2029{\r
2030 //\r
2031 // decode the adc mask - adcs to be read out\r
2032 //\r
2033 mcm->fMCMADCWords = 0;\r
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
2059 mcm->fMCMADCWords = ( mcm->fADCmax ) * ( fTbins / 3 );\r
2060 mcm->fSingleADCwords = 0;\r
2061 if (mcm->fADCmax > 0) {\r
2062 mcm->fSingleADCwords = mcm->fMCMADCWords/mcm->fADCmax;\r
2063 }\r
2064 if (fTbins > 32) mcm->fSingleADCwords = 10; // if the timebin is more than 30, then fix the number of adc words to 10\r
2065}\r
2066 \r
2067//--------------------------------------------------------\r
2068const char *AliTRDrawStream::DumpMCMinfo(const struct AliTRDrawMCM *mcm)\r
2069{\r
2070 //\r
2071 // mcm info in a string\r
2072 //\r
2073 if (!mcm)\r
2074 return Form("Unable to dump. Null received as parameter!?!");\r
2075 else\r
2076 return Form("[ MCM 0x%08x ] : ROB %d MCM %d EvCounter %d", *(mcm->fPos), mcm->fROB, mcm->fMCM, mcm->fEvCounter);\r
2077}\r
2078 \r
2079//--------------------------------------------------------\r
2080const char *AliTRDrawStream::DumpMCMadcMask(const struct AliTRDrawMCM *mcm)\r
2081{\r
2082 //\r
2083 // mcm adc mask in a string\r
2084 //\r
2085 if (!mcm)\r
2086 return Form("Unable to dump. Null received as parameter!?!");\r
2087\r
2088 TString tsreturn = Form("[Word] : 0x%08x => [Mask] : 0x%08x : ", mcm->fADCMaskWord, mcm->fADCMask);\r
2089 for (Int_t i = 0; i < TRDMAXADC; i++) {\r
2090 tsreturn += Form("%d ", mcm->fADCchannel[i]);\r
2091 }\r
2092 tsreturn += "";\r
2093 return tsreturn.Data();\r
2094}\r
2095\r