| 5e319bd5 |
1 | #ifndef ALIADCALIBDATA_H |
| 2 | #define ALIADCALIBDATA_H |
| 3 | |
| 4 | /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * |
| 5 | * See cxx source for full Copyright notice */ |
| 6 | |
| 7 | #include "TNamed.h" |
| aa8120bb |
8 | #include "AliADConst.h" |
| 4188a021 |
9 | |
| 10 | class AliADDataDCS; |
| 11 | |
| 12 | |
| 5e319bd5 |
13 | class AliADCalibData: public TNamed { |
| 14 | |
| 15 | public: |
| 16 | AliADCalibData(); |
| 17 | AliADCalibData(const char* name); |
| 18 | |
| 19 | AliADCalibData(const AliADCalibData &calibda); |
| 20 | AliADCalibData& operator= (const AliADCalibData &calibda); |
| 21 | virtual ~AliADCalibData(); |
| 22 | void Reset(); |
| 4188a021 |
23 | void FillDCSData(AliADDataDCS * data); |
| 5e319bd5 |
24 | |
| aa8120bb |
25 | Float_t GetPedestal(Int_t channel) const {return fPedestal[channel];} |
| 26 | Float_t* GetPedestal() const {return (float*)fPedestal;} |
| 27 | Float_t GetSigma(Int_t channel) const {return fSigma[channel];} |
| 28 | Float_t* GetSigma() const {return (float*)fSigma;} |
| 29 | Float_t GetADCmean(Int_t channel) const {return fADCmean[channel];} |
| 30 | Float_t* GetADCmean() const {return (float*)fADCmean;} |
| 31 | Float_t GetADCsigma(Int_t channel) const {return fADCsigma[channel];} |
| 32 | Float_t* GetADCsigma() const {return (float*)fADCsigma;} |
| 33 | Float_t GetMeanHV(Int_t channel) const {return fMeanHV[channel];} |
| 34 | Float_t* GetMeanHV() const {return (float*)fMeanHV;} |
| 35 | Float_t GetWidthHV(Int_t channel) const {return fWidthHV[channel];} |
| 36 | Float_t* GetWidthHV() const {return (float*)fWidthHV;} |
| 37 | Bool_t IsChannelDead(Int_t channel) const {return fDeadChannel[channel];} |
| 38 | Bool_t* GetDeadMap() const {return (bool*)fDeadChannel;} |
| 39 | |
| 40 | Float_t GetGain(Int_t channel); |
| 41 | Float_t GetTimeOffset(Int_t channel) const {return fTimeOffset[channel];} |
| 42 | Float_t* GetTimeOffset() const {return (float*)fTimeOffset;} |
| 43 | Float_t GetTimeGain(Int_t channel) const {return fTimeGain[channel];} |
| 44 | Float_t* GetTimeGain() const {return (float*)fTimeGain;} |
| 45 | |
| 46 | Float_t* GetTimeResolution() const {return (Float_t*) fTimeResolution;}; |
| 47 | Float_t GetTimeResolution(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fTimeResolution[board]:0);}; |
| 48 | |
| 49 | Float_t* GetWidthResolution() const {return (Float_t*) fWidthResolution;}; |
| 50 | Float_t GetWidthResolution(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fWidthResolution[board]:0);}; |
| 51 | |
| 52 | const UInt_t* GetMatchWindow() const { return fMatchWindow; } |
| 53 | UInt_t GetMatchWindow(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fMatchWindow[board]:0); } |
| 54 | const UInt_t* GetSearchWindow() const { return fSearchWindow; } |
| 55 | UInt_t GetSearchWindow(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fSearchWindow[board]:0); } |
| 56 | const UInt_t* GetTriggerCountOffset() const { return fTriggerCountOffset; } |
| 57 | UInt_t GetTriggerCountOffset(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fTriggerCountOffset[board]:0); } |
| 58 | const UInt_t* GetRollOver() const { return fRollOver; } |
| 59 | UInt_t GetRollOver(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fRollOver[board]:0); } |
| 60 | |
| 61 | Float_t GetDiscriThr(Int_t channel) const {return fDiscriThr[channel];} |
| 62 | Float_t* GetDiscriThr() const {return (Float_t*)fDiscriThr;} |
| 69e96215 |
63 | Float_t GetCalibDiscriThr(Int_t channel, Bool_t scaled); |
| b405b003 |
64 | |
| 65 | UShort_t * GetClk1Win1() const {return (UShort_t*)fClk1Win1;}; |
| 66 | UShort_t GetClk1Win1(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fClk1Win1[board]:0);}; |
| 67 | UShort_t * GetClk2Win1() const {return (UShort_t*)fClk2Win1;}; |
| 68 | UShort_t GetClk2Win1(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fClk2Win1[board]:0);}; |
| 69 | |
| 70 | UShort_t * GetClk1Win2() const {return (UShort_t*)fClk1Win2;}; |
| 71 | UShort_t GetClk1Win2(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fClk1Win2[board]:0);}; |
| 72 | UShort_t * GetClk2Win2() const {return (UShort_t*)fClk2Win2;}; |
| 73 | UShort_t GetClk2Win2(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fClk2Win2[board]:0);}; |
| 74 | |
| 75 | UShort_t * GetDelayClk1Win1() const {return (UShort_t*)fDelayClk1Win1;}; |
| 76 | UShort_t GetDelayClk1Win1(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fDelayClk1Win1[board]:0);}; |
| 77 | UShort_t * GetDelayClk2Win1() const {return (UShort_t*)fDelayClk2Win1;}; |
| 78 | UShort_t GetDelayClk2Win1(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fDelayClk2Win1[board]:0);}; |
| 79 | |
| 80 | UShort_t * GetDelayClk1Win2() const {return (UShort_t*)fDelayClk1Win2;}; |
| 81 | UShort_t GetDelayClk1Win2(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fDelayClk1Win2[board]:0);}; |
| 82 | UShort_t * GetDelayClk2Win2() const {return (UShort_t*)fDelayClk2Win2;}; |
| 83 | UShort_t GetDelayClk2Win2(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fDelayClk2Win2[board]:0);}; |
| 84 | |
| 85 | UShort_t * GetLatchWin1() const {return (UShort_t*)fLatchWin1;}; |
| 86 | UShort_t GetLatchWin1(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fLatchWin1[board]:0);}; |
| 87 | UShort_t * GetLatchWin2() const {return (UShort_t*)fLatchWin2;}; |
| 88 | UShort_t GetLatchWin2(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fLatchWin2[board]:0);}; |
| 89 | |
| 90 | UShort_t * GetResetWin1() const {return (UShort_t*)fResetWin1;}; |
| 91 | UShort_t GetResetWin1(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fResetWin1[board]:0);}; |
| 92 | UShort_t * GetResetWin2() const {return (UShort_t*)fResetWin2;}; |
| 93 | UShort_t GetResetWin2(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fResetWin2[board]:0);}; |
| 94 | |
| 95 | Bool_t * GetPedestalSubtraction() const {return (Bool_t*) fPedestalSubtraction;}; |
| 96 | Bool_t GetPedestalSubtraction(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fPedestalSubtraction[board]:0);}; |
| 97 | |
| 98 | UShort_t GetBBAThreshold() const {return fBBAThreshold;}; |
| 99 | UShort_t GetBBCThreshold() const {return fBBCThreshold;}; |
| 100 | |
| 101 | UShort_t GetBGAThreshold() const {return fBGAThreshold;}; |
| 102 | UShort_t GetBGCThreshold() const {return fBGCThreshold;}; |
| 103 | |
| 104 | UShort_t GetBBAForBGThreshold() const {return fBBAForBGThreshold;}; |
| 105 | UShort_t GetBBCForBGThreshold() const {return fBBCForBGThreshold;}; |
| 106 | |
| 2cbbb1d5 |
107 | UShort_t GetMultADAThrLow() const {return fMultADAThrLow;}; |
| 108 | UShort_t GetMultADAThrHigh() const {return fMultADAThrHigh;}; |
| b405b003 |
109 | |
| 2cbbb1d5 |
110 | UShort_t GetMultADCThrLow() const {return fMultADCThrLow;}; |
| 111 | UShort_t GetMultADCThrHigh() const {return fMultADCThrHigh;}; |
| b405b003 |
112 | |
| 113 | UShort_t GetTriggerSelected(Int_t output) const {return ((output>=0 && output<5)?fTriggerSelected[output]:0);}; |
| 114 | |
| 115 | Bool_t GetEnableCharge(Int_t channel); |
| 116 | Bool_t GetEnableTiming(Int_t channel); |
| 117 | UShort_t GetOnlinePedestal(Int_t integrator, Int_t channel); |
| 118 | UShort_t GetOnlinePedestalCut(Int_t integrator, Int_t channel); |
| 119 | |
| aa8120bb |
120 | |
| 121 | static Int_t GetBoardNumber(Int_t channel); |
| 69e96215 |
122 | static Int_t GetFEEChannelNumber(Int_t channel); |
| 123 | static Int_t GetOfflineChannelNumber(Int_t board, Int_t channel); |
| aa8120bb |
124 | |
| 125 | Float_t GetLightYields(Int_t channel); |
| 126 | |
| 127 | Float_t *GetPMGainsA() const { return fPMGainsA; } |
| 128 | Float_t *GetPMGainsB() const { return fPMGainsB; } |
| 129 | |
| 69e96215 |
130 | void SetPedestal(Float_t val, Int_t channel) {fPedestal[channel]=val;} |
| 131 | void SetPedestal(const Float_t* Pedestal); |
| 132 | void SetSigma(Float_t val, Int_t channel) {fSigma[channel]=val;} |
| 133 | void SetSigma(const Float_t* Sigma); |
| 134 | void SetADCmean(Float_t val, Int_t channel) {fADCmean[channel]=val;} |
| 135 | void SetADCmean(const Float_t* ADCmean); |
| 136 | void SetADCsigma(Float_t val, Int_t channel) {fADCsigma[channel]=val;} |
| 137 | void SetADCsigma(const Float_t* ADCsigma); |
| 138 | void SetMeanHV(Float_t val, Int_t channel) {fMeanHV[channel]=val;} |
| 139 | void SetMeanHV(const Float_t* MeanHV); |
| 140 | void SetWidthHV(Float_t val, Int_t channel) {fWidthHV[channel]=val;} |
| 141 | void SetWidthHV(const Float_t* WidthHV); |
| 142 | void SetDeadChannel(Bool_t val, Int_t channel) {fDeadChannel[channel]=val;} |
| 143 | void SetDeadMap(const Bool_t* deadMap); |
| 144 | |
| 145 | void SetTimeOffset(Float_t val, Int_t board, Int_t channel); |
| 146 | void SetTimeOffset(const Float_t* TimeOffset); |
| 147 | void SetTimeGain(Float_t val, Int_t channel) {fTimeGain[channel]=val;} |
| 148 | void SetTimeGain(const Float_t* TimeGain); |
| 149 | |
| 150 | void SetParameter(TString name, Int_t val); |
| 151 | void SetTimeResolution(UShort_t *resols); |
| 152 | void SetTimeResolution(UShort_t resol, Int_t board); |
| 153 | void SetWidthResolution(UShort_t *resols); |
| 154 | void SetWidthResolution(UShort_t resol, Int_t board); |
| 155 | |
| 156 | void SetMatchWindow(UInt_t *windows); |
| 157 | void SetMatchWindow(UInt_t window, Int_t board); |
| 158 | void SetSearchWindow(UInt_t *windows); |
| 159 | void SetSearchWindow(UInt_t window, Int_t board); |
| 160 | void SetTriggerCountOffset(UInt_t *offsets); |
| 161 | void SetTriggerCountOffset(UInt_t offset, Int_t board); |
| 162 | void SetRollOver(UInt_t *offsets); |
| 163 | void SetRollOver(UInt_t offset, Int_t board); |
| 164 | |
| 165 | void SetDiscriThr(Float_t thr, Int_t board, Int_t channel); |
| 166 | void SetDiscriThr(const Float_t* thresholds); |
| b924d21d |
167 | |
| 168 | void SetADCperMIP(Int_t nADCperMIP); |
| 5e319bd5 |
169 | |
| b405b003 |
170 | void SetClk1Win1(UShort_t* clks); |
| 171 | void SetClk1Win1(UShort_t clk, Int_t board); |
| 172 | void SetClk2Win1(UShort_t* clks); |
| 173 | void SetClk2Win1(UShort_t clk, Int_t board); |
| 174 | |
| 175 | void SetClk1Win2(UShort_t* clks); |
| 176 | void SetClk1Win2(UShort_t clk, Int_t board); |
| 177 | void SetClk2Win2(UShort_t* clks); |
| 178 | void SetClk2Win2(UShort_t clk, Int_t board); |
| 179 | |
| 180 | void SetDelayClk1Win1(UShort_t* delays); |
| 181 | void SetDelayClk1Win1(UShort_t delay, Int_t board); |
| 182 | void SetDelayClk2Win1(UShort_t* delays); |
| 183 | void SetDelayClk2Win1(UShort_t delay, Int_t board); |
| 184 | |
| 185 | void SetDelayClk1Win2(UShort_t* delays); |
| 186 | void SetDelayClk1Win2(UShort_t delay, Int_t board); |
| 187 | void SetDelayClk2Win2(UShort_t* delays); |
| 188 | void SetDelayClk2Win2(UShort_t delay, Int_t board); |
| 189 | |
| 190 | void SetLatchWin1(UShort_t *latchs); |
| 191 | void SetLatchWin1(UShort_t latch, Int_t board); |
| 192 | void SetLatchWin2(UShort_t *latchs); |
| 193 | void SetLatchWin2(UShort_t latch, Int_t board); |
| 194 | |
| 195 | void SetResetWin1(UShort_t *resets); |
| 196 | void SetResetWin1(UShort_t reset, Int_t board); |
| 197 | void SetResetWin2(UShort_t *resets); |
| 198 | void SetResetWin2(UShort_t reset, Int_t board); |
| 199 | |
| 200 | void SetPedestalSubtraction(Bool_t *peds); |
| 201 | void SetPedestalSubtraction(Bool_t ped, Int_t board); |
| 202 | |
| 203 | void SetBBAThreshold(UShort_t th) {fBBAThreshold = th;}; |
| 204 | void SetBBCThreshold(UShort_t th) {fBBCThreshold = th;}; |
| 205 | |
| 206 | void SetBGAThreshold(UShort_t th) {fBGAThreshold = th;}; |
| 207 | void SetBGCThreshold(UShort_t th) {fBGCThreshold = th;}; |
| 208 | |
| 209 | void SetBBAForBGThreshold(UShort_t th) {fBBAForBGThreshold = th;}; |
| 210 | void SetBBCForBGThreshold(UShort_t th) {fBBCForBGThreshold = th;}; |
| 211 | |
| 212 | |
| 2cbbb1d5 |
213 | void SetMultADAThrLow(UShort_t th) {fMultADAThrLow = th;}; |
| 214 | void SetMultADAThrHigh(UShort_t th) {fMultADAThrHigh = th;}; |
| b405b003 |
215 | |
| 2cbbb1d5 |
216 | void SetMultADCThrLow(UShort_t th) {fMultADCThrLow = th;}; |
| 217 | void SetMultADCThrHigh(UShort_t th) {fMultADCThrHigh = th;}; |
| b405b003 |
218 | |
| 219 | void SetTriggerSelected(UShort_t trigger, Int_t output); |
| 220 | |
| 221 | void SetEnableCharge(Bool_t val, Int_t board, Int_t channel); |
| 222 | void SetEnableTiming(Bool_t val, Int_t board, Int_t channel); |
| 223 | void SetEnableCharge(Bool_t val, Int_t channel); |
| 224 | void SetEnableTiming(Bool_t val, Int_t channel); |
| 225 | void SetOnlinePedestal(UShort_t val, Int_t integrator, Int_t board, Int_t channel); |
| 226 | void SetOnlinePedestalCut(UShort_t val, Int_t integrator, Int_t board, Int_t channel); |
| 227 | void SetOnlinePedestal(UShort_t val, Int_t integrator, Int_t channel); |
| 228 | void SetOnlinePedestalCut(UShort_t val, Int_t integrator, Int_t channel); |
| 5e319bd5 |
229 | |
| 230 | protected: |
| aa8120bb |
231 | void InitLightYields(); |
| 232 | void InitPMGains(); |
| b405b003 |
233 | Bool_t IsClkValid(UShort_t clock) const; |
| aa8120bb |
234 | |
| b405b003 |
235 | Float_t fPedestal[32]; // Mean pedestal values - used offline |
| 236 | Float_t fSigma[32]; // Sigmas of pedestal peaks - used offline |
| aa8120bb |
237 | Float_t fADCmean[32]; // ADC mean values |
| 238 | Float_t fADCsigma[32]; // ADC sigma values |
| 239 | Float_t fMeanHV[16]; // Mean PMT HV needed to compute MIP value |
| 240 | Float_t fWidthHV[16]; // Width of the PMT HV |
| 241 | |
| 242 | Float_t fTimeOffset[16]; // Time offsets of the TDC |
| 243 | Float_t fTimeGain[16]; // Gain factors of the TDC |
| 244 | Bool_t fDeadChannel[16]; // List of dead channels |
| 245 | Float_t fTimeResolution[kNCIUBoards]; // Time Resolution of the TDC (ns / channel) |
| 246 | Float_t fWidthResolution[kNCIUBoards]; // Time Width Resolution of the TDC (ns / channel) |
| 247 | |
| 248 | UInt_t fMatchWindow[kNCIUBoards]; // HPTDC matching window (25ns units) |
| 249 | UInt_t fSearchWindow[kNCIUBoards];// HPTDC search window (25ns units) |
| 250 | UInt_t fTriggerCountOffset[kNCIUBoards]; // HPTDC trigger count offset (25ns units) |
| 251 | UInt_t fRollOver[kNCIUBoards]; // HPTDC roll-over (25ns units) |
| b405b003 |
252 | |
| 253 | UShort_t fClk1Win1[kNCIUBoards]; //Profil of the Clock 1 of the Window 1 (BB window) |
| 254 | UShort_t fClk2Win1[kNCIUBoards]; //Profil of the Clock 2 of the Window 1 (BB window) |
| 255 | UShort_t fClk1Win2[kNCIUBoards]; //Profil of the Clock 1 of the Window 2 (BG window) |
| 256 | UShort_t fClk2Win2[kNCIUBoards]; //Profil of the Clock 2 of the Window 2 (BG window) |
| 257 | UShort_t fDelayClk1Win1[kNCIUBoards]; // Delays of the Clock 1 of the Window 1 (BB window) |
| 258 | UShort_t fDelayClk2Win1[kNCIUBoards]; // Delays of the Clock 2 of the Window 1 (BB window) |
| 259 | UShort_t fDelayClk1Win2[kNCIUBoards]; // Delays of the Clock 1 of the Window 2 (BG window) |
| 260 | UShort_t fDelayClk2Win2[kNCIUBoards]; // Delays of the Clock 2 of the Window 2 (BG window) |
| 261 | UShort_t fLatchWin1[kNCIUBoards]; //Profil of the Clock of the Latch signal of Window 1 (BB window) |
| 262 | UShort_t fLatchWin2[kNCIUBoards]; //Profil of the Clock of the Latch signal of Window 2 (BG window) |
| 263 | UShort_t fResetWin1[kNCIUBoards]; //Profil of the Clock of the Reset signal of Window 1 (BB window) |
| 264 | UShort_t fResetWin2[kNCIUBoards]; //Profil of the Clock of the Reset signal of Window 2 (BG window) |
| 265 | Bool_t fPedestalSubtraction[kNCIUBoards]; // Flag to en(dis)able pedestal subtraction before centrality trigger calculation |
| 266 | UShort_t fBBAThreshold; // Minimum bias Threshold in number of channel hit for ADA |
| 267 | UShort_t fBBCThreshold; // Minimum bias Threshold in number of channel hit for ADC |
| 268 | UShort_t fBGAThreshold; // Beam Gas Threshold in number of channel hit for ADA |
| 269 | UShort_t fBGCThreshold; // Beam Gas Threshold in number of channel hit for ADC |
| 270 | UShort_t fBBAForBGThreshold; // BBA threshold for Beam Gas triggers (i.e. BBA and BGC) |
| 271 | UShort_t fBBCForBGThreshold; // BBC threshold for Beam Gas triggers (i.e. BBC and BGA) |
| 2cbbb1d5 |
272 | UShort_t fMultADAThrLow; // Threshold used for multiplicity triggers (i.e. MTA and MTC) |
| 273 | UShort_t fMultADAThrHigh; // Threshold used for multiplicity triggers (i.e. MTA and MTC) |
| 274 | UShort_t fMultADCThrLow; // Threshold used for multiplicity triggers (i.e. MTA and MTC) |
| 275 | UShort_t fMultADCThrHigh; // Threshold used for multiplicity triggers (i.e. MTA and MTC) |
| b405b003 |
276 | UShort_t fTriggerSelected[5]; // Triggers selected on the 5 outputs to CTP |
| 277 | Bool_t fEnableCharge[16]; // Flag to know is a channel is participating to the Charge triggers |
| 278 | Bool_t fEnableTiming[16]; // Flag to know is a channel is participating to the Timing triggers |
| 279 | UShort_t fPedestalOdd[16]; // Pedestals for the Odd integrators |
| 280 | UShort_t fPedestalEven[16]; // Pedestals for the Even integrators |
| 281 | UShort_t fPedestalCutOdd[16]; // Pedestals Cut for the Odd integrators |
| 282 | UShort_t fPedestalCutEven[16]; // Pedestals Cut for the Even integrators |
| aa8120bb |
283 | |
| 284 | Float_t fDiscriThr[16]; // Discriminator thresholds |
| 285 | |
| 286 | Float_t *fLightYields; //! Light Yields channel by channel (read from separate OCDB entry) |
| 287 | Float_t *fPMGainsA; //! PM gain factors channel by channel (read from separate OCDB entry) |
| 288 | Float_t *fPMGainsB; //! PM gain factors channel by channel (read from separate OCDB entry) |
| 5e319bd5 |
289 | |
| 290 | ClassDef(AliADCalibData,1) // AD Calibration data |
| 291 | }; |
| 292 | |
| 293 | #endif |
| 294 | |
git://git.uio.no / u / mrichter / AliRoot.git / blame