Struct EField 

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

Represent an electric field.

Implementations

impl<const D: usize> EField<D>

pub fn new(data: Vec<SVector<Su3Adjoint, D>>) -> Self

Create a new “Electrical” field.

pub const fn data(&self) -> &Vec<SVector<Su3Adjoint, D>>

Get the raw data.

pub fn data_mut(&mut self) -> &mut Vec<SVector<Su3Adjoint, D>>

Get a mut ref to the data data.

pub const fn as_vec(&self) -> &Vec<SVector<Su3Adjoint, D>>

Get the e_field as a Vec of Vector of Su3Adjoint

pub fn as_slice(&self) -> &[SVector<Su3Adjoint, D>]

Get the e_field as a slice of Vector of Su3Adjoint

pub fn as_slice_mut(&mut self) -> &mut [SVector<Su3Adjoint, D>]

Get the e_field as mut ref to slice of Vector of Su3Adjoint

pub fn len(&self) -> usize

Return the number of elements.

pub fn new_determinist<Rng: Rng + ?Sized>( l: &LatticeCyclic<D>, rng: &mut Rng, d: &impl Distribution<Real>, ) -> Self

Single threaded generation with a given random number generator. useful to reproduce a set of data.

Example

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
let distribution = rand::distributions::Uniform::from(-1_f64..1_f64);
let lattice = LatticeCyclic::<4>::new(1_f64, 4)?;
assert_eq!(
    EField::new_determinist(&lattice, &mut rng_1, &distribution),
    EField::new_determinist(&lattice, &mut rng_2, &distribution)
);

pub fn new_random(l: &LatticeCyclic<D>, d: &impl Distribution<Real>) -> Self

Single thread generation by seeding a new rng number. To create a seedable and reproducible set use EField::new_determinist.

Example

use lattice_qcd_rs::{field::EField, lattice::LatticeCyclic};

let distribution = rand::distributions::Uniform::from(-1_f64..1_f64);
let lattice = LatticeCyclic::<3>::new(1_f64, 4)?;
let e_field = EField::new_random(&lattice, &distribution);
assert!(!e_field.is_empty());

pub fn new_cold(l: &LatticeCyclic<D>) -> Self

Create a new cold configuration for the electrical field, i.e. all E ar set to 0.

Example

use lattice_qcd_rs::{field::EField, lattice::LatticeCyclic};

let lattice = LatticeCyclic::<3>::new(1_f64, 4)?;
let e_field = EField::new_cold(&lattice);
assert!(!e_field.is_empty());

pub fn e_vec( &self, point: &LatticePoint<D>, l: &LatticeCyclic<D>, ) -> Option<&SVector<Su3Adjoint, D>>

Get E(point) = [E_x(point), E_y(point), E_z(point)].

pub fn e_field( &self, point: &LatticePoint<D>, dir: &Direction<D>, l: &LatticeCyclic<D>, ) -> Option<&Su3Adjoint>

Get E_{dir}(point). The sign of the direction does not change the output. i.e. E_{-dir}(point) = E_{dir}(point).

pub fn is_empty(&self) -> bool

Returns wether there is no data

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

Return the Gauss parameter G(x) = \sum_i E_i(x) - U_{-i}(x) E_i(x - i) U^\dagger_{-i}(x).

pub fn gauss_sum_div( &self, link_matrix: &LinkMatrix, lattice: &LatticeCyclic<D>, ) -> Option<Real>

Get the deviation from the Gauss law

pub fn project_to_gauss( &self, link_matrix: &LinkMatrix, lattice: &LatticeCyclic<D>, ) -> Option<Self>

project to that the gauss law is approximately respected ( up to f64::EPSILON * 10 per point).

It is mainly use internally but can be use to correct numerical drift in simulations.

Example

use lattice_qcd_rs::error::ImplementationError;
use lattice_qcd_rs::integrator::SymplecticEulerRayon;
use lattice_qcd_rs::simulation::{
    LatticeState, LatticeStateDefault, LatticeStateEFSyncDefault, LatticeStateWithEField,
    SimulationStateSynchronous,
};
use rand::SeedableRng;

let mut rng = rand::rngs::StdRng::seed_from_u64(0); // change with your seed
let distribution =
    rand::distributions::Uniform::from(-std::f64::consts::PI..std::f64::consts::PI);
let mut state = LatticeStateEFSyncDefault::new_random_e_state(
    LatticeStateDefault::<3>::new_determinist(1_f64, 6_f64, 4, &mut rng)?,
    &mut rng,
); // <- here internally when choosing randomly the EField it is projected.

let integrator = SymplecticEulerRayon::default();
for _ in 0..2 {
    for _ in 0..10 {
        state = state.simulate_sync(&integrator, 0.0001_f64)?;
    }
    // we correct the numerical drift of the EField.
    let new_e_field = state
        .e_field()
        .project_to_gauss(state.link_matrix(), state.lattice())
        .ok_or(ImplementationError::OptionWithUnexpectedNone)?;
    state.set_e_field(new_e_field);
}

Trait Implementations

impl<const D: usize> AsMut<[Matrix<Su3Adjoint, Const<D>, Const<1>, ArrayStorage<Su3Adjoint, D, 1>>]> for EField<D>

fn as_mut(&mut self) -> &mut [SVector<Su3Adjoint, D>]

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

impl<const D: usize> AsMut<Vec<Matrix<Su3Adjoint, Const<D>, Const<1>, ArrayStorage<Su3Adjoint, D, 1>>>> for EField<D>

fn as_mut(&mut self) -> &mut Vec<SVector<Su3Adjoint, D>>

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

impl<const D: usize> AsRef<[Matrix<Su3Adjoint, Const<D>, Const<1>, ArrayStorage<Su3Adjoint, D, 1>>]> for EField<D>

fn as_ref(&self) -> &[SVector<Su3Adjoint, D>]

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

impl<const D: usize> AsRef<Vec<Matrix<Su3Adjoint, Const<D>, Const<1>, ArrayStorage<Su3Adjoint, D, 1>>>> for EField<D>

fn as_ref(&self) -> &Vec<SVector<Su3Adjoint, D>>

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

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

fn clone(&self) -> EField<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 EField<D>

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

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A, const D: usize> Extend<A> for EField<D>

where Vec<SVector<Su3Adjoint, D>>: Extend<A>,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = A>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<A, const D: usize> FromIterator<A> for EField<D>

where Vec<SVector<Su3Adjoint, D>>: FromIterator<A>,

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = A>,

Creates a value from an iterator.

impl<A, const D: usize> FromParallelIterator<A> for EField<D>

where Vec<SVector<Su3Adjoint, D>>: FromParallelIterator<A>, A: Send,

fn from_par_iter<I>(par_iter: I) -> Self

where I: IntoParallelIterator<Item = A>,

Creates an instance of the collection from the parallel iterator par_iter.

impl<const D: usize> Index<usize> for EField<D>

type Output = Matrix<Su3Adjoint, Const<D>, Const<1>, ArrayStorage<Su3Adjoint, D, 1>>

The returned type after indexing.

fn index(&self, pos: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const D: usize> IndexMut<usize> for EField<D>

fn index_mut(&mut self, pos: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, const D: usize> IntoIterator for &'a EField<D>

type IntoIter = <&'a Vec<Matrix<Su3Adjoint, Const<D>, Const<1>, ArrayStorage<Su3Adjoint, D, 1>>> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

type Item = &'a Matrix<Su3Adjoint, Const<D>, Const<1>, ArrayStorage<Su3Adjoint, D, 1>>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, const D: usize> IntoIterator for &'a mut EField<D>

type IntoIter = <&'a mut Vec<Matrix<Su3Adjoint, Const<D>, Const<1>, ArrayStorage<Su3Adjoint, D, 1>>> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

type Item = &'a mut Matrix<Su3Adjoint, Const<D>, Const<1>, ArrayStorage<Su3Adjoint, D, 1>>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, const D: usize> ParallelExtend<T> for EField<D>

where Vec<SVector<Su3Adjoint, D>>: ParallelExtend<T>, T: Send,

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = T>,

Extends an instance of the collection with the elements drawn from the parallel iterator par_iter.

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

fn eq(&self, other: &EField<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 EField<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 EField<D>