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 )