RAW/AliAltroRawStreamV3.cxx

   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 ///////////////////////////////////////////////////////////////////////////////
  17 ///
  18 /// This is a base class for reading raw data digits in Altro format.
  19 /// The class is able to read the RCU v3 and above formats.
  20 /// The main difference between the format V3 and older ones is in
  21 /// the coding of the 10-bit Altro payload words. In V3 3 10-bit words
  22 /// are coded in one 32-bit word. The bits 30 and 31 are used to identify
  23 /// the payload, altro header and RCU trailer contents.
  24 ///
  25 ///
  26 /// cvetan.cheshkov@cern.ch 1/04/2009
  27 ///////////////////////////////////////////////////////////////////////////////
  28
  29 #include "AliAltroRawStreamV3.h"
  30 #include "AliRawReader.h"
  31 #include "AliLog.h"
  32 #include "AliAltroRawStream.h"
  33 #include "AliRawEventHeaderBase.h"
  34
  35 ClassImp(AliAltroRawStreamV3)
  36
  37
  38 //_____________________________________________________________________________
  39 AliAltroRawStreamV3::AliAltroRawStreamV3(AliRawReader* rawReader) :
  40   fIsShortDataHeader(kFALSE),
  41   fDDLNumber(-1),
  42   fRCUId(-1),
  43   fHWAddress(-1),
  44   fRawReader(rawReader),
  45   fData(NULL),
  46   fChannelStartPos(-1),
  47   fPosition(-1),
  48   fCount(-1),
  49   fStartTimeBin(-1),
  50   fBunchLength(-1),
  51   fBadChannel(kFALSE),
  52   fPayloadSize(-1),
  53   fChannelPayloadSize(-1),
  54   fBunchDataPointer(NULL),
  55   fBunchDataIndex(-1),
  56   fRCUTrailerData(NULL),
  57   fRCUTrailerSize(0),
  58   fFECERRA(0),
  59   fFECERRB(0),
  60   fERRREG2(0),
  61   fERRREG3(0),
  62   fActiveFECsA(0),
  63   fActiveFECsB(0),
  64   fAltroCFG1(0),
  65   fAltroCFG2(0),
  66   fOldStream(NULL),
  67   fCheckAltroPayload(kTRUE),
  68   fFormatVersion(0)
  69 {
  70   // Constructor
  71   // Create an object to read Altro raw digits in
  72   // RCU version 3 and beyond format
  73   for(Int_t i = 0; i < kMaxNTimeBins; i++) fBunchData[i] = 0;
  74 }
  75
  76 //_____________________________________________________________________________
  77 AliAltroRawStreamV3::~AliAltroRawStreamV3()
  78 {
  79 // destructor
  80 // delete old stream object if one exists
  81   if (fOldStream) delete fOldStream;
  82 }
  83
  84 //_____________________________________________________________________________
  85 AliAltroRawStreamV3::AliAltroRawStreamV3(const AliAltroRawStreamV3& stream) :
  86   TObject(stream),
  87   fIsShortDataHeader(stream.fIsShortDataHeader),
  88   fDDLNumber(stream.fDDLNumber),
  89   fRCUId(stream.fRCUId),
  90   fHWAddress(stream.fHWAddress),
  91   fRawReader(stream.fRawReader),
  92   fData(stream.fData),
  93   fChannelStartPos(stream.fChannelStartPos),
  94   fPosition(stream.fPosition),
  95   fCount(stream.fCount),
  96   fStartTimeBin(stream.fStartTimeBin),
  97   fBunchLength(stream.fBunchLength),
  98   fBadChannel(stream.fBadChannel),
  99   fPayloadSize(stream.fPayloadSize),
 100   fChannelPayloadSize(stream.fChannelPayloadSize),
 101   fBunchDataPointer(stream.fBunchDataPointer),
 102   fBunchDataIndex(stream.fBunchDataIndex),
 103   fRCUTrailerData(stream.fRCUTrailerData),
 104   fRCUTrailerSize(stream.fRCUTrailerSize),
 105   fFECERRA(stream.fFECERRA),
 106   fFECERRB(stream.fFECERRB),
 107   fERRREG2(stream.fERRREG2),
 108   fERRREG3(stream.fERRREG3),
 109   fActiveFECsA(stream.fActiveFECsA),
 110   fActiveFECsB(stream.fActiveFECsB),
 111   fAltroCFG1(stream.fAltroCFG1),
 112   fAltroCFG2(stream.fAltroCFG2),
 113   fOldStream(NULL),
 114   fCheckAltroPayload(stream.fCheckAltroPayload),
 115   fFormatVersion(0)
 116 {
 117   // Copy constructor
 118   // Copy the bunch data array
 119   for(Int_t i = 0; i < kMaxNTimeBins; i++) fBunchData[i] = stream.fBunchData[i];
 120
 121   if (stream.fOldStream)
 122     fOldStream = new AliAltroRawStream(*stream.fOldStream);
 123 }
 124
 125 //_____________________________________________________________________________
 126 AliAltroRawStreamV3& AliAltroRawStreamV3::operator = (const AliAltroRawStreamV3& stream)
 127 {
 128   // assignment operator
 129   // ...
 130   if(&stream == this) return *this;
 131
 132   fIsShortDataHeader = stream.fIsShortDataHeader;
 133   fDDLNumber         = stream.fDDLNumber;
 134   fRCUId             = stream.fRCUId;
 135   fHWAddress         = stream.fHWAddress;
 136   fRawReader         = stream.fRawReader;
 137   fData              = stream.fData;
 138   fChannelStartPos   = stream.fChannelStartPos;
 139   fPosition          = stream.fPosition;
 140   fCount             = stream.fCount;
 141   fStartTimeBin      = stream.fStartTimeBin;
 142   fBunchLength       = stream.fBunchLength;
 143   fBadChannel        = stream.fBadChannel;
 144   fPayloadSize       = stream.fPayloadSize;
 145   fChannelPayloadSize= stream.fChannelPayloadSize;
 146   fBunchDataPointer  = stream.fBunchDataPointer;
 147   fBunchDataIndex    = stream.fBunchDataIndex;
 148   fRCUTrailerData    = stream.fRCUTrailerData;
 149   fRCUTrailerSize    = stream.fRCUTrailerSize;
 150   fFECERRA           = stream.fFECERRA;
 151   fFECERRB           = stream.fFECERRB;
 152   fERRREG2           = stream.fERRREG2;
 153   fERRREG3           = stream.fERRREG3;
 154   fActiveFECsA       = stream.fActiveFECsA;
 155   fActiveFECsB       = stream.fActiveFECsB;
 156   fAltroCFG1         = stream.fAltroCFG1;
 157   fAltroCFG2         = stream.fAltroCFG2;
 158   fFormatVersion     = stream.fFormatVersion;
 159
 160   for(Int_t i = 0; i < kMaxNTimeBins; i++) fBunchData[i] = stream.fBunchData[i];
 161
 162   if (stream.fOldStream) {
 163     if (fOldStream) delete fOldStream;
 164     fOldStream = new AliAltroRawStream(stream.fRawReader);
 165     *fOldStream = *stream.fOldStream;
 166   }
 167
 168   fCheckAltroPayload = stream.fCheckAltroPayload;
 169
 170   return *this;
 171 }
 172
 173 //_____________________________________________________________________________
 174 void AliAltroRawStreamV3::Reset()
 175 {
 176 // Complete reset of raw stream params
 177 // Reset of the raw-reader as well
 178
 179   fDDLNumber = fRCUId = fHWAddress = -1;
 180   fChannelStartPos = -1;
 181   fPosition = fCount = -1;
 182   fBunchLength = fStartTimeBin = -1;
 183   fBadChannel = kFALSE;
 184   fPayloadSize = -1;
 185   fChannelPayloadSize = -1;
 186   fBunchDataPointer = NULL;
 187   fBunchDataIndex = -1;
 188
 189   fRCUTrailerData = NULL;
 190   fRCUTrailerSize = 0;
 191
 192   fFECERRA = fFECERRB = fERRREG2 = fERRREG3 = fActiveFECsA = fActiveFECsB = fAltroCFG1 = fAltroCFG2 = 0;
 193
 194   if (fRawReader) fRawReader->Reset();
 195
 196   if (fOldStream) fOldStream->Reset();
 197 }
 198
 199 //_____________________________________________________________________________
 200 Bool_t AliAltroRawStreamV3::NextDDL()
 201 {
 202 // Read the next DDL payload (CDH + RCU trailer)
 203 // Updates the information which is coming from these
 204 // two sources
 205   fFormatVersion = 0;
 206   fPosition = 0;
 207   // Get next DDL payload
 208   // return wtih false in case no more data payloads
 209   // are found
 210   do {
 211     if (!fRawReader->ReadNextData(fData)) return kFALSE;
 212   } while (fRawReader->GetDataSize() == 0);
 213
 214   fDDLNumber = fRawReader->GetDDLID();
 215   fChannelPayloadSize = -1;
 216   fChannelStartPos = -1;
 217
 218   fFormatVersion = (fRawReader->GetBlockAttributes() & 0xF);
 219
 220   if (fFormatVersion < 2) {
 221     // old altro format data
 222     if (!fOldStream) {
 223       fOldStream = new AliAltroRawStream(fRawReader);
 224       AliInfo(Form("RCU firmware verion %d detected. Using AliAltroRawStream to decode the data.",
 225                    fFormatVersion));
 226     }
 227     Bool_t status = fOldStream->NextDDL(fData);
 228     if (status) {
 229       fRCUId = fOldStream->GetRCUId();
 230       fRCUTrailerSize = fOldStream->GetRCUTrailerSize();
 231       fOldStream->GetRCUTrailerData(fRCUTrailerData);
 232       fFECERRA = fOldStream->GetFECERRA();
 233       fFECERRB = fOldStream->GetFECERRB();
 234       fERRREG2 = fOldStream->GetERRREG2();
 235       fERRREG3 = ((UInt_t)fOldStream->GetNChAddrMismatch()) |
 236         (((UInt_t)fOldStream->GetNChLengthMismatch()) << 12);
 237       fActiveFECsA = fOldStream->GetActiveFECsA();
 238       fActiveFECsB = fOldStream->GetActiveFECsB();
 239       fAltroCFG1 = fOldStream->GetAltroCFG1();
 240       fAltroCFG2 = fOldStream->GetAltroCFG2();
 241       if (fRawReader->GetType() == AliRawEventHeaderBase::kStartOfData)
 242         fPayloadSize = fOldStream->GetRCUPayloadSizeInSOD();
 243     }
 244     return status;
 245   }
 246
 247   return ReadRCUTrailer(fFormatVersion);
 248 }
 249
 250 //_____________________________________________________________________________
 251 Bool_t AliAltroRawStreamV3::NextChannel()
 252 {
 253   // Read the next Altro channel from the
 254   // raw-data stream
 255   // Updates the channel hardware address member and
 256   // channel data size. Sets the error flag in case
 257   // RCU signals readout error in this channel
 258   if (fOldStream) {
 259     Bool_t status = fOldStream->NextChannel();
 260     if (status) {
 261       fHWAddress = fOldStream->GetHWAddress();
 262       fChannelPayloadSize = fOldStream->GetChannelPayloadSize();
 263     }
 264     return status;
 265   }
 266
 267   Int_t channelStartPos=fPosition;
 268   fChannelStartPos = -1;
 269   fCount = -1;
 270   fBadChannel = kFALSE;
 271   fBunchDataIndex = 0;
 272   fBunchLength = -1;
 273
 274   UInt_t word = 0;
 275   do {
 276     word = Get32bitWord(fPosition++);
 277     if (fPosition > fPayloadSize) return kFALSE;
 278   }
 279   while ((word >> 30) != 1);
 280
 281   // check for readout errors
 282   fBadChannel = (word >> 29) & 0x1;
 283
 284   // extract channel payload and hw address
 285   fCount = (word >> 16) & 0x3FF;
 286   fChannelPayloadSize = fCount;
 287   fHWAddress = word & 0xFFF;
 288
 289   // Now unpack the altro data
 290   // Revert the order of the samples
 291   // inside the bunch so that the
 292   // first time is first in the samples
 293   // array
 294   Int_t isample = 0;
 295   Int_t nwords = (fCount+2)/3;
 296   for (Int_t iword = 0; iword < nwords; iword++) {
 297     word = Get32bitWord(fPosition++);
 298     if ((word >> 30) != 0) {
 299       // Unexpected end of altro channel payload
 300       AliWarning(Form("Unexpected end of payload in altro channel payload! DDL=%03d, Address=0x%x, word=0x%x",
 301                       fDDLNumber,fHWAddress,word));
 302       fRawReader->AddMinorErrorLog(kAltroPayloadErr,Form("hw=0x%x",fHWAddress));
 303       if (AliDebugLevel() > 0) HexDumpChannel();
 304       fCount = -1;
 305       fPosition--;
 306       return kFALSE;
 307     }
 308     fBunchData[isample++] = (word >> 20) & 0x3FF;
 309     fBunchData[isample++] = (word >> 10) & 0x3FF;
 310     fBunchData[isample++] = word & 0x3FF;
 311   }
 312
 313   fChannelStartPos=channelStartPos;
 314   return kTRUE;
 315 }
 316
 317 //_____________________________________________________________________________
 318 Bool_t AliAltroRawStreamV3::NextBunch()
 319 {
 320   // Read next altro bunch from the
 321   // raw-data stream.
 322   // Updates the start/end time-bins
 323   // and the array with altro samples
 324   if (fOldStream) {
 325     Bool_t status = fOldStream->NextBunch(fBunchData,fBunchLength,fStartTimeBin);
 326     if (status) fBunchDataPointer = &fBunchData[0];
 327     else fBunchDataPointer = NULL;
 328     return status;
 329   }
 330
 331   Int_t prevTimeBin = (fBunchLength > 0) ? fStartTimeBin-fBunchLength+1 : 1024;
 332   fBunchLength = fStartTimeBin = -1;
 333   fBunchDataPointer = NULL;
 334
 335   if ((fBunchDataIndex >= fCount) || fBadChannel) return kFALSE;
 336
 337   fBunchLength = fBunchData[fBunchDataIndex];
 338   if (fBunchLength <= 2) {
 339     // Invalid bunch size
 340      AliDebug(1,Form("Too short bunch length (%d) @ %d in Address=0x%x (DDL=%03d)!",
 341                     fBunchLength,fBunchDataIndex,fHWAddress,fDDLNumber));
 342     fRawReader->AddMinorErrorLog(kAltroBunchHeadErr,Form("hw=0x%x",fHWAddress));
 343     if (AliDebugLevel() > 0) HexDumpChannel();
 344     fCount = fBunchLength = -1;
 345     return kFALSE;
 346   }
 347   if ((fBunchDataIndex + fBunchLength) > fCount) {
 348     // Too long bunch detected
 349     AliDebug(1,Form("Too long bunch detected @ %d in Address=0x%x (DDL=%03d) ! Expected <= %d 10-bit words, found %d !", fBunchDataIndex,
 350                     fHWAddress,fDDLNumber,fCount-fBunchDataIndex,fBunchLength));
 351     fRawReader->AddMinorErrorLog(kAltroBunchHeadErr,Form("hw=0x%x",fHWAddress));
 352     if (AliDebugLevel() > 0) HexDumpChannel();
 353     fCount = fBunchLength = -1;
 354     return kFALSE;
 355   }
 356   fBunchDataIndex++;
 357   fBunchLength -= 2;
 358
 359   fStartTimeBin = fBunchData[fBunchDataIndex++];
 360   if (fCheckAltroPayload) {
 361     if ((fStartTimeBin-fBunchLength+1) < 0) {
 362       AliWarning(Form("Invalid start time-bin @ %d in Address=0x%x (DDL=%03d)! (%d-%d+1) < 0", fBunchDataIndex-1,
 363                       fHWAddress,fDDLNumber,fStartTimeBin,fBunchLength));
 364       fRawReader->AddMinorErrorLog(kAltroPayloadErr,Form("hw=0x%x",fHWAddress));
 365       if (AliDebugLevel() > 0) HexDumpChannel();
 366       fCount = fBunchLength = -1;
 367       return kFALSE;
 368     }
 369     if (fStartTimeBin >= prevTimeBin) {
 370       AliWarning(Form("Invalid start time-bin @ %d in Address=0x%x (DDL=%03d)! (%d>=%d)", fBunchDataIndex-1,
 371                       fHWAddress,fDDLNumber,fStartTimeBin,prevTimeBin));
 372       fRawReader->AddMinorErrorLog(kAltroPayloadErr,Form("hw=0x%x",fHWAddress));
 373       if (AliDebugLevel() > 0) HexDumpChannel();
 374       fCount = fBunchLength = -1;
 375       return kFALSE;
 376     }
 377   }
 378
 379   fBunchDataPointer = &fBunchData[fBunchDataIndex];
 380
 381   fBunchDataIndex += fBunchLength;
 382
 383   return kTRUE;
 384 }
 385
 386 //_____________________________________________________________________________
 387 const UChar_t *AliAltroRawStreamV3::GetChannelPayload() const
 388 {
 389   //returns raw channel data, length 4+(fChannelPayloadSize+2)/3*4
 390   if (fChannelStartPos<0 || fChannelPayloadSize<0) return NULL;
 391   Int_t channelSize=1+(fChannelPayloadSize+2)/3; // nof 32bit words
 392   if (fPosition<fChannelStartPos+channelSize) return NULL;
 393   return fData+(fChannelStartPos<<2);
 394 }
 395
 396 //_____________________________________________________________________________
 397 UInt_t AliAltroRawStreamV3::Get32bitWord(Int_t index) const
 398 {
 399   // This method returns the 32 bit word at a given
 400   // position inside the raw data payload.
 401   // The 'index' points to the beginning of the word.
 402   // The method is supposed to be endian (platform)
 403   // independent.
 404
 405   index = (index << 2);
 406   UInt_t word  = 0;
 407   word |= fData[index++];
 408   word |= fData[index++] << 8;
 409   word |= fData[index++] << 16;
 410   word |= fData[index++] << 24;
 411
 412   return word;
 413 }
 414
 415 ///_____________________________________________________________________________
 416 Bool_t AliAltroRawStreamV3::ReadRCUTrailer(UChar_t rcuVer)
 417 {
 418   // Read the RCU trailer according
 419   // to the RCU formware version
 420   // specified in CDH
 421   // Cross-check with version found in the
 422   // trailer
 423
 424   fRCUTrailerData = NULL;
 425   fRCUTrailerSize = 0;
 426   fPayloadSize = -1;
 427
 428   Int_t index = fRawReader->GetDataSize()/4;
 429
 430   // First read 32-bit word with the
 431   // trailer size (7 bits), RCU ID (9 bits) and
 432   // RCU firmware version (8 bits?)
 433   // The two major bit should be 11 (identifies
 434   // the end of the trailer)
 435   UInt_t word = Get32bitWord(--index);
 436
 437   if ((word >> 30) != 3) {
 438     fRawReader->AddFatalErrorLog(kRCUTrailerErr,"");
 439     AliError("Last RCU trailer word not found!");
 440     return kFALSE;
 441   }
 442
 443   UChar_t ver = (word >> 16) & 0xFF;
 444   if (ver != rcuVer) {
 445     // Wrong RCU firmware version detected
 446     fRawReader->AddMajorErrorLog(kRCUVerErr,Form("%d!=%d",
 447                                                  ver,rcuVer));
 448     AliDebug(1,Form("Wrong RCU firmware version detected: %d != %d",
 449                     ver,rcuVer));
 450   }
 451
 452   fRCUId = (Int_t)((word >> 7) & 0x1FF);
 453   Int_t trailerSize = (word & 0x7F);
 454
 455   // Now read the beginning of the trailer
 456   // where the payload size is written
 457   if (trailerSize < 2) {
 458     fRawReader->AddMajorErrorLog(kRCUTrailerErr,Form("tr=%d bytes",
 459                                                      trailerSize*4));
 460     AliWarning(Form("Invalid trailer size found (%d bytes) !",
 461                     trailerSize*4));
 462     return kFALSE;
 463   }
 464
 465   trailerSize -= 2;
 466   fRCUTrailerSize = trailerSize*4;
 467
 468   for (; trailerSize > 0; trailerSize--) {
 469     word = Get32bitWord(--index);
 470     if ((word >> 30) != 2) {
 471       fRawReader->AddMinorErrorLog(kRCUTrailerErr,"missing 10");
 472       AliWarning("Missing RCU trailer identifier pattern!");
 473       continue;
 474     }
 475     Int_t parCode = (word >> 26) & 0xF;
 476     Int_t parData = word & 0x3FFFFFF;
 477     switch (parCode) {
 478     case 1:
 479       // ERR_REG1
 480       fFECERRA = ((parData >> 13) & 0x1FFF) << 7;
 481       fFECERRB = ((parData & 0x1FFF)) << 7;
 482       break;
 483     case 2:
 484       // ERR_REG2
 485       fERRREG2 = parData & 0x1FF;
 486       break;
 487     case 3:
 488       // ERR_REG3
 489       fERRREG3 = parData & 0x1FFFFFF;
 490       break;
 491     case 4:
 492       // FEC_RO_A
 493       fActiveFECsA = parData & 0xFFFF;
 494       break;
 495     case 5:
 496       // FEC_RO_B
 497       fActiveFECsB = parData & 0xFFFF;
 498       break;
 499     case 6:
 500       // RDO_CFG1
 501       fAltroCFG1 = parData & 0xFFFFF;
 502       break;
 503     case 7:
 504       // RDO_CFG2
 505       fAltroCFG2 = parData & 0x1FFFFFF;
 506      break;
 507     default:
 508       fRawReader->AddMinorErrorLog(kRCUTrailerErr,"undef word");
 509       AliWarning(Form("Undefined parameter code %d, ignore it !",
 510                       parCode));
 511       break;
 512     }
 513   }
 514
 515   if (index < 1) {
 516     fRawReader->AddMajorErrorLog(kRCUTrailerErr,Form("tr=%d raw=%d bytes",
 517                                                      fRCUTrailerSize+8,
 518                                                      fRawReader->GetDataSize()));
 519     AliWarning(Form("Invalid trailer size found (%d bytes) ! The size is bigger than the raw data size (%d bytes)!",
 520                     fRCUTrailerSize,
 521                     fRawReader->GetDataSize()));
 522   }
 523
 524   fRCUTrailerData = fData + index*4;
 525
 526   // Now read the payload size
 527   // (First word in the RCU trailer)
 528   fPayloadSize = Get32bitWord(--index) & 0x3FFFFFF;
 529
 530   if ((fRawReader->GetDataSize() - fRCUTrailerSize - 8) != (fPayloadSize*4)) {
 531     fRawReader->AddMajorErrorLog(kRCUTrailerSizeErr,Form("h=%d tr=%d rcu=%d bytes",
 532                                                          fRawReader->GetDataSize(),
 533                                                          fRCUTrailerSize+8,
 534                                                          fPayloadSize*4));
 535     AliWarning(Form("Inconsistent raw data size ! Raw data size - %d bytes (from CDH), RCU trailer - %d bytes, raw data size (from RCU trailer) - %d bytes !",
 536                     fRawReader->GetDataSize(),
 537                     fRCUTrailerSize+8,
 538                     fPayloadSize*4));
 539   }
 540
 541   return kTRUE;
 542 }
 543
 544 //_____________________________________________________________________________
 545 Int_t AliAltroRawStreamV3::GetBranch() const
 546 {
 547   // The method provides the RCU branch index (0 or 1)
 548   // for the current hardware address.
 549   // In case the hardware address has not been yet
 550   // initialized, the method returns -1
 551   if (fHWAddress == -1) return -1;
 552
 553   return ((fHWAddress >> 11) & 0x1);
 554 }
 555
 556 //_____________________________________________________________________________
 557 Int_t AliAltroRawStreamV3::GetFEC() const
 558 {
 559   // The method provides the front-end card index
 560   // for the current hardware address.
 561   // In case the hardware address has not been yet
 562   // initialized, the method returns -1
 563   if (fHWAddress == -1) return -1;
 564
 565   return ((fHWAddress >> 7) & 0xF);
 566 }
 567
 568 //_____________________________________________________________________________
 569 Int_t AliAltroRawStreamV3::GetAltro() const
 570 {
 571   // The method provides the altro chip index
 572   // for the current hardware address.
 573   // In case the hardware address has not been yet
 574   // initialized, the method returns -1
 575   if (fHWAddress == -1) return -1;
 576
 577   return ((fHWAddress >> 4) & 0x7);
 578 }
 579
 580 //_____________________________________________________________________________
 581 Int_t AliAltroRawStreamV3::GetChannel() const
 582 {
 583   // The method provides the channel index
 584   // for the current hardware address.
 585   // In case the hardware address has not been yet
 586   // initialized, the method returns -1
 587   if (fHWAddress == -1) return -1;
 588
 589   return (fHWAddress & 0xF);
 590 }
 591
 592 //_____________________________________________________________________________
 593 Bool_t AliAltroRawStreamV3::GetRCUTrailerData(UChar_t*& data) const
 594 {
 595   // Return a pointer to the RCU trailer
 596   // data. Should be called always after
 597   // the RCU trailer was already processed
 598   // in the GetPosition() method
 599   if (!fRCUTrailerSize || !fRCUTrailerData) {
 600     AliError("No valid RCU trailer data is found !");
 601     data = NULL;
 602     return kFALSE;
 603   }
 604
 605   data = fRCUTrailerData;
 606
 607   return kTRUE;
 608 }
 609
 610 //_____________________________________________________________________________
 611 void AliAltroRawStreamV3::PrintRCUTrailer() const
 612 {
 613   // Prints the contents of
 614   // the RCU trailer data
 615   printf("RCU trailer (Format version %d):\n"
 616          "==================================================\n",  GetFormatVersion());
 617   printf("FECERRA:                                   0x%x\n", fFECERRA);
 618   printf("FECERRB:                                   0x%x\n", fFECERRB);
 619   printf("ERRREG2:                                   0x%x\n", fERRREG2);
 620   printf("#channels skipped due to address mismatch: %d\n",GetNChAddrMismatch());
 621   printf("#channels skipped due to bad block length: %d\n",GetNChLengthMismatch());
 622   printf("Active FECs (branch A):                    0x%x\n", fActiveFECsA);
 623   printf("Active FECs (branch B):                    0x%x\n", fActiveFECsB);
 624   printf("Baseline corr:                             0x%x\n",GetBaselineCorr());
 625   printf("Number of presamples:                      %d\n", GetNPresamples());
 626   printf("Number of postsamples:                     %d\n",GetNPostsamples());
 627   printf("Second baseline corr:                      %d\n",GetSecondBaselineCorr());
 628   printf("GlitchFilter:                              %d\n",GetGlitchFilter());
 629   printf("Number of non-ZS postsamples:              %d\n",GetNNonZSPostsamples());
 630   printf("Number of non-ZS presamples:               %d\n",GetNNonZSPresamples());
 631   printf("Number of ALTRO buffers:                   %d\n",GetNAltroBuffers());
 632   printf("Number of pretrigger samples:              %d\n",GetNPretriggerSamples());
 633   printf("Number of samples per channel:             %d\n",GetNSamplesPerCh());
 634   printf("Sparse readout:                            %d\n",GetSparseRO());
 635   printf("Sampling time:                             %e s\n",GetTSample());
 636   printf("L1 Phase:                                  %e s\n",GetL1Phase());
 637   printf("AltroCFG1:                                 0x%x\n",GetAltroCFG1());
 638   printf("AltroCFG2:                                 0x%x\n",GetAltroCFG2());
 639   printf("==================================================\n");
 640 }
 641
 642 //_____________________________________________________________________________
 643 void AliAltroRawStreamV3::SelectRawData(Int_t detId)
 644 {
 645   // Select the raw data for specific
 646   // detector id
 647   AliDebug(1,Form("Selecting raw data for detector %d",detId));
 648   fRawReader->Select(detId);
 649 }
 650
 651 //_____________________________________________________________________________
 652 void AliAltroRawStreamV3::SelectRawData(const char *detName)
 653 {
 654   // Select the raw data for specific
 655   // detector name
 656   AliDebug(1,Form("Selecting raw data for detector %s",detName));
 657   fRawReader->Select(detName);
 658 }
 659
 660 //_____________________________________________________________________________
 661 Double_t AliAltroRawStreamV3::GetTSample() const
 662 {
 663   // Returns the sampling time
 664   // in seconds. In case the rcu trailer
 665   // was note read, return an invalid number (0)
 666
 667   if (!fRCUTrailerData) return 0.;
 668
 669   const Double_t kLHCTimeSample = 25.0e-9; // LHC clocks runs at 40 MHz
 670   UChar_t fq = (fAltroCFG2 >> 5) & 0xF;
 671   Double_t tSample;
 672   switch (fq) {
 673   case 0:
 674     // 20 MHz
 675     tSample = 2.0*kLHCTimeSample;
 676     break;
 677   case 1:
 678     // 10 Mhz
 679     tSample = 4.0*kLHCTimeSample;
 680     break;
 681   case 2:
 682     // 5 MHz
 683     tSample = 8.0*kLHCTimeSample;
 684     break;
 685   default:
 686     AliWarning(Form("Invalid sampling frequency value %d !",
 687                       fq));
 688     tSample = 0.;
 689     break;
 690   }
 691
 692   return tSample;
 693 }
 694
 695 //_____________________________________________________________________________
 696 Double_t AliAltroRawStreamV3::GetL1Phase() const
 697 {
 698   // Returns the L1 phase w.r.t to the
 699   // LHC clock
 700   if (!fRCUTrailerData) return 0.;
 701
 702   const Double_t kLHCTimeSample = 25.0e-9; // LHC clocks runs at 40 MHz
 703   Double_t phase = ((Double_t)(fAltroCFG2 & 0x1F))*kLHCTimeSample;
 704
 705   Double_t tSample = GetTSample();
 706   if (phase >= tSample) {
 707     AliWarning(Form("Invalid L1 trigger phase (%f >= %f) !",
 708                     phase,tSample));
 709     phase = 0.;
 710   }
 711
 712   return phase;
 713 }
 714
 715 //_____________________________________________________________________________
 716 void AliAltroRawStreamV3::AddMappingErrorLog(const char *message)
 717 {
 718   // Signal a mapping error
 719   // The method can be used by the TPC,PHOS,EMCAL,FMD raw stream
 720   // classes in order to log an error related to bad altro mapping
 721
 722   if (fRawReader) fRawReader->AddMinorErrorLog(kBadAltroMapping,message);
 723 }
 724
 725 //_____________________________________________________________________________
 726 UChar_t *AliAltroRawStreamV3::GetRCUPayloadInSOD() const
 727 {
 728   // Get a pointer to the data in case
 729   // of SOD events
 730   if (fRawReader) {
 731     if (fRawReader->GetType() == AliRawEventHeaderBase::kStartOfData) {
 732       return fData;
 733     }
 734   }
 735   return NULL;
 736 }
 737
 738 //_____________________________________________________________________________
 739 Int_t AliAltroRawStreamV3::GetRCUPayloadSizeInSOD() const
 740 {
 741   // Get the size of the RCU data in case
 742   // of SOD events
 743   if (fRawReader) {
 744     if (fRawReader->GetType() == AliRawEventHeaderBase::kStartOfData) {
 745       return fPayloadSize;
 746     }
 747   }
 748   return -1;
 749 }
 750
 751 //_____________________________________________________________________________
 752
 753 void AliAltroRawStreamV3::HexDumpChannel() const
 754 {
 755   // Print of the Hex Data of the current channel
 756   // to decipher read-out warnings and errors
 757   if (fCount>0 && fPosition>0) {
 758     printf("Hex-Dump of DDL: %3d, RCU ID: %d, HWADDR: 0x%03x\n",
 759            fDDLNumber,fRCUId,fHWAddress);
 760     printf("32-bit     - 2bit 10bit 10bit 10bit - ");
 761     printf("Index 10bit  10bit  10bit\n");
 762     printf("**********   **** ***** ***** ***** - ");
 763     printf("***** ****** ****** ******\n");
 764     Int_t nwords = (fCount+2)/3+1;
 765     for (Int_t iword = 0; iword < nwords; iword++) {
 766       UInt_t word32 = Get32bitWord(fPosition-nwords+iword);
 767       UInt_t marker  = word32 >> 30 & 0x3;
 768       UInt_t word101 = word32 >> 20 & 0x3FF;
 769       UInt_t word102 = word32 >> 10 & 0x3FF;
 770       UInt_t word103 = word32 >> 00 & 0x3FF; // nice octal number
 771       printf("0x%08x - 0b%1d%1d 0x%03x 0x%03x 0x%03x",
 772              word32,marker>>1,marker&0x1,word101,word102,word103);
 773       if (iword == 0) { printf(" - Channel Header\n"); continue; }
 774       Int_t base = 3*(iword-1);
 775       printf(" - %5d 0x%03x%c 0x%03x%c 0x%03x%c\n", base,
 776              fBunchData[base],   (fBunchDataIndex == base   ? '*' : ' '),
 777              fBunchData[base+1], (fBunchDataIndex == base+1 ? '*' : ' '),
 778              fBunchData[base+2], (fBunchDataIndex == base+2 ? '*' : ' '));
 779     }
 780   }
 781 }