MDHistoWorkspaceIterator.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2011 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/IMDIterator.h"
#include "MantidDataObjects/MDHistoWorkspace.h"
#include "MantidDataObjects/SkippingPolicy.h"
#include "MantidGeometry/MDGeometry/MDImplicitFunction.h"
#include <boost/tuple/tuple.hpp>
#include <map>
#include <vector>
 
namespace Mantid {
namespace DataObjects {
 
// Typedef for a map for mapping width of neighbours (key) to permutations
// needed in the calcualtion.
using PermutationsMap = std::map<std::vector<int>, std::vector<int64_t>>;
// Typedef for extents
using MDExtentPair = boost::tuple<Mantid::coord_t, Mantid::coord_t>; // Min/Max pair
// Typedef for vector of extents
using VecMDExtents = std::vector<MDExtentPair>;
 
class MANTID_DATAOBJECTS_DLL MDHistoWorkspaceIterator : public Mantid::API::IMDIterator {
public:
  MDHistoWorkspaceIterator(const MDHistoWorkspace_const_sptr &workspace, SkippingPolicy *skippingPolicy,
                           Mantid::Geometry::MDImplicitFunction *function = nullptr, size_t beginPos = 0,
                           size_t endPos = size_t(-1));
  MDHistoWorkspaceIterator(const MDHistoWorkspace *workspace, SkippingPolicy *skippingPolicy,
                           Mantid::Geometry::MDImplicitFunction *function = nullptr, size_t beginPos = 0,
                           size_t endPos = size_t(-1));
  MDHistoWorkspaceIterator(const MDHistoWorkspace_const_sptr &workspace,
                           Mantid::Geometry::MDImplicitFunction *function = nullptr, size_t beginPos = 0,
                           size_t endPos = size_t(-1));
  MDHistoWorkspaceIterator(const MDHistoWorkspace *workspace, Mantid::Geometry::MDImplicitFunction *function = nullptr,
                           size_t beginPos = 0, size_t endPos = size_t(-1));
  ~MDHistoWorkspaceIterator() override;
 
  void init(const MDHistoWorkspace *workspace, Mantid::Geometry::MDImplicitFunction *function, size_t beginPos = 0,
            size_t endPos = size_t(-1));
 
  size_t getDataSize() const override;
 
  bool valid() const override;
 
  bool next() override;
 
  bool next(size_t skip) override;
 
  void jumpTo(size_t index) override;
 
  virtual coord_t jumpToNearest(const Mantid::Kernel::VMD &fromLocation);
 
  signal_t getNormalizedSignal() const override;
 
  signal_t getNormalizedError() const override;
 
  signal_t getSignal() const override;
 
  signal_t getError() 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;
 
  Mantid::Kernel::VMD getCenter() const override;
 
  size_t getNumEvents() const override;
 
  virtual signal_t getNumEventsFraction() const;
 
  uint16_t getInnerExpInfoIndex(size_t index) const override;
 
  uint16_t getInnerGoniometerIndex(size_t index) const override;
 
  int32_t getInnerDetectorID(size_t index) const override;
 
  coord_t getInnerPosition(size_t index, size_t dimension) const override;
 
  signal_t getInnerSignal(size_t index) const override;
 
  signal_t getInnerError(size_t index) const override;
 
  bool getIsMasked() const override;
 
  size_t getLinearIndex() const override;
 
  std::vector<size_t> findNeighbourIndexes() const override;
 
  std::vector<size_t> findNeighbourIndexesFaceTouching() const override;
 
  std::vector<size_t> findNeighbourIndexesByWidth(const int &width) const;
 
  std::pair<std::vector<size_t>, std::vector<bool>> findNeighbourIndexesByWidth1D(const int &width,
                                                                                  const int &width_dimension) const;
 
  std::vector<size_t> findNeighbourIndexesByWidth(const std::vector<int> &widths) const;
 
  bool isWithinBounds(size_t index) const override;
 
  size_t permutationCacheSize() const;
 
  VecMDExtents getBoxExtents() const;
 
protected:
  const MDHistoWorkspace *m_ws;
 
  uint64_t m_pos;
 
  uint64_t m_begin;
 
  uint64_t m_max;
 
  std::unique_ptr<Mantid::Geometry::MDImplicitFunction> m_function;
 
  size_t m_nd;
 
  coord_t *m_center;
 
  coord_t *m_origin;
 
  coord_t *m_binWidth;
 
  size_t *m_index;
 
  size_t *m_indexMax;
 
  size_t *m_indexMaker;
 
  mutable std::vector<int64_t> m_permutationsFaceTouching;
 
  mutable PermutationsMap m_permutationsVertexTouchingMap;
 
  SkippingPolicy_scptr m_skippingPolicy;
 
  std::vector<int64_t> createPermutations(const std::vector<int> &widths) const;
};
 
} // namespace DataObjects
} // namespace Mantid