Struct OrientedPoint 

pub struct OrientedPoint<V, R> {
    pub position: V,
    pub orientation: R,
}

The position and orientation of an extended body.

Use OrientedPoint as a Body or Site property type.

Example

use hoomd_microstate::property::OrientedPoint;
use hoomd_vector::{Angle, Cartesian};

let point = OrientedPoint {
    position: Cartesian::from([1.0, -3.0]),
    orientation: Angle::from(1.2),
};

Fields

position: V

The location of the extended body in space.

orientation: R

Rotate from the body’s reference frame into another frame.

Trait Implementations

impl<B, X> AppendMicrostate<B, OrientedPoint<Cartesian<2>, Angle>, X, Closed<Hypercuboid<2>>> for HoomdGsdFile

fn append_microstate( &mut self, microstate: &Microstate<B, OrientedPoint<Cartesian<2>, Angle>, X, Closed<Hypercuboid<2>>>, ) -> Result<Frame<'_>, AppendError>

Append the contents of the microstate as a frame in a GSD file.

impl<B, X> AppendMicrostate<B, OrientedPoint<Cartesian<2>, Angle>, X, Periodic<Hypercuboid<2>>> for HoomdGsdFile

fn append_microstate( &mut self, microstate: &Microstate<B, OrientedPoint<Cartesian<2>, Angle>, X, Periodic<Hypercuboid<2>>>, ) -> Result<Frame<'_>, AppendError>

Append the contents of the microstate as a frame in a GSD file.

impl<B, X> AppendMicrostate<B, OrientedPoint<Cartesian<3>, Versor>, X, Closed<Hypercuboid<3>>> for HoomdGsdFile

fn append_microstate( &mut self, microstate: &Microstate<B, OrientedPoint<Cartesian<3>, Versor>, X, Closed<Hypercuboid<3>>>, ) -> Result<Frame<'_>, AppendError>

Append the contents of the microstate as a frame in a GSD file.

impl<B, X> AppendMicrostate<B, OrientedPoint<Cartesian<3>, Versor>, X, Periodic<Hypercuboid<3>>> for HoomdGsdFile

fn append_microstate( &mut self, microstate: &Microstate<B, OrientedPoint<Cartesian<3>, Versor>, X, Periodic<Hypercuboid<3>>>, ) -> Result<Frame<'_>, AppendError>

Append the contents of the microstate as a frame in a GSD file.

impl<V: Clone, R: Clone> Clone for OrientedPoint<V, R>

fn clone(&self) -> OrientedPoint<V, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug, R: Debug> Debug for OrientedPoint<V, R>

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

Formats the value using the given formatter.

impl<V: Default, R: Default> Default for OrientedPoint<V, R>

fn default() -> OrientedPoint<V, R>

Returns the “default value” for a type.

impl<'de, V, R> Deserialize<'de> for OrientedPoint<V, R>

where V: Deserialize<'de>, R: 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, R> Orientation for OrientedPoint<V, R>

type Rotation = R

Type that can express the orientation of a body or site.

fn orientation(&self) -> &R

The orientation of this body or site.

fn orientation_mut(&mut self) -> &mut R

The orientation of this body or site (mutable).

impl<V: PartialEq, R: PartialEq> PartialEq for OrientedPoint<V, R>

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

type Position = P

Every position is located in this vector space.

fn position(&self) -> &P

The position of this body or site [length].

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

The mutable position of this body or site [length].

impl<V, R> Serialize for OrientedPoint<V, R>

where V: Serialize, R: 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 OrientedPoint<V, R>

where V: Vector, R: Rotate<V> + Rotation,

Treat OrientedPoint sites as constituents of oriented rigid bodies.

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

Move Point properties from the local body frame to the system frame.

\vec{r} = \vec{r}_\mathrm{body} + R_\mathrm{body}(\vec{r}_\mathrm{site})

R = R_\mathrm{body}(R_\mathrm{site})

use approxim::assert_relative_eq;
use hoomd_microstate::{Transform, property::OrientedPoint};
use hoomd_vector::{Angle, Cartesian};
use std::f64::consts::PI;

let body_properties = OrientedPoint {
    position: Cartesian::from([1.0, -2.0]),
    orientation: Angle::from(PI / 2.0),
};
let site_properties = OrientedPoint {
    position: Cartesian::from([-1.0, 0.0]),
    orientation: Angle::from(PI / 4.0),
};

let system_site = body_properties.transform(&site_properties);
assert_relative_eq!(system_site.position, [1.0, -3.0].into());
assert_relative_eq!(system_site.orientation.theta, 3.0 * PI / 4.0);

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

where V: Vector, R: Rotate<V>,

Treat Point sites as constituents of oriented rigid bodies.

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

Move Point properties from the local body frame to the system frame.

\vec{r} = \vec{r}_\mathrm{body} + R_\mathrm{body}(\vec{r}_\mathrm{site})

use approxim::assert_relative_eq;
use hoomd_microstate::{
    Transform,
    property::{OrientedPoint, Point},
};
use hoomd_vector::{Angle, Cartesian};
use std::f64::consts::PI;

let body_properties = OrientedPoint {
    position: Cartesian::from([1.0, -2.0]),
    orientation: Angle::from(PI / 2.0),
};
let site_properties = Point::new(Cartesian::from([-1.0, 0.0]));

let system_site = body_properties.transform(&site_properties);
assert_relative_eq!(system_site.position, [1.0, -3.0].into());

impl<V: Copy, R: Copy> Copy for OrientedPoint<V, R>

impl<V, R> StructuralPartialEq for OrientedPoint<V, R>