[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() 
{
  delete fScalerMean;
  delete fScalerSecMean;
}

//---------------------------------------------------------------
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]+= aValue->GetUInt();
                    }
		    fScalerSecMean[j] = t0_scaler_sec[j] / 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]+= aValue->GetFloat();
                    }
                    fHViA[j] = t0_a_hv_imon[j] / 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]+= aValue->GetFloat();
                    }
                    fHVvA[j] = t0_a_hv_vmon[j] / 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]+= aValue->GetFloat();
                    }
                    fLViA[j] = t0_a_lv_imon[j] / 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]+= aValue->GetFloat();
                    }
                    fLVvA[j] = t0_a_lv_vmon[j] / 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]+= aValue->GetFloat();
                    }
                    fHViC[j] = t0_c_hv_imon[j] / 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]+= aValue->GetFloat();
                    }
                    fHVvC[j] = t0_c_hv_vmon[j] / 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]+= aValue->GetFloat();
                    }
                    fLViC[j] = t0_c_lv_imon[j] / 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]+= aValue->GetFloat();
                    }
                    fLVvC[j] = t0_c_lv_vmon[j] / 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]+= aValue->GetFloat();
                    }
                    fCFDtA[j] = t0_a_cfd_thre[j] / 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]+= aValue->GetFloat();
                    }
                    fCFDwA[j] = t0_a_cfd_walk[j] / 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]+= aValue->GetFloat();
                    }
                    fCFDtC[j] = t0_c_cfd_thre[j] / 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]+= aValue->GetFloat();
                    }
                    fCFDwC[j] = t0_c_cfd_walk[j] / 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]+= aValue->GetFloat();
                    }
                    fTRM[j] = t0_ac_trm[j] / 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]+= aValue->GetFloat();
                    }
                    fDRM[j] = t0_ac_drm[j] / 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();
                    }
                    fTRM[j] = 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);
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+kHV)
                {
                  fAliasNames[i] = "t00_a_hv_imon_";
                  sindex.Form("%02d",i);
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+2*kHV)
                {
                  fAliasNames[i] = "t00_a_hv_vmon_";
                  sindex.Form("%02d",i);
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+2*kHV+kLV)
                {
                  fAliasNames[i] = "t00_a_lv_imon_";
                  sindex.Form("%02d",i);
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+2*kHV+2*kLV)
                {
                  fAliasNames[i] = "t00_a_lv_vmon_";
                  sindex.Form("%02d",i);
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+3*kHV+2*kLV)
                {
                  fAliasNames[i] = "t00_c_hv_imon_";
                  sindex.Form("%02d",i);
                  fAliasNames[i] += sindex;
                }
                else if (i < 2*kScalers+4*kHV+2*kLV)
                {
                  fAliasNames[i] = "t00_c_hv_vmon_";
                  sindex.Form("%02d",i);
                  fAliasNames[i] += sindex;
                }
                else if (i < 2*kScalers+4*kHV+3*kLV)
                {
                  fAliasNames[i] = "t00_c_lv_imon_";
                  sindex.Form("%02d",i);
                  fAliasNames[i] += sindex;
                }
                else if (i < 2*kScalers+4*kHV+4*kLV)
                {
                  fAliasNames[i] = "t00_c_lv_vmon_";
                  sindex.Form("%02d",i);
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+4*kHV+4*kLV+kCFD)
                {
                  fAliasNames[i] = "t00_a_cfd_thre_";
                  sindex.Form("%02d",i);
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+4*kHV+4*kLV+2*kCFD)
                {
                  fAliasNames[i] = "t00_a_cfd_walk_";
                  sindex.Form("%02d",i);
                  fAliasNames[i] += sindex;
                }
		  else if (i < 2*kScalers+4*kHV+4*kLV+3*kCFD)
                {
                  fAliasNames[i] = "t00_c_cfd_thre_";
                  sindex.Form("%02d",i);
                  fAliasNames[i] += sindex;
                }
                else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD)
                {
                  fAliasNames[i] = "t00_c_cfd_walk_";
                  sindex.Form("%02d",i);
                  fAliasNames[i] += sindex;
                }
		else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
                {
                  fAliasNames[i] = "t00_ac_trm_";
                  sindex.Form("%02d",i);
                  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);
                  fAliasNames[i] += sindex;
                }
		else
		{
                  fAliasNames[i] = "t00_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	{
	215	delete fScalerMean;
	216	delete fScalerSecMean;
dc7ca31d	217	}
	218
	219	//---------------------------------------------------------------
91366e58	220	Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
91366e58	221	{
8eb4ac75	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
970bb0d0	241	TObjArray *aliasArr;
8eb4ac75	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++)
970bb0d0	280	{
8eb4ac75	281	aliasEntr[j]=0;
9dcc11e4	282	for (Int_t k=0;k<32;k++)
	283	{
	284	t0_scaler[k]=0;
8eb4ac75	285	t0_scaler_sec[k]=0;
8eb4ac75	286
9dcc11e4	287	}
9dcc11e4	288	aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
970bb0d0	289	if(!aliasArr)
	290	{
	291	AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
91366e58	292	continue;
970bb0d0	293	}
8eb4ac75	294	Introduce(j, aliasArr);
970bb0d0	295	if(aliasArr->GetEntries()<2)
	296	{
	297	AliError(Form("Alias %s has just %d entries!",
	298	fAliasNames[j].Data(),aliasArr->GetEntries()));
	299	continue;
	300	}
8eb4ac75	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)
970bb0d0	312	{
8eb4ac75	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 < 2kScalers+2kHV)
	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 < 2kScalers+2kHV+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 < 2kScalers+2kHV+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 < 2kScalers+3kHV+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 < 2kScalers+4kHV+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 < 2kScalers+4kHV+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 < 2kScalers+4kHV+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 < 2kScalers+4kHV+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 < 2kScalers+4kHV+4kLV+2kCFD)
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 < 2kScalers+4kHV+4kLV+3kCFD)
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 < 2kScalers+4kHV+4kLV+4kCFD)
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 < 2kScalers+4kHV+4kLV+4kCFD+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 < 2kScalers+4kHV+4kLV+4kCFD+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
970bb0d0	473	}
dc7ca31d	474	fIsProcessed=kTRUE;
9dcc11e4	475	return kTRUE;
dc7ca31d	476	}
	477
	478	//---------------------------------------------------------------
91366e58	479	void AliT0DataDCS::Init()
91366e58	480	{
9dcc11e4	481	TString sindex;
91366e58	482	for(int i=0;i<kNAliases;i++)
8eb4ac75	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 < 2kScalers+2kHV)
	503	{
	504	fAliasNames[i] = "t00_a_hv_vmon_";
	505	sindex.Form("%02d",i);
	506	fAliasNames[i] += sindex;
	507	}
	508	else if (i < 2kScalers+2kHV+kLV)
	509	{
	510	fAliasNames[i] = "t00_a_lv_imon_";
	511	sindex.Form("%02d",i);
	512	fAliasNames[i] += sindex;
	513	}
	514	else if (i < 2kScalers+2kHV+2*kLV)
	515	{
	516	fAliasNames[i] = "t00_a_lv_vmon_";
	517	sindex.Form("%02d",i);
	518	fAliasNames[i] += sindex;
	519	}
	520	else if (i < 2kScalers+3kHV+2*kLV)
	521	{
	522	fAliasNames[i] = "t00_c_hv_imon_";
	523	sindex.Form("%02d",i);
	524	fAliasNames[i] += sindex;
	525	}
	526	else if (i < 2kScalers+4kHV+2*kLV)
	527	{
	528	fAliasNames[i] = "t00_c_hv_vmon_";
	529	sindex.Form("%02d",i);
	530	fAliasNames[i] += sindex;
	531	}
	532	else if (i < 2kScalers+4kHV+3*kLV)
	533	{
	534	fAliasNames[i] = "t00_c_lv_imon_";
	535	sindex.Form("%02d",i);
	536	fAliasNames[i] += sindex;
	537	}
	538	else if (i < 2kScalers+4kHV+4*kLV)
	539	{
	540	fAliasNames[i] = "t00_c_lv_vmon_";
	541	sindex.Form("%02d",i);
	542	fAliasNames[i] += sindex;
	543	}
	544	else if (i < 2kScalers+4kHV+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 < 2kScalers+4kHV+4kLV+2kCFD)
551	{
552	fAliasNames[i] = "t00_a_cfd_walk_";
553	sindex.Form("%02d",i);
554	fAliasNames[i] += sindex;
555	}
556	else if (i < 2kScalers+4kHV+4kLV+3kCFD)
557	{
558	fAliasNames[i] = "t00_c_cfd_thre_";
559	sindex.Form("%02d",i);
560	fAliasNames[i] += sindex;
561	}
562	else if (i < 2kScalers+4kHV+4kLV+4kCFD)
563	{
564	fAliasNames[i] = "t00_c_cfd_walk_";
565	sindex.Form("%02d",i);
566	fAliasNames[i] += sindex;
567	}
568	else if (i < 2kScalers+4kHV+4kLV+4kCFD+kTRM)
569	{
570	fAliasNames[i] = "t00_ac_trm_";
571	sindex.Form("%02d",i);
572	fAliasNames[i] += sindex;
573	}
574	else if (i < 2kScalers+4kHV+4kLV+4kCFD+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
dc7ca31d	585	}
dc7ca31d	586
dc7ca31d	587	}
	588
	589	//---------------------------------------------------------------
8eb4ac75	590	void AliT0DataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
8eb4ac75	591	{
dc7ca31d	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
dc7ca31d	599
91366e58	600