IMDWorkspace.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 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 +
#pragma once
 
#include "MantidAPI/DllConfig.h"
#include "MantidAPI/IMDIterator.h"
#include "MantidAPI/ITableWorkspace_fwd.h"
#include "MantidAPI/MDGeometry.h"
#include "MantidAPI/Workspace.h"
#include "MantidKernel/PropertyWithValue.h"
#include "MantidKernel/SpecialCoordinateSystem.h"
#include <cstdint>
#include <vector>
 
namespace Mantid {
 
namespace Geometry {
class MDImplicitFunction;
}
 
namespace API {
 
static const signal_t MDMaskValue = std::numeric_limits<double>::quiet_NaN();
 
class MANTID_API_DLL IMDWorkspace : public Workspace, public API::MDGeometry {
public:
  IMDWorkspace();
  IMDWorkspace &operator=(const IMDWorkspace &other) = delete;
 
  struct LinePlot {
    std::vector<coord_t> x;
    std::vector<signal_t> y;
    std::vector<signal_t> e;
  };
 
  std::unique_ptr<IMDWorkspace> clone() const { return std::unique_ptr<IMDWorkspace>(doClone()); }
 
  std::unique_ptr<IMDWorkspace> cloneEmpty() const { return std::unique_ptr<IMDWorkspace>(doCloneEmpty()); }
 
  virtual uint64_t getNPoints() const = 0;
  /*** Get the number of events, associated with the workspace
   * For MDEvenWorkspace it is equal to the number of points
   * For regularly gridded workspace (MDHistoWorkspace and MatrixWorkspace),
   * it is the number of contributed non-zero events.
   */
  virtual uint64_t getNEvents() const = 0;
 
  virtual std::vector<std::unique_ptr<IMDIterator>>
  createIterators(size_t suggestedNumCores = 1, Mantid::Geometry::MDImplicitFunction *function = nullptr) const = 0;
 
  virtual signal_t getSignalAtCoord(const coord_t *coords, const Mantid::API::MDNormalization &normalization) const = 0;
 
  // is masked, used for plotting
  virtual signal_t getSignalWithMaskAtCoord(const coord_t *coords,
                                            const Mantid::API::MDNormalization &normalization) const = 0;
 
  virtual LinePlot getLinePlot(const Mantid::Kernel::VMD &start, const Mantid::Kernel::VMD &end,
                               Mantid::API::MDNormalization normalize) const;
 
  std::unique_ptr<IMDIterator> createIterator(Mantid::Geometry::MDImplicitFunction *function = nullptr) const;
 
  const std::string &getConvention() const;
  void setConvention(std::string convention);
  std::string changeQConvention();
 
  signal_t getSignalAtVMD(const Mantid::Kernel::VMD &coords,
                          const Mantid::API::MDNormalization &normalization = Mantid::API::VolumeNormalization) const;
 
  signal_t
  getSignalWithMaskAtVMD(const Mantid::Kernel::VMD &coords,
                         const Mantid::API::MDNormalization &normalization = Mantid::API::VolumeNormalization) const;
 
  virtual void setMDMasking(std::unique_ptr<Mantid::Geometry::MDImplicitFunction> maskingRegion) = 0;
 
  virtual void clearMDMasking() = 0;
  virtual Kernel::SpecialCoordinateSystem getSpecialCoordinateSystem() const = 0;
  virtual void clearFileBacked(bool /* loadFileContentsToMemory*/) {}
  virtual ITableWorkspace_sptr makeBoxTable(size_t /*start*/, size_t /* num*/) {
    throw Kernel::Exception::NotImplementedError("This method is not generally implemented ");
  }
 
  // Preferred normalization to use for display
  virtual MDNormalization displayNormalization() const;
 
  // Preferred normalization to use for displaying histo workspaces
  virtual MDNormalization displayNormalizationHisto() const;
 
  // Check if this class is an instance of MDHistoWorkspace
  virtual bool isMDHistoWorkspace() const { return false; }
 
  // Check if this class has an oriented lattice on a sample object
  virtual bool hasOrientedLattice() const = 0;
 
protected:
  IMDWorkspace(const IMDWorkspace &) = default;
 
  void makeSinglePointWithNaN(std::vector<coord_t> &x, std::vector<signal_t> &y, std::vector<signal_t> &e) const;
 
  const std::string toString() const override;
 
private:
  std::string m_convention;
  IMDWorkspace *doClone() const override = 0;
  IMDWorkspace *doCloneEmpty() const override = 0;
};
 
using IMDWorkspace_sptr = std::shared_ptr<IMDWorkspace>;
using IMDWorkspace_const_sptr = std::shared_ptr<const IMDWorkspace>;
} // namespace API
} // namespace Mantid
 
// Instantiated and exported by API/src/PropertyWithValue.cpp
MANTID_API_EXTERN_TEMPLATE(Mantid::Kernel::PropertyWithValue<std::shared_ptr<Mantid::API::IMDWorkspace>>);