Struct qmc::sse::qmc_runner::Qmc

pub struct Qmc<R, M> where
    R: Rng,
    M: QmcManager,  { /* fields omitted */ }

A manager for QMC and interactions.

Implementations

impl<R: Rng, M: QmcManager> Qmc<R, M>

pub fn new(nvars: usize, rng: R, do_loop_updates: bool) -> Self

Make a new QMC instance with nvars.

pub fn new_with_state<I: Into<Vec<bool>>>(
    nvars: usize,
    rng: R,
    state: I,
    do_loop_updates: bool
) -> Self

Make a new QMC instance with nvars.

pub fn new_with_state_with_manager_hook<F, I: Into<Vec<bool>>>(
    nvars: usize,
    rng: R,
    state: I,
    do_loop_updates: bool,
    f: F
) -> Self where
    F: Fn(usize) -> M, 

Make a new QMC instance with nvars. Allows hooking into manager construction with f.

pub fn get_bonds(&self) -> &[Interaction]

Get interactions.

pub fn make_interaction<MAT: Into<Vec<f64>>, VAR: Into<Vec<usize>>>(
    &mut self,
    mat: MAT,
    vars: VAR
) -> Result<(), String>

Add an interaction to the QMC instance.

pub fn make_interaction_and_offset<MAT: Into<Vec<f64>>, VAR: Into<Vec<usize>>>(
    &mut self,
    mat: MAT,
    vars: VAR
) -> Result<(), String>

Add an interaction to the QMC instance, adjust with a diagonal offset.

pub fn make_diagonal_interaction<MAT: Into<Vec<f64>>, VAR: Into<Vec<usize>>>(
    &mut self,
    mat: MAT,
    vars: VAR
) -> Result<(), String>

Add an interaction to the QMC instance.

pub fn make_diagonal_interaction_and_offset<MAT: Into<Vec<f64>>, VAR: Into<Vec<usize>>>(
    &mut self,
    mat: MAT,
    vars: VAR
) -> Result<(), String>

Add an interaction to the QMC instance, adjust with a diagonal offset.

pub fn diagonal_update(&mut self, beta: f64)

Perform a single diagonal update.

pub fn loop_update(&mut self)

Perform a single loop update. Will be inefficient without XX terms.

pub fn cluster_update(&mut self) -> Result<(), &str>

Flip spins using quantum cluster updates if QMC has ising symmetry.

pub fn flip_free_bits(&mut self)

Flip spins using thermal fluctuations.

pub fn set_do_heatbath(&mut self, do_heatbath: bool)

Enable or disable the heatbath diagonal update.

pub fn should_do_heatbath(&self) -> bool

Should the model do heatbath diagonal updates.

pub fn set_do_loop_updates(&mut self, do_loop_updates: bool)

Change whether loop updates will be performed.

pub fn should_do_loop_update(&self) -> bool

Should the model do loop updates.

pub fn should_do_cluster_update(&self) -> bool

Should the model do cluster updates.

pub fn into_vec(self) -> Vec<bool>

Convert the state to a vector.

pub fn get_offset(&self) -> f64

Get the total energy offset.

pub fn get_manager_ref(&self) -> &M

Get a reference to the diagonal op manager.

pub fn get_cutoff(&self) -> usize

Get the cutoff.

pub fn set_cutoff(&mut self, cutoff: usize)

Set the cutoff to a new value

pub fn increase_cutoff_to(&mut self, cutoff: usize)

Set the cutoff to a new value so long as that new value is larger than the old one.

pub fn can_swap_managers(&self, other: &Self) -> Result<(), String>

Check if two instances can safely swap managers and initial states

pub fn swap_manager_and_state(&mut self, other: &mut Self)

Swap managers and initial states

pub fn clone_state(&self) -> Vec<bool>

Clone the state at p=0.

Trait Implementations

impl<R, M> Clone for Qmc<R, M> where
    R: Rng + Clone,
    M: QmcManager + Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug, M: Debug> Debug for Qmc<R, M> where
    R: Rng,
    M: QmcManager, 

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

Formats the value using the given formatter.

impl<R, M> From<QmcIsingGraph<R, M>> for Qmc<R, M> where
    R: Rng,
    M: IsingManager + QmcManager, 

fn from(g: QmcIsingGraph<R, M>) -> Self

Performs the conversion.

impl<R, M> QmcStepper for Qmc<R, M> where
    R: Rng,
    M: QmcManager, 

fn timestep(&mut self, beta: f64) -> &[bool]

Take a single QMC step and return a reference to the state

fn get_n(&self) -> usize

Get the current number of operators in the graph

fn get_energy_for_average_n(&self, average_n: f64, beta: f64) -> f64

Get the average energy given the average number of ops and beta.

fn state_ref(&self) -> &[bool]

Get a reference to the state.

fn get_bond_count(&self, bond: usize) -> usize

Get the number of a given bond

fn imaginary_time_fold<F, T>(&self, fold_fn: F, init: T) -> T where
    F: Fn(T, &[bool]) -> T, 

Fold through imaginary time states.

fn timesteps(&mut self, t: usize, beta: f64) -> f64

Take t qmc timesteps at beta.

fn timesteps_sample(
    &mut self,
    t: usize,
    beta: f64,
    sampling_freq: Option<usize>
) -> (Vec<Vec<bool>>, f64)

Take t qmc timesteps at beta and sample states.

fn timesteps_sample_iter<F>(
    &mut self,
    t: usize,
    beta: f64,
    sampling_freq: Option<usize>,
    iter_fn: F
) -> f64 where
    F: Fn(&[bool]), 

Take t qmc timesteps at beta and sample states, apply f to each.

fn timesteps_sample_iter_zip<F, I, T>(
    &mut self,
    t: usize,
    beta: f64,
    sampling_freq: Option<usize>,
    zip_with: I,
    iter_fn: F
) -> f64 where
    F: Fn(T, &[bool]),
    I: IntoIterator<Item = T>, 

Take t qmc timesteps at beta and sample states, apply f to each and the zipped iterator.

fn timesteps_measure<F, T>(
    &mut self,
    timesteps: usize,
    beta: f64,
    init_t: T,
    state_fold: F,
    sampling_freq: Option<usize>
) -> (T, f64) where
    F: Fn(T, &[bool]) -> T, 

Take t qmc timesteps at beta and sample states, fold across states and output results.

fn timesteps_iter_zip_with_self<F, I, T>(
    &mut self,
    t: usize,
    beta: f64,
    sampling_freq: Option<usize>,
    zip_with: I,
    iter_fn: F
) -> f64 where
    F: Fn(T, &Self),
    I: IntoIterator<Item = T>, 

Take t qmc timesteps at beta and sample states, apply f to each and the zipped iterator.

fn timesteps_measure_with_self<F, T>(
    &mut self,
    timesteps: usize,
    beta: f64,
    init_t: T,
    state_fold: F,
    sampling_freq: Option<usize>
) -> (T, f64) where
    F: Fn(T, &Self) -> T, 

Take t qmc timesteps at beta and sample states, fold across states and output results.