Struct net_ensembles::sampling::ReesWalker

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

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, Global> 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, Global>

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, Global> 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, Hist, Energy, S, Res> Clone for ReesWalker<R, Hist, Energy, S, Res> where
    R: Clone,
    S: Clone,
    Res: Clone,
    Hist: Clone,
    Energy: Clone, 

pub 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, Hist, Energy, S, Res> Debug for ReesWalker<R, Hist, Energy, S, Res> where
    R: Debug,
    S: Debug,
    Res: Debug,
    Hist: Debug,
    Energy: Debug, 

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

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>,
    S: Deserialize<'de>,
    Hist: Deserialize<'de>,
    Energy: Deserialize<'de>, 

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReesWalker<R, Hist, Energy, S, Res>, <__D as Deserializer<'de>>::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, 

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

Performs the conversion.

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

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

Serialize this value into the given Serde serializer.