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   delete fScalerMean;
 216   delete fScalerSecMean;
 217 }
 218
 219 //---------------------------------------------------------------
 220 Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
 221 {
 222                 Int_t t0_scaler[kScalers];
 223                 Int_t t0_scaler_sec[kScalers];
 224                 Int_t aliasEntr[kNAliases];
 225                 Float_t t0_a_hv_imon[kHV];
 226                 Float_t t0_a_hv_vmon[kHV];
 227                 Float_t t0_a_lv_imon[kLV];
 228                 Float_t t0_a_lv_vmon[kLV];
 229                 Float_t t0_c_hv_imon[kHV];
 230                 Float_t t0_c_hv_vmon[kHV];
 231                 Float_t t0_c_lv_imon[kLV];
 232                 Float_t t0_c_lv_vmon[kLV];
 233                 Float_t t0_a_cfd_thre[kCFD];
 234                 Float_t t0_a_cfd_walk[kCFD];
 235                 Float_t t0_c_cfd_thre[kCFD];
 236                 Float_t t0_c_cfd_walk[kCFD];
 237                 Float_t t0_ac_trm[kTRM];
 238                 Float_t t0_ac_drm[kDRM];
 239                 Float_t t0_atten=0.;
 240
 241                 TObjArray *aliasArr;
 242                 for(Int_t k=0; k<kScalers; k++)
 243                 {
 244                    t0_scaler[k]=0;
 245                    t0_scaler_sec[k]=0;
 246                 }
 247
 248                 for(Int_t k=0; k<kHV; k++)
 249                 {
 250                    t0_a_hv_imon[k]=0.;
 251                    t0_a_hv_vmon[k]=0.;
 252                    t0_c_hv_imon[k]=0.;
 253                    t0_c_hv_vmon[k]=0.;
 254                 }
 255                 for(Int_t k=0; k<kHV; k++)
 256                 {
 257                    t0_a_lv_imon[k]=0.;
 258                    t0_a_lv_vmon[k]=0.;
 259                    t0_c_lv_imon[k]=0.;
 260                    t0_c_lv_vmon[k]=0.;
 261                 }
 262                 for(Int_t k=0; k<kCFD; k++)
 263                 {
 264                    t0_a_cfd_thre[k]=0.;
 265                    t0_a_cfd_walk[k]=0.;
 266                    t0_c_cfd_thre[k]=0.;
 267                    t0_c_cfd_walk[k]=0.;
 268                 }
 269                 for(Int_t k=0; k<kTRM; k++)
 270                 {
 271                    t0_ac_trm[k]=0.;
 272                 }
 273                 for(Int_t k=0; k<kDRM; k++)
 274                 {
 275                    t0_ac_drm[k]=0.;
 276                 }
 277
 278 // here starts the main loop
 279                 for(Int_t j=0; j<kNAliases; j++)
 280                 {
 281                   aliasEntr[j]=0;
 282                   for (Int_t k=0;k<32;k++)
 283                   {
 284                     t0_scaler[k]=0;
 285                     t0_scaler_sec[k]=0;
 286
 287                   }
 288                   aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
 289                   if(!aliasArr)
 290                   {
 291                         AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
 292                         continue;
 293                   }
 294                   Introduce(j, aliasArr);
 295                   if(aliasArr->GetEntries()<2)
 296                   {
 297                         AliError(Form("Alias %s has just %d entries!",
 298                                         fAliasNames[j].Data(),aliasArr->GetEntries()));
 299                         continue;
 300                   }
 301                   if (j < kScalers)
 302                   {
 303                     aliasEntr[j] = aliasArr->GetEntries();
 304                     for(Int_t l=0; l<aliasEntr[j]; l++)
 305                     {
 306                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 307                       t0_scaler[j]+= aValue->GetUInt();
 308                     }
 309                     fScalerMean[j] = t0_scaler[j] / aliasEntr[j];
 310                   }
 311                   else if (j < 2*kScalers)
 312                   {
 313                     aliasEntr[j] = aliasArr->GetEntries();
 314                     for(Int_t l=0; l<aliasEntr[j]; l++)
 315                     {
 316                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 317                       t0_scaler_sec[j]+= aValue->GetUInt();
 318                     }
 319                     fScalerSecMean[j] = t0_scaler_sec[j] / aliasEntr[j];
 320                   }
 321                   else if (j < 2*kScalers+kHV)
 322                   {
 323                     aliasEntr[j] = aliasArr->GetEntries();
 324                     for(Int_t l=0; l<aliasEntr[j]; l++)
 325                     {
 326                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 327                       t0_a_hv_imon[j]+= aValue->GetFloat();
 328                     }
 329                     fHViA[j] = t0_a_hv_imon[j] / aliasEntr[j];
 330                   }
 331                   else if (j < 2*kScalers+2*kHV)
 332                   {
 333                     aliasEntr[j] = aliasArr->GetEntries();
 334                     for(Int_t l=0; l<aliasEntr[j]; l++)
 335                     {
 336                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 337                       t0_a_hv_vmon[j]+= aValue->GetFloat();
 338                     }
 339                     fHVvA[j] = t0_a_hv_vmon[j] / aliasEntr[j];
 340                   }
 341                   else if (j < 2*kScalers+2*kHV+kLV)
 342                   {
 343                     aliasEntr[j] = aliasArr->GetEntries();
 344                     for(Int_t l=0; l<aliasEntr[j]; l++)
 345                     {
 346                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 347                       t0_a_lv_imon[j]+= aValue->GetFloat();
 348                     }
 349                     fLViA[j] = t0_a_lv_imon[j] / aliasEntr[j];
 350                   }
 351                   else if (j < 2*kScalers+2*kHV+2*kLV)
 352                   {
 353                     aliasEntr[j] = aliasArr->GetEntries();
 354                     for(Int_t l=0; l<aliasEntr[j]; l++)
 355                     {
 356                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 357                       t0_a_lv_vmon[j]+= aValue->GetFloat();
 358                     }
 359                     fLVvA[j] = t0_a_lv_vmon[j] / aliasEntr[j];
 360                   }
 361                   else if (j < 2*kScalers+3*kHV+2*kLV)
 362                   {
 363                     aliasEntr[j] = aliasArr->GetEntries();
 364                     for(Int_t l=0; l<aliasEntr[j]; l++)
 365                     {
 366                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 367                       t0_c_hv_imon[j]+= aValue->GetFloat();
 368                     }
 369                     fHViC[j] = t0_c_hv_imon[j] / aliasEntr[j];
 370                   }
 371                   else if (j < 2*kScalers+4*kHV+2*kLV)
 372                   {
 373                     aliasEntr[j] = aliasArr->GetEntries();
 374                     for(Int_t l=0; l<aliasEntr[j]; l++)
 375                     {
 376                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 377                       t0_c_hv_vmon[j]+= aValue->GetFloat();
 378                     }
 379                     fHVvC[j] = t0_c_hv_vmon[j] / aliasEntr[j];
 380                   }
 381                   else if (j < 2*kScalers+4*kHV+3*kLV)
 382                   {
 383                     aliasEntr[j] = aliasArr->GetEntries();
 384                     for(Int_t l=0; l<aliasEntr[j]; l++)
 385                     {
 386                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 387                       t0_c_lv_imon[j]+= aValue->GetFloat();
 388                     }
 389                     fLViC[j] = t0_c_lv_imon[j] / aliasEntr[j];
 390                   }
 391                   else if (j < 2*kScalers+4*kHV+4*kLV)
 392                   {
 393                     aliasEntr[j] = aliasArr->GetEntries();
 394                     for(Int_t l=0; l<aliasEntr[j]; l++)
 395                     {
 396                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 397                       t0_c_lv_vmon[j]+= aValue->GetFloat();
 398                     }
 399                     fLVvC[j] = t0_c_lv_vmon[j] / aliasEntr[j];
 400                   }
 401                   else if (j < 2*kScalers+4*kHV+4*kLV+kCFD)
 402                   {
 403                     aliasEntr[j] = aliasArr->GetEntries();
 404                     for(Int_t l=0; l<aliasEntr[j]; l++)
 405                     {
 406                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 407                       t0_a_cfd_thre[j]+= aValue->GetFloat();
 408                     }
 409                     fCFDtA[j] = t0_a_cfd_thre[j] / aliasEntr[j];
 410                   }
 411                   else if (j < 2*kScalers+4*kHV+4*kLV+2*kCFD)
 412                   {
 413                     aliasEntr[j] = aliasArr->GetEntries();
 414                     for(Int_t l=0; l<aliasEntr[j]; l++)
 415                     {
 416                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 417                       t0_a_cfd_walk[j]+= aValue->GetFloat();
 418                     }
 419                     fCFDwA[j] = t0_a_cfd_walk[j] / aliasEntr[j];
 420                   }
 421                   else if (j < 2*kScalers+4*kHV+4*kLV+3*kCFD)
 422                   {
 423                     aliasEntr[j] = aliasArr->GetEntries();
 424                     for(Int_t l=0; l<aliasEntr[j]; l++)
 425                     {
 426                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 427                       t0_c_cfd_thre[j]+= aValue->GetFloat();
 428                     }
 429                     fCFDtC[j] = t0_c_cfd_thre[j] / aliasEntr[j];
 430                   }
 431                   else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD)
 432                   {
 433                     aliasEntr[j] = aliasArr->GetEntries();
 434                     for(Int_t l=0; l<aliasEntr[j]; l++)
 435                     {
 436                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 437                       t0_c_cfd_walk[j]+= aValue->GetFloat();
 438                     }
 439                     fCFDwC[j] = t0_c_cfd_walk[j] / aliasEntr[j];
 440                   }
 441                   else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
 442                   {
 443                     aliasEntr[j] = aliasArr->GetEntries();
 444                     for(Int_t l=0; l<aliasEntr[j]; l++)
 445                     {
 446                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 447                       t0_ac_trm[j]+= aValue->GetFloat();
 448                     }
 449                     fTRM[j] = t0_ac_trm[j] / aliasEntr[j];
 450                   }
 451                   else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
 452                   {
 453                     aliasEntr[j] = aliasArr->GetEntries();
 454                     for(Int_t l=0; l<aliasEntr[j]; l++)
 455                     {
 456                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 457                       t0_ac_drm[j]+= aValue->GetFloat();
 458                     }
 459                     fDRM[j] = t0_ac_drm[j] / aliasEntr[j];
 460                   }
 461                   else
 462                   {
 463                     aliasEntr[j] = aliasArr->GetEntries();
 464                     for(Int_t l=0; l<aliasEntr[j]; l++)
 465                     {
 466                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 467                       t0_atten += aValue->GetInt();
 468                     }
 469                     fTRM[j] = t0_atten / aliasEntr[j];
 470                   }
 471
 472
 473                 }
 474         fIsProcessed=kTRUE;
 475         return kTRUE;
 476 }
 477
 478 //---------------------------------------------------------------
 479 void AliT0DataDCS::Init()
 480 {
 481         TString sindex;
 482         for(int i=0;i<kNAliases;i++)
 483         {
 484                 if (i<kScalers)
 485                 {
 486                   fAliasNames[i] = "t00_ac_scaler_";
 487                   sindex.Form("%02d",i);
 488                   fAliasNames[i] += sindex;
 489                 }
 490                 else if (i < 2*kScalers)
 491                 {
 492                   fAliasNames[i] = "t00_ac_scaler_sec_";
 493                   sindex.Form("%02d",i);
 494                   fAliasNames[i] += sindex;
 495                 }
 496                 else if (i < 2*kScalers+kHV)
 497                 {
 498                   fAliasNames[i] = "t00_a_hv_imon_";
 499                   sindex.Form("%02d",i);
 500                   fAliasNames[i] += sindex;
 501                 }
 502                 else if (i < 2*kScalers+2*kHV)
 503                 {
 504                   fAliasNames[i] = "t00_a_hv_vmon_";
 505                   sindex.Form("%02d",i);
 506                   fAliasNames[i] += sindex;
 507                 }
 508                 else if (i < 2*kScalers+2*kHV+kLV)
 509                 {
 510                   fAliasNames[i] = "t00_a_lv_imon_";
 511                   sindex.Form("%02d",i);
 512                   fAliasNames[i] += sindex;
 513                 }
 514                 else if (i < 2*kScalers+2*kHV+2*kLV)
 515                 {
 516                   fAliasNames[i] = "t00_a_lv_vmon_";
 517                   sindex.Form("%02d",i);
 518                   fAliasNames[i] += sindex;
 519                 }
 520                 else if (i < 2*kScalers+3*kHV+2*kLV)
 521                 {
 522                   fAliasNames[i] = "t00_c_hv_imon_";
 523                   sindex.Form("%02d",i);
 524                   fAliasNames[i] += sindex;
 525                 }
 526                 else if (i < 2*kScalers+4*kHV+2*kLV)
 527                 {
 528                   fAliasNames[i] = "t00_c_hv_vmon_";
 529                   sindex.Form("%02d",i);
 530                   fAliasNames[i] += sindex;
 531                 }
 532                 else if (i < 2*kScalers+4*kHV+3*kLV)
 533                 {
 534                   fAliasNames[i] = "t00_c_lv_imon_";
 535                   sindex.Form("%02d",i);
 536                   fAliasNames[i] += sindex;
 537                 }
 538                 else if (i < 2*kScalers+4*kHV+4*kLV)
 539                 {
 540                   fAliasNames[i] = "t00_c_lv_vmon_";
 541                   sindex.Form("%02d",i);
 542                   fAliasNames[i] += sindex;
 543                 }
 544                 else if (i < 2*kScalers+4*kHV+4*kLV+kCFD)
 545                 {
 546                   fAliasNames[i] = "t00_a_cfd_thre_";
 547                   sindex.Form("%02d",i);
 548                   fAliasNames[i] += sindex;
 549                 }
 550                 else if (i < 2*kScalers+4*kHV+4*kLV+2*kCFD)
 551                 {
 552                   fAliasNames[i] = "t00_a_cfd_walk_";
 553                   sindex.Form("%02d",i);
 554                   fAliasNames[i] += sindex;
 555                 }
 556                   else if (i < 2*kScalers+4*kHV+4*kLV+3*kCFD)
 557                 {
 558                   fAliasNames[i] = "t00_c_cfd_thre_";
 559                   sindex.Form("%02d",i);
 560                   fAliasNames[i] += sindex;
 561                 }
 562                 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD)
 563                 {
 564                   fAliasNames[i] = "t00_c_cfd_walk_";
 565                   sindex.Form("%02d",i);
 566                   fAliasNames[i] += sindex;
 567                 }
 568                 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
 569                 {
 570                   fAliasNames[i] = "t00_ac_trm_";
 571                   sindex.Form("%02d",i);
 572                   fAliasNames[i] += sindex;
 573                 }
 574                  else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
 575                 {
 576                   fAliasNames[i] = "t00_ac_drm_";
 577                   sindex.Form("%02d",i);
 578                   fAliasNames[i] += sindex;
 579                 }
 580                 else
 581                 {
 582                   fAliasNames[i] = "t00_atten";
 583                 }
 584
 585         }
 586
 587 }
 588
 589 //---------------------------------------------------------------
 590 void AliT0DataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
 591 {
 592
 593         int entries=aliasArr->GetEntries();
 594         AliInfo(Form("************ Alias: %s **********",fAliasNames[numAlias].Data()));
 595         AliInfo(Form("          %d DP values collected",entries));
 596
 597 }
 598
 599
 600