Struct LatticeStateEFSyncDefault 

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

wrapper to implement LatticeStateWithEField from a LatticeState using the default implementation of conjugate momenta.

It also implement SimulationStateSynchronous.

Implementations

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

where State: LatticeState<D> + ?Sized,

pub fn state_owned(self) -> State

where State: Sized,

Absorbs self and return the state as owned. It essentially deconstruct the structure.

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

Get a reference to the state.

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

Get a mutable reference to the state.

pub fn new_random_e_state(lattice_state: State, rng: &mut impl Rng) -> Self

where State: Sized,

Take a state and generate a new random one and try projecting it to the Gauss law.

Panic

Panics if N(0, 0.5/beta ) is not a valid distribution (for example beta = 0). Panics if the field could not be projected to the Gauss law.

pub fn new_e_cold(lattice_state: State) -> Self

where State: Sized,

Create a new Self from a state and a cold configuration of the e field (i.e. set to 0)

pub fn e_field_mut(&mut self) -> &mut EField<D>

Get a mutable reference to the efield

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

where Self: LatticeStateWithEField<D>, State: LatticeState<D> + ?Sized,

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).

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

where Self: LatticeStateWithEFieldNew<D>, <Self as LatticeStateWithEFieldNew<D>>::Error: From<LatticeInitializationError>, State: LatticeState<D>,

pub fn new_determinist<R>( size: Real, beta: Real, number_of_points: usize, rng: &mut R, d: &impl Distribution<Real>, ) -> Result<Self, <Self as LatticeStateWithEFieldNew<D>>::Error>

where R: Rng + ?Sized,

Generate a hot (i.e. random) initial state.

Single threaded generation with a given random number generator. size is the size parameter of the lattice and number_of_points is the number of points in each spatial dimension of the lattice. See LatticeCyclic::new for more info.

useful to reproduce a set of data but slower than LatticeStateEFSyncDefault::new_random_threaded.

Errors

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

Example

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

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
let distribution = rand::distributions::Uniform::from(-1_f64..1_f64);
assert_eq!(
    LatticeStateEFSyncDefault::<LatticeStateDefault<4>, 4>::new_determinist(1_f64, 1_f64, 4, &mut rng_1, &distribution).unwrap(),
    LatticeStateEFSyncDefault::<LatticeStateDefault<4>, 4>::new_determinist(1_f64, 1_f64, 4, &mut rng_2, &distribution).unwrap()
);

pub fn new_determinist_cold_e_hot_link<R>( size: Real, beta: Real, number_of_points: usize, rng: &mut R, ) -> Result<Self, <Self as LatticeStateWithEFieldNew<D>>::Error>

where R: Rng + ?Sized,

Generate a configuration with cold e_field and hot link matrices

Errors

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

pub fn new_cold( size: Real, beta: Real, number_of_points: usize, ) -> Result<Self, <Self as LatticeStateWithEFieldNew<D>>::Error>

Generate a new cold state.

It meas that the link matrices are set to the identity and electrical field are set to 0.

Errors

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

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

where Self: LatticeStateWithEFieldNew<D, Error = StateInitializationError>, State: LatticeState<D>,

pub fn new_random_threaded<Distribution>( size: Real, beta: Real, number_of_points: usize, d: &Distribution, number_of_thread: usize, ) -> Result<Self, ThreadedStateInitializationError>

where Distribution: Distribution<Real> + Sync,

Generate a hot (i.e. random) initial state.

Multi threaded generation of random data. Due to the non deterministic way threads operate a set cannot be reproduce easily, In that case use LatticeStateEFSyncDefault::new_determinist.

Errors

Return StateInitializationError::LatticeInitializationError if the parameter is invalid for LatticeCyclic. Return ThreadError::ThreadNumberIncorrect if number_of_points = 0. Returns an error if a thread panicked. Finally, propagates the error form Self::new.

Trait Implementations

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

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

fn clone(&self) -> LatticeStateEFSyncDefault<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 LatticeStateEFSyncDefault<State, D>

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

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

Formats the value using the given formatter.

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

where State: LatticeState<D> + ?Sized + Deserialize<'de>, SVector<Su3Adjoint, D>: 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> LatticeState<D> for LatticeStateEFSyncDefault<State, D>

where State: LatticeState<D> + ?Sized,

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 link_matrix(&self) -> &LinkMatrix

Get the link matrices of this state.

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<const D: usize> LatticeStateWithEField<D> for LatticeStateEFSyncDefault<LatticeStateDefault<D>, D>

where Direction<D>: DirectionList,

fn hamiltonian_efield(&self) -> Real

By default \sum_x Tr(E_i E_i)

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

The “Electrical” field of this state.

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

Panic

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

fn t(&self) -> usize

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

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

Get the derive of U_i(x).

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

Get the derive of E(x) (as a vector of Su3Adjoint).

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 LatticeStateEFSyncDefault<State, D>

where State: LatticeState<D> + LatticeStateNew<D>, Self: LatticeStateWithEField<D>, StateInitializationError: Into<State::Error>, State::Error: From<NormalError>,

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. If e_field or link_matrix does not have the corresponding amount of data compared to lattice it fails to create the state. t is the number of time the simulation ran. i.e. the time sate.

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

Error type

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> PartialEq for LatticeStateEFSyncDefault<State, D>

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

fn eq(&self, other: &LatticeStateEFSyncDefault<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> Serialize for LatticeStateEFSyncDefault<State, D>

where State: LatticeState<D> + ?Sized + Serialize, SVector<Su3Adjoint, D>: 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> SimulationStateSynchronous<D> for LatticeStateEFSyncDefault<State, D>

where State: LatticeState<D> + Clone + ?Sized, Self: LatticeStateWithEField<D>,

This is an sync State

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

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

does half a step for the conjugate momenta.

fn simulate_using_leapfrog_n<I, State>( &self, integrator: &I, delta_t: Real, number_of_steps: usize, ) -> Result<Self, MultiIntegrationError<I::Error>>

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

Does number_of_steps with delta_t at each step using a leap_frog algorithm by fist doing half a step and then finishing by doing half step.

fn simulate_using_leapfrog_n_auto<I>( &self, integrator: &I, delta_t: Real, number_of_steps: usize, ) -> Result<Self, MultiIntegrationError<I::Error>>

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

Does the same thing as SimulationStateSynchronous::simulate_using_leapfrog_n but use the default wrapper SimulationStateLeap for the leap frog state.

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

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

Does a simulation step using the sync algorithm

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

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

Does numbers_of_times of step of size delta_t using the sync algorithm

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

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

Integrate the state using the symplectic algorithm ( by going to leapfrog and back to sync)

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

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

Does numbers_of_times of step of size delta_t using the symplectic algorithm

fn simulate_symplectic_n_auto<I>( &self, integrator: &I, delta_t: Real, number_of_steps: usize, ) -> Result<Self, MultiIntegrationError<I::Error>>

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

Does the same thing as SimulationStateSynchronous::simulate_symplectic_n but use the default wrapper SimulationStateLeap for the leap frog state.

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

where State: LatticeState<D> + ?Sized,