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