SparseOrbital¶
-
class
sisl.
SparseOrbital
(geometry, dim=1, dtype=None, nnzpr=None, **kwargs)[source]¶ Sparse object with number of rows equal to the total number of orbitals in the
Geometry
Attributes
Number of components per element
Data type of sparse elements (in str)
Data type of sparse elements
Whether the contained data is finalized and non-used elements have been removed
Associated geometry
Associated geometry
Number of non-zero elements
Shape of sparse matrix
Methods
Rij
(self[, what, dtype])Create a sparse matrix with the vectors between atoms/orbitals
__init__
(self, geometry[, dim, dtype, nnzpr])Create sparse object with element between orbitals
append
(self, other, axis[, eps])Append other along axis to construct a new connected sparse matrix
construct
(self, func[, na_iR, method, eta])Automatically construct the sparse model based on a function that does the setting up of the elements
copy
(self[, dtype])A copy of this object
create_construct
(self, R, param)Create a simple function for passing to the
construct
function.cut
(self, seps, axis, \*args, \*\*kwargs)Cuts the sparse orbital model into different parts.
edges
(self[, atom, exclude, orbital])Retrieve edges (connections) of a given
atom
or list ofatom
’seliminate_zeros
(self[, atol])Removes all zero elements from the sparse matrix
empty
(self[, keep_nnz])See
empty
for detailsfinalize
(self)Finalizes the model
fromsp
(geom, \*sp)Create a sparse model from a preset Geometry and a list of sparse matrices
iter_nnz
(self[, atom, orbital])Iterations of the non-zero elements
nonzero
(self[, atom, only_col])Indices row and column indices where non-zero elements exists
prepend
(self, other, axis[, eps])See
append
for detailsremove
(self, atom[, orb_index])Remove a subset of this sparse matrix by only retaining the atoms corresponding to
atom
remove_orbital
(self, atom, orbital)Remove a subset of orbitals on
atom
according toorbital
repeat
(self, reps, axis)Create a repeated sparse orbital object, equivalent to
Geometry.repeat
reset
(self[, dim, dtype, nnzpr])The sparsity pattern has all elements removed and everything is reset.
rij
(self[, what, dtype])Create a sparse matrix with the distance between atoms/orbitals
set_nsc
(self, \*args, \*\*kwargs)Reset the number of allowed supercells in the sparse orbital
spalign
(self, other)See
align
for detailsspsame
(self, other)Compare two sparse objects and check whether they have the same entries.
sub
(self, atom)Create a subset of this sparse matrix by only retaining the atoms corresponding to
atom
sub_orbital
(self, atom, orbital)Retain only a subset of the orbitals on
atom
according toorbital
swap
(self, a, b)Swaps atoms in the sparse geometry to obtain a new order of atoms
tile
(self, reps, axis)Create a tiled sparse orbital object, equivalent to
Geometry.tile
toSparseAtom
(self[, dim, dtype])Convert the sparse object (without data) to a new sparse object with equivalent but reduced sparse pattern
tocsr
(self[, dim, isc])Return a
csr_matrix
for the specified dimensiontranspose
(self)Create the transposed sparse geometry by interchanging supercell indices
-
Rij
(self, what='orbital', dtype=<class 'numpy.float64'>)[source]¶ Create a sparse matrix with the vectors between atoms/orbitals
- Parameters
- what{‘orbital’, ‘atom’}
which kind of sparse vector matrix to return, either an atomic vector matrix or an orbital vector matrix. The orbital matrix is equivalent to the atomic one with the same vectors repeated for the same atomic orbitals. The default is the same type as the parent class.
- dtypenumpy.dtype, optional
the data-type of the sparse matrix.
Notes
The returned sparse matrix with vectors are taken from the current sparse pattern. I.e. a subsequent addition of sparse elements will make them inequivalent. It is thus important to only create the sparse vector matrix when the sparse structure is completed.
-
append
(self, other, axis, eps=0.01)[source]¶ Append other along axis to construct a new connected sparse matrix
This method tries to append two sparse geometry objects together by the following these steps:
Create the new extended geometry
Use neighbor cell couplings from self as the couplings to other This may cause problems if the coupling atoms are not exactly equi-positioned. If the coupling coordinates and the coordinates in other differ by more than 0.001 Ang, a warning will be issued. If this difference is above eps the couplings will be removed.
When appending sparse matrices made up of atoms, this method assumes that the orbitals on the overlapping atoms have the same orbitals, as well as the same orbital ordering.
- Parameters
- otherobject
must be an object of the same type as self
- axisint
axis to append the two sparse geometries along
- epsfloat, optional
tolerance that all coordinates must be within to allow an append. It is important that this value is smaller than half the distance between the two closests atoms such that there is no ambiguity in selecting equivalent atoms. An internal stricter eps is used as a baseline, see above.
- Returns
- object
a new instance with two sparse matrices joined and appended together
- Raises
- ValueError if atomic coordinates does not overlap within eps
See also
prepend
equivalent scheme as this method
transpose
ensure hermiticity by using this routine
Geometry.append
Geometry.prepend
Notes
This routine and how it is functioning may change in future releases. There are many design choices in how to assign the matrix elements when combining two models and it is not clear what is the best procedure.
The current implentation does not preserve the hermiticity of the matrix.
Examples
>>> sporb = SparseOrbital(....) >>> forced_hermitian = (sporb + sporb.transpose()) * 0.5
-
construct
(self, func, na_iR=1000, method='rand', eta=False)¶ Automatically construct the sparse model based on a function that does the setting up of the elements
This may be called in two variants.
Pass a function (func), see e.g.
create_construct
which does the setting up.Pass a tuple/list in func which consists of two elements, one is
R
the radii parameters for the corresponding parameters. The second is the parameters corresponding to theR[i]
elements. In this second case all atoms must only have one orbital.
- Parameters
- funccallable or array_like
this function must take 4 arguments. 1. Is this object (
self
) 2. Is the currently examined atom (ia
) 3. Is the currently bounded indices (idxs
) 4. Is the currently bounded indices atomic coordinates (idxs_xyz
) An example func could be:>>> def func(self, ia, idxs, idxs_xyz=None): ... idx = self.geometry.close(ia, R=[0.1, 1.44], idx=idxs, idx_xyz=idxs_xyz) ... self[ia, idx[0]] = 0 ... self[ia, idx[1]] = -2.7
- na_iRint, optional
number of atoms within the sphere for speeding up the iter_block loop.
- method{‘rand’, str}
method used in
Geometry.iter_block
, see there for details- etabool, optional
whether an ETA will be printed
See also
create_construct
a generic function used to create a generic function which this routine requires
tile
tiling after construct is much faster for very large systems
repeat
repeating after construct is much faster for very large systems
-
copy
(self, dtype=None)¶ A copy of this object
- Parameters
- dtypenumpy.dtype, optional
it is possible to convert the data to a different data-type If not specified, it will use
self.dtype
-
create_construct
(self, R, param)¶ Create a simple function for passing to the
construct
function.This is simply to leviate the creation of simplistic functions needed for setting up the sparse elements.
Basically this returns a function:
>>> def func(self, ia, idxs, idxs_xyz=None): ... idx = self.geometry.close(ia, R=R, idx=idxs) ... for ix, p in zip(idx, param): ... self[ia, ix] = p
- Parameters
- Rarray_like
radii parameters for different shells. Must have same length as param or one less. If one less it will be extended with
R[0]/100
- paramarray_like
coupling constants corresponding to the R ranges.
param[0,:]
are the elements for the all atoms withinR[0]
of each atom.
See also
construct
routine to create the sparse matrix from a generic function (as returned from
create_construct
)
Notes
This function only works for geometry sparse matrices (i.e. one element per atom). If you have more than one element per atom you have to implement the function your-self.
-
cut
(self, seps, axis, *args, **kwargs)[source]¶ Cuts the sparse orbital model into different parts.
Recreates a new sparse orbital object with only the cutted atoms in the structure.
Cutting is the opposite of tiling.
- Parameters
- sepsint
number of times the structure will be cut
- axisint
the axis that will be cut
-
property
dim
¶ Number of components per element
-
property
dkind
¶ Data type of sparse elements (in str)
-
property
dtype
¶ Data type of sparse elements
-
edges
(self, atom=None, exclude=None, orbital=None)[source]¶ Retrieve edges (connections) of a given
atom
or list ofatom
’sThe returned edges are unique and sorted (see
numpy.unique
) and are returned in supercell indices (i.e.0 <= edge < self.geometry.no_s
).- Parameters
- atomint or list of int
the edges are returned only for the given atom (but by using all orbitals of the requested atom). The returned edges are also atoms.
- excludeint or list of int, optional
remove edges which are in the exclude list. Default to
atom
.- orbitalint or list of int
the edges are returned only for the given orbital. The returned edges are orbitals.
See also
SparseCSR.edges
the underlying routine used for extracting the edges
-
eliminate_zeros
(self, atol=0.0)¶ Removes all zero elements from the sparse matrix
This is an in-place operation.
- Parameters
- atolfloat, optional
absolute tolerance equal or below this value will be considered 0.
-
empty
(self, keep_nnz=False)¶ See
empty
for details
-
finalize
(self)¶ Finalizes the model
Finalizes the model so that all non-used elements are removed. I.e. this simply reduces the memory requirement for the sparse matrix.
Note that adding more elements to the sparse matrix is more time-consuming than for a non-finalized sparse matrix due to the internal data-representation.
-
property
finalized
¶ Whether the contained data is finalized and non-used elements have been removed
-
classmethod
fromsp
(geom, *sp)¶ Create a sparse model from a preset Geometry and a list of sparse matrices
-
property
geom
¶ Associated geometry
-
property
geometry
¶ Associated geometry
-
iter_nnz
(self, atom=None, orbital=None)[source]¶ Iterations of the non-zero elements
An iterator on the sparse matrix with, row and column
- Parameters
- atomint or array_like
only loop on the non-zero elements coinciding with the orbitals on these atoms (not compatible with the
orbital
keyword)- orbitalint or array_like
only loop on the non-zero elements coinciding with the orbital (not compatible with the
atom
keyword)
Examples
>>> for i, j in self.iter_nnz(): ... self[i, j] # is then the non-zero value
-
property
nnz
¶ Number of non-zero elements
-
nonzero
(self, atom=None, only_col=False)[source]¶ Indices row and column indices where non-zero elements exists
- Parameters
- atomint or array_like of int, optional
only return the tuples for the requested atoms, default is all atoms But for all orbitals.
- only_colbool, optional
only return then non-zero columns
See also
SparseCSR.nonzero
the equivalent function call
-
prepend
(self, other, axis, eps=0.01)[source]¶ See
append
for detailsThis is currently equivalent to:
>>> other.append(self, axis, eps)
-
remove
(self, atom, orb_index=None)[source]¶ Remove a subset of this sparse matrix by only retaining the atoms corresponding to
atom
- Parameters
- atomarray_like of int or Atom
indices of removed atoms or Atom for direct removal of all atoms
See also
Geometry.remove
equivalent to the resulting
Geometry
from this routineGeometry.sub
the negative of
Geometry.remove
sub
the opposite of
remove
, i.e. retain a subset of atoms
-
remove_orbital
(self, atom, orbital)[source]¶ Remove a subset of orbitals on
atom
according toorbital
- Parameters
- atomarray_like of int or Atom
indices of atoms or
Atom
that will be reduced in size according toorbital
- orbitalarray_like of int or Orbital
indices of the orbitals on
atom
that are removed from the sparse matrix.
Examples
>>> obj = SparseOrbital(...) >>> # remove the second orbital on the 2nd atom >>> # all other orbitals are retained >>> obj.remove_orbital(1, 1)
-
repeat
(self, reps, axis)[source]¶ Create a repeated sparse orbital object, equivalent to
Geometry.repeat
The already existing sparse elements are extrapolated to the new supercell by repeating them in blocks like the coordinates.
- Parameters
- repsint
number of repetitions along cell-vector axis
- axisint
0, 1, 2 according to the cell-direction
See also
Geometry.repeat
the same ordering as the final geometry
Geometry.tile
a different ordering of the final geometry
tile
a different ordering of the final geometry
-
reset
(self, dim=None, dtype=<class 'numpy.float64'>, nnzpr=None)¶ The sparsity pattern has all elements removed and everything is reset.
The object will be the same as if it had been initialized with the same geometry as it were created with.
- Parameters
- dimint, optional
number of dimensions per element, default to the current number of elements per matrix element.
- dtypenumpy.dtype, optional
the datatype of the sparse elements
- nnzprint, optional
number of non-zero elements per row
-
rij
(self, what='orbital', dtype=<class 'numpy.float64'>)[source]¶ Create a sparse matrix with the distance between atoms/orbitals
- Parameters
- what{‘orbital’, ‘atom’}
which kind of sparse distance matrix to return, either an atomic distance matrix or an orbital distance matrix. The orbital matrix is equivalent to the atomic one with the same distance repeated for the same atomic orbitals. The default is the same type as the parent class.
- dtypenumpy.dtype, optional
the data-type of the sparse matrix.
Notes
The returned sparse matrix with distances are taken from the current sparse pattern. I.e. a subsequent addition of sparse elements will make them inequivalent. It is thus important to only create the sparse distance when the sparse structure is completed.
-
set_nsc
(self, *args, **kwargs)[source]¶ Reset the number of allowed supercells in the sparse orbital
If one reduces the number of supercells any sparse element that references the supercell will be deleted.
See
SuperCell.set_nsc
for allowed parameters.See also
SuperCell.set_nsc
the underlying called method
-
property
shape
¶ Shape of sparse matrix
-
spalign
(self, other)¶ See
align
for details
-
spsame
(self, other)¶ Compare two sparse objects and check whether they have the same entries.
This does not necessarily mean that the elements are the same
-
sub
(self, atom)[source]¶ Create a subset of this sparse matrix by only retaining the atoms corresponding to
atom
Negative indices are wrapped and thus works, supercell atoms are also wrapped to the unit-cell.
- Parameters
- atomarray_like of int or Atom
indices of retained atoms or
Atom
for retaining only that atom
See also
Geometry.remove
the negative of
Geometry.sub
Geometry.sub
equivalent to the resulting
Geometry
from this routineremove
the negative of
sub
, i.e. remove a subset of atoms
Examples
>>> obj = SparseOrbital(...) >>> obj.sub(1) # only retain the second atom in the SparseGeometry >>> obj.sub(obj.atoms.atom[0]) # retain all atoms which is equivalent to >>> # the first atomic specie
-
sub_orbital
(self, atom, orbital)[source]¶ Retain only a subset of the orbitals on
atom
according toorbital
This allows one to retain only a given subset of the sparse matrix elements.
- Parameters
- atomarray_like of int or Atom
indices of atoms or
Atom
that will be reduced in size according toorbital
- orbitalarray_like of int or Orbital
indices of the orbitals on
atom
that are retained in the sparse matrix, the list of orbitals will be sorted. One cannot re-arrange matrix elements currently.
Notes
Future implementations may allow one to re-arange orbitals using this method.
Examples
>>> obj = SparseOrbital(...) >>> # only retain the second orbital on the 2nd atom >>> # all other orbitals are retained >>> obj.sub_orbital(1, 1)
-
swap
(self, a, b)¶ Swaps atoms in the sparse geometry to obtain a new order of atoms
This can be used to reorder elements of a geometry.
- Parameters
- aarray_like
the first list of atomic coordinates
- barray_like
the second list of atomic coordinates
-
tile
(self, reps, axis)[source]¶ Create a tiled sparse orbital object, equivalent to
Geometry.tile
The already existing sparse elements are extrapolated to the new supercell by repeating them in blocks like the coordinates.
- Parameters
- repsint
number of repetitions along cell-vector axis
- axisint
0, 1, 2 according to the cell-direction
See also
Geometry.tile
the same ordering as the final geometry
Geometry.repeat
a different ordering of the final geometry
repeat
a different ordering of the final geometry
-
toSparseAtom
(self, dim=None, dtype=None)[source]¶ Convert the sparse object (without data) to a new sparse object with equivalent but reduced sparse pattern
This converts the orbital sparse pattern to an atomic sparse pattern.
- Parameters
- dimint, optional
number of dimensions allocated in the SparseAtom object, default to the same
- dtypenumpy.dtype, optional
used data-type for the sparse object. Defaults to the same.
-
tocsr
(self, dim=0, isc=None, **kwargs)¶ Return a
csr_matrix
for the specified dimension- Parameters
- dimint, optional
the dimension in the sparse matrix (for non-orthogonal cases the last dimension is the overlap matrix)
- iscint, optional
the supercell index, or all (if
isc=None
)
-
transpose
(self)¶ Create the transposed sparse geometry by interchanging supercell indices
Sparse geometries are (typically) relying on symmetry in the supercell picture. Thus when one transposes a sparse geometry one should ideally get the same matrix. This is true for the Hamiltonian, density matrix, etc.
This routine transposes all rows and columns such that any interaction between row, r, and column c in a given supercell (i,j,k) will be transposed into row c, column r in the supercell (-i,-j,-k).
- Returns
- object
an equivalent sparse geometry with transposed matrix elements
Notes
For Hamiltonians with non-collinear or spin-orbit there is no transposing of the sub-spin matrix box. This needs to be done manually.
Examples
Force a sparse geometry to be Hermitian:
>>> sp = SparseOrbital(...) >>> sp = (sp + sp.transpose()) * 0.5
-