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