]>
Commit | Line | Data |
---|---|---|
71b70904 | 1 | #ifndef ALIPOISSONCALCULATOR_H |
2 | #define ALIPOISSONCALCULATOR_H | |
3 | #include <TNamed.h> | |
4 | class TH2D; | |
ce63a99e | 5 | class TH1D; |
71b70904 | 6 | class TBrowser; |
d23503ee | 7 | class TAxis; |
71b70904 | 8 | |
ce63a99e | 9 | /** |
10 | * A class to calculate the multiplicity in @f$(\eta,\varphi)@f$ bins | |
11 | * using Poisson statistics. | |
12 | * | |
13 | * The input is assumed to be binned in @f$(\eta,\varphi)@f$ as | |
14 | * described by the 2D histogram passwd to the Reset member function. | |
15 | * | |
16 | * The data is grouped in to regions as defined by the parameters | |
63d9ab53 | 17 | * fXLumping and fYLumping. The total number of cells and number |
ce63a99e | 18 | * of empty cells is then calculate in each region. The mean |
19 | * multiplicity over the region is then determined as | |
20 | * | |
21 | * @f[ | |
22 | * \langle m\rangle = -\log\left(\frac{e}{t}\right) | |
23 | * @f] | |
24 | * where @f$ e@f$ is the number of empty cells and @f$t@f$ is the | |
25 | * total number of cells in the region. A correction for counting | |
26 | * statistics, is then applied | |
27 | * @f{eqnarray*}{ | |
28 | * c &=& \frac{1}{1 - \exp{-\langle m\rangle}}\\ &=& | |
29 | * \frac{1}{1 - \frac{e}{t}} | |
30 | * @f} | |
31 | * and the final number in each cell is then | |
32 | * @f$h_i c \langle m\rangle@f$ | |
33 | * where @f$h_i@f$ is the number of hits in the cell @f$i@f$ | |
34 | * | |
35 | */ | |
71b70904 | 36 | class AliPoissonCalculator : public TNamed |
37 | { | |
38 | public: | |
ce63a99e | 39 | /** |
40 | * Constructor | |
41 | */ | |
71b70904 | 42 | AliPoissonCalculator(); |
ce63a99e | 43 | /** |
44 | * Constructor | |
45 | * | |
46 | */ | |
21d778b1 | 47 | AliPoissonCalculator(const char*/*, UShort_t d, Char_t r*/); |
d23503ee | 48 | /** |
ce63a99e | 49 | * Copy constructor |
50 | * | |
51 | * @param o Object to copy from | |
52 | */ | |
53 | AliPoissonCalculator(const AliPoissonCalculator& o); | |
54 | ||
55 | /** | |
56 | * Destructor | |
57 | */ | |
71b70904 | 58 | virtual ~AliPoissonCalculator(); |
ce63a99e | 59 | /** |
60 | * Assignment operator | |
61 | * | |
62 | * @param o Object to assign from | |
63 | * | |
64 | * @return Reference to this object | |
65 | */ | |
66 | AliPoissonCalculator& operator=(const AliPoissonCalculator& o); | |
67 | /** | |
68 | * Set the number of eta bins to group into a region | |
69 | * | |
290052e7 | 70 | * @param nx Number of @f$\eta@f$ bins per region |
71 | * @param ny Number of @f$\phi@f$ bins per region | |
ce63a99e | 72 | */ |
e18cb8bd | 73 | void SetLumping(UShort_t nx, UShort_t ny); |
21d778b1 | 74 | /** |
e18cb8bd | 75 | * Set the number of X bins to group into a region |
21d778b1 | 76 | * |
290052e7 | 77 | * @param nx Number of eta bins per region |
21d778b1 | 78 | */ |
e18cb8bd | 79 | void SetXLumping(UShort_t nx) { SetLumping(nx, fYLumping); } //*MENU* |
ce63a99e | 80 | /** |
e18cb8bd | 81 | * Set the number of Y bins to group into a region |
ce63a99e | 82 | * |
290052e7 | 83 | * @param ny Number of eta bins per region |
ce63a99e | 84 | */ |
e18cb8bd | 85 | void SetYLumping(UShort_t ny) { SetLumping(fYLumping, ny); } //*MENU* |
ce63a99e | 86 | /** |
87 | * Intialize this object | |
88 | * | |
e18cb8bd | 89 | * @param xLumping If larger than 0, set the eta lumping to this |
90 | * @param yLumping If larger than 0, set the phi lumping to this | |
ce63a99e | 91 | */ |
e18cb8bd | 92 | void Init(Int_t xLumping=-1, Int_t yLumping=-1); |
d23503ee | 93 | |
94 | /** | |
95 | * Initialize this object. | |
96 | * | |
97 | * Also book the cache histograms | |
290052e7 | 98 | * |
99 | * @param xaxis The X-axis | |
100 | * @param yaxis The Y-axis | |
d23503ee | 101 | */ |
102 | void Define(const TAxis& xaxis, const TAxis& yaxis); | |
79909b8b | 103 | /** |
104 | * Make output stuff for the passed list | |
105 | * | |
79909b8b | 106 | */ |
107 | void MakeOutput(); | |
ce63a99e | 108 | /** |
109 | * Output stuff to the passed list | |
110 | * | |
111 | * @param d List to add output histograms to | |
112 | */ | |
113 | void Output(TList* d); | |
114 | /** | |
115 | * Reset the cache histogram | |
116 | * | |
d23503ee | 117 | * @param base Base histogram |
ce63a99e | 118 | */ |
d23503ee | 119 | void Reset(const TH2D* base); |
ce63a99e | 120 | /** |
121 | * Fill in an observation | |
122 | * | |
290052e7 | 123 | * @param strip X axis bin number |
124 | * @param sec Y axis bin number | |
ce63a99e | 125 | * @param hit True if hit |
126 | * @param weight Weight if this | |
127 | */ | |
21d778b1 | 128 | void Fill(UShort_t strip, UShort_t sec, Bool_t hit, Double_t weight=1); |
ce63a99e | 129 | /** |
130 | * Calculate result and store in @a output | |
131 | * | |
290052e7 | 132 | * @param correct Whether to apply correction or not |
133 | * | |
ce63a99e | 134 | * @return The result histogram (fBase overwritten) |
135 | */ | |
e18cb8bd | 136 | TH2D* Result(Bool_t correct=true); |
ce63a99e | 137 | /** |
138 | * @return Always true | |
139 | */ | |
140 | Bool_t IsFolder() const { return kTRUE; } | |
141 | /** | |
142 | * Print information | |
143 | * | |
144 | * @param option Not used | |
145 | */ | |
71b70904 | 146 | void Print(const Option_t* option="") const; |
ce63a99e | 147 | /** |
148 | * Browse this object | |
149 | * | |
150 | * @param b Object to browse | |
151 | */ | |
71b70904 | 152 | void Browse(TBrowser* b); |
71b70904 | 153 | |
e18cb8bd | 154 | /** |
155 | * Get the empty versus total histogram | |
156 | * | |
157 | * @return Empty versus total | |
158 | */ | |
ce63a99e | 159 | TH2D* GetEmptyVsTotal() const { return fEmptyVsTotal; } |
e18cb8bd | 160 | /** |
161 | * Get the histogram of the means | |
162 | * | |
163 | * @return Means | |
164 | */ | |
ce63a99e | 165 | TH1D* GetMean() const { return fMean; } |
e18cb8bd | 166 | /** |
167 | * Get the occupancy histogram | |
168 | * | |
169 | * @return Occupancy histogram | |
170 | */ | |
ce63a99e | 171 | TH1D* GetOccupancy() const { return fOcc; } |
e18cb8bd | 172 | /** |
173 | * Get the correction histogram | |
174 | * | |
175 | * @return correction histogram | |
176 | */ | |
ce63a99e | 177 | TH2D* GetCorrection() const { return fCorr; } |
e18cb8bd | 178 | |
179 | /** | |
180 | * Get the X bin in the reduced historgam | |
181 | * | |
182 | * @param ix X bin in full histogram | |
183 | * | |
184 | * @return X bin in reduced histogram | |
185 | */ | |
186 | Int_t GetReducedXBin(Int_t ix) const; | |
187 | /** | |
188 | * Get the X bin in the reduced historgam | |
189 | * | |
190 | * @param x X value | |
191 | * | |
192 | * @return X bin in reduced histogram | |
193 | */ | |
194 | Int_t GetReducedXBin(Double_t x) const; | |
195 | /** | |
196 | * Get the Y bin in the reduced historgam | |
197 | * | |
198 | * @param iy Y bin in full histogram | |
199 | * | |
200 | * @return Y bin in reduced histogram | |
201 | */ | |
202 | Int_t GetReducedYBin(Int_t iy) const; | |
203 | /** | |
204 | * Get the Y bin in the reduced historgam | |
205 | * | |
206 | * @param y Y value | |
207 | * | |
208 | * @return Y bin in reduced histogram | |
209 | */ | |
210 | Int_t GetReducedYBin(Double_t y) const; | |
211 | ||
ce63a99e | 212 | protected: |
d23503ee | 213 | /** |
214 | * check that the lumping parameter makes sense | |
215 | * | |
216 | * @param which Which axis | |
217 | * @param nBins Number of bins | |
218 | * @param lumping Lumping | |
219 | * | |
220 | * @return The new value of the lumping | |
221 | */ | |
222 | Int_t CheckLumping(char which, Int_t nBins, Int_t lumping) const; | |
ce63a99e | 223 | /** |
224 | * Clean up allocated space | |
225 | * | |
226 | */ | |
227 | void CleanUp(); | |
228 | /** | |
229 | * Calculate the mean | |
230 | * | |
231 | * This is based on the fact that for a Poisson | |
232 | * @f[ | |
233 | * P(n;\lambda) = \frac{-\lambda^n e^{-\lambda}}{n!} | |
234 | * @f] | |
235 | * we have the probability for 0 observation | |
236 | * @f[ | |
237 | * P(0;\lambda) = e^{-\lambda} = \frac{N_{empty}}{N_{total}} | |
238 | * @f] | |
239 | * and so we get that the mean is the defined region is | |
240 | * @f[ | |
241 | * \lambda = -\log\left(\frac{N_{empty}}{N_{total}}\right) | |
242 | * @f] | |
243 | * | |
244 | * Note the boundary conditions | |
245 | * - @f$N_{total}=0 \rightarrow\lambda=0@f$ | |
246 | * - @f$N_{empty}<\epsilon\rightarrow N_{empty} = \epsilon@f$ | |
247 | * | |
248 | * @param empty Number of empty bins | |
249 | * @param total Total number of bins | |
250 | * | |
251 | * @return The mean in the defined region | |
252 | */ | |
253 | Double_t CalculateMean(Double_t empty, Double_t total) const; | |
254 | /** | |
255 | * The mean @f$\lambda@f$ calculated above is not the full story. | |
256 | * In addition it needs to be corrected using the expression | |
257 | * @f[ | |
258 | * \frac{1}{1-e^{\lambda}} = | |
259 | * \frac{1}{1-\frac{N_{empty}}{N_{total}}} | |
260 | * @f] | |
261 | * | |
262 | * Note the boundary conditions | |
263 | * - @f$N_{total}=0 \rightarrow\lambda=0@f$ | |
264 | * - @f$|N_{total}-N_{empty}|<\epsilon\rightarrow N_{empty} = | |
265 | * N_{total}-\epsilon@f$ | |
266 | * | |
267 | * @param empty Number of empty bins | |
268 | * @param total Total number of bins | |
269 | * | |
270 | * @return The correction to the mean. | |
271 | */ | |
272 | Double_t CalculateCorrection(Double_t empty, Double_t total) const; | |
e18cb8bd | 273 | UShort_t fXLumping; // Grouping of eta bins |
274 | UShort_t fYLumping; // Grouping of phi bins | |
ce63a99e | 275 | TH2D* fTotal; // Total number of strips in a region |
276 | TH2D* fEmpty; // Total number of strips in a region | |
277 | TH2D* fBasic; // Total number basic hits in a region | |
278 | TH2D* fEmptyVsTotal; // Empty versus total cells | |
279 | TH1D* fMean; // Mean calculated by poisson method | |
280 | TH1D* fOcc; // Histogram of occupancies | |
281 | TH2D* fCorr; // Correction as a function of mean | |
e18cb8bd | 282 | ClassDef(AliPoissonCalculator,2) // Calculate N_ch using Poisson |
71b70904 | 283 | }; |
284 | ||
ce63a99e | 285 | #endif |
71b70904 | 286 | // Local Variables: |
287 | // mode: C++ | |
288 | // End: | |
289 |