STEER/STEERBase/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   "MFT",
  68   "FIT",  //alla
  69   "HLT"
  70 };
  71
  72 Int_t AliDAQ::fgkNumberOfDdls[AliDAQ::kNDetectors] = {
  73   20,
  74   24,
  75   16,
  76   216,
  77   18,
  78   72,
  79   20,
  80   20,
  81   10,
  82   6,
  83   20,
  84   2,
  85   3,
  86   1,
  87   1,
  88   1,
  89   1,
  90   1,
  91   46,
  92   1,
  93   10,
  94   1, // alla
  95   28
  96 };
  97
  98 Float_t AliDAQ::fgkNumberOfLdcs[AliDAQ::kNDetectors] = {
  99   4,
 100   4,
 101   4,
 102   36,
 103   3,
 104   12,
 105   4,
 106   4,
 107   2,
 108   1,
 109   5,
 110   1,
 111   1,
 112   0.5,
 113   0.5,
 114   1,
 115   1,
 116   1,
 117   8,
 118   1,
 119   1,
 120   1,  //alla
 121   7
 122 };
 123
 124 const char* AliDAQ::fgkOfflineModuleName[AliDAQ::kNDetectors] = {
 125   "ITS",
 126   "ITS",
 127   "ITS",
 128   "TPC",
 129   "TRD",
 130   "TOF",
 131   "HMPID",
 132   "PHOS",
 133   "CPV",
 134   "PMD",
 135   "MUON",
 136   "MUON",
 137   "FMD",
 138   "T0",
 139   "VZERO",
 140   "ZDC",
 141   "ACORDE",
 142   "CTP",
 143   "EMCAL",
 144   "DAQ_TEST",
 145   "MFT",
 146   "FIT",  //alla
 147   "HLT"
 148 };
 149
 150 const char* AliDAQ::fgkOnlineName[AliDAQ::kNDetectors] = {
 151   "SPD",
 152   "SDD",
 153   "SSD",
 154   "TPC",
 155   "TRD",
 156   "TOF",
 157   "HMP",
 158   "PHS",
 159   "CPV",
 160   "PMD",
 161   "MCH",
 162   "MTR",
 163   "FMD",
 164   "T00",
 165   "V00",
 166   "ZDC",
 167   "ACO",
 168   "TRI",
 169   "EMC",
 170   "TST",
 171   "MFT",
 172   "FIT",  //alla
 173   "HLT"
 174 };
 175
 176 AliDAQ::AliDAQ(const AliDAQ& source) :
 177   TObject(source)
 178 {
 179   // Copy constructor
 180   // Nothing to be done
 181 }
 182
 183 AliDAQ& AliDAQ::operator = (const AliDAQ& /* source */)
 184 {
 185   // Assignment operator
 186   // Nothing to be done
 187   return *this;
 188 }
 189
 190 Int_t AliDAQ::DetectorID(const char *detectorName)
 191 {
 192   // Return the detector index
 193   // corresponding to a given
 194   // detector name
 195   TString detStr = detectorName;
 196
 197   Int_t iDet;
 198   for(iDet = 0; iDet < kNDetectors; iDet++) {
 199     if (detStr.CompareTo(fgkDetectorName[iDet],TString::kIgnoreCase) == 0)
 200       break;
 201   }
 202   if (iDet == kNDetectors) {
 203     AliErrorClass(Form("Invalid detector name: %s !",detectorName));
 204     return -1;
 205   }
 206   return iDet;
 207 }
 208
 209 const char *AliDAQ::DetectorName(Int_t detectorID)
 210 {
 211   // Returns the name of particular
 212   // detector identified by its index
 213   if (detectorID < 0 || detectorID >= kNDetectors) {
 214     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 215     return "";
 216   }
 217   return fgkDetectorName[detectorID];
 218 }
 219
 220 Int_t AliDAQ::DdlIDOffset(const char *detectorName)
 221 {
 222   // Returns the DDL ID offset
 223   // for a given detector
 224   Int_t detectorID = DetectorID(detectorName);
 225   if (detectorID < 0)
 226     return -1;
 227
 228   return DdlIDOffset(detectorID);
 229 }
 230
 231 Int_t AliDAQ::DdlIDOffset(Int_t detectorID)
 232 {
 233   // Returns the DDL ID offset
 234   // for a given detector identified
 235   // by its index
 236   if (detectorID < 0 || detectorID >= kNDetectors) {
 237     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 238     return -1;
 239   }
 240   // HLT has a DDL offset = 30
 241   if (detectorID == (kNDetectors-1)) return (kHLTId << 8);
 242
 243   return (detectorID << 8);
 244 }
 245
 246 const char *AliDAQ::DetectorNameFromDdlID(Int_t ddlID,Int_t &ddlIndex)
 247 {
 248   // Returns the detector name for
 249   // a given DDL ID
 250   ddlIndex = -1;
 251   Int_t detectorID = DetectorIDFromDdlID(ddlID,ddlIndex);
 252   if (detectorID < 0)
 253     return "";
 254
 255   return DetectorName(detectorID);
 256 }
 257
 258 Int_t AliDAQ::DetectorIDFromDdlID(Int_t ddlID,Int_t &ddlIndex)
 259 {
 260   // Returns the detector ID and
 261   // the ddl index within the
 262   // detector range for
 263   // a given input DDL ID
 264   Int_t detectorID = ddlID >> 8;
 265
 266   // HLT
 267   if (detectorID == kHLTId) detectorID = kNDetectors-1;
 268
 269   if (detectorID < 0 || detectorID >= kNDetectors) {
 270     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 271     return -1;
 272   }
 273   ddlIndex = ddlID & 0xFF;
 274   if (ddlIndex >= fgkNumberOfDdls[detectorID]) {
 275     AliErrorClass(Form("Invalid DDL index %d (%d -> %d) for detector %d",
 276                        ddlIndex,0,fgkNumberOfDdls[detectorID],detectorID));
 277     ddlIndex = -1;
 278     return -1;
 279   }
 280   return detectorID;
 281 }
 282
 283 Int_t AliDAQ::DdlID(const char *detectorName, Int_t ddlIndex)
 284 {
 285   // Returns the DDL ID starting from
 286   // the detector name and the DDL
 287   // index inside the detector
 288   Int_t detectorID = DetectorID(detectorName);
 289   if (detectorID < 0)
 290     return -1;
 291
 292   return DdlID(detectorID,ddlIndex);
 293 }
 294
 295 Int_t AliDAQ::DdlID(Int_t detectorID, Int_t ddlIndex)
 296 {
 297   // Returns the DDL ID starting from
 298   // the detector ID and the DDL
 299   // index inside the detector
 300   Int_t ddlID = DdlIDOffset(detectorID);
 301   if (ddlID < 0)
 302     return -1;
 303
 304   if (ddlIndex >= fgkNumberOfDdls[detectorID]) {
 305     AliErrorClass(Form("Invalid DDL index %d (%d -> %d) for detector %d",
 306                        ddlIndex,0,fgkNumberOfDdls[detectorID],detectorID));
 307     return -1;
 308   }
 309
 310   ddlID += ddlIndex;
 311   return ddlID;
 312 }
 313
 314 const char *AliDAQ::DdlFileName(const char *detectorName, Int_t ddlIndex)
 315 {
 316   // Returns the DDL file name
 317   // (used in the simulation) starting from
 318   // the detector name and the DDL
 319   // index inside the detector
 320   Int_t detectorID = DetectorID(detectorName);
 321   if (detectorID < 0)
 322     return "";
 323
 324   return DdlFileName(detectorID,ddlIndex);
 325 }
 326
 327 const char *AliDAQ::DdlFileName(Int_t detectorID, Int_t ddlIndex)
 328 {
 329   // Returns the DDL file name
 330   // (used in the simulation) starting from
 331   // the detector ID and the DDL
 332   // index inside the detector
 333   Int_t ddlID = DdlIDOffset(detectorID);
 334   if (ddlID < 0)
 335     return "";
 336
 337   if (ddlIndex >= fgkNumberOfDdls[detectorID]) {
 338     AliErrorClass(Form("Invalid DDL index %d (%d -> %d) for detector %d",
 339                        ddlIndex,0,fgkNumberOfDdls[detectorID],detectorID));
 340     return "";
 341   }
 342
 343   ddlID += ddlIndex;
 344   static TString fileName;
 345
 346   fileName = DetectorName(detectorID);
 347   fileName += "_";
 348   fileName += ddlID;
 349   fileName += ".ddl";
 350   return fileName.Data();
 351 }
 352
 353 Int_t AliDAQ::NumberOfDdls(const char *detectorName)
 354 {
 355   // Returns the number of DDLs for
 356   // a given detector
 357   Int_t detectorID = DetectorID(detectorName);
 358   if (detectorID < 0)
 359     return -1;
 360
 361   return NumberOfDdls(detectorID);
 362 }
 363
 364 Int_t AliDAQ::NumberOfDdls(Int_t detectorID)
 365 {
 366   // Returns the number of DDLs for
 367   // a given detector
 368   if (detectorID < 0 || detectorID >= kNDetectors) {
 369     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 370     return -1;
 371   }
 372
 373   return fgkNumberOfDdls[detectorID];
 374 }
 375
 376 Float_t AliDAQ::NumberOfLdcs(const char *detectorName)
 377 {
 378   // Returns the number of DDLs for
 379   // a given detector
 380   Int_t detectorID = DetectorID(detectorName);
 381   if (detectorID < 0)
 382     return -1;
 383
 384   return NumberOfLdcs(detectorID);
 385 }
 386
 387 Float_t AliDAQ::NumberOfLdcs(Int_t detectorID)
 388 {
 389   // Returns the number of DDLs for
 390   // a given detector
 391   if (detectorID < 0 || detectorID >= kNDetectors) {
 392     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 393     return -1;
 394   }
 395
 396   return fgkNumberOfLdcs[detectorID];
 397 }
 398
 399 void AliDAQ::PrintConfig()
 400 {
 401   // Print the DAQ configuration
 402   // for all the detectors
 403   printf("===================================================================================================\n"
 404          "|                              ALICE Data Acquisition Configuration                               |\n"
 405          "===================================================================================================\n"
 406          "| Detector ID | Detector Name | DDL Offset | # of DDLs | # of LDCs | Online Name | AliRoot Module |\n"
 407          "===================================================================================================\n");
 408   for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
 409     printf("|%11d  |%13s  |%10d  |%9d  |%9.1f  |%11s  |%14s  |\n",
 410            iDet,DetectorName(iDet),DdlIDOffset(iDet),NumberOfDdls(iDet),NumberOfLdcs(iDet),
 411            OnlineName(iDet),OfflineModuleName(iDet));
 412   }
 413   printf("===================================================================================================\n");
 414
 415 }
 416
 417 const char *AliDAQ::ListOfTriggeredDetectors(UInt_t detectorPattern)
 418 {
 419   // Returns a string with the list of
 420   // active detectors. The input is the
 421   // trigger pattern word contained in
 422   // the raw-data event header.
 423
 424   static TString detList;
 425   detList = "";
 426   for(Int_t iDet = 0; iDet < (kNDetectors-1); iDet++) {
 427     if ((detectorPattern >> iDet) & 0x1) {
 428       detList += fgkDetectorName[iDet];
 429       detList += " ";
 430     }
 431   }
 432
 433   // Always remember HLT
 434   if ((detectorPattern >> kHLTId) & 0x1) detList += fgkDetectorName[kNDetectors-1];
 435
 436   return detList.Data();
 437 }
 438
 439 UInt_t  AliDAQ::DetectorPattern(const char *detectorList)
 440 {
 441   // Returns a 32-bit word containing the
 442   // the detector pattern corresponding to a given
 443   // list of detectors
 444   UInt_t pattern = 0;
 445   TString detList = detectorList;
 446   for(Int_t iDet = 0; iDet < (kNDetectors-1); iDet++) {
 447     TString det = fgkDetectorName[iDet];
 448     if((detList.CompareTo(det) == 0) ||
 449        detList.BeginsWith(det) ||
 450        detList.EndsWith(det) ||
 451        detList.Contains( " "+det+" " )) pattern |= (1 << iDet) ;
 452   }
 453
 454   // HLT
 455   TString hltDet = fgkDetectorName[kNDetectors-1];
 456   if((detList.CompareTo(hltDet) == 0) ||
 457        detList.BeginsWith(hltDet) ||
 458        detList.EndsWith(hltDet) ||
 459        detList.Contains( " "+hltDet+" " )) pattern |= (1 << kHLTId) ;
 460
 461   return pattern;
 462 }
 463
 464 UInt_t  AliDAQ::DetectorPatternOffline(const char *detectorList)
 465 {
 466   // Returns a 32-bit word containing the
 467   // the detector pattern corresponding to a given
 468   // list of detectors.
 469   // The list of detectors must follow offline module
 470   // name convention.
 471   UInt_t pattern = 0;
 472   TString detList = detectorList;
 473   for(Int_t iDet = 0; iDet < (kNDetectors-1); iDet++) {
 474     TString det = fgkOfflineModuleName[iDet];
 475     if((detList.CompareTo(det) == 0) ||
 476        detList.BeginsWith(det) ||
 477        detList.EndsWith(det) ||
 478        detList.Contains( " "+det+" " )) pattern |= (1 << iDet) ;
 479   }
 480
 481   // HLT
 482   TString hltDet = fgkOfflineModuleName[kNDetectors-1];
 483   if((detList.CompareTo(hltDet) == 0) ||
 484        detList.BeginsWith(hltDet) ||
 485        detList.EndsWith(hltDet) ||
 486        detList.Contains( " "+hltDet+" " )) pattern |= (1 << kHLTId) ;
 487
 488   return pattern;
 489 }
 490
 491 const char *AliDAQ::OfflineModuleName(const char *detectorName)
 492 {
 493   // Returns the name of the offline module
 494   // for a given detector (online naming convention)
 495   Int_t detectorID = DetectorID(detectorName);
 496   if (detectorID < 0)
 497     return "";
 498
 499   return OfflineModuleName(detectorID);
 500 }
 501
 502 const char *AliDAQ::OfflineModuleName(Int_t detectorID)
 503 {
 504   // Returns the name of the offline module
 505   // for a given detector (online naming convention)
 506   if (detectorID < 0 || detectorID >= kNDetectors) {
 507     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 508     return "";
 509   }
 510
 511   return fgkOfflineModuleName[detectorID];
 512 }
 513
 514 const char *AliDAQ::OnlineName(const char *detectorName)
 515 {
 516   // Returns the name of the online detector name (3 characters)
 517   // for a given detector
 518   Int_t detectorID = DetectorID(detectorName);
 519   if (detectorID < 0)
 520     return "";
 521
 522   return OnlineName(detectorID);
 523 }
 524
 525 const char *AliDAQ::OnlineName(Int_t detectorID)
 526 {
 527   // Returns the name of the online detector name (3 characters)
 528   // for a given detector
 529   if (detectorID < 0 || detectorID >= kNDetectors) {
 530     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 531     return "";
 532   }
 533
 534   return fgkOnlineName[detectorID];
 535 }
 536