]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - RAW/AliAltroRawStream.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Error corrected
[u/mrichter/AliRoot.git] / RAW / AliAltroRawStream.cxx
... / ...
CommitLineData
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 Altro digits in raw data.
21///
22/// It loops over all Altro 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///////////////////////////////////////////////////////////////////////////////
28
29#include "AliAltroRawStream.h"
30#include "AliRawReader.h"
31#include "AliLog.h"
32
33ClassImp(AliAltroRawStream)
34
35
36//_____________________________________________________________________________
37AliAltroRawStream::AliAltroRawStream(AliRawReader* rawReader) :
38 fNoAltroMapping(kTRUE),
39 fIsShortDataHeader(kFALSE),
40 fDDLNumber(-1),
41 fPrevDDLNumber(-1),
42 fRCUId(-1),
43 fPrevRCUId(-1),
44 fHWAddress(-1),
45 fPrevHWAddress(-1),
46 fTime(-1),
47 fPrevTime(-1),
48 fSignal(-1),
49 fTimeBunch(-1),
50 fRawReader(rawReader),
51 fData(NULL),
52 fPosition(0),
53 fCount(0),
54 fBunchLength(0),
55 fRCUTrailerData(NULL),
56 fRCUTrailerSize(0),
57 fFECERRA(0),
58 fFECERRB(0),
59 fERRREG2(0),
60 fERRREG3(0),
61 fERRREG4(0),
62 fActiveFECsA(0),
63 fActiveFECsB(0),
64 fAltroCFG1(0),
65 fAltroCFG2(0)
66{
67// create an object to read Altro raw digits
68 fSegmentation[0] = fSegmentation[1] = fSegmentation[2] = -1;
69}
70
71//_____________________________________________________________________________
72AliAltroRawStream::AliAltroRawStream(const AliAltroRawStream& stream) :
73 TObject(stream),
74 fNoAltroMapping(stream.fNoAltroMapping),
75 fIsShortDataHeader(stream.fIsShortDataHeader),
76 fDDLNumber(stream.fDDLNumber),
77 fPrevDDLNumber(stream.fPrevDDLNumber),
78 fRCUId(stream.fRCUId),
79 fPrevRCUId(stream.fPrevRCUId),
80 fHWAddress(stream.fHWAddress),
81 fPrevHWAddress(stream.fPrevHWAddress),
82 fTime(stream.fTime),
83 fPrevTime(stream.fPrevTime),
84 fSignal(stream.fSignal),
85 fTimeBunch(stream.fTimeBunch),
86 fRawReader(stream.fRawReader),
87 fData(stream.fData),
88 fPosition(stream.fPosition),
89 fCount(stream.fCount),
90 fBunchLength(stream.fBunchLength),
91 fRCUTrailerData(stream.fRCUTrailerData),
92 fRCUTrailerSize(stream.fRCUTrailerSize),
93 fFECERRA(stream.fFECERRA),
94 fFECERRB(stream.fFECERRB),
95 fERRREG2(stream.fERRREG2),
96 fERRREG3(stream.fERRREG3),
97 fERRREG4(stream.fERRREG4),
98 fActiveFECsA(stream.fActiveFECsA),
99 fActiveFECsB(stream.fActiveFECsB),
100 fAltroCFG1(stream.fAltroCFG1),
101 fAltroCFG2(stream.fAltroCFG2)
102{
103 fSegmentation[0] = stream.fSegmentation[0];
104 fSegmentation[1] = stream.fSegmentation[1];
105 fSegmentation[2] = stream.fSegmentation[2];
106}
107
108//_____________________________________________________________________________
109AliAltroRawStream& AliAltroRawStream::operator = (const AliAltroRawStream& stream)
110{
111 if(&stream == this) return *this;
112
113 fNoAltroMapping = stream.fNoAltroMapping;
114 fIsShortDataHeader = stream.fIsShortDataHeader;
115 fDDLNumber = stream.fDDLNumber;
116 fPrevDDLNumber = stream.fPrevDDLNumber;
117 fRCUId = stream.fRCUId;
118 fPrevRCUId = stream.fPrevRCUId;
119 fHWAddress = stream.fHWAddress;
120 fPrevHWAddress = stream.fPrevHWAddress;
121 fTime = stream.fTime;
122 fPrevTime = stream.fPrevTime;
123 fSignal = stream.fSignal;
124 fTimeBunch = stream.fTimeBunch;
125 fRawReader = stream.fRawReader;
126 fData = stream.fData;
127 fPosition = stream.fPosition;
128 fCount = stream.fCount;
129 fBunchLength = stream.fBunchLength;
130 fRCUTrailerData = stream.fRCUTrailerData;
131 fRCUTrailerSize = stream.fRCUTrailerSize;
132 fFECERRA = stream.fFECERRA;
133 fFECERRB = stream.fFECERRB;
134 fERRREG2 = stream.fERRREG2;
135 fERRREG3 = stream.fERRREG3;
136 fERRREG4 = stream.fERRREG4;
137 fActiveFECsA = stream.fActiveFECsA;
138 fActiveFECsB = stream.fActiveFECsB;
139 fAltroCFG1 = stream.fAltroCFG1;
140 fAltroCFG2 = stream.fAltroCFG2;
141
142 fSegmentation[0] = stream.fSegmentation[0];
143 fSegmentation[1] = stream.fSegmentation[1];
144 fSegmentation[2] = stream.fSegmentation[2];
145
146 return *this;
147}
148
149//_____________________________________________________________________________
150AliAltroRawStream::~AliAltroRawStream()
151{
152// clean up
153
154}
155
156//_____________________________________________________________________________
157void AliAltroRawStream::Reset()
158{
159// reset altro raw stream params
160
161 fPosition = fCount = fBunchLength = 0;
162
163 fRCUTrailerData = NULL;
164 fRCUTrailerSize = 0;
165
166 fFECERRA = fFECERRB = fERRREG2 = fERRREG3 = fERRREG4 = fActiveFECsA = fActiveFECsB = fAltroCFG1 = fAltroCFG2 = 0;
167
168 fDDLNumber = fPrevDDLNumber = fRCUId = fPrevRCUId = fHWAddress = fPrevHWAddress = fTime = fPrevTime = fSignal = fTimeBunch = -1;
169
170 if (fRawReader) fRawReader->Reset();
171
172 fSegmentation[0] = fSegmentation[1] = fSegmentation[2] = -1;
173}
174
175//_____________________________________________________________________________
176Bool_t AliAltroRawStream::Next()
177{
178// read the next raw digit
179// returns kFALSE if there is no digit left
180
181 fPrevDDLNumber = fDDLNumber;
182 fPrevRCUId = fRCUId;
183 fPrevHWAddress = fHWAddress;
184 fPrevTime = fTime;
185
186 while (fCount == 0) { // next trailer
187 while (fPosition <= 0) { // next payload
188 do {
189 if (!fRawReader->ReadNextData(fData)) return kFALSE;
190 } while (fRawReader->GetDataSize() == 0);
191
192 fDDLNumber = fRawReader->GetDDLID();
193
194 fPosition = GetPosition();
195 }
196
197 ReadTrailer();
198
199 fBunchLength = 0;
200 }
201
202 if (fBunchLength == 0) ReadBunch();
203 else fTime--;
204
205 ReadAmplitude();
206
207 return kTRUE;
208}
209
210//_____________________________________________________________________________
211void AliAltroRawStream::SelectRawData(Int_t detId)
212{
213 // Select the raw data for specific
214 // detector id
215 AliDebug(1,Form("Selecting raw data for detector %d",detId));
216 fRawReader->Select(detId);
217}
218
219//_____________________________________________________________________________
220void AliAltroRawStream::SelectRawData(const char *detName)
221{
222 // Select the raw data for specific
223 // detector name
224 AliDebug(1,Form("Selecting raw data for detector %s",detName));
225 fRawReader->Select(detName);
226}
227
228//_____________________________________________________________________________
229UShort_t AliAltroRawStream::GetNextWord()
230{
231 // Read the next 10 bit word in backward direction
232 // The input stream access is given by fData and fPosition
233
234 fPosition--;
235
236 Int_t iBit = fPosition * 10;
237 Int_t iByte = iBit / 8;
238 Int_t shift = iBit % 8;
239
240 // the raw data is written as integers where the low bits are filled first
241 // -> little endian is assumed here !
242 Int_t iByteLow = iByte;
243 iByte++;
244 Int_t iByteHigh = iByte;
245 return ((fData[iByteHigh] * 256 + fData[iByteLow]) >> shift) & 0x03FF;
246}
247
248//_____________________________________________________________________________
249Bool_t AliAltroRawStream::ReadTrailer()
250{
251 //Read a trailer of 40 bits in the backward reading mode
252 //In case of no mapping is provided, read a dummy trailer
253 if (fNoAltroMapping) {
254 AliError("No ALTRO mapping information is loaded! Reading a dummy trailer!");
255 return ReadDummyTrailer();
256 }
257
258 //First reading filling words
259 UShort_t temp;
260 Int_t nFillWords = 0;
261 while ((temp = GetNextWord()) == 0x2AA) nFillWords++;
262 if (nFillWords == 0) {
263 fRawReader->AddMajorErrorLog(kAltroTrailerErr,"no 0x2AA");
264 // PrintDebug();
265 AliWarning(Form("Incorrect trailer found ! Expected 0x2AA not found (0x%x != 0x2AA) ! Current position %d, DDL=%d",
266 temp,fPosition,fDDLNumber));
267 // trying to recover and find the next bunch
268 while ((fPosition > 2) && (temp != 0x2AA)) temp = GetNextWord();
269 if (temp != 0x2AA) {
270 fCount = fPosition = 0;
271 return kFALSE;
272 }
273 temp = GetNextWord();
274 }
275
276 //Then read the trailer
277 if (fPosition < 2) {
278 fRawReader->AddMajorErrorLog(kAltroTrailerErr,Form("size %d < 5",
279 fPosition));
280 // PrintDebug();
281 AliWarning(Form("Incorrect raw data size ! Expected at least 5 words but found %d !",fPosition));
282 fCount = fPosition = 0;
283 return kFALSE;
284 }
285
286 fCount = (temp << 4) & 0x3FF;
287 if ((temp >> 6) != 0xA) {
288 fRawReader->AddMajorErrorLog(kAltroTrailerErr,"no 0xA");
289 // PrintDebug();
290 AliWarning(Form("Incorrect trailer found ! Expecting 0xA but found 0x%x !",temp >> 6));
291 fCount = 0;
292 return kFALSE;
293 }
294
295 temp = GetNextWord();
296 fHWAddress = (temp & 0x3) << 10;
297 if (((temp >> 2) & 0xF) != 0xA) {
298 fRawReader->AddMajorErrorLog(kAltroTrailerErr,"no second 0xA");
299 // PrintDebug();
300 AliWarning(Form("Incorrect trailer found ! Expecting second 0xA but found 0x%x !",(temp >> 2) & 0xF));
301 fCount = 0;
302 return kFALSE;
303 }
304 fCount |= ((temp & 0x3FF) >> 6);
305
306 if (fCount >= fPosition) {
307 fRawReader->AddMajorErrorLog(kAltroTrailerErr,"invalid size");
308 // PrintDebug();
309 AliWarning(Form("Incorrect trailer found ! The altro payload size is invalid (%d >= %d) !",fCount,fPosition));
310 fCount = 0;
311 return kFALSE;
312 }
313 temp = GetNextWord();
314 fHWAddress |= temp;
315
316 fPosition -= (4 - (fCount % 4)) % 4; // skip fill words
317
318 return kTRUE;
319}
320
321//_____________________________________________________________________________
322Bool_t AliAltroRawStream::ReadDummyTrailer()
323{
324 //Read a trailer of 40 bits in the backward reading mode
325 //In case of no mapping is provided, read a dummy trailer
326 UShort_t temp;
327 while ((temp = GetNextWord()) == 0x2AA);
328
329 fSegmentation[0] = temp;
330 fSegmentation[1] = GetNextWord();
331 fSegmentation[2] = GetNextWord();
332 fCount = GetNextWord();
333 if (fCount == 0) return kFALSE;
334 fHWAddress = -1;
335
336 fPosition -= (4 - (fCount % 4)) % 4; // skip fill words
337
338 return kTRUE;
339}
340
341//_____________________________________________________________________________
342void AliAltroRawStream::ReadBunch()
343{
344 // Read altro payload in
345 // backward direction
346 if (fCount <= 2) {
347 fRawReader->AddMinorErrorLog(kBunchLengthReadErr,"");
348 // PrintDebug();
349 AliWarning(Form("Could not read bunch length and time bin ! Only %d 10-bit words are left !",fCount));
350 fBunchLength = fTimeBunch = fCount = 0;
351 return;
352 }
353
354 fBunchLength = GetNextWord() - 2;
355 if (fBunchLength > fCount) {
356 fRawReader->AddMinorErrorLog(kBunchLengthReadErr,Form("bl=%d",fBunchLength));
357 // PrintDebug();
358 AliWarning(Form("Could not read bunch length ! Bunch length = %d (>%d)",fBunchLength,fCount));
359 fBunchLength = fTimeBunch = fCount = 0;
360 return;
361 }
362 fTimeBunch = fBunchLength;
363 fCount--;
364
365 fTime = GetNextWord();
366 fCount--;
367
368 return;
369}
370
371//_____________________________________________________________________________
372void AliAltroRawStream::ReadAmplitude()
373{
374 // Read next time bin amplitude
375 if (fCount <= 0) {
376 fRawReader->AddMinorErrorLog(kAmplitudeReadErr,"");
377 // PrintDebug();
378 AliWarning("Could not read sample amplitude !");
379 fCount = fSignal = fBunchLength = 0;
380 return;
381 }
382
383 fSignal = GetNextWord();
384
385 fCount--;
386 fBunchLength--;
387
388 return;
389}
390
391//_____________________________________________________________________________
392Int_t AliAltroRawStream::GetPosition()
393{
394 // Sets the position in the
395 // input stream
396 // Read the RCU trailer
397 // This includes the trailer size,
398 // RCU identifier and raw data payload.
399 // The RCU trailer format is described
400 // in details in the RCU manual.
401
402 // We use the last word of the payload
403 // in order to decide which RCU firmware
404 // was used during the data taking.
405 // The firmware v2 adds 0xAAAA as 16
406 // most significant bits and since the
407 // payload size (firmware v1) can not be
408 // that big, we use this as a unique
409 // label of the firmware version.
410
411 Int_t index = fRawReader->GetDataSize();
412 UInt_t word = Get32bitWord(index);
413 if (((word >> 16) == 0xaaaa) || (word == 2)) {
414 // This is RCU formware v2
415 // The statement word==2 is needed only temporary
416 // in order to be able to read previously generated
417 // aliroot raw data
418
419 Int_t trailerSize = 0;
420 if (word == 2) {
421 AliInfo("Old simulated raw data is assumed!");
422 trailerSize = 2;
423 fRCUId = 0;
424 }
425 else {
426 // First read 32-bit word with the
427 // trailer size (7 bits), RCU ID (9 bits) and
428 // 0xAAA (the rest - 16 bits)
429 fRCUId = (Int_t)((word >> 7) & 0x1ff);
430 trailerSize = (word & 0x7F);
431 }
432
433 // Now read the beginning of the trailer
434 // where the payload size is written
435 if (trailerSize < 2) {
436 fRawReader->AddMajorErrorLog(kRCUTrailerErr,Form("tr=%d bytes",
437 trailerSize*4));
438 AliWarning(Form("Invalid trailer size found (%d bytes) !",
439 trailerSize*4));
440 }
441
442 Int_t position = ReadRCUTrailer(index,trailerSize);
443 // The size is specified in a number of 40bits
444 // Therefore we need to transform it to number of bytes
445 position *= 5;
446
447 // Check the consistency of the header and trailer
448 if (((fRawReader->GetDataSize() - trailerSize*4) < position) ||
449 ((fRawReader->GetDataSize() - trailerSize*4) >= (position + 4))) {
450 fRawReader->AddMajorErrorLog(kRCUTrailerSizeErr,Form("h=%d tr=%d rcu=%d bytes",
451 fRawReader->GetDataSize(),
452 trailerSize*4,
453 position));
454 AliWarning(Form("Inconsistent raw data size ! Raw data size - %d bytes (from the header), RCU trailer - %d bytes, raw data paylod - %d bytes !",
455 fRawReader->GetDataSize(),
456 trailerSize*4,
457 position));
458 position = fRawReader->GetDataSize() - trailerSize*4;
459 }
460
461 return position * 8 / 10;
462 }
463 else {
464 // In case of the Old RCU trailer format
465 // we have to read just the size of altro payload
466 // in units of 40-bit words
467 Int_t position = (Int_t)word;
468
469 fRCUId = -1;
470 fRCUTrailerSize = 0;
471 fRCUTrailerData = NULL;
472
473 // The size is specified in a number of 40bits
474 // Therefore we need to transform it to number of bytes
475 position *= 5;
476
477 if (!fIsShortDataHeader) {
478
479 // Check the consistency of the header and trailer
480 if (((fRawReader->GetDataSize() - 4) < position) ||
481 ((fRawReader->GetDataSize() - 4) >= (position + 4))) {
482 fRawReader->AddMajorErrorLog(kRCUTrailerSizeErr,Form("h=%d rcu=%d bytes",
483 fRawReader->GetDataSize()-4,
484 position));
485 // PrintDebug();
486 AliWarning(Form("Inconsistent raw data size ! Expected %d bytes (from the header), found %d bytes (in the RCU trailer)!",
487 fRawReader->GetDataSize()-4,
488 position));
489 position = fRawReader->GetDataSize()-4;
490 }
491 }
492 else {
493 // Check the consistency of the header and trailer
494 // In this case the header is shorter by 4 bytes
495 if ((fRawReader->GetDataSize() < position) ||
496 (fRawReader->GetDataSize() >= (position + 4))) {
497 fRawReader->AddMajorErrorLog(kRCUTrailerSizeErr,Form("h=%d rcu=%d bytes",
498 fRawReader->GetDataSize(),
499 position));
500 // PrintDebug();
501 AliWarning(Form("Inconsistent raw data size ! Expected %d bytes (from the header), found %d bytes (in the RCU trailer)!",
502 fRawReader->GetDataSize(),
503 position));
504 position = fRawReader->GetDataSize();
505 }
506
507 // 7 32-bit words Common Data Header
508 // therefore we have to shift back by 4 bytes
509 // the pointer to the raw data payload
510 fData -= 4;
511 }
512
513 // Return the position in units of 10-bit words
514 return position*8/10;
515 }
516}
517
518//_____________________________________________________________________________
519UInt_t AliAltroRawStream::Get32bitWord(Int_t &index)
520{
521 // This method returns the 32 bit word at a given
522 // position inside the raw data payload.
523 // The 'index' points to the beginning of the next word.
524 // The method is supposed to be endian (platform)
525 // independent.
526 if (!fData) {
527 PrintDebug();
528 AliFatal("Raw data paylod buffer is not yet initialized !");
529 }
530
531 if (index < 4) {
532 fRawReader->AddFatalErrorLog(k32bitWordReadErr,Form("pos = %d",index));
533 // PrintDebug();
534 AliWarning(Form("Invalid raw data payload position (%d) !",index));
535 }
536
537 UInt_t word = 0;
538 word = fData[--index] << 24;
539 word |= fData[--index] << 16;
540 word |= fData[--index] << 8;
541 word |= fData[--index];
542
543 return word;
544}
545
546//_____________________________________________________________________________
547Int_t AliAltroRawStream::ReadRCUTrailer(Int_t &index, Int_t trailerSize)
548{
549 // The method decodes the RCU trailer data
550 // according to the RCU fw ver.2 specs
551
552 fRCUTrailerSize = trailerSize*4;
553
554 for (trailerSize -= 2; trailerSize > 0; trailerSize--) {
555 Int_t word = Get32bitWord(index);
556 Int_t parCode = word >> 26;
557 Int_t parData = word & 0x3FFFFFF;
558 switch (parCode) {
559 case 1:
560 // ERR_REG1
561 fFECERRA = ((parData >> 13) & 0x1FFF) << 7;
562 fFECERRB = ((parData & 0x1FFF)) << 7;
563 break;
564 case 2:
565 // ERR_REG2
566 fERRREG2 = parData & 0x1FF;
567 break;
568 case 3:
569 // ERR_REG3
570 fERRREG3 = parData & 0xFFF;
571 break;
572 case 4:
573 // ERR_REG4
574 fERRREG4 = parData & 0xFFF;
575 break;
576 case 5:
577 // FEC_RO_A
578 fActiveFECsA = parData & 0xFFFF;
579 break;
580 case 6:
581 // FEC_RO_B
582 fActiveFECsB = parData & 0xFFFF;
583 break;
584 case 7:
585 // RDO_CFG1
586 fAltroCFG1 = parData & 0x7FFFF;
587 break;
588 case 8:
589 // RDO_CFG2
590 fAltroCFG2 = parData & 0x1FFFFFF;
591 break;
592 default:
593 fRawReader->AddMinorErrorLog(kRCUTrailerErr,"undef word");
594 AliWarning(Form("Undefined parameter code %d, ignore it !",
595 parCode));
596 break;
597 }
598 }
599
600 if (index < 4) {
601 fRawReader->AddMajorErrorLog(kRCUTrailerErr,Form("tr=%d raw=%d bytes",
602 trailerSize*4,
603 fRawReader->GetDataSize()));
604 AliWarning(Form("Invalid trailer size found (%d bytes) ! The size is bigger than the raw data size (%d bytes)!",
605 trailerSize*4,
606 fRawReader->GetDataSize()));
607 }
608 fRCUTrailerSize = trailerSize*4;
609 fRCUTrailerData = fData + index;
610
611 Int_t position = Get32bitWord(index);
612
613
614 return position;
615}
616
617//_____________________________________________________________________________
618Double_t AliAltroRawStream::GetTSample() const
619{
620 // Returns the sampling time
621 // in seconds. In case the rcu trailer
622 // was note read, return an invalid number (0)
623
624 if (!fRCUTrailerData) return 0.;
625
626 const Double_t kLHCTimeSample = 25.0e-9; // LHC clocks runs at 40 MHz
627 UChar_t fq = (fAltroCFG2 >> 5) & 0xF;
628 Double_t tSample;
629 switch (fq) {
630 case 0:
631 // 20 MHz
632 tSample = 2.0*kLHCTimeSample;
633 break;
634 case 1:
635 // 10 Mhz
636 tSample = 4.0*kLHCTimeSample;
637 break;
638 case 2:
639 // 5 MHz
640 tSample = 8.0*kLHCTimeSample;
641 break;
642 default:
643 AliWarning(Form("Invalid sampling frequency value %d !",
644 fq));
645 tSample = 0.;
646 break;
647 }
648
649 return tSample;
650}
651
652//_____________________________________________________________________________
653Double_t AliAltroRawStream::GetL1Phase() const
654{
655 // Returns the L1 phase w.r.t to the
656 // LHC clock
657 if (!fRCUTrailerData) return 0.;
658
659 const Double_t kLHCTimeSample = 25.0e-9; // LHC clocks runs at 40 MHz
660 Double_t phase = ((Double_t)(fAltroCFG2 & 0x1F))*kLHCTimeSample;
661
662 Double_t tSample = GetTSample();
663 if (phase >= tSample) {
664 AliWarning(Form("Invalid L1 trigger phase (%f >= %d) !",
665 phase,tSample));
666 phase = 0.;
667 }
668
669 return phase;
670}
671
672//_____________________________________________________________________________
673void AliAltroRawStream::PrintRCUTrailer() const
674{
675 // Prints the contents of
676 // the RCU trailer data
677 printf("RCU trailer:\n===========\n");
678 printf("FECERRA: 0x%x\nFECERRB: 0x%x\n",fFECERRA,fFECERRB);
679 printf("ERRREG2: 0x%x\n",fERRREG2);
680 printf("#channels skipped due to address mismatch: %d\n",GetNChAddrMismatch());
681 printf("#channels skipped due to bad block length: %d\n",GetNChLengthMismatch());
682 printf("Active FECs (branch A): 0x%x\nActive FECs (branch B): 0x%x\n",fActiveFECsA,fActiveFECsB);
683 printf("Baseline corr: 0x%x\n",GetBaselineCorr());
684 printf("Number of presamples: %d\nNumber of postsamples: %d\n",GetNPresamples(),GetNPostsamples());
685 printf("Second baseline corr: %d\n",GetSecondBaselineCorr());
686 printf("GlitchFilter: %d\n",GetGlitchFilter());
687 printf("Number of non-ZS postsamples: %d\nNumber of non-ZS presamples: %d\n",GetNNonZSPostsamples(),GetNNonZSPresamples());
688 printf("Number of ALTRO buffers: %d\n",GetNAltroBuffers());
689 printf("Number of pretrigger samples: %d\n",GetNPretriggerSamples());
690 printf("Number of samples per channel: %d\n",GetNSamplesPerCh());
691 printf("Sparse readout: %d\n",GetSparseRO());
692 printf("Sampling time: %e s\n",GetTSample());
693 printf("L1 Phase: %e s\n",GetL1Phase());
694 printf("AltroCFG1: 0x%x\nAltroCFG2: 0x%x\n",GetAltroCFG1(),GetAltroCFG2());
695 printf("===========\n");
696}
697
698//_____________________________________________________________________________
699Bool_t AliAltroRawStream::GetRCUTrailerData(UChar_t*& data) const
700{
701 // Return a pointer to the RCU trailer
702 // data. Should be called always after
703 // the RCU trailer was already processed
704 // in the GetPosition() method
705 if (!fRCUTrailerSize || !fRCUTrailerData) {
706 AliError("No valid RCU trailer data is found !");
707 data = NULL;
708 return kFALSE;
709 }
710
711 data = fRCUTrailerData;
712
713 return kTRUE;
714}
715
716//_____________________________________________________________________________
717void AliAltroRawStream::PrintDebug() const
718{
719 // The method prints all the available
720 // debug information.
721 // Its is used in case of decoding errors.
722
723 AliError("Start of debug printout\n--------------------");
724
725 Dump();
726 if (fRawReader) fRawReader->Dump();
727
728 AliError("End of debug printout\n--------------------");
729}
730
731//_____________________________________________________________________________
732Int_t AliAltroRawStream::GetBranch() const
733{
734 // The method provides the RCU branch index (0 or 1)
735 // for the current hardware address.
736 // In case the hardware address has not been yet
737 // initialized, the method returns -1
738 if (fHWAddress == -1) return -1;
739
740 return ((fHWAddress >> 11) & 0x1);
741}
742
743//_____________________________________________________________________________
744Int_t AliAltroRawStream::GetFEC() const
745{
746 // The method provides the front-end card index
747 // for the current hardware address.
748 // In case the hardware address has not been yet
749 // initialized, the method returns -1
750 if (fHWAddress == -1) return -1;
751
752 return ((fHWAddress >> 7) & 0xF);
753}
754
755//_____________________________________________________________________________
756Int_t AliAltroRawStream::GetAltro() const
757{
758 // The method provides the altro chip index
759 // for the current hardware address.
760 // In case the hardware address has not been yet
761 // initialized, the method returns -1
762 if (fHWAddress == -1) return -1;
763
764 return ((fHWAddress >> 4) & 0x7);
765}
766
767//_____________________________________________________________________________
768Int_t AliAltroRawStream::GetChannel() const
769{
770 // The method provides the channel index
771 // for the current hardware address.
772 // In case the hardware address has not been yet
773 // initialized, the method returns -1
774 if (fHWAddress == -1) return -1;
775
776 return (fHWAddress & 0xF);
777}
778
779//_____________________________________________________________________________
780void AliAltroRawStream::AddMappingErrorLog(const char *message)
781{
782 // Signal a mapping error
783 // The method can be used by the TPC,PHOS,EMCAL,FMD raw stream
784 // classes in order to log an error related to bad altro mapping
785
786 if (fRawReader) fRawReader->AddMinorErrorLog(kBadAltroMapping,message);
787}