Struct DynamicPoint 

pub struct DynamicPoint<V>
where
    V: Outer,
{
    pub position: V,
    pub mass: f64,
    pub momentum: V,
    pub net_force: V,
    pub net_virial: V::Tensor,
}

A position in space with the properties necessary for translational motion in MD.

Use DynamicPoint as a Body property type.

A default DynamicPoint has a mass of 1.0. Position, momentum, and net force of $\vec{0}$, and a zero-tensor for net virial.

Example

use hoomd_microstate::property::DynamicPoint;
use hoomd_vector::Cartesian;

let dynamic_point = DynamicPoint {
    position: Cartesian::from([1.0, -3.0]),
    mass: 1.0,
    ..Default::default()
};

Fields

position: V

The location of the extended body in space $[\mathrm{length}]$.

mass: f64

The mass of the extended body $[\mathrm{mass}]$.

momentum: V

The translational momentum of the extended body $[\mathrm{mass} \cdot \mathrm{length}] \cdot \mathrm{time}^{-1}]$.

net_force: V

The net force applied to the body in a Microstate $[\mathrm{mass} \cdot \mathrm{length}] \cdot \mathrm{time}^{-2}]$.

net_virial: V::Tensor

The net virial applied to the body in a Microstate $[\mathrm{energy}]$.

Trait Implementations

impl<V> Clone for DynamicPoint<V>

where V: Outer + Clone, V::Tensor: Clone,

fn clone(&self) -> DynamicPoint<V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V> Debug for DynamicPoint<V>

where V: Outer + Debug, V::Tensor: Debug,

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

Formats the value using the given formatter.

impl<V> Default for DynamicPoint<V>

where V: Default + Outer, V::Tensor: Default,

fn default() -> Self

Construct a DynamicPoint with mass 1.0. Position, momentum, and net force are set to the 0 vector.

Example

use hoomd_linear_algebra::{GeneralMatrix, matrix::Matrix};
use hoomd_microstate::property::DynamicPoint;
use hoomd_vector::Cartesian;

let dynamic_point = DynamicPoint::<Cartesian<3>>::default();
assert_eq!(dynamic_point.mass, 1.0);
assert_eq!(dynamic_point.position, [0.0, 0.0, 0.0].into());
assert_eq!(dynamic_point.momentum, [0.0, 0.0, 0.0].into());
assert_eq!(dynamic_point.net_force, [0.0, 0.0, 0.0].into());
assert_eq!(dynamic_point.net_virial, Matrix::zeros());

impl<'de, V> Deserialize<'de> for DynamicPoint<V>

where V: Outer + Deserialize<'de>, V::Tensor: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<V: Outer> Mass for DynamicPoint<V>

fn mass(&self) -> f64

The mass of this body $[\mathrm{mass}]$.

impl<V> Momentum for DynamicPoint<V>

where V: Mul<f64, Output = V> + Div<f64, Output = V> + Copy + Outer,

type Momentum = V

Type that can express momentum and velocity.

fn momentum(&self) -> &V

The momentum of this body $[ \mathrm{energy}^{1/2} \cdot \mathrm{mass}^{1/2}]$.

fn momentum_mut(&mut self) -> &mut V

The mutable momentum of this body $[ \mathrm{energy}^{1/2} \cdot \mathrm{mass}^{1/2}]$.

fn velocity(&self) -> Self::Momentum

The velocity of this body $[ \mathrm{energy}^{1/2} \cdot \mathrm{mass}^{-1/2}]$.

fn set_velocity(&mut self, velocity: Self::Momentum)

Change the velocity of this body.

impl<V: Outer> NetForce for DynamicPoint<V>

type NetForce = V

Force vector type.

fn net_force(&self) -> &Self::NetForce

The net force on this body $[\mathrm{energy} \cdot \mathrm{length}^{-1}]$.

fn net_force_mut(&mut self) -> &mut Self::NetForce

The mutable net force on this body $[\mathrm{energy} \cdot \mathrm{length}^{-1}]$.

impl<V: Outer> NetVirial for DynamicPoint<V>

type NetVirial = <V as Outer>::Tensor

Virial vector type.

fn net_virial(&self) -> &Self::NetVirial

The net virial on this body $[\mathrm{energy}]$.

fn net_virial_mut(&mut self) -> &mut Self::NetVirial

The mutable net virial on this body $[\mathrm{energy}]$.

impl<V> PartialEq for DynamicPoint<V>

where V: Outer + PartialEq, V::Tensor: PartialEq,

fn eq(&self, other: &DynamicPoint<V>) -> 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<P: Outer> Position for DynamicPoint<P>

type Position = P

Every position is located in this vector space.

fn position(&self) -> &P

The position of this body or site $[\mathrm{length}]$.

fn position_mut(&mut self) -> &mut P

The mutable position of this body or site $[\mathrm{length}]$.

impl<V> Serialize for DynamicPoint<V>

where V: Outer + Serialize, V::Tensor: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<V, R> Transform<OrientedPoint<V, R>> for DynamicPoint<V>

where V: Vector + Outer, R: Copy,

fn transform( &self, site_properties: &OrientedPoint<V, R>, ) -> OrientedPoint<V, R>

DynamicPoint transforms OrientedPoint by vector addition.

\vec{r} = \vec{r}_\mathrm{body} + \vec{r}_\mathrm{site}

use approxim::assert_relative_eq;
use hoomd_microstate::{
    Transform,
    property::{DynamicPoint, OrientedPoint},
};
use hoomd_vector::{Cartesian, Versor};

let body_properties = DynamicPoint {
    position: Cartesian::from([1.0, -2.0, 3.0]),
    ..Default::default()
};
let site_properties = OrientedPoint {
    position: Cartesian::from([-3.0, 2.0, 1.0]),
    orientation: Versor::default(),
};

let system_site = body_properties.transform(&site_properties);
assert_relative_eq!(system_site.position, [-2.0, 0.0, 4.0].into());

impl<V: Vector + Outer> Transform<Point<V>> for DynamicPoint<V>

fn transform(&self, site_properties: &Point<V>) -> Point<V>

DynamicPoint transforms Point by vector addition.

\vec{r} = \vec{r}_\mathrm{body} + \vec{r}_\mathrm{site}

use approxim::assert_relative_eq;
use hoomd_microstate::{
    Transform,
    property::{DynamicPoint, Point},
};
use hoomd_vector::Cartesian;

let body_properties = DynamicPoint {
    position: Cartesian::from([1.0, -2.0, 3.0]),
    ..Default::default()
};
let site_properties = Point::new(Cartesian::from([-3.0, 2.0, 1.0]));

let system_site = body_properties.transform(&site_properties);
assert_relative_eq!(system_site.position, [-2.0, 0.0, 4.0].into());

impl<V> Copy for DynamicPoint<V>

where V: Outer + Copy, V::Tensor: Copy,

impl<V> StructuralPartialEq for DynamicPoint<V>

where V: Outer,