EBGeometry_Octree.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 Robert Marskar <robert.marskar@sintef.no>
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef EBGEOMETRY_OCTREE_HPP
#define EBGEOMETRY_OCTREE_HPP
 
// Std includes
#include <array>
#include <cstddef>
#include <functional>
#include <memory>
 
// Our includes
#include "EBGeometry_Macros.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
namespace Octree {
 
enum OctantIndex : size_t
{
  BottomLeftFront  = 0,
  BottomRightFront = 1,
  BottomLeftBack   = 2,
  BottomRightBack  = 3,
  TopLeftFront     = 4,
  TopRightFront    = 5,
  TopLeftBack      = 6,
  TopRightBack     = 7
};
 
template <typename T>
constexpr std::array<Vec3T<T>, 8> LowCorner = {Vec3T<T>(0.0, 0.0, 0.0),
                                               Vec3T<T>(0.5, 0.0, 0.0),
                                               Vec3T<T>(0.0, 0.5, 0.0),
                                               Vec3T<T>(0.5, 0.5, 0.0),
                                               Vec3T<T>(0.0, 0.0, 0.5),
                                               Vec3T<T>(0.5, 0.0, 0.5),
                                               Vec3T<T>(0.0, 0.5, 0.5),
                                               Vec3T<T>(0.5, 0.5, 0.5)};
 
template <typename T>
constexpr std::array<Vec3T<T>, 8> HighCorner = {LowCorner<T>[0] + 0.5 * Vec3T<T>::ones(),
                                                LowCorner<T>[1] + 0.5 * Vec3T<T>::ones(),
                                                LowCorner<T>[2] + 0.5 * Vec3T<T>::ones(),
                                                LowCorner<T>[3] + 0.5 * Vec3T<T>::ones(),
                                                LowCorner<T>[4] + 0.5 * Vec3T<T>::ones(),
                                                LowCorner<T>[5] + 0.5 * Vec3T<T>::ones(),
                                                LowCorner<T>[6] + 0.5 * Vec3T<T>::ones(),
                                                LowCorner<T>[7] + 0.5 * Vec3T<T>::ones()};
 
template <typename Meta, typename Data = void>
class Node : public std::enable_shared_from_this<Node<Meta, Data>>
{
public:
  using SplitFunction = std::function<bool(const Node<Meta, Data>& a_node)>;
 
  using MetaConstructor = std::function<Meta(const OctantIndex& a_index, const Meta& a_parentMeta)>;
 
  using DataConstructor =
    std::function<std::shared_ptr<Data>(const OctantIndex& a_index, const std::shared_ptr<Data>& a_parentData)>;
 
  using LeafEvaluator = std::function<void(const Node<Meta, Data>& a_node)>;
 
  using PrunePredicate = std::function<bool(const Node<Meta, Data>& a_node)>;
 
  using ChildOrderer = std::function<void(std::array<std::shared_ptr<const Node<Meta, Data>>, 8>& a_children)>;
 
  Node() = default;
 
  Node(const Node& a_other) = default;
 
  Node(Node&& a_other) = default;
 
  ~Node() = default;
 
  Node&
  operator=(const Node& a_other) = default;
 
  Node&
  operator=(Node&& a_other) = default;
 
  [[nodiscard]] inline const std::array<std::shared_ptr<Node<Meta, Data>>, 8>&
  getChildren() const noexcept;
 
  [[nodiscard]] inline std::array<std::shared_ptr<Node<Meta, Data>>, 8>&
  getChildren() noexcept;
 
  [[nodiscard]] inline Meta&
  getMetaData() noexcept;
 
  [[nodiscard]] inline const Meta&
  getMetaData() const noexcept;
 
  [[nodiscard]] inline std::shared_ptr<Data>&
  getData() noexcept;
 
  [[nodiscard]] inline const std::shared_ptr<Data>&
  getData() const noexcept;
 
  [[nodiscard]] inline bool
  isLeaf() const noexcept;
 
  inline void
  buildDepthFirst(const SplitFunction&   a_splitFunction,
                  const MetaConstructor& a_metaConstructor,
                  const DataConstructor& a_dataConstructor) noexcept;
 
  inline void
  buildBreadthFirst(const SplitFunction&   a_splitFunction,
                    const MetaConstructor& a_metaConstructor,
                    const DataConstructor& a_dataConstructor) noexcept;
 
  inline void
  traverse(
    const LeafEvaluator&  a_leafEvaluator,
    const PrunePredicate& a_prunePredicate,
    const ChildOrderer&   a_childOrderer = [](std::array<std::shared_ptr<const Node<Meta, Data>>, 8>&) -> void {
      return;
    }) const noexcept;
 
protected:
  Meta m_meta;
 
  std::shared_ptr<Data> m_data;
 
  std::array<std::shared_ptr<Node<Meta, Data>>, 8> m_children;
};
} // namespace Octree
 
} // namespace EBGeometry
 
#include "EBGeometry_OctreeImplem.hpp"
 
#endif