PWGLF/FORWARD/analysis2/AliFMDCorrELossFit.h

   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
   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  *
  13  * @ingroup pwglf_forward_eloss
  14  *
  15  */
  16 #include <TObject.h>
  17 #include <TAxis.h>
  18 #include <TObjArray.h>
  19 class TF1;
  20 class TBrowser;
  21
  22 /**
  23  * @defgroup pwglf_forward_corr Corrections
  24  *
  25  * Correction objects used
  26  *
  27  * @ingroup pwglf_forward
  28  */
  29 /**
  30  * Object holding the Energy loss fit 'correction'
  31  *
  32  * These are generated from Monte-Carlo or real ESDs.
  33  *
  34  * @ingroup pwglf_forward_corr
  35  * @ingroup pwglf_forward_eloss
  36  */
  37 class AliFMDCorrELossFit : public TObject
  38 {
  39 public:
  40   /**
  41    * POD structure to hold data from fits
  42    *
  43    * @ingroup pwglf_forward_corr
  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      *
  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
  89      * @param c         @f$ C@f$ - scale constant
  90      * @param ec        @f$ \delta C@f$ - error on @f$ C@f$
  91      * @param delta     @f$ \Delta@f$ - Most probable value
  92      * @param edelta    @f$ \delta\Delta@f$ - error on @f$\Delta@f$
  93      * @param xi        @f$ \xi@f$ - width
  94      * @param exi       @f$ \delta\xi@f$ - error on @f$\xi@f$
  95      * @param sigma     @f$ \sigma@f$ - Width of Gaussian
  96      * @param esigma    @f$ \delta\sigma@f$ - error on @f$\sigma@f$
  97      * @param sigman    @f$ \sigma_n@f$ - Noise width
  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$
 101      * @param ea        Array of @f$ N-1@f$ error on the weights @f$ a_i@f$ for
 102      *                  @f$ i=2,\ldots@f$
 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,
 111              const Double_t* a,const Double_t* ea);
 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     /**
 171      * @param i Which weight to get
 172      *
 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     /**
 201      * @param i Which weight to get
 202      *
 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
 307      *
 308      * @return See above
 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;
 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;
 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;
 359     /**
 360      * Calculate the quality
 361      *
 362      * @param maxChi2nu   Maximum reduced @f$\chi^2@f$
 363      * @param maxRelError Maximum relative error
 364      * @param leastWeight Least weight to use
 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
 408    *
 409    * @return true on success
 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
 420    *
 421    * @return true on success
 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    *
 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
 431    *
 432    * @return true on success
 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
 440    * @param eta       Eta value
 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
 445    * @param c         @f$ C@f$ - scale constant
 446    * @param ec        @f$ \delta C@f$ - error on @f$ C@f$
 447    * @param delta     @f$ \Delta@f$ - most probable value
 448    * @param edelta    @f$ \delta\Delta@f$ - error on @f$\Delta@f$
 449    * @param xi        @f$ \xi@f$ - Landau width
 450    * @param exi       @f$ \delta\xi@f$ - error on @f$\xi@f$
 451    * @param sigma     @f$ \sigma@f$ - Gaussian width
 452    * @param esigma    @f$ \delta\sigma@f$ - error on @f$\sigma@f$
 453    * @param sigman    @f$ \sigma_n@f$ - Noise width
 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$
 457    * @param ea        Array of @f$ N-1@f$ errors on weights @f$ a_i@f$ for
 458    *                  @f$ i=2,\ldots@f$
 459    *
 460    * @return true on success
 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    *
 486    * @param nBins Number of bins
 487    * @param min   Minimum @f$ \eta@f$
 488    * @param max   maximum @f$ \eta@f$
 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;
 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;
 564   /* @} */
 565
 566   /**
 567    * @{
 568    * @name Lower bounds on fits
 569    */
 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;
 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,
 607                          Double_t f, Bool_t showErrors,
 608                          Bool_t includeSigma) const;
 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,
 622                          Double_t f, Bool_t showErrors,
 623                          Bool_t includeSigma) const;
 624
 625
 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
 655    *  - error Plot error bars
 656    *  - relative Plot relative errors
 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*
 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    */
 676   TList* GetStacks(Bool_t err, Bool_t rel, UShort_t maxN=5) const;
 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