Tatooine
Classes | Public Types | Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | Friends | List of all members
tatooine::celltree< Mesh > Struct Template Reference

#include <celltree.h>

Inheritance diagram for tatooine::celltree< Mesh >:
[legend]
Collaboration diagram for tatooine::celltree< Mesh >:
[legend]

Classes

struct  node_type
 

Public Types

using real_type = typename Mesh::real_type
 
using vec_t = vec< real_type, num_dimensions()>
 
using this_type = celltree< Mesh >
 

Public Member Functions

 celltree (celltree const &)=default
 
 celltree (celltree &&) noexcept=default
 
auto operator= (celltree const &) -> celltree &=default
 
auto operator= (celltree &&) noexcept -> celltree &=default
 
 ~celltree ()=default
 
 celltree (Mesh const &mesh)
 
 celltree (Mesh const &mesh, vec< real_type, num_dimensions()> const &min, vec< real_type, num_dimensions()> const &max)
 
constexpr auto mesh () const -> auto const &
 
constexpr auto cell_handles () const -> auto const &
 
constexpr auto node (std::size_t const i) const -> auto const &
 
constexpr auto nodes () const -> auto const &
 
constexpr auto indices () const -> auto const &
 
template<std::size_t... Seq>
constexpr auto min_cell_boundary (std::size_t const cell_idx, std::uint8_t const dim, std::index_sequence< Seq... >) const
 
template<std::size_t... Seq>
constexpr auto max_cell_boundary (std::size_t const cell_idx, std::uint8_t const dim, std::index_sequence< Seq... >) const
 
template<std::size_t... Seq>
constexpr auto cell_center (std::size_t const cell_idx, std::uint8_t const dim, std::index_sequence< Seq... >) const
 
constexpr auto axis_aligned_bounding_box () const
 
auto cells_at (vec_t const &x) const
 
auto write_vtk (filesystem::path const &path)
 

Static Public Member Functions

static constexpr auto num_dimensions () -> std::size_t
 
static constexpr auto num_vertices_per_simplex ()
 

Private Member Functions

constexpr auto mesh () -> auto &
 
constexpr auto cell_handles () -> auto &
 
constexpr auto node (std::size_t const i) -> auto &
 
constexpr auto nodes () -> auto &
 
constexpr auto indices () -> auto &
 
template<std::size_t... Seq>
auto cells_at (vec_t const &x, std::size_t const cur_node_idx, std::vector< std::size_t > &cells, std::index_sequence< Seq... > seq) const -> void
 
template<std::size_t... Seq>
auto split_dimension (std::size_t const ni, std::index_sequence< Seq... >) const
 
auto add_children (std::size_t const ni)
 
template<std::size_t... Seq>
auto split_if_necessary (std::size_t const ni, std::size_t const level, std::size_t const max_level)
 
template<std::size_t... Seq>
auto split (std::size_t const ni, std::size_t const level, std::size_t const max_level)
 
template<std::size_t... Seq>
auto split (std::size_t const ni, std::size_t const level, std::size_t const max_level, std::index_sequence< Seq... > seq) -> void
 
template<std::size_t... Seq>
auto split_with_median (std::size_t const ni, std::size_t const li, std::size_t const ri, std::uint8_t const split_dim, std::index_sequence< Seq... > seq)
 
template<std::size_t... Seq>
auto split_with_heuristic (std::size_t const ni, std::size_t const li, std::size_t const ri, std::uint8_t const split_dim, real_type const min, real_type const max, std::index_sequence< Seq... > seq)
 TODO heuristic not working correctly. More...
 
template<std::size_t... Seq>
auto sort_indices (std::size_t const ni, std::uint8_t const dim, std::index_sequence< Seq... > seq)
 
auto write_vtk_collect_positions_and_indices (std::vector< vec< real_type, num_dimensions()> > &positions, std::vector< std::vector< std::size_t > > &indices, std::size_t cur_node_idx, tatooine::axis_aligned_bounding_box< real_type, num_dimensions()> const &aabb, std::size_t cur_level=0, std::size_t cur_idx=0) -> std::size_t
 

Private Attributes

Mesh const * m_mesh
 
std::vector< node_typem_nodes
 
std::vector< std::size_t > m_cell_handles
 
vec< real_type, num_dimensions()> m_min
 
vec< real_type, num_dimensions()> m_max
 

Friends

struct detail::celltree_parent< celltree< Mesh >, typename Mesh::real_type, Mesh::num_dimensions(), Mesh::num_vertices_per_simplex()>
 

Member Typedef Documentation

◆ real_type

template<typename Mesh >
using tatooine::celltree< Mesh >::real_type = typename Mesh::real_type

◆ this_type

template<typename Mesh >
using tatooine::celltree< Mesh >::this_type = celltree<Mesh>

◆ vec_t

template<typename Mesh >
using tatooine::celltree< Mesh >::vec_t = vec<real_type, num_dimensions()>

Constructor & Destructor Documentation

◆ celltree() [1/4]

template<typename Mesh >
tatooine::celltree< Mesh >::celltree ( celltree< Mesh > const &  )
default

◆ celltree() [2/4]

template<typename Mesh >
tatooine::celltree< Mesh >::celltree ( celltree< Mesh > &&  )
defaultnoexcept

◆ ~celltree()

template<typename Mesh >
tatooine::celltree< Mesh >::~celltree ( )
default

◆ celltree() [3/4]

template<typename Mesh >
tatooine::celltree< Mesh >::celltree ( Mesh const &  mesh)
inline

◆ celltree() [4/4]

template<typename Mesh >
tatooine::celltree< Mesh >::celltree ( Mesh const &  mesh,
vec< real_type, num_dimensions()> const &  min,
vec< real_type, num_dimensions()> const &  max 
)
inline

Member Function Documentation

◆ add_children()

template<typename Mesh >
auto tatooine::celltree< Mesh >::add_children ( std::size_t const  ni)
inlineprivate
Parameters
ninode index

◆ axis_aligned_bounding_box()

template<typename Mesh >
constexpr auto tatooine::celltree< Mesh >::axis_aligned_bounding_box ( ) const
inlineconstexpr

◆ cell_center()

template<typename Mesh >
template<std::size_t... Seq>
constexpr auto tatooine::celltree< Mesh >::cell_center ( std::size_t const  cell_idx,
std::uint8_t const  dim,
std::index_sequence< Seq... >   
) const
inlineconstexpr

◆ cell_handles() [1/2]

template<typename Mesh >
constexpr auto tatooine::celltree< Mesh >::cell_handles ( ) -> auto&
inlineconstexprprivate

◆ cell_handles() [2/2]

template<typename Mesh >
constexpr auto tatooine::celltree< Mesh >::cell_handles ( ) const -> auto const&
inlineconstexpr

◆ cells_at() [1/2]

template<typename Mesh >
auto tatooine::celltree< Mesh >::cells_at ( vec_t const &  x) const
inline

◆ cells_at() [2/2]

template<typename Mesh >
template<std::size_t... Seq>
auto tatooine::celltree< Mesh >::cells_at ( vec_t const &  x,
std::size_t const  cur_node_idx,
std::vector< std::size_t > &  cells,
std::index_sequence< Seq... >  seq 
) const -> void
inlineprivate

◆ indices() [1/2]

template<typename Mesh >
constexpr auto tatooine::celltree< Mesh >::indices ( ) -> auto&
inlineconstexprprivate

◆ indices() [2/2]

template<typename Mesh >
constexpr auto tatooine::celltree< Mesh >::indices ( ) const -> auto const&
inlineconstexpr

◆ max_cell_boundary()

template<typename Mesh >
template<std::size_t... Seq>
constexpr auto tatooine::celltree< Mesh >::max_cell_boundary ( std::size_t const  cell_idx,
std::uint8_t const  dim,
std::index_sequence< Seq... >   
) const
inlineconstexpr

◆ mesh() [1/2]

template<typename Mesh >
constexpr auto tatooine::celltree< Mesh >::mesh ( ) -> auto&
inlineconstexprprivate

◆ mesh() [2/2]

template<typename Mesh >
constexpr auto tatooine::celltree< Mesh >::mesh ( ) const -> auto const&
inlineconstexpr

◆ min_cell_boundary()

template<typename Mesh >
template<std::size_t... Seq>
constexpr auto tatooine::celltree< Mesh >::min_cell_boundary ( std::size_t const  cell_idx,
std::uint8_t const  dim,
std::index_sequence< Seq... >   
) const
inlineconstexpr

◆ node() [1/2]

template<typename Mesh >
constexpr auto tatooine::celltree< Mesh >::node ( std::size_t const  i) -> auto&
inlineconstexprprivate

◆ node() [2/2]

template<typename Mesh >
constexpr auto tatooine::celltree< Mesh >::node ( std::size_t const  i) const -> auto const&
inlineconstexpr

◆ nodes() [1/2]

template<typename Mesh >
constexpr auto tatooine::celltree< Mesh >::nodes ( ) -> auto&
inlineconstexprprivate

◆ nodes() [2/2]

template<typename Mesh >
constexpr auto tatooine::celltree< Mesh >::nodes ( ) const -> auto const&
inlineconstexpr

◆ num_dimensions()

template<typename Mesh >
static constexpr auto tatooine::celltree< Mesh >::num_dimensions ( ) -> std::size_t
inlinestaticconstexpr

◆ num_vertices_per_simplex()

template<typename Mesh >
static constexpr auto tatooine::celltree< Mesh >::num_vertices_per_simplex ( )
inlinestaticconstexpr

◆ operator=() [1/2]

template<typename Mesh >
auto tatooine::celltree< Mesh >::operator= ( celltree< Mesh > &&  ) -> celltree &=default
defaultnoexcept

◆ operator=() [2/2]

template<typename Mesh >
auto tatooine::celltree< Mesh >::operator= ( celltree< Mesh > const &  ) -> celltree &=default
default

◆ sort_indices()

template<typename Mesh >
template<std::size_t... Seq>
auto tatooine::celltree< Mesh >::sort_indices ( std::size_t const  ni,
std::uint8_t const  dim,
std::index_sequence< Seq... >  seq 
)
inlineprivate
Parameters
ninode index

◆ split() [1/2]

template<typename Mesh >
template<std::size_t... Seq>
auto tatooine::celltree< Mesh >::split ( std::size_t const  ni,
std::size_t const  level,
std::size_t const  max_level 
)
inlineprivate

◆ split() [2/2]

template<typename Mesh >
template<std::size_t... Seq>
auto tatooine::celltree< Mesh >::split ( std::size_t const  ni,
std::size_t const  level,
std::size_t const  max_level,
std::index_sequence< Seq... >  seq 
) -> void
inlineprivate

◆ split_dimension()

template<typename Mesh >
template<std::size_t... Seq>
auto tatooine::celltree< Mesh >::split_dimension ( std::size_t const  ni,
std::index_sequence< Seq... >   
) const
inlineprivate
Parameters
ninode index

◆ split_if_necessary()

template<typename Mesh >
template<std::size_t... Seq>
auto tatooine::celltree< Mesh >::split_if_necessary ( std::size_t const  ni,
std::size_t const  level,
std::size_t const  max_level 
)
inlineprivate

◆ split_with_heuristic()

template<typename Mesh >
template<std::size_t... Seq>
auto tatooine::celltree< Mesh >::split_with_heuristic ( std::size_t const  ni,
std::size_t const  li,
std::size_t const  ri,
std::uint8_t const  split_dim,
real_type const  min,
real_type const  max,
std::index_sequence< Seq... >  seq 
)
inlineprivate

TODO heuristic not working correctly.

◆ split_with_median()

template<typename Mesh >
template<std::size_t... Seq>
auto tatooine::celltree< Mesh >::split_with_median ( std::size_t const  ni,
std::size_t const  li,
std::size_t const  ri,
std::uint8_t const  split_dim,
std::index_sequence< Seq... >  seq 
)
inlineprivate

◆ write_vtk()

template<typename Mesh >
auto tatooine::celltree< Mesh >::write_vtk ( filesystem::path const &  path)
inline

◆ write_vtk_collect_positions_and_indices()

template<typename Mesh >
auto tatooine::celltree< Mesh >::write_vtk_collect_positions_and_indices ( std::vector< vec< real_type, num_dimensions()> > &  positions,
std::vector< std::vector< std::size_t > > &  indices,
std::size_t  cur_node_idx,
tatooine::axis_aligned_bounding_box< real_type, num_dimensions()> const &  aabb,
std::size_t  cur_level = 0,
std::size_t  cur_idx = 0 
) -> std::size_t
inlineprivate

Friends And Related Function Documentation

◆ detail::celltree_parent< celltree< Mesh >, typename Mesh::real_type, Mesh::num_dimensions(), Mesh::num_vertices_per_simplex()>

template<typename Mesh >
friend struct detail::celltree_parent< celltree< Mesh >, typename Mesh::real_type, Mesh::num_dimensions(), Mesh::num_vertices_per_simplex()>
friend

Member Data Documentation

◆ m_cell_handles

template<typename Mesh >
std::vector<std::size_t> tatooine::celltree< Mesh >::m_cell_handles
private

◆ m_max

template<typename Mesh >
vec<real_type, num_dimensions()> tatooine::celltree< Mesh >::m_max
private

◆ m_mesh

template<typename Mesh >
Mesh const* tatooine::celltree< Mesh >::m_mesh
private

◆ m_min

template<typename Mesh >
vec<real_type, num_dimensions()> tatooine::celltree< Mesh >::m_min
private

◆ m_nodes

template<typename Mesh >
std::vector<node_type> tatooine::celltree< Mesh >::m_nodes
private

The documentation for this struct was generated from the following file: