Line data Source code
1 : /**************************************************************************
2 : * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 : * *
4 : * Author: The ALICE Off-line Project. *
5 : * Contributors are mentioned in the code where appropriate. *
6 : * *
7 : * Permission to use, copy, modify and distribute this software and its *
8 : * documentation strictly for non-commercial purposes is hereby granted *
9 : * without fee, provided that the above copyright notice appears in all *
10 : * copies and that both the copyright notice and this permission notice *
11 : * appear in the supporting documentation. The authors make no claims *
12 : * about the suitability of this software for any purpose. It is *
13 : * provided "as is" without express or implied warranty. *
14 : **************************************************************************/
15 :
16 : #ifndef ALIADQAPARAM_H
17 : #define ALIADQAPARAM_H
18 :
19 : #include "TNamed.h"
20 :
21 0 : class AliADQAParam : public TNamed
22 : {
23 : public:
24 : AliADQAParam();
25 : virtual ~AliADQAParam();
26 :
27 : //HPTDC time
28 0 : void SetNTdcTimeBins (Int_t val) { fNTdcTimeBins = val; }
29 0 : void SetTdcTimeMin (Float_t val) { fTdcTimeMin = val; }
30 0 : void SetTdcTimeMax (Float_t val) { fTdcTimeMax = val; }
31 : //HPTDC time flag
32 0 : void SetNTdcTimeBinsFlag (Int_t val) { fNTdcTimeBinsFlag = val; }
33 0 : void SetTdcTimeMinBBFlag (Float_t val) { fTdcTimeMinBBFlag = val; }
34 0 : void SetTdcTimeMaxBBFlag (Float_t val) { fTdcTimeMaxBBFlag = val; }
35 0 : void SetTdcTimeMinBGFlag (Float_t val) { fTdcTimeMinBGFlag = val; }
36 0 : void SetTdcTimeMaxBGFlag (Float_t val) { fTdcTimeMaxBGFlag = val; }
37 : //HPTDC TimeRatio
38 0 : void SetNTdcTimeRatioBins (Int_t val) { fNTdcTimeRatioBins = val; }
39 0 : void SetTdcTimeRatioMin (Float_t val) { fTdcTimeRatioMin = val; }
40 0 : void SetTdcTimeRatioMax (Float_t val) { fTdcTimeRatioMax = val; }
41 : //Width
42 0 : void SetNTdcWidthBins (Int_t val) { fNTdcWidthBins = val; }
43 0 : void SetTdcWidthMin (Float_t val) { fTdcWidthMin = val; }
44 0 : void SetTdcWidthMax (Float_t val) { fTdcWidthMax = val; }
45 : //Charge per channel
46 0 : void SetNChargeChannelBins (Int_t val) { fNChargeChannelBins = val; }
47 0 : void SetChargeChannelMin (Int_t val) { fChargeChannelMin = val; }
48 0 : void SetChargeChannelMax (Int_t val) { fChargeChannelMax = val; }
49 0 : void SetChargeChannelZoomMin (Int_t val) { fChargeChannelZoomMin = val; }
50 0 : void SetChargeChannelZoomMax (Int_t val) { fChargeChannelZoomMax = val; }
51 : //Charge per side
52 0 : void SetNChargeSideBins (Int_t val) { fNChargeSideBins = val; }
53 0 : void SetChargeSideMin (Int_t val) { fChargeSideMin = val; }
54 0 : void SetChargeSideMax (Int_t val) { fChargeSideMax = val; }
55 : //Chharge correlation
56 0 : void SetNChargeCorrBins (Int_t val) { fNChargeCorrBins = val; }
57 0 : void SetChargeCorrMin (Int_t val) { fChargeCorrMin = val; }
58 0 : void SetChargeCorrMax (Int_t val) { fChargeCorrMax = val; }
59 : //Pair time correlation
60 0 : void SetNPairTimeCorrBins(Int_t val) { fNPairTimeCorrBins = val;}
61 0 : void SetPairTimeCorrMin(Float_t val) { fPairTimeCorrMin = val;}
62 0 : void SetPairTimeCorrMax(Float_t val) { fPairTimeCorrMax = val;}
63 : //Pair time diference
64 0 : void SetNPairTimeDiffBins(Int_t val) { fNPairTimeDiffBins = val;}
65 0 : void SetPairTimeDiffMin(Float_t val) { fPairTimeDiffMin = val;}
66 0 : void SetPairTimeDiffMax(Float_t val) { fPairTimeDiffMax = val;}
67 : //Mean time correlation
68 0 : void SetNMeanTimeCorrBins(Int_t val) { fNMeanTimeCorrBins = val;}
69 0 : void SetMeanTimeCorrMin(Float_t val) { fMeanTimeCorrMin = val;}
70 0 : void SetMeanTimeCorrMax(Float_t val) { fMeanTimeCorrMax = val;}
71 : //Charge trends
72 0 : void SetChargeTrendMin(Float_t val) {fChargeTrendMin = val;}
73 0 : void SetChargeTrendMax(Float_t val) {fChargeTrendMax = val;}
74 :
75 : //QA checker limits
76 0 : void SetSatMed(Float_t val) {fSatMed = val;}
77 0 : void SetSatHigh(Float_t val) {fSatHigh = val;}
78 0 : void SetSatHuge(Float_t val) {fSatHuge = val;}
79 :
80 0 : void SetMaxPedDiff(Int_t val) {fMaxPedDiff = val;}
81 0 : void SetMaxPedWidth(Float_t val) {fMaxPedWidth = val;}
82 :
83 0 : void SetMaxNoTimeRate(Float_t val) {fMaxNoTimeRate = val;}
84 0 : void SetMaxNoFlagRate(Float_t val) {fMaxNoFlagRate = val;}
85 0 : void SetMaxBBVariation(Float_t val) {fMaxBBVariation = val;}
86 0 : void SetMaxBGVariation(Float_t val) {fMaxBGVariation = val;}
87 :
88 0 : void SetAsynchronBB(Float_t val) {fAsynchronBB = val;}
89 0 : void SetAsynchronBG(Float_t val) {fAsynchronBG = val;}
90 :
91 : //HPTDC time
92 0 : Int_t GetNTdcTimeBins() const { return fNTdcTimeBins; }
93 0 : Float_t GetTdcTimeMin() const { return fTdcTimeMin; }
94 0 : Float_t GetTdcTimeMax() const { return fTdcTimeMax; }
95 : //HPTDC time with flag
96 0 : Int_t GetNTdcTimeBinsFlag() const { return fNTdcTimeBinsFlag; }
97 0 : Float_t GetTdcTimeMinBBFlag() const { return fTdcTimeMinBBFlag; }
98 0 : Float_t GetTdcTimeMaxBBFlag() const { return fTdcTimeMaxBBFlag; }
99 0 : Float_t GetTdcTimeMinBGFlag() const { return fTdcTimeMinBGFlag; }
100 0 : Float_t GetTdcTimeMaxBGFlag() const { return fTdcTimeMaxBGFlag; }
101 : //HPTDC TimeRatio
102 0 : Int_t GetNTdcTimeRatioBins() const { return fNTdcTimeRatioBins; }
103 0 : Float_t GetTdcTimeRatioMin() const { return fTdcTimeRatioMin; }
104 0 : Float_t GetTdcTimeRatioMax() const { return fTdcTimeRatioMax; }
105 : //Width
106 0 : Int_t GetNTdcWidthBins() const { return fNTdcWidthBins; }
107 0 : Float_t GetTdcWidthMin() const { return fTdcWidthMin; }
108 0 : Float_t GetTdcWidthMax() const { return fTdcWidthMax; }
109 : //Charge per channel
110 0 : Int_t GetNChargeChannelBins() const { return fNChargeChannelBins; }
111 0 : Int_t GetChargeChannelMin() const { return fChargeChannelMin; }
112 0 : Int_t GetChargeChannelMax() const { return fChargeChannelMax; }
113 0 : Int_t GetChargeChannelZoomMin() const { return fChargeChannelZoomMin; }
114 0 : Int_t GetChargeChannelZoomMax() const { return fChargeChannelZoomMax; }
115 : //Charge per side
116 0 : Int_t GetNChargeSideBins() const { return fNChargeSideBins; }
117 0 : Int_t GetChargeSideMin() const { return fChargeSideMin; }
118 0 : Int_t GetChargeSideMax() const { return fChargeSideMax; }
119 : //Charge correlation - be careful with nBins
120 0 : Int_t GetNChargeCorrBins() const { return fNChargeCorrBins; }
121 0 : Int_t GetChargeCorrMin() const { return fChargeCorrMin; }
122 0 : Int_t GetChargeCorrMax() const { return fChargeCorrMax; }
123 : //Pair time correlation
124 0 : Int_t GetNPairTimeCorrBins() const { return fNPairTimeCorrBins;}
125 0 : Float_t GetPairTimeCorrMin() const { return fPairTimeCorrMin;}
126 0 : Float_t GetPairTimeCorrMax() const { return fPairTimeCorrMax;}
127 : //Pair time difference
128 0 : Int_t GetNPairTimeDiffBins() const { return fNPairTimeDiffBins;}
129 0 : Float_t GetPairTimeDiffMin() const { return fPairTimeDiffMin;}
130 0 : Float_t GetPairTimeDiffMax() const { return fPairTimeDiffMax;}
131 : //Mean time correlation
132 0 : Int_t GetNMeanTimeCorrBins() const { return fNMeanTimeCorrBins;}
133 0 : Float_t GetMeanTimeCorrMin() const { return fMeanTimeCorrMin;}
134 0 : Float_t GetMeanTimeCorrMax() const { return fMeanTimeCorrMax;}
135 : //Charge trends
136 0 : Float_t GetChargeTrendMin() const {return fChargeTrendMin;}
137 0 : Float_t GetChargeTrendMax() const {return fChargeTrendMax;}
138 :
139 : //QA checker limits
140 0 : Float_t GetSatMed() const {return fSatMed;}
141 0 : Float_t GetSatHigh() const {return fSatHigh;}
142 0 : Float_t GetSatHuge() const {return fSatHuge;}
143 :
144 0 : Int_t GetMaxPedDiff() const {return fMaxPedDiff;}
145 0 : Float_t GetMaxPedWidth() const {return fMaxPedWidth;}
146 :
147 0 : Float_t GetMaxNoTimeRate() const {return fMaxNoTimeRate;}
148 0 : Float_t GetMaxNoFlagRate() const {return fMaxNoFlagRate;}
149 0 : Float_t GetMaxBBVariation() const {return fMaxBBVariation;}
150 0 : Float_t GetMaxBGVariation() const {return fMaxBGVariation;}
151 :
152 0 : Float_t GetAsynchronBB() const {return fAsynchronBB;}
153 0 : Float_t GetAsynchronBG() const {return fAsynchronBG;}
154 :
155 : private:
156 :
157 : //QA histogram bins and limits
158 : Int_t fNTdcTimeBins; //Time bining
159 : Float_t fTdcTimeMin;
160 : Float_t fTdcTimeMax;
161 : Int_t fNTdcTimeBinsFlag; //Time bining with BB/BG flag
162 : Float_t fTdcTimeMinBBFlag;
163 : Float_t fTdcTimeMaxBBFlag;
164 : Float_t fTdcTimeMinBGFlag;
165 : Float_t fTdcTimeMaxBGFlag;
166 : Int_t fNTdcTimeRatioBins; //Time ratio w_flag/All bining
167 : Float_t fTdcTimeRatioMin;
168 : Float_t fTdcTimeRatioMax;
169 : Int_t fNTdcWidthBins; //Width binning
170 : Float_t fTdcWidthMin;
171 : Float_t fTdcWidthMax;
172 : Int_t fNChargeChannelBins; //Charge binnings
173 : Int_t fChargeChannelMin;
174 : Int_t fChargeChannelMax;
175 : Int_t fChargeChannelZoomMin;
176 : Int_t fChargeChannelZoomMax;
177 : Int_t fNChargeSideBins;
178 : Int_t fChargeSideMin;
179 : Int_t fChargeSideMax;
180 : Int_t fNChargeCorrBins;
181 : Int_t fChargeCorrMin;
182 : Int_t fChargeCorrMax;
183 : Float_t fChargeTrendMin;
184 : Float_t fChargeTrendMax;
185 :
186 : Int_t fNPairTimeCorrBins;
187 : Float_t fPairTimeCorrMin;
188 : Float_t fPairTimeCorrMax;
189 :
190 : Int_t fNPairTimeDiffBins;
191 : Float_t fPairTimeDiffMin;
192 : Float_t fPairTimeDiffMax;
193 :
194 : Int_t fNMeanTimeCorrBins;
195 : Float_t fMeanTimeCorrMin;
196 : Float_t fMeanTimeCorrMax;
197 :
198 : //QA checker limits
199 : Float_t fSatMed;
200 : Float_t fSatHigh;
201 : Float_t fSatHuge;
202 :
203 : Int_t fMaxPedDiff;
204 : Float_t fMaxPedWidth;
205 :
206 : Float_t fMaxNoTimeRate;
207 : Float_t fMaxNoFlagRate;
208 : Float_t fMaxBBVariation;
209 : Float_t fMaxBGVariation;
210 :
211 : Float_t fAsynchronBB;
212 : Float_t fAsynchronBG;
213 :
214 :
215 16 : ClassDef(AliADQAParam,5)
216 : };
217 : #endif
|
