Line data Source code
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 176 : 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",
62 : "ZDC",
63 : "ACORDE",
64 : "TRG",
65 : "EMCAL",
66 : "DAQ_TEST",
67 : "EMPTY",
68 : "AD",
69 : "MFT",
70 : "FIT",
71 : "HLT"
72 : };
73 :
74 : Int_t AliDAQ::fgkNumberOfDdls[AliDAQ::kNDetectors] = {
75 : 20, // ITSSPD
76 : 24, // ITSSDD
77 : 16, // ITSSSD
78 : 216, // TPC
79 : 18, // TRD
80 : 72, // TOF
81 : 14, // HMPID
82 : 21, // PHOS
83 : 10, // CPV
84 : 6, // PMD
85 : 20, // MUONTRK
86 : 2, // MUONTRG
87 : 3, // FMD
88 : 1, // T0
89 : 1, // VZERO
90 : 1, // ZDC
91 : 1, // ACORDE
92 : 2, // TRG
93 : 46, // EMCAL (including DCal)
94 : 12, // DAQ_TEST
95 : 0, // EMPTY
96 : 1, // AD
97 : 10, // MFT
98 : 1, // FIT
99 : 28 // HLT
100 : };
101 :
102 : Float_t AliDAQ::fgkNumberOfLdcs[AliDAQ::kNDetectors] = {
103 : 7, // ITSSPD
104 : 8, // ITSSDD
105 : 6, // ITSSSD
106 : 36, // TPC
107 : 9, // TRD
108 : 24, // TOF
109 : 5, // HMPID
110 : 8, // PHOS
111 : 1, // CPV
112 : 2, // PMD
113 : 7, // MUONTRK
114 : 1, // MUONTRG
115 : 1, // FMD
116 : 1, // T0
117 : 1, // VZERO
118 : 1, // ZDC
119 : 1, // ACORDE
120 : 1, // TRG
121 : 15, // EMCAL
122 : 2, // DAQ_TEST
123 : 0, // EMPTY
124 : 1, // AD
125 : 1, // MFT
126 : 1, // FIT
127 : 14 // HLT
128 : };
129 :
130 : const char* AliDAQ::fgkOfflineModuleName[AliDAQ::kNDetectors] = {
131 : "ITS",
132 : "ITS",
133 : "ITS",
134 : "TPC",
135 : "TRD",
136 : "TOF",
137 : "HMPID",
138 : "PHOS",
139 : "CPV",
140 : "PMD",
141 : "MUON",
142 : "MUON",
143 : "FMD",
144 : "T0",
145 : "VZERO",
146 : "ZDC",
147 : "ACORDE",
148 : "CTP",
149 : "EMCAL",
150 : "DAQ_TEST",
151 : "EMPTY",
152 : "AD",
153 : "MFT",
154 : "FIT",
155 : "HLT"
156 : };
157 :
158 : const char* AliDAQ::fgkOnlineName[AliDAQ::kNDetectors] = {
159 : "SPD",
160 : "SDD",
161 : "SSD",
162 : "TPC",
163 : "TRD",
164 : "TOF",
165 : "HMP",
166 : "PHS",
167 : "CPV",
168 : "PMD",
169 : "MCH",
170 : "MTR",
171 : "FMD",
172 : "T00",
173 : "V00",
174 : "ZDC",
175 : "ACO",
176 : "TRI",
177 : "EMC",
178 : "TST",
179 : "EMP",
180 : "AD0",
181 : "MFT",
182 : "FIT",
183 : "HLT"
184 : };
185 :
186 : Int_t AliDAQ::fgkRunPeriod = 1;
187 : Int_t AliDAQ::fgkFirstSTUDDL = 44;
188 : Int_t AliDAQ::fgkLastSTUDDL = 45;
189 :
190 : AliDAQ::AliDAQ(const AliDAQ& source) :
191 0 : TObject(source)
192 0 : {
193 : // Copy constructor
194 : // Nothing to be done
195 0 : }
196 :
197 : AliDAQ& AliDAQ::operator = (const AliDAQ& /* source */)
198 : {
199 : // Assignment operator
200 : // Nothing to be done
201 0 : return *this;
202 : }
203 :
204 : Int_t AliDAQ::DetectorID(const char *detectorName)
205 : {
206 : // Return the detector index
207 : // corresponding to a given
208 : // detector name
209 9432 : TString detStr = detectorName;
210 :
211 : Int_t iDet;
212 9432 : if (detStr.CompareTo(fgkDetectorName[kNDetectors-1],TString::kIgnoreCase)==0) { //HLT
213 14 : return kHLTId;
214 : }
215 56312 : for(iDet = 0; iDet < kNDetectors; iDet++) {
216 56312 : if (detStr.CompareTo(fgkDetectorName[iDet],TString::kIgnoreCase) == 0)
217 : break;
218 : }
219 4702 : if (iDet == kNDetectors) {
220 0 : AliErrorClass(Form("Invalid detector name: %s !",detectorName));
221 0 : return -1;
222 : }
223 4702 : return iDet;
224 4716 : }
225 :
226 : const char *AliDAQ::DetectorName(Int_t detectorID)
227 : {
228 : // Returns the name of particular
229 : // detector identified by its index
230 11522 : if (detectorID==kHLTId) return fgkDetectorName[kNDetectors-1];
231 5761 : if (detectorID < 0 || detectorID > kNDetectors-1) { //Accept also kNDetectors - 1 as HLT id
232 0 : AliErrorClass(Form("Invalid detector index: %d (%d -> %d, %d) !",detectorID,0,kNDetectors-2,kHLTId));
233 0 : return "";
234 : }
235 5761 : return fgkDetectorName[detectorID];
236 5761 : }
237 :
238 : Int_t AliDAQ::DdlIDOffset(const char *detectorName)
239 : {
240 : // Returns the DDL ID offset
241 : // for a given detector
242 34 : Int_t detectorID = DetectorID(detectorName);
243 17 : if (detectorID < 0)
244 0 : return -1;
245 :
246 17 : return DdlIDOffset(detectorID);
247 17 : }
248 :
249 : Int_t AliDAQ::DdlIDOffset(Int_t detectorID)
250 : {
251 : // Returns the DDL ID offset
252 : // for a given detector identified
253 : // by its index
254 24114 : if (detectorID < 0 || (detectorID > kNDetectors-1 && detectorID!=kHLTId)) {//Accept also kNDetectors - 1 as HLT id
255 0 : AliErrorClass(Form("Invalid detector index: %d (%d -> %d, %d) !",detectorID,0,kNDetectors-2,kHLTId));
256 0 : return -1;
257 : }
258 : // HLT has a DDL offset = 30, we accept detectorID == kNDetectors - 1 as HLT detector-id as well.
259 8262 : if (detectorID==kNDetectors-1) return (kHLTId << 8);
260 :
261 7814 : return (detectorID << 8);
262 8038 : }
263 :
264 : const char *AliDAQ::DetectorNameFromDdlID(Int_t ddlID,Int_t &ddlIndex)
265 : {
266 : // Returns the detector name for
267 : // a given DDL ID
268 10 : ddlIndex = -1;
269 5 : Int_t detectorID = DetectorIDFromDdlID(ddlID,ddlIndex);
270 5 : if (detectorID < 0)
271 0 : return "";
272 :
273 5 : return DetectorName(detectorID);
274 5 : }
275 :
276 : Int_t AliDAQ::DetectorIDFromDdlID(Int_t ddlID,Int_t &ddlIndex)
277 : {
278 : // Returns the detector ID and
279 : // the ddl index within the
280 : // detector range for
281 : // a given input DDL ID
282 159596 : Int_t detectorID = ddlID >> 8;
283 :
284 159596 : if (detectorID < 0 || (detectorID >= kNDetectors-1 && detectorID!=kHLTId)) {//detectorID comes from ddlID, so it cannot be kNDetectors - 1!
285 0 : AliErrorClass(Form("Invalid detector index: %d (%d -> %d) !",detectorID,0,kNDetectors-1));
286 0 : return -1;
287 : }
288 79798 : ddlIndex = ddlID & 0xFF;
289 79798 : if (ddlIndex >= NumberOfDdls(detectorID)) {
290 0 : AliErrorClass(Form("Invalid DDL index %d (%d -> %d) for detector %d",
291 : ddlIndex,0,NumberOfDdls(detectorID),detectorID));
292 0 : ddlIndex = -1;
293 0 : return -1;
294 : }
295 79798 : return detectorID;
296 79798 : }
297 :
298 : Int_t AliDAQ::DdlID(const char *detectorName, Int_t ddlIndex)
299 : {
300 : // Returns the DDL ID starting from
301 : // the detector name and the DDL
302 : // index inside the detector
303 0 : Int_t detectorID = DetectorID(detectorName);
304 0 : if (detectorID < 0)
305 0 : return -1;
306 :
307 0 : return DdlID(detectorID,ddlIndex);
308 0 : }
309 :
310 : Int_t AliDAQ::DdlID(Int_t detectorID, Int_t ddlIndex)
311 : {
312 : // Returns the DDL ID starting from
313 : // the detector ID and the DDL
314 : // index inside the detector
315 8432 : Int_t ddlID = DdlIDOffset(detectorID);
316 4216 : if (ddlID < 0)
317 0 : return -1;
318 :
319 4216 : if (ddlIndex >= NumberOfDdls(detectorID)) {
320 0 : AliErrorClass(Form("Invalid DDL index %d (%d -> %d) for detector %d",
321 : ddlIndex,0,NumberOfDdls(detectorID),detectorID));
322 0 : return -1;
323 : }
324 :
325 4216 : ddlID += ddlIndex;
326 4216 : return ddlID;
327 4216 : }
328 :
329 : const char *AliDAQ::DdlFileName(const char *detectorName, Int_t ddlIndex)
330 : {
331 : // Returns the DDL file name
332 : // (used in the simulation) starting from
333 : // the detector name and the DDL
334 : // index inside the detector
335 3098 : Int_t detectorID = DetectorID(detectorName);
336 1549 : if (detectorID < 0)
337 0 : return "";
338 :
339 1549 : return DdlFileName(detectorID,ddlIndex);
340 1549 : }
341 :
342 : const char *AliDAQ::DdlFileName(Int_t detectorID, Int_t ddlIndex)
343 : {
344 : // Returns the DDL file name
345 : // (used in the simulation) starting from
346 : // the detector ID and the DDL
347 : // index inside the detector
348 7466 : Int_t ddlID = DdlIDOffset(detectorID);
349 3733 : if (ddlID < 0)
350 0 : return "";
351 :
352 3733 : if (ddlIndex >= NumberOfDdls(detectorID)) {
353 0 : AliErrorClass(Form("Invalid DDL index %d (%d -> %d) for detector %d",
354 : ddlIndex,0,NumberOfDdls(detectorID),detectorID));
355 0 : return "";
356 : }
357 :
358 3733 : ddlID += ddlIndex;
359 3736 : static TString fileName;
360 :
361 3733 : fileName = DetectorName(detectorID);
362 3733 : fileName += "_";
363 3733 : fileName += ddlID;
364 3733 : fileName += ".ddl";
365 3733 : return fileName.Data();
366 3733 : }
367 :
368 : Int_t AliDAQ::NumberOfDdls(const char *detectorName)
369 : {
370 : // Returns the number of DDLs for
371 : // a given detector
372 3202 : Int_t detectorID = DetectorID(detectorName);
373 1601 : if (detectorID < 0)
374 0 : return -1;
375 :
376 1601 : return NumberOfDdls(detectorID);
377 1601 : }
378 :
379 : Int_t AliDAQ::NumberOfDdls(Int_t detectorID)
380 : {
381 : // Returns the number of DDLs for
382 : // a given detector
383 286614 : if (detectorID < 0 || (detectorID > kNDetectors-1 && detectorID!=kHLTId)) {//Accept also kNDetectors - 1 as HLT id
384 0 : AliErrorClass(Form("Invalid detector index: %d (%d -> %d, %d) !",detectorID,0,kNDetectors-2,kHLTId));
385 0 : return -1;
386 : }
387 :
388 : int detectorIDindex = detectorID;
389 95538 : if (detectorID==kHLTId) detectorIDindex=kNDetectors-1;
390 :
391 95538 : return fgkNumberOfDdls[detectorIDindex];
392 95538 : }
393 :
394 : Float_t AliDAQ::NumberOfLdcs(const char *detectorName)
395 : {
396 : // Returns the number of DDLs for
397 : // a given detector
398 0 : Int_t detectorID = DetectorID(detectorName);
399 0 : if (detectorID < 0)
400 0 : return -1;
401 :
402 0 : return NumberOfLdcs(detectorID);
403 0 : }
404 :
405 : Float_t AliDAQ::NumberOfLdcs(Int_t detectorID)
406 : {
407 : // Returns the number of DDLs for
408 : // a given detector
409 6552 : if (detectorID < 0 || (detectorID > kNDetectors-1 && detectorID!=kHLTId)) {//Accept also kNDetectors - 1 as HLT id
410 0 : AliErrorClass(Form("Invalid detector index: %d (%d -> %d, %d) !",detectorID,0,kNDetectors-2,kHLTId));
411 0 : return -1;
412 : }
413 :
414 : int detectorIDindex = detectorID;
415 2184 : if (detectorID==kHLTId) detectorIDindex=kNDetectors-1;
416 :
417 2184 : return fgkNumberOfLdcs[detectorIDindex];
418 2184 : }
419 :
420 : void AliDAQ::PrintConfig()
421 : {
422 : // Print the DAQ configuration
423 : // for all the detectors
424 0 : printf("===================================================================================================\n"
425 : "| ALICE Data Acquisition Configuration |\n"
426 : "===================================================================================================\n"
427 : "| Detector ID | Detector Name | DDL Offset | # of DDLs | # of LDCs | Online Name | AliRoot Module |\n"
428 : "===================================================================================================\n");
429 0 : for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
430 0 : printf("|%11d |%13s |%10d |%9d |%9.1f |%11s |%14s |\n",
431 0 : iDet,DetectorName(iDet),DdlIDOffset(iDet),NumberOfDdls(iDet),NumberOfLdcs(iDet),
432 0 : OnlineName(iDet),OfflineModuleName(iDet));
433 : }
434 0 : printf("===================================================================================================\n");
435 :
436 0 : }
437 :
438 : const char *AliDAQ::ListOfTriggeredDetectors(UInt_t detectorPattern)
439 : {
440 : // Returns a string with the list of
441 : // active detectors. The input is the
442 : // trigger pattern word contained in
443 : // the raw-data event header.
444 :
445 61 : static TString detList;
446 26 : detList = "";
447 1300 : for(Int_t iDet = 0; iDet < (kNDetectors-1); iDet++) {
448 624 : if ((detectorPattern >> iDet) & 0x1) {
449 477 : detList += fgkDetectorName[iDet];
450 477 : detList += " ";
451 477 : }
452 : }
453 :
454 : // Always remember HLT
455 43 : if ((detectorPattern >> kHLTId) & 0x1) detList += fgkDetectorName[kNDetectors-1];
456 :
457 26 : return detList.Data();
458 0 : }
459 :
460 : UInt_t AliDAQ::DetectorPattern(const char *detectorList)
461 : {
462 : // Returns a 32-bit word containing the
463 : // the detector pattern corresponding to a given
464 : // list of detectors
465 : UInt_t pattern = 0;
466 218 : TString detList = detectorList;
467 5450 : for(Int_t iDet = 0; iDet < (kNDetectors-1); iDet++) {
468 2616 : TString det = fgkDetectorName[iDet];
469 18082 : if((detList.CompareTo(det) == 0) ||
470 5232 : detList.BeginsWith(det) ||
471 7848 : detList.EndsWith(det) ||
472 9340 : detList.Contains( " "+det+" " )) pattern |= (1 << iDet) ;
473 2616 : }
474 :
475 : // HLT
476 109 : TString hltDet = fgkDetectorName[kNDetectors-1];
477 763 : if((detList.CompareTo(hltDet) == 0) ||
478 218 : detList.BeginsWith(hltDet) ||
479 327 : detList.EndsWith(hltDet) ||
480 327 : detList.Contains( " "+hltDet+" " )) pattern |= (1 << kHLTId) ;
481 :
482 : return pattern;
483 109 : }
484 :
485 : UInt_t AliDAQ::DetectorPatternOffline(const char *detectorList)
486 : {
487 : // Returns a 32-bit word containing the
488 : // the detector pattern corresponding to a given
489 : // list of detectors.
490 : // The list of detectors must follow offline module
491 : // name convention.
492 : UInt_t pattern = 0;
493 32 : TString detList = detectorList;
494 800 : for(Int_t iDet = 0; iDet < (kNDetectors-1); iDet++) {
495 384 : TString det = fgkOfflineModuleName[iDet];
496 2592 : if((detList.CompareTo(det) == 0) ||
497 768 : detList.BeginsWith(det) ||
498 1008 : detList.EndsWith(det) ||
499 1296 : detList.Contains( " "+det+" " )) pattern |= (1 << iDet) ;
500 384 : }
501 :
502 : // HLT
503 16 : TString hltDet = fgkOfflineModuleName[kNDetectors-1];
504 80 : if((detList.CompareTo(hltDet) == 0) ||
505 32 : detList.BeginsWith(hltDet) ||
506 48 : detList.EndsWith(hltDet) ||
507 16 : detList.Contains( " "+hltDet+" " )) pattern |= (1 << kHLTId) ;
508 :
509 : return pattern;
510 16 : }
511 :
512 : const char *AliDAQ::OfflineModuleName(const char *detectorName)
513 : {
514 : // Returns the name of the offline module
515 : // for a given detector (online naming convention)
516 0 : Int_t detectorID = DetectorID(detectorName);
517 0 : if (detectorID < 0)
518 0 : return "";
519 :
520 0 : return OfflineModuleName(detectorID);
521 0 : }
522 :
523 : const char *AliDAQ::OfflineModuleName(Int_t detectorID)
524 : {
525 : // Returns the name of the offline module
526 : // for a given detector (online naming convention)
527 3048 : if (detectorID < 0 || (detectorID > kNDetectors-1 && detectorID!=kHLTId)) { //Accept also kNDetectors - 1 as HLT id
528 0 : AliErrorClass(Form("Invalid detector index: %d (%d -> %d, %d) !",detectorID,0,kNDetectors-2,kHLTId));
529 0 : return "";
530 : }
531 :
532 : int detectorIDindex=detectorID;
533 1016 : if (detectorID==kHLTId) detectorIDindex = kNDetectors-1;
534 :
535 1016 : return fgkOfflineModuleName[detectorIDindex];
536 1016 : }
537 :
538 : const char *AliDAQ::OnlineName(const char *detectorName)
539 : {
540 : // Returns the name of the online detector name (3 characters)
541 : // for a given detector
542 0 : Int_t detectorID = DetectorID(detectorName);
543 0 : if (detectorID < 0)
544 0 : return "";
545 :
546 0 : return OnlineName(detectorID);
547 0 : }
548 :
549 : const char *AliDAQ::OnlineName(Int_t detectorID)
550 : {
551 : // Returns the name of the online detector name (3 characters)
552 : // for a given detector
553 84 : if (detectorID < 0 || (detectorID > kNDetectors-1 && detectorID!=kHLTId)) { //Accept also kNDetectors - 1 as HLT id
554 0 : AliErrorClass(Form("Invalid detector index: %d (%d -> %d, %d) !",detectorID,0,kNDetectors-2,kHLTId));
555 0 : return "";
556 : }
557 :
558 : int detectorIDindex=detectorID;
559 28 : if (detectorID==kHLTId) detectorIDindex = kNDetectors-1;
560 :
561 28 : return fgkOnlineName[detectorIDindex];
562 28 : }
563 :
564 : void AliDAQ::SetRun1(){
565 : // Set RunPeriod
566 0 : fgkRunPeriod = 1;
567 : // STU
568 0 : fgkFirstSTUDDL=44;
569 0 : fgkLastSTUDDL=44;
570 :
571 : // Change the default values to the ones used in Run1
572 : // DDL
573 0 : fgkNumberOfDdls[6] = 20; // HMPID in Run1
574 0 : fgkNumberOfDdls[17] = 1; // TRG
575 0 : fgkNumberOfDdls[18] = 46; // EMCAL
576 0 : fgkNumberOfDdls[19] = 1; // DAQ_TEST
577 :
578 : // LDC
579 0 : fgkNumberOfLdcs[0] = 4; // ITSSPD
580 0 : fgkNumberOfLdcs[1] = 4; // ITSSDD
581 0 : fgkNumberOfLdcs[2] = 4; // ITSSSD
582 0 : fgkNumberOfLdcs[4] = 3; // TRD
583 0 : fgkNumberOfLdcs[5] = 12; // TOF
584 0 : fgkNumberOfLdcs[6] = 4; // HMPID
585 0 : fgkNumberOfLdcs[7] = 4; // PHOS
586 0 : fgkNumberOfLdcs[8] = 2; // CPV
587 0 : fgkNumberOfLdcs[9] = 1; // PMD
588 0 : fgkNumberOfLdcs[10] = 5; // MUONTRK
589 0 : fgkNumberOfLdcs[13] = 0.5; // T0
590 0 : fgkNumberOfLdcs[14] = 0.5; // VZERO
591 0 : fgkNumberOfLdcs[18] = 8; // EMCAL
592 0 : fgkNumberOfLdcs[19] = 1; // DAQ_TEST
593 0 : fgkNumberOfLdcs[24] = 7; // HLT
594 0 : }
595 :
596 : void AliDAQ::SetRun2(){
597 : // Set RunPeriod
598 0 : fgkRunPeriod = 2;
599 : // STU
600 0 : fgkFirstSTUDDL=44;
601 0 : fgkLastSTUDDL=45;
602 :
603 : // Change the default values to the ones used in Run2
604 : // DDL
605 0 : fgkNumberOfDdls[6] = 14; // HMPID in Run2
606 0 : fgkNumberOfDdls[17] = 2; // TRG
607 0 : fgkNumberOfDdls[18] = 46; // EMCAL
608 0 : fgkNumberOfDdls[19] = 12; // DAQ_TEST
609 :
610 : // LDC
611 0 : fgkNumberOfLdcs[0] = 7; // ITSSPD
612 0 : fgkNumberOfLdcs[1] = 8; // ITSSDD
613 0 : fgkNumberOfLdcs[2] = 6; // ITSSSD
614 0 : fgkNumberOfLdcs[4] = 9; // TRD
615 0 : fgkNumberOfLdcs[5] = 24; // TOF
616 0 : fgkNumberOfLdcs[6] = 5; // HMPID
617 0 : fgkNumberOfLdcs[7] = 8; // PHOS
618 0 : fgkNumberOfLdcs[8] = 1; // CPV
619 0 : fgkNumberOfLdcs[9] = 2; // PMD
620 0 : fgkNumberOfLdcs[10] = 7; // MUONTRK
621 0 : fgkNumberOfLdcs[13] = 1; // T0
622 0 : fgkNumberOfLdcs[14] = 1; // VZERO
623 0 : fgkNumberOfLdcs[18] = 15; // EMCAL
624 0 : fgkNumberOfLdcs[19] = 2; // DAQ_TEST
625 0 : fgkNumberOfLdcs[24] = 14; // HLT
626 0 : }
|
