TRD/AliTRDrawStream.cxx

   1 /**************************************************************************\r
   2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
   3 q*                                                                        *\r
   4 * Author: The ALICE Off-line Project.                                    *\r
   5 * Contributors are mentioned in the code where appropriate.              *\r
   6 *                                                                        *\r
   7 * Permission to use, copy, modify and distribute this software and its   *\r
   8 * documentation strictly for non-commercial purposes is hereby granted   *\r
   9 * without fee, provided that the above copyright notice appears in all   *\r
  10 * copies and that both the copyright notice and this permission notice   *\r
  11 * appear in the supporting documentation. The authors make no claims     *\r
  12 * about the suitability of this software for any purpose. It is          *\r
  13 * provided "as is" without express or implied warranty.                  *\r
  14 **************************************************************************/\r
  15 \r
  16 /* $Id: AliTRDrawStream.cxx 27797 2008-08-05 14:37:22Z cblume $ */\r
  17 \r
  18 ///////////////////////////////////////////////////////////////////////////////\r
  19 //                                                                           //\r
  20 // This class provides access to TRD digits in raw data.                     //\r
  21 //                                                                           //\r
  22 // It loops over all TRD digits in the raw data given by the AliRawReader.   //\r
  23 // The Next method goes to the next digit. If there are no digits left       //\r
  24 // it returns kFALSE.                                                        //\r
  25 // Several getters provide information about the current digit.              //\r
  26 //                                                                           //\r
  27 // Author: M. Ploskon (ploskon@ikf.uni-frankfurt.de)                         //\r
  28 //                                                                           //\r
  29 ///////////////////////////////////////////////////////////////////////////////\r
  30 \r
  31 #include "TString.h"\r
  32 #include "TFile.h"\r
  33 #include "TTreeStream.h"\r
  34 \r
  35 #include "AliTRDrawStream.h"\r
  36 #include "AliTRDgeometry.h"\r
  37 #include "AliTRDfeeParam.h"\r
  38 #include "AliTRDdigitsManager.h"\r
  39 #include "AliTRDarrayDictionary.h"\r
  40 #include "AliTRDarrayADC.h"\r
  41 #include "AliTRDSignalIndex.h"\r
  42 //#include "AliTRDcalibDB.h" \r
  43 //#include "Cal/AliTRDCalPadStatus.h" //is now read in clusterizer\r
  44 #include "AliTRDrawTPStream.h"\r
  45 \r
  46 #include "AliLog.h"\r
  47 #include "AliRawReader.h"\r
  48 \r
  49 #define END_OF_TRACKLET_MARKEROLD 0xaaaaaaaa\r
  50 #define END_OF_TRACKLET_MARKERNEW 0x10001000\r
  51 #define ENDOFRAWDATAMARKER 0x00000000\r
  52 #define WORD_SIZE sizeof(UInt_t)           // size of a word in bytes\r
  53 #define EXTRA_LEAD_WORDS 24\r
  54 #define CDH_WORDS 8\r
  55 \r
  56 #define IS_BIT_SET(w,b) ( ((w) >> (b)) & 0x1 ) // 1 if bit b is set in word w\r
  57 #define GET_VALUE_AT(w,m,s) (( (w) >> (s)) & (m) )      // get value of word w rshifted by s and mask with m\r
  58 \r
  59 // SM index word masks:\r
  60 #define SM_HEADER_SIZE(w) GET_VALUE_AT(w,0xffff,16) \r
  61 #define TRACKLETS_ENABLED(w) IS_BIT_SET(w,5)\r
  62 #define STACK_MASK(w) ((w) & 0x1f)\r
  63 \r
  64 // Stack word masks\r
  65 #define STACK_HEADER_SIZE(w) GET_VALUE_AT(w,0xffff,16)\r
  66 #define STACK_LINK_WORD(w) ((w) & 0xfff)\r
  67 #define LINK0_DATA_TYPE_FLAG(w) (GET_VALUE_AT(w,0x3,4) == (0x0) ? 0 : 1) // 0 if physics data\r
  68 #define LINK1_DATA_TYPE_FLAG(w) (GET_VALUE_AT(w,0x3,20) == (0x0) ? 0 : 1) // 0 if physics data\r
  69 #define LINK0_MONITOR_FLAG(w) (GET_VALUE_AT(w,0xf,0) == (0x0) ? 0 : 1) // 0 if OK\r
  70 #define LINK1_MONITOR_FLAG(w) (GET_VALUE_AT(w,0xf,16) == (0x0) ? 0 : 1) // 0 if OK\r
  71 \r
  72 // HC word masks\r
  73 //#define HC_HEADER_MASK_ERR(w) ( ((w) & (0x80000003)) == (0x80000001) ? 0 : 1) // 0 if OK!!!\r
  74 #define HC_HEADER_MASK_ERR(w) ( ((w) & (0x3)) == (0x1) ? 0 : 1) // 0 if OK!!!\r
  75 \r
  76 // HC word 0\r
  77 #define HC_SPECIAL_RAW_VERSION(w) IS_BIT_SET(w,31)\r
  78 #define HC_MAJOR_RAW_VERSION(w) GET_VALUE_AT(w,0x7f,24)\r
  79 #define HC_MAJOR_RAW_VERSION_OPT(w) GET_VALUE_AT(w,0x7,24)\r
  80 #define HC_MINOR_RAW_VERSION(w) GET_VALUE_AT(w,0x7f,17)\r
  81 #define HC_EXTRA_WORDS(w) GET_VALUE_AT(w,0x7,14)\r
  82 #define HC_DCS_BOARD(w) GET_VALUE_AT(w,0xfff<<20,20)\r
  83 #define HC_SM_NUMBER(w) GET_VALUE_AT(w,0x1f,9)\r
  84 #define HC_LAYER_NUMBER(w) GET_VALUE_AT(w,0x7,6)\r
  85 #define HC_STACK_NUMBER(w) GET_VALUE_AT(w,0x7,3)\r
  86 #define HC_SIDE_NUMBER(w) IS_BIT_SET(w,2)\r
  87 \r
  88 // HC word 1\r
  89 #define HC_NTIMEBINS(w) GET_VALUE_AT(w,0x3f,26)\r
  90 #define HC_BUNCH_CROSS_COUNTER(w) GET_VALUE_AT(w,0xffff,10)\r
  91 #define HC_PRETRIGGER_COUNTER(w) GET_VALUE_AT(w,0xf,6)\r
  92 #define HC_PRETRIGGER_PHASE(w) GET_VALUE_AT(w,0xf,2)\r
  93 \r
  94 // MCM word and ADC mask\r
  95 #define MCM_HEADER_MASK_ERR(w) ( ((w) & (0xf)) == (0xc) ? 0 : 1) // 0 if OK!!!\r
  96 #define MCM_ADCMASK_MASK_ERR(w) ( ((w) & (0xf)) == (0xc) ? 0 : 1) // 0 if OK!!!\r
  97 #define MCM_MCM_NUMBER(w) GET_VALUE_AT(w,0x0f,24)\r
  98 #define MCM_ROB_NUMBER(w) GET_VALUE_AT(w,0x7,28)\r
  99 #define MCM_EVENT_COUNTER(w) GET_VALUE_AT(w,0x00fffff,4)\r
 100 #define MCM_ADCMASK_VAL(w) GET_VALUE_AT(w,0x1fffff,4)\r
 101 #define MCM_ADCMASK_NADC(w) GET_VALUE_AT(w,0x1f,25)\r
 102 \r
 103 #define MCM_DUMMY_ADCMASK_VAL 0x015fffffc  // updated \r
 104 #define ADCDATA_VAL1 0x2  // updated \r
 105 #define ADCDATA_VAL2 0x3  // updated \r
 106 \r
 107 //--------------------------------------------------------\r
 108 #define ADC_WORD_MASK(w) ((w) & 0x3)\r
 109 //--------------------------------------------------------\r
 110 \r
 111 \r
 112 ClassImp(AliTRDrawStream)\r
 113 \r
 114 Bool_t AliTRDrawStream::fgExtraSkip = kFALSE;\r
 115 Bool_t AliTRDrawStream::fgSkipCDH = kFALSE;\r
 116 Bool_t AliTRDrawStream::fgWarnError = kTRUE;\r
 117 Bool_t AliTRDrawStream::fgCleanDataOnly = kFALSE;\r
 118 Bool_t AliTRDrawStream::fgDebugFlag = kTRUE;\r
 119 Bool_t AliTRDrawStream::fgEnableMemoryReset = kTRUE;\r
 120 Bool_t AliTRDrawStream::fgStackNumberChecker = kTRUE;\r
 121 Bool_t AliTRDrawStream::fgStackLinkNumberChecker = kTRUE;\r
 122 Bool_t AliTRDrawStream::fgSkipData = kTRUE;\r
 123 Bool_t AliTRDrawStream::fgEnableDecodeConfigData = kFALSE;\r
 124 Int_t AliTRDrawStream::fgDumpHead = -1;\r
 125 Int_t  AliTRDrawStream::fgCommonAdditive = 0;\r
 126 Int_t AliTRDrawStream::fgEmptySignals[] = \r
 127   {\r
 128     -1, -1, -1, -1, -1,  -1, -1, -1, -1, -1,  -1, -1, -1, -1, -1\r
 129     -1, -1, -1, -1, -1,  -1, -1, -1, -1, -1,  -1, -1, -1, -1, -1\r
 130   };\r
 131 Short_t AliTRDrawStream::fgMCMordering[] =\r
 132   {\r
 133     12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3 \r
 134   };\r
 135 Short_t AliTRDrawStream::fgROBordering[] =\r
 136   {\r
 137     0, 1, 2, 3\r
 138   };\r
 139 Int_t  AliTRDrawStream::fgLastHC = -1;\r
 140 Int_t  AliTRDrawStream::fgLastROB = -1;\r
 141 Int_t  AliTRDrawStream::fgLastIndex = -1;\r
 142 Bool_t  AliTRDrawStream::fgDumpingEnable = kFALSE;\r
 143 Int_t  AliTRDrawStream::fgDumpingSM = -1;\r
 144 Int_t  AliTRDrawStream::fgDumpingStack = -1;\r
 145 Int_t  AliTRDrawStream::fgDumpingLayer = -1;\r
 146 Int_t  AliTRDrawStream::fgDumpingROB = -1;\r
 147 Int_t  AliTRDrawStream::fgDumpingMCM = -1;\r
 148 \r
 149 \r
 150 AliTRDrawStream::AliTRDrawStream()\r
 151   : AliTRDrawStreamBase()\r
 152   , fSM()\r
 153   , fStack(0)\r
 154   , fHC(0)\r
 155   , fMCM(0)\r
 156   , fADC(0)\r
 157   , fpPos(0)\r
 158   , fpBegin(0)\r
 159   , fpEnd(0)\r
 160   , fWordLength(0)\r
 161   , fStackNumber(-1)\r
 162   , fStackLinkNumber(-1)\r
 163   , fhcMCMcounter(0)\r
 164   , fmcmADCcounter(0)\r
 165   , fLinkTrackletCounter(-1)\r
 166   , fEndOfTrackletCount(-1)\r
 167   , fNWordsCounter(-1)\r
 168   , fMaskADCword(0)\r
 169   , fTbinADC(0)\r
 170   , fDecodedADCs(-1)\r
 171   , fEventCounter(0)\r
 172   , fLastEventCounter(0)\r
 173   , fSharedPadsOn(kFALSE)\r
 174   , fMaxADCgeom(0)\r
 175   , fBufferRead(0)\r
 176   , fGeometry(0)\r
 177   , fRawReader(0)\r
 178   , fTRDfeeParam(0)\r
 179 {\r
 180   //\r
 181   // default constructor\r
 182   //\r
 183 \r
 184   if (Init() == kFALSE)\r
 185     {\r
 186       AliWarning("Unable to Init.");      \r
 187     }\r
 188 }\r
 189 \r
 190 //--------------------------------------------------------\r
 191 AliTRDrawStream::AliTRDrawStream(AliRawReader *rawReader)\r
 192   : AliTRDrawStreamBase(rawReader)\r
 193   , fSM()\r
 194   , fStack(0)\r
 195   , fHC(0)\r
 196   , fMCM(0)\r
 197   , fADC(0)\r
 198   , fpPos(0)\r
 199   , fpBegin(0)\r
 200   , fpEnd(0)\r
 201   , fWordLength(0)\r
 202   , fStackNumber(-1)\r
 203   , fStackLinkNumber(-1)\r
 204   , fhcMCMcounter(0)\r
 205   , fmcmADCcounter(0)\r
 206   , fLinkTrackletCounter(-1)\r
 207   , fEndOfTrackletCount(-1)\r
 208   , fNWordsCounter(-1)\r
 209   , fMaskADCword(0)\r
 210   , fTbinADC(0)\r
 211   , fDecodedADCs(-1)\r
 212   , fEventCounter(0)\r
 213   , fLastEventCounter(0)\r
 214   , fSharedPadsOn(kFALSE)\r
 215   , fMaxADCgeom(0)\r
 216   , fBufferRead(0)\r
 217   , fGeometry(0)\r
 218   , fRawReader(rawReader)\r
 219   , fTRDfeeParam(0)\r
 220 {\r
 221   //\r
 222   // default constructor\r
 223   //\r
 224   if (fRawReader)\r
 225     {     \r
 226       if (Init() == kFALSE)\r
 227   {\r
 228     AliWarning("Unable to Init. Try setting up the reader with SetReader or buffer with Init(void *, UInt_t )");          \r
 229   }\r
 230     }\r
 231   else\r
 232     {\r
 233       AliWarning("Unable to setup reader. Use SetReader(AliRawReader*).");\r
 234     }\r
 235 }\r
 236 \r
 237 //------------------------------------------------------------\r
 238 \r
 239 AliTRDrawStream::AliTRDrawStream(const AliTRDrawStream& /*st*/)\r
 240   : AliTRDrawStreamBase()\r
 241   , fSM()\r
 242   , fStack(0)\r
 243   , fHC(0)\r
 244   , fMCM(0)\r
 245   , fADC(0)\r
 246   , fpPos(0)\r
 247   , fpBegin(0)\r
 248   , fpEnd(0)\r
 249   , fWordLength(0)\r
 250   , fStackNumber(-1)\r
 251   , fStackLinkNumber(-1)\r
 252   , fhcMCMcounter(0)\r
 253   , fmcmADCcounter(0)\r
 254   , fLinkTrackletCounter(-1)\r
 255   , fEndOfTrackletCount(-1)\r
 256   , fNWordsCounter(-1)\r
 257   , fMaskADCword(0)\r
 258   , fTbinADC(0)\r
 259   , fDecodedADCs(-1)\r
 260   , fEventCounter(0)\r
 261   , fLastEventCounter(0)\r
 262   , fSharedPadsOn(kFALSE)\r
 263   , fMaxADCgeom(0)\r
 264   , fBufferRead(0)\r
 265   , fGeometry(0)\r
 266   , fRawReader(0)\r
 267   , fTRDfeeParam(0)\r
 268 {\r
 269   //\r
 270   // Copy constructor\r
 271   // \r
 272   AliError("Not implemeneted.");\r
 273 }\r
 274 \r
 275 //------------------------------------------------------------\r
 276 Bool_t AliTRDrawStream::SetRawVersion(Int_t fraw)\r
 277 {\r
 278   //\r
 279   // function provided for backward compatibility\r
 280   //\r
 281   AliWarning("Raw data version is read from raw data stream! No point of setting it in here.");\r
 282   fraw = 0; // avoid warnings\r
 283   return kFALSE;\r
 284 }\r
 285 \r
 286 //------------------------------------------------------------\r
 287 AliTRDrawStream::~AliTRDrawStream()\r
 288 {\r
 289   //\r
 290   // destructor\r
 291   //\r
 292   delete fGeometry;\r
 293 }\r
 294 \r
 295 //------------------------------------------------------------\r
 296 \r
 297 AliTRDrawStream &\r
 298 AliTRDrawStream::operator=(const AliTRDrawStream &)\r
 299 {\r
 300   //\r
 301   // we are not using this functionality\r
 302   //\r
 303   AliFatal("May not use.");\r
 304   return *this;\r
 305 }\r
 306 \r
 307 //___________________________________________________________\r
 308 void \r
 309 AliTRDrawStream::SwapOnEndian()\r
 310 {\r
 311   //\r
 312   // Check the endian and swap if needed\r
 313   //\r
 314   int itemp = 1;\r
 315   char* ptemp = (char*) &itemp;\r
 316   if (ptemp[0] != 1)\r
 317     {\r
 318       if (fgDebugFlag) AliDebug(8, "Swapping.");\r
 319 \r
 320       fpPos = fpBegin;\r
 321       UInt_t iutmp = 0;\r
 322       while (fpPos < fpEnd)\r
 323   {\r
 324     fpPos += 1;\r
 325     iutmp = (((*fpPos & 0x000000ffU) << 24) | ((*fpPos & 0x0000ff00U) <<  8) |\r
 326       ((*fpPos & 0x00ff0000U) >>  8) | ((*fpPos & 0xff000000U) >> 24));\r
 327     // here we override the value in the buffer!\r
 328     *fpPos = iutmp;       \r
 329   }\r
 330       fpPos = fpBegin;\r
 331     }\r
 332 }\r
 333 \r
 334 //------------------------------------------------------------\r
 335 Bool_t\r
 336 AliTRDrawStream::DumpWords(UInt_t *px, UInt_t iw, UInt_t marker)\r
 337 {\r
 338     //UInt_t iEnd = iw;\r
 339     //if ( iw ==0 ) iEnd = (fpEnd - px)/sizeof(UInt_t); // if iw is 0, dump all words\r
 340 \r
 341   TString tsreturn = Form("\n[ Dump Sequence at 0x%08x ] : ", px);\r
 342   for (UInt_t i = 0; i < iw; i++)\r
 343   //for (UInt_t i = 0; i < iEnd; i++)\r
 344     {\r
 345       if ( iw != 0 && px + iw > fpEnd) return kFALSE;\r
 346 \r
 347       if (i % 8 == 0) tsreturn += "\n                              ";\r
 348       if (marker != 0 && marker == px[i]) tsreturn += Form(" *>0x%08x<* ", px[i]);\r
 349       else tsreturn += Form("0x%08x ", px[i]);\r
 350     }\r
 351   tsreturn += "\n";\r
 352 \r
 353   AliInfo(tsreturn.Data());\r
 354 \r
 355   return kTRUE;\r
 356 }\r
 357 \r
 358 //------------------------------------------------------------\r
 359 Bool_t \r
 360 AliTRDrawStream::SkipWords(UInt_t iw)\r
 361 {\r
 362   //\r
 363   // Skip words corresponding to iw\r
 364   //\r
 365   if ( fpPos + iw < fpEnd )\r
 366     {\r
 367       fpPos += iw;\r
 368       return kTRUE;\r
 369     }\r
 370   else\r
 371     {\r
 372       if (fgWarnError) AliWarning(Form("Skip %d words failed. %d available", iw, fpEnd - fpPos - 1));\r
 373       return kFALSE;\r
 374     }\r
 375 \r
 376   return kTRUE;\r
 377 }\r
 378 \r
 379 //------------------------------------------------------------\r
 380 Bool_t \r
 381 AliTRDrawStream::SetReader(AliRawReader * reader)\r
 382 {\r
 383   //\r
 384   // Set reader pointer\r
 385   //\r
 386 \r
 387   if (reader != 0)\r
 388     {\r
 389       fRawReader = reader;\r
 390       if (fRawReader)\r
 391   {       \r
 392     return Init();\r
 393   }\r
 394       else\r
 395   {\r
 396     AliWarning("Unable to setup reader.");\r
 397     return kFALSE;\r
 398   }\r
 399     }\r
 400   else\r
 401     {\r
 402       AliWarning("AliRawReader argument is 0.");\r
 403       fRawReader = 0;\r
 404     }\r
 405 \r
 406   return kFALSE;\r
 407 }\r
 408 \r
 409 //------------------------------------------------------------\r
 410 Int_t \r
 411 AliTRDrawStream::NextBuffer()\r
 412 {\r
 413   //\r
 414   // return -1 if no more buffers available\r
 415   // return  0 DecodeSM failed (clean data required for example) but still maybe more data to come\r
 416   // return  1 DecodeSM OK\r
 417   // \r
 418 \r
 419   if (fRawReader != 0)\r
 420     {\r
 421       UChar_t *buffer = 0;\r
 422       UInt_t length = 0;\r
 423       Bool_t kBufferSet = fRawReader->ReadNextData(buffer);\r
 424       if (kBufferSet == kTRUE)\r
 425   {\r
 426     if (fgDebugFlag)  AliDebug(9, "Buffer is set.");\r
 427     length = fRawReader->GetDataSize();\r
 428     if (fgExtraSkip == kTRUE)\r
 429       {\r
 430         buffer += EXTRA_LEAD_WORDS * WORD_SIZE;\r
 431         length -= EXTRA_LEAD_WORDS * WORD_SIZE;\r
 432       }\r
 433 \r
 434     if (fgSkipCDH == kTRUE)\r
 435       {\r
 436         buffer += CDH_WORDS * WORD_SIZE;\r
 437         length -= CDH_WORDS * WORD_SIZE;              \r
 438       }\r
 439 \r
 440     if (length > 0)\r
 441       {\r
 442         if (fgDebugFlag)  AliDebug(9, Form("Buffer length : %d", length));\r
 443               if (fgEnableMemoryReset) ResetMemory(); //[mj]\r
 444         if (DecodeSM((void*)buffer, length) == kTRUE)\r
 445     return 1;\r
 446         else\r
 447     return 0;\r
 448       }\r
 449   }\r
 450       else\r
 451   {\r
 452     return -1;\r
 453   }\r
 454     }\r
 455 \r
 456   return -1;\r
 457 }\r
 458 \r
 459 //------------------------------------------------------------\r
 460 void \r
 461 AliTRDrawStream::ResetCounters()\r
 462 {\r
 463   //\r
 464   // reset some global counters\r
 465   //\r
 466   fBufferRead = kFALSE; // important to read buffer\r
 467 \r
 468   fStackNumber = 0;\r
 469   fStackLinkNumber = 0;\r
 470   fDecodedADCs = 0;\r
 471 \r
 472   fSM.fActiveStacks = 0;\r
 473   fSM.fNexpectedHalfChambers = 0;\r
 474 \r
 475   fLinkTrackletCounter = 0;\r
 476   fLastEventCounter = 0;\r
 477   fEventCounter = 0;\r
 478 }\r
 479 \r
 480 //------------------------------------------------------------\r
 481 void \r
 482 AliTRDrawStream::ResetIterators()\r
 483 {\r
 484   //\r
 485   // reset data which should be reset every sm\r
 486   //\r
 487   fStackNumber = 0;     // reset for Next() function \r
 488   fStackLinkNumber = 0; // reset for Next() function\r
 489   fhcMCMcounter = 0;  \r
 490   fmcmADCcounter = 0;\r
 491 }\r
 492 \r
 493 //------------------------------------------------------------\r
 494 void\r
 495 AliTRDrawStream::ResetPerSM()\r
 496 {\r
 497   //\r
 498   // reset every SM\r
 499   //\r
 500 \r
 501   fSM.fHeaderSize = 0;\r
 502   fSM.fTrackletEnable = kFALSE;\r
 503   fSM.fCorrupted = 0;\r
 504   fSM.fNexpectedHalfChambers = 0;\r
 505   fSM.fNexpectedHalfChambers = 0;\r
 506   fSM.fClean = kTRUE;\r
 507   fSM.fPos = NULL;\r
 508   for (Int_t i=0; i<5; i++){\r
 509     fSM.fStackActive[i] = kFALSE;\r
 510   }\r
 511 }     \r
 512 \r
 513 //------------------------------------------------------------\r
 514 void\r
 515 AliTRDrawStream::ResetPerStack()\r
 516 {\r
 517   //\r
 518   // reset every Stack\r
 519   //\r
 520 \r
 521   fStack->fHeaderSize = 0;\r
 522   fStack->fActiveLinks = 0;\r
 523   fStack->fPos = NULL;\r
 524   for (Int_t i=0; i<12; i++){\r
 525     fStack->fLinksActive[i] = kFALSE;\r
 526     fStack->fLinksDataType[i] = 0;\r
 527     fStack->fLinksMonitor[i] = 0;\r
 528     fStack->fLinkMonitorError[i] = 0;\r
 529   }\r
 530 }\r
 531 \r
 532 //------------------------------------------------------------\r
 533 void \r
 534 AliTRDrawStream::ResetPerHC()\r
 535 {\r
 536   //\r
 537   // reset every HC\r
 538   //\r
 539   fEventCounter = 0;\r
 540   fHC->fTrackletError = 0;\r
 541   fHC->fNTracklets = 0;\r
 542   fHC->fSpecialRawV = 0;\r
 543   fHC->fRawVMajor = 0;\r
 544   fHC->fRawVMajorOpt = 0;\r
 545   fHC->fRawVMinor = 0;\r
 546   fHC->fNExtraWords = 0;\r
 547   fHC->fDCSboard = 0;\r
 548   fHC->fSM = 0;\r
 549   fHC->fStack = 0;\r
 550   fHC->fLayer = 0;\r
 551   fHC->fSide = 0;\r
 552   fHC->fTimeBins = 0;\r
 553   fHC->fBunchCrossCounter = 0;\r
 554   fHC->fPreTriggerCounter = 0;\r
 555   fHC->fPreTriggerPhase = 0;\r
 556   fHC->fDET = 0;\r
 557   fHC->fROC = 0;\r
 558   fHC->fRowMax = 0;\r
 559   fHC->fColMax = 0;\r
 560   fHC->fMCMmax = 0;\r
 561 \r
 562   fHC->fH0Corrupted = 0;\r
 563   fHC->fH1Corrupted = 0;\r
 564   fHC->fCorrupted = 0;\r
 565 }\r
 566 \r
 567 //------------------------------------------------------------\r
 568 void\r
 569 AliTRDrawStream::ResetPerMCM()\r
 570 {\r
 571   //\r
 572   // reset every MCM \r
 573   //\r
 574   fMCM->fROB = 0;\r
 575   fMCM->fMCM = 0;\r
 576   fMCM->fROW = 0;\r
 577   fMCM->fEvCounter = 0;\r
 578   fMCM->fADCMask = 0;\r
 579   fMCM->fADCMaskWord = 0;\r
 580   fMCM->fADCmax = 0;\r
 581   fMCM->fADCcount = 0;\r
 582   fMCM->fMCMADCWords = 0;\r
 583   fMCM->fSingleADCwords = 0;\r
 584   fMCM->fMCMhdCorrupted = 0;\r
 585   fMCM->fADCmaskCorrupted = 0;\r
 586   fMCM->fCorrupted = 0;\r
 587   fMCM->fPos = NULL;\r
 588   fMCM->fAdcDataPos = NULL;\r
 589   fMCM->fADCcounter = 0;\r
 590 \r
 591   memset(fMCM->fADCchannel, 0, TRD_MAX_ADC*sizeof(UInt_t));\r
 592 }\r
 593 \r
 594 //------------------------------------------------------------\r
 595 void\r
 596 AliTRDrawStream::ResetPerADC()\r
 597 {\r
 598   //\r
 599   // reset every ADC \r
 600   //\r
 601   fADC->fPos = NULL;\r
 602   fADC->fADCnumber = 0;\r
 603   fADC->fCOL = 0;\r
 604   fADC->fIsShared = kTRUE;\r
 605   fADC->fCorrupted = 0;\r
 606 \r
 607   memset(fADC->fSignals, 0, TRD_MAX_TBINS*sizeof(Int_t));\r
 608 }\r
 609 \r
 610 //------------------------------------------------------------\r
 611 void\r
 612 AliTRDrawStream::ResetMemory()\r
 613 {                 \r
 614   //              \r
 615   // initialize all the data members to prevent read data\r
 616   // from previous buffer\r
 617   //              \r
 618   ResetPerSM();\r
 619   for (Int_t istack=0; istack<5; istack++){\r
 620     fStack = &fSM.fStacks[istack];\r
 621     ResetPerStack();\r
 622     for (Int_t ilink=0; ilink<12; ilink++){\r
 623         fHC = &fStack->fHalfChambers[ilink];\r
 624         ResetPerHC();\r
 625         for (Int_t imcm=0; imcm<TRD_MAX_MCM; imcm++){\r
 626           fMCM = &fHC->fMCMs[imcm];\r
 627           ResetPerMCM();\r
 628           for (Int_t iadc=0; iadc<TRD_MAX_ADC; iadc++){\r
 629               fADC = &fMCM->fADCs[iadc];\r
 630               ResetPerADC();\r
 631           }\r
 632         }\r
 633     }      \r
 634   }\r
 635 }         \r
 636 \r
 637 //------------------------------------------------------------\r
 638 \r
 639 Bool_t \r
 640 AliTRDrawStream::Next()\r
 641 {\r
 642   //\r
 643   // returns with true on next adc read\r
 644   // returns false on errors and end of buffer\r
 645   // \r
 646 if (fBufferRead)\r
 647   {\r
 648 \r
 649     while (fStackNumber < 5 && fSM.fActiveStacks > 0)\r
 650       {\r
 651         if(fSM.fStackActive[fStackNumber] == kTRUE)\r
 652     {\r
 653       fStack = &fSM.fStacks[fStackNumber];\r
 654       while (fStackLinkNumber < 12)\r
 655         {\r
 656           if (fStack->fLinksActive[fStackLinkNumber] == kTRUE && fStack->fLinksMonitor[fStackLinkNumber] == 0)\r
 657       {\r
 658         fHC = &fStack->fHalfChambers[fStackLinkNumber];\r
 659         if (!fHC)\r
 660           {\r
 661             AliError(Form("HC missing at stack %d link %d", fStackNumber, fStackLinkNumber));\r
 662             return kFALSE;\r
 663           }\r
 664         if (fHC->fCorrupted == 0 && (fHC->fH0Corrupted == 0 && fHC->fH1Corrupted == 0) | !fgSkipData) // if HC data corrupted(in any case), we don't read data at all from this HC \r
 665           {\r
 666             while (fhcMCMcounter < fHC->fMCMmax)\r
 667         {\r
 668           fMCM = &fHC->fMCMs[fhcMCMcounter];\r
 669           if (!fMCM)\r
 670             {\r
 671               AliError(Form("HC missing at stack %d link %d atMCMslot %d", \r
 672                 fStackNumber, fStackLinkNumber, fhcMCMcounter));\r
 673               return kFALSE;\r
 674             }\r
 675           while(fmcmADCcounter < fMCM->fADCmax)\r
 676             {\r
 677               fADC = &fMCM->fADCs[fmcmADCcounter];\r
 678               if (!fADC)\r
 679           {\r
 680             AliError(Form("ADC missing at stack %d link %d MCMslot %d ADCslot %d", \r
 681               fStackNumber, fStackLinkNumber, fhcMCMcounter, fmcmADCcounter));\r
 682             return kFALSE;\r
 683           }\r
 684               fmcmADCcounter++;\r
 685               if (fSharedPadsOn)\r
 686           {\r
 687             return kTRUE;\r
 688           }\r
 689               else\r
 690           {\r
 691             if (fADC->fIsShared == kFALSE)\r
 692               return kTRUE;\r
 693           }\r
 694             } //while adc in MCM\r
 695           fhcMCMcounter++;\r
 696           // next MCM should go through all active ADCs\r
 697           fmcmADCcounter = 0;\r
 698         } // while mcm\r
 699           } // if HC OK\r
 700       }// if link active\r
 701           fStackLinkNumber++;\r
 702           // next stack link (HC) should go through all active MCMs\r
 703           fhcMCMcounter = 0;\r
 704         }// while links\r
 705     }// if stack active\r
 706         fStackNumber++;\r
 707         // next stack should go through all links - start from 0\r
 708         fStackLinkNumber = 0;\r
 709       }\r
 710   } // fBufferRead\r
 711 \r
 712   // in case rawreader manages the mem buffers, go for the next buffer \r
 713   if (fRawReader)\r
 714     {\r
 715       Int_t nextBuff = NextBuffer();\r
 716       while (nextBuff != -1)\r
 717     {\r
 718       if (nextBuff > 0)\r
 719               {\r
 720                 fBufferRead = kTRUE;\r
 721           return Next();                  \r
 722               }\r
 723       nextBuff = NextBuffer();\r
 724     }\r
 725     }\r
 726 \r
 727   return kFALSE;\r
 728 }\r
 729 \r
 730 //------------------------------------------------------------\r
 731 Int_t \r
 732 AliTRDrawStream::NextChamber(AliTRDdigitsManager *const digitsManager, UInt_t **trackletContainer) \r
 733 {\r
 734   //\r
 735   // Fills single chamber digit array \r
 736   // Return value is the detector number\r
 737   //\r
 738 \r
 739   //AliTRDcalibDB *cal = AliTRDcalibDB::Instance();\r
 740   AliTRDarrayADC *digits = 0;\r
 741   AliTRDarrayDictionary *track0 = 0;\r
 742   AliTRDarrayDictionary *track1 = 0;\r
 743   AliTRDarrayDictionary *track2 = 0; \r
 744   AliTRDSignalIndex *indexes = 0;\r
 745 \r
 746   // Loop through the digits\r
 747   Int_t lastdet = -1;\r
 748   Int_t det     = -1;\r
 749   Int_t lastside = -1; \r
 750   Int_t side     = -1;\r
 751   Int_t it = 0;\r
 752   Int_t ntracklets = 0;\r
 753 \r
 754   if (trackletContainer){ \r
 755     for (Int_t i = 0; i < 2; i++) \r
 756       for (Int_t j = 0; j < MAX_TRACKLETS_PERHC; j++) \r
 757           trackletContainer[i][j] = 0; \r
 758   }\r
 759 \r
 760   while (Next()) \r
 761     {      \r
 762       det    = GetDet();\r
 763       side   = GetSide();\r
 764 \r
 765       if (trackletContainer)\r
 766         {\r
 767         if ((det + side*AliTRDgeometry::kNdet) != (lastdet + lastside*AliTRDgeometry::kNdet))\r
 768         {\r
 769           if (det != lastdet)\r
 770             {\r
 771               if (lastdet != -1)\r
 772                 {\r
 773                 fmcmADCcounter--; \r
 774                 return lastdet;\r
 775                 }\r
 776             }\r
 777           ntracklets = GetNTracklets();\r
 778           if(ntracklets > 0) memcpy(trackletContainer[side], GetTrackletWords(), sizeof(UInt_t) * ntracklets); //copy tracklet words to trackletContainer array\r
 779           lastside = side; \r
 780           } \r
 781         } \r
 782 \r
 783 \r
 784       if (det != lastdet) \r
 785   { \r
 786     // If new detector found\r
 787     if (lastdet == -1)\r
 788       {\r
 789         lastdet = det;\r
 790       }\r
 791     else\r
 792       {\r
 793         fmcmADCcounter--; \r
 794         return lastdet;\r
 795       }\r
 796 \r
 797     if (det < 0 || det >= AliTRDgeometry::kNdet)\r
 798       {\r
 799         if (fSM.fClean == kTRUE)\r
 800     {\r
 801       AliError(Form("Strange Det Number %d BUT event buffer seems to be clean.", det));\r
 802     }\r
 803         else\r
 804     {\r
 805       AliError(Form("Strange Det Number %d. Event buffer marked NOT clean!", det));\r
 806     }\r
 807         continue;\r
 808       }\r
 809 \r
 810     // Add a container for the digits of this detector\r
 811     digits = (AliTRDarrayADC *) digitsManager->GetDigits(det);\r
 812 \r
 813           if (digitsManager->UsesDictionaries()) \r
 814             {\r
 815         track0 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,0);\r
 816         track1 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,1);\r
 817         track2 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,2);\r
 818       }\r
 819 \r
 820     if (!digits)\r
 821       {\r
 822         if (fSM.fClean == kTRUE)\r
 823     {\r
 824       AliError(Form("Unable to get digits for det %d BUT event buffer seems to be clean.", det));\r
 825     }\r
 826         else\r
 827     {\r
 828       AliError(Form("Unable to get digits for det %d. Event buffer is NOT clean!", det));\r
 829     }\r
 830         return -1;\r
 831       }\r
 832 \r
 833     Int_t rowMax = GetRowMax();\r
 834     Int_t colMax = GetColMax();\r
 835     Int_t ntbins = GetNumberOfTimeBins();\r
 836 \r
 837     // Allocate memory space for the digits buffer\r
 838     if (digits->GetNtime() == 0) \r
 839       {\r
 840         digits->Allocate(rowMax, colMax, ntbins);\r
 841               if (digitsManager->UsesDictionaries()) \r
 842                 {\r
 843             track0->Allocate(rowMax, colMax, ntbins);\r
 844             track1->Allocate(rowMax, colMax, ntbins);\r
 845             track2->Allocate(rowMax, colMax, ntbins);\r
 846     }\r
 847       }\r
 848 \r
 849     indexes = digitsManager->GetIndexes(det);\r
 850     indexes->SetSM(GetSM());\r
 851     indexes->SetStack(GetStack());\r
 852     indexes->SetLayer(GetLayer());\r
 853     indexes->SetDetNumber(det);\r
 854     if (indexes->IsAllocated() == kFALSE)\r
 855       indexes->Allocate(rowMax, colMax, ntbins);\r
 856   }\r
 857 \r
 858       //Char_t padStatus =  cal->GetPadStatus(det, GetCol(), GetRow());\r
 859 \r
 860       // ntimebins data are ready to read\r
 861       for (it = 0; it < GetNumberOfTimeBins(); it++)\r
 862   {\r
 863     if (GetSignals()[it] > 0)\r
 864       {\r
 865         digits->SetData(GetRow(), GetCol(), it, GetSignals()[it]);\r
 866         /*if(padStatus)\r
 867           digits->SetPadStatus(GetRow(), GetCol(), it, padStatus);*/\r
 868                 \r
 869         indexes->AddIndexRC(GetRow(), GetCol());\r
 870               if (digitsManager->UsesDictionaries()) \r
 871                 {\r
 872             track0->SetData(GetRow(), GetCol(), it, 0);\r
 873             track1->SetData(GetRow(), GetCol(), it, 0);\r
 874             track2->SetData(GetRow(), GetCol(), it, 0);\r
 875     }\r
 876       }\r
 877   } // tbins\r
 878     }// while Next()\r
 879 \r
 880   return det;\r
 881 }\r
 882 \r
 883 //------------------------------------------------------------\r
 884 Bool_t\r
 885 AliTRDrawStream::Init()\r
 886 {\r
 887   //\r
 888   // Initialize geometry and fee parameters \r
 889   //\r
 890 \r
 891   TDirectory *saveDir = gDirectory; \r
 892   \r
 893   if (!fGeometry) \r
 894     {\r
 895       fGeometry = new AliTRDgeometry();\r
 896     }\r
 897   \r
 898   if (!fGeometry) \r
 899     {\r
 900       AliError("Geometry FAILED!");\r
 901       return kFALSE;\r
 902     }\r
 903 \r
 904   fTRDfeeParam = AliTRDfeeParam::Instance();\r
 905   if (!fTRDfeeParam)\r
 906     {\r
 907       AliError("AliTRDfeeParam FAILED!");\r
 908       return kFALSE;\r
 909     }\r
 910 \r
 911   fMaxADCgeom = (Int_t)fGeometry->ADCmax();\r
 912 \r
 913   ResetCounters(); // fBufferRead is set to kFALSE - important\r
 914 \r
 915   saveDir->cd();\r
 916 \r
 917   return kTRUE;\r
 918 }\r
 919 \r
 920 //------------------------------------------------------------\r
 921 Bool_t \r
 922 AliTRDrawStream::InitBuffer(void * const buffer, UInt_t length)\r
 923 {\r
 924   // \r
 925   // set initial information about the buffer\r
 926   //\r
 927 \r
 928   if (fgDebugFlag)  AliDebug(5, Form("Equipment ID: %d",fRawReader->GetEquipmentId()));\r
 929   if (fRawReader->GetEquipmentId()<1024 || fRawReader->GetEquipmentId()>1041) //tmp protection\r
 930     return kFALSE; \r
 931 \r
 932   ResetCounters();\r
 933 \r
 934   fpBegin = (UInt_t *)buffer;\r
 935 \r
 936   if (WORD_SIZE == 0)\r
 937     {\r
 938       AliFatal("Strange word size. size of UInt_t == 0");\r
 939       return kFALSE;\r
 940     }\r
 941 \r
 942   fWordLength = length/WORD_SIZE;\r
 943   fpEnd = fpBegin + fWordLength;\r
 944   fpPos = fpBegin;\r
 945 \r
 946   if (fpBegin == 0 || length <= 0)\r
 947     {\r
 948       AliError(Form("Buffer size or pointer is strange. pointer to the buffer is 0x%08x of size %d", fpBegin, length));\r
 949       return kFALSE;\r
 950     }\r
 951 \r
 952   SwapOnEndian();\r
 953 \r
 954   if (fgDumpHead >= 0){\r
 955     if ( fgDumpHead == 0 ){ // dump all words\r
 956         AliInfo(Form("---------- Dumping all words from the beginnig of the buffer ----------"));\r
 957         if (DumpWords(fpBegin, fWordLength) == kFALSE) AliError("Dump failed. Not enough data.");\r
 958     } else {\r
 959         AliInfo(Form("---------- Dumping %u words from the beginnig of the buffer ----------",fgDumpHead));\r
 960         if (DumpWords(fpBegin, fgDumpHead) == kFALSE) AliError("Dump failed. Not enough data.");\r
 961     }\r
 962     AliInfo(Form("---------- Dumping ended ----------------------------------------------"));\r
 963   }\r
 964 \r
 965   return kTRUE;\r
 966 }\r
 967 \r
 968 //------------------------------------------------------------\r
 969 Bool_t \r
 970 AliTRDrawStream::DecodeGTUheader()\r
 971 {\r
 972   // Decode Supermodule Index Word\r
 973   DecodeSMInfo(fpPos, &fSM);\r
 974 \r
 975   if (fgDebugFlag)  AliDebug(5, DumpSMInfo(&fSM));\r
 976 \r
 977   fpPos++;\r
 978   if (fpPos < fpEnd)\r
 979     {   \r
 980       // fSM.fHeaderSize represent additional Supermodule header size which contains additional information regarding hardware design.\r
 981       // For the moment, we skip decoding these words \r
 982       if (SkipWords(fSM.fHeaderSize) == kTRUE)\r
 983   {\r
 984     for (Int_t istack = 0; istack < 5; istack++)\r
 985       {\r
 986         if (fSM.fStackActive[istack] == kFALSE)\r
 987     continue;\r
 988 \r
 989         fStack = &fSM.fStacks[istack];\r
 990 \r
 991               // Decode Stack Index Word of given stack\r
 992         DecodeStackInfo(fpPos, fStack);\r
 993         fpPos++;\r
 994 \r
 995         fSM.fNexpectedHalfChambers += fStack->fActiveLinks;\r
 996         \r
 997         if (fgDebugFlag)  AliDebug(5, DumpStackInfo(fStack));\r
 998         \r
 999         if (SkipWords(fStack->fHeaderSize-6) == kFALSE) // 6 is the 6 stack header words for 12 links \r
1000     {\r
1001       if (fRawReader) fRawReader->AddMajorErrorLog(kDecodeStackInfo, "Stack header words missing");\r
1002       return kFALSE;\r
1003     }\r
1004               for (Int_t iword=0; iword<6; iword++) // decode 6 stack header words\r
1005                 {\r
1006                   // Decode Stack Header Word of given stack\r
1007             DecodeStackHeader(fpPos, fStack, iword); \r
1008             fpPos++;\r
1009                 }\r
1010       }\r
1011   }\r
1012       else\r
1013   {\r
1014     return kFALSE;\r
1015   }\r
1016     }\r
1017   else\r
1018     {\r
1019       if (fgWarnError) AliWarning("No additional sm headers and stack index words present.");\r
1020       if (fRawReader) fRawReader->AddMajorErrorLog(kDecodeStackInfo, "Stack info missing");\r
1021       return kFALSE;\r
1022     }\r
1023 \r
1024   if (fpPos < fpEnd)\r
1025     {\r
1026       if (fgDebugFlag)  AliDebug(5, "GTU headers are OK.");\r
1027     }\r
1028   else\r
1029     {\r
1030       if (fgWarnError) AliWarning("No data just after GTU headers.");\r
1031       if (fRawReader) fRawReader->AddMajorErrorLog(kMissingData, "Missing sm data");\r
1032       return kFALSE;\r
1033     }\r
1034 \r
1035   if (fgDebugFlag)  AliDebug(5, Form("Expected half chambers from GTU header: %d", fSM.fNexpectedHalfChambers));\r
1036 \r
1037   return kTRUE;\r
1038 }\r
1039 \r
1040 //------------------------------------------------------------\r
1041 Bool_t \r
1042 AliTRDrawStream::DecodeSM(void * const buffer, UInt_t length)\r
1043 {\r
1044   //\r
1045   // decode one sm data in buffer\r
1046   //\r
1047   \r
1048   ResetIterators(); \r
1049 \r
1050   fSM.fClean = kTRUE;\r
1051   if (InitBuffer(buffer, length) == kFALSE)\r
1052     {\r
1053       if (fgWarnError) AliError("InitBuffer failed.");      \r
1054       fSM.fClean = kFALSE;\r
1055       return kFALSE;\r
1056     }\r
1057 \r
1058   if (DecodeGTUheader()== kFALSE)\r
1059     return kFALSE;\r
1060 \r
1061   for (Int_t istack = 0; istack < 5; istack++)\r
1062     {\r
1063       fStackNumber = istack; \r
1064       if (fSM.fStackActive[istack] == kFALSE)\r
1065   continue;\r
1066       \r
1067       fStack = &fSM.fStacks[istack];\r
1068 \r
1069       fgLastHC  = -1; // to check rob number odering \r
1070       for (Int_t ilink = 0; ilink < 12; ilink++)\r
1071   {\r
1072     fStackLinkNumber = ilink; \r
1073     if (fStack->fLinksActive[ilink] == kFALSE)\r
1074       continue;\r
1075 \r
1076           // check GTU link monitor \r
1077           if (!(fStack->fLinksDataType[ilink] == 0 && fStack->fLinksMonitor[ilink] == 0))\r
1078             {\r
1079               fStack->fLinkMonitorError[ilink] = 1;\r
1080               SeekEndOfData(); // skip this HC data if GTU link monitor report error\r
1081               fStack->fLinkMonitorError[ilink] += fNWordsCounter; // counts words of given hc having link monitor error\r
1082               continue; \r
1083             }\r
1084 \r
1085     if (fpPos >= fpEnd)\r
1086       {\r
1087         if (fRawReader) fRawReader->AddMajorErrorLog(kLinkDataMissing, "Link data missing");          \r
1088               if (fgWarnError) AliError("Link data missing.");      \r
1089         fSM.fClean = kFALSE;\r
1090         break;\r
1091       }\r
1092 \r
1093     fHC = &fStack->fHalfChambers[ilink];\r
1094           ResetPerHC();\r
1095 \r
1096     if (fSM.fTrackletEnable == kTRUE)\r
1097       {\r
1098         if (DecodeTracklets() == kFALSE)\r
1099     {\r
1100       \r
1101       fSM.fClean = kFALSE;\r
1102       SeekEndOfData();\r
1103 \r
1104       if (fgWarnError) \r
1105         {\r
1106           AliError(Form("Tracklet decoding failed stack %d link %d", fStackNumber, fStackLinkNumber));\r
1107         }\r
1108       continue;\r
1109     }\r
1110       }\r
1111 \r
1112     if (fpPos >= fpEnd)\r
1113       {\r
1114         if (fRawReader) fRawReader->AddMajorErrorLog(kHCdataMissing, "HC data missing");              \r
1115               if (fgWarnError) AliError("HC data missing.");      \r
1116         fSM.fClean = kFALSE;\r
1117         break;\r
1118       }\r
1119     \r
1120           fgLastROB   = -1; // to check mcm number odering \r
1121           fgLastIndex = -1 ; // to check mcm number odering \r
1122     if (DecodeHC() == kFALSE)\r
1123       {\r
1124         fSM.fClean = kFALSE;\r
1125               if (fHC->fCorrupted < 16)  SeekEndOfData(); // In case that we meet END_OF_TRACKLET_MARKERNEW \r
1126                                                           // during ADC data decoding or MCM header decoding\r
1127                                                           // we don't seek ENDOFRAWDATAMARKER\r
1128 \r
1129         if (fgWarnError) \r
1130     {\r
1131       AliError(Form("Failed HC : %s", DumpHCinfoH0(fHC)));\r
1132       AliError(Form("Failed HC : %s", DumpHCinfoH1(fHC)));\r
1133     }\r
1134                 \r
1135         continue;\r
1136       }\r
1137     else\r
1138       {\r
1139         SeekEndOfData(); // make sure that finish off with the end of data markers\r
1140       }\r
1141 \r
1142   } // ilink\r
1143     } // istack\r
1144 \r
1145   ResetIterators(); // need to do it again for Next() function \r
1146 \r
1147   if (fSM.fClean == kTRUE)\r
1148     return kTRUE;\r
1149   \r
1150   if (fgCleanDataOnly && (fSM.fClean == kFALSE))\r
1151     {\r
1152       if (fgWarnError) \r
1153   {\r
1154     AliWarning("Buffer with errors. Returning FALSE.");\r
1155     AliWarning(Form("--- Failed SM : %s ---", DumpSMInfo(&fSM)));\r
1156   }\r
1157       fSM.fActiveStacks = 0; // Next() will not give data\r
1158       return kFALSE;\r
1159     }\r
1160 \r
1161   return kTRUE;\r
1162 }\r
1163 \r
1164 //------------------------------------------------------------\r
1165 Int_t \r
1166 AliTRDrawStream::DecodeSM()\r
1167 {\r
1168   //\r
1169   // decode SM data in case AliRawReader is in use\r
1170   //    \r
1171   if (fRawReader)\r
1172     {      \r
1173       Int_t nextBuff = NextBuffer();\r
1174       while (nextBuff != -1)\r
1175   {\r
1176     if (nextBuff > 0)\r
1177       return nextBuff;            \r
1178     nextBuff = NextBuffer();\r
1179   }\r
1180       return -1;\r
1181     }\r
1182   else\r
1183     {\r
1184       AliWarning("AliRawReader not set.");\r
1185     }\r
1186   return kFALSE;\r
1187 }\r
1188 \r
1189 //------------------------------------------------------------\r
1190 Int_t \r
1191 AliTRDrawStream::DecodeSM(AliRawReader *reader)\r
1192 {\r
1193   //\r
1194   // decode SM with the AliRawReader\r
1195   //\r
1196   if (reader != 0)\r
1197     {\r
1198       fRawReader = reader;\r
1199       return DecodeSM();\r
1200     }\r
1201   else\r
1202     {\r
1203       AliWarning("Argument AliRawReader is 0.");\r
1204     }\r
1205   return kFALSE;\r
1206 }\r
1207 \r
1208 //------------------------------------------------------------\r
1209 Bool_t \r
1210 AliTRDrawStream::SeekEndOfData()\r
1211 {\r
1212   //\r
1213   // go to end of data marker\r
1214   //\r
1215   Int_t fEndOfDataCount = 0;\r
1216   fNWordsCounter = 0;\r
1217 \r
1218   while ( *fpPos != ENDOFRAWDATAMARKER && fpPos < fpEnd )\r
1219     {\r
1220       fpPos++;\r
1221       fNWordsCounter++;\r
1222     }\r
1223   while (*fpPos == ENDOFRAWDATAMARKER && fpPos < fpEnd )\r
1224     {\r
1225       fEndOfDataCount++;\r
1226       fpPos++;      \r
1227     }\r
1228   \r
1229   return kTRUE;\r
1230 }\r
1231 \r
1232 //------------------------------------------------------------\r
1233 Bool_t\r
1234 AliTRDrawStream::SkipMCMdata(UInt_t iw)\r
1235 {\r
1236   //\r
1237   // skip mcm data words due to corruption \r
1238   //\r
1239   if (fgDebugFlag) AliDebug(11,Form("Skip %d words due to MCM header corruption.",iw));\r
1240   UInt_t iwcounter = 0;  \r
1241   while ( *fpPos != ENDOFRAWDATAMARKER && iwcounter < iw)\r
1242     {\r
1243       if ( *fpPos == END_OF_TRACKLET_MARKERNEW) \r
1244         {  \r
1245           if (fgDebugFlag) AliDebug(11,"Met END_OF_TRACKLET_MARKERNEW");\r
1246           fMCM->fCorrupted += 16;\r
1247           fHC->fCorrupted += 16;\r
1248           return kFALSE;\r
1249         } \r
1250       fpPos++;\r
1251       iwcounter++; \r
1252     }\r
1253 \r
1254   if (iwcounter == iw)\r
1255     {\r
1256       fpPos++;\r
1257       return kTRUE;\r
1258     }\r
1259 \r
1260   if (fgDebugFlag) AliDebug(11,"Met ENDOFRAWDATAMARKER");\r
1261   return kFALSE;\r
1262 }\r
1263 \r
1264 //------------------------------------------------------------\r
1265 Bool_t \r
1266 AliTRDrawStream::SeekNextMCMheader()\r
1267 {\r
1268   //\r
1269   // go to mcm marker\r
1270   //\r
1271 \r
1272   fpPos++;\r
1273 \r
1274   while ( *fpPos != ENDOFRAWDATAMARKER && fpPos < fpEnd )\r
1275     {\r
1276       if (MCM_HEADER_MASK_ERR(*fpPos) == 0 && MCM_HEADER_MASK_ERR(*(fpPos+1)) == 0)      \r
1277   {\r
1278     if (fgDebugFlag) AliDebug(11,Form("^^^ Found : Pos 0x%08x : Val 0x%08x", fpPos, *fpPos));\r
1279     return kTRUE;\r
1280   }\r
1281       if ( *fpPos == END_OF_TRACKLET_MARKERNEW) \r
1282         {  \r
1283           fMCM->fCorrupted += 16;\r
1284           fHC->fCorrupted += 16;\r
1285           return kFALSE;\r
1286         } \r
1287       fpPos++;\r
1288     }\r
1289 \r
1290   SeekEndOfData();\r
1291   return kFALSE;\r
1292 }\r
1293 \r
1294 //------------------------------------------------------------\r
1295 \r
1296 Bool_t \r
1297 AliTRDrawStream::DecodeTracklets()\r
1298 {\r
1299   //\r
1300   // decode tracklets\r
1301   //\r
1302 \r
1303   fLinkTrackletCounter = 0;\r
1304   fEndOfTrackletCount = 0;\r
1305   fHC->fNTracklets = 0;\r
1306 \r
1307   for (Int_t i = 0; i < MAX_TRACKLETS_PERHC; i++) \r
1308   fHC->fTrackletWords[i] = 0; \r
1309 \r
1310   if (fgDebugFlag)  AliDebug(10, Form("Decode tracklets at 0x%08x : 0x%08x", fpPos, *fpPos));\r
1311 \r
1312   while ( *fpPos != END_OF_TRACKLET_MARKEROLD && *fpPos != END_OF_TRACKLET_MARKERNEW && fpPos < fpEnd )\r
1313     {\r
1314       if (fgDebugFlag)  AliDebug(10, Form("Tracklet found at 0x%08x : 0x%08x", fpPos, *fpPos));\r
1315 \r
1316       fLinkTrackletCounter++;\r
1317 \r
1318       if (fLinkTrackletCounter > MAX_TRACKLETS_PERHC)\r
1319   {\r
1320     if (fgDebugFlag) AliDebug(11,Form("Max number of tracklets exceeded %d > %d.", \r
1321         fLinkTrackletCounter, MAX_TRACKLETS_PERHC));\r
1322     if (fRawReader) fRawReader->AddMajorErrorLog(kTrackletOverflow,"Too many tracklets"); \r
1323           fHC->fTrackletError = 1;\r
1324     return kFALSE;\r
1325   }\r
1326 \r
1327       fHC->fTrackletWords[fLinkTrackletCounter-1] = UInt_t(*fpPos); //store tracklet words into array  \r
1328       fHC->fNTracklets = fLinkTrackletCounter;\r
1329       fpPos++;\r
1330     }\r
1331 \r
1332   while ( ( *fpPos == END_OF_TRACKLET_MARKEROLD || *fpPos == END_OF_TRACKLET_MARKERNEW ) && fpPos < fpEnd )\r
1333     {\r
1334       if (fgDebugFlag)  AliDebug(10, Form("EoTracklets found at 0x%08x : 0x%08x", fpPos, *fpPos));\r
1335 \r
1336       fEndOfTrackletCount++;\r
1337       fpPos++;\r
1338     }\r
1339 \r
1340   if ( fEndOfTrackletCount < 2 )\r
1341     {\r
1342       if (fgDebugFlag) AliDebug(11,"End of tracklets word missing"); \r
1343       if (fRawReader) fRawReader->AddMajorErrorLog(kEOTrackeltsMissing, "End of tracklets word missing"); \r
1344       fHC->fTrackletError += 2;\r
1345       return kFALSE;\r
1346     }\r
1347 \r
1348   return kTRUE;\r
1349 }\r
1350 \r
1351 //------------------------------------------------------------\r
1352 Bool_t \r
1353 AliTRDrawStream::IsRowValid()\r
1354 {\r
1355   if ( (fHC->fStack == 2 && fMCM->fROW >= fGeometry->RowmaxC0()) ||\r
1356       (fHC->fStack != 2 && fMCM->fROW >= fGeometry->RowmaxC1()) || fMCM->fROW < 0 ) \r
1357     {\r
1358       if (fgDebugFlag) AliDebug(11,Form("SM%d L%dS%d: Wrong Padrow (%d) fROB=%d, fSIDE=%d, fMCM=%02d"\r
1359           , fHC->fSM, fHC->fLayer, fHC->fStack, fMCM->fROW, fMCM->fROB, fHC->fSide, fMCM->fMCM ));\r
1360       return kFALSE;\r
1361     }\r
1362   return kTRUE;\r
1363 }\r
1364 \r
1365 //------------------------------------------------------------\r
1366 Bool_t \r
1367 AliTRDrawStream::IsMCMheaderOK()\r
1368 {\r
1369   //\r
1370   // check the mcm header\r
1371   //\r
1372 \r
1373   if (fgLastROB != fMCM->fROB) \r
1374     {\r
1375       fgLastIndex = 0;\r
1376       if (fgLastROB== -1) fgLastROB = fMCM->fROB;\r
1377     }\r
1378   else\r
1379     {\r
1380       Int_t matchingcounter = 0; \r
1381       for (Int_t i=fgLastIndex+1; i<16; i++)\r
1382         { \r
1383           if ( fMCM->fMCM == fgMCMordering[i] )\r
1384             {\r
1385               fgLastIndex = i;\r
1386               matchingcounter++;\r
1387               break;\r
1388             }\r
1389         }\r
1390       if (matchingcounter == 0)   \r
1391         {\r
1392           fMCM->fMCMhdCorrupted += 2;\r
1393           AliDebug(11,Form("MCM number from last MCM is larger: MCM # from last MCM %d,  MCM # from current MCM %d \n",(fMCM-1)->fMCM, fMCM->fMCM));\r
1394         }\r
1395     }\r
1396 \r
1397   if ( fgLastHC == fHC->fLayer*2 + fHC->fSide )\r
1398     {\r
1399       if ( fMCM->fROB < (fMCM-1)->fROB )\r
1400         {\r
1401         fMCM->fMCMhdCorrupted += 2;\r
1402         AliDebug(11,Form("ROB number from last MCM is larger: ROB # from last MCM %d,  ROB # from current MCM %d \n",(fMCM-1)->fROB, fMCM->fROB));\r
1403         }\r
1404       else fgLastROB = fMCM->fROB; \r
1405     }\r
1406 \r
1407   fgLastHC = fHC->fLayer*2 + fHC->fSide; \r
1408 \r
1409   /*\r
1410   // this check will come back later again when we have "patched MCM map"\r
1411   int expectedROB = -1;\r
1412   if(!fHC->fSide) expectedROB = int(fHC->fMCMmax/16)*2;\r
1413   else expectedROB = int(fHC->fMCMmax/16)*2 + 1;\r
1414   int expectedMCM = 4*(3-int((fHC->fMCMmax%16)/4)) + fHC->fMCMmax%4;\r
1415 \r
1416   if ( expectedROB != fMCM->fROB || expectedMCM != fMCM->fMCM)\r
1417     {\r
1418       fMCM->fMCMhdCorrupted += 2;\r
1419       AliDebug(11,Form("ROB expected %d ROB read %d,  MCM expected %d MCM read %d\n",expectedROB, fMCM->fROB, expectedMCM, fMCM->fMCM));\r
1420     }\r
1421   */\r
1422 \r
1423   // below two conditions are redundant  \r
1424   /*\r
1425   if ( fMCM->fMCM < 0 || fMCM->fMCM > 15 || fMCM->fROB < 0 || fMCM->fROB > 7 ) \r
1426     {\r
1427       fMCM->fMCMhdCorrupted += 8;  // need to assign new number\r
1428       if (fgDebugFlag) AliDebug(11,Form("ROB or MCM number is out of range. %s\n", DumpMCMinfo(fMCM)));\r
1429     }\r
1430   if (IsRowValid() == kFALSE)\r
1431     {\r
1432       fMCM->fMCMhdCorrupted += 16; // need to assign new number\r
1433     }\r
1434   */  \r
1435     \r
1436   if (fEventCounter == 0)\r
1437     {\r
1438       fEventCounter = fMCM->fEvCounter;\r
1439     }\r
1440 \r
1441   if (fEventCounter != fMCM->fEvCounter)\r
1442     {\r
1443       fMCM->fMCMhdCorrupted += 4;      if (fgDebugFlag) AliDebug(11,Form("Event number(%d) of current MCM is different from that(%d) of reference MCM %s.\n", fMCM->fEvCounter, fEventCounter, DumpMCMinfo(fMCM)));\r
1444     }\r
1445 \r
1446   if (fEventCounter < fLastEventCounter)\r
1447     {\r
1448       fMCM->fMCMhdCorrupted += 8;      if (fgDebugFlag) AliDebug(11,Form("Event from the past? Current %d Last %d %s.\n", fEventCounter, fLastEventCounter, DumpMCMinfo(fMCM)));\r
1449     }\r
1450 \r
1451   if ( fMCM->fADCmaskCorrupted > 0 )\r
1452       return kFALSE;\r
1453 \r
1454   if ( fMCM->fMCMhdCorrupted > 0 )\r
1455       return kFALSE;\r
1456 \r
1457   return kTRUE;\r
1458 }\r
1459 \r
1460 //------------------------------------------------------------\r
1461 Bool_t \r
1462 AliTRDrawStream::DecodeMCMheader()\r
1463 {\r
1464   //\r
1465   // decode the mcm header\r
1466   //\r
1467 \r
1468   DecodeMCMheader(fpPos, fMCM); \r
1469 \r
1470   if (fgDumpingEnable) \r
1471     {\r
1472       if (fMCM->fMCM == fgDumpingMCM) \r
1473         {\r
1474           if (fMCM->fROB == fgDumpingROB && fHC->fLayer == fgDumpingLayer)\r
1475             {\r
1476               if (fHC->fSM == fgDumpingSM && fHC->fStack == fgDumpingStack)\r
1477                 { \r
1478                   if (fgDebugFlag) {\r
1479                     AliDebug(5,DumpHCinfoH0(fHC));\r
1480                     AliDebug(5,DumpMCMinfo(fMCM));\r
1481                   }\r
1482                   DumpWords(fpPos, 212);\r
1483                 }  \r
1484             }\r
1485         }\r
1486     }\r
1487 \r
1488   if (fHC->fCorrupted >= 16)\r
1489     {\r
1490       fpPos--; \r
1491       return kFALSE;\r
1492     }\r
1493 \r
1494   fMCM->fROW = fTRDfeeParam->GetPadRowFromMCM(fMCM->fROB, fMCM->fMCM); \r
1495 \r
1496   if ((fHC->fRawVMajor > 2 && fHC->fRawVMajor <5) || ((fHC->fRawVMajor & 32) == 32)) //cover old and new version definition of ZS data\r
1497     {\r
1498       fpPos++;\r
1499       if ( fpPos < fpEnd )\r
1500   {\r
1501     DecodeMask(fpPos, fMCM); \r
1502           if (fHC->fCorrupted >= 16)\r
1503             {\r
1504               fpPos--; \r
1505               return kFALSE;\r
1506             }\r
1507     MCMADCwordsWithTbins(fHC->fTimeBins, fMCM);\r
1508     fMCM->fAdcDataPos = fpPos + 1;\r
1509   }\r
1510       else\r
1511   {\r
1512     if (fgDebugFlag) AliDebug(11,"Expected ADC mask word. Fail due to buffer END.");      \r
1513     if (fRawReader) fRawReader->AddMajorErrorLog(kMCMADCMaskMissing,"Missing"); \r
1514           fHC->fCorrupted += 32;\r
1515     return kFALSE;\r
1516   }\r
1517     }\r
1518   else\r
1519     {\r
1520       UInt_t dummyMask = MCM_DUMMY_ADCMASK_VAL;\r
1521       DecodeMask(&dummyMask, fMCM); \r
1522       MCMADCwordsWithTbins(fHC->fTimeBins, fMCM);\r
1523       fMCM->fAdcDataPos = fpPos + 1;\r
1524     }\r
1525 \r
1526   if (fgDebugFlag)  \r
1527     {\r
1528       AliDebug(6, DumpMCMinfo(fMCM));\r
1529       AliDebug(7, DumpMCMadcMask(fMCM));\r
1530     }\r
1531 \r
1532   if (IsMCMheaderOK() == kFALSE)\r
1533       return kFALSE;\r
1534     \r
1535   return kTRUE;\r
1536 }\r
1537 \r
1538 //------------------------------------------------------------\r
1539 Bool_t \r
1540 AliTRDrawStream::IsHCheaderOK()\r
1541 {\r
1542   //\r
1543   // check insanity of half chamber header\r
1544   //\r
1545 \r
1546   if (fHC->fStack < 0 || fHC->fStack > 4)\r
1547     {\r
1548       if (fgDebugFlag) AliDebug(11,Form("Wrong Stack %d", fHC->fStack));\r
1549       return kFALSE;\r
1550     }\r
1551 \r
1552   if (fHC->fLayer < 0 || fHC->fLayer >= AliTRDgeometry::kNlayer)\r
1553     {\r
1554       if (fgDebugFlag) AliDebug(11,Form("Wrong layer %d", fHC->fLayer));\r
1555       return kFALSE;\r
1556     }\r
1557 \r
1558   if (fHC->fSide < 0 || fHC->fSide > 1)\r
1559     {\r
1560       if (fgDebugFlag) AliDebug(11,Form("Wrong Side %d", fHC->fSide));\r
1561       return kFALSE;\r
1562     }\r
1563 \r
1564   if (fgStackNumberChecker)\r
1565     {\r
1566     if (fHC->fStack != fStackNumber) \r
1567       {\r
1568         if (fgDebugFlag) AliDebug(11,Form("Missmatch: Stack number between HC header %d and GTU link mask %d", \r
1569               fHC->fStack, fStackNumber));\r
1570         fStackNumber = -1;\r
1571         return kFALSE;\r
1572     }\r
1573     }\r
1574 \r
1575   if (fgStackLinkNumberChecker)\r
1576     {\r
1577     //if (fHC->fLayer * 2 + fHC->fSide != fStackLinkNumber) \r
1578     // let it make flexible to consider known fiber swapping\r
1579     if ((fHC->fLayer * 2 != fStackLinkNumber) && (fHC->fLayer * 2 != fStackLinkNumber - 1))  \r
1580       {\r
1581         if (fgDebugFlag) AliDebug(11,Form("Missmatch: Layer number between HC header %d and GTU link mask %d | %s", \r
1582                     fHC->fLayer, fStackLinkNumber, DumpStackInfo(fStack)));\r
1583         fStackLinkNumber = -1;\r
1584         return kFALSE;      \r
1585       }\r
1586     }\r
1587 \r
1588   // SLOW GEOM : consistancy check with geometry\r
1589   fHC->fDET = fGeometry->GetDetector(fHC->fLayer, fHC->fStack, fHC->fSM);\r
1590   if (fHC->fDET < 0 || fHC->fDET >= AliTRDgeometry::kNdet)\r
1591     {\r
1592       if (fgDebugFlag) AliDebug(11,Form("Wrong detector %d", fHC->fDET));      \r
1593       if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongDet, "Wrong Det");       \r
1594       return kFALSE;\r
1595     }\r
1596 \r
1597   if (fHC->fSM != fGeometry->GetSector(fHC->fDET)\r
1598       || fHC->fSM <0 || fHC->fSM >= AliTRDgeometry::kNsector)\r
1599     {\r
1600       if (fgDebugFlag) AliDebug(11,Form("Wrong SM(sector) %d (Geometry says: %d) Stack=%d Layer=%d Det=%d", \r
1601               fHC->fSM, fGeometry->GetSector(fHC->fDET),\r
1602               fHC->fStack, fHC->fLayer, fHC->fDET));      \r
1603       if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongSM, "Wrong SM");       \r
1604       return kFALSE;\r
1605     }\r
1606 \r
1607   fHC->fROC    = fGeometry->GetDetectorSec(fHC->fLayer, fHC->fStack);\r
1608   if (fHC->fROC < 0)\r
1609     {\r
1610       if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongROC, "Wrong ROC");       \r
1611       return kFALSE;\r
1612     }\r
1613 \r
1614   fHC->fRowMax = fGeometry->GetRowMax(fHC->fLayer, fHC->fStack, fHC->fSM);\r
1615   if (fHC->fRowMax < 1)\r
1616     {\r
1617       if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongROC, "Wrong ROC Row Max");       \r
1618       return kFALSE;\r
1619     }\r
1620 \r
1621   fHC->fColMax = fGeometry->GetColMax(fHC->fROC);\r
1622   if (fHC->fColMax < 1)\r
1623     {\r
1624       if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongROC, "Wrong ROC Col Max");       \r
1625       return kFALSE;\r
1626     }\r
1627   \r
1628   return kTRUE;\r
1629 }\r
1630 \r
1631 //------------------------------------------------------------\r
1632 Bool_t \r
1633 AliTRDrawStream::DecodeHCheader()\r
1634 {  \r
1635   //\r
1636   // decode the half chamber header\r
1637   //\r
1638 \r
1639   if (DecodeHCwordH0(fpPos, fHC) == kFALSE)\r
1640     return kFALSE;\r
1641     \r
1642   if (fHC->fNExtraWords > 0)\r
1643     {\r
1644       fpPos++;\r
1645       if (fpPos < fpEnd)\r
1646   {\r
1647     if (DecodeHCwordH1(fpPos, fHC) == kFALSE)\r
1648             return kFALSE;\r
1649   }\r
1650       else\r
1651   {\r
1652     if (fgDebugFlag) AliDebug(11,"Expected HC header word 1. Fail due to buffer END.");\r
1653     if (fRawReader) fRawReader->AddMajorErrorLog(kHCWordMissing,"Next HC word 1 (count from 0) missing"); \r
1654     return kFALSE;\r
1655   }\r
1656     }\r
1657 \r
1658   if (fgDebugFlag)  AliDebug(5, DumpHCinfoH0(fHC));\r
1659   if (fgDebugFlag)  AliDebug(5, DumpHCinfoH1(fHC));\r
1660 \r
1661   fHC->fDET = -1;\r
1662   if (IsHCheaderOK() == kFALSE)\r
1663     {\r
1664       fHC->fH0Corrupted += 2;\r
1665       if (fgDebugFlag) AliDebug(11,Form("H0 Header Insane. Word 0x%08x", *fHC->fPos));\r
1666       return kFALSE;\r
1667     }\r
1668   \r
1669   return kTRUE;\r
1670 }\r
1671 \r
1672 //------------------------------------------------------------\r
1673 Bool_t \r
1674 AliTRDrawStream::DecodeHC()\r
1675 {\r
1676   //\r
1677   // decode hc header and data\r
1678   //\r
1679 \r
1680   if (DecodeHCheader() == kFALSE)\r
1681     {\r
1682       if (fgWarnError) AliWarning(Form("HC Header decode failed. H0 Error: %d H1 Error: %d",fHC->fH0Corrupted,fHC->fH1Corrupted));\r
1683       if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderCorrupt, "HC header corrupted"); \r
1684       return kFALSE;\r
1685     }\r
1686   else\r
1687     {\r
1688       fpPos++;\r
1689       if (fpPos >= fpEnd)\r
1690   {\r
1691           fHC->fCorrupted += 1;\r
1692     if (fgDebugFlag) AliDebug(11,"No MCM data? Not enough data in the buffer.");\r
1693     if (fRawReader) fRawReader->AddMajorErrorLog(kMCMdataMissing, "MCM data missing"); \r
1694     return kFALSE;\r
1695   }\r
1696     }\r
1697 \r
1698   if ((fHC->fRawVMajor & 64) == 64) // test pattern data\r
1699     {\r
1700       AliTRDrawTPStream *tpStream = new AliTRDrawTPStream(fHC->fRawVMajorOpt, fpPos);\r
1701       if (tpStream->DecodeTPdata() == kFALSE)\r
1702         {\r
1703          if (fgWarnError) AliError("failed to decode test pattern data");\r
1704          return kFALSE; \r
1705         }\r
1706       return kTRUE;\r
1707     } \r
1708 \r
1709   fHC->fMCMmax = 0;\r
1710   while (*fpPos != ENDOFRAWDATAMARKER && fpPos < fpEnd)\r
1711     {\r
1712       if (fHC->fMCMmax > TRD_MAX_MCM)\r
1713   {\r
1714           fHC->fCorrupted += 2;\r
1715     if (fgDebugFlag) AliDebug(11,"More mcm data than expected!");\r
1716     if (fRawReader) fRawReader->AddMajorErrorLog(kMCMoverflow, "Too many mcms found!"); \r
1717     return kFALSE;\r
1718   }\r
1719 \r
1720       fMCM = &fHC->fMCMs[fHC->fMCMmax];\r
1721 \r
1722       if (DecodeMCMheader() == kFALSE)\r
1723   {\r
1724           if (fHC->fCorrupted < 4) fHC->fCorrupted += 4; // benchmark hc data corruption as 4\r
1725     \r
1726     if (fgSkipData == kTRUE || fHC->fCorrupted >= 16)\r
1727               {fHC->fMCMmax++; return kFALSE;} // stop HC data reading\r
1728           \r
1729           fHC->fMCMmax++; // increase mcm counter to match with expected rob/mcm number\r
1730 \r
1731           // in case we decide to keep reading data, skip this mcm data and find next mcm header \r
1732           if (fMCM->fADCmaskCorrupted < 2) \r
1733             {  \r
1734               if (SkipMCMdata(fMCM->fADCcount*fMCM->fSingleADCwords) == kFALSE)\r
1735             return kFALSE;\r
1736               continue;\r
1737             }\r
1738           else \r
1739             {\r
1740               if (SeekNextMCMheader() == kFALSE)\r
1741             return kFALSE;\r
1742               continue;\r
1743             }\r
1744   }\r
1745 \r
1746       fHC->fMCMmax++;\r
1747 \r
1748       if (fMCM->fADCmax > 0)\r
1749   {\r
1750     fpPos++;\r
1751     if (fpPos >= fpEnd)\r
1752       {\r
1753               fMCM->fCorrupted += 1;\r
1754               if (fHC->fCorrupted < 4) fHC->fCorrupted += 4; // benchmark hc data corruption as 4\r
1755         if (fgDebugFlag)  AliDebug(9, Form("Buffer short of data. ADC data expected."));          \r
1756         return kFALSE;\r
1757       }\r
1758 \r
1759     for (Int_t iadc = 0; iadc < fMCM->fADCmax; iadc++)\r
1760       {\r
1761         fADC = &fMCM->fADCs[iadc];\r
1762         fADC->fADCnumber = fMCM->fADCchannel[iadc];\r
1763 \r
1764         if (fgDebugFlag)  AliDebug(9, Form("This is ADC %d of %d. ADC number is %d.", \r
1765             iadc+1, fMCM->fADCmax, fMCM->fADCchannel[iadc]));\r
1766 \r
1767         if (fpPos + fMCM->fSingleADCwords >= fpEnd)\r
1768     {\r
1769       \r
1770                   fMCM->fCorrupted += 2;\r
1771                   if (fHC->fCorrupted < 4) fHC->fCorrupted += 4; // benchmark hc data corruption as 4\r
1772       if (fgDebugFlag) AliDebug(11,"ADC (10 words) expected. Not enough data in the buffer.");\r
1773       return kFALSE;\r
1774     }\r
1775 \r
1776               if (fHC->fRawVMajor < 64) // normal(real) ADC data\r
1777                 {\r
1778             if (DecodeADC() == kFALSE)\r
1779         {\r
1780                       if (fMCM->fCorrupted < 4) fMCM->fCorrupted += 4; // benchmark mcm data corruption as 4\r
1781                       if (fHC->fCorrupted < 4) fHC->fCorrupted += 4;   // benchmark hc data corruption as 4\r
1782           if (fADC->fIsShared && fADC->fCorrupted == 16)   // check if we are out of the det when the pad is shared\r
1783             {\r
1784               fADC->fCOL = -1;\r
1785               fpPos = fADC->fPos + fMCM->fSingleADCwords;\r
1786             }\r
1787           else\r
1788             {\r
1789               if (fgDebugFlag) AliDebug(11,Form("ADC decode failed."));\r
1790                     if (fgSkipData == kTRUE || fHC->fCorrupted >= 16) \r
1791                             return kFALSE; // stop HC data reading\r
1792             }\r
1793         }\r
1794                 } \r
1795               else // test pattern data\r
1796                 {\r
1797                   if (fgWarnError) AliError("These are test pattern data. You need other reader"); // will be served in other class\r
1798                 }\r
1799       } \r
1800   } \r
1801       else\r
1802   {\r
1803     fpPos++;\r
1804   }\r
1805     }//while eof data\r
1806 \r
1807   if (fpPos >= fpEnd)\r
1808     {\r
1809       if (fgDebugFlag) AliDebug(11,"We are at the end of buffer. There should be one more word left.");\r
1810       return kFALSE;\r
1811     }\r
1812 \r
1813   return kTRUE;\r
1814 }\r
1815 //------------------------------------------------------------\r
1816 \r
1817 Bool_t\r
1818 AliTRDrawStream::DecodeADC()\r
1819 {\r
1820   //\r
1821   // decode single ADC channel\r
1822   //\r
1823 \r
1824   fADC->fCorrupted = 0;\r
1825   if(fADC->fADCnumber%2==1) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL1);\r
1826   if(fADC->fADCnumber%2==0) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL2);\r
1827 \r
1828   fADC->fPos = fpPos;\r
1829   fTbinADC = 0;\r
1830 \r
1831   for (Int_t i = 0; i < TRD_MAX_TBINS; i++)\r
1832     fADC->fSignals[i] = 0;\r
1833 \r
1834   for (Int_t iw = 0; iw < fMCM->fSingleADCwords; iw++)\r
1835     {\r
1836       if (HC_HEADER_MASK_ERR(*fpPos) == 0 || *fpPos == END_OF_TRACKLET_MARKERNEW)\r
1837         {\r
1838           if (fgWarnError) AliError(Form("There should be ADC data. We meet HC header or END_OF_TRACKLET_MARKER 0x%08x",*fpPos));\r
1839     fADC->fCorrupted += 16;\r
1840           fHC->fCorrupted += 16; \r
1841           fpPos--;\r
1842 \r
1843           return kFALSE;\r
1844         }\r
1845       if (fMaskADCword != ADC_WORD_MASK(*fpPos))\r
1846   {\r
1847     fADC->fCorrupted += 1;\r
1848           if (fgDebugFlag) AliDebug(11,Form("Wrong ADC data mask! ADC channel number: %02d [Expected mask: 0x%08x  Current mask: 0x%08x] MCM= %s Error : %d",\r
1849                                           fADC->fADCnumber, fMaskADCword, ADC_WORD_MASK(*fpPos),DumpMCMinfo(fMCM),fADC->fCorrupted));\r
1850           fpPos++;\r
1851     continue;\r
1852   }\r
1853 \r
1854       // here we subtract the baseline ( == common additive)\r
1855       fADC->fSignals[fTbinADC + 0] = ((*fpPos & 0x00000ffc) >>  2) - fgCommonAdditive;\r
1856       fADC->fSignals[fTbinADC + 1] = ((*fpPos & 0x003ff000) >> 12) - fgCommonAdditive;\r
1857       fADC->fSignals[fTbinADC + 2] = ((*fpPos & 0xffc00000) >> 22) - fgCommonAdditive;\r
1858 \r
1859       fTbinADC += 3;\r
1860       fpPos++;\r
1861     }\r
1862 \r
1863   if (fADC->fADCnumber <= 1 || fADC->fADCnumber == fMaxADCgeom - 1)\r
1864     {\r
1865       fADC->fIsShared = kTRUE;\r
1866     }\r
1867   else\r
1868     {\r
1869       fADC->fIsShared = kFALSE;\r
1870     }\r
1871 \r
1872   if ( fADC->fADCnumber >= fMaxADCgeom - 1)\r
1873     {\r
1874       fADC->fCOL = AliTRDfeeParam::Instance()->GetPadColFromADC(fMCM->fROB, fMCM->fMCM, fADC->fADCnumber - 1);\r
1875       fADC->fCOL--;\r
1876     }\r
1877   else\r
1878     {\r
1879       fADC->fCOL = fTRDfeeParam->GetPadColFromADC(fMCM->fROB, fMCM->fMCM, fADC->fADCnumber);\r
1880     }\r
1881 \r
1882   if (fADC->fCOL >= fHC->fColMax || fADC->fCOL < 0)\r
1883     {\r
1884       if (fADC->fIsShared == kFALSE)\r
1885   {\r
1886     fADC->fCorrupted += 32;\r
1887     if (fgDebugFlag) AliDebug(11,Form("Wrong column! ADCnumber %d MaxIs %d Col %d MaxIs %d MCM= %s", \r
1888             fADC->fADCnumber, fMaxADCgeom, fADC->fCOL, fHC->fColMax, DumpMCMinfo(fMCM)));\r
1889   }\r
1890       //else\r
1891   //{\r
1892     // we are out of the det when the pad is shared\r
1893     //if (fgDebugFlag) AliDebug(11, Form("Column out of the detector! ADCnumber %d MaxIs %d Col %d MaxIs %d MCM= %s", \r
1894     //                               fADC->fADCnumber, fMaxADCgeom, fADC->fCOL, fHC->fColMax, DumpMCMinfo(fMCM)));\r
1895     //fADC->fCorrupted += 32;\r
1896   //}\r
1897     }\r
1898 \r
1899   if (fADC->fCorrupted > 0)\r
1900     {\r
1901       return kFALSE;\r
1902     }\r
1903 \r
1904   fDecodedADCs++;\r
1905   return kTRUE;\r
1906 }\r
1907 \r
1908 //--------------------------------------------------------\r
1909 \r
1910 \r
1911 void AliTRDrawStream::DecodeSMInfo(const UInt_t *word, struct AliTRDrawSM *sm) const\r
1912 {\r
1913   //\r
1914   // Decode Supermodule Index Word\r
1915   // The Supermodule Index Word is a 32-Bit word wit following structure\r
1916   // ssssssss ssssssss vvvv rrrr r d t mmmm\r
1917   // s: Size of the Supermodule Header, v: Supermodule Header Version, r: Reserved for future use\r
1918   // d: Track Data Enabled Bit, t: Tracklet Data Enabled Bit, m: Stack Mask \r
1919   //\r
1920   sm->fPos = (UInt_t*)word; \r
1921 \r
1922   UInt_t vword = *word;\r
1923   sm->fHeaderSize = SM_HEADER_SIZE(vword);\r
1924     \r
1925   if (TRACKLETS_ENABLED(vword) > 0)\r
1926     sm->fTrackletEnable = kTRUE;\r
1927   else\r
1928     sm->fTrackletEnable = kFALSE;\r
1929     \r
1930   UInt_t stackMask = STACK_MASK(vword);\r
1931   sm->fActiveStacks = 0;\r
1932   for (Int_t i = 0; i < 5; i++)\r
1933     {\r
1934       if (IS_BIT_SET(stackMask,i) > 0)\r
1935   {\r
1936     sm->fStackActive[i] = kTRUE;\r
1937     sm->fActiveStacks++;\r
1938   }\r
1939       else\r
1940   {\r
1941     sm->fStackActive[i] = kFALSE;\r
1942   }\r
1943     }\r
1944 }\r
1945 \r
1946 //--------------------------------------------------------\r
1947 const char *AliTRDrawStream::DumpSMInfo(const struct AliTRDrawSM *sm)\r
1948 {\r
1949   //\r
1950   // Get SM structure into a const char\r
1951   //\r
1952   return Form("[ SM Info 0x%08x] : Hsize %d TrackletEnable %d Stacks %d %d %d %d %d",\r
1953         *sm->fPos,\r
1954         sm->fHeaderSize, sm->fTrackletEnable,\r
1955         sm->fStackActive[0], sm->fStackActive[1], sm->fStackActive[2],\r
1956         sm->fStackActive[3], sm->fStackActive[4]);      \r
1957 }\r
1958 \r
1959 //--------------------------------------------------------\r
1960 void AliTRDrawStream::DecodeStackInfo(const UInt_t *word, struct AliTRDrawStack *st) const\r
1961 {\r
1962   //\r
1963   // Decode Stack #i Index Word\r
1964   // The Stack #i Index Word is a 32-Bit word wit following structure\r
1965   // ssssssss ssssssss vvvv mmmm mmmmmmmm\r
1966   // s: Size of the Stack #i Header, v: Supermodule Header Version, m: Link Mask\r
1967   //\r
1968   st->fPos = (UInt_t*)word;\r
1969       \r
1970   UInt_t vword = *word;\r
1971   st->fHeaderSize = STACK_HEADER_SIZE(vword);\r
1972 \r
1973   UInt_t linkMask = STACK_LINK_WORD(vword);\r
1974   st->fActiveLinks = 0;\r
1975   for (Int_t i = 0; i < 12; i++)\r
1976     {\r
1977       if (IS_BIT_SET(linkMask,i) > 0)\r
1978   {\r
1979     st->fLinksActive[i] = kTRUE;\r
1980     st->fActiveLinks++;\r
1981   }\r
1982       else\r
1983   {\r
1984     st->fLinksActive[i] = kFALSE;\r
1985   }\r
1986     }\r
1987 }\r
1988   \r
1989 //--------------------------------------------------------\r
1990 void AliTRDrawStream::DecodeStackHeader(const UInt_t *word, struct AliTRDrawStack *st, Int_t iword) const\r
1991 {\r
1992   //\r
1993   // decode gtu header for stack info\r
1994   //\r
1995       st->fPos = (UInt_t*)word;\r
1996       \r
1997       UInt_t vword = *word;\r
1998       st->fLinksDataType[2*iword]    = LINK0_DATA_TYPE_FLAG(vword);\r
1999       st->fLinksMonitor[2*iword]     = LINK0_MONITOR_FLAG(vword);\r
2000       st->fLinksDataType[2*iword+1]  = LINK1_DATA_TYPE_FLAG(vword);\r
2001       st->fLinksMonitor[2*iword+1]   = LINK1_MONITOR_FLAG(vword);\r
2002 }\r
2003 \r
2004 //--------------------------------------------------------\r
2005 const char *AliTRDrawStream::DumpStackInfo(const struct AliTRDrawStack *st)\r
2006 {\r
2007   //\r
2008   // format the string with the stack info\r
2009   //\r
2010 \r
2011   return Form("[ Stack Info 0x%08x ] : Hsize %d Links Active %d %d %d %d %d %d %d %d %d %d %d %d",\r
2012         *st->fPos,\r
2013         st->fHeaderSize,\r
2014         st->fLinksActive[0], st->fLinksActive[1], st->fLinksActive[2], st->fLinksActive[3],\r
2015         st->fLinksActive[4], st->fLinksActive[5], st->fLinksActive[6], st->fLinksActive[7],\r
2016         st->fLinksActive[8], st->fLinksActive[9], st->fLinksActive[10], st->fLinksActive[11]);\r
2017 \r
2018 }\r
2019 \r
2020 //--------------------------------------------------------\r
2021 Bool_t AliTRDrawStream::DecodeHCwordH0(const UInt_t *word, struct AliTRDrawHC *hc) const\r
2022 {\r
2023   //\r
2024   // decode the hc header word 0\r
2025   //\r
2026   UInt_t vword = *word;\r
2027 \r
2028   hc->fH0Corrupted = HC_HEADER_MASK_ERR(vword);\r
2029   if (hc->fH0Corrupted > 0)\r
2030     {\r
2031     if (fgDebugFlag) AliDebug(11,Form("H0 Header Mask Error. Word 0x%08x", *fHC->fPos));\r
2032     return kFALSE;\r
2033     }\r
2034 \r
2035   hc->fSpecialRawV =  HC_SPECIAL_RAW_VERSION(vword);\r
2036   hc->fRawVMajor = HC_MAJOR_RAW_VERSION(vword);\r
2037   hc->fRawVMajorOpt = HC_MAJOR_RAW_VERSION_OPT(vword); \r
2038   hc->fRawVMinor = HC_MINOR_RAW_VERSION(vword);\r
2039   hc->fNExtraWords = HC_EXTRA_WORDS(vword);\r
2040   hc->fDCSboard = HC_DCS_BOARD(vword);\r
2041   hc->fSM = HC_SM_NUMBER(vword);\r
2042   hc->fStack = HC_STACK_NUMBER(vword);\r
2043   hc->fLayer = HC_LAYER_NUMBER(vword);\r
2044   hc->fSide = HC_SIDE_NUMBER(vword);\r
2045 \r
2046   hc->fPos[0] = (UInt_t*)word;\r
2047 \r
2048   return kTRUE;\r
2049 }\r
2050 \r
2051 //--------------------------------------------------------\r
2052 Bool_t AliTRDrawStream::DecodeHCwordH1(const UInt_t *word, struct AliTRDrawHC *hc) const\r
2053 {\r
2054   //\r
2055   // decode the hc header word 1\r
2056   //\r
2057 \r
2058   UInt_t vword = *word;\r
2059 \r
2060   hc->fH1Corrupted = HC_HEADER_MASK_ERR(vword);\r
2061   if (hc->fH1Corrupted > 0)\r
2062     { \r
2063     if (fgDebugFlag) AliDebug(11,Form("H1 Header Mask Error. Word 0x%08x", *fHC->fPos));\r
2064     return kFALSE;\r
2065     }\r
2066 \r
2067   hc->fTimeBins = HC_NTIMEBINS(vword);\r
2068   hc->fBunchCrossCounter = HC_BUNCH_CROSS_COUNTER(vword);\r
2069   hc->fPreTriggerCounter = HC_PRETRIGGER_COUNTER(vword);\r
2070   hc->fPreTriggerPhase = HC_PRETRIGGER_PHASE(vword);\r
2071 \r
2072   hc->fPos[1] = (UInt_t*)word;\r
2073 \r
2074   return kTRUE;\r
2075 }\r
2076   \r
2077 //--------------------------------------------------------\r
2078 const char *AliTRDrawStream::DumpHCinfoH0(const struct AliTRDrawHC *hc)\r
2079 {\r
2080   //\r
2081   // dump the hc header word 0\r
2082   //\r
2083   if (!hc)\r
2084     return Form("Unable to dump. Null received as parameter!?!");\r
2085   else\r
2086     return Form("[ HC[0] at 0x%08x ] : 0x%08x Info is : RawV %d SM %d Stack %d Layer %d Side %d DCSboard %d",\r
2087     hc->fPos[0], *(hc->fPos[0]), hc->fRawVMajor, hc->fSM, hc->fStack, hc->fLayer, hc->fSide, hc->fDCSboard);\r
2088 }\r
2089 \r
2090 //--------------------------------------------------------\r
2091 const char *AliTRDrawStream::DumpHCinfoH1(const struct AliTRDrawHC *hc)\r
2092 {\r
2093   //\r
2094   // dump the hc header word 1\r
2095   //\r
2096   if (!hc)\r
2097     return Form("Unable to dump. Null received as parameter!?!");\r
2098   else\r
2099     return Form("[ HC[1] at 0x%08x ] : 0x%08x Info is : TBins %d BCcount %d PreTrigCount %d PreTrigPhase %d",\r
2100     hc->fPos[1], *(hc->fPos[1]), hc->fTimeBins, hc->fBunchCrossCounter, hc->fPreTriggerCounter, hc->fPreTriggerPhase);\r
2101 }\r
2102 \r
2103 //--------------------------------------------------------\r
2104 void AliTRDrawStream::DecodeMCMheader(const UInt_t *word, struct AliTRDrawMCM *mcm) const\r
2105 {\r
2106   //\r
2107   // decode the mcm header\r
2108   //\r
2109   UInt_t vword = *word;\r
2110 \r
2111   if (vword == END_OF_TRACKLET_MARKERNEW) \r
2112     {\r
2113       if (fgWarnError) AliError(Form("There should be MCM header. We meet END_OF_TRACKLET_MARKER 0x%08x",vword));\r
2114       mcm->fMCMhdCorrupted += 16;\r
2115       fHC->fCorrupted += 16; //to finish data reading of this HC\r
2116     }\r
2117 \r
2118   mcm->fMCMhdCorrupted = MCM_HEADER_MASK_ERR(vword); //if MCM header mask has error\r
2119   if (fgDebugFlag && mcm->fMCMhdCorrupted != 0) AliDebug(11,Form("Wrong MCM header mask 0x%08x.\n", *fpPos));\r
2120 \r
2121   mcm->fROB = MCM_ROB_NUMBER(vword);\r
2122   mcm->fMCM = MCM_MCM_NUMBER(vword);\r
2123   mcm->fEvCounter = MCM_EVENT_COUNTER(vword);\r
2124   mcm->fPos = (UInt_t*)word;\r
2125 }\r
2126 \r
2127 //--------------------------------------------------------\r
2128 UInt_t AliTRDrawStream::GetMCMadcMask(const UInt_t *word, struct AliTRDrawMCM *mcm) const\r
2129 {\r
2130   //\r
2131   // get the adc mask\r
2132   //\r
2133   UInt_t vword = *word;\r
2134 \r
2135   mcm->fADCmax    = 0;\r
2136   mcm->fADCMask   = 0;\r
2137   mcm->fADCcount  = 0;\r
2138   mcm->fADCMaskWord = vword;\r
2139 \r
2140   if (vword == END_OF_TRACKLET_MARKERNEW)\r
2141     {\r
2142       if (fgWarnError) AliError(Form("There should be MCMadcMask. We meet END_OF_TRACKLET_MARKER 0x%08x",vword));\r
2143       mcm->fADCmaskCorrupted += 16;\r
2144       fHC->fCorrupted += 16; //to finish data reading of this HC\r
2145     }\r
2146 \r
2147   if ( MCM_ADCMASK_MASK_ERR(vword) == 0 )\r
2148     {\r
2149       mcm->fADCMask  = MCM_ADCMASK_VAL(vword);\r
2150       mcm->fADCcount = MCM_ADCMASK_NADC(~vword);\r
2151     }\r
2152   else\r
2153     {\r
2154       mcm->fADCMask = 0xffffffff;\r
2155       mcm->fADCmaskCorrupted = 1; // mcm adc mask error\r
2156       if (fgDebugFlag) AliDebug(11,Form("Wrong ADC Mask word 0x%08x.\n", *fpPos));\r
2157     }\r
2158 \r
2159   return mcm->fADCMask;\r
2160 }\r
2161 \r
2162 //--------------------------------------------------------\r
2163 void AliTRDrawStream::DecodeMask(const UInt_t *word, struct AliTRDrawMCM *mcm) const\r
2164 {\r
2165   //\r
2166   // decode the adc mask - adcs to be read out\r
2167   //\r
2168   mcm->fMCMADCWords = 0;\r
2169   mcm->fSingleADCwords = 0;\r
2170   mcm->fADCmax = 0;\r
2171   mcm->fADCMask = GetMCMadcMask(word, mcm);\r
2172 \r
2173   if (mcm->fADCMask > 0)\r
2174     {\r
2175       for (Int_t i = 0; i < TRD_MAX_ADC; i++)\r
2176   {\r
2177     mcm->fADCchannel[mcm->fADCmax] = 0;\r
2178     if( IS_BIT_SET(mcm->fADCMask,i) )\r
2179       {\r
2180         mcm->fADCchannel[mcm->fADCmax] = i;\r
2181         mcm->fADCmax++;\r
2182       }\r
2183   }\r
2184     }\r
2185   if (mcm->fADCcount != mcm->fADCmax && fHC->fRawVMajor >= 32) // backward compatibility\r
2186     {\r
2187       mcm->fADCmaskCorrupted += 2; \r
2188       if (fgDebugFlag) AliDebug(11,Form("ADC counts from ADCMask are different %d %d : ADCMask word 0x%08x\n", mcm->fADCcount, mcm->fADCmax, *fMCM->fPos));\r
2189     }\r
2190 }\r
2191 \r
2192 //--------------------------------------------------------\r
2193 void AliTRDrawStream::MCMADCwordsWithTbins(UInt_t fTbins, struct AliTRDrawMCM *mcm) const\r
2194 {\r
2195   //\r
2196   //  count the expected mcm words for a given tbins\r
2197   //\r
2198   mcm->fMCMADCWords = ( mcm->fADCmax ) * ( fTbins / 3 );\r
2199   mcm->fSingleADCwords = 0;\r
2200   if (mcm->fADCmax > 0)\r
2201     {\r
2202       mcm->fSingleADCwords = mcm->fMCMADCWords/mcm->fADCmax;\r
2203     }\r
2204 }\r
2205   \r
2206 //--------------------------------------------------------\r
2207 const char *AliTRDrawStream::DumpMCMinfo(const struct AliTRDrawMCM *mcm)\r
2208 {\r
2209   //\r
2210   // mcm info in a string\r
2211   //\r
2212   if (!mcm)\r
2213     return Form("Unable to dump. Null received as parameter!?!");\r
2214   else\r
2215     return Form("[ MCM 0x%08x ] : ROB %d MCM %d EvCounter %d", *(mcm->fPos), mcm->fROB, mcm->fMCM, mcm->fEvCounter);\r
2216 }\r
2217   \r
2218 //--------------------------------------------------------\r
2219 const char *AliTRDrawStream::DumpMCMadcMask(const struct AliTRDrawMCM *mcm)\r
2220 {\r
2221   //\r
2222   // mcm adc mask in a string\r
2223   //\r
2224   if (!mcm)\r
2225     return Form("Unable to dump. Null received as parameter!?!");\r
2226 \r
2227   TString tsreturn = Form("[Word] : 0x%08x => [Mask] : 0x%08x : ", mcm->fADCMaskWord, mcm->fADCMask);\r
2228   for (Int_t i = 0; i < TRD_MAX_ADC; i++)\r
2229     {\r
2230       tsreturn += Form("%d ", mcm->fADCchannel[i]);\r
2231     }\r
2232   tsreturn += "";\r
2233   return tsreturn.Data();\r
2234 }\r