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