]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TRD/AliTRDRawStreamTB.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
BlockFilter component added; minor corrections
[u/mrichter/AliRoot.git] / TRD / AliTRDRawStreamTB.cxx
CommitLineData
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
44using namespace AliTRDrawDataUtilsTB;
45
46ClassImp(AliTRDRawStreamTB)
47
48Bool_t AliTRDRawStreamTB::fgStackIndexBug=kFALSE;
49Int_t AliTRDRawStreamTB::fgForceRawVersion = -1;
50Bool_t AliTRDRawStreamTB::fgSupressWarnings=kFALSE;
51Bool_t AliTRDRawStreamTB::fgRawDataHack=kFALSE;
52Bool_t AliTRDRawStreamTB::fgExtraDebug=kFALSE;
53
54//_____________________________________________________________________________
55AliTRDRawStreamTB::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//_____________________________________________________________________________
148AliTRDRawStreamTB::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//_____________________________________________________________________________
243AliTRDRawStreamTB::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//_____________________________________________________________________________
334AliTRDRawStreamTB& 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//_____________________________________________________________________________
347AliTRDRawStreamTB::~AliTRDRawStreamTB()
348{
349 //
350 // Destructor
351 //
352
353 if (fGeo)
354 {
355 delete fGeo;
356 }
357
358}
359
360//_____________________________________________________________________________
361void AliTRDRawStreamTB::SetRawReader(AliRawReader *rawReader)
362{
363 //
364 // Set the rawreader
365 //
366
367 if (rawReader)
368 {
369 fRawReader = rawReader;
370 }
371}
372
373//_____________________________________________________________________________
374Bool_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//____________________________________________________________________________
391Int_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//____________________________________________________________________________
461void 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//____________________________________________________________________________
489Int_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//____________________________________________________________________________
539Int_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//____________________________________________________________________________
568void 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//____________________________________________________________________________
750Int_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//____________________________________________________________________________
789void 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//____________________________________________________________________________
825void 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//____________________________________________________________________________
931Bool_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//____________________________________________________________________________
997Bool_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//____________________________________________________________________________
1118Bool_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//____________________________________________________________________________
1184Bool_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//____________________________________________________________________________
1295Bool_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// //____________________________________________________________________________
1326void AliTRDRawStreamTB::ChangeStatus(Int_t kstat)
1327{
1328 fLastStatus = fNextStatus;
1329 fNextStatus = kstat;
1330}
1331
1332//____________________________________________________________________________
1333Bool_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//____________________________________________________________________________
1359Bool_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//____________________________________________________________________________
1431Int_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//____________________________________________________________________________
1514Int_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//____________________________________________________________________________
1530Int_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}