def perform(self, root):
global basis_size, sloppy_per_job, T, current_config
if current_config is not None and current_config.conf_file != self.conf_file:
current_config = None
if current_config is None:
current_config = config(self.conf_file)
output_correlator = g.corr_io.writer(f"{root}/{self.name}/head.dat")
# <np,sp| D^{-1} Gamma D^{-1} |n,s> = < (D^{-1})^\dagger |np,sp> | Gamma | D^{-1} |n,s > >
# = < Gamma5 D^{-1} Gamma5 |np,sp> | Gamma | D^{-1} |n,s > >
# = < D^{-1} |np,sp> | Gamma5 Gamma | D^{-1} |n,s > > gamma5_sign[sp]
gamma5_sign = [1.0, 1.0, -1.0, -1.0]
indices = [0, 1, 2, 5]
prec = {"sloppy": 0, "exact": 1}[self.solver]
for i0 in range(0, basis_size, sloppy_per_job):
half_peramb_i = {}
for l in g.load(
f"{root}/{self.conf}/pm_{self.solver}_t{self.t}_i{i0}/propagators"
):
for x in l:
half_peramb_i[x] = l[x]
for j0 in range(0, basis_size, sloppy_per_job):
if j0 == i0:
half_peramb_j = half_peramb_i
else:
half_peramb_j = {}
for l in g.load(
f"{root}/{self.conf}/pm_{self.solver}_t{self.t}_i{j0}/propagators"
):
for x in l:
half_peramb_j[x] = l[x]
for i in range(i0, i0 + sloppy_per_job):
for spin in range(4):
g.message(i, spin)
hp_i = half_peramb_i[
f"t{self.t}s{spin}c{i}_{self.solver}"]
for mu in indices:
hp_i_gamma = g(g.gamma[5] * g.gamma[mu] * hp_i)
for spin_prime in range(4):
slc_j = [
g(gamma5_sign[spin_prime] *
g.adj(half_peramb_j[
f"t{self.t}s{spin_prime}c{j}_{self.solver}"]
) * hp_i_gamma)
for j in range(j0, j0 + sloppy_per_job)
]
slc = g.slice(slc_j, 3)
for j in range(j0, j0 + sloppy_per_job):
output_correlator.write(
f"output/G{mu}_prec{prec}/n_{j}_{i}_s_{spin_prime}_{spin}_t_{self.t}",
slc[j - j0],
)
output_correlator.close()
def correlate_test_3d(a, b, x):
# c[x] = (1/vol) sum_y a[y]*b[y+x]
bprime = b
L = a.grid.gdimensions
vol = L[0] * L[1] * L[2]
for i in range(3):
# see core test: dst = g.cshift(src, 0, 1) -> dst[x] = src[x+1]
bprime = g.cshift(bprime, i, x[i]) # bprime[y] = b[y+x]
return g.slice(a * bprime, 3)[x[3]] / vol
def fft_baryon(baryon_list, contracted_baryon, integer_momenta,
source_position):
lattice_momenta = np.zeros((integer_momenta.shape[0], 4), dtype=np.float64)
lattice_momenta[:, :3] = integer_momenta * 2 * np.pi / L
for ii, momentum in enumerate(lattice_momenta):
phase = g.exp_ixp(-1 * momentum)
source_phase = np.exp(1.0j * np.dot(momentum[:3], source_position[:3]))
baryon_list.append(
np.array(g.slice(phase * contracted_baryon, 3)[:]) * source_phase)
def perform(self, root):
global basis_size, T
output_correlator = g.corr_io.writer(f"{root}/{self.name}/head.dat")
vcj = g.load(f"{root}/{self.conf}/pm_basis/basis")
for m in self.mom:
mom_str = "_".join([str(x) for x in m])
p = np.array([
2.0 * np.pi / vcj[0].grid.gdimensions[i] * m[i]
for i in range(3)
] + [0])
phase = g.complex(vcj[0].grid)
phase[:] = 1
phase @= g.exp_ixp(p) * phase
g.message("L = ", vcj[0].grid.gdimensions)
g.message("Momentum", p, m)
for n in range(basis_size):
t0 = g.time()
vc_n = g(phase * vcj[n])
t1 = g.time()
slc_nprime = [
g(g.adj(vcj[nprime]) * vc_n)
for nprime in range(basis_size)
]
t2 = g.time()
slc = g.slice(slc_nprime, 3)
t3 = g.time()
for nprime in range(basis_size):
output_correlator.write(
f"output/mom/{mom_str}_n_{nprime}_{n}", slc[nprime])
t4 = g.time()
if n % 10 == 0:
g.message(n, "Timing", t1 - t0, t2 - t1, t3 - t2, t4 - t3)
output_correlator.close()
def contract(pos, prop, tag, may_save_prop=True):
t0 = pos[3]
prop_tag = "%s/%s" % (tag, str(pos))
# save propagators
if params["save_propagators"] and may_save_prop:
output.write({prop_tag: prop})
output.flush()
# create and save correlators
for op_snk, op_src in correlators:
G_snk = operators[op_snk]
G_src = operators[op_src]
corr = g.slice(g.trace(G_src * g.gamma[5] * g.adj(prop) * g.gamma[5] * G_snk * prop), 3)
corr = corr[t0:] + corr[:t0]
corr_tag = "%s/snk%s-src%s" % (prop_tag, op_snk, op_src)
output_correlator.write(corr_tag, corr)
g.message("Correlator %s\n" % corr_tag, corr)
if "WORK_DIR" in os.environ:
work_dir = os.environ["WORK_DIR"]
else:
work_dir = "."
# request test files
files = ["psrc-prop-0.field", "pion-corr.txt"]
for f in files:
gpt.repository.load(f"{work_dir}/{f}", f"gpt://tests/io/qlat/{f}")
# load field
prop = gpt.load(f"{work_dir}/psrc-prop-0.field")
gpt.message("Grid from qlat propagator =", prop.grid)
# calculate correlator
corr_pion = gpt.slice(gpt.trace(gpt.adj(prop) * prop), 3)
# load reference
with open(f"{work_dir}/pion-corr.txt", "r") as f:
txt = f.readlines()
# read lines corresponding to real part of time slices and
# check difference w.r.t. what we have loaded above
for i in range(8):
ref = float(txt[1 + i * 2].split(" ")[-1][:-1])
diff = abs(ref - corr_pion[i].real)
assert diff < 1e-7 # propagator was computed in single precision
gpt.message("Time slice %d difference %g" % (i, diff))
gpt.message("Test successful")
def perform(self, root):
global basis_size, sloppy_per_job, T, current_config
if current_config is not None and current_config.conf_file != self.conf_file:
current_config = None
if current_config is None:
current_config = config(self.conf_file)
output_correlator = g.corr_io.writer(f"{root}/{self.name}/head.dat")
# <np,sp| D^{-1} Gamma D^{-1} |n,s> = < (D^{-1})^\dagger |np,sp> | Gamma | D^{-1} |n,s > >
# = < Gamma5 D^{-1} Gamma5 |np,sp> | Gamma | D^{-1} |n,s > >
# = < D^{-1} |np,sp> | Gamma5 Gamma | D^{-1} |n,s > > gamma5_sign[sp]
indices = [0, 1, 2, 5]
prec = {"sloppy": 0, "exact": 1}[self.solver]
half_peramb = g.load(
f"{root}/{self.conf}/pm_compressed_half_peramb_{self.solver}_t{self.t}/propagators"
)
sdomain = half_peramb["sparse_domain"]
scale = (sdomain.grid.gsites / sdomain.grid.Nprocessors /
len(sdomain.local_coordinates))
g.message("scale =", scale)
gamma5_sign = [1.0 * scale, 1.0 * scale, -1.0 * scale, -1.0 * scale]
for i0 in range(0, basis_size, sloppy_per_job):
half_peramb_i = {}
for i in range(i0, i0 + sloppy_per_job):
for spin in range(4):
f = g.vspincolor(sdomain.grid)
f[:] = 0
sdomain.promote(
f, half_peramb[f"t{self.t}s{spin}c{i}_{self.solver}"])
half_peramb_i[f"t{self.t}s{spin}c{i}_{self.solver}"] = f
for j0 in range(0, basis_size, sloppy_per_job):
if j0 == i0:
half_peramb_j = half_peramb_i
else:
half_peramb_j = {}
for j in range(j0, j0 + sloppy_per_job):
for spin in range(4):
f = g.vspincolor(sdomain.grid)
f[:] = 0
sdomain.promote(
f, half_peramb[
f"t{self.t}s{spin}c{j}_{self.solver}"])
half_peramb_j[
f"t{self.t}s{spin}c{j}_{self.solver}"] = f
for i in range(i0, i0 + sloppy_per_job):
for spin in range(4):
g.message(i, spin)
hp_i = g(sdomain.weight() * half_peramb_i[
f"t{self.t}s{spin}c{i}_{self.solver}"])
for mu in indices:
hp_i_gamma = g(g.gamma[5] * g.gamma[mu] * hp_i)
for spin_prime in range(4):
slc_j = [
g(gamma5_sign[spin_prime] *
g.adj(half_peramb_j[
f"t{self.t}s{spin_prime}c{j}_{self.solver}"]
) * hp_i_gamma)
for j in range(j0, j0 + sloppy_per_job)
]
slc = g.slice(slc_j, 3)
for j in range(j0, j0 + sloppy_per_job):
output_correlator.write(
f"output/G{mu}_prec{prec}/n_{j}_{i}_s_{spin_prime}_{spin}_t_{self.t}",
slc[j - j0],
)
output_correlator.close()
def sanity_check(dst, measurement):
g.message(f"sanity check {measurement}")
correlator = g.slice(g.eval(g.trace(g.adj(dst) * dst)), 3)
for t, c in enumerate(correlator):
g.message(t, c)
eps2 = g.norm2(w * dst_eo1 - src) / g.norm2(src)
g.message("Result of M M^-1 = 1 test: eps2=", eps2)
assert eps2 < 1e-10
# and a reference
if True:
dst = g.mspincolor(grid)
dst @= slv * src
eps2 = g.norm2(dst_eo1 - dst) / g.norm2(dst_eo1)
g.message("Result of test EO1 versus G5M: eps2=", eps2)
assert eps2 < 1e-10
dst = dst_eo2
# two-point
correlator = g.slice(g.trace(dst * g.adj(dst)), 3)
# test value of correlator
correlator_ref = [
1.0710210800170898,
0.08988216519355774,
0.015699388459324837,
0.003721018321812153,
0.0010877142194658518,
0.0003579717595130205,
0.00012700144725386053,
5.180457083042711e-05,
3.406393443583511e-05,
5.2738148951902986e-05,
0.0001297977869398892,
0.0003634534077718854,
# propagator
dst = g.mspincolor(grid)
dst @= propagator * src
# momentum
p = 2.0 * np.pi * np.array([1, 0, 0, 0]) / L
P = g.exp_ixp(p)
# operators
G_src = g.gamma[5] * P
G_snk = g.gamma[5] * g.adj(P)
G_op = g.gamma["T"]
# 2pt
correlator_2pt = g.slice(
g.trace(G_src * g.gamma[5] * g.adj(dst) * g.gamma[5] * G_snk * dst), 3)
# sequential solve through t=8
t_op = 8
src_seq = g.lattice(src)
src_seq[:] = 0
src_seq[:, :, :, t_op] = dst[:, :, :, t_op]
# create seq prop with gamma_T operator
dst_seq = g.lattice(src_seq)
src_seq @= G_op * src_seq
dst_seq @= propagator * src_seq
# 3pt
correlator_3pt = g.slice(
g.trace(G_src * g.gamma[5] * g.adj(dst_seq) * g.gamma[5] * G_snk *
# qm.bulk_propagator_to_propagator * qm.bulk_propagator(slv) == qm.propagator(slv)
dst_qm_bulk = g(slv_qm_bulk.grouped(3) * src)
dst_qm @= qm.bulk_propagator_to_propagator * dst_qm_bulk
dst_qz @= slv_qz * src
dst_qz_kappa @= slv_qz_kappa * src
# test similarity transformated solve
eps2 = g.norm2(dst_qz - dst_qz_kappa) / g.norm2(dst_qz)
g.message(f"Kappa similarity transformed solve: {eps2}")
assert eps2 < 1e-6
assert len(cg.history) > len(cg_kappa.history)
# calculate J5q
p = qm.J5q(dst_qm_bulk)
J5q = g.slice(g.trace(p * g.adj(p)), 3)
J5q_ref = [
1.3814802514389157e-05,
8.530755621904973e-06,
7.805140739947092e-06,
5.135065748618217e-06,
5.082366897113388e-06,
4.842216185352299e-06,
7.341488071688218e-06,
7.706037649768405e-06,
]
eps = np.linalg.norm(np.array(J5q) - np.array(J5q_ref))
g.message(f"J5q test: {eps}")
assert eps < 1e-5
for lattice_object in [
g.complex(grid_dp),
g.vcomplex(grid_dp, 10),
g.vspin(grid_dp),
g.vcolor(grid_dp),
g.vspincolor(grid_dp),
g.mspin(grid_dp),
g.mcolor(grid_dp),
g.mspincolor(grid_dp),
]:
g.message(f"Testing slice with random {lattice_object.describe()}")
obj_list = [g.copy(lattice_object) for _ in range(3)]
rng.cnormal(obj_list)
for dimension in range(4):
tmp = g.slice(obj_list, dimension)
full_sliced = np.array([[g.util.tensor_to_value(v) for v in obj]
for obj in tmp])
for n, obj in enumerate(obj_list):
tmp = g.slice(obj, dimension)
sliced = np.array([g.util.tensor_to_value(v) for v in tmp])
assert np.allclose(full_sliced[n], sliced, atol=0.0, rtol=1e-13)
sliced_numpy = np.array([
np.sum(
obj[slice(0, L[0]) if dimension != 0 else x,
slice(0, L[1]) if dimension != 1 else x,
slice(0, L[2]) if dimension != 2 else x,
slice(0, L[3]) if dimension != 3 else x, ],
axis=0,
for pol in pols:
g.message(pol)
# sequential source
tmp_seq_src = g.qcd.sequential_source.nucleon3pt_seq_src.p2p_ubaru(
dst, pols[pol], Cg5, t_sink)
for snk_mom_n, snk_mom in enumerate(sink_mom):
g.message(sink_moms_list[snk_mom_n])
P = g.exp_ixp(snk_mom)
seq_src = g.lattice(src)
seq_src[:] = tmp_seq_src[:]
seq_src @= P * seq_src
sanity_corr = g.slice(g.trace(g.adj(seq_src) * seq_src), 3)
g.message("Sequential Source Correlator")
for t, c in enumerate(sanity_corr):
g.message(t, c)
# Sequential propagator
seq_prop = g.lattice(src)
seq_prop @= slv_eo2 * seq_src
sanity_corr = g.slice(g.trace(g.adj(seq_prop) * seq_prop), 3)
g.message("Sequential Propagator Correlator")
for t, c in enumerate(sanity_corr):
g.message(t, c)
for q_n, q in enumerate(q_mom):
g.message(q_list[q_n])
dst @= slv_eo2 * src
propagators = [dst, g.eval(g.gamma[5] * g.adj(dst) * g.gamma[5])]
for l, prop in enumerate(propagators):
contraction_routines = [
qC.quark_contract_12(prop, prop),
qC.quark_contract_13(prop, prop),
qC.quark_contract_14(prop, prop),
qC.quark_contract_23(prop, prop),
qC.quark_contract_24(prop, prop),
qC.quark_contract_34(prop, prop)
]
for m, di_quark in enumerate(contraction_routines):
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)))
#!/usr/bin/env python3
#
# Authors: Christoph Lehner 2020
#
# Desc.: Pion and vector propagator from a point source at the origin
#
import gpt as g
# load gauge field and describe fermion
gauge = g.qcd.gaugefield("params.txt")
light = g.qcd.fermion("light.txt")
# create point source
src = g.qcd.propagator(gauge.dp.grid)
g.create.point(src, [0, 0, 0, 0])
# solve
prop = light.solve.exact(src)
# pion
corr_pion = g.slice(g.adj(prop) * prop, 3)
print("Pion two point:")
print(corr_pion)
# vector
gamma = g.qcd.gamma
corr_vector = g.slice(gamma[0] * g.adj(prop) * gamma[0] * prop, 3)
print("Vector two point:")
print(corr_vector)
g.message("Momentum adj test (2): ", eps)
assert eps < 1e-20
################################################################################
# Test FFT
################################################################################
fft_l_sp = g.eval(g.fft() * l_sp)
eps = g.norm2(g.adj(g.fft()) * fft_l_sp - l_sp) / g.norm2(l_sp)
g.message("FFTinv * FFT:", eps)
assert eps < 1e-12
eps = g.norm2(g.sum(exp_ixp * l_sp) / np.prod(L) - fft_l_sp[1, 2, 3, 4])
g.message("FFT forward test:", eps)
assert eps < 1e-12
fft_mom_A = g.slice(
g.exp_ixp(2.0 * np.pi * np.array([1, 2, 3, 0]) / L) * l_sp, 3) / np.prod(
L[0:3])
fft_mom_B = [
g.vcolor(x) for x in g.eval(g.fft([0, 1, 2]) * l_sp)[1, 2, 3, 0:L[3]]
]
for t in range(L[3]):
eps = g.norm2(fft_mom_A[t] - fft_mom_B[t])
assert eps < 1e-12
################################################################################
# Test vcomplex
################################################################################
va = g.vcomplex(grid_sp, 30)
vb = g.lattice(va)
va[:] = g.vcomplex([1] * 15 + [0.5] * 15, 30)
vb[:] = g.vcomplex([0.5] * 5 + [1.0] * 20 + [0.2] * 5, 30)
dst_madwf_dc_sc = g(slv_madwf_dc * src_sc)
eps2 = g.norm2(dst_madwf_dc_sc - dst_dwf_sc) / g.norm2(dst_dwf_sc)
g.message(f"MADWF defect_correcting test: {eps2}")
assert eps2 < 1e-10
# propagator
dst_qm = g.mspincolor(grid)
dst_qz = g.mspincolor(grid)
dst_qm @= slv_qm * src
dst_qz @= slv_qz * src
# two-point
correlator_qm = g.slice(
g.trace(g.gamma[0] * g.gamma[0] * dst_qm * g.gamma[0] * g.gamma[0] *
g.adj(dst_qm)),
3,
)
correlator_qz = g.slice(g.trace(dst_qz * g.adj(dst_qz)), 3)
correlator_ref = [
0.4873415231704712,
0.14763720333576202,
0.021136583760380745,
0.007964665070176125,
0.005833963863551617,
0.00796868372708559,
0.021054629236459732,
0.14703410863876343,
]
# output
dst_qm = g.mspincolor(grid)
dst_qz = g.mspincolor(grid)
dst_qm @= slv_qm * src
dst_qz @= slv_qz * src
# test madwf
src_sc = rng.cnormal(g.vspincolor(grid))
dst_madwf_sc = g(slv_madwf * src_sc)
dst_dwf_sc = g(slv_qm * src_sc)
eps2 = g.norm2(dst_madwf_sc - dst_dwf_sc) / g.norm2(dst_dwf_sc)
g.message(f"MADWF test: {eps2}")
assert eps2 < 5e-4
# two-point
correlator_qm = g.slice(g.trace(dst_qm * g.adj(dst_qm)), 3)
correlator_qz = g.slice(g.trace(dst_qz * g.adj(dst_qz)), 3)
correlator_ref = [
0.4873415231704712,
0.14763720333576202,
0.021136583760380745,
0.007964665070176125,
0.005833963863551617,
0.00796868372708559,
0.021054629236459732,
0.14703410863876343,
]
# output
eps_qm = 0.0
eps_qz = 0.0
def perform(self, root):
global basis_size, sloppy_per_job, T, current_config
if current_config is not None and current_config.conf_file != self.conf_file:
current_config = None
if current_config is None:
current_config = config(self.conf_file)
output_correlator = g.corr_io.writer(f"{root}/{self.name}/head.dat")
vcj = g.load(f"{root}/{self.conf}/pm_basis/basis")
for i0 in range(0, basis_size, sloppy_per_job):
half_peramb = {}
for l in g.load(
f"{root}/{self.conf}/pm_{self.solver}_t{self.t}_i{i0}/propagators"
):
for x in l:
half_peramb[x] = l[x]
g.mem_report(details=False)
vc = g.vcolor(vcj[0].grid)
c = g.coordinates(vc)
prec = {"sloppy": 0, "exact": 1}[self.solver]
for spin_prime in range(4):
plan = None
for spin in range(4):
for i in range(i0, i0 + sloppy_per_job):
hp = half_peramb[f"t{self.t}s{spin}c{i}_{self.solver}"]
if plan is None:
plan = g.copy_plan(vc, hp)
plan.destination += vc.view[c]
plan.source += hp.view[c, spin_prime, :]
plan = plan()
plan(vc, hp)
t0 = g.time()
slc_j = [
g(g.adj(vcj[j]) * vc) for j in range(basis_size)
]
t1 = g.time()
slc = g.slice(slc_j, 3)
t2 = g.time()
for j in range(basis_size):
output_correlator.write(
f"output/peramb_prec{prec}/n_{j}_{i}_s_{spin_prime}_{spin}_t_{self.t}",
slc[j],
)
t3 = g.time()
if i % 50 == 0:
g.message(spin_prime, spin, i, "Timing", t1 - t0,
t2 - t1, t3 - t2)
output_correlator.close()
