def read_sc(self):
""" Returns a SuperCell object from a siesta.TSHS file
"""
n_s = _siesta.read_tshs_sizes(self.file)[3]
arr = _siesta.read_tshs_cell(self.file, n_s)
nsc = np.array(arr[0], np.int32)
cell = np.array(arr[1], np.float64)
cell.shape = (3, 3)
isc = np.array(arr[2], np.int32)
sc = np.array(arr[2], np.float64)
SC = SuperCell(cell, nsc=nsc)
SC.sc_off = np.dot(sc.T, cell.T)
return SC
def setUp(self):
alat = 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) * alat, nsc=[3, 3, 1])
self.g = Grid([10, 10, 100], sc=self.sc)
def read_sc(self, *args, **kwargs):
""" Returns `SuperCell` object from the FDF file """
f, lc = self._read('LatticeConstant')
s = float(lc.split()[1])
if 'ang' in lc.lower():
pass
elif 'bohr' in lc.lower():
s *= Bohr2Ang
# Read in cell
cell = np.empty([3, 3], np.float64)
f, lc = self._read_block('LatticeVectors')
if f:
for i in range(3):
cell[i, :] = [float(k) for k in lc[i].split()[:3]]
else:
f, lc = self._read_block('LatticeParameters')
if f:
tmp = [float(k) for k in lc[0].split()[:6]]
cell = SuperCell.tocell(*tmp)
if not f:
# the fdf file contains neither the latticevectors or parameters
raise SileError(
'Could not find Vectors or Parameters block in file')
cell *= s
return SuperCell(cell)
def read_sc(self):
""" Returns `SuperCell` object from a .TBT.nc file """
cell = np.array(np.copy(self.cell), dtype=np.float64)
cell.shape = (3, 3)
try:
nsc = self._value('nsc')
except:
nsc = None
sc = SuperCell(cell, nsc=nsc)
try:
sc.sc_off = self._value('isc_off')
except:
pass
return sc
def __init__(self):
alat = 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) * alat, nsc=[3, 3, 1])
self.g = Grid([10, 10, 100], sc=self.sc)
self.g.fill(2.)
def test_param_circle(self, n):
bz = BrillouinZone.param_circle(1, 10, 0.1, n, [1 / 2] * 3)
assert len(bz) == 10
sc = SuperCell(1)
bz_loop = BrillouinZone.param_circle(sc, 10, 0.1, n, [1 / 2] * 3, True)
assert len(bz_loop) == 10
assert not np.allclose(bz.k, bz_loop.k)
assert np.allclose(bz_loop.k[0, :], bz_loop.k[-1, :])
def test_sparse_orbital_add_axis(setup):
g = setup.g.copy()
s = SparseOrbital(g)
s.construct([[0.1, 1.5], [1, 2]])
s1 = s.add(s, axis=2)
s2 = SparseOrbital(g.append(SuperCell([0, 0, 10]), 2).add(g, offset=[0, 0, 5]))
s2.construct([[0.1, 1.5], [1, 2]])
assert s1.spsame(s2)
def test_pickle(self):
import pickle as p
s = p.dumps(self.sc)
n = p.loads(s)
assert_true(self.sc == n)
assert_false(self.sc != n)
s = SuperCell([1, 1, 1])
assert_false(self.sc == s)
def read_supercell(self, *args, **kwargs):
cell = _siesta.read_grid_cell(self.file)
_bin_check(self, 'read_supercell', 'could not read cell.')
cell = np.array(cell.T, np.float64)
cell.shape = (3, 3)
return SuperCell(cell)
def _r_geometry_sisl(self, na, header, sp, xyz):
""" Read the geometry as though it was created with sisl """
# Default version of the header is 1
v = header.get("sisl-version", 1)
nsc = list(map(int, header.pop("nsc").split()))
cell = _a.fromiterd(header.pop("cell").split()).reshape(3, 3)
return Geometry(xyz, atoms=sp, sc=SuperCell(cell, nsc=nsc))
def read_energy_density_matrix(self, **kwargs):
""" Returns the energy density matrix from the siesta.DM file """
# Now read the sizes used...
spin, no, nsc, nnz = _siesta.read_tsde_sizes(self.file)
_bin_check(self, 'read_energy_density_matrix',
'could not read energy density matrix sizes.')
ncol, col, dEDM = _siesta.read_tsde_edm(self.file, spin, no, nsc, nnz)
_bin_check(self, 'read_energy_density_matrix',
'could not read energy density matrix.')
# Try and immediately attach a geometry
geom = kwargs.get('geometry', kwargs.get('geom', None))
if geom is None:
# We truly, have no clue,
# Just generate a boxed system
xyz = [[x, 0, 0] for x in range(no)]
sc = SuperCell([no, 1, 1], nsc=nsc)
geom = Geometry(xyz, Atom(1), sc=sc)
if nsc[0] != 0 and np.any(geom.nsc != nsc):
# We have to update the number of supercells!
geom.set_nsc(nsc)
if geom.no != no:
raise SileError(
str(self) + '.read_energy_density_matrix could '
'not use the passed geometry as the number of atoms or orbitals '
'is inconsistent with DM file.')
# Create the energy density matrix container
EDM = EnergyDensityMatrix(geom,
spin,
nnzpr=1,
dtype=np.float64,
orthogonal=False)
# Create the new sparse matrix
EDM._csr.ncol = ncol.astype(np.int32, copy=False)
EDM._csr.ptr = np.insert(np.cumsum(ncol, dtype=np.int32), 0, 0)
# Correct fortran indices
EDM._csr.col = col.astype(np.int32, copy=False) - 1
EDM._csr._nnz = len(col)
EDM._csr._D = np.empty([nnz, spin + 1], np.float64)
EDM._csr._D[:, :spin] = dEDM[:, :]
# EDM file does not contain overlap matrix... so neglect it for now.
EDM._csr._D[:, spin] = 0.
# Convert the supercells to sisl supercells
if nsc[0] != 0 or geom.no_s >= col.max():
_csr_from_siesta(geom, EDM._csr)
else:
warn(
str(self) + '.read_energy_density_matrix may '
'result in a wrong sparse pattern!')
return EDM
def read_supercell(self):
""" Returns `SuperCell` object from this file """
cell = _a.arrayd(np.copy(self.cell))
cell.shape = (3, 3)
try:
nsc = self._value('nsc')
except:
nsc = None
sc = SuperCell(cell, nsc=nsc)
try:
sc.sc_off = self._value('isc_off')
except:
# This is ok, we simply do not have the supercell offsets
pass
return sc
def read_supercell(self):
""" Returns `SuperCell` object from the XV file """
cell = np.empty([3, 3], np.float64)
for i in range(3):
cell[i, :] = list(map(float, self.readline().split()[:3]))
cell *= Bohr2Ang
return SuperCell(cell)
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 read_supercell(self):
""" Returns a SuperCell object from a SIESTA.grid.nc file
"""
cell = np.array(self._value('cell'), np.float64)
# Yes, this is ugly, I really should implement my unit-conversion tool
cell *= Bohr2Ang
cell.shape = (3, 3)
return SuperCell(cell)
def bcc(alat, atom, orthogonal=False):
"""
Returns a BCC lattice (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, ah]], atom, sc=sc)
else:
sc = SuperCell(np.array([[1, 1, 1],
[1, -1, 1],
[1, 1, -1]], np.float64) * alat / 2,
nsc=[3, 3, 3])
g = Geometry([0, 0, 0], atom, sc=sc)
return g
def test_sparse_orbital_add_no_axis():
from sisl.geom import sc
g = (sc(1., Atom(1, R=1.5)) * 2).add(SuperCell([0, 0, 5]))
s = SparseOrbital(g)
s.construct([[0.1, 1.5], [1, 2]])
s1 = s.add(s, offset=[0, 0, 3])
s2 = SparseOrbital(g.add(g, offset=[0, 0, 3]))
s2.construct([[0.1, 1.5], [1, 2]])
assert s1.spsame(s2)
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 __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.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 read_supercell(self):
""" Reads a supercell from the Sile """
# 1st line is number of supercells
nsc = _a.fromiteri(map(int, self.readline().split()[:3]))
self.readline() # natoms, nspecies
self.readline() # species
cell = _a.fromiterd(map(float, self.readline().split()[:9]))
# Typically ScaleUp uses very large unit-cells
# so supercells will typically be restricted to [3, 3, 3]
return SuperCell(cell * Bohr2Ang, nsc=nsc)
def read_sc(self):
""" Returns `SuperCell` object from the XV file """
cell = np.empty([3, 3], np.float64)
for i in range(3):
cell[i, :] = np.fromstring(self.readline(),
dtype=float, sep=' ')[0:3]
cell *= Bohr2Ang
return SuperCell(cell)
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 read_supercell(self):
""" Returns a SuperCell object from a TranSiesta file """
n_s = _siesta.read_tshs_sizes(self.file)[3]
_bin_check(self, 'read_supercell', 'could not read sizes.')
arr = _siesta.read_tshs_cell(self.file, n_s)
_bin_check(self, 'read_supercell', 'could not read cell.')
nsc = np.array(arr[0], np.int32)
cell = np.array(arr[1].T, np.float64)
cell.shape = (3, 3)
return SuperCell(cell, nsc=nsc)
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 read_supercell(self):
""" Reads a supercell from the Sile """
# 1st line is number of supercells
nsc = ensure_array(map(int, self.readline().split()[:3]), np.int32)
self.readline() # natoms, nspecies
self.readline() # species
cell = ensure_array(map(float, self.readline().split()[:9]), np.float64)
# Typically ScaleUp uses very large unit-cells
# so supercells will typically be restricted to [3, 3, 3]
return SuperCell(cell * Bohr2Ang)
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_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_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_supercell(self):
""" Reads supercell object from the file """
self.fh.seek(0)
# read until "lattice_vector" is found
cell = []
for line in self:
if line.startswith("lattice_vector"):
cell.append([float(f) for f in line.split()[1:]])
return SuperCell(cell)
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 __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]*2)
self.g = Geometry(np.array([[0., 0., 0.],
[1., 0., 0.]], np.float64) * bond,
atom=C, sc=self.sc)
self.mol = Geometry([[i, 0, 0] for i in range(10)], sc=[50])
def test_spin1(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.int32, spin=Spin.POLARIZED)
for i in range(10):
j = range(i*2, i*2+3)
H[0, j] = (i, i*2)
H2 = Hamiltonian(g, 2, dtype=np.int32)
for i in range(10):
j = range(i*2, i*2+3)
H2[0, j] = (i, i*2)
assert H.spsame(H2)
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 _read_sc(self):
""" Defered routine """
f, l = self.step_to('unit_cell_cart', case=False)
if not f:
raise ValueError("The unit-cell vectors could not be found in the seed-file.")
# Create the cell
cell = np.empty([3, 3], np.float64)
for i in [0, 1, 2]:
cell[i, :] = [float(x) for x in self.readline().split()]
return SuperCell(cell)
class TestGrid(object):
def setUp(self):
alat = 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) * alat, nsc=[3, 3, 1])
self.g = Grid([10, 10, 100], sc=self.sc)
def tearDown(self):
del self.sc
del self.g
def test_append(self):
g = self.g.append(self.g, 0)
assert_true(np.allclose(g.grid.shape, [20, 10, 100]))
g = self.g.append(self.g, 1)
assert_true(np.allclose(g.grid.shape, [10, 20, 100]))
g = self.g.append(self.g, 2)
assert_true(np.allclose(g.grid.shape, [10, 10, 200]))
def test_size(self):
assert_true(np.allclose(self.g.grid.shape, [10, 10, 100]))
def test_item(self):
assert_true(np.allclose(self.g[1:2, 1:2, 2:3], self.g.grid[1:2, 1:2, 2:3]))
def test_dcell(self):
assert_true(np.all(self.g.dcell*self.g.cell >= 0))
def test_dvol(self):
assert_true(self.g.dvol > 0)
def test_shape(self):
assert_true(np.all(self.g.shape == self.g.grid.shape))
def test_dtype(self):
assert_true(self.g.dtype == self.g.grid.dtype)
def test_copy(self):
assert_true(self.g.copy() == self.g)
def test_swapaxes(self):
g = self.g.swapaxes(0, 1)
assert_true(np.allclose(self.g.cell[0,:], g.cell[1,:]))
assert_true(np.allclose(self.g.cell[1,:], g.cell[0,:]))
def test_interp(self):
shape = np.array(self.g.shape, np.int32)
g = self.g.interp(shape * 2)
g1 = g.interp(shape)
assert_true(np.allclose(self.g.grid, g1.grid))
def test_index1(self):
mid = np.array(self.g.shape, np.int32) // 2
idx = self.g.index(self.sc.center())
print(mid, idx)
assert_true(np.all(mid == idx))
def test_sum(self):
for i in range(3):
assert_true(self.g.sum(i).shape[i] == 1)
def test_mean(self):
for i in range(3):
assert_true(self.g.mean(i).shape[i] == 1)
def test_cross_section(self):
for i in range(3):
assert_true(self.g.cross_section(1, i).shape[i] == 1)
def test_remove_part(self):
for i in range(3):
assert_true(self.g.remove_part(1, i, above=True).shape[i] == 1)
def test_sub_part(self):
for i in range(3):
assert_true(self.g.sub_part(1, i, above=False).shape[i] == 1)
def test_sub(self):
for i in range(3):
assert_true(self.g.sub(1, i).shape[i] == 1)
for i in range(3):
assert_true(self.g.sub([1,2], i).shape[i] == 2)
def test_remove(self):
for i in range(3):
assert_true(self.g.remove(1, i).shape[i] == self.g.shape[i]-1)
for i in range(3):
assert_true(self.g.remove([1,2], i).shape[i] == self.g.shape[i]-2)
def test_argumentparser(self):
self.g.ArgumentParser()
