Struct qsym2::target::vibration::VibrationalCoordinate

pub struct VibrationalCoordinate<'a, T>
where
    T: ComplexFloat + Lapack,
{ /* private fields */ }

Structure to manage vibrational coordinates.

Implementations

impl<'a, T> VibrationalCoordinate<'a, T>

where T: ComplexFloat + Clone + Lapack,

pub fn builder() -> VibrationalCoordinateBuilder<'a, T>

Returns a builder to construct a new VibrationalCoordinate.

pub fn frequency(&self) -> &T

Returns the frequency of the vibration.

pub fn coefficients(&self) -> &Array1<T>

Returns a shared reference to the coefficient array.

Trait Implementations

impl<'a, T> Clone for VibrationalCoordinate<'a, T>

where T: ComplexFloat + Lapack + Clone,

fn clone(&self) -> VibrationalCoordinate<'a, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T> ComplexConjugationTransformable for VibrationalCoordinate<'a, T>

where T: ComplexFloat + Lapack,

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<'a, T> Debug for VibrationalCoordinate<'a, T>

where T: Debug + ComplexFloat + Lapack,

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

Formats the value using the given formatter.

impl<'a, T> Display for VibrationalCoordinate<'a, T>

where T: Display + ComplexFloat + Lapack,

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

Formats the value using the given formatter.

impl<'a, T> From<VibrationalCoordinate<'a, T>> for VibrationalCoordinate<'a, Complex<T>>

where T: Float + FloatConst + Lapack, Complex<T>: Lapack,

fn from(value: VibrationalCoordinate<'a, T>) -> Self

Converts to this type from the input type.

impl<'a, G, T> Orbit<G, VibrationalCoordinate<'a, T>> for VibrationalCoordinateSymmetryOrbit<'a, G, T>

where G: SymmetryGroupProperties, T: ComplexFloat + Debug + Lapack, VibrationalCoordinate<'a, T>: SymmetryTransformable,

type OrbitIter = OrbitIterator<'a, G, VibrationalCoordinate<'a, T>>

Type of the iterator over items in the orbit.

fn group(&self) -> &G

The group generating the orbit.

fn origin(&self) -> &VibrationalCoordinate<'a, T>

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<'a, T> Overlap<T, Dim<[usize; 2]>> for VibrationalCoordinate<'a, T>

where T: Lapack + ComplexFloat<Real = <T as Scalar>::Real> + Debug + Mul<<T as ComplexFloat>::Real, Output = T>, <T as ComplexFloat>::Real: Debug + RelativeEq<<T as ComplexFloat>::Real> + AbsDiffEq<Epsilon = <T as Scalar>::Real>,

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

Computes the overlap between two vibrational coordinates.

Typically, metric is None, which means that the local orthogonal Cartesian coordinates are non-overlapping.

Panics

Panics if self and other have mismatched coefficient array lengths.

fn overlap_definition(&self) -> String

Returns the mathematical definition of the overlap between two vibrational coordinates.

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, T> PartialEq for VibrationalCoordinate<'a, T>

where T: ComplexFloat<Real = f64> + Lapack,

fn eq(&self, other: &Self) -> 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<'a, G, T> RepAnalysis<G, VibrationalCoordinate<'a, T>, T, Dim<[usize; 2]>> for VibrationalCoordinateSymmetryOrbit<'a, G, T>

where G: SymmetryGroupProperties, G::CharTab: SubspaceDecomposable<T>, T: Lapack + ComplexFloat<Real = <T as Scalar>::Real> + Debug + Mul<<T as ComplexFloat>::Real, Output = T>, <T as ComplexFloat>::Real: Debug + Zero + RelativeEq<<T as ComplexFloat>::Real> + AbsDiffEq<Epsilon = <T as Scalar>::Real>, VibrationalCoordinate<'a, T>: SymmetryTransformable,

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.

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

Reduces the representation or corepresentation spanned by the items in the orbit to a direct sum of the irreducible representations or corepresentations of the generating group.

impl<'a, T> SpatialUnitaryTransformable for VibrationalCoordinate<'a, T>

where T: ComplexFloat + LinalgScalar + ScalarOperand + Copy + Lapack, f64: Into<T>,

fn transform_spatial_mut( &mut self, rmat: &Array2<f64>, perm: 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<'a, T> SpinUnitaryTransformable for VibrationalCoordinate<'a, T>

where T: ComplexFloat + Lapack,

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

Performs a spin transformation in-place.

This has no effects on the vibrational coordinate as vibrational coordinates are entirely spatial.

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

Performs a spin transformation and returns the transformed result.

impl<'a, T> SymmetryTransformable for VibrationalCoordinate<'a, T>

where T: ComplexFloat + Lapack, VibrationalCoordinate<'a, T>: SpatialUnitaryTransformable + TimeReversalTransformable,

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

Determines the permutation of sites (e.g. atoms in molecules) due to the action of a symmetry operation.

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<'a, T> TimeReversalTransformable for VibrationalCoordinate<'a, T>

where T: ComplexFloat + Lapack,

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

Provides a custom implementation of time reversal where the components of the vibrational coordinates are complex-conjugated to respect the antiunitarity of time reversal.

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

Performs a time-reversal transformation and returns the time-reversed result.

impl<'a, T> Eq for VibrationalCoordinate<'a, T>

where T: ComplexFloat<Real = f64> + Lapack,