Symmetry Operation

AbstractSpaceSymmetryOperation{S<:Real}

Abstract space symmetry operation, i.e. translation, point, and space operation. See also TranslationOperation, PointOperation, SpaceOperation.

domaintype(arg::AbstractSpaceSymmetryOperation{S}) where {S<:Real}

Domain type of arg, i.e. the type of the coordinates.

IdentityOperation{S<:Real} <: AbstractSpaceSymmetryOperation{S}

Represents identity (space symmetry) operation

Fields

• dimension::Int: dimension of the space on which the identity operation acts

IdentityOperation(S, dim::Integer)

Construct an identity operation of dimension dim, on coordinates of type S.

isidentity(arg::IdentityOperation)

Check whether the argument is an identity. Always true.

istranslation(arg::IdentityOperation)

Check whether the argument is a translation operation. Always true.

ispoint(arg::IdentityOperation)

Check whether the argument is a point operation. Always true.

dimension(arg::IdentityOperation)

Return the spatial dimension of the identity operation.

apply_operation(identity{S}, coordinate::AbstractArray{S}) where {S<:Real}

Do nothing.

TranslationOperation{S<:Real}

Represents translation symmetry operation

Fields

• displacement: displacement vector

Examples

julia> using LatticeTools

julia> TranslationOperation([1, 2])
TranslationOperation{Int64}([1, 2])

julia> TranslationOperation([0.5, 0.0, 0.5])
TranslationOperation{Float64}([0.5, 0.0, 0.5])

TranslationOperation{S}(displacement::AbstractVector{<:Real}) where {S}

Construct a translation operation of displacement on coordinate space of type S.

TranslationOperation{S}(displacement::AbstractVector{<:Real}) where {S}

Construct a translation operation of displacement on coordinate space of type S.

TranslationOperation(displacement::AbstractVector{S}) where {S<:Real}

Construct a translation operation of displacement on coordinate space of type S.

isidentity(t::TranslationOperation)

Return true if the translation operation is an identity, i.e. iszero(t.displacement)

istranslation(arg::TranslationOperation)

Always return true, since arg is already a translation operation.

ispoint(arg::TranslationOperation)

Return true if arg is a point operation. The only way this can be true is when arg is an identity operation.

dimension(arg::TranslationOperation)

Spatial dimension of the translation operation

apply_operation(symop::TranslationOperation{S}, coordinate::AbstractArray{S}) where S

Return the translated coordinate.

PointOperation{S<:Real}

Represents point symmetry operation

Fields

• matrix: rotation/mirror/inversion matrix

PointOperation(matrix::AbstractMatrix{S}) where {S<:Real}

Construct a point operation with matrix.

isidentity(arg::PointOperation)

Check whether arg is identity.

istranslation(arg::PointOperation)

Check whether arg is a translation operation, i.e. identity.

ispoint(arg::PointOperation)

Check whether arg is a point operation. Always true.

dimension(arg::PointOperation)

Return spatial dimension of arg.

apply_operation(symop::PointOperation{S}, coordinate::AbstractArray{S}) where {S}

Apply point operation to the coordinates.

SpaceOperation{Tp<:Real, Tt<:Real}

Represent a spatial symmetry operation of the following form:

\[S_{[M, \mathbf{R}]}: \mathbf{r} \mapsto M \cdot ( \mathbf{r} + \mathbf{R} )\]

Fields

• matrix: Rotation matrix
• displacement: Displacement vector

SpaceOperation(matrix::AbstractMatrix{Tp}, displacement::AbstractVector{Tt}) where {Tp<:Real, Tt<:Real}

Construct a space operation by matrix and displacement.

SpaceOperation([point], [translation])

Construct a space operation by point and translation.

Arguments

• point::PointOperation{Tp}
• translation::TranslationOperation{Tt}

isidentity(arg::SpaceOperation)

Check whether arg is identity (i.e. identity point and identity translation)

istranslation(arg::SpaceOperation)

Check whether arg is a translation operation (i.e., point operation is identity)

ispoint(arg::SpaceOperation)

Check whether arg is a point operation (i.e. translation is identity)

dimension(arg::SpaceOperation)

Return the spatial dimension of arg.

apply_operation(op::SpaceOperation{Tp, Tt}, coord::AbstractArray{<:Union{Tp, Tt}}) where {Tp, Tt}