Struct NewtonDamped2DF32

pub struct NewtonDamped2DF32 {
    pub pos: SVector<f32, 2>,
    pub vel: SVector<f32, 2>,
    pub damping_constant: f32,
    pub mass: f32,
}

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: SVector<f32, 2>

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

vel: SVector<f32, 2>

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

damping_constant: f32

Damping constant $\lambda$.

mass: f32

Mass $m$ of the object.

Implementations

impl NewtonDamped2DF32

pub fn new( pos: [f32; 2], vel: [f32; 2], damping_constant: f32, mass: f32, ) -> Self

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

impl NewtonDamped2DF32

pub fn get_pos(&self) -> [f32; 2]

Available on crate feature pyo3 only.

[pyo3] getter for pos

pub fn get_vel(&self) -> [f32; 2]

Available on crate feature pyo3 only.

[pyo3] getter for vel

pub fn get_damping_constant(&self) -> f32

Available on crate feature pyo3 only.

[pyo3] getter for damping_constant

pub fn get_mass(&self) -> f32

Available on crate feature pyo3 only.

[pyo3] getter for mass

pub fn set_pos(&mut self, pos: [f32; 2])

Available on crate feature pyo3 only.

[pyo3] setter for pos

pub fn set_vel(&mut self, vel: [f32; 2])

Available on crate feature pyo3 only.

[pyo3] setter for vel

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

Available on crate feature pyo3 only.

[pyo3] setter for damping_constant

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

Available on crate feature pyo3 only.

[pyo3] setter for mass

Trait Implementations

impl Clone for NewtonDamped2DF32

fn clone(&self) -> NewtonDamped2DF32

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NewtonDamped2DF32

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NewtonDamped2DF32

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl IntoPy<Py<PyAny>> for NewtonDamped2DF32

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl Mechanics<Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, f32> for NewtonDamped2DF32

fn get_random_contribution( &self, _: &mut ChaCha8Rng, _dt: f32, ) -> Result<(SVector<f32, 2>, SVector<f32, 2>), 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: SVector<f32, 2>, ) -> Result<(SVector<f32, 2>, SVector<f32, 2>), 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 NewtonDamped2DF32

fn eq(&self, other: &NewtonDamped2DF32) -> 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<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>> for NewtonDamped2DF32

fn pos(&self) -> SVector<f32, 2>

Gets the cells current position.

fn set_pos(&mut self, pos: &SVector<f32, 2>)

Gets the cells current velocity.

impl PyClass for NewtonDamped2DF32

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for NewtonDamped2DF32

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<NewtonDamped2DF32>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature<NewtonDamped2DF32> for PyClassImplCollector<NewtonDamped2DF32>

fn new_text_signature(self) -> Option<&'static str>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a NewtonDamped2DF32

type Holder = Option<PyRef<'py, NewtonDamped2DF32>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a mut NewtonDamped2DF32

type Holder = Option<PyRefMut<'py, NewtonDamped2DF32>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl PyMethods<NewtonDamped2DF32> for PyClassImplCollector<NewtonDamped2DF32>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for NewtonDamped2DF32

const NAME: &'static str = "NewtonDamped2DF32"

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_bound(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

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

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

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

Checks if object is an instance of this type.

impl Serialize for NewtonDamped2DF32

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Velocity<Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>> for NewtonDamped2DF32

fn velocity(&self) -> SVector<f32, 2>

Gets the cells current velocity.

fn set_velocity(&mut self, velocity: &SVector<f32, 2>)

Sets the cells current velocity.

impl DerefToPyAny for NewtonDamped2DF32

impl StructuralPartialEq for NewtonDamped2DF32