Struct OrbitBasis 

pub struct OrbitBasis<'g, G, I>
where
    G: GroupProperties,
{ /* private fields */ }

Basis defined by a set of origins $\{\mathbf{w}_I\}$ and a group $\mathcal{G} = \{g_i\}$.

Each element in the basis is given by the action of the group on the origins, $\mathcal{G} \cdot \{ \mathbf{w}_I \} = \{ \hat{g}_i \mathbf{w}_I \}$.

Implementations

impl<'g, G, I> OrbitBasis<'g, G, I>

where G: GroupProperties + Clone, I: Clone,

pub fn builder() -> OrbitBasisBuilder<'g, G, I>

pub fn origins(&self) -> &Vec<I>

The origins from which orbits are generated.

pub fn group(&self) -> &G

The group acting on the origins to generate orbits, the concatenation of which forms the basis.

pub fn prefactors( &self, ) -> Option<&VecDeque<(G::GroupElement, fn(&G::GroupElement, &I) -> Result<I, Error>)>>

Additional operators acting on the entire orbit basis (right-most operator acts first). Each operator has an associated action that defines how it operatres on the elements in the orbit basis.

impl<'g, G, I> OrbitBasis<'g, G, I>

where G: GroupProperties, I: Clone,

pub fn to_eager(&self) -> Result<EagerBasis<I>, Error>

Converts this orbit basis into the equivalent eager basis.

Trait Implementations

impl<'g, G, I> Basis for OrbitBasis<'g, G, I>

where G: GroupProperties, I: Clone,

fn iter(&self) -> Self::BasisIter<'_>

Iterates over the elements $\hat{g}_i \mathbf{w}_I$ of the OrbitBasis. Each element is indexed by iI where i enumerates the group elements and I enumerates the origins. I is the fast index and i the slow one.

type Item = I

Type of the item in the basis.

type BasisIter<'b> = OrbitBasisIterator<G, I> where Self: 'b

Type of the iterator over items in the basis.

fn n_items(&self) -> usize

Returns the number of items in the basis.

fn first(&self) -> Option<Self::Item>

Shared reference to the first item in the basis.

impl<'g, G, I, T> BasisSymmetryOrbitMetric<G, T> for OrbitBasis<'g, G, I>

where G: SymmetryGroupProperties + Clone, I: Overlap<T, Ix2> + Clone, T: ComplexFloat + Debug + Lapack, OrbitBasis<'g, G, I>: SymmetryTransformable,

fn basis_symmetry_orbit_metric( &self, _group: &G, _symmetry_transformation_kind: &SymmetryTransformationKind, metric: Option<&Array2<T>>, metric_h: Option<&Array2<T>>, ) -> Result<Array3<T>, Error>

Computes the basis symmetry-orbit metric for this orbit basis.

Since this orbit basis already contains information about its group and group action, _group and _symmetry_transformation_kind will be ignored.

Given that the associated group of the orbit basis is $\mathcal{G}$ and that its origins are $\{ \mathbf{w}_{I} \}$, the metric is defined as

\braket{\hat{g}_k \hat{g}_i \mathbf{w}_I | \hat{g}_j \mathbf{w}_J},

arranged in a rank-3 array indexed by $k$, $iI$, and $jJ$.

Arguments

• metric - The atomic-orbital overlap matrix with respect to the conventional sesquilinear inner product.
• metric_h - The atomic-orbital overlap matrix with respect to the bilinear inner product.

Returns

The basis symmetry-orbit metric as a rank-3 array indexed as described above.

impl<'g, G, I: Clone> Clone for OrbitBasis<'g, G, I>

where G: GroupProperties + Clone, G::GroupElement: Clone,

fn clone(&self) -> OrbitBasis<'g, G, I>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'g, G, I> ComplexConjugationTransformable for OrbitBasis<'g, G, I>

where G: GroupProperties + Clone, I: ComplexConjugationTransformable,

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<'g, G, I> DefaultTimeReversalTransformable for OrbitBasis<'g, G, I>

where G: GroupProperties + Clone, I: DefaultTimeReversalTransformable,

impl<'g, G, I> SpatialUnitaryTransformable for OrbitBasis<'g, G, I>

where G: GroupProperties + Clone, I: SpatialUnitaryTransformable,

fn transform_spatial_mut( &mut self, _: &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<'g, G, I> SpinUnitaryTransformable for OrbitBasis<'g, G, I>

where G: GroupProperties + Clone, I: SpinUnitaryTransformable,

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

Performs a spin transformation in-place.

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

Performs a spin transformation and returns the transformed result.

impl<'g, G, I> SymmetryTransformable for OrbitBasis<'g, G, I>

where G: GroupProperties<GroupElement = SymmetryOperation> + Clone, I: SymmetryTransformable, OrbitBasis<'g, G, I>: 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_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_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_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_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( &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( &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( &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, 'g, G> TimeReversalTransformable for OrbitBasis<'g, G, SlaterDeterminant<'a, Complex<f64>, SpinOrbitCoupled>>

where G: GroupProperties<GroupElement = SymmetryOperation> + Clone,

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

Performs a time-reversal transformation in-place.

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

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