RAW/AliDAQ.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 //////////////////////////////////////////////////////////////////////////////
  17 //                                                                          //
  18 // The AliDAQ class is responsible for handling all the information about   //
  19 // Data Acquisition configuration. It defines the detector indexing,        //
  20 // the number of DDLs and LDCs per detector.                                //
  21 // The number of LDCs per detector is used only in the simulation in order  //
  22 // to define the configuration of the dateStream application. Therefore the //
  23 // numbers in the corresponding array can be changed without affecting the  //
  24 // rest of the aliroot code.                                                //
  25 // The equipment ID (DDL ID) is an integer (32-bit) number defined as:      //
  26 // Equipment ID = (detectorID << 8) + DDLIndex                              //
  27 // where the detectorID is given by fgkDetectorName array and DDLIndex is   //
  28 // the index of the corresponding DDL inside the detector partition.        //
  29 // Due to DAQ/HLT limitations, the ddl indexes should be consequtive, or    //
  30 // at least without big gaps in between.                                    //
  31 // The sub-detector code use only this class in the simulation and reading  //
  32 // of the raw data.                                                         //
  33 //                                                                          //
  34 // cvetan.cheshkov@cern.ch  2006/06/09                                      //
  35 //                                                                          //
  36 //////////////////////////////////////////////////////////////////////////////
  37
  38 #include <TClass.h>
  39 #include <TString.h>
  40
  41 #include "AliDAQ.h"
  42 #include "AliLog.h"
  43
  44 ClassImp(AliDAQ)
  45
  46 const char* AliDAQ::fgkDetectorName[AliDAQ::kNDetectors] = {
  47   "ITSSPD",
  48   "ITSSDD",
  49   "ITSSSD",
  50   "TPC",
  51   "TRD",
  52   "TOF",
  53   "HMPID",
  54   "PHOS",
  55   "CPV",
  56   "PMD",
  57   "MUONTRK",
  58   "MUONTRG",
  59   "FMD",
  60   "T0",
  61   "VZERO", // Name to be changed to V0 ?
  62   "ZDC",
  63   "ACORDE",
  64   "TRG",
  65   "EMCAL",
  66   "DAQ_TEST",
  67   "HLT"
  68 };
  69
  70 Int_t AliDAQ::fgkNumberOfDdls[AliDAQ::kNDetectors] = {
  71   20,
  72   24,
  73   16,
  74   216,
  75   18,
  76   72,
  77   20,
  78   20,
  79   10,
  80   6,
  81   20,
  82   2,
  83   3,
  84   1,
  85   1,
  86   1,
  87   1,
  88   1,
  89   24,
  90   1,
  91   10
  92 };
  93
  94 Float_t AliDAQ::fgkNumberOfLdcs[AliDAQ::kNDetectors] = {
  95   4,
  96   4,
  97   4,
  98   36,
  99   3,
 100   12,
 101   4,
 102   4,
 103   2,
 104   1,
 105   4,
 106   1,
 107   1,
 108   0.5,
 109   0.5,
 110   1,
 111   1,
 112   1,
 113   4,
 114   1,
 115   5
 116 };
 117
 118 AliDAQ::AliDAQ(const AliDAQ& source) :
 119   TObject(source)
 120 {
 121   // Copy constructor
 122   // Nothing to be done
 123 }
 124
 125 AliDAQ& AliDAQ::operator = (const AliDAQ& /* source */)
 126 {
 127   // Assignment operator
 128   // Nothing to be done
 129   return *this;
 130 }
 131
 132 Int_t AliDAQ::DetectorID(const char *detectorName)
 133 {
 134   // Return the detector index
 135   // corresponding to a given
 136   // detector name
 137   TString detStr = detectorName;
 138
 139   Int_t iDet;
 140   for(iDet = 0; iDet < kNDetectors; iDet++) {
 141     if (detStr.CompareTo(fgkDetectorName[iDet],TString::kIgnoreCase) == 0)
 142       break;
 143   }
 144   if (iDet == kNDetectors) {
 145     AliErrorClass(Form("Invalid detector name: %s !",detectorName));
 146     return -1;
 147   }
 148   return iDet;
 149 }
 150
 151 const char *AliDAQ::DetectorName(Int_t detectorID)
 152 {
 153   // Returns the name of particular
 154   // detector identified by its index
 155   if (detectorID < 0 || detectorID >= kNDetectors) {
 156     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 157     return "";
 158   }
 159   return fgkDetectorName[detectorID];
 160 }
 161
 162 Int_t AliDAQ::DdlIDOffset(const char *detectorName)
 163 {
 164   // Returns the DDL ID offset
 165   // for a given detector
 166   Int_t detectorID = DetectorID(detectorName);
 167   if (detectorID < 0)
 168     return -1;
 169
 170   return DdlIDOffset(detectorID);
 171 }
 172
 173 Int_t AliDAQ::DdlIDOffset(Int_t detectorID)
 174 {
 175   // Returns the DDL ID offset
 176   // for a given detector identified
 177   // by its index
 178   if (detectorID < 0 || detectorID >= kNDetectors) {
 179     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 180     return -1;
 181   }
 182   // HLT has a DDL offset = 30
 183   if (detectorID == (kNDetectors-1)) return (kHLTId << 8);
 184
 185   return (detectorID << 8);
 186 }
 187
 188 const char *AliDAQ::DetectorNameFromDdlID(Int_t ddlID,Int_t &ddlIndex)
 189 {
 190   // Returns the detector name for
 191   // a given DDL ID
 192   ddlIndex = -1;
 193   Int_t detectorID = DetectorIDFromDdlID(ddlID,ddlIndex);
 194   if (detectorID < 0)
 195     return "";
 196
 197   return DetectorName(detectorID);
 198 }
 199
 200 Int_t AliDAQ::DetectorIDFromDdlID(Int_t ddlID,Int_t &ddlIndex)
 201 {
 202   // Returns the detector ID and
 203   // the ddl index within the
 204   // detector range for
 205   // a given input DDL ID
 206   Int_t detectorID = ddlID >> 8;
 207
 208   // HLT
 209   if (detectorID == kHLTId) detectorID = kNDetectors-1;
 210
 211   if (detectorID < 0 || detectorID >= kNDetectors) {
 212     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 213     return -1;
 214   }
 215   ddlIndex = ddlID & 0xFF;
 216   if (ddlIndex >= fgkNumberOfDdls[detectorID]) {
 217     AliErrorClass(Form("Invalid DDL index %d (%d -> %d) for detector %d",
 218                        ddlIndex,0,fgkNumberOfDdls[detectorID],detectorID));
 219     ddlIndex = -1;
 220     return -1;
 221   }
 222   return detectorID;
 223 }
 224
 225 Int_t AliDAQ::DdlID(const char *detectorName, Int_t ddlIndex)
 226 {
 227   // Returns the DDL ID starting from
 228   // the detector name and the DDL
 229   // index inside the detector
 230   Int_t detectorID = DetectorID(detectorName);
 231   if (detectorID < 0)
 232     return -1;
 233
 234   return DdlID(detectorID,ddlIndex);
 235 }
 236
 237 Int_t AliDAQ::DdlID(Int_t detectorID, Int_t ddlIndex)
 238 {
 239   // Returns the DDL ID starting from
 240   // the detector ID and the DDL
 241   // index inside the detector
 242   Int_t ddlID = DdlIDOffset(detectorID);
 243   if (ddlID < 0)
 244     return -1;
 245
 246   if (ddlIndex >= fgkNumberOfDdls[detectorID]) {
 247     AliErrorClass(Form("Invalid DDL index %d (%d -> %d) for detector %d",
 248                        ddlIndex,0,fgkNumberOfDdls[detectorID],detectorID));
 249     return -1;
 250   }
 251
 252   ddlID += ddlIndex;
 253   return ddlID;
 254 }
 255
 256 const char *AliDAQ::DdlFileName(const char *detectorName, Int_t ddlIndex)
 257 {
 258   // Returns the DDL file name
 259   // (used in the simulation) starting from
 260   // the detector name and the DDL
 261   // index inside the detector
 262   Int_t detectorID = DetectorID(detectorName);
 263   if (detectorID < 0)
 264     return "";
 265
 266   return DdlFileName(detectorID,ddlIndex);
 267 }
 268
 269 const char *AliDAQ::DdlFileName(Int_t detectorID, Int_t ddlIndex)
 270 {
 271   // Returns the DDL file name
 272   // (used in the simulation) starting from
 273   // the detector ID and the DDL
 274   // index inside the detector
 275   Int_t ddlID = DdlIDOffset(detectorID);
 276   if (ddlID < 0)
 277     return "";
 278
 279   if (ddlIndex >= fgkNumberOfDdls[detectorID]) {
 280     AliErrorClass(Form("Invalid DDL index %d (%d -> %d) for detector %d",
 281                        ddlIndex,0,fgkNumberOfDdls[detectorID],detectorID));
 282     return "";
 283   }
 284
 285   ddlID += ddlIndex;
 286   static TString fileName;
 287
 288   fileName = DetectorName(detectorID);
 289   fileName += "_";
 290   fileName += ddlID;
 291   fileName += ".ddl";
 292   return fileName.Data();
 293 }
 294
 295 Int_t AliDAQ::NumberOfDdls(const char *detectorName)
 296 {
 297   // Returns the number of DDLs for
 298   // a given detector
 299   Int_t detectorID = DetectorID(detectorName);
 300   if (detectorID < 0)
 301     return -1;
 302
 303   return NumberOfDdls(detectorID);
 304 }
 305
 306 Int_t AliDAQ::NumberOfDdls(Int_t detectorID)
 307 {
 308   // Returns the number of DDLs for
 309   // a given detector
 310   if (detectorID < 0 || detectorID >= kNDetectors) {
 311     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 312     return -1;
 313   }
 314
 315   return fgkNumberOfDdls[detectorID];
 316 }
 317
 318 Float_t AliDAQ::NumberOfLdcs(const char *detectorName)
 319 {
 320   // Returns the number of DDLs for
 321   // a given detector
 322   Int_t detectorID = DetectorID(detectorName);
 323   if (detectorID < 0)
 324     return -1;
 325
 326   return NumberOfLdcs(detectorID);
 327 }
 328
 329 Float_t AliDAQ::NumberOfLdcs(Int_t detectorID)
 330 {
 331   // Returns the number of DDLs for
 332   // a given detector
 333   if (detectorID < 0 || detectorID >= kNDetectors) {
 334     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 335     return -1;
 336   }
 337
 338   return fgkNumberOfLdcs[detectorID];
 339 }
 340
 341 void AliDAQ::PrintConfig()
 342 {
 343   // Print the DAQ configuration
 344   // for all the detectors
 345   printf("====================================================================\n"
 346          "|                ALICE Data Acquisition Configuration              |\n"
 347          "====================================================================\n"
 348          "| Detector ID | Detector Name | DDL Offset | # of DDLs | # of LDCs |\n"
 349          "====================================================================\n");
 350   for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
 351     printf("|%11d  |%13s  |%10d  |%9d  |%9.1f  |\n",
 352            iDet,DetectorName(iDet),DdlIDOffset(iDet),NumberOfDdls(iDet),NumberOfLdcs(iDet));
 353   }
 354   printf("====================================================================\n");
 355
 356 }