ROOT logo
/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

//////////////////////////////////////////////////////////////////////////////
//                                                                          //
// The AliDAQ class is responsible for handling all the information about   //
// Data Acquisition configuration. It defines the detector indexing,        //
// the number of DDLs and LDCs per detector.                                //
// The number of LDCs per detector is used only in the simulation in order  //
// to define the configuration of the dateStream application. Therefore the //
// numbers in the corresponding array can be changed without affecting the  //
// rest of the aliroot code.                                                //
// The equipment ID (DDL ID) is an integer (32-bit) number defined as:      //
// Equipment ID = (detectorID << 8) + DDLIndex                              //
// where the detectorID is given by fgkDetectorName array and DDLIndex is   //
// the index of the corresponding DDL inside the detector partition.        //
// Due to DAQ/HLT limitations, the ddl indexes should be consequtive, or    //
// at least without big gaps in between.                                    //
// The sub-detector code use only this class in the simulation and reading  //
// of the raw data.                                                         //
//                                                                          //
// cvetan.cheshkov@cern.ch  2006/06/09                                      //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

#include <TClass.h>
#include <TString.h>

#include "AliDAQ.h"
#include "AliLog.h"

ClassImp(AliDAQ)

const char* AliDAQ::fgkDetectorName[AliDAQ::kNDetectors] = {
  "ITSSPD",
  "ITSSDD",
  "ITSSSD",
  "TPC",
  "TRD",
  "TOF",
  "HMPID",
  "PHOS",
  "CPV",
  "PMD",
  "MUONTRK",
  "MUONTRG",
  "FMD",
  "T0",
  "VZERO", // Name to be changed to V0 ?
  "ZDC",
  "ACORDE",
  "TRG",
  "EMCAL",
  "DAQ_TEST",
  "MFT",
  "FIT",  //alla
  "HLT"
};

Int_t AliDAQ::fgkNumberOfDdls[AliDAQ::kNDetectors] = {
  20,
  24,
  16,
  216,
  18,
  72,
  20,
  20,
  10,
  6,
  20,
  2,
  3,
  1,
  1,
  1,
  1,
  1,
  46,
  1,
  10,
  1, // alla
  28
};

Float_t AliDAQ::fgkNumberOfLdcs[AliDAQ::kNDetectors] = {
  4,
  4,
  4,
  36,
  3,
  12,
  4,
  4,
  2,
  1,
  5,
  1,
  1,
  0.5,
  0.5,
  1,
  1,
  1,
  8,
  1,
  1,
  1,  //alla
  7
};

const char* AliDAQ::fgkOfflineModuleName[AliDAQ::kNDetectors] = {
  "ITS",
  "ITS",
  "ITS",
  "TPC",
  "TRD",
  "TOF",
  "HMPID",
  "PHOS",
  "CPV",
  "PMD",
  "MUON",
  "MUON",
  "FMD",
  "T0",
  "VZERO",
  "ZDC",
  "ACORDE",
  "CTP",
  "EMCAL",
  "DAQ_TEST",
  "MFT",
  "FIT",  //alla
  "HLT"
};

const char* AliDAQ::fgkOnlineName[AliDAQ::kNDetectors] = {
  "SPD",
  "SDD",
  "SSD",
  "TPC",
  "TRD",
  "TOF",
  "HMP",
  "PHS",
  "CPV",
  "PMD",
  "MCH",
  "MTR",
  "FMD",
  "T00",
  "V00",
  "ZDC",
  "ACO",
  "TRI",
  "EMC",
  "TST",
  "MFT",
  "FIT",  //alla
  "HLT"
};

AliDAQ::AliDAQ(const AliDAQ& source) :
  TObject(source)
{
  // Copy constructor
  // Nothing to be done
}

AliDAQ& AliDAQ::operator = (const AliDAQ& /* source */)
{
  // Assignment operator
  // Nothing to be done
  return *this;
}

Int_t AliDAQ::DetectorID(const char *detectorName)
{
  // Return the detector index
  // corresponding to a given
  // detector name
  TString detStr = detectorName;

  Int_t iDet;
  for(iDet = 0; iDet < kNDetectors; iDet++) {
    if (detStr.CompareTo(fgkDetectorName[iDet],TString::kIgnoreCase) == 0)
      break;
  }
  if (iDet == kNDetectors) {
    AliErrorClass(Form("Invalid detector name: %s !",detectorName));
    return -1;
  }
  return iDet;
}

const char *AliDAQ::DetectorName(Int_t detectorID)
{
  // Returns the name of particular
  // detector identified by its index
  if (detectorID < 0 || detectorID >= kNDetectors) {
    AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
    return "";
  }
  return fgkDetectorName[detectorID];
}

Int_t AliDAQ::DdlIDOffset(const char *detectorName)
{
  // Returns the DDL ID offset
  // for a given detector
  Int_t detectorID = DetectorID(detectorName);
  if (detectorID < 0)
    return -1;
  
  return DdlIDOffset(detectorID);
}

Int_t AliDAQ::DdlIDOffset(Int_t detectorID)
{
  // Returns the DDL ID offset
  // for a given detector identified
  // by its index
  if (detectorID < 0 || detectorID >= kNDetectors) {
    AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
    return -1;
  }
  // HLT has a DDL offset = 30
  if (detectorID == (kNDetectors-1)) return (kHLTId << 8);

  return (detectorID << 8);
}

const char *AliDAQ::DetectorNameFromDdlID(Int_t ddlID,Int_t &ddlIndex)
{
  // Returns the detector name for
  // a given DDL ID
  ddlIndex = -1;
  Int_t detectorID = DetectorIDFromDdlID(ddlID,ddlIndex);
  if (detectorID < 0)
    return "";

  return DetectorName(detectorID);
}

Int_t AliDAQ::DetectorIDFromDdlID(Int_t ddlID,Int_t &ddlIndex)
{
  // Returns the detector ID and
  // the ddl index within the
  // detector range for
  // a given input DDL ID
  Int_t detectorID = ddlID >> 8;

  // HLT
  if (detectorID == kHLTId) detectorID = kNDetectors-1;

  if (detectorID < 0 || detectorID >= kNDetectors) {
    AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
    return -1;
  }
  ddlIndex = ddlID & 0xFF;
  if (ddlIndex >= fgkNumberOfDdls[detectorID]) {
    AliErrorClass(Form("Invalid DDL index %d (%d -> %d) for detector %d",
		       ddlIndex,0,fgkNumberOfDdls[detectorID],detectorID));
    ddlIndex = -1;
    return -1;
  }
  return detectorID;
}

Int_t AliDAQ::DdlID(const char *detectorName, Int_t ddlIndex)
{
  // Returns the DDL ID starting from
  // the detector name and the DDL
  // index inside the detector
  Int_t detectorID = DetectorID(detectorName);
  if (detectorID < 0)
    return -1;

  return DdlID(detectorID,ddlIndex);
}

Int_t AliDAQ::DdlID(Int_t detectorID, Int_t ddlIndex)
{
  // Returns the DDL ID starting from
  // the detector ID and the DDL
  // index inside the detector
  Int_t ddlID = DdlIDOffset(detectorID);
  if (ddlID < 0)
    return -1;
  
  if (ddlIndex >= fgkNumberOfDdls[detectorID]) {
    AliErrorClass(Form("Invalid DDL index %d (%d -> %d) for detector %d",
		       ddlIndex,0,fgkNumberOfDdls[detectorID],detectorID));
    return -1;
  }

  ddlID += ddlIndex;
  return ddlID;
}

const char *AliDAQ::DdlFileName(const char *detectorName, Int_t ddlIndex)
{
  // Returns the DDL file name
  // (used in the simulation) starting from
  // the detector name and the DDL
  // index inside the detector
  Int_t detectorID = DetectorID(detectorName);
  if (detectorID < 0)
    return "";

  return DdlFileName(detectorID,ddlIndex);
}

const char *AliDAQ::DdlFileName(Int_t detectorID, Int_t ddlIndex)
{
  // Returns the DDL file name
  // (used in the simulation) starting from
  // the detector ID and the DDL
  // index inside the detector
  Int_t ddlID = DdlIDOffset(detectorID);
  if (ddlID < 0)
    return "";
  
  if (ddlIndex >= fgkNumberOfDdls[detectorID]) {
    AliErrorClass(Form("Invalid DDL index %d (%d -> %d) for detector %d",
		       ddlIndex,0,fgkNumberOfDdls[detectorID],detectorID));
    return "";
  }

  ddlID += ddlIndex;
  static TString fileName;

  fileName = DetectorName(detectorID);
  fileName += "_";
  fileName += ddlID;
  fileName += ".ddl";
  return fileName.Data();
}

Int_t AliDAQ::NumberOfDdls(const char *detectorName)
{
  // Returns the number of DDLs for
  // a given detector
  Int_t detectorID = DetectorID(detectorName);
  if (detectorID < 0)
    return -1;

  return NumberOfDdls(detectorID);
}

Int_t AliDAQ::NumberOfDdls(Int_t detectorID)
{
  // Returns the number of DDLs for
  // a given detector
  if (detectorID < 0 || detectorID >= kNDetectors) {
    AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
    return -1;
  }

  return fgkNumberOfDdls[detectorID];
}

Float_t AliDAQ::NumberOfLdcs(const char *detectorName)
{
  // Returns the number of DDLs for
  // a given detector
  Int_t detectorID = DetectorID(detectorName);
  if (detectorID < 0)
    return -1;

  return NumberOfLdcs(detectorID);
}

Float_t AliDAQ::NumberOfLdcs(Int_t detectorID)
{
  // Returns the number of DDLs for
  // a given detector
  if (detectorID < 0 || detectorID >= kNDetectors) {
    AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
    return -1;
  }

  return fgkNumberOfLdcs[detectorID];
}

void AliDAQ::PrintConfig()
{
  // Print the DAQ configuration
  // for all the detectors
  printf("===================================================================================================\n"
	 "|                              ALICE Data Acquisition Configuration                               |\n"
	 "===================================================================================================\n"
	 "| Detector ID | Detector Name | DDL Offset | # of DDLs | # of LDCs | Online Name | AliRoot Module |\n"
	 "===================================================================================================\n");
  for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
    printf("|%11d  |%13s  |%10d  |%9d  |%9.1f  |%11s  |%14s  |\n",
	   iDet,DetectorName(iDet),DdlIDOffset(iDet),NumberOfDdls(iDet),NumberOfLdcs(iDet),
	   OnlineName(iDet),OfflineModuleName(iDet));
  }
  printf("===================================================================================================\n");

}

const char *AliDAQ::ListOfTriggeredDetectors(UInt_t detectorPattern)
{
  // Returns a string with the list of
  // active detectors. The input is the
  // trigger pattern word contained in
  // the raw-data event header.

  static TString detList;
  detList = "";
  for(Int_t iDet = 0; iDet < (kNDetectors-1); iDet++) {
    if ((detectorPattern >> iDet) & 0x1) {
      detList += fgkDetectorName[iDet];
      detList += " ";
    }
  }

  // Always remember HLT
  if ((detectorPattern >> kHLTId) & 0x1) detList += fgkDetectorName[kNDetectors-1];

  return detList.Data();
}

UInt_t  AliDAQ::DetectorPattern(const char *detectorList)
{
  // Returns a 32-bit word containing the
  // the detector pattern corresponding to a given
  // list of detectors
  UInt_t pattern = 0;
  TString detList = detectorList;
  for(Int_t iDet = 0; iDet < (kNDetectors-1); iDet++) {
    TString det = fgkDetectorName[iDet];
    if((detList.CompareTo(det) == 0) || 
       detList.BeginsWith(det) ||
       detList.EndsWith(det) ||
       detList.Contains( " "+det+" " )) pattern |= (1 << iDet) ;
  }

  // HLT
  TString hltDet = fgkDetectorName[kNDetectors-1];
  if((detList.CompareTo(hltDet) == 0) || 
       detList.BeginsWith(hltDet) ||
       detList.EndsWith(hltDet) ||
       detList.Contains( " "+hltDet+" " )) pattern |= (1 << kHLTId) ;
  
  return pattern;
}

UInt_t  AliDAQ::DetectorPatternOffline(const char *detectorList)
{
  // Returns a 32-bit word containing the
  // the detector pattern corresponding to a given
  // list of detectors.
  // The list of detectors must follow offline module
  // name convention.
  UInt_t pattern = 0;
  TString detList = detectorList;
  for(Int_t iDet = 0; iDet < (kNDetectors-1); iDet++) {
    TString det = fgkOfflineModuleName[iDet];
    if((detList.CompareTo(det) == 0) || 
       detList.BeginsWith(det) ||
       detList.EndsWith(det) ||
       detList.Contains( " "+det+" " )) pattern |= (1 << iDet) ;
  }

  // HLT
  TString hltDet = fgkOfflineModuleName[kNDetectors-1];
  if((detList.CompareTo(hltDet) == 0) || 
       detList.BeginsWith(hltDet) ||
       detList.EndsWith(hltDet) ||
       detList.Contains( " "+hltDet+" " )) pattern |= (1 << kHLTId) ;
  
  return pattern;
}

const char *AliDAQ::OfflineModuleName(const char *detectorName)
{
  // Returns the name of the offline module
  // for a given detector (online naming convention)
  Int_t detectorID = DetectorID(detectorName);
  if (detectorID < 0)
    return "";

  return OfflineModuleName(detectorID);
}

const char *AliDAQ::OfflineModuleName(Int_t detectorID)
{
  // Returns the name of the offline module
  // for a given detector (online naming convention)
  if (detectorID < 0 || detectorID >= kNDetectors) {
    AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
    return "";
  }

  return fgkOfflineModuleName[detectorID];
}

const char *AliDAQ::OnlineName(const char *detectorName)
{
  // Returns the name of the online detector name (3 characters)
  // for a given detector
  Int_t detectorID = DetectorID(detectorName);
  if (detectorID < 0)
    return "";

  return OnlineName(detectorID);
}

const char *AliDAQ::OnlineName(Int_t detectorID)
{
  // Returns the name of the online detector name (3 characters)
  // for a given detector
  if (detectorID < 0 || detectorID >= kNDetectors) {
    AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
    return "";
  }

  return fgkOnlineName[detectorID];
}

 AliDAQ.cxx:1
 AliDAQ.cxx:2
 AliDAQ.cxx:3
 AliDAQ.cxx:4
 AliDAQ.cxx:5
 AliDAQ.cxx:6
 AliDAQ.cxx:7
 AliDAQ.cxx:8
 AliDAQ.cxx:9
 AliDAQ.cxx:10
 AliDAQ.cxx:11
 AliDAQ.cxx:12
 AliDAQ.cxx:13
 AliDAQ.cxx:14
 AliDAQ.cxx:15
 AliDAQ.cxx:16
 AliDAQ.cxx:17
 AliDAQ.cxx:18
 AliDAQ.cxx:19
 AliDAQ.cxx:20
 AliDAQ.cxx:21
 AliDAQ.cxx:22
 AliDAQ.cxx:23
 AliDAQ.cxx:24
 AliDAQ.cxx:25
 AliDAQ.cxx:26
 AliDAQ.cxx:27
 AliDAQ.cxx:28
 AliDAQ.cxx:29
 AliDAQ.cxx:30
 AliDAQ.cxx:31
 AliDAQ.cxx:32
 AliDAQ.cxx:33
 AliDAQ.cxx:34
 AliDAQ.cxx:35
 AliDAQ.cxx:36
 AliDAQ.cxx:37
 AliDAQ.cxx:38
 AliDAQ.cxx:39
 AliDAQ.cxx:40
 AliDAQ.cxx:41
 AliDAQ.cxx:42
 AliDAQ.cxx:43
 AliDAQ.cxx:44
 AliDAQ.cxx:45
 AliDAQ.cxx:46
 AliDAQ.cxx:47
 AliDAQ.cxx:48
 AliDAQ.cxx:49
 AliDAQ.cxx:50
 AliDAQ.cxx:51
 AliDAQ.cxx:52
 AliDAQ.cxx:53
 AliDAQ.cxx:54
 AliDAQ.cxx:55
 AliDAQ.cxx:56
 AliDAQ.cxx:57
 AliDAQ.cxx:58
 AliDAQ.cxx:59
 AliDAQ.cxx:60
 AliDAQ.cxx:61
 AliDAQ.cxx:62
 AliDAQ.cxx:63
 AliDAQ.cxx:64
 AliDAQ.cxx:65
 AliDAQ.cxx:66
 AliDAQ.cxx:67
 AliDAQ.cxx:68
 AliDAQ.cxx:69
 AliDAQ.cxx:70
 AliDAQ.cxx:71
 AliDAQ.cxx:72
 AliDAQ.cxx:73
 AliDAQ.cxx:74
 AliDAQ.cxx:75
 AliDAQ.cxx:76
 AliDAQ.cxx:77
 AliDAQ.cxx:78
 AliDAQ.cxx:79
 AliDAQ.cxx:80
 AliDAQ.cxx:81
 AliDAQ.cxx:82
 AliDAQ.cxx:83
 AliDAQ.cxx:84
 AliDAQ.cxx:85
 AliDAQ.cxx:86
 AliDAQ.cxx:87
 AliDAQ.cxx:88
 AliDAQ.cxx:89
 AliDAQ.cxx:90
 AliDAQ.cxx:91
 AliDAQ.cxx:92
 AliDAQ.cxx:93
 AliDAQ.cxx:94
 AliDAQ.cxx:95
 AliDAQ.cxx:96
 AliDAQ.cxx:97
 AliDAQ.cxx:98
 AliDAQ.cxx:99
 AliDAQ.cxx:100
 AliDAQ.cxx:101
 AliDAQ.cxx:102
 AliDAQ.cxx:103
 AliDAQ.cxx:104
 AliDAQ.cxx:105
 AliDAQ.cxx:106
 AliDAQ.cxx:107
 AliDAQ.cxx:108
 AliDAQ.cxx:109
 AliDAQ.cxx:110
 AliDAQ.cxx:111
 AliDAQ.cxx:112
 AliDAQ.cxx:113
 AliDAQ.cxx:114
 AliDAQ.cxx:115
 AliDAQ.cxx:116
 AliDAQ.cxx:117
 AliDAQ.cxx:118
 AliDAQ.cxx:119
 AliDAQ.cxx:120
 AliDAQ.cxx:121
 AliDAQ.cxx:122
 AliDAQ.cxx:123
 AliDAQ.cxx:124
 AliDAQ.cxx:125
 AliDAQ.cxx:126
 AliDAQ.cxx:127
 AliDAQ.cxx:128
 AliDAQ.cxx:129
 AliDAQ.cxx:130
 AliDAQ.cxx:131
 AliDAQ.cxx:132
 AliDAQ.cxx:133
 AliDAQ.cxx:134
 AliDAQ.cxx:135
 AliDAQ.cxx:136
 AliDAQ.cxx:137
 AliDAQ.cxx:138
 AliDAQ.cxx:139
 AliDAQ.cxx:140
 AliDAQ.cxx:141
 AliDAQ.cxx:142
 AliDAQ.cxx:143
 AliDAQ.cxx:144
 AliDAQ.cxx:145
 AliDAQ.cxx:146
 AliDAQ.cxx:147
 AliDAQ.cxx:148
 AliDAQ.cxx:149
 AliDAQ.cxx:150
 AliDAQ.cxx:151
 AliDAQ.cxx:152
 AliDAQ.cxx:153
 AliDAQ.cxx:154
 AliDAQ.cxx:155
 AliDAQ.cxx:156
 AliDAQ.cxx:157
 AliDAQ.cxx:158
 AliDAQ.cxx:159
 AliDAQ.cxx:160
 AliDAQ.cxx:161
 AliDAQ.cxx:162
 AliDAQ.cxx:163
 AliDAQ.cxx:164
 AliDAQ.cxx:165
 AliDAQ.cxx:166
 AliDAQ.cxx:167
 AliDAQ.cxx:168
 AliDAQ.cxx:169
 AliDAQ.cxx:170
 AliDAQ.cxx:171
 AliDAQ.cxx:172
 AliDAQ.cxx:173
 AliDAQ.cxx:174
 AliDAQ.cxx:175
 AliDAQ.cxx:176
 AliDAQ.cxx:177
 AliDAQ.cxx:178
 AliDAQ.cxx:179
 AliDAQ.cxx:180
 AliDAQ.cxx:181
 AliDAQ.cxx:182
 AliDAQ.cxx:183
 AliDAQ.cxx:184
 AliDAQ.cxx:185
 AliDAQ.cxx:186
 AliDAQ.cxx:187
 AliDAQ.cxx:188
 AliDAQ.cxx:189
 AliDAQ.cxx:190
 AliDAQ.cxx:191
 AliDAQ.cxx:192
 AliDAQ.cxx:193
 AliDAQ.cxx:194
 AliDAQ.cxx:195
 AliDAQ.cxx:196
 AliDAQ.cxx:197
 AliDAQ.cxx:198
 AliDAQ.cxx:199
 AliDAQ.cxx:200
 AliDAQ.cxx:201
 AliDAQ.cxx:202
 AliDAQ.cxx:203
 AliDAQ.cxx:204
 AliDAQ.cxx:205
 AliDAQ.cxx:206
 AliDAQ.cxx:207
 AliDAQ.cxx:208
 AliDAQ.cxx:209
 AliDAQ.cxx:210
 AliDAQ.cxx:211
 AliDAQ.cxx:212
 AliDAQ.cxx:213
 AliDAQ.cxx:214
 AliDAQ.cxx:215
 AliDAQ.cxx:216
 AliDAQ.cxx:217
 AliDAQ.cxx:218
 AliDAQ.cxx:219
 AliDAQ.cxx:220
 AliDAQ.cxx:221
 AliDAQ.cxx:222
 AliDAQ.cxx:223
 AliDAQ.cxx:224
 AliDAQ.cxx:225
 AliDAQ.cxx:226
 AliDAQ.cxx:227
 AliDAQ.cxx:228
 AliDAQ.cxx:229
 AliDAQ.cxx:230
 AliDAQ.cxx:231
 AliDAQ.cxx:232
 AliDAQ.cxx:233
 AliDAQ.cxx:234
 AliDAQ.cxx:235
 AliDAQ.cxx:236
 AliDAQ.cxx:237
 AliDAQ.cxx:238
 AliDAQ.cxx:239
 AliDAQ.cxx:240
 AliDAQ.cxx:241
 AliDAQ.cxx:242
 AliDAQ.cxx:243
 AliDAQ.cxx:244
 AliDAQ.cxx:245
 AliDAQ.cxx:246
 AliDAQ.cxx:247
 AliDAQ.cxx:248
 AliDAQ.cxx:249
 AliDAQ.cxx:250
 AliDAQ.cxx:251
 AliDAQ.cxx:252
 AliDAQ.cxx:253
 AliDAQ.cxx:254
 AliDAQ.cxx:255
 AliDAQ.cxx:256
 AliDAQ.cxx:257
 AliDAQ.cxx:258
 AliDAQ.cxx:259
 AliDAQ.cxx:260
 AliDAQ.cxx:261
 AliDAQ.cxx:262
 AliDAQ.cxx:263
 AliDAQ.cxx:264
 AliDAQ.cxx:265
 AliDAQ.cxx:266
 AliDAQ.cxx:267
 AliDAQ.cxx:268
 AliDAQ.cxx:269
 AliDAQ.cxx:270
 AliDAQ.cxx:271
 AliDAQ.cxx:272
 AliDAQ.cxx:273
 AliDAQ.cxx:274
 AliDAQ.cxx:275
 AliDAQ.cxx:276
 AliDAQ.cxx:277
 AliDAQ.cxx:278
 AliDAQ.cxx:279
 AliDAQ.cxx:280
 AliDAQ.cxx:281
 AliDAQ.cxx:282
 AliDAQ.cxx:283
 AliDAQ.cxx:284
 AliDAQ.cxx:285
 AliDAQ.cxx:286
 AliDAQ.cxx:287
 AliDAQ.cxx:288
 AliDAQ.cxx:289
 AliDAQ.cxx:290
 AliDAQ.cxx:291
 AliDAQ.cxx:292
 AliDAQ.cxx:293
 AliDAQ.cxx:294
 AliDAQ.cxx:295
 AliDAQ.cxx:296
 AliDAQ.cxx:297
 AliDAQ.cxx:298
 AliDAQ.cxx:299
 AliDAQ.cxx:300
 AliDAQ.cxx:301
 AliDAQ.cxx:302
 AliDAQ.cxx:303
 AliDAQ.cxx:304
 AliDAQ.cxx:305
 AliDAQ.cxx:306
 AliDAQ.cxx:307
 AliDAQ.cxx:308
 AliDAQ.cxx:309
 AliDAQ.cxx:310
 AliDAQ.cxx:311
 AliDAQ.cxx:312
 AliDAQ.cxx:313
 AliDAQ.cxx:314
 AliDAQ.cxx:315
 AliDAQ.cxx:316
 AliDAQ.cxx:317
 AliDAQ.cxx:318
 AliDAQ.cxx:319
 AliDAQ.cxx:320
 AliDAQ.cxx:321
 AliDAQ.cxx:322
 AliDAQ.cxx:323
 AliDAQ.cxx:324
 AliDAQ.cxx:325
 AliDAQ.cxx:326
 AliDAQ.cxx:327
 AliDAQ.cxx:328
 AliDAQ.cxx:329
 AliDAQ.cxx:330
 AliDAQ.cxx:331
 AliDAQ.cxx:332
 AliDAQ.cxx:333
 AliDAQ.cxx:334
 AliDAQ.cxx:335
 AliDAQ.cxx:336
 AliDAQ.cxx:337
 AliDAQ.cxx:338
 AliDAQ.cxx:339
 AliDAQ.cxx:340
 AliDAQ.cxx:341
 AliDAQ.cxx:342
 AliDAQ.cxx:343
 AliDAQ.cxx:344
 AliDAQ.cxx:345
 AliDAQ.cxx:346
 AliDAQ.cxx:347
 AliDAQ.cxx:348
 AliDAQ.cxx:349
 AliDAQ.cxx:350
 AliDAQ.cxx:351
 AliDAQ.cxx:352
 AliDAQ.cxx:353
 AliDAQ.cxx:354
 AliDAQ.cxx:355
 AliDAQ.cxx:356
 AliDAQ.cxx:357
 AliDAQ.cxx:358
 AliDAQ.cxx:359
 AliDAQ.cxx:360
 AliDAQ.cxx:361
 AliDAQ.cxx:362
 AliDAQ.cxx:363
 AliDAQ.cxx:364
 AliDAQ.cxx:365
 AliDAQ.cxx:366
 AliDAQ.cxx:367
 AliDAQ.cxx:368
 AliDAQ.cxx:369
 AliDAQ.cxx:370
 AliDAQ.cxx:371
 AliDAQ.cxx:372
 AliDAQ.cxx:373
 AliDAQ.cxx:374
 AliDAQ.cxx:375
 AliDAQ.cxx:376
 AliDAQ.cxx:377
 AliDAQ.cxx:378
 AliDAQ.cxx:379
 AliDAQ.cxx:380
 AliDAQ.cxx:381
 AliDAQ.cxx:382
 AliDAQ.cxx:383
 AliDAQ.cxx:384
 AliDAQ.cxx:385
 AliDAQ.cxx:386
 AliDAQ.cxx:387
 AliDAQ.cxx:388
 AliDAQ.cxx:389
 AliDAQ.cxx:390
 AliDAQ.cxx:391
 AliDAQ.cxx:392
 AliDAQ.cxx:393
 AliDAQ.cxx:394
 AliDAQ.cxx:395
 AliDAQ.cxx:396
 AliDAQ.cxx:397
 AliDAQ.cxx:398
 AliDAQ.cxx:399
 AliDAQ.cxx:400
 AliDAQ.cxx:401
 AliDAQ.cxx:402
 AliDAQ.cxx:403
 AliDAQ.cxx:404
 AliDAQ.cxx:405
 AliDAQ.cxx:406
 AliDAQ.cxx:407
 AliDAQ.cxx:408
 AliDAQ.cxx:409
 AliDAQ.cxx:410
 AliDAQ.cxx:411
 AliDAQ.cxx:412
 AliDAQ.cxx:413
 AliDAQ.cxx:414
 AliDAQ.cxx:415
 AliDAQ.cxx:416
 AliDAQ.cxx:417
 AliDAQ.cxx:418
 AliDAQ.cxx:419
 AliDAQ.cxx:420
 AliDAQ.cxx:421
 AliDAQ.cxx:422
 AliDAQ.cxx:423
 AliDAQ.cxx:424
 AliDAQ.cxx:425
 AliDAQ.cxx:426
 AliDAQ.cxx:427
 AliDAQ.cxx:428
 AliDAQ.cxx:429
 AliDAQ.cxx:430
 AliDAQ.cxx:431
 AliDAQ.cxx:432
 AliDAQ.cxx:433
 AliDAQ.cxx:434
 AliDAQ.cxx:435
 AliDAQ.cxx:436
 AliDAQ.cxx:437
 AliDAQ.cxx:438
 AliDAQ.cxx:439
 AliDAQ.cxx:440
 AliDAQ.cxx:441
 AliDAQ.cxx:442
 AliDAQ.cxx:443
 AliDAQ.cxx:444
 AliDAQ.cxx:445
 AliDAQ.cxx:446
 AliDAQ.cxx:447
 AliDAQ.cxx:448
 AliDAQ.cxx:449
 AliDAQ.cxx:450
 AliDAQ.cxx:451
 AliDAQ.cxx:452
 AliDAQ.cxx:453
 AliDAQ.cxx:454
 AliDAQ.cxx:455
 AliDAQ.cxx:456
 AliDAQ.cxx:457
 AliDAQ.cxx:458
 AliDAQ.cxx:459
 AliDAQ.cxx:460
 AliDAQ.cxx:461
 AliDAQ.cxx:462
 AliDAQ.cxx:463
 AliDAQ.cxx:464
 AliDAQ.cxx:465
 AliDAQ.cxx:466
 AliDAQ.cxx:467
 AliDAQ.cxx:468
 AliDAQ.cxx:469
 AliDAQ.cxx:470
 AliDAQ.cxx:471
 AliDAQ.cxx:472
 AliDAQ.cxx:473
 AliDAQ.cxx:474
 AliDAQ.cxx:475
 AliDAQ.cxx:476
 AliDAQ.cxx:477
 AliDAQ.cxx:478
 AliDAQ.cxx:479
 AliDAQ.cxx:480
 AliDAQ.cxx:481
 AliDAQ.cxx:482
 AliDAQ.cxx:483
 AliDAQ.cxx:484
 AliDAQ.cxx:485
 AliDAQ.cxx:486
 AliDAQ.cxx:487
 AliDAQ.cxx:488
 AliDAQ.cxx:489
 AliDAQ.cxx:490
 AliDAQ.cxx:491
 AliDAQ.cxx:492
 AliDAQ.cxx:493
 AliDAQ.cxx:494
 AliDAQ.cxx:495
 AliDAQ.cxx:496
 AliDAQ.cxx:497
 AliDAQ.cxx:498
 AliDAQ.cxx:499
 AliDAQ.cxx:500
 AliDAQ.cxx:501
 AliDAQ.cxx:502
 AliDAQ.cxx:503
 AliDAQ.cxx:504
 AliDAQ.cxx:505
 AliDAQ.cxx:506
 AliDAQ.cxx:507
 AliDAQ.cxx:508
 AliDAQ.cxx:509
 AliDAQ.cxx:510
 AliDAQ.cxx:511
 AliDAQ.cxx:512
 AliDAQ.cxx:513
 AliDAQ.cxx:514
 AliDAQ.cxx:515
 AliDAQ.cxx:516
 AliDAQ.cxx:517
 AliDAQ.cxx:518
 AliDAQ.cxx:519
 AliDAQ.cxx:520
 AliDAQ.cxx:521
 AliDAQ.cxx:522
 AliDAQ.cxx:523
 AliDAQ.cxx:524
 AliDAQ.cxx:525
 AliDAQ.cxx:526
 AliDAQ.cxx:527
 AliDAQ.cxx:528
 AliDAQ.cxx:529
 AliDAQ.cxx:530
 AliDAQ.cxx:531
 AliDAQ.cxx:532
 AliDAQ.cxx:533
 AliDAQ.cxx:534
 AliDAQ.cxx:535
 AliDAQ.cxx:536