FunctionGenerator.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 +
#include <utility>
 
#include "MantidAPI/FunctionGenerator.h"
#include "MantidAPI/IConstraint.h"
#include "MantidAPI/ParameterTie.h"
 
namespace Mantid::API {
 
using namespace Kernel;
 
FunctionGenerator::FunctionGenerator(const IFunction_sptr &source) : m_source(source), m_dirty(true) {
  if (source) {
    m_nOwnParams = source->nParams();
  }
  declareAttribute("NumDeriv", Attribute(false));
}
 
void FunctionGenerator::init() {}
 
void FunctionGenerator::setSource(IFunction_sptr source) const { m_source = std::move(source); }
 
void FunctionGenerator::setParameter(size_t i, const double &value, bool explicitlySet) {
  if (i < m_nOwnParams) {
    m_source->setParameter(i, value, explicitlySet);
    m_dirty = true;
  } else {
    checkTargetFunction();
    m_target->setParameter(i - m_nOwnParams, value, explicitlySet);
  }
}
 
void FunctionGenerator::setParameterDescription(size_t i, const std::string &description) {
  if (i < m_nOwnParams) {
    m_source->setParameterDescription(i, description);
  } else {
    checkTargetFunction();
    m_target->setParameterDescription(i - m_nOwnParams, description);
  }
}
 
double FunctionGenerator::getParameter(size_t i) const {
  if (i < m_nOwnParams) {
    return m_source->getParameter(i);
  } else {
    checkTargetFunction();
    return m_target->getParameter(i - m_nOwnParams);
  }
}
 
bool FunctionGenerator::hasParameter(const std::string &name) const {
  if (isSourceName(name)) {
    return m_source->hasParameter(name);
  } else {
    checkTargetFunction();
    return m_target->hasParameter(name);
  }
}
 
void FunctionGenerator::setParameter(const std::string &name, const double &value, bool explicitlySet) {
  auto i = parameterIndex(name);
  setParameter(i, value, explicitlySet);
}
 
void FunctionGenerator::setParameterDescription(const std::string &name, const std::string &description) {
  auto i = parameterIndex(name);
  setParameterDescription(i, description);
}
 
double FunctionGenerator::getParameter(const std::string &name) const {
  auto i = parameterIndex(name);
  return getParameter(i);
}
 
size_t FunctionGenerator::nParams() const {
  checkTargetFunction();
  return m_source->nParams() + m_target->nParams();
}
 
size_t FunctionGenerator::parameterIndex(const std::string &name) const {
  if (isSourceName(name)) {
    return m_source->parameterIndex(name);
  } else {
    checkTargetFunction();
    return m_target->parameterIndex(name) + m_nOwnParams;
  }
}
 
std::string FunctionGenerator::parameterName(size_t i) const {
  if (i < m_nOwnParams) {
    return m_source->parameterName(i);
  } else {
    checkTargetFunction();
    return m_target->parameterName(i - m_nOwnParams);
  }
}
 
std::string FunctionGenerator::parameterDescription(size_t i) const {
  if (i < m_nOwnParams) {
    return m_source->parameterDescription(i);
  } else {
    checkTargetFunction();
    return m_target->parameterDescription(i - m_nOwnParams);
  }
}
 
bool FunctionGenerator::isExplicitlySet(size_t i) const {
  if (i < m_nOwnParams) {
    return m_source->isExplicitlySet(i);
  } else {
    checkTargetFunction();
    return m_target->isExplicitlySet(i - m_nOwnParams);
  }
}
 
double FunctionGenerator::getError(size_t i) const {
  if (i < m_nOwnParams) {
    return m_source->getError(i);
  } else {
    checkTargetFunction();
    return m_target->getError(i - m_nOwnParams);
  }
}
 
double FunctionGenerator::getError(const std::string &name) const {
  auto index = parameterIndex(name);
  return getError(index);
}
 
void FunctionGenerator::setError(size_t i, double err) {
  if (i < m_nOwnParams) {
    m_source->setError(i, err);
  } else {
    checkTargetFunction();
    m_target->setError(i - m_nOwnParams, err);
  }
}
 
void FunctionGenerator::setError(const std::string &name, double err) {
  auto index = parameterIndex(name);
  setError(index, err);
}
 
void FunctionGenerator::setParameterStatus(size_t i, IFunction::ParameterStatus status) {
  if (i < m_nOwnParams) {
    m_source->setParameterStatus(i, status);
  } else {
    checkTargetFunction();
    m_target->setParameterStatus(i - m_nOwnParams, status);
  }
}
 
IFunction::ParameterStatus FunctionGenerator::getParameterStatus(size_t i) const {
  if (i < m_nOwnParams) {
    return m_source->getParameterStatus(i);
  } else {
    checkTargetFunction();
    return m_target->getParameterStatus(i - m_nOwnParams);
  }
}
 
size_t FunctionGenerator::getParameterIndex(const ParameterReference &ref) const {
  if (ref.getLocalFunction() == this) {
    auto index = ref.getLocalIndex();
    auto np = nParams();
    if (index < np) {
      return index;
    }
    return np;
  }
  checkTargetFunction();
  return m_target->getParameterIndex(ref) + m_nOwnParams;
}
 
void FunctionGenerator::setUpForFit() {
  updateTargetFunction();
  IFunction::setUpForFit();
}
 
void FunctionGenerator::declareParameter(const std::string & /*name*/, double /*initValue*/,
                                         const std::string & /*description*/) {
  throw Kernel::Exception::NotImplementedError("FunctionGenerator cannot not have its own parameters.");
}
 
size_t FunctionGenerator::nAttributes() const {
  checkTargetFunction();
  return IFunction::nAttributes() + m_source->nAttributes() + m_target->nAttributes();
}
 
std::vector<std::string> FunctionGenerator::getAttributeNames() const {
  checkTargetFunction();
  return IFunction::getAttributeNames();
}
 
IFunction::Attribute FunctionGenerator::getAttribute(const std::string &attName) const {
  if (IFunction::hasAttribute(attName)) {
    return IFunction::getAttribute(attName);
  } else if (isSourceName(attName)) {
    return m_source->getAttribute(attName);
  } else {
    checkTargetFunction();
    return m_target->getAttribute(attName);
  }
}
 
void FunctionGenerator::setAttribute(const std::string &attName, const IFunction::Attribute &att) {
  if (IFunction::hasAttribute(attName)) {
    IFunction::setAttribute(attName, att);
    m_dirty = true;
    m_target.reset();
  } else if (isSourceName(attName)) {
    m_source->setAttribute(attName, att);
    m_dirty = true;
  } else {
    checkTargetFunction();
    m_target->setAttribute(attName, att);
  }
}
 
bool FunctionGenerator::hasAttribute(const std::string &attName) const {
  if (IFunction::hasAttribute(attName)) {
    return true;
  }
  if (isSourceName(attName)) {
    return m_source->hasAttribute(attName);
  } else {
    checkTargetFunction();
    return m_target->hasAttribute(attName);
  }
}
std::string FunctionGenerator::attributeName(size_t i) const {
  if (i < IFunction::nAttributes()) {
    return IFunction::attributeName(i);
  } else if (i < IFunction::nAttributes() + m_source->nAttributes()) {
    return m_source->attributeName(i - IFunction::nAttributes());
  } else if (i < nAttributes()) {
    return m_target->attributeName(i - (IFunction::nAttributes() + m_source->nAttributes()));
  } else {
    throw(std::runtime_error("Attribute index out of range"));
  }
}
 
// Evaluates the function
void FunctionGenerator::function(const FunctionDomain &domain, FunctionValues &values) const {
  updateTargetFunction();
  if (!m_target) {
    throw std::logic_error("FunctionGenerator failed to generate target function.");
  }
  m_target->function(domain, values);
}
 
bool FunctionGenerator::isSourceName(const std::string &aName) const {
  if (aName.empty()) {
    throw std::invalid_argument("Parameter or attribute name cannot be empty string.");
  }
  return (aName.front() != 'f' || aName.find('.') == std::string::npos);
}
 
void FunctionGenerator::checkTargetFunction() const {
  if (m_dirty) {
    updateTargetFunction();
  }
  if (!m_target) {
    throw std::logic_error("FunctionGenerator failed to generate target function.");
  }
}
 
ParameterTie *FunctionGenerator::getTie(size_t i) const {
  auto tie = IFunction::getTie(i);
  if (!tie) {
    return nullptr;
  }
  if (i < m_nOwnParams) {
    tie = m_source->getTie(i);
  } else {
    checkTargetFunction();
    tie = m_target->getTie(i - m_nOwnParams);
  }
  return tie;
}
 
IConstraint *FunctionGenerator::getConstraint(size_t i) const {
  auto constraint = IFunction::getConstraint(i);
  if (constraint == nullptr) {
    if (i < m_nOwnParams) {
      constraint = m_source->getConstraint(i);
    } else {
      checkTargetFunction();
      constraint = m_target->getConstraint(i - m_nOwnParams);
    }
  }
  return constraint;
}
 
} // namespace Mantid::API