Struct ParallelSweep 

pub struct ParallelSweep<L, K, B, S> { /* private fields */ }

In parallel, apply local trial moves to bodies in the microstate.

The generic type names are:

• L: The LocalTrial type.
• K: The Checkerboard type.
• B: The Body::properties type.
• S: The Site::properties type.

Example

use hoomd_mc::{HypercuboidCheckerboard, ParallelSweep, Translate};
use hoomd_microstate::property::Point;
use hoomd_vector::Cartesian;

let d = 0.1;
let translate =
    Translate::<Cartesian<2>>::with_maximum_distance(d.try_into()?);
let translate_sweep = ParallelSweep::<
    _,
    HypercuboidCheckerboard<2>,
    Point<Cartesian<2>>,
    Point<Cartesian<2>>,
>::new(1.0.try_into()?, translate);

Implementations

impl<L, K, B, S> ParallelSweep<L, K, B, S>

where K: Default,

pub fn new(body_interaction_range: PositiveReal, local_trial: L) -> Self

Construct a new ParallelSweep.

To avoid applying conflicting moves at the same time, you need to provide the largest distance between any two interacting bodies: body_interaction_range (measured between the body positions). ParallelSweep cannot compute this value, nor can it validate whether the provided value is correct.

The local_trial arguments determines what trial moves ParallelSweep attempts.

Example

use hoomd_mc::{HypercuboidCheckerboard, ParallelSweep, Translate};
use hoomd_microstate::property::Point;
use hoomd_vector::Cartesian;

let d = 0.1;
let translate =
    Translate::<Cartesian<2>>::with_maximum_distance(d.try_into()?);
let translate_sweep = ParallelSweep::<
    _,
    HypercuboidCheckerboard<2>,
    Point<Cartesian<2>>,
    Point<Cartesian<2>>,
>::new(1.0.try_into()?, translate);

impl<L, K, B, S> ParallelSweep<L, K, B, S>

pub fn body_interaction_range(&self) -> &PositiveReal

Get the body interaction range.

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

Get the body interaction range (mutable).

pub fn local_trial(&self) -> &L

Get the local trial.

pub fn local_trial_mut(&mut self) -> &mut L

Get the local trial (mutable).

Trait Implementations

impl<L: Clone, K: Clone, B: Clone, S: Clone> Clone for ParallelSweep<L, K, B, S>

fn clone(&self) -> ParallelSweep<L, K, B, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: Debug, K: Debug, B: Debug, S: Debug> Debug for ParallelSweep<L, K, B, S>

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

Formats the value using the given formatter.

impl<'de, L, K, B, S> Deserialize<'de> for ParallelSweep<L, K, B, S>

where L: Deserialize<'de>, K: Deserialize<'de>, B: Default, S: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<L: PartialEq, K: PartialEq, B: PartialEq, S: PartialEq> PartialEq for ParallelSweep<L, K, B, S>

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

where L: Serialize, K: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<P, B, S, X, C, L, H, MA, K> Trial<Microstate<B, S, X, C>, H, MA> for ParallelSweep<L, K, B, S>

where P: Copy, B: Copy + Default + Transform<S> + Position<Position = P> + Send + Sync, S: Copy + Default + Position<Position = P> + Send + Sync, X: PointUpdate<P, SiteKey> + Sync, L: LocalTrial<B> + Sync, H: DeltaEnergyOne<B, S, X, C> + Sync, C: Wrap<B> + Wrap<S> + GenerateGhosts<S> + Cover<P, Checkerboard = K> + Sync, MA: Temperature, K: Checkerboard<P> + Sync,

fn apply( &mut self, microstate: &mut Microstate<B, S, X, C>, hamiltonian: &H, macrostate: &MA, ) -> Self::Count

In parallel, apply local trial moves to bodies in the microstate.

Each trial move is accepted when:

r < \exp\left(\frac{-\Delta H}{kT}\right)

where r is a random value uniformly distributed in [0,1), $\Delta H$ is the change in energy computed by the given hamiltonian and $kT$ is the temperature given in macrostate.

ParallelSweep covers the simulation domain with a colored checkerboard (given by the K type). For each color, apply applies trial moves in parallel to bodies checkerboard spaces of that color (one trial move per space). A move is invalid when the body center leaves the initial checkerboard space. The return value counts only valid moves.

One invocation of apply continues to apply trial moves until it has attempted at least as many trial moves as there are bodies in the microstate. Therefore, one call to ParallelSweep::apply roughly equivalent to one call to Sweep::apply. However, ParallelSweep will always attempt more trial moves because it rounds up. To make quantitative comparisons between the methods, normalize by the number of attempted moves.

Example

use hoomd_geometry::shape::Rectangle;
use hoomd_interaction::Zero;
use hoomd_mc::{ParallelSweep, Translate, Trial};
use hoomd_microstate::{
    Body, Microstate, boundary::Closed, property::Position,
};
use hoomd_simulation::macrostate::Isothermal;
use hoomd_vector::Cartesian;

let square = Rectangle::with_equal_edges(10.0.try_into()?);
let mut microstate = Microstate::builder()
    .boundary(Closed(square))
    .bodies([Body::point(Cartesian::from([0.0, 0.0]))])
    .try_build()?;
let d = 0.1;
let translate = Translate::with_maximum_distance(d.try_into()?);
let mut translate_sweep = ParallelSweep::new(1.0.try_into()?, translate);

let hamiltonian = Zero;
let macrostate = Isothermal { temperature: 1.0 };

translate_sweep.apply(&mut microstate, &hamiltonian, &macrostate);
microstate.increment_step();

type Count = Count

Represent the number of accepted and rejected individual trial moves.

impl<P, B, S, X, C, L, H, MA, K> Tune<P, B, S, X, C, L, H, MA> for ParallelSweep<L, K, B, S>

where P: Copy, B: Copy + Default + Transform<S> + Position<Position = P>, S: Copy + Default + Position<Position = P>, X: PointUpdate<P, SiteKey>, L: LocalTrial<B> + Adjust + Display, H: DeltaEnergyOne<B, S, X, C>, C: Wrap<B> + Wrap<S> + GenerateGhosts<S>, MA: Temperature,

fn tune( &mut self, microstate: &Microstate<B, S, X, C>, hamiltonian: &H, macrostate: &MA, target_acceptance: OpenUnitIntervalNumber, samples: usize, steps: usize, )

Tune the trial move maximum size to achieve a given acceptance ratio.

Use tune_default unless you have a specific need to adjust the tuning parameters.

Example

use hoomd_geometry::shape::Rectangle;
use hoomd_interaction::{
    MaximumInteractionRange, PairwiseCutoff, pairwise::HardSphere,
};
use hoomd_mc::{ParallelSweep, Translate, Trial, Tune};
use hoomd_microstate::{
    Body, Microstate, boundary::Periodic, property::Position,
};
use hoomd_simulation::macrostate::Isothermal;
use hoomd_vector::Cartesian;

let square = Rectangle::with_equal_edges(10.0.try_into()?);
let mut microstate = Microstate::builder()
    .boundary(Periodic::new(1.0, square)?)
    .try_build()?;
microstate.add_body(Body::point(Cartesian::from([-0.6, -0.6])))?;
microstate.add_body(Body::point(Cartesian::from([-0.6, 0.6])))?;
microstate.add_body(Body::point(Cartesian::from([0.6, -0.6])))?;
microstate.add_body(Body::point(Cartesian::from([0.6, 0.6])))?;
let d = 0.1;
let translate = Translate::with_maximum_distance(d.try_into()?);
let mut translate_sweep = ParallelSweep::new(1.0.try_into()?, translate);

let hamiltonian = PairwiseCutoff(HardSphere { diameter: 1.0 });
let macrostate = Isothermal { temperature: 1.0 };

translate_sweep.tune_default(&microstate, &hamiltonian, &macrostate);

translate_sweep.apply(&mut microstate, &hamiltonian, &macrostate);

fn tune_default( &mut self, microstate: &Microstate<B, S, X, C>, hamiltonian: &H, macrostate: &MA, )

Tune the trial move maximum size with default parameters.

impl<L, K, B, S> StructuralPartialEq for ParallelSweep<L, K, B, S>