Struct Tree 

pub struct Tree<const N: usize> { /* private fields */ }

An N-dimensional hypertree, which subdives each axis in two in each refinement step.

Used as a basis for axes aligned adaptive finite difference meshes. The tree is

Implementations

impl<const N: usize> Tree<N>

pub fn new(domain: HyperBox<N>) -> Self

Constructs a new tree consisting of a single root cell, covering the given domain.

pub fn set_periodic(&mut self, axis: usize, periodic: bool)

pub fn domain(&self) -> HyperBox<N>

pub fn num_active_cells(&self) -> usize

The number of active (leaf) cells in this tree.

pub fn num_cells(&self) -> usize

The total number of cells in this tree (including )

pub fn num_levels(&self) -> usize

The maximum depth of this tree.

pub fn level_cells( &self, level: usize, ) -> impl Iterator<Item = CellId> + ExactSizeIterator

pub fn cell_indices(&self) -> impl Iterator<Item = CellId>

pub fn active_cell_indices(&self) -> impl Iterator<Item = ActiveCellId>

pub fn bounds(&self, cell: CellId) -> HyperBox<N>

Returns the numerical bounds of a given cell.

pub fn active_bounds(&self, active: ActiveCellId) -> HyperBox<N>

pub fn level(&self, cell: CellId) -> usize

Returns the level of a given cell.

pub fn active_level(&self, cell: ActiveCellId) -> usize

pub fn children(&self, cell: CellId) -> Option<CellId>

Returns the children of a given node. Node must not be leaf.

pub fn child(&self, cell: CellId, child: Split<N>) -> Option<CellId>

Returns a child of a give node.

pub fn parent(&self, cell: CellId) -> Option<CellId>

The parent node of a given node.

pub fn active_zvalue(&self, active: ActiveCellId) -> &BitSlice<usize, Lsb0>

Returns the zvalue of the given active cell.

pub fn active_split(&self, active: ActiveCellId, level: usize) -> Split<N>

pub fn most_recent_active_split(&self, active: ActiveCellId) -> Option<Split<N>>

pub fn check_refine_flags(&self, flags: &[bool]) -> bool

Checks whether the given refinement flags are balanced.

pub fn balance_refine_flags(&self, flags: &mut [bool])

Balances the given refinement flags, flagging additional cells for refinement to preserve the 2:1 fine coarse ratio between every two neighbors.

pub fn refine_active_index_map(&self, flags: &[bool], map: &mut [ActiveCellId])

Fills the map with updated indices after refinement is performed. If a cell is refined, this will point to the base cell in that new subdivision.

pub fn refine(&mut self, flags: &[bool])

pub fn check_coarsen_flags(&self, flags: &[bool]) -> bool

Checks that the given coarsening flags are balanced and valid.

pub fn balance_coarsen_flags(&self, flags: &mut [bool])

Balances the given coarsening flags

pub fn coarsen_active_index_map(&self, flags: &[bool], map: &mut [ActiveCellId])

Maps current cells to indices after coarsening is performed.

pub fn coarsen(&mut self, flags: &[bool])

pub fn build(&mut self)

pub fn cell_from_active_index(&self, active: ActiveCellId) -> CellId

Computes the cell index corresponding to an active cell.

pub fn active_index_from_cell(&self, cell: CellId) -> Option<ActiveCellId>

Computes active cell index from a cell, returning None if cell is not active.

pub fn active_children( &self, cell: CellId, ) -> impl Iterator<Item = ActiveCellId> + ExactSizeIterator

Returns an iterator over active cells that are children of the given cell. If is_active(cell) = true then this iterator will be a singleton returning the same value as tree.active_index_from_cell(cell).

pub fn is_active(&self, node: CellId) -> bool

True if a node has no children.

pub fn cell_from_point(&self, point: [f64; N]) -> CellId

Returns the cell which owns the given point. Performs in O(log N).

pub fn cell_from_point_cached(&self, point: [f64; N], cache: CellId) -> CellId

Returns the node which owns the given point, shortening this search with an initial guess. Rather than operating in O(log N) time, this approaches O(1) if the guess is sufficiently close.

pub fn neighbor(&self, cell: CellId, face: Face<N>) -> Option<CellId>

Returns the neighboring cell along the given face. If the neighboring cell is more refined, this returns the cell index of the adjacent cell with tree.level(neighbor) == tree.level(cell). If this passes over a nonperiodic boundary then it returns None.

pub fn neighbor_region(&self, cell: CellId, region: Region<N>) -> Option<CellId>

Returns the neighboring cell in the given region. If the neighboring cell is more refined, this returns the cell index of the adjacent cell with tree.level(neighbor) == tree.level(cell). If this passes over a nonperiodic boundary then it returns None.

pub fn _neighbor_region2( &self, cell: CellId, region: Region<N>, ) -> Option<CellId>

Returns the neighboring cell in the given region. If the neighboring cell is more refined, this returns the cell index of the adjacent cell with tree.level(neighbor) == tree.level(cell). If this passes over a nonperiodic boundary then it returns None.

pub fn active_neighbors_in_region( &self, cell: CellId, region: Region<N>, ) -> impl Iterator<Item = ActiveCellId> + '_

Iterates over

pub fn active_neighborhood( &self, cell: ActiveCellId, ) -> impl Iterator<Item = ActiveCellId> + '_

pub fn active_coarse_neighborhood( &self, cell: ActiveCellId, ) -> impl Iterator<Item = ActiveCellId> + '_

pub fn is_boundary_face(&self, cell: CellId, face: Face<N>) -> bool

Returns true if a face lies on a boundary.

pub fn boundary_region(&self, cell: CellId, region: Region<N>) -> Region<N>

Given a neighboring region to a cell, determines which global region that belongs to (usually)

Trait Implementations

impl<const N: usize> Clone for Tree<N>

fn clone(&self) -> Tree<N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize> DataSize for Tree<N>

const IS_DYNAMIC: bool = true

If true, the type has a heap size that can vary at runtime, depending on the actual value.

const STATIC_HEAP_SIZE: usize = 0

The amount of space a value of the type always occupies. If IS_DYNAMIC is false, this is the total amount of heap memory occupied by the value. Otherwise this is a lower bound.

fn estimate_heap_size(&self) -> usize

Estimates the size of heap memory taken up by this value.

impl<const N: usize> Debug for Tree<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, const N: usize> Deserialize<'de> for Tree<N>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: usize> From<Tree<N>> for TreeSer<N>

fn from(value: Tree<N>) -> Self

Converts to this type from the input type.

impl<const N: usize> From<TreeSer<N>> for Tree<N>

fn from(value: TreeSer<N>) -> Self

Converts to this type from the input type.

impl<const N: usize> PartialEq for Tree<N>

fn eq(&self, other: &Tree<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> Serialize for Tree<N>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: usize> StructuralPartialEq for Tree<N>