Struct Site 

pub struct Site<S> {
    pub site_tag: usize,
    pub body_tag: usize,
    pub properties: S,
}

Interactions in hoomd-rs apply between sites.

A Site (often called an atom or a particle in other codes) has a tag that uniquely identities it in the Microstate and is associated with a given body (see Body). All interactions in hoomd-rs occur on or between sites as a function of their properties which has the generic type S. At a minimum, Microstate assumes that S implements Position. S is generic so that users can build custom types that store orientation, charge, mass, color, or whatever other fields are needed to implement their model.

Add sites to the Microstate as members of bodies (Body).

Example

Find the center of all interaction sites in a Microstate:

use hoomd_microstate::{Body, Microstate, MicrostateBuilder};
use hoomd_vector::{Cartesian, Vector};

let microstate = Microstate::builder()
    .bodies([
        Body::point(Cartesian::from([1.0, 0.0])),
        Body::point(Cartesian::from([-1.0, 2.0])),
    ])
    .try_build()?;

let average_site_position = microstate
    .sites()
    .iter()
    .map(|site| site.properties.position)
    .sum::<Cartesian<2>>()
    / (microstate.sites().len() as f64);

Fields

site_tag: usize

Every site in a Microstate has a unique value in site_tag.

body_tag: usize

The body tag of the Body associated with this site.

properties: S

The properties of the site.

Trait Implementations

impl<S: Clone> Clone for Site<S>

fn clone(&self) -> Site<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for Site<S>

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

Formats the value using the given formatter.

impl<'de, S> Deserialize<'de> for Site<S>

where 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<S: PartialEq> PartialEq for Site<S>

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

where 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<S: Copy> Copy for Site<S>

impl<S> StructuralPartialEq for Site<S>