IMDWorkspace.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/IMDWorkspace.h"
#include "MantidGeometry/MDGeometry/IMDDimension.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/IPropertyManager.h"
#include "MantidKernel/VMD.h"
 
#include <sstream>
#include <utility>
 
using Mantid::Kernel::VMD;
 
namespace Mantid::API {
//-----------------------------------------------------------------------------------------------
IMDWorkspace::IMDWorkspace(const Parallel::StorageMode storageMode)
    : Workspace(storageMode), Mantid::API::MDGeometry(),
      m_convention(Kernel::ConfigService::Instance().getString("Q.convention")) {}
 
std::unique_ptr<IMDIterator> IMDWorkspace::createIterator(Mantid::Geometry::MDImplicitFunction *function) const {
  std::vector<std::unique_ptr<IMDIterator>> iterators = this->createIterators(1, function);
  if (iterators.empty())
    throw std::runtime_error("IMDWorkspace::createIterator(): iterator "
                             "creation was not successful. No iterators "
                             "returned by " +
                             this->id());
  return std::move(iterators[0]);
}
 
//---------------------------------------------------------------------------------------------
std::string IMDWorkspace::getConvention() const { return m_convention; }
 
//---------------------------------------------------------------------------------------------
void IMDWorkspace::setConvention(std::string convention) { m_convention = std::move(convention); }
 
//---------------------------------------------------------------------------------------------
std::string IMDWorkspace::changeQConvention() {
  if (this->getConvention() == "Crystallography")
    m_convention = "Inelastic";
  else
    m_convention = "Crystallography";
  return m_convention;
}
 
//-------------------------------------------------------------------------------------------
signal_t IMDWorkspace::getSignalAtVMD(const Mantid::Kernel::VMD &coords,
                                      const Mantid::API::MDNormalization &normalization) const {
  return this->getSignalAtCoord(coords.getBareArray(), normalization);
}
 
//-------------------------------------------------------------------------------------------
signal_t IMDWorkspace::getSignalWithMaskAtVMD(const Mantid::Kernel::VMD &coords,
                                              const Mantid::API::MDNormalization &normalization) const {
  return this->getSignalWithMaskAtCoord(coords.getBareArray(), normalization);
}
 
//-----------------------------------------------------------------------------------------------
 
const std::string IMDWorkspace::toString() const {
  std::ostringstream os;
  os << id() << "\n"
     << "Title: " + getTitle() << "\n";
  for (size_t i = 0; i < getNumDims(); i++) {
    const auto &dim = getDimension(i);
    os << "Dim " << i << ": (" << dim->getName() << ") " << dim->getMinimum() << " to " << dim->getMaximum() << " in "
       << dim->getNBins() << " bins";
    // Also show the dimension ID string, if different than name
    if (dim->getDimensionId() != dim->getName())
      os << ". Id=" << dim->getDimensionId();
    os << "\n";
  }
  if (hasOriginalWorkspace()) {
    os << "Binned from '" << getOriginalWorkspace()->getName();
  }
  os << "\n";
  if (this->getConvention() == "Crystallography")
    os << "Crystallography: kf-ki";
  else
    os << "Inelastic: ki-kf";
  os << "\n";
 
  return os.str();
}
 
//----------------------------------------------------------------------------------------------
void IMDWorkspace::makeSinglePointWithNaN(std::vector<coord_t> &x, std::vector<signal_t> &y,
                                          std::vector<signal_t> &e) const {
  x.emplace_back(0.f);
  y.emplace_back(std::numeric_limits<signal_t>::quiet_NaN());
  e.emplace_back(std::numeric_limits<signal_t>::quiet_NaN());
}
 
//-----------------------------------------------------------------------------------------------
IMDWorkspace::LinePlot IMDWorkspace::getLinePlot(const Mantid::Kernel::VMD &start, const Mantid::Kernel::VMD &end,
                                                 Mantid::API::MDNormalization normalize) const {
  // TODO: Don't use a fixed number of points later
  size_t numPoints = 200;
 
  VMD step = (end - start) / double(numPoints);
  double stepLength = step.norm();
 
  // This will be the curve as plotted
  LinePlot line;
  for (size_t i = 0; i < numPoints; i++) {
    // Coordinate along the line
    VMD coord = start + step * double(i);
    // Record the position along the line
    line.x.emplace_back(static_cast<coord_t>(stepLength * double(i)));
 
    signal_t yVal = this->getSignalAtCoord(coord.getBareArray(), normalize);
    line.y.emplace_back(yVal);
    line.e.emplace_back(0.0);
  }
  // And the last point
  line.x.emplace_back((end - start).norm());
  return line;
}
 
MDNormalization IMDWorkspace::displayNormalization() const { return NoNormalization; }
 
MDNormalization IMDWorkspace::displayNormalizationHisto() const { return NoNormalization; }
} // namespace Mantid::API
 
namespace Mantid::Kernel {
template <>
MANTID_API_DLL Mantid::API::IMDWorkspace_sptr
IPropertyManager::getValue<Mantid::API::IMDWorkspace_sptr>(const std::string &name) const {
  auto *prop = dynamic_cast<PropertyWithValue<Mantid::API::IMDWorkspace_sptr> *>(getPointerToProperty(name));
  if (prop) {
    return *prop;
  } else {
    std::string message =
        "Attempt to assign property " + name + " to incorrect type. Expected shared_ptr<IMDWorkspace>.";
    throw std::runtime_error(message);
  }
}
 
template <>
MANTID_API_DLL Mantid::API::IMDWorkspace_const_sptr
IPropertyManager::getValue<Mantid::API::IMDWorkspace_const_sptr>(const std::string &name) const {
  auto *prop = dynamic_cast<PropertyWithValue<Mantid::API::IMDWorkspace_sptr> *>(getPointerToProperty(name));
  if (prop) {
    return prop->operator()();
  } else {
    std::string message =
        "Attempt to assign property " + name + " to incorrect type. Expected const shared_ptr<IMDWorkspace>.";
    throw std::runtime_error(message);
  }
}
 
} // namespace Mantid::Kernel