Struct coupe::Grid

pub struct Grid<const D: usize> { /* private fields */ }

Representation of a cartesian mesh.

Coupe can partition grids (also called cartesian meshes) faster and consuming less memory than unstructured meshes.

Example

You can feed grids to topologic algorithms, thanks to the Topology trait. You can also partition them directly with, eg., RCB:

// Define a 2-by-2 grid.
let side = std::num::NonZeroUsize::new(2).unwrap();
let grid = Grid::new_2d(side, side);

// All cells have the same weight.
let mut partition = [0; 4];
let weights = [1.0; 4];

// Run 2 iterations of RCB.
grid.rcb(&mut partition, &weights, 2);

// There are 4 parts, their order is unspecified.
partition.sort();
assert_eq!(partition, [0, 1, 2, 3]);

Implementations

impl Grid<2>

pub fn new_2d(width: NonZeroUsize, height: NonZeroUsize) -> Self

Define a new 2D grid.

pub fn rcb<W>(self, partition: &mut [usize], weights: &[W], iter_count: usize)where W: Send + Sync + PartialOrd + Num + Sum + AsPrimitive<f64>, f64: AsPrimitive<W>,

Run RCB on the 2D grid.

Weights and partition indices are row major.

impl Grid<3>

pub fn new_3d( width: NonZeroUsize, height: NonZeroUsize, depth: NonZeroUsize ) -> Self

Define a new 3D grid.

pub fn rcb<W>(self, partition: &mut [usize], weights: &[W], iter_count: usize)where W: Send + Sync + PartialOrd + Num + Sum + AsPrimitive<f64>, f64: AsPrimitive<W>,

Run RCB on the 3D grid.

Weights and partition indices are row-then-column major.

Trait Implementations

impl<const D: usize> Clone for Grid<D>

fn clone(&self) -> Grid<D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const D: usize> Debug for Grid<D>

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

Formats the value using the given formatter.

impl<const D: usize, E> Topology<E> for Grid<D>where E: One,

type Neighbors<'a> = GridNeighbors<D, E> where Self: 'a

Return type for Topology::neighbors.

fn len(&self) -> usize

The number of elements in the mesh.

fn neighbors(&self, vertex: usize) -> Self::Neighbors<'_>

An iterator over the neighbors of the given vertex.

fn is_empty(&self) -> bool

Whether the topology has no elements.

fn lambda_cut<W>(&self, partition: &[usize], weights: W) -> W::Itemwhere Self: Sync, W: IntoParallelIterator, W::Iter: IndexedParallelIterator, W::Item: Sum + Mul<Output = W::Item> + FromPrimitive,

The λ-1 cut (lambda-1 cut) of a partition.

impl<const D: usize> Copy for Grid<D>