Struct lattice_qcd_rs::simulation::monte_carlo::heat_bath::HeatBathSweep

pub struct HeatBathSweep<Rng: Rng> { /* private fields */ }

Pseudo heat bath algorithm

Example

use lattice_qcd_rs::simulation::{HeatBathSweep, LatticeState, LatticeStateDefault};
use rand::SeedableRng;

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

let mut state = LatticeStateDefault::<3>::new_cold(1_f64, 6_f64, 4)?;
for _ in 0..2 {
    state = state.monte_carlo_step(&mut heat_bath)?;
    // operation to track the progress or the evolution
}
// operation at the end of the simulation

Implementations

impl<Rng: Rng> HeatBathSweep<Rng>

pub const fn new(rng: Rng) -> Self

Create a new Self form a rng.

pub fn rng_owned(self) -> Rng

Absorbed self and return the RNG as owned. It essentially deconstruct the structure.

pub fn rng_mut(&mut self) -> &mut Rng

Get a mutable reference to the rng.

pub const fn rng(&self) -> &Rng

Get a reference to the rng.

Trait Implementations

impl<Rng: Rng> AsMut<Rng> for HeatBathSweep<Rng>

fn as_mut(&mut self) -> &mut Rng

Converts this type into a mutable reference of the (usually inferred) input type.

impl<Rng: Rng> AsRef<Rng> for HeatBathSweep<Rng>

fn as_ref(&self) -> &Rng

Converts this type into a shared reference of the (usually inferred) input type.

impl<Rng: Clone + Rng> Clone for HeatBathSweep<Rng>

fn clone(&self) -> HeatBathSweep<Rng>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Rng: Debug + Rng> Debug for HeatBathSweep<Rng>

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

Formats the value using the given formatter.

impl<Rng: Rng + Default> Default for HeatBathSweep<Rng>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, Rng> Deserialize<'de> for HeatBathSweep<Rng>where Rng: Deserialize<'de> + Rng,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Rng: Hash + Rng> Hash for HeatBathSweep<Rng>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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: PartialEq + Rng> PartialEq<HeatBathSweep<Rng>> for HeatBathSweep<Rng>

fn eq(&self, other: &HeatBathSweep<Rng>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<Rng> Serialize for HeatBathSweep<Rng>where Rng: Serialize + Rng,

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

Serialize this value into the given Serde serializer.

impl<Rng: Eq + Rng> Eq for HeatBathSweep<Rng>

impl<Rng: Rng> StructuralEq for HeatBathSweep<Rng>

impl<Rng: Rng> StructuralPartialEq for HeatBathSweep<Rng>