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()
theta = 0.91231 quark0 = g.qcd.fermion.mobius( U_unit, Ls=8, mass=0.1, b=1, c=0, M5=1.8, boundary_phases=[np.exp(1j * theta), 1, 1, 1], ) q0prop = quark0.propagator( inv.preconditioned(pc.eo2_ne(), inv.cg(eps=1e-7, maxiter=1000))) src = g.vspincolor(U_unit[0].grid) src[:] = 0 src[:, :, :, 0, 0, 0] = 1 prop = g(q0prop * g.exp_ixp(np.array([theta / L[0], 0, 0, 0])) * src) prop_1000_over_0000 = complex(prop[1, 0, 0, 2, 0, 0]) / complex(prop[0, 0, 0, 2, 0, 0]) eps = abs(prop_1000_over_0000) - 1 g.message(f"Twisted boundary covariance is a phase: {eps}") assert eps < 1e-6 eps = abs(prop_1000_over_0000 - np.exp(1j * theta / L[0])) g.message(f"Twisted boundary covariance as expected momentum: {eps}") assert eps < 1e-6 # test instantiation of other actions rhq = g.qcd.fermion.rhq_columbia(U, mass=4.0, cp=3.0, zeta=2.5, boundary_phases=[1, 1, 1, -1])
src = g.mspincolor(grid) rng.cnormal(src) dst1 = g(V * smear * src) dst2 = g(smear_transformed * V * src) eps2 = g.norm2(dst1 - dst2) / g.norm2(dst1) g.message(f"Covariance test: {eps2}") assert eps2 < 1e-29 # Test smearing operator on point source over unit gauge field for dimensions in [[0, 1, 2], [0, 1, 2, 3]]: for sigma, steps in [(0.5, 3), (0.16, 2)]: smear_unit = g.create.smear.gauss(U_unit, sigma=sigma, steps=steps, dimensions=dimensions) src = g.vcolor(grid) src[:] = g.vcolor([1, 0, 0]) # anti-periodic boundary conditions in time mean space and time are # differently quantized p = 2.0 * np.pi * np.array([1, 2, 3, 4.5]) / L src_mom = g(g.exp_ixp(p) * src) laplace = sum([2.0 * (np.cos(p[i]) - 1.0) for i in dimensions]) factor = (1.0 + laplace * sigma**2.0 / steps / 4.0)**steps dst = g(smear_unit * src_mom) eps2 = g.norm2(dst - factor * src_mom) / g.norm2(dst) g.message(f"Gaussian test using eigen representation: {eps2}") assert eps2 < 1e-29
def assign_pos_view(): lhs[pos] = l_dp.view[pos] for method in [assign_copy, assign_pos, assign_pos_view]: lhs[:] = 0 method() eps2 = g.norm2(lhs - l_dp) / g.norm2(l_dp) assert eps2 < 1e-25 ################################################################################ # Test exp_ixp ################################################################################ # multiply momentum phase in l p = 2.0 * np.pi * np.array([1, 2, 3, 4]) / L exp_ixp = g.exp_ixp(p) # Test one component xc = (2, 3, 1, 5) x = np.array(list(xc)) ref = np.exp(1j * np.dot(p, x)) * l_dp[xc] val = g.eval(exp_ixp * l_dp)[xc] eps = g.norm2(ref - val) g.message("Reference value test: ", eps) assert eps < 1e-25 # single/double eps = g.norm2(exp_ixp * l_sp - g.convert(exp_ixp * l_dp, g.single)) / g.norm2(l_sp) g.message("Momentum phase test single/double: ", eps)
# even-odd preconditioned matrix eo = g.qcd.fermion.preconditioner.eo2(w) # build solver s = g.qcd.fermion.solver cg = g.algorithms.iterative.cg({"eps": 1e-6, "maxiter": 1000}) propagator = s.propagator(s.inv_eo_ne(eo, cg)) # 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]
assert info_index["blocks"] == 1 plan(lhs, l_dp) for method in [assign_copy, assign_pos, assign_pos_view]: lhs[:] = 0 method() eps2 = g.norm2(lhs - l_dp) / g.norm2(l_dp) assert eps2 < 1e-25 ################################################################################ # Test exp_ixp ################################################################################ # multiply momentum phase in l p = 2.0 * np.pi * np.array([1, 2, 3, 4]) / L exp_ixp = g.exp_ixp(p) # Test one component xc = (2, 3, 1, 5) x = np.array(list(xc)) ref = np.exp(1j * np.dot(p, x)) * l_dp[xc] val = g.eval(exp_ixp * l_dp)[xc] eps = g.norm2(ref - val) g.message("Reference value test: ", eps) assert eps < 1e-25 # single/double eps = g.norm2(exp_ixp * l_sp - g.convert(exp_ixp * l_dp, g.single)) / g.norm2(l_sp) g.message("Momentum phase test single/double: ", eps)
sink_mom = 2.0 * np.pi * np.array( ([-1, 0, 0, 0], [0, 0, 0, 0]), dtype=float) / L sink_moms_list = ["sink_mom_-100", "sink_mom_000"] t_sink = 31 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)