def readdOffdiagConstants(g, offdiags):
ginv = g.copy()
ginv << inverse(g)
for s, b in ginv:
orbs = range(len(b.data[0,:,:]))
for i,j in product(*[orbs]*2):
b[i, j] += offdiags[s][i,j]
g << inverse(ginv)
return g
def _g_lat(m, eps, bz_grid, spins):
n_k = len(bz_grid)
n_bands = len(eps[0, :, :])
g = [BlockGf(name_block_generator = [(s, m[0][s]) for s in spins], name = '$G_{lat}$', make_copies = True) for i in range(n_k)]
g_p = scatter_list(g)
for g_k, m_k, eps_k in izip(g_p, scatter_list(m), scatter_list(eps)):
for s in spins:
g_k[s] << inverse(inverse(m_k[s]) - eps_k)
g = allgather_list(g_p)
return g
def addExtField(g, field):
if field:
indices = [i for i in g.indices]
g = g.copy()
ginv = g.copy()
ginv << inverse(g)
for s, b in ginv:
for i in range(len(b.data[0,:,:])):
b[i,i] += field[s][i]
g << inverse(ginv)
return g
def setOffdiagsZero(g):
ginv = g.copy()
ginv << inverse(g)
offdiags = ginv.copy()
for s, b in ginv:
orbs = range(len(b.data[0,:,:]))
for i,j in product(*[orbs]*2):
if i != j:
b[i, j] << 0
else:
offdiags[s][i,j] << 0
g << inverse(ginv)
return g, offdiags
def _sigma_lat(m, bz_grid, mu, spins):
n_k = len(bz_grid)
sig = [BlockGf(name_block_generator = [(s, m[0][s]) for s in spins], name = '$\Sigma_{lat}$', make_copies = True) for i in range(n_k)]
sig_p = scatter_list(sig)
for m_k, sig_k in izip(scatter_list(m), sig_p):
for s in spins:
sig_k[s] << iOmega_n + mu - inverse(m_k[s])
sig = allgather_list(sig_p)
return sig
def make_g_0_iw_with_delta_tau_real(self, n_tau = 10000):
delta_iw = delta(self.g_0_iw)
delta_tau = self.get_delta_tau()
for s, b in delta_tau:
for n, tau in enumerate(b.mesh):
b.data[n,:,:] = b.data[n,:,:].real
# Tail consistency is maintained anyways
#for i in range(len(b.tail.data)):
# orbs = range(len(b.tail.data[i,:,:]))
# for j, k in product(orbs, orbs):
# b.tail.data[i,j,k] = b.tail.data[i,j,k].real
delta_iw_new = self.g_0_iw.copy()
for s, b in delta_iw_new:
b.set_from_fourier(delta_tau[s])
g_0_inv = self.g_0_iw.copy()
g_0_inv << inverse(self.g_0_iw)
g_0_inv << g_0_inv + delta_iw - delta_iw_new
self.g_0_iw << inverse(g_0_inv)
def _g_lat(sigma_lat, mu, eps, bz_grid, spins):
n_k = len(bz_grid)
n_bands = len(eps[0, :, :])
g = [BlockGf(name_block_generator = [(s, sigma_lat[i][s]) for s in spins], name = '$G_{lat}$', make_copies = True) for i in range(n_k)]
g_p = scatter_list(g)
for g_k, sig_k, eps_k in izip(g_p, scatter_list(sigma_lat), scatter_list(eps)):
for s, b in g_k:
b << inverse((iOmega_n + mu) * identity(n_bands) - eps_k - sig_k[s])
g = allgather_list(g_p)
return g
def make_g_0_iw_with_delta_tau_real(self, n_tau = 10000, verbosity = 0):
delta_iw = delta(self.g_0_iw)
delta_tau = self.get_delta_tau()
for s, b in delta_tau:
for n, tau in enumerate(b.mesh):
if verbosity >= 2 and (b.data[:,:,:].imag > 10**-8).any():
print 'WARNING:'
print 'delta_tau.imag is of significant magnitude!'
b.data[n,:,:] = b.data[n,:,:].real
# Tail consistency is maintained anyways
#for i in range(len(b.tail.data)):
# orbs = range(len(b.tail.data[i,:,:]))
# for j, k in product(orbs, orbs):
# b.tail.data[i,j,k] = b.tail.data[i,j,k].real
delta_iw_new = self.g_0_iw.copy()
for s, b in delta_iw_new:
b.set_from_fourier(delta_tau[s])
g_0_inv = self.g_0_iw.copy()
g_0_inv << inverse(self.g_0_iw)
g_0_inv << g_0_inv + delta_iw - delta_iw_new
self.g_0_iw << inverse(g_0_inv)
def assign_weiss_field(G0, parms, nspins, spin_names, nflavors, flavor_names):
hyb_mat_prefix = parms.get('HYB_MAT', '%s.hybmat'%parms['PREFIX'])
hyb_mat = genfromtxt('%s.real'%hyb_mat_prefix)[:,1:]\
+ 1j*genfromtxt('%s.imag'%hyb_mat_prefix)[:,1:]
hyb_tail = genfromtxt('%s.tail'%hyb_mat_prefix)
mu_vec = genfromtxt(parms.get('MU_VECTOR', '%s.mu_eff'%parms['PREFIX']))
for s in range(nspins):
for f in range(nflavors):
hyb_w = triqs_gf.GfImFreq(indices=[0], beta=parms['BETA'],
n_points=parms['N_MAX_FREQ'])
hyb_w.data[:, 0, 0] = hyb_mat[:, nspins*f+s]
for n in range(len(hyb_tail)):
hyb_w.tail[n+1][0, 0] = hyb_tail[n, nspins*f+s]
block, i = mkind(spin_names[s], flavor_names[f])
G0[block][i, i] << triqs_gf.inverse(triqs_gf.iOmega_n\
+mu_vec[nspins*f+s]-hyb_w)
def _cumulant_lat(sigma, mu, ssp, rbz_grid, spins):
n_k = len(rbz_grid)
n_sites = len(ssp.values()[0])
m_sl = [BlockGf(name_block_generator = [(s, GfImFreq(indices = range(n_sites), mesh = sigma[spins[0]].mesh)) for s in spins], name = '$M_{lat}$') for i in range(n_k)]
m_c = BlockGf(name_block_generator = [(s, GfImFreq(indices = range(len(sigma[spins[0]].data[0, :, :])), mesh = sigma[spins[0]].mesh)) for s in spins], name = '$M_C$')
for s, b in m_c: b << inverse(iOmega_n + mu - sigma[s])
mTrans = dict()
for r in ssp.keys():
mTrans[r] = empty([n_sites, n_sites], dtype = object)
for a in range(n_sites):
for b in range(n_sites):
mTrans[r][a,b] = ssp[r][a][b]
m_sl_p = scatter_list(m_sl)
for m, k in izip(m_sl_p, scatter_list(rbz_grid)):
for s, b in m:
for r, mTrans_r in mTrans.items():
for a in range(n_sites):
for b in range(n_sites):
if type(mTrans_r[a, b]) == tuple:
m[s][a, b] += mTrans_r[a, b][2] * exp(complex(0, 2 * pi * dot(k, array(r)))) * m_c[s][mTrans_r[a, b][0], mTrans_r[a, b][1]]
m_sl = allgather_list(m_sl_p)
return m_sl
L = TBLattice ( units = [(1, 0, 0) , (0, 1, 0) ], hopping = hop)
SL = TBSuperLattice(tb_lattice =L, super_lattice_units = [ (2, 0), (0, 2) ])
# SumK function that will perform the sum over the BZ
SK = SumkDiscreteFromLattice (lattice = SL, n_points = 8, method = "Riemann")
# Defines G and Sigma with a block structure compatible with the SumK function
G= BlockGf( name_block_generator = [ (s, GfImFreq(indices = SK.GFBlocIndices, mesh = S.G.mesh)) for s in ['up', 'down'] ], make_copies = False)
Sigma = G.copy()
# Init Sigma
for n, B in S.Sigma : B <<= 2.0
S.symm_to_real(gf_in = S.Sigma, gf_out = Sigma) # Embedding
# Computes sum over BZ and returns density
dens = (SK(mu = Chemical_potential, Sigma = Sigma, field = None , result = G).total_density()/4)
mpi.report("Total density = %.3f"%dens)
S.real_to_symm(gf_in = G, gf_out = S.G) # Extraction
S.G0 = inverse(S.Sigma + inverse(S.G)) # Finally get S.G0
# Solve the impurity problem
S.solve(n_cycles = 3000, n_warmup_cycles = 0, length_cycle = 10, n_legendre = 30)
# Opens the results shelve
if mpi.is_master_node():
Results = HDFArchive("cdmft_4_sites.output.h5", 'w')
Results["G"] = S.G
Results["Gl"] = S.G_legendre
from pytriqs.plot.mpl_interface import oplot
from pytriqs.gf.local import GfImFreq, Omega, inverse
g = GfImFreq(indices=[0], beta=300, n_points=1000, name="g")
g << inverse(Omega + 0.5)
# the data we want to fit...
# The green function for omega \in [0,0.2]
X, Y = g.x_data_view(x_window=(0, 0.2), flatten_y=True)
from pytriqs.fit import Fit, linear, quadratic
fitl = Fit(X, Y.imag, linear)
fitq = Fit(X, Y.imag, quadratic)
oplot(g, '-o', x_window=(0, 5))
oplot(fitl, '-x', x_window=(0, 0.5))
oplot(fitq, '-x', x_window=(0, 1))
# a bit more complex, we want to fit with a one fermion level ....
# Cf the definition of linear and quadratic in the lib
one_fermion_level = lambda X, a, b: 1 / (a * X * 1j + b
), r"${1}/(%f x + %f)$", (1, 1)
fit1 = Fit(X, Y, one_fermion_level)
oplot(fit1, '-x', x_window=(0, 3))
from pytriqs.plot.mpl_interface import oplot
from pytriqs.gf.local import GfImFreq, Omega, inverse
g = GfImFreq(indices=[0], beta=300, n_points=1000, name="g")
g <<= inverse(Omega + 0.5)
# the data we want to fit...
# The green function for omega \in [0,0.2]
X, Y = g.x_data_view(x_window=(0, 0.2), flatten_y=True)
from pytriqs.fit import Fit, linear, quadratic
fitl = Fit(X, Y.imag, linear)
fitq = Fit(X, Y.imag, quadratic)
oplot(g, "-o", x_window=(0, 5))
oplot(fitl, "-x", x_window=(0, 0.5))
oplot(fitq, "-x", x_window=(0, 1))
# a bit more complex, we want to fit with a one fermion level ....
# Cf the definition of linear and quadratic in the lib
one_fermion_level = lambda X, a, b: 1 / (a * X * 1j + b), r"${1}/(%f x + %f)$", (1, 1)
fit1 = Fit(X, Y, one_fermion_level)
oplot(fit1, "-x", x_window=(0, 3))
# Import the Green's functions
from pytriqs.gf.local 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 pytriqs.utility.mpi as mpi
mpi.bcast(g)
#Block
from pytriqs.gf.local 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 pytriqs.gf.local import *
# A Green's function on the Matsubara axis set to a semicircular
gw = GfImFreq(indices=[1], beta=50)
gw <<= SemiCircular(half_bandwidth=1)
# Create an imaginary-time Green's function and plot it
from pytriqs.gf.local import GfReFreq, Omega, Wilson, inverse
import numpy
eps_d,t = 0.3, 0.2
# Create the real-frequency Green's function and initialize it
g = GfReFreq(indices = ['s','d'], window = (-2, 2), n_points = 1000, name = "$G_\mathrm{s+d}$")
g['d','d'] = Omega - eps_d
g['d','s'] = t
g['s','d'] = t
g['s','s'] = inverse( Wilson(1.0) )
g.invert()
# Plot it with matplotlib. 'S' means: spectral function ( -1/pi Imag (g) )
from pytriqs.plot.mpl_interface import *
oplot( g['d','d'], '-o', RI = 'S', x_window = (-1.8,1.8), name = "Impurity" )
oplot( g['s','s'], '-x', RI = 'S', x_window = (-1.8,1.8), name = "Bath" )
plt.show()
from pytriqs.gf.local import GfReFreq, Omega, Wilson, inverse
import numpy
eps_d, t = 0.3, 0.2
# Create the real-frequency Green's function and initialize it
g = GfReFreq(indices=["s", "d"], window=(-2, 2), n_points=1000, name="$G_\mathrm{s+d}$")
g["d", "d"] = Omega - eps_d
g["d", "s"] = t
g["s", "d"] = t
g["s", "s"] = inverse(Wilson(1.0))
g.invert()
# Plot it with matplotlib. 'S' means: spectral function ( -1/pi Imag (g) )
from pytriqs.plot.mpl_interface import oplot
oplot(g["d", "d"], "-o", RI="S", x_window=(-1.8, 1.8), name="Impurity")
oplot(g["s", "s"], "-x", RI="S", x_window=(-1.8, 1.8), name="Bath")
from pytriqs.plot.mpl_interface import oplot
from pytriqs.gf.local import GfImFreq, Omega, inverse
g = GfImFreq(indices = [0], beta = 300, n_points = 1000, name = "g")
g << inverse( Omega + 0.5 )
# the data we want to fit...
# The green function for omega \in [0,0.2]
X,Y = g.x_data_view (x_window = (0,0.2), flatten_y = True )
from pytriqs.fit import Fit, linear, quadratic
fitl = Fit ( X,Y.imag, linear )
fitq = Fit ( X,Y.imag, quadratic )
oplot (g, '-o', x_window = (0,5) )
oplot (fitl , '-x', x_window = (0,0.5) )
oplot (fitq , '-x', x_window = (0,1) )
# a bit more complex, we want to fit with a one fermion level ....
# Cf the definition of linear and quadratic in the lib
one_fermion_level = lambda X, a,b : 1/(a * X *1j + b), r"${1}/(%f x + %f)$" , (1,1)
fit1 = Fit ( X,Y, one_fermion_level )
oplot (fit1 , '-x', x_window = (0,3) )
# Defines G and Sigma with a block structure compatible with the SumK function
G = BlockGf(name_block_generator=[(s,
GfImFreq(indices=SK.GFBlocIndices,
mesh=S.G.mesh))
for s in ['up', 'down']],
make_copies=False)
Sigma = G.copy()
# Init Sigma
for n, B in S.Sigma:
B <<= 2.0
S.symm_to_real(gf_in=S.Sigma, gf_out=Sigma) # Embedding
# Computes sum over BZ and returns density
dens = (SK(mu=Chemical_potential, Sigma=Sigma, field=None,
result=G).total_density() / 4)
mpi.report("Total density = %.3f" % dens)
S.real_to_symm(gf_in=G, gf_out=S.G) # Extraction
S.G0 = inverse(S.Sigma + inverse(S.G)) # Finally get S.G0
# Solve the impurity problem
S.solve(n_cycles=3000, n_warmup_cycles=0, length_cycle=10, n_legendre=30)
# Opens the results shelve
if mpi.is_master_node():
Results = HDFArchive("cdmft_4_sites.output.h5", 'w')
Results["G"] = S.G
Results["Gl"] = S.G_legendre
# Import the Green's functions
from pytriqs.gf.local 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 = "$G_\mathrm{imp}$")
g << inverse( iOmega_n + 0.5 )
from pytriqs.plot.mpl_interface import oplot
oplot(g, '-o', x_window = (0,10))
from pytriqs.plot.mpl_interface import oplot
from pytriqs.gf.local import GfImFreq, Omega, inverse
g = GfImFreq(indices=[0], beta=300, n_points=1000, name="g")
g <<= inverse(Omega + 0.5)
# the data we want to fit...
# The green function for omega \in [0,0.2]
X, Y = g.x_data_view(x_window=(0, 0.2), flatten_y=True)
from pytriqs.fit import Fit, linear, quadratic
fitl = Fit(X, Y.imag, linear)
fitq = Fit(X, Y.imag, quadratic)
oplot(g, '-o', x_window=(0, 5))
oplot(fitl, '-x', x_window=(0, 0.5))
oplot(fitq, '-x', x_window=(0, 1))
# a bit more complex, we want to fit with a one fermion level ....
# Cf the definition of linear and quadratic in the lib
one_fermion_level = lambda X, a, b: 1 / (a * X * 1j + b
), r"${1}/(%f x + %f)$", (1, 1)
fit1 = Fit(X, Y, one_fermion_level)
oplot(fit1, '-x', x_window=(0, 3))
from pytriqs.gf.local import GfReFreq, Omega, Wilson, inverse
import numpy
eps_d,t = 0.3, 0.2
# Create the real-frequency Green's function and initialize it
g = GfReFreq(indices = ['s','d'], window = (-2, 2), n_points = 1000, name = "$G_\mathrm{s+d}$")
g['d','d'] = Omega - eps_d
g['d','s'] = t
g['s','d'] = t
g['s','s'] = inverse( Wilson(1.0) )
g.invert()
# Plot it with matplotlib. 'S' means: spectral function ( -1/pi Imag (g) )
from pytriqs.plot.mpl_interface import oplot
oplot( g['d','d'], '-o', RI = 'S', x_window = (-1.8,1.8), name = "Impurity" )
oplot( g['s','s'], '-x', RI = 'S', x_window = (-1.8,1.8), name = "Bath" )
def run_dmft_loops(self, n_dmft_loops = 1):
"""runs the DMFT calculation"""
clp = p = CleanLoopParameters(self.get_parameters())
report = Reporter(**clp)
report('Parameters:', clp)
scheme = Scheme(**clp)
dmft = DMFTObjects(**clp)
raw_dmft = DMFTObjects(**clp)
g_0_c_iw, g_c_iw, sigma_c_iw, dmu = dmft.get_dmft_objs() # ref, ref, ref, value
report('Initializing...')
if clp['nambu']:
transf = NambuTransformation(**clp)
scheme.set_pretransf(transf.pretransformation(), transf.pretransformation_inverse())
raw_transf = NambuTransformation(**clp)
else:
transf = ClustersiteTransformation(g_loc = scheme.g_local(sigma_c_iw, dmu), **clp)
clp.update({'g_transf_struct': transf.get_g_struct()})
raw_transf = ClustersiteTransformation(**clp)
transf.set_hamiltonian(**clp)
report('Transformation ready')
report('New basis:', transf.get_g_struct())
impurity = Solver(beta = clp['beta'], gf_struct = dict(transf.get_g_struct()),
n_tau = clp['n_tau'], n_iw = clp['n_iw'], n_l = clp['n_legendre'])
impurity.Delta_tau.name = '$\\tilde{\\Delta}_c$'
rnames = random_generator_names_list()
report('H = ', transf.hamiltonian)
report('Impurity solver ready')
report('')
for loop_nr in range(self.next_loop(), self.next_loop() + n_dmft_loops):
report('DMFT-loop nr. %s'%loop_nr)
if mpi.is_master_node(): duration = time()
report('Calculating dmu...')
dmft.find_dmu(scheme, **clp)
g_0_c_iw, g_c_iw, sigma_c_iw, dmu = dmft.get_dmft_objs()
report('dmu = %s'%dmu)
report('Calculating local Greenfunction...')
g_c_iw << scheme.g_local(sigma_c_iw, dmu)
g_c_iw << addExtField(g_c_iw, p['ext_field'])
if mpi.is_master_node() and p['verbosity'] > 1: checksym_plot(g_c_iw, p['archive'][0:-3] + 'Gchecksym' + str(loop_nr) + '.pdf')
report('Calculating Weiss-field...')
g_0_c_iw << inverse(inverse(g_c_iw) + sigma_c_iw)
dmft.make_g_0_iw_with_delta_tau_real()
report('Changing basis...')
transf.set_dmft_objs(*dmft.get_dmft_objs())
if mpi.is_master_node() and p['verbosity'] > 1:
checktransf_plot(transf.get_g_iw(), p['archive'][0:-3] + 'Gchecktransf' + str(loop_nr) + '.pdf')
checktransf_plot(g_0_c_iw, p['archive'][0:-3] + 'Gweisscheck' + str(loop_nr) + '.pdf')
checksym_plot(inverse(transf.g_0_iw), p['archive'][0:-3] + 'invGweisscheckconst' + str(loop_nr) + '.pdf')
#checksym_plot(inverse(transf.get_g_iw()), p['archive'][0:-3] + 'invGsymcheckconst' + str(loop_nr) + '.pdf')
if not clp['random_name']: clp.update({'random_name': rnames[int((loop_nr + mpi.rank) % len(rnames))]}) # TODO move
if not clp['random_seed']: clp.update({'random_seed': 862379 * mpi.rank + 12563 * self.next_loop()})
impurity.G0_iw << transf.get_g_0_iw()
report('Solving impurity problem...')
mpi.barrier()
impurity.solve(h_int = transf.get_hamiltonian(), **clp.get_cthyb_parameters())
if mpi.is_master_node() and p['verbosity'] > 1:
checksym_plot(inverse(impurity.G0_iw), p['archive'][0:-3] + 'invGweisscheckconstsolver' + str(loop_nr) + '.pdf')
report('Postprocessing measurements...')
if clp['measure_g_l']:
for ind, g in transf.get_g_iw(): g << LegendreToMatsubara(impurity.G_l[ind])
else:
for ind, g in transf.get_g_iw(): g.set_from_fourier(impurity.G_tau[ind])
raw_transf.set_dmft_objs(transf.get_g_0_iw(),
transf.get_g_iw(),
inverse(transf.get_g_0_iw()) - inverse(transf.get_g_iw()))
if clp['measure_g_tau'] and clp['fit_tail']:
for ind, g in transf.get_g_iw():
for tind in transf.get_g_struct():
if tind[0] == ind: block_inds = tind[1]
fixed_moments = TailGf(len(block_inds), len(block_inds), 1, 1)
fixed_moments[1] = identity(len(block_inds))
g.fit_tail(fixed_moments, 3, clp['tail_start'], clp['n_iw'] - 1)
if mpi.is_master_node() and p['verbosity'] > 1: checksym_plot(inverse(transf.get_g_iw()), p['archive'][0:-3] + 'invGsymcheckconstsolver' + str(loop_nr) + '.pdf')
report('Backtransforming...')
transf.set_sigma_iw(inverse(transf.get_g_0_iw()) - inverse(transf.get_g_iw()))
dmft.set_dmft_objs(*transf.get_backtransformed_dmft_objs())
dmft.set_dmu(dmu)
raw_dmft.set_dmft_objs(*raw_transf.get_backtransformed_dmft_objs())
raw_dmft.set_dmu(dmu)
if clp['mix']: dmft.mix()
if clp['impose_paramagnetism']: dmft.paramagnetic()
if clp['impose_afm']: dmft.afm()
if clp['site_symmetries']: dmft.site_symmetric(clp['site_symmetries'])
density = scheme.apply_pretransf_inv(dmft.get_g_iw(), True).total_density()
report('Saving results...')
if mpi.is_master_node():
a = HDFArchive(p['archive'], 'a')
if not a.is_group('results'):
a.create_group('results')
a_r = a['results']
a_r.create_group(str(loop_nr))
a_l = a_r[str(loop_nr)]
a_l['g_c_iw'] = dmft.get_g_iw()
a_l['g_c_iw_raw'] = raw_dmft.get_g_iw()
a_l['g_transf_iw'] = transf.get_g_iw()
a_l['g_transf_iw_raw'] = raw_transf.get_g_iw()
a_l['sigma_c_iw'] = dmft.get_sigma_iw()
a_l['sigma_c_iw_raw'] = raw_dmft.get_sigma_iw()
a_l['sigma_transf_iw'] = transf.get_sigma_iw()
a_l['sigma_transf_iw_raw'] = raw_transf.get_sigma_iw()
a_l['g_0_c_iw'] = dmft.get_g_0_iw()
a_l['g_0_c_iw_raw'] = raw_dmft.get_g_0_iw()
a_l['g_0_transf_iw'] = transf.get_g_0_iw()
a_l['g_0_transf_iw_raw'] = raw_transf.get_g_0_iw()
a_l['dmu'] = dmft.get_dmu()
a_l['density'] = density
a_l['loop_time'] = {'seconds': time() - duration,
'hours': (time() - duration)/3600.,
'days': (time() - duration)/3600./24.}
a_l['n_cpu'] = mpi.size
a_l['cdmft_code_version'] = CDmft._version
clp_dict = dict()
clp_dict.update(clp)
a_l['parameters'] = clp_dict
a_l['triqs_code_version'] = version
a_l['delta_transf_tau'] = impurity.Delta_tau
if clp['measure_g_l']: a_l['g_transf_l'] = impurity.G_l
if clp['measure_g_tau']: a_l['g_transf_tau'] = impurity.G_tau
a_l['sign'] = impurity.average_sign
if clp['measure_density_matrix']: a_l['density_matrix'] = impurity.density_matrix
a_l['g_atomic_tau'] = impurity.atomic_gf
a_l['h_loc_diagonalization'] = impurity.h_loc_diagonalization
if a_r.is_data('n_dmft_loops'):
a_r['n_dmft_loops'] += 1
else:
a_r['n_dmft_loops'] = 1
del a_l, a_r, a
report('Loop done')
report('')
mpi.barrier()
