SeqDomain.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/SeqDomain.h"
#include "MantidCurveFitting/ParDomain.h"
#include <numeric>
 
namespace Mantid::CurveFitting {
 
size_t SeqDomain::size() const {
  return std::accumulate(m_creators.cbegin(), m_creators.cend(), static_cast<size_t>(0),
                         [](size_t sum, const auto &creator) { return sum + creator->getDomainSize(); });
}
 
size_t SeqDomain::getNDomains() const { return m_creators.size(); }
 
void SeqDomain::getDomainAndValues(size_t i, API::FunctionDomain_sptr &domain, API::FunctionValues_sptr &values) const {
  if (i >= m_creators.size())
    throw std::range_error("Function domain index is out of range.");
  if (!m_domain[i] || i != m_currentIndex) {
    m_domain[m_currentIndex].reset();
    m_values[m_currentIndex].reset();
    m_creators[i]->createDomain(m_domain[i], m_values[i]);
    m_currentIndex = i;
  }
  domain = m_domain[i];
  values = m_values[i];
}
 
void SeqDomain::addCreator(const API::IDomainCreator_sptr &creator) {
  m_creators.emplace_back(creator);
  m_domain.emplace_back(API::FunctionDomain_sptr());
  m_values.emplace_back(API::FunctionValues_sptr());
}
 
SeqDomain *SeqDomain::create(API::IDomainCreator::DomainType type) {
  if (type == API::IDomainCreator::Sequential) {
    return new SeqDomain;
  } else if (type == API::IDomainCreator::Parallel) {
    return new ParDomain;
  }
  throw std::invalid_argument("Unknown SeqDomain type");
}
 
void SeqDomain::additiveCostFunctionVal(const CostFunctions::CostFuncFitting &costFunction) {
  API::FunctionDomain_sptr domain;
  API::FunctionValues_sptr values;
  const size_t n = getNDomains();
  for (size_t i = 0; i < n; ++i) {
    values.reset();
    getDomainAndValues(i, domain, values);
    if (!values) {
      throw std::runtime_error("CostFunction: undefined FunctionValues.");
    }
    costFunction.addVal(domain, values);
  }
}
 
//------------------------------------------------------------------------------------------------
void SeqDomain::rwpVal(const CostFunctions::CostFuncRwp &rwp) {
  API::FunctionDomain_sptr domain;
  API::FunctionValues_sptr values;
  const size_t n = getNDomains();
  for (size_t i = 0; i < n; ++i) {
    values.reset();
    getDomainAndValues(i, domain, values);
    if (!values) {
      throw std::runtime_error("Rwp: undefined FunctionValues.");
    }
    rwp.addVal(domain, values);
  }
}
 
void SeqDomain::additiveCostFunctionValDerivHessian(const CostFunctions::CostFuncFitting &costFunction, bool evalDeriv,
                                                    bool evalHessian) {
  API::FunctionDomain_sptr domain;
  API::FunctionValues_sptr values;
  const size_t n = getNDomains();
  for (size_t i = 0; i < n; ++i) {
    values.reset();
    getDomainAndValues(i, domain, values);
    if (!values) {
      throw std::runtime_error("CostFunction: undefined FunctionValues.");
    }
    costFunction.addValDerivHessian(costFunction.getFittingFunction(), domain, values, evalDeriv, evalHessian);
  }
}
 
void SeqDomain::rwpValDerivHessian(const CostFunctions::CostFuncRwp &rwp, bool evalDeriv, bool evalHessian) {
  API::FunctionDomain_sptr domain;
  API::FunctionValues_sptr values;
  const size_t n = getNDomains();
  for (size_t i = 0; i < n; ++i) {
    values.reset();
    getDomainAndValues(i, domain, values);
    if (!values) {
      throw std::runtime_error("Rwp: undefined FunctionValues.");
    }
    rwp.addValDerivHessian(rwp.getFittingFunction(), domain, values, evalDeriv, evalHessian);
  }
}
 
} // namespace Mantid::CurveFitting