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