MDBoxBase.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/IMDNode.h"
#include "MantidAPI/IMDWorkspace.h"
#include "MantidDataObjects/MDLeanEvent.h"
#include "MantidGeometry/MDGeometry/MDDimensionExtents.h"
#include "MantidGeometry/MDGeometry/MDImplicitFunction.h"
#include "MantidKernel/ISaveable.h"
#include "MantidKernel/VMD.h"
#include <iosfwd>
#include <mutex>
 
#define MDBOX_TRACK_CENTROID
 
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 MDBoxBase : public Mantid::API::IMDNode {
public:
  //-----------------------------------------------------------------------------------------------
  MDBoxBase(Mantid::API::BoxController *const boxController = nullptr, const uint32_t depth = 0,
            const size_t boxID = UNDEF_SIZET);
 
  MDBoxBase(Mantid::API::BoxController *const boxController, const uint32_t depth, const size_t boxID,
            const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> &extentsVector);
 
  MDBoxBase(const MDBoxBase<MDE, nd> &box, Mantid::API::BoxController *const otherBC);
 
  std::string getEventType() const override { return MDE::getTypeName(); }
  unsigned int getCoordType() const override { return sizeof(coord_t); }
 
  bool isLeaf() const override final { return getNumChildren() == 0; }
 
  size_t getID() const override { return m_fileID; }
  void setID(const size_t &newID) override { m_fileID = newID; }
  // -------------------------------- Parents/Children-Related
  // -------------------------------------------
  void setParent(IMDNode *parent) override { m_parent = parent; }
 
  IMDNode *getParent() override { return m_parent; }
 
  const IMDNode *getParent() const override { return m_parent; }
 
  const IMDNode *getBoxAtCoord(const coord_t * /*coords*/) override { return this; }
 
  // -------------------------------- Events-Related
  // -------------------------------------------
  void getEventsData(std::vector<coord_t> & /*coordTable*/, size_t &nColumns) const override { nColumns = 0; }
  void setEventsData(const std::vector<coord_t> & /*coordTable*/) override {}
  virtual std::vector<MDE> *getEventsCopy() = 0;
 
  //----------------------------------------------------------------------------------------------------------------------
  virtual size_t addEvent(const MDE &point) = 0;
  virtual size_t addEventUnsafe(const MDE &point) = 0;
  //----------------------------------------------------------------------------------------------------------------------
  // add range of events
  virtual size_t addEvents(const std::vector<MDE> &events);
  virtual size_t addEventsUnsafe(const std::vector<MDE> &events);
  //----------------------------------------------------------------------------------------------------------------------
  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 = 0;
 
  void centroidSphere(Mantid::API::CoordTransform &radiusTransform, const coord_t radiusSquared, coord_t *centroid,
                      signal_t &signal) const override = 0;
 
  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 = 0;
 
  // -------------------------------------------------------------------------------------------
  Mantid::API::BoxController *getBoxController() const override { return m_BoxController; }
  Mantid::API::BoxController *getBoxController() override { return m_BoxController; }
 
  // -------------------------------- Geometry/vertexes-Related
  // -------------------------------------------
 
  std::vector<Mantid::Kernel::VMD> getVertexes() const override;
  std::unique_ptr<coord_t[]> getVertexesArray(size_t &numVertices) const override;
  std::unique_ptr<coord_t[]> getVertexesArray(size_t &numVertices, const size_t outDimensions,
                                              const bool *maskDim) const override;
  void transformDimensions(std::vector<double> &scaling, std::vector<double> &offset) override;
 
  //-----------------------------------------------------------------------------------------------
  void setExtents(size_t dim, double min, double max) {
    if (dim >= nd)
      throw std::invalid_argument("Invalid dimension passed to MDBox::setExtents");
 
    extents[dim].setExtents(min, max);
    // volume has to be recalculated as extents have changed;
    this->calcVolume();
  }
  void setExtents(double min[nd], double max[nd]) {
    for (size_t dim = 0; dim < nd; dim++) {
      this->extents[dim].setExtents(min[dim], max[dim]);
    }
    this->calcVolume();
  }
 
  //-----------------------------------------------------------------------------------------------
  Mantid::Geometry::MDDimensionExtents<coord_t> &getExtents(size_t dim) override { return extents[dim]; }
 
  //-----------------------------------------------------------------------------------------------
  std::string getExtentsStr() const {
    std::string mess;
    size_t ndm1 = nd - 1;
    if (ndm1 > 32)
      return mess;
 
    for (size_t d = 0; d < ndm1; ++d)
      mess += extents[d].extentsStr() + ",";
 
    mess += extents[ndm1].extentsStr();
    return mess;
  }
 
  coord_t getBoxSize(size_t d) { return extents[d].getSize(); }
 
  //-----------------------------------------------------------------------------------------------
  void getCenter(coord_t *const center) const override {
    for (size_t d = 0; d < nd; ++d)
      center[d] = extents[d].getCentre();
  }
 
  //-----------------------------------------------------------------------------------------------
  inline void calcVolume() override {
    double volume(1);
    for (size_t d = 0; d < nd; d++) {
      volume *= double(extents[d].getSize());
    }
    m_inverseVolume = coord_t(1. / volume);
  }
 
  //-----------------------------------------------------------------------------------------------
  signal_t getSignal() const override { return m_signal; }
 
  //-----------------------------------------------------------------------------------------------
  signal_t getError() const override { return sqrt(m_errorSquared); }
 
  //-----------------------------------------------------------------------------------------------
  signal_t getErrorSquared() const override { return m_errorSquared; }
 
  //-----------------------------------------------------------------------------------------------
  virtual signal_t getTotalWeight() const { return m_totalWeight; }
 
  //-----------------------------------------------------------------------------------------------
  void setSignal(const signal_t signal) override { m_signal = signal; }
 
  //-----------------------------------------------------------------------------------------------
  void setErrorSquared(const signal_t ErrorSquared) override { m_errorSquared = ErrorSquared; }
 
  //-----------------------------------------------------------------------------------------------
  virtual void setTotalWeight(const signal_t total) { m_totalWeight = total; }
 
  //-----------------------------------------------------------------------------------------------
  signal_t getSignalNormalized() const override { return m_signal * m_inverseVolume; }
 
  //-----------------------------------------------------------------------------------------------
  virtual signal_t getErrorSquaredNormalized() const { return m_errorSquared * m_inverseVolume; }
 
  //-----------------------------------------------------------------------------------------------
  uint32_t getDepth() const override { return m_depth; }
 
  //-----------------------------------------------------------------------------------------------
  void setDepth(uint32_t depth) { m_depth = depth; }
 
  //-----------------------------------------------------------------------------------------------
  coord_t getVolume() const { return 1.0f / m_inverseVolume; }
 
  //-----------------------------------------------------------------------------------------------
  coord_t getInverseVolume() const override { return m_inverseVolume; }
 
  //-----------------------------------------------------------------------------------------------
  void setInverseVolume(const coord_t invVolume) override { m_inverseVolume = invVolume; }
 
  virtual void calculateGridCaches() {}
 
protected:
  template <typename EventIterator> void calcCaches(const EventIterator &begin, const EventIterator &end);
  Mantid::Geometry::MDDimensionExtents<coord_t> extents[nd];
 
  mutable coord_t m_centroid[nd];
  mutable signal_t m_signal;
 
  mutable signal_t m_errorSquared;
 
  mutable signal_t m_totalWeight;
 
  Mantid::API::BoxController *const m_BoxController;
 
  coord_t m_inverseVolume;
 
  uint32_t m_depth;
 
  Mantid::API::IMDNode *m_parent;
 
  size_t m_fileID;
  std::mutex m_dataMutex;
 
private:
  MDBoxBase(const MDBoxBase<MDE, nd> &box);
 
public:
  using sptr = std::shared_ptr<MDBoxBase<MDE, nd>>;
 
}; //(end class MDBoxBase)
 
#ifndef __INTEL_COMPILER
#pragma pack(pop) // Return to default packing size
#endif
 
template <typename MDE, size_t nd>
template <typename EventIterator>
void MDBoxBase<MDE, nd>::calcCaches(const EventIterator &begin, const EventIterator &end) {
  m_signal = 0;
  m_errorSquared = 0;
  m_totalWeight = 0;
  coord_t *centroid = m_centroid;
  std::fill_n(centroid, nd, 0.0f);
  for (auto it = begin; it != end; ++it) {
    auto evSignal = it->getSignal();
    m_signal += evSignal;
    m_errorSquared += it->getErrorSquared();
    ++m_totalWeight;
    for (auto d = 0u; d < nd; d++) {
      // Total up the coordinate weighted by the signal.
      centroid[d] += it->getCenter(d) * static_cast<coord_t>(evSignal);
    }
  }
 
  // Normalize by the total signal
  const coord_t reciprocal = 1.0f / static_cast<coord_t>(m_signal);
  for (size_t d = 0; d < nd; ++d) {
    centroid[d] *= reciprocal;
  }
}
 
} // namespace DataObjects
} // namespace Mantid