Struct net_ensembles::sampling::wang_landau::WangLandauAdaptive [−][src]
pub struct WangLandauAdaptive<Hist, R, E, S, Res, Energy> { /* fields omitted */ }
Expand description
Adaptive WangLandau 1/t
- please cite
Yannick Feld and Alexander K. Hartmann, “Large-deviations of the basin stability of power grids,” Chaos 29:113113 (2019), DOI 10.1063/1.5121415
as this adaptive approach was first used and described in this paper. Also cite the following
- The 1/t Wang Landau approach comes from this paper
R. E. Belardinelli and V. D. Pereyra, Fast algorithm to calculate density of states,” Phys. Rev. E 75: 046701 (2007), DOI 10.1103/PhysRevE.75.046701
- The original Wang Landau algorithim comes from this paper
F. Wang and D. P. Landau, “Efficient, multiple-range random walk algorithm to calculate the density of states,” Phys. Rev. Lett. 86, 2050–2053 (2001), DOI 10.1103/PhysRevLett.86.2050
Implementations
impl<Hist, R, E, S, Res, Energy> WangLandauAdaptive<Hist, R, E, S, Res, Energy> where
Hist: Histogram + HistogramVal<Energy>,
impl<Hist, R, E, S, Res, Energy> WangLandauAdaptive<Hist, R, E, S, Res, Energy> where
Hist: Histogram + HistogramVal<Energy>,
Check if self
is initialized
- if this returns true, you can begin the WangLandau simulation
- otherwise call one of the
self.init*
methods
Is the simulation in the process of rebuilding the statistics, i.e., is it currently trying many differnt step sizes?
Is the simulation has finished the process of rebuilding the statistics, i.e., is it currently not trying many differnt step sizes
Tracks progress
- tracks progress until
self.is_rebuilding_statistics
becomes false - returned value is always
0 <= val <= 1.0
Fraction of steps accepted since the statistics were reset the last time
- (steps accepted since last reset) / (steps since last reset)
Estimate accept/reject statistics
- contains list of estimated probabilities for accepting a step of corresponding step size
- list[i] corresponds to step size
i + self.min_step
- O(trial_step_max - trial_step_min)
impl<R, E, S, Res, Hist, Energy> WangLandauAdaptive<Hist, R, E, S, Res, Energy> where
R: Rng,
E: MarkovChain<S, Res>,
Hist: Histogram + HistogramVal<Energy>,
Energy: Clone,
impl<R, E, S, Res, Hist, Energy> WangLandauAdaptive<Hist, R, E, S, Res, Energy> where
R: Rng,
E: MarkovChain<S, Res>,
Hist: Histogram + HistogramVal<Energy>,
Energy: Clone,
New WangLandauAdaptive
log_f_threshold
- threshold for the simulationensemble
ensemble used for the simulationrng
- random number generator usedsamples_per_trial
- how often a specific step_size should be tried before estimating the fraction of accepted steps resulting from the stepsizetrial_step_min
andtrial_step_max
: The step sizes tried are: [trial_step_min, trial_step_min + 1, …, trial_step_max]min_best_of_count
: After estimating, use at least the bestmin_best_of_count
step sizes foundbest_of_threshold
: After estimating, use all steps for which abs(acceptance_rate -0.5) <= best_of_threshold holds truehistogram
: How your energy will be binned etccheck_refine_every
: how often to check if log_f can be refined?
Important
- **You need to call on of the
self.init*
members before starting the Wang Landau simulation! - you can check withself.is_initialized()
- Err if
trial_step_max < trial_step_min
- Err if
log_f_threshold <= 0.0
pub fn init_mixed_heuristik<F, U>(
&mut self,
overlap: NonZeroUsize,
mid: U,
energy_fn: F,
step_limit: Option<u64>
) -> Result<(), WangLandauErrors> where
F: Fn(&mut E) -> Option<Energy>,
U: One + Bounded + WrappingAdd + Eq + PartialOrd<U>,
Hist: HistogramIntervalDistance<Energy>,
pub fn init_mixed_heuristik<F, U>(
&mut self,
overlap: NonZeroUsize,
mid: U,
energy_fn: F,
step_limit: Option<u64>
) -> Result<(), WangLandauErrors> where
F: Fn(&mut E) -> Option<Energy>,
U: One + Bounded + WrappingAdd + Eq + PartialOrd<U>,
Hist: HistogramIntervalDistance<Energy>,
Find a valid starting Point
- if the ensemble is already at a valid starting point, the ensemble is left unchanged (as long as your energy calculation does not change the ensemble)
overlap
- see trait HistogramIntervalDistance. Should smaller than the number of bins in your histogram. E.g.overlap = 3
if you have 200 binsmid
- should be something like128u8
,0i8
or0i16
. It is very unlikely that using a type with more than 16 bit makes sense for midstep_limit
: Some(val) -> val is max number of steps tried, if no valid state is found, it will return an Error. None -> will loop until either a valid state is found or forever- alternates between greedy and interval heuristik everytime a wrapping counter passes
mid
orU::min_value()
- I recommend using this heuristik, if you do not know which one to use
Parameter
energy_fn
function calculatingSome(energy)
of the system or rather the Parameter of which you wish to obtain the probability distribution. Has to be the same function as used for the wang landau simulation later. If there are any states, for which the calculation is invalid,None
should be returned- steps resulting in ensembles for which
energy_fn(&mut ensemble)
isNone
will always be rejected
pub fn init_interval_heuristik<F>(
&mut self,
overlap: NonZeroUsize,
energy_fn: F,
step_limit: Option<u64>
) -> Result<(), WangLandauErrors> where
F: Fn(&mut E) -> Option<Energy>,
Hist: HistogramIntervalDistance<Energy>,
pub fn init_interval_heuristik<F>(
&mut self,
overlap: NonZeroUsize,
energy_fn: F,
step_limit: Option<u64>
) -> Result<(), WangLandauErrors> where
F: Fn(&mut E) -> Option<Energy>,
Hist: HistogramIntervalDistance<Energy>,
Find a valid starting Point
- if the ensemble is already at a valid starting point, the ensemble is left unchanged (as long as your energy calculation does not change the ensemble)
- Uses overlapping intervals. Accepts a step, if the resulting ensemble is in the same interval as before, or it is in an interval closer to the target interval
Parameter
step_limit
: Some(val) -> val is max number of steps tried, if no valid state is found, it will return an Error. None -> will loop until either a valid state is found or foreverenergy_fn
function calculatingSome(energy)
of the system or rather the Parameter of which you wish to obtain the probability distribution. Has to be the same function as used for the wang landau simulation later. If there are any states, for which the calculation is invalid,None
should be returned- steps resulting in ensembles for which
energy_fn(&mut ensemble)
isNone
will always be rejected
pub fn init_greedy_heuristic<F>(
&mut self,
energy_fn: F,
step_limit: Option<u64>
) -> Result<(), WangLandauErrors> where
F: Fn(&mut E) -> Option<Energy>,
pub fn init_greedy_heuristic<F>(
&mut self,
energy_fn: F,
step_limit: Option<u64>
) -> Result<(), WangLandauErrors> where
F: Fn(&mut E) -> Option<Energy>,
Find a valid starting Point
- if the ensemble is already at a valid starting point, the ensemble is left unchanged (as long as your energy calculation does not change the ensemble)
- Uses a greedy heuristik. Performs markov steps. If that brought us closer to the target interval, the step is accepted. Otherwise it is rejected
Parameter
step_limit
: Some(val) -> val is max number of steps tried, if no valid state is found, it will return an Error. None -> will loop until either a valid state is found or foreverenergy_fn
function calculatingSome(energy)
of the system or rather the Parameter of which you wish to obtain the probability distribution. Has to be the same function as used for the wang landau simulation later. If there are any states, for which the calculation is invalid,None
should be returned- steps resulting in ensembles for which
energy_fn(&mut ensemble)
isNone
will always be rejected
pub fn wang_landau_while<F, W>(&mut self, energy_fn: F, condition: W) where
F: Fn(&E) -> Option<Energy>,
W: FnMut(&WangLandauAdaptive<Hist, R, E, S, Res, Energy>) -> bool,
pub fn wang_landau_while<F, W>(&mut self, energy_fn: F, condition: W) where
F: Fn(&E) -> Option<Energy>,
W: FnMut(&WangLandauAdaptive<Hist, R, E, S, Res, Energy>) -> bool,
Wang Landau
- perform Wang Landau simulation
- calls
self.wang_landau_step(energy_fn)
untilself.is_finished()
orcondition(&self)
is false
Important
- You have to call one of the
self.init*
functions before calling this one - you can check withself.is_initialized()
- will panic otherwise, at least in debug mode
pub fn wang_landau_while_acc<F, W>(&mut self, energy_fn: F, condition: W) where
F: FnMut(&E, &S, &mut Energy),
W: FnMut(&WangLandauAdaptive<Hist, R, E, S, Res, Energy>) -> bool,
pub fn wang_landau_while_acc<F, W>(&mut self, energy_fn: F, condition: W) where
F: FnMut(&E, &S, &mut Energy),
W: FnMut(&WangLandauAdaptive<Hist, R, E, S, Res, Energy>) -> bool,
Wang Landau Simulation
- similar to
wang_landau_while
Difference
uses accumulating markov steps, i.e., it updates the Energy during the markov steps.
This can be more efficient. Therefore the energy_fn
now gets the state of the ensemble
after the markov step &E
, the step that was performed &S
as well as a mutable
reference to the old Energy &mut Energy
which is to change
pub unsafe fn wang_landau_while_unsafe<F, W>(
&mut self,
energy_fn: F,
condition: W
) where
F: FnMut(&mut E) -> Option<Energy>,
W: FnMut(&WangLandauAdaptive<Hist, R, E, S, Res, Energy>) -> bool,
pub unsafe fn wang_landau_while_unsafe<F, W>(
&mut self,
energy_fn: F,
condition: W
) where
F: FnMut(&mut E) -> Option<Energy>,
W: FnMut(&WangLandauAdaptive<Hist, R, E, S, Res, Energy>) -> bool,
Wang Landau
- if possible, use
self.wang_landau_while()
instead - it is safer - You have mutable access to your ensemble, which is why this function is unsafe. If you do anything, which changes the future outcome of the energy function, the results will be wrong!
- perform Wang Landau simulation
- calls
self.wang_landau_step(energy_fn)
untilself.is_finished()
orcondition(&self)
is false
Important
- You have to call one of the
self.init*
functions before calling this one - you can check withself.is_initialized()
- will panic otherwise, at least in debug mode
Wang Landau
- perform Wang Landau simulation
- calls
self.wang_landau_step(energy_fn, valid_ensemble)
untilself.is_finished()
Important
- You have to call one of the
self.init*
functions before calling this one - you can check withself.is_initialized()
- will panic otherwise, at least in debug mode
Wang Landau simulation
- similar to
wang_landau_convergence
Difference
uses accumulating markov steps, i.e., it updates the Energy during the markov steps.
This can be more efficient. Therefore the energy_fn
now gets the state of the ensemble
after the markov step &E
, the step that was performed &S
as well as a mutable
reference to the old Energy &mut Energy
which is to change
pub unsafe fn wang_landau_convergence_unsafe<F>(&mut self, energy_fn: F) where
F: FnMut(&mut E) -> Option<Energy>,
pub unsafe fn wang_landau_convergence_unsafe<F>(&mut self, energy_fn: F) where
F: FnMut(&mut E) -> Option<Energy>,
Wang Landau
- if possible, use
self.wang_landau_convergence()
instead - it is safer - You have mutable access to your ensemble, which is why this function is unsafe. If you do anything, which changes the future outcome of the energy function, the results will be wrong!
- perform Wang Landau simulation
- calls
self.wang_landau_step_unsafe(energy_fn, valid_ensemble)
untilself.is_finished()
Important
- You have to call one of the
self.init*
functions before calling this one - you can check withself.is_initialized()
- will panic otherwise, at least in debug mode
Wang Landau Step
- performs a single Wang Landau step
Parameter
energy_fn
function calculatingSome(energy)
of the system or rather the Parameter of which you wish to obtain the probability distribution. If there are any states, for which the calculation is invalid,None
should be returned- steps resulting in ensembles for which
energy_fn(&mut ensemble)
isNone
will always be rejected
Important
- You have to call one of the
self.init*
functions before calling this one - you can check withself.is_initialized()
- will panic otherwise, at least in debug mode
pub unsafe fn wang_landau_step_unsafe<F>(&mut self, energy_fn: F) where
F: FnMut(&mut E) -> Option<Energy>,
pub unsafe fn wang_landau_step_unsafe<F>(&mut self, energy_fn: F) where
F: FnMut(&mut E) -> Option<Energy>,
Wang Landau Step
- if possible, use
self.wang_landau_step()
instead - it is safer - unsafe, because you have to make sure, that the
energy_fn
function does not change the state of the ensemble in such a way, that the result ofenergy_fn
changes when called again. Maybe do cleanup at the beginning of the energy function? - performs a single Wang Landau step
Parameter
energy_fn
function calculatingSome(energy)
of the system or rather the Parameter of which you wish to obtain the probability distribution. If there are any states, for which the calculation is invalid,None
should be returned- steps resulting in ensembles for which
energy_fn(&mut ensemble)
isNone
will always be rejected
Important
- You have to call one of the
self.init*
functions before calling this one - you can check withself.is_initialized()
- will panic otherwise, at least in debug mode
Accumulating wang landau step
- similar to
wang_landau_step
Difference
- this uses accumulating markov steps, i.e., it calculates the Energy during each markov step, which can be more efficient. This assumes, that cloning the Energy is cheap, which is true for primitive types like usize or f64
- parameter of
energy_fn
:&E
Ensemble after the markov step&S
was performed.&mut Energy
is the old energy, which has to be changed to the new energy of the sytem
Trait Implementations
impl<'de, Hist, R, E, S, Res, Energy> Deserialize<'de> for WangLandauAdaptive<Hist, R, E, S, Res, Energy> where
R: Deserialize<'de>,
S: Deserialize<'de>,
E: Deserialize<'de>,
Hist: Deserialize<'de>,
Energy: Deserialize<'de>,
impl<'de, Hist, R, E, S, Res, Energy> Deserialize<'de> for WangLandauAdaptive<Hist, R, E, S, Res, Energy> where
R: Deserialize<'de>,
S: Deserialize<'de>,
E: Deserialize<'de>,
Hist: Deserialize<'de>,
Energy: Deserialize<'de>,
pub fn deserialize<__D>(
__deserializer: __D
) -> Result<WangLandauAdaptive<Hist, R, E, S, Res, Energy>, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
pub fn deserialize<__D>(
__deserializer: __D
) -> Result<WangLandauAdaptive<Hist, R, E, S, Res, Energy>, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
pub fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer,
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. Read more
impl<Hist, R, E, S, Res, T> TryFrom<WangLandauAdaptive<Hist, R, E, S, Res, T>> for EntropicSamplingAdaptive<Hist, R, E, S, Res, T> where
R: Rng,
Hist: Histogram,
impl<Hist, R, E, S, Res, T> TryFrom<WangLandauAdaptive<Hist, R, E, S, Res, T>> for EntropicSamplingAdaptive<Hist, R, E, S, Res, T> where
R: Rng,
Hist: Histogram,
type Error = EntropicErrors
type Error = EntropicErrors
The type returned in the event of a conversion error.
pub fn try_from(
wl: WangLandauAdaptive<Hist, R, E, S, Res, T>
) -> Result<EntropicSamplingAdaptive<Hist, R, E, S, Res, T>, <EntropicSamplingAdaptive<Hist, R, E, S, Res, T> as TryFrom<WangLandauAdaptive<Hist, R, E, S, Res, T>>>::Error>
pub fn try_from(
wl: WangLandauAdaptive<Hist, R, E, S, Res, T>
) -> Result<EntropicSamplingAdaptive<Hist, R, E, S, Res, T>, <EntropicSamplingAdaptive<Hist, R, E, S, Res, T> as TryFrom<WangLandauAdaptive<Hist, R, E, S, Res, T>>>::Error>
Performs the conversion.
impl<Hist, R, E, S, Res, T> TryFrom<WangLandauAdaptive<Hist, R, E, S, Res, T>> for EntropicSampling<Hist, R, E, S, Res, T> where
R: Rng,
Hist: Histogram,
impl<Hist, R, E, S, Res, T> TryFrom<WangLandauAdaptive<Hist, R, E, S, Res, T>> for EntropicSampling<Hist, R, E, S, Res, T> where
R: Rng,
Hist: Histogram,
pub fn try_from(
wl: WangLandauAdaptive<Hist, R, E, S, Res, T>
) -> Result<EntropicSampling<Hist, R, E, S, Res, T>, <EntropicSampling<Hist, R, E, S, Res, T> as TryFrom<WangLandauAdaptive<Hist, R, E, S, Res, T>>>::Error>
pub fn try_from(
wl: WangLandauAdaptive<Hist, R, E, S, Res, T>
) -> Result<EntropicSampling<Hist, R, E, S, Res, T>, <EntropicSampling<Hist, R, E, S, Res, T> as TryFrom<WangLandauAdaptive<Hist, R, E, S, Res, T>>>::Error>
Uses as stepsize: first entry of bestof. If bestof is empty, it uses
wl.min_step_size() + (wl.max_step_size() - wl.max_step_size()) / 2
type Error = EntropicErrors
type Error = EntropicErrors
The type returned in the event of a conversion error.
How many steps were accepted until now? Read more
How many steps were rejected until now? Read more
returns currently set threshold for log_f
Try to set the threshold. Read more
Current (non normalized) estimate of ln(P(E)) Read more
Returns current wang landau mode Read more
Counter Read more
Writes Information about the simulation to a file. E.g. How many steps were performed. Read more
Checks wang landau threshold Read more
Current (non normalized) estimate of log10(P(E)) Read more
Current (non normalized) estimate of log_base(P(E)) Read more
Counter Read more
Calculate, which fraction of steps were accepted Read more
Calculate, which fraction of steps were rejected Read more
impl<R, E, S, Res, Hist, Energy> WangLandauEnergy<Energy> for WangLandauAdaptive<Hist, R, E, S, Res, Energy>
impl<R, E, S, Res, Hist, Energy> WangLandauEnergy<Energy> for WangLandauAdaptive<Hist, R, E, S, Res, Energy>
impl<R, E, S, Res, Hist, T> WangLandauEnsemble<E> for WangLandauAdaptive<Hist, R, E, S, Res, T>
impl<R, E, S, Res, Hist, T> WangLandauEnsemble<E> for WangLandauAdaptive<Hist, R, E, S, Res, T>
impl<R, E, S, Res, Hist, Energy> WangLandauHist<Hist> for WangLandauAdaptive<Hist, R, E, S, Res, Energy>
impl<R, E, S, Res, Hist, Energy> WangLandauHist<Hist> for WangLandauAdaptive<Hist, R, E, S, Res, Energy>
Auto Trait Implementations
impl<Hist, R, E, S, Res, Energy> RefUnwindSafe for WangLandauAdaptive<Hist, R, E, S, Res, Energy> where
E: RefUnwindSafe,
Energy: RefUnwindSafe,
Hist: RefUnwindSafe,
R: RefUnwindSafe,
Res: RefUnwindSafe,
S: RefUnwindSafe,
impl<Hist, R, E, S, Res, Energy> Send for WangLandauAdaptive<Hist, R, E, S, Res, Energy> where
E: Send,
Energy: Send,
Hist: Send,
R: Send,
Res: Send,
S: Send,
impl<Hist, R, E, S, Res, Energy> Sync for WangLandauAdaptive<Hist, R, E, S, Res, Energy> where
E: Sync,
Energy: Sync,
Hist: Sync,
R: Sync,
Res: Sync,
S: Sync,
impl<Hist, R, E, S, Res, Energy> Unpin for WangLandauAdaptive<Hist, R, E, S, Res, Energy> where
E: Unpin,
Energy: Unpin,
Hist: Unpin,
R: Unpin,
Res: Unpin,
S: Unpin,
impl<Hist, R, E, S, Res, Energy> UnwindSafe for WangLandauAdaptive<Hist, R, E, S, Res, Energy> where
E: UnwindSafe,
Energy: UnwindSafe,
Hist: UnwindSafe,
R: UnwindSafe,
Res: UnwindSafe,
S: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more
pub fn cast_trunc(self) -> T
pub fn cast_trunc(self) -> T
Cast to integer, truncating Read more
pub fn cast_nearest(self) -> T
pub fn cast_nearest(self) -> T
Cast to the nearest integer Read more
pub fn cast_floor(self) -> T
pub fn cast_floor(self) -> T
Cast the floor to an integer Read more
pub fn try_cast_trunc(self) -> Result<T, Error>
pub fn try_cast_trunc(self) -> Result<T, Error>
Try converting to integer with truncation Read more
pub fn try_cast_nearest(self) -> Result<T, Error>
pub fn try_cast_nearest(self) -> Result<T, Error>
Try converting to the nearest integer Read more
pub fn try_cast_floor(self) -> Result<T, Error>
pub fn try_cast_floor(self) -> Result<T, Error>
Try converting the floor to an integer Read more
pub fn try_cast_ceil(self) -> Result<T, Error>
pub fn try_cast_ceil(self) -> Result<T, Error>
Try convert the ceiling to an integer Read more