Struct CellAgentBox

pub struct CellAgentBox<Cel> {
    pub cell: Cel,
    /* private fields */
}

A container struct containing meta-information of a given Cell Some variables such as id are not required and not desired to be initialized by the user. This CellAgentBox acts as a container around the cell to hold these variables.

Fields

cell: Cel

The user-defined cell which is stored inside this container.

Implementations

impl<Cel> CellAgentBox<Cel>

pub fn get_parent_id(&self) -> Option<(u64, u64)>

Available on crate feature cpu_os_threads only.

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

impl<Cel> CellAgentBox<Cel>

pub fn new( voxel_index: u64, n_cell: u64, cell: Cel, parent_id: Option<(u64, u64)>, ) -> CellAgentBox<Cel>

Available on crate feature cpu_os_threads only.

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

Trait Implementations

impl<Cel> Clone for CellAgentBox<Cel>

where Cel: Clone,

fn clone(&self) -> CellAgentBox<Cel>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Cel> Debug for CellAgentBox<Cel>

where Cel: Debug,

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

Formats the value using the given formatter.

impl<'de, Cel> Deserialize<'de> for CellAgentBox<Cel>

where Cel: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

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

fn apply_boundary( &self, cbox: &mut CellAgentBox<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: &CellAgentBox<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 CellAgentBox<Cel>

type Identifier = (u64, u64)

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

fn get_id(&self) -> (u64, u64)

Retrieves the Identifier from the object.

fn ref_id(&self) -> &(u64, u64)

Returns a reference to the id of the object.

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

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

fn get_interaction_information(&self) -> Inf

Get additional information of cellular properties (ie. for cell-specific interactions). For now, this can also be used to get the mass of the other cell-agent. In the future, we will probably provide a custom function for this.

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<Pos, Vel, For, Float, A> Mechanics<Pos, Vel, For, Float> for CellAgentBox<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> PartialEq for CellAgentBox<Cel>

where Cel: PartialEq,

fn eq(&self, other: &CellAgentBox<Cel>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Cel> PlotSelf for CellAgentBox<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 CellAgentBox<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<Cel> Serialize for CellAgentBox<Cel>

where Cel: 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 CellAgentBox<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.

impl<Cel> StructuralPartialEq for CellAgentBox<Cel>