X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=T0%2FAliT0DataDCS.cxx;h=d3fbe0b308a886c340329dea5876bf67d2d93667;hb=044113f2d751708c6e4db514098f0ef829125fa6;hp=fe5e787a0604f5a50df4ae440008db130c9f359e;hpb=19682e7d69b3a7d8705b1fd57c05286eaba19fbc;p=u%2Fmrichter%2FAliRoot.git

diff --git a/T0/AliT0DataDCS.cxx b/T0/AliT0DataDCS.cxx
index fe5e787a060..d3fbe0b308a 100644
--- a/T0/AliT0DataDCS.cxx
+++ b/T0/AliT0DataDCS.cxx
@@ -30,12 +30,6 @@ Preliminary test version (T.Malkiewicz)
 
 #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
@@ -63,10 +57,12 @@ AliT0DataDCS::AliT0DataDCS():
 	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++)
   {
@@ -110,10 +106,12 @@ AliT0DataDCS::AliT0DataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime, UInt_t
 	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++)
   {
@@ -244,80 +242,83 @@ AliT0DataDCS::~AliT0DataDCS()
 //---------------------------------------------------------------
 Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
 {
- 	        Int_t t0_scaler[kScalers];
-		Int_t t0_scaler_sec[kScalers];
+  //process DCS data
+
+ 	        UInt_t t0Scaler[kScalers];
+		UInt_t t0ScalerSec[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.;
-		Int_t t0_MPDcentA=0;
-	        Int_t t0_MPDcentC=0;
-	        Int_t t0_MPDsemiCentA=0;
-	        Int_t t0_MPDsemiCentC=0;
-        	Int_t t0_TVDCtop=0;
-	        Int_t t0_TVDCbottom=0;  		
-		Int_t t0_MPDmode=0;
+		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()));
@@ -336,9 +337,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
 		    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)
 		  {
@@ -346,9 +347,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
    	            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)
                   {
@@ -356,9 +357,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     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)
                   {
@@ -366,9 +367,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     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)
                   {
@@ -376,9 +377,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     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)
                   {
@@ -386,9 +387,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     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)
                   {
@@ -396,9 +397,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     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)
                   {
@@ -406,9 +407,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     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)
                   {
@@ -416,9 +417,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     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)
                   {
@@ -426,9 +427,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     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)
                   {
@@ -436,9 +437,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     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)
                   {
@@ -446,9 +447,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     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)
                   {
@@ -456,9 +457,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     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)
                   {
@@ -466,9 +467,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     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)
                   {
@@ -476,9 +477,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     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)
                   {
@@ -486,9 +487,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     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 if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+kAtten)
                   {
@@ -496,9 +497,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
 		    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 = t0_atten / aliasEntr[j];
+                    fAtten = t0atten /((Float_t) aliasEntr[j]);
                   }
 		  else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+2*kAtten)
                   {
@@ -506,9 +507,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     for(Int_t l=0; l<aliasEntr[j]; l++)
                     {
                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
-                      t0_MPDcentA += aValue->GetInt();
+                      t0MPDcentA +=  aValue->GetFloat();
                     }
-                    fMPDcentA = t0_MPDcentA / aliasEntr[j];
+                    fMPDcentA = t0MPDcentA /((Float_t) aliasEntr[j]);
                   }
 		  else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+3*kAtten)
                   {
@@ -516,9 +517,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     for(Int_t l=0; l<aliasEntr[j]; l++)
                     {
                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
-                      t0_MPDcentC += aValue->GetInt();
+                      t0MPDcentC += (Int_t) aValue->GetFloat();
                     }
-                    fMPDcentC = t0_MPDcentC / aliasEntr[j];
+                    fMPDcentC = ((Int_t) t0MPDcentC) /((Int_t) aliasEntr[j]);
                   }
                   else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+4*kAtten)
                   {
@@ -526,9 +527,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     for(Int_t l=0; l<aliasEntr[j]; l++)
                     {
                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
-                      t0_MPDsemiCentA += aValue->GetInt();
+                      t0MPDsemiCentA += (Int_t) aValue->GetFloat();
                     }
-                    fMPDsemiCentA = t0_MPDsemiCentA / aliasEntr[j];
+                    fMPDsemiCentA =  ((Int_t) t0MPDsemiCentA) /((Int_t) aliasEntr[j]);
                   }
 		  else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+5*kAtten)
                   {
@@ -536,9 +537,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     for(Int_t l=0; l<aliasEntr[j]; l++)
                     {
                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
-                      t0_MPDsemiCentC += aValue->GetInt();
+                      t0MPDsemiCentC += (Int_t) aValue->GetFloat();
                     }
-                    fMPDsemiCentC = t0_MPDsemiCentC / aliasEntr[j];
+                    fMPDsemiCentC =  ((Int_t) t0MPDsemiCentC)/ ((Int_t) aliasEntr[j]);
                   }
 		  else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+6*kAtten)
                   {
@@ -546,9 +547,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     for(Int_t l=0; l<aliasEntr[j]; l++)
                     {
                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
-                      t0_TVDCtop += aValue->GetInt();
+                      t0TVDCtop += (Int_t)  aValue->GetFloat();
                     }
-                    fTVDCtop = t0_TVDCtop / 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)
                   {
@@ -556,9 +557,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     for(Int_t l=0; l<aliasEntr[j]; l++)
                     {
                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
-                      t0_TVDCbottom += aValue->GetInt();
+                      t0TVDCbottom += (Int_t) aValue->GetFloat();
                     }
-                    fTVDCbottom = t0_TVDCbottom / aliasEntr[j];
+                    fTVDCbottom = ((Int_t) t0TVDCbottom) /((Int_t) aliasEntr[j]);
                   }
 		  else
                   {
@@ -566,9 +567,9 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
                     for(Int_t l=0; l<aliasEntr[j]; l++)
                     {
                       AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
-                      t0_MPDmode += aValue->GetInt();
+                      t0MPDmode += (Int_t) aValue->GetFloat();
                     }
-                    fMPDmode = t0_MPDmode / aliasEntr[j];
+                    fMPDmode = ((Int_t) t0MPDmode)/((Int_t) aliasEntr[j]);
 		  }
 		}
 	fIsProcessed=kTRUE;
@@ -578,138 +579,140 @@ Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
 //---------------------------------------------------------------
 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("%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_";
+  // 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 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";
+      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";
 	}
+    }
 
 }
 
@@ -724,4 +727,73 @@ void AliT0DataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
 }
 
 
+//---------------------------------------------------------------
+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);   
+}
+