def set_g4_tau_matrix(self, g4_tau, op_list):
assert (g4_tau.target_shape == tuple([len(op_list)] * 4))
for (i1, o1), (i2, o2), (i3, o3), (i4, o4) in \
mpi_op_comb(op_list, repeat=4):
self.set_g4_tau(g4_tau[i1, i2, i3, i4], o1, dagger(o2), o3,
dagger(o4))
g4_tau = mpi_all_reduce_g(g4_tau)
return g4_tau
def operator_single_particle_transform(op, U, fundamental_operators):
""" Transform the operator op according to the single particle
transform matrix U defined in the subspace of operators listed in
fundamental_operators. """
# -- Convert fundamental operators back and forth from index
op_idx_map = get_operator_index_map(fundamental_operators)
op_idx_set = set(op_idx_map)
# -- Transformed creation operator
def c_transf(s, i):
if (s, i) not in op_idx_set:
return c(s, i)
k = op_idx_map.index((s, i))
ret = Operator()
for l in xrange(U.shape[0]):
op_idx = op_idx_map[l]
ret += U[k, l] * c(*op_idx)
return ret
# -- Precompute transformed operators
op_trans_dict = {}
for fop in fundamental_operators:
dag, idxs = op_serialize_fundamental(fop)
op_trans_dict[(dag, idxs)] = c_transf(*idxs)
op_trans_dict[(not dag, idxs)] = dagger(c_transf(*idxs))
# -- Loop over given operator and substitute operators
# -- fundamental_operators with the transformed operators
op_trans = Operator()
for term in op:
op_factor = Operator(1.)
for factor in term:
if type(factor) is list:
for dag, idxs in factor:
tup = (dag, tuple(idxs))
if tup in op_trans_dict.keys():
op_factor *= op_trans_dict[tup]
else:
op_factor *= {False:c, True:c_dag}[dag](*idxs)
else: # constant prefactor
op_factor *= factor
op_trans += op_factor
return op_trans
def set_g2_tau_matrix(self, g_tau, op_list):
assert (g_tau.target_shape == tuple([len(op_list)] * 2))
for (i1, o1), (i2, o2) in mpi_op_comb(op_list, repeat=2):
self.set_g2_tau(g_tau[i1, i2], o1, dagger(o2))
g_tau = mpi_all_reduce_g(g_tau)
return g_tau
def operator_from_quartic_tensor(h_quart, fundamental_operators):
# -- Convert fundamental operators back and forth from index
op_idx_map = get_operator_index_map(fundamental_operators)
op_idx_set = set(op_idx_map)
nop = len(fundamental_operators)
H = Operator(0.)
for t in itertools.product(enumerate(fundamental_operators), repeat=4):
idx, ops = zip(*t)
o1, o2, o3, o4 = ops
o1, o2 = dagger(o1), dagger(o2)
H += h_quart[idx] * o1 * o2 * o3 * o4
return H
def get_quadratic_operator(h, fundamental_operators):
# -- Check Hermicity
np.testing.assert_array_almost_equal(h, h.T.conj())
H = Operator(0.)
for idx1, o1 in enumerate(fundamental_operators):
o1 = dagger(o1)
for idx2, o2 in enumerate(fundamental_operators):
H += h[idx1, idx2] * o1 * o2
return H
def d_dag(b, m):
return dagger(d(b, m))
index_list = []
for i1 in xrange(4):
for i2 in xrange(i1, 4):
index_list.append((i1, i2))
#F = 0.0001 / m.beta
F = 0.1 / m.beta
F_vec = np.array([-F, F])
work_list = np.array(index_list)
work_list = mpi.slice_array(work_list)
for i1, i2 in work_list:
o1, o2 = m.op_imp[i1], m.op_imp[i2]
O1 = dagger(o1) * o2
O1 = O1 + dagger(O1)
ed_p = TriqsExactDiagonalization(m.H + F * O1, m.op_full, m.beta)
ed_m = TriqsExactDiagonalization(m.H - F * O1, m.op_full, m.beta)
p.g_tau_field[(i1, i2)] = g_tau.copy()
ed_p.set_g2_tau_matrix(p.g_tau_field[(i1, i2)], m.op_imp)
for i3, i4 in itertools.product(range(4), repeat=2):
o3, o4 = m.op_imp[i3], m.op_imp[i4]
O2 = dagger(o3) * o4
O2_vec = np.zeros(2, dtype=np.complex)
O2_vec[0] = ed_m.get_expectation_value(O2)
#p.T = np.kron(ortho_group.rvs(2), np.eye(2)) # orbital only rotation
# use parametrized "weak" realvalued 4x4 transform
p.T = unitary_transf_4x4(t_vec=[0.3, 0.3, 0.3, 0.0, 0.0, 0.0])
#p.T = unitary_transf_4x4(t_vec=[0.25*np.pi, 0.0, 0.0, 0.0, 0.0, 0.0])
#p.T = np.eye(4)
p.T = np.matrix(p.T)
print p.T
# -- Different types of operator sets
p.op_imp = [c('0', 0), c('0', 1), c('0', 2), c('0', 3)]
p.op_full = p.op_imp + [c('1', 0), c('1', 1), c('1', 2), c('1', 3)]
p.spin_block_ops = [c('0', 0), c('1', 0), c('0', 1), c('1', 1)]
p.spin_block_ops += [dagger(op) for op in p.spin_block_ops]
p.org_ops = copy.copy(p.op_imp)
p.org_ops += [dagger(op) for op in p.org_ops]
p.diag_ops = [c('0_0', 0), c('0_1', 0), c('0_2', 0), c('0_3', 0)]
p.diag_ops += [dagger(op) for op in p.diag_ops]
p.gf_struct = [['0', [0, 1, 2, 3]]]
p.gf_struct_diag = [['0_0', [0]], ['0_1', [0]], ['0_2', [0]], ['0_3', [0]]]
p.index_converter = {
('0', 0): ('loc', 0, 'up'),
('0', 1): ('loc', 0, 'down'),
('0', 2): ('loc', 1, 'up'),
('0', 3): ('loc', 1, 'down'),
beta=m.beta,
statistic='Boson',
n_points=50,
target_shape=(4, 4, 4, 4))
p.chi = np.zeros_like(p.chi_static)
tau = np.array([float(tau) for tau in p.chi_tau.mesh])
for i1, i2, i3, i4, in itertools.product(range(4), repeat=4):
print i1, i2, i3, i4
o1, o2, o3, o4 = m.op_imp[i1], m.op_imp[i2], m.op_imp[i3], m.op_imp[i4]
O1 = dagger(o1) * o2
O2 = dagger(o3) * o4
p.O1_exp[i1, i2] = ed.get_expectation_value(O1)
p.O2_exp[i3, i4] = ed.get_expectation_value(O2)
p.chi_dissconn[i1, i2, i3, i4] = p.O1_exp[i1, i2] * p.O2_exp[i3, i4]
p.chi_static[i1, i2, i3, i4] = ed.get_expectation_value(O1 * O2)
ed.set_g2_tau(p.chi_tau[i1, i2, i3, i4], O1, O2)
chi_tau = p.chi_tau[i1, i2, i3, i4]
chi_tau *= -1. # cancel gf -1 prefactor
chi_dissconn = p.chi_dissconn[i1, i2, i3, i4]
