#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
fStartTimeDCSQuery(0),
fEndTimeDCSQuery(0),
fAtten(0.),
+ fMPDcentA(0),
+ fMPDcentC(0),
+ fMPDsemiCentA(0),
+ fMPDsemiCentC(0),
+ fTVDCtop(0),
+ fTVDCbottom(0),
+ fMPDmode(0),
fIsProcessed(kFALSE)
{
+ // default constructor
+ //
for(Int_t i=0;i<kScalers;i++)
{
- fScalerMean[i]=0.;
- fScalerSecMean[i]=0.;
+ fScalerMean[i]=0;
+ fScalerSecMean[i]=0;
}
for(Int_t i=0;i<kHV;i++)
{
{
fDRM[i]=0.;
}
+ for ( Int_t i=0; i<kCFD; i++ )
+ {
+ fCFDtA[i] = 0;
+ fCFDtC[i] = 0;
+ fCFDwA[i] = 0;
+ fCFDwC[i] = 0;
+ }
+
}
//---------------------------------------------------------------
fStartTimeDCSQuery(startTimeDCSQuery),
fEndTimeDCSQuery(endTimeDCSQuery),
fAtten(0.),
+ fMPDcentA(0),
+ fMPDcentC(0),
+ fMPDsemiCentA(0),
+ fMPDsemiCentC(0),
+ fTVDCtop(0),
+ fTVDCbottom(0),
+ fMPDmode(0),
fIsProcessed(kFALSE)
{
+ // constructor
+
for(Int_t i=0;i<kScalers;i++)
{
- fScalerMean[i]=0.;
- fScalerSecMean[i]=0.;
+ fScalerMean[i]=0;
+ fScalerSecMean[i]=0;
}
for(Int_t i=0;i<kHV;i++)
{
fStartTimeDCSQuery(0),
fEndTimeDCSQuery(0),
fAtten(0.),
+ fMPDcentA(0),
+ fMPDcentC(0),
+ fMPDsemiCentA(0),
+ fMPDsemiCentC(0),
+ fTVDCtop(0),
+ fTVDCbottom(0),
+ fMPDmode(0),
fIsProcessed(kFALSE)
{
fEndTimeDCSQuery=data.fEndTimeDCSQuery;
fIsProcessed=data.fIsProcessed;
fAtten=data.fAtten;
-
+ fMPDcentA=data.fMPDcentA;
+ fMPDcentC=data.fMPDcentC;
+ fMPDsemiCentA=data.fMPDsemiCentA;
+ fMPDsemiCentC=data.fMPDsemiCentC;
+ fTVDCtop=data.fTVDCtop;
+ fTVDCbottom=data.fTVDCbottom;
+ fMPDmode=data.fMPDmode;
for(int i=0;i<kNAliases;i++)
{
fAliasNames[i]=data.fAliasNames[i];
{
fDRM[i]=data.fDRM[i];
}
+ for ( Int_t i=0; i<kCFD; i++ )
+ {
+ fCFDtA[i] = data.fCFDtA[i];
+ fCFDtC[i] = data.fCFDtC[i];
+ fCFDwA[i] = data.fCFDwA[i];
+ fCFDwC[i] = data.fCFDwC[i];
+ }
}
//---------------------------------------------------------------
//---------------------------------------------------------------
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.;
+ //process DCS data
+ UInt_t t0Scaler[kScalers];
+ UInt_t t0ScalerSec[kScalers];
+ Int_t aliasEntr[kNAliases];
+ Float_t t0AhvImon[kHV];
+ Float_t t0AHVvmon[kHV];
+ Float_t t0AlvImon[kLV];
+ Float_t t0AlvVmon[kLV];
+ Float_t t0ChvImon[kHV];
+ Float_t t0ChvVmon[kHV];
+ Float_t t0ClvImon[kLV];
+ Float_t t0ClvVmon[kLV];
+ Float_t t0AcfdThre[kCFD];
+ Float_t t0AcfdWalk[kCFD];
+ Float_t t0CcfdThre[kCFD];
+ Float_t t0CcfdWalk[kCFD];
+ Float_t t0ACtrm[kTRM];
+ Float_t t0ACdrm[kDRM];
+ Float_t t0atten=0.;
+ Int_t t0MPDcentA=0;
+ Int_t t0MPDcentC=0;
+ Int_t t0MPDsemiCentA=0;
+ Int_t t0MPDsemiCentC=0;
+ Int_t t0TVDCtop=0;
+ Int_t t0TVDCbottom=0;
+ Int_t t0MPDmode=0;
+
TObjArray *aliasArr;
for(Int_t k=0; k<kScalers; k++)
{
- t0_scaler[k]=0;
- t0_scaler_sec[k]=0;
+ t0Scaler[k]=0;
+ t0ScalerSec[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.;
+ t0AhvImon[k]=0.;
+ t0AHVvmon[k]=0.;
+ t0ChvImon[k]=0.;
+ t0ChvVmon[k]=0.;
}
- for(Int_t k=0; k<kHV; k++)
+ for(Int_t k=0; k<kLV; 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.;
+ t0AlvImon[k]=0.;
+ t0AlvVmon[k]=0.;
+ t0ClvImon[k]=0.;
+ t0ClvVmon[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.;
+ t0AcfdThre[k]=0.;
+ t0AcfdWalk[k]=0.;
+ t0CcfdThre[k]=0.;
+ t0CcfdWalk[k]=0.;
}
for(Int_t k=0; k<kTRM; k++)
{
- t0_ac_trm[k]=0.;
+ t0ACtrm[k]=0.;
}
for(Int_t k=0; k<kDRM; k++)
{
- t0_ac_drm[k]=0.;
+ t0ACdrm[k]=0.;
}
-// here starts the main loop
+ // 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;
+ t0Scaler[k]=0;
+ t0ScalerSec[k]=0;
}
aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
+
if(!aliasArr)
{
AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
for(Int_t l=0; l<aliasEntr[j]; l++)
{
AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
- t0_scaler[j]+= aValue->GetUInt();
+ t0Scaler[j]+= (UInt_t) aValue->GetFloat();
}
- fScalerMean[j] = t0_scaler[j] / aliasEntr[j];
+ fScalerMean[j] = ((UInt_t) t0Scaler[j])/((UInt_t) aliasEntr[j]);
}
else if (j < 2*kScalers)
{
for(Int_t l=0; l<aliasEntr[j]; l++)
{
AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
- t0_scaler_sec[j-kScalers]+= aValue->GetUInt();
+ t0ScalerSec[j-kScalers]+= (UInt_t) aValue->GetFloat();
}
- fScalerSecMean[j-kScalers] = t0_scaler_sec[j-kScalers] / aliasEntr[j];
+ fScalerSecMean[j-kScalers] = ((UInt_t) t0ScalerSec[j-kScalers])/((UInt_t) aliasEntr[j]);
}
else if (j < 2*kScalers+kHV)
{
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();
+ t0AhvImon[j-2*kScalers]+= aValue->GetFloat();
}
- fHViA[j-2*kScalers] = t0_a_hv_imon[j-2*kScalers] / aliasEntr[j];
+ fHViA[j-2*kScalers] = t0AhvImon[j-2*kScalers] / aliasEntr[j];
}
else if (j < 2*kScalers+2*kHV)
{
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();
+ t0AHVvmon[j-(2*kScalers+kHV)]+= aValue->GetFloat();
}
- fHVvA[j-(2*kScalers+kHV)] = t0_a_hv_vmon[j-(2*kScalers+kHV)] / aliasEntr[j];
+ fHVvA[j-(2*kScalers+kHV)] = t0AHVvmon[j-(2*kScalers+kHV)] / aliasEntr[j];
}
else if (j < 2*kScalers+2*kHV+kLV)
{
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();
+ t0AlvImon[j-(2*kScalers+2*kHV)]+= aValue->GetFloat();
}
- fLViA[j-(2*kScalers+2*kHV)] = t0_a_lv_imon[j-(2*kScalers+2*kHV)] / aliasEntr[j];
+ fLViA[j-(2*kScalers+2*kHV)] = t0AlvImon[j-(2*kScalers+2*kHV)] / aliasEntr[j];
}
else if (j < 2*kScalers+2*kHV+2*kLV)
{
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();
+ t0AlvVmon[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];
+ fLVvA[j-(2*kScalers+2*kHV+kLV)] = t0AlvVmon[j-(2*kScalers+2*kHV+kLV)] / aliasEntr[j];
}
else if (j < 2*kScalers+3*kHV+2*kLV)
{
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();
+ t0ChvImon[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];
+ fHViC[j-(2*kScalers+2*kHV+2*kLV)] = t0ChvImon[j-(2*kScalers+2*kHV+2*kLV)] / aliasEntr[j];
}
else if (j < 2*kScalers+4*kHV+2*kLV)
{
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();
+ t0ChvVmon[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];
+ fHVvC[j-(2*kScalers+3*kHV+2*kLV)] = t0ChvVmon[j-(2*kScalers+3*kHV+2*kLV)] / aliasEntr[j];
}
else if (j < 2*kScalers+4*kHV+3*kLV)
{
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();
+ t0ClvImon[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];
+ fLViC[j-(2*kScalers+4*kHV+2*kLV)] = t0ClvImon[j-(2*kScalers+4*kHV+2*kLV)] / aliasEntr[j];
}
else if (j < 2*kScalers+4*kHV+4*kLV)
{
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();
+ t0ClvVmon[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];
+ fLVvC[j-(2*kScalers+4*kHV+3*kLV)] = t0ClvVmon[j-(2*kScalers+4*kHV+3*kLV)] / aliasEntr[j];
}
else if (j < 2*kScalers+4*kHV+4*kLV+kCFD)
{
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();
+ t0AcfdThre[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];
+ fCFDtA[j-(2*kScalers+4*kHV+4*kLV)] = t0AcfdThre[j-(2*kScalers+4*kHV+4*kLV)] / aliasEntr[j];
}
else if (j < 2*kScalers+4*kHV+4*kLV+2*kCFD)
{
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();
+ t0AcfdWalk[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];
+ fCFDwA[j-(2*kScalers+4*kHV+4*kLV+kCFD)] = t0AcfdWalk[j-(2*kScalers+4*kHV+4*kLV+kCFD)] / aliasEntr[j];
}
else if (j < 2*kScalers+4*kHV+4*kLV+3*kCFD)
{
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();
+ t0CcfdThre[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];
+ fCFDtC[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)] = t0CcfdThre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)] / aliasEntr[j];
}
else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD)
{
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();
+ t0CcfdWalk[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];
+ fCFDwC[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)] = t0CcfdWalk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)] / aliasEntr[j];
}
else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
{
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();
+ t0ACtrm[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];
+ fTRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] = t0ACtrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] / aliasEntr[j];
}
else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
{
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();
+ t0ACdrm[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];
+ fDRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)] = t0ACdrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)] / aliasEntr[j];
}
- else
+ else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+kAtten)
{
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();
+ t0atten += aValue->GetFloat();
+ }
+ fAtten = t0atten /((Float_t) aliasEntr[j]);
+ }
+ else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+2*kAtten)
+ {
+ aliasEntr[j] = aliasArr->GetEntries();
+ for(Int_t l=0; l<aliasEntr[j]; l++)
+ {
+ AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
+ t0MPDcentA += Int_t(aValue->GetFloat());
+ }
+ if(aliasEntr[j]!=0)
+ fMPDcentA = t0MPDcentA / aliasEntr[j];
+ }
+ else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+3*kAtten)
+ {
+ aliasEntr[j] = aliasArr->GetEntries();
+ for(Int_t l=0; l<aliasEntr[j]; l++)
+ {
+ AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
+ t0MPDcentC += (Int_t) aValue->GetFloat();
+ }
+ fMPDcentC = ((Int_t) t0MPDcentC) /((Int_t) aliasEntr[j]);
+ }
+ else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+4*kAtten)
+ {
+ aliasEntr[j] = aliasArr->GetEntries();
+ for(Int_t l=0; l<aliasEntr[j]; l++)
+ {
+ AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
+ t0MPDsemiCentA += (Int_t) aValue->GetFloat();
+ }
+ fMPDsemiCentA = ((Int_t) t0MPDsemiCentA) /((Int_t) aliasEntr[j]);
+ }
+ else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+5*kAtten)
+ {
+ aliasEntr[j] = aliasArr->GetEntries();
+ for(Int_t l=0; l<aliasEntr[j]; l++)
+ {
+ AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
+ t0MPDsemiCentC += (Int_t) aValue->GetFloat();
+ }
+ fMPDsemiCentC = ((Int_t) t0MPDsemiCentC)/ ((Int_t) aliasEntr[j]);
+ }
+ else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+6*kAtten)
+ {
+ aliasEntr[j] = aliasArr->GetEntries();
+ for(Int_t l=0; l<aliasEntr[j]; l++)
+ {
+ AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
+ t0TVDCtop += (Int_t) aValue->GetFloat();
}
- fAtten = t0_atten / aliasEntr[j];
+ fTVDCtop = ((Int_t) t0TVDCtop)/((Int_t) aliasEntr[j]);
}
+ else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+7*kAtten)
+ {
+ aliasEntr[j] = aliasArr->GetEntries();
+ for(Int_t l=0; l<aliasEntr[j]; l++)
+ {
+ AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
+ t0TVDCbottom += (Int_t) aValue->GetFloat();
+ }
+ fTVDCbottom = ((Int_t) t0TVDCbottom) /((Int_t) aliasEntr[j]);
+ }
+ else
+ {
+ aliasEntr[j] = aliasArr->GetEntries();
+ for(Int_t l=0; l<aliasEntr[j]; l++)
+ {
+ AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
+ t0MPDmode += (Int_t) aValue->GetFloat();
+ }
+ fMPDmode = ((Int_t) t0MPDmode)/((Int_t) 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_";
+ // initialize all DP aliases
+
+ 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("%01d",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("%01d",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("%01d",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("%01d",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)
+ }
+ 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";
+ 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 if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+kAtten)
+ {
+ fAliasNames[i] = "t00_ac_atten";
+ }
+ else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+2*kAtten)
+ {
+ fAliasNames[i] = "t00_a_mpd_cent";
+ }
+ else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+3*kAtten)
+ {
+ fAliasNames[i] = "t00_c_mpd_cent";
+ }
+ else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+4*kAtten)
+ {
+ fAliasNames[i] = "t00_a_mpd_scent";
}
-
+ else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+5*kAtten)
+ {
+ fAliasNames[i] = "t00_c_mpd_scent";
}
+ else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+6*kAtten)
+ {
+ fAliasNames[i] = "t00_ac_tvdc_top";
+ }
+ else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+7*kAtten)
+ {
+ fAliasNames[i] = "t00_ac_tvdc_bottom";
+ }
+ else
+ {
+ fAliasNames[i] = "t00_ac_mpd_mode";
+ }
+ }
}
}
+//---------------------------------------------------------------
+void AliT0DataDCS::PrintfArray(const char *label, const Float_t *array, Int_t numElements) const
+{
+ //print all elements of array
+ printf("%s: \n",label);
+ for(Int_t i=0;i<numElements;i++){
+ printf(" %.2f", array[i]);
+ }
+ printf("\n");
+}
+//---------------------------------------------------------------
+
+void AliT0DataDCS::PrintT0Data() const
+{
+ //print DP values
+
+ printf("AliT0DataDCS::Print()\n");
+ printf("RUN: %d\n", fRun);
+ printf("START TIME: %d\n", fStartTime);
+ printf("END TIME: %d\n", fEndTime);
+ printf("StartTimeDCSQuery: %d\n", fStartTimeDCSQuery);
+ printf("EndTimeDCSQuery: %d\n", fEndTimeDCSQuery);
+
+ PrintfArray("HV A side current", fHViA, kHV);
+ PrintfArray("HV A side voltage", fHVvA, kHV);
+ PrintfArray("LV A side current", fLViA, kLV);
+ PrintfArray("LV A side voltage", fLVvA, kLV);
+ PrintfArray("HV C side current", fHViC, kHV);
+ PrintfArray("HV C side voltage", fHVvC, kHV);
+ PrintfArray("LV C side current", fLViC, kLV);
+ PrintfArray("LV C side voltage", fLVvC, kLV);
+
+ PrintfArray("CFD threshold A side", fCFDtA, kCFD);
+ PrintfArray("CFD walk A side", fCFDwA, kCFD);
+ PrintfArray("CFD threshold C side", fCFDtC, kCFD);
+ PrintfArray("CFD walk C side", fCFDwC, kCFD);
+
+ //PrintfArray("SCALERS", (Float_t*) fScalerMean, kScalers);
+ printf("SCALERS: \n");
+ for(Int_t i=0;i<kScalers;i++){
+ printf(" %d", fScalerMean[i]);
+ }
+ printf("\n");
+
+
+ // PrintfArray("SCALERS per second",(Float_t*) fScalerSecMean, kScalers);
+ printf("SCALERS per second: \n");
+ for(Int_t i=0;i<kScalers;i++){
+ printf(" %d", fScalerSecMean[i]);
+ }
+ printf("\n");
+
+
+
+
+ PrintfArray("TRM", fTRM, kTRM);
+ PrintfArray("DRM", fDRM, kDRM);
+
+ printf("Laser Amplitude: %f\n", fAtten);
+ printf("mult. discrim. central A side: %d\n", fMPDcentA);
+ printf("mult. discrim. central C side: %d\n", fMPDcentC);
+ printf("mult. discrim. semi-central A side: %d\n", fMPDsemiCentA);
+ printf("mult. discrim. semi-central C side: %d\n", fMPDsemiCentC);
+
+ printf("TVDC top: %d\n", fTVDCtop);
+ printf("TVDC bottom: %d\n", fTVDCbottom);
+ printf("MPDmode: %d\n", fMPDmode);
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff