PWGLF/FORWARD/analysis2/AliFMDEnergyFitter.h

   1 //
   2 // Class to fit the energy distribution.
   3 //
   4 #ifndef ALIFMDENERGYFITTER_H
   5 #define ALIFMDENERGYFITTER_H
   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  *
  14  * @ingroup pwglf_forward_eloss
  15  */
  16 #include <TNamed.h>
  17 // #include <TH1D.h>
  18 #include <TAxis.h>
  19 #include <TList.h>
  20 #include <TObjArray.h>
  21 #include <TClonesArray.h>
  22 #include "AliFMDCorrELossFit.h"
  23 #include "AliForwardUtil.h"
  24 class TH1;
  25 class TH2;
  26 class AliESDFMD;
  27 class TFitResult;
  28 class TF1;
  29 class 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  *
  44  * @image html alice-int-2012-040-eloss_fits.png "Summary of fits"
  45  *
  46  * @ingroup pwglf_forward_algo
  47  * @ingroup pwglf_forward_eloss
  48  */
  49 class AliFMDEnergyFitter : public TNamed
  50 {
  51 public:
  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   };
  88
  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   };
 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);
 124
 125   // -----------------------------------------------------------------
 126   /**
 127    * @{
 128    * @name Setters of options and parameters
 129    */
 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);
 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);
 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; }
 171   /**
 172    * Set the number of bins to subtract
 173    *
 174    * @param n
 175    */
 176   void SetFitRangeBinWidth(UShort_t n=4) { fFitRangeBinWidth = n; }
 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    */
 184   void SetDoFits(Bool_t doFit=kTRUE) { fDoFits = doFit; }
 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; }
 192   /**
 193    * Set how many particles we will try to fit at most to the data
 194    *
 195    * @param n Max number of particle to try to fit
 196    */
 197   void SetNParticles(UShort_t n) { fNParticles = (n<1 ? 1 : (n>5 ? 5 : n)); }
 198   /**
 199    * Set the minimum number of entries each histogram must have
 200    * before we try to fit our response function to it
 201    *
 202    * @param n Minimum number of entries
 203    */
 204   void SetMinEntries(UShort_t n) { fMinEntries = (n < 1 ? 1 : n); }
 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; }
 217   /**
 218    * Set the maximum relative error
 219    *
 220    * @param e Maximum relative error
 221    */
 222   void SetMaxRelativeParameterError(Double_t e=0.2) { fMaxRelParError = e; }
 223   /**
 224    * Set the maximum @f$ \chi^2/\nu@f$
 225    *
 226    * @param c Maximum @f$ \chi^2/\nu@f$
 227    */
 228   void SetMaxChi2PerNDF(Double_t c=10) { fMaxChi2PerNDF = c; }
 229   /**
 230    * Set the least weight
 231    *
 232    * @param c Least weight
 233    */
 234   void SetMinWeight(Double_t c=1e-7) { fMinWeight = c; }
 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; }
 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   }
 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);
 318   /**
 319    * Fitter the input AliESDFMD object
 320    *
 321    * @param input     Input
 322    * @param cent      Event centrality (or < 0 if not valid)
 323    * @param empty     Whether the event is 'empty'
 324    *
 325    * @return True on success, false otherwise
 326    */
 327   virtual Bool_t Accumulate(const AliESDFMD& input,
 328                             Double_t         cent,
 329                             Bool_t           empty);
 330   /**
 331    * Scale the histograms to the total number of events
 332    *
 333    * @param dir Where the histograms are
 334    */
 335   virtual void Fit(const TList* dir);
 336   /**
 337    * Generate the corrections object
 338    *
 339    * @param dir List to analyse
 340    */
 341   void MakeCorrectionsObject(TList* dir);
 342   /** @} */
 343   /**
 344    * Print information
 345    *
 346    * @param option Not used
 347    */
 348   void Print(Option_t* option="") const;
 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);
 357 protected:
 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
 373   /**
 374    * Internal data structure to keep track of the histograms
 375    */
 376   struct RingHistos : public AliForwardUtil::RingHistos
 377   {
 378     typedef AliFMDCorrELossFit::ELossFit ELossFit_t;
 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     /**
 391      * Copy constructor - not defined
 392      *
 393      * @param o Object to copy from
 394      */
 395     RingHistos(const RingHistos& o);
 396     /**
 397      * Assignment operator  - not defined
 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();
 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);
 436     /**
 437      * Define outputs
 438      *
 439      * @param dir
 440      */
 441     virtual void CreateOutputObjects(TList* dir);
 442     /**
 443      * Initialise object
 444      *
 445      * @param eAxis      Eta axis
 446      * @param cAxis      Centrality axis
 447      * @param maxDE      Max energy loss to consider
 448      * @param nDEbins    Number of bins
 449      * @param useIncrBin Whether to use an increasing bin size
 450      */
 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);
 456     /**
 457      * Fill histogram
 458      *
 459      * @param empty  True if event is empty
 460      * @param eta    @f$ Eta@f$
 461      * @param icent  Centrality bin (1 based)
 462      * @param mult   Signal
 463      */
 464     virtual void Fill(Bool_t empty, Double_t eta, Int_t icent, Double_t mult);
 465     /**
 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.
 469      *
 470      * @param dir         Output list
 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$
 481      * @param minWeight   Least weight ot consider
 482      * @param regCut      Regularization cut-off
 483      * @param residuals   Mode for residual plots
 484      *
 485      * @return List of fit parameters
 486      */
 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
 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
 561      * @param minEntries  Least number of entries required
 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$
 570      * @param minWeight   Least weight ot consider
 571      * @param regCut      Regularization cut-off
 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)
 575      *
 576      * @return The best fit function
 577      */
 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;
 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      */
 602     virtual ELossFit_t* FindBestFit(const TH1* dist,
 603                                     Double_t   relErrorCut,
 604                                     Double_t   chi2nuCut,
 605                                     Double_t   minWeightCut) const;
 606     /**
 607      * Calculate residuals of the fit
 608      *
 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
 614      */
 615     virtual void CalculateResiduals(EResidualMethod  mode,
 616                                     Double_t         lowCut,
 617                                     TH1*             dist,
 618                                     ELossFit_t*      fit,
 619                                     TCollection*     out) const;
 620     /**
 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.
 627      *
 628      * @param d    Parent list
 629      * @param obj  Object to add fits to
 630      * @param eta  Eta axis
 631      */
 632     virtual void FindBestFits(const TList*        d,
 633                               AliFMDCorrELossFit& obj,
 634                               const TAxis&        eta);
 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      */
 644     TH1* MakePar(const char* name, const char* title, const TAxis& eta) const;
 645     /**
 646      * Make a histogram that contains the results of the fit over the
 647      * full ring
 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      */
 659     TH1* MakeTotal(const char*  name,
 660                     const char*  title,
 661                     const TAxis& eta,
 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;
 671     mutable TObjArray    fBest;
 672     mutable TClonesArray fFits;
 673     Int_t                fDebug;
 674     ClassDef(RingHistos,4);
 675   };
 676   virtual RingHistos* CreateRingHistos(UShort_t d, Char_t r) const;
 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;
 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);
 709
 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
 728   Double_t        fRegularizationCut; // When to regularize the chi^2
 729
 730   ClassDef(AliFMDEnergyFitter,6); //
 731 };
 732
 733 #endif
 734 // Local Variables:
 735 //  mode: C++
 736 // End: