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