Public API

Lattice(data::AbstractMatrix)

Construct a Lattice from a matrix.

Lattice(𝐚::AbstractVector, 𝐛::AbstractVector, 𝐜::AbstractVector)

Construct a Lattice from three basis vectors.

Lattice(basisvectors::AbstractVector{<:AbstractVector})

Construct a Lattice from a vector of three basis vectors.

Lattice(a, b, c, α, β, γ; axis = :a)

Construct a Lattice from the six cell parameters.

The default convention we used here is that edge vector 𝐚 in the positive x-axis direction, edge vector 𝐛 in the x-y plane with a positive y-axis component, and edge vector 𝐜 with a positive z-axis component in the Cartesian system. See Wikipedia. You can also choose axis = :c.

Lattice(cell::Cell)

Get the lattice of a Cell.

Lattice(g::MetricTensor)

Construct a Lattice from a MetricTensor.

supercell(lattice::Lattice, repfactors::AbstractMatrix{<:Integer})
supercell(lattice::Lattice, repfactors::AbstractVector{<:Integer})
supercell(lattice::Lattice, repfactor::Integer)

Create a supercell from lattice.

supercell(cell::Cell, repfactors::AbstractMatrix{<:Integer})
supercell(cell::Cell, repfactors::AbstractVector{<:Integer})
supercell(cell::Cell, repfactor::Integer)

Create a supercell from cell.

ReciprocalPoint(x, y, z, w)

Represent a special point of the 3D Brillouin zone. Each of them has a weight w.

ReciprocalLattice(data::MMatrix)

Construct a ReciprocalLattice.

coordinates(arr::AbstractArray{<:ReciprocalPoint})

Get the coordinates of an array of ReciprocalPoints.

weights(arr::AbstractArray{<:ReciprocalPoint})

Get the weights of an array of ReciprocalPoints.

MetricTensor(𝐚::AbstractVector, 𝐛::AbstractVector, 𝐜::AbstractVector)

Generate a MetricTensor from the three basis vectors.

MetricTensor(lattice::Lattice)

Generate a MetricTensor from a Lattice.

MetricTensor(a, b, c, α, β, γ)

Generate a MetricTensor from the six cell parameters.

distance(𝐚::AbstractVector, g::MetricTensor, 𝐛::AbstractVector)

Get the distance between two coordinates using a MetricTensor.

CartesianFromFractional(lattice::Union{Lattice,ReciprocalLattice})
CartesianFromFractional(a, b, c, α, β, γ)

Get the transformation from fractional coordinates to Cartesian coordinates.

FractionalFromCartesian(lattice::Union{Lattice,ReciprocalLattice})
FractionalFromCartesian(a, b, c, α, β, γ)

Get the transformation from Cartesian coordinates to fractional coordinates.

PrimitiveFromStandardized(tf::AbstractMatrix)

Construct the transformation from a standardized cell to a primitive cell.

StandardizedFromPrimitive(tf::AbstractMatrix)

Construct the transformation from a primitive cell to a standardized cell.

cellvolume(a, b, c, α, β, γ)

Calculate the cell volume from 6 cell parameters.

cellvolume(l::Lattice)
cellvolume(c::Cell)

Calculate the cell volume from a Lattice or a Cell.

cellvolume(g::MetricTensor)

Calculate the cell volume from a MetricTensor.

SeitzOperator(𝐑::AbstractMatrix, 𝐭::AbstractVector)
SeitzOperator(𝐑::AbstractMatrix)
SeitzOperator(𝐭::AbstractVector)

Construct a Seitz operator from matrices, vectors, or both.

The operator is defined by the following equation:

\[\left[ \begin{array}{ccc|c} & & & \\ & \mathbf{R} & & \mathbf{t} \\ & & & \\ \hline 0 & 0 & 0 & 1 \end{array} \right],\]

where $\mathbf{R}$ is a point group operation and $\mathbf{t}$ is a translation.