コード例 #1
0
ファイル: baryon.py プロジェクト: lehner/gpt
def diquark(Q1, Q2):
    eps = g.epsilon(Q1.otype.shape[2])
    R = g.lattice(Q1)

    # D_{a2,a1} = epsilon_{a1,b1,c1}*epsilon_{a2,b2,c2}*spin_transpose(Q1_{b1,b2})*Q2_{c1,c2}
    Q1 = g.separate_color(Q1)
    Q2 = g.separate_color(Q2)

    D = {x: g.lattice(Q1[x]) for x in Q1}
    for d in D:
        D[d][:] = 0

    for i1, sign1 in eps:
        for i2, sign2 in eps:
            D[i2[0], i1[0]] += (sign1 * sign2 * Q1[i1[1], i2[1]] *
                                g.transpose(Q2[i1[2], i2[2]]))

    g.merge_color(R, D)
    return R
コード例 #2
0
ファイル: tensor.py プロジェクト: wettig/gpt
 def transpose(self):
     if not self.transposable():
         return gpt.transpose(gpt.expr(self))
     return tensor(np.transpose(self.array, self.otype.transposed),
                   self.otype)
コード例 #3
0
ファイル: tensors.py プロジェクト: mbruno46/gpt
mc[:] = mc_comp
vc_comp = g.vcomplex([rng.cnormal() for i in range(ntest)], ntest)
vc = g.vcomplex(grid, ntest)
vc[:] = vc_comp
assert g.norm2(mc[0, 0, 0, 0] - mc_comp) < 1e-10

vc2 = g.eval(mc * vc)
vc2_comp = mc_comp * vc_comp
vc3 = g.eval(mc_comp * vc)
assert g.norm2(vc2[0, 0, 0, 0] - vc2_comp) < 1e-10
eps2 = g.norm2(vc2 - vc3) / g.norm2(vc2)
assert eps2 < 1e-10

# test transpose and adjoint of mcomplex
mc_adj = g.eval(g.adj(mc))
mc_transpose = g.eval(g.transpose(mc))
mc_array = mc[0, 0, 0, 0].array
mc_adj_array = mc_adj[0, 0, 0, 0].array
mc_transpose_array = mc_transpose[0, 0, 0, 0].array
assert np.linalg.norm(mc_adj_array - mc_array.transpose().conjugate()) < 1e-13
assert np.linalg.norm(mc_transpose_array - mc_array.transpose()) < 1e-13
assert g.norm2(g.adj(mc[0, 0, 0, 0]) - mc_adj[0, 0, 0, 0]) < 1e-25
assert g.norm2(g.transpose(mc[0, 0, 0, 0]) - mc_transpose[0, 0, 0, 0]) < 1e-25

# assign entire lattice
cm = g.mcolor(grid)
cv = g.vcolor(grid)
cv[:] = 0
cm[:] = 0

# assign position and tensor index
コード例 #4
0
ファイル: test-io.py プロジェクト: ssolbUR/gpt
g.message(g.trace(g.mspincolor(gr)[0, 0, 0, 0]))

# Expression including numpy array
r = g.eval(u * U[0] + U[1] * u)
g.message(g.norm2(r))

# test inner and outer products
v = g.vspincolor([[0, 0, 0], [0, 0, 2], [0, 0, 0], [0, 0, 0]])
w = g.vspincolor([[0, 0, 0], [0, 0, 0], [0, 0, 0], [1, 0, 0]])
xx = v * g.adj(w)
g.message(xx[1][3][2][0])
g.message(xx)
g.message(g.adj(v) * v)

g.message(g.transpose(v) * v)

u += g.adj(u)
g.message(u)

v = g.vspincolor([[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]])
l = g.vspincolor(gr)
l[:] = 0
l[0, 0, 0, 0] = v

g.message(l)

for mu in [0, 1, 2, 3, 5]:
    for nu in [0, 1, 2, 3, 5]:
        g.message(
            mu, nu,