-
Notifications
You must be signed in to change notification settings - Fork 0
/
decay_axial.py
142 lines (139 loc) · 5.83 KB
/
decay_axial.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
import sys
sys.path.append('$HOME/c51/scripts/')
import c51lib as c51
import numpy as np
import matplotlib.pyplot as plt
import gvar as gv
import multiprocessing as multi
from tabulate import tabulate
import yaml
import collections
def decay_axial(pr, meson, draws):
if meson == 'pion':
shortname = 'll'
elif meson == 'kaon':
shortname = 'ls'
# read data
twopt_dat = c51.open_data(pr.data_loc['file_loc'], pr.data_loc['spec_'+meson])
twopt_ss = np.squeeze(twopt_dat[:,:,0,:])
twopt_ps = np.squeeze(twopt_dat[:,:,1,:])
axial_dat = np.squeeze(c51.open_data(pr.data_loc['file_loc'], pr.data_loc['axial_'+shortname]))
T = len(twopt_ss[0])
if pr.plot_data_flag == 'on':
# unfolded correlator data
c51.scatter_plot(np.arange(len(twopt_ss[0])), c51.make_gvars(twopt_ss), 'two point no fold')
c51.scatter_plot(np.arange(len(axial_dat[0])), c51.make_gvars(axial_dat), 'axial_'+shortname+' no fold')
# fold data
axial_dat = c51.fold(axial_dat, phase=-1.0)
twopt_ss = c51.fold(twopt_ss, phase=1.0)
twopt_ps = c51.fold(twopt_ps, phase=1.0)
if pr.plot_data_flag == 'on':
# folded correlator data
c51.scatter_plot(np.arange(len(twopt_ss[0])), c51.make_gvars(twopt_ss), 'two point folded')
c51.scatter_plot(np.arange(len(axial_dat[0])), c51.make_gvars(axial_dat), 'axial_'+shortname+' folded')
# effective mass
eff = c51.effective_plots(T)
meff = eff.effective_mass(c51.make_gvars(twopt_ss), 1, 'cosh')
meff_axial = eff.effective_mass(c51.make_gvars(axial_dat)[1:], 1, 'cosh')
xlim = [3, len(meff)]
ylim = c51.find_yrange(meff, xlim[0], xlim[1])
c51.scatter_plot(np.arange(len(meff)), meff, 'two pt effective mass', xlim = xlim, ylim = ylim)
ylim = c51.find_yrange(meff, xlim[0], xlim[1])
c51.scatter_plot(np.arange(len(meff_axial))+1, meff_axial, 'axial_'+shortname+' effective mass', xlim = xlim, ylim = ylim)
# scaled correlator
E0 = pr.priors[meson]['E0'][0]
scaled = eff.scaled_correlator(c51.make_gvars(twopt_ss), E0, phase=1.0)
scaled_axial = eff.scaled_correlator(c51.make_gvars(axial_dat)[1:], E0, phase=-1.0)
c51.scatter_plot(np.arange(len(scaled)), scaled, 'two pt scaled correlator (take sqrt to get Z0)')
c51.scatter_plot(np.arange(len(scaled_axial))+1, scaled_axial, 'axial_'+shortname+' scaled correlator (divide by Z0 to get F0)')
# concatenate
decay_axial_ss = np.concatenate((axial_dat, twopt_ss), axis=1)
# read priors
priors = pr.priors[meson]
# read trange
trange = pr.trange['decay_axial']
# fit
args = ((g, trange, T, decay_axial_ss, priors, draws) for g in range(len(draws)))
pool = multi.Pool()
p = pool.map_async(decay_axial_fit, args)
# sort via bootstrap number
output = np.sort(np.array(p.get()), axis=0)
return output
# bootstrap routine
def decay_axial_fit(args):
g, trange, T, decay_axial_ss, priors, draws = args
# resample
decay_axial_ss = c51.make_gvars(decay_axial_ss[draws[g]])
# make priors
bsp = c51.dict_of_tuple_to_gvar(priors)
# fit
fitfcn = c51.fit_function(T, nstates=2)
fit = c51.fitscript_v2(trange, T, decay_axial_ss, bsp, fitfcn.axial_twoptss_fitfcn, result_flag='off')
# record nbs
fit = [g, fit]
return fit
if __name__=='__main__':
# read parameters
pr = c51.process_params()
# bootstrap draws
# if draw number = 0, draws boot0
draw_n = 1000
draws = pr.bs_draws(draw_n)
# bootstrap axial_ll
fpi = decay_axial(pr, 'pion', draws)
# bootstrap axial_ls
fk = decay_axial(pr, 'kaon', draws)
# process output and plot distribution
fpi_proc = c51.process_bootstrap(fpi)
fk_proc = c51.process_bootstrap(fk)
fpi_boot0, fpi_bs = fpi_proc()
fk_boot0, fk_bs = fk_proc()
print fpi_boot0
if pr.plot_hist_flag == 'on':
c51.histogram_plot(fpi_bs, 'F0', 'pion F0')
c51.histogram_plot(fpi_bs, 'E0', 'pion E0')
c51.histogram_plot(fk_bs, 'F0', 'kaon F0')
c51.histogram_plot(fk_bs, 'E0', 'kaon F0')
# plot stability for boot0 fits
if pr.plot_stab_flag == 'on':
c51.stability_plot(fpi_boot0, 'F0', 'boot0 fpi')
c51.stability_plot(fpi_boot0, 'E0', 'boot0 m_pi')
c51.stability_plot(fk_boot0, 'F0', 'boot0 fk')
c51.stability_plot(fk_boot0, 'E0', 'boot0 m_k')
# boot0 result
F0_pi = fpi_proc.read_boot0('F0')
E0_pi = fpi_proc.read_boot0('E0')
F0_k = fk_proc.read_boot0('F0')
E0_k = fk_proc.read_boot0('E0')
# calculate decay constant
fpi = -1.0*F0_pi*np.sqrt(2.0/E0_pi)
fk = -1.0*F0_k*np.sqrt(2.0/E0_k)
table_print = collections.OrderedDict()
table_print['tmin'] = fpi_boot0['tmin']
table_print['tmax'] = fpi_boot0['tmax']
table_print['fk'] = fk
table_print['fpi'] = fpi
table_print['fk/fpi'] = fk/fpi
print tabulate(table_print, headers='keys')
# bootstrap errors
if draw_n > 0:
F0_pi_bs_mean = fpi_proc.read_bs('F0')
E0_pi_bs_mean = fpi_proc.read_bs('E0')
F0_k_bs_mean = fk_proc.read_bs('F0')
E0_k_bs_mean = fk_proc.read_bs('E0')
fpi_bserror = -1.0*F0_pi_bs_mean*np.sqrt(2.0/E0_pi_bs_mean)
fk_bserror = -1.0*F0_k_bs_mean*np.sqrt(2.0/E0_k_bs_mean)
if pr.plot_hist_flag == 'on':
c51.histogram_plot(fpi_bserror, xlabel='fpi')
c51.histogram_plot(fk_bserror, xlabel='fk')
# result
fpi_boot0_avg = np.average(fpi)
fpi_error = np.std(fpi_bserror)
fk_boot0_avg = np.average(fk)
fk_error = np.std(fk_bserror)
print 'fk: ', gv.gvar(fk_boot0_avg, fk_error)
print 'fpi: ', gv.gvar(fpi_boot0_avg, fpi_error)
fkfpi_boot0_avg = np.average(fk/fpi)
fkfpi_error = np.std(fk_bserror/fpi_bserror)
print 'fk/fpi: ', gv.gvar(fkfpi_boot0_avg, fkfpi_error)
plt.show()