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<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,
    transverse: f64,
    longitudinal: f64,
    cutoff: usize,
    rng: Rg
) -> 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_offdiagonal_step(&mut self)

Take a single offdiagonal step.

pub fn single_rvb_step(&mut self) -> Result<(), String>

Perform a single rvb step.

pub fn set_run_rvb(&mut self, run_rvb: bool) -> Result<(), String>

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, 

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug + Rng, M: Debug + IsingManager> Debug for QMCIsingGraph<R, M>

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> IntoQMC<R, M> for QMCIsingGraph<R, M> where
    R: Rng,
    M: IsingManager + QMCManager, 

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

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

The manager which can be debugged.

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

Count the number of diagonal and offdiagonal ops.

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

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

Perform a single step of qmc.

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

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

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

pub fn verify(&self) -> bool

Check integrity.