AliFMDEnergyFitter.h

Go to the documentation of this file.

//
// Class to fit the energy distribution.  
//
#ifndef ALIFMDENERGYFITTER_H
#define ALIFMDENERGYFITTER_H

#include <TNamed.h>
// #include <TH1D.h>
#include <TAxis.h>
#include <TList.h>
#include <TObjArray.h>
#include <TClonesArray.h>
#include "AliFMDCorrELossFit.h"
#include "AliForwardUtil.h"
#include "AliLandauGaus.h"
class TH1;
class TH2;
class AliESDFMD;
class TFitResult;
class TF1;
class TArrayD;

class AliFMDEnergyFitter : public TNamed
{
public: 
  enum { 
    kC    = AliLandauGaus::kC,
    kDelta  = AliLandauGaus::kDelta, 
    kXi   = AliLandauGaus::kXi, 
    kSigma  = AliLandauGaus::kSigma, 
    kSigmaN = AliLandauGaus::kSigmaN,
    kN    = AliLandauGaus::kN, 
    kA    = AliLandauGaus::kA
  };
  enum EResidualMethod {
    kNoResiduals = 0, 
    kResidualDifference, 
    kResidualScaledDifference, 
    kResidualSquareDifference
  };

   enum FMDRingBits { 
     kFMD1I=0x01,
     kFMD1 =kFMD1I,
     kFMD2I=0x02,
     kFMD2O=0x04,
     kFMD2 =kFMD2I|kFMD2O,
     kFMD3I=0x08,
     kFMD3O=0x10,
     kFMD3 =kFMD3I|kFMD3O
  };
  virtual ~AliFMDEnergyFitter();
  AliFMDEnergyFitter();
  AliFMDEnergyFitter(const char* title);

  // -----------------------------------------------------------------
  void SetEtaAxis(Int_t nBins, Double_t etaMin, Double_t etaMax);
  void SetEtaAxis(const TAxis& etaAxis);
  void SetCentralityAxis(UShort_t nBins, Double_t* bins);
  void SetLowCut(Double_t lowCut=0.3) { fLowCut = lowCut; }
  Double_t GetLowCut() const { return fLowCut; }
  void SetFitRangeBinWidth(UShort_t n=4) { fFitRangeBinWidth = n; }
  void SetDoFits(Bool_t doFit=kTRUE) { fDoFits = doFit; }
  void SetDoMakeObject(Bool_t doMake=kTRUE) { fDoMakeObject = doMake; }
  void SetNParticles(UShort_t n) { fNParticles = (n<1 ? 1 : (n>7 ? 7 : n)); }
  void SetMinEntries(UShort_t n) { fMinEntries = (n < 1 ? 1 : n); }
  void SetMaxE(Double_t x) { fMaxE = x; }
  void SetNEbins(Int_t x) { fNEbins = x; }
  void SetMaxRelativeParameterError(Double_t e=0.2) { fMaxRelParError = e; }
  void SetMaxChi2PerNDF(Double_t c=10) { fMaxChi2PerNDF = c; }
  void SetMinWeight(Double_t c=1e-7) { fMinWeight = c; }
  void SetUseIncreasingBins(Bool_t x) { fUseIncreasingBins = x; }
  void SetStoreResiduals(EResidualMethod x=kResidualDifference) 
  { 
    fResidualMethod = x; 
  }
  void SetRegularizationCut(Double_t cut=3e6) 
  {
    fRegularizationCut = cut;
  }
  void SetSkips(UShort_t skip) { fSkips = skip; }
  void SetDebug(Int_t dbg=1);
  void SetEnableDeltaShift(Bool_t use=true);

  /* @} */
  // -----------------------------------------------------------------
  void Init();
  virtual void CreateOutputObjects(TList* dir);
  virtual void SetupForData(const TAxis& etaAxis, UShort_t sys=0);
  virtual Bool_t Accumulate(const AliESDFMD& input, 
          Double_t         cent,
          Bool_t           empty);
  virtual void Fit(const TList* dir);
  void MakeCorrectionsObject(TList* dir);
  void Print(Option_t* option="") const;
  Bool_t ReadParameters(const TCollection* list);
  //==================================================================
  struct RingHistos : public AliForwardUtil::RingHistos
  { 
    typedef AliFMDCorrELossFit::ELossFit ELossFit_t;
    RingHistos();
    RingHistos(UShort_t d, Char_t r);
    RingHistos(const RingHistos& o){;}
    RingHistos& operator=(const RingHistos& o){return *this;}
    ~RingHistos();
    virtual TArrayD MakeIncreasingAxis(Int_t    n, 
               Double_t min, 
               Double_t max) const;
    TH2* Make(const char*  name, 
        const char*  title, 
        const TAxis& eAxis, 
        Double_t     deMax=12, 
        Int_t        nDeBins=300, 
        Bool_t       incr=true);
    virtual void CreateOutputObjects(TList* dir);
    virtual void SetupForData(const TAxis& eAxis, 
            const TAxis& cAxis,
            Double_t     maxDE=10, 
            Int_t        nDEbins=300, 
            Bool_t       useIncrBin=true);
    virtual void Fill(Bool_t empty, Double_t eta, Int_t icent, Double_t mult);
    virtual TObjArray* Fit(TList*          dir, 
         Double_t        lowCut, 
         UShort_t        nParticles,
         UShort_t        minEntries,
         UShort_t        minusBins,
         Double_t        relErrorCut, 
         Double_t        chi2nuCut,
         Double_t        minWeight,
         Double_t        regCut,
         EResidualMethod residuals) const;
    virtual TObjArray* FitSlices(TList*          dir, 
         const char*     name,
         Double_t        lowCut, 
         UShort_t        nParticles,
         UShort_t        minEntries,
         UShort_t        minusBins,
         Double_t        relErrorCut, 
         Double_t        chi2nuCut,
         Double_t        minWeight,
         Double_t        regCut,
         EResidualMethod residuals,
         Bool_t          scaleToPeak=true,
         TObjArray*      best=0) const;
    virtual void Scale(TH1* dist) const;
    virtual ELossFit_t* FitHist(TH1*      dist,
        Double_t  lowCut, 
        UShort_t  nParticles,
        UShort_t  minEntries,
        UShort_t  minusBins,
        Double_t  relErrorCut, 
        Double_t  chi2nuCut,
        Double_t  minWeight,
        Double_t  regCut,
        Bool_t    scaleToPeak,
        UShort_t& status) const;
    virtual ELossFit_t* FindBestFit(const TH1* dist,
            Double_t   relErrorCut, 
            Double_t   chi2nuCut,
            Double_t   minWeightCut) const;
    virtual void CalculateResiduals(EResidualMethod  mode,
            Double_t         lowCut,
            TH1*             dist, 
            ELossFit_t*      fit, 
            TCollection*     out) const;
    virtual void FindBestFits(const TList*        d, 
            AliFMDCorrELossFit& obj,
            const TAxis&        eta);
    TH1* MakePar(const char* name, const char* title, const TAxis& eta) const;
    TH1* MakeTotal(const char*  name, 
        const char*  title, 
        const TAxis& eta, 
        Int_t        low, 
        Int_t        high, 
        Double_t     val, 
        Double_t     err) const;
    TH1*                 fEDist;     // Ring energy distribution 
    TH1*                 fEmpty;     // Ring energy dist for empty events
    TH2*                 fHist;      // Two dimension Delta distribution
    // TList*               fEtaEDists; // Energy distributions per eta bin. 
    TList*               fList;
    mutable TObjArray    fBest;
    mutable TClonesArray fFits;
    Int_t                fDebug;
    ClassDef(RingHistos,4);
  };
protected:
  AliFMDEnergyFitter(const AliFMDEnergyFitter& o);
  AliFMDEnergyFitter& operator=(const AliFMDEnergyFitter& o);

  virtual RingHistos* CreateRingHistos(UShort_t d, Char_t r) const;
  RingHistos* GetRingHistos(UShort_t d, Char_t r) const;
  static Bool_t CheckSkip(UShort_t d, Char_t r, UShort_t skips);

  TList           fRingHistos;        // List of histogram containers
  Double_t        fLowCut;            // Low cut on energy
  UShort_t        fNParticles;        // Number of landaus to try to fit 
  UShort_t        fMinEntries;        // Minimum number of entries
  UShort_t        fFitRangeBinWidth;  // N-bins to subtract from found max
  Bool_t          fDoFits;            // Whether to actually do the fits 
  Bool_t          fDoMakeObject;      // Whether to make corrections object
  TAxis           fEtaAxis;           // Eta axis 
  TAxis           fCentralityAxis;    // Centrality axis 
  Double_t        fMaxE;              // Maximum energy loss to consider 
  Int_t           fNEbins;            // Number of energy loss bins 
  Bool_t          fUseIncreasingBins; // Wheter to use increasing bin sizes 
  Double_t        fMaxRelParError;    // Relative error cut
  Double_t        fMaxChi2PerNDF;     // chi^2/nu cit
  Double_t        fMinWeight;         // Minimum weight value 
  Int_t           fDebug;             // Debug level 
  EResidualMethod fResidualMethod;    // Whether to store residuals (debugging)
  UShort_t        fSkips;             // Rings to skip when fitting 
  Double_t        fRegularizationCut; // When to regularize the chi^2

  ClassDef(AliFMDEnergyFitter,8); //
};

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