TRD/AliTRDRawStreamV2.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 /* $Id$ */
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 //                                                                           //
  20 // This class provides access to TRD digits in raw data.                     //
  21 //                                                                           //
  22 // It loops over all TRD digits in the raw data given by the AliRawReader.   //
  23 // The Next method goes to the next digit. If there are no digits left       //
  24 // it returns kFALSE.                                                        //
  25 // Several getters provide information about the current digit.              //
  26 //                                                                           //
  27 // Author: C. Lippmann (C.Lippmann@gsi.de)                                   //
  28 //                                                                           //
  29 ///////////////////////////////////////////////////////////////////////////////
  30
  31 #include "AliLog.h"
  32 #include "AliRawReader.h"
  33
  34 #include "AliTRDRawStreamV2.h"
  35 #include "AliTRDgeometry.h"
  36 #include "AliTRDcalibDB.h"
  37 #include "AliTRDfeeParam.h"
  38 #include "AliTRDdigitsManager.h"
  39 #include "AliTRDdataArrayI.h"
  40 #include "AliTRDdataArrayS.h"
  41 #include "AliTRDSignalIndex.h"
  42
  43 ClassImp(AliTRDRawStreamV2)
  44
  45 //_____________________________________________________________________________
  46 AliTRDRawStreamV2::AliTRDRawStreamV2()
  47   :AliTRDrawStreamBase()
  48 //  :TObject()
  49   ,fGeo(NULL)
  50   ,fSig()
  51   ,fADC(0)
  52   ,fTB(0)
  53   ,fEv(0)
  54   ,fROB(0)
  55   ,fMCM(0)
  56   ,fSM(0)
  57   ,fLAYER(0)
  58   ,fSTACK(0)
  59   ,fROC(0)
  60   ,fSIDE(0)
  61   ,fDCS(0)
  62   ,fROW(0)
  63   ,fCOL(0)
  64   ,fDET(0)
  65   ,fLastDET(-1)
  66   ,fBCctr(0)
  67   ,fPTctr(0)
  68   ,fPTphase(0)
  69   ,fRVmajor(0)
  70   ,fRVminor(0)
  71   ,fHCHWords(0)
  72   ,fTBins(0)
  73   ,fTCon(0)
  74   ,fPEDon(0)
  75   ,fGAINon(0)
  76   ,fXTon(0)
  77   ,fNonLinOn(0)
  78   ,fBypass(0)
  79   ,fCommonAdditive(0)
  80   ,fZeroSuppressed(0)
  81   ,fHCHctr1(0)
  82   ,fHCHctr2(0)
  83   ,fMCMHctr1(0)
  84   ,fMCMHctr2(0)
  85   ,fGTUctr1(0)
  86   ,fGTUctr2(0)
  87   ,fHCdataCtr(0)
  88   ,fTracklPID(0.)
  89   ,fTracklDefL(0.)
  90   ,fTracklPadPos(0.)
  91   ,fTracklPadRow(0)
  92   ,fGTUlinkMask()
  93   ,fMCMWordCrt(0)
  94   ,fMCMWordsExpected(0)
  95   ,fRawReader(NULL)
  96   ,fRawVersion(2)
  97   ,fRawDigitThreshold(0)
  98   ,fNextStatus(0)
  99   ,fLastStatus(0)
 100   ,fTbSwitch(0)
 101   ,fTbSwitchCtr(0)
 102   ,fTimeWords(0)
 103   ,fWordCtr(0)
 104   ,fRowMax(0)
 105   ,fColMax(0)
 106   ,fADCmask()
 107   ,fLastADCmask(0)
 108   ,fChamberDone()
 109   ,fRetVal(0)
 110   ,fEqID(0)
 111   ,fDataSize(0)
 112   ,fSizeOK(kFALSE)
 113   ,fCountBytes(0)
 114   ,fBufSize(0)
 115   ,fkBufferSet(kFALSE)
 116   ,fPos(NULL)
 117   ,fDataWord(NULL)
 118   ,fTimeBinsCalib(0)
 119   ,fADClookup()
 120   ,fNActiveADCs(0)
 121   ,fEndOfDataFlag(kFALSE)
 122 {
 123   //
 124   // Default constructor
 125   //
 126
 127   for (Int_t i = 0; i < 540; i++) {
 128     fChamberDone[i] = 0;
 129   }
 130
 131 }
 132
 133 //_____________________________________________________________________________
 134 AliTRDRawStreamV2::AliTRDRawStreamV2(AliRawReader *rawReader)
 135   :AliTRDrawStreamBase(rawReader)
 136 //  :TObject()
 137   ,fGeo(NULL)
 138   ,fADC(0)
 139   ,fTB(0)
 140   ,fEv(0)
 141   ,fROB(0)
 142   ,fMCM(0)
 143   ,fSM(0)
 144   ,fLAYER(0)
 145   ,fSTACK(0)
 146   ,fROC(0)
 147   ,fSIDE(0)
 148   ,fDCS(0)
 149   ,fROW(0)
 150   ,fCOL(0)
 151   ,fDET(0)
 152   ,fLastDET(-1)
 153   ,fBCctr(0)
 154   ,fPTctr(0)
 155   ,fPTphase(0)
 156   ,fRVmajor(0)
 157   ,fRVminor(0)
 158   ,fHCHWords(0)
 159   ,fTBins(0)
 160   ,fTCon(0)
 161   ,fPEDon(0)
 162   ,fGAINon(0)
 163   ,fXTon(0)
 164   ,fNonLinOn(0)
 165   ,fBypass(0)
 166   ,fCommonAdditive(0)
 167   ,fZeroSuppressed(0)
 168   ,fHCHctr1(0)
 169   ,fHCHctr2(0)
 170   ,fMCMHctr1(0)
 171   ,fMCMHctr2(0)
 172   ,fGTUctr1(0)
 173   ,fGTUctr2(0)
 174   ,fHCdataCtr(0)
 175   ,fTracklPID(0.)
 176   ,fTracklDefL(0.)
 177   ,fTracklPadPos(0.)
 178   ,fTracklPadRow(0)
 179   ,fGTUlinkMask()
 180   ,fMCMWordCrt(0)
 181   ,fMCMWordsExpected(0)
 182   ,fRawReader(rawReader)
 183   ,fRawVersion(2)
 184   ,fRawDigitThreshold(0)
 185   ,fNextStatus(0)
 186   ,fLastStatus(0)
 187   ,fTbSwitch(0)
 188   ,fTbSwitchCtr(0)
 189   ,fTimeWords(0)
 190   ,fWordCtr(0)
 191   ,fRowMax(0)
 192   ,fColMax(0)
 193   ,fADCmask()
 194   ,fLastADCmask(0)
 195   ,fChamberDone()
 196   ,fRetVal(0)
 197   ,fEqID(0)
 198   ,fDataSize(0)
 199   ,fSizeOK(kFALSE)
 200   ,fCountBytes(0)
 201   ,fBufSize(0)
 202   ,fkBufferSet(kFALSE)
 203   ,fPos(NULL)
 204   ,fDataWord(NULL)
 205   ,fTimeBinsCalib(0)
 206   ,fADClookup()
 207   ,fNActiveADCs(0)
 208   ,fEndOfDataFlag(kFALSE)
 209 {
 210   //
 211   // Create an object to read TRD raw digits
 212   //
 213
 214   fRawReader->Select("TRD");
 215
 216   for (Int_t i = 0; i < 540; i++) {
 217     fChamberDone[i] = 0;
 218   }
 219
 220 }
 221
 222 //_____________________________________________________________________________
 223 AliTRDRawStreamV2::AliTRDRawStreamV2(const AliTRDRawStreamV2& stream)
 224   :AliTRDrawStreamBase(stream)
 225 //  :TObject()
 226   ,fGeo(NULL)
 227   ,fSig()
 228   ,fADC(-1)
 229   ,fTB(-1)
 230   ,fEv(-1)
 231   ,fROB(-1)
 232   ,fMCM(-1)
 233   ,fSM(-1)
 234   ,fLAYER(-1)
 235   ,fSTACK(-1)
 236   ,fROC(-1)
 237   ,fSIDE(-1)
 238   ,fDCS(-1)
 239   ,fROW(-1)
 240   ,fCOL(-1)
 241   ,fDET(0)
 242   ,fLastDET(-1)
 243   ,fBCctr(-1)
 244   ,fPTctr(-1)
 245   ,fPTphase(-1)
 246   ,fRVmajor(-1)
 247   ,fRVminor(-1)
 248   ,fHCHWords(-1)
 249   ,fTBins(-1)
 250   ,fTCon(0)
 251   ,fPEDon(0)
 252   ,fGAINon(0)
 253   ,fXTon(0)
 254   ,fNonLinOn(-1)
 255   ,fBypass(-1)
 256   ,fCommonAdditive(-1)
 257   ,fZeroSuppressed(0)
 258   ,fHCHctr1(-1)
 259   ,fHCHctr2(-1)
 260   ,fMCMHctr1(-1)
 261   ,fMCMHctr2(-1)
 262   ,fGTUctr1(-1)
 263   ,fGTUctr2(-1)
 264   ,fHCdataCtr(-1)
 265   ,fTracklPID(-1.)
 266   ,fTracklDefL(-1.)
 267   ,fTracklPadPos(-1.)
 268   ,fTracklPadRow(-1)
 269   ,fGTUlinkMask()
 270   ,fMCMWordCrt(0)
 271   ,fMCMWordsExpected(0)
 272   ,fRawReader(NULL)
 273   ,fRawVersion(-1)
 274   ,fRawDigitThreshold(0)
 275   ,fNextStatus(0)
 276   ,fLastStatus(0)
 277   ,fTbSwitch(0)
 278   ,fTbSwitchCtr(0)
 279   ,fTimeWords(0)
 280   ,fWordCtr(0)
 281   ,fRowMax(-1)
 282   ,fColMax(-1)
 283   ,fADCmask()
 284   ,fLastADCmask(0)
 285   ,fChamberDone()
 286   ,fRetVal(0)
 287   ,fEqID(0)
 288   ,fDataSize(0)
 289   ,fSizeOK(kFALSE)
 290   ,fCountBytes(0)
 291   ,fBufSize(0)
 292   ,fkBufferSet(kFALSE)
 293   ,fPos(NULL)
 294   ,fDataWord(NULL)
 295   ,fTimeBinsCalib(0)
 296   ,fADClookup()
 297   ,fNActiveADCs(0)
 298   ,fEndOfDataFlag(kFALSE)
 299 {
 300   //
 301   // Copy constructor
 302   //
 303
 304   AliFatal("Copy constructor not implemented");
 305
 306 }
 307
 308 //_____________________________________________________________________________
 309 AliTRDRawStreamV2& AliTRDRawStreamV2::operator = (const AliTRDRawStreamV2&
 310                                               /* stream */)
 311 {
 312   //
 313   // Assigment operator
 314   //
 315
 316   Fatal("operator =", "assignment operator not implemented");
 317   return *this;
 318
 319 }
 320
 321 //_____________________________________________________________________________
 322 AliTRDRawStreamV2::~AliTRDRawStreamV2()
 323 {
 324   //
 325   // Destructor
 326   //
 327
 328   if (fGeo) {
 329     delete fGeo;
 330   }
 331
 332 }
 333
 334 //_____________________________________________________________________________
 335 void AliTRDRawStreamV2::SetRawReader(AliRawReader *rawReader)
 336 {
 337   //
 338   // Set the rawreader
 339   //
 340
 341   if (rawReader)
 342     {
 343       fRawReader = rawReader;
 344     }
 345 }
 346
 347 //_____________________________________________________________________________
 348 Bool_t AliTRDRawStreamV2::SetRawVersion(Int_t rv)
 349 {
 350   //
 351   // Set the raw data version
 352   //
 353
 354   if ( rv >= 0 && rv <= 3 ) {
 355     fRawVersion = rv;
 356     return kTRUE;
 357   }
 358
 359   return kFALSE;
 360
 361 }
 362
 363 //____________________________________________________________________________
 364 Bool_t AliTRDRawStreamV2::Init()
 365 {
 366   //
 367   // Initialization
 368   //
 369
 370   if (!AliTRDcalibDB::Instance()) {
 371     AliError("Could not get calibration object");
 372     return kFALSE;
 373   }
 374
 375   if (!fGeo) {
 376     fGeo = new AliTRDgeometry();
 377   }
 378
 379   fTimeBinsCalib = AliTRDcalibDB::Instance()->GetNumberOfTimeBins();
 380   //AliDebug(2, Form("Number of Timebins read from CDB: %d", fTimeBinsCalib));
 381
 382   // The number of data words needed for this number of time bins (there
 383   // are 3 time bins in one word)
 384   fTimeWords = (fTimeBinsCalib-1)/3 + 1;
 385
 386   fTbSwitch    = 3;
 387   fTbSwitchCtr = 0;
 388
 389   fHCHctr1 = fHCHctr2 =  0;
 390   fGTUctr1 = fGTUctr2 = -1;
 391
 392   fHCdataCtr = 0;
 393   fWordCtr   = 0;
 394
 395   fDET     = 0;
 396   fLastDET     = -1;
 397   fRetVal = 0;
 398   fEqID     = 0;
 399   fDataSize = 0;
 400   fSizeOK = kFALSE;
 401
 402   fLastStatus = kStart;
 403   fNextStatus = kStart;
 404
 405   fCountBytes = 0;
 406   fBufSize = 0;
 407   fDataWord = NULL;
 408   fPos = NULL;
 409   fWordCtr = 0;
 410   fkBufferSet = kFALSE;
 411
 412   fMCMWordCrt = 0;
 413   fMCMWordsExpected = 0;
 414
 415   fEndOfDataFlag = kFALSE;
 416   // set all ADC active
 417   // should be 1111 1111 1111 1111 1111 1 = 21 bits active (0-20)
 418   fNActiveADCs = ChannelsToRead(0x1fffff);
 419
 420   fLastADCmask = 0;
 421
 422   return kTRUE;
 423 }
 424
 425 //____________________________________________________________________________
 426 void AliTRDRawStreamV2::SwapOnEndian()
 427 {
 428   //
 429   // Check the endian and swap if needed
 430   //
 431
 432   int itemp = 1;
 433   char* ptemp = (char*) &itemp;
 434   if (ptemp[0] != 1)
 435     {
 436       // need to swap...
 437       // assume we are at the begining of the buffer!
 438       //AliDebug(5, "Swapping.");
 439       UInt_t *pbegin = (UInt_t*)fPos;
 440       UInt_t iutmp = 0;
 441       for (UInt_t i = 0; i < fBufSize / fgkSizeWord; i++)
 442         {
 443           fDataWord = pbegin + i;
 444           iutmp = (((*fDataWord & 0x000000ffU) << 24) | ((*fDataWord & 0x0000ff00U) <<  8) |
 445                    ((*fDataWord & 0x00ff0000U) >>  8) | ((*fDataWord & 0xff000000U) >> 24));
 446           // here we override the value in the buffer!
 447           *fDataWord = iutmp;
 448         }
 449       fDataWord = pbegin;
 450     }
 451 }
 452 //____________________________________________________________________________
 453 Int_t AliTRDRawStreamV2::NextData()
 454 {
 455   //
 456   // Updates the next data word pointer
 457   //
 458
 459   if (fCountBytes + fgkSizeWord >= fBufSize)
 460     {
 461       fkBufferSet = fRawReader->ReadNextData(fPos);
 462       if (fkBufferSet == kTRUE)
 463         {
 464           fBufSize = fRawReader->GetDataSize();
 465           fCountBytes = 0;
 466           fDataWord = (UInt_t*)fPos;
 467           SwapOnEndian();
 468           ChangeStatus(kNextSM);
 469           fWordCtr = 0;
 470           return kNextSM;
 471         }
 472       else
 473         {
 474           ChangeStatus(kStop);
 475           return kNoMoreData;
 476         }
 477     }
 478   else
 479     {
 480       fPos += fgkSizeWord;
 481       fCountBytes += fgkSizeWord;
 482       fDataWord = (UInt_t*)fPos;
 483       fWordCtr++;
 484       return kWordOK;
 485     }
 486 }
 487
 488 //============================================================================
 489 // Decoding functions
 490 //============================================================================
 491
 492 //____________________________________________________________________________
 493 void AliTRDRawStreamV2::DecodeHCheader(Int_t timeBins)
 494 {
 495   //
 496   // Decode the HC header (fRawVersion == 2, 3, 4, ???)
 497   //
 498
 499   fRVmajor = (*fDataWord >> 24) & 0x7f;
 500   fRVminor = (*fDataWord >> 17) & 0x7f;
 501
 502   if (fRVmajor < 2 || fRVmajor > 4)
 503     AliError(Form(" Unsupported raw version: %d", fRawVersion))
 504
 505   if ( fRawVersion != fRVmajor ) {
 506
 507     AliWarning("===============================================================================");
 508     AliWarning(Form("Mismatch between fRawVersion (%d) and fRVmajor from HC header (%d)"
 509                     ,fRawVersion,fRVmajor));
 510     AliWarning(Form("Setting fRawVersion to %d", fRVmajor));
 511     AliWarning("===============================================================================");
 512     fRawVersion = fRVmajor;
 513
 514   }
 515
 516   //
 517   // check for zero suppression
 518   if ( fRawVersion >= 3 || fRawVersion <= 4 ) fZeroSuppressed = kTRUE;
 519   else                                        fZeroSuppressed = kFALSE;
 520
 521   // 1st word (h[0])
 522   if ( (*fDataWord & 0x3) == 1 ) {
 523
 524     fHCHWords = (*fDataWord >> 14) & 0x7;
 525     fSM       = (*fDataWord >>  9) & 0x1f;
 526     fLAYER    = (*fDataWord >>  6) & 0x7;
 527     fSTACK    = (*fDataWord >>  3) & 0x7;
 528     fSIDE     = (*fDataWord >>  2) & 0x1;
 529
 530     fROC      = fGeo->GetDetectorSec(fLAYER, fSTACK);
 531
 532     //AliDebug(3, Form("0x%08x: HC header: sm=%d; roc=%d; side=%x", *fDataWord, fSM, fROC, fSIDE+10));
 533     //AliDebug(5, Form("0x%08x: HC header: expecting %d HC words", *fDataWord, fHCHWords));
 534
 535     if ((fSM    <  0) ||
 536         (fSM    > 17) ||
 537         (fLAYER <  0) ||
 538         (fLAYER >  5) ||
 539         (fSTACK <  0) ||
 540         (fSTACK >  4) ||
 541         (fSIDE  <  0) ||
 542         (fSIDE  >  1))
 543       {
 544         AliWarning(Form("0x%08x: Strange HC header: dcs=%d; sm=%d; layer=%d; stack=%d.",
 545                         *fDataWord, fDCS, fSM, fLAYER, fSTACK));
 546         fRawReader->AddMajorErrorLog(kHCHeaderCorrupt,Form("0x%08x:dcs=%d; sm=%d; layer=%d; stack=%d.",
 547                                                            *fDataWord, fDCS, fSM, fLAYER, fSTACK));
 548       }
 549     else
 550       {
 551         fHCHctr1++;
 552         fHCHctr2++;
 553       }
 554   }
 555   else
 556     {
 557       AliWarning(Form("0x%08x: No HC header when it was expected.", *fDataWord));
 558       fRawReader->AddMajorErrorLog(kHCHeaderMissing,Form("0x%08x", *fDataWord));
 559     }
 560
 561   // 2nd word (h[1])
 562   if ( fHCHWords >= 1 )
 563     {
 564       // read one more word
 565       if (NextData() != kWordOK)
 566         {
 567           AliWarning("Next HC word missing");
 568           fRawReader->AddMajorErrorLog(kHCWordMissing,"Next HC word missing");
 569           fNextStatus = kNextHC;
 570           return;
 571         }
 572
 573       if ( (*fDataWord & 0x3) == 1 )
 574         {
 575
 576           fBCctr   =  (*fDataWord >> 16);
 577           fPTctr   =  (*fDataWord >> 12) & 0xf;
 578           fPTphase =  (*fDataWord >>  8) & 0xf;
 579           fTBins   = ((*fDataWord >>  2) & 0x3f) + 1;
 580           fTimeWords = (fTBins - 1)/3 + 1;
 581
 582 //        AliDebug(3, Form("0x%08x: HC header 2: BCctr=%d PTctr=%d PTph=%d TB=%d"
 583 //                         , *fDataWord, fBCctr, fPTctr, fPTphase, fTBins));
 584
 585           if( fTBins != timeBins )
 586             {
 587               AliWarning("===============================================================================");
 588               AliError(Form("Mismatch between nNTB from CDB (%d) and from HC header (%d)"
 589                             , timeBins, fTBins));
 590               AliWarning(Form("We will use the value from the raw data (HC header): %d", fTBins));
 591               AliWarning("===============================================================================");
 592
 593               fTimeWords = (fTBins - 1)/3 + 1;
 594             }
 595         }
 596     }
 597
 598   // 3nd word (h[2])
 599   if ( fHCHWords >= 2 ) {
 600     // read one more word
 601     if (NextData() != kWordOK)
 602       {
 603         AliWarning("Next HC word missing");
 604         fRawReader->AddMajorErrorLog(kHCWordMissing,"Next HC word missing");
 605         fNextStatus = kNextHC;
 606         return;
 607       }
 608     if ( (*fDataWord & 0x3) == 1 ) {
 609
 610       fTCon     = (*fDataWord >> 29) & 0x1;
 611       fPEDon    = (*fDataWord >> 31) & 0x1;
 612       fGAINon   = (*fDataWord >> 30) & 0x1;
 613       fXTon     = (*fDataWord >> 28) & 0x1;
 614       fNonLinOn = (*fDataWord >> 27) & 0x1;
 615       fBypass   = (*fDataWord >> 26) & 0x1;
 616
 617       fCommonAdditive = (*fDataWord >> 20) & 0x3f;
 618
 619 //       AliDebug(3, Form("0x%08x: HC header 3: TC=%d, PED=%d, GAIN=%d, XT=%d, NonLin=%d, Bypass=%d, Add=%d"
 620 //                    , fTCon, fPEDon, fGAINon, fXTon, fNonLinOn, fBypass, fCommonAdditive));
 621     }
 622   }
 623
 624 }
 625
 626 //____________________________________________________________________________
 627 Int_t AliTRDRawStreamV2::ChannelsToRead(Int_t ADCmask)
 628 {
 629   //
 630   // Return the channels to read
 631   //
 632
 633   memset(fADClookup, -1, 32 * sizeof(Int_t));
 634   fADClookup[0] = 0; // count entries
 635   fADClookup[1] = 2; // index - data start at 2
 636   UInt_t mask = 0;
 637   for (Int_t i = 0; i < 30; i++)
 638     {
 639       mask = 1 << i;
 640       if ((ADCmask & mask))
 641         {
 642           //AliDebug(9, Form("fDataWord=0x%08x mask=0x%08x i=%d", *fDataWord, mask, i));
 643           fADClookup[fADClookup[1]] = i;
 644           ++fADClookup[0];
 645           ++fADClookup[1];
 646         }
 647     }
 648
 649   // test the iteration - comment out for production
 650   // begin of comment out section
 651   char schannels[512];
 652   sprintf(schannels, "ADC Channels to read: ");
 653   fADClookup[1] = 2;
 654   while(fADClookup[1] - 2 < fADClookup[0])
 655     {
 656       //AliDebug(9, Form("max=%d index=%d adc=%d", fADClookup[0], fADClookup[1], fADClookup[fADClookup[1]]));
 657       strcat(schannels, Form("%d ", fADClookup[fADClookup[1]]));
 658       fADClookup[1]++;
 659     }
 660   //AliDebug(9, Form("%s", schannels));
 661   //AliDebug(9, Form("ADC channels = %d", fADClookup[0]));
 662   // end of comment out section
 663
 664   fADClookup[1] = 2;
 665   return fADClookup[0];
 666 }
 667
 668 //____________________________________________________________________________
 669 void AliTRDRawStreamV2::DecodeTracklet()
 670 {
 671   //
 672   // Decode the Tracklet
 673   //
 674   // this function is not tested yet on real tracklets
 675   //
 676
 677   if ( fRawVersion < 1 || fRawVersion > 3 )
 678     {
 679       AliError(Form(" Unsupported raw version: %d", fRawVersion));
 680     }
 681
 682   fTracklPID    = (*fDataWord >> 24) & 0xff;
 683   fTracklPadRow = (*fDataWord >> 20) & 0xf;    // 0:15
 684   fTracklDefL   = (*fDataWord >> 13) & 0x7f;
 685   fTracklPadPos = (*fDataWord)       & 0x1fff;
 686
 687   fTracklPID    /= (Float_t)((1<<8) - 1);                      // 0:1 (steps of 0.39%)
 688   fTracklDefL    = (fTracklDefL  - ((1<< 7)-1)/2.) * 140.e-4;  // -0.889:0.889cm
 689   fTracklPadPos  = (fTracklPadPos - ((1<<13)-1)/2.) * 160.e-4; // -65.528:65.528 cm
 690
 691   //AliDebug(4, Form("0x%08x: Tracklet found: SM%d L%dS%d side %x: PadRow=%d PadPos=%f DefL=%f PID=%f"
 692   //              , *fDataWord, fSM, fLAYER, fSTACK, fSIDE+10
 693   //                , fTracklPadRow, fTracklPadPos, fTracklDefL, fTracklPID));
 694
 695   if( ((fSTACK == 2) && (fTracklPadRow >= (Int_t) fGeo->RowmaxC0())) ||
 696       ((fSTACK != 2) && (fTracklPadRow >= (Int_t) fGeo->RowmaxC1())) ) {
 697     AliWarning(Form("Strange Row read from Tracklet Word: %d", fTracklPadRow));
 698     fRawReader->AddMajorErrorLog(kTrackletRowMismatch,Form("Word: %d", fTracklPadRow));
 699   }
 700
 701 }
 702
 703 //____________________________________________________________________________
 704 void AliTRDRawStreamV2::DecodeMCMheader()
 705 {
 706   //
 707   // Decode the MCM header
 708   //
 709
 710   if ( fRawVersion < 1 || fRawVersion > 3 )
 711     {
 712       AliError(Form(" Unsupported raw version: %d", fRawVersion));
 713     }
 714
 715   fMCM  = (*fDataWord & 0xff000000) >> 24;
 716   fEv   = (*fDataWord & 0x00fffff0) >> 4;
 717
 718   fROB  = fMCM / 16;
 719   fMCM  = fMCM % 16;
 720
 721   fROW  = AliTRDfeeParam::Instance()->GetPadRowFromMCM(fROB, fMCM);
 722
 723 //   AliDebug(4, Form("0x%08x: SM%d L%dS%d. MCM Header: fROB=%d fMCM=%02d fEv=%02d"
 724 //                , *fDataWord, fSM, fLAYER, fSTACK, fROB, fMCM, fEv));
 725
 726   if ( fROB % 2 == 0 && fSIDE == 1 ) {
 727     AliWarning(Form("SM%d L%dS%d: Mismatch between fROB (%d) and fSIDE (%d): fMCM=%02d"
 728                    , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM ));
 729     fRawReader->AddMajorErrorLog(kROBSideMismatch,Form("SM%d L%dS%d: fROB (%d) fSIDE (%d): fMCM=%02d"
 730                                                        , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM ));
 731   }
 732   if ( fROB % 2 != 0 && fSIDE == 0 ) {
 733     AliWarning(Form("SM%d L%dS%d: Mismatch between fROB (%d) and fSIDE (%d): fMCM=%02d"
 734                    , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM ));
 735     fRawReader->AddMajorErrorLog(kROBSideMismatch,Form("SM%d L%dS%d: fROB (%d) fSIDE (%d): fMCM=%02d"
 736                                                        , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM ));
 737   }
 738   if ( (fSTACK == 2 && fROW >= fGeo->RowmaxC0()) ||
 739        (fSTACK != 2 && fROW >= fGeo->RowmaxC1()) || fROW < 0 ) {
 740     AliWarning(Form("SM%d L%dS%d: Wrong Padrow (%d) fROB=%d, fSIDE=%d, fMCM=%02d"
 741                    , fSM, fLAYER, fSTACK, fROW, fROB, fSIDE, fMCM ));
 742     fRawReader->AddMajorErrorLog(kWrongPadrow,Form("SM%d L%dS%d: Padrow (%d) fROB=%d, fSIDE=%d, fMCM=%02d"
 743                                                   , fSM, fLAYER, fSTACK, fROW, fROB, fSIDE, fMCM ));
 744   }
 745
 746   fMCMHctr1++;
 747   fMCMHctr2++;
 748
 749   fMCMWordCrt = 1; // MCM header
 750
 751   // AdcMask for Zero supressed data
 752   if ( fRawVersion == 3 )
 753     {
 754       // read one more word
 755       if (NextData() != kWordOK)
 756         {
 757           AliWarning("MCM ADC mask missing");
 758           fRawReader->AddMajorErrorLog(kMCMADCMaskMissing,"Missing");
 759           fNextStatus = kNextHC;
 760           return;
 761         }
 762       else
 763         {
 764           ++fMCMWordCrt;
 765
 766           for ( Int_t ctr = 0; ctr < fGeo->ADCmax(); ctr++ ) {
 767             if ( (*fDataWord >> (11+ctr)) == 0x1 ) fADCmask[ctr] = kTRUE;
 768             else                                  fADCmask[ctr] = kFALSE;
 769           }
 770
 771           //AliDebug(4, Form("0x%08x: ADC mask", *fDataWord));
 772           fNActiveADCs = ChannelsToRead(*fDataWord);
 773         }
 774     }
 775
 776   if (fRawVersion <= 2)
 777     {
 778       // no zero suppression
 779       // raw version 2:
 780       // 1 MCM header + 21 * ( Ntimebin/3)
 781       // If NTimebin = 30, it is 211 words.
 782       //fMCMWordsExpected = 1 + 21 * (fTBins / 3);
 783       //fNActiveADCs = 21;
 784       fNActiveADCs = ChannelsToRead(0x1fffff); // should be 1111 1111 1111 1111 1111 1 = 21 bits active (0-20)
 785       //fMCMWordsExpected = 1 + fNActiveADCs * ((fTBins-1) / 3. + 1.);
 786       //directly get it like that:
 787       fMCMWordsExpected = 1 + fNActiveADCs * fTBins / 3;
 788     }
 789
 790   if (fRawVersion >= 3)
 791     {
 792       // raw version 3:
 793       // 1 MCM header + 1 ADC mask + NofActiveADCs * ( Ntimebin/3 )
 794       //directly get it like that:
 795       fMCMWordsExpected = 1 + 1 + (fTBins * fNActiveADCs) / 3;
 796     }
 797
 798   //AliDebug(5, Form("We expect %d MCM words. We read %d so far.", fMCMWordsExpected, fMCMWordCrt));
 799 }
 800 //____________________________________________________________________________
 801 Bool_t AliTRDRawStreamV2::DecodeNextRawWord()
 802 {
 803   //
 804   // Decode the next raw data word
 805   //
 806
 807   //AliDebug(8, Form("-----------------------------------------"));
 808   //AliDebug(8, Form("DATA IS 0x%x", *fDataWord));
 809
 810   if (fADClookup[1] - 2 > fADClookup[0])
 811     {
 812 //       AliDebug(8, Form("Overflow Index ADC = %d Max Index = %d Value = %d. Done with ADCs in this MCM. Is this already MCM header 0x%x?",
 813 //                     fADClookup[1] - 2, fADClookup[0], fADClookup[fADClookup[1]], *fDataWord));
 814       fTbSwitchCtr = 0;
 815       fMCMWordsExpected = 0;
 816       AliWarning("Trying to recover. Fall back to DecodeMCM.");
 817       DecodeMCM();
 818       //ChangeStatus(kNextMCM);
 819       return kFALSE;
 820     }
 821
 822   if ( (*fDataWord & 0x00000003) != 0x2 && (*fDataWord & 0x00000003) != 0x3) {
 823     AliWarning(Form("Data %08x : Data Word ends neither with b11 nor b10", (Int_t)*fDataWord));
 824     fRawReader->AddMinorErrorLog(kDataMaskError,Form("Data %08x", (Int_t)*fDataWord));
 825     fMCMWordsExpected = 0;
 826     AliWarning("Trying to recover. Fall back to DecodeMCM.");
 827     DecodeMCM();
 828     //ChangeStatus(kNextMCM);
 829     return kFALSE;
 830   }
 831
 832   if ( (*fDataWord & 0x3) != fLastADCmask || fTbSwitchCtr > fTimeWords)
 833     {
 834       fADC = fADClookup[fADClookup[1]];
 835 //       AliDebug(8, Form("Next fADC = %d at index = %d MCM Word Number: %d Max MCM Words is %d",
 836 //                     fADC, fADClookup[1] - 2, fMCMWordCrt, fMCMWordsExpected));
 837       ++fADClookup[1];
 838       fTB = 0;
 839       fTbSwitchCtr = 0;
 840       fLastStatus = kNextData;
 841       fLastADCmask = (*fDataWord) & 0x3;
 842     }
 843
 844   ++fTbSwitchCtr;
 845
 846   //decode data here
 847   Bool_t kIsDataOK = kFALSE;
 848
 849   // We have only 21 ADC channels.
 850   if ( fADC > (Int_t)fGeo->ADCmax() - 1 )
 851     {
 852       AliWarning(Form("Data %08x : Data is strange. fADC is already %d", (Int_t)*fDataWord, (Int_t)fADC));
 853       fRawReader->AddMinorErrorLog(kADCChannelOverflow,Form("Data %08x : fADC=%d", (Int_t)*fDataWord, (Int_t)fADC));
 854     }
 855   else
 856     {
 857       // There are 18 pads connected to each MCM ADC channels 2...19. The other channels cross to other
 858       // MCMs and are good for online tracking in the MCM.
 859       if ( fADC > 1 && fADC < (Int_t)fGeo->ADCmax() - 1 )
 860         {
 861
 862           // Get Pad column
 863           // fCOL = fFee->GetPadColFromADC(fROB, fMCM, fADC);
 864           fCOL = AliTRDfeeParam::Instance()->GetPadColFromADC(fROB, fMCM, fADC);
 865
 866           // We have only 144 Pad Columns
 867           //if ( fCOL > fColMax-1 || fCOL < 0 )
 868           if ( fCOL >= 0 && fCOL < fColMax && fROW >= 0 && fROW < fRowMax )
 869             {
 870               // Decode 32 bit data words with information from 3 time bins and copy the data
 871               fSig[0] = (*fDataWord & 0x00000ffc) >> 2;
 872               fSig[1] = (*fDataWord & 0x003ff000) >> 12;
 873               fSig[2] = (*fDataWord & 0xffc00000) >> 22;
 874
 875               // Print data to screen:
 876               //AliDebug(5, Form("DATA : 0x%x", *fDataWord));
 877               //          AliDebug(5, Form("SM%d L%dS%d: ROB%d MCM=%d ADC=%d (ROW=%d COL=%d): Data %04d %04d %04d\n",
 878               //                           fSM, fLAYER, fSTACK, fROB, fMCM, fADC, fROW, fCOL, fSig[0], fSig[1], fSig[2]));
 879               kIsDataOK = kTRUE;
 880             }
 881           else
 882             {
 883               AliWarning(Form("SM%d L%dS%d: Wrong Pad column (%d) fROB=%d, fSIDE=%d, fMCM=%02d", fSM,
 884                               fLAYER, fSTACK, fCOL, fROB, fSIDE, fMCM ));
 885               fRawReader->AddMajorErrorLog(kWrongPadcolumn,Form("SM%d L%dS%d: column (%d) fROB=%d, fSIDE=%d, fMCM=%02d", fSM,
 886                                                                 fLAYER, fSTACK, fCOL, fROB, fSIDE, fMCM ));
 887               kIsDataOK = kFALSE;
 888             }
 889         }
 890       else
 891         {
 892           //AliDebug(5, Form("fADC not accepted %d - DATA : 0x%x", fADC, *fDataWord));
 893           fCOL = -1;
 894           kIsDataOK = kFALSE;
 895         }
 896     }// if fADC is ok
 897
 898   ++fMCMWordCrt;
 899   //AliDebug(5, Form("We expect %d MCM words. We read %d so far.", fMCMWordsExpected, fMCMWordCrt));
 900
 901   // all mcm data processed go to next one
 902   if ( fMCMWordCrt >= fMCMWordsExpected)
 903     {
 904       ChangeStatus(kNextMCM);
 905     }
 906
 907   return kIsDataOK;
 908 }
 909
 910 //____________________________________________________________________________
 911 Bool_t AliTRDRawStreamV2::DecodeMCM()
 912 {
 913   //
 914   // Decode a single MCM
 915   //
 916
 917   if( ((*fDataWord & 0x80000000) == 0x0) && ((*fDataWord & 0x0000000f) == 0xC) )
 918     { // MCM Header
 919       DecodeMCMheader();
 920       if ( fMCM < 0 || fMCM > 15 || fROB < 0 || fROB > 7 )
 921         {
 922           AliWarning("Wrong fMCM or fROB. Skip this data");
 923           fRawReader->AddMajorErrorLog(kWrongMCMorROB,Form("MCM=%d, ROB=%d",fMCM,fROB));
 924           ChangeStatus(kNextHC);
 925           return kFALSE;
 926         }
 927
 928       fTbSwitch    = 3;  // For first adc channel we expect: (*fDataWord & 3) = 3
 929       fTbSwitchCtr = 0;  //
 930       fADC = fTB   = 0;  // Reset Counter
 931       fLastADCmask = 0; // Reset
 932
 933       if (fMCMWordCrt < fMCMWordsExpected)
 934         {
 935           ChangeStatus(kNextData);
 936         }
 937       else
 938         {
 939           ChangeStatus(kNextMCM);
 940         }
 941       return kTRUE;
 942     }
 943
 944   if ( *fDataWord == fgkEndofrawdatamarker )
 945     {  // End of half-chamber data, finished
 946       fGTUctr1 = -1;
 947       ChangeStatus(kNextHC);
 948       fEndOfDataFlag = kTRUE;
 949       //AliDebug(5, "Expecting MCM header but got End-Of-Raw-Data Marker");
 950       if (fMCMWordsExpected == 0 || fMCMWordsExpected == fMCMWordCrt)
 951         return kTRUE;
 952       else
 953         {
 954           //AliDebug(5, Form("MCM words missing? %d [expected=%d got=%d] ", fMCMWordsExpected - fMCMWordCrt, fMCMWordsExpected, fMCMWordCrt));
 955           //AliWarning(Form("MCM words missing? %d [expected=%d got=%d] ", fMCMWordsExpected - fMCMWordCrt, fMCMWordsExpected, fMCMWordCrt));
 956           return kFALSE;
 957         }
 958     }
 959
 960   //AliDebug(3, Form("Expecting MCM header but got 0x%x. Going to Next MCM header.", *fDataWord));
 961   AliWarning(Form("Expecting MCM header but got 0x%x. Fall back: Next MCM header.", *fDataWord));
 962   ChangeStatus(kNextMCM);
 963
 964   return kFALSE;
 965 }
 966
 967 //____________________________________________________________________________
 968 Bool_t AliTRDRawStreamV2::DecodeHC()
 969 {
 970   //
 971   // Decode a half chamber
 972   //
 973
 974   if ( fNextStatus == kNextHC )
 975     {
 976       //AliDebug(5, "kNextHC");
 977       //
 978       // 1) Find end_of_tracklet_marker
 979       //
 980       // GTU Link Mask?
 981       if (DecodeGTUlinkMask())
 982         {
 983           return kTRUE;
 984         }
 985
 986       // endoftrackletmarker?
 987       if ( *fDataWord == fgkEndoftrackletmarker )
 988         {
 989           //AliDebug(3, "End-of-tracklet-marker found");
 990           //AliDebug(5, Form("Data 0x%x", *fDataWord));
 991           ChangeStatus(kSeekNonEoTracklet);
 992           return kTRUE;
 993         }
 994       else
 995         {
 996           // Tracklets found
 997           //AliDebug(3, "Tracklet found");
 998           //AliDebug(5, Form("Tracklet data 0x%x", *fDataWord));
 999           DecodeTracklet();
1000           return kTRUE;
1001         }
1002     } // if next HC
1003
1004   if (fNextStatus == kSeekNonEoTracklet)
1005     {
1006       //AliDebug(5, "kSeekNonEoTracklet");
1007
1008       //
1009       // 2) Look for non-end_of_tracklet_marker
1010       //
1011       //printf("Word %d: 0x%08x\n", fWordCtr, *fDataWord);
1012
1013       if ( *fDataWord != fgkEndoftrackletmarker )
1014         {
1015           ChangeStatus(kDecodeHC);
1016           //AliDebug(3, "NON end-of-tracklet-marker found");
1017           //AliDebug(5, Form("Data 0x%x", *fDataWord));
1018           //// no do not continue - this should be the hcheader
1019         }
1020       else
1021         {
1022           //just go on and find the non-end_of_tracklet_marker
1023           return kTRUE;
1024         }
1025     }
1026
1027   if ( fNextStatus == kDecodeHC )
1028     {
1029       //AliDebug(5, "kDecodeHC");
1030
1031       //
1032       // 3) This Word must be Half Chamber Header
1033       //
1034       if ( (*fDataWord & 0x00000003) == 1 )
1035         { // HC header
1036           DecodeHCheader(fTimeBinsCalib); // This is the new header!
1037           fLastDET = fDET;
1038           fDET    = fGeo->GetDetector(fLAYER, fSTACK, fSM);
1039           fRowMax = fGeo->GetRowMax(fLAYER,fSTACK,fSM);
1040           fColMax = fGeo->GetColMax(fROC);
1041
1042           fMCMHctr2 = 0;
1043           fHCdataCtr = 0;
1044           fChamberDone[fDET]++;
1045           //AliDebug(6, Form("--------------      DET %d fChamberDone[fDET]=%d", fDET, fChamberDone[fDET]));
1046
1047           ChangeStatus(kNextMCM);
1048           return kTRUE;
1049         } //HC header
1050       else
1051         {
1052           AliWarning(Form("Expecting HC header mask but got 0x%x. Fall back: Next HC.", *fDataWord));
1053           ChangeStatus(kNextHC);
1054           // before we went to //ChangeStatus(kNextSM);
1055         }
1056     } // if decode HC
1057
1058   return kFALSE;
1059 }
1060
1061 //____________________________________________________________________________
1062 Bool_t AliTRDRawStreamV2::DecodeGTUlinkMask()
1063 {
1064   //
1065   // Decode the link masks sent by the GTU. These marke the active optical links
1066   // between GTU and Super Module. Up to now only fully active links are found
1067   // (0xfff = 12 active links).
1068   //
1069
1070   if ( (*fDataWord & 0xfffff000) ==  0xe0000000 )
1071     {
1072       if ( fRawVersion < 1 || fRawVersion > 3 )
1073         {
1074           AliError(Form(" Unsupported raw version: %d", fRawVersion));
1075         }
1076
1077       if ( fGTUctr1 == -1 ) fGTUctr2++;
1078       fGTUctr1++;
1079
1080       if ( (fGTUctr1 >= 0) && (fGTUctr1 < 5) && (fGTUctr2 >= 0) && (fGTUctr2 < 18) )
1081         {
1082           fGTUlinkMask[fGTUctr2][fGTUctr1] = (*fDataWord & 0xfff);
1083         }
1084
1085       //AliDebug(5, Form("GTU link mask 0x%x decoded 0x%x", *fDataWord, fGTUlinkMask[fGTUctr2][fGTUctr1]));
1086       return kTRUE;
1087     }
1088
1089   return kFALSE;
1090 }
1091
1092 //____________________________________________________________________________
1093 void AliTRDRawStreamV2::ChangeStatus(Int_t kstat)
1094 {
1095   //
1096   // Change the status
1097   //
1098
1099   fLastStatus = fNextStatus;
1100   fNextStatus = kstat;
1101 }
1102
1103 //____________________________________________________________________________
1104 Bool_t AliTRDRawStreamV2::DecodeSM()
1105 {
1106   //
1107   // Decode a supermodule
1108   //
1109
1110   fDET     = 0;
1111   fRetVal = 0;
1112   fEqID     = 0;
1113   fDataSize = 0;
1114   fSizeOK = kFALSE;
1115
1116   // After reading the first word check for size of this data and get Eq. ID
1117   if ( fWordCtr == 1 )
1118     {
1119       fDataSize = fRawReader->GetDataSize()/4;  // Size of this payload in 32bit words
1120       fEqID     = fRawReader->GetEquipmentId(); // Get Equipment ID
1121       if ( fDataSize > 0 ) fSizeOK = kTRUE;
1122       //AliDebug(3, Form("fDataSize=%d fEqID=%d", fDataSize, fEqID));
1123     }
1124
1125   // GTU Link Mask?
1126   if ( DecodeGTUlinkMask() )
1127     {
1128       ChangeStatus(kNextHC);
1129       return kTRUE;
1130     }
1131   else
1132     {
1133       AliWarning(Form("Equipment %d: First data word is not GTU Link Mask! Fall back: None. Stop.", fEqID));
1134       fRawReader->AddMajorErrorLog(kGTULinkMaskMissing,Form("Equipment %d",fEqID));
1135       ChangeStatus(kStop);
1136     }
1137
1138   return kFALSE;
1139 }
1140
1141 //____________________________________________________________________________
1142 Bool_t AliTRDRawStreamV2::Next()
1143 {
1144   //
1145   // Updates the next data word pointer
1146   //
1147
1148   if (fNextStatus == kStart)
1149     {
1150       Init();
1151     }
1152
1153   while (fNextStatus != kStop)
1154     { // !kStop
1155       NextData();
1156
1157       switch (fNextStatus)
1158         {
1159         case kNextData:
1160           {
1161           if (DecodeNextRawWord() == kTRUE)
1162             {
1163               fTB += 3;
1164               if (fSig[0] > fRawDigitThreshold || fSig[1] > fRawDigitThreshold || fSig[2] > fRawDigitThreshold)
1165                 return kTRUE;
1166             }
1167           }; break;
1168         case kNextMCM:
1169           {
1170             if (DecodeMCM() == kFALSE)
1171               AliWarning(Form("Decode MCM unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos));
1172           }; break;
1173         case kNextHC:
1174         case kSeekNonEoTracklet:
1175         case kDecodeHC:
1176           {
1177             if (DecodeHC() == kFALSE)
1178               {
1179                 AliWarning(Form("Decode HC unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos));
1180               }
1181             else
1182               {
1183                 //the hc header should be decoded by now
1184                 if (fLastStatus == kDecodeHC)
1185                   {
1186                     fLastDET = fDET;
1187                     fChamberDone[fDET]++;
1188                   }
1189               }
1190           }; break;
1191         case kNextSM:
1192           {
1193             if (DecodeSM() == kFALSE)
1194                 AliWarning(Form("Decode SM unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos));
1195           }; break;
1196         case kStop:
1197           ; break;
1198         default:
1199           AliWarning(Form("Unknown state %d. Last state %d. Current Word 0x%x at pos 0x%x", fNextStatus, fLastStatus, *fDataWord, fPos));
1200           ChangeStatus(kStop);
1201         };
1202
1203     } // not kStop
1204
1205   //AliDebug(1, Form("That's all folks! %d", fSM));
1206   return kFALSE;
1207 }
1208
1209 //____________________________________________________________________________
1210 Int_t AliTRDRawStreamV2::NextChamber(AliTRDdigitsManager *man, UInt_t** /*trackletContainer*/)
1211 {
1212   //
1213   // Fills single chamber digit array
1214   // Return value is the detector number
1215   //
1216
1217   AliTRDdataArrayS *digits = 0;
1218   AliTRDdataArrayI *track0 = 0;
1219   AliTRDdataArrayI *track1 = 0;
1220   AliTRDdataArrayI *track2 = 0;
1221   AliTRDSignalIndex *indexes = 0;
1222
1223   if (fNextStatus == kStart)
1224     {
1225       Init();
1226     }
1227
1228 //   while (fNextStatus != kStop)
1229 //     { // !kStop
1230 //       NextData();
1231 //       // catch 3 things
1232 //       // 1) if end of raw data - if chamber complete return
1233 //       // 2) fill the data with signals if data decoded ok
1234 //       // 3) initialize (destroy old) after the det has changed -> just after HC header decoding
1235 //     } // not kStop
1236
1237   while (fNextStatus != kStop)
1238     { // !kStop
1239       NextData();
1240
1241       switch (fNextStatus)
1242         {
1243
1244         case kNextData:
1245           {
1246             if (DecodeNextRawWord() == kTRUE)
1247               {
1248                 for (Int_t it = 0; it < 3; it++)
1249                   {
1250                     if ( fTB + it < fTBins )
1251                       {
1252                         if ( fSig[it] > fRawDigitThreshold )
1253                           {
1254                             digits->SetDataUnchecked(fROW, fCOL, fTB + it, fSig[it]);
1255                             indexes->AddIndexTBin(fROW, fCOL, fTB + it);
1256                             if (man->UsesDictionaries())
1257                               {
1258                                 track0->SetDataUnchecked(fROW, fCOL, fTB + it, 0);
1259                                 track1->SetDataUnchecked(fROW, fCOL, fTB + it, 0);
1260                                 track2->SetDataUnchecked(fROW, fCOL, fTB + it, 0);
1261                               } // if dictionaries
1262                           } // signal above zero
1263                       } // check the tbins range
1264                   } // for each tbin of current 3
1265                 fTB += 3;
1266               }
1267             else
1268               {
1269                 // can be here as a fall back from decode raw data calling decodemcm
1270                 if (fEndOfDataFlag == kTRUE)
1271                   {
1272                     if (fChamberDone[fDET] == 2)
1273                       {
1274                         return fDET;
1275                       }
1276                     fEndOfDataFlag = kFALSE;
1277                   }
1278               }
1279           }; break;
1280
1281         case kNextMCM:
1282           {
1283             if (DecodeMCM() == kFALSE)
1284               {
1285                 AliWarning(Form("Decode MCM unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos));
1286               }
1287             // default place for end of raw data...
1288             if (fEndOfDataFlag == kTRUE)
1289               {
1290                 if (fChamberDone[fDET] == 2)
1291                   {
1292                     return fDET;
1293                   }
1294                 fEndOfDataFlag = kFALSE;
1295               }
1296           }; break;
1297
1298         case kNextHC:
1299         case kSeekNonEoTracklet:
1300         case kDecodeHC:
1301           {
1302             if (DecodeHC() == kFALSE)
1303               {
1304                 AliWarning(Form("Decode HC unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos));
1305               }
1306             else
1307               {
1308                 //the hc header should be decoded by now
1309                 if (fLastStatus == kDecodeHC)
1310                   {
1311 //                  AliDebug(4, Form("???? New DET ???? %d last %d", fDET, fLastDET));
1312                     // allocate stuff for the new det
1313                     //man->ResetArrays();
1314                     digits = (AliTRDdataArrayS *) man->GetDigits(fDET);
1315                     track0 = (AliTRDdataArrayI *) man->GetDictionary(fDET,0);
1316                     track1 = (AliTRDdataArrayI *) man->GetDictionary(fDET,1);
1317                     track2 = (AliTRDdataArrayI *) man->GetDictionary(fDET,2);
1318
1319                     // Allocate memory space for the digits buffer
1320                     if (digits->GetNtime() == 0)
1321                       {
1322 //                      AliDebug(5, Form("Alloc digits for det %d rows %d cols %d tbins %d", fDET, fRowMax, fColMax, fTBins));
1323                         digits->Allocate(fRowMax, fColMax, fTBins);
1324                         if (man->UsesDictionaries())
1325                           {
1326                             track0->Allocate(fRowMax, fColMax, fTBins);
1327                             track1->Allocate(fRowMax, fColMax, fTBins);
1328                             track2->Allocate(fRowMax, fColMax, fTBins);
1329                           }
1330                       }
1331
1332                     indexes = man->GetIndexes(fDET);
1333                     indexes->SetSM(fSM);
1334                     indexes->SetStack(fSTACK);
1335                     indexes->SetLayer(fLAYER);
1336                     indexes->SetDetNumber(fDET);
1337
1338                     if (indexes->IsAllocated() == kFALSE)
1339                       {
1340 //                      AliDebug(4, "Allocating indexes");
1341                         indexes->Allocate(fRowMax, fColMax, fTBins);
1342                       }
1343                   } // is the HC header already decoded?
1344               } // decode hc ok
1345           }; break;
1346
1347         case kNextSM:
1348           {
1349             if (DecodeSM() == kFALSE)
1350               AliWarning(Form("Decode SM unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos));
1351           }; break;
1352
1353         case kStop:
1354           ; break;
1355
1356         default:
1357           AliWarning(Form("Unknown state %d. Last state %d. Current Word 0x%x at pos 0x%x", fNextStatus, fLastStatus, *fDataWord, fPos));
1358           ChangeStatus(kStop);
1359         };
1360
1361     } // not kStop
1362
1363   // we do not return chambers for which the end-of-data was not received twice (for each HC)
1364
1365   //AliDebug(1, Form("That's all folks! %d", fSM));
1366   //return kFALSE;
1367   return -1;
1368 }