def gradient(self, Uprime, dUprime):
assert dUprime == Uprime
R = g.group.cartesian(Uprime)
for r, x in zip(
R + R, mat_pg(dst_p, src_p) + mat_pg.adj()(src_p, dst_p)
):
g.set_checkerboard(
r, g.qcd.gauge.project.traceless_hermitian(x)
)
return R
def _Mdiag(self, dst, src):
assert dst != src
g.pick_checkerboard(g.even, self.src_e, src)
g.pick_checkerboard(g.odd, self.src_o, src)
self.dst_o @= self.Mooee * self.src_o
self.dst_e @= self.Mooee * self.src_e
g.set_checkerboard(dst, self.dst_o)
g.set_checkerboard(dst, self.dst_e)
def draw(self, fields, rng):
U = fields[0:-1]
phi = fields[-1]
phi_o = g.lattice(self.M.F_grid_eo, phi.otype)
g.pick_checkerboard(g.odd, phi_o, phi)
act_o = self.two_flavor_evenodd_schur.draw(U + [phi_o], rng)
phi[:] = 0
g.set_checkerboard(phi, phi_o)
return act_o
def _M(self, dst, src):
assert dst != src
g.pick_checkerboard(g.even, self.src_e, src)
g.pick_checkerboard(g.odd, self.src_o, src)
self.dst_o @= self.Meooe * self.src_e + self.Mooee * self.src_o
self.dst_e @= self.Meooe * self.src_o + self.Mooee * self.src_e
g.set_checkerboard(dst, self.dst_o)
g.set_checkerboard(dst, self.dst_e)
self.apply_boundaries(dst)
def operator(left, right):
op.Meooe.mat(tmp[0], right)
op.Mooee.inv_mat(tmp[1], tmp[0])
frc_o = op.Meooe_projected_gradient(left, tmp[1])
op.Meooe.adj_mat(tmp[0], left)
op.Mooee.adj_inv_mat(tmp[1], tmp[0])
frc_e = op.Meooe_projected_gradient(tmp[1], right)
frc = g.group.cartesian(op.U)
for mu in range(len(frc)):
g.set_checkerboard(frc[mu], frc_o[mu])
g.set_checkerboard(frc[mu], frc_e[mu])
frc[mu] *= -1.0
return frc
def verify_projected_even_odd(M, Meo, dst_p, src_p, src):
src_proj_p = g.lattice(src)
src_proj_p[:] = 0
g.set_checkerboard(src_proj_p, src_p)
dst_proj_p = g.eval(M * src_proj_p)
g.pick_checkerboard(dst_p.checkerboard(), dst_p, dst_proj_p)
reference = g.copy(dst_p)
dst_p @= Meo * src_p
eps = (g.norm2(dst_p - reference) / g.norm2(reference)) ** 0.5
eps_ref = src.grid.precision.eps * finger_print_tolerance
g.message(f"Test projected full matrix result versus eo matrix: {eps}")
assert eps < eps_ref
def export_parity(self, o):
gpt.set_checkerboard(o, self.out_p)
gpt.set_checkerboard(o, self.out_np)
def promote(self, dst, src):
gpt.set_checkerboard(dst, src)
vec_half(),
vec_half(),
vec_half(),
vec_half(),
vec_half(),
vec_half(),
)
rng.cnormal(src)
g.pick_checkerboard(g.even, src_e, src)
g.pick_checkerboard(g.odd, src_o, src)
# Meo + Moe = Dhop
mat.Dhop.mat(ref, src)
mat.Meooe.mat(res_o, src_e)
mat.Meooe.mat(res_e, src_o)
g.set_checkerboard(res, res_e)
g.set_checkerboard(res, res_o)
rel_dev = g.norm2(ref - res) / g.norm2(ref)
g.message(f"""
Test: Meo + Moe = Dhop
src = {g.norm2(src)}
ref = {g.norm2(ref)}
res = {g.norm2(res)}
rel. dev. = {rel_dev} -> test {'passed' if rel_dev <= 1e-15 else 'failed'}"""
)
assert rel_dev <= 1e-15
# Meo^dag + Moe^dag = Dhop^dag
mat.Dhop.adj_mat(ref, src)
mat.Meooe.adj_mat(res_o, src_e)
mat.Meooe.adj_mat(res_e, src_o)
# full mask
mask = g.complex(grid)
# simple plaquette action
def staple(U, mu):
st = g.lattice(U[0])
st[:] = 0
for nu in range(len(U)):
if mu != nu:
st += g.qcd.gauge.staple(U, mu, nu)
return st
# 5 heatbath sweeps
beta = 1.1
g.default.push_verbose("u1_heat_bath", False)
markov = g.algorithms.markov.u1_heat_bath(rng)
for it in range(5):
plaq = g.qcd.gauge.plaquette(U)
g.message(f"U(1) heatbath {it} has P = {plaq}")
for cb in [g.even, g.odd]:
mask[:] = 0
mask_rb.checkerboard(cb)
g.set_checkerboard(mask, mask_rb)
for mu in range(len(U)):
st = g.eval(beta * staple(U, mu))
markov(U[mu], st, mask)
assert abs(plaq - 0.7133781214555105) < 1e-6
g.repository.load(f"{work_dir}/{f}", f"gpt://tests/qcd/openqcd_dslash/{f}")
# load fields from files
U = g.load(f"{work_dir}/gauge.bc_{bc}.bin")
src = read_openqcd_fermion(f"{work_dir}/src.bc_{bc}.bin")
dst_oqcd_M = read_openqcd_fermion(f"{work_dir}/dst_Dw_dble.bc_{bc}.bin")
dst_oqcd_Moo = read_openqcd_fermion(f"{work_dir}/dst_Dwoo_dble.bc_{bc}.bin", g.odd)
dst_oqcd_Mee = read_openqcd_fermion(f"{work_dir}/dst_Dwee_dble.bc_{bc}.bin", g.even)
dst_oqcd_Moe = read_openqcd_fermion(f"{work_dir}/dst_Dwoe_dble.bc_{bc}.bin", g.odd)
dst_oqcd_Meo = read_openqcd_fermion(f"{work_dir}/dst_Dweo_dble.bc_{bc}.bin", g.even)
dst_oqcd_Mdag = read_openqcd_fermion(f"{work_dir}/dst_Dwdag_dble.bc_{bc}.bin")
# construct methods of our dirac operators from the read in fields
dst_oqcd_Dhop = g.lattice(dst_oqcd_M)
dst_oqcd_Mdiag = g.lattice(dst_oqcd_M)
g.set_checkerboard(dst_oqcd_Dhop, dst_oqcd_Moe)
g.set_checkerboard(dst_oqcd_Dhop, dst_oqcd_Meo)
g.set_checkerboard(dst_oqcd_Mdiag, dst_oqcd_Mee)
g.set_checkerboard(dst_oqcd_Mdiag, dst_oqcd_Moo)
# create fermion operators
wc_ref = g.qcd.fermion.reference.wilson_clover(U, wc_params)
wc_fast = g.qcd.fermion.wilson_clover(U, wc_params)
# src fields on half grids
src_e, src_o = g.vspincolor(wc_fast.F_grid_eo), g.vspincolor(wc_fast.F_grid_eo)
g.pick_checkerboard(g.even, src_e, src)
g.pick_checkerboard(g.odd, src_o, src)
# create list of test cases
tests = {}
