def D_DWF(dst, src, b, c, mass_plus, mass_minus):
D_W = g.qcd.fermion.wilson_clover(
U,
mass=-1.8,
csw_r=0.0,
csw_t=0.0,
nu=1.0,
xi_0=1.0,
isAnisotropic=False,
boundary_phases=[1, 1, 1, -1],
)
src_s = g.separate(src, 0)
dst_s = [g.lattice(s) for s in src_s]
Ls = len(src_s)
src_plus_s = []
src_minus_s = []
for s in range(Ls):
src_plus_s.append(g(0.5 * src_s[s] + 0.5 * g.gamma[5] * src_s[s]))
src_minus_s.append(g(0.5 * src_s[s] - 0.5 * g.gamma[5] * src_s[s]))
for d in dst_s:
d[:] = 0
for s in range(Ls):
dst_s[s] += b * D_W * src_s[s] + src_s[s]
for s in range(1, Ls):
dst_s[s] += c * D_W * src_plus_s[s - 1] - src_plus_s[s - 1]
for s in range(0, Ls - 1):
dst_s[s] += c * D_W * src_minus_s[s + 1] - src_minus_s[s + 1]
dst_s[0] -= mass_plus * (c * D_W * src_plus_s[Ls - 1] - src_plus_s[Ls - 1])
dst_s[Ls - 1] -= mass_minus * (c * D_W * src_minus_s[0] - src_minus_s[0])
dst @= g.merge(dst_s, 0)
def _J5q(dst4d, src5d):
src4d = gpt.separate(src5d, 0)
Ls = len(src4d)
# create correlator at the midpoint of the 5-th direction
p_plus = gpt.eval(src4d[Ls // 2 - 1] +
gpt.gamma[5] * src4d[Ls // 2 - 1])
p_minus = gpt.eval(src4d[Ls // 2] - gpt.gamma[5] * src4d[Ls // 2])
gpt.eval(dst4d, 0.5 * (p_plus + p_minus))
def lattice_reverse_check(lat):
grid = lat.grid
l_rev_ref = g.lattice(lat)
l_rev_ref.checkerboard(lat.checkerboard().inv())
T = grid.fdimensions[3]
for t in range(T):
# 31 <- 0 => interchange even and odd sites
l_rev_ref[:, :, :, T - t - 1] = lat[:, :, :, t]
l_rev = g.merge(list(reversed(g.separate(lat, 3))), 3)
eps = g.norm2(l_rev - l_rev_ref)
g.message("Temporal inverse lattice test: ", eps)
assert eps == 0.0
for i in range(len(m)):
for j in range(4):
k = i * 4 + j
assert g.norm2(l[k][1, 2, 0, 0] - m[i][1, 2, 0, 0, j]) == 0.0
# Test merging slices along a new 2nd dimension 4 at a time
m = g.merge(l, 1, N=4)
assert len(m) == Nlat // 4
for i in range(len(m)):
for j in range(4):
k = i * 4 + j
assert g.norm2(l[k][1, 2, 0, 0] - m[i][1, j, 2, 0, 0]) == 0.0
test = g.separate(m, 1)
assert len(test) == Nlat
for i in range(len(l)):
assert g.norm2(l[i] - test[i]) == 0.0
# default arguments should be compatible
test = g.separate(g.merge(l))
for i in range(len(l)):
assert g.norm2(l[i] - test[i]) == 0.0
################################################################################
# Test split grid
################################################################################
for src in [l, l_rb]:
split_grid = src[0].grid.split(
def sep(x):
return g.separate(x, dimension=0)
u_dst[:, :, :, t] = u_src[:, :, :, t]
# save smeared gauge field
g.save(config_smeared, U, g.format.nersc())
g.message("Plaquette after", g.qcd.gauge.plaquette(U))
for u in U:
g.message("Unitarity violation",
g.norm2(u * g.adj(u) - g.identity(u)) / g.norm2(u))
g.message(
"SU violation",
g.norm2(g.matrix.det(u) - g.identity(g.complex(u.grid))) / g.norm2(u),
)
# separate time slices and define laplace operator
U3 = [g.separate(u, 3) for u in U[0:3]]
for t in range(Nt):
if t % t_groups != t_group:
continue
g.message(f"Laplace basis for time-slice {t}")
U3_t = [u[t] for u in U3]
grid = U3_t[0].grid
lap = g.create.smear.laplace(
g.covariant.shift(U3_t, boundary_phases=[1.0, 1.0, 1.0, -1.0]),
dimensions=[0, 1, 2],
)
for i in range(len(m)):
for j in range(4):
k = i * 4 + j
assert g.norm2(l[k][1, 2, 0, 0] - m[i][1, 2, 0, 0, j]) == 0.0
# Test merging slices along a new 2nd dimension 4 at a time
m = g.merge(l, 1, N=4)
assert len(m) == Nlat // 4
for i in range(len(m)):
for j in range(4):
k = i * 4 + j
assert g.norm2(l[k][1, 2, 0, 0] - m[i][1, j, 2, 0, 0]) == 0.0
test = g.separate(m, 1)
assert len(test) == Nlat
for i in range(len(l)):
assert g.norm2(l[i] - test[i]) == 0.0
# default arguments should be compatible
test = g.separate(g.merge(l))
for i in range(len(l)):
assert g.norm2(l[i] - test[i]) == 0.0
################################################################################
# Test split grid
################################################################################
for src in [l, l_rb]:
split_grid = src[0].grid.split(g.default.get_ivec("--mpi_split", None, 4),
def conserved_current(self,
psi_left,
src_left,
psi_right,
src_right,
mu,
sign,
psi_left_flavor=None):
# sign = +1 (vector), -1 (axial vector)
mass_plus = self.params["mass_plus"]
mass_minus = self.params["mass_minus"]
psi_right_shift = self.covariant_shift()
assert not self.daggered
assert mass_plus == mass_minus
mass = mass_plus
psi_left_shift = (psi_left_flavor.covariant_shift()
if psi_left_flavor is not None else psi_right_shift)
L_Q = gpt.separate(psi_left, 0, self.separate_cache)
R_Q = gpt.separate(psi_right, 0, self.separate_cache)
Ls = len(L_Q)
Pplus = (gpt.gamma["I"].tensor() + gpt.gamma[5].tensor()) * 0.5
Pminus = (gpt.gamma["I"].tensor() - gpt.gamma[5].tensor()) * 0.5
L_Q_4d = gpt(Pminus * L_Q[0] + Pplus * L_Q[Ls - 1])
R_Q_4d = gpt(Pminus * R_Q[0] + Pplus * R_Q[Ls - 1])
L_TopRowWithSource = gpt(src_left + (1.0 - mass) * L_Q_4d)
R_TopRowWithSource = gpt(src_right + (1.0 - mass) * R_Q_4d)
TermA = gpt(Pplus * L_Q_4d)
TermB = gpt(Pminus * L_Q_4d)
TermC = gpt(Pminus * L_TopRowWithSource)
TermD = gpt(Pplus * L_TopRowWithSource)
L_TmLsGq0 = gpt(TermD - TermA + TermB)
L_TmLsTmp = gpt(TermC - TermB + TermA)
TermA = gpt(Pplus * R_Q_4d)
TermB = gpt(Pminus * R_Q_4d)
TermC = gpt(Pminus * R_TopRowWithSource)
TermD = gpt(Pplus * R_TopRowWithSource)
R_TmLsGq0 = gpt(TermD - TermA + TermB)
R_TmLsTmp = gpt(TermC - TermB + TermA)
R_TmLsGq = [
gpt(Pminus * R_Q[s] + Pplus * R_Q[(s - 1 + Ls) % Ls])
for s in range(Ls)
]
L_TmLsGq = [
gpt(Pminus * L_Q[s] + Pplus * L_Q[(s - 1 + Ls) % Ls])
for s in range(Ls)
]
dst = gpt.lattice(src_left)
dst[:] = 0
for s in range(Ls):
sp = (s + 1) % Ls
sr = Ls - 1 - s
srp = (sr + 1) % Ls
b = self.params["b_s"][s]
c = self.params["c_s"][s]
bpc = -0.5 / (b + c)
if s == 0:
p5d = gpt(b * Pminus * L_TmLsGq[Ls - 1] +
c * Pplus * L_TmLsGq[Ls - 1] +
b * Pplus * L_TmLsTmp + c * Pminus * L_TmLsTmp)
tmp = gpt(b * Pminus * R_TmLsGq0 + c * Pplus * R_TmLsGq0 +
b * Pplus * R_TmLsGq[1] + c * Pminus * R_TmLsGq[1])
elif s == Ls - 1:
p5d = gpt(b * Pminus * L_TmLsGq0 + c * Pplus * L_TmLsGq0 +
b * Pplus * L_TmLsGq[1] + c * Pminus * L_TmLsGq[1])
tmp = gpt(b * Pminus * R_TmLsGq[Ls - 1] +
c * Pplus * R_TmLsGq[Ls - 1] +
b * Pplus * R_TmLsTmp + c * Pminus * R_TmLsTmp)
else:
p5d = gpt(b * Pminus * L_TmLsGq[sr] +
c * Pplus * L_TmLsGq[sr] +
b * Pplus * L_TmLsGq[srp] +
c * Pminus * L_TmLsGq[srp])
tmp = gpt(b * Pminus * R_TmLsGq[s] + c * Pplus * R_TmLsGq[s] +
b * Pplus * R_TmLsGq[sp] + c * Pminus * R_TmLsGq[sp])
us_p5d = gpt(psi_right_shift.forward[mu] * tmp)
gp5d = gpt(gpt.gamma[5] * p5d * gpt.gamma[5])
gus_p5d = gpt(gpt.gamma[mu] * us_p5d)
C = gpt(bpc * gpt.adj(gp5d) * (us_p5d - gus_p5d))
if s == 0:
p5d = gpt(b * Pminus * R_TmLsGq0 + c * Pplus * R_TmLsGq0 +
b * Pplus * R_TmLsGq[1] + c * Pminus * R_TmLsGq[1])
tmp = gpt(b * Pminus * L_TmLsGq[Ls - 1] +
c * Pplus * L_TmLsGq[Ls - 1] +
b * Pplus * L_TmLsTmp + c * Pminus * L_TmLsTmp)
elif s == Ls - 1:
p5d = gpt(b * Pminus * R_TmLsGq[Ls - 1] +
c * Pplus * R_TmLsGq[Ls - 1] +
b * Pplus * R_TmLsTmp + c * Pminus * R_TmLsTmp)
tmp = gpt(b * Pminus * L_TmLsGq0 + c * Pplus * L_TmLsGq0 +
b * Pplus * L_TmLsGq[1] + c * Pminus * L_TmLsGq[1])
else:
p5d = gpt(b * Pminus * R_TmLsGq[s] + c * Pplus * R_TmLsGq[s] +
b * Pplus * R_TmLsGq[sp] + c * Pminus * R_TmLsGq[sp])
tmp = gpt(b * Pminus * L_TmLsGq[sr] +
c * Pplus * L_TmLsGq[sr] +
b * Pplus * L_TmLsGq[srp] +
c * Pminus * L_TmLsGq[srp])
us_p5d = gpt(psi_left_shift.forward[mu] * tmp)
gp5d = gpt(gpt.gamma[mu] * p5d)
gus_p5d = gpt(gpt.gamma[5] * us_p5d * gpt.gamma[5])
C -= gpt(bpc * gpt.adj(gus_p5d) * (gp5d + p5d))
if s < Ls // 2:
dst += sign * C
else:
dst += C
return dst
