InterpolationOption.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 "MantidAlgorithms/InterpolationOption.h"
#include "MantidHistogramData/Interpolate.h"
#include "MantidKernel/ListValidator.h"
#include "MantidKernel/PropertyWithValue.h"
 
#include <cassert>
 
namespace {
// The name of the interpolation property
std::string PROP_NAME("Interpolation");
std::string LINEAR_OPT("Linear");
std::string CSPLINE_OPT("CSpline");
std::vector<std::string> OPTIONS{LINEAR_OPT, CSPLINE_OPT};
} // namespace
 
namespace Mantid {
using HistogramData::interpolateCSplineInplace;
using HistogramData::interpolateLinearInplace;
using HistogramData::minSizeForCSplineInterpolation;
using HistogramData::minSizeForLinearInterpolation;
using Kernel::Property;
 
namespace Algorithms {
 
void InterpolationOption::set(const InterpolationOption::Value &kind, const bool calculateErrors,
                              const bool independentErrors) {
  m_value = kind;
  m_calculateErrors = calculateErrors;
  m_independentErrors = independentErrors;
}
 
void InterpolationOption::set(const std::string &kind, const bool calculateErrors, const bool independentErrors) {
  if (kind == LINEAR_OPT) {
    m_value = Value::Linear;
  } else if (kind == CSPLINE_OPT) {
    m_value = Value::CSpline;
  } else {
    throw std::invalid_argument("InterpolationOption::set() - Unknown interpolation method '" + kind + "'");
  }
  m_calculateErrors = calculateErrors;
  m_independentErrors = independentErrors;
}
 
std::unique_ptr<Property> InterpolationOption::property() const {
  using Kernel::StringListValidator;
  using StringProperty = Kernel::PropertyWithValue<std::string>;
 
  return std::make_unique<StringProperty>(PROP_NAME, LINEAR_OPT, std::make_shared<StringListValidator>(OPTIONS));
}
 
std::string InterpolationOption::propertyDoc() const {
  return "Method of interpolation used to compute unsimulated values.";
}
 
std::string InterpolationOption::validateInputSize(const size_t size) const {
  size_t nMin;
  switch (m_value) {
  case Value::Linear:
    nMin = minSizeForLinearInterpolation();
    if (size < nMin) {
      return "Linear interpolation requires at least " + std::to_string(nMin) + " points.";
    }
    break;
  case Value::CSpline:
    nMin = minSizeForCSplineInterpolation();
    if (size < nMin) {
      return "CSpline interpolation requires at least " + std::to_string(nMin) + " points.";
    }
    break;
  }
  return std::string();
}
 
void InterpolationOption::applyInplace(HistogramData::Histogram &inOut, size_t stepSize) const {
  switch (m_value) {
  case Value::Linear:
    interpolateLinearInplace(inOut, stepSize, m_calculateErrors, m_independentErrors);
    return;
  case Value::CSpline:
    interpolateCSplineInplace(inOut, stepSize, m_calculateErrors, m_independentErrors);
    return;
  default:
    throw std::runtime_error("InterpolationOption::applyInplace() - "
                             "Unimplemented interpolation method.");
  }
}
 
void InterpolationOption::applyInPlace(const HistogramData::Histogram &in, HistogramData::Histogram &out) const {
  switch (m_value) {
  case Value::Linear:
    interpolateLinearInplace(in, out, m_calculateErrors, m_independentErrors);
    return;
  case Value::CSpline:
    interpolateCSplineInplace(in, out, m_calculateErrors, m_independentErrors);
    return;
  default:
    throw std::runtime_error("InterpolationOption::applyInplace() - "
                             "Unimplemented interpolation method.");
  }
}
 
} // namespace Algorithms
} // namespace Mantid