Added forward declaration
[u/mrichter/AliRoot.git] / ZDC / AliZDCCalibData.h
1 #ifndef ALIZDCCALIBDATA_H
2 #define ALIZDCCALIBDATA_H
3
4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5  * See cxx source for full Copyright notice                               */
6
7 ////////////////////////////////////////////////
8 //  class for ZDC calibration                 //
9 ////////////////////////////////////////////////
10
11 #include "TNamed.h"
12 #include "TH1.h"
13 #include "AliCDBEntry.h"
14
15 class AliZDC;
16
17 class AliZDCCalibData: public TNamed {
18
19  public:
20   AliZDCCalibData();
21   AliZDCCalibData(const char* name);
22   AliZDCCalibData(const AliZDCCalibData &calibda);
23   AliZDCCalibData& operator= (const AliZDCCalibData &calibda);
24   virtual ~AliZDCCalibData();
25   void Reset();
26   virtual void  Print(Option_t *) const; 
27   //
28   Float_t  GetMeanPed(Int_t channel)       const {return fMeanPedestal[channel];}
29   Float_t* GetMeanPed()                    const {return (float*)fMeanPedestal;}
30   Float_t  GetMeanPedWidth(Int_t channel)  const {return fMeanPedWidth[channel];}
31   Float_t* GetMeanPedWidth()               const {return (float*)fMeanPedWidth;}
32   Float_t  GetOOTPed(Int_t channel)        const {return fOOTPedestal[channel];}
33   Float_t* GetOOTPed()                     const {return (float*)fOOTPedestal;}
34   Float_t  GetOOTPedWidth(Int_t channel)   const {return fOOTPedWidth[channel];}
35   Float_t* GetOOTPedWidth()                const {return (float*)fOOTPedWidth;}
36   Float_t  GetPedCorrCoeff0(Int_t channel) const {return fPedCorrCoeff[0][channel];}
37   Float_t  GetPedCorrCoeff1(Int_t channel) const {return fPedCorrCoeff[1][channel];}
38   Float_t* GetPedCorrCoeff()               const {return (float*)fPedCorrCoeff;}
39   //
40   Float_t  GetEnCalib(Int_t channel)    const {return fEnCalibration[channel];}
41   Float_t* GetEnCalib()                 const {return (float*)fEnCalibration;}
42   //
43   Float_t  GetZN1EqualCoeff(Int_t channel) const {return fZN1EqualCoeff[channel];}
44   Float_t* GetZN1EqualCoeffs()             const {return (float*)fZN1EqualCoeff;}
45   Float_t  GetZP1EqualCoeff(Int_t channel) const {return fZP1EqualCoeff[channel];}
46   Float_t* GetZP1EqualCoeffs()             const {return (float*)fZP1EqualCoeff;}
47   Float_t  GetZN2EqualCoeff(Int_t channel) const {return fZN2EqualCoeff[channel];}
48   Float_t* GetZN2EqualCoeffs()             const {return (float*)fZN2EqualCoeff;}
49   Float_t  GetZP2EqualCoeff(Int_t channel) const {return fZP2EqualCoeff[channel];}
50   Float_t* GetZP2EqualCoeffs()             const {return (float*)fZP2EqualCoeff;}
51  
52   //
53   void  SetMeanPed(Int_t channel, Float_t val) {fMeanPedestal[channel]=val;}
54   void  SetMeanPed(Float_t* MeanPed);
55   void  SetMeanPedWidth(Int_t channel, Float_t val) {fMeanPedWidth[channel]=val;}
56   void  SetMeanPedWidth(Float_t* MeanPedWidth);
57   void  SetOOTPed(Int_t channel, Float_t val) {fOOTPedestal[channel]=val;}
58   void  SetOOTPed(Float_t* OOTPed);
59   void  SetOOTPedWidth(Int_t channel, Float_t val) {fOOTPedWidth[channel]=val;}
60   void  SetOOTPedWidth(Float_t* OOTPedWidth);
61   void  SetPedCorrCoeff(Int_t channel, Float_t valCoeff0, Float_t valCoeff1)
62         {fPedCorrCoeff[0][channel]=valCoeff0; fPedCorrCoeff[1][channel]=valCoeff1;}
63   void  SetPedCorrCoeff(Float_t* PedCorrCoeff);
64   void  SetPedCorrCoeff(Float_t* PedCorrCoeff0, Float_t* PedCorrCoeff1);
65   //
66   void  SetEnCalib(Int_t channel, Float_t val) {fEnCalibration[channel]=val;}
67   void  SetEnCalib(Float_t* EnCalib);
68   //
69   void  SetZN1EqualCoeff(Int_t channel, Float_t val) {fZN1EqualCoeff[channel]=val;}
70   void  SetZN1EqualCoeff(Float_t* EqualCoeff);
71   void  SetZP1EqualCoeff(Int_t channel, Float_t val) {fZP1EqualCoeff[channel]=val;}
72   void  SetZP1EqualCoeff(Float_t* EqualCoeff);
73   void  SetZN2EqualCoeff(Int_t channel, Float_t val) {fZN2EqualCoeff[channel]=val;}
74   void  SetZN2EqualCoeff(Float_t* EqualCoeff);
75   void  SetZP2EqualCoeff(Int_t channel, Float_t val) {fZP2EqualCoeff[channel]=val;}
76   void  SetZP2EqualCoeff(Float_t* EqualCoeff);
77   //  
78   void    SetZEMEndValue(Float_t ZEMEndValue) {fZEMEndValue = ZEMEndValue;}
79   void    SetZEMCutFraction(Float_t ZEMCutFraction) {fZEMCutFraction = ZEMCutFraction;}
80   void    SetDZEMSup(Float_t DZEMSup) {fDZEMSup = DZEMSup;}
81   void    SetDZEMInf(Float_t DZEMInf) {fDZEMInf = DZEMInf;}
82   virtual Float_t GetZEMEndValue()     const {return fZEMEndValue;}
83   virtual Float_t GetZEMCutFraction()  const {return fZEMCutFraction;}
84   virtual Float_t GetDZEMSup()         const {return fDZEMSup;}
85   virtual Float_t GetDZEMInf()         const {return fDZEMInf;}
86   //
87   void    SetEZN1MaxValue(Float_t value)  {fEZN1MaxValue = value;}
88   void    SetEZP1MaxValue(Float_t value)  {fEZP1MaxValue = value;}
89   void    SetEZDC1MaxValue(Float_t value) {fEZDC1MaxValue = value;}
90   void    SetEZN2MaxValue(Float_t value)  {fEZN2MaxValue = value;}
91   void    SetEZP2MaxValue(Float_t value)  {fEZP2MaxValue = value;}
92   void    SetEZDC2MaxValue(Float_t value) {fEZDC2MaxValue = value;}
93   virtual Float_t GetEZN1MaxValue()  const {return fEZN1MaxValue;}
94   virtual Float_t GetEZP1MaxValue()  const {return fEZP1MaxValue;}
95   virtual Float_t GetEZDC1MaxValue() const {return fEZDC1MaxValue;}
96   virtual Float_t GetEZN2MaxValue()  const {return fEZN2MaxValue;}
97   virtual Float_t GetEZP2MaxValue()  const {return fEZP2MaxValue;}
98   virtual Float_t GetEZDC2MaxValue() const {return fEZDC2MaxValue;}
99   
100  protected:
101   // --- Pedestals
102   Float_t  fMeanPedestal[47];    // Mean pedestal values 
103   Float_t  fMeanPedWidth[47];    // Mean pedestal values 
104   Float_t  fOOTPedestal[44];     // "Out of Time" pedestal values
105   Float_t  fOOTPedWidth[44];     // "Out of Time" pedestal values
106   Float_t  fPedCorrCoeff[2][44]; // Fit of correlation in-time vs. out-of-time
107   // --- E calibration
108   Float_t  fEnCalibration[6];    // Coeff. for energy calibration
109   // --- Coefficients for tower calibration
110   Float_t  fZN1EqualCoeff[5];    // Equalization coefficients for ZN1 PTMs
111   Float_t  fZP1EqualCoeff[5];    // Equalization coefficients for ZN1 PTMs
112   Float_t  fZN2EqualCoeff[5];    // Equalization coefficients for ZN1 PTMs
113   Float_t  fZP2EqualCoeff[5];    // Equalization coefficients for ZN1 PTMs
114   // --- Coefficients for centrality selection from ZEM signal
115   Float_t  fZEMEndValue;         // End point value of ZEM energy spectrum
116   Float_t  fZEMCutFraction;      // Fraction of ZEM energy spectrum used to cut
117   Float_t  fDZEMSup;// Upper value of EZDCvs.ZEM correlation where ZEM signal is used
118   Float_t  fDZEMInf;// Lower value of EZDCvs.ZEM correlation where ZEM signal is used
119   // --- Parameters from EZDC vs. Nspec correlation
120   Float_t  fEZN1MaxValue;        // Max value of ZN1 vs. Nspec n correlation
121   Float_t  fEZP1MaxValue;        // Max value of ZP1 vs. Nspec p correlation
122   Float_t  fEZDC1MaxValue;       // Max value of ZDC1 vs. Nspec n+p correlation
123   Float_t  fEZN2MaxValue;        // Max value of ZN2 vs. Nspec n correlation
124   Float_t  fEZP2MaxValue;        // Max value of ZP2 vs. Nspec p correlation
125   Float_t  fEZDC2MaxValue;       // Max value of ZDC2 vs. Nspec n+p correlation
126   //
127   ClassDef(AliZDCCalibData,9)    // ZDC  Calibration data
128 };
129
130 #endif