]>
Commit | Line | Data |
---|---|---|
0eedb47d | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | /* $Id$ */ | |
17 | ||
18 | /////////////////////////////////////////////////////////////////////////////// | |
19 | // // | |
20 | // This class provides access to TRD digits in raw data. // | |
21 | // // | |
22 | // It loops over all TRD digits in the raw data given by the AliRawReader. // | |
23 | // The Next method goes to the next digit. If there are no digits left // | |
24 | // it returns kFALSE. // | |
25 | // Several getters provide information about the current digit. // | |
26 | // // | |
27 | // Author: C. Lippmann (C.Lippmann@gsi.de) // | |
28 | // // | |
29 | /////////////////////////////////////////////////////////////////////////////// | |
30 | ||
31 | #include "AliLog.h" | |
32 | #include "AliRawReader.h" | |
33 | #include "AliTRDRawStreamTB.h" | |
34 | #include "AliTRDgeometry.h" | |
35 | #include "AliTRDcalibDB.h" | |
36 | #include "AliTRDfeeParam.h" | |
37 | ||
38 | #include "AliTRDdigitsManager.h" | |
39 | #include "AliTRDdataArrayI.h" | |
40 | #include "AliTRDSignalIndex.h" | |
41 | ||
42 | #include "TMath.h" | |
43 | ||
44 | using namespace AliTRDrawDataUtilsTB; | |
45 | ||
46 | ClassImp(AliTRDRawStreamTB) | |
47 | ||
48 | Bool_t AliTRDRawStreamTB::fgStackIndexBug=kFALSE; | |
49 | Int_t AliTRDRawStreamTB::fgForceRawVersion = -1; | |
50 | Bool_t AliTRDRawStreamTB::fgSupressWarnings=kFALSE; | |
51 | Bool_t AliTRDRawStreamTB::fgRawDataHack=kFALSE; | |
52 | Bool_t AliTRDRawStreamTB::fgExtraDebug=kFALSE; | |
53 | ||
54 | //_____________________________________________________________________________ | |
55 | AliTRDRawStreamTB::AliTRDRawStreamTB() | |
56 | :TObject() | |
57 | ,fSig() | |
58 | ,fADC(0) | |
59 | ,fMaxADCgeom(-1) | |
60 | ,fTB(0) | |
61 | ,fEv(0) | |
62 | ,fROB(0) | |
63 | ,fMCM(0) | |
64 | ,fSM(0) | |
65 | ,fLAYER(0) | |
66 | ,fSTACK(0) | |
67 | ,fROC(0) | |
68 | ,fSIDE(0) | |
69 | ,fDCS(0) | |
70 | ,fROW(0) | |
71 | ,fCOL(0) | |
72 | ,fDET(-1) | |
73 | ,fLastDET(-1) | |
74 | ,fBCctr(0) | |
75 | ,fPTctr(0) | |
76 | ,fPTphase(0) | |
77 | ,fRVmajor(0) | |
78 | ,fRVminor(0) | |
79 | ,fHCHWords(0) | |
80 | ,fTBins(0) | |
81 | ,fTCon(0) | |
82 | ,fPEDon(0) | |
83 | ,fGAINon(0) | |
84 | ,fXTon(0) | |
85 | ,fNonLinOn(0) | |
86 | ,fBypass(0) | |
87 | ,fCommonAdditive(0) | |
88 | ,fZeroSuppressed(0) | |
89 | ,fHCHctr1(0) | |
90 | ,fHCHctr2(0) | |
91 | ,fMCMHctr1(0) | |
92 | ,fMCMHctr2(0) | |
93 | ,fGTUctr1(0) | |
94 | ,fGTUctr2(0) | |
95 | ,fHCdataCtr(0) | |
96 | ,fTracklPID(0.) | |
97 | ,fTracklDefL(0.) | |
98 | ,fTracklPadPos(0.) | |
99 | ,fTracklPadRow(0) | |
100 | ,fGTUlinkMask() | |
101 | ,fMCMWordCrt(0) | |
102 | ,fMCMWordsExpected(0) | |
103 | ,fRawReader(NULL) | |
104 | ,fRawVersion(0) | |
105 | ,fRawDigitThreshold(0) | |
106 | ,fNextStatus(0) | |
107 | ,fLastStatus(0) | |
108 | ,fTbSwitch(0) | |
109 | ,fTbSwitchCtr(0) | |
110 | ,fTimeWords(0) | |
111 | ,fWordCtr(0) | |
112 | ,fRowMax(0) | |
113 | ,fColMax(0) | |
114 | ,fADCmask() | |
115 | ,fLastADCmask(0) | |
116 | ,fChamberDone() | |
117 | ,fRetVal(0) | |
118 | ,fEqID(0) | |
119 | ,fDataSize(0) | |
120 | ,fSizeOK(kFALSE) | |
121 | ,fCountBytes(0) | |
122 | ,fBufSize(0) | |
123 | ,fkBufferSet(kFALSE) | |
124 | ,fPos(NULL) | |
125 | ,fDataWord(NULL) | |
126 | ,fTimeBinsCalib(0) | |
127 | ,fADClookup() | |
128 | ,fNActiveADCs(0) | |
129 | ,fEndOfDataFlag(kFALSE) | |
130 | ,fHCInfo() | |
131 | ,fMCMInfo() | |
132 | ,fiSMx(0) | |
133 | ,fSharedPadsOn(kFALSE) | |
134 | ,fIsPadShared(kFALSE) | |
135 | ,fGeo(NULL) | |
136 | { | |
137 | // | |
138 | // Default constructor | |
139 | // | |
140 | ||
141 | for (Int_t i = 0; i < 540; i++) { | |
142 | fChamberDone[i] = 0; | |
143 | } | |
144 | ||
145 | } | |
146 | ||
147 | //_____________________________________________________________________________ | |
148 | AliTRDRawStreamTB::AliTRDRawStreamTB(AliRawReader *rawReader) | |
149 | :TObject() | |
150 | ,fSig() | |
151 | ,fADC(0) | |
152 | ,fMaxADCgeom(-1) | |
153 | ,fTB(0) | |
154 | ,fEv(0) | |
155 | ,fROB(0) | |
156 | ,fMCM(0) | |
157 | ,fSM(0) | |
158 | ,fLAYER(0) | |
159 | ,fSTACK(0) | |
160 | ,fROC(0) | |
161 | ,fSIDE(0) | |
162 | ,fDCS(0) | |
163 | ,fROW(0) | |
164 | ,fCOL(0) | |
165 | ,fDET(-1) | |
166 | ,fLastDET(-1) | |
167 | ,fBCctr(0) | |
168 | ,fPTctr(0) | |
169 | ,fPTphase(0) | |
170 | ,fRVmajor(0) | |
171 | ,fRVminor(0) | |
172 | ,fHCHWords(0) | |
173 | ,fTBins(0) | |
174 | ,fTCon(0) | |
175 | ,fPEDon(0) | |
176 | ,fGAINon(0) | |
177 | ,fXTon(0) | |
178 | ,fNonLinOn(0) | |
179 | ,fBypass(0) | |
180 | ,fCommonAdditive(0) | |
181 | ,fZeroSuppressed(0) | |
182 | ,fHCHctr1(0) | |
183 | ,fHCHctr2(0) | |
184 | ,fMCMHctr1(0) | |
185 | ,fMCMHctr2(0) | |
186 | ,fGTUctr1(0) | |
187 | ,fGTUctr2(0) | |
188 | ,fHCdataCtr(0) | |
189 | ,fTracklPID(0.) | |
190 | ,fTracklDefL(0.) | |
191 | ,fTracklPadPos(0.) | |
192 | ,fTracklPadRow(0) | |
193 | ,fGTUlinkMask() | |
194 | ,fMCMWordCrt(0) | |
195 | ,fMCMWordsExpected(0) | |
196 | ,fRawReader(rawReader) | |
197 | ,fRawVersion(0) | |
198 | ,fRawDigitThreshold(0) | |
199 | ,fNextStatus(0) | |
200 | ,fLastStatus(0) | |
201 | ,fTbSwitch(0) | |
202 | ,fTbSwitchCtr(0) | |
203 | ,fTimeWords(0) | |
204 | ,fWordCtr(0) | |
205 | ,fRowMax(0) | |
206 | ,fColMax(0) | |
207 | ,fADCmask() | |
208 | ,fLastADCmask(0) | |
209 | ,fChamberDone() | |
210 | ,fRetVal(0) | |
211 | ,fEqID(0) | |
212 | ,fDataSize(0) | |
213 | ,fSizeOK(kFALSE) | |
214 | ,fCountBytes(0) | |
215 | ,fBufSize(0) | |
216 | ,fkBufferSet(kFALSE) | |
217 | ,fPos(NULL) | |
218 | ,fDataWord(NULL) | |
219 | ,fTimeBinsCalib(0) | |
220 | ,fADClookup() | |
221 | ,fNActiveADCs(0) | |
222 | ,fEndOfDataFlag(kFALSE) | |
223 | ,fHCInfo() | |
224 | ,fMCMInfo() | |
225 | ,fiSMx(0) | |
226 | ,fSharedPadsOn(kFALSE) | |
227 | ,fIsPadShared(kFALSE) | |
228 | ,fGeo(NULL) | |
229 | { | |
230 | // | |
231 | // Create an object to read TRD raw digits | |
232 | // | |
233 | ||
234 | fRawReader->Select("TRD"); | |
235 | ||
236 | for (Int_t i = 0; i < 540; i++) { | |
237 | fChamberDone[i] = 0; | |
238 | } | |
239 | ||
240 | } | |
241 | ||
242 | //_____________________________________________________________________________ | |
243 | AliTRDRawStreamTB::AliTRDRawStreamTB(const AliTRDRawStreamTB& stream) | |
244 | :TObject(stream) | |
245 | ,fSig() | |
246 | ,fADC(-1) | |
247 | ,fMaxADCgeom(-1) | |
248 | ,fTB(-1) | |
249 | ,fEv(-1) | |
250 | ,fROB(-1) | |
251 | ,fMCM(-1) | |
252 | ,fSM(-1) | |
253 | ,fLAYER(-1) | |
254 | ,fSTACK(-1) | |
255 | ,fROC(-1) | |
256 | ,fSIDE(-1) | |
257 | ,fDCS(-1) | |
258 | ,fROW(-1) | |
259 | ,fCOL(-1) | |
260 | ,fDET(-1) | |
261 | ,fLastDET(-1) | |
262 | ,fBCctr(-1) | |
263 | ,fPTctr(-1) | |
264 | ,fPTphase(-1) | |
265 | ,fRVmajor(-1) | |
266 | ,fRVminor(-1) | |
267 | ,fHCHWords(-1) | |
268 | ,fTBins(-1) | |
269 | ,fTCon(0) | |
270 | ,fPEDon(0) | |
271 | ,fGAINon(0) | |
272 | ,fXTon(0) | |
273 | ,fNonLinOn(-1) | |
274 | ,fBypass(-1) | |
275 | ,fCommonAdditive(-1) | |
276 | ,fZeroSuppressed(0) | |
277 | ,fHCHctr1(-1) | |
278 | ,fHCHctr2(-1) | |
279 | ,fMCMHctr1(-1) | |
280 | ,fMCMHctr2(-1) | |
281 | ,fGTUctr1(-1) | |
282 | ,fGTUctr2(-1) | |
283 | ,fHCdataCtr(-1) | |
284 | ,fTracklPID(-1.) | |
285 | ,fTracklDefL(-1.) | |
286 | ,fTracklPadPos(-1.) | |
287 | ,fTracklPadRow(-1) | |
288 | ,fGTUlinkMask() | |
289 | ,fMCMWordCrt(0) | |
290 | ,fMCMWordsExpected(0) | |
291 | ,fRawReader(NULL) | |
292 | ,fRawVersion(0) | |
293 | ,fRawDigitThreshold(0) | |
294 | ,fNextStatus(0) | |
295 | ,fLastStatus(0) | |
296 | ,fTbSwitch(0) | |
297 | ,fTbSwitchCtr(0) | |
298 | ,fTimeWords(0) | |
299 | ,fWordCtr(0) | |
300 | ,fRowMax(-1) | |
301 | ,fColMax(-1) | |
302 | ,fADCmask() | |
303 | ,fLastADCmask(0) | |
304 | ,fChamberDone() | |
305 | ,fRetVal(0) | |
306 | ,fEqID(0) | |
307 | ,fDataSize(0) | |
308 | ,fSizeOK(kFALSE) | |
309 | ,fCountBytes(0) | |
310 | ,fBufSize(0) | |
311 | ,fkBufferSet(kFALSE) | |
312 | ,fPos(NULL) | |
313 | ,fDataWord(NULL) | |
314 | ,fTimeBinsCalib(0) | |
315 | ,fADClookup() | |
316 | ,fNActiveADCs(0) | |
317 | ,fEndOfDataFlag(kFALSE) | |
318 | ,fHCInfo() | |
319 | ,fMCMInfo() | |
320 | ,fiSMx(0) | |
321 | ,fSharedPadsOn(kFALSE) | |
322 | ,fIsPadShared(kFALSE) | |
323 | ,fGeo(NULL) | |
324 | { | |
325 | // | |
326 | // Copy constructor | |
327 | // | |
328 | ||
329 | AliFatal("Copy constructor not implemented"); | |
330 | ||
331 | } | |
332 | ||
333 | //_____________________________________________________________________________ | |
334 | AliTRDRawStreamTB& AliTRDRawStreamTB::operator = (const AliTRDRawStreamTB& | |
335 | /* stream */) | |
336 | { | |
337 | // | |
338 | // Assigment operator | |
339 | // | |
340 | ||
341 | Fatal("operator =", "assignment operator not implemented"); | |
342 | return *this; | |
343 | ||
344 | } | |
345 | ||
346 | //_____________________________________________________________________________ | |
347 | AliTRDRawStreamTB::~AliTRDRawStreamTB() | |
348 | { | |
349 | // | |
350 | // Destructor | |
351 | // | |
352 | ||
353 | if (fGeo) | |
354 | { | |
355 | delete fGeo; | |
356 | } | |
357 | ||
358 | } | |
359 | ||
360 | //_____________________________________________________________________________ | |
361 | void AliTRDRawStreamTB::SetRawReader(AliRawReader *rawReader) | |
362 | { | |
363 | // | |
364 | // Set the rawreader | |
365 | // | |
366 | ||
367 | if (rawReader) | |
368 | { | |
369 | fRawReader = rawReader; | |
370 | } | |
371 | } | |
372 | ||
373 | //_____________________________________________________________________________ | |
374 | Bool_t AliTRDRawStreamTB::SetRawVersion(Int_t rv) | |
375 | { | |
376 | // | |
377 | // Set the raw data version | |
378 | // | |
379 | ||
380 | if ( rv >= 0 && rv <= 3 ) { | |
381 | fRawVersion = rv; | |
382 | return kTRUE; | |
383 | } | |
384 | ||
385 | return kFALSE; | |
386 | ||
387 | } | |
388 | ||
389 | ||
390 | //____________________________________________________________________________ | |
391 | Int_t AliTRDRawStreamTB::Init() | |
392 | { | |
393 | // | |
394 | // Initialization | |
395 | // | |
396 | ||
397 | if (!AliTRDcalibDB::Instance()) { | |
398 | AliError("Could not get calibration object"); | |
399 | return 0; | |
400 | } | |
401 | ||
402 | if (!fGeo) { | |
403 | fGeo = new AliTRDgeometry(); | |
404 | } | |
405 | ||
406 | fMaxADCgeom = (Int_t)fGeo->ADCmax(); | |
407 | ||
408 | fTimeBinsCalib = AliTRDcalibDB::Instance()->GetNumberOfTimeBins(); | |
409 | //AliDebug(2, Form("Number of Timebins read from CDB: %d", fTimeBinsCalib)); | |
410 | ||
411 | // The number of data words needed for this number of time bins (there | |
412 | // are 3 time bins in one word) | |
413 | fTimeWords = (fTimeBinsCalib-1)/3 + 1; | |
414 | ||
415 | fTbSwitch = 3; | |
416 | fTbSwitchCtr = 0; | |
417 | ||
418 | fHCHctr1 = fHCHctr2 = 0; | |
419 | fGTUctr1 = fGTUctr2 = -1; | |
420 | ||
421 | fHCdataCtr = 0; | |
422 | fWordCtr = 0; | |
423 | ||
424 | fDET = -1; | |
425 | fLastDET = -1; | |
426 | fRetVal = 0; | |
427 | fEqID = 0; | |
428 | fDataSize = 0; | |
429 | fSizeOK = kFALSE; | |
430 | ||
431 | fLastStatus = kStart; | |
432 | fNextStatus = kStart; | |
433 | ||
434 | fCountBytes = 0; | |
435 | fBufSize = 0; | |
436 | fDataWord = NULL; | |
437 | fPos = NULL; | |
438 | fWordCtr = 0; | |
439 | fkBufferSet = kFALSE; | |
440 | ||
441 | fMCMWordCrt = 0; | |
442 | fMCMWordsExpected = 0; | |
443 | ||
444 | fEndOfDataFlag = kFALSE; | |
445 | // set all ADC active | |
446 | fNActiveADCs = ChannelsToRead(0x1fffff); // should be 1111 1111 1111 1111 1111 1 = 21 bits active (0-20) | |
447 | ||
448 | fLastADCmask = 0; | |
449 | ||
450 | //default value overwritten by HC header word h[2] | |
451 | fCommonAdditive = 10; | |
452 | //fSharedPadsOn = kFALSE; | |
453 | //fSharedPadsOn = kTRUE; | |
454 | fIsPadShared = kFALSE; | |
455 | fZeroSuppressed = kFALSE; | |
456 | ||
457 | return kTRUE; | |
458 | } | |
459 | ||
460 | //____________________________________________________________________________ | |
461 | void AliTRDRawStreamTB::SwapOnEndian() | |
462 | { | |
463 | // | |
464 | // Check the endian and swap if needed | |
465 | // | |
466 | ||
467 | int itemp = 1; | |
468 | char* ptemp = (char*) &itemp; | |
469 | if (ptemp[0] != 1) | |
470 | { | |
471 | // need to swap... | |
472 | // assume we are at the begining of the buffer! | |
473 | //AliDebug(5, "Swapping."); | |
474 | UInt_t *pbegin = (UInt_t*)fPos; | |
475 | UInt_t iutmp = 0; | |
476 | for (UInt_t i = 0; i < fBufSize / AliTRDrawDataUtilsTB::kSizeWord; i++) | |
477 | { | |
478 | fDataWord = pbegin + i; | |
479 | iutmp = (((*fDataWord & 0x000000ffU) << 24) | ((*fDataWord & 0x0000ff00U) << 8) | | |
480 | ((*fDataWord & 0x00ff0000U) >> 8) | ((*fDataWord & 0xff000000U) >> 24)); | |
481 | // here we override the value in the buffer! | |
482 | *fDataWord = iutmp; | |
483 | } | |
484 | fDataWord = pbegin; | |
485 | } | |
486 | } | |
487 | ||
488 | //____________________________________________________________________________ | |
489 | Int_t AliTRDRawStreamTB::NextData() | |
490 | { | |
491 | // | |
492 | // Updates the next data word pointer | |
493 | // | |
494 | ||
495 | if (fCountBytes + kSizeWord >= fBufSize) | |
496 | { | |
497 | fkBufferSet = fRawReader->ReadNextData(fPos); | |
498 | if (fkBufferSet == kTRUE) | |
499 | { | |
500 | fBufSize = fRawReader->GetDataSize(); | |
501 | fCountBytes = 0; | |
502 | fDataWord = (UInt_t*)fPos; | |
503 | SwapOnEndian(); | |
504 | if (fgRawDataHack == kTRUE) | |
505 | { | |
506 | SkipWords(24); | |
507 | fCountBytes += 24 * kSizeWord; | |
508 | //fgRawDataHack = kFALSE; | |
509 | } | |
510 | ChangeStatus(kNextSM); | |
511 | fWordCtr = 0; | |
512 | AliDebug(3, "NextSM. Buffer is set."); | |
513 | return kNextSM; | |
514 | } | |
515 | else | |
516 | { | |
517 | AliDebug(3, "No more data!"); | |
518 | //ChangeStatus(kStop); | |
519 | ChangeStatus(kNoMoreData); | |
520 | return kNoMoreData; | |
521 | } | |
522 | } | |
523 | else | |
524 | { | |
525 | fPos += kSizeWord; | |
526 | fCountBytes += kSizeWord; | |
527 | fDataWord = (UInt_t*)fPos; | |
528 | fWordCtr++; | |
529 | AliDebug(10, Form("Current word %d : 0x%x at 0x%x. Count bytes %d of %d", | |
530 | fWordCtr, *fDataWord, fPos, fCountBytes, fBufSize)); | |
531 | // if (fCountBytes > 3080000) | |
532 | // printf("Current word %d : 0x%x at 0x%x. Count bytes %d of %d\n", | |
533 | // fWordCtr, *fDataWord, fPos, fCountBytes, fBufSize); | |
534 | return kWordOK; | |
535 | } | |
536 | } | |
537 | ||
538 | //____________________________________________________________________________ | |
539 | Int_t AliTRDRawStreamTB::RewindWord() | |
540 | { | |
541 | // | |
542 | // Updates the next data word pointer | |
543 | // | |
544 | ||
545 | if (fkBufferSet == kFALSE) | |
546 | return kStart; | |
547 | ||
548 | if (fCountBytes > 0) | |
549 | { | |
550 | fPos -= kSizeWord; | |
551 | fCountBytes -= kSizeWord; | |
552 | fDataWord = (UInt_t*)fPos; | |
553 | fWordCtr--; | |
554 | } | |
555 | else | |
556 | { | |
557 | AliWarning("Already at the begining of the buffer"); | |
558 | } | |
559 | ||
560 | return kWordOK; | |
561 | } | |
562 | ||
563 | //============================================================================ | |
564 | // Decoding functions | |
565 | //============================================================================ | |
566 | ||
567 | //____________________________________________________________________________ | |
568 | void AliTRDRawStreamTB::DecodeHCheader(Int_t timeBins) | |
569 | { | |
570 | // | |
571 | // Decode the HC header (fRawVersion == 2, 3, 4, ???) | |
572 | // | |
573 | //AliDebug(3, "Here"); | |
574 | ||
575 | // 1st word (h[0]) | |
576 | if ( (*fDataWord & 0x3) == 1 ) | |
577 | { | |
578 | ||
579 | fHCInfo.DecodeH0(fDataWord); | |
580 | if (fgExtraDebug) | |
581 | fHCInfo.Dump(); | |
582 | ||
583 | fHCHWords = fHCInfo.fNExtraWords; | |
584 | fSM = fHCInfo.fSM; | |
585 | fLAYER = fHCInfo.fLayer; | |
586 | fSTACK = fHCInfo.fStack; | |
587 | fSIDE = fHCInfo.fSide; | |
588 | ||
589 | fRVmajor = fHCInfo.fRawVMajor; | |
590 | fRVminor = fHCInfo.fRawVMinor; | |
591 | ||
592 | //assuming valid raw version w/o ZS | |
593 | if (fRVmajor <= 0) | |
594 | fRVmajor = 2; | |
595 | ||
596 | if ( fRawVersion != fRVmajor ) | |
597 | { | |
598 | if (fgSupressWarnings == kTRUE) | |
599 | { | |
600 | if (fgForceRawVersion > 0) | |
601 | { | |
602 | fRawVersion = fgForceRawVersion; | |
603 | } | |
604 | else | |
605 | { | |
606 | fRawVersion = fRVmajor; | |
607 | } | |
608 | } | |
609 | else | |
610 | { | |
611 | AliWarning("==============================================================================="); | |
612 | AliWarning(Form("Mismatch between fRawVersion (%d) and fRVmajor from HC header (%d)" | |
613 | ,fRawVersion,fRVmajor)); | |
614 | if (fgForceRawVersion > 0) | |
615 | { | |
616 | AliWarning(Form("Forcing fRawVersion to %d", fgForceRawVersion)); | |
617 | fRawVersion = fgForceRawVersion; | |
618 | } | |
619 | else | |
620 | { | |
621 | AliWarning(Form("Setting fRawVersion to %d", fRVmajor)); | |
622 | fRawVersion = fRVmajor; | |
623 | } | |
624 | AliWarning("==============================================================================="); | |
625 | } //warn or not | |
626 | }//if raw version missmatch | |
627 | ||
628 | //AliInfo(Form("Raw Version %d", fRawVersion)); | |
629 | ||
630 | // | |
631 | // check for zero suppression | |
632 | if ( fRawVersion >= 3 || fRawVersion <= 4 ) fZeroSuppressed = kTRUE; | |
633 | else fZeroSuppressed = kFALSE; | |
634 | ||
635 | fROC = fGeo->GetDetectorSec(fLAYER, fSTACK); | |
636 | ||
637 | AliDebug(3, Form("0x%08x: HC header: sm=%d; roc=%d; side=%x", *fDataWord, fSM, fROC, fSIDE+10)); | |
638 | AliDebug(5, Form("0x%08x: HC header: expecting %d HC words", *fDataWord, fHCHWords)); | |
639 | ||
640 | if ((fSM < 0) || | |
641 | (fSM > 17) || | |
642 | (fLAYER < 0) || | |
643 | (fLAYER > 5) || | |
644 | (fSTACK < 0) || | |
645 | (fSTACK > 4) || | |
646 | (fSIDE < 0) || | |
647 | (fSIDE > 1)) | |
648 | { | |
649 | AliWarning(Form("0x%08x: Strange HC header: dcs=%d; sm=%d; layer=%d; stack=%d.", | |
650 | *fDataWord, fDCS, fSM, fLAYER, fSTACK)); | |
651 | fRawReader->AddMajorErrorLog(kHCHeaderCorrupt,Form("0x%08x:dcs=%d; sm=%d; layer=%d; stack=%d.", | |
652 | *fDataWord, fDCS, fSM, fLAYER, fSTACK)); | |
653 | } | |
654 | else | |
655 | { | |
656 | fHCHctr1++; | |
657 | fHCHctr2++; | |
658 | } | |
659 | } | |
660 | else | |
661 | { | |
662 | AliWarning(Form("0x%08x: No HC header when it was expected.", *fDataWord)); | |
663 | fRawReader->AddMajorErrorLog(kHCHeaderMissing,Form("0x%08x", *fDataWord)); | |
664 | } | |
665 | ||
666 | // 2nd word (h[1]) | |
667 | if ( fHCHWords >= 1 ) | |
668 | { | |
669 | // read one more word | |
670 | if (NextData() != kWordOK) | |
671 | { | |
672 | AliWarning("Next HC ( H[1] ) word missing"); | |
673 | fRawReader->AddMajorErrorLog(kHCWordMissing,"Next HC ( H[1] )word missing"); | |
674 | ChangeStatus(kNextHC); | |
675 | return; | |
676 | } | |
677 | ||
678 | if ( (*fDataWord & 0x3) == 1 ) | |
679 | { | |
680 | ||
681 | fHCInfo.DecodeH1(fDataWord); | |
682 | ||
683 | fBCctr = fHCInfo.fBunchCrossCounter; | |
684 | fPTctr = fHCInfo.fPreTriggerCounter; | |
685 | fPTphase = fHCInfo.fPreTriggerPhase; | |
686 | fTBins = fHCInfo.fTimeBins; | |
687 | ||
688 | fTimeWords = (fTBins - 1)/3 + 1; | |
689 | ||
690 | AliDebug(3, Form("0x%08x: HC header [1]: BCctr=%d PTctr=%d PTph=%d TB=%d" | |
691 | , *fDataWord, fBCctr, fPTctr, fPTphase, fTBins)); | |
692 | ||
693 | if( fTBins != timeBins ) | |
694 | { | |
695 | if (fgSupressWarnings == kTRUE) | |
696 | { | |
697 | fTimeWords = (fTBins - 1)/3 + 1; | |
698 | } | |
699 | else | |
700 | { | |
701 | AliWarning("==============================================================================="); | |
702 | AliError(Form("Mismatch between nNTB from CDB (%d) and from HC header (%d)" | |
703 | , timeBins, fTBins)); | |
704 | AliWarning(Form("We will use the value from the raw data (HC header): %d", fTBins)); | |
705 | AliWarning("==============================================================================="); | |
706 | fTimeWords = (fTBins - 1)/3 + 1; | |
707 | } | |
708 | } | |
709 | } | |
710 | } | |
711 | ||
712 | // 3nd word (h[2]) | |
713 | if ( fHCHWords >= 2 ) | |
714 | { | |
715 | // read one more word | |
716 | if (NextData() != kWordOK) | |
717 | { | |
718 | AliWarning("Next HC ( [2] )word missing"); | |
719 | fRawReader->AddMajorErrorLog(kHCWordMissing,"Next HC ( [2] ) word missing"); | |
720 | ChangeStatus(kNextHC); | |
721 | return; | |
722 | } | |
723 | ||
724 | if ( (*fDataWord & 0x3) == 1 ) | |
725 | { | |
726 | ||
727 | fTCon = (*fDataWord >> 29) & 0x1; | |
728 | fPEDon = (*fDataWord >> 31) & 0x1; | |
729 | fGAINon = (*fDataWord >> 30) & 0x1; | |
730 | fXTon = (*fDataWord >> 28) & 0x1; | |
731 | fNonLinOn = (*fDataWord >> 27) & 0x1; | |
732 | fBypass = (*fDataWord >> 26) & 0x1; | |
733 | ||
734 | fCommonAdditive = (*fDataWord >> 20) & 0x3f; | |
735 | ||
736 | AliDebug(3, Form("0x%08x: HC header 3: TC=%d, PED=%d, GAIN=%d, XT=%d, NonLin=%d, Bypass=%d, Add=%d" | |
737 | , fTCon, fPEDon, fGAINon, fXTon, fNonLinOn, fBypass, fCommonAdditive)); | |
738 | } | |
739 | } | |
740 | ||
741 | if (fTBins <= 0) | |
742 | { | |
743 | fTBins = 30; | |
744 | fTimeWords = (fTBins - 1)/3 + 1; | |
745 | AliDebug(5, Form("Forced tbins %d timewords %d", fTBins, fTimeWords)); | |
746 | } | |
747 | } | |
748 | ||
749 | //____________________________________________________________________________ | |
750 | Int_t AliTRDRawStreamTB::ChannelsToRead(Int_t ADCmask) | |
751 | { | |
752 | //AliDebug(3, "Here"); | |
753 | memset(fADClookup, -1, 32 * sizeof(Int_t)); | |
754 | fADClookup[0] = 0; // count entries | |
755 | fADClookup[1] = 2; // index - data start at 2 | |
756 | UInt_t mask = 0; | |
757 | for (Int_t i = 0; i < 30; i++) | |
758 | { | |
759 | mask = 1 << i; | |
760 | if ((ADCmask & mask)) | |
761 | { | |
762 | //AliDebug(9, Form("fDataWord=0x%08x mask=0x%08x i=%d", *fDataWord, mask, i)); | |
763 | fADClookup[fADClookup[1]] = i; | |
764 | ++fADClookup[0]; | |
765 | ++fADClookup[1]; | |
766 | } | |
767 | } | |
768 | ||
769 | // test the iteration - comment out for production | |
770 | // begin of comment out section | |
771 | // char schannels[512]; | |
772 | // sprintf(schannels, "ADC Channels to read: "); | |
773 | // fADClookup[1] = 2; | |
774 | // while(fADClookup[1] - 2 < fADClookup[0]) | |
775 | // { | |
776 | // AliDebug(9, Form("max=%d index=%d adc=%d", fADClookup[0], fADClookup[1], fADClookup[fADClookup[1]])); | |
777 | // strcat(schannels, Form("%d ", fADClookup[fADClookup[1]])); | |
778 | // fADClookup[1]++; | |
779 | // } | |
780 | //AliDebug(9, Form("%s", schannels)); | |
781 | //AliDebug(9, Form("ADC channels = %d", fADClookup[0])); | |
782 | // end of comment out section | |
783 | ||
784 | fADClookup[1] = 2; | |
785 | return fADClookup[0]; | |
786 | } | |
787 | ||
788 | //____________________________________________________________________________ | |
789 | void AliTRDRawStreamTB::DecodeTracklet() | |
790 | { | |
791 | ||
792 | // | |
793 | // Decode the Tracklet | |
794 | // | |
795 | // this function is not tested yet on real tracklets | |
796 | // | |
797 | //AliDebug(3, "Here"); | |
798 | // if ( fRawVersion < 1 || fRawVersion > 3 ) | |
799 | // { | |
800 | // AliError(Form(" Unsupported raw version: %d", fRawVersion)); | |
801 | // } | |
802 | ||
803 | fTracklPID = (*fDataWord >> 24) & 0xff; | |
804 | fTracklPadRow = (*fDataWord >> 20) & 0xf; // 0:15 | |
805 | fTracklDefL = (*fDataWord >> 13) & 0x7f; | |
806 | fTracklPadPos = (*fDataWord) & 0x1fff; | |
807 | ||
808 | fTracklPID /= (Float_t)((1<<8) - 1); // 0:1 (steps of 0.39%) | |
809 | fTracklDefL = (fTracklDefL - ((1<< 7)-1)/2.) * 140.e-4; // -0.889:0.889cm | |
810 | fTracklPadPos = (fTracklPadPos - ((1<<13)-1)/2.) * 160.e-4; // -65.528:65.528 cm | |
811 | ||
812 | AliDebug(4, Form("0x%08x: Tracklet found: SM%d L%dS%d side %x: PadRow=%d PadPos=%f DefL=%f PID=%f" | |
813 | , *fDataWord, fSM, fLAYER, fSTACK, fSIDE+10 | |
814 | , fTracklPadRow, fTracklPadPos, fTracklDefL, fTracklPID)); | |
815 | ||
816 | if( (fSTACK == 2) && (fTracklPadRow >= (Int_t) fGeo->RowmaxC0()) || | |
817 | (fSTACK != 2) && (fTracklPadRow >= (Int_t) fGeo->RowmaxC1()) ) { | |
818 | AliWarning(Form("Strange Row read from Tracklet Word: %d", fTracklPadRow)); | |
819 | fRawReader->AddMajorErrorLog(kTrackletRowMismatch,Form("Word: %d", fTracklPadRow)); | |
820 | } | |
821 | ||
822 | } | |
823 | ||
824 | //____________________________________________________________________________ | |
825 | void AliTRDRawStreamTB::DecodeMCMheader() | |
826 | { | |
827 | ||
828 | // | |
829 | // Decode the MCM header | |
830 | // | |
831 | //AliDebug(3, "Here"); | |
832 | ||
833 | if ( fRawVersion < 0 || fRawVersion > 3 ) | |
834 | { | |
835 | AliError(Form(" Unsupported raw version: %d", fRawVersion)); | |
836 | } | |
837 | ||
838 | fMCMInfo.Decode(fDataWord); | |
839 | ||
840 | fMCM = fMCMInfo.fMCM; | |
841 | fROB = fMCMInfo.fROB; | |
842 | fEv = fMCMInfo.fEvCounter; | |
843 | if (fgExtraDebug) | |
844 | fMCMInfo.Dump(); | |
845 | ||
846 | fROW = AliTRDfeeParam::Instance()->GetPadRowFromMCM(fROB, fMCM); | |
847 | ||
848 | AliDebug(4, Form("0x%08x: SM%d L%dS%d. MCM Header: fROB=%d fMCM=%02d fEv=%02d" | |
849 | , *fDataWord, fSM, fLAYER, fSTACK, fROB, fMCM, fEv)); | |
850 | ||
851 | if ( fROB % 2 == 0 && fSIDE == 1 ) | |
852 | { | |
853 | AliWarning(Form("SM%d L%dS%d: Mismatch between fROB (%d) and fSIDE (%d): fMCM=%02d" | |
854 | , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM )); | |
855 | fRawReader->AddMajorErrorLog(kROBSideMismatch,Form("SM%d L%dS%d: fROB (%d) fSIDE (%d): fMCM=%02d" | |
856 | , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM )); | |
857 | } | |
858 | ||
859 | if ( fROB % 2 != 0 && fSIDE == 0 ) | |
860 | { | |
861 | AliWarning(Form("SM%d L%dS%d: Mismatch between fROB (%d) and fSIDE (%d): fMCM=%02d" | |
862 | , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM )); | |
863 | fRawReader->AddMajorErrorLog(kROBSideMismatch,Form("SM%d L%dS%d: fROB (%d) fSIDE (%d): fMCM=%02d" | |
864 | , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM )); | |
865 | } | |
866 | ||
867 | if ( (fSTACK == 2 && fROW >= fGeo->RowmaxC0()) || | |
868 | (fSTACK != 2 && fROW >= fGeo->RowmaxC1()) || fROW < 0 ) | |
869 | { | |
870 | AliWarning(Form("SM%d L%dS%d: Wrong Padrow (%d) fROB=%d, fSIDE=%d, fMCM=%02d" | |
871 | , fSM, fLAYER, fSTACK, fROW, fROB, fSIDE, fMCM )); | |
872 | fRawReader->AddMajorErrorLog(kWrongPadrow,Form("SM%d L%dS%d: Padrow (%d) fROB=%d, fSIDE=%d, fMCM=%02d" | |
873 | , fSM, fLAYER, fSTACK, fROW, fROB, fSIDE, fMCM )); | |
874 | } | |
875 | ||
876 | fMCMHctr1++; | |
877 | fMCMHctr2++; | |
878 | ||
879 | fMCMWordCrt = 1; // MCM header | |
880 | ||
881 | // AdcMask for Zero supressed data | |
882 | if ( fRawVersion == 3 ) | |
883 | { | |
884 | // read one more word | |
885 | if (NextData() != kWordOK) | |
886 | { | |
887 | AliWarning("MCM ADC mask missing"); | |
888 | fRawReader->AddMajorErrorLog(kMCMADCMaskMissing,"Missing"); | |
889 | fNextStatus = kNextHC; | |
890 | return; | |
891 | } | |
892 | else | |
893 | { | |
894 | ++fMCMWordCrt; | |
895 | ||
896 | for ( Int_t ctr = 0; ctr < fMaxADCgeom; ctr++ ) { | |
897 | if ( (*fDataWord >> (11+ctr)) == 0x1 ) fADCmask[ctr] = kTRUE; | |
898 | else fADCmask[ctr] = kFALSE; | |
899 | } | |
900 | ||
901 | if (*fDataWord & 0xf != 0xc) | |
902 | { | |
903 | AliWarning(Form("ADC mask does not end with 0xc : 0x%x", *fDataWord)); | |
904 | } | |
905 | ||
906 | //AliDebug(4, Form("0x%08x: ADC mask", *fDataWord)); | |
907 | // 7 MSbits are ignored! | |
908 | UInt_t maskWord = (*fDataWord >> 4) & 0x1fffff; | |
909 | fNActiveADCs = ChannelsToRead(maskWord); | |
910 | } | |
911 | } | |
912 | ||
913 | if (fRawVersion <= 2) | |
914 | { | |
915 | fNActiveADCs = ChannelsToRead(0x1fffff); // should be 1111 1111 1111 1111 1111 1 = 21 bits active (0-20) | |
916 | //directly get it like that: | |
917 | fMCMWordsExpected = 1 + fNActiveADCs * fTBins / 3; | |
918 | } | |
919 | ||
920 | if (fRawVersion >= 3) | |
921 | { | |
922 | // raw version 3: | |
923 | //directly get it like that: | |
924 | fMCMWordsExpected = 1 + 1 + (fTBins * fNActiveADCs) / 3; | |
925 | } | |
926 | ||
927 | AliDebug(8, Form("TBins %d fNActiveADCs %d => We expect %d MCM words. We read %d so far.", fTBins, fNActiveADCs, fMCMWordsExpected, fMCMWordCrt)); | |
928 | } | |
929 | ||
930 | //____________________________________________________________________________ | |
931 | Bool_t AliTRDRawStreamTB::DecodeADCWord() | |
932 | { | |
933 | // Decode ADC word for any pad | |
934 | // Rearange this function!!! | |
935 | //AliDebug(3, "Here"); | |
936 | Bool_t kIsDataOK = kFALSE; | |
937 | ||
938 | // Get Pad column | |
939 | // fCOL = fFee->GetPadColFromADC(fROB, fMCM, fADC); | |
940 | if ( fADC >= fMaxADCgeom - 1) | |
941 | { | |
942 | // let us guess the Column | |
943 | // take the one before last ADC and shift by one column | |
944 | // later we check if we are inside the limits of the chamber | |
945 | fCOL = AliTRDfeeParam::Instance()->GetPadColFromADC(fROB, fMCM, fADC - 1); | |
946 | fCOL--; | |
947 | //AliDebug(8, Form("-x fADC %d fCOL %d", fADC, fCOL)); | |
948 | if (fCOL >= fColMax || fCOL < 0) | |
949 | { | |
950 | //AliDebug(8, Form("-xx fADC %d fCOL %d", fADC, fCOL)); | |
951 | fCOL = -1; | |
952 | kIsDataOK = kFALSE; | |
953 | return kIsDataOK; | |
954 | } | |
955 | } | |
956 | else | |
957 | { | |
958 | //AliDebug(8, Form("-y fADC %d fCOL %d", fADC, fCOL)); | |
959 | fCOL = AliTRDfeeParam::Instance()->GetPadColFromADC(fROB, fMCM, fADC); | |
960 | if (fCOL >= fColMax || fCOL < 0) | |
961 | { | |
962 | //AliDebug(8, Form("-xx fADC %d fCOL %d", fADC, fCOL)); | |
963 | fCOL = -1; | |
964 | kIsDataOK = kFALSE; | |
965 | return kIsDataOK; | |
966 | } | |
967 | } | |
968 | ||
969 | // We have only 144 Pad Columns | |
970 | //if ( fCOL > fColMax-1 || fCOL < 0 ) | |
971 | if ( fCOL >= 0 && fCOL < fColMax && fROW >= 0 && fROW < fRowMax ) | |
972 | { | |
973 | // Decode 32 bit data words with information from 3 time bins and copy the data | |
974 | fSig[0] = (*fDataWord & 0x00000ffc) >> 2; | |
975 | fSig[1] = (*fDataWord & 0x003ff000) >> 12; | |
976 | fSig[2] = (*fDataWord & 0xffc00000) >> 22; | |
977 | ||
978 | // Print data to screen: | |
979 | AliDebug(5, Form("DATA : 0x%x tTbin %d", *fDataWord, fTB)); | |
980 | AliDebug(5, Form("SM%d L%dS%d: ROB%d MCM=%d ADC=%d (ROW=%d COL=%d): Data %04d %04d %04d\n", | |
981 | fSM, fLAYER, fSTACK, fROB, fMCM, fADC, fROW, fCOL, fSig[0], fSig[1], fSig[2])); | |
982 | kIsDataOK = kTRUE; | |
983 | } | |
984 | else | |
985 | { | |
986 | AliWarning(Form("SM%d L%dS%d: Wrong Pad column (%d) fROB=%d, fSIDE=%d, fMCM=%02d", fSM, | |
987 | fLAYER, fSTACK, fCOL, fROB, fSIDE, fMCM )); | |
988 | fRawReader->AddMajorErrorLog(kWrongPadcolumn,Form("SM%d L%dS%d: column (%d) fROB=%d, fSIDE=%d, fMCM=%02d", fSM, | |
989 | fLAYER, fSTACK, fCOL, fROB, fSIDE, fMCM )); | |
990 | kIsDataOK = kFALSE; | |
991 | } | |
992 | ||
993 | return kIsDataOK; | |
994 | } | |
995 | ||
996 | //____________________________________________________________________________ | |
997 | Bool_t AliTRDRawStreamTB::DecodeNextRawWord() | |
998 | { | |
999 | //AliDebug(8, Form("-----------------------------------------")); | |
1000 | //AliDebug(8, Form("DATA IS 0x%x", *fDataWord)); | |
1001 | ||
1002 | //AliDebug(3, "Here"); | |
1003 | if ( *fDataWord == kEndOfRawDataMarker ) | |
1004 | { // End of half-chamber data, finished | |
1005 | AliDebug(3, "We have reached the eof data. Next should be HC header."); | |
1006 | fGTUctr1 = -1; | |
1007 | ChangeStatus(kNextHC); | |
1008 | fEndOfDataFlag = kTRUE; | |
1009 | return kFALSE; | |
1010 | } | |
1011 | ||
1012 | if (fADClookup[1] - 2 > fADClookup[0]) | |
1013 | { | |
1014 | AliDebug(8, Form("Overflow Index ADC = %d Max Index = %d Value = %d. Done with ADCs in this MCM. Is this already MCM header 0x%x?", | |
1015 | fADClookup[1] - 2, fADClookup[0], fADClookup[fADClookup[1]], *fDataWord)); | |
1016 | fTB = 0; | |
1017 | fTbSwitchCtr = 0; | |
1018 | fMCMWordsExpected = 0; | |
1019 | AliWarning("Trying to recover. Fall back to DecodeMCM."); | |
1020 | RewindWord(); | |
1021 | ChangeStatus(kNextMCM); | |
1022 | return kFALSE; | |
1023 | } | |
1024 | ||
1025 | if ( (*fDataWord & 0x00000003) != 0x2 && (*fDataWord & 0x00000003) != 0x3) | |
1026 | { | |
1027 | AliWarning(Form("Data %08x : Data Word ends neither with b11 nor b10", (Int_t)*fDataWord)); | |
1028 | fRawReader->AddMinorErrorLog(kDataMaskError,Form("Data %08x", (Int_t)*fDataWord)); | |
1029 | fMCMWordsExpected = 0; | |
1030 | fTB = 0; | |
1031 | fTbSwitchCtr = 0; | |
1032 | AliWarning("Trying to recover. Fall back to DecodeMCM."); | |
1033 | RewindWord(); | |
1034 | ChangeStatus(kNextMCM); | |
1035 | return kFALSE; | |
1036 | } | |
1037 | ||
1038 | if ( (*fDataWord & 0x3) != fLastADCmask || fTbSwitchCtr >= fTimeWords) | |
1039 | { | |
1040 | fADC = fADClookup[fADClookup[1]]; | |
1041 | AliDebug(8, Form("Next fADC = %d at index = %d MCM Word Number: %d Max MCM Words is %d", | |
1042 | fADC, fADClookup[1] - 2, fMCMWordCrt, fMCMWordsExpected)); | |
1043 | AliDebug(10, Form("LastMask 0x%x this data 0x%x OR fTbSwitchCtr %d >= fTimeWords %d", | |
1044 | fLastADCmask, (*fDataWord) & 0x3, fTbSwitchCtr, fTimeWords)); | |
1045 | if ((*fDataWord & 0x3) != fLastADCmask && fTbSwitchCtr < fTimeWords && fTbSwitchCtr > 0) | |
1046 | { | |
1047 | AliWarning(Form("Change of mask! But not all words read!")); | |
1048 | AliWarning(Form("Next fADC = %d at index = %d MCM Word Number: %d Max MCM Words is %d", | |
1049 | fADC, fADClookup[1] - 2, fMCMWordCrt, fMCMWordsExpected)); | |
1050 | AliWarning(Form("LastMask 0x%x this data 0x%x OR fTbSwitchCtr %d >= fTimeWords %d", | |
1051 | fLastADCmask, (*fDataWord) & 0x3, fTbSwitchCtr, fTimeWords)); | |
1052 | } | |
1053 | ++fADClookup[1]; | |
1054 | fTB = 0; | |
1055 | fTbSwitchCtr = 0; | |
1056 | ChangeStatus(kNextData); | |
1057 | fLastADCmask = (*fDataWord) & 0x3; | |
1058 | } | |
1059 | ||
1060 | ++fTbSwitchCtr; | |
1061 | ||
1062 | //decode data here | |
1063 | Bool_t kIsDataOK = kFALSE; | |
1064 | ||
1065 | // We have only 21 ADC channels. | |
1066 | if ( fADC > fMaxADCgeom - 1 || fADC < 0) | |
1067 | { | |
1068 | AliWarning(Form("Data 0x%08x : Data is strange. fADC is %d", (Int_t)*fDataWord, (Int_t)fADC)); | |
1069 | AliWarning(Form("fADClookup[0] %d fADClookup[1] %d", fADClookup[0], fADClookup[1])); | |
1070 | fRawReader->AddMinorErrorLog(kADCChannelOverflow,Form("Data %08x : fADC=%d", (Int_t)*fDataWord, (Int_t)fADC)); | |
1071 | } | |
1072 | else | |
1073 | { | |
1074 | // There are 18 pads connected to each MCM ADC channels 2...19. The other channels cross to other | |
1075 | // MCMs and are good for online tracking in the MCM. | |
1076 | if (fSharedPadsOn == kTRUE) | |
1077 | { | |
1078 | kIsDataOK = DecodeADCWord(); | |
1079 | if (fADC <= 1 || fADC == fMaxADCgeom - 1) | |
1080 | { | |
1081 | AliDebug(9, Form("Shared Pad fADC == %d", fADC)); | |
1082 | fIsPadShared = kTRUE; | |
1083 | } | |
1084 | else | |
1085 | { | |
1086 | fIsPadShared = kFALSE; | |
1087 | } | |
1088 | } | |
1089 | else | |
1090 | { | |
1091 | if ( fADC > 1 && fADC < fMaxADCgeom - 1 ) | |
1092 | { | |
1093 | kIsDataOK = DecodeADCWord(); | |
1094 | } | |
1095 | else | |
1096 | { | |
1097 | AliDebug(9, Form("fADC not accepted - shared pad %d - DATA : 0x%x", fADC, *fDataWord)); | |
1098 | fCOL = -1; | |
1099 | kIsDataOK = kFALSE; | |
1100 | } | |
1101 | } | |
1102 | }// if fADC is ok | |
1103 | ||
1104 | ++fMCMWordCrt; | |
1105 | AliDebug(8, Form("We expect %d MCM words. We read %d so far.Current word is 0x%x", fMCMWordsExpected, fMCMWordCrt, *fDataWord)); | |
1106 | ||
1107 | // all mcm data processed go to next one | |
1108 | if ( fMCMWordCrt >= fMCMWordsExpected) | |
1109 | { | |
1110 | AliDebug(8, Form("We expect %d MCM words. We read %d so far. Going to next MCM.", fMCMWordsExpected, fMCMWordCrt)); | |
1111 | ChangeStatus(kNextMCM); | |
1112 | } | |
1113 | ||
1114 | return kIsDataOK; | |
1115 | } | |
1116 | ||
1117 | //____________________________________________________________________________ | |
1118 | Bool_t AliTRDRawStreamTB::DecodeMCM() | |
1119 | { | |
1120 | fTbSwitch = 3; // For first adc channel we expect: (*fDataWord & 3) = 3 | |
1121 | fTbSwitchCtr = 0; // | |
1122 | fADC = fTB = 0; // Reset Counter | |
1123 | fLastADCmask = 0; // Reset | |
1124 | ||
1125 | //AliDebug(3, "Here"); | |
1126 | ||
1127 | //if( ((*fDataWord & 0x80000000) == 0x0) && ((*fDataWord & 0x0000000f) == 0xC) ) | |
1128 | //if( ((*fDataWord & 0xf0000000) == 0x80000000) && ((*fDataWord & 0x0000000f) == 0xC) ) | |
1129 | if( (*fDataWord & 0x0000000f) == 0xC ) | |
1130 | { // MCM Header | |
1131 | // this changed the status | |
1132 | DecodeMCMheader(); | |
1133 | if ( fMCM < 0 || fMCM > 15 || fROB < 0 || fROB > 7 ) | |
1134 | { | |
1135 | AliWarning("Wrong fMCM or fROB. Skip this data"); | |
1136 | fRawReader->AddMajorErrorLog(kWrongMCMorROB,Form("MCM=%d, ROB=%d",fMCM,fROB)); | |
1137 | ChangeStatus(kNextHC); | |
1138 | return kFALSE; | |
1139 | } | |
1140 | ||
1141 | if (fMCMWordCrt < fMCMWordsExpected) | |
1142 | { | |
1143 | AliDebug(5, Form("Going to read data.")); | |
1144 | ChangeStatus(kNextData); | |
1145 | } | |
1146 | else | |
1147 | { | |
1148 | //AliDebug(5, Form("! fMCMWordCrt < fMCMWordsExpected")); | |
1149 | ChangeStatus(kNextMCM); | |
1150 | } | |
1151 | //fEndOfDataFlag = kFALSE; | |
1152 | return kTRUE; | |
1153 | } | |
1154 | ||
1155 | if ( *fDataWord == kEndOfRawDataMarker ) | |
1156 | { // End of half-chamber data, finished | |
1157 | AliDebug(10, "We have reached the eof data. Next should be HC header."); | |
1158 | fGTUctr1 = -1; | |
1159 | ||
1160 | ChangeStatus(kNextHC); | |
1161 | fEndOfDataFlag = kTRUE; | |
1162 | //AliDebug(5, "Expecting MCM header but got End-Of-Raw-Data Marker"); | |
1163 | if (fMCMWordsExpected == 0 || fMCMWordsExpected == fMCMWordCrt) | |
1164 | { | |
1165 | AliDebug(5, Form("Got all mcm words. Returning true.")); | |
1166 | return kTRUE; | |
1167 | } | |
1168 | else | |
1169 | { | |
1170 | AliDebug(5, Form("MCM words missing? %d [expected=%d got=%d] ", fMCMWordsExpected - fMCMWordCrt, fMCMWordsExpected, fMCMWordCrt)); | |
1171 | //AliWarning(Form("MCM words missing? %d [expected=%d got=%d] ", fMCMWordsExpected - fMCMWordCrt, fMCMWordsExpected, fMCMWordCrt)); | |
1172 | return kFALSE; | |
1173 | } | |
1174 | } | |
1175 | ||
1176 | //AliDebug(3, Form("Expecting MCM header but got 0x%x. Going to Next MCM header.", *fDataWord)); | |
1177 | AliWarning(Form("Expecting MCM header but got 0x%x. Fall back: Next MCM header.", *fDataWord)); | |
1178 | ChangeStatus(kNextMCM); | |
1179 | ||
1180 | return kFALSE; | |
1181 | } | |
1182 | ||
1183 | //____________________________________________________________________________ | |
1184 | Bool_t AliTRDRawStreamTB::DecodeHC() | |
1185 | { | |
1186 | //AliDebug(3, "Here"); | |
1187 | ||
1188 | // left overs from the last chamber? | |
1189 | if (*fDataWord == kEndOfRawDataMarker) | |
1190 | { | |
1191 | AliDebug(3, "We have reached the eof data. Next should be HC header or end of the event!"); | |
1192 | ChangeStatus(kNextHC); | |
1193 | return kFALSE; | |
1194 | } | |
1195 | ||
1196 | // if (kFALSE == fSMinfo[fiSMx].fTrackletEnable) | |
1197 | // { | |
1198 | // // jump to data decoding - no traklets to expect | |
1199 | // ChangeStatus(kDecodeHC); | |
1200 | // } | |
1201 | // else | |
1202 | // { | |
1203 | // ChangeStatus(kNextHC); | |
1204 | // } | |
1205 | ||
1206 | if ( fNextStatus == kNextHC && fSMinfo[fiSMx].fTrackletEnable == kTRUE) | |
1207 | { | |
1208 | //AliDebug(5, "kNextHC"); | |
1209 | // | |
1210 | // 1) Find end_of_tracklet_marker if tracklets present! | |
1211 | // | |
1212 | // GTU Link Mask? | |
1213 | ||
1214 | // endoftrackletmarker? | |
1215 | if ( *fDataWord == kEndOfTrackletMarker ) | |
1216 | { | |
1217 | AliDebug(3, "End-of-tracklet-marker found"); | |
1218 | AliDebug(5, Form("Data 0x%x", *fDataWord)); | |
1219 | ChangeStatus(kSeekNonEoTracklet); | |
1220 | return kTRUE; | |
1221 | } | |
1222 | else | |
1223 | { | |
1224 | // Tracklets found | |
1225 | //AliDebug(3, "Tracklet found"); | |
1226 | AliDebug(5, Form("Tracklet data 0x%x", *fDataWord)); | |
1227 | DecodeTracklet(); | |
1228 | return kTRUE; | |
1229 | } | |
1230 | } // if next HC | |
1231 | else | |
1232 | { | |
1233 | if (fSMinfo[fiSMx].fTrackletEnable == kFALSE) | |
1234 | ChangeStatus(kDecodeHC); | |
1235 | } | |
1236 | ||
1237 | if (fNextStatus == kSeekNonEoTracklet) | |
1238 | { | |
1239 | AliDebug(5, "kSeekNonEoTracklet"); | |
1240 | ||
1241 | // | |
1242 | // 2) Look for non-end_of_tracklet_marker | |
1243 | // | |
1244 | //printf("Word %d: 0x%08x\n", fWordCtr, *fDataWord); | |
1245 | ||
1246 | if ( *fDataWord != kEndOfTrackletMarker ) | |
1247 | { | |
1248 | ChangeStatus(kDecodeHC); | |
1249 | AliDebug(3, "NON end-of-tracklet-marker found"); | |
1250 | AliDebug(5, Form("Data 0x%x", *fDataWord)); | |
1251 | //// no do not continue - this should be the hcheader | |
1252 | } | |
1253 | else | |
1254 | { | |
1255 | //just go on and find the non-end_of_tracklet_marker | |
1256 | return kTRUE; | |
1257 | } | |
1258 | } | |
1259 | ||
1260 | if ( fNextStatus == kDecodeHC ) | |
1261 | { | |
1262 | AliDebug(5, "kDecodeHC"); | |
1263 | ||
1264 | // | |
1265 | // 3) This Word must be Half Chamber Header | |
1266 | // | |
1267 | if ( (*fDataWord & 0xf0000000) == 0x80000000 && (*fDataWord & 0x00000003) == 1 ) | |
1268 | { // HC header | |
1269 | AliDebug(5, Form("Is this the HC header? 0x%x", *fDataWord)); | |
1270 | DecodeHCheader(fTimeBinsCalib); // This is the new header! | |
1271 | // fLastDET = fDET; | |
1272 | fDET = fGeo->GetDetector(fLAYER, fSTACK, fSM); | |
1273 | fRowMax = fGeo->GetRowMax(fLAYER,fSTACK,fSM); | |
1274 | fColMax = fGeo->GetColMax(fROC); | |
1275 | ||
1276 | fMCMHctr2 = 0; | |
1277 | fHCdataCtr = 0; | |
1278 | fChamberDone[fDET]++; | |
1279 | AliDebug(2, Form("-------------- DET %d fChamberDone[fDET]=%d", fDET, fChamberDone[fDET])); | |
1280 | ||
1281 | ChangeStatus(kNextMCM); | |
1282 | return kTRUE; | |
1283 | } //HC header | |
1284 | else | |
1285 | { | |
1286 | AliWarning(Form("Expecting HC header mask but got 0x%x. Fall back: Next HC.", *fDataWord)); | |
1287 | ChangeStatus(kNextHC); | |
1288 | // before we went to //ChangeStatus(kNextSM); | |
1289 | } | |
1290 | } // if decode HC | |
1291 | ||
1292 | return kFALSE; | |
1293 | } | |
1294 | //____________________________________________________________________________ | |
1295 | Bool_t AliTRDRawStreamTB::DecodeGTUlinkMask() | |
1296 | { | |
1297 | // | |
1298 | // Decode the link masks sent by the GTU. These marke the active optical links | |
1299 | // between GTU and Super Module. Up to now only fully active links are found | |
1300 | // (0xfff = 12 active links). | |
1301 | // | |
1302 | ||
1303 | if ( (*fDataWord & 0xfffff000) == 0xe0000000 ) | |
1304 | { | |
1305 | if ( fRawVersion < 1 || fRawVersion > 3 ) | |
1306 | { | |
1307 | AliError(Form(" Unsupported raw version: %d", fRawVersion)); | |
1308 | } | |
1309 | ||
1310 | if ( fGTUctr1 == -1 ) fGTUctr2++; | |
1311 | fGTUctr1++; | |
1312 | ||
1313 | if ( (fGTUctr1 >= 0) && (fGTUctr1 < 5) && (fGTUctr2 >= 0) && (fGTUctr2 < 18) ) | |
1314 | { | |
1315 | fGTUlinkMask[fGTUctr2][fGTUctr1] = (*fDataWord & 0xfff); | |
1316 | } | |
1317 | ||
1318 | //AliDebug(5, Form("GTU link mask 0x%x decoded 0x%x", *fDataWord, fGTUlinkMask[fGTUctr2][fGTUctr1])); | |
1319 | return kTRUE; | |
1320 | } | |
1321 | ||
1322 | return kFALSE; | |
1323 | } | |
1324 | ||
1325 | // //____________________________________________________________________________ | |
1326 | void AliTRDRawStreamTB::ChangeStatus(Int_t kstat) | |
1327 | { | |
1328 | fLastStatus = fNextStatus; | |
1329 | fNextStatus = kstat; | |
1330 | } | |
1331 | ||
1332 | //____________________________________________________________________________ | |
1333 | Bool_t AliTRDRawStreamTB::DecodeSM() | |
1334 | { | |
1335 | fLastDET = -1; | |
1336 | fDET = -1; | |
1337 | fRetVal = 0; | |
1338 | fEqID = 0; | |
1339 | fDataSize = 0; | |
1340 | fSizeOK = kFALSE; | |
1341 | ||
1342 | Int_t status = DecodeHeadingInfo(); | |
1343 | if (status == kWordOK) | |
1344 | { | |
1345 | ChangeStatus(kNextHC); | |
1346 | return kTRUE; | |
1347 | } | |
1348 | else | |
1349 | { | |
1350 | AliWarning(Form("Decoding SM info failed. Fall back: None. Stop.", fEqID)); | |
1351 | fRawReader->AddMajorErrorLog(kGTULinkMaskMissing,Form("Equipment %d",fEqID)); | |
1352 | ChangeStatus(kStop); | |
1353 | } | |
1354 | ||
1355 | return kFALSE; | |
1356 | } | |
1357 | ||
1358 | //____________________________________________________________________________ | |
1359 | Bool_t AliTRDRawStreamTB::Next() | |
1360 | { | |
1361 | // | |
1362 | // Updates the next data word pointer | |
1363 | // | |
1364 | ||
1365 | if (fNextStatus == kStart) | |
1366 | { | |
1367 | Init(); | |
1368 | } | |
1369 | ||
1370 | while (fNextStatus != kStop && fNextStatus != kNoMoreData) | |
1371 | { // !kStop | |
1372 | NextData(); | |
1373 | ||
1374 | switch (fNextStatus) | |
1375 | { | |
1376 | case kNextData: | |
1377 | { | |
1378 | if (DecodeNextRawWord() == kTRUE) | |
1379 | { | |
1380 | fTB += 3; | |
1381 | if (fTB - 3 > 29) | |
1382 | { | |
1383 | AliWarning(Form("Invalid time bin %d. sm %d det %d rob %d col %d row %d mcm=%d adc=%d ", fTB-3, fSM, fDET, fROB, fCOL, fROW, fMCM, fADC)); | |
1384 | AliWarning(Form("max=%d index=%d adc=%d", fADClookup[0], fADClookup[1], fADClookup[fADClookup[1]-1])); | |
1385 | } | |
1386 | if (fSig[0] > fRawDigitThreshold || fSig[1] > fRawDigitThreshold || fSig[2] > fRawDigitThreshold) | |
1387 | return kTRUE; | |
1388 | } | |
1389 | }; break; | |
1390 | case kNextMCM: | |
1391 | { | |
1392 | if (DecodeMCM() == kFALSE) | |
1393 | AliWarning(Form("Decode MCM unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos)); | |
1394 | }; break; | |
1395 | case kNextHC: | |
1396 | case kSeekNonEoTracklet: | |
1397 | case kDecodeHC: | |
1398 | { | |
1399 | if (DecodeHC() == kFALSE) | |
1400 | { | |
1401 | if (*fDataWord == kEndOfRawDataMarker) | |
1402 | { | |
1403 | AliDebug(2, Form("End of data at 0x%x", fPos)); | |
1404 | } | |
1405 | else | |
1406 | { | |
1407 | AliWarning(Form("Decode HC unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos)); | |
1408 | } | |
1409 | } | |
1410 | }; break; | |
1411 | case kNextSM: | |
1412 | { | |
1413 | if (DecodeSM() == kFALSE) | |
1414 | AliWarning(Form("Decode SM unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos)); | |
1415 | }; break; | |
1416 | case kNoMoreData: | |
1417 | case kStop: | |
1418 | ; break; | |
1419 | default: | |
1420 | AliWarning(Form("Unknown state %d. Last state %d. Current Word 0x%x at pos 0x%x", fNextStatus, fLastStatus, *fDataWord, fPos)); | |
1421 | ChangeStatus(kStop); | |
1422 | }; | |
1423 | ||
1424 | } // not kStop | |
1425 | ||
1426 | //AliDebug(1, Form("That's all folks! %d", fSM)); | |
1427 | return kFALSE; | |
1428 | } | |
1429 | ||
1430 | //____________________________________________________________________________ | |
1431 | Int_t AliTRDRawStreamTB::NextChamber(AliTRDdigitsManager *digitsManager) | |
1432 | { | |
1433 | // | |
1434 | // Fills single chamber digit array | |
1435 | // Return value is the detector number | |
1436 | // | |
1437 | ||
1438 | AliTRDdataArrayI *digits = 0; | |
1439 | AliTRDdataArrayI *track0 = 0; | |
1440 | AliTRDdataArrayI *track1 = 0; | |
1441 | AliTRDdataArrayI *track2 = 0; | |
1442 | AliTRDSignalIndex *indexes = 0; | |
1443 | ||
1444 | // Loop through the digits | |
1445 | Int_t lastdet = -1; | |
1446 | Int_t det = -1; | |
1447 | // Int_t returnDet = -1; | |
1448 | Int_t it = 0; | |
1449 | while (Next()) | |
1450 | { | |
1451 | det = fDET; | |
1452 | ||
1453 | if (det != lastdet) | |
1454 | { | |
1455 | // If new detector found | |
1456 | if (lastdet == -1) | |
1457 | { | |
1458 | lastdet = det; | |
1459 | } | |
1460 | else | |
1461 | { | |
1462 | return lastdet; | |
1463 | } | |
1464 | ||
1465 | // Add a container for the digits of this detector | |
1466 | digits = digitsManager->GetDigits(det); | |
1467 | track0 = digitsManager->GetDictionary(det,0); | |
1468 | track1 = digitsManager->GetDictionary(det,1); | |
1469 | track2 = digitsManager->GetDictionary(det,2); | |
1470 | ||
1471 | // Allocate memory space for the digits buffer | |
1472 | if (digits->GetNtime() == 0) | |
1473 | { | |
1474 | digits->Allocate(fRowMax,fColMax, fTBins); | |
1475 | track0->Allocate(fRowMax,fColMax, fTBins); | |
1476 | track1->Allocate(fRowMax,fColMax, fTBins); | |
1477 | track2->Allocate(fRowMax,fColMax, fTBins); | |
1478 | } | |
1479 | ||
1480 | indexes = digitsManager->GetIndexes(det); | |
1481 | indexes->SetSM(GetSM()); | |
1482 | indexes->SetStack(GetStack()); | |
1483 | indexes->SetLayer(GetLayer()); | |
1484 | indexes->SetDetNumber(det); | |
1485 | if (indexes->IsAllocated() == kFALSE) | |
1486 | indexes->Allocate(fRowMax, fColMax, fTBins); | |
1487 | } | |
1488 | ||
1489 | // 3 timebin data are stored per word | |
1490 | for (it = 0; it < 3; it++) | |
1491 | { | |
1492 | // if ( GetTimeBin() + it < fTBins ) | |
1493 | // { | |
1494 | if (fSig[it] > 0) | |
1495 | { | |
1496 | digits->SetDataUnchecked(fROW, fCOL, fTB - 3 + it, fSig[it]); | |
1497 | ||
1498 | indexes->AddIndexTBin(fROW, fCOL, fTB - 3 + it); | |
1499 | track0->SetDataUnchecked(fROW, fCOL, fTB - 3 + it, 0); | |
1500 | track1->SetDataUnchecked(fROW, fCOL, fTB - 3 + it, 0); | |
1501 | track2->SetDataUnchecked(fROW, fCOL, fTB - 3 + it, 0); | |
1502 | } | |
1503 | // } | |
1504 | } // tbins | |
1505 | }// while Next() | |
1506 | ||
1507 | // what happens if the last HC is turned off? | |
1508 | return det; | |
1509 | //return -1; | |
1510 | } | |
1511 | ||
1512 | // new stuff | |
1513 | //____________________________________________________________________________ | |
1514 | Int_t AliTRDRawStreamTB::SkipWords(UInt_t iw) | |
1515 | { | |
1516 | Int_t status = kWordOK; | |
1517 | for (UInt_t i = 0; i < iw; i++) | |
1518 | { | |
1519 | status = NextData(); | |
1520 | AliDebug(5, Form("Skipping word %d of %d [0x%x]", i+1, iw, *fDataWord)); | |
1521 | if (status != kWordOK) | |
1522 | return status; | |
1523 | } | |
1524 | ||
1525 | //status = NextData(); | |
1526 | return status; | |
1527 | } | |
1528 | ||
1529 | //____________________________________________________________________________ | |
1530 | Int_t AliTRDRawStreamTB::DecodeHeadingInfo() | |
1531 | { | |
1532 | // SM info... | |
1533 | fSMinfo[fiSMx].Decode(fDataWord); | |
1534 | if (fgExtraDebug) | |
1535 | fSMinfo[fiSMx].Dump(); | |
1536 | ||
1537 | Int_t status = SkipWords(fSMinfo[fiSMx].fHeaderSize); | |
1538 | if (status != kWordOK) | |
1539 | return status; | |
1540 | else | |
1541 | status = NextData(); | |
1542 | ||
1543 | //fSMinfo[fiSMx].fStackActive[0] = kTRUE; | |
1544 | // now stack info.. | |
1545 | if (status == kWordOK) | |
1546 | { | |
1547 | for (Int_t i = 0; i < 5; i++) | |
1548 | { | |
1549 | if (fSMinfo[fiSMx].fStackActive[i] == kFALSE) | |
1550 | continue; | |
1551 | AliDebug(5, Form("Decode stack info %d 0x%x", i, *fDataWord)); | |
1552 | if (fgStackIndexBug == kFALSE) | |
1553 | fStackInfo[fiSMx][i].Decode(fDataWord); | |
1554 | else | |
1555 | fStackInfo[fiSMx][i].DecodeBug(fDataWord); | |
1556 | ||
1557 | if (fgExtraDebug) | |
1558 | fStackInfo[fiSMx][i].Dump(); | |
1559 | ||
1560 | status = SkipWords(fStackInfo[fiSMx][i].fHeaderSize); | |
1561 | if (status != kWordOK) | |
1562 | return status; | |
1563 | else | |
1564 | if (i < 4) | |
1565 | status = NextData(); | |
1566 | ||
1567 | if (status != kWordOK) | |
1568 | return status; | |
1569 | } | |
1570 | } | |
1571 | ||
1572 | RewindWord(); | |
1573 | return status; | |
1574 | } |