Fix some documentation issues
[u/mrichter/AliRoot.git] / PWGLF / FORWARD / analysis2 / AliFMDEnergyFitter.h
CommitLineData
7984e5f7 1//
2// Class to fit the energy distribution.
3//
7c1a1f1d 4#ifndef ALIFMDENERGYFITTER_H
5#define ALIFMDENERGYFITTER_H
ffca499d 6/**
7 * @file AliFMDEnergyFitter.h
8 * @author Christian Holm Christensen <cholm@dalsgaard.hehi.nbi.dk>
9 * @date Wed Mar 23 14:02:23 2011
10 *
11 * @brief
12 *
13 *
bd6f5206 14 * @ingroup pwglf_forward_eloss
ffca499d 15 */
f8715167 16#include <TNamed.h>
0b7de667 17// #include <TH1D.h>
f8715167 18#include <TAxis.h>
19#include <TList.h>
20#include <TObjArray.h>
0bd4b00f 21#include <TClonesArray.h>
22#include "AliFMDCorrELossFit.h"
f8715167 23#include "AliForwardUtil.h"
0b7de667 24class TH1;
25class TH2;
f8715167 26class AliESDFMD;
27class TFitResult;
28class TF1;
29class TArrayD;
30
31/**
32 * Class to fit the energy distribution.
33 *
34 * @par Input:
35 * - AliESDFMD object - from reconstruction
36 *
37 * @par Output:
38 * - Lists of histogram - one per ring. Each list has a number of
39 * histograms corresponding to the number of eta bins defined.
40 *
41 * @par Corrections used:
42 * - None
43 *
671df6c9 44 * @image html alice-int-2012-040-eloss_fits.png "Summary of fits"
45 *
bd6f5206 46 * @ingroup pwglf_forward_algo
47 * @ingroup pwglf_forward_eloss
f8715167 48 */
49class AliFMDEnergyFitter : public TNamed
50{
51public:
e65b8b56 52 /**
53 * Enumeration of parameters
54 */
55 enum {
56 /** Index of pre-constant @f$ C@f$ */
57 kC = AliForwardUtil::ELossFitter::kC,
58 /** Index of most probable value @f$ \Delta_p@f$ */
59 kDelta = AliForwardUtil::ELossFitter::kDelta,
60 /** Index of Landau width @f$ \xi@f$ */
61 kXi = AliForwardUtil::ELossFitter::kXi,
62 /** Index of Gaussian width @f$ \sigma@f$ */
63 kSigma = AliForwardUtil::ELossFitter::kSigma,
64 /** Index of Gaussian additional width @f$ \sigma_n@f$ */
65 kSigmaN = AliForwardUtil::ELossFitter::kSigmaN,
66 /** Index of Number of particles @f$ N@f$ */
67 kN = AliForwardUtil::ELossFitter::kN,
68 /** Base index of particle strengths @f$ a_i@f$ for
69 @f$i=2,\ldots,N@f$ */
70 kA = AliForwardUtil::ELossFitter::kA
71 };
72 /**
73 * Enumeration of residual methods
74 */
75 enum EResidualMethod {
76 /** Do not calculate residuals */
77 kNoResiduals = 0,
78 /** The residuals stored are the difference, and the errors are
79 stored in the error bars of the histogram. */
80 kResidualDifference,
81 /** The residuals stored are the differences scaled to the error
82 on the data */
83 kResidualScaledDifference,
84 /** The residuals stored are the square difference scale to the
85 square error on the data. */
86 kResidualSquareDifference
87 };
c389303e 88
e65b8b56 89 /**
90 * FMD ring bits for skipping
91 */
92 enum FMDRingBits {
93 /** FMD1i */
94 kFMD1I=0x01,
95 /** All of FMD1 */
96 kFMD1 =kFMD1I,
97 /** FMD2i */
98 kFMD2I=0x02,
99 /** FMD2o */
100 kFMD2O=0x04,
101 /** All of FMD2 */
102 kFMD2 =kFMD2I|kFMD2O,
103 /** FMD3i */
104 kFMD3I=0x08,
105 /** FMD3o */
106 kFMD3O=0x10,
107 /** All of FMD3 */
108 kFMD3 =kFMD3I|kFMD3O
109 };
f8715167 110 /**
111 * Destructor
112 */
113 virtual ~AliFMDEnergyFitter();
114 /**
115 * Default Constructor - do not use
116 */
117 AliFMDEnergyFitter();
118 /**
119 * Constructor
120 *
121 * @param title Title of object - not significant
122 */
123 AliFMDEnergyFitter(const char* title);
f8715167 124
0b7de667 125 // -----------------------------------------------------------------
4b9857f3 126 /**
0b7de667 127 * @{
128 * @name Setters of options and parameters
4b9857f3 129 */
4b9857f3 130 /**
131 * Set the eta axis to use. This will force the code to use this
132 * eta axis definition - irrespective of whatever axis is passed to
133 * the Init member function. Therefore, this member function can be
134 * used to force another eta axis than one found in the correction
135 * objects.
136 *
137 * @param nBins Number of bins
138 * @param etaMin Minimum of the eta axis
139 * @param etaMax Maximum of the eta axis
140 */
141 void SetEtaAxis(Int_t nBins, Double_t etaMin, Double_t etaMax);
142 /**
143 * Set the eta axis to use. This will force the code to use this
144 * eta axis definition - irrespective of whatever axis is passed to
145 * the Init member function. Therefore, this member function can be
146 * used to force another eta axis than one found in the correction
147 * objects.
148 *
149 * @param etaAxis Eta axis to use
150 */
151 void SetEtaAxis(const TAxis& etaAxis);
5e4d905e 152 /**
153 * Set the centrality bins. E.g.,
154 * @code
155 * UShort_t n = 12;
156 * Double_t bins[] = { 0., 5., 10., 15., 20., 30.,
157 * 40., 50., 60., 70., 80., 100. };
158 * task->GetFitter().SetCentralityBins(n, bins);
159 * @endcode
160 *
161 * @param nBins Size of @a bins
162 * @param bins Bin limits.
163 */
164 void SetCentralityAxis(UShort_t nBins, Double_t* bins);
f8715167 165 /**
166 * Set the low cut used for energy
167 *
168 * @param lowCut Low cut
169 */
170 void SetLowCut(Double_t lowCut=0.3) { fLowCut = lowCut; }
4b9857f3 171 /**
172 * Set the number of bins to subtract
173 *
174 * @param n
175 */
c389303e 176 void SetFitRangeBinWidth(UShort_t n=4) { fFitRangeBinWidth = n; }
f8715167 177 /**
178 * Whether or not to enable fitting of the final merged result.
179 * Note, fitting takes quite a while and one should be careful not to do
180 * this needlessly
181 *
182 * @param doFit Whether to do the fits or not
183 */
c389303e 184 void SetDoFits(Bool_t doFit=kTRUE) { fDoFits = doFit; }
0bd4b00f 185 /**
186 * Set whether to make the corrections object on the output. Note,
187 * fits should be enable for this to have any effect.
188 *
189 * @param doMake If true (false is default), do make the corrections object.
190 */
191 void SetDoMakeObject(Bool_t doMake=kTRUE) { fDoMakeObject = doMake; }
f8715167 192 /**
c389303e 193 * Set how many particles we will try to fit at most to the data
f8715167 194 *
c389303e 195 * @param n Max number of particle to try to fit
f8715167 196 */
0b7de667 197 void SetNParticles(UShort_t n) { fNParticles = (n<1 ? 1 : (n>5 ? 5 : n)); }
f8715167 198 /**
c389303e 199 * Set the minimum number of entries each histogram must have
200 * before we try to fit our response function to it
f8715167 201 *
c389303e 202 * @param n Minimum number of entries
f8715167 203 */
204 void SetMinEntries(UShort_t n) { fMinEntries = (n < 1 ? 1 : n); }
4b9857f3 205 /**
206 * Set maximum energy loss to consider
207 *
208 * @param x Maximum energy loss to consider
209 */
210 void SetMaxE(Double_t x) { fMaxE = x; }
211 /**
212 * Set number of energy loss bins
213 *
214 * @param x Number of energy loss bins
215 */
216 void SetNEbins(Int_t x) { fNEbins = x; }
7c1a1f1d 217 /**
218 * Set the maximum relative error
219 *
220 * @param e Maximum relative error
221 */
0bd4b00f 222 void SetMaxRelativeParameterError(Double_t e=0.2) { fMaxRelParError = e; }
7c1a1f1d 223 /**
224 * Set the maximum @f$ \chi^2/\nu@f$
225 *
226 * @param c Maximum @f$ \chi^2/\nu@f$
227 */
0bd4b00f 228 void SetMaxChi2PerNDF(Double_t c=10) { fMaxChi2PerNDF = c; }
7c1a1f1d 229 /**
230 * Set the least weight
231 *
232 * @param c Least weight
233 */
0bd4b00f 234 void SetMinWeight(Double_t c=1e-7) { fMinWeight = c; }
4b9857f3 235 /**
236 * Set wheter to use increasing bin sizes
237 *
238 * @param x Wheter to use increasing bin sizes
239 */
240 void SetUseIncreasingBins(Bool_t x) { fUseIncreasingBins = x; }
e65b8b56 241 /**
242 * Set whether to make residuals, and in that case how.
243 *
244 * - Square difference: @f$chi_i^2=(h_i - f(x_i))^2/\delta_i^2@f$
245 * - Scaled difference: @f$(h_i - f(x_i))/\delta_i@f$
246 * - Difference: @f$(h_i - f(x_i)) \pm\delta_i@f$
247 *
248 * where @f$h_i, x_i, \delta_i@f$ is the bin content, bin center,
249 * and bin error for bin @f$i@f$ respectively, and @f$ f@f$ is the
250 * fitted function.
251 *
252 * @param x Residual method
253 */
254 void SetStoreResiduals(EResidualMethod x=kResidualDifference)
255 {
256 fResidualMethod = x;
257 }
258 /**
259 * Set the regularization cut @f$c_{R}@f$. If a @f$\Delta@f$
260 * distribution has more entries @f$ N_{dist}@f$ than @f$c_{R}@f$,
261 * then we modify the errors of the the distribution with the factor
262 *
263 * @f[
264 * \sqrt{N_{dist}/c_{R}}
265 * @f]
266 *
267 * to keep the @f$\chi^2/\nu@f$ within resonable limits.
268 *
269 * The large residuals @f$chi_i^2=(h_i - f(x_i))^2/\delta_i^2@f$
270 * (see also SetStoreResiduals) comes about on the boundary between
271 * the @f$N@f$ and @f$N+1@f$ particle contributions, and seems to
272 * fall off for larger @f$N@f$. This may indicate that there's a
273 * component in the distributions that the function
274 *
275 * @f[
276 * f(\Delta;\Delta_p,\xi,\sigma,\mathbf{a}) = \sum_i=1^{n} a_i\int
277 * d\Delta' L(\Delta;\Delta',\xi) G(\Delta';\Delta_p,\sigma)
278 * @f]
279 *
280 * does not capture.
281 *
282 * @param cut
283 */
284 void SetRegularizationCut(Double_t cut=3e6)
285 {
286 fRegularizationCut = cut;
287 }
0b7de667 288 void SetSkips(UShort_t skip) { fSkips = skip; }
289 /**
290 * Set the debug level. The higher the value the more output
291 *
292 * @param dbg Debug level
293 */
294 void SetDebug(Int_t dbg=1);
295 /* @} */
296 // -----------------------------------------------------------------
297 /**
298 * @{
299 * @name Processing
300 */
301 void Init();
302 /**
303 * Define the output histograms. These are put in a sub list of the
304 * passed list. The histograms are merged before the parent task calls
305 * AliAnalysisTaskSE::Terminate
306 *
307 * @param dir Directory to add to
308 */
309 virtual void CreateOutputObjects(TList* dir);
310 /**
311 * Initialise the task
312 *
313 * @param etaAxis The eta axis to use. Note, that if the eta axis
314 * has already been set (using SetEtaAxis), then this parameter will be
315 * ignored
316 */
317 virtual void SetupForData(const TAxis& etaAxis);
f8715167 318 /**
319 * Fitter the input AliESDFMD object
320 *
321 * @param input Input
5e4d905e 322 * @param cent Event centrality (or < 0 if not valid)
f8715167 323 * @param empty Whether the event is 'empty'
324 *
325 * @return True on success, false otherwise
326 */
0b7de667 327 virtual Bool_t Accumulate(const AliESDFMD& input,
328 Double_t cent,
329 Bool_t empty);
f8715167 330 /**
331 * Scale the histograms to the total number of events
332 *
c389303e 333 * @param dir Where the histograms are
f8715167 334 */
0b7de667 335 virtual void Fit(const TList* dir);
7c1a1f1d 336 /**
337 * Generate the corrections object
338 *
339 * @param dir List to analyse
340 */
0bd4b00f 341 void MakeCorrectionsObject(TList* dir);
0b7de667 342 /** @} */
0bd4b00f 343 /**
344 * Print information
345 *
346 * @param option Not used
347 */
348 void Print(Option_t* option="") const;
e65b8b56 349 /**
350 * Read the parameters from a list - used when re-running the code
351 *
352 * @param list Input list
353 *
354 * @return true if the parameter where read
355 */
356 Bool_t ReadParameters(const TCollection* list);
f8715167 357protected:
0b7de667 358 /**
359 * Copy constructor
360 *
361 * @param o Object to copy from
362 */
363 AliFMDEnergyFitter(const AliFMDEnergyFitter& o);
364 /**
365 * Assignment operator
366 *
367 * @param o Object to assign from
368 *
369 * @return Reference to this
370 */
371 AliFMDEnergyFitter& operator=(const AliFMDEnergyFitter& o);
372
f8715167 373 /**
374 * Internal data structure to keep track of the histograms
375 */
376 struct RingHistos : public AliForwardUtil::RingHistos
377 {
e65b8b56 378 typedef AliFMDCorrELossFit::ELossFit ELossFit_t;
f8715167 379 /**
380 * Default CTOR
381 */
382 RingHistos();
383 /**
384 * Constructor
385 *
386 * @param d detector
387 * @param r ring
388 */
389 RingHistos(UShort_t d, Char_t r);
390 /**
0b7de667 391 * Copy constructor - not defined
f8715167 392 *
393 * @param o Object to copy from
394 */
395 RingHistos(const RingHistos& o);
396 /**
0b7de667 397 * Assignment operator - not defined
f8715167 398 *
399 * @param o Object to assign from
400 *
401 * @return Reference to this
402 */
403 RingHistos& operator=(const RingHistos& o);
404 /**
405 * Destructor
406 */
407 ~RingHistos();
0b7de667 408 /**
409 * Make an axis with increasing bins
410 *
411 * @param n Number of bins
412 * @param min Minimum
413 * @param max Maximum
414 *
415 * @return An axis with quadratically increasing bin size
416 */
417 virtual TArrayD MakeIncreasingAxis(Int_t n,
418 Double_t min,
419 Double_t max) const;
420 /**
421 * Make E/E_mip histogram
422 *
423 * @param name Name of histogram
424 * @param title Title of histogram
425 * @param eAxis @f$\eta@f$ axis
426 * @param deMax Maximum energy loss
427 * @param nDeBins Number energy loss bins
428 * @param incr Whether to make bins of increasing size
429 */
430 TH2* Make(const char* name,
431 const char* title,
432 const TAxis& eAxis,
433 Double_t deMax=12,
434 Int_t nDeBins=300,
435 Bool_t incr=true);
f8715167 436 /**
437 * Define outputs
438 *
439 * @param dir
440 */
0b7de667 441 virtual void CreateOutputObjects(TList* dir);
f8715167 442 /**
443 * Initialise object
444 *
c389303e 445 * @param eAxis Eta axis
5e4d905e 446 * @param cAxis Centrality axis
c389303e 447 * @param maxDE Max energy loss to consider
448 * @param nDEbins Number of bins
449 * @param useIncrBin Whether to use an increasing bin size
f8715167 450 */
0b7de667 451 virtual void SetupForData(const TAxis& eAxis,
452 const TAxis& cAxis,
453 Double_t maxDE=10,
454 Int_t nDEbins=300,
455 Bool_t useIncrBin=true);
f8715167 456 /**
457 * Fill histogram
458 *
459 * @param empty True if event is empty
671df6c9 460 * @param eta @f$ Eta@f$
5e4d905e 461 * @param icent Centrality bin (1 based)
f8715167 462 * @param mult Signal
463 */
0b7de667 464 virtual void Fill(Bool_t empty, Double_t eta, Int_t icent, Double_t mult);
f8715167 465 /**
0b7de667 466 * Get the the 2D histogram eloss name from our sub-list of @a dir
467 * and call the Fit function described below (with &fBest) as last
468 * argument.
f8715167 469 *
c389303e 470 * @param dir Output list
c389303e 471 * @param lowCut Lower cut
472 * @param nParticles Max number of convolved landaus to fit
473 * @param minEntries Minimum number of entries
474 * @param minusBins Number of bins from peak to subtract to
475 * get the fit range
476 * @param relErrorCut Cut applied to relative error of parameter.
477 * Note, for multi-particle weights, the cut
478 * is loosend by a factor of 2
479 * @param chi2nuCut Cut on @f$ \chi^2/\nu@f$ -
480 * the reduced @f$\chi^2@f$
c8b1a7db 481 * @param minWeight Least weight ot consider
e65b8b56 482 * @param regCut Regularization cut-off
483 * @param residuals Mode for residual plots
290052e7 484 *
0b7de667 485 * @return List of fit parameters
f8715167 486 */
0b7de667 487 virtual TObjArray* Fit(TList* dir,
488 Double_t lowCut,
489 UShort_t nParticles,
490 UShort_t minEntries,
491 UShort_t minusBins,
492 Double_t relErrorCut,
493 Double_t chi2nuCut,
494 Double_t minWeight,
495 Double_t regCut,
496 EResidualMethod residuals) const;
497 /**
498 * Get the the 2D histogram @a name from our sub-list of @a
499 * dir. Then for each eta slice, try to fit the energu loss
500 * distribution up to @a nParticles particle responses.
501 *
502 * The fitted distributions (along with the functions fitted) are
503 * stored in a newly created sublist (<i>name</i>Dists).
504 *
505 * The fit parameters are also recorded in the newly created sub-list
506 * <i>name</i>Results.
507 *
508 * If @a residuals is not equal to kNoResiduals, then the
509 * residuals of the fits will be stored in the newly created
510 * sub-list <i>name</i>Residuals.
511 *
512 * A histogram named <i>name</i>Status is also generated and
513 * stored in the output list.
514 *
515 * @param dir Output list
516 * @param name Name of 2D base histogram in list
517 * @param lowCut Lower cut
518 * @param nParticles Max number of convolved landaus to fit
519 * @param minEntries Minimum number of entries
520 * @param minusBins Number of bins from peak to subtract to
521 * get the fit range
522 * @param relErrorCut Cut applied to relative error of parameter.
523 * Note, for multi-particle weights, the cut
524 * is loosend by a factor of 2
525 * @param chi2nuCut Cut on @f$ \chi^2/\nu@f$ -
526 * the reduced @f$\chi^2@f$
527 * @param minWeight Least weight ot consider
528 * @param regCut Regularization cut-off
529 * @param residuals Mode for residual plots
530 * @param scaleToPeak If true, scale distribution to peak value
531 * @param best Optional array to store fits in
532 *
533 * @return List of fit parameters
534 */
535 virtual TObjArray* FitSlices(TList* dir,
536 const char* name,
537 Double_t lowCut,
538 UShort_t nParticles,
539 UShort_t minEntries,
540 UShort_t minusBins,
541 Double_t relErrorCut,
542 Double_t chi2nuCut,
543 Double_t minWeight,
544 Double_t regCut,
545 EResidualMethod residuals,
546 Bool_t scaleToPeak=true,
547 TObjArray* best=0) const;
548
81775aba 549 /**
550 * Fit a signal histogram. First, the bin @f$ b_{min}@f$ with
551 * maximum bin content in the range @f$ [E_{min},\infty]@f$ is
552 * found. Then the fit range is set to the bin range
553 * @f$ [b_{min}-\Delta b,b_{min}+2\Delta b]@f$, and a 1
554 * particle signal is fitted to that. The parameters of that fit
555 * is then used as seeds for a fit of the @f$ N@f$ particle response
556 * to the data in the range
557 * @f$ [b_{min}-\Delta b,N(\Delta_1+\xi_1\log(N))+2N\xi@f$
558 *
559 * @param dist Histogram to fit
560 * @param lowCut Lower cut @f$ E_{min}@f$ on signal
671df6c9 561 * @param minEntries Least number of entries required
81775aba 562 * @param nParticles Max number @f$ N@f$ of convolved landaus to fit
563 * @param minusBins Number of bins @f$ \Delta b@f$ from peak to
564 * subtract to get the fit range
565 * @param relErrorCut Cut applied to relative error of parameter.
566 * Note, for multi-particle weights, the cut
567 * is loosend by a factor of 2
568 * @param chi2nuCut Cut on @f$ \chi^2/\nu@f$ -
569 * the reduced @f$\chi^2@f$
c8b1a7db 570 * @param minWeight Least weight ot consider
e65b8b56 571 * @param regCut Regularization cut-off
0b7de667 572 * @param scaleToPeak If true, scale distribution to peak value
573 * @param status On return, contain the status code (0: OK, 1:
574 * empty, 2: low statistics, 3: fit failed)
81775aba 575 *
576 * @return The best fit function
577 */
0b7de667 578 virtual ELossFit_t* FitHist(TH1* dist,
579 Double_t lowCut,
580 UShort_t nParticles,
581 UShort_t minEntries,
582 UShort_t minusBins,
583 Double_t relErrorCut,
584 Double_t chi2nuCut,
585 Double_t minWeight,
586 Double_t regCut,
587 Bool_t scaleToPeak,
588 UShort_t& status) const;
0bd4b00f 589 /**
590 * Find the best fit
591 *
592 * @param dist Histogram
593 * @param relErrorCut Cut applied to relative error of parameter.
594 * Note, for multi-particle weights, the cut
595 * is loosend by a factor of 2
596 * @param chi2nuCut Cut on @f$ \chi^2/\nu@f$ -
597 * the reduced @f$\chi^2@f$
598 * @param minWeightCut Least valid @f$ a_i@f$
599 *
600 * @return Best fit
601 */
0b7de667 602 virtual ELossFit_t* FindBestFit(const TH1* dist,
603 Double_t relErrorCut,
604 Double_t chi2nuCut,
605 Double_t minWeightCut) const;
f8715167 606 /**
0b7de667 607 * Calculate residuals of the fit
f8715167 608 *
0b7de667 609 * @param mode How to calculate
610 * @param lowCut Lower cut
611 * @param dist Distribution
612 * @param fit Function fitted to distribution
613 * @param out Output list to store residual histogram in
f8715167 614 */
0b7de667 615 virtual void CalculateResiduals(EResidualMethod mode,
616 Double_t lowCut,
617 TH1* dist,
618 ELossFit_t* fit,
619 TCollection* out) const;
f8715167 620 /**
0b7de667 621 * Find the best fits. This assumes that the array fBest has been
622 * filled with the best possible fits for each eta bin, and that
623 * the fits are placed according to the bin number of the eta bin.
624 *
625 * This is called by the parent class when generating the corretion
626 * object.
f8715167 627 *
0b7de667 628 * @param d Parent list
629 * @param obj Object to add fits to
630 * @param eta Eta axis
f8715167 631 */
0b7de667 632 virtual void FindBestFits(const TList* d,
633 AliFMDCorrELossFit& obj,
634 const TAxis& eta);
f8715167 635 /**
636 * Make a parameter histogram
637 *
638 * @param name Name of histogram.
639 * @param title Title of histogram.
640 * @param eta Eta axis
641 *
642 * @return
643 */
0b7de667 644 TH1* MakePar(const char* name, const char* title, const TAxis& eta) const;
4b9857f3 645 /**
0b7de667 646 * Make a histogram that contains the results of the fit over the
647 * full ring
4b9857f3 648 *
649 * @param name Name
650 * @param title Title
651 * @param eta Eta axis
652 * @param low Least bin
653 * @param high Largest bin
654 * @param val Value of parameter
655 * @param err Error on parameter
656 *
657 * @return The newly allocated histogram
658 */
0b7de667 659 TH1* MakeTotal(const char* name,
660 const char* title,
f8715167 661 const TAxis& eta,
0b7de667 662 Int_t low,
663 Int_t high,
664 Double_t val,
665 Double_t err) const;
666 TH1* fEDist; // Ring energy distribution
667 TH1* fEmpty; // Ring energy dist for empty events
668 TH2* fHist; // Two dimension Delta distribution
669 // TList* fEtaEDists; // Energy distributions per eta bin.
670 TList* fList;
81775aba 671 mutable TObjArray fBest;
672 mutable TClonesArray fFits;
0b7de667 673 Int_t fDebug;
674 ClassDef(RingHistos,4);
f8715167 675 };
0b7de667 676 virtual RingHistos* CreateRingHistos(UShort_t d, Char_t r) const;
f8715167 677 /**
678 * Get the ring histogram container
679 *
680 * @param d Detector
681 * @param r Ring
682 *
683 * @return Ring histogram container
684 */
685 RingHistos* GetRingHistos(UShort_t d, Char_t r) const;
e65b8b56 686 /**
687 * Check if the detector @a d, ring @a r is listed <i>in</i> the @a
688 * skips bit mask. If the detector/ring is in the mask, return true.
689 *
690 * That is, use case is
691 * @code
692 * for (UShort_t d=1. d<=3, d++) {
693 * UShort_t nr = (d == 1 ? 1 : 2);
694 * for (UShort_t q = 0; q < nr; q++) {
695 * Char_t r = (q == 0 ? 'I' : 'O');
696 * if (CheckSkips(d, r, skips)) continue;
697 * // Process detector/ring
698 * }
699 * }
700 * @endcode
701 *
702 * @param d Detector
703 * @param r Ring
704 * @param skips Mask of detector/rings to skip
705 *
706 * @return True if detector @a d, ring @a r is in the mask @a skips
707 */
708 static Bool_t CheckSkip(UShort_t d, Char_t r, UShort_t skips);
f8715167 709
0b7de667 710 TList fRingHistos; // List of histogram containers
711 Double_t fLowCut; // Low cut on energy
712 UShort_t fNParticles; // Number of landaus to try to fit
713 UShort_t fMinEntries; // Minimum number of entries
714 UShort_t fFitRangeBinWidth; // N-bins to subtract from found max
715 Bool_t fDoFits; // Whether to actually do the fits
716 Bool_t fDoMakeObject; // Whether to make corrections object
717 TAxis fEtaAxis; // Eta axis
718 TAxis fCentralityAxis; // Centrality axis
719 Double_t fMaxE; // Maximum energy loss to consider
720 Int_t fNEbins; // Number of energy loss bins
721 Bool_t fUseIncreasingBins; // Wheter to use increasing bin sizes
722 Double_t fMaxRelParError; // Relative error cut
723 Double_t fMaxChi2PerNDF; // chi^2/nu cit
724 Double_t fMinWeight; // Minimum weight value
725 Int_t fDebug; // Debug level
726 EResidualMethod fResidualMethod; // Whether to store residuals (debugging)
727 UShort_t fSkips; // Rings to skip when fitting
e65b8b56 728 Double_t fRegularizationCut; // When to regularize the chi^2
f8715167 729
0b7de667 730 ClassDef(AliFMDEnergyFitter,6); //
f8715167 731};
732
733#endif
734// Local Variables:
735// mode: C++
736// End: