Struct qsym2::sandbox::target::real_space_function::RealSpaceFunction

pub struct RealSpaceFunction<T, F>
where
    T: ComplexFloat + Lapack,
    F: Fn(&Point3<f64>) -> T,
{ /* private fields */ }

Structure to manage real-space functions.

Implementations

impl<T, F> RealSpaceFunction<T, F>

where T: ComplexFloat + Clone + Lapack, F: Clone + Fn(&Point3<f64>) -> T,

pub fn builder() -> RealSpaceFunctionBuilder<T, F>

Returns a builder to construct a new RealSpaceFunction.

pub fn grid_points(&self) -> Vec<&Point3<f64>>

Returns a vector of shared references to the grid points at which the real-space function is evaluated.

pub fn function(&self) -> &F

Returns a shared reference to the function defining the RealSpaceFunction.

Trait Implementations

impl<T, F> Clone for RealSpaceFunction<T, F>

where T: ComplexFloat + Lapack + Clone, F: Fn(&Point3<f64>) -> T + Clone,

fn clone(&self) -> RealSpaceFunction<T, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, F> ComplexConjugationTransformable for RealSpaceFunction<T, F>

where T: ComplexFloat + Lapack, F: Clone + Fn(&Point3<f64>) -> T,

fn transform_cc_mut(&mut self) -> Result<&mut Self, TransformationError>

Performs a complex conjugation in-place.

fn transform_cc(&self) -> Result<Self, TransformationError>

Performs a complex conjugation and returns the complex-conjugated result.

impl<T, F> Display for RealSpaceFunction<T, F>

where T: ComplexFloat + Lapack, F: Fn(&Point3<f64>) -> T,

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

Formats the value using the given formatter.

impl<'a, G, T, F> Orbit<G, RealSpaceFunction<T, F>> for RealSpaceFunctionSymmetryOrbit<'a, G, T, F>

where G: SymmetryGroupProperties + Clone, T: ComplexFloat + Debug + Lapack, F: Fn(&Point3<f64>) -> T, RealSpaceFunction<T, F>: SymmetryTransformable,

type OrbitIter = OrbitIterator<'a, G, RealSpaceFunction<T, F>>

Type of the iterator over items in the orbit.

fn group(&self) -> &'a G

The group generating the orbit.

fn origin(&self) -> &RealSpaceFunction<T, F>

The origin of the orbit.

fn iter(&self) -> Self::OrbitIter

An iterator over items in the orbit arising from the action of the group on the origin.

impl<T, F> Overlap<T, Dim<[usize; 1]>> for RealSpaceFunction<T, F>

where T: ComplexFloat + Lapack + Send + Sync, F: Clone + Sync + Send + Fn(&Point3<f64>) -> T,

fn overlap( &self, other: &Self, metric: Option<&Array1<T>>, _: Option<&Array1<T>>, ) -> Result<T, Error>

Computes the overlap between two real-space functions.

No attempts are made to check that the grid points between the two real-space functions are ‘compatible’. The overlap is simply evaluated as

    \sum_i [\hat{\iota} f_1(\mathbf{r}_{1i})]^* f_2(\mathbf{r}_{2i}) w_i,

where $w_i$ are weight values.

Errors

Errors if self and other have mismatched numbers of grid points or if the number of weight values does not match the number of grid points.

fn overlap_definition(&self) -> String

Returns the mathematical definition of the overlap between two real-space functions.

fn complex_symmetric(&self) -> bool

If true, the inner product is bilinear and $\hat{\iota} = \hat{\kappa}$. If false, the inner product is sesquilinear and $\hat{\iota} = \mathrm{id}$.

impl<'a, G, T, F> RepAnalysis<G, RealSpaceFunction<T, F>, T, Dim<[usize; 1]>> for RealSpaceFunctionSymmetryOrbit<'a, G, T, F>

where G: SymmetryGroupProperties + Clone, G::CharTab: SubspaceDecomposable<T>, T: Lapack + ComplexFloat<Real = <T as Scalar>::Real> + Debug + Send + Sync + Mul<<T as ComplexFloat>::Real, Output = T>, <T as ComplexFloat>::Real: Debug + Zero + From<u16> + ToPrimitive + RelativeEq<<T as ComplexFloat>::Real> + AbsDiffEq<Epsilon = <T as Scalar>::Real>, F: Clone + Sync + Send + Fn(&Point3<f64>) -> T, RealSpaceFunction<T, F>: SymmetryTransformable,

fn analyse_rep( &self, ) -> Result<<<G as CharacterProperties>::CharTab as SubspaceDecomposable<T>>::Decomposition, DecompositionError>

Reduces the representation or corepresentation spanned by the real-space functions in the orbit to a direct sum of the irreducible representations or corepresentations of the generating symmetry group.

Returns

The decomposed result.

Errors

Errors if the decomposition fails, e.g. because one or more calculated multiplicities are non-integral.

fn set_smat(&mut self, smat: Array2<T>)

Sets the overlap matrix between the items in the orbit.

fn smat(&self) -> Option<&Array2<T>>

Returns the overlap matrix between the items in the orbit.

fn xmat(&self) -> &Array2<T>

Returns the transformation matrix $\mathbf{X}$ for the overlap matrix $\mathbf{S}$ between the items in the orbit.

fn norm_preserving_scalar_map(&self, i: usize) -> Result<fn(_: T) -> T, Error>

Returns the norm-preserving scalar map $f$ for every element of the generating group defined by

fn integrality_threshold(&self) -> <T as ComplexFloat>::Real

Returns the threshold for integrality checks of irreducible representation or corepresentation multiplicities.

fn eigenvalue_comparison_mode(&self) -> &EigenvalueComparisonMode

Returns the enumerated type specifying the comparison mode for filtering out orbit overlap eigenvalues.

fn calc_smat( &mut self, metric: Option<&Array<T, D>>, metric_h: Option<&Array<T, D>>, use_cayley_table: bool, ) -> Result<&mut Self, Error>

Calculates and stores the overlap matrix between items in the orbit, with respect to a metric of the basis in which these items are expressed.

fn normalise_smat(&mut self) -> Result<&mut Self, Error>

Normalises overlap matrix between items in the orbit such that its diagonal entries are unity.

fn calc_tmat(&self, op: &G::GroupElement) -> Result<Array2<T>, Error>

Computes the $\mathbf{T}(g)$ matrix for a particular element $g$ of the generating group.

fn calc_dmat(&self, op: &G::GroupElement) -> Result<Array2<T>, Error>

Computes the representation or corepresentation matrix $\mathbf{D}(g)$ for a particular element $g$ in the generating group in the basis of the orbit.

fn calc_character(&self, op: &G::GroupElement) -> Result<T, Error>

Computes the character of a particular element $g$ in the generating group in the basis of the orbit.

fn calc_characters( &self, ) -> Result<Vec<(<G as ClassProperties>::ClassSymbol, T)>, Error>

Computes the characters of the elements in a conjugacy-class transversal of the generating group in the basis of the orbit.

impl<T, F> SpatialUnitaryTransformable for RealSpaceFunction<T, F>

where T: ComplexFloat + Lapack, F: Clone + Fn(&Point3<f64>) -> T,

fn transform_spatial_mut( &mut self, rmat: &Array2<f64>, _: Option<&Permutation<usize>>, ) -> Result<&mut Self, TransformationError>

Performs a spatial transformation in-place.

fn transform_spatial( &self, rmat: &Array2<f64>, perm: Option<&Permutation<usize>>, ) -> Result<Self, TransformationError>

Performs a spatial transformation and returns the transformed result.

impl<T, F> SpinUnitaryTransformable for RealSpaceFunction<T, F>

where T: ComplexFloat + Lapack, F: Clone + Fn(&Point3<f64>) -> T,

fn transform_spin_mut( &mut self, _: &Array2<Complex<f64>>, ) -> Result<&mut Self, TransformationError>

Performs a spin transformation in-place.

Since real-space functions are entirely spatial, spin transformations have no effect on them. This thus simply returns self without modification.

fn transform_spin( &self, dmat: &Array2<Complex<f64>>, ) -> Result<Self, TransformationError>

Performs a spin transformation and returns the transformed result.

impl<T, F> SymmetryTransformable for RealSpaceFunction<T, F>

where T: ComplexFloat + Lapack, F: Clone + Fn(&Point3<f64>) -> T, RealSpaceFunction<T, F>: SpatialUnitaryTransformable + TimeReversalTransformable,

fn sym_permute_sites_spatial( &self, _: &SymmetryOperation, ) -> Result<Permutation<usize>, TransformationError>

Real-space functions have no local sites for permutation. This method therefore simply returns the identity permutation on one object.

fn sym_transform_spatial_mut( &mut self, symop: &SymmetryOperation, ) -> Result<&mut Self, TransformationError>

Performs a spatial transformation according to a specified symmetry operation in-place.

fn sym_transform_spatial( &self, symop: &SymmetryOperation, ) -> Result<Self, TransformationError>

Performs a spatial transformation according to a specified symmetry operation and returns the transformed result.

fn sym_transform_spatial_with_spintimerev_mut( &mut self, symop: &SymmetryOperation, ) -> Result<&mut Self, TransformationError>

Performs a spatial transformation according to a specified symmetry operation in-place, but with spin-including time reversal.

fn sym_transform_spatial_with_spintimerev( &self, symop: &SymmetryOperation, ) -> Result<Self, TransformationError>

Performs a spatial transformation according to a specified symmetry operation but with spin-including time reversal and returns the transformed result.

fn sym_transform_spin_mut( &mut self, symop: &SymmetryOperation, ) -> Result<&mut Self, TransformationError>

Performs a spin transformation according to a specified symmetry operation in-place.

fn sym_transform_spin( &self, symop: &SymmetryOperation, ) -> Result<Self, TransformationError>

Performs a spin transformation according to a specified symmetry operation and returns the transformed result.

fn sym_transform_spin_spatial_mut( &mut self, symop: &SymmetryOperation, ) -> Result<&mut Self, TransformationError>

Performs a coupled spin-spatial transformation according to a specified symmetry operation in-place.

fn sym_transform_spin_spatial( &self, symop: &SymmetryOperation, ) -> Result<Self, TransformationError>

Performs a coupled spin-spatial transformation according to a specified symmetry operation and returns the transformed result.

impl<T, F> DefaultTimeReversalTransformable for RealSpaceFunction<T, F>

where T: ComplexFloat + Lapack, F: Clone + Fn(&Point3<f64>) -> T,