Struct CartesianCuboid

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

A generic Domain with a cuboid layout.

This struct can be used to define custom domains on top of its behaviour.

Fields

rng_seed: u64

Seed from which all random numbers will be initially drawn

Implementations

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

where F: Clone,

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

Get the minimum point which defines the simulation domain

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

Get the maximum point which defines the simulation domain

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

Get the discretization used to generate voxels

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

Get the number of voxels in each dimension of the domain

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

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

pub fn from_boundaries_and_interaction_range( min: impl Into<[F; D]>, max: impl Into<[F; D]>, interaction_range: F, ) -> Result<Self, BoundaryError>

Builds a new CartesianCuboid from given boundaries and maximum interaction ranges of the containing cells.

let min = [2.0, 3.0, 1.0];
let max = [10.0, 10.0, 20.0];
let interaction_range = 2.0;
let domain = CartesianCuboid::from_boundaries_and_interaction_range(
    min,
    max,
    interaction_range
)?;

assert_eq!(domain.get_n_voxels()[0], 4);
assert_eq!(domain.get_n_voxels()[1], 3);
assert_eq!(domain.get_n_voxels()[2], 9);

pub fn from_boundaries_and_n_voxels( min: impl Into<[F; D]>, max: impl Into<[F; D]>, n_voxels: impl Into<[usize; D]>, ) -> Result<Self, BoundaryError>

Builds a new CartesianCuboid from given boundaries and the number of voxels per dimension specified.

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

where F: 'static + Float + Copy + Debug + FromPrimitive + ToPrimitive + SubAssign + Div<Output = F> + DivAssign,

pub fn get_voxel_index_of_raw( &self, pos: &SVector<F, D>, ) -> Result<[usize; D], BoundaryError>

Obtains the voxel index given a regular vector

This function can be used in derivatives of this type.

Trait Implementations

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

fn clone(&self) -> CartesianCuboid<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 CartesianCuboid<F, D>

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

Formats the value using the given formatter.

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, const D: usize> DomainRngSeed for CartesianCuboid<F, D>

fn get_rng_seed(&self) -> u64

Obtains the current rng seed

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

where F: 'static + Float + Copy + Debug + FromPrimitive + ToPrimitive + SubAssign + Div<Output = F> + DivAssign, C: Position<SVector<F, D>>,

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.