]>
Commit | Line | Data |
---|---|---|
7984e5f7 | 1 | // Object holding the Energy loss fit 'correction' |
2 | // | |
3 | // These are generated from Monte-Carlo or real ESDs. | |
4 | #ifndef ALIFMDCORRELOSSFIT_H | |
5 | #define ALIFMDCORRELOSSFIT_H | |
ffca499d | 6 | /** |
7 | * @file AliFMDCorrELossFit.h | |
8 | * @author Christian Holm Christensen <cholm@dalsgaard.hehi.nbi.dk> | |
9 | * @date Wed Mar 23 14:01:15 2011 | |
10 | * | |
11 | * @brief | |
12 | * | |
bd6f5206 | 13 | * @ingroup pwglf_forward_eloss |
ffca499d | 14 | * |
15 | */ | |
0bd4b00f | 16 | #include <TObject.h> |
17 | #include <TAxis.h> | |
18 | #include <TObjArray.h> | |
19 | class TF1; | |
20 | class TBrowser; | |
21 | ||
7c1a1f1d | 22 | /** |
bd6f5206 | 23 | * @defgroup pwglf_forward_corr Corrections |
7c1a1f1d | 24 | * |
290052e7 | 25 | * Correction objects used |
26 | * | |
bd6f5206 | 27 | * @ingroup pwglf_forward |
7c1a1f1d | 28 | */ |
0bd4b00f | 29 | /** |
30 | * Object holding the Energy loss fit 'correction' | |
31 | * | |
32 | * These are generated from Monte-Carlo or real ESDs. | |
33 | * | |
bd6f5206 | 34 | * @ingroup pwglf_forward_corr |
35 | * @ingroup pwglf_forward_eloss | |
0bd4b00f | 36 | */ |
37 | class AliFMDCorrELossFit : public TObject | |
38 | { | |
39 | public: | |
40 | /** | |
41 | * POD structure to hold data from fits | |
42 | * | |
bd6f5206 | 43 | * @ingroup pwglf_forward_corr |
0bd4b00f | 44 | */ |
45 | struct ELossFit : public TObject | |
46 | { | |
47 | Int_t fN; // Number of peaks fitted | |
48 | UShort_t fNu; // Number degrees of freedom | |
49 | Double_t fChi2; // Chi square from fit | |
50 | Double_t fC; // Scaling constant | |
51 | Double_t fDelta; // Most probable value | |
52 | Double_t fXi; // Width parameter of Landau | |
53 | Double_t fSigma; // Sigma on folded gaussian | |
54 | Double_t fSigmaN; // Sigma of detector noise | |
55 | Double_t* fA; // [fN] Weights | |
56 | Double_t fEC; // Error on C | |
57 | Double_t fEDelta; // Error on Delta | |
58 | Double_t fEXi; // Error on Xi | |
59 | Double_t fESigma; // Error on sigma | |
60 | Double_t fESigmaN;// Error on sigma (noise) | |
61 | Double_t* fEA; // [fN] Error on weights | |
62 | Int_t fQuality;// Assigned quality | |
63 | UShort_t fDet; // Detector | |
64 | Char_t fRing; // Ring | |
65 | UShort_t fBin; // Eta bin | |
66 | ||
67 | static Double_t fgMaxRelError; // Global default max relative error | |
68 | static Double_t fgLeastWeight; // Global default least weight | |
69 | static Double_t fgMaxChi2nu; // Global default maximum reduced chi^2 | |
70 | /** | |
71 | * Default constructor | |
72 | * | |
73 | */ | |
74 | ELossFit(); | |
75 | /** | |
76 | * Construct from a function | |
77 | * | |
78 | * @param quality Quality flag | |
79 | * @param f Function | |
80 | */ | |
81 | ELossFit(Int_t quality,const TF1& f); | |
82 | /** | |
83 | * Constructor with full parameter set | |
84 | * | |
0bd4b00f | 85 | * @param quality Quality flag |
86 | * @param n @f$ N@f$ - Number of fitted peaks | |
87 | * @param chi2 @f$ \chi^2 @f$ | |
88 | * @param nu @f$ \nu @f$ - number degrees of freedom | |
7c1a1f1d | 89 | * @param c @f$ C@f$ - scale constant |
0bd4b00f | 90 | * @param ec @f$ \delta C@f$ - error on @f$ C@f$ |
7c1a1f1d | 91 | * @param delta @f$ \Delta@f$ - Most probable value |
0bd4b00f | 92 | * @param edelta @f$ \delta\Delta@f$ - error on @f$\Delta@f$ |
7c1a1f1d | 93 | * @param xi @f$ \xi@f$ - width |
0bd4b00f | 94 | * @param exi @f$ \delta\xi@f$ - error on @f$\xi@f$ |
7c1a1f1d | 95 | * @param sigma @f$ \sigma@f$ - Width of Gaussian |
0bd4b00f | 96 | * @param esigma @f$ \delta\sigma@f$ - error on @f$\sigma@f$ |
7c1a1f1d | 97 | * @param sigman @f$ \sigma_n@f$ - Noise width |
0bd4b00f | 98 | * @param esigman @f$ \delta\sigma_n@f$ - error on @f$\sigma_n@f$ |
99 | * @param a Array of @f$ N-1@f$ weights @f$ a_i@f$ for | |
100 | * @f$ i=2,\ldots@f$ | |
7c1a1f1d | 101 | * @param ea Array of @f$ N-1@f$ error on the weights @f$ a_i@f$ for |
102 | * @f$ i=2,\ldots@f$ | |
0bd4b00f | 103 | */ |
104 | ELossFit(Int_t quality,UShort_t n, | |
105 | Double_t chi2, UShort_t nu, | |
106 | Double_t c, Double_t ec, | |
107 | Double_t delta, Double_t edelta, | |
108 | Double_t xi, Double_t exi, | |
109 | Double_t sigma, Double_t esigma, | |
110 | Double_t sigman, Double_t esigman, | |
fb3430ac | 111 | const Double_t* a,const Double_t* ea); |
0bd4b00f | 112 | /** |
113 | * Copy constructor | |
114 | * | |
115 | * @param o Object to copy from | |
116 | */ | |
117 | ELossFit(const ELossFit& o); | |
118 | /** | |
119 | * Assignment operator | |
120 | * | |
121 | * @param o Object to assign from | |
122 | * | |
123 | * @return Reference to this object | |
124 | */ | |
125 | ELossFit& operator=(const ELossFit& o); | |
126 | /** | |
127 | * Destructor | |
128 | */ | |
129 | ~ELossFit(); | |
130 | /** | |
131 | * @{ | |
132 | * @name Access to parameters | |
133 | */ | |
134 | /** | |
135 | * @return Number of peaks fitted | |
136 | */ | |
137 | Int_t GetN() const { return fN; } | |
138 | /** | |
139 | * @return Number degrees of freedom | |
140 | */ | |
141 | UShort_t GetNu() const { return fNu; } | |
142 | /** | |
143 | * @return Chi square from fit | |
144 | */ | |
145 | Double_t GetChi2() const { return fChi2; } | |
146 | /** | |
147 | * @return Scaling constant | |
148 | */ | |
149 | Double_t GetC() const { return fC; } | |
150 | /** | |
151 | * @return Most probable value | |
152 | */ | |
153 | Double_t GetDelta() const { return fDelta; } | |
154 | /** | |
155 | * @return Width parameter of Landau | |
156 | */ | |
157 | Double_t GetXi() const { return fXi; } | |
158 | /** | |
159 | * @return Sigma on folded gaussian | |
160 | */ | |
161 | Double_t GetSigma() const { return fSigma; } | |
162 | /** | |
163 | * @return Sigma of detector noise | |
164 | */ | |
165 | Double_t GetSigmaN() const { return fSigmaN; } | |
166 | /** | |
167 | * @return Weights | |
168 | */ | |
169 | Double_t* GetAs() const { return fA; } | |
170 | /** | |
290052e7 | 171 | * @param i Which weight to get |
172 | * | |
0bd4b00f | 173 | * @return Weights |
174 | */ | |
175 | Double_t GetA(UShort_t i) const; | |
176 | /** | |
177 | * @return Error on C | |
178 | */ | |
179 | Double_t GetEC() const { return fEC; } | |
180 | /** | |
181 | * @return Error on Delta | |
182 | */ | |
183 | Double_t GetEDelta() const { return fEDelta; } | |
184 | /** | |
185 | * @return Error on Xi | |
186 | */ | |
187 | Double_t GetEXi() const { return fEXi; } | |
188 | /** | |
189 | * @return Error on sigma | |
190 | */ | |
191 | Double_t GetESigma() const { return fESigma; } | |
192 | /** | |
193 | * @return Error on sigma (noise) | |
194 | */ | |
195 | Double_t GetESigmaN() const { return fESigmaN; } | |
196 | /** | |
197 | * @return Error on weights | |
198 | */ | |
199 | Double_t* GetEAs() const { return fEA; } | |
200 | /** | |
290052e7 | 201 | * @param i Which weight to get |
202 | * | |
0bd4b00f | 203 | * @return Error on weights |
204 | */ | |
205 | Double_t GetEA(UShort_t i) const; | |
206 | /** | |
207 | * @return Assigned quality | |
208 | */ | |
209 | Int_t GetQuality() const { return fQuality; } | |
210 | /** | |
211 | * @return Detector | |
212 | */ | |
213 | UShort_t GetDet() const { return fDet; } | |
214 | /** | |
215 | * @return Ring | |
216 | */ | |
217 | Char_t GetRing() const { return fRing; } | |
218 | /** | |
219 | * @return Eta bin | |
220 | */ | |
221 | UShort_t GetBin() const { return fBin; } | |
222 | /* @} */ | |
223 | ||
224 | /** | |
225 | * @{ | |
226 | * @name Evaluation | |
227 | */ | |
228 | /** | |
229 | * Evaluate | |
230 | * @f[ | |
231 | * f_N(x;\Delta,\xi,\sigma') = | |
232 | * \sum_{i=1}^{n} a_i f(x;\Delta_i,\xi_i,\sigma_i') | |
233 | * @f] | |
234 | * | |
235 | * (see AliForwardUtil::NLandauGaus) for the maximum @f$ N @f$ | |
236 | * that fulfills the requirements | |
237 | * | |
238 | * @param x Where to evaluate | |
239 | * @param maxN @f$ \max{N}@f$ | |
240 | * | |
241 | * @return @f$ f_N(x;\Delta,\xi,\sigma')@f$ | |
242 | */ | |
243 | Double_t Evaluate(Double_t x, | |
244 | UShort_t maxN=999) const; | |
245 | /** | |
246 | * Evaluate | |
247 | * @f[ | |
248 | * f_W(x;\Delta,\xi,\sigma') = | |
249 | * \frac{\sum_{i=1}^{n} i a_i f_i(x;\Delta,\xi,\sigma')}{ | |
250 | * f_N(x;\Delta,\xi,\sigma')} = | |
251 | * \frac{\sum_{i=1}^{n} i a_i f(x;\Delta_i,\xi_i,\sigma_i')}{ | |
252 | * \sum_{i=1}^{n} a_i f(x;\Delta_i,\xi_i,\sigma_i')} | |
253 | * @f] | |
254 | * where @f$ n@f$ fulfills the requirements (see FindMaxWeight). | |
255 | * | |
256 | * If the denominator is zero, then 1 is returned. | |
257 | * | |
258 | * See also AliForwardUtil::ILandauGaus and AliForwardUtil::NLandauGaus | |
259 | * for more information on the evaluated functions. | |
260 | * | |
261 | * @param x Where to evaluate | |
262 | * @param maxN @f$ \max{N}@f$ | |
263 | * | |
264 | * @return @f$ f_W(x;\Delta,\xi,\sigma')@f$. | |
265 | */ | |
266 | Double_t EvaluateWeighted(Double_t x, | |
267 | UShort_t maxN=9999) const; | |
268 | /** | |
269 | * Find the maximum weight to use. The maximum weight is the | |
270 | * largest i for which | |
271 | * | |
272 | * - @f$ i \leq \max{N}@f$ | |
273 | * - @f$ a_i > \min{a}@f$ | |
274 | * - @f$ \delta a_i/a_i > \delta_{max}@f$ | |
275 | * | |
276 | * @param maxRelError @f$ \min{a}@f$ | |
277 | * @param leastWeight @f$ \delta_{max}@f$ | |
278 | * @param maxN @f$ \max{N}@f$ | |
279 | * | |
280 | * @return The largest index @f$ i@f$ for which the above | |
281 | * conditions hold. Will never return less than 1. | |
282 | */ | |
283 | Int_t FindMaxWeight(Double_t maxRelError=2*fgMaxRelError, | |
284 | Double_t leastWeight=fgLeastWeight, | |
285 | UShort_t maxN=999) const; | |
286 | /* @} */ | |
287 | /** | |
288 | * @{ | |
289 | * @name TObject Sortable interface | |
290 | */ | |
291 | /** | |
292 | * Declare this object as sortable | |
293 | * | |
294 | * @return Always true | |
295 | */ | |
296 | Bool_t IsSortable() const { return kTRUE; } | |
297 | /** | |
298 | * Compare to another ELossFit object. | |
299 | * | |
300 | * - +1, if this quality is better (larger) than other objects quality | |
301 | * - -1, if this quality is worse (smaller) than other objects quality | |
302 | * - +1, if this @f$|\chi^2/\nu-1|@f$ is smaller than the same for other | |
303 | * - -1, if this @f$|\chi^2/\nu-1|@f$ is larger than the same for other | |
304 | * - 0 otherwise | |
305 | * | |
306 | * @param o Other object to compare to | |
290052e7 | 307 | * |
308 | * @return See above | |
0bd4b00f | 309 | */ |
310 | Int_t Compare(const TObject* o) const; | |
311 | /* @} */ | |
312 | /** | |
313 | * @{ | |
314 | * name Auxiliary member functions | |
315 | */ | |
316 | /** | |
317 | * Information to standard output | |
318 | * | |
319 | * @param option Not used | |
320 | */ | |
321 | void Print(Option_t* option) const; // *MENU* | |
322 | /** | |
323 | * Draw this fit | |
324 | * | |
325 | * @param option Options | |
326 | * - COMP Draw components too | |
327 | */ | |
328 | void Draw(Option_t* option="comp"); // *MENU* | |
329 | /** | |
330 | * Browse this object | |
331 | * | |
332 | * @param b Browser | |
333 | */ | |
334 | void Browse(TBrowser* b); | |
335 | /** | |
336 | * Get the name of this object | |
337 | * | |
338 | * | |
339 | * @return | |
340 | */ | |
341 | const Char_t* GetName() const; | |
5bb5d1f6 | 342 | /** |
343 | * Calculate the lower bound | |
344 | * | |
345 | * @param f Width factor | |
346 | * @param includeSigma Whether to include sigma | |
347 | * | |
348 | * @return @f$ \Delta - f (\xi + \sigma)@f$ | |
349 | */ | |
350 | Double_t GetLowerBound(Double_t f, Bool_t includeSigma) const; | |
16ac05a3 | 351 | /** |
352 | * Calculate the lower bound | |
353 | * | |
354 | * @param f fraction of @f$\Delta@f$ | |
355 | * | |
356 | * @return @f$ f\Delta@f$ | |
357 | */ | |
358 | Double_t GetLowerBound(Double_t f) const; | |
0bd4b00f | 359 | /** |
360 | * Calculate the quality | |
290052e7 | 361 | * |
362 | * @param maxChi2nu Maximum reduced @f$\chi^2@f$ | |
363 | * @param maxRelError Maximum relative error | |
364 | * @param leastWeight Least weight to use | |
0bd4b00f | 365 | */ |
366 | void CalculateQuality(Double_t maxChi2nu=fgMaxChi2nu, | |
367 | Double_t maxRelError=fgMaxRelError, | |
368 | Double_t leastWeight=fgLeastWeight); | |
369 | /* @} */ | |
370 | ClassDef(ELossFit,1); // Result of fit | |
371 | }; | |
372 | ||
373 | /** | |
374 | * Default constructor | |
375 | */ | |
376 | AliFMDCorrELossFit(); | |
377 | /** | |
378 | * Copy constructor | |
379 | * | |
380 | * @param o Object to copy from | |
381 | */ | |
382 | AliFMDCorrELossFit(const AliFMDCorrELossFit& o); | |
383 | /** | |
384 | * Destructor | |
385 | */ | |
386 | virtual ~AliFMDCorrELossFit(); | |
387 | /** | |
388 | * Assignment operator | |
389 | * | |
390 | * @param o Object to assign from | |
391 | * | |
392 | * @return Reference to this object | |
393 | */ | |
394 | AliFMDCorrELossFit& operator=(const AliFMDCorrELossFit& o); | |
395 | ||
396 | /** | |
397 | * @{ | |
398 | * @name Set fits | |
399 | */ | |
400 | /** | |
401 | * Set the fit parameters from a function | |
402 | * | |
403 | * @param d Detector | |
404 | * @param r Ring | |
405 | * @param eta Eta | |
406 | * @param quality Quality flag | |
407 | * @param f Function from fit | |
290052e7 | 408 | * |
409 | * @return true on success | |
0bd4b00f | 410 | */ |
411 | Bool_t SetFit(UShort_t d, Char_t r, Double_t eta, Int_t quality, | |
412 | const TF1& f); | |
413 | /** | |
414 | * Set the fit parameters from a function | |
415 | * | |
416 | * @param d Detector | |
417 | * @param r Ring | |
418 | * @param eta Eta | |
419 | * @param f ELoss fit result - note, the object will take ownership | |
290052e7 | 420 | * |
421 | * @return true on success | |
0bd4b00f | 422 | */ |
423 | Bool_t SetFit(UShort_t d, Char_t r, Double_t eta, ELossFit* f); | |
424 | /** | |
425 | * Set the fit parameters from a function | |
426 | * | |
7c1a1f1d | 427 | * @param d Detector |
428 | * @param r Ring | |
429 | * @param etaBin Eta (bin number, 1->nBins) | |
430 | * @param f ELoss fit result - note, the object will take ownership | |
290052e7 | 431 | * |
432 | * @return true on success | |
0bd4b00f | 433 | */ |
434 | Bool_t SetFit(UShort_t d, Char_t r, Int_t etaBin, ELossFit* f); | |
435 | /** | |
436 | * Set the fit parameters from a function | |
437 | * | |
438 | * @param d Detector number | |
439 | * @param r Ring identifier | |
7c1a1f1d | 440 | * @param eta Eta value |
0bd4b00f | 441 | * @param quality Quality flag |
442 | * @param n @f$ N@f$ - Number of fitted peaks | |
443 | * @param chi2 @f$ \chi^2 @f$ | |
444 | * @param nu @f$ \nu @f$ - number degrees of freedom | |
7c1a1f1d | 445 | * @param c @f$ C@f$ - scale constant |
0bd4b00f | 446 | * @param ec @f$ \delta C@f$ - error on @f$ C@f$ |
7c1a1f1d | 447 | * @param delta @f$ \Delta@f$ - most probable value |
0bd4b00f | 448 | * @param edelta @f$ \delta\Delta@f$ - error on @f$\Delta@f$ |
7c1a1f1d | 449 | * @param xi @f$ \xi@f$ - Landau width |
0bd4b00f | 450 | * @param exi @f$ \delta\xi@f$ - error on @f$\xi@f$ |
7c1a1f1d | 451 | * @param sigma @f$ \sigma@f$ - Gaussian width |
0bd4b00f | 452 | * @param esigma @f$ \delta\sigma@f$ - error on @f$\sigma@f$ |
7c1a1f1d | 453 | * @param sigman @f$ \sigma_n@f$ - Noise width |
0bd4b00f | 454 | * @param esigman @f$ \delta\sigma_n@f$ - error on @f$\sigma_n@f$ |
455 | * @param a Array of @f$ N-1@f$ weights @f$ a_i@f$ for | |
456 | * @f$ i=2,\ldots@f$ | |
7c1a1f1d | 457 | * @param ea Array of @f$ N-1@f$ errors on weights @f$ a_i@f$ for |
458 | * @f$ i=2,\ldots@f$ | |
290052e7 | 459 | * |
460 | * @return true on success | |
0bd4b00f | 461 | */ |
462 | Bool_t SetFit(UShort_t d, Char_t r, Double_t eta, | |
463 | Int_t quality,UShort_t n, | |
464 | Double_t chi2, UShort_t nu, | |
465 | Double_t c, Double_t ec, | |
466 | Double_t delta, Double_t edelta, | |
467 | Double_t xi, Double_t exi, | |
468 | Double_t sigma, Double_t esigma, | |
469 | Double_t sigman, Double_t esigman, | |
470 | Double_t* a, Double_t* ea); | |
471 | /* @} */ | |
472 | ||
473 | /** | |
474 | * @{ | |
475 | * @name Set and get eta axis | |
476 | */ | |
477 | /** | |
478 | * Set the eta axis to use | |
479 | * | |
480 | * @param axis Eta axis | |
481 | */ | |
482 | void SetEtaAxis(const TAxis& axis); | |
483 | /** | |
484 | * Set the eta axis to use | |
485 | * | |
7c1a1f1d | 486 | * @param nBins Number of bins |
487 | * @param min Minimum @f$ \eta@f$ | |
488 | * @param max maximum @f$ \eta@f$ | |
0bd4b00f | 489 | */ |
490 | void SetEtaAxis(Int_t nBins, Double_t min, Double_t max); | |
491 | /** | |
492 | * Get the eta axis used | |
493 | * | |
494 | * @return | |
495 | */ | |
496 | const TAxis& GetEtaAxis() const { return fEtaAxis; } | |
497 | /** | |
498 | * Set the low cut used when fitting | |
499 | * | |
500 | * @param cut Cut value | |
501 | */ | |
502 | void SetLowCut(Double_t cut) { fLowCut = cut; } | |
503 | /** | |
504 | * Get the low cut used when fitting | |
505 | * | |
506 | * @return Low cut used for fitting | |
507 | */ | |
508 | Double_t GetLowCut() const { return fLowCut; } | |
509 | /** | |
510 | * Find the eta bin corresponding to the given eta | |
511 | * | |
512 | * @param eta Eta value | |
513 | * | |
514 | * @return Bin (in @f$[1,N_{bins}]@f$) corresponding to the given | |
515 | * eta, or 0 if out of range. | |
516 | */ | |
517 | Int_t FindEtaBin(Double_t eta) const; | |
518 | /* @} */ | |
519 | ||
520 | /** | |
521 | * @{ | |
522 | * @name Find fits | |
523 | */ | |
524 | /** | |
525 | * Find the fit corresponding to the specified parameters | |
526 | * | |
527 | * @param d Detector | |
528 | * @param r Ring | |
529 | * @param eta Eta value | |
530 | * | |
531 | * @return Fit parameters or null in case of problems | |
532 | */ | |
533 | ELossFit* FindFit(UShort_t d, Char_t r, Double_t eta) const; | |
534 | /** | |
535 | * Find the fit corresponding to the specified parameters | |
536 | * | |
537 | * @param d Detector | |
538 | * @param r Ring | |
539 | * @param etabin Eta bin (1 based) | |
540 | * | |
541 | * @return Fit parameters or null in case of problems | |
542 | */ | |
543 | ELossFit* FindFit(UShort_t d, Char_t r, Int_t etabin) const; | |
1174780f | 544 | /** |
545 | * Find the fit corresponding to the specified parameters | |
546 | * | |
547 | * @param d Detector | |
548 | * @param r Ring | |
549 | * @param eta Eta value | |
550 | * | |
551 | * @return Fit parameters or null in case of problems | |
552 | */ | |
553 | ELossFit* GetFit(UShort_t d, Char_t r, Double_t eta) const; | |
554 | /** | |
555 | * Find the fit corresponding to the specified parameters | |
556 | * | |
557 | * @param d Detector | |
558 | * @param r Ring | |
559 | * @param etabin Eta bin (1 based) | |
560 | * | |
561 | * @return Fit parameters or null in case of problems | |
562 | */ | |
563 | ELossFit* GetFit(UShort_t d, Char_t r, Int_t etabin) const; | |
0bd4b00f | 564 | /* @} */ |
565 | ||
5bb5d1f6 | 566 | /** |
567 | * @{ | |
568 | * @name Lower bounds on fits | |
569 | */ | |
16ac05a3 | 570 | /** |
571 | * Get the lower validity bound of the fit | |
572 | * | |
573 | * @param d Detector | |
574 | * @param r Ring | |
575 | * @param etaBin Eta bin (1-based) | |
576 | * @param f Fraction of @f$\Delta_{mp}@f$ | |
577 | * | |
578 | * @return @f$ f\Delta_{mp}@f$ | |
579 | */ | |
580 | Double_t GetLowerBound(UShort_t d, Char_t r, Int_t etaBin, | |
581 | Double_t f) const; | |
582 | /** | |
583 | * Get the lower validity bound of the fit | |
584 | * | |
585 | * @param d Detector | |
586 | * @param r Ring | |
587 | * @param eta Eta value | |
588 | * @param f Fraction of @f$\Delta_{mp}@f$ | |
589 | * | |
590 | * @return @f$ f\Delta_{mp}@f$ | |
591 | */ | |
592 | Double_t GetLowerBound(UShort_t d, Char_t r, Double_t eta, | |
593 | Double_t f) const; | |
5bb5d1f6 | 594 | /** |
595 | * Get the lower validity bound of the fit | |
596 | * | |
597 | * @param d Detector | |
598 | * @param r Ring | |
599 | * @param etaBin Eta bin (1-based) | |
600 | * @param f Factor on xi (and sigma) | |
601 | * @param showErrors Show errors | |
602 | * @param includeSigma Whether to include sigma | |
603 | * | |
604 | * @return @f$ \Delta_{mp} - f(\xi+\sigma)@f$ | |
605 | */ | |
606 | Double_t GetLowerBound(UShort_t d, Char_t r, Int_t etaBin, | |
16ac05a3 | 607 | Double_t f, Bool_t showErrors, |
608 | Bool_t includeSigma) const; | |
5bb5d1f6 | 609 | /** |
610 | * Get the lower validity bound of the fit | |
611 | * | |
612 | * @param d Detector | |
613 | * @param r Ring | |
614 | * @param eta Eta value | |
615 | * @param f Factor on xi (and sigma) | |
616 | * @param showErrors Show errors | |
617 | * @param includeSigma Whether to include sigma | |
618 | * | |
619 | * @return @f$ \Delta_{mp} - f(\xi+\sigma)@f$ | |
620 | */ | |
621 | Double_t GetLowerBound(UShort_t d, Char_t r, Double_t eta, | |
16ac05a3 | 622 | Double_t f, Bool_t showErrors, |
623 | Bool_t includeSigma) const; | |
5bb5d1f6 | 624 | |
625 | ||
0bd4b00f | 626 | /** |
627 | * @{ | |
628 | * @name Miscellaneous | |
629 | */ | |
630 | /** | |
631 | * Get the ring array corresponding to the specified ring | |
632 | * | |
633 | * @param d Detector | |
634 | * @param r Ring | |
635 | * | |
636 | * @return Pointer to ring array, or null in case of problems | |
637 | */ | |
638 | TObjArray* GetRingArray(UShort_t d, Char_t r) const; | |
639 | /** | |
640 | * Signal that this is a folder | |
641 | * | |
642 | * @return Always true | |
643 | */ | |
644 | Bool_t IsFolder() const { return true; } | |
645 | /** | |
646 | * Browse this object | |
647 | * | |
648 | * @param b | |
649 | */ | |
650 | void Browse(TBrowser* b); | |
651 | /** | |
652 | * Draw this object | |
653 | * | |
654 | * @param option Options. Possible values are | |
7dacdf84 | 655 | * - error Plot error bars |
656 | * - relative Plot relative errors | |
0bd4b00f | 657 | */ |
658 | void Draw(Option_t* option=""); //*MENU* | |
659 | /** | |
660 | * Print this object. | |
661 | * | |
662 | * @param option Options | |
663 | * - R Print recursive | |
664 | * | |
665 | */ | |
666 | void Print(Option_t* option="R") const; //*MENU* | |
c6115ede | 667 | /** |
668 | * Get a list of THStack - one for each parameter | |
669 | * | |
670 | * @param err Show errors | |
671 | * @param rel Show relative errors | |
672 | * @param maxN Maximum weight to use | |
673 | * | |
674 | * @return List of THStack | |
675 | */ | |
f7cfc454 | 676 | TList* GetStacks(Bool_t err, Bool_t rel, UShort_t maxN=5) const; |
0bd4b00f | 677 | /* @} */ |
678 | protected: | |
679 | /** | |
680 | * Get the ring array corresponding to the specified ring | |
681 | * | |
682 | * @param d Detector | |
683 | * @param r Ring | |
684 | * | |
685 | * @return Pointer to ring array, or newly created container | |
686 | */ | |
687 | TObjArray* GetOrMakeRingArray(UShort_t d, Char_t r); | |
688 | ||
689 | TObjArray fRings; // Array of rings | |
690 | TAxis fEtaAxis; // Eta axis used | |
691 | Double_t fLowCut; // Low cut used when fitting | |
692 | ||
693 | ClassDef(AliFMDCorrELossFit,2); | |
694 | }; | |
695 | ||
696 | //____________________________________________________________________ | |
697 | inline void | |
698 | AliFMDCorrELossFit::SetEtaAxis(Int_t nBins, Double_t min, Double_t max) | |
699 | { | |
700 | fEtaAxis.Set(nBins, min, max); | |
701 | } | |
702 | //____________________________________________________________________ | |
703 | inline void | |
704 | AliFMDCorrELossFit::SetEtaAxis(const TAxis& e) | |
705 | { | |
706 | fEtaAxis.Set(e.GetNbins(), e.GetXmin(), e.GetXmax()); | |
707 | } | |
708 | //____________________________________________________________________ | |
709 | inline Double_t | |
710 | AliFMDCorrELossFit::ELossFit::GetA(UShort_t i) const | |
711 | { | |
712 | if (i < 1) return 0; | |
713 | if (i > fN) return 0; | |
714 | if (i == 1) return 1; | |
715 | return fA[i-2]; | |
716 | } | |
717 | //____________________________________________________________________ | |
718 | inline Double_t | |
719 | AliFMDCorrELossFit::ELossFit::GetEA(UShort_t i) const | |
720 | { | |
721 | if (i < 1) return 0; | |
722 | if (i > fN) return 0; | |
723 | if (i == 1) return 1; | |
724 | return fEA[i-2]; | |
725 | } | |
726 | ||
727 | ||
728 | #endif | |
729 | // Local Variables: | |
730 | // mode: C++ | |
731 | // End: | |
732 |