FullprofPolynomial.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 "MantidCurveFitting/Functions/FullprofPolynomial.h"
#include "MantidAPI/FunctionFactory.h"
 
namespace Mantid::CurveFitting::Functions {
 
using namespace CurveFitting;
 
DECLARE_FUNCTION(FullprofPolynomial)
 
//----------------------------------------------------------------------------------------------
FullprofPolynomial::FullprofPolynomial() : m_n(6), m_bkpos(1.) {
  // Declare first 6th order polynomial as default
  for (int i = 0; i < m_n; ++i) {
    std::string parName = "A" + std::to_string(i);
    declareParameter(parName);
  }
}
 
//----------------------------------------------------------------------------------------------
void FullprofPolynomial::function1D(double *out, const double *xValues, const size_t nData) const {
  // Generate a vector for all coefficient
  std::vector<double> B(m_n, 0.0);
  for (int i = 0; i < m_n; ++i)
    B[i] = getParameter(i);
 
  // Calculate
  for (size_t i = 0; i < nData; ++i) {
    double tof = xValues[i];
    double x = tof / m_bkpos - 1.;
    double pow_x = 1.;
#if 1
    // It is the first try as benchmark
    double y_b = 0.;
    for (int j = 0; j < m_n; ++j) {
      y_b += B[j] * pow_x;
      pow_x *= x;
    }
#else
    // This is the efficient coding
    double y_b = B[0];
    for (size_t j = 1; j < m_n; ++j) {
      pow_x *= x;
      y_b += B[j] * pow_x;
    }
#endif
 
    out[i] = y_b;
  }
}
 
//----------------------------------------------------------------------------------------------
void FullprofPolynomial::functionDeriv1D(API::Jacobian *out, const double *xValues, const size_t nData) {
  for (size_t i = 0; i < nData; i++) {
    double tof = xValues[i];
    double x = tof / m_bkpos - 1.;
 
    // Order 0
    double pow_x = 1.0;
    out->set(i, 0, pow_x);
    // Rest
    for (int j = 1; j < m_n; ++j) {
      // It does dirivative to B_j
      pow_x *= x;
      out->set(i, j, pow_x);
    }
  }
}
 
//----------------------------------------------------------------------------------------------
std::vector<std::string> FullprofPolynomial::getAttributeNames() const { return {"n", "Bkpos"}; }
 
//----------------------------------------------------------------------------------------------
API::IFunction::Attribute FullprofPolynomial::getAttribute(const std::string &attName) const {
  if (attName == "n") {
    return Attribute(m_n);
  } else if (attName == "Bkpos")
    return Attribute(m_bkpos);
 
  throw std::invalid_argument("Polynomial: Unknown attribute " + attName);
}
 
//----------------------------------------------------------------------------------------------
void FullprofPolynomial::setAttribute(const std::string &attName, const API::IFunction::Attribute &att) {
  if (attName == "n") {
    // set theFullprofPolynomial order
    int attint = att.asInt();
    if (attint < 0) {
      throw std::invalid_argument("Polynomial:FullprofPolynomial order cannot be negative.");
    } else if (attint != 6 && attint != 12) {
      throw std::runtime_error("FullprofPolynomial's order must be either 6 or 12. ");
    } else if (attint != m_n) {
      // Only order is (either 6 or 12) and different from current order
      clearAllParameters();
 
      m_n = attint;
      for (int i = 0; i < m_n; ++i) {
        std::string parName = "A" + std::to_string(i);
        declareParameter(parName);
      }
    }
  } else if (attName == "Bkpos") {
    // Background original position
    m_bkpos = att.asDouble();
  }
}
 
//----------------------------------------------------------------------------------------------
bool FullprofPolynomial::hasAttribute(const std::string &attName) const {
  bool has = false;
  if (attName == "n")
    has = true;
  else if (attName == "Bkpos")
    has = true;
 
  return has;
}
 
} // namespace Mantid::CurveFitting::Functions