Struct NoséHooverChain 

pub struct NoséHooverChain<const N: usize> { /* private fields */ }

Chain of Nosé-Hoover thermostats.

NoséHooverChain adds new degrees of freedom ($\eta_i$) to a molecular dynamics simulation in such a way that the existing degrees of freedom sample a constant temperature ensemble. Each NoséHooverChain instance stores the $\eta_i$ and their momenta, $\xi_i$, internally.

The dynamics of each $\eta_i, \xi_i$ are similar to that in MartynaTuckermanTobiasKlein, but they are also chained together. See Martyna et al. 1992 for details.

Reference

• Martyna et al. 1992

Example

use hoomd_md::thermostat::NoséHooverChain;

let thermostat = NoséHooverChain::<3>::zero(0.5.try_into()?);

Implementations

impl<const N: usize> NoséHooverChain<N>

pub fn zero(tau: PositiveReal) -> Self

Construct a new NoséHooverChain thermostat with the given time constant, $\xi_i = 0$, and $\eta_i = 0$ .

This initial condition is likely to be very far from equilibrium which will result in wild kinetic energy oscillations for the first hundred to thousand time steps. Use thermalized to choose the initial position and momentum from a thermal distribution.

Example

use hoomd_md::thermostat::NoséHooverChain;

let thermostat = NoséHooverChain::<3>::zero(0.5.try_into()?);

pub fn thermalized<M, R: Rng + ?Sized>( rng: &mut R, tau: PositiveReal, macrostate: &M, degrees_of_freedom: usize, ) -> Self

where M: Temperature,

Construct a new NoséHooverChain thermostat with random $\xi_i$ values drawn from a thermal distribution.

Panics

This method will panic when degrees_of_freedom is 0.

Example

use hoomd_md::{TranslationalKineticEnergy, thermostat::NoséHooverChain};
use hoomd_microstate::{
    Body, Microstate,
    property::{DynamicPoint, Point},
};
use hoomd_simulation::macrostate::Isothermal;
use hoomd_vector::Cartesian;

let mut microstate = Microstate::builder()
    .bodies([
        Body::single_site(
            DynamicPoint {
                position: Cartesian::from([1.0, 2.0]),
                ..Default::default()
            },
            Point::default(),
        ),
        Body::single_site(
            DynamicPoint {
                position: Cartesian::from([-2.0, 3.0]),
                ..Default::default()
            },
            Point::default(),
        ),
    ])
    .try_build()?;

let macrostate = Isothermal { temperature: 1.5 };
let mut rng = microstate.counter().make_rng();
let translational_thermostat = NoséHooverChain::<3>::thermalized(
    &mut rng,
    0.5.try_into()?,
    &macrostate,
    microstate.translational_kinetic_energy().1,
);
microstate.increment_substep();

pub fn energy(&self) -> f64

The total energy of the thermostat.

Example

use hoomd_md::thermostat::NoséHooverChain;

let thermostat = NoséHooverChain::<3>::zero(0.5.try_into()?);

let energy = thermostat.energy();

pub fn eta(&self) -> &[f64; N]

The chain of thermostat positions.

Example

use hoomd_md::thermostat::NoséHooverChain;

let thermostat = NoséHooverChain::<3>::zero(0.5.try_into()?);

let eta = thermostat.eta();

pub fn xi(&self) -> &[f64; N]

The chain of thermostat momenta.

Example

use hoomd_md::thermostat::NoséHooverChain;

let thermostat = NoséHooverChain::<3>::zero(0.5.try_into()?);

let xi = thermostat.xi();

Trait Implementations

impl<const N: usize> Clone for NoséHooverChain<N>

fn clone(&self) -> NoséHooverChain<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for NoséHooverChain<N>

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

Formats the value using the given formatter.

impl<'de, const N: usize> Deserialize<'de> for NoséHooverChain<N>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: usize> PartialEq for NoséHooverChain<N>

fn eq(&self, other: &NoséHooverChain<N>) -> 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<const N: usize> Serialize for NoséHooverChain<N>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: usize, M> Thermostat<M> for NoséHooverChain<N>

where M: Temperature,

fn integrate_half_step_one<R: Rng + ?Sized>( &mut self, _rng: &mut R, macrostate: &M, delta_t: f64, kinetic_energy: f64, degrees_of_freedom: usize, ) -> f64

Integrate the thermostat one half step forward in time.

fn integrate_half_step_two<R: Rng + ?Sized>( &mut self, rng: &mut R, macrostate: &M, delta_t: f64, kinetic_energy: f64, degrees_of_freedom: usize, ) -> f64

Integrate the thermostat one half step forward in time.

impl<const N: usize> StructuralPartialEq for NoséHooverChain<N>