HybridMinimizer.h

Go to the documentation of this file.

// @(#)root/minuit2:$Id$
// Author: L. Moneta Wed Oct 18 11:48:00 2006

/**********************************************************************
 *                                                                    *
 * Copyright (c) 2006  LCG ROOT Math Team, CERN/PH-SFT                *
 *                                                                    *
 *                                                                    *
 **********************************************************************/

// Header file for class HybridMinimizer

#ifndef ROOT_Minuit2_HybridMinimizer
#define ROOT_Minuit2_HybridMinimizer

#include "Math/Minimizer.h"
#include "Minuit2/MnUserParameterState.h"
#include "Math/IFunctionfwd.h"
#include "Minuit2/MinosError.h"
#include "Minuit2/ModularFunctionMinimizer.h"
#include "Minuit2/FumiliMinimizer.h"

namespace ROOT {

  namespace Minuit2 {

    class ModularFunctionMinimizer;
    class FCNBase;
    class FunctionMinimum;

  }  // namespace Minuit2
}  // namespace ROOT

//_____________________________________________________________________________________________________
namespace PSFitter {

  class HybridMinimizer : public ROOT::Math::Minimizer {
  public:
    enum EMinimizerType { kMigrad, kSimplex, kCombined, kScan, kFumili };

    HybridMinimizer(EMinimizerType type = kMigrad);

    HybridMinimizer(const char *type);

    ~HybridMinimizer() override;

  private:
    // usually copying is non trivial, so we make this unaccessible

    HybridMinimizer(const HybridMinimizer &);

    HybridMinimizer &operator=(const HybridMinimizer &rhs);

  public:
    // clear resources (parameters) for consecutives minimizations
    void Clear() override;

    void SetFunction(const ROOT::Math::IMultiGenFunction &func) override;

    void SetFunction(const ROOT::Math::IMultiGradFunction &func) override;

    bool SetVariable(unsigned int ivar, const std::string &name, double val, double step) override;

    bool SetLowerLimitedVariable(
        unsigned int ivar, const std::string &name, double val, double step, double lower) override;
    bool SetUpperLimitedVariable(
        unsigned int ivar, const std::string &name, double val, double step, double upper) override;
    bool SetLimitedVariable(unsigned int ivar,
                            const std::string &name,
                            double val,
                            double step,
                            double /* lower */,
                            double /* upper */) override;
    bool SetFixedVariable(unsigned int /* ivar */, const std::string & /* name */, double /* val */) override;
    bool SetVariableValue(unsigned int ivar, double val) override;
    bool SetVariableValues(const double *val) override;

    std::string VariableName(unsigned int ivar) const override;

    int VariableIndex(const std::string &name) const override;

    bool Minimize() override;

    double MinValue() const override { return fState.Fval(); }

    double Edm() const override { return fState.Edm(); }

    const double *X() const override;

    const double *MinGradient() const override { return nullptr; }  // not available in Minuit2

    unsigned int NCalls() const override { return fState.NFcn(); }

    unsigned int NDim() const override { return fDim; }

    unsigned int NFree() const override { return fState.VariableParameters(); }

    bool ProvidesError() const override { return true; }

    const double *Errors() const override;

    double CovMatrix(unsigned int i, unsigned int j) const override;

    bool GetCovMatrix(double *cov) const override;

    bool GetHessianMatrix(double *h) const override;

    int CovMatrixStatus() const override;
    double Correlation(unsigned int i, unsigned int j) const override;

    double GlobalCC(unsigned int i) const override;

    bool GetMinosError(unsigned int i, double &errLow, double &errUp, int = 0) override;

    bool Scan(unsigned int i, unsigned int &nstep, double *x, double *y, double xmin = 0, double xmax = 0) override;

    bool Contour(unsigned int i, unsigned int j, unsigned int &npoints, double *xi, double *xj) override;

    bool Hesse() override;


    void PrintResults() override;

    const ROOT::Minuit2::MnUserParameterState &State() { return fState; }

    void SetMinimizerType(EMinimizerType type);

  protected:
    // protected function for accessing the internal Minuit2 object. Needed for derived classes

    virtual const ROOT::Minuit2::ModularFunctionMinimizer *GetMinimizer() const { return fMinimizer; }

    virtual void SetMinimizer(ROOT::Minuit2::ModularFunctionMinimizer *m) { fMinimizer = m; }

    virtual const ROOT::Minuit2::FCNBase *GetFCN() const { return fMinuitFCN; }

    bool ExamineMinimum(const ROOT::Minuit2::FunctionMinimum &min);

  private:
    unsigned int fDim;  // dimension of the function to be minimized
    bool fUseFumili;

    ROOT::Minuit2::MnUserParameterState fState;
    // std::vector<ROOT::Minuit2::MinosError> fMinosErrors;
    ROOT::Minuit2::ModularFunctionMinimizer *fMinimizer;
    ROOT::Minuit2::FCNBase *fMinuitFCN;
    ROOT::Minuit2::FunctionMinimum *fMinimum;
    mutable std::vector<double> fValues;
    mutable std::vector<double> fErrors;
  };

}  // namespace PSFitter
#endif