ParamFunction.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 "MantidAPI/ParamFunction.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/Logger.h"
 
#include <cmath>
#include <limits>
#include <sstream>
 
namespace Mantid::API {
namespace {
Kernel::Logger g_log("ParamFunction");
}
 
void ParamFunction::setParameter(size_t i, const double &value, bool explicitlySet) {
  if (std::isnan(value)) {
    // Check for NaN or -NaN
    std::stringstream errmsg;
    errmsg << "Trying to set a NaN value (" << value << ") to parameter " << this->parameterName(i);
    throw std::invalid_argument(errmsg.str());
  } else if (std::isinf(value)) {
    // Infinity value
    std::stringstream errmsg;
    errmsg << "Trying to set an infinity value (" << value << ") to parameter " << this->parameterName(i);
    throw std::invalid_argument(errmsg.str());
  }
 
  checkParameterIndex(i);
  if (explicitlySet && value != m_parameters[i]) {
    m_explicitlySet[i] = true;
  }
  m_parameters[i] = value;
}
 
void ParamFunction::setParameterDescription(size_t i, const std::string &description) {
  checkParameterIndex(i);
  m_parameterDescriptions[i] = description;
}
 
double ParamFunction::getParameter(size_t i) const {
  checkParameterIndex(i);
  return m_parameters[i];
}
 
void ParamFunction::setParameter(const std::string &name, const double &value, bool explicitlySet) {
  auto it = std::find(m_parameterNames.cbegin(), m_parameterNames.cend(), name);
  if (it == m_parameterNames.cend()) {
    std::ostringstream msg;
    msg << "ParamFunction tries to set value to non-exist parameter (" << name << ") "
        << "of function " << this->name();
    msg << "\nAllowed parameters: ";
    for (const auto &parameterName : m_parameterNames) {
      msg << parameterName << ", ";
    }
    throw std::invalid_argument(msg.str());
  }
  setParameter(static_cast<int>(it - m_parameterNames.begin()), value, explicitlySet);
}
 
void ParamFunction::setParameterDescription(const std::string &name, const std::string &description) {
  auto it = std::find(m_parameterNames.cbegin(), m_parameterNames.cend(), name);
  if (it == m_parameterNames.cend()) {
    std::ostringstream msg;
    msg << "ParamFunction tries to set description to non-exist parameter (" << name << "). ";
    msg << "\nAllowed parameters: ";
    for (const auto &parameterName : m_parameterNames)
      msg << parameterName << ", ";
    throw std::invalid_argument(msg.str());
  }
  setParameterDescription(static_cast<int>(it - m_parameterNames.begin()), description);
}
 
double ParamFunction::getParameter(const std::string &name) const {
  auto it = std::find(m_parameterNames.cbegin(), m_parameterNames.cend(), name);
  if (it == m_parameterNames.cend()) {
    std::ostringstream msg;
    msg << "ParamFunction tries to get value of non-existing parameter (" << name << ") "
        << "to function " << this->name();
    msg << "\nAllowed parameters: ";
    for (const auto &parameterName : m_parameterNames)
      msg << parameterName << ", ";
    throw std::invalid_argument(msg.str());
  }
 
  double parvalue = m_parameters[it - m_parameterNames.cbegin()];
 
  if (!std::isfinite(parvalue)) {
    g_log.warning() << "Parameter " << name << " has a NaN or infinity value " << '\n';
  }
 
  return parvalue;
}
 
bool ParamFunction::hasParameter(const std::string &name) const {
  return std::find(m_parameterNames.cbegin(), m_parameterNames.cend(), name) != m_parameterNames.cend();
}
 
size_t ParamFunction::parameterIndex(const std::string &name) const {
  auto it = std::find(m_parameterNames.cbegin(), m_parameterNames.cend(), name);
  if (it == m_parameterNames.cend()) {
    std::ostringstream msg;
    msg << "ParamFunction " << this->name() << " does not have parameter (" << name << ").";
    throw std::invalid_argument(msg.str());
  }
  return std::distance(m_parameterNames.cbegin(), it);
}
 
std::string ParamFunction::parameterName(size_t i) const {
  checkParameterIndex(i);
  return m_parameterNames[i];
}
 
std::string ParamFunction::parameterDescription(size_t i) const {
  checkParameterIndex(i);
  return m_parameterDescriptions[i];
}
 
double ParamFunction::getError(size_t i) const {
  checkParameterIndex(i);
  return m_errors[i];
}
 
double ParamFunction::getError(const std::string &name) const {
  auto it = std::find(m_parameterNames.cbegin(), m_parameterNames.cend(), name);
  if (it == m_parameterNames.cend()) {
    std::ostringstream msg;
    msg << "ParamFunction tries to get error of non-existing parameter (" << name << ") "
        << "to function " << this->name();
    msg << "\nAllowed parameters: ";
    for (const auto &parameterName : m_parameterNames)
      msg << parameterName << ", ";
    throw std::invalid_argument(msg.str());
  }
  return m_errors[static_cast<int>(it - m_parameterNames.begin())];
}
 
void ParamFunction::setError(size_t i, double err) {
  checkParameterIndex(i);
  m_errors[i] = err;
}
 
void ParamFunction::setError(const std::string &name, double err) {
  auto it = std::find(m_parameterNames.cbegin(), m_parameterNames.cend(), name);
  if (it == m_parameterNames.cend()) {
    std::ostringstream msg;
    msg << "ParamFunction tries to set error of non-existing parameter (" << name << ") "
        << "to function " << this->name();
    msg << "\nAllowed parameters: ";
    for (const auto &parameterName : m_parameterNames)
      msg << parameterName << ", ";
    throw std::invalid_argument(msg.str());
  }
  m_errors[static_cast<int>(it - m_parameterNames.begin())] = err;
}
 
void ParamFunction::declareParameter(const std::string &name, double initValue, const std::string &description) {
  auto it = std::find(m_parameterNames.cbegin(), m_parameterNames.cend(), name);
  if (it != m_parameterNames.cend()) {
    std::ostringstream msg;
    msg << "ParamFunction parameter (" << name << ") already exists.";
    throw std::invalid_argument(msg.str());
  }
 
  m_parameterStatus.emplace_back(Active);
  m_parameterNames.emplace_back(name);
  m_parameterDescriptions.emplace_back(description);
  m_parameters.emplace_back(initValue);
  m_errors.emplace_back(0.0);
  m_explicitlySet.emplace_back(false);
}
 
void ParamFunction::clearAllParameters() {
  clearTies();
  clearConstraints();
  m_parameters.clear();
  m_parameterNames.clear();
  m_parameterDescriptions.clear();
  m_parameterStatus.clear();
}
 
void ParamFunction::setParameterStatus(size_t i, ParameterStatus status) {
  checkParameterIndex(i);
  m_parameterStatus[i] = status;
}
 
IFunction::ParameterStatus ParamFunction::getParameterStatus(size_t i) const {
  checkParameterIndex(i);
  return m_parameterStatus[i];
}
 
double *ParamFunction::getParameterAddress(size_t i) {
  checkParameterIndex(i);
  return &m_parameters[i];
}
 
bool ParamFunction::isExplicitlySet(size_t i) const {
  checkParameterIndex(i);
  return m_explicitlySet[i];
}
 
size_t ParamFunction::getParameterIndex(const ParameterReference &ref) const {
  if (ref.getLocalFunction() == this && ref.getLocalIndex() < nParams()) {
    return ref.getLocalIndex();
  }
  return nParams();
}
 
} // namespace Mantid::API