def __init__(self):
bond = 1.42
sq3h = 3.**.5 * 0.5
self.sc = SuperCell(
np.array([[1.5, sq3h, 0.], [1.5, -sq3h, 0.], [0., 0., 10.]],
np.float64) * bond,
nsc=[3, 3, 1])
n = 60
rf = np.linspace(0, bond * 1.01, n)
rf = (rf, rf)
orb = SphericalOrbital(1, rf, 2.)
C = Atom(6, orb.toAtomicOrbital())
self.g = Geometry(
np.array([[0., 0., 0.], [1., 0., 0.]], np.float64) * bond,
atom=C,
sc=self.sc)
self.D = DensityMatrix(self.g)
self.DS = DensityMatrix(self.g, orthogonal=False)
def func(D, ia, idxs, idxs_xyz):
idx = D.geometry.close(ia,
R=(0.1, 1.44),
idx=idxs,
idx_xyz=idxs_xyz)
ia = ia * 3
i0 = idx[0] * 3
i1 = idx[1] * 3
# on-site
p = 1.
D.D[ia, i0] = p
D.D[ia + 1, i0 + 1] = p
D.D[ia + 2, i0 + 2] = p
# nn
p = 0.1
# on-site directions
D.D[ia, ia + 1] = p
D.D[ia, ia + 2] = p
D.D[ia + 1, ia] = p
D.D[ia + 1, ia + 2] = p
D.D[ia + 2, ia] = p
D.D[ia + 2, ia + 1] = p
D.D[ia, i1 + 1] = p
D.D[ia, i1 + 2] = p
D.D[ia + 1, i1] = p
D.D[ia + 1, i1 + 2] = p
D.D[ia + 2, i1] = p
D.D[ia + 2, i1 + 1] = p
self.func = func
def make_dev(ori='zz',
cell_num=(1, 1),
stripe_len=1,
scaling=1,
nsc=[1, 1, 1],
is_finite=False):
"""
Make the device by giving sisl.Geometry an initial orthogonal supercell and
then tiling it
"""
a = 2.46 * scaling
a_z = 3.35
d = a / (2 * np.sqrt(3))
#shift_to_cell = np.array([.5 * d, .75 * a, 0])
carbon_a = Atom(6, R=a / np.sqrt(3) + 0.01, tag='A')
carbon_b = Atom(6, R=a / np.sqrt(3) + 0.01, tag='B')
atom_list = [carbon_a, carbon_b] * 4
xyz = np.array([[0, 0, 0], [d, -a / 2, 0], [3 * d, -a / 2, 0], [
4 * d, 0, 0
], [d, -a / 2, a_z], [2 * d, 0, a_z], [4 * d, 0, a_z],
[5 * d, -a / 2, a_z]]) + np.array([.5 * d, .75 * a, 0])
lat_vecs = np.array([[6 * d, 0, 0], [0, a, 0], [0, 0, 2 * a_z]])
if ori == 'ac':
xyz = np.array([xyz[:, 1], xyz[:, 0], xyz[:, 2]]).T
lat_vecs = np.array([lat_vecs[:, 1], lat_vecs[:, 0], lat_vecs[:, 2]]).T
print('a', a)
# Repeat in the direction of the stripe
xyz = np.concatenate([xyz + i * lat_vecs[0] for i in range(stripe_len)
]) - (stripe_len / 2) * lat_vecs[0]
atom_list = np.concatenate([atom_list for i in range(stripe_len)])
# Repeat in the direction of transport to the left and right of the origin
xyz = np.concatenate([xyz + i * lat_vecs[1] for i in range(sum(cell_num))
]) - cell_num[0] * lat_vecs[1]
atom_list = np.concatenate([atom_list for i in range(sum(cell_num))])
# Generate the supercell lattice vectors
lat_vecs_sc = np.copy(lat_vecs)
lat_vecs_sc[0] *= stripe_len
lat_vecs_sc[1] *= np.sum(cell_num)
print(np.sum(lat_vecs_sc, axis=1))
# Create the geometry and tile it in the non-transport direction
blg = Geometry(xyz, atom_list, sc=SuperCell(list(lat_vecs_sc), nsc=nsc))
return blg
def read_geometry(self, geometry=None):
""" Returns Geometry object from a TranSiesta file """
# Read supercell
sc = self.read_supercell()
na = _siesta.read_tshs_sizes(self.file)[1]
_bin_check(self, 'read_geometry', 'could not read sizes.')
arr = _siesta.read_tshs_geom(self.file, na)
_bin_check(self, 'read_geometry', 'could not read geometry.')
xyz = np.array(arr[0].T, np.float64)
xyz.shape = (-1, 3)
lasto = np.array(arr[1], np.int32)
# Since the TSHS file does not contain species information
# and/or other stuff we *can* reuse an existing
# geometry which contains the correct atomic numbers etc.
orbs = np.diff(lasto)
if geometry is None:
# Create all different atoms...
# The TSHS file does not contain the
# atomic numbers, so we will just
# create them individually
# Get unique orbitals
uorb = np.unique(orbs)
# Create atoms
atoms = []
for Z, orb in enumerate(uorb):
atoms.append(Atom(Z + 1, [-1] * orb))
def get_atom(atoms, orbs):
for atom in atoms:
if atom.no == orbs:
return atom
atom = []
for orb in orbs:
atom.append(get_atom(atoms, orb))
else:
# Create a new geometry with the correct atomic numbers
atom = []
for ia, no in zip(geometry, orbs):
a = geometry.atoms[ia]
if a.no == no:
atom.append(a)
else:
# correct atom
atom.append(
Atom(a.Z, [-1. for io in range(no)],
mass=a.mass,
tag=a.tag))
# Create and return geometry object
return Geometry(xyz, atom, sc=sc)
def sc(alat, atom):
"""
Returns a Simple cubic lattice (1 atom)
"""
sc = SuperCell(np.array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]], np.float64) * alat,
nsc=[3, 3, 3])
g = Geometry([0, 0, 0], atom, sc=sc)
return g
def fcc(alat, atom, orthogonal=False):
"""
Returns a geometry with the FCC crystal structure (1 atom)
"""
if orthogonal:
sc = SuperCell(np.array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]], np.float64) * alat,
nsc=[3, 3, 3])
ah = alat / 2
g = Geometry([[0, 0, 0], [ah, ah, 0],
[ah, 0, ah], [0, ah, ah]], atom, sc=sc)
else:
sc = SuperCell(np.array([[0, 1, 1],
[1, 0, 1],
[1, 1, 0]], np.float64) * alat / 2,
nsc=[3, 3, 3])
g = Geometry([0, 0, 0], atom, sc=sc)
return g
def test_geometry_car_mixed(sisl_tmp):
f = sisl_tmp('test_read_write.POSCAR', _dir)
atoms = [Atom[1], Atom[2], Atom[2], Atom[1], Atom[1], Atom[2], Atom[3]]
xyz = np.random.rand(len(atoms), 3)
geom = Geometry(xyz, atoms, 100)
geom.write(carSileVASP(f, 'w'))
assert carSileVASP(f).read_geometry() == geom
def test_geometry_car_allsame(sisl_tmp):
f = sisl_tmp('test_read_write.POSCAR', _dir)
atoms = Atom[1]
xyz = np.random.rand(10, 3)
geom = Geometry(xyz, atoms, 100)
geom.write(carSileVASP(f, 'w'))
assert carSileVASP(f).read_geometry() == geom
def read_hamiltonian(self, **kwargs):
""" Returns the electronic structure from the siesta.TSHS file """
# Now read the sizes used...
Gamma, spin, no, no_s, nnz = _siesta.read_hsx_sizes(self.file)
_bin_check(self, 'read_hamiltonian',
'could not read Hamiltonian sizes.')
ncol, col, dH, dS, dxij = _siesta.read_hsx_hsx(self.file, Gamma, spin,
no, no_s, nnz)
_bin_check(self, 'read_hamiltonian', 'could not read Hamiltonian.')
# Try and immediately attach a geometry
geom = kwargs.get('geometry', kwargs.get('geom', None))
if geom is None:
# We have *no* clue about the
if np.allclose(dxij, 0.):
# We truly, have no clue,
# Just generate a boxed system
xyz = [[x, 0, 0] for x in range(no)]
geom = Geometry(xyz, Atom(1), sc=[no, 1, 1])
else:
# Try to figure out the supercell
warn(
self.__class__.__name__ + '.read_hamiltonian '
'(currently we can not calculate atomic positions from xij array)'
)
if geom.no != no:
raise SileError(
str(self) + '.read_hamiltonian could not use the '
'passed geometry as the number of atoms or orbitals is '
'inconsistent with HSX file.')
# Create the Hamiltonian container
H = Hamiltonian(geom,
spin,
nnzpr=1,
dtype=np.float32,
orthogonal=False)
# Create the new sparse matrix
H._csr.ncol = ncol.astype(np.int32, copy=False)
H._csr.ptr = np.insert(np.cumsum(ncol, dtype=np.int32), 0, 0)
# Correct fortran indices
H._csr.col = col.astype(np.int32, copy=False) - 1
H._csr._nnz = len(col)
H._csr._D = np.empty([nnz, spin + 1], np.float32)
H._csr._D[:, :spin] = dH[:, :]
H._csr._D[:, spin] = dS[:]
# Convert the supercells to sisl supercells
if no_s // no == np.product(geom.nsc):
_csr_from_siesta(geom, H._csr)
return H
def test_spin_squared(self, setup, k):
g = Geometry([[i, 0, 0] for i in range(10)],
Atom(6, R=1.01),
sc=SuperCell(1, nsc=[3, 1, 1]))
H = Hamiltonian(g, spin=Spin.POLARIZED)
H.construct(([0.1, 1.1], [[0, 0.1], [1, 1.1]]))
H[0, 0] = (0.1, 0.)
H[0, 1] = (0.5, 0.4)
es_alpha = H.eigenstate(k, spin=0)
es_beta = H.eigenstate(k, spin=1)
sup, sdn = spin_squared(es_alpha.state, es_beta.state)
sup1, sdn1 = H.spin_squared(k)
assert sup.sum() == pytest.approx(sdn.sum())
assert np.all(sup1 == sup)
assert np.all(sdn1 == sdn)
assert len(sup) == es_alpha.shape[0]
assert len(sdn) == es_beta.shape[0]
sup, sdn = spin_squared(es_alpha.sub(range(2)).state, es_beta.state)
assert sup.sum() == pytest.approx(sdn.sum())
assert len(sup) == 2
assert len(sdn) == es_beta.shape[0]
sup, sdn = spin_squared(
es_alpha.sub(range(3)).state,
es_beta.sub(range(2)).state)
sup1, sdn1 = H.spin_squared(k, 3, 2)
assert sup.sum() == pytest.approx(sdn.sum())
assert np.all(sup1 == sup)
assert np.all(sdn1 == sdn)
assert len(sup) == 3
assert len(sdn) == 2
sup, sdn = spin_squared(
es_alpha.sub(0).state.ravel(),
es_beta.sub(range(2)).state)
assert sup.sum() == pytest.approx(sdn.sum())
assert sup.ndim == 1
assert len(sup) == 1
assert len(sdn) == 2
sup, sdn = spin_squared(
es_alpha.sub(0).state.ravel(),
es_beta.sub(0).state.ravel())
assert sup.sum() == pytest.approx(sdn.sum())
assert sup.ndim == 0
assert sdn.ndim == 0
sup, sdn = spin_squared(
es_alpha.sub(range(2)).state,
es_beta.sub(0).state.ravel())
assert sup.sum() == pytest.approx(sdn.sum())
assert len(sup) == 2
assert len(sdn) == 1
def read_geometry(self, primary=False, **kwargs):
""" Reads a geometry from the Sile """
# 1st line is number of supercells
nsc = _a.fromiteri(map(int, self.readline().split()[:3]))
na, ns = map(int, self.readline().split()[:2])
# Convert species to atom objects
try:
species = get_sile(self.file.rsplit('REF', 1)[0] +
'orbocc').read_atom()
except:
species = [Atom(s) for s in self.readline().split()[:ns]]
# Total number of super-cells
if primary:
# Only read in the primary unit-cell
ns = 1
else:
ns = np.prod(nsc)
cell = _a.fromiterd(map(float, self.readline().split()))
try:
cell.shape = (3, 3)
if primary:
cell[0, :] /= nsc[0]
cell[1, :] /= nsc[1]
cell[2, :] /= nsc[2]
except:
c = np.empty([3, 3], np.float64)
c[0, 0] = 1. + cell[0]
c[0, 1] = cell[5] / 2.
c[0, 2] = cell[4] / 2.
c[1, 0] = cell[5] / 2.
c[1, 1] = 1. + cell[1]
c[1, 2] = cell[3] / 2.
c[2, 0] = cell[4] / 2.
c[2, 1] = cell[3] / 2.
c[2, 2] = 1. + cell[2]
cell = c * Ang2Bohr
sc = SuperCell(cell * Bohr2Ang, nsc=nsc)
# Create list of coordinates and atoms
xyz = np.empty([na * ns, 3], np.float64)
atoms = [None] * na * ns
# Read the geometry
for ia in range(na * ns):
# Retrieve line
# ix iy iz ia is x y z
line = self.readline().split()
atoms[ia] = species[int(line[4]) - 1]
xyz[ia, :] = _a.fromiterd(map(float, line[5:8]))
return Geometry(xyz * Bohr2Ang, atoms, sc=sc)
def test_op2(self, setup):
g = Geometry([[i, 0, 0] for i in range(100)], Atom(6, R=1.01), sc=[100])
H = Hamiltonian(g, dtype=np.int32)
for i in range(10):
j = range(i*4, i*4+3)
H[0, j] = i
# +
s = H + 1
for jj in j:
assert s[0, jj] == i+1
assert H[0, jj] == i
assert s[1, jj] == 0
# -
s = H - 1
for jj in j:
assert s[0, jj] == i-1
assert H[0, jj] == i
assert s[1, jj] == 0
# -
s = 1 - H
for jj in j:
assert s[0, jj] == 1-i
assert H[0, jj] == i
assert s[1, jj] == 0
# *
s = H * 2
for jj in j:
assert s[0, jj] == i*2
assert H[0, jj] == i
assert s[1, jj] == 0
# //
s = s // 2
for jj in j:
assert s[0, jj] == i
assert H[0, jj] == i
assert s[1, jj] == 0
# **
s = H ** 2
for jj in j:
assert s[0, jj] == i**2
assert H[0, jj] == i
assert s[1, jj] == 0
# ** (r)
s = 2 ** H
for jj in j:
assert s[0, jj], 2 ** H[0 == jj]
assert H[0, jj] == i
assert s[1, jj] == 0
def test_non_colinear_non_orthogonal(self, setup):
g = Geometry([[i, 0, 0] for i in range(10)],
Atom(6, R=1.01),
sc=SuperCell(100, nsc=[3, 3, 1]))
H = Hamiltonian(g,
dtype=np.float64,
orthogonal=False,
spin=Spin.NONCOLINEAR)
for i in range(10):
j = range(i * 2, i * 2 + 3)
H[i, i, 0] = 0.
H[i, i, 1] = 0.
H[i, i, 2] = 0.1
H[i, i, 3] = 0.1
if i > 0:
H[i, i - 1, 0] = 1.
H[i, i - 1, 1] = 1.
if i < 9:
H[i, i + 1, 0] = 1.
H[i, i + 1, 1] = 1.
H.S[i, i] = 1.
eig1 = H.eigh(dtype=np.complex64)
assert np.allclose(H.eigh(dtype=np.complex128), eig1)
assert len(eig1) == len(H)
H1 = Hamiltonian(g,
dtype=np.float64,
orthogonal=False,
spin=Spin('non-collinear'))
for i in range(10):
j = range(i * 2, i * 2 + 3)
H1[i, i, 0] = 0.
H1[i, i, 1] = 0.
H1[i, i, 2] = 0.1
H1[i, i, 3] = 0.1
if i > 0:
H1[i, i - 1, 0] = 1.
H1[i, i - 1, 1] = 1.
if i < 9:
H1[i, i + 1, 0] = 1.
H1[i, i + 1, 1] = 1.
H1.S[i, i] = 1.
assert H1.spsame(H)
eig1 = H1.eigh(dtype=np.complex64)
assert np.allclose(H1.eigh(dtype=np.complex128), eig1)
assert np.allclose(H.eigh(dtype=np.complex64),
H1.eigh(dtype=np.complex128))
es = H1.eigenstate(dtype=np.complex128)
assert np.allclose(es.eig, eig1)
es.spin_moment()
PDOS = es.PDOS(np.linspace(-1, 1, 100))
DOS = es.DOS(np.linspace(-1, 1, 100))
assert np.allclose(PDOS.sum(1)[0, :], DOS)
def test_geometry(sisl_tmp):
f = sisl_tmp('GRID.cube', _dir)
geom = Geometry(np.random.rand(10, 3), np.random.randint(1, 70, 10), sc=[10, 10, 10, 45, 60, 90])
grid = Grid(0.2, geometry=geom)
grid.grid = np.random.rand(*grid.shape)
grid.write(f)
read = grid.read(f)
assert np.allclose(grid.grid, read.grid)
assert not grid.geometry is None
assert not read.geometry is None
assert grid.geometry == read.geometry
def read_geometry(self, velocity=False, species_Z=False):
""" Returns a `Geometry` object from the XV file
Parameters
----------
species_Z : bool, optional
if ``True`` the atomic numbers are the species indices (useful when
reading the ChemicalSpeciesLabel block simultaneously).
velocity : bool, optional
also return the velocities in the file
Returns
-------
Geometry
velocity : only if `velocity` is true.
"""
sc = self.read_supercell()
# Read number of atoms
na = int(self.readline())
xyz = np.empty([na, 3], np.float64)
vel = np.empty([na, 3], np.float64)
atms = [None] * na
sp = np.empty([na], np.int32)
for ia in range(na):
line = list(map(float, self.readline().split()[:8]))
sp[ia] = int(line[0])
if species_Z:
atms[ia] = Atom(sp[ia])
else:
atms[ia] = Atom(int(line[1]))
xyz[ia, :] = line[2:5]
vel[ia, :] = line[5:8]
xyz *= Bohr2Ang
vel *= Bohr2Ang
# Ensure correct sorting
max_s = sp.max()
sp -= 1
# Ensure we can remove the atom after having aligned them
atms2 = Atoms(AtomUnknown(1000), na=na)
for i in range(max_s):
idx = (sp[:] == i).nonzero()[0]
if len(idx) == 0:
# Always ensure we have "something" for the unoccupied places
atms2[idx] = AtomUnknown(1000 + i)
else:
atms2[idx] = atms[idx[0]]
geom = Geometry(xyz, atms2.reduce(), sc=sc)
if velocity:
return geom, vel
return geom
def __init__(self):
bond = 1.42
sq3h = 3.**.5 * 0.5
self.sc = SuperCell(np.array([[1.5, sq3h, 0.],
[1.5, -sq3h, 0.],
[0., 0., 10.]], np.float64) * bond, nsc=[3, 3, 1])
C = Atom(Z=6, R=[bond * 1.01])
self.g = Geometry(np.array([[0., 0., 0.],
[1., 0., 0.]], np.float64) * bond,
atom=C, sc=self.sc)
self.H = Hamiltonian(self.g)
self.HS = Hamiltonian(self.g, orthogonal=False)
C = Atom(Z=6, R=[bond * 1.01] * 2)
self.g2 = Geometry(np.array([[0., 0., 0.],
[1., 0., 0.]], np.float64) * bond,
atom=C, sc=self.sc)
self.H2 = Hamiltonian(self.g2)
self.HS2 = Hamiltonian(self.g2, orthogonal=False)
def test_berry_phase_method_fail(self):
g = Geometry([[-.6, 0, 0], [0.6, 0, 0]], Atom(1, 1.001), sc=[2, 10, 10])
g.set_nsc([3, 1, 1])
H = Hamiltonian(g)
H.construct([(0.1, 1.0, 1.5), (0, 1., 0.5)])
# Contour
k = np.linspace(0.0, 1.0, 101)
K = np.zeros([k.size, 3])
K[:, 0] = k
bz = BrillouinZone(H, K)
berry_phase(bz, method='unknown')
def hcp(a, atoms, coa=1.63333, orthogonal=False):
""" Hexagonal closed packed lattice with 2 (non-orthogonal) or 4 atoms (orthogonal)
Parameters
----------
a : float
lattice parameter for 1st and 2nd lattice vectors
atoms : Atom
the atom(s) in the HCP lattice
coa : float, optional
c over a parameter where c is the 3rd lattice vector length
orthogonal : bool, optional
whether the lattice is orthogonal (4 atoms)
"""
# height of hcp structure
c = a * coa
a2sq = a / 2**.5
if orthogonal:
sc = SuperCell([[a + a * _c60 * 2, 0, 0], [0, a * _c30 * 2, 0],
[0, 0, c / 2]])
gt = Geometry([[0, 0, 0], [a, 0, 0], [a * _s30, a * _c30, 0],
[a * (1 + _s30), a * _c30, 0]],
atoms,
sc=sc)
# Create the rotated one on top
gr = gt.copy()
# mirror structure
gr.xyz[0, 1] += sc.cell[1, 1]
gr.xyz[1, 1] += sc.cell[1, 1]
gr = gr.translate(-np.amin(gr.xyz, axis=0))
# Now displace to get the correct offset
gr = gr.translate([0, a * _s30 / 2, 0])
g = gt.append(gr, 2)
else:
sc = SuperCell([a, a, c, 90, 90, 60])
g = Geometry([[0, 0, 0], [a2sq * _c30, a2sq * _s30, c / 2]],
atoms,
sc=sc)
if np.all(g.maxR(True) > 0.):
g.optimize_nsc()
return g
def test_imaginary_fail_geometry(sisl_tmp):
fr = sisl_tmp('GRID_real.cube', _dir)
fi = sisl_tmp('GRID_imag.cube', _dir)
geom = Geometry(np.random.rand(10, 3), np.random.randint(1, 70, 10), sc=[10, 10, 10, 45, 60, 90])
grid = Grid(0.2, geometry=geom, dtype=np.complex128)
grid.grid = np.random.rand(*grid.shape) + 1j*np.random.rand(*grid.shape)
grid.write(fr)
# Assert it fails on geometry
grid2 = Grid(0.3, dtype=np.complex128)
grid2.write(fi, imag=True)
grid.read(fr, imag=fi)
def _r_geometry_ase(self, na, header, sp, xyz):
""" Read the geometry as though it was created with ASE """
# Convert F T to nsc
# F = 1
# T = 3
nsc = list(
map(lambda x: "FT".index(x) * 2 + 1,
header.pop("pbc").strip('"').split()))
cell = _a.fromiterd(header.pop("Lattice").strip('"').split()).reshape(
3, 3)
return Geometry(xyz, atom=sp, sc=SuperCell(cell, nsc=nsc))
def test_spin1(self, setup):
g = Geometry([[i, 0, 0] for i in range(10)], Atom(6, R=1.01), sc=[100])
H = Hamiltonian(g, dtype=np.int32, spin=Spin.POLARIZED)
for i in range(10):
j = range(i * 4, i * 4 + 3)
H[0, j] = (i, i * 2)
H2 = Hamiltonian(g, 2, dtype=np.int32)
for i in range(10):
j = range(i * 4, i * 4 + 3)
H2[0, j] = (i, i * 2)
assert H.spsame(H2)
def test_wavefunction1():
N = 50
o1 = SphericalOrbital(0, (np.linspace(0, 2, N), np.exp(-np.linspace(0, 100, N))))
G = Geometry([[1] * 3, [2] * 3], Atom(6, o1), sc=[4, 4, 4])
H = Hamiltonian(G)
R, param = [0.1, 1.5], [1., 0.1]
H.construct([R, param])
ES = H.eigenstate(dtype=np.float64)
# Plot in the full thing
grid = Grid(0.1, geometry=H.geom)
grid.fill(0.)
ES.sub(0).wavefunction(grid)
def test_geometry_car_group(sisl_tmp):
f = sisl_tmp('test_sort.POSCAR', _dir)
atoms = [Atom[1], Atom[2], Atom[2], Atom[1], Atom[1], Atom[2], Atom[3]]
xyz = np.random.rand(len(atoms), 3)
geom = Geometry(xyz, atoms, 100)
geom.write(carSileVASP(f, 'w'), group_species=True)
assert carSileVASP(f).read_geometry() != geom
geom = carSileVASP(f).geometry_group(geom)
assert carSileVASP(f).read_geometry() == geom
def __init__(self):
bond = 1.42
sq3h = 3.**.5 * 0.5
self.sc = SuperCell(
np.array([[1.5, sq3h, 0.], [1.5, -sq3h, 0.], [0., 0., 10.]],
np.float64) * bond,
nsc=[3, 3, 1])
C = Atom(Z=6, R=[bond * 1.01] * 3)
self.g = Geometry(
np.array([[0., 0., 0.], [1., 0., 0.]], np.float64) * bond,
atoms=C,
sc=self.sc)
self.E = EnergyDensityMatrix(self.g)
self.ES = EnergyDensityMatrix(self.g, orthogonal=False)
def func(E, ia, idxs, idxs_xyz):
idx = E.geometry.close(ia,
R=(0.1, 1.44),
atoms=idxs,
atoms_xyz=idxs_xyz)
ia = ia * 3
i0 = idx[0] * 3
i1 = idx[1] * 3
# on-site
p = 1.
E.E[ia, i0] = p
E.E[ia + 1, i0 + 1] = p
E.E[ia + 2, i0 + 2] = p
# nn
p = 0.1
# on-site directions
E.E[ia, ia + 1] = p
E.E[ia, ia + 2] = p
E.E[ia + 1, ia] = p
E.E[ia + 1, ia + 2] = p
E.E[ia + 2, ia] = p
E.E[ia + 2, ia + 1] = p
E.E[ia, i1 + 1] = p
E.E[ia, i1 + 2] = p
E.E[ia + 1, i1] = p
E.E[ia + 1, i1 + 2] = p
E.E[ia + 2, i1] = p
E.E[ia + 2, i1 + 1] = p
self.func = func
def test_so1(self, setup):
g = Geometry([[i, 0, 0] for i in range(10)], Atom(6, R=1.01), sc=[100])
H = Hamiltonian(g, dtype=np.float64, spin=Spin.SPINORBIT)
for i in range(10):
j = range(i * 4, i * 4 + 3)
H[i, i, 0] = 0.
H[i, i, 1] = 0.
H[i, i, 2] = 0.1
H[i, i, 3] = 0.1
H[i, i, 4] = 0.1
H[i, i, 5] = 0.1
H[i, i, 6] = 0.1
H[i, i, 7] = 0.1
if i > 0:
H[i, i - 1, 0] = 1.
H[i, i - 1, 1] = 1.
if i < 9:
H[i, i + 1, 0] = 1.
H[i, i + 1, 1] = 1.
eig1 = H.eigh()
# Check TimeSelector
for i in range(2):
assert np.allclose(H.eigh(), eig1)
assert len(H.eigh()) == len(H)
H1 = Hamiltonian(g, dtype=np.float64, spin=Spin('spin-orbit'))
for i in range(10):
j = range(i * 4, i * 4 + 3)
H1[i, i, 0] = 0.
H1[i, i, 1] = 0.
H1[i, i, 2] = 0.1
H1[i, i, 3] = 0.1
if i > 0:
H1[i, i - 1, 0] = 1.
H1[i, i - 1, 1] = 1.
if i < 9:
H1[i, i + 1, 0] = 1.
H1[i, i + 1, 1] = 1.
assert H1.spsame(H)
eig1 = H1.eigh()
# Check TimeSelector
for i in range(2):
assert np.allclose(H1.eigh(), eig1)
assert np.allclose(H.eigh(), H1.eigh())
es = H.eigenstate()
assert np.allclose(es.eig, eig1)
es.spin_moment()
PDOS = es.PDOS(np.linspace(-1, 1, 100))
DOS = es.DOS(np.linspace(-1, 1, 100))
assert np.allclose(PDOS.sum(1)[0, :], DOS)
def test_wavefunction2():
N = 50
o1 = SphericalOrbital(0, (np.linspace(0, 2, N), np.exp(-np.linspace(0, 100, N))))
G = Geometry([[1] * 3, [2] * 3], Atom(6, o1), sc=[4, 4, 4])
H = Hamiltonian(G)
R, param = [0.1, 1.5], [1., 0.1]
H.construct([R, param])
ES = H.eigenstate(dtype=np.float64)
# This is effectively plotting outside where no atoms exists
# (there could however still be psi weight).
grid = Grid(0.1, sc=SuperCell([2, 2, 2], origo=[2] * 3))
grid.fill(0.)
ES.sub(0).wavefunction(grid)
def test_optimize_nsc1(self):
# Create a 1D chain
geom = Geometry([0] * 3, Atom(1, R=1.), sc=1)
geom.set_nsc([77, 77, 77])
assert_true(np.allclose(geom.optimize_nsc(), [3, 3, 3]))
geom.set_nsc([77, 77, 77])
assert_true(np.allclose(geom.optimize_nsc(1), [77, 3, 77]))
geom.set_nsc([77, 77, 77])
assert_true(np.allclose(geom.optimize_nsc([0, 2]), [3, 77, 3]))
geom.set_nsc([77, 77, 77])
assert_true(np.allclose(geom.optimize_nsc([0, 2], R=2), [5, 77, 5]))
geom.set_nsc([1, 1, 1])
assert_true(np.allclose(geom.optimize_nsc([0, 2], R=2), [5, 1, 5]))
def test_wavefunction_eta():
N = 50
o1 = SphericalOrbital(0, (np.linspace(0, 2, N), np.exp(-np.linspace(0, 100, N))))
G = Geometry([[1] * 3, [2] * 3], Atom(6, o1), sc=[4, 4, 4])
H = Hamiltonian(G, spin=Spin('nc'))
R, param = [0.1, 1.5], [[0., 0., 0.1, -0.1],
[1., 1., 0.1, -0.1]]
H.construct([R, param])
ES = H.eigenstate()
# Plot in the full thing
grid = Grid(0.1, dtype=np.complex128, sc=SuperCell([2, 2, 2], origo=[-1] * 3))
grid.fill(0.)
ES.sub(0).wavefunction(grid, eta=True)
def read_geometry(self):
""" Read geometry from the contained file """
# First we read in the geometry
sc = self.read_supercell()
# Try and go to the first model record
in_model, l = self._step_record('MODEL')
idx = []
tags = []
xyz = []
Z = []
if in_model:
l = self.readline()
def is_atom(line):
return l.startswith('ATOM') or l.startswith('HETATM')
def is_end_model(line):
return l.startswith('ENDMDL') or l == ''
while not is_end_model(l):
if is_atom(l):
idx.append(int(l[6:11]))
tags.append(l[12:16].strip())
xyz.append(
[float(l[30:38]),
float(l[38:46]),
float(l[46:54])])
Z.append(l[76:78].strip())
l = self.readline()
# First sort all atoms according to the idx array
idx = np.array(idx)
idx = np.argsort(idx)
xyz = np.array(xyz)[idx, :]
tags = [tags[i] for i in idx]
Z = [Z[i] for i in idx]
# Create the atom list
atoms = Atoms(Atom(Z[0], tag=tags[0]), na=len(Z))
for i, a in enumerate(map(Atom, Z, tags)):
try:
s = atoms.specie_index(a)
except:
s = len(atoms.atom)
atoms._atom.append(a)
atoms._specie[i] = s
return Geometry(xyz, atoms, sc=sc)
def __init__(self):
bond = 1.42
sq3h = 3.**.5 * 0.5
self.sc = SuperCell(
np.array([[1.5, sq3h, 0.], [1.5, -sq3h, 0.], [0., 0., 10.]],
np.float64) * bond,
nsc=[3, 3, 1])
C = Atom(Z=6, R=[bond * 1.01] * 3)
self.g = Geometry(
np.array([[0., 0., 0.], [1., 0., 0.]], np.float64) * bond,
atom=C,
sc=self.sc)
self.D = DynamicalMatrix(self.g)
def func(D, ia, idxs, idxs_xyz):
idx = D.geom.close(ia,
R=(0.1, 1.44),
idx=idxs,
idx_xyz=idxs_xyz)
ia = ia * 3
i0 = idx[0] * 3
i1 = idx[1] * 3
# on-site
p = 1.
D.D[ia, i0] = p
D.D[ia + 1, i0 + 1] = p
D.D[ia + 2, i0 + 2] = p
# nn
p = 0.1
# on-site directions
D.D[ia, ia + 1] = p
D.D[ia, ia + 2] = p
D.D[ia + 1, ia] = p
D.D[ia + 1, ia + 2] = p
D.D[ia + 2, ia] = p
D.D[ia + 2, ia + 1] = p
D.D[ia, i1 + 1] = p
D.D[ia, i1 + 2] = p
D.D[ia + 1, i1] = p
D.D[ia + 1, i1 + 2] = p
D.D[ia + 2, i1] = p
D.D[ia + 2, i1 + 1] = p
self.func = func
def test_so1(self, setup):
g = Geometry([[i, 0, 0] for i in range(10)], Atom(6, R=1.01), sc=SuperCell(100, nsc=[3, 3, 1]))
H = Hamiltonian(g, dtype=np.float64, spin=Spin.SPINORBIT)
for i in range(10):
j = range(i*2, i*2+3)
H[i, i, 0] = 0.
H[i, i, 1] = 0.
H[i, i, 2] = 0.1
H[i, i, 3] = 0.1
H[i, i, 4] = 0.1
H[i, i, 5] = 0.1
H[i, i, 6] = 0.1
H[i, i, 7] = 0.1
if i > 0:
H[i, i-1, 0] = 1.
H[i, i-1, 1] = 1.
if i < 9:
H[i, i+1, 0] = 1.
H[i, i+1, 1] = 1.
eig1 = H.eigh(dtype=np.complex64)
assert np.allclose(H.eigh(dtype=np.complex128), eig1)
assert len(H.eigh()) == len(H)
H1 = Hamiltonian(g, dtype=np.float64, spin=Spin('spin-orbit'))
for i in range(10):
j = range(i*2, i*2+3)
H1[i, i, 0] = 0.
H1[i, i, 1] = 0.
H1[i, i, 2] = 0.1
H1[i, i, 3] = 0.1
if i > 0:
H1[i, i-1, 0] = 1.
H1[i, i-1, 1] = 1.
if i < 9:
H1[i, i+1, 0] = 1.
H1[i, i+1, 1] = 1.
assert H1.spsame(H)
eig1 = H1.eigh(dtype=np.complex64)
assert np.allclose(H1.eigh(dtype=np.complex128), eig1)
assert np.allclose(H.eigh(dtype=np.complex64), H1.eigh(dtype=np.complex128))
es = H.eigenstate(dtype=np.complex128)
assert np.allclose(es.eig, eig1)
sm = es.spin_moment()
om = es.spin_orbital_moment()
assert np.allclose(sm, om.sum(1))
PDOS = es.PDOS(np.linspace(-1, 1, 100))
DOS = es.DOS(np.linspace(-1, 1, 100))
assert np.allclose(PDOS.sum(1)[0, :], DOS)
