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 #include <iostream>
  40
  41 // AliT0DataDCS class
  42 // declaring DCS aliases for T0
  43 // fetching T0 data points from DCS,
  44 // calculating mean values for the entire run
  45 // and storing the result to Reference DB
  46
  47 ClassImp(AliT0DataDCS)
  48
  49 //---------------------------------------------------------------
  50 AliT0DataDCS::AliT0DataDCS():
  51         TObject(),
  52         fRun(0),
  53         fStartTime(0),
  54         fEndTime(0),
  55         fStartTimeDCSQuery(0),
  56         fEndTimeDCSQuery(0),
  57         fAtten(0.),
  58         fMPDcentA(0),
  59         fMPDcentC(0),
  60         fMPDsemiCentA(0),
  61         fMPDsemiCentC(0),
  62         fTVDCtop(0),
  63         fTVDCbottom(0),
  64         fMPDmode(0),
  65         fIsProcessed(kFALSE)
  66 {
  67   for(Int_t i=0;i<kScalers;i++)
  68   {
  69     fScalerMean[i]=0.;
  70     fScalerSecMean[i]=0.;
  71   }
  72   for(Int_t i=0;i<kHV;i++)
  73   {
  74     fHViA[i]=0.;
  75     fHVvA[i]=0.;
  76     fHViC[i]=0.;
  77     fHVvC[i]=0.;
  78   }
  79   for(Int_t i=0;i<kLV;i++)
  80   {
  81     fLViA[i]=0.;
  82     fLVvA[i]=0.;
  83     fLViC[i]=0.;
  84     fLVvC[i]=0.;
  85   }
  86   for(Int_t i=0;i<kTRM;i++)
  87   {
  88     fTRM[i]=0.;
  89   }
  90   for(Int_t i=0;i<kDRM;i++)
  91   {
  92     fDRM[i]=0.;
  93   }
  94
  95 }
  96 //---------------------------------------------------------------
  97 AliT0DataDCS::AliT0DataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime, UInt_t startTimeDCSQuery, UInt_t endTimeDCSQuery):
  98         TObject(),
  99         fRun(nRun),
 100         fStartTime(startTime),
 101         fEndTime(endTime),
 102         fStartTimeDCSQuery(startTimeDCSQuery),
 103         fEndTimeDCSQuery(endTimeDCSQuery),
 104         fAtten(0.),
 105         fMPDcentA(0),
 106         fMPDcentC(0),
 107         fMPDsemiCentA(0),
 108         fMPDsemiCentC(0),
 109         fTVDCtop(0),
 110         fTVDCbottom(0),
 111         fMPDmode(0),
 112         fIsProcessed(kFALSE)
 113 {
 114   for(Int_t i=0;i<kScalers;i++)
 115   {
 116     fScalerMean[i]=0.;
 117     fScalerSecMean[i]=0.;
 118   }
 119   for(Int_t i=0;i<kHV;i++)
 120   {
 121     fHViA[i]=0.;
 122     fHVvA[i]=0.;
 123     fHViC[i]=0.;
 124     fHVvC[i]=0.;
 125   }
 126   for(Int_t i=0;i<kLV;i++)
 127   {
 128     fLViA[i]=0.;
 129     fLVvA[i]=0.;
 130     fLViC[i]=0.;
 131     fLVvC[i]=0.;
 132   }
 133   for(Int_t i=0;i<kTRM;i++)
 134   {
 135     fTRM[i]=0.;
 136   }
 137   for(Int_t i=0;i<kDRM;i++)
 138   {
 139     fDRM[i]=0.;
 140   }
 141
 142         AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s \n\tStartTime DCS Query %s \n\tEndTime DCS Query %s", nRun,
 143         TTimeStamp(startTime).AsString(),
 144         TTimeStamp(endTime).AsString(),
 145         TTimeStamp(startTimeDCSQuery).AsString(),
 146         TTimeStamp(endTimeDCSQuery).AsString()));
 147
 148         Init();
 149
 150 }
 151 //---------------------------------------------------------------
 152
 153 AliT0DataDCS::AliT0DataDCS(const AliT0DataDCS & data):
 154   TObject(),
 155   fRun(0),
 156   fStartTime(0),
 157   fEndTime(0),
 158   fStartTimeDCSQuery(0),
 159   fEndTimeDCSQuery(0),
 160   fAtten(0.),
 161   fMPDcentA(0),
 162   fMPDcentC(0),
 163   fMPDsemiCentA(0),
 164   fMPDsemiCentC(0),
 165   fTVDCtop(0),
 166   fTVDCbottom(0),
 167   fMPDmode(0),
 168   fIsProcessed(kFALSE)
 169 {
 170
 171 // copy constructor
 172
 173   fRun=data.fRun;
 174   fStartTime=data.fStartTime;
 175   fEndTime=data.fEndTime;
 176   fStartTimeDCSQuery=data.fStartTimeDCSQuery;
 177   fEndTimeDCSQuery=data.fEndTimeDCSQuery;
 178   fIsProcessed=data.fIsProcessed;
 179   fAtten=data.fAtten;
 180   fMPDcentA=data.fMPDcentA;
 181   fMPDcentC=data.fMPDcentC;
 182   fMPDsemiCentA=data.fMPDsemiCentA;
 183   fMPDsemiCentC=data.fMPDsemiCentC;
 184   fTVDCtop=data.fTVDCtop;
 185   fTVDCbottom=data.fTVDCbottom;
 186   fMPDmode=data.fMPDmode;
 187   for(int i=0;i<kNAliases;i++)
 188   {
 189     fAliasNames[i]=data.fAliasNames[i];
 190   }
 191
 192   for(Int_t i=0;i<kScalers;i++)
 193   {
 194     fScalerMean[i]=data.fScalerMean[i];
 195     fScalerSecMean[i]=data.fScalerSecMean[i];
 196   }
 197   for(Int_t i=0;i<kHV;i++)
 198   {
 199     fHViA[i]=data.fHViA[i];
 200     fHVvA[i]=data.fHVvA[i];
 201     fHViC[i]=data.fHViC[i];
 202     fHVvC[i]=data.fHVvC[i];
 203   }
 204   for(Int_t i=0;i<kLV;i++)
 205   {
 206     fLViA[i]=data.fLViA[i];
 207     fLVvA[i]=data.fLVvA[i];
 208     fLViC[i]=data.fLViC[i];
 209     fLVvC[i]=data.fLVvC[i];
 210   }
 211   for(Int_t i=0;i<kTRM;i++)
 212   {
 213     fTRM[i]=data.fTRM[i];
 214   }
 215   for(Int_t i=0;i<kDRM;i++)
 216   {
 217     fDRM[i]=data.fDRM[i];
 218   }
 219 }
 220 //---------------------------------------------------------------
 221
 222 AliT0DataDCS& AliT0DataDCS:: operator=(const AliT0DataDCS & data) {
 223
 224 // assignment operator
 225
 226   this->fRun=data.fRun;
 227   this->fStartTime=data.fStartTime;
 228   this->fEndTime=data.fEndTime;
 229   this->fStartTimeDCSQuery=data.fStartTimeDCSQuery;
 230   this->fEndTimeDCSQuery=data.fEndTimeDCSQuery;
 231
 232   for(int i=0;i<kNAliases;i++)
 233   {
 234     this->fAliasNames[i]=data.fAliasNames[i];
 235   }
 236
 237   return *this;
 238 }
 239
 240 //---------------------------------------------------------------
 241 AliT0DataDCS::~AliT0DataDCS()
 242 {
 243 }
 244
 245 //---------------------------------------------------------------
 246 Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
 247 {
 248                 Int_t t0_scaler[kScalers];
 249                 Int_t t0_scaler_sec[kScalers];
 250                 Int_t aliasEntr[kNAliases];
 251                 Float_t t0_a_hv_imon[kHV];
 252                 Float_t t0_a_hv_vmon[kHV];
 253                 Float_t t0_a_lv_imon[kLV];
 254                 Float_t t0_a_lv_vmon[kLV];
 255                 Float_t t0_c_hv_imon[kHV];
 256                 Float_t t0_c_hv_vmon[kHV];
 257                 Float_t t0_c_lv_imon[kLV];
 258                 Float_t t0_c_lv_vmon[kLV];
 259                 Float_t t0_a_cfd_thre[kCFD];
 260                 Float_t t0_a_cfd_walk[kCFD];
 261                 Float_t t0_c_cfd_thre[kCFD];
 262                 Float_t t0_c_cfd_walk[kCFD];
 263                 Float_t t0_ac_trm[kTRM];
 264                 Float_t t0_ac_drm[kDRM];
 265                 Float_t t0_atten=0.;
 266                 Int_t t0_MPDcentA=0;
 267                 Int_t t0_MPDcentC=0;
 268                 Int_t t0_MPDsemiCentA=0;
 269                 Int_t t0_MPDsemiCentC=0;
 270                 Int_t t0_TVDCtop=0;
 271                 Int_t t0_TVDCbottom=0;
 272                 Int_t t0_MPDmode=0;
 273
 274                 TObjArray *aliasArr;
 275                 for(Int_t k=0; k<kScalers; k++)
 276                 {
 277                    t0_scaler[k]=0;
 278                    t0_scaler_sec[k]=0;
 279                 }
 280
 281                 for(Int_t k=0; k<kHV; k++)
 282                 {
 283                    t0_a_hv_imon[k]=0.;
 284                    t0_a_hv_vmon[k]=0.;
 285                    t0_c_hv_imon[k]=0.;
 286                    t0_c_hv_vmon[k]=0.;
 287                 }
 288                 for(Int_t k=0; k<kLV; k++)
 289                 {
 290                    t0_a_lv_imon[k]=0.;
 291                    t0_a_lv_vmon[k]=0.;
 292                    t0_c_lv_imon[k]=0.;
 293                    t0_c_lv_vmon[k]=0.;
 294                 }
 295                 for(Int_t k=0; k<kCFD; k++)
 296                 {
 297                    t0_a_cfd_thre[k]=0.;
 298                    t0_a_cfd_walk[k]=0.;
 299                    t0_c_cfd_thre[k]=0.;
 300                    t0_c_cfd_walk[k]=0.;
 301                 }
 302                 for(Int_t k=0; k<kTRM; k++)
 303                 {
 304                    t0_ac_trm[k]=0.;
 305                 }
 306                 for(Int_t k=0; k<kDRM; k++)
 307                 {
 308                    t0_ac_drm[k]=0.;
 309                 }
 310
 311 // here starts the main loop
 312                 for(Int_t j=0; j<kNAliases; j++)
 313                 {
 314                   aliasEntr[j]=0;
 315                   for (Int_t k=0;k<32;k++)
 316                   {
 317                     t0_scaler[k]=0;
 318                     t0_scaler_sec[k]=0;
 319
 320                   }
 321                   std::cout << fAliasNames << "   " << j << std::endl;
 322                   std::cout << fAliasNames[j] << std::endl;
 323                   aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
 324                   if(!aliasArr)
 325                   {
 326                         AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
 327                         continue;
 328                   }
 329                   Introduce(j, aliasArr);
 330                   if(aliasArr->GetEntries()<2)
 331                   {
 332                         AliError(Form("Alias %s has just %d entries!",
 333                                         fAliasNames[j].Data(),aliasArr->GetEntries()));
 334                         continue;
 335                   }
 336                   if (j < kScalers)
 337                   {
 338                     aliasEntr[j] = aliasArr->GetEntries();
 339                     for(Int_t l=0; l<aliasEntr[j]; l++)
 340                     {
 341                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 342                       t0_scaler[j]+= aValue->GetUInt();
 343                     }
 344                     fScalerMean[j] = t0_scaler[j] / aliasEntr[j];
 345                   }
 346                   else if (j < 2*kScalers)
 347                   {
 348                     aliasEntr[j] = aliasArr->GetEntries();
 349                     for(Int_t l=0; l<aliasEntr[j]; l++)
 350                     {
 351                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 352                       t0_scaler_sec[j-kScalers]+= aValue->GetUInt();
 353                     }
 354                     fScalerSecMean[j-kScalers] = t0_scaler_sec[j-kScalers] / aliasEntr[j];
 355                   }
 356                   else if (j < 2*kScalers+kHV)
 357                   {
 358                     aliasEntr[j] = aliasArr->GetEntries();
 359                     for(Int_t l=0; l<aliasEntr[j]; l++)
 360                     {
 361                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 362                       t0_a_hv_imon[j-2*kScalers]+= aValue->GetFloat();
 363                     }
 364                     fHViA[j-2*kScalers] = t0_a_hv_imon[j-2*kScalers] / aliasEntr[j];
 365                   }
 366                   else if (j < 2*kScalers+2*kHV)
 367                   {
 368                     aliasEntr[j] = aliasArr->GetEntries();
 369                     for(Int_t l=0; l<aliasEntr[j]; l++)
 370                     {
 371                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 372                       t0_a_hv_vmon[j-(2*kScalers+kHV)]+= aValue->GetFloat();
 373                     }
 374                     fHVvA[j-(2*kScalers+kHV)] = t0_a_hv_vmon[j-(2*kScalers+kHV)] / aliasEntr[j];
 375                   }
 376                   else if (j < 2*kScalers+2*kHV+kLV)
 377                   {
 378                     aliasEntr[j] = aliasArr->GetEntries();
 379                     for(Int_t l=0; l<aliasEntr[j]; l++)
 380                     {
 381                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 382                       t0_a_lv_imon[j-(2*kScalers+2*kHV)]+= aValue->GetFloat();
 383                     }
 384                     fLViA[j-(2*kScalers+2*kHV)] = t0_a_lv_imon[j-(2*kScalers+2*kHV)] / aliasEntr[j];
 385                   }
 386                   else if (j < 2*kScalers+2*kHV+2*kLV)
 387                   {
 388                     aliasEntr[j] = aliasArr->GetEntries();
 389                     for(Int_t l=0; l<aliasEntr[j]; l++)
 390                     {
 391                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 392                       t0_a_lv_vmon[j-(2*kScalers+2*kHV+kLV)]+= aValue->GetFloat();
 393                     }
 394                     fLVvA[j-(2*kScalers+2*kHV+kLV)] = t0_a_lv_vmon[j-(2*kScalers+2*kHV+kLV)] / aliasEntr[j];
 395                   }
 396                   else if (j < 2*kScalers+3*kHV+2*kLV)
 397                   {
 398                     aliasEntr[j] = aliasArr->GetEntries();
 399                     for(Int_t l=0; l<aliasEntr[j]; l++)
 400                     {
 401                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 402                       t0_c_hv_imon[j-(2*kScalers+2*kHV+2*kLV)]+= aValue->GetFloat();
 403                     }
 404                     fHViC[j-(2*kScalers+2*kHV+2*kLV)] = t0_c_hv_imon[j-(2*kScalers+2*kHV+2*kLV)] / aliasEntr[j];
 405                   }
 406                   else if (j < 2*kScalers+4*kHV+2*kLV)
 407                   {
 408                     aliasEntr[j] = aliasArr->GetEntries();
 409                     for(Int_t l=0; l<aliasEntr[j]; l++)
 410                     {
 411                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 412                       t0_c_hv_vmon[j-(2*kScalers+3*kHV+2*kLV)]+= aValue->GetFloat();
 413                     }
 414                     fHVvC[j-(2*kScalers+3*kHV+2*kLV)] = t0_c_hv_vmon[j-(2*kScalers+3*kHV+2*kLV)] / aliasEntr[j];
 415                   }
 416                   else if (j < 2*kScalers+4*kHV+3*kLV)
 417                   {
 418                     aliasEntr[j] = aliasArr->GetEntries();
 419                     for(Int_t l=0; l<aliasEntr[j]; l++)
 420                     {
 421                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 422                       t0_c_lv_imon[j-(2*kScalers+4*kHV+2*kLV)]+= aValue->GetFloat();
 423                     }
 424                     fLViC[j-(2*kScalers+4*kHV+2*kLV)] = t0_c_lv_imon[j-(2*kScalers+4*kHV+2*kLV)] / aliasEntr[j];
 425                   }
 426                   else if (j < 2*kScalers+4*kHV+4*kLV)
 427                   {
 428                     aliasEntr[j] = aliasArr->GetEntries();
 429                     for(Int_t l=0; l<aliasEntr[j]; l++)
 430                     {
 431                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 432                       t0_c_lv_vmon[j-(2*kScalers+4*kHV+3*kLV)]+= aValue->GetFloat();
 433                     }
 434                     fLVvC[j-(2*kScalers+4*kHV+3*kLV)] = t0_c_lv_vmon[j-(2*kScalers+4*kHV+3*kLV)] / aliasEntr[j];
 435                   }
 436                   else if (j < 2*kScalers+4*kHV+4*kLV+kCFD)
 437                   {
 438                     aliasEntr[j] = aliasArr->GetEntries();
 439                     for(Int_t l=0; l<aliasEntr[j]; l++)
 440                     {
 441                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 442                       t0_a_cfd_thre[j-(2*kScalers+4*kHV+4*kLV)]+= aValue->GetFloat();
 443                     }
 444                     fCFDtA[j-(2*kScalers+4*kHV+4*kLV)] = t0_a_cfd_thre[j-(2*kScalers+4*kHV+4*kLV)] / aliasEntr[j];
 445                   }
 446                   else if (j < 2*kScalers+4*kHV+4*kLV+2*kCFD)
 447                   {
 448                     aliasEntr[j] = aliasArr->GetEntries();
 449                     for(Int_t l=0; l<aliasEntr[j]; l++)
 450                     {
 451                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 452                       t0_a_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+kCFD)]+= aValue->GetFloat();
 453                     }
 454                     fCFDwA[j-(2*kScalers+4*kHV+4*kLV+kCFD)] = t0_a_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+kCFD)] / aliasEntr[j];
 455                   }
 456                   else if (j < 2*kScalers+4*kHV+4*kLV+3*kCFD)
 457                   {
 458                     aliasEntr[j] = aliasArr->GetEntries();
 459                     for(Int_t l=0; l<aliasEntr[j]; l++)
 460                     {
 461                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 462                       t0_c_cfd_thre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)]+= aValue->GetFloat();
 463                     }
 464                     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];
 465                   }
 466                   else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD)
 467                   {
 468                     aliasEntr[j] = aliasArr->GetEntries();
 469                     for(Int_t l=0; l<aliasEntr[j]; l++)
 470                     {
 471                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 472                       t0_c_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)]+= aValue->GetFloat();
 473                     }
 474                     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];
 475                   }
 476                   else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
 477                   {
 478                     aliasEntr[j] = aliasArr->GetEntries();
 479                     for(Int_t l=0; l<aliasEntr[j]; l++)
 480                     {
 481                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 482                       t0_ac_trm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)]+= aValue->GetFloat();
 483                     }
 484                     fTRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] = t0_ac_trm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] / aliasEntr[j];
 485                   }
 486                   else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
 487                   {
 488                     aliasEntr[j] = aliasArr->GetEntries();
 489                     for(Int_t l=0; l<aliasEntr[j]; l++)
 490                     {
 491                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 492                       t0_ac_drm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)]+= aValue->GetFloat();
 493                     }
 494                     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];
 495                   }
 496                   else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+kAtten)
 497                   {
 498                     aliasEntr[j] = aliasArr->GetEntries();
 499                     for(Int_t l=0; l<aliasEntr[j]; l++)
 500                     {
 501                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 502                       t0_atten += aValue->GetInt();
 503                     }
 504                     fAtten = t0_atten / aliasEntr[j];
 505                   }
 506                   else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+2*kAtten)
 507                   {
 508                     aliasEntr[j] = aliasArr->GetEntries();
 509                     for(Int_t l=0; l<aliasEntr[j]; l++)
 510                     {
 511                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 512                       t0_MPDcentA += aValue->GetInt();
 513                     }
 514                     fMPDcentA = t0_MPDcentA / aliasEntr[j];
 515                   }
 516                   else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+3*kAtten)
 517                   {
 518                     aliasEntr[j] = aliasArr->GetEntries();
 519                     for(Int_t l=0; l<aliasEntr[j]; l++)
 520                     {
 521                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 522                       t0_MPDcentC += aValue->GetInt();
 523                     }
 524                     fMPDcentC = t0_MPDcentC / aliasEntr[j];
 525                   }
 526                   else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+4*kAtten)
 527                   {
 528                     aliasEntr[j] = aliasArr->GetEntries();
 529                     for(Int_t l=0; l<aliasEntr[j]; l++)
 530                     {
 531                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 532                       t0_MPDsemiCentA += aValue->GetInt();
 533                     }
 534                     fMPDsemiCentA = t0_MPDsemiCentA / aliasEntr[j];
 535                   }
 536                   else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+5*kAtten)
 537                   {
 538                     aliasEntr[j] = aliasArr->GetEntries();
 539                     for(Int_t l=0; l<aliasEntr[j]; l++)
 540                     {
 541                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 542                       t0_MPDsemiCentC += aValue->GetInt();
 543                     }
 544                     fMPDsemiCentC = t0_MPDsemiCentC / aliasEntr[j];
 545                   }
 546                   else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+6*kAtten)
 547                   {
 548                     aliasEntr[j] = aliasArr->GetEntries();
 549                     for(Int_t l=0; l<aliasEntr[j]; l++)
 550                     {
 551                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 552                       t0_TVDCtop += aValue->GetInt();
 553                     }
 554                     fTVDCtop = t0_TVDCtop / aliasEntr[j];
 555                   }
 556                   else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+7*kAtten)
 557                   {
 558                     aliasEntr[j] = aliasArr->GetEntries();
 559                     for(Int_t l=0; l<aliasEntr[j]; l++)
 560                     {
 561                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 562                       t0_TVDCbottom += aValue->GetInt();
 563                     }
 564                     fTVDCbottom = t0_TVDCbottom / aliasEntr[j];
 565                   }
 566                   else
 567                   {
 568                     aliasEntr[j] = aliasArr->GetEntries();
 569                     for(Int_t l=0; l<aliasEntr[j]; l++)
 570                     {
 571                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
 572                       t0_MPDmode += aValue->GetInt();
 573                     }
 574                     fMPDmode = t0_MPDmode / aliasEntr[j];
 575                   }
 576                 }
 577         fIsProcessed=kTRUE;
 578         return kTRUE;
 579 }
 580
 581 //---------------------------------------------------------------
 582 void AliT0DataDCS::Init()
 583 {
 584         TString sindex;
 585         for(int i=0;i<kNAliases;i++)
 586         {
 587                 if (i<kScalers)
 588                 {
 589                   fAliasNames[i] = "t00_ac_scaler_";
 590                   sindex.Form("%02d",i);
 591                   fAliasNames[i] += sindex;
 592                 }
 593                 else if (i < 2*kScalers)
 594                 {
 595                   fAliasNames[i] = "t00_ac_scaler_sec_";
 596                   sindex.Form("%02d",i-kScalers);
 597                   fAliasNames[i] += sindex;
 598                 }
 599                 else if (i < 2*kScalers+kHV)
 600                 {
 601                   fAliasNames[i] = "t00_a_hv_imon_";
 602                   sindex.Form("%02d",i-2*kScalers);
 603                   fAliasNames[i] += sindex;
 604                 }
 605                 else if (i < 2*kScalers+2*kHV)
 606                 {
 607                   fAliasNames[i] = "t00_a_hv_vmon_";
 608                   sindex.Form("%02d",i-(2*kScalers+kHV));
 609                   fAliasNames[i] += sindex;
 610                 }
 611                 else if (i < 2*kScalers+2*kHV+kLV)
 612                 {
 613                   fAliasNames[i] = "t00_a_lv_imon_";
 614                   sindex.Form("%01d",i-(2*kScalers+2*kHV));
 615                   fAliasNames[i] += sindex;
 616                 }
 617                 else if (i < 2*kScalers+2*kHV+2*kLV)
 618                 {
 619                   fAliasNames[i] = "t00_a_lv_vmon_";
 620                   sindex.Form("%01d",i-(2*kScalers+2*kHV+kLV));
 621                   fAliasNames[i] += sindex;
 622                 }
 623                 else if (i < 2*kScalers+3*kHV+2*kLV)
 624                 {
 625                   fAliasNames[i] = "t00_c_hv_imon_";
 626                   sindex.Form("%02d",i-(2*kScalers+2*kHV+2*kLV));
 627                   fAliasNames[i] += sindex;
 628                 }
 629                 else if (i < 2*kScalers+4*kHV+2*kLV)
 630                 {
 631                   fAliasNames[i] = "t00_c_hv_vmon_";
 632                   sindex.Form("%02d",i-(2*kScalers+3*kHV+2*kLV));
 633                   fAliasNames[i] += sindex;
 634                 }
 635                 else if (i < 2*kScalers+4*kHV+3*kLV)
 636                 {
 637                   fAliasNames[i] = "t00_c_lv_imon_";
 638                   sindex.Form("%01d",i-(2*kScalers+4*kHV+2*kLV));
 639                   fAliasNames[i] += sindex;
 640                 }
 641                 else if (i < 2*kScalers+4*kHV+4*kLV)
 642                 {
 643                   fAliasNames[i] = "t00_c_lv_vmon_";
 644                   sindex.Form("%01d",i-(2*kScalers+4*kHV+3*kLV));
 645                   fAliasNames[i] += sindex;
 646                 }
 647                 else if (i < 2*kScalers+4*kHV+4*kLV+kCFD)
 648                 {
 649                   fAliasNames[i] = "t00_a_cfd_thre_";
 650                   sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV));
 651                   fAliasNames[i] += sindex;
 652                 }
 653                 else if (i < 2*kScalers+4*kHV+4*kLV+2*kCFD)
 654                 {
 655                   fAliasNames[i] = "t00_a_cfd_walk_";
 656                   sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+kCFD));
 657                   fAliasNames[i] += sindex;
 658                 }
 659                   else if (i < 2*kScalers+4*kHV+4*kLV+3*kCFD)
 660                 {
 661                   fAliasNames[i] = "t00_c_cfd_thre_";
 662                   sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+2*kCFD));
 663                   fAliasNames[i] += sindex;
 664                 }
 665                 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD)
 666                 {
 667                   fAliasNames[i] = "t00_c_cfd_walk_";
 668                   sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+3*kCFD));
 669                   fAliasNames[i] += sindex;
 670                 }
 671                 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
 672                 {
 673                   fAliasNames[i] = "t00_ac_trm_";
 674                   sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD));
 675                   fAliasNames[i] += sindex;
 676                 }
 677                  else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
 678                 {
 679                   fAliasNames[i] = "t00_ac_drm_";
 680                   sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM));
 681                   fAliasNames[i] += sindex;
 682                 }
 683                 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+kAtten)
 684                 {
 685                   fAliasNames[i] = "t00_ac_atten";
 686                 }
 687                 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+2*kAtten)
 688                 {
 689                   fAliasNames[i] = "t00_a_mpd_cent";
 690                 }
 691                 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+3*kAtten)
 692                 {
 693                   fAliasNames[i] = "t00_c_mpd_cent";
 694                 }
 695                 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+4*kAtten)
 696                 {
 697                   fAliasNames[i] = "t00_a_mpd_scent";
 698                 }
 699                 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+5*kAtten)
 700                 {
 701                   fAliasNames[i] = "t00_c_mpd_scent";
 702                 }
 703                 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+6*kAtten)
 704                 {
 705                   fAliasNames[i] = "t00_ac_tvdc_top";
 706                 }
 707                 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+7*kAtten)
 708                 {
 709                   fAliasNames[i] = "t00_ac_tvdc_bottom";
 710                 }
 711                 else
 712                 {
 713                   fAliasNames[i] = "t00_ac_mpd_mode";
 714                 }
 715         }
 716
 717 }
 718
 719 //---------------------------------------------------------------
 720 void AliT0DataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
 721 {
 722
 723         int entries=aliasArr->GetEntries();
 724         AliInfo(Form("************ Alias: %s **********",fAliasNames[numAlias].Data()));
 725         AliInfo(Form("          %d DP values collected",entries));
 726
 727 }
 728
 729
 730