Struct ModularCell

pub struct ModularCell<Mec, Int, Cyc, React, IntExtracellular> {
    pub mechanics: Mec,
    pub interaction: Int,
    pub interaction_extracellular: IntExtracellular,
    pub cycle: Cyc,
    pub cellular_reactions: React,
    pub volume: f64,
}

Superseded by the CellAgent derive macro.

The ModularCell is a struct with fields that implement the various concepts. The concepts are afterwards derived automatically for the ModularCell struct.

Fields

mechanics: Mec

Physical mechanics of the cell

interaction: Int

Physical interactions with other cells

interaction_extracellular: IntExtracellular

Interaction with extracellular gradient

cycle: Cyc

Cell cycle

cellular_reactions: React

Intracellular reactions

volume: f64

Volume of the cell

Trait Implementations

impl<ConcVecIntracellular, ConcVecExtracellular, Mec, Int, Cyc, React, IntExtracellular> CellularReactions<ConcVecIntracellular, ConcVecExtracellular> for ModularCell<Mec, Int, Cyc, React, IntExtracellular>

where React: CellularReactions<ConcVecIntracellular, ConcVecExtracellular>,

fn calculate_intra_and_extracellular_reaction_increment( &self, internal_concentration_vector: &ConcVecIntracellular, external_concentration_vector: &ConcVecExtracellular, ) -> Result<(ConcVecIntracellular, ConcVecExtracellular), CalcError>

Calculate the time-related change of the intracellular and extracellular concentrations. This is not the increment itself (thus no parameter dt was specified) but rather the time-derivative. Such an approach can be useful when designing addaptive solvers.

fn get_intracellular(&self) -> ConcVecIntracellular

Retrieves the current intracellular concentration.

fn set_intracellular(&mut self, concentration_vector: ConcVecIntracellular)

Sets the intracellular concentration. This is used by the backend after values have been updated.

impl<Mec, Int, Cyc, React, IntExtracellular> Clone for ModularCell<Mec, Int, Cyc, React, IntExtracellular>

where Mec: Clone, Int: Clone, Cyc: Clone, React: Clone, IntExtracellular: Clone,

fn clone(&self) -> ModularCell<Mec, Int, Cyc, React, IntExtracellular>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Mec, Int, Cyc, Float, React, IntExtracellular> Cycle<ModularCell<Mec, Int, Cyc, React, IntExtracellular>, Float> for ModularCell<Mec, Int, Cyc, React, IntExtracellular>

where Cyc: Cycle<ModularCell<Mec, Int, Cyc, React, IntExtracellular>, Float>,

fn update_cycle( rng: &mut ChaCha8Rng, dt: &Float, cell: &mut ModularCell<Mec, Int, Cyc, React, IntExtracellular>, ) -> Option<CycleEvent>

Continuously updates cellular properties and may spawn a CycleEvent which then calls the corresponding functions (see also CycleEvent).

fn divide( rng: &mut ChaCha8Rng, cell: &mut ModularCell<Mec, Int, Cyc, React, IntExtracellular>, ) -> Result<ModularCell<Mec, Int, Cyc, React, IntExtracellular>, DivisionError>

Performs division of the cell by modifying the existing one and spawning an additional cell. The user is responsible for correctly adjusting cell-specific values such as intracellular concentrations or position of the two resulting cells. Corresponds to CycleEvent::Division.

fn update_conditional_phased_death( rng: &mut ChaCha8Rng, dt: &Float, cell: &mut ModularCell<Mec, Int, Cyc, React, IntExtracellular>, ) -> Result<bool, DeathError>

Method corresponding to the CycleEvent::PhasedDeath event. Update the cell while returning a boolean which indicates if the updating procedure has finished. As soon as the return value is true the cell is removed.

impl<Mec, Int, Cyc, React, IntExtracellular> Debug for ModularCell<Mec, Int, Cyc, React, IntExtracellular>

where Mec: Debug, Int: Debug, Cyc: Debug, React: Debug, IntExtracellular: Debug,

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

Formats the value using the given formatter.

impl<'de, Mec, Int, Cyc, React, IntExtracellular> Deserialize<'de> for ModularCell<Mec, Int, Cyc, React, IntExtracellular>

where Mec: Deserialize<'de>, Int: Deserialize<'de>, Cyc: Deserialize<'de>, React: Deserialize<'de>, IntExtracellular: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<ModularCell<Mec, Int, Cyc, React, IntExtracellular>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Pos, Vel, For, Inf, Mec, Int, Cyc, React, IntExtracellular> Interaction<Pos, Vel, For, Inf> for ModularCell<Mec, Int, Cyc, React, IntExtracellular>

where Int: Interaction<Pos, Vel, For, Inf>,

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<Mec, Int, Cyc, React, IntExtracellular, ConcGradientExtracellular> InteractionExtracellularGradient<ModularCell<Mec, Int, Cyc, React, IntExtracellular>, ConcGradientExtracellular> for ModularCell<Mec, Int, Cyc, React, IntExtracellular>

where IntExtracellular: InteractionExtracellularGradient<ModularCell<Mec, Int, Cyc, React, IntExtracellular>, ConcGradientExtracellular>,

fn sense_gradient( cell: &mut ModularCell<Mec, Int, Cyc, React, IntExtracellular>, extracellular_gradient: &ConcGradientExtracellular, ) -> Result<(), CalcError>

The cell-agent senses the gradient and changes the behaviour of the cell.

impl<Pos, Vel, For, Float, Mec, Int, Cyc, React, IntExtracellular> Mechanics<Pos, Vel, For, Float> for ModularCell<Mec, Int, Cyc, React, IntExtracellular>

where Mec: 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<Pos, Mec, Int, Cyc, React, InteractionExtracellular> Position<Pos> for ModularCell<Mec, Int, Cyc, React, InteractionExtracellular>

where Mec: Position<Pos>,

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

Gets the cells current velocity.

fn pos(&self) -> Pos

Gets the cells current position.

impl<Mec, Int, Cyc, React, IntExtracellular> Serialize for ModularCell<Mec, Int, Cyc, React, IntExtracellular>

where Mec: Serialize, Int: Serialize, Cyc: Serialize, React: Serialize, IntExtracellular: 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<Vel, Mec, Int, Cyc, React, InteractionExtracellular> Velocity<Vel> for ModularCell<Mec, Int, Cyc, React, InteractionExtracellular>

where Mec: Velocity<Vel>,

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

Sets the cells current velocity.

fn velocity(&self) -> Vel

Gets the cells current velocity.

impl<Mec, Int, Cyc, React, IntExtracellular> Volume for ModularCell<Mec, Int, Cyc, React, IntExtracellular>

fn get_volume(&self) -> f64

Obtain the cells current volume.