Struct sampling::rees::ReesWalker

pub struct ReesWalker<R, Hist, Energy, S, Res> { /* private fields */ }

Walker for Replica exchange entropic sampling

• performes the random walk in its respective domain

Implementations

impl<R, Hist, Energy, S, Res> ReesWalker<R, Hist, Energy, S, Res>

pub fn id(&self) -> usize

Returns id of walker

• important for mapping the ensemble to the walker

pub fn energy(&self) -> &Energy

Returns reference of current energy

pub fn energy_copy(&self) -> Energy

where Energy: Copy,

Returns current energy

pub fn hist(&self) -> &Hist

Reference to internal histogram

pub fn sweep_size(&self) -> NonZeroUsize

how many steps per sweep

pub fn sweep_size_change(&mut self, sweep_size: NonZeroUsize)

change how many steps per sweep are performed

pub fn step_size(&self) -> usize

step size for markov steps

pub fn step_size_change(&mut self, step_size: usize)

Change step sitze for markov steps

pub fn step_count(&self) -> u64

How many entropic steps were performed until now?

pub fn replica_exchanges(&self) -> u64

How many successful replica exchanges were performed until now?

pub fn proposed_replica_exchanges(&self) -> u64

How many replica exchanges were proposed until now?

pub fn replica_exchange_frac(&self) -> f64

fraction of how many replica exchanges were accepted and how many were proposed

pub fn rejected_markov_steps(&self) -> u64

How many markov steps were rejected until now

pub fn acceptance_rate_markov(&self) -> f64

rate/fraction of acceptance

pub fn log_density(&self) -> &[f64]

• Old non normalized estimate of the natural logarithm of the probability density function
• for refined density use self.log_density_refined()

pub fn log_density_refined(&self) -> Vec<f64>

where Hist: Histogram,

• Current non normalized estimate of the natural logarithm of the probability density function
• calculated by refining old density with current histogram

How does the refining work?

• Let P(i) be the current probability density function (non normalized) at some index i
• Let H(i) be the histogram at some index i We will now calculate the refined density P’, which is calculated as follows:

P’(i) = P(i) * H(i) (if H(i) != 0)

P’(i) = P(i) (if H(i) == 0)

Or in log space, which is what is actually calculated here:

ln(P’(i)) = ln(P(i)) + ln(H(i)) (if H(i) != 0)

ln(P’(i)) = ln(P(i)) (if H(i)=0)

for more information see

J. Lee, “New Monte Carlo algorithm: Entropic sampling,” Phys. Rev. Lett. 71, 211–214 (1993), DOI: 10.1103/PhysRevLett.71.211

pub fn log10_density(&self) -> Vec<f64>

Old estimate of log10 of probability density

• normalized (sum over non log values is 1 (within numerical precision))

pub fn log10_density_refined(&self) -> Vec<f64>

where Hist: Histogram,

Current estimate of log10 of probability density

• normalized (sum over non log values is 1 (within numerical precision))

pub fn is_finished(&self) -> bool

is the simulation finished?

• true, if more (or equal) steps than the step threshold are performed

pub fn step_threshold(&self) -> u64

Return step threshold

pub fn refine(&mut self)

where Hist: Histogram,

Refine current probability density estimate

• refines the current probability estimate by setting it to self.log_density_refined

Trait Implementations

impl<R: Clone, Hist: Clone, Energy: Clone, S: Clone, Res: Clone> Clone for ReesWalker<R, Hist, Energy, S, Res>

fn clone(&self) -> ReesWalker<R, Hist, Energy, S, Res>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug, Hist: Debug, Energy: Debug, S: Debug, Res: Debug> Debug for ReesWalker<R, Hist, Energy, S, Res>

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

Formats the value using the given formatter.

impl<'de, R, Hist, Energy, S, Res> Deserialize<'de> for ReesWalker<R, Hist, Energy, S, Res>

where R: Deserialize<'de>, Hist: Deserialize<'de>, Energy: Deserialize<'de>, S: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R, Hist, Energy, S, Res> From<RewlWalker<R, Hist, Energy, S, Res>> for ReesWalker<R, Hist, Energy, S, Res>

where Hist: Histogram,

fn from(rewl_walker: RewlWalker<R, Hist, Energy, S, Res>) -> Self

Converts to this type from the input type.

impl<R, Hist, Energy, S, Res> Serialize for ReesWalker<R, Hist, Energy, S, Res>

where R: Serialize, Hist: Serialize, Energy: Serialize, S: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.