Struct Rib 

pub struct Rib {
    pub iter_count: usize,
    pub tolerance: f64,
}

Recursive Inertial Bisection algorithm

Partitions a mesh based on the nodes coordinates and coresponding weights.

A variant of the Recursive Coordinate Bisection algorithm where a basis change is performed beforehand so that the first coordinate of the new basis is colinear to the inertia axis of the set of points. This has the goal of producing better shaped partition than RCB.

Example

use coupe::Partition as _;
use coupe::Point2D;

// Here, the inertia axis is the y axis.
// We thus expect Rib to split horizontally first.
let points = [
    Point2D::new(1., 10.),
    Point2D::new(-1., 10.),
    Point2D::new(1., -10.),
    Point2D::new(-1., -10.),
];
let weights = [1; 4];
let mut partition = [0; 4];

// Generate a partition of 2 parts (1 split).
coupe::Rib { iter_count: 1, ..Default::default() }
    .partition(&mut partition, (&points, weights))
    .unwrap();

// The two points at the top are in the same part.
assert_eq!(partition[0], partition[1]);

// The two points at the bottom are in the same part.
assert_eq!(partition[2], partition[3]);

// There are two different parts.
assert_ne!(partition[1], partition[2]);

Reference

Williams, Roy D., 1991. Performance of dynamic load balancing algorithms for unstructured mesh calculations. Concurrency: Practice and Experience, 3(5):457–481. doi:10.1002/cpe.4330030502.

Fields

iter_count: usize

The number of iterations of the algorithm. This will yield a partition of at most 2^num_iter parts.

tolerance: f64

Same meaning as Rcb::tolerance.

Trait Implementations

impl Default for Rib

fn default() -> Rib

Returns the “default value” for a type.

impl<'a, const D: usize, W> Partition<(&'a [Matrix<f64, Const<D>, Const<1>, ArrayStorage<f64, D, 1>>], W)> for Rib

where Const<D>: DimSub<Const<1>> + ToTypenum, DefaultAllocator: Allocator<f64, Const<D>, Const<D>, Buffer = ArrayStorage<f64, D, D>> + Allocator<f64, DimDiff<Const<D>, Const<1>>>, W: IntoParallelIterator, W::Item: RcbWeight, W::Iter: IndexedParallelIterator,

type Metadata = ()

Diagnostic data returned for a specific run of the algorithm.

type Error = Error

Error details, should the algorithm fail to run.

fn partition( &mut self, part_ids: &mut [usize], (points, weights): (&'a [PointND<D>], W), ) -> Result<Self::Metadata, Self::Error>

Partition the given data and output the part ID of each element in part_ids.