Lattice{T}

The type represents a lattice in 3D space formed by three column lattice vectors.

Lattice(matrix::Matrix{T}) where T

Construct a Lattice from a matrix of column vectors.

Lattice(a::T, b::T, c::T, α::T, β::T, γ::T) where T

Construct a Lattice from lattice parameters.

Lattice(a::T, b::T, c::T) where T <: Real

Construct a Lattice with orthogonal lattice vectors.

Lattice(va::Vector{T}, vb::Vector{T}, vc::Vector{T}) where T

Construct a Lattice from three lattice vectors.

Lattice(cellpar::Vector{T}) where T

Construct a Lattice from a six-vector of lattice parameters.

cellmat(lattice::Lattice)

Return the matrix of column vectors.

Get a matrix of column vectors

cellpar(lattice::Lattice)

Return the lattice parameters as a six-vector.

Lattice vectors

Fraction positions of a site

Return a copy of the cell matrix

Return a copy of the reciprocal cell matrix

get_scaled_positions(l::Lattice, v::AbstractVecOrMat) = reciprocal(l) * v

Return the scaled positions.

mic(l::Lattice, vec::AbstractVecOrMat)

Compute the minimum-image convention representation of a series of displacement vectors.

Compute naive MIC representation of the vector(s)

Not safe for skewed cells. Requires

norm(length) < 0.5 * min(cellpar(l)[1:3])

See also:

• W. Smith, "The Minimum Image Convention in Non-Cubic MD Cells", 1989, http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.57.1696.

 mic_safe(l::Lattice, v::AbstractVector)

Compute MIC representation of vectors using a safe approach based on Minkowski reduced cell

 mic_safe(l::Lattice, v::AbstractMatrix)

Compute MIC representation of vectors using a safe approach based on Minkowski reduced cell

 mic_safe(l::Lattice, v::AbstractVector)

Compute MIC representation of vectors using a safe approach based on Minkowski reduced cell

Random displacement vector in a unit cell

random_vec_in_cell(cell::Matrix{T}; scales::Vector=ones(size(cell)[1])) where T

Get an random vector within a unit cell. The cell is a matrix made of column vectors.

rec_cellmat(l::Lattice)

Returns the matrix of reciprocal lattice vectors (without the $2\pi$ factor).

reciprocal(l::Lattice)

Returns the matrix of reciprocal lattice vectors (without the $2\pi$ factor).

Alias to get_scaled_positions

set_cellmat!(lattice::Lattice, mat)

Set the cell matrix and update the reciprocal cell matrix.

update_rec!(l::Lattice)

Update the reciprocal matrix - this should be called everytime cell is changed.

Return the volume of the cell

Wrap a site back into the box

wrap_positions(l::Lattice, v::AbstractVecOrMat)

Wrap positions back into the box defined by the cell vectors.

Compute the require periodicities required to fill a cut off sphere of a certain radius

shift_indices(lattice::AbstractArray, rc::Real)

Compute a vector containing shift indices

shift_vectors(lattice::AbstractMatrix, shift1, shift2, shift3)

Compute the shift vectors needed to include all parts of the lattice within a cut off radius.

Compute shift vectors given lattice matrix and cut off radius

A Cell represents a periodic structure in three-dimensional space.

Defined as:

mutable struct Cell{T}
    lattice::Lattice{T}                 # Lattice of the structure
    symbols::Vector{Symbol}
    positions::Matrix{T}
    arrays::Dict{Symbol, Any}        # Any additional arrays
    metadata::Dict{Symbol, Any}
end

Cell(lat::Lattice, numbers::Vector{Int}, positions::Vector)

Constructure the Cell type from lattice, positions and numbers

Cell(l::Lattice, symbols, positions) where T

Construct a Cell type from arrays

Cell(lat::Lattice, numbers::Vector{Int}, positions)

Constructure the Cell type from lattice, positions and numbers

Base.sort!(cell::Cell)

In-place sort a Cell with the positions sorted by the species kinds.

Base.sort(cell::Cell)

Sort a Cell with the positions sorted by the species kinds.

_distance_matrix_mic(cell::Cell)

Compute the distance matrix for the given structure, using the minimum image convention (or not).

Note the returned matrix does not expand the cell. The distance matrix cannot be safety used for obtaining the minimum separations. For example, a structure with a single atom would be a distance matrix containing only zero.

_distance_matrix_no_mic(structure::Cell)

Compute the distnace matrix without minimum image convention, e.g. the PBC is not respected.

array(structure::Cell, arrayname::Symbol)

Return the additional array stored in the Cell object.

arraynames(structure::Cell)

Return the names of additional arrays.

atomic_numbers(structure::Cell)

Return a Vector of the atomic numbers.

attachmetadata!(structure::Cell, metadata::Dict)

Replace metadata with an existing dictionary.

cellmat(structure::Cell)

Return the matrix of lattice vectors.

cellpar(structure::Cell)

Return the lattice parameters.

check_minsep(structure::Cell, minsep::Dict)

Check if the minimum separation constraints are satisfied. Minimum separations are supplied as an dictionary where the global version under the :global key. To supply the minimum separations between A and B, pass Dict((:A=>:B)=>1.0). Return true or false.

clip(s::Cell, mask::AbstractVector)

Clip a structure with a given indexing array

minsep_matrix(structure::Cell, minsep::Dict)

Initialise the minimum separation matrix and species mapping. Returns the unique species, integer indexed species and the minimum separation matrix.

distance_squared_between(posmat::Matrix, i, j, svec::Matrix, ishift)

Return the squared distance between two positions stored in a matrix and shift vector.

fingerprint(s::Cell; dmat=distance_matrix(s), weighted=true, cut_bl=3.0)

Computed the fingerprint vector based on simple sorted pair-wise distances. NOTE: Does not work for single atom cell!!

fingerprint_distance(f1::AbstractVector, f2::AbstractVector;lim=Inf)

Compute the deviation between two finger print vectors

Comparison is truncated by the size of the shortest vector of the two, or by the lim key word.

formula_and_factor(structure::Cell)

Return reduced formula and associated factor.

get_cellmat(structure::Cell)

Return the matrix of lattice vectors(copy).

get_lattice(structure::Cell)

Return the Lattice instance (copy).

get_positions(cell::Cell)

Return a copy of the positions (cartesian coordinates) of the atoms in a structure.

get_fraction_positions(cell::Cell)

Return fractional positions of the cell.

get_species(structure::Cell)

Return a Vector (copy) of species names.

lattice(structure::Cell)

Return the Lattice instance.

make_supercell(structure::Cell, a, b, c)

Make a supercell

Currently only work with diagonal transform matrices. TODO: Write function for the general cases....

metadata(structure::Cell)

Return the metadata dictionary.

natoms(cell::Cell)

Return number of atoms in a structure.

nions(cell::Cell)

Return number of atoms in a structure.

num_fu(structure::Cell)

Return the number of formula units.

positions(cell::Cell)

Return positions (cartesian coordinates) of the atoms in a structure.

rattle!(cell::Cell, amp)

Rattle the positions of the cell for a given maximum amplitude (uniform distribution).

reduced_fu(structure::Cell)

Return the reduced formula.

set_cellmat!(cell::Cell, mat;scale_positions=true)

Update the Lattice with a new matrix of lattice vectors. Scale of the existing postions if needed.

set_positions!(cell::Cell, pos)

Set the positions of the Cell with a new matrix.

set_scaled_positions!(cell::Cell, scaled::Matrix)

Set scaled positions for a cell.

sorted_symbols(symbols)

Return sorted symbols by atomic numbers.

species(structure::Cell)

Return a Vector of species names.

specindex(structure::Cell)

Return the unique species and integer based indices for each atom.

sposarray(cell::Cell)

Return the positions as a Vector of static arrays. The returned array can provide improved performance for certain type of operations.

volume(structure::Cell)

Return the volume of the cell.

wrap!(vec::AbstractVector, l::Lattice)

Wrap a vector back to the periodic box defined by the lattice vectors.

wrap!(cell::Cell)

Wrap an atom outside of the lattice back into the box defined by the lattice vectors.

wrapped_spos(cell)

Return a static array of wrapped positons.

write_cell(fname, cell::Cell)

Cell(cell::SCell)

Return a Cell object from Spglib.Cell where the SCell.types have been changed to 1-based index. This is useful when the Spglib._expand_cell is called where the types returned is re-indexed.

Cell(cell::SCell)

Return a Cell object from Spglib.Cell.

Alias for Spglib.Cell

SCell(cell::Cell)

Construct Spglib.Cell from Cell type.

niggli_reduce_cell(cell::Cell; wrap_pos=true)

Apply niggli reduction to the lattice using Spglib

niggli_reduce(cell::Cell, symprec=1e-5;)

Apply niggli reduction to the lattice using Spglib. The positions are not wrapped.

Macro for extending the Spglib methods.

Usage:

@extend_scell get_dataset

will allow the get_dataset method of Spglib to be used for Cell type.

Macro for extending the Spglib methods and convert returned Spglib.Cell to Cell.

Usage:

@extend_scell_roundtrip standardize_cell

will allow the standardize_cell method to be used and the returned Spglib.Cell is converted to Cell. This assumes the only changes made is on the Lattice and there is no change in the atomic positions/orders.

Macro for extending the Spglib methods and convert returned Spglib.Cell to Cell.

Usage:

@extend_scell_roundtrip_new find_primitive

will allow the standardize_cell method to be used and the returned Spglib.Cell is converted to Cell.

2D Gauss reduction

Works for column vectors instead of row vectors

convert cell parameters to column vectors

Check if cell parameters are valid

Convert cell vectors to cell parameters

Returns an static array of the cell parameters

Compute volume from cell parameters

Represent an array of points after expansion by periodic boundary

ExtendedPointArray(cell::Cell, rcut)

Constructed an ExtendedPointArray from a given structure. Implicitly, the positions are wrapped inside the unit cell, even if the actual in the original Cell is outside the unit cell. This ensures the correct neighbour list begin constructed.

Iterator interface for going through all neighbours

Iterator interface for going through all neighbours

NeighbourList{T,N}

Type for representing a neighbour list

NeighbourList(ea::ExtendedPointArray, rcut, nmax=1000; savevec=false)

Construct a NeighbourList from an extended point array for the points in the original cell

_need_rebuild(nl::NeighbourList)

Check if a full rebuild is needed for the NeighbourList if the skin is used and if any atom has move more than the skin.

_update_ea_no_lattice_change(ea, cell)

Update extended points without lattice shifts - apply displacements to all image points

_update_ea_with_lattice_change(ea, cell)

Update extended points with lattice shifts - need to rebuild from scratch

Check if a static vector only contains zeros

Iterate the neighbours of a site in the original cell. Returns a tuple of (originalindex, extendedindex, distance) for each iteration

Iterate the neighbours of a site in the original cell. Returns a tuple of (originalindex, extendedindex, distance, vector) for each iteration

get_neighbour(nl::NeighbourList, iorig::Int, idx::Int)

Return a single neighbour.

get_neighbours(nl::NeighbourList, iorig::Int)

Return a Vector of Neighbour objects

Number of ions in the extended cell

Number of ions in the extended cell

Number of ions in the original cell

Number of ions in the original cell

Number of neighbours for a point

rebuild!(ea::ExtendedPointArray, cell)

Rebuild the ExtendedPointArray for an existing cell

rebuild(nl::NeighbourList, cell::Cell)

Perform a full rebuild of the NeighbourList with the latest geometry of the cell

rebuild!(nl::NeighbourList, ea::ExtendedPointArray)

Perform a full rebuild of the neighbour list from scratch for a given ExtendedPointArray. Extended the neighbour storage space if necessary.

update!(nl::NeighbourList, cell::Cell)

Update the NeighbourList with the latest geometry of the Cell. No rebuilding is performed.

Update the calculated distances/vectors but do not rebuild the whole neighbour list

increase_nmax!(nl::NeighbourList, nmax)

Increase the maximum number of neighbours storable in the neighbour list

Read an array containing the lines of the SHELX file

read_res_many(s::AbstractString)

Read many SHELX files from a packed file.

read_res_many(s::IO)

Read many SHELX files from an IO stream

write_res(fname::AbstractString, structure::Cell, mode="w")

Write out SHELX format data to a file

write_res(io::IO, structure::Cell)

Write out SHELX format data including additional information stored in structure.metadata.

Supported keys: :label, :pressure, :volume, :enthalpy, :spin, :abs_spin, :symm, :flag1, flag2, flag3.

The following fields are also treated as the REM line:

• info: If a Dict is supplied the key-value pairs will be written.
• comments: Any additional comments to be written. Must be supplied as a Vector{<:AbstractString}.

The composition of the structure will be written as REM Composition: <E1> <N1> <E2> <N2>.

_process_xyz_attr(attr)

Process ExtXYZ attribute string.

xyz lines for a single frame

Read XYZ file

NOTE: This is a pure julia implementation which may not work with all cases. In the future, better to use ExtXYZ.jl interface.

Write snapshots to a xyz file

Parse the tag line, return a dictionary of the tagline is in the form of <ionsetname> % KEY=VALUE KEY=VALUE

Clean lines by removing new line symbols and comments

Get rid of blocks

Filter away block names contained in only

Find the block with given name, return a Vector of the lines Comments are skipped

Parse tag lines, return a vector of dictionary containing parsed tags

Read a cell file

Read content of a cell file

Read cell related sections

Read a numerical block in the form of a vector of String

Read positions related sections

Read in cell

Read seed with the label parsed. At this stage no explansions are done

Separate the unit from the actual content of the block

Representation of a snapshot

Get the number of ions

Read the initial structure and its energy/forces

read_castep(fname::String)

Read a CASTEP file, return a Vector of the Snapshots

Read fractional coordinates (column vectors) from a table

Read lattice vectors from the lines (column vectors)

Skip to the next header

Commandline options for SHEAP

Record the default options of SHEAP commandline

Prase the output of SHEAP from an IO object

run_sheap(vecs, opt::SheapOptions;metadata=repeat([SheapMetadata()], length(vecs)), show_stderr=true)

Run SHEAP for a iterator of vectors with the given options.