Coding viloations fixed.
authorcvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 26 Jan 2010 12:56:16 +0000 (12:56 +0000)
committercvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 26 Jan 2010 12:56:16 +0000 (12:56 +0000)
VZERO/AliVZEROCalibData.cxx
VZERO/AliVZEROCalibData.h

index 9bd61de..713a0c5 100644 (file)
@@ -27,6 +27,8 @@
 
 #include "AliDCSValue.h"
 #include "AliVZEROCalibData.h"
+#include "AliVZERODataDCS.h"
+#include "AliLog.h"
 
 ClassImp(AliVZEROCalibData)
 
@@ -65,6 +67,7 @@ void AliVZEROCalibData::Reset()
 //________________________________________________________________
 AliVZEROCalibData::AliVZEROCalibData(const char* name)
 {
+  // Constructor
    TString namst = "Calib_";
    namst += name;
    SetName(namst.Data());
@@ -195,70 +198,70 @@ void AliVZEROCalibData::SetParameter(TString name, Int_t val){
 }
 
 //________________________________________________________________
-void AliVZEROCalibData::SetPedestal(Float_t* Pedestal)
+void AliVZEROCalibData::SetPedestal(const Float_t* Pedestal)
 {
   if(Pedestal) for(int t=0; t<128; t++) fPedestal[t] = Pedestal[t];
   else for(int t=0; t<128; t++) fPedestal[t] = 0.0;
 }
 
 //________________________________________________________________
-void AliVZEROCalibData::SetSigma(Float_t* Sigma)
+void AliVZEROCalibData::SetSigma(const Float_t* Sigma)
 {
   if(Sigma) for(int t=0; t<128; t++) fSigma[t] = Sigma[t];
   else for(int t=0; t<128; t++) fSigma[t] = 0.0;
 }
 
 //________________________________________________________________
-void AliVZEROCalibData::SetADCmean(Float_t* ADCmean) 
+void AliVZEROCalibData::SetADCmean(const Float_t* ADCmean) 
 {
   if(ADCmean) for(int t=0; t<128; t++) fADCmean[t] = ADCmean[t];
   else for(int t=0; t<128; t++) fADCmean[t] = 0.0;
 }
 
 //________________________________________________________________
-void AliVZEROCalibData::SetADCsigma(Float_t* ADCsigma) 
+void AliVZEROCalibData::SetADCsigma(const Float_t* ADCsigma) 
 {
   if(ADCsigma) for(int t=0; t<128; t++) fADCsigma[t] = ADCsigma[t];
   else for(int t=0; t<128; t++) fADCsigma[t] = 0.0;
 }
 
 //________________________________________________________________
-void AliVZEROCalibData::SetMeanHV(Float_t* MeanHV) 
+void AliVZEROCalibData::SetMeanHV(const Float_t* MeanHV) 
 {
   if(MeanHV) for(int t=0; t<64; t++) fMeanHV[t] = MeanHV[t];
   else for(int t=0; t<64; t++) fMeanHV[t] = 0.0;
 }
 
 //________________________________________________________________
-void AliVZEROCalibData::SetWidthHV(Float_t* WidthHV) 
+void AliVZEROCalibData::SetWidthHV(const Float_t* WidthHV) 
 {
   if(WidthHV) for(int t=0; t<64; t++) fWidthHV[t] = WidthHV[t];
   else for(int t=0; t<64; t++) fWidthHV[t] = 0.0;
 }
 
 //________________________________________________________________
-void AliVZEROCalibData::SetDeadMap(Bool_t* deadMap) 
+void AliVZEROCalibData::SetDeadMap(const Bool_t* deadMap) 
 {
   if(deadMap) for(int t=0; t<64; t++) fDeadChannel[t] = deadMap[t];
   else for(int t=0; t<64; t++) fDeadChannel[t] = kFALSE;
 }
 
 //________________________________________________________________
-void AliVZEROCalibData::SetGain(Float_t* Gain) 
+void AliVZEROCalibData::SetGain(const Float_t* Gain) 
 {
   if(Gain) for(int t=0; t<128; t++) fGain[t] = Gain[t];
   else for(int t=0; t<128; t++) fGain[t] = 0.0;
 }
 
 //________________________________________________________________
-void AliVZEROCalibData::SetTimeOffset(Float_t* TimeOffset) 
+void AliVZEROCalibData::SetTimeOffset(const Float_t* TimeOffset) 
 {
   if(TimeOffset) for(int t=0; t<64; t++) fTimeOffset[t] = TimeOffset[t];
   else for(int t=0; t<64; t++) fTimeOffset[t] = 0.0;
 }
 
 //________________________________________________________________
-void AliVZEROCalibData::SetTimeGain(Float_t* TimeGain) 
+void AliVZEROCalibData::SetTimeGain(const Float_t* TimeGain) 
 {
   if(TimeGain) for(int t=0; t<64; t++) fTimeGain[t] = TimeGain[t];
   else for(int t=0; t<64; t++) fTimeGain[t] = 0.0;
@@ -270,7 +273,7 @@ Float_t AliVZEROCalibData::GetMIPperADC(Int_t channel) const {
        // Computes the MIP conversion factor - MIP per ADC channel - 
        // Argument passed is the PM number (aliroot numbering)
        
-       Float_t P0[64] = {
+       Float_t p0[64] = {
                7.094891, 7.124938, 7.089708, 7.098169, 7.094482, 7.147250, 7.170978, 7.183392, 
                7.145760, 7.148096, 7.153840, 7.143544, 7.186069, 7.194580, 7.203516, 7.195176, 
                7.188333, 7.198607, 7.209412, 7.226565, 7.221695, 7.205132, 7.191238, 7.227724, 
@@ -279,7 +282,7 @@ Float_t AliVZEROCalibData::GetMIPperADC(Int_t channel) const {
                7.024667, 7.124784, 7.123442, 7.129744, 7.110671, 7.143031, 7.139439, 7.178109, 
                7.247803, 7.139396, 7.293809, 7.094454, 6.992198, 7.206448, 7.244765, 7.056197, 
                7.263595, 7.138569, 7.089582, 7.215683, 7.266183, 7.165123, 7.243276, 7.235135 };
-       Float_t P1[64] = {
+       Float_t p1[64] = {
                0.135569, 0.146405, 0.142425, 0.144278, 0.142307, 0.141648, 0.128477, 0.138239, 
                0.144173, 0.143419, 0.143572, 0.144482, 0.138024, 0.136542, 0.135955, 0.138537, 
                0.148521, 0.141999, 0.139627, 0.130014, 0.134970, 0.135635, 0.139094, 0.140634, 
@@ -290,11 +293,11 @@ Float_t AliVZEROCalibData::GetMIPperADC(Int_t channel) const {
                0.146489, 0.143279, 0.145230, 0.147203, 0.147333, 0.144979, 0.148597, 0.138985 };
        
        // High Voltage retrieval from Calibration Data Base:  
-       Float_t  HV = fMeanHV[channel];  
-       Float_t MIP = -1;
-       if (HV>0)
-         MIP = 0.6/TMath::Exp((TMath::Log(HV) - P0[channel] )/P1[channel]);
-       return MIP; 
+       Float_t  hv = fMeanHV[channel];  
+       Float_t mip = -1;
+       if (hv>0)
+         mip = 0.6/TMath::Exp((TMath::Log(hv) - p0[channel] )/p1[channel]);
+       return mip; 
        
 }
 //________________________________________________________________
index 0663eeb..f2fbe85 100644 (file)
@@ -11,8 +11,8 @@
 ////////////////////////////////////////////////
 
 #include "TNamed.h"
-#include "AliVZERO.h"
-#include "AliVZERODataDCS.h"
+
+class AliVZERODataDCS;
 
 class AliVZEROCalibData: public TNamed {
 
@@ -56,26 +56,26 @@ class AliVZEROCalibData: public TNamed {
   Float_t  GetWidthResolution(Int_t board ) const  {return ((board>=0 && board<kNCIUBoards)?fWidthResolution[board]:0);};
     
   void     SetPedestal(Float_t val, Int_t channel) {fPedestal[channel]=val;}
-  void     SetPedestal(Float_t* Pedestal);
+  void     SetPedestal(const Float_t* Pedestal);
   void     SetSigma(Float_t val, Int_t channel) {fSigma[channel]=val;}
-  void     SetSigma(Float_t* Sigma);
+  void     SetSigma(const Float_t* Sigma);
   void            SetADCmean(Float_t val, Int_t channel) {fADCmean[channel]=val;}
-  void            SetADCmean(Float_t* ADCmean);  
+  void            SetADCmean(const Float_t* ADCmean);  
   void            SetADCsigma(Float_t val, Int_t channel) {fADCsigma[channel]=val;}
-  void            SetADCsigma(Float_t* ADCsigma);
+  void            SetADCsigma(const Float_t* ADCsigma);
   void     SetMeanHV(Float_t val, Int_t channel) {fMeanHV[channel]=val;}
-  void     SetMeanHV(Float_t* MeanHV);  
+  void     SetMeanHV(const Float_t* MeanHV);  
   void     SetWidthHV(Float_t val, Int_t channel) {fWidthHV[channel]=val;}
-  void     SetWidthHV(Float_t* WidthHV); 
+  void     SetWidthHV(const Float_t* WidthHV); 
   void     SetDeadChannel(Bool_t val, Int_t channel) {fDeadChannel[channel]=val;}
-  void     SetDeadMap(Bool_t* deadMap);  
+  void     SetDeadMap(const Bool_t* deadMap);  
    
   void            SetGain(Float_t val, Int_t channel) {fGain[channel]=val;}
-  void            SetGain(Float_t* Gain);  
+  void            SetGain(const Float_t* Gain);  
   void     SetTimeOffset(Float_t val, Int_t channel) {fTimeOffset[channel]=val;}
-  void     SetTimeOffset(Float_t* TimeOffset);
+  void     SetTimeOffset(const Float_t* TimeOffset);
   void     SetTimeGain(Float_t val, Int_t channel) {fTimeGain[channel]=val;}
-  void     SetTimeGain(Float_t* TimeGain);
+  void     SetTimeGain(const Float_t* TimeGain);
   
   void            SetParameter(TString name, Int_t val);
   void     SetTimeResolution(UShort_t *resols);
@@ -94,9 +94,9 @@ class AliVZEROCalibData: public TNamed {
   Float_t  fWidthHV[64];       // Width of the PMT HV
   
   Float_t  fGain[128];        // Gain factor used in digitization only  
-  Float_t  fTimeOffset[64];
-  Float_t  fTimeGain[64];
-  Bool_t   fDeadChannel[64];
+  Float_t  fTimeOffset[64];    // Time offsets of the TDC
+  Float_t  fTimeGain[64];      // Gain factors of the TDC
+  Bool_t   fDeadChannel[64];   // List of dead channels
   Float_t  fTimeResolution[kNCIUBoards]; // Time Resolution of the TDC (ns / channel)
   Float_t  fWidthResolution[kNCIUBoards]; // Time Width Resolution of the TDC (ns / channel)