Struct CartesianDiffusion2D

pub struct CartesianDiffusion2D<F> {
    pub domain: CartesianCuboid<F, 2>,
    pub reactions_dx: Matrix<F, Const<2>, Const<1>, ArrayStorage<F, 2, 1>>,
    pub diffusion_constant: F,
    pub initial_value: Matrix<F, Dyn, Const<1>, VecStorage<F, Dyn, Const<1>>>,
}

Domain based on CartesianCuboid in 2 dimensions with extracellular diffusion.

We solve the equations

Fields

domain: CartesianCuboid<F, 2>

See CartesianCuboid

reactions_dx: Matrix<F, Const<2>, Const<1>, ArrayStorage<F, 2, 1>>

The discretization must be a multiple of the voxel size. This quantity will be used as an initial estimate and rounded to the nearest candidate.

diffusion_constant: F

Diffusion constant

initial_value: Matrix<F, Dyn, Const<1>, VecStorage<F, Dyn, Const<1>>>

Initial values which are uniform over the simulation domain

Trait Implementations

impl<F> Clone for CartesianDiffusion2D<F>

where F: Clone,

fn clone(&self) -> CartesianDiffusion2D<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F, __cr_private_Cell, __cr_private_SubDomain, __cr_private_CellIterator> Domain<__cr_private_Cell, __cr_private_SubDomain, __cr_private_CellIterator> for CartesianDiffusion2D<F>

where CartesianDiffusion2D<F>: DomainRngSeed + DomainCreateSubDomains<__cr_private_SubDomain> + SortCells<__cr_private_Cell, VoxelIndex = <CartesianDiffusion2D<F> as DomainCreateSubDomains<__cr_private_SubDomain>>::VoxelIndex>, __cr_private_SubDomain: SubDomain<VoxelIndex = <CartesianDiffusion2D<F> as DomainCreateSubDomains<__cr_private_SubDomain>>::VoxelIndex>, <CartesianDiffusion2D<F> as DomainCreateSubDomains<__cr_private_SubDomain>>::SubDomainIndex: Clone + Hash + Eq + Ord, <CartesianDiffusion2D<F> as DomainCreateSubDomains<__cr_private_SubDomain>>::VoxelIndex: Clone + Hash + Eq + Ord, __cr_private_CellIterator: IntoIterator<Item = __cr_private_Cell>,

type SubDomainIndex = <CartesianDiffusion2D<F> as DomainCreateSubDomains<__cr_private_SubDomain>>::SubDomainIndex

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

type VoxelIndex = <CartesianDiffusion2D<F> as DomainCreateSubDomains<__cr_private_SubDomain>>::VoxelIndex

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: __cr_private_CellIterator, ) -> Result<DecomposedDomain<<CartesianDiffusion2D<F> as Domain<__cr_private_Cell, __cr_private_SubDomain, __cr_private_CellIterator>>::SubDomainIndex, __cr_private_SubDomain, __cr_private_Cell>, DecomposeError>

Deconstructs the Domain into its respective subdomains.

impl<F> DomainCreateSubDomains<CartesianDiffusion2DSubDomain<F>> for CartesianDiffusion2D<F>

where F: RealField + Copy + AsPrimitive<usize> + 'static + Float + Debug + FromPrimitive, usize: AsPrimitive<F>,

type SubDomainIndex = usize

This should always be identical to Domain::SubDomainIndex.

type VoxelIndex = [usize; 2]

This should always be identical to Domain::VoxelIndex.

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

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

impl<F> DomainRngSeed for CartesianDiffusion2D<F>

fn get_rng_seed(&self) -> u64

Obtains the current rng seed

impl<F, __cr_private_Cell> SortCells<__cr_private_Cell> for CartesianDiffusion2D<F>

where CartesianCuboid<F, 2>: SortCells<__cr_private_Cell>,

type VoxelIndex = <CartesianCuboid<F, 2> as SortCells<__cr_private_Cell>>::VoxelIndex

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

fn get_voxel_index_of( &self, cell: &__cr_private_Cell, ) -> Result<<CartesianDiffusion2D<F> as SortCells<__cr_private_Cell>>::VoxelIndex, BoundaryError>

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