Type Definition sampling::rewl::Rewl

pub type Rewl<Ensemble, R, Hist, Energy, S, Res> = ReplicaExchangeWangLandau<Ensemble, R, Hist, Energy, S, Res>;

Short for ReplicaExchangeWangLandau, which you can look at for citations

Implementations

impl<Ensemble, R, Hist, Energy, S, Res> Rewl<Ensemble, R, Hist, Energy, S, Res>

pub fn walkers(&self) -> &Vec<RewlWalker<R, Hist, Energy, S, Res>>

Read access to internal rewl walkers

• each of these walkers independently samples an interval.
• see paper for more infos

pub fn ensemble_iter(
    &self
) -> impl Iterator<Item = RwLockReadGuard<'_, 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 ensemble_iter_mut(
    &mut self
) -> impl Iterator<Item = &mut Ensemble>

Mutable iterator over ensembles

• if possible, prefer ensemble_iter

Safety

• 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 unsafe fn get_ensemble_mut(&mut self, index: usize) -> Option<&mut Ensemble>

mut access to your ensembles

• if possible, prefer get_ensemble
• None if index out of range

Safety

• 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 num_intervals(&self) -> NonZeroUsize

Get the number of intervals present

pub fn walkers_per_interval(&self) -> NonZeroUsize

Returns number of walkers per 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 min_roundtrips(&self) -> usize

Minimum of roundtrips

Definition of roundtrip: If a walker is in the leftest interval, then in the rightest and then in the leftest again (or the other way around) then this is counted as one roundtrip.

This will return the minimum of roundtrips

pub fn max_roundtrips(&self) -> usize

Maximum of roundtrips

Definition of roundtrip: If a walker is in the leftest interval, then in the rightest and then in the leftest again (or the other way around) then this is counted as one roundtrip.

This will return the maximum of roundtrips

pub fn roundtrip_iter(&self) -> impl Iterator<Item = usize> + '_

Roundtrips

Definition of roundtrip: If a walker is in the leftest interval, then in the rightest and then in the leftest again (or the other way around) then this is counted as one roundtrip.

This will return an iterator over the roundtrips

pub fn largest_log_f(&self) -> f64

returns largest value of factor log_f present in the walkers

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

Log_f factors of the walkers

• the log_f’s will be reduced towards 0 during the simulation

pub fn set_log_f_threshold(
    &mut self,
    new_threshold: f64
) -> Result<f64, ThresholdErrors>

change the threshold of log_f

• it has to be a positive, normal number

pub fn is_finished(&self) -> bool

Is the simulation finished?

checks if all walkers have factors log_f that are below the threshold you chose

pub fn derivative_merged_log_prob_and_aligned(
    &self
) -> Result<ReplicaGlued<Hist>, HistErrors>where
    Hist: HistogramCombine + Histogram,

Results of the simulation

This is what we do the simulation for!

It uses derivative merging to give you a ReplicaGlued which you can use to write the data into a file. The derivative merged is explained in derivative_merged_log_prob_and_aligned

Notes

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

pub fn average_merged_log_probability_and_align(
    &self
) -> Result<ReplicaGlued<Hist>, HistErrors>where
    Hist: HistogramCombine + Histogram,

Results of the simulation

This is what we do the simulation for!

It uses average merging to give you a ReplicaGlued which you can use to write the data into a file. The average merged is explained in average_merged_and_aligned

Notes

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

pub fn get_id_vec(&self) -> Vec<usize>

Get Ids

This is an indicator that the replica exchange works. In the beginning, this will be a sorted vector, e.g. [0,1,2,3,4]. Then it will show, where the ensemble, which the corresponding walkers currently work with, originated from. E.g. If the vector is [3,1,0,2,4], Then walker 0 has a ensemble originating from walker 3, the walker 1 is back to its original ensemble, walker 2 has an ensemble originating form walker 0 and so on.

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

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

pub fn into_rees(self) -> Rees<(), Ensemble, R, Hist, Energy, S, Res>where
    Hist: Histogram,

Convert into Rees

This creates a Replica exchange entropic sampling simulation from this Replica exchange wang landau simulation

pub fn into_rees_with_extra<Extra>(
    self,
    extra: Vec<Extra>
) -> Result<Rees<Extra, Ensemble, R, Hist, Energy, S, Res>, (Self, Vec<Extra>)>where
    Hist: Histogram,

Convert into Rees

• similar to into_rees, though now we can store extra information. The extra information can be anything, e.g., files in which each walker should later write information every nth step or something else entirely.

important

• The vector extra must be exactly as long as the walker slice and each walker is assigned the corresponding entry from the vector extra
• You can look at the walker slice with the walkers method

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

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

Perform the Replica exchange wang landau simulation

• will simulate until all walkers have factors log_f that are below the threshold you chose

pub fn simulate_while<F, C>(&mut self, energy_fn: F, condition: C)where
    Ensemble: Send + Sync,
    R: Send + Sync,
    F: Fn(&mut Ensemble) -> Option<Energy> + Copy + Send + Sync,
    C: FnMut(&Self) -> bool,

Perform the Replica exchange wang landau simulation

• will simulate until all walkers have factors log_f that are below the threshold you chose or
• until condition returns false

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

Sanity check

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

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

Sweep

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