principia_materia.translation_group.lattice_ftg module

class principia_materia.translation_group.lattice_ftg.LatticeFTG(vec, supa, pg=None, strict_symmetry=True, tol=1e-06)

Bases: Lattice

A finite translation group (i.e. supercell) of the primitive lattice with point symmetry.

Parameters:

  • vec (array of float, shape(dim, dim)) – The lattice vectors, in row convention.

  • supa (array of int, shape(dim, dim)) – Super lattice matrix.

  • pg (str or a PointGroup object) – The point group of the lattice.

  • strict_symmetry (bool, optional, default to True) – If True, lattice points must rotate into a point that also fits in the cell.

  • tol (float, optional, default to 1.0E-6) – Tolerance threshold.

copy()

Return a copy of the object.

Returns:

new – A copy of the object itself.

Return type:

LatticeFTG

find_irreducible_lattice_points()

Find the irreducible set of lattice points under the given symmetry.

rotated_lattice_points

Dictionary of how what each lattice points rotate into for each group operation. (Indices)

Type:

dict with str as keys and array of int as values

irreducible_lattice_points_trans

The name of the operation takes the lattice points at its index to one of the irreducible lattice points.

Type:

array of str, shape(multiplicity)

irreducible_lattice_points_index_map

The corresponding irreducible lattice point index in the lattice point list for each lattice point.

Type:

array of int, shape(multiplicity)

irreducible_lattice_points_index

Index of irreducible lattice points in the lattice points list.

Type:

array of int, shape(nilp)

irreducible_lattice_points_map

The corresponding irreducible lattice point index in the irreducible lattice point list for each lattice point.

Type:

array of int, shape(multiplicity)

irreducible_lattice_points_mult

The multiplicity of each irreducible lattice point.

Type:

array of int, shape(nilp)

irreducible_lattice_points

The list of irreducible lattice point.

Type:

array of array of int, shape(nilp, dim)

\* nilp=number of irreducible lattice points
get_index(points)

Find the index of a given lattice point or a list of lattice points.

The algorithm is descrived in method create_mesh. For each lattice point, instead of using the ordinary indexing of a list, this algorithm only has the time complexity of O(1), which is much more efficient when used.

In order to compute the index, the a tranformation matrix \(\textrm{H}_p\) and an index weight vector \(\textrm{IW}\)

\[ \begin{align}\begin{aligned}& H_{p, (j, i)} = H^{-1}_{(j, i)} \times H_{(i, i)} \forall i \in [1, d], j \in [1, i)\\& \textrm{IW}_{i} = \prod_{j=1}^{i} H_{(j, j)}\end{aligned}\end{align} \]

Then the index of any given point in the supercell can be computed directly:

\[& \textrm{index}_{t} = ((t \cdot L + \textrm{floor}(t \cdot L \cdot H_p)) \mod \textrm{diag}(H)) \cdot \textrm{IW}\]
Parameters:

points (array of integers, shape(dim) or shape(N, dim)) – Points to compute indices.

property invsupa

The inverse of the supercell matrix.

property multiplicity

The multiplicity of the supercell.

set_lattice_points()

Find t-points that fit in the supercell.

set_lattice_points_diagonal()

Find the lattice points that fit in the given diagonal supercell.

Same as set_lattice_points_generic, except for diagonal supercells it can be simplified.

set_lattice_points_generic()

Find the lattice points that fit in the given supercell.

It uses the algorithm implemented in get_lattice_points function (described in Phys. Rev. B 100, 014303 (2019)). And meanwhile, prepares the matrices to determine the index of each lattice point using the inverse operation of the above metioned function.

lattice_points

Lattice points of the super cell (i.e. FTG).

Type:

array of int, shape(self.multiplicity, 3)

property supa

The supercell matrix.

property supa_is_diagonal

Whether the supercell is a diagonal matrix.

to_dict()

Return a dictionary containing key information about the LatticeFTG object.

principia_materia.translation_group.lattice_ftg.get_lattice_ftg_io_wrapper(title='LatticeFTG')

YAML data wrapper for LatticeFTG class.

principia_materia.translation_group.lattice_ftg.get_lattice_points(supa, decimals=6)

Find t-points using Hermite Normal Form (HNF) of the \(S_BZ\).

The algorithm is described in paper:

  1. We can decompose the supercell matrix into its HNF:

\[ \begin{align}\begin{aligned}& S_BZ = HL^{-1}\\& S_BZ^{-1} = LH^{-1}\end{aligned}\end{align} \]

  1. Then we have the condition of the t-points that fit in the supercell:

\[ \begin{align}\begin{aligned}& 0 <= t S_BZ^{-1} e_j < 1\\& 0 <= t L H^{-1} e_j < 1\end{aligned}\end{align} \]

  1. If we let \(t' = tL\), we can rewrite the condition

\[0 <= t' H^{-1} e_j < 1\]

, and we can solve for \(t'\) and recover \(t\) afterwards:

\[t = t' L^{-1}\]
Parameters:

  • supa (array of int, shape(dim, dim)) – Supercell matrix.

  • decimals (int, optional, default to 6) – The decimal points to round