Struct Mesh 

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

A discretization of a rectangular axis aligned grid into a collection of uniform grids of nodes with different spacings. A Mesh is built on top of a Quadtree, allowing one to selectively refine areas of interest without wasting computational power on smoother regions of the domain.

This abstraction also handles multithread dispatch and sharing nodes between threads in a an effecient manner. This allows the user to write generic, sequential, and straighforward code on the main thread, while still maximising performance and fully utilizing computational resources.

Implementations

impl<const N: usize> Mesh<N>

pub fn evaluate<P: Function<N> + Sync>( &mut self, order: usize, function: P, source: ImageRef<'_>, dest: ImageMut<'_>, ) -> Result<(), P::Error>

where P::Error: Send,

Applies the projection to source, and stores the result in dest.

pub fn is_block_in_interior(&self, block: BlockId) -> bool

Checks if the all neighbors of the block have strongly enforced boundary conditions (and thus can use centered stencils).

pub fn apply<C: SystemBoundaryConds<N> + Sync, P: Function<N> + Sync>( &mut self, order: usize, bcs: C, op: P, f: ImageMut<'_>, ) -> Result<(), P::Error>

where P::Error: Send,

Applies an operator to a system in place, enforcing both strong and weak boundary conditions and running necessary preprocessing.

pub fn copy_from_slice(&mut self, dest: ImageMut<'_>, src: ImageRef<'_>)

Copies an immutable src slice into a mutable dest slice.

pub fn project<P: Projection<N> + Sync>( &mut self, order: usize, projection: P, dest: &mut [f64], )

Applies a projection and stores the result in the destination vector.

pub fn dissipation<const ORDER: usize>( &mut self, amplitude: f64, dest: ImageMut<'_>, )

Applies the projection to source, and stores the result in dest.

pub fn spacing_per_vertex(&mut self, dest: &mut [f64])

This function computes the distance between each vertex and its nearest neighbor.

pub fn adaptive_cfl(&mut self, spacing_per_vertex: &[f64], dest: ImageMut<'_>)

impl<const N: usize> Mesh<N>

pub fn refine_flags(&self) -> &[bool]

Retrieves a vector representing all regridding flags for the mesh.

pub fn coarsen_flags(&self) -> &[bool]

Retrievs a vector representing all coarsening flags for the mesh.

pub fn regrid(&mut self)

Refines the mesh using currently set flags.

pub fn refine_global(&mut self)

Flags every cell for refinement, then performs the operation.

pub fn refine_innermost(&mut self)

Refines innermost cell

pub fn coarsen_innermost(&mut self)

Coarsens innermost cell

pub fn regrid_in_radius(&mut self, radius: f64, fgl: usize)

Refines or coarsens cells one level (towards target level fgl) within a given radius

pub fn flag_wavelets( &mut self, order: usize, lower: f64, upper: f64, data: ImageRef<'_>, )

Flags cells for refinement using a wavelet criterion. The system must have filled boundaries. This function tags any cell that is insufficiently refined to approximate operators of the given order within the range of error.

pub fn flags_debug(&mut self, debug: &mut [i64])

Store flags for each cell in a debug buffer.

pub fn set_refine_flag(&mut self, cell: usize)

Manually marks a cell for refinement.

pub fn set_coarsen_flag(&mut self, cell: usize)

Manually marks a cell for coarsening.

pub fn buffer_refine_flags(&mut self, count: usize)

pub fn limit_level_range_flags(&mut self, min_level: usize, max_level: usize)

Limits coarsening to cells with a level > min_level, and refinement to cells with a level < max_level.

pub fn balance_flags(&mut self)

After cells have been tagged, the refinement/coarsening flags must be balanced to ensure that the 2:1 balance across faces and vertices is still maintained.

pub fn requires_regridding(&self) -> bool

Returns true if the mesh requires regridding (i.e. any cells are tagged for either refinement or coarsening).

pub fn num_refine_cells(&self) -> usize

The number of cell that are marked for refinement.

pub fn num_coarsen_cells(&self) -> usize

The number of cells that are marked for coarsening.

impl<const N: usize> Mesh<N>

pub fn transfer_system( &mut self, order: usize, source: ImageRef<'_>, dest: ImageMut<'_>, )

Transfers data from an older version of the mesh to the new refined version, using the given order of interpolation.

pub fn fill_boundary<BCs: SystemBoundaryConds<N> + Sync>( &mut self, order: usize, bcs: BCs, system: ImageMut<'_>, )

Enforces strong boundary conditions. This includes strong physical boundary conditions, as well as handling interior boundaries (same level, coarse-fine, or fine-coarse).

pub fn fill_boundary_to_extent<C: SystemBoundaryConds<N> + Sync>( &mut self, order: usize, extent: usize, bcs: C, system: ImageMut<'_>, )

Enforces strong boundary conditions, only filling ghost nodes if those nodes are within extent of a physical node. This is useful if one is using Kriss-Olgier dissipation, where dissipation and derivatives use different order stencils.

pub fn block_debug(&mut self, debug: &mut [i64])

Stores the index of the block which owns each individual node in a debug vector.

pub fn cell_debug(&mut self, debug: &mut [i64])

Stores the index of the cell which owns each individual node in a debug vector.

pub fn interface_neighbor_debug(&mut self, extent: usize, debug: &mut [i64])

Stores the index of the neighbor along each interface.

pub fn interface_index_debug(&mut self, extent: usize, debug: &mut [i64])

Stores the index of each interface for nodes along that interface.

impl<const N: usize> Mesh<N>

pub fn new( bounds: HyperBox<N>, width: usize, ghost: usize, boundary: FaceArray<N, BoundaryClass>, ) -> Self

Constructs a new Mesh covering the domain, with a number of nodes defined by width and ghost.

pub fn width(&self) -> usize

Retrieves width of individual cells in this mesh.

pub fn ghost(&self) -> usize

Retrieves the number of ghost nodes on each cell of a mesh.

pub fn tree(&self) -> &Tree<N>

Retrieves the Quadtree this mesh is built on top of.

pub fn num_blocks(&self) -> usize

Returns the total number of blocks on the mesh.

pub fn num_active_cells(&self) -> usize

Returns the total number of cells on the mesh.

pub fn num_nodes(&self) -> usize

Returns the total number of nodes on the mesh.

pub fn num_dofs(&self) -> usize

pub fn boundary_classes(&self) -> FaceArray<N, BoundaryClass>

Returns the boundary classes associated with each boundary of the physical domain.

pub fn blocks(&self) -> &TreeBlocks<N>

Returns underlying TreeBlocks<N> object.

pub fn block_nodes(&self, block: BlockId) -> Range<usize>

The range of nodes assigned to a given block.

pub fn block_space(&self, block: BlockId) -> NodeSpace<N>

Computes the nodespace corresponding to a block.

pub fn block_bounds(&self, block: BlockId) -> HyperBox<N>

Computes the bounds of a block.

pub fn block_physical_boundary_flags(&self, block: BlockId) -> FaceMask<N>

Computes flags indicating whether a particular face of a block borders a physical boundary.

pub fn block_boundary_classes( &self, block: BlockId, ) -> FaceArray<N, BoundaryClass>

Indicates what class of boundary condition is enforced along each face of the block.

pub fn block_bcs<B: SystemBoundaryConds<N>>( &self, block: BlockId, bcs: B, ) -> BlockBoundaryConds<N, B>

Produces a block boundary which correctly accounts for interior interfaces.

pub fn block_level(&self, block: BlockId) -> usize

The level of a given block.

pub fn window_bounds( &self, block: BlockId, window: NodeWindow<N>, ) -> HyperBox<N>

Finds bounds associated with a node window.

pub fn active_window(&self, cell: ActiveCellId) -> NodeWindow<N>

Retrieves the node window associated with a certain active cell on its block.

pub fn interpolate_window( &self, cell: ActiveCellId, position: [f64; N], ) -> NodeWindow<N>

Retrieves the node window that is optimal for interpolating values to the given position, lying within the given active cell.

pub fn element_window(&self, cell: ActiveCellId) -> NodeWindow<N>

Element associated with a given cell.

pub fn element_coarse_window(&self, cell: ActiveCellId) -> NodeWindow<N>

Returns the window of nodes in a block corresponding to a given cell, including no padding.

pub fn request_element(&mut self, width: usize, order: usize) -> Element<N>

Retrieves an element from the mesh’s element cache.

pub fn replace_element(&mut self, element: Element<N>)

Reinserts an element into the mesh’s element cache.

pub fn cell_node_size(&self, cell: ActiveCellId) -> [usize; N]

Retrieves the number of nodes along each axis of a cell. This defaults to [self.width; N] but is increased by one if the cell lies along a block boundary for a given axis.

pub fn active_node_origin(&self, cell: ActiveCellId) -> [usize; N]

Returns the origin of an active cell in its block’s NodeSpace<N>.

pub fn cell_needs_coarse_element(&self, cell: ActiveCellId) -> bool

Returns true if the given cell is on a boundary that does not contain ghost nodes. If this is the case we must fall back to a lower order element error approximation.

pub fn num_levels(&self) -> usize

Returns number of levels on the mesh.

pub fn min_spacing(&self) -> f64

Returns the minimum spatial distance between any two nodes on the mesh. Commonly used in conjunction with a CFL factor to determine time step.

pub fn block_spacing(&self, block: BlockId) -> f64

Computes the spacing on a particular block (albeit not accounting for coarse-fine interfaces).

pub fn block_compute<F: Fn(&Self, &MeshStore, BlockId) + Sync>(&mut self, f: F)

Runs a computation in parallel on every single block in the mesh, providing a MeshStore object for allocating scratch data.

pub fn try_block_compute<E: Send, F: Fn(&Self, &MeshStore, BlockId) -> Result<(), E> + Sync>( &mut self, f: F, ) -> Result<(), E>

Runs a (possibily failable) computation in parallel on every single block in the mesh.

pub fn l2_norm_system(&mut self, source: ImageRef<'_>) -> f64

Computes the maximum l2 norm of all fields in the system.

pub fn max_norm_system(&mut self, source: ImageRef<'_>) -> f64

Computes the maximum l-infinity norm of all fields in the system.

pub fn bottom_left_value(&self, src: &[f64]) -> f64

Returns the value of a function at the bottom left corner of the mesh.

pub fn l2_norm(&mut self, src: &[f64]) -> f64

Computes the l2 norm of a field on the mesh.

pub fn oscillation_heuristic(&mut self, src: &[f64]) -> f64

pub fn oscillation_heuristic_system(&mut self, source: ImageRef<'_>) -> f64

pub fn max_norm(&mut self, src: &[f64]) -> f64

Computes the l-infinity norm of a field on a mesh.

pub fn write_debug(&self, result: impl Write)

Writes a textual summary of the Mesh to a sink. This is pimrarily used to debug features of the mesh that can’t be easily represented graphically (i.e in .vtu files).

Trait Implementations

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

const IS_DYNAMIC: bool = false

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 Mesh<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for Mesh<N>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, const N: usize> Deserialize<'de> for Mesh<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> Serialize for Mesh<N>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.