AliFMDCorrELossFit.h

Go to the documentation of this file.

// Object holding the Energy loss fit 'correction'
// 
// These are generated from Monte-Carlo or real ESDs. 
#ifndef ALIFMDCORRELOSSFIT_H
#define ALIFMDCORRELOSSFIT_H

#include <TObject.h>
#include <TAxis.h>
#include <TObjArray.h>
#include <TArrayI.h>
class TF1;
class TH1;
class TBrowser;

class AliFMDCorrELossFit : public TObject 
{
public:
  enum {
    kHasShift = (1<<14),
    kIsGoodAsserted = (1<<15),
    kIsGood = (1<<16)
  };
  enum {
    kDefaultQuality = 8
  }; 
  struct ELossFit : public TObject 
  {
    Int_t     fN;      // Number of peaks fitted
    UShort_t  fNu;     // Number degrees of freedom
    Double_t  fChi2;   // Chi square from fit
    Double_t  fC;      // Scaling constant 
    Double_t  fDelta;  // Most probable value 
    Double_t  fXi;     // Width parameter of Landau 
    Double_t  fSigma;  // Sigma on folded gaussian 
    Double_t  fSigmaN; // Sigma of detector noise 
    Double_t* fA;      // [fN] Weights 
    Double_t  fEC;     // Error on C 
    Double_t  fEDelta; // Error on Delta 
    Double_t  fEXi;    // Error on Xi
    Double_t  fESigma; // Error on sigma 
    Double_t  fESigmaN;// Error on sigma (noise)
    Double_t* fEA;     // [fN] Error on weights
    Int_t     fQuality;// Assigned quality 
    UShort_t  fDet;    // Detector 
    Char_t    fRing;   // Ring
    UShort_t  fBin;    // Eta bin

    mutable UShort_t fMaxWeight; 

    static Double_t fgMaxRelError;  // Global default max relative error
    static Double_t fgLeastWeight;  // Global default least weight 
    static Double_t fgMaxChi2nu;    // Global default maximum reduced chi^2
    ELossFit();
    ELossFit(Int_t quality,const TF1& f);
    ELossFit(Int_t     quality,UShort_t  n, 
       Double_t  chi2,   UShort_t  nu, 
       Double_t  c,      Double_t  ec, 
       Double_t  delta,  Double_t  edelta, 
       Double_t  xi,     Double_t  exi,
       Double_t  sigma,  Double_t  esigma, 
       Double_t  sigman, Double_t  esigman, 
       const Double_t* a,const Double_t* ea);
    ELossFit(const ELossFit& o);
    ELossFit& operator=(const ELossFit& o);
    ~ELossFit();
    Int_t GetN() const { return fN; }
    UShort_t GetNu() const { return fNu; }
    Double_t GetChi2() const { return fChi2; }
    Double_t GetC() const { return fC; }
    Double_t GetDelta() const { return fDelta; }
    Double_t GetXi() const { return fXi; }
    Double_t GetSigma() const { return fSigma; }
    Double_t GetSigmaN() const { return fSigmaN; }
    Double_t* GetAs() const { return fA; }
    Double_t GetA(UShort_t i) const;    
    Double_t GetEC() const { return fEC; }
    Double_t GetEDelta() const { return fEDelta; }
    Double_t GetEXi() const { return fEXi; }
    Double_t GetESigma() const { return fESigma; }
    Double_t GetESigmaN() const { return fESigmaN; }
    Double_t* GetEAs() const { return fEA; }
    Double_t GetEA(UShort_t i) const;
    Int_t GetQuality() const { return fQuality; }
    UShort_t GetDet() const { return fDet; }
    Char_t GetRing() const { return fRing; }
    UShort_t GetBin() const { return fBin; }
    /* @} */

    Double_t Evaluate(Double_t x, 
          UShort_t maxN=999) const;
    Double_t EvaluateWeighted(Double_t x, 
            UShort_t maxN=9999) const;
    Int_t FindMaxWeight(Double_t maxRelError=2*fgMaxRelError, 
      Double_t leastWeight=fgLeastWeight, 
      UShort_t maxN=999) const;
    TF1* GetF1(Int_t i=0, Double_t max=20) const;
    /* @} */
    Double_t GetMpvCut(Double_t f) const;
    Double_t GetXiCut(Double_t f) const;
    Double_t GetXiSigmaCut(Double_t f) const;
    Double_t GetAvgXiSigmaCut(Double_t f) const;
    Double_t FindProbabilityCut(Double_t low) const;
    /* @} */
    Bool_t IsSortable() const { return kTRUE; }
    Int_t Compare(const TObject* o) const;
    /* @} */
    void Print(Option_t* option) const; // *MENU*
    void Draw(Option_t* option="comp"); // *MENU*
    void Browse(TBrowser* b);
    const Char_t* GetName() const;
    void CalculateQuality(Double_t maxChi2nu=fgMaxChi2nu, 
        Double_t maxRelError=fgMaxRelError, 
        Double_t leastWeight=fgLeastWeight);
    /* @} */
    ClassDef(ELossFit,2); // Result of fit 
  };

  AliFMDCorrELossFit();
  AliFMDCorrELossFit(const AliFMDCorrELossFit& o);
  virtual ~AliFMDCorrELossFit(); 
  AliFMDCorrELossFit& operator=(const AliFMDCorrELossFit& o);

  Bool_t SetFit(UShort_t d, Char_t r, Double_t eta, Int_t quality, 
    const TF1& f);
  Bool_t SetFit(UShort_t d, Char_t r, Double_t eta, ELossFit* f);
  Bool_t SetFit(UShort_t d, Char_t r, Int_t etaBin, ELossFit* f);
  Bool_t SetFit(UShort_t  d,      Char_t    r, Double_t eta, 
    Int_t     quality,UShort_t  n, 
    Double_t  chi2,   UShort_t  nu, 
    Double_t  c,      Double_t  ec, 
    Double_t  delta,  Double_t  edelta, 
    Double_t  xi,     Double_t  exi,
    Double_t  sigma,  Double_t  esigma, 
    Double_t  sigman, Double_t  esigman, 
    Double_t* a,      Double_t* ea);
  /* @} */
  
  void SetEtaAxis(const TAxis& axis);
  void SetEtaAxis(Int_t nBins, Double_t min, Double_t max);
  const TAxis& GetEtaAxis() const { return fEtaAxis; }
  void SetLowCut(Double_t cut) { fLowCut = cut; }
  Double_t GetLowCut() const { return fLowCut; }
  Int_t FindEtaBin(Double_t eta) const;
  /* @} */

  ELossFit* FindFit(UShort_t d, Char_t r, Double_t eta,
        UShort_t minQ) const;
  ELossFit* FindFit(UShort_t d, Char_t r, Int_t etabin,
        UShort_t minQ) const;
  ELossFit* GetFit(UShort_t d, Char_t r, Double_t eta) const;
  ELossFit* GetFit(UShort_t d, Char_t r, Int_t etabin) const;
  /* @} */

  Double_t GetMpvCut(UShort_t d,
         Char_t   r,
         Int_t    etaBin,
         Double_t f) const;
  Double_t GetXiCut(UShort_t d,
        Char_t   r,
        Int_t    etaBin,
        Double_t f) const;
  Double_t GetXiSigmaCut(UShort_t d,
       Char_t   r,
       Int_t    etaBin,
       Double_t f) const;
  Double_t GetAvgXiSigmaCut(UShort_t d,
          Char_t   r,
          Int_t    etaBin,
          Double_t f) const;
  Double_t GetProbabilityCut(UShort_t d,
           Char_t   r,
           Int_t    etaBin,
           Double_t f) const;

  Bool_t IsGood(Bool_t   verbose=true,
    Double_t minRate=.7,
    Int_t    maxGap=3,         
    Int_t    minInner=25,
    Int_t    minOuter=15,
    Int_t    minQuality=kDefaultQuality);
  /* @} */
  
  void CacheBins(UShort_t minQuality=kDefaultQuality) const;
  TObjArray* GetRingArray(UShort_t d, Char_t r) const;
  Bool_t IsFolder() const { return true; }
  void Browse(TBrowser* b);
  void Draw(Option_t* option=""); //*MENU*
  void Print(Option_t* option="R") const; //*MENU*
  TList* GetStacks(Bool_t err, Bool_t rel, Bool_t good, UShort_t maxN=5) const;
  /* @} */
protected:
  Int_t GetRingIndex(UShort_t d, Char_t r) const;
  TObjArray* GetOrMakeRingArray(UShort_t d, Char_t r);
  void UpdateStackHist(ELossFit* f,     Bool_t rel, 
           Int_t     used, 
           TH1*      hChi, TH1*   hN, 
           TH1*      hC,   TH1*   hDelta, 
           TH1*      hXi,  TH1*   hSigma, 
           Int_t     maxN, TH1**  hA) const;
           
  TObjArray  fRings;    // Array of rings
  TAxis      fEtaAxis;  // Eta axis used
  Double_t   fLowCut;   // Low cut used when fitting 
  mutable TArrayI    fCache;

  ClassDef(AliFMDCorrELossFit,3); 
};

//____________________________________________________________________
inline void 
AliFMDCorrELossFit::SetEtaAxis(Int_t nBins, Double_t min, Double_t max)
{
  fEtaAxis.Set(nBins, min, max);
}
//____________________________________________________________________
inline void 
AliFMDCorrELossFit::SetEtaAxis(const TAxis& e)
{
  fEtaAxis.Set(e.GetNbins(), e.GetXmin(), e.GetXmax());
}
//____________________________________________________________________
inline Double_t
AliFMDCorrELossFit::ELossFit::GetA(UShort_t i) const
{
  if (i <  1)   return 0;
  if (i >  fN)  return 0;
  if (i == 1)   return 1;
  return fA[i-2];
}
//____________________________________________________________________
inline Double_t
AliFMDCorrELossFit::ELossFit::GetEA(UShort_t i) const
{
  if (i <  1)   return 0;
  if (i >  fN)  return 0;
  if (i == 1)   return 1;
  return fEA[i-2];
}


#endif
// Local Variables:
//   mode: C++ 
// End: