Trait Cycle
pub trait Cycle<Cell = Self, Float = f64> {
// Required methods
fn update_cycle(
rng: &mut ChaCha8Rng,
dt: &Float,
cell: &mut Cell,
) -> Option<CycleEvent>;
fn divide(
rng: &mut ChaCha8Rng,
cell: &mut Cell,
) -> Result<Cell, DivisionError>;
// Provided method
fn update_conditional_phased_death(
rng: &mut ChaCha8Rng,
dt: &Float,
cell: &mut Cell,
) -> Result<bool, DeathError> { ... }
}Expand description
This trait represents all cycles of a cell and works in tandem with the CycleEvent enum.
The update_cycle function is designed to be called frequently and return only something if a
specific cycle event is supposed to be occuring. Backends should implement
the functionality to call the corresponding functions as needed.
§Stochasticity
In order to make sure that results are reproducible, the provided rng parameter should be used.
Should a user fall back to the option to use the threaded rng, this simulation cannot guarantee
deterministic results anymore.
We plan to include the stochastic aspect into individual Event variants such
that the correct handling of integrating the underlying stochastic process can be
carried out by the backend.
§Example implementation
This could be an example of a very simplified cell-agent. The user is free to do anything with this function that is desired but is also responsible for keeping track of all the variables. This means for example that intracellular values might need to be adjusted (most often halfed) and new positions need to be assigned to the cells such that the cells are not overlapping …
use rand::Rng;
use rand_chacha::ChaCha8Rng;
use cellular_raza_concepts::{Cycle, CycleEvent, DivisionError};
// We define our cell struct with all parameters needed for this cell-agent.
#[derive(Clone)]
struct Cell {
// Size of the cell (spherical)
radius: f64,
// Track the age of the cell
current_age: f64,
// Used in cycle later. Divide cell if older than maximum age.
maximum_age: f64,
// The position of the cell. We cannot have two positions which are the same. Thus we need
// to update the position as well.
position: [f64; 2],
}
impl Cycle<Cell> for Cell {
fn update_cycle(rng: &mut ChaCha8Rng, dt: &f64, cell: &mut Cell) -> Option<CycleEvent> {
// Increase the current age of the cell
cell.current_age += dt;
// If the cell is older than the current age, return a division event
if cell.current_age > cell.maximum_age {
return Some(CycleEvent::Division)
}
None
}
fn divide(rng: &mut ChaCha8Rng, cell: &mut Cell) -> Result<Cell, DivisionError> {
// Prepare the original cell for division.
// Set the radius of both cells to half of the original radius.
cell.radius *= 0.5;
// Also set the current age of the cell to zero again
cell.current_age = 0.0;
// Clone the existing cell
let mut new_cell = (*cell).clone();
// Define a new position for both cells
// To do this: Pick a random number as an angle.
let angle = rng.gen_range(0.0..2.0*std::f64::consts::PI);
// Calculate the new position of the original and new cell with this angle
let pos = [
cell.radius * angle.cos(),
cell.radius * angle.sin()
];
let new_pos = [
cell.radius * (angle+std::f64::consts::FRAC_PI_2).cos(),
cell.radius * (angle+std::f64::consts::FRAC_PI_2).sin()
];
// Set new positions
cell.position = pos;
new_cell.position = new_pos;
// Finally return the new cell
return Ok(new_cell);
}
}Required Methods§
fn update_cycle(
rng: &mut ChaCha8Rng,
dt: &Float,
cell: &mut Cell,
) -> Option<CycleEvent>
fn update_cycle( rng: &mut ChaCha8Rng, dt: &Float, cell: &mut Cell, ) -> 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 Cell) -> Result<Cell, DivisionError>
fn divide(rng: &mut ChaCha8Rng, cell: &mut Cell) -> Result<Cell, 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.
Provided Methods§
fn update_conditional_phased_death(
rng: &mut ChaCha8Rng,
dt: &Float,
cell: &mut Cell,
) -> Result<bool, DeathError>
fn update_conditional_phased_death( rng: &mut ChaCha8Rng, dt: &Float, cell: &mut Cell, ) -> 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.
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.