Struct qmc::sse::qmc_ising::QmcIsingGraph

pub struct QmcIsingGraph<R: Rng, M: IsingManager> { /* fields omitted */ }

A container to run QMC simulations.

Implementations

impl<R: Rng, M: IsingManager> QmcIsingGraph<R, M>

pub fn new_with_rng_with_manager_hook<F, Rg: Rng>(
    edges: Vec<(Edge, f64)>,
    transverse: f64,
    longitudinal: f64,
    cutoff: usize,
    rng: Rg,
    state: Option<Vec<bool>>,
    f: F
) -> QmcIsingGraph<Rg, M> where
    F: Fn(usize, usize) -> M, 

Make a new QMC graph with an rng instance and a function to construct the op manager from the number of variables and number of interactions / bonds.

pub fn new_with_rng<Rg: Rng>(
    edges: Vec<(Edge, f64)>,
    transverse: f64,
    longitudinal: f64,
    cutoff: usize,
    rng: Rg,
    state: Option<Vec<bool>>
) -> QmcIsingGraph<Rg, M>

Make a new QMC graph with an rng instance.

pub fn new_from_graph<Rg: Rng>(
    graph: GraphState<Rg>,
    transverse: f64,
    longitudinal: f64,
    cutoff: usize
) -> QmcIsingGraph<Rg, M>

Make a new QMC graph with an rng instance.

pub fn make_haminfo(&self) -> HamInfo<'_>

Make the hamiltonian struct.

pub fn hamiltonian(
    info: &HamInfo<'_>,
    vars: &[usize],
    bond: usize,
    input_state: &[bool],
    output_state: &[bool]
) -> f64

Evaluate the hamiltonian using the HamInfo for the graph.

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

Take a single diagonal step.

pub fn single_cluster_step(&mut self) -> usize

Take a single cluster step and return the number of cluster found.

pub fn single_rvb_sweep(
    &mut self,
    updates_in_sweep: Option<usize>
) -> (usize, usize)

Perform a single rvb step and return the number of successes and attempts.

pub fn set_run_rvb(&mut self, run_rvb: bool)

Enable or disable automatic rvb steps. Errors if all js not equal magnitude.

pub fn set_enable_heatbath(&mut self, enable_heatbath: bool)

Enable heatbath diagonal updates.

pub fn print_debug(&self)

Print debug output.

pub fn state_mut(&mut self) -> &mut Vec<bool>

Get a mutable reference to the state at p=0 (can break integrity)

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

Clone the state at p=0.

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

Convert the state to a vector.

pub fn get_nvars(&self) -> usize

Get the number of variables in the graph.

pub fn get_edges(&self) -> &[(Vec<usize>, f64)]

Get the edges on the graph

pub fn get_transverse_field(&self) -> f64

Get the transverse field on the system.

pub fn get_longitudinal_field(&self) -> f64

Get the longitudinal field on the system.

pub fn get_cutoff(&self) -> usize

Get the cutoff used for qmc calculations (pmax).

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

Set the cutoff.

pub fn get_n(&self) -> usize

Get the number of ops in graph.

pub fn get_manager_ref(&self) -> &M

Get a reference to the op manager.

pub fn get_manager_mut(&mut self) -> &mut M

Get a mutable reference to the op manager.

pub fn get_offset(&self) -> f64

Get internal energy offset.

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 rvb_success_rate(&self) -> f64

Average rvb success rate.

Trait Implementations

impl<R, M> Clone for QmcIsingGraph<R, M> where
    R: Rng + Clone,
    M: IsingManager + 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 + Rng, M: Debug + IsingManager> Debug for QmcIsingGraph<R, M>

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> IntoQmc<R, M> for QmcIsingGraph<R, M> where
    R: Rng,
    M: IsingManager + QmcManager, 

fn into_qmc(self) -> Qmc<R, M>

Convert into QMC.

impl<R, M> QmcDebug for QmcIsingGraph<R, M> where
    R: Rng,
    M: IsingManager + DebugOps, 

type M = M

The type of the debuggable manager.

fn get_debug_manager(&self) -> &Self::M

The manager which can be debugged.

fn count_diagonal_and_off(&self) -> (usize, usize)

Count the number of diagonal and offdiagonal ops.

fn count_constant_ops(&self) -> usize

Count the number of constant ops.

impl<R, M> QmcStepper for QmcIsingGraph<R, M> where
    R: Rng,
    M: IsingManager, 

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

Perform a single step of qmc.

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

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

impl<R, M> Verify for QmcIsingGraph<R, M> where
    R: Rng,
    M: IsingManager, 

fn verify(&self) -> bool

Check integrity.