DerivMinimizer.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidCurveFitting/FuncMinimizers/DerivMinimizer.h"
#include "MantidCurveFitting/CostFunctions/CostFuncFitting.h"
 
#include "MantidAPI/IFuncMinimizer.h"
 
namespace Mantid::CurveFitting::FuncMinimisers {
 
double DerivMinimizer::fun(const gsl_vector *x, void *params) {
  DerivMinimizer &minimizer = *static_cast<DerivMinimizer *>(params);
  size_t n = minimizer.m_costFunction->nParams();
  for (size_t i = 0; i < n; ++i) {
    minimizer.m_costFunction->setParameter(i, gsl_vector_get(x, i));
  }
  std::shared_ptr<CostFunctions::CostFuncFitting> fitting =
      std::dynamic_pointer_cast<CostFunctions::CostFuncFitting>(minimizer.m_costFunction);
  if (fitting) {
    fitting->getFittingFunction()->applyTies();
  }
  return minimizer.m_costFunction->val();
}
 
void DerivMinimizer::dfun(const gsl_vector *x, void *params, gsl_vector *g) {
  DerivMinimizer &minimizer = *static_cast<DerivMinimizer *>(params);
  size_t n = minimizer.m_costFunction->nParams();
  for (size_t i = 0; i < n; ++i) {
    minimizer.m_costFunction->setParameter(i, gsl_vector_get(x, i));
  }
  std::shared_ptr<CostFunctions::CostFuncFitting> fitting =
      std::dynamic_pointer_cast<CostFunctions::CostFuncFitting>(minimizer.m_costFunction);
  if (fitting) {
    fitting->getFittingFunction()->applyTies();
  }
  std::vector<double> der(n);
  minimizer.m_costFunction->deriv(der);
  for (size_t i = 0; i < n; ++i) {
    gsl_vector_set(g, i, der[i]);
  }
}
 
void DerivMinimizer::fundfun(const gsl_vector *x, void *params, double *f, gsl_vector *g) {
  DerivMinimizer &minimizer = *static_cast<DerivMinimizer *>(params);
  size_t n = minimizer.m_costFunction->nParams();
  for (size_t i = 0; i < n; ++i) {
    minimizer.m_costFunction->setParameter(i, gsl_vector_get(x, i));
  }
  std::shared_ptr<CostFunctions::CostFuncFitting> fitting =
      std::dynamic_pointer_cast<CostFunctions::CostFuncFitting>(minimizer.m_costFunction);
  if (fitting) {
    fitting->getFittingFunction()->applyTies();
  }
  std::vector<double> der(n);
  *f = minimizer.m_costFunction->valAndDeriv(der);
  for (size_t i = 0; i < n; ++i) {
    gsl_vector_set(g, i, der[i]);
  }
}
 
DerivMinimizer::DerivMinimizer()
    : m_gslSolver(nullptr), m_x(nullptr), m_stopGradient(1e-3), m_stepSize(0.1), m_tolerance(0.0001) {
  initGSLMMin();
}
 
DerivMinimizer::DerivMinimizer(const double stepSize, const double tolerance)
    : m_gslSolver(nullptr), m_x(nullptr), m_stopGradient(1e-3), m_stepSize(stepSize), m_tolerance(tolerance) {
  initGSLMMin();
}
 
void DerivMinimizer::initGSLMMin() {
  m_gslMultiminContainer.f = nullptr;
  m_gslMultiminContainer.df = nullptr;
  m_gslMultiminContainer.fdf = nullptr;
  m_gslMultiminContainer.n = 0;
  m_gslMultiminContainer.params = nullptr;
}
 
DerivMinimizer::~DerivMinimizer() {
  if (m_gslSolver != nullptr) {
    gsl_multimin_fdfminimizer_free(m_gslSolver);
    gsl_vector_free(m_x);
  }
}
 
void DerivMinimizer::initialize(API::ICostFunction_sptr function, size_t maxIterations) {
  UNUSED_ARG(maxIterations);
  m_costFunction = function;
  m_gslMultiminContainer.n = m_costFunction->nParams();
  m_gslMultiminContainer.f = &fun;
  m_gslMultiminContainer.df = &dfun;
  m_gslMultiminContainer.fdf = &fundfun;
  m_gslMultiminContainer.params = this;
 
  m_gslSolver = gsl_multimin_fdfminimizer_alloc(getGSLMinimizerType(), m_gslMultiminContainer.n);
 
  size_t nParams = m_costFunction->nParams();
  // Starting point
  m_x = gsl_vector_alloc(nParams);
  for (size_t i = 0; i < nParams; ++i) {
    gsl_vector_set(m_x, i, m_costFunction->getParameter(i));
  }
 
  gsl_multimin_fdfminimizer_set(m_gslSolver, &m_gslMultiminContainer, m_x, m_stepSize, m_tolerance);
}
 
bool DerivMinimizer::iterate(size_t /*iteration*/) {
  if (m_gslSolver == nullptr) {
    throw std::runtime_error("Minimizer " + this->name() + " was not initialized.");
  }
  int status = gsl_multimin_fdfminimizer_iterate(m_gslSolver);
  if (status) {
    m_errorString = gsl_strerror(status);
    return false;
  }
  status = gsl_multimin_test_gradient(m_gslSolver->gradient, m_stopGradient);
  if (status != GSL_CONTINUE) {
    m_errorString = (status == GSL_SUCCESS) ? API::MinimizerStatus::SUCCESS : gsl_strerror(status);
    return false;
  }
  return true;
}
 
void DerivMinimizer::setStopGradient(const double value) {
  if (value <= 0) {
    throw std::invalid_argument("Gradient norm must be a positive number");
  }
  m_stopGradient = value;
}
 
double DerivMinimizer::costFunctionVal() { return m_gslSolver->f; }
 
} // namespace Mantid::CurveFitting::FuncMinimisers