CorrFitFunc.h

/*
 * CorrFit.h
 *
 *  Created on: 08-04-2015
 *      Author: Daniel Wielanek
 *      E-mail: daniel.wielanek@gmail.com
 *      Warsaw University of Technology, Faculty of Physics
 */
 
#ifndef HALCORRFITFUNC_H_
#define HALCORRFITFUNC_H_
 
#include "CorrFit.h"
 
#include "Array.h"
#include "FemtoConst.h"
#include "MinimizerStepConf.h"
 
#include <Rtypes.h>
#include <RtypesCore.h>
#include <TMath.h>
#include <TString.h>
 
 
class TF1;
class TH1;
 
 
//#define CF_FIT_TRACKING
namespace ROOT {
  namespace Math {
    class Minimizer;
  }
}  // namespace ROOT
namespace Hal {
  class CorrFitGUI;
  class CorrFitMask;
  class ChiSqMap2D;
  class CorrFitHDFunc;
  class CorrFitPainter;
  class CorrFitFunc : public CorrFit {
    friend class Femto1DCF;
    friend class Femto3DCF;
    friend class FemtoSHCF;
    friend class CorrFitPainter;
 
    void PrepareSecondMiminizer(ROOT::Math::Minimizer* min, const double* pars, const double* errors) const;
    void SetParsOfMinimizer(ROOT::Math::Minimizer* min) const;
    Int_t CountNDF() const;
    ROOT::Math::Minimizer* GetMinimizer1(EMinAlgo algo) const;
    ROOT::Math::Minimizer* GetMinimizer2(EMinAlgo algo) const;
 
  protected:
    virtual void RecalculateFunction() const {};
    virtual void RecalculateSmoothFunction() const = 0;
    Femto::EKinematics fKinematics;
    const Int_t fDim;
    Double_t fChi[2];
    Int_t fMaxIterations;
    Int_t fNormParIndex = {0};
    Double_t fTolerance;
    Double_t fActiveBins;
    Array_1<Double_t> fRange;
    Bool_t fTrace;
    Bool_t fOwnRangeMap;
    TObject* fCF;
    TH1* fDenominatorHistogram;
    TH1* fNumeratorHistogram;
    TH1* fCorrelationFunctionHistogram;
    CorrFitMask* fMask;
    CorrFitPainter* fPainter = {nullptr};
    MinimizerStepConf fDiscretteMinimzerConf;
    mutable CorrFitHDFunc* fHDMaps;
    virtual void PrepareHalMinimizer() const;
    virtual void PrepareRootMinimizer(ROOT::Math::Minimizer* minizer) const;
    virtual void EstimateActiveBins() = 0;
    void SetupFunction(TF1* f) const;
    void NumericalMinimization();
    void NumericalPreMinimization(Double_t bins);
    void DummyNumericalFunction();
    void ParametersChanged() const {  // TODO optimize
      RecalculateFunction();
      RecalculateSmoothFunction();
    }
    virtual void Fit(TObject* histo);
    virtual void FitDummy(TObject* histo);
    virtual void Check();
    virtual void Prepare();
    virtual void PrepareRaw() = 0;
    virtual void MakePainter(TString options) = 0;
    void FitStep(Int_t /*step*/) {};
    double FunctorChiTFD(const double* params);
    double FunctorChiTF(const double* params);
    double FunctorLogTFD(const double* params);
    //{ParametersChanged(params);return
    // GetLogTFD(params);};//fgMinimizer->GetLogTFD(params);}
    virtual double GetChiTFD(const double* params) const = 0;
    virtual double GetLogTFD(const double* params) const = 0;
    virtual double GetChiTF(const double* params) const  = 0;
    virtual void SetErrors(TH1* num, const TH1* den) const = 0;
    void CalcError(const Double_t Num,
                   const Double_t NumErr,
                   const Double_t Den,
                   const Double_t DenErr,
                   Double_t& cf,
                   Double_t& cfe) const;
 
  public:
    CorrFitFunc(Int_t nparams = 1, Int_t dim = 1);
    void SetTolerance(Double_t tol) { fTolerance = tol; };
    void SetMaxIteration(Int_t max) { fMaxIterations = max; };
    void SetRange(Double_t min, Double_t max);
    void TraceFitting() { fTrace = kTRUE; };
    virtual void SetFittingMask(const CorrFitMask& map) = 0;
    void SetMinimizerConf(const MinimizerStepConf& conf) { fDiscretteMinimzerConf = conf; };
    void SetMinimizerConf(TString xmlFile);
    void MakeDummyXMLConfig(TString xmlFile);
    Int_t GetFreeParamsNo() const;
    Double_t GetChiSquare(Option_t* opt = "fitted") const;
    Double_t GetChiNDF(Option_t* opt = "fitted") const;
    Double_t GetRangeMin(Int_t flag = 0) const;
    Double_t GetRangeMax(Int_t flag = 0) const;
    ChiSqMap2D*
    GetChiSquareMap(Int_t par1, Int_t par1_steps, Int_t par2, Int_t par2_steps, Bool_t scale = kTRUE, EMinFunc = kChi2) const;
    ChiSqMap2D* GetChiSquareMap(Int_t par1,
                                Int_t par1_steps,
                                Double_t par1_min,
                                Double_t par1_max,
                                Int_t par2,
                                Int_t par2_steps,
                                Double_t par2_min,
                                Double_t par2_max,
                                Bool_t scale = kTRUE,
                                EMinFunc     = kChi2) const;
    TF1* GetFittedFunction() const;
    CorrFitHDFunc* GetHD() const { return fHDMaps; };
    virtual void PreFit(TObject* histo, Double_t bins = 1);
    Double_t GetNorm() const { return GetParameter(NormID()); };
    inline Int_t NormID() const { return fNormParIndex; };
    Double_t GetNormError() const { return GetParError(fNormParIndex); };
    void SetNormLimits(Double_t min, Double_t max) { SetParLimits(NormID(), min, max); }
    virtual void Draw(Option_t* option = "");
    virtual void Repaint();
    Hal::CorrFitGUI* StartGui(Int_t prec = -1);
    CorrFitPainter* GetPainter() const { return fPainter; }
    virtual ~CorrFitFunc();
    ClassDef(CorrFitFunc, 1)
  };
}  // namespace Hal
#endif /* HALCORRFITFUNC_H_ */