def fixed_fermionic_window_python_wnk(chi_wnk, nwf):
r""" Helper routine to reduce the number of fermionic Matsubara
frequencies :math:`\nu` in a two frequency and one momenta dependent
generalized susceptibility :math:`\chi_{abcd}(\omega, \nu, \mathbf{k})`.
Parameters
----------
chi_wnk : two frequency and one momenta dependent generalized
susceptibility :math:`\chi_{abcd}(\omega, \nu, \mathbf{k})`.
nwf : number of fermionic frequencies to keep.
Returns
-------
chi_wnk_out : Susceptibility with reduced number of fermionic Matsubara
frequencies.
"""
g2 = chi_wnk
wmesh, nmesh, kmesh = g2.mesh.components
beta = g2.mesh.components[0].beta
nmesh_small = MeshImFreq(beta=beta, S='Fermion', n_max=nwf)
chi_wnk_out = Gf(mesh=MeshProduct(wmesh, nmesh_small, kmesh),
target_shape=g2.target_shape)
n = g2.data.shape[1]
s = n // 2 - nwf
e = n // 2 + nwf
chi_wnk_out.data[:] = g2.data[:, s:e, :]
return chi_wnk_out
def test_add_fake_bosonic_mesh_with_gf_nk(bzmesh):
nmesh = MeshImFreq(beta=1, S="Fermion", n_max=1)
gf_nk = Gf(mesh=MeshProduct(nmesh, bzmesh), target_shape=(2, 2))
gf_wnk = add_fake_bosonic_mesh(gf_nk)
np.testing.assert_allclose(gf_nk.data, gf_wnk[Idx(0), :, :].data)
def create_random_gamma_wnn(p):
wmesh_gamma = MeshImFreq(beta=p.beta, S="Boson", n_max=p.nw_gamma)
nmesh_gamma = MeshImFreq(beta=p.beta, S="Fermion", n_max=p.nwf)
gamma_wnn = Gf(
mesh=MeshProduct(wmesh_gamma, nmesh_gamma, nmesh_gamma),
target_shape=2 * g0_wk.target_shape,
)
np.random.seed(p.seed)
gamma_wnn.data[:] = np.random.rand(*gamma_wnn.data.shape)
return gamma_wnn
def add_fake_bosonic_mesh(gf, beta=None):
""" Put a one value bosonic mesh as the first mesh argument of a
Green's function object.
Parameters
----------
gf : Gf,
Green's function on some arbitrary mesh. If 'beta' is not given
one mesh needs to be a 'MeshImFreq' to obtain a beta'
beta : float, optional
The inverse temperature used for the fake bosonic mesh.
Returns
-------
gf_w : Gf,
Green's function with an additional one value bosonic mesh
on its first position.
"""
mesh = gf.mesh
if isinstance(mesh, MeshProduct):
meshes = mesh.components
else:
meshes = (mesh, )
# If beta is not given access it from a 'MeshImFreq' of the 'Gf'
if not beta:
betas = [mesh.beta for mesh in meshes if hasattr(mesh, "beta")]
if len(betas) == 0:
raise ValueError(
"No 'beta' was given and the Green's function does not contain"
" a 'MeshImFreq'")
beta = betas[0]
wmesh = MeshImFreq(beta, 'Boson', 1)
mesh = (wmesh, ) + meshes
mesh = MeshProduct(*mesh)
gf_w = Gf(mesh=mesh, target_shape=gf.target_shape)
gf_w.data[0, ...] = gf.data
return gf_w
def G2_loc_fixed_fermionic_window_python(g2, nwf):
""" Limit the last two fermionic freqiencies of a three
frequency Green's function object :math:`G(\omega, \nu, \nu')`
to ``nwf``. """
nw = (g2.data.shape[0] + 1) // 2
n = g2.data.shape[1]
beta = g2.mesh.components[0].beta
assert (n // 2 >= nwf)
mesh_iw = MeshImFreq(beta=beta, S='Boson', n_max=nw)
mesh_inu = MeshImFreq(beta=beta, S='Fermion', n_max=nwf)
mesh_prod = MeshProduct(mesh_iw, mesh_inu, mesh_inu)
g2_out = Gf(mesh=mesh_prod, target_shape=g2.target_shape)
s = n // 2 - nwf
e = n // 2 + nwf
g2_out.data[:] = g2.data[:, s:e, s:e]
return g2_out
statistic='Fermion', n_points=50,
target_shape=(1,1))
g_iwn = GfImFreq(name='$g$', beta=beta,
statistic='Fermion', n_points=10,
target_shape=(1,1))
ed.set_g2_tau(g_tau[0,0], c(up,0), c_dag(up,0))
ed.set_g2_iwn(g_iwn[0,0], c(up,0), c_dag(up,0))
# ------------------------------------------------------------------
# -- Two particle Green's functions
ntau = 20
imtime = MeshImTime(beta, 'Fermion', ntau)
prodmesh = MeshProduct(imtime, imtime, imtime)
g40_tau = Gf(name='g40_tau', mesh=prodmesh, target_shape=[1, 1, 1, 1])
g4_tau = Gf(name='g4_tau', mesh=prodmesh, target_shape=[1, 1, 1, 1])
ed.set_g40_tau(g40_tau, g_tau[0,0])
ed.set_g4_tau(g4_tau[0,0,0,0], c(up,0), c_dag(up,0), c(up,0), c_dag(up,0))
# ------------------------------------------------------------------
# -- Two particle Green's functions (equal times)
prodmesh = MeshProduct(imtime, imtime)
g3pp_tau = Gf(name='g4_tau', mesh=prodmesh, target_shape=[1, 1, 1, 1])
ed.set_g3_tau(g3pp_tau[0,0,0,0], c(up,0), c_dag(up,0), c(up,0)*c_dag(up,0))
# ------------------------------------------------------------------
def test_two_particle_greens_function():
# ------------------------------------------------------------------
# -- Hubbard atom with two bath sites, Hamiltonian
beta = 2.0
V1 = 2.0
V2 = 5.0
epsilon1 = 0.00
epsilon2 = 4.00
mu = 2.0
U = 0.0
up, do = 0, 1
docc = 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)
nB = c_dag(up, 1) * c(up, 1) + c_dag(do, 1) * c(do, 1)
nC = c_dag(up, 2) * c(up, 2) + c_dag(do, 2) * c(do, 2)
H = -mu * nA + epsilon1 * nB + epsilon2 * nC + U * docc + \
V1 * (c_dag(up, 0) * c(up, 1) + c_dag(up, 1) * c(up, 0) +
c_dag(do, 0) * c(do, 1) + c_dag(do, 1) * c(do, 0)) + \
V2 * (c_dag(up, 0) * c(up, 2) + c_dag(up, 2) * c(up, 0) +
c_dag(do, 0) * c(do, 2) + c_dag(do, 2) * c(do, 0))
# ------------------------------------------------------------------
# -- Exact diagonalization
fundamental_operators = [
c(up, 0), c(do, 0),
c(up, 1), c(do, 1),
c(up, 2), c(do, 2)
]
ed = TriqsExactDiagonalization(H, fundamental_operators, beta)
# ------------------------------------------------------------------
# -- single particle Green's functions
g_tau = GfImTime(name=r'$g$',
beta=beta,
statistic='Fermion',
n_points=100,
target_shape=(1, 1))
ed.set_g2_tau(g_tau[0, 0], c(up, 0), c_dag(up, 0))
# ------------------------------------------------------------------
# -- Two particle Green's functions
ntau = 10
imtime = MeshImTime(beta, 'Fermion', ntau)
prodmesh = MeshProduct(imtime, imtime, imtime)
g40_tau = Gf(name='g40_tau', mesh=prodmesh, target_shape=(1, 1, 1, 1))
g4_tau = Gf(name='g4_tau', mesh=prodmesh, target_shape=(1, 1, 1, 1))
ed.set_g40_tau_matrix(g40_tau, g_tau)
ed.set_g4_tau(g4_tau[0, 0, 0, 0], c(up, 0), c_dag(up, 0), c(up, 0),
c_dag(up, 0))
# ------------------------------------------------------------------
# -- compare
zero_outer_planes_and_equal_times(g4_tau)
zero_outer_planes_and_equal_times(g40_tau)
np.testing.assert_array_almost_equal(g4_tau.data, g40_tau.data)
from triqs.lattice import BravaisLattice, BrillouinZone
from triqs.gf import Gf, MeshProduct, MeshBrillouinZone, MeshImFreq
n_k = 32
n_w = 20
t=1
beta = 10.
BL = BravaisLattice([(1, 0, 0), (0, 1, 0)]) # Two unit vectors in R3
BZ = BrillouinZone(BL)
kmesh = MeshBrillouinZone(BZ, n_k=n_k)
wmesh = MeshImFreq(beta=beta, S='Fermion', n_max=n_w)
g0 = Gf(mesh=MeshProduct(wmesh, kmesh), target_shape=[]) # g0(k,omega), scalar valued
def eps(k):
return -2 * t* (np.cos(k.value[0]) + np.cos(k.value[1]))
# NB : loop is a bit slow in python ...
for k in g0.mesh[1]:
for w in g0.mesh[0]:
g0[w,k] = 1/(w - eps(k))
#name = "gd_k"
#G_k = HDFArchive(name+".h5",'r')[name]
spin = 'up'
h_0_mat = TBL._hop[(0,0,0)][0:n_orb,0:n_orb]
h_0 = sum(c_dag_vec[s] * h_0_mat * c_vec[s] for s in spin_names)[0,0]
Umat, Upmat = U_matrix_kanamori(n_orb, U_int=U, J_hund=J)
h_int = h_int_kanamori(spin_names, orb_names, Umat, Upmat, J, off_diag=True)
h_imp = h_0 + h_int
# ==== Non-Interacting Impurity Green function ====
gf_struct = [(s,orb_names) for s in spin_names]
iw_mesh = MeshImFreq(beta, 'Fermion', n_iw)
k_mesh = MeshBrillouinZone(TBL.bz, n_k)
k_iw_mesh = MeshProduct(k_mesh, iw_mesh)
G0_k_iw = BlockGf(mesh=k_iw_mesh, gf_struct=gf_struct)
G0_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct)
iw_vec = array([iw.value * np.eye(n_orb) for iw in iw_mesh])
k_vec = array([k.value for k in k_mesh])
e_k_vec = TBL.hopping(k_vec.T / 2. / pi).transpose(2, 0, 1)[::,0:n_orb,0:n_orb]
mu_mat = mu * np.eye(n_orb)
for s in spin_names:
G0_k_iw[s].data[:] = linalg.inv(iw_vec[None,...] + mu_mat[None,None,...] - e_k_vec[::,None,...])
G0_iw[s].data[:] = np.sum(G0_k_iw[s].data[:], axis=0) / len(k_mesh)
# ==== Hybridization Function ====
def make_calc():
# ------------------------------------------------------------------
# -- Read precomputed ED data
filename = "data_pomerol.tar.gz"
p = read_TarGZ_HDFArchive(filename)
# ------------------------------------------------------------------
# -- RPA tensor
from triqs_tprf.rpa_tensor import get_rpa_tensor
from triqs_tprf.rpa_tensor import fundamental_operators_from_gf_struct
fundamental_operators = fundamental_operators_from_gf_struct(p.gf_struct)
p.U_abcd = get_rpa_tensor(p.H_int, fundamental_operators)
# ------------------------------------------------------------------
# -- Generalized PH susceptibility
loc_bse = ParameterCollection()
loc_bse.chi_wnn = chi_from_gg2_PH(p.G_iw, p.G2_iw_ph)
loc_bse.chi0_wnn = chi0_from_gg2_PH(p.G_iw, p.G2_iw_ph)
loc_bse.gamma_wnn = inverse_PH(loc_bse.chi0_wnn) - inverse_PH(
loc_bse.chi_wnn)
loc_bse.chi_wnn_ref = inverse_PH(
inverse_PH(loc_bse.chi0_wnn) - loc_bse.gamma_wnn)
np.testing.assert_array_almost_equal(loc_bse.chi_wnn.data,
loc_bse.chi_wnn_ref.data)
loc_bse.chi0_w = trace_nn(loc_bse.chi0_wnn)
loc_bse.chi_w = trace_nn(loc_bse.chi_wnn)
# ------------------------------------------------------------------
# -- RPA, using BSE inverses and constant Gamma
loc_rpa = ParameterCollection()
loc_rpa.U_abcd = p.U_abcd
# -- Build constant gamma
loc_rpa.gamma_wnn = loc_bse.gamma_wnn.copy()
loc_rpa.gamma_wnn.data[:] = loc_rpa.U_abcd[None, None, None, ...]
# Nb! In the three frequency form $\Gamma \propto U/\beta^2$
loc_rpa.gamma_wnn.data[:] /= p.beta**2
loc_rpa.chi0_wnn = loc_bse.chi0_wnn
loc_rpa.chi0_w = loc_bse.chi0_w
# -- Solve RPA
loc_rpa.chi_wnn = inverse_PH(
inverse_PH(loc_rpa.chi0_wnn) - loc_rpa.gamma_wnn)
loc_rpa.chi_w = trace_nn(loc_rpa.chi_wnn)
# ------------------------------------------------------------------
# -- Bubble RPA on lattice
lat_rpa = ParameterCollection()
# -- Setup dummy lattice Green's function equal to local Green's function
bz = BrillouinZone(
BravaisLattice(units=np.eye(3), orbital_positions=[(0, 0, 0)]))
periodization_matrix = np.diag(np.array(list([1] * 3), dtype=np.int32))
kmesh = MeshBrZone(bz, periodization_matrix)
wmesh = MeshImFreq(beta=p.beta, S='Fermion', n_max=p.nwf_gf)
lat_rpa.g_wk = Gf(mesh=MeshProduct(wmesh, kmesh),
target_shape=p.G_iw.target_shape)
lat_rpa.g_wk[:, Idx(0, 0, 0)] = p.G_iw
# -- chi0_wk bubble and chi_wk_rpa bubble RPA
from triqs_tprf.lattice_utils import imtime_bubble_chi0_wk
lat_rpa.chi0_wk = imtime_bubble_chi0_wk(lat_rpa.g_wk, nw=1)
from triqs_tprf.lattice import solve_rpa_PH
lat_rpa.chi_wk = solve_rpa_PH(lat_rpa.chi0_wk, p.U_abcd)
lat_rpa.chi0_w = lat_rpa.chi0_wk[:, Idx(0, 0, 0)]
lat_rpa.chi_w = lat_rpa.chi_wk[:, Idx(0, 0, 0)]
print('--> cf Tr[chi0] and chi0_wk')
print(loc_rpa.chi0_w.data.reshape((4, 4)).real)
print(lat_rpa.chi0_w.data.reshape((4, 4)).real)
np.testing.assert_array_almost_equal(loc_rpa.chi0_w.data,
lat_rpa.chi0_w.data,
decimal=2)
print('ok!')
print('--> cf Tr[chi_rpa] and chi_wk_rpa')
print(loc_rpa.chi_w.data.reshape((4, 4)).real)
print(lat_rpa.chi_w.data.reshape((4, 4)).real)
np.testing.assert_array_almost_equal(loc_rpa.chi_w.data,
lat_rpa.chi_w.data,
decimal=2)
print('ok!')
# ------------------------------------------------------------------
# -- Lattice BSE
lat_bse = ParameterCollection()
lat_bse.g_wk = lat_rpa.g_wk
from triqs_tprf.lattice import fourier_wk_to_wr
lat_bse.g_wr = fourier_wk_to_wr(lat_bse.g_wk)
from triqs_tprf.lattice import chi0r_from_gr_PH
lat_bse.chi0_wnr = chi0r_from_gr_PH(nw=1, nnu=p.nwf, gr=lat_bse.g_wr)
from triqs_tprf.lattice import chi0q_from_chi0r
lat_bse.chi0_wnk = chi0q_from_chi0r(lat_bse.chi0_wnr)
# -- Lattice BSE calc
from triqs_tprf.lattice import chiq_from_chi0q_and_gamma_PH
lat_bse.chi_kwnn = chiq_from_chi0q_and_gamma_PH(lat_bse.chi0_wnk,
loc_bse.gamma_wnn)
# -- Trace results
from triqs_tprf.lattice import chi0q_sum_nu_tail_corr_PH
from triqs_tprf.lattice import chi0q_sum_nu
lat_bse.chi0_wk_tail_corr = chi0q_sum_nu_tail_corr_PH(lat_bse.chi0_wnk)
lat_bse.chi0_wk = chi0q_sum_nu(lat_bse.chi0_wnk)
from triqs_tprf.lattice import chiq_sum_nu, chiq_sum_nu_q
lat_bse.chi_kw = chiq_sum_nu(lat_bse.chi_kwnn)
lat_bse.chi0_w_tail_corr = lat_bse.chi0_wk_tail_corr[:, Idx(0, 0, 0)]
lat_bse.chi0_w = lat_bse.chi0_wk[:, Idx(0, 0, 0)]
lat_bse.chi_w = lat_bse.chi_kw[Idx(0, 0, 0), :]
print('--> cf Tr[chi0_wnk] and chi0_wk')
print(lat_bse.chi0_w_tail_corr.data.reshape((4, 4)).real)
print(lat_bse.chi0_w.data.reshape((4, 4)).real)
print(lat_rpa.chi0_w.data.reshape((4, 4)).real)
np.testing.assert_array_almost_equal(lat_bse.chi0_w_tail_corr.data,
lat_rpa.chi0_w.data)
np.testing.assert_array_almost_equal(lat_bse.chi0_w.data,
lat_rpa.chi0_w.data,
decimal=2)
print('ok!')
print('--> cf Tr[chi_kwnn] and chi_wk')
print(lat_bse.chi_w.data.reshape((4, 4)).real)
print(loc_bse.chi_w.data.reshape((4, 4)).real)
np.testing.assert_array_almost_equal(lat_bse.chi_w.data,
loc_bse.chi_w.data)
print('ok!')
# ------------------------------------------------------------------
# -- Store to hdf5
filename = 'data_bse_rpa.h5'
with HDFArchive(filename, 'w') as res:
res['p'] = p
def solve_lattice_bse_at_specific_w(g_wk, gamma_wnn, nw_index):
r""" Compute the generalized lattice susceptibility
:math:`\chi_{\bar{a}b\bar{c}d}(i\omega_{n=\mathrm{nw\_index}}, \mathbf{k})` using the Bethe-Salpeter
equation (BSE) for a specific :math:`i\omega_{n=\mathrm{nw\_index}}`.
Parameters
----------
g_wk : Gf,
Single-particle Green's function :math:`G_{a\bar{b}}(i\nu_n, \mathbf{k})`.
gamma_wnn : Gf,
Local particle-hole vertex function
:math:`\Gamma_{a\bar{b}c\bar{d}}(i\omega_n, i\nu_n, i\nu_n')`.
nw_index : int,
The bosonic Matsubara frequency index :math:`i\omega_{n=\mathrm{nw\_index}}`
at which the BSE is solved.
Returns
-------
chi_k : Gf,
Generalized lattice susceptibility
:math:`\chi_{\bar{a}b\bar{c}d}(i\omega_{n=\mathrm{nw\_index}}, \mathbf{k})`.
chi0_k : Gf,
Generalized bare lattice susceptibility
:math:`\chi^0_{\bar{a}b\bar{c}d}(i\omega_{n=\mathrm{nw\_index}}, \mathbf{k})`.
"""
# Only use \Gamma at the specific \omega
gamma_nn = gamma_wnn[Idx(nw_index), :, :]
# Keep fake bosonic mesh for usability with other functions
gamma_wnn = add_fake_bosonic_mesh(gamma_nn)
fmesh_g = g_wk.mesh.components[0]
kmesh = g_wk.mesh.components[1]
bmesh = gamma_wnn.mesh.components[0]
fmesh = gamma_wnn.mesh.components[1]
nk = len(kmesh)
nwf = len(fmesh) // 2
nwf_g = len(fmesh_g) // 2
if mpi.is_master_node():
print(tprf_banner(), "\n")
print(
'Lattcie BSE with local vertex approximation at specific \omega.\n'
)
print('nk =', nk)
print('nw_index =', nw_index)
print('nwf =', nwf)
print('nwf_g =', nwf_g)
print()
mpi.report('--> chi0_wk_tail_corr')
# Calculate chi0_wk up to the specific \omega
chi0_wk_tail_corr = imtime_bubble_chi0_wk(g_wk,
nw=np.abs(nw_index) + 1,
save_memory=True)
# Only use specific \omega, but put back on fake bosonic mesh
chi0_k_tail_corr = chi0_wk_tail_corr[Idx(nw_index), :]
chi0_wk_tail_corr = add_fake_bosonic_mesh(chi0_k_tail_corr,
beta=bmesh.beta)
chi0_nk = get_chi0_nk_at_specific_w(g_wk, nw_index=nw_index, nwf=nwf)
# Keep fake bosonic mesh for usability with other functions
chi0_wnk = add_fake_bosonic_mesh(chi0_nk)
mpi.report('--> trace chi0_wnk')
chi0_wk = chi0q_sum_nu(chi0_wnk)
dchi_wk = chi0_wk_tail_corr - chi0_wk
chi0_kw = Gf(mesh=MeshProduct(kmesh, bmesh),
target_shape=chi0_wk_tail_corr.target_shape)
chi0_kw.data[:] = chi0_wk_tail_corr.data.swapaxes(0, 1)
del chi0_wk
del chi0_wk_tail_corr
assert (chi0_wnk.mesh.components[0] == bmesh)
assert (chi0_wnk.mesh.components[1] == fmesh)
assert (chi0_wnk.mesh.components[2] == kmesh)
# -- Lattice BSE calc with built in trace
mpi.report('--> chi_kw from BSE')
#mpi.report('DEBUG BSE INACTIVE'*72)
chi_kw = chiq_sum_nu_from_chi0q_and_gamma_PH(chi0_wnk, gamma_wnn)
#chi_kw = chi0_kw.copy()
mpi.barrier()
mpi.report('--> chi_kw from BSE (done)')
del chi0_wnk
mpi.report('--> chi_kw tail corrected (using chi0_wnk)')
for k in kmesh:
chi_kw[
k, :] += dchi_wk[:,
k] # -- account for high freq of chi_0 (better than nothing)
del dchi_wk
mpi.report('--> solve_lattice_bse, done.')
chi_k = chi_kw[:, Idx(0)]
del chi_kw
chi0_k = chi0_kw[:, Idx(0)]
del chi0_kw
return chi_k, chi0_k
def solve_lattice_bse(g_wk, gamma_wnn):
r""" Compute the generalized lattice susceptibility
:math:`\chi_{\bar{a}b\bar{c}d}(\mathbf{k}, \omega_n)` using the Bethe-Salpeter
equation (BSE).
Parameters
----------
g_wk : Gf,
Single-particle Green's function :math:`G_{a\bar{b}}(i\nu_n, \mathbf{k})`.
gamma_wnn : Gf,
Local particle-hole vertex function
:math:`\Gamma_{a\bar{b}c\bar{d}}(i\omega_n, i\nu_n, i\nu_n')`.
Returns
-------
chi_kw : Gf,
Generalized lattice susceptibility
:math:`\chi_{\bar{a}b\bar{c}d}(\mathbf{k}, i\omega_n)`.
chi0_kw : Gf,
Generalized bare lattice susceptibility
:math:`\chi^0_{\bar{a}b\bar{c}d}(\mathbf{k}, i\omega_n)`.
"""
fmesh_g = g_wk.mesh.components[0]
kmesh = g_wk.mesh.components[1]
bmesh = gamma_wnn.mesh.components[0]
fmesh = gamma_wnn.mesh.components[1]
nk = len(kmesh)
nw = (len(bmesh) + 1) // 2
nwf = len(fmesh) // 2
nwf_g = len(fmesh_g) // 2
if mpi.is_master_node():
print(tprf_banner(), "\n")
print('Lattcie BSE with local vertex approximation.\n')
print('nk =', nk)
print('nw =', nw)
print('nwf =', nwf)
print('nwf_g =', nwf_g)
print()
mpi.report('--> chi0_wk_tail_corr')
chi0_wk_tail_corr = imtime_bubble_chi0_wk(g_wk, nw=nw)
mpi.barrier()
mpi.report('B1 ' +
str(chi0_wk_tail_corr[Idx(0), Idx(0, 0, 0)][0, 0, 0, 0]))
mpi.barrier()
chi0_wnk = get_chi0_wnk(g_wk, nw=nw, nwf=nwf)
mpi.barrier()
mpi.report('C ' + str(chi0_wnk[Idx(0), Idx(0), Idx(0, 0, 0)][0, 0, 0, 0]))
mpi.barrier()
mpi.report('--> trace chi0_wnk')
chi0_wk = chi0q_sum_nu(chi0_wnk)
mpi.barrier()
mpi.report('D ' + str(chi0_wk[Idx(0), Idx(0, 0, 0)][0, 0, 0, 0]))
mpi.barrier()
dchi_wk = chi0_wk_tail_corr - chi0_wk
chi0_kw = Gf(mesh=MeshProduct(kmesh, bmesh),
target_shape=chi0_wk_tail_corr.target_shape)
chi0_kw.data[:] = chi0_wk_tail_corr.data.swapaxes(0, 1)
del chi0_wk
del chi0_wk_tail_corr
assert (chi0_wnk.mesh.components[0] == bmesh)
assert (chi0_wnk.mesh.components[1] == fmesh)
assert (chi0_wnk.mesh.components[2] == kmesh)
# -- Lattice BSE calc with built in trace
mpi.report('--> chi_kw from BSE')
#mpi.report('DEBUG BSE INACTIVE'*72)
chi_kw = chiq_sum_nu_from_chi0q_and_gamma_PH(chi0_wnk, gamma_wnn)
#chi_kw = chi0_kw.copy()
mpi.barrier()
mpi.report('--> chi_kw from BSE (done)')
del chi0_wnk
mpi.report('--> chi_kw tail corrected (using chi0_wnk)')
for k in kmesh:
chi_kw[
k, :] += dchi_wk[:,
k] # -- account for high freq of chi_0 (better than nothing)
del dchi_wk
mpi.report('--> solve_lattice_bse, done.')
return chi_kw, chi0_kw
# ----------------------------------------------------------------------
p = ParameterCollection(beta = 10,
nw = 10,
nk = 4,
norb = 2,)
wmesh = MeshImFreq(beta=p.beta, S='Fermion', n_max=p.nw)
cell = np.eye(3)
bl = BravaisLattice(cell)
bz = BrillouinZone(bl)
kmesh = MeshBrZone(bz, p.nk * np.eye(3, dtype=int))
gf = Gf(mesh=MeshProduct(wmesh, kmesh), target_shape=2*(p.norb,))
gf.data[:] = np.random.rand(*gf.data.shape)
# -- Eexception handling
try:
enforce_symmetry(gf, "something", "odd")
except ValueError as error:
if not str(error) == "No symmetrize function for this variable exists.":
raise Exception("Wrong exception was raised: \n %s"%error)
else:
raise Exception("Function call should have failed.")
try:
enforce_symmetry(gf, "frequency", "weird")
except ValueError as error:
if not str(error) == "Symmetry can only be 'even' or 'odd'.":
def make_calc():
# ------------------------------------------------------------------
# -- Read precomputed ED data
filename = "bse_and_rpa_loc_vs_latt.tar.gz"
p = read_TarGZ_HDFArchive(filename)['p']
# ------------------------------------------------------------------
# -- RPA tensor
from triqs_tprf.rpa_tensor import get_rpa_tensor
from triqs_tprf.rpa_tensor import fundamental_operators_from_gf_struct
fundamental_operators = fundamental_operators_from_gf_struct(p.gf_struct)
p.U_abcd = get_rpa_tensor(p.H_int, fundamental_operators)
# ------------------------------------------------------------------
# -- Generalized PH susceptibility
loc_bse = ParameterCollection()
loc_bse.chi_wnn = chi_from_gg2_PH(p.G_iw, p.G2_iw_ph)
loc_bse.chi0_wnn = chi0_from_gg2_PH(p.G_iw, p.G2_iw_ph)
loc_bse.gamma_wnn = inverse_PH(loc_bse.chi0_wnn) - inverse_PH(loc_bse.chi_wnn)
loc_bse.chi_wnn_ref = inverse_PH( inverse_PH(loc_bse.chi0_wnn) - loc_bse.gamma_wnn )
np.testing.assert_array_almost_equal(
loc_bse.chi_wnn.data, loc_bse.chi_wnn_ref.data)
from triqs_tprf.bse import solve_local_bse
loc_bse.gamma_wnn_ref = solve_local_bse(loc_bse.chi0_wnn, loc_bse.chi_wnn)
np.testing.assert_array_almost_equal(
loc_bse.gamma_wnn.data, loc_bse.gamma_wnn_ref.data)
loc_bse.chi0_w = trace_nn(loc_bse.chi0_wnn)
loc_bse.chi_w = trace_nn(loc_bse.chi_wnn)
# ------------------------------------------------------------------
# -- RPA, using BSE inverses and constant Gamma
loc_rpa = ParameterCollection()
loc_rpa.chi0_wnn = loc_bse.chi0_wnn
loc_rpa.chi0_w = loc_bse.chi0_w
loc_rpa.U_abcd = p.U_abcd
# -- Build constant gamma
from triqs_tprf.rpa_tensor import get_gamma_rpa
loc_rpa.gamma_wnn = get_gamma_rpa(loc_rpa.chi0_wnn, loc_rpa.U_abcd)
# -- Solve RPA
loc_rpa.chi_wnn = inverse_PH( inverse_PH(loc_rpa.chi0_wnn) - loc_rpa.gamma_wnn )
loc_rpa.chi_w = trace_nn(loc_rpa.chi_wnn)
# ------------------------------------------------------------------
# -- Bubble RPA on lattice
lat_rpa = ParameterCollection()
# -- Setup dummy lattice Green's function equal to local Green's function
bz = BrillouinZone(BravaisLattice(units=np.eye(3), orbital_positions=[(0,0,0)]))
periodization_matrix = np.diag(np.array(list([1]*3), dtype=int))
kmesh = MeshBrZone(bz, periodization_matrix)
wmesh = MeshImFreq(beta=p.beta, S='Fermion', n_max=p.nwf_gf)
lat_rpa.g_wk = Gf(mesh=MeshProduct(wmesh, kmesh), target_shape=p.G_iw.target_shape)
lat_rpa.g_wk[:, Idx(0, 0, 0)] = p.G_iw
# -- chi0_wk bubble and chi_wk_rpa bubble RPA
from triqs_tprf.lattice_utils import imtime_bubble_chi0_wk
lat_rpa.chi0_wk = imtime_bubble_chi0_wk(lat_rpa.g_wk, nw=1)
from triqs_tprf.lattice import solve_rpa_PH
lat_rpa.chi_wk = solve_rpa_PH(lat_rpa.chi0_wk, p.U_abcd)
lat_rpa.chi0_w = lat_rpa.chi0_wk[:, Idx(0,0,0)]
lat_rpa.chi_w = lat_rpa.chi_wk[:, Idx(0,0,0)]
print('--> cf Tr[chi0] and chi0_wk')
print(loc_rpa.chi0_w.data.reshape((4, 4)).real)
print(lat_rpa.chi0_w.data.reshape((4, 4)).real)
np.testing.assert_array_almost_equal(
loc_rpa.chi0_w.data, lat_rpa.chi0_w.data, decimal=2)
print('ok!')
print('--> cf Tr[chi_rpa] and chi_wk_rpa')
print(loc_rpa.chi_w.data.reshape((4, 4)).real)
print(lat_rpa.chi_w.data.reshape((4, 4)).real)
np.testing.assert_array_almost_equal(
loc_rpa.chi_w.data, lat_rpa.chi_w.data, decimal=2)
print('ok!')
# ------------------------------------------------------------------
# -- Lattice BSE
lat_bse = ParameterCollection()
lat_bse.g_wk = lat_rpa.g_wk
lat_bse.mu = p.mu
lat_bse.e_k = Gf(mesh=kmesh, target_shape=p.G_iw.target_shape)
lat_bse.e_k[Idx(0,0,0)] = np.eye(2)
lat_bse.sigma_w = p.G_iw.copy()
lat_bse.sigma_w << iOmega_n + lat_bse.mu * np.eye(2) - lat_bse.e_k[Idx(0,0,0)] - inverse(p.G_iw)
lat_bse.g_wk_ref = lat_bse.g_wk.copy()
lat_bse.g_wk_ref[:,Idx(0,0,0)] << inverse(
iOmega_n + lat_bse.mu * np.eye(2) - lat_bse.e_k[Idx(0,0,0)] - lat_bse.sigma_w)
np.testing.assert_array_almost_equal(lat_bse.g_wk.data, lat_bse.g_wk_ref.data)
#for w in lat_bse.g_wk.mesh.components[0]:
# print w, lat_bse.g_wk[w, Idx(0,0,0)][0, 0]
from triqs_tprf.lattice import fourier_wk_to_wr
lat_bse.g_wr = fourier_wk_to_wr(lat_bse.g_wk)
from triqs_tprf.lattice import chi0r_from_gr_PH
lat_bse.chi0_wnr = chi0r_from_gr_PH(nw=1, nn=p.nwf, g_nr=lat_bse.g_wr)
from triqs_tprf.lattice import chi0q_from_chi0r
lat_bse.chi0_wnk = chi0q_from_chi0r(lat_bse.chi0_wnr)
#for n in lat_bse.chi0_wnk.mesh.components[1]:
# print n.value, lat_bse.chi0_wnk[Idx(0), n, Idx(0,0,0)][0,0,0,0]
# -- Lattice BSE calc
from triqs_tprf.lattice import chiq_from_chi0q_and_gamma_PH
lat_bse.chi_kwnn = chiq_from_chi0q_and_gamma_PH(lat_bse.chi0_wnk, loc_bse.gamma_wnn)
# -- Lattice BSE calc with built in trace
from triqs_tprf.lattice import chiq_sum_nu_from_chi0q_and_gamma_PH
lat_bse.chi_kw_ref = chiq_sum_nu_from_chi0q_and_gamma_PH(lat_bse.chi0_wnk, loc_bse.gamma_wnn)
# -- Lattice BSE calc with built in trace using g_wk
from triqs_tprf.lattice import chiq_sum_nu_from_g_wk_and_gamma_PH
lat_bse.chi_kw_tail_corr_ref = chiq_sum_nu_from_g_wk_and_gamma_PH(lat_bse.g_wk, loc_bse.gamma_wnn)
# -- Trace results
from triqs_tprf.lattice import chi0q_sum_nu_tail_corr_PH
from triqs_tprf.lattice import chi0q_sum_nu
lat_bse.chi0_wk_tail_corr = chi0q_sum_nu_tail_corr_PH(lat_bse.chi0_wnk)
lat_bse.chi0_wk = chi0q_sum_nu(lat_bse.chi0_wnk)
from triqs_tprf.lattice import chiq_sum_nu, chiq_sum_nu_q
lat_bse.chi_kw = chiq_sum_nu(lat_bse.chi_kwnn)
np.testing.assert_array_almost_equal(lat_bse.chi_kw.data, lat_bse.chi_kw_ref.data)
from triqs_tprf.bse import solve_lattice_bse
lat_bse.chi_kw_tail_corr, tmp = solve_lattice_bse(lat_bse.g_wk, loc_bse.gamma_wnn)
from triqs_tprf.bse import solve_lattice_bse_e_k_sigma_w
lat_bse.chi_kw_tail_corr_new = solve_lattice_bse_e_k_sigma_w(lat_bse.mu, lat_bse.e_k, lat_bse.sigma_w, loc_bse.gamma_wnn)
np.testing.assert_array_almost_equal(lat_bse.chi_kw_tail_corr.data, lat_bse.chi_kw_tail_corr_ref.data)
np.testing.assert_array_almost_equal(lat_bse.chi_kw_tail_corr.data, lat_bse.chi_kw_tail_corr_new.data)
np.testing.assert_array_almost_equal(lat_bse.chi_kw_tail_corr_ref.data, lat_bse.chi_kw_tail_corr_new.data)
lat_bse.chi0_w_tail_corr = lat_bse.chi0_wk_tail_corr[:, Idx(0, 0, 0)]
lat_bse.chi0_w = lat_bse.chi0_wk[:, Idx(0, 0, 0)]
lat_bse.chi_w_tail_corr = lat_bse.chi_kw_tail_corr[Idx(0, 0, 0), :]
lat_bse.chi_w = lat_bse.chi_kw[Idx(0, 0, 0), :]
print('--> cf Tr[chi0_wnk] and chi0_wk')
print(lat_bse.chi0_w_tail_corr.data.reshape((4, 4)).real)
print(lat_bse.chi0_w.data.reshape((4, 4)).real)
print(lat_rpa.chi0_w.data.reshape((4, 4)).real)
np.testing.assert_array_almost_equal(
lat_bse.chi0_w_tail_corr.data, lat_rpa.chi0_w.data)
np.testing.assert_array_almost_equal(
lat_bse.chi0_w.data, lat_rpa.chi0_w.data, decimal=2)
print('ok!')
print('--> cf Tr[chi_kwnn] and chi_wk (without chi0 tail corr)')
print(lat_bse.chi_w.data.reshape((4, 4)).real)
print(loc_bse.chi_w.data.reshape((4, 4)).real)
np.testing.assert_array_almost_equal(
lat_bse.chi_w.data, loc_bse.chi_w.data)
print('ok!')
# ------------------------------------------------------------------
# -- Use chi0 tail corrected trace to correct chi_rpa cf bubble
dchi_wk = lat_bse.chi0_wk_tail_corr - lat_bse.chi0_wk
dchi_w = dchi_wk[:, Idx(0, 0, 0)]
loc_rpa.chi_w_tail_corr = loc_rpa.chi_w + dchi_w
# -- this will be the same, but it will be close to the real physical value
lat_bse.chi_w_tail_corr_ref = lat_bse.chi_w + dchi_w
loc_bse.chi_w_tail_corr_ref = loc_bse.chi_w + dchi_w
print('--> cf Tr[chi_rpa] and chi_wk_rpa')
print(loc_rpa.chi_w.data.reshape((4, 4)).real)
print(loc_rpa.chi_w_tail_corr.data.reshape((4, 4)).real)
print(lat_rpa.chi_w.data.reshape((4, 4)).real)
np.testing.assert_array_almost_equal(
loc_rpa.chi_w_tail_corr.data, lat_rpa.chi_w.data, decimal=3)
print('--> cf Tr[chi_kwnn] with tail corr (from chi0_wnk)')
print(lat_bse.chi_w_tail_corr.data.reshape((4, 4)).real)
print(lat_bse.chi_w_tail_corr_ref.data.reshape((4, 4)).real)
np.testing.assert_array_almost_equal(
lat_bse.chi_w_tail_corr.data, lat_bse.chi_w_tail_corr_ref.data)
print('ok!')
# ------------------------------------------------------------------
# -- Store to hdf5
filename = 'data_bse_rpa.h5'
with HDFArchive(filename,'w') as res:
res['p'] = p
list(map(np.array, list(zip(*list(x)))))
for x in mesh_product_iterator(chi4_tau.mesh)
]
# ----------------------------------------------------------------------
if __name__ == '__main__':
nw = 20
nt = 45
beta = 2.0
imtime = MeshImTime(beta, 'Fermion', nt)
imfreq = MeshImFreq(beta, 'Fermion', nw)
imtime3 = MeshProduct(imtime, imtime, imtime)
imfreq3 = MeshProduct(imfreq, imfreq, imfreq)
chi4_tau = Gf(name=r'$g(\tau)$', mesh=imtime3, target_shape=[1, 1, 1, 1])
print(dir(chi4_tau.indices))
for i in chi4_tau.indices:
print(i)
exit()
# -- Smooth anti-periodic function
w = 0.5
e1, e2, e3 = w, w, w
E = np.array([e1, e2, e3])
for idx, tau in mesh_product_iterator_numpy(chi4_tau.mesh):
chi4_tau[idx.tolist()][:] = np.sum(np.cos(np.pi * E * tau))