Struct net_ensembles::sampling::rees::ReplicaExchangeEntropicSampling

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

Struct used for entropic sampling with replica exchanges

See this, also for merge functions to create the final probability density functions

Implementations

impl<Ensemble, R, Hist, Energy, S, Res, Extra> ReplicaExchangeEntropicSampling<Extra, Ensemble, R, Hist, Energy, S, Res>

pub fn ensemble_iter(
    &'a self
) -> impl Iterator<Item = RwLockReadGuard<'a, Ensemble>>

Iterator over ensembles

If you do not know what RwLockReadGuard<'a, Ensemble> is - do not worry. you can just pretend it is &Ensemble and everything should work out fine, since it implements Deref. Of cause, you can also take a look at RwLockReadGuard

pub fn get_ensemble(
    &self,
    index: usize
) -> Option<RwLockReadGuard<'_, Ensemble>>

read access to your ensembles

• None if index out of range
• If you do not know what RwLockReadGuard<Ensemble> is - do not worry. you can just pretend it is &Ensemble and everything will work out fine, since it implements Deref. Of cause, you can also take a look at RwLockReadGuard

pub unsafe fn get_ensemble_mut(&mut self, index: usize) -> Option<&mut Ensemble>

mut access to your ensembles

• if possible, prefer get_ensemble
• unsafe only use this if you know what you are doing
• it is assumed, that whatever you change has no effect on the Markov Chain, the result of the energy function etc.
• None if index out of range
• might panic if a thread is poisened

pub unsafe fn ensemble_iter_mut(
    &mut self
) -> impl Iterator<Item = &mut Ensemble>

Mutable iterator over ensembles

• if possible, prefer ensemble_iter
• unsafe only use this if you know what you are doing
• it is assumed, that whatever you change has no effect on the Markov Chain, the result of the energy function etc.
• might panic if a thread is poisened

pub fn hists(&self) -> Vec<&Hist, Global>

read access to the internal histograms used by the walkers

pub fn get_hist(&self, index: usize) -> Option<&Hist>

read access to internal histogram

• None if index out of range

impl<Extra, Ensemble, R, Hist, Energy, S, Res> ReplicaExchangeEntropicSampling<Extra, Ensemble, R, Hist, Energy, S, Res>

pub fn is_finished(&self) -> bool

Checks threshold

returns true, if all walkers are finished

pub fn num_intervals(&self) -> usize

Get the number of intervals present

pub fn num_walkers(&self) -> usize

How many walkers are there in total?

pub fn walkers_per_interval(&self) -> NonZeroUsize

Returns number of walkers per interval

pub fn walkers(&self) -> &[ReesWalker<R, Hist, Energy, S, Res>]

Returns internal walkers

• access to internal slice of walkers
• the walkers are sorted and neighboring walker are either sampling the same interval, or a neighboring (and if the replica exchange makes any sense overlapping) interval

pub fn change_step_size_of_interval(
    &mut self,
    n: usize,
    step_size: usize
) -> Result<(), ()>

Change step size for markov chain of walkers

• changes the step size used in the sweep
• changes step size of all walkers in the nth interval
• returns Err if index out of bounds, i.e., the requested interval does not exist
• interval counting starts at 0, i.e., n=0 is the first interval

pub fn get_step_size_of_interval(&self, n: usize) -> Option<usize>

Get step size for markov chain of walkers

• returns None if index out of bounds, i.e., the requested interval does not exist
• interval counting starts at 0, i.e., n=0 is the first interval

pub fn change_sweep_size_of_interval(
    &mut self,
    n: usize,
    sweep_size: NonZeroUsize
) -> Result<(), ()>

Change sweep size for markov chain of walkers

• changes the sweep size used in the sweep
• changes sweep size of all walkers in the nth interval
• returns Err if index out of bounds, i.e., the requested interval does not exist
• interval counting starts at 0, i.e., n=0 is the first interval

pub fn get_sweep_size_of_interval(&self, n: usize) -> Option<NonZeroUsize>

Get sweep size for markov chain of walkers

• returns None if index out of bounds, i.e., the requested interval does not exist
• interval counting starts at 0, i.e., n=0 is the first interval

pub fn extra_slice(&self) -> &[Extra]

Read access to your extra information

pub fn extra_slice_mut(&mut self) -> &mut [Extra]

Write access to your extra information

pub fn unpack_extra(
    self
) -> (ReplicaExchangeEntropicSampling<(), Ensemble, R, Hist, Energy, S, Res>, Vec<Extra, Global>)

Remove extra vector

• returns tuple of Self (without extra, i.e., Rees<(), Ensemble, R, Hist, Energy, S, Res>) and vector of Extra

pub fn swap_extra<Extra2>(
    self,
    new_extra: Vec<Extra2, Global>
) -> Result<(ReplicaExchangeEntropicSampling<Extra2, Ensemble, R, Hist, Energy, S, Res>, Vec<Extra, Global>), ()>

Swap the extra vector

• Note: len of extra has to be the same as self.num_walkers() (which is the same as self.extra_slice().len()) otherwise an Err is returned

impl<Ensemble, R, Hist, Energy, S, Res> ReplicaExchangeEntropicSampling<(), Ensemble, R, Hist, Energy, S, Res>

pub fn add_extra<Extra>(
    self,
    extra: Vec<Extra, Global>
) -> Result<ReplicaExchangeEntropicSampling<Extra, Ensemble, R, Hist, Energy, S, Res>, (ReplicaExchangeEntropicSampling<(), Ensemble, R, Hist, Energy, S, Res>, Vec<Extra, Global>)>

Add extra information to your Replica Exchange entropic sampling simulation

• can be used to, e.g., print stuff during the simulation, or write it to a file and so on

impl<Extra, Ensemble, R, Hist, Energy, S, Res> ReplicaExchangeEntropicSampling<Extra, Ensemble, R, Hist, Energy, S, Res> where
    R: Send + Sync + Rng,
    S: Send + Sync,
    Res: Send + Sync,
    Hist: Send + Sync + Histogram + HistogramVal<Energy>,
    Energy: Send + Sync + Clone,
    Ensemble: Send + Sync + MarkovChain<S, Res>,
    Extra: Send + Sync, 

pub fn refine(&mut self)

Refine the estimate of the probability density functions

• refines the estimate of all walkers
• does so by calling the walker method refine

pub fn sweep<F, P>(&mut self, energy_fn: F, extra_fn: P) where
    F: Fn(&mut Ensemble) -> Option<Energy> + Copy + Send + Sync,
    P: Fn(&ReesWalker<R, Hist, Energy, S, Res>, &mut Ensemble, &mut Extra) + Copy + Send + Sync, 

Sweep

• Performs one sweep of the Replica exchange entropic sampling simulation
• You can make a complete simulation, by repeatatly calling this method until self.is_finished() returns true

pub fn simulate_until_convergence<F, P>(&mut self, energy_fn: F, extra_fn: P) where
    F: Fn(&mut Ensemble) -> Option<Energy> + Copy + Send + Sync,
    R: Send + Sync,
    Ensemble: Send + Sync,
    P: Fn(&ReesWalker<R, Hist, Energy, S, Res>, &mut Ensemble, &mut Extra) + Copy + Send + Sync, 

Perform the Replica exchange simulation

• will simulate until all walkers are finished
• extra_fn should be used for example for writing Data to a file

pub fn simulate_while<F, C, P>(
    &mut self,
    energy_fn: F,
    condition: C,
    extra_fn: P
) where
    C: FnMut(&ReplicaExchangeEntropicSampling<Extra, Ensemble, R, Hist, Energy, S, Res>) -> bool,
    F: Fn(&mut Ensemble) -> Option<Energy> + Copy + Send + Sync,
    R: Send + Sync,
    Ensemble: Send + Sync,
    P: Fn(&ReesWalker<R, Hist, Energy, S, Res>, &mut Ensemble, &mut Extra) + Copy + Send + Sync, 

Perform the Replica exchange simulation

• will simulate until all walkers are finished or
• until condition returns false

pub fn check_energy_fn<F>(&mut self, energy_fn: F) -> bool where
    F: Fn(&mut Ensemble) -> Option<Energy> + Copy + Send + Sync,
    Energy: PartialEq<Energy>, 

Sanity check

• checks if the stored (i.e., last) energy(s) of the system match with the result of energy_fn

pub fn merged_log_prob(&self) -> Result<(Hist, Vec<f64, Global>), HistErrors> where
    Hist: HistogramCombine, 

Result of the simulations!

This is what we do the simulation for!

It returns the natural logarithm of the normalized (i.e. sum=1 within numerical precision) probability density and the histogram, which contains the corresponding bins.

Failes if the internal histograms (invervals) do not align. Might fail if there is no overlap between neighboring intervals

pub fn merged_log_prob_and_aligned(
    &self
) -> Result<(Hist, Vec<f64, Global>, Vec<Vec<f64, Global>, Global>), HistErrors> where
    Hist: HistogramCombine, 

Results of the simulation

This is what we do the simulation for!

It returns histogram, which contains the corresponding bins and the natural logarithm of the normalized (i.e. sum=1 within numerical precision) probability density. Lastly it returns the vector of the aligned probability estimates (also ln) of the different intervals. This can be used to see, how good the simulation worked, e.g., by plotting them to see, if they match

Notes

Failes if the internal histograms (invervals) do not align. Might fail if there is no overlap between neighboring intervals

Trait Implementations

impl<Extra, Ensemble, R, Hist, Energy, S, Res> Debug for ReplicaExchangeEntropicSampling<Extra, Ensemble, R, Hist, Energy, S, Res> where
    R: Debug,
    S: Debug,
    Res: Debug,
    Hist: Debug,
    Energy: Debug,
    Ensemble: Debug,
    Extra: Debug, 

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

Formats the value using the given formatter.

impl<'de, Extra, Ensemble, R, Hist, Energy, S, Res> Deserialize<'de> for ReplicaExchangeEntropicSampling<Extra, Ensemble, R, Hist, Energy, S, Res> where
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    Res: Deserialize<'de>,
    Hist: Deserialize<'de>,
    Energy: Deserialize<'de>,
    Ensemble: Deserialize<'de>,
    Extra: Deserialize<'de>, 

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReplicaExchangeEntropicSampling<Extra, Ensemble, R, Hist, Energy, S, Res>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<Ensemble, R, Hist, Energy, S, Res> From<ReplicaExchangeWangLandau<Ensemble, R, Hist, Energy, S, Res>> for ReplicaExchangeEntropicSampling<(), Ensemble, R, Hist, Energy, S, Res> where
    Hist: Histogram, 

pub fn from(
    rewl: ReplicaExchangeWangLandau<Ensemble, R, Hist, Energy, S, Res>
) -> ReplicaExchangeEntropicSampling<(), Ensemble, R, Hist, Energy, S, Res>

Performs the conversion.

impl<Extra, Ensemble, R, Hist, Energy, S, Res> Serialize for ReplicaExchangeEntropicSampling<Extra, Ensemble, R, Hist, Energy, S, Res> where
    R: Serialize,
    S: Serialize,
    Res: Serialize,
    Hist: Serialize,
    Energy: Serialize,
    Ensemble: Serialize,
    Extra: 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.