Struct Translate 

pub struct Translate<P> { /* private fields */ }

Move the position of a body by a small distance.

Translate proposes local trial moves that translate the position of a body in space by up to a maximum distance, given by a PositiveReal.

The generic type names are:

• P: The type of the point to translate.

Example

use hoomd_mc::Translate;
use hoomd_vector::Cartesian;

let d = 0.1;
let translate =
    Translate::<Cartesian<2>>::with_maximum_distance(d.try_into()?);

Implementations

impl<P> Translate<P>

pub fn with_maximum_distance(maximum_distance: PositiveReal) -> Self

Construct a Translate move with the given maximum distance.

Example

use hoomd_mc::Translate;
use hoomd_vector::Cartesian;

let d = 0.1;
let translate =
    Translate::<Cartesian<2>>::with_maximum_distance(d.try_into()?);

pub fn maximum_distance(&self) -> &PositiveReal

Get the maximum distance.

pub fn maximum_distance_mut(&mut self) -> &mut PositiveReal

Get the maximum distance.

Trait Implementations

impl<P> Adjust for Translate<P>

fn adjust(&mut self, factor: PositiveReal)

Change the maximum trial move size by the given scale factor.

impl<P: Clone> Clone for Translate<P>

fn clone(&self) -> Translate<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug> Debug for Translate<P>

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

Formats the value using the given formatter.

impl<'de, P> Deserialize<'de> for Translate<P>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<P> Display for Translate<P>

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

Format a Translate as {maximum_distance}.

impl<const N: usize, B> LocalTrial<B> for Translate<Cartesian<N>>

where B: Position<Position = Cartesian<N>>, Ball: Distribution<Cartesian<N>>,

fn propose<R: Rng>(&self, rng: &mut R, body_properties: B) -> B

Perturb a body’s position by a random amount.

Example

use hoomd_mc::{LocalTrial, Translate};
use hoomd_microstate::property::Point;
use hoomd_vector::{Cartesian, InnerProduct};
use rand::{Rng, SeedableRng, rngs::StdRng};

let mut rng = StdRng::seed_from_u64(1);
let body_properties = Point::new(Cartesian::from([0.0, 0.0]));
let d = 1.0;
let translate = Translate::with_maximum_distance(d.try_into()?);

let new_body_properties = translate.propose(&mut rng, body_properties);
assert!(new_body_properties.position.norm() < 1.0);

impl LocalTrial<OrientedHyperbolicPoint<3, Angle>> for Translate<OrientedHyperbolicPoint<3, Angle>>

fn propose<R: Rng>( &self, rng: &mut R, body_properties: OrientedHyperbolicPoint<3, Angle>, ) -> OrientedHyperbolicPoint<3, Angle>

Propose local trial moves for an oriented body on a hyperbolic surface.

impl LocalTrial<Point<Hyperbolic<3>>> for Translate<Point<Hyperbolic<3>>>

fn propose<R: Rng>( &self, rng: &mut R, body_properties: Point<Hyperbolic<3>>, ) -> Point<Hyperbolic<3>>

Propose local trial moves for a body on a hyperbolic surface.

Example

use approxim::assert_relative_eq;
use hoomd_manifold::{Hyperbolic, Minkowski};
use hoomd_mc::{LocalTrial, Translate};
use hoomd_microstate::property::{Point, Position};
use hoomd_vector::Metric;
use rand::{SeedableRng, rngs::StdRng};

let mut rng = StdRng::seed_from_u64(13);
let body_properties = Point::new(Hyperbolic::from_minkowski_coordinates(
    [1.0, -1.0, (3.0_f64).sqrt()].into(),
));
let d = 0.1;
let translate = Translate::with_maximum_distance(d.try_into()?);

let new_body_properties = translate.propose(&mut rng, body_properties);

// Translation move keeps the point on the Hyperboloid
assert_relative_eq!(
    new_body_properties
        .position()
        .point()
        .distance_squared(&Minkowski::from([0.0, 0.0, 0.0])),
    -1.0_f64,
    epsilon = 1e-12
);

// Translation move does not move the point more than a distance d
assert!(
    d > new_body_properties.position().distance(
        &Hyperbolic::from_minkowski_coordinates(Minkowski::from([
            1.0,
            -1.0,
            (3.0_f64).sqrt()
        ]))
    )
);

impl LocalTrial<Point<Spherical<3>>> for Translate<Point<Spherical<3>>>

fn propose<R: Rng>( &self, rng: &mut R, body_properties: Point<Spherical<3>>, ) -> Point<Spherical<3>>

Propose local trial moves for a body on the surface of a sphere

Example

use approxim::assert_relative_eq;
use hoomd_manifold::{Spherical, SphericalDisk};
use hoomd_mc::{LocalTrial, Translate};
use hoomd_microstate::property::{Point, Position};
use hoomd_vector::{Cartesian, InnerProduct, Metric, Vector};
use rand::{Rng, SeedableRng, rngs::StdRng};

let mut rng = StdRng::seed_from_u64(14);
let initial_point = Point::new(Spherical::from_cartesian_coordinates(
    [0.5_f64.sqrt(), 0.5_f64.sqrt(), 0.0].into(),
));
let d = 0.1;
let translate = Translate::with_maximum_distance(d.try_into()?);

let new_body_properties = translate.propose(&mut rng, initial_point);

// Translation move keeps point on the surface of the sphere
let new_body_radius = new_body_properties.position.point().norm();
assert_relative_eq!(new_body_radius, 1.0, epsilon = 1e-8);

// Translation move does not translate the point more than a distance d away
assert!(
    d > new_body_properties
        .position()
        .distance(&initial_point.position())
);

impl LocalTrial<Point<Spherical<4>>> for Translate<Point<Spherical<4>>>

fn propose<R: Rng>( &self, rng: &mut R, body_properties: Point<Spherical<4>>, ) -> Point<Spherical<4>>

Propose local trial moves for a body on the surface of a 3-sphere

Example

use approxim::assert_relative_eq;
use hoomd_manifold::{Spherical, SphericalDisk};
use hoomd_mc::{LocalTrial, Translate};
use hoomd_microstate::property::{Point, Position};
use hoomd_vector::{Cartesian, InnerProduct, Metric, Vector};
use rand::{Rng, SeedableRng, rngs::StdRng};
use std::f64::consts::PI;

let mut rng = StdRng::seed_from_u64(14);
let initial_point = Point::new(Spherical::<4>::from_polar_coordinates(
    PI / 4.0,
    PI / 10.0,
    5.0 * PI / 4.0,
));
let d = 0.1;
let translate = Translate::with_maximum_distance(d.try_into()?);

let new_body_properties = translate.propose(&mut rng, initial_point);

// Translation move keeps point on the surface of the sphere
assert_relative_eq!(
    new_body_properties.position().point().norm(),
    1.0_f64,
    epsilon = 1e-8
);

// Translation move does not translate the point more than a distance d away
assert!(
    d > new_body_properties
        .position()
        .distance(&initial_point.position())
);

impl<P: PartialEq> PartialEq for Translate<P>

fn eq(&self, other: &Translate<P>) -> 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> Serialize for Translate<P>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<P> StructuralPartialEq for Translate<P>