Struct LatticeStateDefault 

pub struct LatticeStateDefault<const D: usize> { /* private fields */ }

Represent a simulation state at a set time.

It has the default pure gauge hamiltonian

Implementations

impl<const D: usize> LatticeStateDefault<D>

pub fn new_cold( size: Real, beta: Real, number_of_points: usize, ) -> Result<Self, StateInitializationError>

Create a cold configuration. i.e. all the links are set to the unit matrix.

With the lattice of size size and dimension number_of_points ( see LatticeCyclic::new ) and beta parameter beta.

Errors

Returns StateInitializationError::LatticeInitializationError if the parameter is invalid for LatticeCyclic. Or propagate the error form Self::new.

pub fn new_determinist( size: Real, beta: Real, number_of_points: usize, rng: &mut impl Rng, ) -> Result<Self, StateInitializationError>

Create a “hot” configuration, i.e. the link matrices are chosen randomly.

With the lattice of size size and dimension number_of_points ( see LatticeCyclic::new ) and beta parameter beta.

The creation is determinists meaning that it is reproducible:

Errors

Returns StateInitializationError::LatticeInitializationError if the parameter is invalid for LatticeCyclic. Or propagate the error form Self::new.

Example

This example demonstrate how to reproduce the same configuration

use rand::{rngs::StdRng, SeedableRng};

let mut rng_1 = StdRng::seed_from_u64(0);
let mut rng_2 = StdRng::seed_from_u64(0);
// They have the same seed and should generate the same numbers
assert_eq!(
    LatticeStateDefault::<4>::new_determinist(1_f64, 1_f64, 4, &mut rng_1).unwrap(),
    LatticeStateDefault::<4>::new_determinist(1_f64, 1_f64, 4, &mut rng_2).unwrap()
);

pub fn normalize_link_matrices(&mut self)

Correct the numerical drift, reprojecting all the link matrices to SU(3). see LinkMatrix::normalize.

Example

use lattice_qcd_rs::error::ImplementationError;
use lattice_qcd_rs::prelude::*;
use rand::SeedableRng;

let mut rng = rand::rngs::StdRng::seed_from_u64(0); // change with your seed

let size = 1_f64;
let number_of_pts = 3;
let beta = 1_f64;

let mut simulation =
    LatticeStateDefault::<4>::new_determinist(size, beta, number_of_pts, &mut rng)?;

let spread_parameter = 0.1_f64;
let mut mc = MetropolisHastingsSweep::new(1, spread_parameter, rng)
    .ok_or(ImplementationError::OptionWithUnexpectedNone)?;

for _ in 0..2 {
    for _ in 0..10 {
        simulation = simulation.monte_carlo_step(&mut mc)?;
    }
    // the more we advance te more the link matrices
    // will deviate form SU(3), so we reproject to SU(3)
    // every 10 steps.
    simulation.normalize_link_matrices();
}

pub fn link_mut( &mut self, link: &LatticeLinkCanonical<D>, ) -> Option<&mut CMatrix3>

Get a mutable reference to the link matrix at link

pub fn link_matrix_owned(self) -> LinkMatrix

Absorbs self anf return the link_matrix as owned

Trait Implementations

impl<const D: usize> Clone for LatticeStateDefault<D>

fn clone(&self) -> LatticeStateDefault<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const D: usize> Debug for LatticeStateDefault<D>

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

Formats the value using the given formatter.

impl<'de, const D: usize> Deserialize<'de> for LatticeStateDefault<D>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const D: usize> LatticeState<D> for LatticeStateDefault<D>

fn link_matrix(&self) -> &LinkMatrix

The link matrices of this state.

fn set_link_matrix(&mut self, link_matrix: LinkMatrix)

Panic

Panic if the length of link_matrix is different from lattice.get_number_of_canonical_links_space()

fn hamiltonian_links(&self) -> Real

Get the default pure gauge Hamiltonian.

Panic

Panic if plaquettes cannot be found

const CA: Real = 3f64

C_A constant of the model, usually it is 3.

fn lattice(&self) -> &LatticeCyclic<D>

Get the lattice into which the state exists.

fn beta(&self) -> Real

Returns the beta parameter of the states.

fn monte_carlo_step<M>(self, m: &mut M) -> Result<Self, M::Error>

where Self: Sized, M: MonteCarlo<Self, D> + ?Sized,

Do one monte carlo step with the given method.

fn average_trace_plaquette(&self) -> Option<Complex>

Take the average of the trace of all plaquettes.

impl<const D: usize> LatticeStateNew<D> for LatticeStateDefault<D>

type Error = StateInitializationError

Error type

fn new( lattice: LatticeCyclic<D>, beta: Real, link_matrix: LinkMatrix, ) -> Result<Self, Self::Error>

Create a new simulation state.

impl<Rng, const D: usize> MonteCarlo<LatticeStateDefault<D>, D> for HeatBathSweep<Rng>

where Rng: Rng,

type Error = Never

Error returned while getting the next element.

fn next_element( &mut self, state: LatticeStateDefault<D>, ) -> Result<LatticeStateDefault<D>, Self::Error>

Do one Monte Carlo simulation step.

impl<Rng, const D: usize> MonteCarlo<LatticeStateDefault<D>, D> for MetropolisHastingsDeltaDiagnostic<Rng>

where Rng: Rng,

type Error = Never

Error returned while getting the next element.

fn next_element( &mut self, state: LatticeStateDefault<D>, ) -> Result<LatticeStateDefault<D>, Self::Error>

Do one Monte Carlo simulation step.

impl<Rng, const D: usize> MonteCarlo<LatticeStateDefault<D>, D> for MetropolisHastingsSweep<Rng>

where Rng: Rng,

type Error = Never

Error returned while getting the next element.

fn next_element( &mut self, state: LatticeStateDefault<D>, ) -> Result<LatticeStateDefault<D>, Self::Error>

Do one Monte Carlo simulation step.

impl<const D: usize> MonteCarlo<LatticeStateDefault<D>, D> for OverrelaxationSweepReverse

type Error = Never

Error returned while getting the next element.

fn next_element( &mut self, state: LatticeStateDefault<D>, ) -> Result<LatticeStateDefault<D>, Self::Error>

Do one Monte Carlo simulation step.

impl<const D: usize> MonteCarlo<LatticeStateDefault<D>, D> for OverrelaxationSweepRotation

type Error = Never

Error returned while getting the next element.

fn next_element( &mut self, state: LatticeStateDefault<D>, ) -> Result<LatticeStateDefault<D>, Self::Error>

Do one Monte Carlo simulation step.

impl<const D: usize> PartialEq for LatticeStateDefault<D>

fn eq(&self, other: &LatticeStateDefault<D>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const D: usize> Serialize for LatticeStateDefault<D>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const D: usize> StructuralPartialEq for LatticeStateDefault<D>