def test_cf_G_tau_and_G_iw_nonint(verbose=False):
beta = 3.22
eps = 1.234
niw = 64
ntau = 2 * niw + 1
H = eps * c_dag(0,0) * c(0,0)
fundamental_operators = [c(0,0)]
ed = TriqsExactDiagonalization(H, fundamental_operators, beta)
# ------------------------------------------------------------------
# -- Single-particle Green's functions
G_tau = GfImTime(beta=beta, statistic='Fermion', n_points=ntau, target_shape=(1,1))
G_iw = GfImFreq(beta=beta, statistic='Fermion', n_points=niw, target_shape=(1,1))
G_iw << inverse( iOmega_n - eps )
G_tau << InverseFourier(G_iw)
G_tau_ed = GfImTime(beta=beta, statistic='Fermion', n_points=ntau, target_shape=(1,1))
G_iw_ed = GfImFreq(beta=beta, statistic='Fermion', n_points=niw, target_shape=(1,1))
ed.set_g2_tau(G_tau_ed[0, 0], c(0,0), c_dag(0,0))
ed.set_g2_iwn(G_iw_ed[0, 0], c(0,0), c_dag(0,0))
# ------------------------------------------------------------------
# -- Compare gfs
from pytriqs.utility.comparison_tests import assert_gfs_are_close
assert_gfs_are_close(G_tau, G_tau_ed)
assert_gfs_are_close(G_iw, G_iw_ed)
# ------------------------------------------------------------------
# -- Plotting
if verbose:
from pytriqs.plot.mpl_interface import oplot, plt
subp = [3, 1, 1]
plt.subplot(*subp); subp[-1] += 1
oplot(G_tau.real)
oplot(G_tau_ed.real)
plt.subplot(*subp); subp[-1] += 1
diff = G_tau - G_tau_ed
oplot(diff.real)
oplot(diff.imag)
plt.subplot(*subp); subp[-1] += 1
oplot(G_iw)
oplot(G_iw_ed)
plt.show()
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_fundamental():
assert( op_is_fundamental(c(0, 0)) is True )
assert( op_is_fundamental(c_dag(0, 0)) is True )
assert( op_is_fundamental(c_dag(0, 0)*c(0, 0)) is False )
assert( op_is_fundamental(Operator(1.0)) is False )
assert( op_serialize_fundamental(c(0,0)) == (False, (0,0)) )
assert( op_serialize_fundamental(c_dag(0,0)) == (True, (0,0)) )
assert( op_serialize_fundamental(c(2,4)) == (False, (2,4)) )
assert( op_serialize_fundamental(c_dag(4,3)) == (True, (4,3)) )
def test_single_particle_transform(verbose=False):
if verbose:
print '--> test_single_particle_transform'
h_loc = np.array([
[1.0, 0.0],
[0.0, -1.0],
])
op_imp = [c(0,0), c(0,1)]
H_loc = get_quadratic_operator(h_loc, op_imp)
H_loc_ref = c_dag(0,0) * c(0,0) - c_dag(0,1) * c(0,1)
assert( (H_loc - H_loc_ref).is_zero() )
h_loc_ref = quadratic_matrix_from_operator(H_loc, op_imp)
np.testing.assert_array_almost_equal(h_loc, h_loc_ref)
if verbose:
print 'h_loc =\n', h_loc
print 'h_loc_ref =\n', h_loc_ref
print 'H_loc =', H_loc
T_ab = np.array([
[1., 1.],
[1., -1.],
]) / np.sqrt(2.)
Ht_loc = operator_single_particle_transform(H_loc, T_ab, op_imp)
ht_loc = quadratic_matrix_from_operator(Ht_loc, op_imp)
ht_loc_ref = np.array([
[0., 1.],
[1., 0.],
])
Ht_loc_ref = c_dag(0, 0) * c(0, 1) + c_dag(0, 1) * c(0, 0)
if verbose:
print 'ht_loc =\n', ht_loc
print 'ht_loc_ref =\n', ht_loc_ref
print 'Ht_loc =', Ht_loc
print 'Ht_loc_ref =', Ht_loc_ref
assert( (Ht_loc - Ht_loc_ref).is_zero() )
def test_sparse_matrix_representation():
up, do = 0, 1
fundamental_operators = [c(up, 0), c(do, 0)]
rep = SparseMatrixRepresentation(fundamental_operators)
# -- Test an operator
O_mat = rep.sparse_matrix(c(up, 0))
O_ref = rep.sparse_operators.c_dag[0].getH()
compare_sparse_matrices(O_mat, O_ref)
# -- Test
O_mat = rep.sparse_matrix(c(do, 0))
O_ref = rep.sparse_operators.c_dag[1].getH()
compare_sparse_matrices(O_mat, O_ref)
# -- Test expression
H_expr = c(up, 0) * c(do, 0) * c_dag(up, 0) * c_dag(do, 0)
H_mat = rep.sparse_matrix(H_expr)
c_dag0, c_dag1 = rep.sparse_operators.c_dag
c_0, c_1 = c_dag0.getH(), c_dag1.getH()
H_ref = c_0 * c_1 * c_dag0 * c_dag1
compare_sparse_matrices(H_mat, H_ref)
def solve_aims(G0_iw_list_):
G_iw_list = []
G_tau_list = []
average_sign_list = []
for G0_iw in G0_iw_list_:
print 'G0_iw', G0_iw
# ==== Local Hamiltonian ====
c_dag_vec = matrix([[c_dag('bl', idx) for idx in idx_lst]])
c_vec = matrix([[c('bl', idx)] for idx in idx_lst])
h_0_mat = t_ij_list[0]
h_0 = (c_dag_vec * h_0_mat * c_vec)[0, 0]
# ==== Interacting Hamiltonian ====
Umat, Upmat = U_matrix_kanamori(len(orb_names), U_int=U, J_hund=J)
#op_map = { (s,o): ('bl',i) for i, (s,o) in enumerate(product(spin_names, orb_names)) }
op_map = {(s, o): ('bl', i)
for i, (o, s) in enumerate(product(orb_names, spin_names))}
h_int = h_int_kanamori(spin_names,
orb_names,
Umat,
Upmat,
J,
off_diag=True,
map_operator_structure=op_map)
G_tau, G_iw, average_sign = ctqmc_solver(h_int, G0_iw)
G_iw_list.append(G_iw)
G_tau_list.append(G_tau)
average_sign_list.append(average_sign)
return G_tau_list, G_iw_list, average_sign_list
def solve(self,
H_int,
E_levels,
integrals_of_motion=None,
density_matrix_cutoff=1e-10,
file_quantum_numbers="",
file_eigenvalues=""):
self.__copy_E_levels(E_levels)
H_0 = sum(
self.E_levels[sn][oi1, oi2].real * c_dag(sn, on1) * c(sn, on2)
for sn, (oi1, on1), (
oi2, on2) in product(self.spin_names, enumerate(
self.orb_names), enumerate(self.orb_names)))
if self.verbose and mpi.is_master_node():
print "\n*** compute G_iw and Sigma_iw"
print "*** E_levels =", E_levels
print "*** H_0 =", H_0
# print "*** integrals_of_motion =", integrals_of_motion
N_op = sum(
c_dag(sn, on) * c(sn, on)
for sn, on in product(self.spin_names, self.orb_names))
if integrals_of_motion is None:
if self.spin_orbit:
# use only N op as integrals_of_motion when spin-orbit coupling is included
self.__ed.diagonalize(H_0 + H_int, integrals_of_motion=[N_op])
else:
# use N and S_z as integrals of motion by default
self.__ed.diagonalize(H_0 + H_int)
else:
assert isinstance(integrals_of_motion, list)
# check commutation relation in advance (just for test)
if self.verbose and mpi.is_master_node():
print "*** Integrals of motion:"
for i, op in enumerate(integrals_of_motion):
print " op%d =" % i, op
print "*** commutation relations:"
is_commute = lambda h, op: h * op - op * h
str_if_commute = lambda h, op: "== 0" if is_commute(
h, op).is_zero() else "!= 0"
for i, op in enumerate(integrals_of_motion):
print " [H_0, op%d]" % i, str_if_commute(
H_0,
op), " [H_int, op%d]" % i, str_if_commute(H_int, op)
self.__ed.diagonalize(H_0 + H_int, integrals_of_motion)
# save data
if file_quantum_numbers:
self.__ed.save_quantum_numbers(file_quantum_numbers)
if file_eigenvalues:
self.__ed.save_eigenvalues(file_eigenvalues)
# set density-matrix cutoff
self.__ed.set_density_matrix_cutoff(density_matrix_cutoff)
# Compute G(i\omega)
self.G_iw << self.__ed.G_iw(self.gf_struct, self.beta, self.n_iw)
# Compute G0 and Sigma
E_list = [self.E_levels[sn]
for sn in self.spin_names] # from dict to list
self.G0_iw << iOmega_n
self.G0_iw -= E_list
self.Sigma_iw << self.G0_iw - inverse(self.G_iw)
self.G0_iw.invert()
# *********************************************************************
# TODO: tail
# set tail of Sigma at all zero in the meantime, because tail of G is
# not computed in pomerol solver. This part should be improved.
# *********************************************************************
for s, sig in self.Sigma_iw:
sig.tail.zero()
if __name__ == '__main__':
# ------------------------------------------------------------------
# -- Hubbard atom with two bath sites, Hamiltonian
beta = 10.0
V1 = 1.0
V2 = 1.0
epsilon1 = +2.30
epsilon2 = -2.30
t = 0.1
mu = 1.0
U = 2.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)
hopA = c_dag(up, 0) * c(do, 0) + c_dag(do, 0) * c(up, 0)
hopB = c_dag(up, 1) * c(do, 1) + c_dag(do, 1) * c(up, 1)
hopC = c_dag(up, 2) * c(do, 2) + c_dag(do, 2) * c(up, 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) ) + \
-t * (hopA + hopB + hopC)
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)
def make_calc():
# ------------------------------------------------------------------
# -- Hubbard atom with two bath sites, Hamiltonian
p = ParameterCollection(
beta=1.0,
U=5.0,
nw=1,
nwf=20,
)
p.nwf_gf = 4 * p.nwf
p.mu = 0.5 * p.U
# ------------------------------------------------------------------
ca_up, cc_up = c('0', 0), c_dag('0', 0)
ca_do, cc_do = c('0', 1), c_dag('0', 1)
docc = cc_up * ca_up * cc_do * ca_do
nA = cc_up * ca_up + cc_do * ca_do
p.H = -p.mu * nA + p.U * docc
# ------------------------------------------------------------------
# -- Exact diagonalization
# Conversion from TRIQS to Pomerol notation for operator indices
# TRIQS: block_name, inner_index
# Pomerol: site_label, orbital_index, spin_name
index_converter = {
('0', 0): ('loc', 0, 'up'),
('0', 1): ('loc', 0, 'down'),
}
# -- Create Exact Diagonalization instance
ed = PomerolED(index_converter, verbose=True)
ed.diagonalize(p.H) # -- Diagonalize H
gf_struct = [['0', [0, 1]]]
# -- Single-particle Green's functions
p.G_iw = ed.G_iw(gf_struct, p.beta, n_iw=p.nwf_gf)['0']
# -- Particle-particle two-particle Matsubara frequency Green's function
opt = dict(beta=p.beta,
gf_struct=gf_struct,
blocks=set([("0", "0")]),
n_iw=p.nw,
n_inu=p.nwf)
p.G2_iw_ph = ed.G2_iw_inu_inup(channel='PH', **opt)[('0', '0')]
# ------------------------------------------------------------------
# -- Generalized susceptibility in magnetic PH channel
p.chi_m = Gf(mesh=p.G2_iw_ph.mesh, target_shape=[1, 1, 1, 1])
p.chi_m[0, 0, 0, 0] = p.G2_iw_ph[0, 0, 0, 0] - p.G2_iw_ph[0, 0, 1, 1]
p.chi0_m = chi0_from_gg2_PH(p.G_iw, p.chi_m)
p.label = r'Pomerol'
# ------------------------------------------------------------------
# -- Generalized susceptibility in PH channel
p.chi = chi_from_gg2_PH(p.G_iw, p.G2_iw_ph)
p.chi0 = chi0_from_gg2_PH(p.G_iw, p.G2_iw_ph)
p.gamma = inverse_PH(p.chi0) - inverse_PH(p.chi)
# ------------------------------------------------------------------
# -- Store to hdf5
filename = 'data_pomerol.h5'
with HDFArchive(filename, 'w') as res:
res['p'] = p
# ----------------------------------------------------------------------
if __name__ == '__main__':
# ------------------------------------------------------------------
# -- 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),
fundamental_operators = fundamental_operators_from_gf_struct(gf_struct)
beta = 10.0
U = 2.0
mu = 1.0
h = 0.1
#V = 0.5
V = 1.0
epsilon = 2.3
H = U * n('up', 0) * n('do', 0) + \
- mu * (n('up', 0) + n('do', 0)) + \
h * n('up', 0) - h * n('do', 0) + \
epsilon * (n('up', 1) + n('do', 1)) - epsilon * (n('up', 2) + n('do', 2)) + \
V * ( c_dag('up', 0) * c('up', 1) + c_dag('up', 1) * c('up', 0) ) + \
V * ( c_dag('do', 0) * c('do', 1) + c_dag('do', 1) * c('do', 0) ) + \
V * ( c_dag('up', 0) * c('up', 2) + c_dag('up', 2) * c('up', 0) ) + \
V * ( c_dag('do', 0) * c('do', 2) + c_dag('do', 2) * c('do', 0) )
ed = TriqsExactDiagonalization(H, fundamental_operators, beta)
n_tau = 101
G_tau_up = Gf(mesh=MeshImTime(beta, 'Fermion', n_tau), target_shape=[])
G_tau_do = Gf(mesh=MeshImTime(beta, 'Fermion', n_tau), target_shape=[])
ed.set_g2_tau(G_tau_up, c('up', 0), c_dag('up', 0))
ed.set_g2_tau(G_tau_do, c('do', 0), c_dag('do', 0))
with HDFArchive('anderson.pyed.h5', 'w') as Results:
Results['up'] = G_tau_up
def make_calc(U=10):
# ------------------------------------------------------------------
# -- Hubbard atom with two bath sites, Hamiltonian
params = dict(
beta=2.0,
V1=2.0,
V2=5.0,
epsilon1=0.00,
epsilon2=4.00,
mu=2.0,
U=U,
ntau=40,
niw=15,
)
# ------------------------------------------------------------------
class Dummy():
def __init__(self):
pass
d = Dummy() # storage space
d.params = params
print '--> Solving SIAM with parameters'
for key, value in params.items():
print '%10s = %-10s' % (key, str(value))
globals()[key] = value # populate global namespace
# ------------------------------------------------------------------
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)
d.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(d.H, fundamental_operators, beta)
# ------------------------------------------------------------------
# -- Single-particle Green's functions
Gopt = dict(beta=beta, statistic='Fermion', indices=[1])
d.G_tau = GfImTime(name=r'$G(\tau)$', n_points=ntau, **Gopt)
d.G_iw = GfImFreq(name='$G(i\omega_n)$', n_points=niw, **Gopt)
ed.set_g2_tau(d.G_tau, c(up, 0), c_dag(up, 0))
ed.set_g2_iwn(d.G_iw, c(up, 0), c_dag(up, 0))
# chi2pp = + < c^+_u(\tau^+) c_u(0^+) c^+_d(\tau) c_d(0) >
# = - < c^+_u(\tau^+) c^+_d(\tau) c_u(0^+) c_d(0) >
chi2opt = dict(beta=beta, statistic='Fermion', indices=[1], n_points=ntau)
d.chi2pp_tau = GfImTime(name=r'$\chi^{(2)}_{PP}(\tau)$', **chi2opt)
ed.set_g2_tau(d.chi2pp_tau,
c_dag(up, 0) * c_dag(do, 0),
c(up, 0) * c(do, 0))
d.chi2pp_tau *= -1.0 * -1.0 # commutation sign and gf sign
d.chi2pp_iw = g_iw_from_tau(d.chi2pp_tau, niw)
# chi2ph = < c^+_u(\tau^+) c_u(\tau) c^+_d(0^+) c_d(0) >
d.chi2ph_tau = GfImTime(name=r'$\chi^{(2)}_{PH}(\tau)$', **chi2opt)
#d.chi2ph_tau = Gf(name=r'$\chi^{(2)}_{PH}(\tau)$', **chi2opt)
ed.set_g2_tau(d.chi2ph_tau,
c_dag(up, 0) * c(up, 0),
c_dag(do, 0) * c(do, 0))
d.chi2ph_tau *= -1.0 # gf sign
d.chi2ph_iw = g_iw_from_tau(d.chi2ph_tau, niw)
# ------------------------------------------------------------------
# -- Two particle Green's functions
imtime = MeshImTime(beta, 'Fermion', ntau)
prodmesh = MeshProduct(imtime, imtime, imtime)
G2opt = dict(mesh=prodmesh, target_shape=[1, 1, 1, 1])
d.G02_tau = Gf(name='$G^{(2)}_0(\tau_1, \tau_2, \tau_3)$', **G2opt)
ed.set_g40_tau(d.G02_tau, d.G_tau)
d.G02_iw = chi4_iw_from_tau(d.G02_tau, niw)
d.G2_tau = Gf(name='$G^{(2)}(\tau_1, \tau_2, \tau_3)$', **G2opt)
ed.set_g4_tau(d.G2_tau, c_dag(up, 0), c(up, 0), c_dag(do, 0), c(do, 0))
#ed.set_g4_tau(d.G2_tau, c(up,0), c_dag(up,0), c(do,0), c_dag(do,0)) # <cc^+cc^+>
d.G2_iw = chi4_iw_from_tau(d.G2_tau, niw)
# -- trying to fix the bug in the fft for w2
d.G02_iw.data[:] = d.G02_iw.data[:, ::-1, ...].conj()
d.G2_iw.data[:] = d.G2_iw.data[:, ::-1, ...].conj()
# ------------------------------------------------------------------
# -- 3/2-particle Green's functions (equal times)
prodmesh = MeshProduct(imtime, imtime)
chi3opt = dict(mesh=prodmesh, target_shape=[1, 1, 1, 1])
# chi3pp = <c^+_u(\tau) c_u(0^+) c^+_d(\tau') c_d(0) >
# = - <c^+_u(\tau) c^+_d(\tau') c_u(0^+) c_d(0) >
d.chi3pp_tau = Gf(name='$\Chi^{(3)}_{PP}(\tau_1, \tau_2, \tau_3)$',
**chi3opt)
ed.set_g3_tau(d.chi3pp_tau, c_dag(up, 0), c_dag(do, 0),
c(up, 0) * c(do, 0))
d.chi3pp_tau *= -1.0 # from commutation
d.chi3pp_iw = chi3_iw_from_tau(d.chi3pp_tau, niw)
# chi3ph = <c^+_u(\tau) c_u(\tau') c^+_d(0^+) c_d(0) >
d.chi3ph_tau = Gf(name='$\Chi^{(3)}_{PH}(\tau_1, \tau_2, \tau_3)$',
**chi3opt)
ed.set_g3_tau(d.chi3ph_tau, c_dag(up, 0), c(up, 0),
c_dag(do, 0) * c(do, 0))
d.chi3ph_iw = chi3_iw_from_tau(d.chi3ph_tau, niw)
# ------------------------------------------------------------------
# -- Store to hdf5
filename = 'data_ed.h5'
with HDFArchive(filename, 'w') as res:
for key, value in d.__dict__.items():
res[key] = value
def test_trimer_hamiltonian():
# ------------------------------------------------------------------
# -- 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 = 1.0
# -- construction using triqs operators
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_expr = -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) )
# ------------------------------------------------------------------
fundamental_operators = [
c(up, 0), c(do, 0),
c(up, 1), c(do, 1),
c(up, 2), c(do, 2)
]
rep = SparseMatrixRepresentation(fundamental_operators)
H_mat = rep.sparse_matrix(H_expr)
# -- explicit construction
class Dummy(object):
def __init__(self):
pass
op = Dummy()
op.cdagger = rep.sparse_operators.c_dag
op.c = np.array([cdag.getH() for cdag in op.cdagger])
op.n = np.array([cdag * cop for cop, cdag in zip(op.c, op.cdagger)])
H_ref = -mu * (op.n[0] + op.n[1]) + \
epsilon1 * (op.n[2] + op.n[3]) + \
epsilon2 * (op.n[4] + op.n[5]) + \
U * op.n[0] * op.n[1] + \
V1 * (op.cdagger[0] * op.c[2] + op.cdagger[2] * op.c[0] + \
op.cdagger[1] * op.c[3] + op.cdagger[3] * op.c[1] ) + \
V2 * (op.cdagger[0] * op.c[4] + op.cdagger[4] * op.c[0] + \
op.cdagger[1] * op.c[5] + op.cdagger[5] * op.c[1] )
# ------------------------------------------------------------------
# -- compare
compare_sparse_matrices(H_mat, H_ref)
T_imp = block_diag(T_imp, T_imp)
T_bath = block_diag(T_bath, T_bath)
print 'V =\n', V
print 'T_imp =\n', T_imp
print 'T_bath =\n', T_bath
T = np.block([[T_imp, V], [V.T, T_bath]])
print 'T =\n', T
H_int = h_int_kanamori(spin_names, imp_idxs,
np.array([[0, U - 3 * J], [U - 3 * J, 0]]),
np.array([[U, U - 2 * J], [U - 2 * J, U]]), J, True)
H = H_int + get_quadratic_operator(T, fop)
ed = TriqsExactDiagonalization(H, fop, beta)
n_tau = 101
G_tau_up = Gf(mesh=MeshImTime(beta, 'Fermion', n_tau), target_shape=[2, 2])
G_tau_do = Gf(mesh=MeshImTime(beta, 'Fermion', n_tau), target_shape=[2, 2])
for i1, i2 in itertools.product(range(norb), repeat=2):
ed.set_g2_tau(G_tau_up[i1, i2], c('up', i1), c_dag('up', i2))
ed.set_g2_tau(G_tau_do[i1, i2], c('do', i1), c_dag('do', i2))
with HDFArchive('kanamori_offdiag.pyed.h5', 'w') as Results:
Results['up'] = G_tau_up
Results['dn'] = G_tau_do
n_iw=1025,
n_tau=2500,
n_l=20)
solver = SolverCore(**cp)
# Set hybridization function
mu = 0.5
half_bandwidth = 1.0
delta_w = GfImFreq(indices=[0], beta=cp['beta'])
delta_w << (half_bandwidth / 2.0)**2 * SemiCircular(half_bandwidth)
for name, g0 in solver.G0_iw:
g0 << inverse(iOmega_n + mu - delta_w)
sp = dict(
h_int=n('up', 0) * n('do', 0) + c_dag('up', 0) * c('do', 0) +
c_dag('do', 0) * c('up', 0),
max_time=-1,
length_cycle=50,
n_warmup_cycles=50,
n_cycles=500,
move_double=False,
)
solver.solve(**sp)
filename = 'h5_read_write.h5'
with HDFArchive(filename, 'w') as A:
A['solver'] = solver
# Number of particles on the impurity
N = sum(n(sn, o) for sn, o in product(spin_names, orb_names))
# Local Hamiltonian
H_loc = h_int_kanamori(spin_names, orb_names,
np.array([[0, U - 3 * J], [U - 3 * J, 0]]),
np.array([[U, U - 2 * J], [U - 2 * J, U]]), J, True)
H_loc -= mu * N
# Bath Hamiltonian
H_bath = sum(epsilon[o] * n("B_" + sn, o)
for sn, o in product(spin_names, orb_names))
# Hybridization Hamiltonian
H_hyb = sum(V[o1, o2] * c_dag("B_" + sn, o1) * c(sn, o2) +
np.conj(V[o2, o1]) * c_dag(sn, o1) * c("B_" + sn, o2)
for sn, o1, o2 in product(spin_names, orb_names, orb_names))
# Complete Hamiltonian
H = H_loc + H_hyb + H_bath
# Diagonalize H
ed.diagonalize(H)
# Compute G(i\omega)
G_iw = ed.G_iw(gf_struct, beta, n_iw)
# Compute G(\tau)
G_tau = ed.G_tau(gf_struct, beta, n_tau)
def make_calc(beta=2.0, h_field=0.0):
# ------------------------------------------------------------------
# -- Hubbard atom with two bath sites, Hamiltonian
p = ParameterCollection(
beta=beta,
V1=2.0,
V2=5.0,
epsilon1=0.10,
epsilon2=3.00,
h_field=h_field,
mu=0.0,
U=5.0,
ntau=800,
niw=15,
)
# ------------------------------------------------------------------
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)
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)
p.H = -p.mu * nA + p.U * docc + p.h_field * mA + \
p.epsilon1 * nB + p.epsilon2 * nC + \
p.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) ) + \
p.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) )
# ------------------------------------------------------------------
fundamental_operators = [
c(up, 0), c(do, 0),
c(up, 1), c(do, 1),
c(up, 2), c(do, 2)
]
ed = TriqsExactDiagonalization(p.H, fundamental_operators, p.beta)
g_tau = GfImTime(beta=beta, statistic='Fermion', n_points=400, 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][0, 0], c(up, 0), c_dag(up, 0))
ed.set_g2_tau(p.G_tau[do][0, 0], c(do, 0), c_dag(do, 0))
ed.set_g2_iwn(p.G_iw[up][0, 0], c(up, 0), c_dag(up, 0))
ed.set_g2_iwn(p.G_iw[do][0, 0], c(do, 0), c_dag(do, 0))
p.magnetization = ed.get_expectation_value(0.5 * mA)
p.O_tau = Gf(mesh=MeshImTime(beta, 'Fermion', 400), target_shape=[])
ed.set_g2_tau(p.O_tau, n(up, 0), n(do, 0))
p.O_tau.data[:] *= -1.
p.exp_val = ed.get_expectation_value(n(up, 0) * n(do, 0))
# ------------------------------------------------------------------
# -- Store to hdf5
filename = 'data_pyed_h_field_%4.4f.h5' % h_field
with HDFArchive(filename, 'w') as res:
res['p'] = p
Ek = np.array([
[1.00, 0.75],
[0.75, -1.20],
])
E_loc = np.array([
[0.2, 0.3],
[0.3, 0.4],
])
V = np.array([
[1.0, 0.25],
[0.25, -1.0],
])
h_loc = c_dag('0', 0) * E_loc[0, 0] * c('0', 0) + \
c_dag('0', 0) * E_loc[0, 1] * c('0', 1) + \
c_dag('0', 1) * E_loc[1, 0] * c('0', 0) + \
c_dag('0', 1) * E_loc[1, 1] * c('0', 1)
Delta_iw << inverse( iOmega_n - Ek ) + inverse( iOmega_n + Ek )
Delta_iw.from_L_G_R(V, Delta_iw, V)
Delta_tau = Gf(mesh=tmesh, target_shape=target_shape)
Delta_tail, Delta_tail_err = Delta_iw.fit_hermitian_tail()
Delta_tau << InverseFourier(Delta_iw, Delta_tail)
G0_iw = Gf(mesh=wmesh, target_shape=target_shape)
G0_iw << inverse( iOmega_n - Delta_iw - E_loc )
S.G0_iw << G0_iw
def solve(self, **params_kw):
"""
Solve the impurity problem: calculate G(iw) and Sigma(iw)
Parameters
----------
params_kw : dict {'param':value} that is passed to the core solver.
Two required :ref:`parameters <solve_parameters>` are
* `h_int` (:ref:`Operator object <triqslibs:operators>`): the local Hamiltonian of the impurity problem to be solved,
* `n_cycles` (int): number of measurements to be made.
Other parameters are
* `calc_gtau` (bool): calculate G(tau)
* `calc_gw` (bool): calculate G(w) and Sigma(w)
* `calc_gl` (bool): calculate G(legendre)
* `calc_dm` (bool): calculate density matrix
"""
h_int = params_kw['h_int']
try:
calc_gtau = params_kw['calc_gtau']
except KeyError:
calc_gtau = False
try:
calc_gw = params_kw['calc_gw']
except KeyError:
calc_gw = False
try:
calc_gl = params_kw['calc_gl']
except KeyError:
calc_gl = False
try:
calc_dm = params_kw['calc_dm']
except KeyError:
calc_dm = False
Delta_iw = 0 * self.G0_iw
Delta_iw << iOmega_n
Delta_iw -= inverse(self.G0_iw)
for block, ind in self.gf_struct:
a = Delta_iw[block].fit_tail()
self.eal[block] = a[0][0]
G0_iw_F = 0 * self.G_iw
if calc_gw:
G0_w_F = 0 * self.G_w
G0_iw_F << iOmega_n
if calc_gw:
G0_w_F << Omega
for block, ind in self.gf_struct:
G0_iw_F[block] -= self.eal[block]
if calc_gw:
G0_w_F[block] -= self.eal[block]
G0_iw_F = inverse(G0_iw_F)
if calc_gw:
G0_w_F = inverse(G0_w_F)
H_loc = 1.0 * h_int
for block, ind in self.gf_struct:
for ii, ii_ind in enumerate(ind):
for jj, jj_ind in enumerate(ind):
H_loc += self.eal[block][ii, jj] * c_dag(
block, ii_ind) * c(block, jj_ind)
self.ad = AtomDiag(H_loc, self.fops)
self.G_iw = atomic_g_iw(self.ad, self.beta, self.gf_struct, self.n_iw)
if calc_gw:
self.G_w = atomic_g_w(self.ad, self.beta, self.gf_struct,
(self.w_min, self.w_max), self.n_w,
self.idelta)
if calc_gtau:
self.G_tau = atomic_g_tau(self.ad, self.beta, self.gf_struct,
self.n_tau)
if calc_gl:
self.G_l = atomic_g_l(self.ad, self.beta, self.gf_struct, self.n_l)
if calc_dm:
self.dm = atomic_density_matrix(self.ad, self.beta)
self.Sigma_iw = inverse(G0_iw_F) - inverse(self.G_iw)
if calc_gw:
self.Sigma_w = inverse(G0_w_F) - inverse(self.G_w)
for k, sn in product(range(len(epsilon)), spin_names)})
# Make PomerolED solver object
ed = PomerolED(index_converter, verbose=True)
# Number of particles on the impurity
H_loc = -mu * (n('up', 0) + n('dn', 0)) + U * n('up', 0) * n('dn', 0)
# Bath Hamiltonian
H_bath = sum(eps * n("B%i_%s" % (k, sn), 0)
for sn, (k, eps) in product(spin_names, enumerate(epsilon)))
# Hybridization Hamiltonian
H_hyb = Operator()
for k, v in enumerate(V):
H_hyb += sum(v * c_dag("B%i_%s" % (k, sn), 0) * c(sn, 0) +
np.conj(v) * c_dag(sn, 0) * c("B%i_%s" % (k, sn), 0)
for sn in spin_names)
# Complete Hamiltonian
H = H_loc + H_hyb + H_bath
# Diagonalize H
ed.diagonalize(H)
###########
# G^{(2)} #
###########
common_g2_params = {
'gf_struct': gf_struct,
def make_calc():
# ------------------------------------------------------------------
# -- Hubbard atom with two bath sites, Hamiltonian
params = dict(
beta=2.0,
V1=2.0,
V2=5.0,
epsilon1=0.00,
epsilon2=4.00,
mu=2.0,
U=5.0,
ntau=40,
niw=15,
)
# ------------------------------------------------------------------
class Dummy():
def __init__(self):
pass
d = Dummy() # storage space
d.params = params
print '--> Solving SIAM with parameters'
for key, value in params.items():
print '%10s = %-10s' % (key, str(value))
globals()[key] = value # populate global namespace
# ------------------------------------------------------------------
up, do = 'up', 'dn'
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)
d.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
# Conversion from TRIQS to Pomerol notation for operator indices
# TRIQS: block_name, inner_index
# Pomerol: site_label, orbital_index, spin_name
index_converter = {
(up, 0): ('loc', 0, 'up'),
(do, 0): ('loc', 0, 'down'),
(up, 1): ('loc', 1, 'up'),
(do, 1): ('loc', 1, 'down'),
(up, 2): ('loc', 2, 'up'),
(do, 2): ('loc', 2, 'down'),
}
# -- Create Exact Diagonalization instance
ed = PomerolED(index_converter, verbose=True)
ed.diagonalize(d.H) # -- Diagonalize H
gf_struct = {up: [0], do: [0]}
# -- Single-particle Green's functions
G_iw = ed.G_iw(gf_struct, beta, n_iw=niw)
G_tau = ed.G_tau(gf_struct, beta, n_tau=ntau)
G_w = ed.G_w(gf_struct,
beta,
energy_window=(-2.5, 2.5),
n_w=100,
im_shift=0.01)
d.G_iw = G_iw['up']
d.G_tau = G_tau['up']
d.G_w = G_w['up']
# -- Particle-particle two-particle Matsubara frequency Green's function
opt = dict(block_order='AABB',
beta=beta,
gf_struct=gf_struct,
blocks=set([("up", "dn")]),
n_iw=niw,
n_inu=niw)
G2_iw = ed.G2_iw_inu_inup(channel='AllFermionic', **opt)
d.G2_iw = G2_iw['up', 'dn']
G2_iw_pp = ed.G2_iw_inu_inup(channel='PP', **opt)
d.G2_iw_pp = G2_iw_pp['up', 'dn']
G2_iw_ph = ed.G2_iw_inu_inup(channel='PH', **opt)
d.G2_iw_ph = G2_iw_ph['up', 'dn']
# ------------------------------------------------------------------
# -- Store to hdf5
filename = 'data_pomerol.h5'
with HDFArchive(filename, 'w') as res:
for key, value in d.__dict__.items():
res[key] = value
def make_calc():
# ------------------------------------------------------------------
# -- Hamiltonian
p = ParameterCollection(
beta = 0.5,
U = 0.5,
nw = 1,
nwf = 15,
V = 1.0,
eps = 0.2,
)
p.nwf_gf = 4 * p.nwf
p.mu = 0.5*p.U
# ------------------------------------------------------------------
ca_up, cc_up = c('0', 0), c_dag('0', 0)
ca_do, cc_do = c('0', 1), c_dag('0', 1)
ca0_up, cc0_up = c('1', 0), c_dag('1', 0)
ca0_do, cc0_do = c('1', 1), c_dag('1', 1)
docc = cc_up * ca_up * cc_do * ca_do
nA = cc_up * ca_up + cc_do * ca_do
hybridiz = p.V * (cc0_up * ca_up + cc_up * ca0_up + cc0_do * ca_do + cc_do * ca0_do)
bath_lvl = p.eps * (cc0_up * ca0_up + cc0_do * ca0_do)
p.H_int = p.U * docc
p.H = -p.mu * nA + p.H_int + hybridiz + bath_lvl
# ------------------------------------------------------------------
# -- Exact diagonalization
# Conversion from TRIQS to Pomerol notation for operator indices
# TRIQS: block_name, inner_index
# Pomerol: site_label, orbital_index, spin_name
index_converter = {
('0', 0) : ('loc', 0, 'up'),
('0', 1) : ('loc', 0, 'down'),
('1', 0) : ('loc', 1, 'up'),
('1', 1) : ('loc', 1, 'down'),
}
# -- Create Exact Diagonalization instance
ed = PomerolED(index_converter, verbose=True)
ed.diagonalize(p.H) # -- Diagonalize H
p.gf_struct = [['0', [0, 1]]]
# -- Single-particle Green's functions
p.G_iw = ed.G_iw(p.gf_struct, p.beta, n_iw=p.nwf_gf)['0']
# -- Particle-particle two-particle Matsubara frequency Green's function
opt = dict(
beta=p.beta, gf_struct=p.gf_struct,
blocks=set([("0", "0")]),
n_iw=p.nw, n_inu=p.nwf)
p.G2_iw_ph = ed.G2_iw_inu_inup(channel='PH', **opt)[('0', '0')]
filename = 'data_pomerol.h5'
with HDFArchive(filename,'w') as res:
res['p'] = p
import os
os.system('tar czvf data_pomerol.tar.gz data_pomerol.h5')
os.remove('data_pomerol.h5')
def make_calc(nw=10, beta=2.0, h_field=0.0):
# ------------------------------------------------------------------
# -- Hubbard atom with two bath sites, Hamiltonian
p = ParameterCollection(
beta=beta,
V1=2.0,
V2=5.0,
epsilon1=0.00,
epsilon2=4.00,
h_field=h_field,
mu=2.0,
U=5.0,
ntau=40,
niw=15,
n_inu=nw,
)
# ------------------------------------------------------------------
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)
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)
p.H = -p.mu * nA + p.U * docc + p.h_field * mA + \
p.epsilon1 * nB + p.epsilon2 * nC + \
p.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) ) + \
p.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
# Conversion from TRIQS to Pomerol notation for operator indices
# TRIQS: block_name, inner_index
# Pomerol: site_label, orbital_index, spin_name
index_converter = {
(up, 0): ('loc', 0, 'up'),
(do, 0): ('loc', 0, 'down'),
(up, 1): ('loc', 1, 'up'),
(do, 1): ('loc', 1, 'down'),
(up, 2): ('loc', 2, 'up'),
(do, 2): ('loc', 2, 'down'),
}
# -- Create Exact Diagonalization instance
ed = PomerolED(index_converter, verbose=True)
ed.diagonalize(p.H) # -- Diagonalize H
gf_struct = [[up, [0]], [do, [0]]]
# -- Single-particle Green's functions
p.G_iw = ed.G_iw(gf_struct, beta, n_iw=100)
p.G_tau = ed.G_tau(gf_struct, beta, n_tau=400)
# -- Particle-particle two-particle Matsubara frequency Green's function
opt = dict(block_order='AABB',
beta=beta,
gf_struct=gf_struct,
blocks=set([(up, up), (up, do)]),
n_iw=1,
n_inu=p.n_inu)
p.G2_iw_ph = ed.G2_iw_inu_inup(channel='PH', **opt)
# ------------------------------------------------------------------
# -- Store to hdf5
mpi.barrier()
if mpi.is_master_node():
filename = 'data_pomerol_h_field_%4.4f.h5' % h_field
with HDFArchive(filename, 'w') as res:
res['p'] = p
