Struct CartesianSubDomain

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

Subdomain corresponding to the CartesianCuboid struct.

Implementations

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

where F: Clone,

pub fn get_min(&self) -> SVector<F, D>

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) -> SVector<F, D>

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) -> SVector<F, D>

Get the discretization used to generate voxels

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

Get all voxel indices which are currently in this subdomain

pub fn get_domain_min(&self) -> SVector<F, D>

See CartesianCuboid::get_min.

pub fn get_domain_max(&self) -> SVector<F, D>

See CartesianCuboid::get_max.

pub fn get_domain_n_voxels(&self) -> SVector<usize, D>

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,

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

Trait Implementations

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

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: Debug, const D: usize> Debug for CartesianSubDomain<F, D>

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

Formats the value using the given formatter.

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

where F: Scalar + for<'a> Deserialize<'a>,

fn deserialize<De>(deserializer: De) -> Result<Self, De::Error>

where De: 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<SVector<F, D>>, F: 'static + Float + Copy + Debug + FromPrimitive + ToPrimitive + SubAssign + Div<Output = F> + 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: NonZeroUsize, cells: Ci, ) -> Result<DecomposedDomain<Self::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: NonZeroUsize, ) -> Result<impl IntoIterator<Item = (Self::SubDomainIndex, CartesianSubDomain<F, D>, Vec<Self::VoxelIndex>)>, DecomposeError>

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

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

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: Scalar + Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::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<SVector<F, D>>, 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<Self::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<Self::VoxelIndex>

Get all voxel indices of this [SubDomain].

fn get_neighbor_voxel_indices( &self, voxel_index: &Self::VoxelIndex, ) -> Vec<Self::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>