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