def __init__(self, U, params):
covariant_shift.__init__(self, U, params)
Nc = U[0].otype.Nc
otype = g.ot_vector_spin_color(4, Nc)
grid = U[0].grid
if "mass" in params:
assert "kappa" not in params
self.kappa = 1.0 / (params["mass"] + 4.0) / 2.0
else:
self.kappa = params["kappa"]
self.Meooe = g.matrix_operator(lambda dst, src: self._Meooe(dst, src),
otype=otype,
grid=grid)
self.Mooee = g.matrix_operator(lambda dst, src: self._Mooee(dst, src),
otype=otype,
grid=grid)
matrix_operator.__init__(self,
lambda dst, src: self._M(dst, src),
otype=otype,
grid=grid)
self.G5M = g.matrix_operator(lambda dst, src: self._G5M(dst, src),
otype=otype,
grid=grid)
def zmobius(U, params):
params = copy.deepcopy(params) # save current parameters
params["Ls"] = len(params["omega"])
return zmobius_class_operator("zmobius",
U,
params,
otype=gpt.ot_vector_spin_color(4, 3))
def wilson_clover(U, params):
params = copy.deepcopy(params) # save current parameters
if params["kappa"] is not None:
assert params["mass"] is None
params["mass"] = 1.0 / params["kappa"] / 2.0 - 4.0
del params["kappa"]
if params["use_legacy"]:
assert params["boundary_phases"][-1] != 0.0 # only new op supports open bc
if params["boundary_phases"][-1] != 0.0:
assert params["cF"] == 1.0 # forbid usage of cF without open bc
if params["csw_r"] == 0.0 and params["csw_t"] == 0.0:
# for now Grid does not have MooeeDeriv for clover term
operator_class = wilson_class_operator
else:
operator_class = fine_operator
return operator_class(
"wilson_clover", U, params, otype=gpt.ot_vector_spin_color(4, 3)
)
# produces a string without failing
g.message(
f"Test string conversion of expression:\n{g.trace(0.5 * msc * msc - msc)}")
# left and right multiplication of different data types with scalar
mc = g.mcomplex(grid, ntest)
for dti in [cv, cm, vsc, msc, vc, mc]:
rng.cnormal(dti)
eps = g.norm2(mask * dti - dti * mask)
g.message(f"Done with {dti.otype.__name__}")
assert eps == 0.0
# test numpy versus lattice tensor multiplication
for a_type in [
g.ot_matrix_spin_color(4, 3),
g.ot_vector_spin_color(4, 3),
g.ot_matrix_spin(4),
g.ot_vector_spin(4),
g.ot_matrix_color(3),
g.ot_vector_color(3),
]:
# mtab
for e in a_type.mtab:
if a_type.mtab[e][1] is not None:
b_type = g.str_to_otype(e)
a = rng.cnormal(g.lattice(grid, a_type))
b = rng.cnormal(g.lattice(grid, b_type))
mul_lat = g(a * b)[0, 0, 0, 0]
mul_np = a[0, 0, 0, 0] * b[0, 0, 0, 0]
eps2 = g.norm2(mul_lat - mul_np) / g.norm2(mul_lat)
g.message(f"Test {a_type.__name__} * {b_type.__name__}: {eps2}")
# main test loop
for precision in [g.single, g.double]:
grid = g.grid(g.default.get_ivec("--grid", [16, 16, 16, 32], 4), precision)
N = 100
Nwarmup = 5
g.message(
f"""
Inner Product Benchmark with
fdimensions : {grid.fdimensions}
precision : {precision.__name__}
"""
)
# Source and destination
for tp in [g.ot_singlet(), g.ot_vector_spin_color(4, 3), g.ot_vector_singlet(12)]:
for n in [1, 4]:
one = [g.lattice(grid, tp) for i in range(n)]
two = [g.lattice(grid, tp) for i in range(n)]
rng.cnormal([one, two])
# Rank inner product
nbytes = (one[0].global_bytes() + two[0].global_bytes()) * N * n * n
for use_accelerator, compute_name, access in [
(False, "host", access_host),
(True, "accelerator", access_accelerator),
]:
# Time
dt = 0.0
cgpt.timer_begin()
def mobius(U, params):
params = copy.deepcopy(params) # save current parameters
return mobius_class_operator("mobius",
U,
params,
otype=gpt.ot_vector_spin_color(4, 3))
def __init__(self, U, params):
shift_eo.__init__(self, U, boundary_phases=params["boundary_phases"])
Nc = U[0].otype.Nc
otype = g.ot_vector_spin_color(4, Nc)
grid = U[0].grid
grid_eo = grid.checkerboarded(g.redblack)
self.F_grid = grid
self.U_grid = grid
self.F_grid_eo = grid_eo
self.U_grid_eo = grid_eo
self.vector_space_F = g.vector_space.explicit_grid_otype(self.F_grid, otype)
self.vector_space_U = g.vector_space.explicit_grid_otype(self.U_grid, otype)
self.vector_space_F_eo = g.vector_space.explicit_grid_otype(
self.F_grid_eo, otype
)
self.src_e = g.vspincolor(grid_eo)
self.src_o = g.vspincolor(grid_eo)
self.dst_e = g.vspincolor(grid_eo)
self.dst_o = g.vspincolor(grid_eo)
self.dst_e.checkerboard(g.even)
self.dst_o.checkerboard(g.odd)
if params["kappa"] is not None:
assert params["mass"] is None
self.m0 = 1.0 / params["kappa"] / 2.0 - 4.0
else:
self.m0 = params["mass"]
self.xi_0 = params["xi_0"]
self.csw_r = params["csw_r"] / self.xi_0
self.csw_t = params["csw_t"]
self.nu = params["nu"]
self.kappa = 1.0 / (2.0 * (self.m0 + 1.0 + 3.0 * self.nu / self.xi_0))
self.open_bc = params["boundary_phases"][self.nd - 1] == 0.0
if self.open_bc:
assert all(
[
self.xi_0 == 1.0,
self.nu == 1.0,
self.csw_r == self.csw_t,
"cF" in params,
]
) # open bc only for isotropic case, require cF passed
self.cF = params["cF"]
T = self.L[self.nd - 1]
# compute field strength tensor
if self.csw_r != 0.0 or self.csw_t != 0.0:
self.clover = g.mspincolor(grid)
self.clover[:] = 0
I = g.identity(self.clover)
for mu in range(self.nd):
for nu in range(mu + 1, self.nd):
if mu == (self.nd - 1) or nu == (self.nd - 1):
cp = self.csw_t
else:
cp = self.csw_r
self.clover += (
-0.5
* cp
* g.gamma[mu, nu]
* I
* g.qcd.gauge.field_strength(U, mu, nu)
)
if self.open_bc:
# set field strength tensor to unity at the temporal boundaries
value = -0.5 * self.csw_t
self.clover[:, :, :, 0, :, :, :, :] = 0.0
self.clover[:, :, :, T - 1, :, :, :, :] = 0.0
for alpha in range(4):
for a in range(Nc):
self.clover[:, :, :, 0, alpha, alpha, a, a] = value
self.clover[:, :, :, T - 1, alpha, alpha, a, a] = value
if self.cF != 1.0:
# add improvement coefficients next to temporal boundaries
value = self.cF - 1.0
for alpha in range(4):
for a in range(Nc):
self.clover[:, :, :, 1, alpha, alpha, a, a] += value
self.clover[:, :, :, T - 2, alpha, alpha, a, a] += value
# integrate kappa into clover matrix for inversion
self.clover += 1.0 / 2.0 * 1.0 / self.kappa * I
self.clover_inv = g.matrix.inv(self.clover)
self.clover_eo = {
g.even: g.lattice(grid_eo, self.clover.otype),
g.odd: g.lattice(grid_eo, self.clover.otype),
}
self.clover_inv_eo = {
g.even: g.lattice(grid_eo, self.clover.otype),
g.odd: g.lattice(grid_eo, self.clover.otype),
}
for cb in self.clover_eo:
g.pick_checkerboard(cb, self.clover_eo[cb], self.clover)
g.pick_checkerboard(cb, self.clover_inv_eo[cb], self.clover_inv)
else:
self.clover = None
self.clover_inv = None
self.Meooe = g.matrix_operator(
mat=lambda dst, src: self._Meooe(dst, src),
vector_space=self.vector_space_F_eo,
)
self.Mooee = g.matrix_operator(
mat=lambda dst, src: self._Mooee(dst, src),
inv_mat=lambda dst, src: self._MooeeInv(dst, src),
vector_space=self.vector_space_F_eo,
)
self.Dhop = g.matrix_operator(
mat=lambda dst, src: self._Dhop(dst, src), vector_space=self.vector_space_F
)
matrix_operator.__init__(
self, lambda dst, src: self._M(dst, src), vector_space=self.vector_space_F
)
self.G5M = g.matrix_operator(
lambda dst, src: self._G5M(dst, src), vector_space=self.vector_space_F
)
self.Mdiag = g.matrix_operator(
lambda dst, src: self._Mdiag(dst, src), vector_space=self.vector_space_F
)
self.ImportPhysicalFermionSource = g.matrix_operator(
lambda dst, src: g.copy(dst, src), vector_space=self.vector_space_F
)
self.ExportPhysicalFermionSolution = g.matrix_operator(
lambda dst, src: g.copy(dst, src), vector_space=self.vector_space_F
)
self.ExportPhysicalFermionSource = g.matrix_operator(
lambda dst, src: g.copy(dst, src), vector_space=self.vector_space_F
)
self.Dminus = g.matrix_operator(
lambda dst, src: g.copy(dst, src), vector_space=self.vector_space_F
)
# main test loop
for precision in [g.single, g.double]:
grid = g.grid(g.default.get_ivec("--grid", [16, 16, 16, 32], 4), precision)
N = 100
Nwarmup = 5
g.message(
f"""
Benchmark linear combination
fdimensions : {grid.fdimensions}
precision : {precision.__name__}
"""
)
# Source and destination
for tp in [g.ot_matrix_color(3), g.ot_matrix_spin(4), g.ot_vector_spin_color(4, 3)]:
for nbasis in [4, 8, 16]:
basis = [g.lattice(grid, tp) for i in range(nbasis)]
result = g.lattice(grid, tp)
rng.cnormal(basis)
# Typical usecase: nbasis -> 1
Qt = np.ones((1, nbasis), np.complex128)
# Bytes
nbytes = (nbasis + 1) * result.global_bytes() * N
# Time
dt = 0.0
for it in range(N + Nwarmup):
if it >= Nwarmup:
