Struct qmc::sse::qmc_ising::QMCIsingGraph

pub struct QMCIsingGraph<R: Rng, M: OpContainerConstructor + ClassicalLoopUpdater + Into<L>, L: ClusterUpdater + Into<M>> { /* fields omitted */ }

A container to run QMC simulations.

Implementations

impl<R: Rng, M: OpContainerConstructor + ClassicalLoopUpdater + Into<L>, L: ClusterUpdater + Into<M>> QMCIsingGraph<R, M, L>

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

Make a new QMC graph with an rng instance.

pub fn new_from_graph<Rg: Rng>(
    graph: GraphState,
    transverse: f64,
    cutoff: usize,
    rng: Rg
) -> QMCIsingGraph<Rg, M, L>

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_semiclassical_step(&mut self)

Perform a single semiclassical step.

pub fn set_run_semiclassical(&mut self, run_semiclassical: bool)

Enable or disable automatic semiclassical steps.

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_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) -> bool

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 into_qmc(self) -> QMC<R, M, L>

Convert to a generic QMC instance.

Trait Implementations

impl<R, M, L> Clone for QMCIsingGraph<R, M, L> where
    R: Rng + Clone,
    M: OpContainerConstructor + ClassicalLoopUpdater + Into<L> + Clone,
    L: ClusterUpdater + Into<M> + 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 + OpContainerConstructor + ClassicalLoopUpdater + Into<L>, L: Debug + ClusterUpdater + Into<M>> Debug for QMCIsingGraph<R, M, L>

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

Formats the value using the given formatter.

impl<R, M, L> Into<QMC<R, M, L>> for QMCIsingGraph<R, M, L> where
    R: Rng,
    M: OpContainerConstructor + ClassicalLoopUpdater + Into<L>,
    L: ClusterUpdater + Into<M>, 

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

Performs the conversion.

impl<R, M, L> QMCStepper for QMCIsingGraph<R, M, L> where
    R: Rng,
    M: OpContainerConstructor + ClassicalLoopUpdater + Into<L>,
    L: ClusterUpdater + Into<M>, 

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 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: Iterator<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.

impl<R, M, L> Verify for QMCIsingGraph<R, M, L> where
    R: Rng,
    M: OpContainerConstructor + ClassicalLoopUpdater + Into<L>,
    L: ClusterUpdater + Into<M>, 

fn verify(&self) -> bool

Check integrity.