IMDNode.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2009 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 "MantidGeometry/MDGeometry/MDTypes.h"
#include "MantidKernel/VMD.h"
#include <algorithm>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace Mantid {
namespace Kernel {
class ISaveable;
class ThreadScheduler;
} // namespace Kernel
 
namespace Geometry {
template <typename T> class MDDimensionExtents;
class MDImplicitFunction;
} // namespace Geometry
 
namespace API {
 
class BoxController;
class IBoxControllerIO;
class CoordTransform;
 
class IMDNode {
public:
  virtual ~IMDNode() = default;
  //---------------- ISAVABLE
  virtual Kernel::ISaveable *getISaveable() = 0;
  virtual Kernel::ISaveable *getISaveable() const = 0;
  virtual void setFileBacked(const uint64_t /*fileLocation*/, const size_t /*fileSize*/, const bool /*markSaved*/) = 0;
  virtual void setFileBacked() = 0;
  virtual void clearFileBacked(bool loadFileData) = 0;
  virtual void reserveMemoryForLoad(uint64_t) = 0;
 
  virtual void saveAt(API::IBoxControllerIO *const /*saver */, uint64_t /*position*/) const = 0;
 
  virtual void loadAndAddFrom(API::IBoxControllerIO *const /*saver */, uint64_t /*position*/, size_t /* Size */,
                              std::vector<coord_t> &) = 0;
  virtual void loadAndAddFrom(API::IBoxControllerIO *const /*saver */, uint64_t /*position*/, size_t /* Size */) = 0;
  virtual void clearDataFromMemory() = 0;
  //-------------------------------------------------------------
  virtual void clear() = 0;
 
  virtual std::string getEventType() const = 0;
  virtual unsigned int getCoordType() const = 0;
  //-------------------------------------------------------------
  virtual size_t getID() const = 0;
  virtual void setID(const size_t &newID) = 0;
 
  virtual size_t getNumDims() const = 0;
 
  virtual bool getIsMasked() const = 0;
  virtual void mask() = 0;
  virtual void unmask() = 0;
 
  virtual Mantid::API::BoxController *getBoxController() const = 0;
  virtual Mantid::API::BoxController *getBoxController() = 0;
 
  // -------------------------------- Parents/Children-Related
  // -------------------------------------------
  virtual bool isLeaf() const = 0;
  virtual size_t getNumMDBoxes() const = 0;
  virtual size_t getNumChildren() const = 0;
  virtual IMDNode *getChild(size_t index) = 0;
  virtual void setChildren(const std::vector<IMDNode *> &boxes, const size_t indexStart, const size_t indexEnd) = 0;
  virtual void setParent(IMDNode *parent) = 0;
  virtual IMDNode *getParent() = 0;
  virtual const IMDNode *getParent() const = 0;
  // -------------------------------------------------------------------------------------------
  // box-related
  virtual void getBoxes(std::vector<IMDNode *> &boxes, size_t maxDepth, bool leafOnly) = 0;
  virtual void getBoxes(std::vector<IMDNode *> &boxes, size_t maxDepth, bool leafOnly,
                        Mantid::Geometry::MDImplicitFunction *function) = 0;
 
  virtual void getBoxes(std::vector<IMDNode *> &outBoxes, const std::function<bool(IMDNode *)> &cond) = 0;
 
  // -------------------------------- Events-Related
  // -------------------------------------------
  virtual uint64_t getNPoints() const = 0;
  virtual size_t getDataInMemorySize() const = 0;
  virtual uint64_t getTotalDataSize() const = 0;
 
  virtual void getEventsData(std::vector<coord_t> &coordTable, size_t &nColumns) const = 0;
  virtual void setEventsData(const std::vector<coord_t> &coordTable) = 0;
 
  virtual void buildAndAddEvent(const signal_t Signal, const signal_t errorSq, const std::vector<coord_t> &point,
                                uint16_t expInfoIndex, uint16_t goniometerIndex, uint32_t detectorId) = 0;
  virtual void buildAndAddEventUnsafe(const signal_t Signal, const signal_t errorSq, const std::vector<coord_t> &point,
                                      uint16_t expInfoIndex, uint16_t goniometerIndex, uint32_t detectorId) = 0;
  virtual size_t buildAndAddEvents(const std::vector<signal_t> &sigErrSq, const std::vector<coord_t> &Coord,
                                   const std::vector<uint16_t> &expInfoIndex,
                                   const std::vector<uint16_t> &goniometerIndex,
                                   const std::vector<uint32_t> &detectorId) = 0;
 
  // -------------------------------------------------------------------------------------------
 
  virtual void integrateSphere(Mantid::API::CoordTransform &radiusTransform, const coord_t radiusSquared,
                               signal_t &signal, signal_t &errorSquared, const coord_t innerRadiusSquared = 0.0,
                               const bool useOnePercentBackgroundCorrection = true) const = 0;
  virtual void centroidSphere(Mantid::API::CoordTransform &radiusTransform, const coord_t radiusSquared,
                              coord_t *centroid, signal_t &signal) const = 0;
  virtual void integrateCylinder(Mantid::API::CoordTransform &radiusTransform, const coord_t radius,
                                 const coord_t length, signal_t &signal, signal_t &errorSquared,
                                 std::vector<signal_t> &signal_fit) const = 0;
 
  virtual void splitAllIfNeeded(Mantid::Kernel::ThreadScheduler * /*ts*/ = nullptr) = 0;
  virtual void refreshCache(Kernel::ThreadScheduler * /*ts*/ = nullptr) = 0;
  virtual void calculateCentroid(coord_t * /*centroid*/) const = 0;
  virtual void calculateCentroid(coord_t * /*centroid*/, const int /*expInfoIndex*/) const = 0;
  virtual coord_t *getCentroid() const = 0;
  //----------------------------------------------------------------------------------------------------------------------------------
  // MDBoxBase interface, related to average signals/error box parameters
  virtual signal_t getSignal() const = 0;
  virtual signal_t getError() const = 0;
  virtual signal_t getErrorSquared() const = 0;
  virtual coord_t getInverseVolume() const = 0;
  virtual Mantid::Geometry::MDDimensionExtents<coord_t> &getExtents(size_t dim) = 0;
  virtual const IMDNode *getBoxAtCoord(const coord_t * /*coords*/) = 0;
  virtual void getCenter(coord_t *const /*boxCenter*/) const = 0;
  virtual uint32_t getDepth() const = 0;
  virtual signal_t getSignalNormalized() const = 0;
 
  virtual void calcVolume() = 0;
  virtual void setInverseVolume(const coord_t) = 0;
  virtual void setSignal(const signal_t) = 0;
  virtual void setErrorSquared(const signal_t) = 0;
 
  // -------------------------------- Geometry/vertexes-Related
  // -------------------------------------------
  virtual std::vector<Mantid::Kernel::VMD> getVertexes() const = 0;
  virtual std::unique_ptr<coord_t[]> getVertexesArray(size_t &numVertices) const = 0;
  virtual std::unique_ptr<coord_t[]> getVertexesArray(size_t &numVertices, const size_t outDimensions,
                                                      const bool *maskDim) const = 0;
  virtual void transformDimensions(std::vector<double> &scaling, std::vector<double> &offset) = 0;
 
  // to avoid casting (which need also the number of dimensions) method say if
  // Node is a box. if not, it is gridbox
  virtual bool isBox() const = 0;
 
  virtual signal_t getSignalByNEvents() const { return this->getSignal() / static_cast<signal_t>(this->getNPoints()); }
 
  // ----------------------------- Helper Methods
  // --------------------------------------------------------
  //-----------------------------------------------------------------------------------------------
  static inline bool CompareFilePosition(const IMDNode *const a, const IMDNode *const b) {
 
    return (a->getID() < b->getID());
  }
 
  //-----------------------------------------------------------------------------------------------
  static void sortObjByID(std::vector<IMDNode *> &boxes) { std::sort(boxes.begin(), boxes.end(), CompareFilePosition); }
};
} // namespace API
} // namespace Mantid