def getInfoForDensityCalculation(h5, it):
p = share_fun.load_parms(h5, it);
corr_id = getCorrIndex(p);
dmft_id = getDMFTCorrIndex(p);
N_LAYERS = int(p['N_LAYERS']); FLAVORS = int(p['FLAVORS']); SPINS = int(p['SPINS']);
NORB = int(p['NORB']); NCOR = int(p['NCOR']);
se = h5['SolverData/selfenergy_asymp_coeffs'][:];
se = se[se[:,0] == it][0, 1:].reshape(SPINS,2,-1);
mu = float(p['MU']);
Gcoefs = h5['SolverData/AvgDispersion'][:, 0, :] - mu;
Gcoefs[:, corr_id] += se[:, 0, :];
ret = dict({
'G_asymp_coefs' : Gcoefs,
'correction' : zeros(SPINS)
});
ret1 = dict({
'G_asymp_coefs' : Gcoefs[:,corr_id],
'correction' : zeros(SPINS)
});
if float(p['U']) != 0 and it > 0:
approx_dens = fun.getDensityFromGmat(h5['ImpurityGreen/'+str(it)][:], float(p['BETA']), ret1);
try: correct_dens = -h5['SolverData/Gtau/%d'%it][:, -1, :];
except: correct_dens = None;
if correct_dens is None: d = 0;
else:
d = zeros((SPINS, NCOR));
for L in range(N_LAYERS): d[:, dmft_id] = correct_dens[:, dmft_id] - approx_dens[:, dmft_id];
else: d = 0;
ret['correction'] = zeros((SPINS, NORB));
# ret['correction'][:, corr_id] = d; # correction not needed
return ret;
def averageGreen(delta0, mu0, w, SelfEnergy, parms, Nd, Ntot, tuneup, extra):
N_LAYERS = int(parms['N_LAYERS'])
FLAVORS = int(parms['FLAVORS'])
SPINS = int(parms['SPINS'])
rot_mat = extra['rot_mat']
parallel = int(parms.get('KINT_PARALLEL', 2))
# calculate intersite Coulomb energy here
Vc = zeros(N_LAYERS, dtype=float)
# convert self energy to the C++ form
SelfEnergy_rot = array([irotate(SelfEnergy[s], rot_mat)
for s in range(SPINS)])
SE = array([array([s.flatten() for s in SelfEnergy_rot[n]])
for n in range(SPINS)])
v_delta = array([])
ddelta = 0.
delta_step = 1.
v_nd = array([])
dmu = 0.
mu_step = 0.5
tol = 0.003
firsttime = True
initial_Gasymp = extra['G_asymp_coefs'] if 'G_asymp_coefs' in extra.keys()\
else None
starting_error = 0.
# Delta loop
while True:
delta = delta0 + ddelta
if initial_Gasymp is not None:
extra['G_asymp_coefs'][:N_LAYERS*FLAVORS] = initial_Gasymp[:N_LAYERS*FLAVORS] - ddelta
v_mu = array([])
v_n = array([])
# mu loop
while True:
mu = mu0 + dmu
if initial_Gasymp is not None:
extra['G_asymp_coefs'] = initial_Gasymp - dmu
Gavg = integrate(w, delta, mu, SE, parms, extra, parallel)
Gavg_diag = array([[diag(Gavg[s, n]) for n in range(size(Gavg,1))]
for s in range(SPINS)])
nf = getDensityFromGmat(Gavg_diag, float(parms['BETA']), extra)
my_ntot = sum(nf) if SPINS == 2 else 2*sum(nf)
print " adjust mu: %.5f %.5f %.5f"%(mu, dmu, my_ntot)
if firsttime:
starting_error = abs(Ntot - my_ntot)/N_LAYERS
Gavg0 = Gavg.copy()
firsttime = False
if Ntot < 0 or abs(Ntot - my_ntot)/N_LAYERS < tol or not tuneup:
break
v_mu = r_[v_mu, dmu]
v_n = r_[v_n, my_ntot]
if v_n.min() < Ntot and v_n.max() > Ntot:
dmu = interp_root(v_mu, v_n, Ntot)
else:
dmu += (1. if my_ntot < Ntot else -1.)*mu_step
my_nd = sum(nf[:, :N_LAYERS*FLAVORS])
if tuneup:
print ('adjust double counting: %.5f %.5f '
'%.5f %.5f')%(delta, ddelta, my_nd, my_nd/N_LAYERS)
if Nd < 0 or abs(Nd - my_nd)/N_LAYERS < tol or not tuneup:
break
v_delta = r_[v_delta, ddelta]
v_nd = r_[v_nd, my_nd]
if v_nd.min() < Nd and v_nd.max() > Nd:
ddelta = interp_root(v_delta, v_nd, Nd)
else:
ddelta += (1. if my_nd < Nd else -1.)*delta_step
# adjusted Gavg with mu_new = mu_0 + N*dmu and
# delta_new = delta_0 + N*ddelta;
N = float(parms.get('TUNEUP_FACTOR', 1))
if N != 1. and (ddelta != 0. or dmu != 0.) and starting_error < 50*tol:
mu = mu0 + N*dmu
delta = delta0 + N*ddelta
Gavg = integrate(w, delta, mu, SE, parms, extra, parallel)
print ('TUNEUP_FACTOR = %d final adjustment: mu = %.4f, dmu = %.4f, '
'delta = %.4f, ddelta = %.4f')%(N, mu, N*dmu, delta, N*ddelta)
Gavg = array([rotate_all(Gavg[s], rot_mat) for s in range(SPINS)])
Gavg0 = array([rotate_all(Gavg0[s], rot_mat, need_extra = True)
for s in range(SPINS)])
if initial_Gasymp is not None:
extra['G_asymp_coefs'] = initial_Gasymp
return Gavg, Gavg0, delta, mu, Vc
