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

Trait Implementations

impl<R: Debug, M: Debug> Debug for QMC<R, M> where
    R: Rng,
    M: QMCManager, 

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

Formats the value using the given formatter.

impl<R, M> Into<QMC<R, M>> for QMCIsingGraph<R, M> where
    R: Rng,
    M: IsingManager + QMCManager, 

pub fn into(self) -> QMC<R, M>

Performs the conversion.

impl<R, M> QMCStepper for QMC<R, M> where
    R: Rng,
    M: QMCManager, 

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

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

pub fn get_n(&self) -> usize

Get the current number of operators in the graph

pub 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.

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

Get a reference to the state.

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

Take t qmc timesteps at beta.

pub 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.

pub 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.

pub 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.

pub 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.