SpectraAxis.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 "MantidAPI/SpectraAxis.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAPI/NumericAxis.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/MultiThreaded.h"
#include "MantidKernel/Unit.h"
#include "MantidKernel/VectorHelper.h"
 
namespace Mantid::API {
 
using std::size_t;
 
SpectraAxis::SpectraAxis(const MatrixWorkspace *const parentWorkspace)
    : Axis(), m_parentWS(parentWorkspace), m_edges() {
  this->unit() = std::make_shared<Kernel::Units::Label>("Spectrum", "");
}
 
Axis *SpectraAxis::clone(const MatrixWorkspace *const parentWorkspace) {
  auto newAxis = new SpectraAxis(parentWorkspace);
  // A couple of base class members need copying over manually
  newAxis->title() = this->title();
  newAxis->unit() = this->unit();
  return newAxis;
}
 
Axis *SpectraAxis::clone(const std::size_t length, const MatrixWorkspace *const parentWorkspace) {
  UNUSED_ARG(length)
  // In this implementation, there's no difference between the clone methods -
  // call the other one
  return clone(parentWorkspace);
}
 
std::size_t SpectraAxis::length() const { return m_parentWS->getNumberHistograms(); }
 
double SpectraAxis::operator()(const std::size_t &index, const std::size_t &verticalIndex) const {
  UNUSED_ARG(verticalIndex)
  if (index >= length()) {
    throw Kernel::Exception::IndexError(index, length() - 1, "SpectraAxis: Index out of range.");
  }
 
  return static_cast<double>(m_parentWS->getSpectrum(index).getSpectrumNo());
}
 
void SpectraAxis::setValue(const std::size_t &index, const double &value) {
  UNUSED_ARG(index)
  UNUSED_ARG(value)
  throw std::domain_error("setValue method cannot be used on a SpectraAxis.");
}
 
size_t SpectraAxis::indexOfValue(const double value) const {
  if (m_edges.empty()) // lazy-instantiation
  {
    m_edges.resize(m_parentWS->getNumberHistograms() + 1);
    const size_t npts = m_edges.size() - 1;
    for (size_t i = 0; i < npts - 1; ++i) {
      m_edges[i + 1] = 0.5 * (this->getValue(i) + this->getValue(i + 1));
    }
    // ends
    m_edges[0] = this->getValue(0) - (m_edges[1] - this->getValue(0));
    m_edges[npts] = this->getValue(npts - 1) + (this->getValue(npts - 1) - m_edges[npts - 1]);
  }
  return Mantid::Kernel::VectorHelper::indexOfValueFromEdges(m_edges, value);
}
 
specnum_t SpectraAxis::spectraNo(const std::size_t &index) const {
  if (index >= length()) {
    throw Kernel::Exception::IndexError(index, length() - 1, "SpectraAxis: Index out of range.");
  }
 
  return m_parentWS->getSpectrum(index).getSpectrumNo();
}
 
spec2index_map SpectraAxis::getSpectraIndexMap() const {
  size_t nel = length();
 
  if (nel == 0)
    throw std::runtime_error("getSpectraIndexMap(),  zero elements");
  spec2index_map map;
  for (size_t i = 0; i < nel; ++i) {
    map.emplace(m_parentWS->getSpectrum(i).getSpectrumNo(), i);
  }
  return map;
}
 
bool SpectraAxis::operator==(const Axis &axis2) const {
  if (length() != axis2.length()) {
    return false;
  }
  const auto *spec2 = dynamic_cast<const SpectraAxis *>(&axis2);
  if (!spec2) {
    return false;
  }
  for (size_t i = 0; i < length(); ++i) {
    if (spectraNo(i) != axis2.spectraNo(i))
      return false;
  }
  // All good if we get to here
  return true;
}
 
std::string SpectraAxis::label(const std::size_t &index) const { return "sp-" + std::to_string(spectraNo(index)); }
 
double SpectraAxis::getMin() const { return m_parentWS->getSpectrum(0).getSpectrumNo(); }
 
double SpectraAxis::getMax() const { return m_parentWS->getSpectrum(length() - 1).getSpectrumNo(); }
 
} // namespace Mantid::API