Struct CartesianSubDomain

pub struct CartesianSubDomain<F, const D: usize> { /* private fields */ }

Available on crate feature elli only.

Subdomain corresponding to the CartesianCuboid struct.

Implementations

impl<F, const D: usize> CartesianSubDomain<F, D>

where F: Clone,

pub fn get_min(&self) -> Matrix<F, Const<D>, Const<1>, ArrayStorage<F, D, 1>>

Available on crate feature cpu_os_threads only.

Get the minimum boundary of the subdomain. Note that not all voxels which could be in the space of the subdomain need to be in it.

pub fn get_max(&self) -> Matrix<F, Const<D>, Const<1>, ArrayStorage<F, D, 1>>

Available on crate feature cpu_os_threads only.

Get the maximum boundary of the subdomain. Note that not all voxels which could be in the space of the subdomain need to be in it.

pub fn get_dx(&self) -> Matrix<F, Const<D>, Const<1>, ArrayStorage<F, D, 1>>

Available on crate feature cpu_os_threads only.

Get the discretization used to generate voxels

pub fn get_voxels(&self) -> Vec<[usize; D]>

Available on crate feature cpu_os_threads only.

Get all voxel indices which are currently in this subdomain

pub fn get_domain_min( &self, ) -> Matrix<F, Const<D>, Const<1>, ArrayStorage<F, D, 1>>

Available on crate feature cpu_os_threads only.

See CartesianCuboid::get_min.

pub fn get_domain_max( &self, ) -> Matrix<F, Const<D>, Const<1>, ArrayStorage<F, D, 1>>

Available on crate feature cpu_os_threads only.

See CartesianCuboid::get_max.

pub fn get_domain_n_voxels( &self, ) -> Matrix<usize, Const<D>, Const<1>, ArrayStorage<usize, D, 1>>

Available on crate feature cpu_os_threads only.

See CartesianCuboid::get_n_voxels.

impl<F, const D: usize> CartesianSubDomain<F, D>

pub fn get_index_of<P>(&self, pos: P) -> Result<[usize; D], BoundaryError>

where [F; D]: From<P>, F: 'static + Float + Debug + SubAssign + DivAssign,

Available on crate feature cpu_os_threads only.

Generic method to obtain the voxel index of any type that can be casted to an array.

Trait Implementations

impl<F, const D: usize> Clone for CartesianSubDomain<F, D>

where F: Clone,

fn clone(&self) -> CartesianSubDomain<F, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F, const D: usize> Debug for CartesianSubDomain<F, D>

where F: Debug,

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

Formats the value using the given formatter.

impl<'de, F, const D: usize> Deserialize<'de> for CartesianSubDomain<F, D>

where F: 'static + PartialEq + Clone + Debug + Serialize + for<'a> Deserialize<'a>, [usize; D]: Serialize + for<'a> Deserialize<'a>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<CartesianSubDomain<F, D>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C, Ci, F, const D: usize> Domain<C, CartesianSubDomain<F, D>, Ci> for CartesianCuboid<F, D>

where C: Position<Matrix<F, Const<D>, Const<1>, ArrayStorage<F, D, 1>>>, F: 'static + Float<Output = F> + Copy + Debug + FromPrimitive + ToPrimitive + SubAssign + Div + DivAssign, Ci: IntoIterator<Item = C>,

type SubDomainIndex = usize

Subdomains can be identified by their unique SubDomainIndex. The backend uses this property to construct a mapping (graph) between subdomains.

type VoxelIndex = [usize; D]

Similarly to the SubDomainIndex, voxels can be accessed by their unique index. The backend will use this information to construct a mapping (graph) between voxels inside their respective subdomains.

fn decompose( self, n_subdomains: NonZero<usize>, cells: Ci, ) -> Result<DecomposedDomain<<CartesianCuboid<F, D> as Domain<C, CartesianSubDomain<F, D>, Ci>>::SubDomainIndex, CartesianSubDomain<F, D>, C>, DecomposeError>

Deconstructs the Domain into its respective subdomains.

impl<F, const D: usize> DomainCreateSubDomains<CartesianSubDomain<F, D>> for CartesianCuboid<F, D>

where F: 'static + Float + Debug + FromPrimitive,

type SubDomainIndex = usize

This should always be identical to Domain::SubDomainIndex.

type VoxelIndex = [usize; D]

This should always be identical to Domain::VoxelIndex.

fn create_subdomains( &self, n_subdomains: NonZero<usize>, ) -> Result<impl IntoIterator<Item = (<CartesianCuboid<F, D> as DomainCreateSubDomains<CartesianSubDomain<F, D>>>::SubDomainIndex, CartesianSubDomain<F, D>, Vec<<CartesianCuboid<F, D> as DomainCreateSubDomains<CartesianSubDomain<F, D>>>::VoxelIndex>)>, DecomposeError>

Generates at most n_subdomains. This function can also return a lower amount of subdomains but never less than 1.

impl<F, const D: usize> PartialEq for CartesianSubDomain<F, D>

where F: PartialEq,

fn eq(&self, other: &CartesianSubDomain<F, D>) -> 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<F, const D: usize> Serialize for CartesianSubDomain<F, D>

where F: 'static + PartialEq + Clone + Debug + Serialize + for<'a> Deserialize<'a>, [usize; D]: Serialize + for<'a> Deserialize<'a>,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<C, F, const D: usize> SortCells<C> for CartesianSubDomain<F, D>

where C: Position<Matrix<F, Const<D>, Const<1>, ArrayStorage<F, D, 1>>>, F: 'static + Float + Debug + SubAssign + DivAssign,

type VoxelIndex = [usize; D]

An index which determines to which next smaller unit the cell should be assigned.

fn get_voxel_index_of( &self, cell: &C, ) -> Result<<CartesianSubDomain<F, D> as SortCells<C>>::VoxelIndex, BoundaryError>

If given a cell, we can sort this cell into the corresponding sub unit.

impl<F, const D: usize> SubDomain for CartesianSubDomain<F, D>

type VoxelIndex = [usize; D]

Individual Voxels inside each subdomain can be accessed by this index.

fn get_all_indices( &self, ) -> Vec<<CartesianSubDomain<F, D> as SubDomain>::VoxelIndex>

Get all voxel indices of this SubDomain.

fn get_neighbor_voxel_indices( &self, voxel_index: &<CartesianSubDomain<F, D> as SubDomain>::VoxelIndex, ) -> Vec<<CartesianSubDomain<F, D> as SubDomain>::VoxelIndex>

Obtains the neighbor voxels of the specified voxel index. This function behaves similarly to SortCells::get_voxel_index_of in that it also has to return indices which are in other SubDomains.

impl<Coord, F, const D: usize> SubDomainMechanics<Coord, Coord> for CartesianSubDomain<F, D>

where Coord: Clone + From<[F; D]> + Debug, [F; D]: From<Coord>, F: Float,

fn apply_boundary( &self, pos: &mut Coord, vel: &mut Coord, ) -> Result<(), BoundaryError>

If the subdomain has boundary conditions, this function will enforce them onto the cells. For the future, we plan to replace this function to additionally obtain information about the previous and current location of the cell.

impl<F, const D: usize> StructuralPartialEq for CartesianSubDomain<F, D>