Struct CartesianDiffusion2D

pub struct CartesianDiffusion2D<F> {
    pub domain: CartesianCuboid<F, 2>,
    pub reactions_dx: Vector2<F>,
    pub diffusion_constant: F,
    pub initial_value: DVector<F>,
}

Domain based on CartesianCuboid in 2 dimensions with extracellular diffusion.

We solve the equations

Fields

domain: CartesianCuboid<F, 2>

See CartesianCuboid

reactions_dx: Vector2<F>

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: DVector<F>

Initial values which are uniform over the simulation domain

Trait Implementations

impl<F: Clone> Clone for CartesianDiffusion2D<F>

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 Self: DomainRngSeed + DomainCreateSubDomains<__cr_private_SubDomain> + SortCells<__cr_private_Cell, VoxelIndex = <Self as DomainCreateSubDomains<__cr_private_SubDomain>>::VoxelIndex>, __cr_private_SubDomain: SubDomain<VoxelIndex = <Self as DomainCreateSubDomains<__cr_private_SubDomain>>::VoxelIndex>, <Self as DomainCreateSubDomains<__cr_private_SubDomain>>::SubDomainIndex: Clone + Hash + Eq + Ord, <Self 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: NonZeroUsize, cells: __cr_private_CellIterator, ) -> Result<DecomposedDomain<Self::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: NonZeroUsize, ) -> Result<impl IntoIterator<Item = (Self::SubDomainIndex, CartesianDiffusion2DSubDomain<F>, 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> 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<Self::VoxelIndex, BoundaryError>

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