Bug fix (Tomasz)
[u/mrichter/AliRoot.git] / T0 / AliT0DataDCS.cxx
CommitLineData
9dcc11e4 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 *
8eb4ac75 10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
9dcc11e4 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$Log: AliT0DataDCS.cxx,v $
18 Revision 2008/01/30
19Fetching data points from DCS, calculating mean and storing data to Reference DB
20
21 Version 1.1 2006/10
22Preliminary test version (T.Malkiewicz)
23*/
24
dc7ca31d 25#include "AliT0DataDCS.h"
26
27#include "AliCDBMetaData.h"
28#include "AliDCSValue.h"
29#include "AliLog.h"
30
31#include <TTimeStamp.h>
32#include <TObjString.h>
33#include <TH2F.h>
34#include <TProfile.h>
35#include <TGraph.h>
36#include <TDatime.h>
37#include <TStyle.h>
38#include <TCanvas.h>
39
9dcc11e4 40// AliT0DataDCS class
41// declaring DCS aliases for T0
42// fetching T0 data points from DCS,
43// calculating mean values for the entire run
44// and storing the result to Reference DB
45
dc7ca31d 46ClassImp(AliT0DataDCS)
47
48//---------------------------------------------------------------
49AliT0DataDCS::AliT0DataDCS():
50 TObject(),
9dcc11e4 51 fRun(0),
dc7ca31d 52 fStartTime(0),
53 fEndTime(0),
8eb4ac75 54 fStartTimeDCSQuery(0),
55 fEndTimeDCSQuery(0),
56 fAtten(0.),
dc7ca31d 57 fIsProcessed(kFALSE)
58{
8eb4ac75 59 for(Int_t i=0;i<kScalers;i++)
60 {
61 fScalerMean[i]=0.;
62 fScalerSecMean[i]=0.;
63 }
64 for(Int_t i=0;i<kHV;i++)
65 {
66 fHViA[i]=0.;
67 fHVvA[i]=0.;
68 fHViC[i]=0.;
69 fHVvC[i]=0.;
70 }
71 for(Int_t i=0;i<kLV;i++)
72 {
73 fLViA[i]=0.;
74 fLVvA[i]=0.;
75 fLViC[i]=0.;
76 fLVvC[i]=0.;
77 }
78 for(Int_t i=0;i<kTRM;i++)
79 {
80 fTRM[i]=0.;
81 }
82 for(Int_t i=0;i<kDRM;i++)
83 {
84 fDRM[i]=0.;
85 }
dc7ca31d 86
8eb4ac75 87}
dc7ca31d 88//---------------------------------------------------------------
8eb4ac75 89AliT0DataDCS::AliT0DataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime, UInt_t startTimeDCSQuery, UInt_t endTimeDCSQuery):
dc7ca31d 90 TObject(),
91 fRun(nRun),
92 fStartTime(startTime),
93 fEndTime(endTime),
8eb4ac75 94 fStartTimeDCSQuery(startTimeDCSQuery),
95 fEndTimeDCSQuery(endTimeDCSQuery),
96 fAtten(0.),
dc7ca31d 97 fIsProcessed(kFALSE)
98{
8eb4ac75 99 for(Int_t i=0;i<kScalers;i++)
100 {
101 fScalerMean[i]=0.;
102 fScalerSecMean[i]=0.;
103 }
104 for(Int_t i=0;i<kHV;i++)
105 {
106 fHViA[i]=0.;
107 fHVvA[i]=0.;
108 fHViC[i]=0.;
109 fHVvC[i]=0.;
110 }
111 for(Int_t i=0;i<kLV;i++)
112 {
113 fLViA[i]=0.;
114 fLVvA[i]=0.;
115 fLViC[i]=0.;
116 fLVvC[i]=0.;
117 }
118 for(Int_t i=0;i<kTRM;i++)
119 {
120 fTRM[i]=0.;
121 }
122 for(Int_t i=0;i<kDRM;i++)
123 {
124 fDRM[i]=0.;
125 }
126
127 AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s \n\tStartTime DCS Query %s \n\tEndTime DCS Query %s", nRun,
dc7ca31d 128 TTimeStamp(startTime).AsString(),
8eb4ac75 129 TTimeStamp(endTime).AsString(),
130 TTimeStamp(startTimeDCSQuery).AsString(),
131 TTimeStamp(endTimeDCSQuery).AsString()));
dc7ca31d 132
dc7ca31d 133 Init();
134
135}
8eb4ac75 136//---------------------------------------------------------------
137
138AliT0DataDCS::AliT0DataDCS(const AliT0DataDCS & data):
139 TObject(),
140 fRun(0),
141 fStartTime(0),
142 fEndTime(0),
143 fStartTimeDCSQuery(0),
144 fEndTimeDCSQuery(0),
145 fAtten(0.),
146 fIsProcessed(kFALSE)
147{
148
149// copy constructor
dc7ca31d 150
8eb4ac75 151 fRun=data.fRun;
152 fStartTime=data.fStartTime;
153 fEndTime=data.fEndTime;
154 fStartTimeDCSQuery=data.fStartTimeDCSQuery;
155 fEndTimeDCSQuery=data.fEndTimeDCSQuery;
156 fIsProcessed=data.fIsProcessed;
157 fAtten=data.fAtten;
158
159 for(int i=0;i<kNAliases;i++)
160 {
161 fAliasNames[i]=data.fAliasNames[i];
162 }
163
164 for(Int_t i=0;i<kScalers;i++)
165 {
166 fScalerMean[i]=data.fScalerMean[i];
167 fScalerSecMean[i]=data.fScalerSecMean[i];
168 }
169 for(Int_t i=0;i<kHV;i++)
170 {
171 fHViA[i]=data.fHViA[i];
172 fHVvA[i]=data.fHVvA[i];
173 fHViC[i]=data.fHViC[i];
174 fHVvC[i]=data.fHVvC[i];
175 }
176 for(Int_t i=0;i<kLV;i++)
177 {
178 fLViA[i]=data.fLViA[i];
179 fLVvA[i]=data.fLVvA[i];
180 fLViC[i]=data.fLViC[i];
181 fLVvC[i]=data.fLVvC[i];
182 }
183 for(Int_t i=0;i<kTRM;i++)
184 {
185 fTRM[i]=data.fTRM[i];
186 }
187 for(Int_t i=0;i<kDRM;i++)
188 {
189 fDRM[i]=data.fDRM[i];
190 }
191}
dc7ca31d 192//---------------------------------------------------------------
dc7ca31d 193
8eb4ac75 194AliT0DataDCS& AliT0DataDCS:: operator=(const AliT0DataDCS & data) {
195
196// assignment operator
197
198 this->fRun=data.fRun;
199 this->fStartTime=data.fStartTime;
200 this->fEndTime=data.fEndTime;
201 this->fStartTimeDCSQuery=data.fStartTimeDCSQuery;
202 this->fEndTimeDCSQuery=data.fEndTimeDCSQuery;
203
204 for(int i=0;i<kNAliases;i++)
205 {
206 this->fAliasNames[i]=data.fAliasNames[i];
207 }
208
209 return *this;
210}
211
212//---------------------------------------------------------------
213AliT0DataDCS::~AliT0DataDCS()
214{
dc7ca31d 215}
216
217//---------------------------------------------------------------
91366e58 218Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
219{
8eb4ac75 220 Int_t t0_scaler[kScalers];
221 Int_t t0_scaler_sec[kScalers];
222 Int_t aliasEntr[kNAliases];
223 Float_t t0_a_hv_imon[kHV];
224 Float_t t0_a_hv_vmon[kHV];
225 Float_t t0_a_lv_imon[kLV];
226 Float_t t0_a_lv_vmon[kLV];
227 Float_t t0_c_hv_imon[kHV];
228 Float_t t0_c_hv_vmon[kHV];
229 Float_t t0_c_lv_imon[kLV];
230 Float_t t0_c_lv_vmon[kLV];
231 Float_t t0_a_cfd_thre[kCFD];
232 Float_t t0_a_cfd_walk[kCFD];
233 Float_t t0_c_cfd_thre[kCFD];
234 Float_t t0_c_cfd_walk[kCFD];
235 Float_t t0_ac_trm[kTRM];
236 Float_t t0_ac_drm[kDRM];
237 Float_t t0_atten=0.;
238
970bb0d0 239 TObjArray *aliasArr;
8eb4ac75 240 for(Int_t k=0; k<kScalers; k++)
241 {
242 t0_scaler[k]=0;
243 t0_scaler_sec[k]=0;
244 }
245
246 for(Int_t k=0; k<kHV; k++)
247 {
248 t0_a_hv_imon[k]=0.;
249 t0_a_hv_vmon[k]=0.;
250 t0_c_hv_imon[k]=0.;
251 t0_c_hv_vmon[k]=0.;
252 }
253 for(Int_t k=0; k<kHV; k++)
254 {
255 t0_a_lv_imon[k]=0.;
256 t0_a_lv_vmon[k]=0.;
257 t0_c_lv_imon[k]=0.;
258 t0_c_lv_vmon[k]=0.;
259 }
260 for(Int_t k=0; k<kCFD; k++)
261 {
262 t0_a_cfd_thre[k]=0.;
263 t0_a_cfd_walk[k]=0.;
264 t0_c_cfd_thre[k]=0.;
265 t0_c_cfd_walk[k]=0.;
266 }
267 for(Int_t k=0; k<kTRM; k++)
268 {
269 t0_ac_trm[k]=0.;
270 }
271 for(Int_t k=0; k<kDRM; k++)
272 {
273 t0_ac_drm[k]=0.;
274 }
275
276// here starts the main loop
277 for(Int_t j=0; j<kNAliases; j++)
970bb0d0 278 {
8eb4ac75 279 aliasEntr[j]=0;
9dcc11e4 280 for (Int_t k=0;k<32;k++)
281 {
282 t0_scaler[k]=0;
8eb4ac75 283 t0_scaler_sec[k]=0;
284
9dcc11e4 285 }
286 aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
970bb0d0 287 if(!aliasArr)
288 {
289 AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
91366e58 290 continue;
970bb0d0 291 }
8eb4ac75 292 Introduce(j, aliasArr);
970bb0d0 293 if(aliasArr->GetEntries()<2)
294 {
295 AliError(Form("Alias %s has just %d entries!",
296 fAliasNames[j].Data(),aliasArr->GetEntries()));
297 continue;
298 }
8eb4ac75 299 if (j < kScalers)
300 {
301 aliasEntr[j] = aliasArr->GetEntries();
302 for(Int_t l=0; l<aliasEntr[j]; l++)
303 {
304 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
305 t0_scaler[j]+= aValue->GetUInt();
306 }
307 fScalerMean[j] = t0_scaler[j] / aliasEntr[j];
308 }
309 else if (j < 2*kScalers)
970bb0d0 310 {
8eb4ac75 311 aliasEntr[j] = aliasArr->GetEntries();
312 for(Int_t l=0; l<aliasEntr[j]; l++)
313 {
314 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 315 t0_scaler_sec[j-kScalers]+= aValue->GetUInt();
8eb4ac75 316 }
19fb06bd 317 fScalerSecMean[j-kScalers] = t0_scaler_sec[j-kScalers] / aliasEntr[j];
8eb4ac75 318 }
319 else if (j < 2*kScalers+kHV)
320 {
321 aliasEntr[j] = aliasArr->GetEntries();
322 for(Int_t l=0; l<aliasEntr[j]; l++)
323 {
324 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 325 t0_a_hv_imon[j-2*kScalers]+= aValue->GetFloat();
8eb4ac75 326 }
19fb06bd 327 fHViA[j-2*kScalers] = t0_a_hv_imon[j-2*kScalers] / aliasEntr[j];
8eb4ac75 328 }
329 else if (j < 2*kScalers+2*kHV)
330 {
331 aliasEntr[j] = aliasArr->GetEntries();
332 for(Int_t l=0; l<aliasEntr[j]; l++)
333 {
334 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 335 t0_a_hv_vmon[j-(2*kScalers+kHV)]+= aValue->GetFloat();
8eb4ac75 336 }
19fb06bd 337 fHVvA[j-(2*kScalers+kHV)] = t0_a_hv_vmon[j-(2*kScalers+kHV)] / aliasEntr[j];
8eb4ac75 338 }
339 else if (j < 2*kScalers+2*kHV+kLV)
340 {
341 aliasEntr[j] = aliasArr->GetEntries();
342 for(Int_t l=0; l<aliasEntr[j]; l++)
343 {
344 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 345 t0_a_lv_imon[j-(2*kScalers+2*kHV)]+= aValue->GetFloat();
8eb4ac75 346 }
19fb06bd 347 fLViA[j-(2*kScalers+2*kHV)] = t0_a_lv_imon[j-(2*kScalers+2*kHV)] / aliasEntr[j];
8eb4ac75 348 }
349 else if (j < 2*kScalers+2*kHV+2*kLV)
350 {
351 aliasEntr[j] = aliasArr->GetEntries();
352 for(Int_t l=0; l<aliasEntr[j]; l++)
353 {
354 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 355 t0_a_lv_vmon[j-(2*kScalers+2*kHV+kLV)]+= aValue->GetFloat();
8eb4ac75 356 }
19fb06bd 357 fLVvA[j-(2*kScalers+2*kHV+kLV)] = t0_a_lv_vmon[j-(2*kScalers+2*kHV+kLV)] / aliasEntr[j];
8eb4ac75 358 }
359 else if (j < 2*kScalers+3*kHV+2*kLV)
360 {
361 aliasEntr[j] = aliasArr->GetEntries();
362 for(Int_t l=0; l<aliasEntr[j]; l++)
363 {
364 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 365 t0_c_hv_imon[j-(2*kScalers+2*kHV+2*kLV)]+= aValue->GetFloat();
8eb4ac75 366 }
19fb06bd 367 fHViC[j-(2*kScalers+2*kHV+2*kLV)] = t0_c_hv_imon[j-(2*kScalers+2*kHV+2*kLV)] / aliasEntr[j];
8eb4ac75 368 }
369 else if (j < 2*kScalers+4*kHV+2*kLV)
370 {
371 aliasEntr[j] = aliasArr->GetEntries();
372 for(Int_t l=0; l<aliasEntr[j]; l++)
373 {
374 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 375 t0_c_hv_vmon[j-(2*kScalers+3*kHV+2*kLV)]+= aValue->GetFloat();
8eb4ac75 376 }
19fb06bd 377 fHVvC[j-(2*kScalers+3*kHV+2*kLV)] = t0_c_hv_vmon[j-(2*kScalers+3*kHV+2*kLV)] / aliasEntr[j];
8eb4ac75 378 }
379 else if (j < 2*kScalers+4*kHV+3*kLV)
380 {
381 aliasEntr[j] = aliasArr->GetEntries();
382 for(Int_t l=0; l<aliasEntr[j]; l++)
383 {
384 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 385 t0_c_lv_imon[j-(2*kScalers+4*kHV+2*kLV)]+= aValue->GetFloat();
8eb4ac75 386 }
19fb06bd 387 fLViC[j-(2*kScalers+4*kHV+2*kLV)] = t0_c_lv_imon[j-(2*kScalers+4*kHV+2*kLV)] / aliasEntr[j];
8eb4ac75 388 }
389 else if (j < 2*kScalers+4*kHV+4*kLV)
390 {
391 aliasEntr[j] = aliasArr->GetEntries();
392 for(Int_t l=0; l<aliasEntr[j]; l++)
393 {
394 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 395 t0_c_lv_vmon[j-(2*kScalers+4*kHV+3*kLV)]+= aValue->GetFloat();
8eb4ac75 396 }
19fb06bd 397 fLVvC[j-(2*kScalers+4*kHV+3*kLV)] = t0_c_lv_vmon[j-(2*kScalers+4*kHV+3*kLV)] / aliasEntr[j];
8eb4ac75 398 }
399 else if (j < 2*kScalers+4*kHV+4*kLV+kCFD)
400 {
401 aliasEntr[j] = aliasArr->GetEntries();
402 for(Int_t l=0; l<aliasEntr[j]; l++)
403 {
404 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 405 t0_a_cfd_thre[j-(2*kScalers+4*kHV+4*kLV)]+= aValue->GetFloat();
8eb4ac75 406 }
19fb06bd 407 fCFDtA[j-(2*kScalers+4*kHV+4*kLV)] = t0_a_cfd_thre[j-(2*kScalers+4*kHV+4*kLV)] / aliasEntr[j];
8eb4ac75 408 }
409 else if (j < 2*kScalers+4*kHV+4*kLV+2*kCFD)
410 {
411 aliasEntr[j] = aliasArr->GetEntries();
412 for(Int_t l=0; l<aliasEntr[j]; l++)
413 {
414 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 415 t0_a_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+kCFD)]+= aValue->GetFloat();
8eb4ac75 416 }
19fb06bd 417 fCFDwA[j-(2*kScalers+4*kHV+4*kLV+kCFD)] = t0_a_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+kCFD)] / aliasEntr[j];
8eb4ac75 418 }
419 else if (j < 2*kScalers+4*kHV+4*kLV+3*kCFD)
420 {
421 aliasEntr[j] = aliasArr->GetEntries();
422 for(Int_t l=0; l<aliasEntr[j]; l++)
423 {
424 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 425 t0_c_cfd_thre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)]+= aValue->GetFloat();
8eb4ac75 426 }
19fb06bd 427 fCFDtC[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)] = t0_c_cfd_thre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)] / aliasEntr[j];
8eb4ac75 428 }
429 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD)
430 {
431 aliasEntr[j] = aliasArr->GetEntries();
432 for(Int_t l=0; l<aliasEntr[j]; l++)
433 {
434 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 435 t0_c_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)]+= aValue->GetFloat();
8eb4ac75 436 }
19fb06bd 437 fCFDwC[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)] = t0_c_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)] / aliasEntr[j];
8eb4ac75 438 }
439 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
440 {
441 aliasEntr[j] = aliasArr->GetEntries();
442 for(Int_t l=0; l<aliasEntr[j]; l++)
443 {
444 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 445 t0_ac_trm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)]+= aValue->GetFloat();
8eb4ac75 446 }
19fb06bd 447 fTRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] = t0_ac_trm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] / aliasEntr[j];
8eb4ac75 448 }
449 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
450 {
451 aliasEntr[j] = aliasArr->GetEntries();
452 for(Int_t l=0; l<aliasEntr[j]; l++)
453 {
454 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
19fb06bd 455 t0_ac_drm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)]+= aValue->GetFloat();
8eb4ac75 456 }
19fb06bd 457 fDRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)] = t0_ac_drm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)] / aliasEntr[j];
8eb4ac75 458 }
459 else
460 {
461 aliasEntr[j] = aliasArr->GetEntries();
462 for(Int_t l=0; l<aliasEntr[j]; l++)
463 {
464 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
465 t0_atten += aValue->GetInt();
466 }
19fb06bd 467 fAtten = t0_atten / aliasEntr[j];
8eb4ac75 468 }
19fb06bd 469 }
dc7ca31d 470 fIsProcessed=kTRUE;
9dcc11e4 471 return kTRUE;
dc7ca31d 472}
473
474//---------------------------------------------------------------
91366e58 475void AliT0DataDCS::Init()
476{
9dcc11e4 477 TString sindex;
91366e58 478 for(int i=0;i<kNAliases;i++)
8eb4ac75 479 {
480 if (i<kScalers)
481 {
482 fAliasNames[i] = "t00_ac_scaler_";
483 sindex.Form("%02d",i);
484 fAliasNames[i] += sindex;
485 }
486 else if (i < 2*kScalers)
487 {
488 fAliasNames[i] = "t00_ac_scaler_sec_";
19fb06bd 489 sindex.Form("%02d",i-kScalers);
8eb4ac75 490 fAliasNames[i] += sindex;
491 }
492 else if (i < 2*kScalers+kHV)
493 {
494 fAliasNames[i] = "t00_a_hv_imon_";
19fb06bd 495 sindex.Form("%02d",i-2*kScalers);
8eb4ac75 496 fAliasNames[i] += sindex;
497 }
498 else if (i < 2*kScalers+2*kHV)
499 {
500 fAliasNames[i] = "t00_a_hv_vmon_";
19fb06bd 501 sindex.Form("%02d",i-(2*kScalers+kHV));
8eb4ac75 502 fAliasNames[i] += sindex;
503 }
504 else if (i < 2*kScalers+2*kHV+kLV)
505 {
506 fAliasNames[i] = "t00_a_lv_imon_";
19fb06bd 507 sindex.Form("%02d",i-(2*kScalers+2*kHV));
8eb4ac75 508 fAliasNames[i] += sindex;
509 }
510 else if (i < 2*kScalers+2*kHV+2*kLV)
511 {
512 fAliasNames[i] = "t00_a_lv_vmon_";
19fb06bd 513 sindex.Form("%02d",i-(2*kScalers+2*kHV+kLV));
8eb4ac75 514 fAliasNames[i] += sindex;
515 }
516 else if (i < 2*kScalers+3*kHV+2*kLV)
517 {
518 fAliasNames[i] = "t00_c_hv_imon_";
19fb06bd 519 sindex.Form("%02d",i-(2*kScalers+2*kHV+2*kLV));
8eb4ac75 520 fAliasNames[i] += sindex;
521 }
522 else if (i < 2*kScalers+4*kHV+2*kLV)
523 {
524 fAliasNames[i] = "t00_c_hv_vmon_";
19fb06bd 525 sindex.Form("%02d",i-(2*kScalers+3*kHV+2*kLV));
8eb4ac75 526 fAliasNames[i] += sindex;
527 }
528 else if (i < 2*kScalers+4*kHV+3*kLV)
529 {
530 fAliasNames[i] = "t00_c_lv_imon_";
19fb06bd 531 sindex.Form("%02d",i-(2*kScalers+4*kHV+2*kLV));
8eb4ac75 532 fAliasNames[i] += sindex;
533 }
534 else if (i < 2*kScalers+4*kHV+4*kLV)
535 {
536 fAliasNames[i] = "t00_c_lv_vmon_";
19fb06bd 537 sindex.Form("%02d",i-(2*kScalers+4*kHV+3*kLV));
8eb4ac75 538 fAliasNames[i] += sindex;
539 }
540 else if (i < 2*kScalers+4*kHV+4*kLV+kCFD)
541 {
542 fAliasNames[i] = "t00_a_cfd_thre_";
19fb06bd 543 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV));
8eb4ac75 544 fAliasNames[i] += sindex;
545 }
546 else if (i < 2*kScalers+4*kHV+4*kLV+2*kCFD)
547 {
548 fAliasNames[i] = "t00_a_cfd_walk_";
19fb06bd 549 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+kCFD));
8eb4ac75 550 fAliasNames[i] += sindex;
551 }
552 else if (i < 2*kScalers+4*kHV+4*kLV+3*kCFD)
553 {
554 fAliasNames[i] = "t00_c_cfd_thre_";
19fb06bd 555 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+2*kCFD));
8eb4ac75 556 fAliasNames[i] += sindex;
557 }
558 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD)
559 {
560 fAliasNames[i] = "t00_c_cfd_walk_";
19fb06bd 561 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+3*kCFD));
8eb4ac75 562 fAliasNames[i] += sindex;
563 }
564 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
565 {
566 fAliasNames[i] = "t00_ac_trm_";
19fb06bd 567 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD));
8eb4ac75 568 fAliasNames[i] += sindex;
569 }
570 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
571 {
572 fAliasNames[i] = "t00_ac_drm_";
19fb06bd 573 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM));
8eb4ac75 574 fAliasNames[i] += sindex;
575 }
576 else
577 {
19fb06bd 578 fAliasNames[i] = "t00_ac_atten";
8eb4ac75 579 }
580
dc7ca31d 581 }
582
dc7ca31d 583}
584
585//---------------------------------------------------------------
8eb4ac75 586void AliT0DataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
587{
dc7ca31d 588
589 int entries=aliasArr->GetEntries();
590 AliInfo(Form("************ Alias: %s **********",fAliasNames[numAlias].Data()));
591 AliInfo(Form(" %d DP values collected",entries));
592
593}
594
dc7ca31d 595
91366e58 596