MDEventWorkspace.h

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 +
#pragma once
 
#include "MantidAPI/BoxController.h"
#include "MantidAPI/CoordTransform.h"
#include "MantidAPI/IMDEventWorkspace.h"
#include "MantidAPI/IMDIterator.h"
#include "MantidAPI/ITableWorkspace_fwd.h"
#include "MantidDataObjects/DllConfig.h"
#include "MantidDataObjects/MDBoxBase.h"
#include "MantidDataObjects/MDEvent.h"
#include "MantidDataObjects/MDGridBox.h"
#include "MantidDataObjects/MDHistoWorkspace.h"
#include "MantidDataObjects/MDLeanEvent.h"
#include "MantidKernel/ProgressBase.h"
#include "MantidKernel/PropertyWithValue.h"
 
namespace Mantid {
namespace DataObjects {
 
TMDE_CLASS
class MANTID_DATAOBJECTS_DLL MDEventWorkspace : public API::IMDEventWorkspace {
 
public:
  using sptr = std::shared_ptr<MDEventWorkspace<MDE, nd>>;
  using MDEventType = MDE;
 
  MDEventWorkspace(
      Mantid::API::MDNormalization preferredNormalization = Mantid::API::MDNormalization::VolumeNormalization,
      Mantid::API::MDNormalization preferredNormalizationHisto = Mantid::API::MDNormalization::VolumeNormalization);
  MDEventWorkspace<MDE, nd> &operator=(const MDEventWorkspace<MDE, nd> &other) = delete;
  virtual ~MDEventWorkspace() override = default;
 
  std::unique_ptr<MDEventWorkspace> clone() const { return std::unique_ptr<MDEventWorkspace>(doClone()); }
 
  std::unique_ptr<MDEventWorkspace> cloneEmpty() const { return std::unique_ptr<MDEventWorkspace>(doCloneEmpty()); }
 
  void initialize() override;
 
  const std::string id() const override;
 
  //------------------------ IMDWorkspace Methods
  //-----------------------------------------
 
  size_t getNumDims() const override;
 
  uint64_t getNPoints() const override;
  uint64_t getNEvents() const override { return getNPoints(); }
 
  std::vector<std::unique_ptr<Mantid::API::IMDIterator>>
  createIterators(size_t suggestedNumCores = 1,
                  Mantid::Geometry::MDImplicitFunction *function = nullptr) const override;
 
  signal_t getSignalAtCoord(const coord_t *coords, const Mantid::API::MDNormalization &normalization) const override;
 
  // or 0 if masked
  signal_t getSignalWithMaskAtCoord(const coord_t *coords,
                                    const Mantid::API::MDNormalization &normalization) const override;
 
  bool isInBounds(const coord_t *coords) const;
 
  signal_t getNormalizedSignal(const API::IMDNode *box, const Mantid::API::MDNormalization &normalization) const;
 
  signal_t getNormalizedError(const API::IMDNode *box, const Mantid::API::MDNormalization &normalization) const;
 
  LinePlot getLinePlot(const Mantid::Kernel::VMD &start, const Mantid::Kernel::VMD &end,
                       API::MDNormalization normalize) const override;
 
  // Get ordered list of boundaries in position-along-the-line coordinates
  std::set<coord_t> getBoxBoundaryBisectsOnLine(const Kernel::VMD &start, const Kernel::VMD &end, const size_t num_d,
                                                const Kernel::VMD &dir, const coord_t length) const;
 
  //------------------------ (END) IMDWorkspace Methods
  //-----------------------------------------
 
  size_t getMemorySize() const override;
 
  //------------------------ IMDEventWorkspace Methods
  //-----------------------------------------
 
  Mantid::API::BoxController_sptr getBoxController() override { return m_BoxController; }
 
  Mantid::API::BoxController_const_sptr getBoxController() const override { return m_BoxController; }
 
  std::vector<std::string> getBoxControllerStats() const override;
 
  bool isFileBacked() const override { return m_BoxController->isFileBacked(); }
 
  std::vector<coord_t> estimateResolution() const override;
 
  void splitAllIfNeeded(Kernel::ThreadScheduler *ts) override;
 
  void splitTrackedBoxes(Kernel::ThreadScheduler *ts);
 
  void splitBox() override;
 
  void refreshCache() override;
 
  std::string getEventTypeName() const override;
  size_t sizeofEvent() const override { return sizeof(MDE); }
 
  void setMinRecursionDepth(size_t minDepth) override;
 
  Mantid::API::ITableWorkspace_sptr makeBoxTable(size_t start, size_t num) override;
  //------------------------ (END) IMDEventWorkspace Methods
  //-----------------------------------------
 
  void getBoxes(std::vector<API::IMDNode *> &boxes, size_t maxDepth, bool leafOnly) override {
    this->getBox()->getBoxes(boxes, maxDepth, leafOnly);
  }
 
  size_t addEvent(const MDE &event);
 
  size_t addEvents(const std::vector<MDE> &events);
 
  std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> getMinimumExtents(size_t depth = 2) const override;
 
  bool isGridBox() { return dynamic_cast<MDGridBox<MDE, nd> *>(data.get()) != nullptr; }
 
  MDBoxBase<MDE, nd> *getBox() { return data.get(); }
 
  const MDBoxBase<MDE, nd> *getBox() const { return data.get(); }
 
  void setBox(API::IMDNode *box) override {
    data = std::unique_ptr<MDBoxBase<MDE, nd>>(dynamic_cast<MDBoxBase<MDE, nd> *>(box));
  }
 
  void setMDMasking(std::unique_ptr<Mantid::Geometry::MDImplicitFunction> maskingRegion) override;
 
  void clearMDMasking() override;
 
  Kernel::SpecialCoordinateSystem getSpecialCoordinateSystem() const override;
  void setCoordinateSystem(const Kernel::SpecialCoordinateSystem coordSystem) override;
  virtual void setFileBacked(const std::string &fileName);
  void setFileBacked() override;
  void clearFileBacked(bool LoadFileBackedData) override;
 
  void setDisplayNormalizationHisto(Mantid::API::MDNormalization preferredNormalizationHisto) override;
  Mantid::API::MDNormalization displayNormalizationHisto() const override;
 
  void setDisplayNormalization(Mantid::API::MDNormalization preferredNormalization) override;
  Mantid::API::MDNormalization displayNormalization() const override;
 
protected:
  MDEventWorkspace(const MDEventWorkspace<MDE, nd> &other);
 
  void getBoundariesInDimension(const Mantid::Kernel::VMD &start, const Mantid::Kernel::VMD &dir,
                                const size_t num_boundaries, const coord_t length, const coord_t dir_current_dim,
                                const coord_t box_size, std::set<coord_t> &mid_points) const;
 
  API::BoxController_sptr m_BoxController;
 
  std::unique_ptr<MDBoxBase<MDE, nd>> data;
 
  // std::shared_ptr<BoxCtrlChangesList > m_BoxController;
  Mantid::API::MDNormalization m_displayNormalization;
  Mantid::API::MDNormalization m_displayNormalizationHisto;
 
private:
  MDEventWorkspace *doClone() const override { return new MDEventWorkspace(*this); }
 
  MDEventWorkspace *doCloneEmpty() const override { return new MDEventWorkspace(); }
 
  Kernel::SpecialCoordinateSystem m_coordSystem;
};
 
template <size_t nd> using MDEventWS = MDEventWorkspace<MDEvent<nd>, nd>;
template <size_t nd> using MDLeanEventWS = MDEventWorkspace<MDLeanEvent<nd>, nd>;
 
} // namespace DataObjects
 
// Instantiated and exported by DataObjects/src/PropertyWithValue.cpp
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDEventWS<1>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDEventWS<2>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDEventWS<3>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDEventWS<4>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDEventWS<5>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDEventWS<6>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDEventWS<7>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDEventWS<8>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDEventWS<9>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDLeanEventWS<1>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDLeanEventWS<2>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDLeanEventWS<3>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDLeanEventWS<4>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDLeanEventWS<5>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDLeanEventWS<6>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDLeanEventWS<7>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDLeanEventWS<8>>>);
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(Kernel::PropertyWithValue<std::shared_ptr<DataObjects::MDLeanEventWS<9>>>);
 
} // namespace Mantid