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