Struct NewtonDamped3D

pub struct NewtonDamped3D {
    pub pos: Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>,
    pub vel: Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>,
    pub damping_constant: f64,
    pub mass: f64,
}

Available on crate feature cpu_os_threads only.

Newtonian dynamics governed by mass and damping.

Parameters

Symbol	Parameter	Description
$\vec{x}$	pos	Position of the particle.
$\dot{\vec{x}}$	vel	Velocity of the particle.
$\lambda$	damping	Damping constant
$m$	mass	Mass of the particle.

Equations

The equation of motion is given by \begin{equation} m \ddot{\vec{x}} = \vec{F} - \lambda \dot{\vec{x}} \end{equation} where $\vec{F}$ is the force as calculated by the Interaction trait.

Comments

If the cell is growing, we need to increase the mass $m$. By interacting with the outside world, we can adapt $\lambda$ to external values although this is rarely desirable. Both operations need to be implemented by other concepts such as Cycle.

Fields

pos: Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>

Current position $\vec{x}$ given by a vector of dimension D.

vel: Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>

Current velocity $\dot{\vec{x}}$ given by a vector of dimension D.

damping_constant: f64

Damping constant $\lambda$.

mass: f64

Mass $m$ of the object.

Implementations

impl NewtonDamped3D

pub fn new( pos: [f64; 3], vel: [f64; 3], damping_constant: f64, mass: f64, ) -> NewtonDamped3D

Create a new NewtonDamped3D from position, velocity, damping constant and mass

impl NewtonDamped3D

pub fn get_pos(&self) -> [f64; 3]

[pyo3] getter for pos

pub fn get_vel(&self) -> [f64; 3]

[pyo3] getter for vel

pub fn get_damping_constant(&self) -> f64

[pyo3] getter for damping_constant

pub fn get_mass(&self) -> f64

[pyo3] getter for mass

pub fn set_pos(&mut self, pos: [f64; 3])

[pyo3] setter for pos

pub fn set_vel(&mut self, vel: [f64; 3])

[pyo3] setter for vel

pub fn set_damping_constant(&mut self, damping_constant: f64)

[pyo3] setter for damping_constant

pub fn set_mass(&mut self, mass: f64)

[pyo3] setter for mass

Trait Implementations

impl AbsDiffEq for NewtonDamped3D

type Epsilon = <f64 as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> <NewtonDamped3D as AbsDiffEq>::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq( &self, other: &NewtonDamped3D, epsilon: <NewtonDamped3D as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses the absolute difference to compute the approximimate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of [AbsDiffEq::abs_diff_eq].

impl Clone for NewtonDamped3D

fn clone(&self) -> NewtonDamped3D

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NewtonDamped3D

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NewtonDamped3D

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'py> IntoPyObject<'py> for NewtonDamped3D

type Target = NewtonDamped3D

The Python output type

type Output = Bound<'py, <NewtonDamped3D 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<<NewtonDamped3D as IntoPyObject<'py>>::Output, <NewtonDamped3D as IntoPyObject<'py>>::Error>

Performs the conversion.

impl Mechanics<Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>, Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>, Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>> for NewtonDamped3D

fn get_random_contribution( &self, _: &mut ChaCha8Rng, _dt: f64, ) -> Result<(Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>, Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>), 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: Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>, ) -> Result<(Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>, Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>), 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 PartialEq for NewtonDamped3D

fn eq(&self, other: &NewtonDamped3D) -> 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 Position<Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>> for NewtonDamped3D

fn pos(&self) -> Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>

Gets the cells current position.

fn set_pos( &mut self, pos: &Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>, )

Gets the cells current velocity.

impl PyClass for NewtonDamped3D

type Frozen = False

Whether the pyclass is frozen.

impl PyTypeInfo for NewtonDamped3D

const NAME: &'static str = "NewtonDamped3D"

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 RelativeEq for NewtonDamped3D

fn default_max_relative() -> <NewtonDamped3D as AbsDiffEq>::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &NewtonDamped3D, epsilon: <NewtonDamped3D as AbsDiffEq>::Epsilon, max_relative: <NewtonDamped3D as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of [RelativeEq::relative_eq].

impl Serialize for NewtonDamped3D

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 Velocity<Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>> for NewtonDamped3D

fn velocity(&self) -> Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>

Gets the cells current velocity.

fn set_velocity( &mut self, velocity: &Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>, )

Sets the cells current velocity.

impl DerefToPyAny for NewtonDamped3D

impl StructuralPartialEq for NewtonDamped3D