Struct UniformIn 

pub struct UniformIn<S, C> {
    pub boundary: C,
    pub template_sites: Vec<S>,
}

Generate bodies uniformly in the given boundary condition.

Give UniformIn a template vector of sites and it will randomly generate bodies uniformly distributed in the given boundary. Each generated body will have the same sites (cloned from template_sites) and random body properties sampled in the given boundary.

Example

Place points at random locations in the boundary:

use hoomd_geometry::{IsPointInside, shape::Rectangle};
use hoomd_mc::{BodyDistribution, UniformIn};
use hoomd_microstate::{Body, boundary::Closed, property::Point};
use hoomd_vector::Cartesian;

use rand::{SeedableRng, distr::Distribution, rngs::StdRng};

let rectangle = Closed(Rectangle::with_equal_edges(5.0.try_into()?));
let mut rng = StdRng::seed_from_u64(1);

let uniform_in = UniformIn {
    boundary: rectangle,
    template_sites: vec![Point::new(Cartesian::from([0.0, 0.0]))],
};

let body: Body<Point<Cartesian<2>>, Point<Cartesian<2>>> =
    uniform_in.sample(0, &mut rng);
assert!(
    uniform_in
        .boundary
        .0
        .is_point_inside(&body.properties.position)
);

Place oriented bodies at random locations in the boundary and give them random orientations:

use rand::{SeedableRng, rngs::StdRng};
use std::f64::consts::PI;

use hoomd_geometry::{IsPointInside, shape::Rectangle};
use hoomd_mc::{BodyDistribution, UniformIn};
use hoomd_microstate::{
    Body,
    boundary::Closed,
    property::{OrientedPoint, Point},
};
use hoomd_vector::{Angle, Cartesian};

let rectangle = Closed(Rectangle::with_equal_edges(5.0.try_into()?));
let mut rng = StdRng::seed_from_u64(1);

let uniform_in = UniformIn {
    boundary: rectangle,
    template_sites: vec![
        Point::new(Cartesian::from([-1.0, 0.0])),
        Point::new(Cartesian::from([1.0, 0.0])),
    ],
};

let body: Body<OrientedPoint<Cartesian<2>, Angle>, Point<Cartesian<2>>> =
    uniform_in.sample(0, &mut rng);
assert!(
    uniform_in
        .boundary
        .0
        .is_point_inside(&body.properties.position)
);
assert!(body.properties.orientation.theta < 2.0 * PI);

Fields

boundary: C

Generate bodies inside this boundary.

template_sites: Vec<S>

Give each generated body these sites.

Trait Implementations

impl<V, O, S, C> BodyDistribution<Body<OrientedPoint<V, O>, S>> for UniformIn<S, C>

where S: Clone, C: Distribution<V>, StandardUniform: Distribution<O>,

Randomly place oriented bodies in a given boundary.

sample chooses the body’s position randomly in the given boundary and also assigns a uniform random orientation. Sites, therefore, may be placed outside the boundary. Callers should reject insertions appropriately when add_body fails.

fn sample<R: Rng + ?Sized>( &self, _index: usize, rng: &mut R, ) -> Body<OrientedPoint<V, O>, S>

Sample a body from the distribution with the given index.

impl<V, S, C> BodyDistribution<Body<Point<V>, S>> for UniformIn<S, C>

where S: Clone, C: Distribution<V>,

Randomly place point bodies in a given boundary.

sample chooses the body’s position randomly in the given boundary. Sites, therefore, may be placed outside the boundary. Callers should reject insertions appropriately when add_body fails.

fn sample<R: Rng + ?Sized>( &self, _index: usize, rng: &mut R, ) -> Body<Point<V>, S>

Sample a body from the distribution with the given index.

impl<S: Clone, C: Clone> Clone for UniformIn<S, C>

fn clone(&self) -> UniformIn<S, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug, C: Debug> Debug for UniformIn<S, C>

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

Formats the value using the given formatter.

impl<'de, S, C> Deserialize<'de> for UniformIn<S, C>

where S: Deserialize<'de>, C: 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, C: PartialEq> PartialEq for UniformIn<S, C>

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

where S: Serialize, C: 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, C> StructuralPartialEq for UniformIn<S, C>