Struct Body 

pub struct Body<B, S = B> {
    pub properties: B,
    pub sites: Vec<S>,
}

A collection of interaction sites that can be placed in a Microstate.

The Body properties have a generic type that includes all the body’s degrees of freedom and any other fields needed to implement the user’s model. Bodies interact indirectly via one or more sites. The sites vector stores the properties of the body’s sites in the body frame. The body field properties stores the body’s degrees of freedom (such as position and orientation) in the system frame. Transform describes how a given body transforms its sites from the body frame to the system frame.

In typical cases, such as those implemented in hoomd-rs, Body describes a rigid collection of sites that transform together. However, creative implementations of Transform could achieve other behaviors.

Use the properties defined in property to construct bodies that meet the needs of your model.

Examples

Construct body with a single interaction site at one point:

use hoomd_microstate::Body;
use hoomd_vector::Cartesian;

let body = Body::point(Cartesian::from([-3.0, 5.0]));

Construct an oriented body:

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

let body_properties = OrientedPoint {
    position: Cartesian::from([1.0, -3.0]),
    orientation: Angle::from(1.2),
};
let site_properties = OrientedPoint {
    position: Cartesian::<2>::default(),
    orientation: Angle::default(),
};

let body = Body {
    properties: body_properties,
    sites: vec![site_properties],
};

Construct a rigid body with several point sites:

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

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

let body = Body {
    properties: body_properties,
    sites: vec![
        Point::new(Cartesian::from([0.0, -1.0])),
        Point::new(Cartesian::from([0.0, 0.0])),
        Point::new(Cartesian::from([0.0, 1.0])),
    ],
};

Custom body and site properties

The property module documentation shows you how to define custom body and site property types.

Fields

properties: B

The body’s degrees of freedom.

sites: Vec<S>

Interaction sites in the body’s frame of reference.

Implementations

impl<V> Body<Point<V>, Point<V>>

pub fn point(position: V) -> Self

where V: Default,

Construct a point particle.

A point particle is a Body with a single interaction site at the body’s origin. The body and site property types are identical and have only a position field. Use point particles for simulations of monodisperse hard spheres, identical particles with pairwise interactions, or any time you need a Microstate that consists only of point particles.

Example

use hoomd_microstate::Body;
use hoomd_vector::Cartesian;

let body = Body::point(Cartesian::from([-3.0, 5.0]));
assert_eq!(body.properties.position, [-3.0, 5.0].into());
assert_eq!(body.sites.len(), 1);
assert_eq!(body.sites[0].position, [0.0, 0.0].into());

Trait Implementations

impl<B, S> Clone for Body<B, S>

where B: Clone, S: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Debug, S: Debug> Debug for Body<B, S>

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

Formats the value using the given formatter.

impl<B: Default, S: Default> Default for Body<B, S>

fn default() -> Body<B, S>

Returns the “default value” for a type.

impl<'de, B, S> Deserialize<'de> for Body<B, S>

where B: Deserialize<'de>, S: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<B: PartialEq, S: PartialEq> PartialEq for Body<B, S>

fn eq(&self, other: &Body<B, S>) -> 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<B, S> Serialize for Body<B, S>

where B: Serialize, S: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<B, S> StructuralPartialEq for Body<B, S>