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()