Struct CellBox 

pub struct CellBox<C> {
    pub identifier: CellIdentifier,
    pub parent: Option<CellIdentifier>,
    pub cell: C,
}

Available on crate feature chili only.

Wrapper around the user-defined CellAgent

This wrapper serves to provide a unique identifier and the option to specify the parent of the current cell.

Fields

identifier: CellIdentifier

The identifier is composed of two values, one for the voxel index in which the object was created and another one which counts how many elements have already been created there.

parent: Option<CellIdentifier>

Identifier of the parent cell if this cell was created by cell-division

cell: C

The cell which is encapsulated by this box.

Implementations

impl<Cel> CellBox<Cel>

pub fn get_parent_id(&self) -> Option<CellIdentifier>

Simple method to retrieve the [CellularIdentifier] of the parent cell if existing.

impl<C> CellBox<C>

pub fn new_initial(n_cell: usize, cell: C) -> CellBox<C>

Create a new CellBox for a cell present initially in the simulation.

pub fn new( voxel_index: VoxelPlainIndex, n_cell: u64, cell: C, parent: Option<CellIdentifier>, ) -> CellBox<C>

Create a new CellBox at a specific voxel with a voxel-unique number of cells that has already been created at this position.

Trait Implementations

impl<C> Clone for CellBox<C>

where C: Clone,

fn clone(&self) -> CellBox<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C> Deref for CellBox<C>

type Target = C

The resulting type after dereferencing.

fn deref(&self) -> &<CellBox<C> as Deref>::Target

Dereferences the value.

impl<C> DerefMut for CellBox<C>

fn deref_mut(&mut self) -> &mut <CellBox<C> as Deref>::Target

Mutably dereferences the value.

impl<'de, C> Deserialize<'de> for CellBox<C>

where C: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<CellBox<C>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Cel, Ind, Vox, Dom> Domain<CellBox<Cel>, Ind, Vox> for DomainBox<Dom>

where Dom: Domain<Cel, Ind, Vox>, Vox: Send + Sync, Cel: Send + Sync,

Available on crate feature cpu_os_threads only.

fn apply_boundary(&self, cbox: &mut CellBox<Cel>) -> Result<(), BoundaryError>

Applies boundary conditions to a cell in order to keep it inside the simulation. For the future, we aim to apply boundary conditions to the position of the cell rather than itself. In addition, we would like to be able to invoke events such as Remove to maximize flexibility.

fn get_neighbor_voxel_indices(&self, index: &Ind) -> Vec<Ind>

Retrieves the neighboring voxels of the one specified.

fn get_voxel_index(&self, cbox: &CellBox<Cel>) -> Ind

Provided a cell, gives the corresponding Index and thus which voxel to sort into.

fn get_all_indices(&self) -> Vec<Ind>

Get all indices that are present in the simulation. Required for initial configuration of the simulation domain.

fn generate_contiguous_multi_voxel_regions( &self, n_regions: usize, ) -> Result<Vec<Vec<(Ind, Vox)>>, CalcError>

Allows the backend to split the domain into continuous regions which contain voxels. These regions can then be used for parallelization.

impl<Cel> Id for CellBox<Cel>

type Identifier = CellIdentifier

The identifier type is usually chosen to be completely unique and repeatable across different simulations.

fn get_id(&self) -> CellIdentifier

Retrieves the Identifier from the object.

fn ref_id(&self) -> &CellIdentifier

Returns a reference to the id of the object.

impl<Pos, Vel, For, Inf, A> Interaction<Pos, Vel, For, Inf> for CellBox<A>

where A: Interaction<Pos, Vel, For, Inf> + Serialize + for<'a> Deserialize<'a>,

fn calculate_force_between( &self, own_pos: &Pos, own_vel: &Vel, ext_pos: &Pos, ext_vel: &Vel, ext_information: &Inf, ) -> Result<(For, For), CalcError>

Calculates the forces (velocity-derivative) on the corresponding external position given external velocity. By providing velocities, we can calculate terms that are related to friction. The function returns two forces, one acting on the current agent and the other on the external agent.

fn is_neighbor( &self, own_pos: &Pos, ext_pos: &Pos, ext_inf: &Inf, ) -> Result<bool, CalcError>

Checks if the other cell represented by position and information is a neighbor to the current one or not.

fn react_to_neighbors(&mut self, neighbors: usize) -> Result<(), CalcError>

Reacts to the results gathered by the Interaction::is_neighbor method and changes the state of the cell.

impl<Inf, A> InteractionInformation<Inf> for CellBox<A>

where A: InteractionInformation<Inf>,

fn get_interaction_information(&self) -> Inf

Get additional information of cellular properties (ie. for cell-specific interactions).

impl<Pos, Vel, For, Float, A> Mechanics<Pos, Vel, For, Float> for CellBox<A>

where A: Mechanics<Pos, Vel, For, Float>,

fn get_random_contribution( &self, rng: &mut ChaCha8Rng, dt: Float, ) -> Result<(Pos, Vel), RngError>

Define a new random variable in case that the mechanics type contains a random aspect to its motion. By default this function does nothing.

fn calculate_increment(&self, force: For) -> Result<(Pos, Vel), CalcError>

Calculate the time-derivative of force and velocity given all the forces that act on the cell. Simple damping effects should be included in this trait if not explicitly given by the SubDomainForce trait.

impl<Cel> PlotSelf for CellBox<Cel>

where Cel: PlotSelf + Serialize + for<'a> Deserialize<'a>,

fn plot_self<Db>( &self, root: &mut DrawingArea<Db, Cartesian2d<RangedCoordf64, RangedCoordf64>>, ) -> Result<(), DrawingError>

where Db: DrawingBackend,

Define which elements to draw when plotting the element itself.

fn plot_self_bitmap( &self, root: &mut DrawingArea<BitMapBackend<'_>, Cartesian2d<RangedCoordf64, RangedCoordf64>>, ) -> Result<(), DrawingError>

Overload for backend to have a purely bitmap function. User are not expected to change this function.

fn plot_self_svg( &self, root: &mut DrawingArea<SVGBackend<'_>, Cartesian2d<RangedCoordf64, RangedCoordf64>>, ) -> Result<(), DrawingError>

Overload for backend to have a purely bitmap function. User are not expected to change this function.

impl<A, Pos> Position<Pos> for CellBox<A>

where A: Position<Pos>,

fn pos(&self) -> Pos

Gets the cells current position.

fn set_pos(&mut self, pos: &Pos)

Gets the cells current velocity.

impl<C> Serialize for CellBox<C>

where C: Serialize,

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<A, Vel> Velocity<Vel> for CellBox<A>

where A: Velocity<Vel>,

fn velocity(&self) -> Vel

Gets the cells current velocity.

fn set_velocity(&mut self, velocity: &Vel)

Sets the cells current velocity.