RefAxis.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 "MantidAPI/RefAxis.h"
#include "MantidAPI/MatrixWorkspace.h"
 
namespace Mantid::API {
 
// NumericAxis is set to length 0 since we do not need its internal storage. We
// override public functions of NumericAxis that would access it.
RefAxis::RefAxis(const MatrixWorkspace *const parentWorkspace) : NumericAxis(0), m_parentWS(parentWorkspace) {}
 
RefAxis::RefAxis(const RefAxis &right, const MatrixWorkspace *const parentWorkspace)
    : NumericAxis(right), m_parentWS(parentWorkspace) {}
 
Axis *RefAxis::clone(const MatrixWorkspace *const parentWorkspace) { return new RefAxis(*this, parentWorkspace); }
 
Axis *RefAxis::clone(const std::size_t length, const MatrixWorkspace *const parentWorkspace) {
  static_cast<void>(length);
  return clone(parentWorkspace);
}
 
std::size_t RefAxis::length() const { return m_parentWS->x(0).size(); }
 
double RefAxis::operator()(const std::size_t &index, const std::size_t &verticalIndex) const {
  const auto &x = m_parentWS->x(verticalIndex);
  if (index >= x.size()) {
    throw Kernel::Exception::IndexError(index, x.size() - 1, "Axis: Index out of range.");
  }
  return x[index];
}
 
void RefAxis::setValue(const std::size_t &index, const double &value) {
  UNUSED_ARG(index)
  UNUSED_ARG(value)
  throw std::domain_error("This method cannot be used on a RefAxis.");
}
 
bool RefAxis::operator==(const Axis &axis2) const {
  if (length() != axis2.length()) {
    return false;
  }
  const auto *ra2 = dynamic_cast<const RefAxis *>(&axis2);
  return ra2 != nullptr;
}
 
bool RefAxis::equalWithinTolerance(const Axis &axis2, const double tolerance) const {
  UNUSED_ARG(tolerance);
  return this->operator==(axis2);
}
 
size_t RefAxis::indexOfValue(const double value) const {
  UNUSED_ARG(value)
  throw std::runtime_error("Calling indexOfValue() on RefAxis is forbidden.");
}
 
std::vector<double> RefAxis::createBinBoundaries() const {
  throw std::runtime_error("Calling createBinBoundaries() on RefAxis is forbidden.");
}
 
const std::vector<double> &RefAxis::getValues() const {
  throw std::runtime_error("Calling getValues() on RefAxis is forbidded.");
}
 
double RefAxis::getMin() const {
  throw std::runtime_error("RefAxis cannot determine minimum value. Use readX "
                           "on the workspace instead");
}
double RefAxis::getMax() const {
  throw std::runtime_error("RefAxis cannot determine maximum value. Use readX "
                           "on the workspace instead");
}
 
} // namespace Mantid::API