Struct lattice_qcd_rs::field::LinkMatrix

pub struct LinkMatrix { /* private fields */ }

Represents the link matrices

Implementations

impl LinkMatrix

pub const fn new(data: Vec<Matrix3<Complex<Real>>>) -> Self

Create a new link matrix field from preexisting data.

pub const fn data(&self) -> &Vec<Matrix3<Complex<Real>>>

Get the raw data.

pub fn data_mut(&mut self) -> &mut Vec<Matrix3<Complex<Real>>>

Get a mutable reference to the data

pub const fn as_vec(&self) -> &Vec<Matrix3<Complex<Real>>>

Get the link_matrix as a Vec.

pub fn as_vec_mut(&mut self) -> &mut Vec<Matrix3<Complex<Real>>>

Get the link_matrix as a mutable Vec.

pub fn as_slice(&self) -> &[Matrix3<Complex<Real>>]

Get the link_matrix as a slice.

pub fn as_slice_mut(&mut self) -> &mut [Matrix3<Complex<Real>>]

Get the link_matrix as a mut ref to a slice

pub fn new_determinist<Rng: Rng + ?Sized, const D: usize>( l: &LatticeCyclic<D>, rng: &mut Rng ) -> Self

Single threaded generation with a given random number generator. useful to produce a deterministic set of data but slower than LinkMatrix::new_random_threaded.

Example

use lattice_qcd_rs::{field::LinkMatrix, lattice::LatticeCyclic};
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 lattice = LatticeCyclic::<4>::new(1_f64, 4)?;
assert_eq!(
    LinkMatrix::new_determinist(&lattice, &mut rng_1),
    LinkMatrix::new_determinist(&lattice, &mut rng_2)
);

pub fn new_random_threaded<const D: usize>( l: &LatticeCyclic<D>, number_of_thread: usize ) -> Result<Self, ThreadError>

Multi threaded generation of random data. Due to the non deterministic way threads operate a set cannot be reduced easily. If you want deterministic generation you can use LinkMatrix::new_random_threaded.

Example

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

let lattice = LatticeCyclic::<3>::new(1_f64, 4)?;
let links = LinkMatrix::new_random_threaded(&lattice, 4)?;
assert!(!links.is_empty());

Errors

Returns ThreadError::ThreadNumberIncorrect if number_of_thread is 0.

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

Create a cold configuration ( where the link matrices is set to the identity).

Example

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

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

pub fn matrix<const D: usize>( &self, link: &LatticeLink<D>, l: &LatticeCyclic<D> ) -> Option<Matrix3<Complex<Real>>>

get the link matrix associated to given link using the notation $U_{-i}(x) = U^\dagger_{i}(x-i)$

pub fn sij<const D: usize>( &self, point: &LatticePoint<D>, dir_i: &Direction<D>, dir_j: &Direction<D>, lattice: &LatticeCyclic<D> ) -> Option<Matrix3<Complex<Real>>>

Get $S_ij(x) = U_j(x) U_i(x+j) U^\dagger_j(x+i)$.

pub fn pij<const D: usize>( &self, point: &LatticePoint<D>, dir_i: &Direction<D>, dir_j: &Direction<D>, lattice: &LatticeCyclic<D> ) -> Option<Matrix3<Complex<Real>>>

Get the plaquette $P_{ij}(x) = U_i(x) S^\dagger_ij(x)$.

pub fn average_trace_plaquette<const D: usize>( &self, lattice: &LatticeCyclic<D> ) -> Option<Complex<Real>>

Take the average of the trace of all plaquettes

pub fn clover<const D: usize>( &self, point: &LatticePoint<D>, dir_i: &Direction<D>, dir_j: &Direction<D>, lattice: &LatticeCyclic<D> ) -> Option<CMatrix3>

Get the clover, used for F_mu_nu tensor

pub fn f_mu_nu<const D: usize>( &self, point: &LatticePoint<D>, dir_i: &Direction<D>, dir_j: &Direction<D>, lattice: &LatticeCyclic<D> ) -> Option<CMatrix3>

Get the F^{ij} tensor using the clover appropriation. The direction should be set to positive. See https://arxiv.org/abs/1512.02374.

pub fn magnetic_field_vec<const D: usize>( &self, point: &LatticePoint<D>, lattice: &LatticeCyclic<D> ) -> Option<SVector<CMatrix3, D>>

Get the chromomagnetic field at a given point.

pub fn magnetic_field<const D: usize>( &self, point: &LatticePoint<D>, dir: &Direction<D>, lattice: &LatticeCyclic<D> ) -> Option<CMatrix3>

Get the chromomagnetic field at a given point alongside a given direction.

pub fn magnetic_field_link<const D: usize>( &self, link: &LatticeLink<D>, lattice: &LatticeCyclic<D> ) -> Option<Matrix3<Complex<Real>>>

Get the chromomagnetic field at a given point alongside a given direction given by lattice link.

pub fn len(&self) -> usize

Return the number of elements.

pub fn is_empty(&self) -> bool

Returns wether the there is no data.

pub fn normalize(&mut self)

Correct the numerical drift, reprojecting all the matrices to SU(3).

You can look at the example of super::simulation::LatticeStateDefault::normalize_link_matrices

pub fn iter( &self ) -> impl Iterator<Item = &CMatrix3> + ExactSizeIterator + FusedIterator

Iter on the data.

pub fn iter_mut( &mut self ) -> impl Iterator<Item = &mut CMatrix3> + ExactSizeIterator + FusedIterator

Iter mutably on the data.

Trait Implementations

impl AsMut<[Matrix<Complex<f64>, Const<3>, Const<3>, ArrayStorage<Complex<f64>, 3, 3>>]> for LinkMatrix

fn as_mut(&mut self) -> &mut [CMatrix3]

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

impl AsMut<Vec<Matrix<Complex<f64>, Const<3>, Const<3>, ArrayStorage<Complex<f64>, 3, 3>>, Global>> for LinkMatrix

fn as_mut(&mut self) -> &mut Vec<CMatrix3>

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

impl AsRef<[Matrix<Complex<f64>, Const<3>, Const<3>, ArrayStorage<Complex<f64>, 3, 3>>]> for LinkMatrix

fn as_ref(&self) -> &[CMatrix3]

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

impl AsRef<Vec<Matrix<Complex<f64>, Const<3>, Const<3>, ArrayStorage<Complex<f64>, 3, 3>>, Global>> for LinkMatrix

fn as_ref(&self) -> &Vec<CMatrix3>

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

impl Clone for LinkMatrix

fn clone(&self) -> LinkMatrix

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LinkMatrix

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LinkMatrix

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

Deserialize this value from the given Serde deserializer.

impl<A> Extend<A> for LinkMatrixwhere Vec<CMatrix3>: 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> FromIterator<A> for LinkMatrixwhere Vec<CMatrix3>: FromIterator<A>,

fn from_iter<T>(iter: T) -> Selfwhere T: IntoIterator<Item = A>,

Creates a value from an iterator.

impl<A> FromParallelIterator<A> for LinkMatrixwhere Vec<CMatrix3>: FromParallelIterator<A>, A: Send,

fn from_par_iter<I>(par_iter: I) -> Selfwhere I: IntoParallelIterator<Item = A>,

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

impl Index<usize> for LinkMatrix

type Output = Matrix<Complex<f64>, Const<3>, Const<3>, ArrayStorage<Complex<f64>, 3, 3>>

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for LinkMatrix

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

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

impl<'a> IntoIterator for &'a LinkMatrix

type IntoIter = <&'a Vec<Matrix<Complex<f64>, Const<3>, Const<3>, ArrayStorage<Complex<f64>, 3, 3>>, Global> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

type Item = &'a Matrix<Complex<f64>, Const<3>, Const<3>, ArrayStorage<Complex<f64>, 3, 3>>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut LinkMatrix

type IntoIter = <&'a mut Vec<Matrix<Complex<f64>, Const<3>, Const<3>, ArrayStorage<Complex<f64>, 3, 3>>, Global> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

type Item = &'a mut Matrix<Complex<f64>, Const<3>, Const<3>, ArrayStorage<Complex<f64>, 3, 3>>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> ParallelExtend<T> for LinkMatrixwhere Vec<CMatrix3>: 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 PartialEq<LinkMatrix> for LinkMatrix

fn eq(&self, other: &LinkMatrix) -> 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 Serialize for LinkMatrix

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LinkMatrix