MDBoxIterator.hxx

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 +
#include "MantidDataObjects/MDBoxBase.h"
#include "MantidDataObjects/MDBoxIterator.h"
#include "MantidGeometry/MDGeometry/MDImplicitFunction.h"
#include <cstddef>
 
namespace Mantid {
namespace DataObjects {
 
//----------------------------------------------------------------------------------------------
TMDE(MDBoxIterator)::MDBoxIterator(API::IMDNode *topBox, size_t maxDepth, bool leafOnly,
                                   Mantid::Geometry::MDImplicitFunction *function)
    : m_pos(0), m_current(nullptr), m_currentMDBox(nullptr), m_events(nullptr),
      m_skippingPolicy(new SkipMaskedBins(this)) {
  commonConstruct(topBox, maxDepth, leafOnly, function);
}
 
//----------------------------------------------------------------------------------------------
TMDE(MDBoxIterator)::MDBoxIterator(API::IMDNode *topBox, size_t maxDepth, bool leafOnly, SkippingPolicy *skippingPolicy,
                                   Mantid::Geometry::MDImplicitFunction *function)
    : m_pos(0), m_current(nullptr), m_currentMDBox(nullptr), m_events(nullptr), m_skippingPolicy(skippingPolicy) {
  commonConstruct(topBox, maxDepth, leafOnly, function);
}
 
//----------------------------------------------------------------------------------------------
TMDE(void MDBoxIterator)::commonConstruct(API::IMDNode *topBox, size_t maxDepth, bool leafOnly,
                                          Mantid::Geometry::MDImplicitFunction *function) {
  if (!topBox)
    throw std::invalid_argument("MDBoxIterator::ctor(): NULL top-level box given.");
 
  if (topBox->getDepth() > maxDepth)
    throw std::invalid_argument("MDBoxIterator::ctor(): The maxDepth parameter "
                                "must be >= the depth of the topBox.");
 
  // Use the "getBoxes" to get all the boxes in a vector.
  m_boxes.clear();
  if (function)
    topBox->getBoxes(m_boxes, maxDepth, leafOnly, function);
  else
    topBox->getBoxes(m_boxes, maxDepth, leafOnly);
 
  // We avoid copying by NOT calling the init() method
  m_max = m_boxes.size();
  // Get the first box
  if (m_max > 0)
    m_current = dynamic_cast<MDBoxBase<MDE, nd> *>(m_boxes[0]);
}
 
//----------------------------------------------------------------------------------------------
TMDE(MDBoxIterator)::MDBoxIterator(std::vector<API::IMDNode *> &boxes, size_t begin, size_t end)
    : m_pos(0), m_current(nullptr), m_currentMDBox(nullptr), m_events(nullptr),
      m_skippingPolicy(new SkipMaskedBins(this))
 
{
  this->init(boxes, begin, end);
}
 
//----------------------------------------------------------------------------------------------
TMDE(void MDBoxIterator)::init(std::vector<API::IMDNode *> &boxes, size_t begin, size_t end) {
  if (begin >= boxes.size())
    throw std::runtime_error("MDBoxIterator::ctor(): invalid beginning position.");
  size_t theEnd = end;
  if (theEnd < begin)
    throw std::runtime_error("MDBoxIterator::ctor(): end position is before the position.");
  if (theEnd > boxes.size())
    theEnd = boxes.size();
 
  // Copy the pointers to boxes in the range.
  m_boxes.clear();
  m_boxes.insert(m_boxes.begin(), boxes.begin() + begin, boxes.begin() + theEnd);
 
  m_max = m_boxes.size();
  // Get the first box
  if (m_max > 0)
    m_current = dynamic_cast<MDBoxBase<MDE, nd> *>(m_boxes[0]);
}
 
//----------------------------------------------------------------------------------------------
TMDE(MDBoxIterator)::~MDBoxIterator() {}
 
//----------------------------------------------------------------------------------------------
TMDE(void MDBoxIterator)::jumpTo(size_t index) {
  releaseEvents();
  m_pos = index;
  if (m_pos < m_max) {
    m_current = dynamic_cast<MDBoxBase<MDE, nd> *>(m_boxes[m_pos]);
  }
}
 
//----------------------------------------------------------------------------------------------
TMDE(bool MDBoxIterator)::valid() const { return m_current != nullptr; }
 
//----------------------------------------------------------------------------------------------
TMDE(bool MDBoxIterator)::next() {
  bool result = this->next(1);
  while (m_skippingPolicy->keepGoing()) {
    result = this->next(1);
    if (!result) {
      return result;
    }
  }
  return result;
}
 
//----------------------------------------------------------------------------------------------
TMDE(inline bool MDBoxIterator)::next(size_t skip) {
  releaseEvents();
  m_pos += skip;
  if (m_pos < m_max) {
    // Move up.
    m_current = dynamic_cast<MDBoxBase<MDE, nd> *>(m_boxes[m_pos]);
    return true;
  } else
    // Done - can't iterate
    return false;
}
 
//----------------------------------------------------------------------------------------------
TMDE(void MDBoxIterator)::getEvents() const {
  if (!m_events) {
    if (!m_currentMDBox)
      m_currentMDBox = dynamic_cast<MDBox<MDE, nd> *>(m_current);
    if (m_currentMDBox) {
      // Retrieve the event vector.
      m_events = &m_currentMDBox->getConstEvents();
    } else
      throw std::runtime_error("MDBoxIterator: requested the event list from a "
                               "box that is not a MDBox!");
  }
}
 
//----------------------------------------------------------------------------------------------
TMDE(void MDBoxIterator)::releaseEvents() const {
  if (m_events) {
    m_currentMDBox->releaseEvents();
    m_events = nullptr;
    m_currentMDBox = nullptr;
  }
}
 
//----------------------------------------------------------------------------------------------
TMDE(size_t MDBoxIterator)::getDataSize() const { return m_max; }
 
//----------------------------------------------------------------------------------------------
TMDE(signal_t MDBoxIterator)::getNormalizedSignal() const {
  // What is our normalization factor?
  switch (m_normalization) {
  case API::NoNormalization:
    return m_current->getSignal();
  case API::VolumeNormalization:
    return m_current->getSignal() * m_current->getInverseVolume();
  case API::NumEventsNormalization:
    return m_current->getSignal() / double(m_current->getNPoints());
  }
  return std::numeric_limits<signal_t>::quiet_NaN();
}
 
TMDE(signal_t MDBoxIterator)::getNormalizedError() const {
  // What is our normalization factor?
  switch (m_normalization) {
  case API::NoNormalization:
    return m_current->getError();
  case API::VolumeNormalization:
    return m_current->getError() * m_current->getInverseVolume();
  case API::NumEventsNormalization:
    return m_current->getError() / double(m_current->getNPoints());
  }
  return std::numeric_limits<signal_t>::quiet_NaN();
}
 
TMDE(signal_t MDBoxIterator)::getSignal() const { return m_current->getSignal(); }
 
TMDE(signal_t MDBoxIterator)::getError() const { return m_current->getError(); }
 
TMDE(std::unique_ptr<coord_t[]> MDBoxIterator)::getVertexesArray(size_t &numVertices) const {
  return m_current->getVertexesArray(numVertices);
}
 
TMDE(std::unique_ptr<coord_t[]> MDBoxIterator)::getVertexesArray(size_t &numVertices, const size_t outDimensions,
                                                                 const bool *maskDim) const {
  return m_current->getVertexesArray(numVertices, outDimensions, maskDim);
}
 
TMDE(Mantid::Kernel::VMD MDBoxIterator)::getCenter() const {
  coord_t center[nd];
  m_current->getCenter(center);
  return Mantid::Kernel::VMD(nd, center);
}
 
//----------------------------------------------------------------------------------------------
TMDE(size_t MDBoxIterator)::getNumEvents() const {
  // Do we have a MDBox?
  m_currentMDBox = dynamic_cast<MDBox<MDE, nd> *>(m_current);
  if (m_currentMDBox)
    return m_current->getNPoints();
  else
    return 0;
}
 
TMDE(uint16_t MDBoxIterator)::getInnerExpInfoIndex(size_t index) const {
  getEvents();
  return (*m_events)[index].getExpInfoIndex();
}
 
TMDE(uint16_t MDBoxIterator)::getInnerGoniometerIndex(size_t index) const {
  getEvents();
  return (*m_events)[index].getGoniometerIndex();
}
 
TMDE(int32_t MDBoxIterator)::getInnerDetectorID(size_t index) const {
  getEvents();
  return (*m_events)[index].getDetectorID();
}
 
TMDE(coord_t MDBoxIterator)::getInnerPosition(size_t index, size_t dimension) const {
  getEvents();
  return (*m_events)[index].getCenter(dimension);
}
 
TMDE(signal_t MDBoxIterator)::getInnerSignal(size_t index) const {
  getEvents();
  return (*m_events)[index].getSignal();
}
 
TMDE(signal_t MDBoxIterator)::getInnerError(size_t index) const {
  getEvents();
  return (*m_events)[index].getError();
}
 
TMDE(bool MDBoxIterator)::getIsMasked() const {
  if (m_current) {
    return m_current->getIsMasked();
  }
  return false;
}
 
TMDE(std::vector<size_t> MDBoxIterator)::findNeighbourIndexes() const {
  throw std::runtime_error("MDBoxIterator does not implement findNeighbourIndex");
}
 
TMDE(std::vector<size_t> MDBoxIterator)::findNeighbourIndexesFaceTouching() const {
  throw std::runtime_error("MDBoxIterator does not implement findNeighbourIndexesFaceTouching");
}
 
TMDE(size_t MDBoxIterator)::getLinearIndex() const {
  throw std::runtime_error("MDBoxIterator does not implement getLinearIndex");
}
 
TMDE(bool MDBoxIterator)::isWithinBounds(size_t) const {
  throw std::runtime_error("MDBoxIterator does not implement isWithinBounds");
}
 
} // namespace DataObjects
} // namespace Mantid