def test_1_graphene_all_ArgumentParser(sisl_files, sisl_tmp):
pytest.importorskip("matplotlib", reason="matplotlib not available")
# Local routine to run the collected actions
def run(ns):
ns._actions_run = True
# Run all so-far collected actions
for A, Aargs, Akwargs in ns._actions:
A(*Aargs, **Akwargs)
ns._actions_run = False
ns._actions = []
tbt = sisl.get_sile(sisl_files(_dir, '1_graphene_all.TBT.nc'))
p, ns = tbt.ArgumentParser()
p.parse_args([], namespace=ns)
p, ns = tbt.ArgumentParser()
out = p.parse_args(['--energy', ' -1.995:1.995'], namespace=ns)
assert not out._actions_run
run(out)
p, ns = tbt.ArgumentParser()
out = p.parse_args(['--kpoint', '1'], namespace=ns)
assert out._krng
run(out)
assert out._krng == 1
p, ns = tbt.ArgumentParser()
out = p.parse_args(['--norm', 'orbital'], namespace=ns)
run(out)
assert out._norm == 'orbital'
p, ns = tbt.ArgumentParser()
out = p.parse_args(['--norm', 'atom'], namespace=ns)
run(out)
assert out._norm == 'atom'
p, ns = tbt.ArgumentParser()
out = p.parse_args(['--kpoint', '1', '--norm', 'orbital'], namespace=ns)
run(out)
assert out._krng == 1
assert out._norm == 'orbital'
p, ns = tbt.ArgumentParser()
out = p.parse_args(['--atom', '10:11,14'], namespace=ns)
run(out)
assert out._Ovalue == '10:11,14'
# Only atom 14 is in the device region
assert np.all(out._Orng + 1 == [14])
p, ns = tbt.ArgumentParser()
out = p.parse_args(['--atom', '10:11,12,14:20'], namespace=ns)
run(out)
assert out._Ovalue == '10:11,12,14:20'
# Only 13-48 is in the device
assert np.all(out._Orng + 1 == [14, 15, 16, 17, 18, 19, 20])
p, ns = tbt.ArgumentParser()
out = p.parse_args(['--transmission', 'Left', 'Right'], namespace=ns)
run(out)
assert len(out._data) == 2
assert out._data_header[0][0] == 'E'
assert out._data_header[1][0] == 'T'
p, ns = tbt.ArgumentParser()
out = p.parse_args(
['--transmission', 'Left', 'Right', '--transmission-bulk', 'Left'],
namespace=ns)
run(out)
assert len(out._data) == 3
assert out._data_header[0][0] == 'E'
assert out._data_header[1][0] == 'T'
assert out._data_header[2][:2] == 'BT'
p, ns = tbt.ArgumentParser()
out = p.parse_args(['--dos', '--dos', 'Left', '--ados', 'Right'],
namespace=ns)
run(out)
assert len(out._data) == 4
assert out._data_header[0][0] == 'E'
assert out._data_header[1][0] == 'D'
assert out._data_header[2][:2] == 'AD'
assert out._data_header[3][:2] == 'AD'
p, ns = tbt.ArgumentParser()
out = p.parse_args(['--bulk-dos', 'Left', '--ados', 'Right'], namespace=ns)
run(out)
assert len(out._data) == 3
assert out._data_header[0][0] == 'E'
assert out._data_header[1][:2] == 'BD'
assert out._data_header[2][:2] == 'AD'
p, ns = tbt.ArgumentParser()
out = p.parse_args(['--transmission-eig', 'Left', 'Right'], namespace=ns)
run(out)
assert out._data_header[0][0] == 'E'
for i in range(1, len(out._data)):
assert out._data_header[i][:4] == 'Teig'
p, ns = tbt.ArgumentParser()
out = p.parse_args(['--info'], namespace=ns)
# Test output
f = sisl_tmp('1_graphene_all.dat', _dir)
p, ns = tbt.ArgumentParser()
out = p.parse_args(['--transmission-eig', 'Left', 'Right', '--out', f],
namespace=ns)
assert len(out._data) == 0
f1 = sisl_tmp('1_graphene_all_1.dat', _dir)
f2 = sisl_tmp('1_graphene_all_2.dat', _dir)
p, ns = tbt.ArgumentParser()
out = p.parse_args([
'--transmission', 'Left', 'Right', '--out', f1, '--dos', '--atom',
'12:2:48', '--dos', 'Right', '--ados', 'Left', '--out', f2
],
namespace=ns)
d = sisl.io.tableSile(f1).read_data()
assert len(d) == 2
d = sisl.io.tableSile(f2).read_data()
assert len(d) == 4
assert np.allclose(d[1, :], (d[2, :] + d[3, :]) * 2)
assert np.allclose(d[2, :], d[3, :])
f = sisl_tmp('1_graphene_all_T.png', _dir)
p, ns = tbt.ArgumentParser()
out = p.parse_args([
'--transmission', 'Left', 'Right', '--transmission-bulk', 'Left',
'--plot', f
],
namespace=ns)
def test_zz_sc_geom(sisl_files):
si = sisl.get_sile(sisl_files(_dir, 'zz.gout'))
sc = si.read_supercell()
geom = si.read_geometry()
assert sc == geom.sc
def test_1_graphene_all_content(sisl_files):
""" This tests manifolds itself as:
sisl.geom.graphene(orthogonal=True).tile(3, 0).tile(5, 1)
All output is enabled:
### FDF ###
# Transmission related quantities
TBT.T.All T
TBT.T.Out T
TBT.T.Eig 2
# Density of states
TBT.DOS.Elecs T
TBT.DOS.Gf T
TBT.DOS.A T
TBT.DOS.A.All T
# Orbital currents and Crystal-Orbital investigations.
TBT.Symmetry.TimeReversal F
TBT.Current.Orb T
TBT.COOP.Gf T
TBT.COOP.A T
TBT.COHP.Gf T
TBT.COHP.A T
TBT.k [100 1 1]
### FDF ###
"""
tbt = sisl.get_sile(sisl_files(_dir, '1_graphene_all.TBT.nc'))
assert tbt.E.min() > -2.
assert tbt.E.max() < 2.
# We have 400 energy-points
ne = len(tbt.E)
assert ne == 400
assert tbt.ne == ne
# We have 100 k-points
nk = len(tbt.kpt)
assert nk == 100
assert tbt.nk == nk
assert tbt.wk.sum() == pytest.approx(1.)
for i in range(ne):
assert tbt.Eindex(i) == i
assert tbt.Eindex(tbt.E[i]) == i
# Check raises
with pytest.warns(sisl.SislWarning):
tbt.Eindex(tbt.E.min() - 1.)
with pytest.warns(sisl.SislInfo):
tbt.Eindex(tbt.E.min() - 2e-3)
with pytest.warns(sisl.SislWarning):
tbt.kindex([0, 0, 0.5])
# Can't hit it
#with pytest.warns(sisl.SislInfo):
# tbt.kindex([0.0106, 0, 0])
for i in range(nk):
assert tbt.kindex(i) == i
assert tbt.kindex(tbt.kpt[i]) == i
# Get geometry
geom = tbt.geometry
geom_c1 = tbt.read_geometry(atoms=sisl.Atoms(sisl.Atom[6], geom.na))
geom_c2 = tbt.read_geometry(
atoms=sisl.Atoms(sisl.Atom(6, orbs=2), geom.na))
assert geom_c1 == geom_c2
# Check read is the same as the direct query
assert tbt.na == geom.na
assert tbt.no == geom.no
assert tbt.no == geom.na
assert tbt.na == 3 * 5 * 4
assert np.allclose(tbt.cell, geom.cell)
# Check device atoms (1-orbital system)
assert tbt.na_d == tbt.no_d
assert tbt.na_d == 36 # 3 * 5 * 4 (and device is without electrodes, so 3 * 3 * 4)
assert len(
tbt.pivot()
) == 3 * 3 * 4 # 3 * 5 * 4 (and device is without electrodes, so 3 * 3 * 4)
assert len(tbt.pivot(in_device=True)) == len(tbt.pivot())
assert np.all(tbt.pivot(in_device=True, sort=True) == np.arange(tbt.no_d))
assert np.all(tbt.pivot(sort=True) == np.sort(tbt.pivot()))
# Just check they are there
assert tbt.n_btd() == len(tbt.btd())
# Check electrodes
assert len(tbt.elecs) == 2
elecs = tbt.elecs[:]
assert elecs == ['Left', 'Right']
for i, elec in enumerate(elecs):
assert tbt._elec(i) == elec
# Check the chemical potentials
for elec in elecs:
assert tbt.n_btd(elec) == len(tbt.btd(elec))
assert tbt.chemical_potential(elec) == pytest.approx(0.)
assert tbt.electron_temperature(elec) == pytest.approx(300., abs=1)
assert tbt.eta(elec) == pytest.approx(1e-4, abs=1e-6)
# Check electrode relevant stuff
left = elecs[0]
right = elecs[1]
# Assert we have transmission symmetry
assert np.allclose(tbt.transmission(left, right),
tbt.transmission(right, left))
assert np.allclose(tbt.transmission_eig(left, right),
tbt.transmission_eig(right, left))
# Check that the total transmission is larger than the sum of transmission eigenvalues
assert np.all(
tbt.transmission(left, right) +
1e-7 >= tbt.transmission_eig(left, right).sum(-1))
assert np.all(
tbt.transmission(right, left) +
1e-7 >= tbt.transmission_eig(right, left).sum(-1))
# Check that we can't retrieve from same to same electrode
with pytest.raises(ValueError):
tbt.transmission(left, left)
with pytest.raises(ValueError):
tbt.transmission_eig(left, left)
assert np.allclose(tbt.transmission(left, right, kavg=False),
tbt.transmission(right, left, kavg=False))
# Both methods should be identical for simple bulk systems
assert np.allclose(tbt.reflection(left),
tbt.reflection(left, from_single=True),
atol=1e-5)
# Also check for each k
for ik in range(nk):
assert np.allclose(tbt.transmission(left, right, ik),
tbt.transmission(right, left, ik))
assert np.allclose(tbt.transmission_eig(left, right, ik),
tbt.transmission_eig(right, left, ik))
assert np.all(
tbt.transmission(left, right, ik) +
1e-7 >= tbt.transmission_eig(left, right, ik).sum(-1))
assert np.all(
tbt.transmission(right, left, ik) +
1e-7 >= tbt.transmission_eig(right, left, ik).sum(-1))
assert np.allclose(tbt.DOS(kavg=ik),
tbt.ADOS(left, kavg=ik) + tbt.ADOS(right, kavg=ik))
assert np.allclose(
tbt.DOS(E=0.195, kavg=ik),
tbt.ADOS(left, E=0.195, kavg=ik) +
tbt.ADOS(right, E=0.195, kavg=ik))
# Check that norm returns correct values
assert tbt.norm() == 1
assert tbt.norm(norm='all') == tbt.no_d
assert tbt.norm(norm='atom') == tbt.norm(norm='orbital')
# Check atom is equivalent to orbital
for norm in ['atom', 'orbital']:
assert tbt.norm(0, norm=norm) == 0.
assert tbt.norm(3 * 4, norm=norm) == 1
assert tbt.norm(range(3 * 4, 3 * 5), norm=norm) == 3
# Assert sum(ADOS) == DOS
assert np.allclose(tbt.DOS(), tbt.ADOS(left) + tbt.ADOS(right))
assert np.allclose(tbt.DOS(sum=False),
tbt.ADOS(left, sum=False) + tbt.ADOS(right, sum=False))
# Now check orbital resolved DOS
assert np.allclose(tbt.DOS(sum=False),
tbt.ADOS(left, sum=False) + tbt.ADOS(right, sum=False))
# Current must be 0 when the chemical potentials are equal
assert tbt.current(left, right) == pytest.approx(0.)
assert tbt.current(right, left) == pytest.approx(0.)
high_low = tbt.current_parameter(left, 0.5, 0.0025, right, -0.5, 0.0025)
low_high = tbt.current_parameter(left, -0.5, 0.0025, right, 0.5, 0.0025)
assert high_low > 0.
assert low_high < 0.
assert -high_low == pytest.approx(low_high)
with pytest.warns(sisl.SislWarning):
tbt.current_parameter(left, -10., 0.0025, right, 10., 0.0025)
with warnings.catch_warnings():
warnings.simplefilter('ignore')
# Since this is a perfect system there should be *no* QM shot-noise
# Also, the shot-noise is related to the applied bias, so NO shot-noise
assert np.allclose((tbt.shot_noise(left, right, kavg=False) *
tbt.wkpt.reshape(-1, 1)).sum(0), 0.)
assert np.allclose(tbt.shot_noise(left, right), 0.)
assert np.allclose(tbt.shot_noise(right, left), 0.)
assert np.allclose(tbt.shot_noise(left, right, kavg=1), 0.)
# Since the data-file does not contain all T-eigs (only the first two)
# we can't correctly calculate the fano factors
# This is a pristine system, hence all fano-factors should be more or less zero
# All transmissions are step-functions, however close to band-edges there is some
# smearing.
# When calculating the Fano factor it is extremely important that the zero_T is *sufficient*
# I don't now which value is *good*
assert np.all((tbt.fano(left, right, kavg=False) *
tbt.wkpt.reshape(-1, 1)).sum(0) <= 1)
assert np.all(tbt.fano(left, right) <= 1)
assert np.all(tbt.fano(right, left) <= 1)
assert np.all(tbt.fano(left, right, kavg=0) <= 1)
# Neither should the noise_power exist
assert (tbt.noise_power(right, left, kavg=False) *
tbt.wkpt).sum() == pytest.approx(0.)
assert tbt.noise_power(right, left) == pytest.approx(0.)
assert tbt.noise_power(right, left, kavg=0) == pytest.approx(0.)
# Check specific DOS queries
DOS = tbt.DOS
ADOS = tbt.ADOS
assert DOS(2, atoms=True, sum=False).size == geom.names['Device'].size
assert np.allclose(DOS(2, atoms='Device', sum=False),
DOS(2, atoms=True, sum=False))
assert DOS(2, orbitals=True, sum=False).size == geom.a2o('Device',
all=True).size
assert ADOS(left, 2, atoms=True,
sum=False).size == geom.names['Device'].size
assert ADOS(left, 2, orbitals=True,
sum=False).size == geom.a2o('Device', all=True).size
assert np.allclose(ADOS(left, 2, atoms='Device', sum=False),
ADOS(left, 2, atoms=True, sum=False))
atoms = range(8, 40) # some in device, some not in device
for o in ['atoms', 'orbitals']:
opt = {o: atoms}
for E in [None, 2, 4]:
assert np.allclose(DOS(E), ADOS(left, E) + ADOS(right, E))
assert np.allclose(DOS(E, **opt),
ADOS(left, E, **opt) + ADOS(right, E, **opt))
opt['sum'] = False
for E in [None, 2, 4]:
assert np.allclose(DOS(E), ADOS(left, E) + ADOS(right, E))
assert np.allclose(DOS(E, **opt),
ADOS(left, E, **opt) + ADOS(right, E, **opt))
opt['sum'] = True
opt['norm'] = o[:-1]
for E in [None, 2, 4]:
assert np.allclose(DOS(E), ADOS(left, E) + ADOS(right, E))
assert np.allclose(DOS(E, **opt),
ADOS(left, E, **opt) + ADOS(right, E, **opt))
opt['sum'] = False
for E in [None, 2, 4]:
assert np.allclose(DOS(E), ADOS(left, E) + ADOS(right, E))
assert np.allclose(DOS(E, **opt),
ADOS(left, E, **opt) + ADOS(right, E, **opt))
# Check orbital currents
E = 201
# Sum of orbital current should be 0 (in == out)
orb_left = tbt.orbital_current(left, E)
orb_right = tbt.orbital_current(right, E)
assert orb_left.sum() == pytest.approx(0., abs=1e-7)
assert orb_right.sum() == pytest.approx(0., abs=1e-7)
d1 = np.arange(12, 24).reshape(-1, 1)
d2 = np.arange(24, 36).reshape(-1, 1)
assert orb_left[d1, d2.T].sum() == pytest.approx(
tbt.transmission(left, right)[E])
assert orb_left[d1, d2.T].sum() == pytest.approx(-orb_left[d2, d1.T].sum())
assert orb_right[d2, d1.T].sum() == pytest.approx(
tbt.transmission(right, left)[E])
assert orb_right[d2,
d1.T].sum() == pytest.approx(-orb_right[d1, d2.T].sum())
orb_left.sort_indices()
atom_left = tbt.bond_current(left, E, only='all')
atom_left.sort_indices()
assert np.allclose(orb_left.data, atom_left.data)
assert np.allclose(
orb_left.data,
tbt.bond_current_from_orbital(orb_left, only='all').data)
orb_right.sort_indices()
atom_right = tbt.bond_current(right, E, only='all')
atom_right.sort_indices()
assert np.allclose(orb_right.data, atom_right.data)
assert np.allclose(
orb_right.data,
tbt.bond_current_from_orbital(orb_right, only='all').data)
# Calculate the atom current
# For 1-orbital systems the activity and non-activity are equivalent
assert np.allclose(tbt.atom_current(left, E),
tbt.atom_current(left, E, activity=False))
tbt.vector_current(left, E)
assert np.allclose(
tbt.vector_current_from_bond(atom_left) / 2,
tbt.vector_current(left, E, only='all'))
# Check COOP curves
coop = tbt.orbital_COOP(E)
coop_l = tbt.orbital_ACOOP(left, E)
coop_r = tbt.orbital_ACOOP(right, E)
coop_lr = coop_l + coop_r
# Ensure aligment
coop.eliminate_zeros()
coop.sorted_indices()
coop_lr.eliminate_zeros()
coop_lr.sorted_indices()
assert np.allclose(coop.data, coop_lr.data)
coop = tbt.orbital_COOP(E, isc=[0, 0, 0])
coop_l = tbt.orbital_ACOOP(left, E, isc=[0, 0, 0])
coop_r = tbt.orbital_ACOOP(right, E, isc=[0, 0, 0])
coop_lr = coop_l + coop_r
coop.eliminate_zeros()
coop.sorted_indices()
coop_lr.eliminate_zeros()
coop_lr.sorted_indices()
assert np.allclose(coop.data, coop_lr.data)
coop = tbt.atom_COOP(E)
coop_l = tbt.atom_ACOOP(left, E)
coop_r = tbt.atom_ACOOP(right, E)
coop_lr = coop_l + coop_r
coop.eliminate_zeros()
coop.sorted_indices()
coop_lr.eliminate_zeros()
coop_lr.sorted_indices()
assert np.allclose(coop.data, coop_lr.data)
coop = tbt.atom_COOP(E, isc=[0, 0, 0])
coop_l = tbt.atom_ACOOP(left, E, isc=[0, 0, 0])
coop_r = tbt.atom_ACOOP(right, E, isc=[0, 0, 0])
coop_lr = coop_l + coop_r
coop.eliminate_zeros()
coop.sorted_indices()
coop_lr.eliminate_zeros()
coop_lr.sorted_indices()
assert np.allclose(coop.data, coop_lr.data)
# Check COHP curves
coop = tbt.orbital_COHP(E)
coop_l = tbt.orbital_ACOHP(left, E)
coop_r = tbt.orbital_ACOHP(right, E)
coop_lr = coop_l + coop_r
coop.eliminate_zeros()
coop.sorted_indices()
coop_lr.eliminate_zeros()
coop_lr.sorted_indices()
assert np.allclose(coop.data, coop_lr.data)
coop = tbt.atom_COHP(E)
coop_l = tbt.atom_ACOHP(left, E)
coop_r = tbt.atom_ACOHP(right, E)
coop_lr = coop_l + coop_r
coop.eliminate_zeros()
coop.sorted_indices()
coop_lr.eliminate_zeros()
coop_lr.sorted_indices()
assert np.allclose(coop.data, coop_lr.data)
# Simply print out information
tbt.info()
for elec in elecs:
tbt.info(elec)
def test_1_graphene_all_fail_kavg(sisl_files, sisl_tmp):
tbt = sisl.get_sile(sisl_files(_dir, '1_graphene_all.TBT.nc'))
with pytest.raises(ValueError):
tbt.transmission(kavg=[0, 1])
def test_h2o_dipole_hsx_hs_no_geometry(sisl_files, sisl_tmp):
HSX = sisl.get_sile(sisl_files(_dir, "h2o_dipole.HSX"))
HS = HSX.read_hamiltonian()
S = HSX.read_overlap()
action="append",
default=None,
help=
"Output file to store the resulting Poisson solution. It *has* to have TSV.nc file ending to make the file conforming with TranSiesta."
)
# Parse args
args = p.parse_args()
if args.out is None:
print(
f">\n>\n>{_script}: No out-files has been specified, work will be carried out but not saved!\n>\n>\n"
)
# Read in geometry
geometry = si.get_sile(args.geometry).read_geometry()
# Figure out the electrodes
elecs_V = {}
if len(args.elec_V) == 0:
print(geometry.names)
raise ValueError(
"{}: Please specify the electrode potentials using --elec-V")
for name, V in args.elec_V:
elecs_V[name] = float(V)
if args.dtype == "f":
dtype = np.float32
elif args.dtype == "d":
dtype = np.float64
def NC_init_func(sisl_files, **kwargs):
H = sisl.get_sile(sisl_files("fe_clust_noncollinear.TSHS")).read_hamiltonian()
bz = sisl.BandStructure(H, [[0, 0, 0], [0.5, 0, 0]], 3, ["Gamma", "X"])
return bz.plot.fatbands(**kwargs)
def test_si_pdos_kgrid_hsx_H_no_geometry(sisl_files, sisl_tmp):
si = sisl.get_sile(sisl_files(_dir, "si_pdos_kgrid.HSX"))
H0 = si.read_hamiltonian()
H1 = si.read_hamiltonian(geometry=si_pdos_kgrid_geom())
assert H0._csr.spsame(H1._csr)
from hubbard import HubbardHamiltonian, sp2, density, plot
import numpy as np
import sisl
"""
For this system we get an open-shell solution for U>3 eV
This test obtaines the closed-shell solution for U=2 eV for both a spin-polarized and unpolarized situation
"""
# Build sisl Geometry object
molecule = sisl.get_sile('mol-ref/mol-ref.XV').read_geometry()
molecule.sc.set_nsc([1, 1, 1])
Hsp2 = sp2(molecule)
H = HubbardHamiltonian(Hsp2, U=2.0)
H.set_polarization([36], [77])
dn = H.converge(density.calc_n_insulator,
mixer=sisl.mixing.LinearMixer(),
tol=1e-7)
print('Closed-shell spin-polarized calculation:')
print('dn: {}, Etot: {}\n'.format(dn, H.Etot))
p = plot.Plot()
for i in range(2):
ev = H.eigh(spin=i) - H.find_midgap()
ev = ev[abs(ev) < 2]
p.axes.plot(ev,
np.zeros_like(ev), ['or', 'xg'][i],
label=[r'$\sigma=\uparrow$', r'$\sigma=\downarrow$'][i])
# Compute same system with spin degeneracy
from hubbard import HubbardHamiltonian, sp2, plot, density
import sys
import numpy as np
import sisl
# Build sisl Geometry object
mol_file = '3-anthracene'
mol = sisl.get_sile(mol_file+'.XV').read_geometry()
mol.sc.set_nsc([1, 1, 1])
mol = mol.move(-mol.center(what='xyz'))
# 3NN tight-binding model
Hsp2 = sp2(mol, t1=2.7, t2=0.2, t3=.18, dim=2)
H = HubbardHamiltonian(Hsp2)
# Output file to collect the energy difference between
# FM and AFM solutions
f = open('FM-AFM.dat', 'w')
mixer = sisl.mixing.PulayMixer(0.7, history=7)
for u in np.linspace(0.0, 4.0, 5):
# We approach the solutions from above, starting at U=4eV
H.U = 4.0-u
# AFM case first
success = H.read_density(mol_file+'.nc') # Try reading, if we already have density on file
if not success:
H.random_density()
H.set_polarization([1, 6, 15]) # polarize lower zigzag edge
mixer.clear()
def test_si_pdos_kgrid_grid_fdf(sisl_files):
si = sisl.get_sile(sisl_files(_dir, 'si_pdos_kgrid.fdf'))
VT = si.read_grid("VT", order='bin')
TotPot = si.read_grid("totalpotential", order='bin')
assert np.allclose(VT.grid, TotPot.grid)
def test_si_pdos_kgrid_grid_fractions(sisl_files):
si = sisl.get_sile(sisl_files(_dir, 'si_pdos_kgrid.VT'))
grid = si.read_grid()
grid_halve = si.read_grid(index=[0.5])
assert np.allclose(grid.grid * 0.5, grid_halve.grid)
def test_si_pdos_kgrid_grid_cell(sisl_files):
si = sisl.get_sile(sisl_files(_dir, 'si_pdos_kgrid.VT'))
si.read_supercell()
def test_si_pdos_kgrid_grid(sisl_files):
si = sisl.get_sile(sisl_files(_dir, 'si_pdos_kgrid.VT'))
si.read_grid()
assert si.grid_unit == pytest.approx(sisl.unit.siesta.unit_convert('Ry', 'eV'))
from hubbard import HubbardHamiltonian, density, plot, sp2
import sys
import numpy as np
import sisl
# Build sisl Geometry object
mol = sisl.get_sile('junction-2-2.XV').read_geometry()
mol.sc.set_nsc([1, 1, 1])
# 3NN tight-binding model
Hsp2 = sp2(mol, t1=2.7, t2=0.2, t3=.18)
H = HubbardHamiltonian(Hsp2)
# Output file to collect the energy difference between
# FM and AFM solutions
f = open('FM-AFM.dat', 'w')
mixer = sisl.mixing.PulayMixer(0.7, history=7)
H.set_polarization([77], dn=[23])
for u in np.linspace(0.0, 1.4, 15):
# We approach the solutions from above, starting at U=4eV
H.U = 4.4 - u
# AFM case first
success = H.read_density(
'fig_S15.nc') # Try reading, if we already have density on file
mixer.clear()
dn = H.converge(density.calc_n_insulator, mixer=mixer, tol=1e-6)
eAFM = H.Etot
H.write_density('fig_S15.nc')
def test_si_pdos_kgrid_hsx_H(sisl_files, sisl_tmp):
si = sisl.get_sile(sisl_files(_dir, "si_pdos_kgrid.fdf"))
si.read_hamiltonian(order="HSX")
def init_func_and_attrs(self, request, siesta_test_files):
name = request.param
if name == "siesta_output":
# From a siesta .bands file
init_func = sisl.get_sile(siesta_test_files("SrTiO3.bands")).plot
attrs = {
"bands_shape": (150, 72),
"ticklabels": ('Gamma', 'X', 'M', 'Gamma', 'R', 'X'),
"tickvals":
[0.0, 0.429132, 0.858265, 1.465149, 2.208428, 2.815313],
"gap": 1.677,
"spin_texture": False,
"spin": sisl.Spin("")
}
elif name.startswith("sisl_H"):
gr = sisl.geom.graphene()
H = sisl.Hamiltonian(gr)
H.construct([(0.1, 1.44), (0, -2.7)])
spin_type = name.split("_")[-1]
n_spin, H = {
"unpolarized": (0, H),
"polarized": (2, H.transform(spin=sisl.Spin.POLARIZED)),
"noncolinear": (0, H.transform(spin=sisl.Spin.NONCOLINEAR)),
"spinorbit": (0, H.transform(spin=sisl.Spin.SPINORBIT))
}.get(spin_type)
n_states = 2
if not H.spin.is_diagonal:
n_states *= 2
# Let's create the same graphene bands plot using the hamiltonian
# from two different prespectives
if name.startswith("sisl_H_path"):
# Passing a list of points (as if we were interacting from a GUI)
path = [{
"active": True,
"x": x,
"y": y,
"z": z,
"divisions": 3,
"name": tick
} for tick, (x, y, z) in zip(
["Gamma", "M", "K"], [[0, 0, 0], [2 / 3, 1 /
3, 0], [1 / 2, 0, 0]])]
init_func = partial(H.plot.bands, band_structure=path)
else:
# Directly creating a BandStructure object
bz = sisl.BandStructure(
H, [[0, 0, 0], [2 / 3, 1 / 3, 0], [1 / 2, 0, 0]], 6,
["Gamma", "M", "K"])
init_func = bz.plot
attrs = {
"bands_shape": (6, n_spin, n_states) if n_spin != 0 else
(6, n_states),
"ticklabels": ["Gamma", "M", "K"],
"tickvals": [0., 1.70309799, 2.55464699],
"gap":
0,
"spin_texture":
not H.spin.is_diagonal,
"spin":
H.spin
}
return init_func, attrs
def test_si_pdos_kgrid_hsx_H_fix_orbitals(sisl_files, sisl_tmp):
si = sisl.get_sile(sisl_files(_dir, "si_pdos_kgrid.HSX"))
si.read_hamiltonian(geometry=si_pdos_kgrid_geom(False))
def gen_exchange_siesta(
fdf_fname,
magnetic_elements=[],
kmesh=[4, 4, 4],
emin=-12.0,
emax=0.0,
nz=50,
#height=0.2,
#nz1=50,
#nz2=200,
#nz3=50,
exclude_orbs=[],
Rcut=None,
ne=None,
use_cache=False,
description=''):
try:
import sisl
except:
raise ImportError(
"sisl cannot be imported. Please install sisl first.")
fdf = sisl.get_sile(fdf_fname)
H = fdf.read_hamiltonian()
if H.spin.is_colinear and True:
print("Reading Siesta hamiltonian: colinear spin.")
tbmodel_up = SislWrapper(H, spin=0)
tbmodel_dn = SislWrapper(H, spin=1)
basis = dict(zip(tbmodel_up.orbs, list(range(tbmodel_up.norb))))
print("Starting to calculate exchange.")
description = f""" Input from collinear Siesta data.
working directory: {os.getcwd()}
fdf_fname: {fdf_fname}.
\n"""
exchange = ExchangeCL2(
tbmodels=(tbmodel_up, tbmodel_dn),
atoms=tbmodel_up.atoms,
basis=basis,
efermi=0.0,
magnetic_elements=magnetic_elements,
kmesh=kmesh,
emin=emin,
emax=emax,
nz=nz,
#height=height,
#nz1=nz1,
#nz2=nz2,
#nz3=nz3,
exclude_orbs=exclude_orbs,
Rcut=Rcut,
ne=ne,
use_cache=use_cache,
description=description)
exchange.run()
print("\n")
print(
"All calculation finsihed. The results are in TB2J_results directory."
)
elif H.spin.is_colinear:
print(
"Reading Siesta hamiltonian: colinear spin. Treat as non-colinear")
tbmodel = SislWrapper(H, spin='merge')
basis = dict(zip(tbmodel.orbs, list(range(tbmodel.nbasis))))
print("Starting to calculate exchange.")
description = f""" Input from collinear Siesta data.
working directory: {os.getcwd()}
fdf_fname: {fdf_fname}.
\n"""
exchange = ExchangeNCL(
tbmodels=tbmodel,
atoms=tbmodel.atoms,
basis=basis,
efermi=0.0,
magnetic_elements=magnetic_elements,
kmesh=kmesh,
emin=emin,
emax=emax,
nz=nz,
#height=height,
#nz1=nz1,
#nz2=nz2,
#nz3=nz3,
exclude_orbs=exclude_orbs,
Rcut=Rcut,
ne=ne,
use_cache=use_cache,
description=description)
exchange.run()
print("\n")
print(
"All calculation finsihed. The results are in TB2J_results directory."
)
elif H.spin.is_spinorbit:
print("Reading Siesta hamiltonian: non-colinear spin.")
tbmodel = SislWrapper(H, spin=None)
basis = dict(zip(tbmodel.orbs, list(range(tbmodel.nbasis))))
print("Starting to calculate exchange.")
description = f""" Input from non-collinear Siesta data.
working directory: {os.getcwd()}
fdf_fname: {fdf_fname}.
Warning: The DMI component parallel to the spin orientation, the Jani which has the component of that orientation should be disregarded
e.g. if the spins are along z, the xz, yz, zz, zx, zy components and the z component of DMI.
If you need these component, try to do three calculations with spin along x, y, z, or use structure with z rotated to x, y and z. And then use TB2J_merge.py to get the full set of parameters.
\n"""
exchange = ExchangeNCL(tbmodels=tbmodel,
atoms=tbmodel.atoms,
basis=basis,
efermi=0.0,
magnetic_elements=magnetic_elements,
kmesh=kmesh,
emin=emin,
emax=emax,
nz=nz,
exclude_orbs=exclude_orbs,
Rcut=Rcut,
ne=ne,
use_cache=use_cache,
description=description)
exchange.run()
print("\n")
print(
"All calculation finsihed. The results are in TB2J_results directory."
)
def test_h2o_dipole_hsx_no_ef(sisl_files, sisl_tmp):
HSX = sisl.get_sile(sisl_files(_dir, "h2o_dipole.HSX"))
with pytest.warns(sisl.SislWarning) as warns:
Ef = HSX.read_fermi_level()
assert len(warns) == 1
type=str,
nargs='*',
help="labels for corner points of k-path",
default=None)
parser.add_argument("--hsx",
action='store_true',
help="shift fermi level when reading from HSX")
return parser.parse_args()
if __name__ == '__main__':
args = parse_args()
sile = sisl.get_sile(args.infile)
geom = sile.read_geometry()
H = sile.read_hamiltonian(geometry=geom)
assert H is not None, "Could not read Hamiltonian."
if len(args.division) == 1: args.division = args.division[0]
kpath = sisl.BandStructure(
H,
point=args.kpoints,
division=args.division,
name=args.klabels,
)
def wrap(es, parent, k, weight):
return np.concatenate(
def test_fe(sisl_files):
si = sisl.get_sile(sisl_files(_dir, 'fe.bands'))
labels, k, eig = si.read_data()
assert k.shape == (131, )
assert eig.shape == (131, 2, 15)
assert len(labels[0]) == 5
def test_1_graphene_all_fail_kavg(sisl_files, sisl_tmp):
tbt = sisl.get_sile(sisl_files(_dir, '1_graphene_all.TBT.nc'))
tbt.transmission(kavg=[0, 1])
def test_1_graphene_all_tbtav(sisl_files, sisl_tmp):
tbt = sisl.get_sile(sisl_files(_dir, '1_graphene_all.TBT.nc'))
f = sisl_tmp('1_graphene_all.TBT.AV.nc', _dir)
tbt.write_tbtav(f)
def test_1_graphene_all_fail_kavg_E(sisl_files, sisl_tmp):
tbt = sisl.get_sile(sisl_files(_dir, '1_graphene_all.TBT.nc'))
tbt.orbital_COOP(kavg=[0, 1], E=0.1)
def test_1_graphene_all_fail_kavg_E(sisl_files, sisl_tmp):
tbt = sisl.get_sile(sisl_files(_dir, '1_graphene_all.TBT.nc'))
with pytest.raises(ValueError):
tbt.orbital_COOP(kavg=[0, 1], E=0.1)
def init_func_and_attrs(self, request, siesta_test_files):
name = request.param
if name.startswith("sisl_H"):
gr = sisl.geom.graphene()
H = sisl.Hamiltonian(gr)
H.construct([(0.1, 1.44), (0, -2.7)])
spin_type = name.split("_")[2]
n_spin, H = {
"unpolarized": (1, H),
"polarized": (2, H.transform(spin=sisl.Spin.POLARIZED)),
"noncolinear": (1, H.transform(spin=sisl.Spin.NONCOLINEAR)),
"spinorbit": (1, H.transform(spin=sisl.Spin.SPINORBIT))
}.get(spin_type)
n_states = 2
if H.spin.is_spinorbit or H.spin.is_noncolinear:
n_states *= 2
# Directly creating a BandStructure object
if name.endswith("jump"):
names = ["Gamma", "M", "M", "K"]
bz = sisl.BandStructure(H, [[0, 0, 0], [2 / 3, 1 / 3, 0], None,
[2 / 3, 1 / 3, 0], [1 / 2, 0, 0]],
6, names)
nk = 7
tickvals = [0., 1.70309799, 1.83083034, 2.68237934]
else:
names = ["Gamma", "M", "K"]
bz = sisl.BandStructure(
H, [[0, 0, 0], [2 / 3, 1 / 3, 0], [1 / 2, 0, 0]], 6, names)
nk = 6
tickvals = [0., 1.70309799, 2.55464699]
init_func = bz.plot.fatbands
attrs = {
"bands_shape":
(nk, n_spin, n_states) if H.spin.is_polarized else
(nk, n_states),
"weights_shape":
(n_spin, nk, n_states, 2) if H.spin.is_polarized else
(nk, n_states, 2),
"ticklabels":
names,
"tickvals":
tickvals,
"gap":
0,
"spin_texture":
not H.spin.is_diagonal,
"spin":
H.spin
}
elif name == "wfsx file":
# From a siesta bands.WFSX file
# Since there is no hamiltonian for bi2se3_3ql.fdf, we create a dummy one
wfsx = sisl.get_sile(siesta_test_files("bi2se3_3ql.bands.WFSX"))
geometry = sisl.get_sile(
siesta_test_files("bi2se3_3ql.fdf")).read_geometry()
geometry = sisl.Geometry(geometry.xyz, atoms=wfsx.read_basis())
H = sisl.Hamiltonian(geometry, dim=4)
init_func = partial(H.plot.fatbands,
wfsx_file=wfsx,
E0=-51.68,
entry_points_order=["wfsx file"])
attrs = {
"bands_shape": (16, 8),
"weights_shape": (16, 8, 195),
"ticklabels": None,
"tickvals": None,
"gap": 0.0575,
"spin_texture": False,
"spin": sisl.Spin("nc")
}
return init_func, attrs
def test_1_graphene_all_warn_atom(sisl_files):
tbt = sisl.get_sile(sisl_files(_dir, '1_graphene_all.TBT.nc'))
with pytest.warns(sisl.SislWarning):
tbt.a2p(1)
tol=0.1)
dn = MFH_HC.converge(negf.calc_n_open,
steps=1,
mixer=sisl.mixing.PulayMixer(weight=1., history=7),
tol=1e-6,
print_info=True)
print('Nup, Ndn: ', MFH_HC.n.sum(axis=1))
# Shift device with its Fermi level and write nc file
MFH_HC.H.write('MFH_HC.nc', Ef=negf.Ef)
# TBtrans RUN and plot transmission
import os
print('Clean TBtrans output from previous run')
os.system('rm device.TBT*')
os.system('rm fdf*')
print('Runing TBtrans')
os.system('tbtrans RUN.fdf > RUN.out')
tbt_up = sisl.get_sile('device.TBT_UP.nc')
tbt_dn = sisl.get_sile('device.TBT_DN.nc')
p = plot.Plot()
p.axes.plot(tbt_up.E, tbt_up.transmission(0, 1), label=r'$\sigma=\uparrow$')
p.axes.plot(tbt_dn.E, tbt_dn.transmission(0, 1), label=r'$\sigma=\downarrow$')
p.axes.legend()
p.set_xlim(-10, 10)
p.set_xlabel('Energy [eV]')
p.set_ylabel('Transmission [a.u.]')
p.savefig('transmission.pdf')
def collect_arguments(argv, input=False,
argumentparser=None,
namespace=None):
"""
Function for returning the actual arguments depending on the input options.
This function will create a fake `ArgumentParser` which then
will pass through the input figuring out which options
that should be given to the final `ArgumentParser`.
Parameters
----------
argv : ``list`` of ``str``
the argument list that comprise the arguments
input : ``bool``, ``False``
whether or not the arguments should also gather
from the input file.
argumentparser : ``argparse.ArgumentParser``
the argument parser that should add the options that we find from
the output and input files.
namespace : ``Namespace``
the namespace for the argument parser.
"""
# First we figure out the input file, and the output file
import argparse
import sisl
import sys, os, os.path as osp
# Create the default namespace in case there is none
if namespace is None:
namespace = default_namespace()
if input:
# Grap input-file
p = argparse.ArgumentParser('Parser for input file', add_help=False)
# Now add the input and output file
p.add_argument('input_file',nargs='?',default=None)
# Retrieve the input file
# (return the remaining options)
args, argv = p.parse_known_args(argv)
input_file = args.input_file
else:
input_file = None
# Grap output-file
p = argparse.ArgumentParser('Parser for output file', add_help=False)
p.add_argument('--out','-o',nargs=1, default=None)
# Parse the passed args to sort out the input file and
# the output file
args, _ = p.parse_known_args(argv)
if input_file is not None:
try:
obj = sisl.get_sile(input_file)
argumentparser, namespace = obj.ArgumentParser(argumentparser, namespace=namespace,
**obj._ArgumentParser_args_single())
# Be sure to add the input file
setattr(namespace, '_input_file', input_file)
except Exception as e:
print(e)
raise ValueError("File: '"+input_file+"' cannot be found. Please supply a readable file!")
if args.out is not None:
try:
obj = sisl.get_sile(args.out[0], mode='r')
obj.ArgumentParser_out(argumentparser, namespace=namespace)
except Exception as e:
pass
return argumentparser, namespace, argv
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
from pylab import *
import sisl as si
import numpy as np
###########################
# Input TSHS file
H_dft = si.get_sile('../../single_point15_51/RUN.fdf').read_hamiltonian()
# Atoms whose orbitals will be extracted from DFT
C_list = (H_dft.atoms.Z == 6).nonzero()[0]
O_list = (H_dft.atoms.Z == 8).nonzero()[0]
#print(C_list)
# Here we consider both C and O atoms
C_O_list = np.concatenate((C_list, O_list))
#C_O_list = np.sort(C_O_list)
#He = H_dft.sub(C_list); He.reduce()
# Purging C orbitals --> only taking Pz
H_h_o_cpz = H_dft.sub_orbital(H_dft.geometry.atoms[C_list[0]], orbital=[2])
# Purging O orbitals --> only taking Pz
H_h_opz_cpz = H_h_o_cpz.sub_orbital(H_h_o_cpz.geometry.atoms[O_list[0]],
orbital=[2])
# Removing unnecessary H atoms
H_TB = H_h_opz_cpz.sub(C_O_list)
H_TB.reduce()
#print(H_TB)
