Line data Source code
1 : #ifndef ALIVZEROCALIBDATA_H
2 : #define ALIVZEROCALIBDATA_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 : // //
9 : // class for VZERO calibration //
10 : // //
11 : ////////////////////////////////////////////////
12 :
13 : #include "TNamed.h"
14 :
15 : class AliVZERODataDCS;
16 :
17 : class AliVZEROCalibData: public TNamed {
18 :
19 : public:
20 : enum { kNCIUBoards = 8 };
21 :
22 : AliVZEROCalibData();
23 : AliVZEROCalibData(const char* name);
24 : AliVZEROCalibData(const AliVZEROCalibData &calibda);
25 : AliVZEROCalibData& operator= (const AliVZEROCalibData &calibda);
26 : virtual ~AliVZEROCalibData();
27 : void Reset();
28 : void FillDCSData(AliVZERODataDCS * data);
29 :
30 22016 : Float_t GetPedestal(Int_t channel) const {return fPedestal[channel];}
31 0 : Float_t* GetPedestal() const {return (float*)fPedestal;}
32 22016 : Float_t GetSigma(Int_t channel) const {return fSigma[channel];}
33 0 : Float_t* GetSigma() const {return (float*)fSigma;}
34 0 : Float_t GetADCmean(Int_t channel) const {return fADCmean[channel];}
35 0 : Float_t* GetADCmean() const {return (float*)fADCmean;}
36 0 : Float_t GetADCsigma(Int_t channel) const {return fADCsigma[channel];}
37 0 : Float_t* GetADCsigma() const {return (float*)fADCsigma;}
38 0 : Float_t GetMeanHV(Int_t channel) const {return fMeanHV[channel];}
39 0 : Float_t* GetMeanHV() const {return (float*)fMeanHV;}
40 0 : Float_t GetWidthHV(Int_t channel) const {return fWidthHV[channel];}
41 0 : Float_t* GetWidthHV() const {return (float*)fWidthHV;}
42 512 : Bool_t IsChannelDead(Int_t channel) const {return fDeadChannel[channel];}
43 0 : Bool_t* GetDeadMap() const {return (bool*)fDeadChannel;}
44 :
45 : Float_t GetGain(Int_t channel);
46 768 : Float_t GetTimeOffset(Int_t channel) const {return fTimeOffset[channel];}
47 0 : Float_t* GetTimeOffset() const {return (float*)fTimeOffset;}
48 0 : Float_t GetTimeGain(Int_t channel) const {return fTimeGain[channel];}
49 0 : Float_t* GetTimeGain() const {return (float*)fTimeGain;}
50 :
51 0 : Float_t* GetTimeResolution() const {return (Float_t*) fTimeResolution;};
52 2560 : Float_t GetTimeResolution(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fTimeResolution[board]:0);};
53 :
54 0 : Float_t* GetWidthResolution() const {return (Float_t*) fWidthResolution;};
55 2192 : Float_t GetWidthResolution(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fWidthResolution[board]:0);};
56 :
57 0 : const UInt_t* GetMatchWindow() const { return fMatchWindow; }
58 1024 : UInt_t GetMatchWindow(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fMatchWindow[board]:0); }
59 0 : const UInt_t* GetSearchWindow() const { return fSearchWindow; }
60 0 : UInt_t GetSearchWindow(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fSearchWindow[board]:0); }
61 0 : const UInt_t* GetTriggerCountOffset() const { return fTriggerCountOffset; }
62 1664 : UInt_t GetTriggerCountOffset(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fTriggerCountOffset[board]:0); }
63 0 : const UInt_t* GetRollOver() const { return fRollOver; }
64 1664 : UInt_t GetRollOver(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fRollOver[board]:0); }
65 :
66 1168 : Float_t GetDiscriThr(Int_t channel) const {return fDiscriThr[channel];}
67 0 : Float_t* GetDiscriThr() const {return (Float_t*)fDiscriThr;}
68 :
69 0 : void SetPedestal(Float_t val, Int_t channel) {fPedestal[channel]=val;}
70 : void SetPedestal(const Float_t* Pedestal);
71 0 : void SetSigma(Float_t val, Int_t channel) {fSigma[channel]=val;}
72 : void SetSigma(const Float_t* Sigma);
73 0 : void SetADCmean(Float_t val, Int_t channel) {fADCmean[channel]=val;}
74 : void SetADCmean(const Float_t* ADCmean);
75 0 : void SetADCsigma(Float_t val, Int_t channel) {fADCsigma[channel]=val;}
76 : void SetADCsigma(const Float_t* ADCsigma);
77 0 : void SetMeanHV(Float_t val, Int_t channel) {fMeanHV[channel]=val;}
78 : void SetMeanHV(const Float_t* MeanHV);
79 0 : void SetWidthHV(Float_t val, Int_t channel) {fWidthHV[channel]=val;}
80 : void SetWidthHV(const Float_t* WidthHV);
81 0 : void SetDeadChannel(Bool_t val, Int_t channel) {fDeadChannel[channel]=val;}
82 : void SetDeadMap(const Bool_t* deadMap);
83 :
84 : void SetTimeOffset(Float_t val, Int_t board, Int_t channel);
85 : void SetTimeOffset(const Float_t* TimeOffset);
86 0 : void SetTimeGain(Float_t val, Int_t channel) {fTimeGain[channel]=val;}
87 : void SetTimeGain(const Float_t* TimeGain);
88 :
89 : void SetParameter(TString name, Int_t val);
90 : void SetTimeResolution(UShort_t *resols);
91 : void SetTimeResolution(UShort_t resol, Int_t board);
92 : void SetWidthResolution(UShort_t *resols);
93 : void SetWidthResolution(UShort_t resol, Int_t board);
94 :
95 : void SetMatchWindow(UInt_t *windows);
96 : void SetMatchWindow(UInt_t window, Int_t board);
97 : void SetSearchWindow(UInt_t *windows);
98 : void SetSearchWindow(UInt_t window, Int_t board);
99 : void SetTriggerCountOffset(UInt_t *offsets);
100 : void SetTriggerCountOffset(UInt_t offset, Int_t board);
101 : void SetRollOver(UInt_t *offsets);
102 : void SetRollOver(UInt_t offset, Int_t board);
103 :
104 : void SetDiscriThr(Float_t thr, Int_t board, Int_t channel);
105 : void SetDiscriThr(const Float_t* thresholds);
106 :
107 : Float_t GetMIPperADC(Int_t channel);
108 : Float_t GetHV(Int_t channel, Float_t adcPerMip);
109 :
110 : static Int_t GetOfflineChannelNumber(Int_t board, Int_t channel);
111 : static Int_t GetBoardNumber(Int_t channel);
112 : static Int_t GetFEEChannelNumber(Int_t channel);
113 :
114 : Float_t GetLightYields(Int_t channel);
115 :
116 0 : Float_t *GetPMGainsA() const { return fPMGainsA; }
117 0 : Float_t *GetPMGainsB() const { return fPMGainsB; }
118 :
119 : Float_t GetCalibDiscriThr(Int_t channel, Bool_t scaled, Int_t runNumber);
120 :
121 : protected:
122 : void InitLightYields();
123 : void InitPMGains();
124 : void InitCalDiscriThr();
125 :
126 : Float_t fPedestal[128]; // Mean pedestal values
127 : Float_t fSigma[128]; // Sigmas of pedestal peaks
128 : Float_t fADCmean[128]; // ADC mean values
129 : Float_t fADCsigma[128]; // ADC sigma values
130 : Float_t fMeanHV[64]; // Mean PMT HV needed to compute MIP value
131 : Float_t fWidthHV[64]; // Width of the PMT HV
132 :
133 : Float_t fTimeOffset[64]; // Time offsets of the TDC
134 : Float_t fTimeGain[64]; // Gain factors of the TDC
135 : Bool_t fDeadChannel[64]; // List of dead channels
136 : Float_t fTimeResolution[kNCIUBoards]; // Time Resolution of the TDC (ns / channel)
137 : Float_t fWidthResolution[kNCIUBoards]; // Time Width Resolution of the TDC (ns / channel)
138 :
139 : UInt_t fMatchWindow[kNCIUBoards]; // HPTDC matching window (25ns units)
140 : UInt_t fSearchWindow[kNCIUBoards];// HPTDC search window (25ns units)
141 : UInt_t fTriggerCountOffset[kNCIUBoards]; // HPTDC trigger count offset (25ns units)
142 : UInt_t fRollOver[kNCIUBoards]; // HPTDC roll-over (25ns units)
143 :
144 : Float_t fDiscriThr[64]; // Discriminator thresholds
145 : Bool_t fIsCalThrInit; // Are the calibrated thresholds initialized
146 : Float_t fCalDiscriThr[64]; // Calibrated discriminator thresholds
147 :
148 : Float_t *fLightYields; //! Light Yields channel by channel (read from separate OCDB entry)
149 : Float_t *fPMGainsA; //! PM gain factors channel by channel (read from separate OCDB entry)
150 : Float_t *fPMGainsB; //! PM gain factors channel by channel (read from separate OCDB entry)
151 :
152 68 : ClassDef(AliVZEROCalibData,9) // VZERO Calibration data
153 : };
154 :
155 : #endif
|
