def test_mpi(self):
a = Toto(0)
if mpi.is_master_node():
a = Toto(1)
mpi.bcast(a)
self.assertEqual(a, Toto(1))
def is_vasp_running(vasp_pid):
"""
Tests if VASP initial process is still alive.
"""
pid_exists = False
if mpi.is_master_node():
try:
os.kill(vasp_pid, 0)
except OSError as e:
pid_exists = e.errno == errno.EPERM
else:
pid_exists = True
pid_exists = mpi.bcast(pid_exists)
return pid_exists
gf_struct = [('dn',3), ('up',3)]
beta = 10
# create GF for comparison
G_tau = atomic_g_tau(ad, beta, gf_struct, 400)
G_iw = atomic_g_iw(ad, beta, gf_struct, 100)
G_l = atomic_g_l(ad, beta, gf_struct, 20)
G_w = atomic_g_w(ad, beta, gf_struct, (-2, 2), 400, 0.01)
ad_bcast = None
if mpi.is_master_node():
ad_bcast = ad
else:
ad = None
ad_bcast = mpi.bcast(ad_bcast)
assert isinstance(ad_bcast, AtomDiagReal)
# GF (real)
G_tau_bcast = atomic_g_tau(ad_bcast, beta, gf_struct, 400)
G_iw_bcast = atomic_g_iw(ad_bcast, beta, gf_struct, 100)
G_l_bcast = atomic_g_l(ad_bcast, beta, gf_struct, 20)
G_w_bcast = atomic_g_w(ad_bcast, beta, gf_struct, (-2, 2), 400, 0.01)
assert_block_gfs_are_close(G_tau_bcast, G_tau)
assert_block_gfs_are_close(G_iw_bcast, G_iw)
assert_block_gfs_are_close(G_l_bcast, G_l)
assert_block_gfs_are_close(G_w_bcast, G_w)
G=BlockGf(name_list = ["ch","sp"],block_list = [g,g])
assert G['ch'].data.shape==(200,199,1,1,1)
A=HDFArchive("g_multivar_3.h5",'w')
A["G"] = G
del A
#mpi bcast
import triqs.utility.mpi as mpi
g2=Gf(mesh = mprod, target_shape = [1,1,1])
if mpi.is_master_node():
g2.data[:,:,:,:,:] = 5
assert g2.data[0,0,0,0,0] == 5, "not ok : %s"%(g2.data[0,0,0,0,0])
if not mpi.is_master_node():
assert g2.data[0,0,0,0,0] == 0, "not ok : %s"%(g2.data[0,0,0,0,0])
g2 = mpi.bcast(g2)
if not mpi.is_master_node():
assert g2.data[0,0,0,0,0] == 5, "not ok : %s"%(g2.data[0,0,0,0,0])
#ImTime
##construct product mesh
m1=MeshImTime(beta=1., S="Fermion", n_max=100)
m2=MeshImTime(beta=1., S="Boson", n_max=100)
mprod=MeshProduct(m1,m2)
g=Gf(mesh = mprod, target_shape = [1,1,1])
f=Gf(mesh = mprod, target_shape =[1,1,1])
g.data[:]=2.5
f.data[:]=2.5
#operations
#inplace
f+=g
"dft_tools_version"] = dft_tools_version.dft_tools_hash
if 'iteration_count' in ar['DMFT_results']:
iteration_offset = ar['DMFT_results']['iteration_count'] + 1
S.Sigma_iw = ar['DMFT_results']['Iterations']['Sigma_it' +
str(iteration_offset -
1)]
SK.dc_imp = ar['DMFT_results']['Iterations']['dc_imp' +
str(iteration_offset - 1)]
SK.dc_energ = ar['DMFT_results']['Iterations']['dc_energ' +
str(iteration_offset -
1)]
SK.chemical_potential = ar['DMFT_results']['Iterations'][
'chemical_potential' + str(iteration_offset - 1)].real
ar['DMFT_input']["dmft_script_it" + str(iteration_offset)] = open(
sys.argv[0]).read()
iteration_offset = mpi.bcast(iteration_offset)
S.Sigma_iw = mpi.bcast(S.Sigma_iw)
SK.dc_imp = mpi.bcast(SK.dc_imp)
SK.dc_energ = mpi.bcast(SK.dc_energ)
SK.chemical_potential = mpi.bcast(SK.chemical_potential)
# Calc the first G0
SK.symm_deg_gf(S.Sigma_iw, orb=0)
SK.put_Sigma(Sigma_imp=[S.Sigma_iw])
SK.calc_mu(precision=0.01)
S.G_iw << SK.extract_G_loc()[0]
SK.symm_deg_gf(S.G_iw, orb=0)
#Init the DC term and the self-energy if no previous iteration was found
if iteration_offset == 0:
dm = S.G_iw.density()
def is_vasp_lock_present():
res_bool = False
if mpi.is_master_node():
res_bool = os.path.isfile('./vasp.lock')
res_bool = mpi.bcast(res_bool)
return res_bool
#Converter = Wien2kConverter(filename=dft_filename, repacking=True)
#Converter.convert_dft_input()
#mpi.barrier()
previous_runs = 0
previous_present = False
if mpi.is_master_node():
with HDFArchive(dft_filename + '.h5', 'a') as f:
if 'dmft_output' in f:
ar = f['dmft_output']
if 'iterations' in ar:
previous_present = True
previous_runs = ar['iterations']
else:
f.create_group('dmft_output')
previous_runs = mpi.bcast(previous_runs)
previous_present = mpi.bcast(previous_present)
SK = SumkDFT(hdf_file=dft_filename + '.h5',
use_dft_blocks=use_blocks,
h_field=h_field)
n_orb = SK.corr_shells[0]['dim']
l = SK.corr_shells[0]['l']
spin_names = ["up", "down"]
orb_names = [i for i in range(n_orb)]
# Use GF structure determined by DFT blocks
gf_struct = [(block, indices)
for block, indices in SK.gf_struct_solver[0].items()]
4, 5, 1, 9, 8, 0, 4, 5, 3, 2, 4, 8, 8, 6, 4, 3, 5, 3, 9, 8, 1, 0,
4, 2, 2, 0, 5, 8, 6, 6, 2, 3, 5, 3, 8, 5, 2, 3, 4, 3, 4, 1, 0, 4,
0, 0, 8, 4, 3, 5, 8, 4, 5, 3, 5, 4, 7, 7, 0, 2, 5, 9, 0, 9, 2, 8,
0, 4, 2, 2, 0, 2, 3, 0, 9, 6, 9, 7, 2, 4, 9, 7, 0, 3, 8, 0, 0, 7,
8, 7, 6, 4, 0, 3, 7, 1, 9, 2, 8, 1, 2, 6, 4, 8, 9, 6, 2, 9, 9, 2,
8, 4, 1, 0, 7, 5, 9, 0, 4, 8, 0, 0, 4, 3, 7, 5, 7, 7, 5, 0, 5, 8,
8, 7, 2, 7])
h_ref = py_histogram(x)
h = Histogram(0, 10)
h << x
else:
h, h_ref = None, None
h = mpi.bcast(h)
h_ref = mpi.bcast(h_ref)
for rank in range(mpi.size):
if rank == mpi.rank:
print('-'*72)
print('rank =', mpi.rank)
print('h =\n', h)
print('h_ref =\n', h_ref)
# -- Compare h and h_ref
pts = np.array([ int(h.mesh_point(idx)) for idx in range(len(h))])
for pt, val in zip(pts, h.data):
val = int(val)
#
# You may obtain a copy of the License at
# https:#www.gnu.org/licenses/gpl-3.0.txt
#
# Authors: Olivier Parcollet, Nils Wentzell
# Import the Green's functions
from triqs.gf import GfImFreq, iOmega_n, inverse
# Create the Matsubara-frequency Green's function and initialize it
g = GfImFreq(indices=[1], beta=50, n_points=1000, name="imp")
g << inverse(iOmega_n + 0.5)
import triqs.utility.mpi as mpi
mpi.bcast(g)
#Block
from triqs.gf import *
g1 = GfImFreq(indices=['eg1', 'eg2'], beta=50, n_points=1000, name="egBlock")
g2 = GfImFreq(indices=['t2g1', 't2g2', 't2g3'],
beta=50,
n_points=1000,
name="t2gBlock")
G = BlockGf(name_list=('eg', 't2g'), block_list=(g1, g2), make_copies=False)
mpi.bcast(G)
#imtime
from triqs.gf import *
A2 = 2 * A
print("A ", A)
assert (A2["up"] == 2 * m0).all() and (
A2["dn"] == 2 * m1).all(), "Multiplication by constant failed"
A2 = A * 2
assert (A2["up"] == 2 * m0).all() and (
A2["dn"] == 2 * m1).all(), "Multiplication by constant failed"
A2 = A / 2
assert (A2["up"] == 0.5 * m0).all() and (
A2["dn"] == 0.5 * m1).all(), "Division by constant failed"
A2 = -A
assert (A2["up"] == -m0).all() and (A2["dn"]
== -m1).all(), "Unary minus failed"
# MPI
Abcast = mpi.bcast(A)
assert (A['up']
== Abcast['up']).all() and (A['dn']
== Abcast['dn']).all(), "mpi.bcast failed"
# HDF5
with HDFArchive("block_matrix.output.h5", 'w') as R:
R["A"] = A
with HDFArchive("block_matrix.output.h5", 'r') as R:
A2 = R["A"]
assert (A['up']
== A2['up']).all() and (A['dn']
== A2['dn']).all(), "HDF5 write/read failed"
########################
# Complex block matrix #
del A2
assert G3.data.shape == G.data.shape, "not ok:%s vs %s" % (G3.data.shape,
G.data.shape)
#mpi bcast
import triqs.utility.mpi as mpi
G4 = GfImFreq(beta=1.,
statistic="Fermion",
n_points=100,
indices=[['a'], ['b1', 'b2'], ['c1', 'c2']])
if mpi.is_master_node():
G4.data[:, :, :, :] = 5
assert G4.data[0, 0, 0, 0] == 5, "not ok :%s" % (G4.data[0, 0, 0, 0])
if not mpi.is_master_node():
assert G4.data[0, 0, 0, 0] == 0, "not ok"
G4 = mpi.bcast(G4)
if not mpi.is_master_node():
assert G4.data[0, 0, 0, 0] == 5, "not ok :%s" % (G4.data[0, 0, 0, 0])
##Tv4
print("#############################")
G5 = GfImFreq(mesh=m, indices=[['a'], ['b1', 'b2'], ['c1', 'c2'], ['c']])
print(G5.data.shape)
assert G5.data.shape == (20, 1, 2, 2, 1), "not ok"
assert G5['a', 'b1', 'c2', 'c'].data.shape == (20, ), "not ok"
#ImTime,
print("#############################")
G6 = GfImTime(beta=1.,
statistic="Fermion",
# Authors: Hugo U. R. Strand, Nils Wentzell
""" Dimension of bz mesh is reduced from 3 to 2 by
broadcasting it over mpi...
Author: H. U.R. Strand (2019) """
import numpy as np
from triqs.gf import MeshBrZone
from triqs.lattice.lattice_tools import BrillouinZone
from triqs.lattice.lattice_tools import BravaisLattice
bl = BravaisLattice(np.eye(3), [(0, 0, 0)])
bz = BrillouinZone(bl)
mesh = MeshBrZone(bz, 8 * np.eye(3, dtype=int))
import triqs.utility.mpi as mpi
if mpi.is_master_node():
m = MeshBrZone(bz, 8 * np.eye(3, dtype=int))
else:
m = None
m = mpi.bcast(m)
print(mesh)
print(m)
assert (mesh.domain.lattice.ndim == m.domain.lattice.ndim)
def _main_mpi(model_hdf5_file, input_file, output_file):
"""
Launch SumkDFT and compute chemical potential, local Green's function and density matrix
This function depends on MPI through DFTTools.
Do not call this from non-MPI module directly.
"""
import triqs.utility.mpi as mpi
# read HDF5 file on the master node
if mpi.is_master_node():
with HDFArchive(input_file, 'r') as h:
params = h['params']
keys = list(params.keys())
else:
params = {}
keys = []
assert isinstance(params, dict)
# broadcast parameters
keys = mpi.bcast(keys)
for key in keys:
if not mpi.is_master_node():
params[key] = None
params[key] = mpi.bcast(params[key])
beta = params['beta']
with_dc = params['with_dc']
results = {}
def add_potential(_sigma, _pot):
sigma_plus_pot = _sigma.copy()
for sp, sigma in sigma_plus_pot:
sigma += _pot[sp]
return sigma_plus_pot
def setup_sk(sk, iwn_or_w_or_none):
if iwn_or_w_or_none == 'iwn':
assert len(params['Sigma_iw_sh']) == len(params['potential'])
Sigma_iw_sh_plus_pot = [
add_potential(sigma, pot) for sigma, pot in zip(
params['Sigma_iw_sh'], params['potential'])
]
sk.set_Sigma(Sigma_iw_sh_plus_pot)
elif iwn_or_w_or_none == 'w':
# sk.set_Sigma([params['Sigma_w_sh'][ish] for ish in range(sk.n_inequiv_shells)])
Sigma_w_sh = [
params['Sigma_w_sh'][ish] for ish in range(sk.n_inequiv_shells)
]
Sigma_w_sh_plus_pot = [
add_potential(sigma, pot)
for sigma, pot in zip(Sigma_w_sh, params['potential'])
]
sk.set_Sigma(Sigma_w_sh_plus_pot)
elif iwn_or_w_or_none == "none":
pass
else:
raise RuntimeError("Invalid iwn_or_w")
if params['with_dc']:
sk.set_dc(params['dc_imp'], params['dc_energ'])
sk.set_mu(params['mu'])
if params['calc_mode'] == 'Gloc':
from triqs_dft_tools import SumkDFT
sk = SumkDFT(hdf_file=model_hdf5_file,
use_dft_blocks=False,
h_field=0.0)
setup_sk(sk, 'iwn')
if params['adjust_mu']:
# find the chemical potential for given density
sk.calc_mu(params['prec_mu'])
results['mu'] = float(sk.chemical_potential)
# Local Green's function and Density matrix
results['Gloc_iw_sh'] = sk.extract_G_loc(with_dc=with_dc)
dm = sk.density_matrix(beta=beta)
for ish in range(len(dm)):
for b in list(dm[ish].keys()):
dm[ish][b] = numpy.conj(dm[ish][b])
results['dm_sh'] = dm
elif params['calc_mode'] == 'dos':
# Compute dos
from .sumkdft_post import SumkDFTDCorePost
sk = SumkDFTDCorePost(hdf_file=model_hdf5_file,
use_dft_blocks=False,
h_field=0.0)
setup_sk(sk, 'w')
results['dos'], results['dosproj'], results['dosproj_orb'] = \
sk.dos_wannier_basis(broadening=params['broadening'],
mesh=params['mesh'],
with_Sigma=True, with_dc=with_dc, save_to_file=False)
elif params['calc_mode'] == 'spaghettis':
# A(k, omega)
from .sumkdft_post import SumkDFTDCorePost
sk = SumkDFTDCorePost(hdf_file=model_hdf5_file,
use_dft_blocks=False,
h_field=0.0,
bands_data=params['bands_data'])
setup_sk(sk, 'w')
results['akw'] = sk.spaghettis(broadening=params['broadening'],
plot_range=None,
ishell=None,
save_to_file=None)
elif params['calc_mode'] == 'momentum_distribution':
# n(k)
from .sumkdft_post import SumkDFTDCorePost
sk = SumkDFTDCorePost(hdf_file=model_hdf5_file,
use_dft_blocks=False,
h_field=0.0)
setup_sk(sk, 'iwn')
results['den'] = \
sk.calc_momentum_distribution(mu=params["mu"], beta=beta, with_Sigma=True, with_dc=True)
elif params['calc_mode'] == 'bse':
# chi0
from dft_tools.sumk_dft_chi import SumkDFTChi
# save div data (overwrite if data exist)
if mpi.is_master_node():
with HDFArchive(model_hdf5_file, 'a') as ar:
if 'dft_input_chi' in ar:
del ar['dft_input_chi']
ar.create_group('dft_input_chi')
ar['dft_input_chi']['div'] = numpy.array(params['div'])
# check if IBZ and FBZ data are saved separately
dft_data_fbz = 'dft_input'
if mpi.is_master_node():
with HDFArchive(model_hdf5_file, 'r') as ar:
if 'dft_input_fbz' in ar:
dft_data_fbz = 'dft_input_fbz'
dft_data_fbz = mpi.bcast(dft_data_fbz)
sk = SumkDFTChi(hdf_file=model_hdf5_file,
use_dft_blocks=False,
h_field=0.0,
dft_data_fbz=dft_data_fbz)
setup_sk(sk, 'iwn')
temp_file = None
if params['use_temp_file']:
temp_file = 'G_k_iw_temp.h5'
sk.save_X0q_for_bse(list_wb=params['list_wb'],
n_wf_cutoff=params['n_wf_G2'],
qpoints_saved=params['X0q_qpoints_saved'],
h5_file=params['bse_h5_out_file'],
temp_file=temp_file,
nonlocal_order_parameter=False)
else:
raise RuntimeError("Unknown calc_mode: " + str(params['calc_mode']))
if mpi.is_master_node():
with HDFArchive(output_file, 'w') as h:
for k, v in list(results.items()):
h[k] = v
chemical_potential0 = 0.0
if mpi.is_master_node():
ar = HDFArchive(filename+'.h5','a')
if 'iteration_count' in ar['DMFT_results']:
previous_present = True
iteration_offset = ar['DMFT_results']['iteration_count']+1
print('reading iteration'+str(iteration_offset))
SK_tools.dc_imp = ar['DMFT_results']['Iterations']['dc_imp'+str(iteration_offset-1)]
S.Sigma_w = ar['DMFT_results']['Iterations']['Sigma_w_it'+str(iteration_offset-1)]
dc_energ = ar['DMFT_results']['Iterations']['dc_energ'+str(iteration_offset-1)]
SK_tools.chemical_potential = ar['DMFT_results']['Iterations']['chemical_potential'+str(iteration_offset-1)].real
chemical_potential0 = ar['DMFT_results']['Iterations']['chemical_potential0'].real
mpi.barrier()
S.Sigma_w << mpi.bcast(S.Sigma_w)
SK_tools.chemical_potential = mpi.bcast(SK_tools.chemical_potential)
chemical_potential0 = mpi.bcast(chemical_potential0)
SK_tools.dc_imp = mpi.bcast(SK_tools.dc_imp)
SK_tools.put_Sigma(Sigma_imp = [S.Sigma_w])
idelta = 0.1
DOS, DOSproj, DOSproj_orb = SK_tools.dos_wannier_basis(broadening=idelta, with_dc=True, with_Sigma=True)
SK_tools.chemical_potential = chemical_potential0
SK_tools.put_Sigma(Sigma_imp = [0.0*S.Sigma_w])
idelta = 0.1
DOS0, DOSproj0, DOSproj0_orb = SK_tools.dos_wannier_basis(broadening=idelta, with_dc=False, with_Sigma=True)
if mpi.is_master_node():
ar['DMFT_results']['Iterations']['DOS_it'+str(iteration_offset-1)] = DOS
ar['DMFT_results']['Iterations']['DOSproj_orb_it'+str(iteration_offset-1)] = DOSproj_orb
def dmft_cycle():
filename = 'nio'
Converter = VaspConverter(filename=filename)
Converter.convert_dft_input()
SK = SumkDFT(hdf_file = filename+'.h5', use_dft_blocks = False)
beta = 5.0
Sigma = SK.block_structure.create_gf(beta=beta)
SK.put_Sigma([Sigma])
G = SK.extract_G_loc()
SK.analyse_block_structure_from_gf(G, threshold = 1e-2)
for i_sh in range(len(SK.deg_shells)):
num_block_deg_orbs = len(SK.deg_shells[i_sh])
mpi.report('found {0:d} blocks of degenerate orbitals in shell {1:d}'.format(num_block_deg_orbs, i_sh))
for iblock in range(num_block_deg_orbs):
mpi.report('block {0:d} consists of orbitals:'.format(iblock))
for keys in list(SK.deg_shells[i_sh][iblock].keys()):
mpi.report(' '+keys)
# Setup CTQMC Solver
n_orb = SK.corr_shells[0]['dim']
spin_names = ['up','down']
orb_names = [i for i in range(0,n_orb)]
#gf_struct = set_operator_structure(spin_names, orb_names, orb_hyb)
gf_struct = SK.gf_struct_solver[0]
mpi.report('Sumk to Solver: %s'%SK.sumk_to_solver)
mpi.report('GF struct sumk: %s'%SK.gf_struct_sumk)
mpi.report('GF struct solver: %s'%SK.gf_struct_solver)
S = Solver(beta=beta, gf_struct=gf_struct)
# Construct the Hamiltonian and save it in Hamiltonian_store.txt
H = Operator()
U = 8.0
J = 1.0
U_sph = U_matrix(l=2, U_int=U, J_hund=J)
U_cubic = transform_U_matrix(U_sph, spherical_to_cubic(l=2, convention=''))
Umat, Upmat = reduce_4index_to_2index(U_cubic)
H = h_int_density(spin_names, orb_names, map_operator_structure=SK.sumk_to_solver[0], U=Umat, Uprime=Upmat)
# Print some information on the master node
mpi.report('Greens function structure is: %s '%gf_struct)
mpi.report('U Matrix set to:\n%s'%Umat)
mpi.report('Up Matrix set to:\n%s'%Upmat)
# Parameters for the CTQMC Solver
p = {}
p["max_time"] = -1
p["random_name"] = ""
p["random_seed"] = 123 * mpi.rank + 567
p["length_cycle"] = 100
p["n_warmup_cycles"] = 2000
p["n_cycles"] = 20000
p["fit_max_moment"] = 4
p["fit_min_n"] = 30
p["fit_max_n"] = 50
p["perform_tail_fit"] = True
# Double Counting: 0 FLL, 1 Held, 2 AMF
DC_type = 0
DC_value = 59.0
# Prepare hdf file and and check for previous iterations
n_iterations = 1
iteration_offset = 0
if mpi.is_master_node():
ar = HDFArchive(filename+'.h5','a')
if not 'DMFT_results' in ar: ar.create_group('DMFT_results')
if not 'Iterations' in ar['DMFT_results']: ar['DMFT_results'].create_group('Iterations')
if not 'DMFT_input' in ar: ar.create_group('DMFT_input')
if not 'Iterations' in ar['DMFT_input']: ar['DMFT_input'].create_group('Iterations')
if not 'code_versions' in ar['DMFT_input']: ar['DMFT_input'].create_group('code_versio\
ns')
ar['DMFT_input']['code_versions']["triqs_version"] = triqs_version.version
ar['DMFT_input']['code_versions']["triqs_git"] = triqs_version.git_hash
ar['DMFT_input']['code_versions']["cthyb_version"] = cthyb_version.version
ar['DMFT_input']['code_versions']["cthyb_git"] = cthyb_version.triqs_cthyb_hash
ar['DMFT_input']['code_versions']["dft_tools_version"] = dft_tools_version.version
ar['DMFT_input']['code_versions']["dft_tools_git"] = dft_tools_version.triqs_dft_tools_hash
if 'iteration_count' in ar['DMFT_results']:
iteration_offset = ar['DMFT_results']['iteration_count']+1
S.Sigma_iw = ar['DMFT_results']['Iterations']['Sigma_it'+str(iteration_offset-1)]
SK.dc_imp = ar['DMFT_results']['Iterations']['dc_imp'+str(iteration_offset-1)]
SK.dc_energ = ar['DMFT_results']['Iterations']['dc_energ'+str(iteration_offset-1)]
SK.chemical_potential = ar['DMFT_results']['Iterations']['chemical_potential'+str(iteration_offset-1)].real
ar['DMFT_input']["dmft_script_it"+str(iteration_offset)] = open(sys.argv[0]).read()
iteration_offset = mpi.bcast(iteration_offset)
S.Sigma_iw = mpi.bcast(S.Sigma_iw)
SK.dc_imp = mpi.bcast(SK.dc_imp)
SK.dc_energ = mpi.bcast(SK.dc_energ)
SK.chemical_potential = mpi.bcast(SK.chemical_potential)
# Calc the first G0
SK.symm_deg_gf(S.Sigma_iw, ish=0)
SK.put_Sigma(Sigma_imp = [S.Sigma_iw])
SK.calc_mu(precision=0.01)
S.G_iw << SK.extract_G_loc()[0]
SK.symm_deg_gf(S.G_iw, ish=0)
#Init the DC term and the self-energy if no previous iteration was found
if iteration_offset == 0:
dm = S.G_iw.density()
SK.calc_dc(dm, U_interact=U, J_hund=J, orb=0, use_dc_formula=DC_type,use_dc_value=DC_value)
S.Sigma_iw << SK.dc_imp[0]['up'][0,0]
mpi.report('%s DMFT cycles requested. Starting with iteration %s.'%(n_iterations,iteration_offset))
# The infamous DMFT self consistency cycle
for it in range(iteration_offset, iteration_offset + n_iterations):
mpi.report('Doing iteration: %s'%it)
# Get G0
S.G0_iw << inverse(S.Sigma_iw + inverse(S.G_iw))
# Solve the impurity problem
S.solve(h_int = H, **p)
if mpi.is_master_node():
ar['DMFT_input']['Iterations']['solver_dict_it'+str(it)] = p
ar['DMFT_results']['Iterations']['Gimp_it'+str(it)] = S.G_iw
ar['DMFT_results']['Iterations']['Gtau_it'+str(it)] = S.G_tau
ar['DMFT_results']['Iterations']['Sigma_uns_it'+str(it)] = S.Sigma_iw
# Calculate double counting
dm = S.G_iw.density()
SK.calc_dc(dm, U_interact=U, J_hund=J, orb=0, use_dc_formula=DC_type,use_dc_value=DC_value)
# Get new G
SK.symm_deg_gf(S.Sigma_iw, ish=0)
SK.put_Sigma(Sigma_imp=[S.Sigma_iw])
SK.calc_mu(precision=0.01)
S.G_iw << SK.extract_G_loc()[0]
# print densities
for sig,gf in S.G_iw:
mpi.report("Orbital %s density: %.6f"%(sig,dm[sig][0,0]))
mpi.report('Total charge of Gloc : %.6f'%S.G_iw.total_density())
if mpi.is_master_node():
ar['DMFT_results']['iteration_count'] = it
ar['DMFT_results']['Iterations']['Sigma_it'+str(it)] = S.Sigma_iw
ar['DMFT_results']['Iterations']['Gloc_it'+str(it)] = S.G_iw
ar['DMFT_results']['Iterations']['G0loc_it'+str(it)] = S.G0_iw
ar['DMFT_results']['Iterations']['dc_imp'+str(it)] = SK.dc_imp
ar['DMFT_results']['Iterations']['dc_energ'+str(it)] = SK.dc_energ
ar['DMFT_results']['Iterations']['chemical_potential'+str(it)] = SK.chemical_potential
if mpi.is_master_node():
print('calculating mu...')
SK.chemical_potential = SK.calc_mu( precision = 0.000001 )
if mpi.is_master_node():
print('calculating GAMMA')
SK.calc_density_correction(dm_type='vasp')
if mpi.is_master_node():
print('calculating energy corrections')
correnerg = 0.5 * (S.G_iw * S.Sigma_iw).total_density()
dm = S.G_iw.density() # compute the density matrix of the impurity problem
SK.calc_dc(dm, U_interact=U, J_hund=J, orb=0, use_dc_formula=DC_type,use_dc_value=DC_value)
dc_energ = SK.dc_energ[0]
if mpi.is_master_node():
ar['DMFT_results']['Iterations']['corr_energy_it'+str(it)] = correnerg
ar['DMFT_results']['Iterations']['dc_energy_it'+str(it)] = dc_energ
if mpi.is_master_node(): del ar
return correnerg, dc_energ