HLT/BASE/AliHLTReadoutList.cxx

   1 // $Id$
   2 /**************************************************************************
   3  * This file is property of and copyright by the ALICE HLT Project        *
   4  * ALICE Experiment at CERN, All rights reserved.                         *
   5  *                                                                        *
   6  * Primary Authors: Artur Szostak <artursz@iafrica.com>                   *
   7  *                  for The ALICE HLT Project.                            *
   8  *                                                                        *
   9  * Permission to use, copy, modify and distribute this software and its   *
  10  * documentation strictly for non-commercial purposes is hereby granted   *
  11  * without fee, provided that the above copyright notice appears in all   *
  12  * copies and that both the copyright notice and this permission notice   *
  13  * appear in the supporting documentation. The authors make no claims     *
  14  * about the suitability of this software for any purpose. It is          *
  15  * provided "as is" without express or implied warranty.                  *
  16  **************************************************************************/
  17
  18 /// @file   AliHLTReadoutList.cxx
  19 /// @author Artur Szostak <artursz@iafrica.com>
  20 /// @date   19 Nov 2008
  21 /// @brief  Implementation of the AliHLTReadoutList class.
  22 ///
  23 /// The AliHLTReadoutList class is used as an interface to the AliHLTEventDDL
  24 /// structure. It makes it easy to manipulate the bits in this structure, which
  25 /// define what DDLs should be readout by DAQ.
  26 /// Several operators are also overloaded which are meant to be used in the trigger
  27 /// menu specification for the AliHLTGlobalTrigger. It allows one to construct
  28 /// expressions for the readout lists, which is necessary to be able to evaluate
  29 /// or compose the final readout list, given multiple input readout lists received
  30 /// from individual components that derive from AliHLTTrigger.
  31
  32 #include "AliHLTReadoutList.h"
  33 #include "AliHLTDAQ.h"
  34 #include "Riostream.h"
  35 #include "TString.h"
  36 #include "TObjString.h"
  37 #include "TObjArray.h"
  38 #include <cassert>
  39
  40 ClassImp(AliHLTReadoutList)
  41
  42
  43 const char* AliHLTReadoutList::DetectorIdToString(EDetectorId id)
  44 {
  45   // Converts a detector ID to a user readable string.
  46   switch (id)
  47   {
  48   case kNoDetector: return "kNoDetector";
  49   case kITSSPD:  return "kITSSPD";
  50   case kITSSDD:  return "kITSSDD";
  51   case kITSSSD:  return "kITSSSD";
  52   case kTPC:     return "kTPC";
  53   case kTRD:     return "kTRD";
  54   case kTOF:     return "kTOF";
  55   case kHMPID:   return "kHMPID";
  56   case kPHOS:    return "kPHOS";
  57   case kCPV:     return "kCPV";
  58   case kPMD:     return "kPMD";
  59   case kMUONTRK: return "kMUONTRK";
  60   case kMUONTRG: return "kMUONTRG";
  61   case kFMD:     return "kFMD";
  62   case kT0:      return "kT0";
  63   case kV0:      return "kV0";
  64   case kZDC:     return "kZDC";
  65   case kACORDE:  return "kACORDE";
  66   case kTRG:     return "kTRG";
  67   case kEMCAL:   return "kEMCAL";
  68   case kDAQTEST: return "kDAQTEST";
  69   case kHLT:     return "kHLT";
  70   case kALLDET:  return "kALLDET";
  71   default:       return "UNKNOWN!";
  72   }
  73 }
  74
  75
  76 AliHLTReadoutList::AliHLTReadoutList() :
  77         TNamed("AliHLTReadoutList", "Readout list object used for manipulating and storing an AliHLTEventDDL structure."),
  78         fReadoutList()
  79 {
  80   // Default constructor.
  81
  82   fReadoutList.fCount = gkAliHLTDDLListSize;  // Required by ALICE-INT-2007-015
  83   memset(fReadoutList.fList, 0x0, sizeof(fReadoutList.fList));
  84 }
  85
  86
  87 AliHLTReadoutList::AliHLTReadoutList(Int_t enabledDetectors) :
  88         TNamed("AliHLTReadoutList", "Readout list object used for manipulating and storing an AliHLTEventDDL structure."),
  89         fReadoutList()
  90 {
  91   // Constructor to select which detectors to enable for readout.
  92   // See header file for more details.
  93
  94   fReadoutList.fCount = gkAliHLTDDLListSize;  // Required by ALICE-INT-2007-015
  95   memset(fReadoutList.fList, 0x0, sizeof(fReadoutList.fList));
  96   Enable(enabledDetectors);
  97 }
  98
  99
 100 AliHLTReadoutList::AliHLTReadoutList(const char* enabledList) :
 101         TNamed("AliHLTReadoutList", "Readout list object used for manipulating and storing an AliHLTEventDDL structure."),
 102         fReadoutList()
 103 {
 104   // Constructor to select which detectors and DDLs to enable for readout.
 105   // See header file for more details.
 106
 107   fReadoutList.fCount = gkAliHLTDDLListSize;  // Required by ALICE-INT-2007-015
 108   memset(fReadoutList.fList, 0x0, sizeof(fReadoutList.fList));
 109
 110   TString str(enabledList);
 111   str.ToUpper();
 112   Int_t enabledDetectors = 0;
 113   TObjArray* list = str.Tokenize(" ");
 114   TIter next(list);
 115   const TObjString* objstr = NULL;
 116   while ((objstr = dynamic_cast<const TObjString*>(next())) != NULL)
 117   {
 118     str = objstr->GetString();
 119     if (str.IsDigit()) EnableDDLBit(str.Atoi());
 120     if (str == "ITSSPD") enabledDetectors |= kITSSPD;
 121     if (str == "ITSSDD") enabledDetectors |= kITSSDD;
 122     if (str == "ITSSSD") enabledDetectors |= kITSSSD;
 123     if (str == "TPC") enabledDetectors |= kTPC;
 124     if (str == "TRD") enabledDetectors |= kTRD;
 125     if (str == "TOF") enabledDetectors |= kTOF;
 126     if (str == "HMPID") enabledDetectors |= kHMPID;
 127     if (str == "PHOS") enabledDetectors |= kPHOS;
 128     if (str == "CPV") enabledDetectors |= kCPV;
 129     if (str == "PMD") enabledDetectors |= kPMD;
 130     if (str == "MUONTRK") enabledDetectors |= kMUONTRK;
 131     if (str == "MUONTRG") enabledDetectors |= kMUONTRG;
 132     if (str == "FMD") enabledDetectors |= kFMD;
 133     if (str == "T0") enabledDetectors |= kT0;
 134     if (str == "V0") enabledDetectors |= kV0;
 135     if (str == "ZDC") enabledDetectors |= kZDC;
 136     if (str == "ACORDE") enabledDetectors |= kACORDE;
 137     if (str == "TRG") enabledDetectors |= kTRG;
 138     if (str == "EMCAL") enabledDetectors |= kEMCAL;
 139     if (str == "DAQTEST") enabledDetectors |= kDAQTEST;
 140     if (str == "HLT") enabledDetectors |= kHLT;
 141     if (str == "ALL") enabledDetectors |= kALLDET;
 142   }
 143   delete list;
 144   Enable(enabledDetectors);
 145 }
 146
 147
 148 AliHLTReadoutList::AliHLTReadoutList(const AliHLTEventDDL& list) :
 149         TNamed("AliHLTReadoutList", "Readout list object used for manipulating and storing an AliHLTEventDDL structure."),
 150         fReadoutList()
 151 {
 152   // Constructor to create readout list from AliHLTEventDDL structure.
 153   // See header file for more details.
 154   FillStruct(list);
 155 }
 156
 157
 158 AliHLTReadoutList::AliHLTReadoutList(const AliHLTReadoutList& list) :
 159         TNamed(list),
 160         fReadoutList()
 161 {
 162   // Copy constructor performs a deep copy.
 163
 164   if (list.fReadoutList.fCount == (unsigned)gkAliHLTDDLListSize)
 165   {
 166     memcpy(&fReadoutList, &list.fReadoutList, sizeof(fReadoutList));
 167   }
 168   else
 169   {
 170     FillStruct(list);
 171   }
 172 }
 173
 174
 175 void AliHLTReadoutList::FillStruct(const AliHLTEventDDL& list)
 176 {
 177   // Fills internal DDL bits structure.
 178
 179   fReadoutList.fCount = gkAliHLTDDLListSize;  // Required by ALICE-INT-2007-015
 180   memset(fReadoutList.fList, 0x0, sizeof(fReadoutList.fList));
 181   // Handle lists of different sizes. If the size is for a known version
 182   // of AliHLTEventDDL then handle appropriately, otherwise just copy only
 183   // the overlapping part of the list.
 184   if (list.fCount == (unsigned)gkAliHLTDDLListSizeV0)
 185   {
 186     memcpy(&fReadoutList.fList[0], &list.fList[0], sizeof(AliHLTUInt32_t)*28);
 187     memcpy(&fReadoutList.fList[29], &list.fList[28], sizeof(AliHLTUInt32_t)*2);
 188   }
 189   else if (list.fCount == (unsigned)gkAliHLTDDLListSizeV1)
 190   {
 191     memcpy(&fReadoutList, &list, sizeof(AliHLTEventDDL));
 192   }
 193   else
 194   {
 195     memcpy(&fReadoutList.fList, &list.fList, (fReadoutList.fCount<list.fCount?fReadoutList.fCount:list.fCount)*sizeof(AliHLTUInt32_t));
 196   }
 197 }
 198
 199
 200 AliHLTReadoutList::~AliHLTReadoutList()
 201 {
 202   // Default destructor.
 203 }
 204
 205
 206 bool AliHLTReadoutList::Empty() const
 207 {
 208   // Returns true if the readout list has no DDLs enabled.
 209
 210   for (size_t i = 0; i < sizeof(fReadoutList.fList) / sizeof(fReadoutList.fList[0]); i++)
 211   {
 212     if (fReadoutList.fList[i] != 0x0) return false;
 213   }
 214   return true;
 215 }
 216
 217
 218 void AliHLTReadoutList::Clear(Option_t* /*option*/)
 219 {
 220   // Resets all the DDL readout bits.
 221   memset(fReadoutList.fList, 0x0, sizeof(fReadoutList.fList));
 222
 223 #if 1 // ROOT_SVN_REVISION < 9999  //FIXME: after fixed https://savannah.cern.ch/bugs/?69241
 224   // Check if we need to convert to new format and do so.
 225   if (fReadoutList.fCount == (unsigned)gkAliHLTDDLListSizeV0)
 226   {
 227     fReadoutList.fCount = gkAliHLTDDLListSize;
 228   }
 229 #endif
 230 }
 231
 232
 233 bool AliHLTReadoutList::DecodeDDLID(Int_t ddlId, Int_t& wordIndex, Int_t& bitIndex)
 234 {
 235   // Decodes the word index and bit index within that word for the readout list structure.
 236   // See header file for more details.
 237
 238   // The detector number is bits 15..8 of ddlId and DDL number is bits 7..0.
 239   Int_t detNum = ddlId >> 8;
 240   Int_t ddlNum = ddlId & 0xFF;
 241
 242   switch (detNum)
 243   {
 244   case 0: // SPD
 245   case 1: // SDD
 246   case 2: // SSD
 247     if (ddlNum >= 32) return false; // only have 1 32-bit word.
 248     // the 3 ITS detectors have one word each
 249     wordIndex = detNum;
 250     break;
 251   case 3: // TPC
 252     // the TPC bitfield has in total 8 words
 253     wordIndex = detNum + (ddlNum >> 5);
 254     break;
 255   case 4: // TRD
 256     if (ddlNum >= 32) return false; // only have 1 32-bit word.
 257     // the TRD bitfield starts at word 11 (3 words ITS + 8 words TPC)
 258     wordIndex = 11;
 259     break;
 260   case 5: // TOF
 261     if (ddlNum >= 3*32) return false; // only have 3 32-bit words.
 262     // TOF has 72 DDLs, the bitfield is 3 words starting at position 12
 263     wordIndex = 12 + (ddlNum >> 5);
 264     break;
 265   case 6: // HMPID
 266   case 7: // PHOS
 267   case 8: // CPV
 268   case 9: // PMD
 269   case 10: // MUONTRK (MCH)
 270   case 11: // MUONTRG (MTR)
 271   case 12: // FMD
 272   case 13: // T0
 273   case 14: // V0
 274   case 15: // ZDC
 275   case 16: // ACORDE
 276   case 17: // TRG
 277     if (ddlNum >= 32) return false; // only have 1 32-bit word.
 278     // all these detectors fit into one word, the offset is due to
 279     // TPC and TOF
 280     wordIndex = detNum + 9;
 281     break;
 282   case 18: // EMCAL
 283     if (ddlNum >= 2*32) return false; // only have 2 32-bit words.
 284     // 2 words for EMCAL + DCAL
 285     wordIndex = detNum + 7;
 286     wordIndex = 27 + (ddlNum >> 5);
 287     break;
 288   case 19: // DAQTEST
 289     if (ddlNum >= 32) return false; // only have 1 32-bit word.
 290     wordIndex = 29;
 291     break;
 292   case 30: // HLT
 293     if (ddlNum >= 32) return false; // only have 1 32-bit word.
 294     // the HLT bitfield is in the last word
 295     wordIndex = 30;
 296     break;
 297   default:
 298     return false;
 299   }
 300
 301   if (ddlNum >= AliHLTDAQ::NumberOfDdls(detNum == 30 ? 20 : detNum)) return false;
 302
 303   // The bit index within the word indicated by wordIndex.
 304   bitIndex = ddlNum % 32;
 305   return true;
 306 }
 307
 308
 309 Bool_t AliHLTReadoutList::GetDDLBit(Int_t ddlId) const
 310 {
 311   // Fetches the bit value for a particular DDL in the readout list.
 312   // See header file for more details.
 313
 314   Int_t wordIndex, bitIndex;
 315   if (! DecodeDDLID(ddlId, wordIndex, bitIndex)) return kFALSE;
 316
 317 #if 1 // ROOT_SVN_REVISION < 9999  //FIXME: after fixed https://savannah.cern.ch/bugs/?69241
 318   // Check if we need to convert to new format and do so.
 319   if (fReadoutList.fCount == (unsigned)gkAliHLTDDLListSizeV0)
 320   {
 321     if (wordIndex == 27)
 322     {
 323       if (bitIndex >= 24) return kFALSE;
 324     }
 325     else if (wordIndex == 28)
 326     {
 327       return kFALSE;
 328     }
 329     else if (wordIndex > 28)
 330     {
 331       --wordIndex;
 332     }
 333   }
 334 #endif
 335
 336   return ((fReadoutList.fList[wordIndex] >> bitIndex) & 0x1) == 0x1;
 337 }
 338
 339
 340 void AliHLTReadoutList::SetDDLBit(Int_t ddlId, Bool_t state)
 341 {
 342   // Sets the bit value for a particular DDL in the readout list.
 343   // See header file for more details.
 344
 345 #if 1 // ROOT_SVN_REVISION < 9999  //FIXME: after fixed https://savannah.cern.ch/bugs/?69241
 346   // Check if we need to convert to new format and do so.
 347   if (fReadoutList.fCount == (unsigned)gkAliHLTDDLListSizeV0)
 348   {
 349     AliHLTEventDDL copy = fReadoutList;
 350     FillStruct(copy);
 351   }
 352 #endif
 353   assert(fReadoutList.fCount == gkAliHLTDDLListSize);
 354
 355   Int_t wordIndex, bitIndex;
 356   if (! DecodeDDLID(ddlId, wordIndex, bitIndex)) return;
 357
 358   // To set, 'OR' word with bit mask
 359   if ( state )
 360     fReadoutList.fList[wordIndex] |= (0x00000001 << bitIndex);
 361   // To unset, 'AND' word with bit mask
 362   else
 363     fReadoutList.fList[wordIndex] &= (0xFFFFFFFF ^ (0x00000001 << bitIndex));
 364 }
 365
 366
 367 void AliHLTReadoutList::Enable(Int_t detector)
 368 {
 369   // Enables all DDLs for a particular detector or detectors.
 370   // See header file for more details.
 371
 372 #if 1 // ROOT_SVN_REVISION < 9999  //FIXME: after fixed https://savannah.cern.ch/bugs/?69241
 373   // Check if we need to convert to new format and do so.
 374   if (fReadoutList.fCount == (unsigned)gkAliHLTDDLListSizeV0)
 375   {
 376     AliHLTEventDDL copy = fReadoutList;
 377     FillStruct(copy);
 378   }
 379 #endif
 380   assert(fReadoutList.fCount == gkAliHLTDDLListSize);
 381
 382   if ((detector & kITSSPD) != 0) fReadoutList.fList[0] = 0x000FFFFF;
 383   if ((detector & kITSSDD) != 0) fReadoutList.fList[1] = 0x00FFFFFF;
 384   if ((detector & kITSSSD) != 0) fReadoutList.fList[2] = 0x0000FFFF;
 385   if ((detector & kTPC) != 0)
 386   {
 387     fReadoutList.fList[3] = 0xFFFFFFFF;
 388     fReadoutList.fList[4] = 0xFFFFFFFF;
 389     fReadoutList.fList[5] = 0xFFFFFFFF;
 390     fReadoutList.fList[6] = 0xFFFFFFFF;
 391     fReadoutList.fList[7] = 0xFFFFFFFF;
 392     fReadoutList.fList[8] = 0xFFFFFFFF;
 393     fReadoutList.fList[9] = 0x00FFFFFF;
 394     fReadoutList.fList[10] = 0x00000000;
 395   }
 396   if ((detector & kTRD) != 0) fReadoutList.fList[11] = 0x0003FFFF;
 397   if ((detector & kTOF) != 0)
 398   {
 399     fReadoutList.fList[12] = 0xFFFFFFFF;
 400     fReadoutList.fList[13] = 0xFFFFFFFF;
 401     fReadoutList.fList[14] = 0x000000FF;
 402   }
 403   if ((detector & kHMPID) != 0) fReadoutList.fList[15] = 0x000FFFFF;
 404   if ((detector & kPHOS) != 0) fReadoutList.fList[16] = 0x000FFFFF;
 405   if ((detector & kCPV) != 0) fReadoutList.fList[17] = 0x000003FF;
 406   if ((detector & kPMD) != 0) fReadoutList.fList[18] = 0x0000003F;
 407   if ((detector & kMUONTRK) != 0) fReadoutList.fList[19] = 0x000FFFFF;
 408   if ((detector & kMUONTRG) != 0) fReadoutList.fList[20] = 0x00000003;
 409   if ((detector & kFMD) != 0) fReadoutList.fList[21] = 0x00000007;
 410   if ((detector & kT0) != 0) fReadoutList.fList[22] = 0x00000001;
 411   if ((detector & kV0) != 0) fReadoutList.fList[23] = 0x00000001;
 412   if ((detector & kZDC) != 0) fReadoutList.fList[24] = 0x00000001;
 413   if ((detector & kACORDE) != 0) fReadoutList.fList[25] = 0x00000001;
 414   if ((detector & kTRG) != 0) fReadoutList.fList[26] = 0x00000001;
 415   if ((detector & kEMCAL) != 0)
 416   {
 417     fReadoutList.fList[27] = 0xFFFFFFFF;
 418     fReadoutList.fList[28] = 0x00003FFF;
 419   }
 420   if ((detector & kDAQTEST) != 0) fReadoutList.fList[29] = 0x00000001;
 421   if ((detector & kHLT) != 0) fReadoutList.fList[30] = 0x0FFFFFFF;
 422 }
 423
 424
 425 void AliHLTReadoutList::Disable(Int_t detector)
 426 {
 427   // Disables all DDLs for a particular detector or detectors.
 428   // See header file for more details.
 429
 430 #if 1 // ROOT_SVN_REVISION < 9999  //FIXME: after fixed https://savannah.cern.ch/bugs/?69241
 431   // Check if we need to convert to new format and do so.
 432   if (fReadoutList.fCount == (unsigned)gkAliHLTDDLListSizeV0)
 433   {
 434     AliHLTEventDDL copy = fReadoutList;
 435     FillStruct(copy);
 436   }
 437 #endif
 438   assert(fReadoutList.fCount == gkAliHLTDDLListSize);
 439
 440   if ((detector & kITSSPD) != 0) fReadoutList.fList[0] = 0x00000000;
 441   if ((detector & kITSSDD) != 0) fReadoutList.fList[1] = 0x00000000;
 442   if ((detector & kITSSSD) != 0) fReadoutList.fList[2] = 0x00000000;
 443   if ((detector & kTPC) != 0)
 444   {
 445     fReadoutList.fList[3] = 0x00000000;
 446     fReadoutList.fList[4] = 0x00000000;
 447     fReadoutList.fList[5] = 0x00000000;
 448     fReadoutList.fList[6] = 0x00000000;
 449     fReadoutList.fList[7] = 0x00000000;
 450     fReadoutList.fList[8] = 0x00000000;
 451     fReadoutList.fList[9] = 0x00000000;
 452     fReadoutList.fList[10] = 0x00000000;
 453   }
 454   if ((detector & kTRD) != 0) fReadoutList.fList[11] = 0x00000000;
 455   if ((detector & kTOF) != 0)
 456   {
 457     fReadoutList.fList[12] = 0x00000000;
 458     fReadoutList.fList[13] = 0x00000000;
 459     fReadoutList.fList[14] = 0x00000000;
 460   }
 461   if ((detector & kHMPID) != 0) fReadoutList.fList[15] = 0x00000000;
 462   if ((detector & kPHOS) != 0) fReadoutList.fList[16] = 0x00000000;
 463   if ((detector & kCPV) != 0) fReadoutList.fList[17] = 0x00000000;
 464   if ((detector & kPMD) != 0) fReadoutList.fList[18] = 0x00000000;
 465   if ((detector & kMUONTRK) != 0) fReadoutList.fList[19] = 0x00000000;
 466   if ((detector & kMUONTRG) != 0) fReadoutList.fList[20] = 0x00000000;
 467   if ((detector & kFMD) != 0) fReadoutList.fList[21] = 0x00000000;
 468   if ((detector & kT0) != 0) fReadoutList.fList[22] = 0x00000000;
 469   if ((detector & kV0) != 0) fReadoutList.fList[23] = 0x00000000;
 470   if ((detector & kZDC) != 0) fReadoutList.fList[24] = 0x00000000;
 471   if ((detector & kACORDE) != 0) fReadoutList.fList[25] = 0x00000000;
 472   if ((detector & kTRG) != 0) fReadoutList.fList[26] = 0x00000000;
 473   if ((detector & kEMCAL) != 0)
 474   {
 475     fReadoutList.fList[27] = 0x00000000;
 476     fReadoutList.fList[28] = 0x00000000;
 477   }
 478   if ((detector & kDAQTEST) != 0) fReadoutList.fList[29] = 0x00000000;
 479   if ((detector & kHLT) != 0) fReadoutList.fList[30] = 0x00000000;
 480 }
 481
 482
 483 bool AliHLTReadoutList::DetectorEnabled(Int_t detector) const
 484 {
 485   // Checks if a particular detector's DDLs are enabled.
 486   // See header file for more details.
 487
 488   bool result = true;
 489   if ((detector & kITSSPD) != 0) result &= fReadoutList.fList[0] == 0x000FFFFF;
 490   if ((detector & kITSSDD) != 0) result &= fReadoutList.fList[1] == 0x00FFFFFF;
 491   if ((detector & kITSSSD) != 0) result &= fReadoutList.fList[2] == 0x0000FFFF;
 492   if ((detector & kTPC) != 0)
 493   {
 494     result &= fReadoutList.fList[3] == 0xFFFFFFFF;
 495     result &= fReadoutList.fList[4] == 0xFFFFFFFF;
 496     result &= fReadoutList.fList[5] == 0xFFFFFFFF;
 497     result &= fReadoutList.fList[6] == 0xFFFFFFFF;
 498     result &= fReadoutList.fList[7] == 0xFFFFFFFF;
 499     result &= fReadoutList.fList[8] == 0xFFFFFFFF;
 500     result &= fReadoutList.fList[9] == 0x00FFFFFF;
 501   }
 502   if ((detector & kTRD) != 0) result &= fReadoutList.fList[11] == 0x0003FFFF;
 503   if ((detector & kTOF) != 0)
 504   {
 505     result &= fReadoutList.fList[12] == 0xFFFFFFFF;
 506     result &= fReadoutList.fList[13] == 0xFFFFFFFF;
 507     result &= fReadoutList.fList[14] == 0x000000FF;
 508   }
 509   if ((detector & kHMPID) != 0) result &= fReadoutList.fList[15] == 0x000FFFFF;
 510   if ((detector & kPHOS) != 0) result &= fReadoutList.fList[16] == 0x000FFFFF;
 511   if ((detector & kCPV) != 0) result &= fReadoutList.fList[17] == 0x000003FF;
 512   if ((detector & kPMD) != 0) result &= fReadoutList.fList[18] == 0x0000003F;
 513   if ((detector & kMUONTRK) != 0) result &= fReadoutList.fList[19] == 0x000FFFFF;
 514   if ((detector & kMUONTRG) != 0) result &= fReadoutList.fList[20] == 0x00000003;
 515   if ((detector & kFMD) != 0) result &= fReadoutList.fList[21] == 0x00000007;
 516   if ((detector & kT0) != 0) result &= fReadoutList.fList[22] == 0x00000001;
 517   if ((detector & kV0) != 0) result &= fReadoutList.fList[23] == 0x00000001;
 518   if ((detector & kZDC) != 0) result &= fReadoutList.fList[24] == 0x00000001;
 519   if ((detector & kACORDE) != 0) result &= fReadoutList.fList[25] == 0x00000001;
 520   if ((detector & kTRG) != 0) result &= fReadoutList.fList[26] == 0x00000001;
 521 #if 1 // ROOT_SVN_REVISION < 9999  //FIXME: after fixed https://savannah.cern.ch/bugs/?69241
 522   if (fReadoutList.fCount == (unsigned)gkAliHLTDDLListSizeV0)
 523   {
 524     if ((detector & kEMCAL) != 0) result &= fReadoutList.fList[27] == 0x00FFFFFF;
 525     if ((detector & kDAQTEST) != 0) result &= fReadoutList.fList[28] == 0x00000001;
 526     if ((detector & kHLT) != 0) result &= fReadoutList.fList[29] == 0x000003FF;
 527   }
 528   else
 529 #endif
 530   {
 531     if ((detector & kEMCAL) != 0)
 532     {
 533       result &= fReadoutList.fList[27] == 0xFFFFFFFF;
 534       result &= fReadoutList.fList[28] == 0x00003FFF;
 535     }
 536     if ((detector & kDAQTEST) != 0) result &= fReadoutList.fList[29] == 0x00000001;
 537     if ((detector & kHLT) != 0) result &= fReadoutList.fList[30] == 0x0FFFFFFF;
 538   }
 539
 540   return result;
 541 }
 542
 543
 544 bool AliHLTReadoutList::DetectorDisabled(Int_t detector) const
 545 {
 546   // Checks if a particular detector's DDLs are disabled.
 547   // See header file for more details.
 548
 549   bool result = true;
 550   if ((detector & kITSSPD) != 0) result &= fReadoutList.fList[0] == 0x00000000;
 551   if ((detector & kITSSDD) != 0) result &= fReadoutList.fList[1] == 0x00000000;
 552   if ((detector & kITSSSD) != 0) result &= fReadoutList.fList[2] == 0x00000000;
 553   if ((detector & kTPC) != 0)
 554   {
 555     result &= fReadoutList.fList[3] == 0x00000000;
 556     result &= fReadoutList.fList[4] == 0x00000000;
 557     result &= fReadoutList.fList[5] == 0x00000000;
 558     result &= fReadoutList.fList[6] == 0x00000000;
 559     result &= fReadoutList.fList[7] == 0x00000000;
 560     result &= fReadoutList.fList[8] == 0x00000000;
 561     result &= fReadoutList.fList[9] == 0x00000000;
 562   }
 563   if ((detector & kTRD) != 0) result &= fReadoutList.fList[11] == 0x00000000;
 564   if ((detector & kTOF) != 0)
 565   {
 566     result &= fReadoutList.fList[12] == 0x00000000;
 567     result &= fReadoutList.fList[13] == 0x00000000;
 568     result &= fReadoutList.fList[14] == 0x00000000;
 569   }
 570   if ((detector & kHMPID) != 0) result &= fReadoutList.fList[15] == 0x00000000;
 571   if ((detector & kPHOS) != 0) result &= fReadoutList.fList[16] == 0x00000000;
 572   if ((detector & kCPV) != 0) result &= fReadoutList.fList[17] == 0x00000000;
 573   if ((detector & kPMD) != 0) result &= fReadoutList.fList[18] == 0x00000000;
 574   if ((detector & kMUONTRK) != 0) result &= fReadoutList.fList[19] == 0x00000000;
 575   if ((detector & kMUONTRG) != 0) result &= fReadoutList.fList[20] == 0x00000000;
 576   if ((detector & kFMD) != 0) result &= fReadoutList.fList[21] == 0x00000000;
 577   if ((detector & kT0) != 0) result &= fReadoutList.fList[22] == 0x00000000;
 578   if ((detector & kV0) != 0) result &= fReadoutList.fList[23] == 0x00000000;
 579   if ((detector & kZDC) != 0) result &= fReadoutList.fList[24] == 0x00000000;
 580   if ((detector & kACORDE) != 0) result &= fReadoutList.fList[25] == 0x00000000;
 581   if ((detector & kTRG) != 0) result &= fReadoutList.fList[26] == 0x00000000;
 582 #if 1 // ROOT_SVN_REVISION < 9999  //FIXME: after fixed https://savannah.cern.ch/bugs/?69241
 583   if (fReadoutList.fCount == (unsigned)gkAliHLTDDLListSizeV0)
 584   {
 585     if ((detector & kEMCAL) != 0) result &= fReadoutList.fList[27] == 0x00000000;
 586     if ((detector & kDAQTEST) != 0) result &= fReadoutList.fList[28] == 0x00000000;
 587     if ((detector & kHLT) != 0) result &= fReadoutList.fList[29] == 0x00000000;
 588   }
 589   else
 590 #endif
 591   {
 592     if ((detector & kEMCAL) != 0)
 593     {
 594       result &= fReadoutList.fList[27] == 0x00000000;
 595       result &= fReadoutList.fList[28] == 0x00000000;
 596     }
 597     if ((detector & kDAQTEST) != 0) result &= fReadoutList.fList[29] == 0x00000000;
 598     if ((detector & kHLT) != 0) result &= fReadoutList.fList[30] == 0x00000000;
 599   }
 600
 601   return result;
 602 }
 603
 604
 605 Int_t AliHLTReadoutList::GetFirstWord(EDetectorId detector)
 606 {
 607   // See header file for more details.
 608   switch (detector)
 609   {
 610   case kITSSPD:  return 0;
 611   case kITSSDD:  return 1;
 612   case kITSSSD:  return 2;
 613   case kTPC:     return 3;
 614   case kTRD:     return 11;
 615   case kTOF:     return 12;
 616   case kHMPID:   return 15;
 617   case kPHOS:    return 16;
 618   case kCPV:     return 17;
 619   case kPMD:     return 18;
 620   case kMUONTRK: return 19;
 621   case kMUONTRG: return 20;
 622   case kFMD:     return 21;
 623   case kT0:      return 22;
 624   case kV0:      return 23;
 625   case kZDC:     return 24;
 626   case kACORDE:  return 25;
 627   case kTRG:     return 26;
 628   case kEMCAL:   return 27;
 629   case kDAQTEST: return 29;
 630   case kHLT:     return 30;
 631   default:       return -1;
 632   }
 633 }
 634
 635
 636 Int_t AliHLTReadoutList::GetWordCount(EDetectorId detector)
 637 {
 638   // See header file for more details.
 639   switch (detector)
 640   {
 641   case kITSSPD:  return 1;
 642   case kITSSDD:  return 1;
 643   case kITSSSD:  return 1;
 644   case kTPC:     return 8;
 645   case kTRD:     return 1;
 646   case kTOF:     return 3;
 647   case kHMPID:   return 1;
 648   case kPHOS:    return 1;
 649   case kCPV:     return 1;
 650   case kPMD:     return 1;
 651   case kMUONTRK: return 1;
 652   case kMUONTRG: return 1;
 653   case kFMD:     return 1;
 654   case kT0:      return 1;
 655   case kV0:      return 1;
 656   case kZDC:     return 1;
 657   case kACORDE:  return 1;
 658   case kTRG:     return 1;
 659   case kEMCAL:   return 2;
 660   case kDAQTEST: return 1;
 661   case kHLT:     return 1;
 662   default:       return 0;
 663   }
 664 }
 665
 666
 667 AliHLTReadoutList::EDetectorId AliHLTReadoutList::GetDetectorFromWord(Int_t wordindex)
 668 {
 669   // See header file for more details.
 670   switch (wordindex)
 671   {
 672   case 0: return kITSSPD;
 673   case 1: return kITSSDD;
 674   case 2: return kITSSSD;
 675   case 3: return kTPC;
 676   case 4: return kTPC;
 677   case 5: return kTPC;
 678   case 6: return kTPC;
 679   case 7: return kTPC;
 680   case 8: return kTPC;
 681   case 9: return kTPC;
 682   case 10: return kTPC;
 683   case 11: return kTRD;
 684   case 12: return kTOF;
 685   case 13: return kTOF;
 686   case 14: return kTOF;
 687   case 15: return kHMPID;
 688   case 16: return kPHOS;
 689   case 17: return kCPV;
 690   case 18: return kPMD;
 691   case 19: return kMUONTRK;
 692   case 20: return kMUONTRG;
 693   case 21: return kFMD;
 694   case 22: return kT0;
 695   case 23: return kV0;
 696   case 24: return kZDC;
 697   case 25: return kACORDE;
 698   case 26: return kTRG;
 699   case 27: return kEMCAL;
 700   case 28: return kEMCAL;
 701   case 29: return kDAQTEST;
 702   case 30: return kHLT;
 703   default: return kNoDetector;
 704   }
 705 }
 706
 707
 708 AliHLTReadoutList::EDetectorId AliHLTReadoutList::GetFirstUsedDetector(EDetectorId startAfter) const
 709 {
 710   // See header file for more details.
 711
 712   if (startAfter < kITSSPD and fReadoutList.fList[0] != 0x00000000) return kITSSPD;
 713   if (startAfter < kITSSDD and fReadoutList.fList[1] != 0x00000000) return kITSSDD;
 714   if (startAfter < kITSSSD and fReadoutList.fList[2] != 0x00000000) return kITSSSD;
 715   if (startAfter < kTPC and fReadoutList.fList[3] != 0x00000000) return kTPC;
 716   if (startAfter < kTPC and fReadoutList.fList[4] != 0x00000000) return kTPC;
 717   if (startAfter < kTPC and fReadoutList.fList[5] != 0x00000000) return kTPC;
 718   if (startAfter < kTPC and fReadoutList.fList[6] != 0x00000000) return kTPC;
 719   if (startAfter < kTPC and fReadoutList.fList[7] != 0x00000000) return kTPC;
 720   if (startAfter < kTPC and fReadoutList.fList[8] != 0x00000000) return kTPC;
 721   if (startAfter < kTPC and fReadoutList.fList[9] != 0x00000000) return kTPC;
 722   if (startAfter < kTPC and fReadoutList.fList[10] != 0x00000000) return kTPC;
 723   if (startAfter < kTRD and fReadoutList.fList[11] != 0x00000000) return kTRD;
 724   if (startAfter < kTOF and fReadoutList.fList[12] != 0x00000000) return kTOF;
 725   if (startAfter < kTOF and fReadoutList.fList[13] != 0x00000000) return kTOF;
 726   if (startAfter < kTOF and fReadoutList.fList[14] != 0x00000000) return kTOF;
 727   if (startAfter < kHMPID and fReadoutList.fList[15] != 0x00000000) return kHMPID;
 728   if (startAfter < kPHOS and fReadoutList.fList[16] != 0x00000000) return kPHOS;
 729   if (startAfter < kCPV and fReadoutList.fList[17] != 0x00000000) return kCPV;
 730   if (startAfter < kPMD and fReadoutList.fList[18] != 0x00000000) return kPMD;
 731   if (startAfter < kMUONTRK and fReadoutList.fList[19] != 0x00000000) return kMUONTRK;
 732   if (startAfter < kMUONTRG and fReadoutList.fList[20] != 0x00000000) return kMUONTRG;
 733   if (startAfter < kFMD and fReadoutList.fList[21] != 0x00000000) return kFMD;
 734   if (startAfter < kT0 and fReadoutList.fList[22] != 0x00000000) return kT0;
 735   if (startAfter < kV0 and fReadoutList.fList[23] != 0x00000000) return kV0;
 736   if (startAfter < kZDC and fReadoutList.fList[24] != 0x00000000) return kZDC;
 737   if (startAfter < kACORDE and fReadoutList.fList[25] != 0x00000000) return kACORDE;
 738   if (startAfter < kTRG and fReadoutList.fList[26] != 0x00000000) return kTRG;
 739   if (startAfter < kEMCAL and fReadoutList.fList[27] != 0x00000000) return kEMCAL;
 740 #if 1 // ROOT_SVN_REVISION < 9999  //FIXME: after fixed https://savannah.cern.ch/bugs/?69241
 741   // Check if we need to convert to new format and do so.
 742   if (fReadoutList.fCount == (unsigned)gkAliHLTDDLListSizeV0)
 743   {
 744     if (startAfter < kDAQTEST and fReadoutList.fList[28] != 0x00000000) return kDAQTEST;
 745     if (startAfter < kHLT and fReadoutList.fList[29] != 0x00000000) return kHLT;
 746   }
 747   else
 748 #endif
 749   {
 750     if (startAfter < kEMCAL and fReadoutList.fList[28] != 0x00000000) return kEMCAL;
 751     if (startAfter < kDAQTEST and fReadoutList.fList[29] != 0x00000000) return kDAQTEST;
 752     if (startAfter < kHLT and fReadoutList.fList[30] != 0x00000000) return kHLT;
 753   }
 754   return kNoDetector;
 755 }
 756
 757
 758 void AliHLTReadoutList::Print(Option_t* /*option*/) const
 759 {
 760   // Prints the DDLs that will be readout according to this readout list.
 761
 762   cout << "Readout enabled for DDLs:" << endl;
 763   for (Int_t i = 0; i < AliHLTDAQ::NumberOfDetectors(); i++)
 764   {
 765     Int_t maxddls = AliHLTDAQ::NumberOfDdls(i);
 766     cout << AliHLTDAQ::DetectorName(i) << ":";
 767     bool nonefound = true;
 768     for (Int_t j = 0; j < maxddls; j++)
 769     {
 770       Int_t ddlId = ( ((i == AliHLTDAQ::NumberOfDetectors()-1) ? 30 : i) << 8 ) + j;
 771       if (GetDDLBit(ddlId))
 772       {
 773         cout << " " << ddlId;
 774         nonefound = false;
 775       }
 776     }
 777     if (nonefound) cout << " none";
 778     cout << endl;
 779   }
 780 }
 781
 782
 783 AliHLTReadoutList& AliHLTReadoutList::operator = (const AliHLTReadoutList& list)
 784 {
 785   // Assignment operator performs a deep copy.
 786
 787   TObject::operator = (list);
 788   if (&list != this)
 789   {
 790     if (list.fReadoutList.fCount == (unsigned)gkAliHLTDDLListSize)
 791     {
 792       memcpy(&fReadoutList, &list.fReadoutList, sizeof(fReadoutList));
 793     }
 794     else
 795     {
 796       FillStruct(list);
 797     }
 798   }
 799   return *this;
 800 }
 801
 802
 803 AliHLTReadoutList& AliHLTReadoutList::operator |= (const AliHLTReadoutList& list)
 804 {
 805   // This operator performs a bitwise inclusive or operation on all DDL bits.
 806   // See header file for more details.
 807   this->OrEq(list);
 808   return *this;
 809 }
 810
 811 AliHLTReadoutList& AliHLTReadoutList::OrEq(const AliHLTReadoutList& list)
 812 {
 813   // a bitwise inclusive or operation on all DDL bits.
 814   // See header file for more details.
 815
 816   assert( fReadoutList.fCount == (unsigned)gkAliHLTDDLListSize );
 817   assert( fReadoutList.fCount == list.fReadoutList.fCount );
 818   for (Int_t i = 0; i < gkAliHLTDDLListSize; i++)
 819   {
 820     fReadoutList.fList[i] |= list.fReadoutList.fList[i];
 821   }
 822   return *this;
 823 }
 824
 825
 826 AliHLTReadoutList& AliHLTReadoutList::operator ^= (const AliHLTReadoutList& list)
 827 {
 828   // This operator performs a bitwise exclusive or (xor) operation on all DDL bits.
 829   // See header file for more details.
 830
 831   this->XorEq(list);
 832   return *this;
 833 }
 834
 835 AliHLTReadoutList& AliHLTReadoutList::XorEq(const AliHLTReadoutList& list)
 836 {
 837   // bitwise exclusive or (xor) operation on all DDL bits.
 838   // See header file for more details.
 839
 840   assert( fReadoutList.fCount == (unsigned)gkAliHLTDDLListSize );
 841   assert( fReadoutList.fCount == list.fReadoutList.fCount );
 842   for (Int_t i = 0; i < gkAliHLTDDLListSize; i++)
 843   {
 844     fReadoutList.fList[i] ^= list.fReadoutList.fList[i];
 845   }
 846   return *this;
 847 }
 848
 849
 850 AliHLTReadoutList& AliHLTReadoutList::operator &= (const AliHLTReadoutList& list)
 851 {
 852   // This operator performs a bitwise and operation on all DDL bits.
 853   // See header file for more details.
 854
 855   this->AndEq(list);
 856   return *this;
 857 }
 858
 859 AliHLTReadoutList& AliHLTReadoutList::AndEq(const AliHLTReadoutList& list)
 860 {
 861   // bitwise and operation on all DDL bits.
 862   // See header file for more details.
 863
 864   assert( fReadoutList.fCount == (unsigned)gkAliHLTDDLListSize );
 865   assert( fReadoutList.fCount == list.fReadoutList.fCount );
 866   for (Int_t i = 0; i < gkAliHLTDDLListSize; i++)
 867   {
 868     fReadoutList.fList[i] &= list.fReadoutList.fList[i];
 869   }
 870   return *this;
 871 }
 872
 873 AliHLTReadoutList& AliHLTReadoutList::operator -= (const AliHLTReadoutList& list)
 874 {
 875   // This operator removes all the DDLs specified in list from this readout list.
 876   // See header file for more details.
 877
 878   assert( fReadoutList.fCount == (unsigned)gkAliHLTDDLListSize );
 879   assert( fReadoutList.fCount == list.fReadoutList.fCount );
 880   for (Int_t i = 0; i < gkAliHLTDDLListSize; i++)
 881   {
 882     // Effectively apply: this = this & (~ (this & list))
 883     // i.e. this = this & (this ^ list)
 884     fReadoutList.fList[i] &= fReadoutList.fList[i] ^ list.fReadoutList.fList[i];
 885   }
 886   return *this;
 887 }
 888
 889
 890 AliHLTReadoutList AliHLTReadoutList::operator ~ () const
 891 {
 892   // This operator performs a bitwise ones compliment on all DDL bits.
 893   // See header file for more details.
 894
 895   AliHLTReadoutList readoutlist;
 896   readoutlist.fReadoutList.fCount = gkAliHLTDDLListSize;
 897   readoutlist.fReadoutList.fList[0] = 0x000FFFFF & (~fReadoutList.fList[0]);
 898   readoutlist.fReadoutList.fList[1] = 0x00FFFFFF & (~fReadoutList.fList[1]);
 899   readoutlist.fReadoutList.fList[2] = 0x0000FFFF & (~fReadoutList.fList[2]);
 900   readoutlist.fReadoutList.fList[3] = 0xFFFFFFFF & (~fReadoutList.fList[3]);
 901   readoutlist.fReadoutList.fList[4] = 0xFFFFFFFF & (~fReadoutList.fList[4]);
 902   readoutlist.fReadoutList.fList[5] = 0xFFFFFFFF & (~fReadoutList.fList[5]);
 903   readoutlist.fReadoutList.fList[6] = 0xFFFFFFFF & (~fReadoutList.fList[6]);
 904   readoutlist.fReadoutList.fList[7] = 0xFFFFFFFF & (~fReadoutList.fList[7]);
 905   readoutlist.fReadoutList.fList[8] = 0xFFFFFFFF & (~fReadoutList.fList[8]);
 906   readoutlist.fReadoutList.fList[9] = 0x00FFFFFF & (~fReadoutList.fList[9]);
 907   readoutlist.fReadoutList.fList[10] = 0x00000000;// & (~fReadoutList.fList[10]); // Commented out the end part to suppress coverty warning.
 908   readoutlist.fReadoutList.fList[11] = 0x0003FFFF & (~fReadoutList.fList[11]);
 909   readoutlist.fReadoutList.fList[12] = 0xFFFFFFFF & (~fReadoutList.fList[12]);
 910   readoutlist.fReadoutList.fList[13] = 0xFFFFFFFF & (~fReadoutList.fList[13]);
 911   readoutlist.fReadoutList.fList[14] = 0x000000FF & (~fReadoutList.fList[14]);
 912   readoutlist.fReadoutList.fList[15] = 0x000FFFFF & (~fReadoutList.fList[15]);
 913   readoutlist.fReadoutList.fList[16] = 0x000FFFFF & (~fReadoutList.fList[16]);
 914   readoutlist.fReadoutList.fList[17] = 0x000003FF & (~fReadoutList.fList[17]);
 915   readoutlist.fReadoutList.fList[18] = 0x0000003F & (~fReadoutList.fList[18]);
 916   readoutlist.fReadoutList.fList[19] = 0x000FFFFF & (~fReadoutList.fList[19]);
 917   readoutlist.fReadoutList.fList[20] = 0x00000003 & (~fReadoutList.fList[20]);
 918   readoutlist.fReadoutList.fList[21] = 0x00000007 & (~fReadoutList.fList[21]);
 919   readoutlist.fReadoutList.fList[22] = 0x00000001 & (~fReadoutList.fList[22]);
 920   readoutlist.fReadoutList.fList[23] = 0x00000001 & (~fReadoutList.fList[23]);
 921   readoutlist.fReadoutList.fList[24] = 0x00000001 & (~fReadoutList.fList[24]);
 922   readoutlist.fReadoutList.fList[25] = 0x00000001 & (~fReadoutList.fList[25]);
 923   readoutlist.fReadoutList.fList[26] = 0x00000001 & (~fReadoutList.fList[26]);
 924 #if 1 // ROOT_SVN_REVISION < 9999  //FIXME: after fixed https://savannah.cern.ch/bugs/?69241
 925   // Check if we need to convert to new format and do so.
 926   if (fReadoutList.fCount == (unsigned)gkAliHLTDDLListSizeV0)
 927   {
 928     readoutlist.fReadoutList.fList[27] = 0x00FFFFFF & (~fReadoutList.fList[27]);
 929     readoutlist.fReadoutList.fList[28] = 0x00000000;
 930     readoutlist.fReadoutList.fList[29] = 0x00000001 & (~fReadoutList.fList[28]);
 931     readoutlist.fReadoutList.fList[30] = 0x000003FF & (~fReadoutList.fList[29]);
 932   }
 933   else
 934 #endif
 935   {
 936     readoutlist.fReadoutList.fList[27] = 0xFFFFFFFF & (~fReadoutList.fList[27]);
 937     readoutlist.fReadoutList.fList[28] = 0x00003FFF & (~fReadoutList.fList[28]);
 938     readoutlist.fReadoutList.fList[29] = 0x00000001 & (~fReadoutList.fList[29]);
 939     readoutlist.fReadoutList.fList[30] = 0x0FFFFFFF & (~fReadoutList.fList[30]);
 940   }
 941   return readoutlist;
 942 }
 943
 944 #if ROOT_VERSION_CODE < ROOT_VERSION(5,26,0)
 945 void AliHLTReadoutList::Streamer(TBuffer &R__b)
 946 {
 947    // Stream an object of class AliHLTReadoutList.
 948
 949    if (R__b.IsReading()) {
 950       R__b.ReadClassBuffer(AliHLTReadoutList::Class(),this);
 951       // Convert old structure to new version if necessary.
 952       if (fReadoutList.fCount == (unsigned)gkAliHLTDDLListSizeV0)
 953       {
 954         fReadoutList.fList[30] = fReadoutList.fList[29];
 955         fReadoutList.fList[29] = fReadoutList.fList[28];
 956         fReadoutList.fList[28] = 0x0;
 957         fReadoutList.fCount = gkAliHLTDDLListSizeV1;
 958       }
 959    } else {
 960       R__b.WriteClassBuffer(AliHLTReadoutList::Class(),this);
 961    }
 962 }
 963 #endif // ROOT version check.