Struct Rotate 

pub struct Rotate<O> { /* private fields */ }

Change the orientation of a body by a small amount.

Rotate proposes local trial moves that rotate the orientation of a body by a small amount. The maximum_rotation parameter sets the largest possible rotation.

When proposing trial moves for Angle, maximum_rotation is measured in radians and the rotation is uniformly chosen between -maximum_rotation and maximum_rotation.

When proposing trial moves for Versor, maximum_rotation is measured in radians and the width of a Gaussian distribution centered on 0.

The generic type names are:

• O: The type of the orientation to rotate.

Example

use hoomd_mc::Rotate;
use hoomd_vector::Angle;

let a = 0.1;
let rotate = Rotate::<Angle>::with_maximum_rotation(a.try_into()?);

Implementations

impl<P> Rotate<P>

pub fn with_maximum_rotation(maximum_rotation: PositiveReal) -> Self

Construct a Rotate move with the given maximum rotation.

Example

use hoomd_mc::Rotate;
use hoomd_vector::Angle;

let a = 0.1;
let rotate = Rotate::<Angle>::with_maximum_rotation(a.try_into()?);

pub fn maximum_rotation(&self) -> &PositiveReal

Get the maximum rotation.

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

Get the maximum rotation.

Trait Implementations

impl Adjust for Rotate<Angle>

fn adjust(&mut self, factor: PositiveReal)

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

impl Adjust for Rotate<Versor>

fn adjust(&mut self, factor: PositiveReal)

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

impl<O: Clone> Clone for Rotate<O>

fn clone(&self) -> Rotate<O>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<O: Debug> Debug for Rotate<O>

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

Formats the value using the given formatter.

impl<'de, O> Deserialize<'de> for Rotate<O>

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 Rotate<P>

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

Format a Rotate as {maximum_rotation}.

impl<B> LocalTrial<B> for Rotate<Angle>

where B: Orientation<Rotation = Angle>,

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

Perturb a body’s orientation by a random amount.

Example

use hoomd_mc::{LocalTrial, Rotate};
use hoomd_microstate::property::OrientedPoint;
use hoomd_vector::{Angle, Cartesian};
use rand::{Rng, SeedableRng, rngs::StdRng};

let mut rng = StdRng::seed_from_u64(1);
let body_properties = OrientedPoint {
    position: Cartesian::from([0.0, 0.0]),
    orientation: Angle::from(0.0),
};
let rotate = Rotate::with_maximum_rotation(0.1.try_into()?);

let new_body_properties = rotate.propose(&mut rng, body_properties);
assert!(new_body_properties.orientation.theta.abs() < 0.1);

impl<B> LocalTrial<B> for Rotate<Versor>

where B: Orientation<Rotation = Versor>,

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

Perturb a body’s orientation by a random amount.

In three dimensions, we design this perturbation as a versor whose distribution is centered on the existing orientation and whose distribution is narrow. To do so, we sample from a 3-dimensional Normal distribution in the tangent space of SO(3), lift to the manifold, then rotate to center on the current orientation. The result is a small displacement from a quaternion input, with fast decay in the tails that make large displacements unlikely. This is desirable for Monte Carlo, as large moves are very likely to be rejected. This sampling obeys detailed balance.

Example

use hoomd_mc::{LocalTrial, Rotate};
use hoomd_microstate::property::OrientedPoint;
use hoomd_vector::{Cartesian, Versor};
use rand::{Rng, SeedableRng, rngs::StdRng};

let mut rng = StdRng::seed_from_u64(1);
let initial_orientation = Versor::default();
let body_properties = OrientedPoint {
    position: Cartesian::from([0.0, 0.0, 0.0]),
    orientation: initial_orientation,
};
let rotate = Rotate::with_maximum_rotation(0.1.try_into()?);

let new_body_properties = rotate.propose(&mut rng, body_properties);
assert!(new_body_properties.orientation != initial_orientation);

impl<O: PartialEq> PartialEq for Rotate<O>

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<O> StructuralPartialEq for Rotate<O>