MDBox.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/MDBoxBase.h"
#include "MantidDataObjects/MDDimensionStats.h"
#include "MantidDataObjects/MDLeanEvent.h"
#include "MantidGeometry/MDGeometry/MDDimensionExtents.h"
#include "MantidGeometry/MDGeometry/MDTypes.h"
#include "MantidKernel/MultiThreaded.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 MDBox : public MDBoxBase<MDE, nd> {
public:
  MDBox(Mantid::API::BoxController_sptr &splitter, const uint32_t depth = 0, const size_t nBoxEvents = UNDEF_SIZET,
        const size_t boxID = UNDEF_SIZET);
 
  MDBox(Mantid::API::BoxController *const splitter, const uint32_t depth = 0, const size_t nBoxEvents = UNDEF_SIZET,
        const size_t boxID = UNDEF_SIZET);
 
  MDBox(Mantid::API::BoxController_sptr &splitter, const uint32_t depth,
        const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> &extentsVector,
        const size_t nBoxEvents = UNDEF_SIZET, const size_t boxID = UNDEF_SIZET);
  MDBox(Mantid::API::BoxController *const splitter, const uint32_t depth,
        const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> &extentsVector,
        const size_t nBoxEvents = UNDEF_SIZET, const size_t boxID = UNDEF_SIZET);
 
  using EventIterator = typename std::vector<MDE>::const_iterator;
  MDBox(Mantid::API::BoxController *const bc, const uint32_t depth,
        const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> &extentsVector, EventIterator begin,
        EventIterator end);
 
  MDBox(const MDBox<MDE, nd> &other, Mantid::API::BoxController *const otherBC);
 
  ~MDBox() override;
 
  // ----------------------------- ISaveable Methods
  // ------------------------------------------------------
  Kernel::ISaveable *getISaveable() override;
  Kernel::ISaveable *getISaveable() const override;
  void setFileBacked(const uint64_t /*fileLocation*/, const size_t /*fileSize*/, const bool /*markSaved*/) override;
  void setFileBacked() override;
  void clearFileBacked(bool loadDiskBackedData) override;
  //-----------------------------------------------------------------------------------------------
  void saveAt(API::IBoxControllerIO *const, uint64_t /*position*/) const override;
  void loadAndAddFrom(API::IBoxControllerIO *const, uint64_t, size_t, std::vector<coord_t> &) override;
  void loadAndAddFrom(API::IBoxControllerIO *const, uint64_t /*position*/, size_t /* Size */) override;
  void reserveMemoryForLoad(uint64_t /* Size */) override;
  void clearDataFromMemory() override;
 
  void clear() override;
 
  uint64_t getNPoints() const override;
  size_t getDataInMemorySize() const override { return data.size(); }
  uint64_t getTotalDataSize() const override { return getNPoints(); }
 
  size_t getNumDims() const override;
  size_t getNumMDBoxes() const override;
 
  size_t getNumChildren() const override { return 0; }
  // to avoid casting (which need also the number of dimensions) method say if
  // Node is a box. if not, it is gridbox
  bool isBox() const override { return true; }
 
  API::IMDNode *getChild(size_t /*index*/) override { throw std::runtime_error("MDBox does not have children."); }
 
  void setChildren(const std::vector<API::IMDNode *> & /*boxes*/, const size_t /*indexStart*/,
                   const size_t /*indexEnd*/) override {
    throw std::runtime_error("MDBox cannot have children.");
  }
 
  bool isDataAdded() const;
 
  std::vector<MDE> &getEvents();
  const std::vector<MDE> &getConstEvents() const;
  // the same as getConstEvents above,
  const std::vector<MDE> &getEvents() const;
  void releaseEvents();
 
  std::vector<MDE> *getEventsCopy() override;
 
  void getEventsData(std::vector<coord_t> &coordTable, size_t &nColumns) const override;
  void setEventsData(const std::vector<coord_t> &coordTable) override;
 
  size_t addEvent(const MDE &Evnt) override;
  size_t addEventUnsafe(const MDE &Evnt) override;
 
  // add range of events
  size_t addEvents(const std::vector<MDE> &events) override;
  // unhide MDBoxBase methods
  size_t addEventsUnsafe(const std::vector<MDE> &events) 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 goniometernIndex, 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> &goniometernIndex,
                           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
  splitAllIfNeeded(Mantid::Kernel::ThreadScheduler * /*ts*/ = nullptr) override { /* Do nothing with a box default. */ }
 
  //---------------------------------------------------------------------------------------------------------------------------------
  void refreshCache(Kernel::ThreadScheduler * /*ts*/ = nullptr) override;
  void calculateCentroid(coord_t *centroid) const override;
  void calculateCentroid(coord_t *centroid, const int expInfoIndex) const override;
  coord_t *getCentroid() const override;
  void calculateDimensionStats(MDDimensionStats *stats) const;
  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 getBoxes(std::vector<MDBoxBase<MDE, nd> *> &boxes, size_t /*maxDepth*/, bool /*leafOnly*/);
  void getBoxes(std::vector<API::IMDNode *> &boxes, size_t /*maxDepth*/, bool /*leafOnly*/) override;
 
  void getBoxes(std::vector<MDBoxBase<MDE, nd> *> &boxes, size_t maxDepth, bool leafOnly,
                Mantid::Geometry::MDImplicitFunction *function);
  void getBoxes(std::vector<API::IMDNode *> &boxes, 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;
  //------------------------------------------------------------------------------------------------------------------------------------
  void transformDimensions(std::vector<double> &scaling, std::vector<double> &offset) override;
  //------------------------------------------------------------------------------------------------------------------------------------
  /* Getter to determine if masking is applied.
  @return true if masking is applied.   */
  bool getIsMasked() const override { return m_bIsMasked; }
  void mask() override;
  void unmask() override;
 
protected:
  // the pointer to the class, responsible for saving/restoring this class to
  // the hdd
  mutable std::unique_ptr<Kernel::ISaveable> m_Saveable;
  mutable std::vector<MDE> data;
 
  bool m_bIsMasked;
 
private:
  MDBox(const MDBox &);
  void initMDBox(const size_t nBoxEvents);
  std::vector<coord_t> m_tableData;
 
public:
  using sptr = std::shared_ptr<MDBox<MDE, nd>>;
 
  using vec_t = std::vector<MDE>;
};
 
#ifndef __INTEL_COMPILER
#pragma pack(pop) // Return to default packing size
#endif
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------
/* Internal TMP class to simplify adding events to the box for events and lean
 * events using single interface*/
template <typename MDE, size_t nd> struct IF {
public:
  // create generic events from array of events data and add them to the grid
  // box
  static inline void EXEC(std::vector<MDE> &data, 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,
                          size_t nEvents) {
    for (size_t i = 0; i < nEvents; i++) {
      data.emplace_back(sigErrSq[2 * i], sigErrSq[2 * i + 1], expInfoIndex[i], goniometerIndex[i], detectorId[i],
                        &Coord[i * nd]);
    }
  }
  // create single generic event from event's data
  static inline MDE BUILD_EVENT(const signal_t Signal, const signal_t Error, const coord_t *Coord,
                                const uint16_t expInfoIndex, const uint16_t goniometerIndex,
                                const uint32_t detectorId) {
    return MDE(Signal, Error, expInfoIndex, goniometerIndex, detectorId, Coord);
  }
};
/* Specialize for the case of LeanEvent */
template <size_t nd> struct IF<MDLeanEvent<nd>, nd> {
public:
  // create lean events from array of events data and add them to the box
  static inline void EXEC(std::vector<MDLeanEvent<nd>> &data, 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*/, size_t nEvents) {
    for (size_t i = 0; i < nEvents; i++) {
      data.emplace_back(sigErrSq[2 * i], sigErrSq[2 * i + 1], &Coord[i * nd]);
    }
  }
  // create single lean event from event's data
  static inline MDLeanEvent<nd> BUILD_EVENT(const signal_t Signal, const signal_t Error, const coord_t *Coord,
                                            const uint16_t /*expInfoIndex*/, const uint16_t /*goniometerIndex*/,
                                            const uint32_t /*detectorId*/) {
    return MDLeanEvent<nd>(Signal, Error, Coord);
  }
};
} // namespace DataObjects
 
} // namespace Mantid