TRD/AliTRDrawStream.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 //  Decoding data from the TRD raw stream                                 //
  19 //  and translation into ADC values                                       //
  20 //                                                                        //
  21 //  Author: J. Klein (jochen.klein@cern.ch)                               //
  22 //                                                                        //
  23 ////////////////////////////////////////////////////////////////////////////
  24
  25 #include <cstdio>
  26 #include <cstdarg>
  27
  28 #include "TClonesArray.h"
  29 #include "TTree.h"
  30
  31 #include "AliLog.h"
  32 #include "AliRawReader.h"
  33 #include "AliTRDdigitsManager.h"
  34 #include "AliTRDdigitsParam.h"
  35 #include "AliTRDtrapConfig.h"
  36 #include "AliTRDarrayADC.h"
  37 #include "AliTRDarrayDictionary.h"
  38 #include "AliTRDSignalIndex.h"
  39 #include "AliTRDtrackletWord.h"
  40 #include "AliESDTrdTrack.h"
  41 #include "AliTreeLoader.h"
  42
  43 #include "AliTRDrawStream.h"
  44
  45 // temporary
  46 #include "AliRunLoader.h"
  47
  48 ClassImp(AliTRDrawStream)
  49
  50 // some static information
  51 const Int_t AliTRDrawStream::fgkMcmOrder[] = {12, 13, 14, 15,
  52                                               8, 9, 10, 11,
  53                                               4, 5, 6, 7,
  54                                               0, 1, 2, 3};
  55 const Int_t  AliTRDrawStream::fgkRobOrder [] = {0, 1, 2, 3};
  56 const Int_t  AliTRDrawStream::fgkNlinks = 12;
  57 const Int_t  AliTRDrawStream::fgkNstacks = 5;
  58 const UInt_t AliTRDrawStream::fgkDataEndmarker     = 0x00000000;
  59 const UInt_t AliTRDrawStream::fgkTrackletEndmarker = 0x10001000;
  60
  61 const char* AliTRDrawStream::fgErrorMessages[] = {
  62   "Unknown error",
  63   "Link monitor active",
  64   "Pretrigger counter mismatch",
  65   "not a TRD equipment (1024-1041)",
  66   "Invalid Stack header",
  67   "Invalid detector number",
  68   "No digits could be retrieved from the digitsmanager",
  69   "HC header mismatch",
  70   "HC check bits wrong",
  71   "Unexpected position in readout stream",
  72   "Invalid testpattern mode",
  73   "Testpattern mismatch",
  74   "Number of timebins changed",
  75   "ADC mask inconsistent",
  76   "ADC check bits invalid",
  77   "Missing ADC data",
  78   "Missing expected ADC channels",
  79   "Missing MCM headers"
  80 };
  81
  82 const Int_t AliTRDrawStream::fgErrorDebugLevel[] = {
  83   0,
  84   0,
  85   2,
  86   1,
  87   0,
  88   1,
  89   1,
  90   1,
  91   1,
  92   2,
  93   1,
  94   1,
  95   1,
  96   1,
  97   2,
  98   1,
  99   1,
 100   1
 101 };
 102
 103 AliTRDrawStream::ErrorBehav_t AliTRDrawStream::fgErrorBehav[] = {
 104   AliTRDrawStream::kTolerate,
 105   AliTRDrawStream::kDiscardHC,
 106   AliTRDrawStream::kTolerate,
 107   AliTRDrawStream::kAbort,
 108   AliTRDrawStream::kAbort,
 109   AliTRDrawStream::kAbort,
 110   AliTRDrawStream::kAbort,
 111   AliTRDrawStream::kDiscardHC,
 112   AliTRDrawStream::kDiscardHC,
 113   AliTRDrawStream::kTolerate,
 114   AliTRDrawStream::kTolerate,
 115   AliTRDrawStream::kTolerate,
 116   AliTRDrawStream::kTolerate,
 117   AliTRDrawStream::kTolerate,
 118   AliTRDrawStream::kTolerate,
 119   AliTRDrawStream::kTolerate,
 120   AliTRDrawStream::kTolerate,
 121   AliTRDrawStream::kTolerate
 122 };
 123
 124 AliTRDrawStream::AliTRDrawStream(AliRawReader *rawReader) :
 125   fStats(),
 126   fStoreError(&AliTRDrawStream::StoreErrorTree),
 127   fRawReader(rawReader),
 128   fDigitsManager(0x0),
 129   fDigitsParam(0x0),
 130   fErrors(0x0),
 131   fLastError(),
 132   fErrorFlags(0),
 133   fPayloadStart(0x0),
 134   fPayloadCurr(0x0),
 135   fPayloadSize(0),
 136   fNtimebins(-1),
 137   fLastEvId(-1),
 138   fCurrSlot(-1),
 139   fCurrLink(-1),
 140   fCurrRobPos(-1),
 141   fCurrMcmPos(-1),
 142   fCurrEquipmentId(0),
 143   fCurrSmuIndexHeaderSize(0),
 144   fCurrSmuIndexHeaderVersion(0),
 145   fCurrTrackEnable(0),
 146   fCurrTrackletEnable(0),
 147   fCurrStackMask(0),
 148   fCurrStackIndexWord(0x0),
 149   fCurrStackHeaderSize(0x0),
 150   fCurrStackHeaderVersion(0x0),
 151   fCurrLinkMask(0x0),
 152   fCurrCleanCheckout(0x0),
 153   fCurrBoardId(0x0),
 154   fCurrHwRev(0x0),
 155   fCurrLinkMonitorFlags(0x0),
 156   fCurrLinkDataTypeFlags(0x0),
 157   fCurrLinkDebugFlags(0x0),
 158   fCurrSpecial(-1),
 159   fCurrMajor(-1),
 160   fCurrMinor(-1),
 161   fCurrAddHcWords(-1),
 162   fCurrSm(-1),
 163   fCurrStack(-1),
 164   fCurrLayer(-1),
 165   fCurrSide(-1),
 166   fCurrHC(-1),
 167   fCurrCheck(-1),
 168   fCurrNtimebins(-1),
 169   fCurrBC(-1),
 170   fCurrPtrgCnt(-1),
 171   fCurrPtrgPhase(-1),
 172   fNDumpMCMs(0),
 173   fTrackletArray(0x0),
 174   fAdcArray(0x0),
 175   fSignalIndex(0x0),
 176   fTrackletTree(0x0),
 177   fTracklets(0x0),
 178   fTracks(0x0),
 179   fMarkers(0x0)
 180 {
 181   // default constructor
 182
 183   fCurrStackIndexWord     = new UInt_t[fgkNstacks];
 184   fCurrStackHeaderSize    = new UInt_t[fgkNstacks];
 185   fCurrStackHeaderVersion = new UInt_t[fgkNstacks];
 186   fCurrLinkMask           = new UInt_t[fgkNstacks];
 187   fCurrCleanCheckout      = new UInt_t[fgkNstacks];
 188   fCurrBoardId            = new UInt_t[fgkNstacks];
 189   fCurrHwRev              = new UInt_t[fgkNstacks];
 190   fCurrLinkMonitorFlags   = new UInt_t[fgkNstacks * fgkNlinks];
 191   fCurrLinkDataTypeFlags  = new UInt_t[fgkNstacks * fgkNlinks];
 192   fCurrLinkDebugFlags     = new UInt_t[fgkNstacks * fgkNlinks];
 193   for (Int_t i = 0; i < 100; i++)
 194     fDumpMCM[i] = 0;
 195
 196   // preparing TClonesArray
 197   fTrackletArray = new TClonesArray("AliTRDtrackletWord", 256);
 198
 199   // setting up the error tree
 200   fErrors = new TTree("errorStats", "Error statistics");
 201   fErrors->SetDirectory(0x0);
 202   fErrors->Branch("error", &fLastError);
 203   fErrors->SetCircular(1000);
 204 }
 205
 206 AliTRDrawStream::~AliTRDrawStream()
 207 {
 208   // destructor
 209
 210   delete fErrors;
 211
 212   delete [] fCurrStackIndexWord;
 213   delete [] fCurrStackHeaderSize;
 214   delete [] fCurrStackHeaderVersion;
 215   delete [] fCurrLinkMask;
 216   delete [] fCurrCleanCheckout;
 217   delete [] fCurrBoardId;
 218   delete [] fCurrHwRev;
 219   delete [] fCurrLinkMonitorFlags;
 220   delete [] fCurrLinkDataTypeFlags;
 221   delete [] fCurrLinkDebugFlags;
 222 }
 223
 224 Bool_t AliTRDrawStream::ReadEvent(TTree *trackletTree)
 225 {
 226   // read the current event from the raw reader and fill it to the digits manager
 227
 228   if (!fRawReader) {
 229     AliError("No raw reader available");
 230     return kFALSE;
 231   }
 232
 233   // tracklet output
 234   ConnectTracklets(trackletTree);
 235
 236   // some preparations
 237   fDigitsParam = 0x0;
 238
 239   // loop over all DDLs
 240   // data starts with GTU payload, i.e. SMU index word
 241   UChar_t *buffer = 0x0;
 242
 243   while (fRawReader->ReadNextData(buffer)) {
 244
 245     fCurrEquipmentId = fRawReader->GetEquipmentId();
 246     AliDebug(2, Form("equipment: %i", fCurrEquipmentId));
 247
 248     if (fCurrEquipmentId < 1024 || fCurrEquipmentId > 1041) {
 249       EquipmentError(kNonTrdEq, "Skipping");
 250       continue;
 251     }
 252
 253     // setting the pointer to data and current reading position
 254     fPayloadCurr = fPayloadStart = (UInt_t*) (buffer);
 255     fPayloadSize = fRawReader->GetDataSize() / sizeof(UInt_t);
 256     fStats.fStatsSector[fCurrEquipmentId - 1024].fBytes = fRawReader->GetDataSize();
 257     AliDebug(2, Form("Read buffer of size: %i", fRawReader->GetDataSize()));
 258
 259     // read SMU index header
 260     if (ReadSmHeader() < 0) {
 261       AliError(Form("Reading SMU header failed, skipping this DDL %i", fCurrEquipmentId));
 262       continue;
 263     }
 264
 265     // read stack index header
 266     for (Int_t iStack = 0; iStack < 5; iStack++) {
 267       if ((fCurrStackMask & (1 << iStack)) != 0)
 268         ReadStackIndexHeader(iStack);
 269     }
 270
 271     for (Int_t iStack = 0; iStack < 5; iStack++) {
 272       fCurrSlot = iStack;
 273       if ((fCurrStackMask & (1 << fCurrSlot)) == 0)
 274         continue;
 275
 276       AliDebug(2, Form("Stack %i, Link mask: 0x%02x", fCurrSlot, fCurrLinkMask[fCurrSlot]));
 277       for (Int_t iLink = 0; iLink < 12; iLink++) {
 278         fCurrLink = iLink;
 279         fCurrHC   = fCurrSm * 60 + fCurrSlot * 12 + iLink;
 280         if ((fCurrLinkMask[fCurrSlot] & (1 << fCurrLink)) == 0)
 281           continue;
 282
 283         fErrorFlags = 0;
 284         // check for link monitor error flag
 285         if (fCurrLinkMonitorFlags[fCurrSlot*fgkNlinks + fCurrLink] != 0)
 286           LinkError(kLinkMonitor);
 287
 288         // read the data from one HC
 289         ReadLinkData();
 290
 291         // read all data endmarkers
 292         SeekNextLink();
 293       }
 294     }
 295   }
 296   return kTRUE;
 297 }
 298
 299
 300 Bool_t AliTRDrawStream::NextDDL()
 301 {
 302   // continue reading with the next equipment
 303
 304   if (!fRawReader)
 305     return kFALSE;
 306
 307   fCurrEquipmentId = 0;
 308   fCurrSlot = 0;
 309   fCurrLink = 0;
 310
 311   UChar_t *buffer = 0x0;
 312
 313   while (fRawReader->ReadNextData(buffer)) {
 314
 315     fCurrEquipmentId = fRawReader->GetEquipmentId();
 316     AliDebug(2, Form("equipment: %i", fCurrEquipmentId));
 317
 318     if (fCurrEquipmentId < 1024 || fCurrEquipmentId > 1041) {
 319       EquipmentError(kNonTrdEq, "Skipping");
 320       continue;
 321     }
 322
 323     // setting the pointer to data and current reading position
 324     fPayloadCurr = fPayloadStart = (UInt_t*) (buffer);
 325     fPayloadSize = fRawReader->GetDataSize() / sizeof(UInt_t);
 326     AliDebug(2, Form("Read buffer of size: %i", fRawReader->GetDataSize()));
 327
 328     // read SMU index header
 329     if (ReadSmHeader() < 0) {
 330       AliError(Form("Reading SMU header failed, skipping this DDL %i", fCurrEquipmentId));
 331       continue;
 332     }
 333
 334     // read stack index header
 335     for (Int_t iStack = 0; iStack < 5; iStack++) {
 336       if ((fCurrStackMask & (1 << iStack)) != 0) {
 337         ReadStackIndexHeader(iStack);
 338       }
 339     }
 340     return kTRUE;
 341   }
 342
 343   return kFALSE;
 344 }
 345
 346
 347 Int_t AliTRDrawStream::NextChamber(AliTRDdigitsManager *digMgr, UInt_t ** /* trackletContainer */, UShort_t ** /* errorContainer */)
 348 {
 349   // read the data for the next chamber
 350   // in case you only want to read the data of a single chamber
 351   // to read all data ReadEvent(...) is recommended
 352
 353   fDigitsManager = digMgr;
 354   fDigitsParam   = 0x0;
 355
 356   fErrorFlags = 0;
 357
 358   // tracklet output preparation
 359   TTree *trklTree = 0x0;
 360   AliRunLoader *rl = AliRunLoader::Instance();
 361   AliLoader* trdLoader = rl ? rl->GetLoader("TRDLoader") : NULL;
 362   AliDataLoader *trklLoader = trdLoader ? trdLoader->GetDataLoader("tracklets") : NULL;
 363   if (trklLoader) {
 364     AliTreeLoader *trklTreeLoader = (AliTreeLoader*) trklLoader->GetBaseLoader("tracklets-raw");
 365     if (trklTreeLoader)
 366       trklTree = trklTreeLoader->Tree();
 367     else
 368       trklTree = trklLoader->Tree();
 369   }
 370
 371   if (fTrackletTree != trklTree)
 372     ConnectTracklets(trklTree);
 373
 374   if (!fRawReader) {
 375     AliError("No raw reader available");
 376     return -1;
 377   }
 378
 379   if (fCurrSlot < 0 || fCurrSlot >= 5) {
 380     if (!NextDDL()) {
 381       fCurrSlot = -1;
 382       return -1;
 383     }
 384   }
 385
 386   AliDebug(2, Form("Stack %i, Link %i, mask: 0x%02x", fCurrSlot, fCurrLink, fCurrLinkMask[fCurrSlot]));
 387   fCurrHC   = (fCurrEquipmentId - 1024) * 60 + fCurrSlot * 12 + fCurrLink;
 388
 389   if (fCurrLinkMonitorFlags[fCurrSlot*fgkNlinks + fCurrLink] != 0)
 390     LinkError(kLinkMonitor);
 391
 392   // read the data from one HC
 393   ReadLinkData();
 394
 395   // read all data endmarkers
 396   SeekNextLink();
 397
 398   if (fCurrLink % 2 == 0) {
 399     // if we just read the A-side HC then also check the B-side
 400     fCurrLink++;
 401     fCurrHC++;
 402     if (fCurrLinkMask[fCurrSlot] & (1 << fCurrLink)) {
 403       ReadLinkData();
 404       SeekNextLink();
 405     }
 406   }
 407
 408   //??? to check
 409   do {
 410     fCurrLink++;
 411     if (fCurrLink > 11) {
 412       fCurrLink = 0;
 413       fCurrSlot++;
 414     }
 415   } while ((fCurrSlot < 5) &&
 416            (((fCurrStackMask & (1 << fCurrSlot)) == 0) ||
 417             ((fCurrLinkMask[fCurrSlot] & (1 << fCurrLink))) == 0));
 418
 419   // return chamber information from HC if it is valid
 420   // otherwise return information from link position
 421   if (fCurrSm < 0 || fCurrSm > 17 || fCurrStack < 0 || fCurrStack > 4 || fCurrLayer < 0 || fCurrLayer > 5)
 422     return ((fCurrEquipmentId-1024) + fCurrSlot * 6 + fCurrLink/2);
 423   else
 424     return (fCurrSm * 30 + fCurrStack * 6 + fCurrLayer);
 425 }
 426
 427
 428 Int_t AliTRDrawStream::ReadSmHeader()
 429 {
 430   // read the SMU index header at the current reading position
 431   // and store the information in the corresponding variables
 432
 433   if (fPayloadCurr - fPayloadStart >= fPayloadSize - 1) {
 434     EquipmentError(kUnknown, "SM Header incomplete");
 435     return -1;
 436   }
 437
 438   fCurrSmuIndexHeaderSize     = ((*fPayloadCurr) >> 16) & 0xffff;
 439   fCurrSmuIndexHeaderVersion  = ((*fPayloadCurr) >> 12) &    0xf;
 440   //  fCurrSmuIndexHeaderTrgAvail = ((*fPayloadCurr) >>  9) &    0x1;
 441   //  fCurrSmuIndexHeaderEvType   = ((*fPayloadCurr) >>  7) &    0x3;
 442   fCurrTrackEnable            = ((*fPayloadCurr) >>  6) &    0x1;
 443   fCurrTrackletEnable         = ((*fPayloadCurr) >>  5) &    0x1;
 444   fCurrStackMask              = ((*fPayloadCurr)      ) &   0x1f;
 445
 446   AliDebug(5, Form("SMU header: size: %i, version: %i, track enable: %i, tracklet enable: %i, stack mask: %2x",
 447                    fCurrSmuIndexHeaderSize,
 448                    fCurrSmuIndexHeaderVersion,
 449                    fCurrTrackEnable,
 450                    fCurrTrackletEnable,
 451                    fCurrStackMask));
 452
 453   // decode GTU track words
 454   UInt_t trackWord[2];
 455   Int_t stack = 0;
 456   Int_t idx = 0;
 457   for (UInt_t iWord = 4; iWord < fCurrSmuIndexHeaderSize; iWord++) {
 458     if (fPayloadCurr[iWord] == 0x10000000) {
 459       stack++;
 460       idx = 0;
 461     }
 462     else {
 463       if ((idx == 0) &&
 464           ((fPayloadCurr[iWord] & 0xfffff0f0) == 0x13370000)) {
 465         AliDebug(1,Form("stack %i: fast trigger word: 0x%08x", stack, fPayloadCurr[iWord]));
 466         continue;
 467       }
 468       else if ((idx & 0x1)==0x1) {
 469         trackWord[idx&0x1] = fPayloadCurr[iWord];
 470         AliDebug(1,Form("track debug word: 0x%08x%08x", trackWord[1], trackWord[0]));
 471 //      if (fTracks)
 472 //        new ((*fTracks)[fTracks->GetEntriesFast()]) AliESDTrdTrack(0, 0, trackWord[0], trackWord[1], fCurrEquipmentId-1024);
 473       }
 474       else {
 475         trackWord[idx&0x1] = fPayloadCurr[iWord];
 476       }
 477       idx++;
 478     }
 479   }
 480
 481   fPayloadCurr += fCurrSmuIndexHeaderSize + 1;
 482
 483   return fCurrSmuIndexHeaderSize + 1;
 484 }
 485
 486 Int_t AliTRDrawStream::ReadStackIndexHeader(Int_t stack)
 487 {
 488   // read the stack index header
 489   // and store the information in the corresponding variables
 490
 491   fCurrStackIndexWord[stack]     = *fPayloadCurr;
 492   fCurrStackHeaderSize[stack]    = (((*fPayloadCurr) >> 16) & 0xffff) + 1;
 493   fCurrStackHeaderVersion[stack] = ((*fPayloadCurr) >> 12) & 0xf;
 494   fCurrLinkMask[stack]           = (*fPayloadCurr) & 0xfff;
 495
 496   if (fPayloadCurr - fPayloadStart >= fPayloadSize - (Int_t) fCurrStackHeaderSize[stack]) {
 497     StackError(kStackHeaderInvalid, "Stack index header aborted");
 498     return -1;
 499   }
 500
 501   switch (fCurrStackHeaderVersion[stack]) {
 502   case 0xa:
 503     if (fCurrStackHeaderSize[stack] < 8) {
 504       StackError(kStackHeaderInvalid, "Stack header smaller than expected!");
 505       return -1;
 506     }
 507
 508     fCurrCleanCheckout[stack] = fPayloadCurr[1] & 0x1;
 509     fCurrBoardId[stack]       = (fPayloadCurr[1] >> 8) & 0xff;
 510     fCurrHwRev[stack]         = (fPayloadCurr[1] >> 16) & 0xffff;
 511
 512     for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
 513       // A side
 514       fCurrLinkMonitorFlags  [stack*fgkNlinks + iLayer*2]      = fPayloadCurr[iLayer+2] & 0xf;
 515       fCurrLinkDataTypeFlags [stack*fgkNlinks + iLayer*2]      = (fPayloadCurr[iLayer+2] >> 4) & 0x3;
 516       fCurrLinkDebugFlags    [stack*fgkNlinks + iLayer*2]      = (fPayloadCurr[iLayer+2] >> 12) & 0xf;
 517       // B side
 518       fCurrLinkMonitorFlags  [stack*fgkNlinks + iLayer*2 + 1]  = (fPayloadCurr[iLayer+2] >> 16) & 0xf;
 519       fCurrLinkDataTypeFlags [stack*fgkNlinks + iLayer*2 + 1]  = (fPayloadCurr[iLayer+2] >> 20) & 0x3;
 520       fCurrLinkDebugFlags    [stack*fgkNlinks + iLayer*2 + 1]  = (fPayloadCurr[iLayer+2] >> 28) & 0xf;
 521     }
 522     break;
 523
 524   default:
 525     StackError(kStackHeaderInvalid, "Invalid Stack Index Header version %x", fCurrStackHeaderVersion[stack]);
 526   }
 527
 528   fPayloadCurr += fCurrStackHeaderSize[stack];
 529
 530   return fCurrStackHeaderSize[stack];
 531 }
 532
 533 Int_t AliTRDrawStream::ReadLinkData()
 534 {
 535   // read the data in one link (one HC) until the data endmarker is reached
 536   // returns the number of words read!
 537
 538   Int_t count = 0;
 539   UInt_t* startPosLink = fPayloadCurr;
 540
 541 //  printf("----- HC: %i -----\n", fCurrHC);
 542 //  for (Int_t i = 0; i < 3; i++) {
 543 //    printf("0x%08x 0x%08x 0x%08x 0x%08x\n",
 544 //         fPayloadCurr[i*4+0], fPayloadCurr[i*4+1], fPayloadCurr[i*4+2], fPayloadCurr[i*4+3]);
 545 //  }
 546
 547   if (fMarkers)
 548     new ((*fMarkers)[fMarkers->GetEntriesFast()])
 549       AliTRDrawStreamError(-kHCactive, fCurrSm, fCurrStack, fCurrLink);
 550
 551   if (fErrorFlags & kDiscardHC)
 552     return count;
 553
 554   count += ReadTracklets();
 555   if (fErrorFlags & kDiscardHC)
 556     return count;
 557
 558   count += ReadHcHeader();
 559   if (fErrorFlags & kDiscardHC)
 560     return count;
 561
 562   Int_t det = fCurrSm * 30 + fCurrStack * 6 + fCurrLayer;
 563
 564   if (det > -1 && det < 540) {
 565
 566     if ((fAdcArray = fDigitsManager->GetDigits(det))) {
 567       //fAdcArray->Expand();
 568       if (fAdcArray->GetNtime() != fCurrNtimebins)
 569         fAdcArray->Allocate(16, 144, fCurrNtimebins);
 570     }
 571     else {
 572       LinkError(kNoDigits);
 573     }
 574
 575     if (!fDigitsParam) {
 576       fDigitsParam = fDigitsManager->GetDigitsParam();
 577     }
 578     if (fDigitsParam) {
 579       fDigitsParam->SetPretriggerPhase(det, fCurrPtrgPhase);
 580       fDigitsParam->SetNTimeBins(det, fCurrNtimebins);
 581       fDigitsParam->SetADCbaseline(det, 10);
 582     }
 583
 584     if (fDigitsManager->UsesDictionaries()) {
 585       fDigitsManager->GetDictionary(det, 0)->Reset();
 586       fDigitsManager->GetDictionary(det, 1)->Reset();
 587       fDigitsManager->GetDictionary(det, 2)->Reset();
 588     }
 589
 590     if ((fSignalIndex = fDigitsManager->GetIndexes(det))) {
 591       fSignalIndex->SetSM(fCurrSm);
 592       fSignalIndex->SetStack(fCurrStack);
 593       fSignalIndex->SetLayer(fCurrLayer);
 594       fSignalIndex->SetDetNumber(det);
 595       if (!fSignalIndex->IsAllocated())
 596         fSignalIndex->Allocate(16, 144, fCurrNtimebins);
 597     }
 598
 599     // ----- check which kind of data -----
 600     if (fCurrMajor & 0x40) {
 601       if ((fCurrMajor & 0x7) == 0x7) {
 602         AliDebug(1, "This is a config event");
 603         UInt_t *startPos = fPayloadCurr;
 604         while (fPayloadCurr - fPayloadStart < fPayloadSize &&
 605                *fPayloadCurr != fgkDataEndmarker)
 606           fPayloadCurr++;
 607         count += fPayloadCurr - startPos;
 608
 609         // feeding TRAP config
 610         AliTRDtrapConfig *trapcfg = AliTRDtrapConfig::Instance();
 611         trapcfg->ReadPackedConfig(fCurrHC, startPos, fPayloadCurr - startPos);
 612       }
 613       else {
 614         Int_t tpmode = fCurrMajor & 0x7;
 615         AliDebug(1, Form("Checking testpattern (mode %i) data", tpmode));
 616         ReadTPData(tpmode);
 617       }
 618     }
 619     else if (fCurrMajor & 0x20) {
 620       AliDebug(1, "This is a zs event");
 621       count += ReadZSData();
 622     }
 623     else {
 624       AliDebug(1, "This is a nozs event");
 625       count += ReadNonZSData();
 626     }
 627   }
 628   else {
 629     LinkError(kInvalidDetector, "%i", det);
 630     while (fPayloadCurr - fPayloadStart < fPayloadSize &&
 631            *fPayloadCurr != fgkDataEndmarker)
 632       fPayloadCurr++;
 633   }
 634
 635   fStats.fStatsSector[fCurrSm].fStatsHC[fCurrHC%60].fBytes     += (fPayloadCurr - startPosLink) * sizeof(UInt_t);
 636   fStats.fStatsSector[fCurrSm].fStatsHC[fCurrHC%60].fBytesRead += count * sizeof(UInt_t);
 637   fStats.fStatsSector[fCurrSm].fBytesRead                      += count * sizeof(UInt_t);
 638   fStats.fBytesRead                                            += count * sizeof(UInt_t);
 639
 640   return count;
 641 }
 642
 643 Int_t AliTRDrawStream::ReadTracklets()
 644 {
 645   // read the tracklets from one HC
 646
 647   fTrackletArray->Clear();
 648
 649   UInt_t *start = fPayloadCurr;
 650   while (*(fPayloadCurr) != fgkTrackletEndmarker &&
 651          fPayloadCurr - fPayloadStart < fPayloadSize) {
 652
 653     new ((*fTrackletArray)[fTrackletArray->GetEntriesFast()]) AliTRDtrackletWord(*(fPayloadCurr), fCurrHC);
 654
 655     fPayloadCurr++;
 656   }
 657
 658   if (fTrackletArray->GetEntriesFast() > 0) {
 659     AliDebug(1, Form("Found %i tracklets in %i %i %i (ev. %i)", fTrackletArray->GetEntriesFast(),
 660                      fCurrSm, fCurrSlot, fCurrLink, fRawReader->GetEventIndex()));
 661     if (fCurrSm > -1 && fCurrSm < 18) {
 662       fStats.fStatsSector[fCurrSm].fStatsHC[fCurrHC%60].fNTracklets += fTrackletArray->GetEntriesFast();
 663       fStats.fStatsSector[fCurrSm].fNTracklets                      += fTrackletArray->GetEntriesFast();
 664     }
 665     if (fTrackletTree)
 666       fTrackletTree->Fill();
 667     if (fTracklets)
 668       for (Int_t iTracklet = 0; iTracklet < fTrackletArray->GetEntriesFast(); iTracklet++) {
 669         new ((*fTracklets)[fTracklets->GetEntriesFast()]) AliTRDtrackletWord(*((AliTRDtrackletWord*)(*fTrackletArray)[iTracklet]));
 670       }
 671   }
 672
 673   // loop over remaining tracklet endmarkers
 674   while ((*(fPayloadCurr) == fgkTrackletEndmarker &&
 675           fPayloadCurr - fPayloadStart < fPayloadSize))
 676     fPayloadCurr++;
 677
 678   return fPayloadCurr - start;
 679 }
 680
 681 Int_t AliTRDrawStream::ReadHcHeader()
 682 {
 683   // read and parse the HC header of one HC
 684   // and store the information in the corresponding variables
 685
 686   UInt_t *start = fPayloadCurr;
 687   // check not to be at the data endmarker
 688   if (*fPayloadCurr == fgkDataEndmarker)
 689     return 0;
 690
 691   fCurrSpecial    = (*fPayloadCurr >> 31) & 0x1;
 692   fCurrMajor      = (*fPayloadCurr >> 24) & 0x7f;
 693   fCurrMinor      = (*fPayloadCurr >> 17) & 0x7f;
 694   fCurrAddHcWords = (*fPayloadCurr >> 14) & 0x7;
 695   fCurrSm         = (*fPayloadCurr >> 9) & 0x1f;
 696   fCurrLayer      = (*fPayloadCurr >> 6) & 0x7;
 697   fCurrStack      = (*fPayloadCurr >> 3) & 0x7;
 698   fCurrSide       = (*fPayloadCurr >> 2) & 0x1;
 699   fCurrCheck      = (*fPayloadCurr) & 0x3;
 700
 701   if (fCurrSm != (((Int_t) fCurrEquipmentId) - 1024) ||
 702       fCurrStack != fCurrSlot ||
 703       fCurrLayer != fCurrLink / 2 ||
 704       fCurrSide != fCurrLink % 2) {
 705     LinkError(kHCmismatch,
 706               "HC: %i, %i, %i, %i\n 0x%08x 0x%08x 0x%08x 0x%08x",
 707               fCurrSm, fCurrStack, fCurrLayer, fCurrSide,
 708               fPayloadCurr[0], fPayloadCurr[1], fPayloadCurr[2], fPayloadCurr[3]);;
 709   }
 710   if (fCurrCheck != 0x1) {
 711     LinkError(kHCcheckFailed);
 712   }
 713
 714   if (fCurrAddHcWords > 0) {
 715     fCurrNtimebins = (fPayloadCurr[1] >> 26) & 0x3f;
 716     fCurrBC = (fPayloadCurr[1] >> 10) & 0xffff;
 717     fCurrPtrgCnt = (fPayloadCurr[1] >> 6) & 0xf;
 718     fCurrPtrgPhase = (fPayloadCurr[1] >> 2) & 0xf;
 719   }
 720
 721   fPayloadCurr += 1 + fCurrAddHcWords;
 722
 723   return (fPayloadCurr - start);
 724 }
 725
 726 Int_t AliTRDrawStream::ReadTPData(Int_t mode)
 727 {
 728   // testing of testpattern 1 to 3 (hardcoded), 0 missing
 729   // evcnt checking missing
 730   Int_t cpu = 0;
 731   Int_t cpufromchannel[] = {0, 0, 0, 0, 0,  1, 1, 1, 1, 1,  2, 2, 2, 2, 2,  3, 3, 3, 3, 3, 3};
 732   Int_t evcnt = 0;
 733   Int_t count = 0;
 734   Int_t mcmcount = -1;
 735   Int_t wordcount = 0;
 736   Int_t channelcount = 0;
 737   UInt_t expword = 0;
 738   UInt_t expadcval = 0;
 739   UInt_t diff = 0;
 740   Int_t lastmcmpos = -1;
 741   Int_t lastrobpos = -1;
 742
 743   UInt_t* start = fPayloadCurr;
 744
 745   while (*(fPayloadCurr) != fgkDataEndmarker &&
 746          fPayloadCurr - fPayloadStart < fPayloadSize - 1) {
 747
 748     // ----- Checking MCM Header -----
 749     AliDebug(2, Form("MCM header: 0x%08x", *fPayloadCurr));
 750     mcmcount++;
 751
 752     // ----- checking for proper readout order - ROB -----
 753     if (GetROBReadoutPos(ROB(*fPayloadCurr) / 2) >= lastrobpos) {
 754       lastrobpos = GetROBReadoutPos(ROB(*fPayloadCurr) / 2);
 755     }
 756     else {
 757       ROBError(kPosUnexp);
 758     }
 759     fCurrRobPos = ROB(*fPayloadCurr);
 760
 761     // ----- checking for proper readout order - MCM -----
 762     if (GetMCMReadoutPos(MCM(*fPayloadCurr)) >= (lastmcmpos + 1) % 16) {
 763       lastmcmpos = GetMCMReadoutPos(MCM(*fPayloadCurr));
 764     }
 765     else {
 766       MCMError(kPosUnexp);
 767     }
 768     fCurrMcmPos = MCM(*fPayloadCurr);
 769
 770
 771     fPayloadCurr++;
 772
 773     evcnt = 0x3f & *fPayloadCurr >> 26;
 774     cpu = -1;
 775     channelcount = 0;
 776     while (channelcount < 21) {
 777       count = 0;
 778       if (cpu != cpufromchannel[channelcount]) {
 779         cpu = cpufromchannel[channelcount];
 780         expadcval = (1 << 9) | (fCurrRobPos << 6) | (fCurrMcmPos << 2) | cpu;
 781         wordcount = 0;
 782       }
 783
 784       while (count < 10) {
 785         if (channelcount % 2 == 0)
 786           expword = 0x3;
 787         else
 788           expword = 0x2;
 789
 790         if (mode == 1) {
 791           // ----- TP 1 -----
 792           expword |= expadcval << 2;
 793           expadcval = ( (expadcval << 1) | ( ( (expadcval >> 9) ^ (expadcval >> 6) ) & 1) ) & 0x3FF;
 794           expword |= expadcval << 12;
 795           expadcval = ( (expadcval << 1) | ( ( (expadcval >> 9) ^ (expadcval >> 6) ) & 1) ) & 0x3FF;
 796           expword |= expadcval << 22;
 797           expadcval = ( (expadcval << 1) | ( ( (expadcval >> 9) ^ (expadcval >> 6) ) & 1) ) & 0x3FF;
 798         }
 799         else if (mode == 2) {
 800           // ----- TP 2 ------
 801           expword = ((0x3f & evcnt) << 26) | ((fCurrSm + 1) << 21) | ((fCurrLayer + 1) << 18) |
 802             ((fCurrStack + 1) << 15) |
 803             (fCurrRobPos << 12) | (fCurrMcmPos << 8) | (cpu << 6) | (wordcount + 1);
 804         }
 805         else if (mode == 3) {
 806           // ----- TP 3 -----
 807           expword = ((0xfff & evcnt) << 20) | (fCurrSm << 15) | (fCurrLink/2 << 12) | (fCurrStack << 9) |
 808             (fCurrRobPos << 6) | (fCurrMcmPos << 2) | (cpu << 0);
 809         }
 810         else {
 811           expword = 0;
 812           LinkError(kTPmodeInvalid, "Just reading");
 813         }
 814
 815         diff = *fPayloadCurr ^ expword;
 816         if (diff != 0) {
 817           MCMError(kTPmismatch,
 818                    "Seen 0x%08x, expected 0x%08x, diff: 0x%08x (0x%02x)",
 819                    *fPayloadCurr, expword, diff, 0xff & (diff | diff >> 8 | diff >> 16 | diff >> 24));;
 820         }
 821         fPayloadCurr++;
 822         count++;
 823         wordcount++;
 824       }
 825       channelcount++;
 826     }
 827     // continue with next MCM
 828   }
 829   return fPayloadCurr - start;
 830 }
 831
 832
 833 Int_t AliTRDrawStream::ReadZSData()
 834 {
 835   // read the zs data from one link from the current reading position
 836
 837   UInt_t *start = fPayloadCurr;
 838
 839   Int_t mcmcount = 0;
 840   Int_t mcmcountExp = fCurrStack == 2 ? 48 : 64;
 841   Int_t channelcount = 0;
 842   Int_t channelcountExp = 0;
 843   Int_t channelcountMax = 0;
 844   Int_t timebins;
 845   Int_t currentTimebin = 0;
 846   Int_t adcwc = 0;
 847   Int_t evno = -1;
 848   Int_t lastmcmpos = -1;
 849   Int_t lastrobpos = -1;
 850
 851   if (fCurrNtimebins != fNtimebins) {
 852     if (fNtimebins > 0)
 853       LinkError(kNtimebinsChanged,
 854                 "No. of timebins changed from %i to %i", fNtimebins, fCurrNtimebins);
 855     fNtimebins = fCurrNtimebins;
 856   }
 857
 858   timebins = fNtimebins;
 859
 860   while (*(fPayloadCurr) != fgkDataEndmarker &&
 861          fPayloadCurr - fPayloadStart < fPayloadSize) {
 862
 863     // ----- Checking MCM Header -----
 864     AliDebug(2, Form("MCM header: 0x%08x", *fPayloadCurr));
 865     UInt_t *startPosMCM = fPayloadCurr;
 866
 867     // ----- checking for proper readout order - ROB -----
 868     if (GetROBReadoutPos(ROB(*fPayloadCurr) / 2) >= lastrobpos) {
 869       lastrobpos = GetROBReadoutPos(ROB(*fPayloadCurr) / 2);
 870     }
 871     else {
 872       ROBError(kPosUnexp);
 873     }
 874     fCurrRobPos = ROB(*fPayloadCurr);
 875
 876     // ----- checking for proper readout order - MCM -----
 877     if (GetMCMReadoutPos(MCM(*fPayloadCurr)) > lastmcmpos) {
 878       lastmcmpos = GetMCMReadoutPos(lastmcmpos);
 879     }
 880     else {
 881       MCMError(kPosUnexp);
 882     }
 883     fCurrMcmPos = MCM(*fPayloadCurr);
 884
 885     if (EvNo(*fPayloadCurr) != evno) {
 886       if (evno == -1)
 887         evno = EvNo(*fPayloadCurr);
 888       else {
 889         MCMError(kPtrgCntMismatch, "%i <-> %i", evno, EvNo(*fPayloadCurr));
 890       }
 891     }
 892     Int_t adccoloff = AdcColOffset(*fPayloadCurr);
 893     Int_t padcoloff = PadColOffset(*fPayloadCurr);
 894     Int_t row = Row(*fPayloadCurr);
 895     fPayloadCurr++;
 896
 897     // ----- Reading ADC channels -----
 898     AliDebug(2, Form("ADC mask: 0x%08x", *fPayloadCurr));
 899
 900     // ----- analysing the ADC mask -----
 901     channelcount = 0;
 902     channelcountExp = GetNActiveChannelsFromMask(*fPayloadCurr);
 903     channelcountMax = GetNActiveChannels(*fPayloadCurr);
 904     Int_t channelmask = GetActiveChannels(*fPayloadCurr);
 905     Int_t channelno = -1;
 906     fPayloadCurr++;
 907
 908     if (channelcountExp != channelcountMax) {
 909       if (channelcountExp > channelcountMax) {
 910         Int_t temp = channelcountExp;
 911         channelcountExp = channelcountMax;
 912         channelcountMax = temp;
 913       }
 914       while (channelcountExp < channelcountMax && channelcountExp < 21 &&
 915              fPayloadCurr - fPayloadStart < fPayloadSize - 10 * channelcountExp - 1) {
 916         MCMError(kAdcMaskInconsistent,
 917                  "Possible MCM-H: 0x%08x, possible ADC-mask: 0x%08x",
 918                  *(fPayloadCurr + 10 * channelcountExp),
 919                  *(fPayloadCurr + 10 * channelcountExp + 1) );
 920         if (!CouldBeMCMhdr( *(fPayloadCurr + 10 * channelcountExp)) && !CouldBeADCmask( *(fPayloadCurr + 10 * channelcountExp + 1)))
 921           channelcountExp++;
 922         else {
 923           break;
 924         }
 925       }
 926       MCMError(kAdcMaskInconsistent,
 927                "Inconsistency in no. of active channels: Counter: %i, Mask: %i, chosen: %i!",
 928                GetNActiveChannels(fPayloadCurr[-1]), GetNActiveChannelsFromMask(fPayloadCurr[-1]), channelcountExp);
 929     }
 930     AliDebug(2, Form("expecting %i active channels, timebins: %i", channelcountExp, fCurrNtimebins));
 931
 932     // ----- reading marked ADC channels -----
 933     while (channelcount < channelcountExp && *(fPayloadCurr) != fgkDataEndmarker) {
 934       if (channelno < 20)
 935         channelno++;
 936       while (channelno < 20 && (channelmask & 1 << channelno) == 0)
 937         channelno++;
 938
 939       if (fCurrNtimebins > 30) {
 940         currentTimebin = ((*fPayloadCurr >> 2) & 0x3f);
 941         timebins = ((*fPayloadCurr >> 8) & 0xf) * 3;
 942       }
 943       else {
 944         currentTimebin = 0;
 945       }
 946
 947       adcwc = 0;
 948       AliDebug(2, Form("Now looking %i words", timebins / 3));
 949       Int_t adccol = adccoloff - channelno;
 950       Int_t padcol = padcoloff - channelno;
 951 //      if (adccol < 3 || adccol > 165)
 952 //      AliInfo(Form("writing channel %i of det %3i %i:%2i to adcrow/-col: %i/%i padcol: %i",
 953 //                   channelno, fCurrHC/2, fCurrRobPos, fCurrMcmPos, row, adccol, padcol));
 954
 955       while (adcwc < timebins / 3 &&
 956              *(fPayloadCurr) != fgkDataEndmarker &&
 957              fPayloadCurr - fPayloadStart < fPayloadSize) {
 958         int check = 0x3 & *fPayloadCurr;
 959         if (channelno % 2 != 0) { // odd channel
 960           if (check != 0x2 && channelno < 21) {
 961             MCMError(kAdcCheckInvalid,
 962                      "%i for %2i. ADC word in odd channel %i",
 963                      check, adcwc+1, channelno);
 964           }
 965         }
 966         else {                  // even channel
 967           if (check != 0x3 && channelno < 21) {
 968             MCMError(kAdcCheckInvalid,
 969                      "%i for %2i. ADC word in even channel %i",
 970                      check, adcwc+1, channelno);
 971           }
 972         }
 973
 974         // filling the actual timebin data
 975         int tb2 = 0x3ff & *fPayloadCurr >> 22;
 976         int tb1 = 0x3ff & *fPayloadCurr >> 12;
 977         int tb0 = 0x3ff & *fPayloadCurr >> 2;
 978         if (adcwc != 0 || fCurrNtimebins <= 30)
 979           fAdcArray->SetDataByAdcCol(row, adccol, currentTimebin++, tb0);
 980         else
 981           tb0 = -1;
 982         fAdcArray->SetDataByAdcCol(row, adccol, currentTimebin++, tb1);
 983         fAdcArray->SetDataByAdcCol(row, adccol, currentTimebin++, tb2);
 984
 985         adcwc++;
 986         fPayloadCurr++;
 987       }
 988
 989       if (adcwc != timebins / 3)
 990         MCMError(kAdcDataAbort);
 991
 992       // adding index
 993       if (padcol > 0 && padcol < 144) {
 994         fSignalIndex->AddIndexRC(row, padcol);
 995       }
 996
 997       channelcount++;
 998     }
 999
1000     fStats.fStatsSector[fCurrSm].fStatsHC[fCurrHC%60].fNChannels += channelcount;
1001     fStats.fStatsSector[fCurrSm].fNChannels                      += channelcount;
1002     if (channelcount != channelcountExp)
1003       MCMError(kAdcChannelsMiss);
1004
1005     mcmcount++;
1006     fStats.fStatsSector[fCurrSm].fStatsHC[fCurrHC%60].fNMCMs++;
1007     fStats.fStatsSector[fCurrSm].fNMCMs++;
1008
1009     if (IsDumping() && DumpingMCM(fCurrHC/2, fCurrRobPos, fCurrMcmPos)) {
1010       DumpRaw(Form("Event %i: Det %3i ROB %i MCM %2i", fRawReader->GetEventIndex(), fCurrHC/2, fCurrRobPos, fCurrMcmPos),
1011               startPosMCM, fPayloadCurr - startPosMCM);
1012     }
1013
1014     // continue with next MCM
1015   }
1016
1017   // check for missing MCMs (if header suppression is inactive)
1018   if (((fCurrMajor & 0x1) == 0) && (mcmcount != mcmcountExp)) {
1019     LinkError(kMissMcmHeaders,
1020               "No. of MCM headers %i not as expected: %i",
1021               mcmcount, mcmcountExp);
1022   }
1023
1024   return (fPayloadCurr - start);
1025 }
1026
1027 Int_t AliTRDrawStream::ReadNonZSData()
1028 {
1029   // read the non-zs data from one link from the current reading position
1030
1031   UInt_t *start = fPayloadCurr;
1032
1033   Int_t mcmcount = 0;
1034   Int_t mcmcountExp = fCurrStack == 2 ? 48 : 64;
1035   Int_t channelcount = 0;
1036   Int_t channelcountExp = 0;
1037   Int_t timebins;
1038   Int_t currentTimebin = 0;
1039   Int_t adcwc = 0;
1040   Int_t evno = -1;
1041   Int_t lastmcmpos = -1;
1042   Int_t lastrobpos = -1;
1043
1044   if (fCurrNtimebins != fNtimebins) {
1045     if (fNtimebins > 0)
1046       LinkError(kNtimebinsChanged,
1047                 "No. of timebins changed from %i to %i", fNtimebins, fCurrNtimebins);
1048     fNtimebins = fCurrNtimebins;
1049   }
1050
1051   timebins = fNtimebins;
1052
1053   while (*(fPayloadCurr) != fgkDataEndmarker &&
1054          fPayloadCurr - fPayloadStart < fPayloadSize - 2) {
1055
1056     // ----- Checking MCM Header -----
1057     AliDebug(2, Form("MCM header: 0x%08x", *fPayloadCurr));
1058
1059     // ----- checking for proper readout order - ROB -----
1060     if (GetROBReadoutPos(ROB(*fPayloadCurr) / 2) >= lastrobpos) {
1061       lastrobpos = GetROBReadoutPos(ROB(*fPayloadCurr) / 2);
1062     }
1063     else {
1064       ROBError(kPosUnexp);
1065     }
1066     fCurrRobPos = ROB(*fPayloadCurr);
1067
1068     // ----- checking for proper readout order - MCM -----
1069     if (GetMCMReadoutPos(MCM(*fPayloadCurr)) >= (lastmcmpos + 1) % 16) {
1070       lastmcmpos = GetMCMReadoutPos(*fPayloadCurr);
1071     }
1072     else {
1073       MCMError(kPosUnexp);
1074     }
1075     fCurrMcmPos = MCM(*fPayloadCurr);
1076
1077     if (EvNo(*fPayloadCurr) != evno) {
1078       if (evno == -1)
1079         evno = EvNo(*fPayloadCurr);
1080       else {
1081         MCMError(kPtrgCntMismatch, "%i <-> %i", evno, EvNo(*fPayloadCurr));
1082       }
1083     }
1084
1085     channelcount = 0;
1086     channelcountExp = 21;
1087     int channelno = -1;
1088
1089     Int_t adccoloff = AdcColOffset(*fPayloadCurr);
1090     Int_t padcoloff = PadColOffset(*fPayloadCurr);
1091     Int_t row = Row(*fPayloadCurr);
1092
1093     fPayloadCurr++;
1094
1095     // ----- reading marked ADC channels -----
1096     while (channelcount < channelcountExp &&
1097            *(fPayloadCurr) != fgkDataEndmarker) {
1098       if (channelno < 20)
1099         channelno++;
1100
1101       currentTimebin = 0;
1102
1103       adcwc = 0;
1104       AliDebug(2, Form("Now looking %i words", timebins / 3));
1105       Int_t adccol = adccoloff - channelno;
1106       Int_t padcol = padcoloff - channelno;
1107       while (adcwc < timebins / 3 &&
1108              *(fPayloadCurr) != fgkDataEndmarker &&
1109              fPayloadCurr - fPayloadStart < fPayloadSize) {
1110         int check = 0x3 & *fPayloadCurr;
1111         if (channelno % 2 != 0) { // odd channel
1112           if (check != 0x2 && channelno < 21) {
1113             MCMError(kAdcCheckInvalid,
1114                      "%i for %2i. ADC word in odd channel %i",
1115                      check, adcwc+1, channelno);
1116           }
1117         }
1118         else {                  // even channel
1119           if (check != 0x3 && channelno < 21) {
1120             MCMError(kAdcCheckInvalid,
1121                      "%i for %2i. ADC word in even channel %i",
1122                      check, adcwc+1, channelno);
1123           }
1124         }
1125
1126         // filling the actual timebin data
1127         int tb2 = 0x3ff & *fPayloadCurr >> 22;
1128         int tb1 = 0x3ff & *fPayloadCurr >> 12;
1129         int tb0 = 0x3ff & *fPayloadCurr >> 2;
1130         if (adcwc != 0 || fCurrNtimebins <= 30)
1131           fAdcArray->SetDataByAdcCol(row, adccol, currentTimebin++, tb0);
1132         else
1133           tb0 = -1;
1134         fAdcArray->SetDataByAdcCol(row, adccol, currentTimebin++, tb1);
1135         fAdcArray->SetDataByAdcCol(row, adccol, currentTimebin++, tb2);
1136
1137         adcwc++;
1138         fPayloadCurr++;
1139       }
1140
1141       if (adcwc != timebins / 3)
1142         MCMError(kAdcDataAbort);
1143
1144       // adding index
1145       if (padcol > 0 && padcol < 144) {
1146         fSignalIndex->AddIndexRC(row, padcol);
1147       }
1148
1149       channelcount++;
1150     }
1151
1152     if (channelcount != channelcountExp)
1153       MCMError(kAdcChannelsMiss);
1154     mcmcount++;
1155     // continue with next MCM
1156   }
1157
1158   // check for missing MCMs (if header suppression is inactive)
1159   if (mcmcount != mcmcountExp) {
1160     LinkError(kMissMcmHeaders,
1161               "%i not as expected: %i", mcmcount, mcmcountExp);
1162   }
1163
1164   return (fPayloadCurr - start);
1165 }
1166
1167 Int_t AliTRDrawStream::SeekNextLink()
1168 {
1169   UInt_t *start = fPayloadCurr;
1170
1171   // read until data endmarkers
1172   while (fPayloadCurr - fPayloadStart < fPayloadSize &&
1173          *fPayloadCurr != fgkDataEndmarker)
1174     fPayloadCurr++;
1175
1176   // read all data endmarkers
1177   while (fPayloadCurr - fPayloadStart < fPayloadSize &&
1178          *fPayloadCurr == fgkDataEndmarker)
1179     fPayloadCurr++;
1180
1181   return (fPayloadCurr - start);
1182 }
1183
1184 Bool_t AliTRDrawStream::ConnectTracklets(TTree *trklTree)
1185 {
1186   fTrackletTree = trklTree;
1187   if (!fTrackletTree)
1188     return kTRUE;
1189
1190   if (!fTrackletTree->GetBranch("hc"))
1191     fTrackletTree->Branch("hc", &fCurrHC, "hc/I");
1192   else
1193     fTrackletTree->SetBranchAddress("hc", &fCurrHC);
1194
1195   if (!fTrackletTree->GetBranch("trkl"))
1196     fTrackletTree->Branch("trkl", &fTrackletArray);
1197   else
1198     fTrackletTree->SetBranchAddress("trkl", &fTrackletArray);
1199
1200   return kTRUE;
1201 }
1202
1203
1204 void AliTRDrawStream::EquipmentError(ErrorCode_t err, const char *const msg, ...)
1205 {
1206   // register error according to error code on equipment level
1207   // and return the corresponding error message
1208
1209   fLastError.fSector = fCurrEquipmentId - 1024;
1210   fLastError.fStack  = -1;
1211   fLastError.fLink   = -1;
1212   fLastError.fRob    = -1;
1213   fLastError.fMcm    = -1;
1214   fLastError.fError  = err;
1215   (this->*fStoreError)();
1216
1217   va_list ap;
1218   if (fgErrorDebugLevel[err] > 10)
1219     AliDebug(fgErrorDebugLevel[err],
1220              Form("Event %6i: Eq. %2d - %s : %s",
1221                   fRawReader->GetEventIndex(), fCurrEquipmentId, fgErrorMessages[err],
1222                   (va_start(ap, msg), vsprintf(fErrorBuffer, msg, ap), va_end(ap), fErrorBuffer) ));
1223   else
1224     AliError(Form("Event %6i: Eq. %2d - %s : %s",
1225                   fRawReader->GetEventIndex(), fCurrEquipmentId, fgErrorMessages[err],
1226                   (va_start(ap, msg), vsprintf(fErrorBuffer, msg, ap), va_end(ap), fErrorBuffer) ));
1227   fErrorFlags |= fgErrorBehav[err];
1228 }
1229
1230
1231 void AliTRDrawStream::StackError(ErrorCode_t err, const char *const msg, ...)
1232 {
1233   // register error according to error code on stack level
1234   // and return the corresponding error message
1235
1236   fLastError.fSector = fCurrEquipmentId - 1024;
1237   fLastError.fStack  = fCurrSlot;
1238   fLastError.fLink   = -1;
1239   fLastError.fRob    = -1;
1240   fLastError.fMcm    = -1;
1241   fLastError.fError  = err;
1242   (this->*fStoreError)();
1243
1244   va_list ap;
1245   if (fgErrorDebugLevel[err] > 0)
1246     AliDebug(fgErrorDebugLevel[err],
1247              Form("Event %6i: Eq. %2d S %i - %s : %s",
1248                   fRawReader->GetEventIndex(), fCurrEquipmentId, fCurrSlot, fgErrorMessages[err],
1249                   (va_start(ap, msg), vsprintf(fErrorBuffer, msg, ap), va_end(ap), fErrorBuffer) ));
1250   else
1251     AliError(Form("Event %6i: Eq. %2d S %i - %s : %s",
1252                   fRawReader->GetEventIndex(), fCurrEquipmentId, fCurrSlot, fgErrorMessages[err],
1253                   (va_start(ap, msg), vsprintf(fErrorBuffer, msg, ap), va_end(ap), fErrorBuffer) ));
1254   fErrorFlags |= fgErrorBehav[err];
1255 }
1256
1257
1258 void AliTRDrawStream::LinkError(ErrorCode_t err, const char *const msg, ...)
1259 {
1260   // register error according to error code on link level
1261   // and return the corresponding error message
1262
1263   fLastError.fSector = fCurrEquipmentId - 1024;
1264   fLastError.fStack  = fCurrSlot;
1265   fLastError.fLink   = fCurrLink;
1266   fLastError.fRob    = -1;
1267   fLastError.fMcm    = -1;
1268   fLastError.fError  = err;
1269   (this->*fStoreError)();
1270
1271   va_list ap;
1272   if (fgErrorDebugLevel[err] > 0)
1273     AliDebug(fgErrorDebugLevel[err],
1274              Form("Event %6i: Eq. %2d S %i l %2i - %s : %s",
1275                   fRawReader->GetEventIndex(), fCurrEquipmentId, fCurrSlot, fCurrLink, fgErrorMessages[err],
1276                   (va_start(ap, msg), vsprintf(fErrorBuffer, msg, ap), va_end(ap), fErrorBuffer) ));
1277   else
1278     AliError(Form("Event %6i: Eq. %2d S %i l %2i - %s : %s",
1279                   fRawReader->GetEventIndex(), fCurrEquipmentId, fCurrSlot, fCurrLink, fgErrorMessages[err],
1280                   (va_start(ap, msg), vsprintf(fErrorBuffer, msg, ap), va_end(ap), fErrorBuffer) ));
1281   fErrorFlags |= fgErrorBehav[err];
1282 }
1283
1284
1285 void AliTRDrawStream::ROBError(ErrorCode_t err, const char *const msg, ...)
1286 {
1287   // register error according to error code on ROB level
1288   // and return the corresponding error message
1289
1290   fLastError.fSector = fCurrEquipmentId - 1024;
1291   fLastError.fStack  = fCurrSlot;
1292   fLastError.fLink   = fCurrLink;
1293   fLastError.fRob    = fCurrRobPos;
1294   fLastError.fMcm    = -1;
1295   fLastError.fError  = err;
1296   (this->*fStoreError)();
1297
1298   va_list ap;
1299   if (fgErrorDebugLevel[err] > 0)
1300     AliDebug(fgErrorDebugLevel[err],
1301              Form("Event %6i: Eq. %2d S %i l %2i ROB %i - %s : %s",
1302                   fRawReader->GetEventIndex(), fCurrEquipmentId, fCurrSlot, fCurrLink, fCurrRobPos, fgErrorMessages[err],
1303                   (va_start(ap, msg), vsprintf(fErrorBuffer, msg, ap), va_end(ap), fErrorBuffer) ));
1304   else
1305     AliError(Form("Event %6i: Eq. %2d S %i l %2i ROB %i - %s : %s",
1306                   fRawReader->GetEventIndex(), fCurrEquipmentId, fCurrSlot, fCurrLink, fCurrRobPos, fgErrorMessages[err],
1307                   (va_start(ap, msg), vsprintf(fErrorBuffer, msg, ap), va_end(ap), fErrorBuffer) ));
1308   fErrorFlags |= fgErrorBehav[err];
1309 }
1310
1311
1312 void AliTRDrawStream::MCMError(ErrorCode_t err, const char *const msg, ...)
1313 {
1314   // register error according to error code on MCM level
1315   // and return the corresponding error message
1316
1317   fLastError.fSector = fCurrEquipmentId - 1024;
1318   fLastError.fStack  = fCurrSlot;
1319   fLastError.fLink   = fCurrLink;
1320   fLastError.fRob    = fCurrRobPos;
1321   fLastError.fMcm    = fCurrMcmPos;
1322   fLastError.fError  = err;
1323   (this->*fStoreError)();
1324
1325   va_list ap;
1326   if (fgErrorDebugLevel[err] > 0)
1327     AliDebug(fgErrorDebugLevel[err],
1328              Form("Event %6i: Eq. %2d S %i l %2i ROB %i MCM %2i - %s : %s",
1329                   fRawReader->GetEventIndex(), fCurrEquipmentId, fCurrSlot, fCurrLink, fCurrRobPos, fCurrMcmPos, fgErrorMessages[err],
1330                   (va_start(ap, msg), vsprintf(fErrorBuffer, msg, ap), va_end(ap), fErrorBuffer) ));
1331   else
1332     AliError(Form("Event %6i: Eq. %2d S %i l %2i ROB %i MCM %2i - %s : %s",
1333                   fRawReader->GetEventIndex(), fCurrEquipmentId, fCurrSlot, fCurrLink, fCurrRobPos, fCurrMcmPos, fgErrorMessages[err],
1334                   (va_start(ap, msg), vsprintf(fErrorBuffer, msg, ap), va_end(ap), fErrorBuffer) ));
1335   fErrorFlags |= fgErrorBehav[err];
1336 }
1337
1338 const char* AliTRDrawStream::GetErrorMessage(ErrorCode_t errCode)
1339 {
1340   // return the error message for the given error code
1341
1342   if (errCode > 0 && errCode < kLastErrorCode)
1343     return fgErrorMessages[errCode];
1344   else
1345     return "";
1346 }
1347
1348 void AliTRDrawStream::AliTRDrawStats::ClearStats()
1349 {
1350   // clear statistics (includes clearing sector-wise statistics)
1351
1352   fBytesRead = 0;
1353   for (Int_t iSector = 0; iSector < 18; iSector++) {
1354     fStatsSector[iSector].ClearStats();
1355   }
1356
1357 }
1358
1359 void AliTRDrawStream::AliTRDrawStats::AliTRDrawStatsSector::ClearStats()
1360 {
1361   // clear statistics (includes clearing HC-wise statistics)
1362
1363   fBytes = 0;
1364   fBytesRead = 0;
1365   fNTracklets = 0;
1366   fNMCMs = 0;
1367   fNChannels = 0;
1368
1369   for (Int_t iHC = 0; iHC < 60; iHC++) {
1370     fStatsHC[iHC].ClearStats();
1371   }
1372 }
1373
1374 void AliTRDrawStream::AliTRDrawStats::AliTRDrawStatsSector::AliTRDrawStatsHC::ClearStats()
1375 {
1376   // clear statistics
1377
1378   fBytes = 0;
1379   fBytesRead = 0;
1380   fNTracklets = 0;
1381   fNMCMs = 0;
1382   fNChannels = 0;
1383 }
1384
1385 void AliTRDrawStream::SetDumpMCM(Int_t det, Int_t rob, Int_t mcm, Bool_t dump)
1386 {
1387   // mark MCM for dumping of raw data
1388
1389   if (dump) {
1390     fDumpMCM[fNDumpMCMs++] = (det << 7) | (rob << 4) | mcm;
1391   }
1392   else {
1393     Int_t iMCM;
1394     for (iMCM = 0; iMCM < fNDumpMCMs; iMCM++) {
1395       if (fDumpMCM[iMCM] == ((det << 7) | (rob << 4) | mcm)) {
1396         fNDumpMCMs--;
1397         break;
1398       }
1399     }
1400     for ( ; iMCM < fNDumpMCMs; iMCM++) {
1401       fDumpMCM[iMCM] = fDumpMCM[iMCM+1];
1402     }
1403   }
1404 }
1405
1406 Bool_t AliTRDrawStream::DumpingMCM(Int_t det, Int_t rob, Int_t mcm)
1407 {
1408   // check if MCM data should be dumped
1409
1410   for (Int_t iMCM = 0; iMCM < fNDumpMCMs; iMCM++) {
1411     if (fDumpMCM[iMCM] == ((det << 7) | (rob << 4) | mcm)) {
1412       return kTRUE;
1413     }
1414   }
1415   return kFALSE;
1416 }
1417
1418 void AliTRDrawStream::DumpRaw(TString title, UInt_t *start, Int_t length)
1419 {
1420   // dump raw data
1421
1422   title += "\n";
1423   Int_t pos = 0;
1424   for ( ; pos+3 < length; pos += 4) {
1425     title += Form("0x%08x 0x%08x 0x%08x 0x%08x\n",
1426                   start[pos+0], start[pos+1], start[pos+2], start[pos+3]);
1427   }
1428   for ( ; pos < length; pos++) {
1429     title += Form("0x%08x ", start[pos]);
1430   }
1431   AliInfo(title);
1432 }
1433
1434 AliTRDrawStream::AliTRDrawStreamError::AliTRDrawStreamError(Int_t error, Int_t sector, Int_t stack, Int_t link, Int_t rob, Int_t mcm) :
1435   fError(error),
1436   fSector(sector),
1437   fStack(stack),
1438   fLink(link),
1439   fRob(rob),
1440   fMcm(mcm)
1441 {
1442   // ctor
1443
1444 }