Struct Bacteria

pub struct Bacteria {
    pub mechanics: NewtonDamped2D,
    pub cycle: BacteriaCycle,
    pub cellular_reactions: BacteriaReactions,
    pub interactionextracellulargradient: GradientSensing,
}

Bacteria-Agent as used in the pool-model example

Fields

mechanics: NewtonDamped2D

See NewtonDamped2D mechanics

cycle: BacteriaCycle

See BacteriaCycle

cellular_reactions: BacteriaReactions

See BacteriaReactions

interactionextracellulargradient: GradientSensing

See GradientSensing

Implementations

impl Bacteria

pub fn from( py: Python<'_>, bacteria_template: BacteriaTemplate, ) -> Result<Bacteria, PyErr>

Available on crate feature cpu_os_threads only.

Convert a BacteriaTemplate into a Bacteria

pub fn volume_to_mass(&self, volume: f64) -> f64

Available on crate feature cpu_os_threads only.

We can have a look at this paper https://doi.org/10.1128/jb.148.1.58-63.1981 and see that the average density of E.Coli is between 1.080 and 1.100 g/ml This means we can safely set the density to 1.09

pub fn mass_to_volume(&self, mass: f64) -> f64

Available on crate feature cpu_os_threads only.

Conversion function of mass to volume

pub fn increase_volume(&mut self, volume_increment: f64)

Available on crate feature cpu_os_threads only.

Modifies the cell and increases the overall volume by the specified amount.

pub fn cell_radius(&self) -> f64

Available on crate feature cpu_os_threads only.

Obtain the current cell radius

Trait Implementations

impl Clone for Bacteria

fn clone(&self) -> Bacteria

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Cycle<Bacteria> for BacteriaCycle

fn update_cycle( rng: &mut ChaCha8Rng, dt: &f64, cell: &mut Bacteria, ) -> 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, c1: &mut Bacteria, ) -> Result<Bacteria, 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 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.

impl<__cr_private_Float> Cycle<Bacteria, __cr_private_Float> for Bacteria

where BacteriaCycle: Cycle<Bacteria, __cr_private_Float>,

fn update_cycle( rng: &mut ChaCha8Rng, dt: &__cr_private_Float, cell: &mut Bacteria, ) -> 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 Bacteria, ) -> Result<Bacteria, 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: &__cr_private_Float, cell: &mut Bacteria, ) -> 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 Debug for Bacteria

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Bacteria

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__cr_private_Pos, __cr_private_Vel, __cr_private_For, __cr_private_Inf> Interaction<__cr_private_Pos, __cr_private_Vel, __cr_private_For, __cr_private_Inf> for Bacteria

where BacteriaReactions: Interaction<__cr_private_Pos, __cr_private_Vel, __cr_private_For, __cr_private_Inf> + InteractionInformation<__cr_private_Inf>,

fn calculate_force_between( &self, own_pos: &__cr_private_Pos, own_vel: &__cr_private_Vel, ext_pos: &__cr_private_Pos, ext_vel: &__cr_private_Vel, ext_info: &__cr_private_Inf, ) -> Result<(__cr_private_For, __cr_private_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.

impl InteractionExtracellularGradient<Bacteria, Matrix<Matrix<f64, Const<2>, Const<1>, ArrayStorage<f64, 2, 1>>, Const<cellular_raza_building_blocks::::cell_models::pool_bacteria::{impl#5}::{constant#0}>, Const<1>, ArrayStorage<Matrix<f64, Const<2>, Const<1>, ArrayStorage<f64, 2, 1>>, cellular_raza_building_blocks::::cell_models::pool_bacteria::{impl#5}::{constant#0}, 1>>> for GradientSensing

fn sense_gradient( _cell: &mut Bacteria, _gradient: &Matrix<Matrix<f64, Const<2>, Const<1>, ArrayStorage<f64, 2, 1>>, Const<cellular_raza_building_blocks::::cell_models::pool_bacteria::{impl#5}::sense_gradient::{constant#0}>, Const<1>, ArrayStorage<Matrix<f64, Const<2>, Const<1>, ArrayStorage<f64, 2, 1>>, cellular_raza_building_blocks::::cell_models::pool_bacteria::{impl#5}::sense_gradient::{constant#0}, 1>>, ) -> Result<(), CalcError>

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

impl<__cr_private_ExtraGradient> InteractionExtracellularGradient<Bacteria, __cr_private_ExtraGradient> for Bacteria

where GradientSensing: InteractionExtracellularGradient<Bacteria, __cr_private_ExtraGradient>,

fn sense_gradient( cell: &mut Bacteria, gradient: &__cr_private_ExtraGradient, ) -> Result<(), CalcError>

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

impl<__cr_private_Inf> InteractionInformation<__cr_private_Inf> for Bacteria

where BacteriaReactions: InteractionInformation<__cr_private_Inf>,

fn get_interaction_information(&self) -> __cr_private_Inf

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

impl<'py> IntoPyObject<'py> for Bacteria

type Target = Bacteria

The Python output type

type Output = Bound<'py, <Bacteria as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Bacteria as IntoPyObject<'py>>::Output, <Bacteria as IntoPyObject<'py>>::Error>

Performs the conversion.

impl<__cr_private_Ri> Intracellular<__cr_private_Ri> for Bacteria

where BacteriaReactions: Intracellular<__cr_private_Ri>,

fn get_intracellular(&self) -> __cr_private_Ri

Obtains the current intracellular values.

fn set_intracellular(&mut self, concentration_vector: __cr_private_Ri)

Sets the current intracellular values.

impl<__cr_private_Pos, __cr_private_Vel, __cr_private_For, __cr_private_Float> Mechanics<__cr_private_Pos, __cr_private_Vel, __cr_private_For, __cr_private_Float> for Bacteria

where NewtonDamped2D: Mechanics<__cr_private_Pos, __cr_private_Vel, __cr_private_For, __cr_private_Float>,

fn calculate_increment( &self, force: __cr_private_For, ) -> Result<(__cr_private_Pos, __cr_private_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.

fn get_random_contribution( &self, rng: &mut ChaCha8Rng, dt: __cr_private_Float, ) -> Result<(__cr_private_Pos, __cr_private_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.

impl<__cr_private_Pos> Position<__cr_private_Pos> for Bacteria

where NewtonDamped2D: Position<__cr_private_Pos>,

fn pos(&self) -> __cr_private_Pos

Gets the cells current position.

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

Gets the cells current velocity.

impl PyClass for Bacteria

type Frozen = False

Whether the pyclass is frozen.

impl PyTypeInfo for Bacteria

const NAME: &'static str = "Bacteria"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl<__cr_private_Ri> Reactions<__cr_private_Ri> for Bacteria

where BacteriaReactions: Reactions<__cr_private_Ri>, Bacteria: Intracellular<__cr_private_Ri>,

fn calculate_intracellular_increment( &self, intracellular: &__cr_private_Ri, ) -> Result<__cr_private_Ri, CalcError>

Calculates the purely intracellular reaction increment. Users who implement this trait should always use the given argument instead of relying on values obtained via self.

impl Serialize for Bacteria

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<__cr_private_Vel> Velocity<__cr_private_Vel> for Bacteria

where NewtonDamped2D: Velocity<__cr_private_Vel>,

fn velocity(&self) -> __cr_private_Vel

Gets the cells current velocity.

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

Sets the cells current velocity.

impl Volume for Bacteria

fn get_volume(&self) -> f64

Obtain the cells current volume.

impl DerefToPyAny for Bacteria