MDGridBox.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/IMDWorkspace.h"
#include "MantidDataObjects/MDBox.h"
#include "MantidDataObjects/MDBoxBase.h"
#include "MantidDataObjects/MDLeanEvent.h"
#include "MantidGeometry/MDGeometry/MDDimensionExtents.h"
#include "MantidKernel/ProgressBase.h"
#include "MantidKernel/Task.h"
#include "MantidKernel/ThreadScheduler.h"
 
namespace Mantid {
namespace DataObjects {
 
#ifndef __INTEL_COMPILER // As of July 13, the packing has no effect for the
                         // Intel compiler and produces a warning
#pragma pack(push, 4)    // Ensure the structure is no larger than it needs to
#endif
 
//===============================================================================================
TMDE_CLASS
class MANTID_DATAOBJECTS_DLL MDGridBox : public MDBoxBase<MDE, nd> {
public:
  MDGridBox(std::shared_ptr<API::BoxController> &bc, const uint32_t depth,
            const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> &extentsVector);
  MDGridBox(Mantid::API::BoxController *const bc, const uint32_t depth,
            const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> &extentsVector);
 
  MDGridBox(MDBox<MDE, nd> *box);
 
  MDGridBox(const MDGridBox<MDE, nd> &other, Mantid::API::BoxController *const otherBC);
 
  ~MDGridBox() override;
  // ----------------------------- ISaveable Methods
  // ------------------------------------------------------
  Kernel::ISaveable *getISaveable() override { return nullptr; }
  Kernel::ISaveable *getISaveable() const override { return nullptr; }
  void setFileBacked(const uint64_t /*fileLocation*/, const size_t /*fileSize*/, const bool /*markSaved*/) override;
  void setFileBacked() override;
  void clearFileBacked(bool loadDiskBackedData) override;
  void clear() override;
  void clearDataFromMemory() override { /*it seems works on boxes only though recursive
                                  clearing makes sence, not yet implemented*/
  }
  void saveAt(API::IBoxControllerIO *const, uint64_t /*position*/) const override { /*Not saveable */
  }
 
  void loadAndAddFrom(API::IBoxControllerIO *const, uint64_t /*position*/, size_t /* Size */,
                      std::vector<coord_t> & /*memory*/) override { /*Not directly loadable */
  }
 
  void loadAndAddFrom(API::IBoxControllerIO *const, uint64_t /*position*/,
                      size_t /* Size */) override { /*Not directly loadable */
  }
  void reserveMemoryForLoad(uint64_t /* Size */) override { /*Not directly loadable */
  }
  //-------------------------------------------------------------------------------------------------------
  // Setters for cached values
  void setNPoints(const uint64_t &n) { nPoints = n; }
  //-------------------------------------------------------------------------------------------------------
  uint64_t getNPoints() const override { return nPoints; }
  uint64_t getTotalDataSize() const override { return nPoints; }
  size_t getDataInMemorySize() const override;
 
  size_t getNumDims() const override;
  size_t getNumMDBoxes() const override;
  size_t getNumChildren() const override;
  bool isBox() const override { return false; }
 
  size_t getChildIndexFromID(size_t childId) const;
  API::IMDNode *getChild(size_t index) override;
  void setChild(size_t index, MDGridBox<MDE, nd> *newChild);
 
  void setChildren(const std::vector<API::IMDNode *> &otherBoxes, const size_t indexStart,
                   const size_t indexEnd) override;
 
  void getBoxes(std::vector<API::IMDNode *> &outBoxes, size_t maxDepth, bool leafOnly) override;
  void getBoxes(std::vector<API::IMDNode *> &outBoxes, size_t maxDepth, bool leafOnly,
                Mantid::Geometry::MDImplicitFunction *function) override;
 
  void getBoxes(std::vector<API::IMDNode *> &outBoxes, const std::function<bool(API::IMDNode *)> &cond) final override;
 
  const API::IMDNode *getBoxAtCoord(const coord_t *coords) override;
 
  void transformDimensions(std::vector<double> &scaling, std::vector<double> &offset) override;
  //----------------------------------------------------------------------------
 
  std::vector<MDE> *getEventsCopy() override;
 
  //----------------------------------------------------------------------------------------------------------------------
  size_t addEvent(const MDE &event) override;
  size_t addEventUnsafe(const MDE &event) override;
 
  /*--------------->  EVENTS from event data
   * <-------------------------------------------------------------*/
  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) override;
  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) override;
  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) override;
  //----------------------------------------------------------------------------------------------------------------------
 
  void centerpointBin(MDBin<MDE, nd> &bin, bool *fullyContained) const override;
 
  void generalBin(MDBin<MDE, nd> & /*bin*/, Mantid::Geometry::MDImplicitFunction & /*function*/) const override {}
 
  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 override;
 
  void centroidSphere(Mantid::API::CoordTransform &radiusTransform, const coord_t radiusSquared, coord_t *centroid,
                      signal_t &signal) const override;
 
  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 override;
 
  void splitContents(size_t index, Kernel::ThreadScheduler *ts = nullptr);
 
  void splitAllIfNeeded(Kernel::ThreadScheduler *ts = nullptr) override;
 
  void refreshCache(Kernel::ThreadScheduler *ts = nullptr) override;
 
  void calculateGridCaches() override final;
 
  bool getIsMasked() const override;
  void mask() override;
  void unmask() override;
  // ======================= Testing/Debugging Methods =================
  std::vector<MDBoxBase<MDE, nd> *> &getBoxes() { return m_Children; }
 
  //-------------------------------------------------------------------------
  void calculateCentroid(coord_t * /*centroid*/) const override {
    throw(std::runtime_error("This function should not be called on MDGridBox "
                             "(as its meaning for MDbox is dubious too)"));
  }
  //-------------------------------------------------------------------------
  void calculateCentroid(coord_t * /*centroid*/, const int /*expInfoIndex*/) const override {
    throw(std::runtime_error("This function should not be called on MDGridBox "
                             "(as its meaning for MDbox is dubious too)"));
  }
  //-------------------------------------------------------------------------
  coord_t *getCentroid() const override {
    throw(std::runtime_error("This function should not be called on MDGridBox "
                             "(as its meaning for MDbox is dubious too)"));
  }
 
public:
  using sptr = std::shared_ptr<MDGridBox<MDE, nd>>;
 
  using boxVector_t = std::vector<MDBoxBase<MDE, nd> *>;
 
private:
  size_t calculateChildIndex(const MDE &event) const;
 
  size_t split[nd];
  size_t splitCumul[nd];
  double m_SubBoxSize[nd];
 
  size_t numBoxes;
 
  std::vector<MDBoxBase<MDE, nd> *> m_Children;
 
  coord_t diagonalSquared;
 
  size_t nPoints;
 
  //=================== PRIVATE METHODS =======================================
 
  size_t getLinearIndex(size_t *indices) const;
 
  size_t computeSizesFromSplit();
  void fillBoxShell(const size_t tot, const coord_t ChildInverseVolume);
  MDGridBox(const MDGridBox<MDE, nd> &box);
  MDGridBox() = default;
  size_t initGridBox();
};
 
#ifndef __INTEL_COMPILER
#pragma pack(pop) // Return to default packing size
#endif
 
} // namespace DataObjects
} // namespace Mantid