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   "RICH",  // Name to be changed to HMPID
  54   "PHOS",
  55   "CPV",
  56   "PMD",
  57   "MUONTRK",
  58   "MUONTRG",
  59   "FMD",
  60   "START", // Name to be changed to T0
  61   "VZERO", // Name to be changed to V0 ?
  62   "ZDC",
  63   "CRT",   // Name to be changed to ACCORDE
  64   "TRG",
  65   "EMCAL",
  66   "HLT"
  67 };
  68
  69 Int_t AliDAQ::fgkNumberOfDdls[AliDAQ::kNDetectors] = {
  70   20,
  71   24,
  72   16,
  73   216,
  74   18,
  75   72,
  76   20,
  77   20,
  78   10,
  79   6,
  80   20,
  81   2,
  82   3,
  83   1,
  84   1,
  85   1,
  86   1,
  87   1,
  88   24,
  89   10
  90 };
  91
  92 Float_t AliDAQ::fgkNumberOfLdcs[AliDAQ::kNDetectors] = {
  93   4,
  94   4,
  95   4,
  96   36,
  97   3,
  98   12,
  99   4,
 100   4,
 101   2,
 102   1,
 103   4,
 104   1,
 105   1,
 106   0.5,
 107   0.5,
 108   1,
 109   1,
 110   1,
 111   4,
 112   5
 113 };
 114
 115 AliDAQ::AliDAQ(const AliDAQ& source) :
 116   TObject(source)
 117 {
 118   // Copy constructor
 119   // Nothing to be done
 120 }
 121
 122 AliDAQ& AliDAQ::operator = (const AliDAQ& /* source */)
 123 {
 124   // Assignment operator
 125   // Nothing to be done
 126   return *this;
 127 }
 128
 129 Int_t AliDAQ::DetectorID(const char *detectorName)
 130 {
 131   // Return the detector index
 132   // corresponding to a given
 133   // detector name
 134   TString detStr = detectorName;
 135
 136   Int_t iDet;
 137   for(iDet = 0; iDet < kNDetectors; iDet++) {
 138     if (detStr.CompareTo(fgkDetectorName[iDet],TString::kIgnoreCase) == 0)
 139       break;
 140   }
 141   if (iDet == kNDetectors) {
 142     AliErrorClass(Form("Invalid detector name: %s !",detectorName));
 143     return -1;
 144   }
 145   return iDet;
 146 }
 147
 148 const char *AliDAQ::DetectorName(Int_t detectorID)
 149 {
 150   // Returns the name of particular
 151   // detector identified by its index
 152   if (detectorID < 0 || detectorID >= kNDetectors) {
 153     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 154     return "";
 155   }
 156   return fgkDetectorName[detectorID];
 157 }
 158
 159 Int_t AliDAQ::DdlIDOffset(const char *detectorName)
 160 {
 161   // Returns the DDL ID offset
 162   // for a given detector
 163   Int_t detectorID = DetectorID(detectorName);
 164   if (detectorID < 0)
 165     return -1;
 166
 167   return DdlIDOffset(detectorID);
 168 }
 169
 170 Int_t AliDAQ::DdlIDOffset(Int_t detectorID)
 171 {
 172   // Returns the DDL ID offset
 173   // for a given detector identified
 174   // by its index
 175   if (detectorID < 0 || detectorID >= kNDetectors) {
 176     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 177     return -1;
 178   }
 179   return (detectorID << 8);
 180 }
 181
 182 const char *AliDAQ::DetectorNameFromDdlID(Int_t ddlID)
 183 {
 184   // Returns the detector name for
 185   // a given DDL ID
 186   Int_t detectorID = DetectorIDFromDdlID(ddlID);
 187   if (detectorID < 0)
 188     return "";
 189
 190   return DetectorName(detectorID);
 191 }
 192
 193 Int_t AliDAQ::DetectorIDFromDdlID(Int_t ddlID)
 194 {
 195   // Returns the detector ID for
 196   // a given DDL ID
 197   Int_t detectorID = ddlID >> 8;
 198   if (detectorID < 0 || detectorID >= kNDetectors) {
 199     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 200     return -1;
 201   }
 202   Int_t ddlIndex = ddlID & 0xFF;
 203   if (ddlIndex >= fgkNumberOfDdls[detectorID]) {
 204     AliErrorClass(Form("Invalid DDL index %d (%d -> %d) for detector %d",
 205                        ddlIndex,0,fgkNumberOfDdls[detectorID],detectorID));
 206     return -1;
 207   }
 208   return detectorID;
 209 }
 210
 211 Int_t AliDAQ::DdlID(const char *detectorName, Int_t ddlIndex)
 212 {
 213   // Returns the DDL ID starting from
 214   // the detector name and the DDL
 215   // index inside the detector
 216   Int_t detectorID = DetectorID(detectorName);
 217   if (detectorID < 0)
 218     return -1;
 219
 220   return DdlID(detectorID,ddlIndex);
 221 }
 222
 223 Int_t AliDAQ::DdlID(Int_t detectorID, Int_t ddlIndex)
 224 {
 225   // Returns the DDL ID starting from
 226   // the detector ID and the DDL
 227   // index inside the detector
 228   Int_t ddlID = DdlIDOffset(detectorID);
 229   if (ddlID < 0)
 230     return -1;
 231
 232   if (ddlIndex >= fgkNumberOfDdls[detectorID]) {
 233     AliErrorClass(Form("Invalid DDL index %d (%d -> %d) for detector %d",
 234                        ddlIndex,0,fgkNumberOfDdls[detectorID],detectorID));
 235     return -1;
 236   }
 237
 238   ddlID += ddlIndex;
 239   return ddlID;
 240 }
 241
 242 Int_t AliDAQ::NumberOfDdls(const char *detectorName)
 243 {
 244   // Returns the number of DDLs for
 245   // a given detector
 246   Int_t detectorID = DetectorID(detectorName);
 247   if (detectorID < 0)
 248     return -1;
 249
 250   return NumberOfDdls(detectorID);
 251 }
 252
 253 Int_t AliDAQ::NumberOfDdls(Int_t detectorID)
 254 {
 255   // Returns the number of DDLs for
 256   // a given detector
 257   if (detectorID < 0 || detectorID >= kNDetectors) {
 258     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 259     return -1;
 260   }
 261
 262   return fgkNumberOfDdls[detectorID];
 263 }
 264
 265 Float_t AliDAQ::NumberOfLdcs(const char *detectorName)
 266 {
 267   // Returns the number of DDLs for
 268   // a given detector
 269   Int_t detectorID = DetectorID(detectorName);
 270   if (detectorID < 0)
 271     return -1;
 272
 273   return NumberOfLdcs(detectorID);
 274 }
 275
 276 Float_t AliDAQ::NumberOfLdcs(Int_t detectorID)
 277 {
 278   // Returns the number of DDLs for
 279   // a given detector
 280   if (detectorID < 0 || detectorID >= kNDetectors) {
 281     AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
 282     return -1;
 283   }
 284
 285   return fgkNumberOfLdcs[detectorID];
 286 }
 287
 288 void AliDAQ::PrintConfig()
 289 {
 290   // Print the DAQ configuration
 291   // for all the detectors
 292   printf("====================================================================\n"
 293          "|                ALICE Data Acquisition Configuration              |\n"
 294          "====================================================================\n"
 295          "| Detector ID | Detector Name | DDL Offset | # of DDLs | # of LDCs |\n"
 296          "====================================================================\n");
 297   for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
 298     printf("|%11d  |%13s  |%10d  |%9d  |%9.1f  |\n",
 299            iDet,DetectorName(iDet),DdlIDOffset(iDet),NumberOfDdls(iDet),NumberOfLdcs(iDet));
 300   }
 301   printf("====================================================================\n");
 302
 303 }