]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TRD/AliTRDRawStream.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Split femto code into two libraries
[u/mrichter/AliRoot.git] / TRD / AliTRDRawStream.cxx
CommitLineData
b864d801 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///////////////////////////////////////////////////////////////////////////////
2745a409 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// //
7925de54 27// Author: C. Lippmann (C.Lippmann@gsi.de) //
28// //
b864d801 29///////////////////////////////////////////////////////////////////////////////
30
2745a409 31#include "AliLog.h"
b864d801 32#include "AliRawReader.h"
7925de54 33#include "AliTRDdigitsManager.h"
34#include "AliTRDdataArrayI.h"
2745a409 35
36#include "AliTRDRawStream.h"
7925de54 37#include "AliTRDgeometry.h"
38#include "AliTRDCommonParam.h"
3551db50 39#include "AliTRDcalibDB.h"
b864d801 40
41ClassImp(AliTRDRawStream)
42
2745a409 43//_____________________________________________________________________________
44AliTRDRawStream::AliTRDRawStream()
45 :TObject()
7925de54 46 ,fSig()
47 ,fADC(0)
48 ,fTB(0)
49 ,fEv(0)
50 ,fROB(0)
51 ,fMCM(0)
52 ,fSM(0)
53 ,fLAYER(0)
54 ,fSTACK(0)
55 ,fROC(0)
56 ,fSIDE(0)
57 ,fDCS(0)
58 ,fROW(0)
59 ,fCOL(0)
60 ,fBCctr(0)
61 ,fPTctr(0)
62 ,fPTphase(0)
63 ,fRVmajor(0)
64 ,fRVminor(0)
65 ,fHCHWords(0)
66 ,fTBins(0)
67 ,fTCon(0)
68 ,fPEDon(0)
69 ,fGAINon(0)
bd63bf88 70 ,fXTon(0)
71 ,fNonLinOn(0)
72 ,fBypass(0)
73 ,fCommonAdditive(0)
74 ,fZeroSuppressed(0)
7925de54 75 ,fHCHctr1(0)
76 ,fHCHctr2(0)
77 ,fMCMHctr1(0)
78 ,fMCMHctr2(0)
79 ,fGTUctr1(0)
80 ,fGTUctr2(0)
bd63bf88 81 ,fHCdataCtr(0)
82 ,fTracklPID(0.)
83 ,fTracklDefL(0.)
84 ,fTracklPadPos(0.)
7925de54 85 ,fTracklPadRow(0)
86 ,fGTUlinkMask()
87 ,fRawReader(NULL)
2745a409 88 ,fCount(0)
89 ,fDetector(-1)
90 ,fPrevDetector(-1)
91 ,fNPads(-1)
92 ,fRow(-1)
93 ,fPrevRow(-1)
94 ,fColumn(-1)
95 ,fPrevColumn(-1)
96 ,fTime(-1)
97 ,fSignal(-1)
bd63bf88 98 ,fRawVersion(2)
7925de54 99 ,fDataWord(0)
100 ,fStatus(0)
bd63bf88 101 ,fTbSwitch(0)
102 ,fTbSwitchCtr(0)
103 ,fTimeWords(0)
104 ,fWordCtr(0)
7925de54 105 ,fRowMax(0)
106 ,fColMax(0)
bd63bf88 107 ,fADCmask()
7925de54 108 ,fChamberDone()
109 ,fGeo(NULL)
110 ,fDigitsManager(NULL)
111 ,fDigits(NULL)
112 ,fTrack0(NULL)
113 ,fTrack1(NULL)
114 ,fTrack2(NULL)
2745a409 115{
116 //
117 // Default constructor
118 //
b864d801 119
7925de54 120 for (Int_t i = 0; i < 540; i++) {
121 fChamberDone[i] = 0;
122 }
123
124}
125
126//_____________________________________________________________________________
127AliTRDRawStream::AliTRDRawStream(AliRawReader *rawReader
128 , AliTRDdigitsManager *man
129 , AliTRDdataArrayI *dig)
130 :TObject()
131 ,fSig()
132 ,fADC(0)
133 ,fTB(0)
134 ,fEv(0)
135 ,fROB(0)
136 ,fMCM(0)
137 ,fSM(0)
138 ,fLAYER(0)
139 ,fSTACK(0)
140 ,fROC(0)
141 ,fSIDE(0)
142 ,fDCS(0)
143 ,fROW(0)
144 ,fCOL(0)
145 ,fBCctr(0)
146 ,fPTctr(0)
147 ,fPTphase(0)
148 ,fRVmajor(0)
149 ,fRVminor(0)
150 ,fHCHWords(0)
151 ,fTBins(0)
152 ,fTCon(0)
153 ,fPEDon(0)
154 ,fGAINon(0)
bd63bf88 155 ,fXTon(0)
156 ,fNonLinOn(0)
157 ,fBypass(0)
158 ,fCommonAdditive(0)
159 ,fZeroSuppressed(0)
7925de54 160 ,fHCHctr1(0)
161 ,fHCHctr2(0)
162 ,fMCMHctr1(0)
163 ,fMCMHctr2(0)
164 ,fGTUctr1(0)
165 ,fGTUctr2(0)
bd63bf88 166 ,fHCdataCtr(0)
167 ,fTracklPID(0.)
168 ,fTracklDefL(0.)
169 ,fTracklPadPos(0.)
7925de54 170 ,fTracklPadRow(0)
171 ,fGTUlinkMask()
172 ,fRawReader(rawReader)
173 ,fCount(0)
174 ,fDetector(-1)
175 ,fPrevDetector(-1)
176 ,fNPads(-1)
177 ,fRow(-1)
178 ,fPrevRow(-1)
179 ,fColumn(-1)
180 ,fPrevColumn(-1)
181 ,fTime(-1)
182 ,fSignal(-1)
bd63bf88 183 ,fRawVersion(2)
7925de54 184 ,fDataWord(0)
185 ,fStatus(0)
bd63bf88 186 ,fTbSwitch(0)
187 ,fTbSwitchCtr(0)
188 ,fTimeWords(0)
189 ,fWordCtr(0)
7925de54 190 ,fRowMax(0)
191 ,fColMax(0)
bd63bf88 192 ,fADCmask()
7925de54 193 ,fChamberDone()
194 ,fGeo(NULL)
195 ,fDigitsManager(man)
196 ,fDigits(dig)
197 ,fTrack0(NULL)
198 ,fTrack1(NULL)
199 ,fTrack2(NULL)
200
201{
202 //
203 // Create an object to read TRD raw digits
204 //
205
206 fGeo = new AliTRDgeometry();
207
208 fRawReader->Select("TRD");
209
210 for (Int_t i = 0; i < 540; i++) {
211 fChamberDone[i] = 0;
212 }
213
2745a409 214}
215
216//_____________________________________________________________________________
7925de54 217AliTRDRawStream::AliTRDRawStream(AliRawReader *rawReader)
2745a409 218 :TObject()
7925de54 219 ,fSig()
220 ,fADC(0)
221 ,fTB(0)
222 ,fEv(0)
223 ,fROB(0)
224 ,fMCM(0)
225 ,fSM(0)
226 ,fLAYER(0)
227 ,fSTACK(0)
228 ,fROC(0)
229 ,fSIDE(0)
230 ,fDCS(0)
231 ,fROW(0)
232 ,fCOL(0)
233 ,fBCctr(0)
234 ,fPTctr(0)
235 ,fPTphase(0)
236 ,fRVmajor(0)
237 ,fRVminor(0)
238 ,fHCHWords(0)
239 ,fTBins(0)
240 ,fTCon(0)
241 ,fPEDon(0)
242 ,fGAINon(0)
bd63bf88 243 ,fXTon(0)
244 ,fNonLinOn(0)
245 ,fBypass(0)
246 ,fCommonAdditive(0)
247 ,fZeroSuppressed(0)
7925de54 248 ,fHCHctr1(0)
249 ,fHCHctr2(0)
250 ,fMCMHctr1(0)
251 ,fMCMHctr2(0)
252 ,fGTUctr1(0)
253 ,fGTUctr2(0)
bd63bf88 254 ,fHCdataCtr(0)
255 ,fTracklPID(0.)
256 ,fTracklDefL(0.)
257 ,fTracklPadPos(0.)
7925de54 258 ,fTracklPadRow(0)
259 ,fGTUlinkMask()
2745a409 260 ,fRawReader(rawReader)
261 ,fCount(0)
262 ,fDetector(-1)
263 ,fPrevDetector(-1)
264 ,fNPads(-1)
265 ,fRow(-1)
266 ,fPrevRow(-1)
267 ,fColumn(-1)
268 ,fPrevColumn(-1)
269 ,fTime(-1)
270 ,fSignal(-1)
bd63bf88 271 ,fRawVersion(2)
7925de54 272 ,fDataWord(0)
273 ,fStatus(0)
bd63bf88 274 ,fTbSwitch(0)
275 ,fTbSwitchCtr(0)
276 ,fTimeWords(0)
277 ,fWordCtr(0)
7925de54 278 ,fRowMax(0)
279 ,fColMax(0)
bd63bf88 280 ,fADCmask()
7925de54 281 ,fChamberDone()
282 ,fGeo(NULL)
283 ,fDigitsManager(NULL)
284 ,fDigits(NULL)
285 ,fTrack0(NULL)
286 ,fTrack1(NULL)
287 ,fTrack2(NULL)
288
b864d801 289{
2745a409 290 //
291 // Create an object to read TRD raw digits
292 //
b864d801 293
362c9d61 294 fRawReader->Select("TRD");
2745a409 295
7925de54 296 for (Int_t i = 0; i < 540; i++) {
297 fChamberDone[i] = 0;
298 }
299
b864d801 300}
301
2745a409 302//_____________________________________________________________________________
7925de54 303AliTRDRawStream::AliTRDRawStream(const AliTRDRawStream& stream)
304 :TObject(stream)
305 ,fSig()
bd63bf88 306 ,fADC(-1)
307 ,fTB(-1)
308 ,fEv(-1)
309 ,fROB(-1)
310 ,fMCM(-1)
311 ,fSM(-1)
312 ,fLAYER(-1)
313 ,fSTACK(-1)
314 ,fROC(-1)
315 ,fSIDE(-1)
316 ,fDCS(-1)
317 ,fROW(-1)
318 ,fCOL(-1)
319 ,fBCctr(-1)
320 ,fPTctr(-1)
321 ,fPTphase(-1)
322 ,fRVmajor(-1)
323 ,fRVminor(-1)
324 ,fHCHWords(-1)
325 ,fTBins(-1)
7925de54 326 ,fTCon(0)
327 ,fPEDon(0)
328 ,fGAINon(0)
bd63bf88 329 ,fXTon(0)
330 ,fNonLinOn(-1)
331 ,fBypass(-1)
332 ,fCommonAdditive(-1)
333 ,fZeroSuppressed(0)
334 ,fHCHctr1(-1)
335 ,fHCHctr2(-1)
336 ,fMCMHctr1(-1)
337 ,fMCMHctr2(-1)
338 ,fGTUctr1(-1)
339 ,fGTUctr2(-1)
340 ,fHCdataCtr(-1)
341 ,fTracklPID(-1.)
342 ,fTracklDefL(-1.)
343 ,fTracklPadPos(-1.)
344 ,fTracklPadRow(-1)
7925de54 345 ,fGTUlinkMask()
346 ,fRawReader(NULL)
bd63bf88 347 ,fCount(-1)
7925de54 348 ,fDetector(-1)
349 ,fPrevDetector(-1)
350 ,fNPads(-1)
351 ,fRow(-1)
352 ,fPrevRow(-1)
353 ,fColumn(-1)
354 ,fPrevColumn(-1)
355 ,fTime(-1)
356 ,fSignal(-1)
bd63bf88 357 ,fRawVersion(-1)
7925de54 358 ,fDataWord(0)
bd63bf88 359 ,fStatus(-1)
360 ,fTbSwitch(0)
361 ,fTbSwitchCtr(0)
362 ,fTimeWords(0)
363 ,fWordCtr(0)
364 ,fRowMax(-1)
365 ,fColMax(-1)
366 ,fADCmask()
7925de54 367 ,fChamberDone()
368 ,fGeo(NULL)
369 ,fDigitsManager(NULL)
370 ,fDigits(NULL)
371 ,fTrack0(NULL)
372 ,fTrack1(NULL)
373 ,fTrack2(NULL)
374
b864d801 375{
2745a409 376 //
377 // Copy constructor
378 //
379
380 AliFatal("Copy constructor not implemented");
381
b864d801 382}
383
2745a409 384//_____________________________________________________________________________
b864d801 385AliTRDRawStream& AliTRDRawStream::operator = (const AliTRDRawStream&
386 /* stream */)
387{
2745a409 388 //
389 // Assigment operator
390 //
391
b864d801 392 Fatal("operator =", "assignment operator not implemented");
393 return *this;
2745a409 394
b864d801 395}
396
2745a409 397//_____________________________________________________________________________
b864d801 398AliTRDRawStream::~AliTRDRawStream()
399{
2745a409 400 //
401 // Destructor
402 //
b864d801 403
7925de54 404}
405
406//_____________________________________________________________________________
407Bool_t AliTRDRawStream::SetRawVersion(Int_t rv)
408{
409 //
410 // Set the raw data version
411 //
412
bd63bf88 413 if ( rv >= 0 && rv <= 3 ) {
7925de54 414 fRawVersion = rv;
415 return kTRUE;
416 }
417
418 return kFALSE;
419
b864d801 420}
421
2745a409 422//_____________________________________________________________________________
b864d801 423Bool_t AliTRDRawStream::Next()
424{
2745a409 425 //
7925de54 426 // This is Bogdans code for reading raw data (offline use only).
427 // It is used for fRawVersion == 0. This funcyion read the next raw digit.
2745a409 428 // Returns kFALSE if there is no digit left
429 //
b864d801 430
431 fPrevDetector = fDetector;
2745a409 432 fPrevRow = fRow;
433 fPrevColumn = fColumn;
b864d801 434 UChar_t data;
435
7925de54 436 AliTRDcalibDB *calibration = AliTRDcalibDB::Instance();
437 if (!calibration) return kFALSE;
3551db50 438
439 Int_t timeBins = calibration->GetNumberOfTimeBins();
440
b864d801 441 while (fCount >= 0) {
442
443 while (fCount == 0) { // next detector
7925de54 444
b864d801 445 // read the flag
7925de54 446 if (!fRawReader->ReadNextChar(data)) {
447 return kFALSE;
448 }
b864d801 449 if (data != 0xBB) {
2745a409 450 AliError(Form("wrong flag: %x", data));
b864d801 451 fCount = -1;
452 return kFALSE;
453 }
454
455 // read the detector number
456 if (!fRawReader->ReadNextChar(data)) {
2745a409 457 AliError("Could not read detector number");
b864d801 458 fCount = -1;
459 return kFALSE;
460 }
461 fDetector = data;
462 if (!fRawReader->ReadNextChar(data)) {
2745a409 463 AliError("Could not read detector number");
b864d801 464 fCount = -1;
465 return kFALSE;
466 }
467 fDetector += (UInt_t(data) << 8);
468
469 // read the number of byts
470 if (!fRawReader->ReadNextChar(data)) {
2745a409 471 AliError("Could not read number of bytes");
b864d801 472 fCount = -1;
473 return kFALSE;
474 }
475 fCount = data;
476 if (!fRawReader->ReadNextChar(data)) {
2745a409 477 AliError("Could not read number of bytes");
b864d801 478 fCount = -1;
479 return kFALSE;
480 }
481 fCount += (UInt_t(data) << 8);
928e9fae 482 if (!fRawReader->ReadNextChar(data)) {
2745a409 483 AliError("Could not read number of bytes");
928e9fae 484 fCount = -1;
485 return kFALSE;
486 }
487 fCount += (UInt_t(data) << 16);
b864d801 488
489 // read the number of active pads
490 if (!fRawReader->ReadNextChar(data)) {
2745a409 491 AliError("Could not read number of active pads");
b864d801 492 fCount = -1;
493 return kFALSE;
494 }
495 fNPads = data;
496 if (!fRawReader->ReadNextChar(data)) {
2745a409 497 AliError("Could not read number of active pads");
b864d801 498 fCount = -1;
499 return kFALSE;
500 }
501 fNPads += (UInt_t(data) << 8);
502
3551db50 503 fTime = timeBins;
b864d801 504
b864d801 505 }
506
507 // read the pad row and column number
3551db50 508 if ((fTime >= timeBins) && (fCount > 2)) {
b864d801 509 if (!fRawReader->ReadNextChar(data)) {
2745a409 510 AliError("Could not read row number");
b864d801 511 fCount = -1;
512 return kFALSE;
513 }
514 fCount--;
515 fRow = data - 1;
516 if (!fRawReader->ReadNextChar(data)) {
2745a409 517 AliError("Could not read column number");
b864d801 518 fCount = -1;
519 return kFALSE;
520 }
521 fCount--;
522 fColumn = data - 1;
523 fTime = 0;
524 }
525
526 // read the next data byte
527 if (!fRawReader->ReadNextChar(data)) {
2745a409 528 AliError("Could not read data");
b864d801 529 fCount = -1;
530 return kFALSE;
531 }
532 fCount--;
533
534 if (data == 0) { // zeros
535 if (!fRawReader->ReadNextChar(data)) {
2745a409 536 AliError("Could not read time value");
b864d801 537 fCount = -1;
538 return kFALSE;
539 }
540 fCount--;
541 fTime += data + 1;
542
2745a409 543 }
544 else { // signal
b864d801 545 fSignal = (UInt_t(data & 0x7F) << 8);
546 if (!fRawReader->ReadNextChar(data)) {
2745a409 547 AliError("Could not read ADC value");
b864d801 548 fCount = -1;
549 return kFALSE;
550 }
551 fCount--;
552 fSignal += data;
553 fTime++;
554 return kTRUE;
555 }
556 }
557
558 return kFALSE;
2745a409 559
b864d801 560}
7925de54 561
562//____________________________________________________________________________
bd63bf88 563Int_t AliTRDRawStream::ReadAll()
7925de54 564{
565
566 //
41235089 567 // Read all TRD raw data word (32 bits). This is for all fRawVersion > 0.
bd63bf88 568 // Return 0 if something is not cool, 2 if data seems empty
7925de54 569 //
570 // by C. Lippmann
571 //
572
573 AliTRDCommonParam *commonParam = AliTRDCommonParam::Instance();
574 if (!commonParam) {
575 AliError("Could not get common parameters");
bd63bf88 576 return 0;
7925de54 577 }
578
579 AliTRDcalibDB *calibration = AliTRDcalibDB::Instance();
580 if (!calibration) {
581 AliError("Could not get calibration object");
bd63bf88 582 return 0;
7925de54 583 }
584
585 UInt_t timeTotal = calibration->GetNumberOfTimeBins();
bd63bf88 586 AliDebug(2, Form("Number of Timebins read from CDB: %d", timeTotal));
7925de54 587
588 // The number of data words needed for this number of time bins (there
589 // are 3 time bins in one word)
bd63bf88 590 fTimeWords = (timeTotal-1)/3 + 1;
7925de54 591
bd63bf88 592 fTbSwitch = 3;
593 fTbSwitchCtr = 0;
594
595 Int_t EqID = 0;
596 UInt_t datasize = 0;
597 Int_t iDET = 0;
598
599 Int_t retval = 0;
7925de54 600
bd63bf88 601 Bool_t sizeOK = kFALSE;
7925de54 602
603 fHCHctr1 = fHCHctr2 = 0;
604 fGTUctr1 = fGTUctr2 = -1;
605
bd63bf88 606 fHCdataCtr = 0;
607 fWordCtr = 0;
608
7925de54 609 AliInfo("Converting TRD raw data to digits ...");
610
611 while ( 1 ) { // loop over all supermodules
612
bd63bf88 613 fWordCtr = 0;
7925de54 614 fHCHctr1 = 0;
615 fMCMHctr1 = 0;
616
617 //
618 // 0) Find first GTU Link Mask and test if we can read data
619 //
620 do {
621
41235089 622 if ( !fRawReader->ReadNextInt( fDataWord ) ) { // This is the standard exit point
623 // Compress also the digits from the last detector
624 if ( fChamberDone[iDET] == 2 ) {
625 //printf("Compressing data for det %d\n", iDET);
626 fDigits->Compress(1,0);
627 fTrack0->Compress(1,0);
628 fTrack1->Compress(1,0);
629 fTrack2->Compress(1,0);
630 }
7925de54 631 AliInfo(Form("Finished processing TRD raw data: Found %d Half-Chambers", fHCHctr2));
41235089 632 //
633 /*
634 fDigits = fDigitsManager->GetDigits(iDET+1);
635 fTrack0 = fDigitsManager->GetDictionary(iDET+1,0);
636 fTrack1 = fDigitsManager->GetDictionary(iDET+1,1);
637 fTrack2 = fDigitsManager->GetDictionary(iDET+1,2);
638 fDigits->Allocate(fRowMax,fColMax,timeTotal);
639 fTrack0->Allocate(fRowMax,fColMax,timeTotal);
640 fTrack1->Allocate(fRowMax,fColMax,timeTotal);
641 fTrack2->Allocate(fRowMax,fColMax,timeTotal);
642 fDigits->SetDataUnchecked(0, 0, 0, 50);
643 fTrack0->SetDataUnchecked(0, 0, 0, 0);
bd63bf88 644 fTrack1->Set
41235089 645 fTrack2->SetDataUnchecked(0, 0, 0, 0);
646 fDigits->Compress(1,0);
647 fTrack0->Compress(1,0);
648 fTrack1->Compress(1,0);
649 fTrack2->Compress(1,0);
650 */
651 //
bd63bf88 652 if ( sizeOK ) return 1;
653 else return 2;
7925de54 654 }
bd63bf88 655
656 fWordCtr++;
7925de54 657
658 // After reading the first word check for size of this data and get Eq. ID
bd63bf88 659 if ( fWordCtr == 1 ) {
660 datasize = fRawReader->GetDataSize()/4; // Size of this payload in 32bit words
7925de54 661 EqID = fRawReader->GetEquipmentId(); // Get Equipment ID
bd63bf88 662 //if ( sizeOK = kFALSE && datasize > 0 ) { sizeOK = kTRUE; printf("Yo\n"); }
663 if ( datasize > 0 ) sizeOK = kTRUE;
7925de54 664 }
665
666 // GTU Link Mask?
667 if ( (fDataWord & 0xfffff000) == 0xe0000000 ) {
668 fStatus = 1; // GTU link mask found
669 DecodeGTUlinkMask();
670 break;
671 }
672 else {
673 AliError(Form("Equipment %d: First data word is not GTU Link Mask!", EqID));
bd63bf88 674 return 0;
7925de54 675 }
676
677 }
bd63bf88 678 while ( fWordCtr < datasize );
7925de54 679
680 //
681 // loop over all half chambers in one supermodule
682 //
bd63bf88 683 while ( fWordCtr < datasize ) {
7925de54 684
685 //
686 // 1) Find end_of_tracklet_marker
687 //
bd63bf88 688 while ( fWordCtr < datasize ) {
7925de54 689
690 if ( !fRawReader->ReadNextInt( fDataWord ) ) {
691 AliError("Could not read data");
bd63bf88 692 return 0;
7925de54 693 }
bd63bf88 694 fWordCtr++;
7925de54 695
696 // GTU Link Mask?
697 if ( (fDataWord & 0xfffff000) == 0xe0000000 ) {
698 DecodeGTUlinkMask();
699 continue;
700 }
701
41235089 702 // endoftrackletmarker?
bd63bf88 703 if ( fDataWord == kEndoftrackletmarker ) {
41235089 704 AliDebug(3, "end-of-tracklet-marker found");
7925de54 705 fStatus = 1;
706 break;
707 }
708 else {
709 // Tracklets found
710 AliDebug(3, "Tracklet found");
711 DecodeTracklet();
712 }
713
714 }
715
716 if ( fStatus == 0 ) break;
717
718 //
719 // 2) Look for non-end_of_tracklet_marker
720 //
721 fStatus = 0;
bd63bf88 722 while ( fWordCtr < datasize ) {
7925de54 723
724 if ( !fRawReader->ReadNextInt( fDataWord ) ) {
725 AliError("Could not read data");
bd63bf88 726 return 0;
7925de54 727 }
bd63bf88 728 fWordCtr++;
729 //printf("Word %d: 0x%08x\n", fWordCtr, fDataWord);
7925de54 730
bd63bf88 731 if ( fDataWord != kEndoftrackletmarker ) {
7925de54 732 fStatus = 1;
733 break;
734 }
735
736 }
737
738 if ( fStatus == 0 ) break;
739
740 //
741 // 3) This Word must be Half Chamber Header
742 //
743 fStatus = 0;
744 if ( (fDataWord & 0x00000003) == 1 ) { // HC header
745
746 // If both half chambers of chamber corresponding to previous header
747 // were already processed, we can compress these digits
bd63bf88 748 iDET = fGeo->GetDetector(fLAYER, fSTACK, fSM); // !!this is still the previous HC!!
7925de54 749 if ( fChamberDone[iDET] == 2 ) {
41235089 750 //printf("Compressing data for det %d\n", iDET);
7925de54 751 fDigits->Compress(1,0);
752 fTrack0->Compress(1,0);
753 fTrack1->Compress(1,0);
754 fTrack2->Compress(1,0);
755 }
7925de54 756 // Read from new HC header the chamber position (fLAYER, fSTACK, fSM)
41235089 757 DecodeHCheader(timeTotal); // This is the new header!
7925de54 758 iDET = fGeo->GetDetector(fLAYER, fSTACK, fSM);
759 fRowMax = commonParam->GetRowMax(fLAYER,fSTACK,fSM);
760 fColMax = commonParam->GetColMax(fROC);
761
41235089 762 // The container for the digits of this detector
7925de54 763 fDigits = fDigitsManager->GetDigits(iDET);
764 fTrack0 = fDigitsManager->GetDictionary(iDET,0);
765 fTrack1 = fDigitsManager->GetDictionary(iDET,1);
766 fTrack2 = fDigitsManager->GetDictionary(iDET,2);
767
7925de54 768 // Allocate memory if it was not already done
769 if (fDigits->GetNtime() == 0) {
41235089 770 //printf("Allocating digits memory for det %d\n", iDET);
bd63bf88 771 fDigits->Allocate(fRowMax, fColMax, fTBins);
772 fTrack0->Allocate(fRowMax, fColMax, fTBins);
773 fTrack1->Allocate(fRowMax, fColMax, fTBins);
774 fTrack2->Allocate(fRowMax, fColMax, fTBins);
775 }
776 if ( fZeroSuppressed ) { // Make sure digits in this HC are 0
777 for ( Int_t colctr = fSIDE*fColMax/2; colctr < fColMax*(1+fSIDE)/2; colctr++ ) {
778 for ( Int_t rowctr = 0; rowctr < fRowMax; rowctr++ ) {
779 for ( Int_t timectr = 0; timectr < fTBins; timectr++ ) {
780 fDigits->SetDataUnchecked(rowctr, colctr, timectr, 0);
781 fTrack0->SetDataUnchecked(rowctr, colctr, timectr, 0);
782 fTrack1->SetDataUnchecked(rowctr, colctr, timectr, 0);
783 fTrack2->SetDataUnchecked(rowctr, colctr, timectr, 0);
784 }
785 }
786 }
7925de54 787 }
7925de54 788 fMCMHctr2 = 0;
bd63bf88 789 fHCdataCtr = 0;
7925de54 790
8c56d8cc 791 fChamberDone[iDET]++;
41235089 792
7925de54 793 }
794
795 //
796 // 4) Scan MCM data
797 //
798 fStatus = 0;
bd63bf88 799 while ( fWordCtr < datasize ) {
7925de54 800
801 if ( !fRawReader->ReadNextInt( fDataWord ) ) {
802 AliError("Could not read data");
bd63bf88 803 return 0;
7925de54 804 }
bd63bf88 805 fWordCtr++;
806 //printf("Word %d: 0x%08x\n", fWordCtr, fDataWord);
7925de54 807
bd63bf88 808 fHCdataCtr += 4;
809
810 //if( (fDataWord & 0x0000000f) == 0xC ) { // MCM Header
811 if( ((fDataWord & 0x80000000) == 0x0) && ((fDataWord & 0x0000000f) == 0xC) ) { // MCM Header
7925de54 812 DecodeMCMheader();
813 if ( fMCM < 0 || fMCM > 15 || fROB < 0 || fROB > 7 ) {
814 AliError("Wrong fMCM or fROB. Skip this data");
815 break;
816 }
bd63bf88 817 fTbSwitch = 3; // For first adc channel we expect: (fDataWord & 3) = 3
818 fTbSwitchCtr = 0; //
819 fADC = fTB = 0; // Reset Counter
820 fStatus = 1; // Now 1 means MCM header is found
7925de54 821 continue;
822 }
823
bd63bf88 824 if ( fDataWord == kEndofrawdatamarker ) { // End of half-chamber data, finished
7925de54 825 fGTUctr1 = -1;
826 break;
827 }
828
829 if ( fStatus == 1 ) { // MCM header is set, ADC data is valid.
830
7925de54 831 // Found some data. Decode it now:
bd63bf88 832 retval = DecodeDataWord();
833 if ( retval == 0 ) continue;
834 if ( retval == -1 ) break;
835
7925de54 836 if ( fADC > 1 && fADC < (Int_t)fGeo->ADCmax()-1 ) {
837
7925de54 838 // Write Digits
839 if ( fCOL >= 0 && fCOL < fColMax && fROW >= 0 && fROW < fRowMax ) { // A real pad
41235089 840 for ( Int_t ctr = 0; ctr < 3; ctr++ ) {
7925de54 841 if ( fTB+ctr < (Int_t)timeTotal ) {
41235089 842 /*
7925de54 843 fDigits->SetDataUnchecked(fROW, fCOL, fTB+ctr, fSig[ctr]);
844 fTrack0->SetDataUnchecked(fROW, fCOL, fTB+ctr, 0);
845 fTrack1->SetDataUnchecked(fROW, fCOL, fTB+ctr, 0);
846 fTrack2->SetDataUnchecked(fROW, fCOL, fTB+ctr, 0);
41235089 847 */
bd63bf88 848
849 //
850 // Pedestal subtraction done here (???):
851 //
852 //fDigits->SetData(fROW, fCOL, fTB+ctr, fSig[ctr] - fCommonAdditive);
41235089 853 fDigits->SetData(fROW, fCOL, fTB+ctr, fSig[ctr]);
9f5053b6 854 // The MC labels have been already flushed, no need
855 // in the following three lines
856 // fTrack0->SetData(fROW, fCOL, fTB+ctr, 0);
857 // fTrack1->SetData(fROW, fCOL, fTB+ctr, 0);
858 // fTrack2->SetData(fROW, fCOL, fTB+ctr, 0);
859 //
7925de54 860 }
861 }
862 }
863
864 fTB += 3;
865
bd63bf88 866 }
7925de54 867 else {
868
869 fCOL = -1;
870
871 }
872
873 }
bd63bf88 874
7925de54 875 }
876
bd63bf88 877 AliDebug(2, Form("SM%02d L%dS%d side %x: Processed %dMCMs=%dbyte", fSM, fLAYER, fSTACK, fSIDE+10,
878 fMCMHctr2, fHCdataCtr));
7925de54 879
880 } // End Half-Chamber loop
881
bd63bf88 882 AliDebug(1, Form("SM%02d (Eq %d): Processed %d HC (%dMCMs=%dbyte)", fSM, EqID, fHCHctr1, fMCMHctr1,
883 datasize*4));
884
7925de54 885 } // End Super Module loop
886
41235089 887 // Compress also the digits from the last detector
888 if ( fChamberDone[iDET] == 2 ) {
889 //printf("Compressing data for det %d\n", iDET);
890 fDigits->Compress(1,0);
891 fTrack0->Compress(1,0);
892 fTrack1->Compress(1,0);
893 fTrack2->Compress(1,0);
894 }
895
bd63bf88 896 if ( sizeOK ) return 1;
897 else return 2;
7925de54 898
899}
900
901//============================================================================
902// Decoding functions
903//============================================================================
904
905//____________________________________________________________________________
906void AliTRDRawStream::DecodeHCheader(Int_t timeBins)
907{
908 //
909 // Decode a half chamber header
910 //
911
bd63bf88 912 if ( (fDataWord >> 31) == 0 ) { // Can only happen for fRawVersion == 1
913
914 if ( fRawVersion != 1 ) {
915
916 AliWarning("===============================================================================");
917 AliWarning(Form("Mismatch between fRawVersion (%d) and HC header signature", fRawVersion));
918 AliWarning("Setting fRawVersion to 1");
919 AliWarning("===============================================================================");
920 fRawVersion = 1;
7925de54 921
7925de54 922 }
bd63bf88 923
924 DecodeHCheaderV1();
7925de54 925 return;
926
927 }
928 else {
929
930 fRVmajor = (fDataWord >> 24) & 0x7f;
931 fRVminor = (fDataWord >> 17) & 0x7f;
bd63bf88 932
7925de54 933 if ( fRawVersion != fRVmajor ) {
bd63bf88 934
935 AliWarning("===============================================================================");
936 AliWarning(Form("Mismatch between fRawVersion (%d) and fRVmajor from HC header (%d)"
937 ,fRawVersion,fRVmajor));
938 AliWarning(Form("Setting fRawVersion to %d", fRVmajor));
939 AliWarning("===============================================================================");
940 fRawVersion = fRVmajor;
941
7925de54 942 }
bd63bf88 943 if ( fRawVersion >= 2 && fRawVersion <= 3 ) {
944 DecodeHCheaderV2V3(timeBins);
7925de54 945 }
bd63bf88 946
947 //
948 // check for zero suppression
949 if ( fRawVersion >= 3 || fRawVersion <= 4 ) fZeroSuppressed = kTRUE;
950 else fZeroSuppressed = kFALSE;
951
7925de54 952 return;
953
954 }
955
956 AliError(Form(" Unsupported raw version: %d", fRawVersion));
957 return;
958
959}
960
961//____________________________________________________________________________
962void AliTRDRawStream::DecodeHCheaderV1()
963{
964
965 //
966 // Decode the HC header (fRawVersion == 1, SM I Commissioning 06)
967 //
968
969 if ( (fDataWord & 0x3) == 1 ) {
970
971 fDCS = (fDataWord >> 20);
972 fSM = (fDataWord >> 15) & 0x1f;
973 fLAYER = (fDataWord >> 12) & 0x7;
974 fSTACK = (fDataWord >> 9) & 0x7;
975 fSIDE = (fDataWord >> 8) & 0x1;
976
977 fROC = fGeo->GetDetectorSec(fLAYER, fSTACK);
978
979 //AliDebug(3, Form("0x%08x: HC header: dcs=%d; sm=%d; roc=%d; side=%x", fDataWord, fDCS, fSM, fROC, fSIDE+10));
bd63bf88 980
7925de54 981 if ((fSM < 0) ||
982 (fSM > 17) ||
983 (fLAYER < 0) ||
984 (fLAYER > 5) ||
985 (fSTACK < 0) ||
986 (fSTACK > 4) ||
987 (fSIDE < 0) ||
988 (fSIDE > 1)) {
bd63bf88 989 AliWarning(Form("0x%08x: Strange HC header: dcs=%d; sm=%d; layer=%d; stack=%d.",
990 fDataWord, fDCS, fSM, fLAYER, fSTACK));
7925de54 991 }
992 else {
993 fStatus = 1;
994 fHCHctr1++;
995 fHCHctr2++;
996 }
997 fHCHWords = 0;
998
999 }
1000 else {
1001
1002 AliError(Form("0x%08x: No HC header when it was expected.", fDataWord));
1003
1004 }
1005
1006}
1007
1008
1009//____________________________________________________________________________
bd63bf88 1010void AliTRDRawStream::DecodeHCheaderV2V3(Int_t timeBins)
7925de54 1011{
1012 //
bd63bf88 1013 // Decode the HC header (fRawVersion == 2, 3, 4, ???)
7925de54 1014 //
1015
bd63bf88 1016 // 1st word (h[0])
7925de54 1017 if ( (fDataWord & 0x3) == 1 ) {
1018
1019 fHCHWords = (fDataWord >> 14) & 0x7;
1020 fSM = (fDataWord >> 9) & 0x1f;
1021 fLAYER = (fDataWord >> 6) & 0x7;
1022 fSTACK = (fDataWord >> 3) & 0x7;
1023 fSIDE = (fDataWord >> 2) & 0x1;
1024
1025 fROC = fGeo->GetDetectorSec(fLAYER, fSTACK);
1026
1027 AliDebug(3, Form("0x%08x: HC header: sm=%d; roc=%d; side=%x", fDataWord, fSM, fROC, fSIDE+10));
1028
1029 if ((fSM < 0) ||
1030 (fSM > 17) ||
1031 (fLAYER < 0) ||
1032 (fLAYER > 5) ||
1033 (fSTACK < 0) ||
1034 (fSTACK > 4) ||
1035 (fSIDE < 0) ||
1036 (fSIDE > 1)) {
1037 AliError(Form("0x%08x: Strange HC header: dcs=%d; sm=%d; layer=%d; stack=%d.",
1038 fDataWord, fDCS, fSM, fLAYER, fSTACK));
1039 }
1040 else {
1041 fStatus = 1;
1042 fHCHctr1++;
1043 fHCHctr2++;
1044 }
1045 }
1046 else {
1047 AliError(Form("0x%08x: No HC header when it was expected.", fDataWord));
1048 }
1049
bd63bf88 1050 // 2nd word (h[1])
7925de54 1051 if ( fHCHWords >= 1 ) {
1052 // read one more word
1053 if ( !fRawReader->ReadNextInt( fDataWord ) ) {
1054 AliError("Could not read data");
1055 return;
1056 }
bd63bf88 1057 fWordCtr++;
7925de54 1058 if ( (fDataWord & 0x3) == 1 ) {
1059
1060 fBCctr = (fDataWord >> 16);
1061 fPTctr = (fDataWord >> 12) & 0xf;
1062 fPTphase = (fDataWord >> 8) & 0xf;
1063 fTBins = ((fDataWord >> 2) & 0x3f) + 1;
1064
1065 AliDebug(3, Form("0x%08x: HC header 2: BCctr=%d PTctr=%d PTph=%d TB=%d"
1066 , fDataWord, fBCctr, fPTctr, fPTphase, fTBins));
1067
1068 if( fTBins != timeBins ) {
bd63bf88 1069
1070 AliWarning("===============================================================================");
1071 AliError(Form("Mismatch between nNTB from CDB (%d) and from HC header (%d)"
1072 , timeBins, fTBins));
1073 AliWarning(Form("We will use the value from the raw data (HC header): %d", fTBins));
1074 AliWarning("===============================================================================");
1075
7925de54 1076 }
1077
1078 }
1079
1080 }
1081
bd63bf88 1082 // 3nd word (h[2])
7925de54 1083 if ( fHCHWords >= 2 ) {
1084 // read one more word
1085 if ( !fRawReader->ReadNextInt( fDataWord ) ) {
1086 AliError("Could not read data");
1087 return;
1088 }
bd63bf88 1089 fWordCtr++;
7925de54 1090 if ( (fDataWord & 0x3) == 1 ) {
bd63bf88 1091
1092 fTCon = (fDataWord >> 29) & 0x1;
1093 fPEDon = (fDataWord >> 31) & 0x1;
1094 fGAINon = (fDataWord >> 30) & 0x1;
1095 fXTon = (fDataWord >> 28) & 0x1;
1096 fNonLinOn = (fDataWord >> 27) & 0x1;
1097 fBypass = (fDataWord >> 26) & 0x1;
1098
1099 fCommonAdditive = (fDataWord >> 20) & 0x3f;
1100
1101 AliDebug(3, Form("0x%08x: HC header 3: TC=%d, PED=%d, GAIN=%d, XT=%d, NonLin=%d, Bypass=%d, Add=%d"
1102 , fTCon, fPEDon, fGAINon, fXTon, fNonLinOn, fBypass, fCommonAdditive));
1103
1104 if( fTBins != timeBins ) {
1105 AliError(Form("Mismatch between Number of Time Bins from CDB (%d) and from HC header (%d)"
1106 , timeBins, fTBins));
1107 }
1108
7925de54 1109 }
1110
1111 }
1112
1113}
1114
1115//____________________________________________________________________________
1116void AliTRDRawStream::DecodeMCMheader()
1117{
1118 //
1119 //
1120 //
1121
bd63bf88 1122 if ( fRawVersion >= 1 && fRawVersion <= 3 ) {
1123 DecodeMCMheaderVx();
7925de54 1124 return;
1125 }
1126
1127 AliError(Form(" Unsupported raw version: %d", fRawVersion));
1128 return;
1129
1130}
1131
1132//____________________________________________________________________________
bd63bf88 1133void AliTRDRawStream::DecodeMCMheaderVx()
7925de54 1134{
1135
1136 //
1137 // Decode the MCM header
1138 //
1139
1140 fMCM = (fDataWord & 0xff000000) >> 24;
1141 fEv = (fDataWord & 0x00fffff0) >> 4;
1142
1143 fROB = fMCM / 16;
1144 fMCM = fMCM % 16;
1145
bd63bf88 1146 fROW = fGeo->GetPadRowFromMCM(fROB, fMCM);
7925de54 1147
1148 AliDebug(4, Form("0x%08x: SM%d L%dS%d. MCM Header: fROB=%d fMCM=%02d fEv=%02d"
1149 , fDataWord, fSM, fLAYER, fSTACK, fROB, fMCM, fEv));
1150
1151 if ( fROB % 2 == 0 && fSIDE == 1 ) {
1152 AliError(Form("SM%d L%dS%d: Mismatch between fROB (%d) and fSIDE (%d): fMCM=%02d"
1153 , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM ));
1154 }
1155 if ( fROB % 2 != 0 && fSIDE == 0 ) {
1156 AliError(Form("SM%d L%dS%d: Mismatch between fROB (%d) and fSIDE (%d): fMCM=%02d"
1157 , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM ));
1158 }
bd63bf88 1159 if ( (fSTACK == 2 && fROW >= fGeo->RowmaxC0()) ||
1160 (fSTACK != 2 && fROW >= fGeo->RowmaxC1()) || fROW < 0 ) {
7925de54 1161 AliError(Form("SM%d L%dS%d: Wrong Padrow (%d) fROB=%d, fSIDE=%d, fMCM=%02d"
1162 , fSM, fLAYER, fSTACK, fROW, fROB, fSIDE, fMCM ));
1163 }
1164
1165 fMCMHctr1++;
1166 fMCMHctr2++;
1167
bd63bf88 1168 // AdcMask for Zero supressed data
1169 if ( fRawVersion == 3 ) {
1170 // read one more word
1171 if ( !fRawReader->ReadNextInt( fDataWord ) ) {
1172 AliError("Could not read data");
1173 return;
1174 }
1175 fWordCtr++;
1176 if ( (fDataWord & 0x000007ff) == 0xC ) { // at the moment bits 4-10 are empty
1177 //if ( (fDataWord & 0x0000000f) == 0xC ) {
1178
1179 for ( Int_t ctr = 0; ctr < fGeo->ADCmax(); ctr++ ) {
1180 if ( (fDataWord >> (11+ctr)) == 0x1 ) fADCmask[ctr] = kTRUE;
1181 else fADCmask[ctr] = kFALSE;
1182 }
1183
1184 AliDebug(4, Form("0x%08x: ADC mask", fDataWord));
1185
1186 }
1187 else {
1188 AliError("Expected ADC mask but did not find one!");
1189 }
1190
1191 }
1192
7925de54 1193}
1194
1195//____________________________________________________________________________
1196void AliTRDRawStream::DecodeTracklet()
1197{
1198 //
1199 //
1200 //
1201
bd63bf88 1202 if ( fRawVersion >= 1 && fRawVersion <= 3 ) {
1203 DecodeTrackletVx();
7925de54 1204 return;
1205 }
1206
1207 AliError(Form(" Unsupported raw version: %d", fRawVersion));
1208 return;
1209
1210}
1211
1212//____________________________________________________________________________
bd63bf88 1213void AliTRDRawStream::DecodeTrackletVx()
7925de54 1214{
1215
1216 //
1217 // Decode the Tracklet
1218 //
1219 // this function is not tested yet on real tracklets
1220 //
1221
1222 fTracklPID = (fDataWord >> 24) & 0xff;
1223 fTracklPadRow = (fDataWord >> 20) & 0xf; // 0:15
1224 fTracklDefL = (fDataWord >> 13) & 0x7f;
1225 fTracklPadPos = (fDataWord) & 0x1fff;
1226
1227 fTracklPID /= (Float_t)((1<<8) - 1); // 0:1 (steps of 0.39%)
1228 fTracklDefL = (fTracklDefL - ((1<< 7)-1)/2.) * 140.e-4; // -0.889:0.889cm
1229 fTracklPadPos = (fTracklPadPos - ((1<<13)-1)/2.) * 160.e-4; // -65.528:65.528 cm
1230
1231 AliDebug(4, Form("0x%08x: Tracklet found: SM%d L%dS%d side %x: PadRow=%d PadPos=%f DefL=%f PID=%f"
1232 , fDataWord, fSM, fLAYER, fSTACK, fSIDE+10
1233 , fTracklPadRow, fTracklPadPos, fTracklDefL, fTracklPID));
1234
f78960c8 1235 if( (fSTACK == 2) && (fTracklPadRow >= (Int_t) fGeo->RowmaxC0()) ||
1236 (fSTACK != 2) && (fTracklPadRow >= (Int_t) fGeo->RowmaxC1()) ) {
7925de54 1237 AliError(Form("Strange Row read from Tracklet Word: %d", fTracklPadRow));
1238 }
1239
1240}
1241
1242//____________________________________________________________________________
1243void AliTRDRawStream::DecodeGTUlinkMask()
1244{
1245 //
1246 //
1247 //
1248
bd63bf88 1249 if ( fRawVersion >= 1 && fRawVersion <= 3 ) {
1250 DecodeGTUlinkMaskVx();
7925de54 1251 return;
1252 }
1253
1254 AliError(Form(" Unsupported raw version: %d", fRawVersion));
1255 return;
1256
1257}
1258
1259//____________________________________________________________________________
bd63bf88 1260void AliTRDRawStream::DecodeGTUlinkMaskVx()
7925de54 1261{
1262
1263 //
1264 // Decode the link masks sent by the GTU. These marke the active optical links
1265 // between GTU and Super Module. Up to now only fully active links are found
1266 // (0xfff = 12 active links).
1267 //
1268
1269 if ( fGTUctr1 == -1 ) fGTUctr2++;
1270 fGTUctr1++;
1271
1272 //printf("fGTUctr=%d",fGTUctr);
1273 //printf("fGTUctr1=%d, fGTUctr2=%d",fGTUctr1, fGTUctr2);
1274
1275 if ( (fGTUctr1 >= 0) && (fGTUctr1 < 5) && (fGTUctr2 >= 0) && (fGTUctr2 < 18) ) {
1276 fGTUlinkMask[fGTUctr2][fGTUctr1] = (fDataWord & 0xfff);
1277 }
1278
1279 for ( Int_t ctr = 0; ctr < 12; ctr++ ) {
1280 if ( IsGTULinkActive(fGTUctr2, ctr/2, fGTUctr1, ctr%2) ) {
1281 AliDebug(3, Form("SM %2d Stack %d: GTU Link %2d is active!", fGTUctr2, fGTUctr1, ctr));
1282 }
1283 }
1284
1285}
1286
bd63bf88 1287//____________________________________________________________________________
1288Int_t AliTRDRawStream::DecodeDataWord()
1289{
1290
1291 //
1292 // Decode the Data
1293 //
1294
1295 if ( fRawVersion >= 1 && fRawVersion <= 2 ) {
1296 return DecodeDataWordV1V2();
1297 }
1298 else if ( fRawVersion >= 3 && fRawVersion <= 3 ) {
1299 return DecodeDataWordV3();
1300 }
1301
1302 AliError(Form(" Unsupported raw version: %d", fRawVersion));
1303 return -1;
1304
1305}
1306
1307//____________________________________________________________________________
1308Int_t AliTRDRawStream::DecodeDataWordV1V2()
1309{
1310
1311 //
1312 // Decode the Data (full raw data. No zero suppression. 21 adc channels)
1313 //
1314 // return 0 means continue to next data word
1315 // return -1 means break data loop
1316 //
1317
1318 if ( (fDataWord & 0x00000003) != 0x2 && (fDataWord & 0x00000003) != 0x3) {
1319 AliError(Form("Data %08x : Data Word ends neither with b11 nor b10", (Int_t)fDataWord));
1320 return -1;
1321 }
1322
1323 if ( (fDataWord & 0x00000003) != fTbSwitch ) { // Next ADC channel found
1324 //if ( fTB+1 != timeBins ) AliError(Form("Time bins in data (%d) != DB (%d)", fTB+1, timeBins));
1325 fTbSwitch = (fTbSwitch & 2) | !(fTbSwitch & 1); // 0x3 <--> 0x2
1326 fTbSwitchCtr = 0;
1327 fADC++;
1328 fTB=0;
1329 }
1330
1331 fTbSwitchCtr++; // Just read one word
1332
1333 // We have only timeTotal time bins
1334 if ( fTbSwitchCtr > fTimeWords ) {
1335 AliError(Form("Data is strange. Already found %d words for this ADC channel", (Int_t)fTbSwitchCtr));
1336 return 0;
1337 }
1338
1339 // We have only 21 ADC channels.
1340 if ( fADC > (Int_t)fGeo->ADCmax()-1 ) {
1341 AliError(Form("Data %08x : Data is strange. fADC is already %d", (Int_t)fDataWord, (Int_t)fADC));
1342 return 0;
1343 }
1344
1345 // There are 18 pads connected to each MCM ADC channels 2...19. The other channels cross to other
1346 // MCMs and are good for online tracking in the MCM.
1347 if ( fADC > 1 && fADC < (Int_t)fGeo->ADCmax()-1 ) {
1348
1349 // Get Pad column
1350 fCOL = fGeo->GetPadColFromADC(fROB, fMCM, fADC);
1351
1352 // We have only 144 Pad Columns
1353 if ( fCOL > fColMax-1 || fCOL < 0 ) {
1354 AliError(Form("SM%d L%dS%d: Wrong Pad column (%d) fROB=%d, fSIDE=%d, fMCM=%02d", fSM,
1355 fLAYER, fSTACK, fCOL, fROB, fSIDE, fMCM ));
1356 }
1357
1358 // Decode 32 bit data words with information from 3 time bins and copy the data
1359 fSig[0] = (fDataWord & 0x00000ffc) >> 2;
1360 fSig[1] = (fDataWord & 0x003ff000) >> 12;
1361 fSig[2] = (fDataWord & 0xffc00000) >> 22;
1362
1363 // Print data to screen:
9f5053b6 1364 // Do NOT switch on for default production, it is VERY slow
1365 // AliDebug(5, Form("SM%d L%dS%d: ROB%d MCM=%d ADC=%d (ROW=%d COL=%d): Data %04d %04d %04d\n",
1366 // fSM, fLAYER, fSTACK, fROB, fMCM, fADC, fROW, fCOL, fSig[0], fSig[1], fSig[2]));
bd63bf88 1367
1368 }
1369 else {
1370
1371 fCOL = -1;
1372
1373 }
1374
5a21f812 1375 return 1;
1376
bd63bf88 1377}
1378
1379//____________________________________________________________________________
1380Int_t AliTRDRawStream::DecodeDataWordV3()
1381{
1382
1383 //
1384 // Decode the data (Zero suppresses data. 21 adc channels)
1385 //
1386 // return 0 means continue to next data word
1387 // return -1 means break data loop
1388 //
1389 // NOT TESTED YET!!!!!!!!
1390 //
1391
1392 if ( (fDataWord & 0x00000003) != 0x2 && (fDataWord & 0x00000003) != 0x3) {
1393 AliError(Form("Data %08x : Data Word ends neither with b11 nor b10", (Int_t)fDataWord));
1394 return -1;
1395 }
1396
1397 if ( (fDataWord & 0x00000003) != fTbSwitch ) { // Next ADC channel found
1398 //if ( fTB+1 != timeBins ) AliError(Form("Time bins in data (%d) != DB (%d)", fTB+1, timeBins));
1399 fTbSwitch = (fTbSwitch & 2) | !(fTbSwitch & 1); // 0x3 <--> 0x2
1400 fTbSwitchCtr = 0;
1401 //
1402 // Jump to next ADC channel that is not masked
1403 do {
1404 fADC++;
1405 } while ( ((fADC < fGeo->ADCmax()) && (fADCmask[fADC] == kFALSE)) || (fADC >= fGeo->ADCmax()) );
1406 fTB=0;
1407 }
1408
1409 fTbSwitchCtr++; // Just read one word
1410
1411 // We have only timeTotal time bins
1412 if ( fTbSwitchCtr > fTimeWords ) {
1413 AliError(Form("Data is strange. Already found %d words for this ADC channel", (Int_t)fTbSwitchCtr));
1414 return 0;
1415 }
1416
1417 // We have only 21 ADC channels.
1418 if ( fADC > (Int_t)fGeo->ADCmax()-1 ) {
1419 AliError(Form("Data %08x : Data is strange. fADC is already %d", (Int_t)fDataWord, (Int_t)fADC));
1420 return 0;
1421 }
1422
1423 // There are 18 pads connected to each MCM ADC channels 2...19. The other channels cross to other
1424 // MCMs and are good for online tracking in the MCM.
1425 if ( fADC > 1 && fADC < (Int_t)fGeo->ADCmax()-1 ) {
1426
1427 // Get Pad column
1428 fCOL = fGeo->GetPadColFromADC(fROB, fMCM, fADC);
1429
1430 // We have only 144 Pad Columns
1431 if ( fCOL > fColMax-1 || fCOL < 0 ) {
1432 AliError(Form("SM%d L%dS%d: Wrong Pad column (%d) fROB=%d, fSIDE=%d, fMCM=%02d", fSM,
1433 fLAYER, fSTACK, fCOL, fROB, fSIDE, fMCM ));
1434 }
1435
1436 // Decode 32 bit data words with information from 3 time bins and copy the data
1437 fSig[0] = (fDataWord & 0x00000ffc) >> 2;
1438 fSig[1] = (fDataWord & 0x003ff000) >> 12;
1439 fSig[2] = (fDataWord & 0xffc00000) >> 22;
1440
1441 // Print data to screen:
1442 AliDebug(5, Form("SM%d L%dS%d: ROB%d MCM=%d ADC=%d (ROW=%d COL=%d): Data %04d %04d %04d\n",
1443 fSM, fLAYER, fSTACK, fROB, fMCM, fADC, fROW, fCOL, fSig[0], fSig[1], fSig[2]));
1444
1445 }
1446 else {
1447
1448 fCOL = -1;
1449
1450 }
1451
5a21f812 1452 return 1;
1453
bd63bf88 1454}