def distribute(self, mat, dst, src, zero_lhs):
src, dst = gpt.util.to_list(src), gpt.util.to_list(dst)
if src[0].otype.__name__ == self.ot_matrix:
assert dst[0].otype.__name__ == self.ot_matrix
src_grid = src[0].grid
dst_grid = dst[0].grid
n_src = self.spin_ndim * self.color_ndim * len(src)
n_dst = self.spin_ndim * self.color_ndim * len(dst)
dst_sc = [gpt.gpt_object(dst_grid, self) for i in range(n_dst)]
src_sc = [gpt.gpt_object(src_grid, self) for i in range(n_src)]
if zero_lhs:
for idx in range(n_dst):
dst_sc[idx][:] = 0
for i in range(len(src)):
for s in range(self.spin_ndim):
for c in range(self.color_ndim):
idx = c + self.color_ndim * (s + self.spin_ndim * i)
gpt.qcd.prop_to_ferm(src_sc[idx], src[i], s, c)
mat(dst_sc, src_sc)
for i in range(len(dst)):
for s in range(self.spin_ndim):
for c in range(self.color_ndim):
idx = c + self.color_ndim * (s + self.spin_ndim * i)
gpt.qcd.ferm_to_prop(dst[i], dst_sc[idx], s, c)
else:
raise TypeError(
f"Unexpected type {src[0].otype.__name__} <> {self.ot_matrix}")
def generators(self, dt):
r = []
# accumulate generators in pauli / Gell-Mann ordering
for i in range(self.Nc):
for j in range(i + 1, self.Nc):
# sigma_x
alg = numpy.zeros(shape=(self.Nc, self.Nc), dtype=dt)
alg[i, j] = 1.0
alg[j, i] = 1.0
r.append(alg)
# sigma_y
alg = numpy.zeros(shape=(self.Nc, self.Nc), dtype=dt)
alg[i, j] = -1j
alg[j, i] = 1j
r.append(alg)
# sigma_z
if j == i + 1:
alg = numpy.zeros(shape=(self.Nc, self.Nc), dtype=dt)
for l in range(j):
alg[l, l] = 1.0
alg[j, j] = -j
r.append(alg)
# need to satisfy normalization Tr(T_a T_b) = 1/2 delta_{ab}
for alg in r:
alg /= (numpy.trace(numpy.dot(alg, alg)) * 2.0)**0.5
# return gpt_object version
algebra_otype = ot_matrix_su_n_fundamental_algebra(self.Nc)
return [gpt.gpt_object(i, algebra_otype) for i in r]
def generators(self, dt):
T_f = ot_matrix_su_n_fundamental_algebra(self.Nc).generators(dt)
if self.Nc not in ot_matrix_su_n_adjoint_algebra.f:
ot_matrix_su_n_adjoint_algebra.f[
self.Nc] = compute_structure_constant(T_f, dt)
# assert compute_structure_constant(ot_matrix_su_n_fundamental_algebra(2).generators(dt),dt)[0][1][2] == 1
# assert compute_structure_constant(ot_matrix_su_n_adjoint_algebra(2).generators(dt),dt)[0][1][2] == 1
r = []
for a in range(self.Ndim):
r.append(ot_matrix_su_n_adjoint_algebra.f[self.Nc][a] / 1j)
# return gpt_object version
algebra_otype = ot_matrix_su_n_adjoint_algebra(self.Nc)
return [gpt.gpt_object(i, algebra_otype) for i in r]
def init(x, p):
otype = x.otype
x[:] = g.gpt_object(
np.identity(otype.shape[0], dtype=x.grid.precision.complex_dtype), otype
)
