Bug fix (Tomasz)
[u/mrichter/AliRoot.git] / T0 / AliT0DataDCS.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 $Log: AliT0DataDCS.cxx,v $
18  Revision   2008/01/30 
19 Fetching data points from DCS, calculating mean and storing data to Reference DB 
20  
21  Version 1.1  2006/10
22 Preliminary test version (T.Malkiewicz)
23 */
24
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
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
46 ClassImp(AliT0DataDCS)
47
48 //---------------------------------------------------------------
49 AliT0DataDCS::AliT0DataDCS():
50         TObject(),
51         fRun(0),        
52         fStartTime(0),
53         fEndTime(0),
54         fStartTimeDCSQuery(0),
55         fEndTimeDCSQuery(0),
56         fAtten(0.),
57         fIsProcessed(kFALSE)
58 {
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   }
86
87 }
88 //---------------------------------------------------------------
89 AliT0DataDCS::AliT0DataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime, UInt_t startTimeDCSQuery, UInt_t endTimeDCSQuery):
90         TObject(),
91         fRun(nRun),
92         fStartTime(startTime),
93         fEndTime(endTime),
94         fStartTimeDCSQuery(startTimeDCSQuery),
95         fEndTimeDCSQuery(endTimeDCSQuery),
96         fAtten(0.),
97         fIsProcessed(kFALSE)
98 {
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,
128         TTimeStamp(startTime).AsString(),
129         TTimeStamp(endTime).AsString(),
130         TTimeStamp(startTimeDCSQuery).AsString(), 
131         TTimeStamp(endTimeDCSQuery).AsString()));
132
133         Init();
134
135 }
136 //---------------------------------------------------------------
137
138 AliT0DataDCS::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
150
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 }
192 //---------------------------------------------------------------
193
194 AliT0DataDCS& 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 //---------------------------------------------------------------
213 AliT0DataDCS::~AliT0DataDCS() 
214 {
215 }
216
217 //---------------------------------------------------------------
218 Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
219 {
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
239                 TObjArray *aliasArr;
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++)
278                 {
279                   aliasEntr[j]=0;
280                   for (Int_t k=0;k<32;k++) 
281                   {
282                     t0_scaler[k]=0;
283                     t0_scaler_sec[k]=0; 
284                     
285                   }
286                   aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
287                   if(!aliasArr)
288                   {
289                         AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
290                         continue;
291                   }
292                   Introduce(j, aliasArr);
293                   if(aliasArr->GetEntries()<2)
294                   {
295                         AliError(Form("Alias %s has just %d entries!",
296                                         fAliasNames[j].Data(),aliasArr->GetEntries()));
297                         continue;
298                   }
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)
310                   {
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));
315                       t0_scaler_sec[j-kScalers]+= aValue->GetUInt();
316                     }
317                     fScalerSecMean[j-kScalers] = t0_scaler_sec[j-kScalers] / aliasEntr[j];
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));
325                       t0_a_hv_imon[j-2*kScalers]+= aValue->GetFloat();
326                     }
327                     fHViA[j-2*kScalers] = t0_a_hv_imon[j-2*kScalers] / aliasEntr[j];
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));
335                       t0_a_hv_vmon[j-(2*kScalers+kHV)]+= aValue->GetFloat();
336                     }
337                     fHVvA[j-(2*kScalers+kHV)] = t0_a_hv_vmon[j-(2*kScalers+kHV)] / aliasEntr[j];
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));
345                       t0_a_lv_imon[j-(2*kScalers+2*kHV)]+= aValue->GetFloat();
346                     }
347                     fLViA[j-(2*kScalers+2*kHV)] = t0_a_lv_imon[j-(2*kScalers+2*kHV)] / aliasEntr[j];
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));
355                       t0_a_lv_vmon[j-(2*kScalers+2*kHV+kLV)]+= aValue->GetFloat();
356                     }
357                     fLVvA[j-(2*kScalers+2*kHV+kLV)] = t0_a_lv_vmon[j-(2*kScalers+2*kHV+kLV)] / aliasEntr[j];
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));
365                       t0_c_hv_imon[j-(2*kScalers+2*kHV+2*kLV)]+= aValue->GetFloat();
366                     }
367                     fHViC[j-(2*kScalers+2*kHV+2*kLV)] = t0_c_hv_imon[j-(2*kScalers+2*kHV+2*kLV)] / aliasEntr[j];
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));
375                       t0_c_hv_vmon[j-(2*kScalers+3*kHV+2*kLV)]+= aValue->GetFloat();
376                     }
377                     fHVvC[j-(2*kScalers+3*kHV+2*kLV)] = t0_c_hv_vmon[j-(2*kScalers+3*kHV+2*kLV)] / aliasEntr[j];
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));
385                       t0_c_lv_imon[j-(2*kScalers+4*kHV+2*kLV)]+= aValue->GetFloat();
386                     }
387                     fLViC[j-(2*kScalers+4*kHV+2*kLV)] = t0_c_lv_imon[j-(2*kScalers+4*kHV+2*kLV)] / aliasEntr[j];
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));
395                       t0_c_lv_vmon[j-(2*kScalers+4*kHV+3*kLV)]+= aValue->GetFloat();
396                     }
397                     fLVvC[j-(2*kScalers+4*kHV+3*kLV)] = t0_c_lv_vmon[j-(2*kScalers+4*kHV+3*kLV)] / aliasEntr[j];
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));
405                       t0_a_cfd_thre[j-(2*kScalers+4*kHV+4*kLV)]+= aValue->GetFloat();
406                     }
407                     fCFDtA[j-(2*kScalers+4*kHV+4*kLV)] = t0_a_cfd_thre[j-(2*kScalers+4*kHV+4*kLV)] / aliasEntr[j];
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));
415                       t0_a_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+kCFD)]+= aValue->GetFloat();
416                     }
417                     fCFDwA[j-(2*kScalers+4*kHV+4*kLV+kCFD)] = t0_a_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+kCFD)] / aliasEntr[j];
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));
425                       t0_c_cfd_thre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)]+= aValue->GetFloat();
426                     }
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];
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));
435                       t0_c_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)]+= aValue->GetFloat();
436                     }
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];
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));
445                       t0_ac_trm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)]+= aValue->GetFloat();
446                     }
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];
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));
455                       t0_ac_drm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)]+= aValue->GetFloat();
456                     }
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];
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                     }
467                     fAtten = t0_atten / aliasEntr[j];
468                   }
469                 }
470         fIsProcessed=kTRUE;
471         return kTRUE;
472 }
473
474 //---------------------------------------------------------------
475 void AliT0DataDCS::Init()
476 {
477         TString sindex;
478         for(int i=0;i<kNAliases;i++)
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_";
489                   sindex.Form("%02d",i-kScalers);
490                   fAliasNames[i] += sindex;
491                 }
492                 else if (i < 2*kScalers+kHV)
493                 {
494                   fAliasNames[i] = "t00_a_hv_imon_";
495                   sindex.Form("%02d",i-2*kScalers);
496                   fAliasNames[i] += sindex;
497                 }
498                 else if (i < 2*kScalers+2*kHV)
499                 {
500                   fAliasNames[i] = "t00_a_hv_vmon_";
501                   sindex.Form("%02d",i-(2*kScalers+kHV));
502                   fAliasNames[i] += sindex;
503                 }
504                 else if (i < 2*kScalers+2*kHV+kLV)
505                 {
506                   fAliasNames[i] = "t00_a_lv_imon_";
507                   sindex.Form("%02d",i-(2*kScalers+2*kHV));
508                   fAliasNames[i] += sindex;
509                 }
510                 else if (i < 2*kScalers+2*kHV+2*kLV)
511                 {
512                   fAliasNames[i] = "t00_a_lv_vmon_";
513                   sindex.Form("%02d",i-(2*kScalers+2*kHV+kLV));
514                   fAliasNames[i] += sindex;
515                 }
516                 else if (i < 2*kScalers+3*kHV+2*kLV)
517                 {
518                   fAliasNames[i] = "t00_c_hv_imon_";
519                   sindex.Form("%02d",i-(2*kScalers+2*kHV+2*kLV));
520                   fAliasNames[i] += sindex;
521                 }
522                 else if (i < 2*kScalers+4*kHV+2*kLV)
523                 {
524                   fAliasNames[i] = "t00_c_hv_vmon_";
525                   sindex.Form("%02d",i-(2*kScalers+3*kHV+2*kLV));
526                   fAliasNames[i] += sindex;
527                 }
528                 else if (i < 2*kScalers+4*kHV+3*kLV)
529                 {
530                   fAliasNames[i] = "t00_c_lv_imon_";
531                   sindex.Form("%02d",i-(2*kScalers+4*kHV+2*kLV));
532                   fAliasNames[i] += sindex;
533                 }
534                 else if (i < 2*kScalers+4*kHV+4*kLV)
535                 {
536                   fAliasNames[i] = "t00_c_lv_vmon_";
537                   sindex.Form("%02d",i-(2*kScalers+4*kHV+3*kLV));
538                   fAliasNames[i] += sindex;
539                 }
540                 else if (i < 2*kScalers+4*kHV+4*kLV+kCFD)
541                 {
542                   fAliasNames[i] = "t00_a_cfd_thre_";
543                   sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV));
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_";
549                   sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+kCFD));
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_";
555                   sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+2*kCFD));
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_";
561                   sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+3*kCFD));
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_";
567                   sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD));
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_";
573                   sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM));
574                   fAliasNames[i] += sindex;
575                 }
576                 else
577                 {
578                   fAliasNames[i] = "t00_ac_atten";
579                 }
580
581         }
582
583 }
584
585 //---------------------------------------------------------------
586 void AliT0DataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
587 {
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
595
596