Struct CartesianSubDomainRods

pub struct CartesianSubDomainRods<F, const D: usize> {
    pub subdomain: CartesianSubDomain<F, D>,
    pub gel_pressure: F,
    pub surface_friction: F,
    pub surface_friction_distance: F,
}

Available on crate feature elli only.

The corresponding SubDomain of the CartesianCuboidRods domain.

Fields

subdomain: CartesianSubDomain<F, D>

Base subdomain as created by the CartesianCuboid domain.

gel_pressure: F

See CartesianCuboidRods

surface_friction: F

Computes friction at all surfaces of the box

surface_friction_distance: F

The distance for which the friction will be applied

Trait Implementations

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

where F: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de, F, const D: usize> Deserialize<'de> for CartesianSubDomainRods<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<CartesianSubDomainRods<F, D>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F, const D: usize> DomainCreateSubDomains<CartesianSubDomainRods<F, D>> for CartesianCuboidRods<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 = (<CartesianCuboidRods<F, D> as DomainCreateSubDomains<CartesianSubDomainRods<F, D>>>::SubDomainIndex, CartesianSubDomainRods<F, D>, Vec<<CartesianCuboidRods<F, D> as DomainCreateSubDomains<CartesianSubDomainRods<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> Serialize for CartesianSubDomainRods<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 CartesianSubDomainRods<F, D>

where C: Position<Matrix<F, Dyn, Const<D>, VecStorage<F, Dyn, Const<D>>>>, F: 'static + Field + Clone + Debug + FromPrimitive + ToPrimitive + Float + Copy,

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<<CartesianSubDomainRods<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 CartesianSubDomainRods<F, D>

type VoxelIndex = <CartesianSubDomain<F, D> as SubDomain>::VoxelIndex

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

fn get_neighbor_voxel_indices( &self, voxel_index: &<CartesianSubDomainRods<F, D> as SubDomain>::VoxelIndex, ) -> Vec<<CartesianSubDomainRods<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.

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

Get all voxel indices of this SubDomain.

impl<F> SubDomainForce<Matrix<F, Dyn, Const<3>, VecStorage<F, Dyn, Const<3>>>, Matrix<F, Dyn, Const<3>, VecStorage<F, Dyn, Const<3>>>, Matrix<F, Dyn, Const<3>, VecStorage<F, Dyn, Const<3>>>, F> for CartesianSubDomainRods<F, 3>

where F: RealField + Float,

fn calculate_custom_force( &self, pos: &Matrix<F, Dyn, Const<3>, VecStorage<F, Dyn, Const<3>>>, vel: &Matrix<F, Dyn, Const<3>, VecStorage<F, Dyn, Const<3>>>, radius: &F, ) -> Result<Matrix<F, Dyn, Const<3>, VecStorage<F, Dyn, Const<3>>>, CalcError>

Calculates the force which acts on the cell agent

impl<F, const D: usize> SubDomainMechanics<Matrix<F, Dyn, Const<D>, VecStorage<F, Dyn, Const<D>>>, Matrix<F, Dyn, Const<D>, VecStorage<F, Dyn, Const<D>>>> for CartesianSubDomainRods<F, D>

where F: RealField + Float,

fn apply_boundary( &self, pos: &mut Matrix<F, Dyn, Const<D>, VecStorage<F, Dyn, Const<D>>>, vel: &mut Matrix<F, Dyn, Const<D>, VecStorage<F, Dyn, Const<D>>>, ) -> 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.