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