def test_eigh_orthogonal():
gr = _get()
# The most simple setup.
sp = SparseOrbitalBZ(gr)
sp[0, 0] = 0.5
sp[1, 1] = 0.5
assert np.allclose(sp.eigh(), [0.5, 0.5])
assert np.allclose(sp.eigh([0.5] * 3), [0.5, 0.5])
def test_eigsh_orthogonal():
gr = _get()
# The most simple setup.
sp = SparseOrbitalBZ(gr)
sp[0, 0] = 0.5
sp[1, 1] = 0.5
# Fails due to too many requested eigenvalues
sp.eigsh()
def test_eigh_non_orthogonal():
gr = _get()
# The most simple setup.
sp = SparseOrbitalBZ(gr, orthogonal=False)
sp[0, 0] = 0.5
sp[1, 1] = 0.5
sp.S[0, 0] = 1.
sp.S[1, 1] = 1.
assert np.allclose(sp.eigh(), [0.5, 0.5])
def test_S():
gr = _get()
# The most simple setup.
sp = SparseOrbitalBZ(gr, orthogonal=False)
sp[0, 0] = 0.5
sp[1, 1] = 0.5
sp.S[0, 0] = 1.
sp.S[1, 1] = 1.
assert sp[1, 1, 0] == pytest.approx(0.5)
assert sp.S[1, 1] == pytest.approx(1.)
def read_overlap(self, **kwargs):
""" Returns the overlap matrix from the TranSiesta file """
tshs_g = self.read_geometry()
geom = _geometry_align(tshs_g, kwargs.get('geometry', tshs_g),
self.__class__, 'read_overlap')
# read the sizes used...
sizes = _siesta.read_tshs_sizes(self.file)
_bin_check(self, 'read_overlap', 'could not read sizes.')
isc = _siesta.read_tshs_cell(self.file, sizes[3])[2].T
_bin_check(self, 'read_overlap', 'could not read cell.')
no = sizes[2]
nnz = sizes[4]
ncol, col, dS = _siesta.read_tshs_s(self.file, no, nnz)
_bin_check(self, 'read_overlap', 'could not read overlap matrix.')
# Create the Hamiltonian container
S = SparseOrbitalBZ(geom, nnzpr=1)
# Create the new sparse matrix
S._csr.ncol = ncol.astype(np.int32, copy=False)
S._csr.ptr = np.insert(np.cumsum(ncol, dtype=np.int32), 0, 0)
# Correct fortran indices
S._csr.col = col.astype(np.int32, copy=False) - 1
S._csr._nnz = len(col)
S._csr._D = _a.emptyd([nnz, 1])
S._csr._D[:, 0] = dS[:]
# Convert to sisl supercell
_csr_from_sc_off(S.geometry, isc, S._csr)
return S
def read_overlap(self, **kwargs):
""" Returns the overlap matrix from the siesta.HSX file """
# Now read the sizes used...
Gamma, spin, no, no_s, nnz = _siesta.read_hsx_sizes(self.file)
ncol, col, dS = _siesta.read_hsx_s(self.file, Gamma, spin, no, no_s, nnz)
geom = kwargs.get('geometry', kwargs.get('geom', None))
if geom is None:
warn(self.__class__.__name__ + ".read_overlap requires input geometry to assign S")
if geom.no != no:
raise SileError(self.__class__.__name__ + '.read_overlap could not use the '
'passed geometry as the number of atoms or orbitals is '
'inconsistent with HSX file.')
# Create the Hamiltonian container
S = SparseOrbitalBZ(geom, nnzpr=1)
# Create the new sparse matrix
S._csr.ncol = ncol.astype(np.int32, copy=False)
S._csr.ptr = np.insert(np.cumsum(ncol, dtype=np.int32), 0, 0)
# Correct fortran indices
S._csr.col = col.astype(np.int32, copy=False) - 1
S._csr._nnz = len(col)
S._csr._D = np.empty([nnz, 1], np.float32)
S._csr._D[:, 0] = dS[:]
# Convert the supercells to sisl supercells
if no_s // no == np.product(geom.nsc):
_csr_from_siesta(geom, S._csr)
return S
def read_overlap(self, **kwargs):
""" Returns the overlap matrix from the siesta.HSX file """
# Now read the sizes used...
Gamma, spin, no, no_s, nnz = _siesta.read_hsx_sizes(self.file)
ncol, col, dS = _siesta.read_hsx_s(self.file, Gamma, spin, no, no_s,
nnz)
geom = kwargs.get('geometry', kwargs.get('geom', None))
if geom is None:
warn(self.__class__.__name__ +
".read_overlap requires input geometry to assign S")
if geom.no != no:
raise ValueError(
"Reading HSX files requires the input geometry to have the "
"correct number of orbitals {} / {}.".format(no, geom.no))
# Create the Hamiltonian container
S = SparseOrbitalBZ(geom, nnzpr=1)
# Create the new sparse matrix
S._csr.ncol = ncol.astype(np.int32, copy=False)
S._csr.ptr = np.insert(np.cumsum(ncol, dtype=np.int32), 0, 0)
# Correct fortran indices
S._csr.col = col.astype(np.int32, copy=False) - 1
S._csr._nnz = len(col)
S._csr._D = np.empty([nnz, 1], np.float32)
S._csr._D[:, 0] = dS[:]
return S
def read_overlap(self, **kwargs):
""" Returns the overlap matrix from the siesta.TSHS file """
# First read the geometry
geom = self.read_geometry()
# Now read the sizes used...
sizes = _siesta.read_tshs_sizes(self.file)
no = sizes[2]
nnz = sizes[4]
ncol, col, dS = _siesta.read_tshs_s(self.file, no, nnz)
# Create the Hamiltonian container
S = SparseOrbitalBZ(geom, nnzpr=1)
# Create the new sparse matrix
S._csr.ncol = ncol.astype(np.int32, copy=False)
S._csr.ptr = np.insert(np.cumsum(ncol, dtype=np.int32), 0, 0)
# Correct fortran indices
S._csr.col = col.astype(np.int32, copy=False) - 1
S._csr._nnz = len(col)
S._csr._D = np.empty([nnz, 1], np.float64)
S._csr._D[:, 0] = dS[:]
return S
def test_sparse_orbital_bz_hermitian(n0, n1, n2):
g = geom.fcc(1., Atom(1, R=1.5)) * 2
s = SparseOrbitalBZ(g)
s.construct([[0.1, 1.51], [1, 2]])
s = s.tile(n0, 0).tile(n1, 1).tile(n2, 2)
no = s.geometry.no
nnz = 0
for io in range(no):
# orbitals connecting to io
edges = s.edges(io)
# Figure out the transposed supercell indices of the edges
isc = -s.geometry.o2isc(edges)
# Convert to supercell
IO = s.geometry.sc.sc_index(isc) * no + io
# Figure out if 'io' is also in the back-edges
for jo, edge in zip(IO, edges % no):
assert jo in s.edges(edge)
nnz += 1
# Check that we have counted all nnz
assert s.nnz == nnz
# Since we are also dealing with f32 data-types we cannot go beyond 1e-7
approx_zero = pytest.approx(0., abs=1e-5)
for k0 in [0, 0.1]:
for k1 in [0, -0.15]:
for k2 in [0, 0.33333]:
k = (k0, k1, k2)
if np.allclose(k, 0.):
dtypes = [None, np.float32, np.float64]
else:
dtypes = [None, np.complex64, np.complex128]
# Also assert Pk == Pk.H for all data-types
for dtype in dtypes:
Pk = s.Pk(k=k, format='csr', dtype=dtype)
assert abs(Pk - Pk.getH()).toarray().max() == approx_zero
Pk = s.Pk(k=k, format='array', dtype=dtype)
assert np.abs(Pk - np.conj(Pk.T)).max() == approx_zero
def test_pickle_non_orthogonal():
import pickle as p
gr = _get()
sp = SparseOrbitalBZ(gr, orthogonal=False)
sp[0, 0] = 0.5
sp[1, 1] = 0.5
sp.S[0, 0] = 1.
sp.S[1, 1] = 1.
s = p.dumps(sp)
SP = p.loads(s)
assert sp.spsame(SP)
assert np.allclose(sp.eigh(), SP.eigh())
def read_overlap(self, **kwargs):
""" Returns the overlap matrix from the siesta.TSHS file """
tshs_g = self.read_geometry()
geom = kwargs.get('geometry', tshs_g)
if geom.na != tshs_g.na or geom.no != tshs_g.no:
raise SileError(
self.__class__.__name__ + '.read_overlap could not use the '
'passed geometry as the number of atoms or orbitals is '
'inconsistent with TSHS file.')
# Ensure that the number of supercells is correct
if np.any(geom.nsc != tshs_g.nsc):
geom.set_nsc(tshs_g.nsc)
# read the sizes used...
sizes = _siesta.read_tshs_sizes(self.file)
_bin_check(self, 'read_overlap', 'could not read sizes.')
isc = _siesta.read_tshs_cell(self.file, sizes[3])[2].T
_bin_check(self, 'read_overlap', 'could not read cell.')
no = sizes[2]
nnz = sizes[4]
ncol, col, dS = _siesta.read_tshs_s(self.file, no, nnz)
_bin_check(self, 'read_overlap', 'could not read overlap matrix.')
# Create the Hamiltonian container
S = SparseOrbitalBZ(geom, nnzpr=1)
# Create the new sparse matrix
S._csr.ncol = ncol.astype(np.int32, copy=False)
S._csr.ptr = np.insert(np.cumsum(ncol, dtype=np.int32), 0, 0)
# Correct fortran indices
S._csr.col = col.astype(np.int32, copy=False) - 1
S._csr._nnz = len(col)
S._csr._D = np.empty([nnz, 1], np.float64)
S._csr._D[:, 0] = dS[:]
# Convert to sisl supercell
_csr_from_sc_off(S.geometry, isc, S._csr)
return S
def test_eigsh_non_orthogonal():
sp = SparseOrbitalBZ(_get(), orthogonal=False)
sp.construct([(0.1, 1.44), ([0, 1.], [-2.7, 0])])
sp.eigsh(n=1)
def test_str():
gr = _get()
# The most simple setup.
sp = SparseOrbitalBZ(gr)
str(sp)
def test_eigsh_non_orthogonal():
gr = _get()
# The most simple setup.
sp = SparseOrbitalBZ(gr, orthogonal=False)
sp.eigsh()