Struct SimulationStateLeap 

pub struct SimulationStateLeap<State, const D: usize>
where
    State: SimulationStateSynchronous<D> + ?Sized,
{ /* private fields */ }

wrapper for a simulation state using leap frog (SimulationStateLeap) using a synchronous type (SimulationStateSynchronous).

Implementations

impl<State, const D: usize> SimulationStateLeap<State, D>

where State: SimulationStateSynchronous<D> + LatticeStateWithEField<D> + ?Sized,

pub const fn state(&self) -> &State

get a reference to the state

pub const fn new_from_state(state: State) -> Self

Create a new SimulationStateLeap directly from a state without applying any modification.

In most cases wou will prefer to build it using LatticeStateNew or Self::from_synchronous.

pub fn state_mut(&mut self) -> &mut State

get a mutable reference to the state

pub fn from_synchronous<I>( s: &State, integrator: &I, delta_t: Real, ) -> Result<Self, I::Error>

where I: SymplecticIntegrator<State, Self, D> + ?Sized,

Create a leap state from a sync one by integrating by half a step the e_field.

Errors

Returns an error if the integration failed.

pub fn gauss(&self, point: &LatticePoint<D>) -> Option<CMatrix3>

Get the gauss coefficient G(x) = \sum_i E_i(x) - U_{-i}(x) E_i(x - i) U^\dagger_{-i}(x).

Trait Implementations

impl<State: SimulationStateSynchronous<D> + LatticeStateWithEField<D>, const D: usize> AsMut<State> for SimulationStateLeap<State, D>

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

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

impl<State: SimulationStateSynchronous<D> + LatticeStateWithEField<D>, const D: usize> AsRef<State> for SimulationStateLeap<State, D>

fn as_ref(&self) -> &State

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

impl<State, const D: usize> Clone for SimulationStateLeap<State, D>

where State: SimulationStateSynchronous<D> + ?Sized + Clone,

fn clone(&self) -> SimulationStateLeap<State, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<State, const D: usize> Debug for SimulationStateLeap<State, D>

where State: SimulationStateSynchronous<D> + ?Sized + Debug,

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

Formats the value using the given formatter.

impl<State, const D: usize> Default for SimulationStateLeap<State, D>

where State: SimulationStateSynchronous<D> + Default + ?Sized,

fn default() -> Self

Returns the “default value” for a type.

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

where State: SimulationStateSynchronous<D> + ?Sized + 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, const D: usize> Display for SimulationStateLeap<State, D>

where State: SimulationStateSynchronous<D> + Display + ?Sized,

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

Formats the value using the given formatter.

impl<State, const D: usize> Hash for SimulationStateLeap<State, D>

where State: SimulationStateSynchronous<D> + ?Sized + Hash,

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<State, const D: usize> LatticeState<D> for SimulationStateLeap<State, D>

where State: LatticeStateWithEField<D> + SimulationStateSynchronous<D> + ?Sized,

We just transmit the function of State, there is nothing new.

fn link_matrix(&self) -> &LinkMatrix

The link matrices of this state.

fn set_link_matrix(&mut self, link_matrix: LinkMatrix)

Panic

panic under the same condition as State::set_link_matrix

const CA: Real = State::CA

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 hamiltonian_links(&self) -> Real

Returns the Hamiltonian of the links configuration.

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<State, const D: usize> LatticeStateWithEField<D> for SimulationStateLeap<State, D>

where State: LatticeStateWithEField<D> + SimulationStateSynchronous<D> + ?Sized,

We just transmit the function of State, there is nothing new.

fn e_field(&self) -> &EField<D>

The “Electrical” field of this state.

fn set_e_field(&mut self, e_field: EField<D>)

Panic

panic under the same condition as State::set_e_field

fn t(&self) -> usize

return the time state, i.e. the number of time the simulation ran.

fn hamiltonian_efield(&self) -> Real

Get the energy of the conjugate momenta configuration

fn derivative_u( link: &LatticeLinkCanonical<D>, link_matrix: &LinkMatrix, e_field: &EField<D>, lattice: &LatticeCyclic<D>, ) -> Option<CMatrix3>

Get the derivative \partial_t U(link), returns None if the link is outside of the lattice.

fn derivative_e( point: &LatticePoint<D>, link_matrix: &LinkMatrix, e_field: &EField<D>, lattice: &LatticeCyclic<D>, ) -> Option<SVector<Su3Adjoint, D>>

Get the derivative \partial_t E(point), returns None if the link is outside of the lattice.

fn reset_e_field<Rng>( &mut self, rng: &mut Rng, ) -> Result<(), StateInitializationError>

where Rng: Rng + ?Sized,

Reset the e_field with radom value distributed as N(0, 1 / beta) rand_distr::StandardNormal.

fn hamiltonian_total(&self) -> Real

Get the total energy, by default LatticeStateWithEField::hamiltonian_efield

impl<State, const D: usize> LatticeStateWithEFieldNew<D> for SimulationStateLeap<State, D>

where State: LatticeStateWithEField<D> + SimulationStateSynchronous<D> + LatticeStateWithEFieldNew<D>,

type Error = <State as LatticeStateWithEFieldNew<D>>::Error

Error type

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

Create a new simulation state

fn new_random_e<R>( lattice: LatticeCyclic<D>, beta: Real, link_matrix: LinkMatrix, rng: &mut R, ) -> Result<Self, Self::Error>

where R: Rng + ?Sized,

Create a new state with e_field randomly distributed as rand_distr::Normal^.

impl<State, const D: usize> Ord for SimulationStateLeap<State, D>

where State: SimulationStateSynchronous<D> + ?Sized + Ord,

fn cmp(&self, other: &SimulationStateLeap<State, D>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<State, const D: usize> PartialEq for SimulationStateLeap<State, D>

where State: SimulationStateSynchronous<D> + ?Sized + PartialEq,

fn eq(&self, other: &SimulationStateLeap<State, 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<State, const D: usize> PartialOrd for SimulationStateLeap<State, D>

where State: SimulationStateSynchronous<D> + ?Sized + PartialOrd,

fn partial_cmp(&self, other: &SimulationStateLeap<State, D>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<State, const D: usize> Serialize for SimulationStateLeap<State, D>

where State: SimulationStateSynchronous<D> + ?Sized + 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, const D: usize> SimulationStateLeapFrog<D> for SimulationStateLeap<State, D>

where State: SimulationStateSynchronous<D> + LatticeStateWithEField<D> + ?Sized,

This state is a leap frog state

fn simulate_to_synchronous<I, State>( &self, integrator: &I, delta_t: Real, ) -> Result<State, I::Error>

where Self: Sized, State: SimulationStateSynchronous<D> + ?Sized, I: SymplecticIntegrator<State, Self, D> + ?Sized,

Simulate the state to synchronous by finishing the half step.

fn simulate_leap<I, T>( &self, integrator: &I, delta_t: Real, ) -> Result<Self, I::Error>

where Self: Sized, I: SymplecticIntegrator<T, Self, D> + ?Sized, T: SimulationStateSynchronous<D> + ?Sized,

Does one simulation step using the leap frog algorithm.

fn simulate_leap_n<I, T>( &self, integrator: &I, delta_t: Real, numbers_of_times: usize, ) -> Result<Self, MultiIntegrationError<I::Error>>

where Self: Sized, I: SymplecticIntegrator<T, Self, D> + ?Sized, T: SimulationStateSynchronous<D> + ?Sized,

does numbers_of_times simulation set of size delta_t using the leap frog algorithm.

impl<State, const D: usize> SymplecticIntegrator<State, SimulationStateLeap<State, D>, D> for SymplecticEuler

where State: SimulationStateSynchronous<D> + LatticeStateWithEField<D> + LatticeStateWithEFieldNew<D>,

type Error = SymplecticEulerError<<State as LatticeStateWithEFieldNew<D>>::Error>

Type of error returned by the Integrator.

fn integrate_sync_sync( &self, l: &State, delta_t: Real, ) -> Result<State, Self::Error>

Integrate a sync state to a sync state by advancing the link matrices and the electrical field simultaneously.

fn integrate_leap_leap( &self, l: &SimulationStateLeap<State, D>, delta_t: Real, ) -> Result<SimulationStateLeap<State, D>, Self::Error>

Integrate a leap state to a leap state using leap frog algorithm.

fn integrate_sync_leap( &self, l: &State, delta_t: Real, ) -> Result<SimulationStateLeap<State, D>, Self::Error>

Integrate a sync state to a leap state by doing a half step for the conjugate momenta.

fn integrate_leap_sync( &self, l: &SimulationStateLeap<State, D>, delta_t: Real, ) -> Result<State, Self::Error>

Integrate a leap state to a sync state by finishing doing a step for the position and finishing the half step for the conjugate momenta.

fn integrate_symplectic( &self, l: &State, delta_t: Real, ) -> Result<State, Self::Error>

Integrate a Sync state by going to leap and then back to sync. This is the symplectic method of integration, which should conserve approximately the hamiltonian

impl<State, const D: usize> SymplecticIntegrator<State, SimulationStateLeap<State, D>, D> for SymplecticEulerRayon

where State: SimulationStateSynchronous<D> + LatticeStateWithEField<D> + LatticeStateWithEFieldNew<D>,

type Error = <State as LatticeStateWithEFieldNew<D>>::Error

Type of error returned by the Integrator.

fn integrate_sync_sync( &self, l: &State, delta_t: Real, ) -> Result<State, Self::Error>

Integrate a sync state to a sync state by advancing the link matrices and the electrical field simultaneously.

fn integrate_leap_leap( &self, l: &SimulationStateLeap<State, D>, delta_t: Real, ) -> Result<SimulationStateLeap<State, D>, Self::Error>

Integrate a leap state to a leap state using leap frog algorithm.

fn integrate_sync_leap( &self, l: &State, delta_t: Real, ) -> Result<SimulationStateLeap<State, D>, Self::Error>

Integrate a sync state to a leap state by doing a half step for the conjugate momenta.

fn integrate_leap_sync( &self, l: &SimulationStateLeap<State, D>, delta_t: Real, ) -> Result<State, Self::Error>

Integrate a leap state to a sync state by finishing doing a step for the position and finishing the half step for the conjugate momenta.

fn integrate_symplectic( &self, l: &State, delta_t: Real, ) -> Result<State, Self::Error>

Integrate a Sync state by going to leap and then back to sync. This is the symplectic method of integration, which should conserve approximately the hamiltonian

impl<State, const D: usize> Eq for SimulationStateLeap<State, D>

where State: SimulationStateSynchronous<D> + ?Sized + Eq,

impl<State, const D: usize> StructuralPartialEq for SimulationStateLeap<State, D>

where State: SimulationStateSynchronous<D> + ?Sized,