def baryon_decuplet_base_contraction(prop_1, prop_2, diquarks, pol_matrix):
assert isinstance(diquarks, list)
contraction = gpt.trace(
gpt.eval(pol_matrix * gpt.color_trace(prop_2 * gpt.spin_trace(diquarks[0]))) +
gpt.eval(pol_matrix * gpt.color_trace(prop_2 * diquarks[0]))
)
contraction += gpt.eval(gpt.trace(pol_matrix * gpt.color_trace(prop_2 * diquarks[1])))
contraction += gpt.eval(gpt.trace(pol_matrix * gpt.color_trace(prop_1 * diquarks[2])))
contraction *= 2
contraction += gpt.eval(gpt.trace(pol_matrix * gpt.color_trace(prop_1 * gpt.spin_trace(diquarks[2]))))
return contraction
def chroma_sigma_star(prop_1, prop_2, prop_3, spm, polm, diquark):
#diquark = quark_contract_13(gpt.eval(prop_1 * spm), gpt.eval(spm * prop_3))
contraction = gpt.trace(gpt.eval(polm * prop_2 * gpt.spin_trace(diquark)))
diquark2 = quark_contract_24(prop_2, gpt.eval(spm * prop_3 * spm))
contraction += gpt.trace(gpt.eval(prop_1 * polm * diquark2))
diquark2 @= quark_contract_13(prop_1, gpt.eval(spm * prop_3))
contraction += gpt.trace(gpt.eval(polm * prop_2 * spm * diquark2))
return gpt.eval(contraction)
def uud_two_point(Q1, Q2, kernel):
#
# eps(a,b,c) eps(a',b',c') (kernel)_alpha'beta' (kernel)_alphabeta Pp_gammagamma' Q2_beta'beta_b'b
# (Q1_alpha'alpha_a'a Q1_gamma'gamma_c'c - Q1_alpha'gamma_a'c Q1_gamma'alpha_c'a)
#
# =
#
# eps(a,b,c) eps(a',b',c') (kernel)_alpha'beta' (kernel)_alphabeta Pp_gammagamma' Q2_beta'beta_b'b
# Q1_alpha'alpha_a'a Q1_gamma'gamma_c'c
# -
# eps(a,b,c) eps(a',b',c') (kernel)_alpha'beta' (kernel)_alphabeta Pp_gammagamma' Q2_beta'beta_b'b
# Q1_alpha'gamma_a'c Q1_gamma'alpha_c'a
#
# =
#
# eps(c,a,b) eps(c',a',b') (Q1 kernel)_alpha'beta_a'a (kernel Q2)^Tspin_betaalpha'_b'b Tr_S[Pp Q1_c'c]
# +
# eps(a,b,c) eps(a',b',c') Pp_gammagamma'
# (Q1 kernel)_gamma'beta_c'c (kernel Q2)^Tspin_betaalpha'_b'b Q1_alpha'gamma_a'a
#
# =
#
# Tr_S[diquark(Q1 kernel, kernel Q2)_{cc'}] Tr_S[Pp Q1_c'c]
# +
# diquark(Q1 kernel, kernel Q2)_{gamma'alpha', aa'} Pp_gammagamma'
# Q1_alpha'gamma_a'a
#
# =
#
# Tr_C[Tr_S[diquark(Q1 kernel, kernel Q2)] Tr_S[Q1 Pp]]
# +
# Tr[ Q1 Pp diquark(Q1 kernel, kernel Q2) ]
#
#
# with
#
# diquark(Q1,Q2)_{gammagamma', cc'} = eps(c,a,b) eps(c',a',b') (Q1)_gammabeta_a'a (Q2)^Tspin_betagamma'_b'b
#
dq = g.qcd.baryon.diquark(g(Q1 * kernel), g(kernel * Q2))
return g(g.color_trace(g.spin_trace(dq) * Q1 + dq * Q1))
def p2n_dbaru(src, Pol_i, Spin_M, t_sink):
I = g.ot_matrix_spin_color(4, 3).identity()
tmp_seq_src = g.lattice(src)
q1_tmp = g.eval(src * Spin_M) # e.g. D * Cg5
q2_tmp = g.eval(Spin_M * src) # e.g. Cg5 * D
di_quark = qC.quarkContract24(q1_tmp, q2_tmp)
tmp_seq_src = qC.quarkContract14(g.eval(Pol_i * q1_tmp), q2_tmp)
tmp_seq_src += g.eval(Pol_i * di_quark)
tmp_seq_src += g.eval(g.spin_trace(di_quark) * I * Pol_i)
q1_tmp = q2_tmp * Spin_M # e.g. (Cg5 * D) * Cg5
q2_tmp = src * Pol_i # e.g. D * Pol_i
tmp_seq_src -= qC.quarkContract13(q1_tmp, q2_tmp)
seq_src = g.lattice(src)
seq_src[:] = 0
seq_src[:, :, :, t_sink] = tmp_seq_src[:, :, :, t_sink]
return seq_src
def p2p_ubaru(src, Pol_i, Spin_M, t_sink):
I = g.ot_matrix_spin_color(4, 3).identity()
tmp_seq_src = g.lattice(src)
q1_tmp = g.eval(src * Spin_M) # e.g. D * Cg5
q2_tmp = g.eval(Spin_M * src) # e.g. Cg5 * D
di_quark = qC.quarkContract24(q1_tmp, q2_tmp)
tmp_seq_src = g.eval(Pol_i * di_quark)
tmp_seq_src += g.eval(g.spin_trace(di_quark) * I * Pol_i)
q1_tmp = g.eval(q2_tmp * Spin_M) # e.g. Cg5 * D * Cg5
q2_tmp = g.eval(src * Pol_i) # e.g. D * Pol_i
tmp_seq_src -= qC.quarkContract13(q1_tmp, q2_tmp)
tmp_seq_src -= g.spin_transpose(qC.quarkContract12(q2_tmp, q1_tmp))
tmp_seq_src @= g.eval(g.gamma[5] * g.adj(tmp_seq_src) * g.gamma[5])
seq_src = g.lattice(src)
seq_src[:] = 0
seq_src[:, :, :, t_sink] = tmp_seq_src[:, :, :, t_sink]
return seq_src
# set entire block to tensor
src = g.vspincolor(grid)
zero = g.vspincolor([[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]])
val = g.vspincolor([[1, 1, 1], [1, 1, 1], [0, 0, 0], [0, 0, 0]])
src[:] = 0
src[:, :, :, 0] = val
for x in range(grid.fdimensions[0]):
for t in range(grid.fdimensions[3]):
compare = val if t == 0 else zero
eps = g.norm2(src[x, 0, 0, t] - compare)
assert eps < 1e-13
# spin and color traces
mc = g.eval(g.spin_trace(msc))
assert g.norm2(mc[0, 0, 0, 0] - g.spin_trace(msc[0, 0, 0, 0])) < 1e-13
ms = g.eval(g.color_trace(msc))
assert g.norm2(ms[0, 0, 0, 0] - g.color_trace(msc[0, 0, 0, 0])) < 1e-13
eps0 = g.norm2(g.trace(msc) - g.spin_trace(ms))
eps1 = g.norm2(g.trace(msc) - g.color_trace(mc))
assert eps0 < 1e-9 and eps1 < 1e-9
# create singlet by number
assert g.complex(0.5).array[0] == 0.5
# test expression -> string conversion;
# at this point only make sure that it
# produces a string without failing
# test creating spinor projections as expession templates
P = g.gamma[0] * g.gamma[1] - g.gamma[2] * g.gamma[3]
dst @= P * l
ref @= g.gamma[0] * g.gamma[1] * l - g.gamma[2] * g.gamma[3] * l
eps = g.norm2(dst - ref) / g.norm2(l)
g.message("Test Regular Expression: ", eps)
assert eps == 0.0
# test algebra versus matrix
for mu in [0, 1, 2, 3, 5, "I"]:
for op in [
lambda a, b: a * b,
lambda a, b: b * a,
lambda a, b: g.spin_trace(a * b),
lambda a, b: g.spin_trace(b * a),
lambda a, b: g.color_trace(a * b),
lambda a, b: g.color_trace(b * a),
lambda a, b: g.trace(a * b),
lambda a, b: g.trace(b * a),
]:
dst_alg = g(op(g.gamma[mu], l))
dst_mat = g(op(g.gamma[mu].tensor(), l))
eps2 = g.norm2(dst_alg - dst_mat) / g.norm2(dst_mat)
g.message(f"Algebra<>Matrix {mu}: {eps2}")
assert eps2 < 1e-14
# reconstruct and test the gamma matrix elements
for mu in g.gamma:
gamma = g.gamma[mu]
def sss_two_point(Q1, kernel):
dq = g.qcd.baryon.diquark(g(Q1 * kernel), g(kernel * Q1))
return g(-2.0 * g.color_trace(g.spin_trace(dq) * Q1 + 2.0 * dq * Q1))
def uud_two_point(Q1, Q2, kernel):
dq = g.qcd.baryon.diquark(g(Q1 * kernel), g(kernel * Q2))
return g(g.color_trace(g.spin_trace(dq) * Q1 + dq * Q1))
correlator = g.slice(g.trace(di_quark * g.adj(di_quark)), 3)
for t, c in enumerate(correlator):
correlators[n, m, l, t] = c.real
# test gauge covariance
for k in range(len(contraction_routines)):
for t in range(Nt):
assert (correlators[0, k, l, t] - correlators[1, k, l, t] < 1e-12)
# test spin structure
for n in range(4):
I = g.ot_matrix_spin_color(4, 3).identity()
if (n == 0):
di_quark1 = qC.quark_contract_12(dst, dst)
di_quark2 = qC.quark_contract_12(dst, g.eval(I * g.spin_trace(dst)))
correlator1 = g.slice(g.trace(di_quark1), 3)
correlator2 = g.slice(g.color_trace(di_quark2), 3)
for t in range(Nt):
assert (correlator1[t] - correlator2[t][0, 0]) < 1e-13
if (n == 1):
di_quark1 = qC.quark_contract_34(dst, dst)
di_quark2 = qC.quark_contract_34(g.eval(I * g.spin_trace(dst)), dst)
correlator1 = g.slice(g.trace(di_quark1), 3)
correlator2 = g.slice(g.color_trace(di_quark2), 3)
for t in range(Nt):
def contract_three_flavor_baryon(prop_1, prop_2, prop_3, pol_matrix, source_spin_matrix, sink_spin_matrix):
di_quark = quark_contract_13(gpt.eval(prop_1 * source_spin_matrix), gpt.eval(sink_spin_matrix * prop_2))
return gpt.trace(gpt.eval(pol_matrix * gpt.color_trace(prop_3 * gpt.spin_trace(di_quark))))
def contract_lambda_naive(prop_up, prop_down, prop_strange, spin_matrix, pol_matrix, diquark=None):
if diquark is None:
diquark = quark_contract_13(
gpt.eval(prop_up * spin_matrix), gpt.eval(spin_matrix * prop_down)
)
return gpt.trace(pol_matrix * gpt.color_trace(prop_strange * gpt.spin_trace(diquark)))
def baryon_octet_base_contraction(prop, diquark, pol_matrix):
return gpt.trace(
pol_matrix * gpt.color_trace(prop * gpt.spin_trace(diquark)) +
pol_matrix * gpt.color_trace(prop * diquark)
)
