def h5diff(f1, f2, key=None, precision=1.e-6):
"""
Modified version of triqs.utility.h5diff.h5diff
key is the path of the data set to be compared: e.g., "dmft_out/Sigma_iw"
"""
if key is None:
h5diff_org(os.path.abspath(f1), os.path.abspath(f2), precision)
return
keys = key.split("/")
h1 = HDFArchive(os.path.abspath(f1), 'r')
h2 = HDFArchive(os.path.abspath(f2), 'r')
for k in keys:
h1 = h1[k]
h2 = h2[k]
compare(key, h1, h2, 0, precision)
if failures:
print('-' * 50, file=sys.stderr)
print('-' * 20 + ' FAILED ' + '-' * 20, file=sys.stderr)
print('-' * 50, file=sys.stderr)
for x in failures:
print(x, file=sys.stderr)
print('-' * 50, file=sys.stderr)
raise RuntimeError("FAILED")
def test_archive_base(self):
d = {'dbl' : 1.0, 'lst' : [1,[1],'a']}
# === Write to archive
with HDFArchive('hdf_archive2.h5','w', init = list(d.items())) as arch:
arch['int'] = 100
arch['arr'] = np.array([[1,2,3],[4,5,6]])
arch['tpl'] = (2,[2],'b')
arch['dct'] = { 'a':[10], 'b':20 }
arch['nan'] = float('nan')
arch['nanarr'] = np.array([np.nan, 1.0])
arch.create_group('grp')
grp = arch['grp']
grp['int'] = 98
grp['tpl'] = (3,[3],'c')
grp['dct'] = { 'a':[30], 'b':40 }
# === Read access
with HDFArchive('hdf_archive2.h5','r') as arch:
dct = arch['dct']
grp = arch['grp']
# === Read/Write access
with HDFArchive('hdf_archive2.h5','a') as arch:
dct = arch['dct']
dct['c'] = 'triqs'
arch['dct'] = dct
grp = arch['grp']
dct = grp['dct']
dct['c'] = 'qmc'
grp['dct'] = dct
grp['d'] = 700
grp['x'] = 1.5
grp['y'] = 'zzz'
# === Final check
arch = HDFArchive('hdf_archive2.h5','r')
self.assertEqual( arch['dbl'] , 1.0 )
self.assertEqual( arch['lst'] , [1,[1],'a'] )
self.assertEqual( arch['int'] , 100 )
assert_arrays_are_close( arch['arr'] , np.array([[1, 2, 3], [4, 5, 6]]) )
self.assertEqual( arch['tpl'] , (2,[2],'b') )
self.assertEqual( arch['dct'] , {'a':[10], 'b':20, 'c':'triqs'} )
self.assertTrue( isnan(arch['nan']) )
self.assertTrue( np.array_equal(np.isnan(arch['nanarr']), np.array([True, False])) )
self.assertEqual( arch['grp']['int'] , 98 )
self.assertEqual( arch['grp']['tpl'] , (3,[3],'c') )
self.assertEqual( arch['grp']['dct'] , { 'a':[30], 'b':40, 'c':'qmc'} )
self.assertEqual( arch['grp']['d'] , 700 )
self.assertEqual( arch['grp']['x'] , 1.5 )
self.assertEqual( arch['grp']['y'] , 'zzz' )
def test_hdf5_types(self):
filename = 'h5archive.h5'
p = dict(
my_flag=True,
my_int=1,
my_long=1,
my_float=1.,
my_complex=1.j,
my_string='foobar',
my_string_unicode='foobar',
my_ndarray_int=np.array([1]),
my_ndarray_float=np.array([1.]),
my_ndarray_complex=np.array([1.j]),
)
with HDFArchive(filename, 'w') as a:
a['p'] = p
with HDFArchive(filename, 'r') as a:
p_ref = a['p']
for key in list(p.keys()):
print(key, type(p[key]), type(p_ref[key]))
assert( type(p[key]) == type(p_ref[key]) )
if type(p[key]) == np.ndarray:
assert( p[key].dtype == p_ref[key].dtype )
print('dtypes: ', p[key].dtype, p_ref[key].dtype)
def test_TBLattice(self):
tbl = TBLattice(units=self.units,
hoppings=self.hoppings,
orbital_positions=self.orbital_positions,
orbital_names=self.orbital_names)
print(tbl)
self.assertEqual(list(self.hoppings.keys()), list(tbl.hoppings.keys()))
self.assertTrue(
all(
map(np.array_equal, self.hoppings.values(),
tbl.hoppings.values())))
# Make sure manual BravaisLattice / TightBinding / BrillouinZone
# construction yields same objects
bl = BravaisLattice(self.units, self.orbital_positions,
self.orbital_names)
bz = BrillouinZone(bl)
tb = TightBinding(bl, self.hoppings)
self.assertEqual(bl, tbl.bl)
self.assertEqual(bz, tbl.bz)
self.assertEqual(tb, tbl.tb)
# Test H5 Read / Write
with HDFArchive("tbl.h5", 'w') as arch:
arch['tbl'] = tbl
with HDFArchive("tbl.h5", 'r') as arch:
tbl_read = arch['tbl']
self.assertEqual(tbl, tbl_read)
def test_hdf5_types(self):
filename = 'h5archive.h5'
# Test creation of softlinks
with HDFArchive(filename, 'w') as a:
a.create_group("group")
a['data'] = 11
a['group']['data'] = 22
a.create_softlink('data', 'link')
a.create_softlink('/group/data', '/group/link')
with HDFArchive(filename, 'r') as a:
link_data = a['link']
link_group_data = a['group']['link']
self.assertEqual(link_data, 11)
self.assertEqual(link_group_data, 22)
# Test overwriting of softlinks
with HDFArchive(filename, 'a') as a:
a['other data'] = 33
a.create_softlink('other data', 'link')
with HDFArchive(filename, 'r') as a:
link_data = a['link']
self.assertEqual(link_data, 33)
# Test exception on overwriting of softlinks
with HDFArchive(filename, 'a') as a:
with self.assertRaises(RuntimeError):
a.create_softlink('data', 'link', delete_if_exists=False)
def test_storable(self):
obj = Storable()
obj.vec = [1, 2, 4, 5]
obj.s = "some other string"
with HDFArchive('h5_class.h5','w') as arch:
arch['obj'] = obj
with HDFArchive('h5_class.h5','r') as arch:
obj_in = arch['obj']
self.assertTrue(all(obj.vec == obj_in.vec))
self.assertEqual(obj.s, obj_in.s)
def generate_Hk_path(self, params):
"""
Override the original method. It is assumed that H(k) data are already stored in seedname.h5.
"""
# check h5 file
with HDFArchive(self._seedname + '.h5', 'r') as f:
if not 'dft_bands_input' in f:
warn(" seedname.h5/dft_bands_input should be prepared in advance in lattice='external'")
return None, None
n_k = f["dft_bands_input"]["n_k"]
# generate x values
xk = []
xnode = []
file_kpath = "kpath.in"
if not os.path.exists(file_kpath):
warn(" '%s' not found" %file_kpath)
return None, None
with open(file_kpath, "r") as f:
# -40 -40 40 80 2.31040 Z
for line in f:
array = line.split()
assert len(array) >= 5
x = float(array[4])
xk.append(x)
if len(array) >= 6:
xnode.append(XNode(x = x, label = array[5]))
assert len(xk) == n_k
return numpy.array(xk), xnode
def set_group(self, grp):
"""
return True if succeeded
"""
if hasattr(self, 'data'):
del self.data
with HDFArchive(self.h5_file_in, 'r') as ar:
if grp not in ar:
return False
ar = ar[grp]
self.data = {key: ar[key] for key in list(ar.keys())}
print("\n*** grp = " + grp)
print(list(self.data.keys()))
if 'n_k' in self.data:
self.nk = self.data['n_k']
print("n_k =", self.nk)
if hasattr(self, '_max_n_orbitals'):
del self._max_n_orbitals
self.data_new = {}
return True
def write_dft_bands_input_data(seedname,
params,
n_k,
kvec,
lattice_model,
bands_data='dft_bands_input'):
"""
Write DFT band input data into a HDF5 file
:param seedname:
:param params: runtime parameters
:param n_k: Number of k points
:param kvec: 2D array
:param lattice_model: object of LatticeModel
:return: None
"""
assert kvec.shape[0] == n_k
hopping, n_orbitals, proj_mat = lattice_model.generate_dft_band_input_data(
params, kvec)
#
# Output them into seedname.h5
#
with HDFArchive(seedname + '.h5', 'a') as f:
if not (bands_data in f):
f.create_group(bands_data)
f[bands_data]['hopping'] = hopping
f[bands_data]['n_k'] = n_k
f[bands_data]['n_orbitals'] = n_orbitals
f[bands_data]['proj_mat'] = proj_mat
print(' Done')
def generate_model_file(self):
#
#
p = self._params
seedname = self._params["model"]["seedname"]
with open(seedname+'.inp', 'w') as f:
_generate_w90_converter_input(self.nkdiv(), p, f)
# Convert General-Hk to SumDFT-HDF5 format
converter = Wannier90Converter(seedname=seedname)
converter.convert_dft_input()
if p["model"]["spin_orbit"]:
with HDFArchive(seedname + '.h5', 'a') as f:
f["dft_input"]["SP"] = 1
f["dft_input"]["SO"] = 1
corr_shells = f["dft_input"]["corr_shells"]
for icor in range(p["model"]['ncor']):
corr_shells[icor]["SO"] = 1
f["dft_input"]["corr_shells"] = corr_shells
# Make projectors compatible with DCore's block structure
# proj_mat (n_k, nb, n_corr, max_dim_sh, max_n_orb)
proj_mat = f['dft_input']['proj_mat']
n_k, nb, n_corr, max_dim_sh, max_n_orb = proj_mat.shape
assert nb == 1
# (n_k, nb, n_corr, orb, spin, orb, spin) => (n_k, nb, n_corr, spin, orb, spin, orb)
assert max_dim_sh//2 > 0
proj_mat = proj_mat.reshape((n_k, nb, n_corr, max_dim_sh//2, 2, max_n_orb//2, 2))
proj_mat = proj_mat.transpose((0, 1, 2, 4, 3, 6, 5))
proj_mat = proj_mat.reshape((n_k, 1, n_corr, max_dim_sh, max_n_orb))
f['dft_input']['proj_mat'] = proj_mat
def _get_results(self, group_prefix, n_data, orbital_symmetrize, dtype=float, stop_if_data_not_exist=True):
"""
Read results with two spin-orbital indices from HDF5 file
Returns
-------
numpy.ndarray of size (2*self.n_orb, 2*self.n_orb, n_data)
"""
data_shape = (2*self.n_orb, 2*self.n_orb, n_data)
array = numpy.zeros(data_shape, dtype=dtype)
with HDFArchive('sim.h5', 'r') as f:
results = f["simulation"]["results"]
for i1, i2 in product(range(2*self.n_orb), repeat=2):
group = "%s_%d_%d" % (group_prefix, i1, i2)
if group in results:
array[i1, i2, :] = results[group]["mean"]["value"]
if orbital_symmetrize: # Only i1>i2 is computed in CTQMC.
array[i2, i1, :] = array[i1, i2, :]
elif stop_if_data_not_exist:
raise Exception("data does not exist in sim.h5/simulation/results/{}. alps_cthyb might be old.".format(group))
# [(o1,s1), (o2,s2)] -> [o1, s1, o2, s2] -> [s1, o1, s2, o2] -> [(s1,o1), (s2,o2)]
array = array.reshape((self.n_orb, 2, self.n_orb, 2, -1))\
.transpose((1, 0, 3, 2, 4))\
.reshape((2*self.n_orb, 2*self.n_orb, -1))
return array
def calc_field(plot=True):
filenames = glob.glob('data_pyed_h_field*.h5')
out = ParameterCollection()
d = ParameterCollection(data=[])
h_vec, m_vec, m_ref_vec = [], [], []
for filename in filenames:
print('--> Loading:', filename)
with HDFArchive(filename, 'r') as s:
p = s['p']
d.data.append(p)
h_vec.append(p.h_field)
m = 0.5 * (-p.G_tau['up'](p.beta) + p.G_tau['dn'](p.beta))
m_vec.append(np.squeeze(m))
m_ref_vec.append(p.magnetization)
# Susceptibilit from quadratic expectation value
if np.abs(p.h_field) < 1e-9:
out.chi_exp = p.magnetization2 * 2 * p.beta
h_vec, m_vec, m_ref_vec = np.array(h_vec), np.array(m_vec), np.array(
m_ref_vec)
sidx = np.argsort(h_vec)
d.h_vec, d.m_vec, d.m_ref_vec = h_vec[sidx], m_vec[sidx], m_ref_vec[sidx]
from scipy.interpolate import InterpolatedUnivariateSpline as IUS
spl = IUS(d.h_vec, d.m_ref_vec)
out.chi = -spl(0, nu=1) # Linear response
out.beta = p.beta
print('beta, chi, chi_exp =', out.beta, out.chi, out.chi_exp)
filename_out = 'data_pyed_extrap_h_field_beta%6.6f.h5' % out.beta
with HDFArchive(filename_out, 'w') as s:
s['field'] = out
for key, value in list(out.dict().items()):
setattr(d, key, value)
if plot: plot_field(d)
def main(input_file, output_file):
"""
Solve the impurity problem.
"""
import time
t_start = time.time()
with HDFArchive(os.path.abspath(input_file), 'r') as h:
rot = h['rot'] if 'rot' in h else None
beta = h['beta']
gf_struct = h['gf_struct']
# convert a dict to a list of pairs [ (str,[int,...]), ...]
gf_struct = [(k, list(v)) for k, v in gf_struct.items()]
u_mat = h['u_mat']
n_iw = h['n_iw']
G0_iw = h['G0_iw']
params = h['params']
if rot is not None:
raise RuntimeError("TRIQS/HubbardI interface does not support basis rotation!")
h_int = make_h_int(u_mat, gf_struct)
# Create a working horse
S = Solver(beta, gf_struct, n_iw)
S.G0_iw << G0_iw
for k in params:
# e.g. numpy.bool_ to bool
params[k] = convert_to_built_in_scalar_type(params[k])
S.solve(h_int=h_int, **params)
# Retrieve results from the working horse
Sigma_iw = S.Sigma_iw.copy()
G_iw = S.G_iw.copy()
if mpi.is_master_node():
with HDFArchive(os.path.abspath(output_file), 'w') as h:
h['Sigma_iw'] = Sigma_iw
h['Gimp_iw'] = G_iw
t_end = time.time()
if mpi.is_master_node():
print('TRIQS/hubbardI ran for {} seconds.'.format(t_end-t_start))
def test_hk(self):
self.proj_gr.orthogonalize()
self.proj_gr.calc_hk(self.eigvals)
testout = _rpath + 'hk.test.h5'
with HDFArchive(testout, 'w') as h5test:
h5test['hk'] = self.proj_gr.hk
expected_file = _rpath + 'hk.ref.h5'
self.assertH5FileEqual(testout, expected_file)
def test_hdf5_bool(self):
# Write
with HDFArchive('bool.h5','w') as arch:
arch['t'] = True
arch['f'] = False
arch['i'] = 10
with HDFArchive('bool.h5','r') as arch:
t = arch['t']
f = arch['f']
i = arch['i']
self.assertTrue(t)
self.assertFalse(f)
self.assertIs(type(t),bool)
self.assertIs(type(f),bool)
self.assertIs(type(i),int)
def save_sparse_info(self, freqs):
grp = self.args['sparse_grp']
with HDFArchive(self.args['h5_file'], 'a') as f:
if grp not in f:
f.create_group(grp)
# save all arguments in __init__ to re-instantiate
f[grp]['args'] = self.args
# save list of frequencies (sampling points)
f[grp]['freqs'] = freqs
def write_dft_band_input_data(self,
params,
kvec,
bands_data='dft_bands_input'):
"""
Returns
-------
hopping : complex
k-dependent one-body Hamiltonian
n_orbitals : integer
Number of orbitals at each k. It does not depend on k
proj_mat : complex
Projection onto each correlated orbitals
"""
n_k = kvec.shape[0]
assert kvec.shape[1] == 3
norb_sh = numpy.array(params['model']['norb_corr_sh'])
assert len(norb_sh) == 1
assert params['model']['ncor'] == 1
#
# Energy band
#
norb = norb_sh[0]
dim_Hk = 2 * norb if params['model']['spin_orbit'] else norb
n_spin = 1
n_orbitals = numpy.ones((n_k, n_spin), dtype=int) * dim_Hk
hopping = numpy.zeros((n_k, n_spin, dim_Hk, dim_Hk), complex)
if params['model']['spin_orbit']:
for ik in range(n_k):
hopping[ik, 0, :, :] = self.Hk(kvec[ik])
else:
for ik in range(n_k):
# Copy only the up component
hopping[ik, 0, :, :] = self.Hk(kvec[ik])[0]
#
# proj_mat is (norb*norb) identities at each correlation shell
#
proj_mat = numpy.zeros([n_k, n_spin, 1, dim_Hk, dim_Hk], complex)
proj_mat[:, :, 0, 0:dim_Hk, 0:dim_Hk] = numpy.identity(dim_Hk, complex)
#
# Output them into seedname.h5
#
with HDFArchive(params['model']['seedname'] + '.h5', 'a') as f:
if not (bands_data in f):
f.create_group(bands_data)
f[bands_data]['hopping'] = hopping
f[bands_data]['n_k'] = n_k
f[bands_data]['n_orbitals'] = n_orbitals
f[bands_data]['proj_mat'] = proj_mat
print(' Done')
def __generate_local_potential(p):
print("\n @ Write the information of local potential")
# str
local_potential_matrix = p["model"]["local_potential_matrix"]
local_potential_factor = p["model"]["local_potential_factor"]
n_inequiv_shells = p["model"]['n_inequiv_shells']
spin_orbit = p["model"]["spin_orbit"]
# read parameters from DFT data
skc = SumkDFTCompat(p["model"]["seedname"] + '.h5')
assert skc.n_inequiv_shells == n_inequiv_shells
corr_shells = skc.corr_shells
dim_sh = [corr_shells[skc.inequiv_to_corr[ish]]['dim'] for ish in range(n_inequiv_shells)]
# set factor
try:
fac = ast.literal_eval(local_potential_factor)
if isinstance(fac, float) or isinstance(fac, int):
fac = [float(fac)] * n_inequiv_shells
elif isinstance(fac, list) or isinstance(fac, tuple):
assert len(fac) == n_inequiv_shells
else:
raise Exception("local_potential_factor should be float or list of length %d" % n_inequiv_shells)
except Exception as e:
print("Error: local_potential_factor =", local_potential_factor)
print(e)
exit(1)
# print factor
print("fac =", fac)
# set potential matrix
pot = set_potential(local_potential_matrix, "local_potential_matrix", n_inequiv_shells, dim_sh, spin_orbit)
for ish in range(n_inequiv_shells):
pot[ish] *= fac[ish]
# check if potential matrix is hermitian
def is_hermitian(mat):
return numpy.allclose(mat, mat.transpose().conj())
try:
for ish, pot_ish in enumerate(pot):
for sp in range(pot_ish.shape[0]):
assert is_hermitian(pot_ish[sp]), "potential matrix for ish={} sp={} is not hermitian".format(ish, sp)
except AssertionError as e:
print("Error:", e)
exit(1)
# write potential matrix
with HDFArchive(p["model"]["seedname"] + '.h5', 'a') as f:
f["DCore"]["LocalPotential"] = pot
print("\n Written to {0}".format(p["model"]["seedname"]+'.h5'))
def make_calc(beta=2.0, h_field=0.0):
# ------------------------------------------------------------------
# -- Hubbard atom with two bath sites, Hamiltonian
p = ParameterCollection(
beta = beta,
h_field = h_field,
U = 5.0,
ntau = 40,
niw = 15,
)
p.mu = 0.5*p.U
# ------------------------------------------------------------------
print('--> Solving SIAM with parameters')
print(p)
# ------------------------------------------------------------------
up, do = 'up', 'dn'
docc = c_dag(up,0) * c(up,0) * c_dag(do,0) * c(do,0)
mA = c_dag(up,0) * c(up,0) - c_dag(do,0) * c(do,0)
nA = c_dag(up,0) * c(up,0) + c_dag(do,0) * c(do,0)
p.H = -p.mu * nA + p.U * docc + p.h_field * mA
# ------------------------------------------------------------------
fundamental_operators = [c(up,0), c(do,0)]
ed = TriqsExactDiagonalization(p.H, fundamental_operators, p.beta)
g_tau = GfImTime(beta=beta, statistic='Fermion', n_points=40, indices=[0])
g_iw = GfImFreq(beta=beta, statistic='Fermion', n_points=10, indices=[0])
p.G_tau = BlockGf(name_list=[up,do], block_list=[g_tau]*2, make_copies=True)
p.G_iw = BlockGf(name_list=[up,do], block_list=[g_iw]*2, make_copies=True)
ed.set_g2_tau(p.G_tau[up], c(up,0), c_dag(up,0))
ed.set_g2_tau(p.G_tau[do], c(do,0), c_dag(do,0))
ed.set_g2_iwn(p.G_iw[up], c(up,0), c_dag(up,0))
ed.set_g2_iwn(p.G_iw[do], c(do,0), c_dag(do,0))
p.magnetization = ed.get_expectation_value(0.5 * mA)
p.magnetization2 = ed.get_expectation_value(0.25 * mA * mA)
# ------------------------------------------------------------------
# -- Store to hdf5
filename = 'data_pyed_h_field_%4.4f.h5' % h_field
with HDFArchive(filename,'w') as res:
res['p'] = p
def test_issue_multifile(self):
# Open a file more than once and write to it
with HDFArchive("multifile.h5", 'w') as arch:
arch['i'] = 14
with HDFArchive("multifile.h5", 'a') as arch:
arch['d'] = 3.2
# Open a file more than once and read from it
with HDFArchive("multifile.h5", 'r') as arch:
self.assertEqual(arch['i'], 14)
self.assertEqual(arch['d'], 3.2)
# Open a file more than once and write to it
with HDFArchive("multifile.h5", 'a') as arch:
arch['c'] = 1.2 + 3j
with HDFArchive("multifile.h5", 'a') as arch:
arch['s'] = "a string"
# Open a file more than once and read from it
with HDFArchive("multifile.h5", 'r') as arch:
self.assertEqual(arch['c'], 1.2 + 3j)
self.assertEqual(arch['s'], "a string")
def read_TarGZ_HDFArchive(filename):
tar = tarfile.open(filename, "r:gz")
f = tar.extractfile(tar.getmembers()[0])
tmp = NamedTemporaryFile(delete=False)
tmp.write(f.read())
tmp.close()
data = HDFArchive(tmp.name, 'r')
os.remove(tmp.name)
return data
def write_TarGZ_HDFArchive(filename, **kwargs):
filename = filename.split('.')[0]
filename_h5 = filename + '.h5'
filename_tar = filename + '.tar.gz'
with HDFArchive(filename_h5, 'w') as res:
for key, value in list(kwargs.items()):
res[key] = value
with tarfile.open(filename_tar, 'w:gz') as tar:
tar.add(filename_h5)
os.remove(filename_h5)
def solve(self, rot, mpirun_command, params_kw):
params = copy.deepcopy(params_kw)
# Write input parameters
with HDFArchive(os.path.abspath('input.h5'), 'w') as h:
h['beta'] = self.beta
h['gf_struct'] = self.gf_struct
h['u_mat'] = self.u_mat
h['n_iw'] = self.n_iw
if not rot is None:
h['rot'] = rot
h['G0_iw'] = self._G0_iw
h['params'] = params
if 'calc_Sigma_w' in params and params['calc_Sigma_w']:
h['calc_Sigma_w'] = True
for k in ['omega_min', 'omega_max', 'n_omega']:
h[k] = params[k]
else:
h['calc_Sigma_w'] = False
# Run a working horse
commands = [sys.executable, "-m", self._impl_module_name()]
commands.append(os.path.abspath('./input.h5'))
commands.append(os.path.abspath('./output.h5'))
with open('./output', 'w') as output_file:
launch_mpi_subprocesses(mpirun_command, commands, output_file)
with open('./output', 'r') as output_file:
for line in output_file:
print(line)
# Read results
with HDFArchive(os.path.abspath('output.h5'), 'r') as h:
self._Sigma_iw << h['Sigma_iw']
self._Gimp_iw << h['Gimp_iw']
if 'Sigma_w' in h:
self._Sigma_w = h['Sigma_w']
def __init__(self, params):
super(ExternalModel, self).__init__(params)
self._seedname = self._params["model"]["seedname"]
h5_file = self._seedname+'.h5'
# check if h5 file already exists
try:
assert os.path.exists(h5_file)
with HDFArchive(h5_file, 'r') as ar:
assert 'dft_input' in ar
except:
raise Exception("Prepare, in advance, '%s' file which stores DFT data in 'dft_input' subgroup" % h5_file)
# set nkdiv
self._nkdiv = set_nk(params["model"]["nk"],
params["model"]["nk0"],
params["model"]["nk1"],
params["model"]["nk2"])
# Set [model][norb_inequiv_sh], which is necessary for generate_umat
with HDFArchive(h5_file, 'r') as f:
n_inequiv_shells = f["dft_input"]["n_inequiv_shells"]
corr_shells = f["dft_input"]["corr_shells"]
inequiv_to_corr = f["dft_input"]["inequiv_to_corr"]
norb_inequiv_sh = [corr_shells[icsh]['dim'] for icsh in inequiv_to_corr]
try:
assert len(norb_inequiv_sh) == n_inequiv_shells
except:
print("ExternalModel.__init__: failed in setting 'norb_inequiv_sh'")
print(" n_inequiv_shells =", n_inequiv_shells)
print(" inequiv_to_corr =", inequiv_to_corr)
print(" corr_shells =", corr_shells)
print(" norb_inequiv_sh =", norb_inequiv_sh)
exit(1)
params['model']['norb_inequiv_sh'] = norb_inequiv_sh
def change_dataset(self, *args):
self.locked1 = True
self.quantities = []
if self.pickle_mode:
with open(self.h5_file, 'r') as fi:
self._result = _get_path(self.dataset.get(), pickle.load(fi))
else:
with HDFArchive(self.h5_file, 'r') as arx:
self._result = _get_path(self.dataset.get(), arx)
for function in dir(self._result):
if not function.startswith("plot_"):
continue
# if there is an error with getting the data
# we do not want to offer it in the menu
try:
getattr(self._result, function).original(self._result)
self.quantities.append(function[5:])
except Exception as e:
print(e)
pass
if not hasattr(self._result, 'analyzer_results'):
ar = []
elif self._result.matrix_structure is not None and self._result.element_wise:
m = product(*map(range, self._result.effective_matrix_structure))
ar = [(i, self._get_ar_i(i)) for i in m]
else:
ar = [(None, self._result.analyzer_results)]
for ia, a in ar:
for key, analyzer in a.items():
for function in dir(analyzer):
if not function.startswith("plot_"):
continue
# if there is an error with getting the data
# we do not want to offer it in the menu
try:
getattr(analyzer, function).\
original(analyzer, self._result, element=ia)
ky = key + ': ' + function[5:]
if ky not in self.quantities:
self.quantities.append(ky)
except:
pass
self.update_quantity_ui()
self.locked1 = False
self.update_plot()
def save(self, h5_file_out, grp):
if self.h5_file_in == h5_file_out:
# overwrite only updated components
data_save = self.data_new
else:
# write all components
data_save = dict(self.data)
data_save.update(self.data_new)
with HDFArchive(h5_file_out, 'a') as ar:
if grp not in ar:
ar.create_group(grp)
ar = ar[grp]
for key, d in list(data_save.items()):
ar[key] = d
def set_blockgf_from_h5(sigma, group):
# swdata = numpy.zeros((2, self.n_orb, self.n_iw), dtype=complex)
swdata = numpy.zeros((2*self.n_orb, self.n_iw), dtype=complex)
with HDFArchive('sim.h5', 'r') as f:
# for orb in range(self.n_orb):
# for spin in range(2):
# swdata_array = f[group][str(orb*2+spin)]["mean"]["value"]
# assert swdata_array.dtype == numpy.complex
# assert swdata_array.shape == (self.n_iw,)
# swdata[spin, orb, :] = swdata_array
for i in range(2*self.n_orb):
swdata_array = f[group][str(i)]["mean"]["value"]
assert swdata_array.dtype == numpy.complex
assert swdata_array.shape == (self.n_iw,)
swdata[i, :] = swdata_array
assign_from_numpy_array(sigma, swdata, self.block_names)
def calculate(d, temp, u, mu, path):
n_loops = 20
epsilon = d.eps
rho = d.rho
delta_eps = epsilon[1] - epsilon[0]
n_bins = epsilon.size
beta = 1. / temp
s = Solver(beta=beta, gf_struct=[('up', [0]), ('down', [0])])
g_temp = s.G0_iw.copy()
g_temp.zero()
for spin in ['up', 'down']:
for i in range(
n_bins
): # Use local self energy and density of states create a new G
g_temp['%s' % spin] += rho[i] * delta_eps * \
inverse(iOmega_n + mu - epsilon[i])
for block, g0 in s.G0_iw: # dyson equations
g0 << g_temp[block]
for it in range(n_loops): # num of loops
if it > 0: # No need for the first loop,already have a S.G0_iw
g_temp.zero()
for spin in ['up', 'down']:
for i in range(
n_bins
): # Use local self energy and density of states create a new G
g_temp['%s' % spin] += rho[i] * delta_eps * \
inverse(iOmega_n + mu - epsilon[i] - s.Sigma_iw['%s' % spin])
for block, g0 in s.G0_iw: # dyson equations
g0 << inverse(inverse(g_temp[block]) + s.Sigma_iw[block])
s.solve(
h_int=u * n('up', 0) * n('down', 0), # Local Hamiltonian
n_cycles=50000, # Number of QMC cycles
length_cycle=50, # Length of one cycle
n_warmup_cycles=10000,
measure_density_matrix=True, # Measure the reduced density matrix
use_norm_as_weight=True)
rho = s.density_matrix
# Object containing eigensystem of the local Hamiltonian
h_loc_diag = s.h_loc_diagonalization
atomsnumbs = trace_rho_op(rho, n('up', 0) + n('down', 0), h_loc_diag)
doubleocc = trace_rho_op(rho, n('up', 0) * n('down', 0), h_loc_diag)
with HDFArchive(path + "/mu %.2f.h5" % mu) as A:
A['N'] = atomsnumbs
A['D'] = doubleocc
return atomsnumbs, doubleocc
def test_ortho_normion(self):
self.proj_gr.normion = True
self.proj_gr.orthogonalize()
dens_mat, overl = self.proj_sh.density_matrix(self.el_struct)
testout = _rpath + 'projortho_normion.test.h5'
with HDFArchive(testout, 'w') as h5test:
h5test['density_matrix'] = dens_mat
h5test['overlap_matrix'] = overl
# FIXME: redundant
self.assertEqual(overl[0, 0, ...], np.eye(5))
self.assertEqual(overl[0, 1, ...], np.eye(5))
expected_file = _rpath + 'projortho_normion.ref.h5'
self.assertH5FileEqual(testout, expected_file)
def read_dft_input_data(file, subgrp, things_to_read):
"""
Small version of SumkDFT.read_input_from_hdf()
Read DFT data from a HDF file and return the data as a dict.
"""
values = {}
with HDFArchive(file, 'r') as ar:
if not subgrp in ar:
raise RuntimeError("subrp " + subgrp + "does not exist in " +
file + "!")
# first read the necessary things:
for it in things_to_read:
values[it] = ar[subgrp][it]
return values
