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) )