Struct lattice_qcd_rs::simulation::monte_carlo::hybrid_monte_carlo::HybridMonteCarlo

pub struct HybridMonteCarlo<State, Rng, I, const D: usize>where
    State: LatticeState<D> + Clone + ?Sized,
    LatticeStateEFSyncDefault<State, D>: SimulationStateSynchronous<D>,
    I: SymplecticIntegrator<LatticeStateEFSyncDefault<State, D>, SimulationStateLeap<LatticeStateEFSyncDefault<State, D>, D>, D>,
    Rng: Rng,{ /* private fields */ }

Hybrid Monte Carlo algorithm (HCM for short).

The idea of HCM is to generate a random set on conjugate momenta to the link matrices. This conjugated momenta is also refed as the “Electric” field or e_field with distribution N(0, 1 / beta). And to solve the equation of motion. The new state is accepted with probability Exp( -H_old + H_new) where the Hamiltonian has an extra term Tr(E_i ^ 2). The advantage is that the simulation can be done in a symplectic way i.e. it conserved the Hamiltonian. Which means that the method has a high acceptance rate.

Example

See the the level module documentation.

Implementations

impl<State, Rng, I, const D: usize> HybridMonteCarlo<State, Rng, I, D>where State: LatticeState<D> + Clone + ?Sized, LatticeStateEFSyncDefault<State, D>: SimulationStateSynchronous<D>, I: SymplecticIntegrator<LatticeStateEFSyncDefault<State, D>, SimulationStateLeap<LatticeStateEFSyncDefault<State, D>, D>, D>, Rng: Rng,

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

Get a ref to the rng.

pub const fn integrator(&self) -> &I

Get the integrator.

pub fn integrator_mut(&mut self) -> &mut I

Get a mut ref to the integrator.

pub const fn delta_t(&self) -> Real

Get delta_t.

pub const fn number_of_steps(&self) -> usize

Get the number of steps.

pub const fn new( delta_t: Real, number_of_steps: usize, integrator: I, rng: Rng ) -> Self

gives the following parameter for the HCM :

• delta_t is the step size per integration of the equation of motion
• number_of_steps is the number of time
• integrator is the methods to solve the equation of motion
• rng, a random number generator

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

Get a mutable reference to the rng.

pub fn rng_owned(self) -> Rng

Get the last probably of acceptance of the random change.

Trait Implementations

impl<State, Rng, I, const D: usize> AsMut<Rng> for HybridMonteCarlo<State, Rng, I, D>where State: LatticeState<D> + Clone + ?Sized, LatticeStateEFSyncDefault<State, D>: SimulationStateSynchronous<D>, I: SymplecticIntegrator<LatticeStateEFSyncDefault<State, D>, SimulationStateLeap<LatticeStateEFSyncDefault<State, D>, D>, D>, Rng: Rng,

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

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

impl<State, Rng, I, const D: usize> AsRef<Rng> for HybridMonteCarlo<State, Rng, I, D>where State: LatticeState<D> + Clone + ?Sized, LatticeStateEFSyncDefault<State, D>: SimulationStateSynchronous<D>, I: SymplecticIntegrator<LatticeStateEFSyncDefault<State, D>, SimulationStateLeap<LatticeStateEFSyncDefault<State, D>, D>, D>, Rng: Rng,

fn as_ref(&self) -> &Rng

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

impl<State, Rng, I, const D: usize> Clone for HybridMonteCarlo<State, Rng, I, D>where State: LatticeState<D> + Clone + ?Sized + Clone, LatticeStateEFSyncDefault<State, D>: SimulationStateSynchronous<D>, I: SymplecticIntegrator<LatticeStateEFSyncDefault<State, D>, SimulationStateLeap<LatticeStateEFSyncDefault<State, D>, D>, D> + Clone, Rng: Rng + Clone,

fn clone(&self) -> HybridMonteCarlo<State, Rng, I, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<State, Rng, I, const D: usize> Debug for HybridMonteCarlo<State, Rng, I, D>where State: LatticeState<D> + Clone + ?Sized + Debug, LatticeStateEFSyncDefault<State, D>: SimulationStateSynchronous<D>, I: SymplecticIntegrator<LatticeStateEFSyncDefault<State, D>, SimulationStateLeap<LatticeStateEFSyncDefault<State, D>, D>, D> + Debug, Rng: Rng + Debug,

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

Formats the value using the given formatter.

impl<'de, State, Rng, I, const D: usize> Deserialize<'de> for HybridMonteCarlo<State, Rng, I, D>where State: LatticeState<D> + Clone + ?Sized + Deserialize<'de>, LatticeStateEFSyncDefault<State, D>: SimulationStateSynchronous<D>, I: SymplecticIntegrator<LatticeStateEFSyncDefault<State, D>, SimulationStateLeap<LatticeStateEFSyncDefault<State, D>, D>, D> + Deserialize<'de>, Rng: Rng + Deserialize<'de>,

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

Deserialize this value from the given Serde deserializer.

impl<State, Rng, I, const D: usize> MonteCarlo<State, D> for HybridMonteCarlo<State, Rng, I, D>where State: LatticeState<D> + Clone + ?Sized, LatticeStateEFSyncDefault<State, D>: SimulationStateSynchronous<D>, I: SymplecticIntegrator<LatticeStateEFSyncDefault<State, D>, SimulationStateLeap<LatticeStateEFSyncDefault<State, D>, D>, D>, Rng: Rng,

type Error = MultiIntegrationError<<I as SymplecticIntegrator<LatticeStateEFSyncDefault<State, D>, SimulationStateLeap<LatticeStateEFSyncDefault<State, D>, D>, D>>::Error>

Error returned while getting the next element.

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

Do one Monte Carlo simulation step.

impl<State, Rng, I, const D: usize> PartialEq<HybridMonteCarlo<State, Rng, I, D>> for HybridMonteCarlo<State, Rng, I, D>where State: LatticeState<D> + Clone + ?Sized + PartialEq, LatticeStateEFSyncDefault<State, D>: SimulationStateSynchronous<D>, I: SymplecticIntegrator<LatticeStateEFSyncDefault<State, D>, SimulationStateLeap<LatticeStateEFSyncDefault<State, D>, D>, D> + PartialEq, Rng: Rng + PartialEq,

fn eq(&self, other: &HybridMonteCarlo<State, Rng, I, D>) -> 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<State, Rng, I, const D: usize> Serialize for HybridMonteCarlo<State, Rng, I, D>where State: LatticeState<D> + Clone + ?Sized + Serialize, LatticeStateEFSyncDefault<State, D>: SimulationStateSynchronous<D>, I: SymplecticIntegrator<LatticeStateEFSyncDefault<State, D>, SimulationStateLeap<LatticeStateEFSyncDefault<State, D>, D>, D> + Serialize, Rng: Rng + Serialize,

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

Serialize this value into the given Serde serializer.

impl<State, Rng, I, const D: usize> StructuralPartialEq for HybridMonteCarlo<State, Rng, I, D>where State: LatticeState<D> + Clone + ?Sized, LatticeStateEFSyncDefault<State, D>: SimulationStateSynchronous<D>, I: SymplecticIntegrator<LatticeStateEFSyncDefault<State, D>, SimulationStateLeap<LatticeStateEFSyncDefault<State, D>, D>, D>, Rng: Rng,