EBGeometry_Octree.hpp

Go to the documentation of this file.

/* EBGeometry
 * Copyright © 2023 Robert Marskar
 * Please refer to Copyright.txt and LICENSE in the EBGeometry root directory.
 */
 
#ifndef EBGeometry_Octree
#define EBGeometry_Octree
 
// Std includes
#include <array>
#include <functional>
#include <memory>
 
// Our includes
#include "EBGeometry_Vec.hpp"
#include "EBGeometry_NamespaceHeader.hpp"
 
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>::one(),
                                                  LowCorner<T>[1] + 0.5 * Vec3T<T>::one(),
                                                  LowCorner<T>[2] + 0.5 * Vec3T<T>::one(),
                                                  LowCorner<T>[3] + 0.5 * Vec3T<T>::one(),
                                                  LowCorner<T>[4] + 0.5 * Vec3T<T>::one(),
                                                  LowCorner<T>[5] + 0.5 * Vec3T<T>::one(),
                                                  LowCorner<T>[6] + 0.5 * Vec3T<T>::one(),
                                                  LowCorner<T>[7] + 0.5 * Vec3T<T>::one()};
 
  template <typename Meta, typename Data = void>
  class Node : public std::enable_shared_from_this<Node<Meta, Data>>
  {
  public:
    using StopFunction = 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 Updater = std::function<void(const Node<Meta, Data>& a_node)>;
 
    using Visiter = std::function<bool(const Node<Meta, Data>& a_node)>;
 
    using Sorter = std::function<void(std::array<std::shared_ptr<const Node<Meta, Data>>, 8>& a_children)>;
 
    Node();
 
    virtual ~Node();
 
    inline const std::array<std::shared_ptr<Node<Meta, Data>>, 8>&
    getChildren() const noexcept;
 
    inline std::array<std::shared_ptr<Node<Meta, Data>>, 8>&
    getChildren() noexcept;
 
    inline Meta&
    getMetaData() noexcept;
 
    inline const Meta&
    getMetaData() const noexcept;
 
    inline std::shared_ptr<Data>&
    getData() noexcept;
 
    inline const std::shared_ptr<Data>&
    getData() const noexcept;
 
    inline bool
    isLeaf() const noexcept;
 
    inline void
    buildDepthFirst(const StopFunction&    a_stopFunction,
                    const MetaConstructor& a_metaConstructor,
                    const DataConstructor& a_dataConstructor) noexcept;
 
    inline void
    buildBreadthFirst(const StopFunction&    a_stopFunction,
                      const MetaConstructor& a_metaConstructor,
                      const DataConstructor& a_dataConstructor) noexcept;
 
    inline void
    traverse(
      const Updater& a_updater,
      const Visiter& a_visiter,
      const Sorter&  a_sorter = [](std::array<std::shared_ptr<const Node<Meta, Data>>, 8>& a_children) -> 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
 
#include "EBGeometry_NamespaceFooter.hpp"
 
#include "EBGeometry_OctreeImplem.hpp"
 
#endif