def bilinear_Lambdas(Data):
# type check? data loaded?
amputated = amputate_bilinears(Data.inprop_list,
Data.outprop_list,
Data.bilinear_array)
# Include Tr[qslash*inv(prop)]
# Are you matching momenta to the prop correctly?
Data.prop_trace_in = prop_trace(Data.inprop_list, Data.ap, sin=True)*Data.V
#Data.prop_trace_out = prop_trace(Data.outprop_list, Data.ap2, sin=True)*Data.V
Data.prop_trace_in2 = prop_trace(Data.inprop_list, Data.ap, sin=False)*Data.V
#Data.prop_trace_out2 = prop_trace(Data.outprop_list, Data.ap2, sin=False)*Data.V
norm = Data.V/12.
Lambda = lambda x, y: (trace(dot(dw.hc(x), y)).real)*norm
Data.Lambda = map(Lambda, Gc, amputated)
# For the (X, g) schemes.
Data.Lambda_V = (Data.Lambda[1] + Data.Lambda[2] + Data.Lambda[4] +
Data.Lambda[8])*(1./4)
Data.Lambda_A = (Data.Lambda[14] + Data.Lambda[13] + Data.Lambda[11] +
Data.Lambda[7])*(1./4)
Data.Lambda_VpA = (Data.Lambda[1] + Data.Lambda[2] + Data.Lambda[4] +
Data.Lambda[8] + Data.Lambda[14] + Data.Lambda[13] +
Data.Lambda[11] + Data.Lambda[7])*(1./8)
Data.Lambda_VmA = 2*(Data.Lambda_V - Data.Lambda_A)/\
(Data.Lambda_V + Data.Lambda_A)
Data.Lambda_PmS = 2*(Data.Lambda[15] - Data.Lambda[0])/\
(Data.Lambda[15] + Data.Lambda[0])
Data.Lambda_T = (Data.Lambda[3] + Data.Lambda[5] + Data.Lambda[6] +
Data.Lambda[9] + Data.Lambda[10] + Data.Lambda[12])/6.
# For the (X, q) schemes.
aq = Data.aq
Gmu = (amputated[1], amputated[2], amputated[4], amputated[8])
qmuGmu = sum([aq[i]*Gmu[i] for i in range(4)])
Data.Vq = (trace(dot(qmuGmu, dw.slash(aq))).real)*norm/Data.apSq
Gmu5 = (amputated[14], -amputated[13], amputated[11], -amputated[7])
qmuGmu5 = sum([aq[i]*Gmu5[i] for i in range(4)])
tmp = reduce(dot, [qmuGmu5, Gc[15], dw.slash(aq)]).real
Data.Vq5 = trace(tmp*norm)/Data.apSq
Data.Vq_ = Data.Vq
Data.Vq = (Data.Vq + Data.Vq5)/2
# Z-factors.
Data.Z_S = dict(g=None, q=None)
Data.Z_T = dict(g=None, q=None)
Data.Z_S['g'] = Data.Lambda_VpA/Data.Lambda[0]
Data.Z_S['q'] = Data.Vq/Data.Lambda[0]
Data.Z_T['g'] = Data.Lambda_VpA/Data.Lambda_T
Data.Z_T['q'] = Data.Vq/Data.Lambda_T
def test_traces(self):
"Ensure Tr(hc(G[i]).G[j]) = 4 delta_{ij}"
traces = np.array([[np.trace(np.dot(dw.hc(dw.G[i]), dw.G[j]))/4
for i in range(16)] for j in range(16)])
np.testing.assert_array_equal(traces, np.identity(16, dtype=complex))
def bilinear_LambdaJK(Data):
amputatedJK = map(amputate_bilinears, JKsample(Data.inprop_list),
JKsample(Data.outprop_list),
JKsample(Data.bilinear_array))
norm = Data.V/12.
Lambda = lambda x, y: (trace(dot(dw.hc(x), y)).real)*norm
Data.LambdaJK = [np.array(map(Lambda, Gc, amp)) for amp in amputatedJK]
Data.Lambda_sigmaJK = JKsigma(Data.LambdaJK, Data.Lambda)
# For the (X, g) schemes.
def V(Lambda):
return (Lambda[1] + Lambda[2] + Lambda[4] + Lambda[8])*(1/4.)
def A(Lambda):
return (Lambda[14] + Lambda[13] + Lambda[11] + Lambda[7])*(1/4.)
def VpA(Lambda):
return (Lambda[1] + Lambda[2] + Lambda[4] +
Lambda[8] + Lambda[14] + Lambda[13] +
Lambda[11] + Lambda[7])*(1./8)
def VmA(Lambda):
return 2*(V(Lambda) - A(Lambda))/(V(Lambda) + A(Lambda))
def PmS(Lambda):
return 2*(Lambda[15] - Lambda[0])/(Lambda[15] + Lambda[0])
def T(Lambda):
return (Lambda[3] + Lambda[5] + Lambda[6] +
Lambda[9] + Lambda[10] + Lambda[12])/6.
Data.Lambda_VpA_JK = map(VpA, Data.LambdaJK)
Data.Lambda_VpA_sigmaJK = JKsigma(Data.Lambda_VpA_JK, Data.Lambda_VpA)
Data.Lambda_V_JK = map(V, Data.LambdaJK)
Data.Lambda_V_sigmaJK = JKsigma(Data.Lambda_V_JK, Data.Lambda_V)
Data.Lambda_A_JK = map(A, Data.LambdaJK)
Data.Lambda_A_sigmaJK = JKsigma(Data.Lambda_A_JK, Data.Lambda_A)
Data.Lambda_V_sigmaJK = JKsigma(Data.Lambda_V_JK, Data.Lambda_V)
Data.Lambda_VmA_JK = map(VmA, Data.LambdaJK)
Data.Lambda_VmA_sigmaJK = JKsigma(Data.Lambda_VmA_JK, Data.Lambda_VmA)
Data.Lambda_PmS_JK = map(PmS, Data.LambdaJK)
Data.Lambda_PmS_sigmaJK = JKsigma(Data.Lambda_PmS_JK, Data.Lambda_PmS)
Data.Lambda_T_JK = map(T, Data.LambdaJK)
Data.Lambda_T_sigmaJK = JKsigma(Data.Lambda_T_JK, Data.Lambda_T)
# For the (X, q) schemes.
aq = Data.aq
apSq = Data.apSq
def Vq(amputated):
Gmu = (amputated[1], amputated[2], amputated[4], amputated[8])
qmuGmu = sum([aq[i]*Gmu[i] for i in range(4)])
return (trace(dot(qmuGmu, dw.slash(aq))).real)*norm/apSq
def Vq5(amputated):
Gmu5 = (amputated[14], -amputated[13], amputated[11], -amputated[7])
qmuGmu5 = sum([aq[i]*Gmu5[i] for i in range(4)])
tmp = reduce(dot, [qmuGmu5, Gc[15], dw.slash(aq)]).real
return trace(tmp*norm)/Data.apSq
Data.Vq_JK = [(Vq(amp)+Vq5(amp))/2 for amp in amputatedJK]
Data.Vq_sigmaJK = JKsigma(Data.Vq_JK, Data.Vq)
# Z-factors.
Z_S = lambda Lambda, Lambda_vec: Lambda_vec/Lambda[0]
Data.Z_S_JK = dict(g=None, q=None)
Data.Z_S_sigmaJK = dict(g=None, q=None)
Data.Z_S_JK['g'] = map(Z_S, Data.LambdaJK, Data.Lambda_VpA_JK)
Data.Z_S_JK['q'] = map(Z_S, Data.LambdaJK, Data.Vq_JK)
Data.Z_S_sigmaJK['g'] = JKsigma(Data.Z_S_JK['g'], Data.Z_S['g'])
Data.Z_S_sigmaJK['q'] = JKsigma(Data.Z_S_JK['q'], Data.Z_S['q'])
Z_T = lambda Lambda_T, Lambda_vec: Lambda_vec/Lambda_T
Data.Z_T_JK = dict(g=None, q=None)
Data.Z_T_sigmaJK = dict(g=None, q=None)
Data.Z_T_JK['g'] = map(Z_T, Data.Lambda_T_JK, Data.Lambda_VpA_JK)
Data.Z_T_JK['q'] = map(Z_T, Data.Lambda_T_JK, Data.Vq_JK)
Data.Z_T_sigmaJK['g'] = JKsigma(Data.Z_T_JK['g'], Data.Z_T['g'])
Data.Z_T_sigmaJK['q'] = JKsigma(Data.Z_T_JK['q'], Data.Z_T['q'])
'''
Gauge-average and amputate bilinear correlation functions.
Acts on a list of tuples [(prop, [bl0, bl1,...,bl15]), ...]
corresponding to each gauge configuration.'''
prop_list, bilinear_array = zip(*prop_bilinear_tuples) # Unzip.
N = len(prop_list)
assert N == len(prop_list) == len(bilinear_array)
prop_inv = inv(sum(prop_list)/N)
bilinears = sum(bilinear_array)/N
return array([reduce(dot, [prop_inv, bilinears[g], prop_inv])
for g in range(16)])
gamma_trace = lambda g, a: trace(dot(dw.hc(g), a).real)
def bilinear_Lambdas(Data):
data_tuples = zip(Data.prop_list, Data.bilinear_array)
norm = Data.V/12
amputated = amputate_bilinears_e(data_tuples)
Data.Lambda = map(gamma_trace, Gc, amputated*norm)
# For the (X, g) schemes.
Data.Lambda_VpA = (Data.Lambda[1] + Data.Lambda[2] + Data.Lambda[4] +
Data.Lambda[8] + Data.Lambda[14] + Data.Lambda[13] +
Data.Lambda[11] + Data.Lambda[7])*(1./8)
Data.Lambda_V = (Data.Lambda[1] + Data.Lambda[2] + Data.Lambda[4] +
Data.Lambda[8])*(1./4)
Data.Lambda_A = (Data.Lambda[14] + Data.Lambda[13] + Data.Lambda[11] +
Data.Lambda[7])*(1./4)
