[u/mrichter/AliRoot.git] / T0 / AliT0DataDCS.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *  
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/*
$Log: AliT0DataDCS.cxx,v $
 Revision   2008/01/30 
Fetching data points from DCS, calculating mean and storing data to Reference DB 
 
 Version 1.1  2006/10
Preliminary test version (T.Malkiewicz)
*/

#include "AliT0DataDCS.h"

#include "AliCDBMetaData.h"
#include "AliDCSValue.h"
#include "AliLog.h"

#include <TTimeStamp.h>
#include <TObjString.h>
#include <TH2F.h>
#include <TProfile.h>
#include <TGraph.h>
#include <TDatime.h>
#include <TStyle.h>
#include <TCanvas.h>

// AliT0DataDCS class
// declaring DCS aliases for T0
// fetching T0 data points from DCS, 
// calculating mean values for the entire run
// and storing the result to Reference DB

ClassImp(AliT0DataDCS)

//---------------------------------------------------------------
AliT0DataDCS::AliT0DataDCS():
	TObject(),
	fRun(0),	
	fStartTime(0),
	fEndTime(0),
	fStartTimeDCSQuery(0),
	fEndTimeDCSQuery(0),
	fAtten(0.),
	fIsProcessed(kFALSE)
{
  for(Int_t i=0;i<kScalers;i++) 
  {
    fScalerMean[i]=0.;
    fScalerSecMean[i]=0.;
  }
  for(Int_t i=0;i<kHV;i++)
  {
    fHViA[i]=0.;
    fHVvA[i]=0.;
    fHViC[i]=0.;
    fHVvC[i]=0.;
  }
  for(Int_t i=0;i<kLV;i++)
  {
    fLViA[i]=0.;
    fLVvA[i]=0.;
    fLViC[i]=0.;
    fLVvC[i]=0.;
  }
  for(Int_t i=0;i<kTRM;i++)
  {
    fTRM[i]=0.;
  }
  for(Int_t i=0;i<kDRM;i++)
  {
    fDRM[i]=0.;
  }

}
//---------------------------------------------------------------
AliT0DataDCS::AliT0DataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime, UInt_t startTimeDCSQuery, UInt_t endTimeDCSQuery):
	TObject(),
	fRun(nRun),
	fStartTime(startTime),
	fEndTime(endTime),
	fStartTimeDCSQuery(startTimeDCSQuery),
	fEndTimeDCSQuery(endTimeDCSQuery),
	fAtten(0.),
	fIsProcessed(kFALSE)
{
  for(Int_t i=0;i<kScalers;i++)
  {
    fScalerMean[i]=0.;
    fScalerSecMean[i]=0.;
  }
  for(Int_t i=0;i<kHV;i++)
  {
    fHViA[i]=0.;
    fHVvA[i]=0.;
    fHViC[i]=0.;
    fHVvC[i]=0.;
  }
  for(Int_t i=0;i<kLV;i++)
  {
    fLViA[i]=0.;
    fLVvA[i]=0.;
    fLViC[i]=0.;
    fLVvC[i]=0.;
  }
  for(Int_t i=0;i<kTRM;i++)
  {
    fTRM[i]=0.;
  }
  for(Int_t i=0;i<kDRM;i++)
  {
    fDRM[i]=0.;
  }

	AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s \n\tStartTime DCS Query %s \n\tEndTime DCS Query %s", nRun,
	TTimeStamp(startTime).AsString(),
	TTimeStamp(endTime).AsString(),
	TTimeStamp(startTimeDCSQuery).AsString(), 
        TTimeStamp(endTimeDCSQuery).AsString()));

	Init();

}
//---------------------------------------------------------------

AliT0DataDCS::AliT0DataDCS(const AliT0DataDCS & data):
  TObject(), 
  fRun(0),
  fStartTime(0),
  fEndTime(0),
  fStartTimeDCSQuery(0),
  fEndTimeDCSQuery(0),
  fAtten(0.),
  fIsProcessed(kFALSE)
{

// copy constructor

  fRun=data.fRun;
  fStartTime=data.fStartTime;
  fEndTime=data.fEndTime;
  fStartTimeDCSQuery=data.fStartTimeDCSQuery;
  fEndTimeDCSQuery=data.fEndTimeDCSQuery;
  fIsProcessed=data.fIsProcessed;
  fAtten=data.fAtten;

  for(int i=0;i<kNAliases;i++) 
  {
    fAliasNames[i]=data.fAliasNames[i];
  }
  
  for(Int_t i=0;i<kScalers;i++)
  {
    fScalerMean[i]=data.fScalerMean[i];
    fScalerSecMean[i]=data.fScalerSecMean[i];
  }
  for(Int_t i=0;i<kHV;i++)
  {
    fHViA[i]=data.fHViA[i];
    fHVvA[i]=data.fHVvA[i];
    fHViC[i]=data.fHViC[i];
    fHVvC[i]=data.fHVvC[i];
  }
  for(Int_t i=0;i<kLV;i++)
  {
    fLViA[i]=data.fLViA[i];
    fLVvA[i]=data.fLVvA[i];
    fLViC[i]=data.fLViC[i];
    fLVvC[i]=data.fLVvC[i];
  }
  for(Int_t i=0;i<kTRM;i++)
  {
    fTRM[i]=data.fTRM[i];
  }
  for(Int_t i=0;i<kDRM;i++)
  {
    fDRM[i]=data.fDRM[i];
  }
}
//---------------------------------------------------------------

AliT0DataDCS& AliT0DataDCS:: operator=(const AliT0DataDCS & data) { 

// assignment operator

  this->fRun=data.fRun;
  this->fStartTime=data.fStartTime;
  this->fEndTime=data.fEndTime;
  this->fStartTimeDCSQuery=data.fStartTimeDCSQuery;
  this->fEndTimeDCSQuery=data.fEndTimeDCSQuery;

  for(int i=0;i<kNAliases;i++)
  {
    this->fAliasNames[i]=data.fAliasNames[i];
  }

  return *this;
}

//---------------------------------------------------------------
AliT0DataDCS::~AliT0DataDCS() 
{
}

//---------------------------------------------------------------
Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
{
 	        Int_t t0_scaler[kScalers];
		Int_t t0_scaler_sec[kScalers];
		Int_t aliasEntr[kNAliases];
		Float_t t0_a_hv_imon[kHV];
		Float_t t0_a_hv_vmon[kHV];
		Float_t t0_a_lv_imon[kLV];
                Float_t t0_a_lv_vmon[kLV];
                Float_t t0_c_hv_imon[kHV];
                Float_t t0_c_hv_vmon[kHV];
                Float_t t0_c_lv_imon[kLV];
                Float_t t0_c_lv_vmon[kLV];
		Float_t t0_a_cfd_thre[kCFD];
                Float_t t0_a_cfd_walk[kCFD];
                Float_t t0_c_cfd_thre[kCFD];
                Float_t t0_c_cfd_walk[kCFD];
                Float_t t0_ac_trm[kTRM];
                Float_t t0_ac_drm[kDRM];
		Float_t t0_atten=0.;

		TObjArray *aliasArr;
        	for(Int_t k=0; k<kScalers; k++)
		{
		   t0_scaler[k]=0;
                   t0_scaler_sec[k]=0;
		}

		for(Int_t k=0; k<kHV; k++)
                {
                   t0_a_hv_imon[k]=0.;
                   t0_a_hv_vmon[k]=0.;
		   t0_c_hv_imon[k]=0.;
                   t0_c_hv_vmon[k]=0.;
                }
		for(Int_t k=0; k<kHV; k++)
                {
                   t0_a_lv_imon[k]=0.;
                   t0_a_lv_vmon[k]=0.;
                   t0_c_lv_imon[k]=0.;
                   t0_c_lv_vmon[k]=0.;
                }
		for(Int_t k=0; k<kCFD; k++)
                {
                   t0_a_cfd_thre[k]=0.;
                   t0_a_cfd_walk[k]=0.;
 		   t0_c_cfd_thre[k]=0.;
                   t0_c_cfd_walk[k]=0.;
                }
		for(Int_t k=0; k<kTRM; k++)
                {
                   t0_ac_trm[k]=0.;
		}
		for(Int_t k=0; k<kDRM; k++)
                {
                   t0_ac_drm[k]=0.;
                }

// here starts the main loop
		for(Int_t j=0; j<kNAliases; j++)
        	{
		  aliasEntr[j]=0;
		  for (Int_t k=0;k<32;k++) 
		  {
		    t0_scaler[k]=0;
		    t0_scaler_sec[k]=0;	
		    
      		  }
		  aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
                  if(!aliasArr)
                  {
                        AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
                        continue;
                  }
		  Introduce(j, aliasArr);
                  if(aliasArr->GetEntries()<2)
                  {
                        AliError(Form("Alias %s has just %d entries!",
                                        fAliasNames[j].Data(),aliasArr->GetEntries()));
                        continue;
                  }
		  if (j < kScalers)
		  { 
		    aliasEntr[j] = aliasArr->GetEntries();
		    for(Int_t l=0; l<aliasEntr[j]; l++)
		    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
		      t0_scaler[j]+= aValue->GetUInt();
	            }
		    fScalerMean[j] = t0_scaler[j] / aliasEntr[j];
		  }
		  else if (j < 2*kScalers)
		  {
		    aliasEntr[j] = aliasArr->GetEntries();		
   	            for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_scaler_sec[j-kScalers]+= aValue->GetUInt();
                    }
		    fScalerSecMean[j-kScalers] = t0_scaler_sec[j-kScalers] / aliasEntr[j];
		  }
		  else if (j < 2*kScalers+kHV)
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
                    for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_a_hv_imon[j-2*kScalers]+= aValue->GetFloat();
                    }
                    fHViA[j-2*kScalers] = t0_a_hv_imon[j-2*kScalers] / aliasEntr[j];
                  }
		  else if (j < 2*kScalers+2*kHV)
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
                    for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_a_hv_vmon[j-(2*kScalers+kHV)]+= aValue->GetFloat();
                    }
                    fHVvA[j-(2*kScalers+kHV)] = t0_a_hv_vmon[j-(2*kScalers+kHV)] / aliasEntr[j];
                  }
		  else if (j < 2*kScalers+2*kHV+kLV)
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
                    for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_a_lv_imon[j-(2*kScalers+2*kHV)]+= aValue->GetFloat();
                    }
                    fLViA[j-(2*kScalers+2*kHV)] = t0_a_lv_imon[j-(2*kScalers+2*kHV)] / aliasEntr[j];
                  }
		  else if (j < 2*kScalers+2*kHV+2*kLV)
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
                    for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_a_lv_vmon[j-(2*kScalers+2*kHV+kLV)]+= aValue->GetFloat();
                    }
                    fLVvA[j-(2*kScalers+2*kHV+kLV)] = t0_a_lv_vmon[j-(2*kScalers+2*kHV+kLV)] / aliasEntr[j];
                  }
                  else if (j < 2*kScalers+3*kHV+2*kLV)
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
                    for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_c_hv_imon[j-(2*kScalers+2*kHV+2*kLV)]+= aValue->GetFloat();
                    }
                    fHViC[j-(2*kScalers+2*kHV+2*kLV)] = t0_c_hv_imon[j-(2*kScalers+2*kHV+2*kLV)] / aliasEntr[j];
                  }
                  else if (j < 2*kScalers+4*kHV+2*kLV)
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
                    for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_c_hv_vmon[j-(2*kScalers+3*kHV+2*kLV)]+= aValue->GetFloat();
                    }
                    fHVvC[j-(2*kScalers+3*kHV+2*kLV)] = t0_c_hv_vmon[j-(2*kScalers+3*kHV+2*kLV)] / aliasEntr[j];
                  }
                  else if (j < 2*kScalers+4*kHV+3*kLV)
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
                    for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_c_lv_imon[j-(2*kScalers+4*kHV+2*kLV)]+= aValue->GetFloat();
                    }
                    fLViC[j-(2*kScalers+4*kHV+2*kLV)] = t0_c_lv_imon[j-(2*kScalers+4*kHV+2*kLV)] / aliasEntr[j];
                  }
                  else if (j < 2*kScalers+4*kHV+4*kLV)
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
                    for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_c_lv_vmon[j-(2*kScalers+4*kHV+3*kLV)]+= aValue->GetFloat();
                    }
                    fLVvC[j-(2*kScalers+4*kHV+3*kLV)] = t0_c_lv_vmon[j-(2*kScalers+4*kHV+3*kLV)] / aliasEntr[j];
                  }
		  else if (j < 2*kScalers+4*kHV+4*kLV+kCFD)
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
                    for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_a_cfd_thre[j-(2*kScalers+4*kHV+4*kLV)]+= aValue->GetFloat();
                    }
                    fCFDtA[j-(2*kScalers+4*kHV+4*kLV)] = t0_a_cfd_thre[j-(2*kScalers+4*kHV+4*kLV)] / aliasEntr[j];
                  }
		  else if (j < 2*kScalers+4*kHV+4*kLV+2*kCFD)
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
                    for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_a_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+kCFD)]+= aValue->GetFloat();
                    }
                    fCFDwA[j-(2*kScalers+4*kHV+4*kLV+kCFD)] = t0_a_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+kCFD)] / aliasEntr[j];
                  }
		  else if (j < 2*kScalers+4*kHV+4*kLV+3*kCFD)
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
                    for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_c_cfd_thre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)]+= aValue->GetFloat();
                    }
                    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];
                  }
                  else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD)
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
                    for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_c_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)]+= aValue->GetFloat();
                    }
                    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];
                  }
                  else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
                    for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_ac_trm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)]+= aValue->GetFloat();
                    }
                    fTRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] = t0_ac_trm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] / aliasEntr[j];
                  }
                  else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
                    for(Int_t l=0; l<aliasEntr[j]; l++)
                    {
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_ac_drm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)]+= aValue->GetFloat();
                    }
                    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];
                  }
                  else
                  {
                    aliasEntr[j] = aliasArr->GetEntries();
		    for(Int_t l=0; l<aliasEntr[j]; l++)
		    {		
                      AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
                      t0_atten += aValue->GetInt();
                    }
                    fAtten = t0_atten / aliasEntr[j];
                  }
		}
	fIsProcessed=kTRUE;
	return kTRUE;
}

//---------------------------------------------------------------
void AliT0DataDCS::Init()
{
	TString sindex;
	for(int i=0;i<kNAliases;i++)
	{	
		if (i<kScalers)
		{
		  fAliasNames[i] = "t00_ac_scaler_";
		  sindex.Form("%02d",i);
	          fAliasNames[i] += sindex;
		}
		else if (i < 2*kScalers)
		{
		  fAliasNames[i] = "t00_ac_scaler_sec_";
                  sindex.Form("%02d",i-kScalers);
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+kHV)
                {
                  fAliasNames[i] = "t00_a_hv_imon_";
                  sindex.Form("%02d",i-2*kScalers);
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+2*kHV)
                {
                  fAliasNames[i] = "t00_a_hv_vmon_";
                  sindex.Form("%02d",i-(2*kScalers+kHV));
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+2*kHV+kLV)
                {
                  fAliasNames[i] = "t00_a_lv_imon_";
                  sindex.Form("%02d",i-(2*kScalers+2*kHV));
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+2*kHV+2*kLV)
                {
                  fAliasNames[i] = "t00_a_lv_vmon_";
                  sindex.Form("%02d",i-(2*kScalers+2*kHV+kLV));
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+3*kHV+2*kLV)
                {
                  fAliasNames[i] = "t00_c_hv_imon_";
                  sindex.Form("%02d",i-(2*kScalers+2*kHV+2*kLV));
                  fAliasNames[i] += sindex;
                }
                else if (i < 2*kScalers+4*kHV+2*kLV)
                {
                  fAliasNames[i] = "t00_c_hv_vmon_";
                  sindex.Form("%02d",i-(2*kScalers+3*kHV+2*kLV));
                  fAliasNames[i] += sindex;
                }
                else if (i < 2*kScalers+4*kHV+3*kLV)
                {
                  fAliasNames[i] = "t00_c_lv_imon_";
                  sindex.Form("%02d",i-(2*kScalers+4*kHV+2*kLV));
                  fAliasNames[i] += sindex;
                }
                else if (i < 2*kScalers+4*kHV+4*kLV)
                {
                  fAliasNames[i] = "t00_c_lv_vmon_";
                  sindex.Form("%02d",i-(2*kScalers+4*kHV+3*kLV));
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+4*kHV+4*kLV+kCFD)
                {
                  fAliasNames[i] = "t00_a_cfd_thre_";
                  sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV));
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+4*kHV+4*kLV+2*kCFD)
                {
                  fAliasNames[i] = "t00_a_cfd_walk_";
                  sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+kCFD));
                  fAliasNames[i] += sindex;
                }
		  else if (i < 2*kScalers+4*kHV+4*kLV+3*kCFD)
                {
                  fAliasNames[i] = "t00_c_cfd_thre_";
                  sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+2*kCFD));
                  fAliasNames[i] += sindex;
                }
                else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD)
                {
                  fAliasNames[i] = "t00_c_cfd_walk_";
                  sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+3*kCFD));
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
                {
                  fAliasNames[i] = "t00_ac_trm_";
                  sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD));
                  fAliasNames[i] += sindex;
                }
		 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
                {
                  fAliasNames[i] = "t00_ac_drm_";
                  sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM));
                  fAliasNames[i] += sindex;
                }
		else
		{
                  fAliasNames[i] = "t00_ac_atten";
                }

	}

}

//---------------------------------------------------------------
void AliT0DataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
{

	int entries=aliasArr->GetEntries();
	AliInfo(Form("************ Alias: %s **********",fAliasNames[numAlias].Data()));
	AliInfo(Form("    	%d DP values collected",entries));

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