def form_factor_fixed_qsq(self, form='f+', qsq=0.0,
var='qsq', decay='Bs2Ds', withpole=False, nz=3, gvar=True):
"""
Construct the f+ or f0 form factors at a fixed q^2 value.
"""
if form == 'f0':
PHI = const_b2d.PHI0
elif form == 'f+':
PHI = const_b2d.PHI_PLUS
#if form not in ('f+', 'f0'):
else:
print "Only f+ and f0 form factors are provided."
return
z = self.q_sq2z(qsq)
formfactor = self.fcn(z, self.params(decay), nz)[form] / self.Pphi(qsq, form)
formfactor /= PHI
if var == 'qsq':
if gvar:
res = [qsq, formfactor]
else:
res = [qsq, gv.mean(formfactor), gv.sdev(formfactor)]
elif var == 'z':
if gvar:
res = [qsq, formfactor]
else:
res = [z, gv.mean(formfactor), gv.sdev(formfactor)]
return res
def errreturn(val):
if isinstance(val, vegas._vegas.RAvg):
error = gvar.sdev(val)
else:
valp = val[0]
error = gvar.sdev(valp)
return error
def form_factor_fixed_qsq(self, form='f+', qsq=0.0,
var='qsq', withpole=True, nz=4, gvar=True):
"""
Construct the f+ or f0 form factors at a fixed q^2 value.
"""
if form not in ('f+', 'f0'):
print "Only f+ and f0 form factors are provided."
return
z = self.q_sq2z(qsq)
if withpole:
formfactor = self.fcn(z, self.params())[form] / self.Pphi(qsq, form)
else:
formfactor = self.fcn(z, self.params())[form]
if var == 'qsq':
if gvar:
res = [qsq, formfactor]
else:
res = [qsq, gv.mean(formfactor), gv.sdev(formfactor)]
elif var == 'z':
if gvar:
res = [qsq, formfactor]
else:
res = [z, gv.mean(formfactor), gv.sdev(formfactor)]
return res
def plot_corre_and_fit(options, num, labels, data, fcnlabel, fcn, choosefit):
xlow = options.xlow
xhigh = options.xhigh
ylow = options.ylow
yhigh = options.yhigh
tkxy = options.tkxy
xmax = options.rmax[num]
choose_t = options.choose[num]
outdir = options.outdir
t = np.arange(NT)
x = {"tc": t, "tg": t, "tgc": t}
fcnout = -(fcn(x, choosefit.p)[fcnlabel])
upper = gv.mean(fcnout) + gv.sdev(fcnout)
lower = gv.mean(fcnout) - gv.sdev(fcnout)
idata = data.copy()
jacksamp = jacksample(idata, 0)
_, jkerr = jackerror(jacksamp, 0) # * at_inverse
exmean = -(np.average(idata, axis=0))
fig, ax = plt.subplots()
ax.errorbar(
t,
exmean,
jkerr,
fmt="o",
color="blue",
markersize=5,
capsize=4,
linewidth=1.0,
capthick=1.0,
markeredgecolor="black",
fillstyle="full",
markerfacecolor="w",
)
ax.fill_between(t, lower, upper, alpha=0.5, color="dimgray")
ax.fill_between(
np.arange(choose_t, xmax + 1),
lower[choose_t:xmax + 1],
upper[choose_t:xmax + 1],
alpha=1.0,
color="royalblue",
)
ax.xaxis.set_major_locator(MultipleLocator(tkxy[0]))
ax.xaxis.set_minor_locator(MultipleLocator(tkxy[1]))
# ax.yaxis.set_major_locator(MultipleLocator(tkxy[2]))
# ax.yaxis.set_minor_locator(MultipleLocator(tkxy[3]))
ax.set_xlabel(options.xlabel, fontsize=24)
ax.set_ylabel(labels, fontsize=24)
ax.set_xlim(xlow[num], xhigh[num])
ax.set_ylim(ylow[num], yhigh[num])
plt.tight_layout()
plt.savefig(outdir + "fit_" + fcnlabel + ".pdf")
plt.show()
def errorbar(ax, x, y, bands=False, **kwargs):
"""Wrapper to plot gvars using the matplotlib function errorbar."""
if hasattr(y, 'values'):
y = y.values
if hasattr(x, 'values'):
x = x.values
try:
xerr = gv.sdev(x)
# sdev throws error w/ x = np.arange(>50)
except ZeroDivisionError:
xerr = 0. * np.array(x) # in case x passed from plot().
x = gv.mean(x)
try:
yerr = gv.sdev(y)
except ZeroDivisionError:
yerr = 0. * y
y = gv.mean(y)
if bands:
ax.errorbar(x=x, y=y, **kwargs)
facecolor = kwargs.get('color', ax.lines[-1].get_color())
alpha = kwargs.get('alpha', 1.0)
ax.fill_between(x,
y - yerr,
y + yerr,
facecolor=facecolor,
alpha=alpha)
else:
ax.errorbar(x=x, xerr=xerr, y=y, yerr=yerr, **kwargs)
return ax
def plot_fit(plt, p, data, *args, **kargs):
if not ONE_W or not SHOW_PLOT:
return plt
xline = np.linspace(data.x[0], data.x[-1], 100)
yline = data.fitfcn(p, x=xline)
yp = gv.mean(yline) + gv.sdev(yline)
ym = gv.mean(yline) - gv.sdev(yline)
if args[0][0] == 'k':
plt.plot(xline, gv.mean(yline), *args)
else:
plt.fill_between(xline,yp,ym, **kargs)
def test_svd(self):
" EigenBasis.svd "
tdata = [1, 2, 3, 4]
G = self.make_G(tdata, keyfmt="{s1}{s2}", srcs="ab")
basis = EigenBasis(data=G, keyfmt="{s1}{s2}", srcs="ab", t=2, tdata=tdata)
Gsvd = basis.svd(G, svdcut=0.9)
self.assertEqual(basis.svdn, 15)
self.assertEqual(str(basis.svdcorrection), "0.000(30)")
for k in G:
np.testing.assert_allclose(gv.mean(G[k]), gv.mean(Gsvd[k]))
self.assertTrue(np.all(gv.sdev(Gsvd[k]) > gv.sdev(G[k])))
def fast_w2pix(w, axis_min, axis_step):
"""Fast conversion of wavelength/wavenumber to pixel
:param w: wavelength/wavenumber
:param axis_min: min axis wavelength/wavenumber
:param axis_step: axis step size in wavelength/wavenumber
"""
w_ = (w - axis_min)
if np.any(gvar.sdev(w_) != 0.):
w_ = gvar.gvar(gvar.mean(w_), gvar.sdev(w_))
return gvar.fabs(w_) / axis_step
def f_fit_plot(x,
y,
all_dta,
fit,
error_band=False,
semilog=False,
full_data=True):
'''
Function for plotting data with the fit lines and error bands.
For correlators, using a semi-log plot.
full_data=True, plots the entire data and the best-fit in the fit region
'''
plt.figure()
# Plots data points
if full_data: # Plot all the correlators even those not used in the fit.
plt.errorbar(x=all_dta['x'],
y=gv.mean(all_dta['y']),
yerr=gv.sdev(all_dta['y']),
color='black',
linestyle='None',
marker='o')
else: # Plot the data points used in the fit
plt.errorbar(x=x['x'],
y=gv.mean(y['y']),
yerr=gv.sdev(y['y']),
linestyle='None',
color='red',
marker='s')
# Plot the best fit line
# # Using a finer grid to get a continuous curve.
curvex = dict(x)
curvex['x'] = np.linspace(min(fit.x['x']), max(fit.x['x']), 500)
curvey = gv.mean(fit.fcn(curvex, fit.p))
plt.plot(curvex['x'], curvey, color='blue')
if error_band:
obs_fit = gv.mean(fit.fcn(curvex, fit.p))
err_fit = gv.sdev(fit.fcn(curvex, fit.p))
sigma = 2.0
plt.fill_between(curvex['x'],
obs_fit - sigma * err_fit,
obs_fit + sigma * err_fit,
color='yellow') # providing an error band.
if semilog: plt.semilogy()
plt.title("Plot")
def make_plot(x, y, fit, ylabel='y(x)', xmax=1.0):
if not MAKE_PLOTS:
return
plt.errorbar(x, gv.mean(y), gv.sdev(y), fmt='bo')
x = np.arange(0., xmax, 0.01)
yfit = f(x, fit.p)
plt.plot(x, gv.mean(yfit), 'k--')
yplus = gv.mean(yfit) + gv.sdev(yfit)
yminus = gv.mean(yfit) - gv.sdev(yfit)
plt.fill_between(x, yminus, yplus, color='0.8')
plt.xlim(0,1)
plt.ylim(0.3,1.9)
plt.xlabel('x')
plt.ylabel(ylabel)
plt.show()
def plot_error_ellipsis(self, x_key, y_key, observable):
x = self._get_posterior(x_key)[observable]
y = self._get_posterior(y_key)[observable]
fig, ax = plt.subplots()
corr = '{0:.3g}'.format(gv.evalcorr([x, y])[0, 1])
std_x = '{0:.3g}'.format(gv.sdev(x))
std_y = '{0:.3g}'.format(gv.sdev(y))
text = ('$R_{x, y}=$ %s\n $\sigma_x =$ %s\n $\sigma_y =$ %s' %
(corr, std_x, std_y))
# these are matplotlib.patch.Patch properties
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
# place a text box in upper left in axes coords
ax.text(0.05,
0.95,
text,
transform=ax.transAxes,
fontsize=14,
verticalalignment='top',
bbox=props)
C = gv.evalcov([x, y])
eVe, eVa = np.linalg.eig(C)
for e, v in zip(eVe, eVa.T):
plt.plot([
gv.mean(x) - 1 * np.sqrt(e) * v[0],
1 * np.sqrt(e) * v[0] + gv.mean(x)
], [
gv.mean(y) - 1 * np.sqrt(e) * v[1],
1 * np.sqrt(e) * v[1] + gv.mean(y)
],
'k-',
lw=2)
#plt.scatter(x-np.mean(x), y-np.mean(y), rasterized=True, marker=".", alpha=100.0/self.bs_N)
#plt.scatter(x, y, rasterized=True, marker=".", alpha=100.0/self.bs_N)
plt.grid()
plt.gca().set_aspect('equal', adjustable='datalim')
plt.xlabel(x_key.replace('_', '\_'), fontsize=24)
plt.ylabel(y_key.replace('_', '\_'), fontsize=24)
fig = plt.gcf()
plt.close()
return fig
def bootstrap(self, a=0.45):
"""
"""
omega = _twopi
phi = 0
offset = 0.50
nbootstrap = 500
amp = []
for ii in range(nbootstrap):
mean, cov = self.test_qinfer_estimate(a, omega, phi, offset)
amp.append(gvar.gvar(mean[0], np.sqrt(np.diag(cov))[0]))
a_weighted = np.mean(gvar.mean(amp))
print('mean = {}'.format((a_weighted - a) / a))
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.hist((gvar.mean(amp) - a) / a)
plt.xlabel('ratio of a_fit / a - 1')
plt.ylabel('frequency')
plt.subplot(1, 2, 2)
plt.hist(gvar.sdev(amp))
plt.xlabel('standard error of a')
plt.ylabel('frequency')
plt.tight_layout()
plt.show()
def main():
print(
gv.ranseed(
(2050203335594632366, 8881439510219835677, 2605204918634240925)))
log_stdout('eg3a.out')
integ = vegas.Integrator(4 * [[0, 1]])
# adapt grid
training = integ(f(), nitn=10, neval=1000)
# evaluate multi-integrands
result = integ(f(), nitn=10, neval=5000)
print('I[0] =', result[0], ' I[1] =', result[1], ' I[2] =', result[2])
print('Q = %.2f\n' % result.Q)
print('<x> =', result[1] / result[0])
print('sigma_x**2 = <x**2> - <x>**2 =',
result[2] / result[0] - (result[1] / result[0])**2)
print('\ncorrelation matrix:\n', gv.evalcorr(result))
unlog_stdout()
r = gv.gvar(gv.mean(result), gv.sdev(result))
print(r[1] / r[0])
print((r[1] / r[0]).sdev / (result[1] / result[0]).sdev)
print(r[2] / r[0] - (r[1] / r[0])**2)
print(result.summary())
def diff_decay_rate_bk(self, lepton='mu', start=const.MMU**2,
end=const.TMINUS, num_points=500):
"""
Calculate the differential decay rate for B -> K mu nu or B -> K tau
nu.
"""
if lepton == 'mu':
ml = const.MMU
elif lepton == 'tau':
ml = const.MTAU
else:
print "Only the 'mu' or 'tau' lepton is allowed."
return
start = ml**2
res = []
step = (end - start) / num_points
for qsq in np.arange(start, end + step, step):
i = self.q_sq2z(qsq)
E = self.q_sq2E(qsq)
PK = self.q_sq2PK(qsq)
fac_overall = const.GF**2 / (24*np.pi**3*const.MBS**2) * (1 - ml**2 / qsq)**2 * PK
fac_plus = (1 + ml**2/2./qsq) * const.MBS**2 * PK**2
fac_zero = 3.0 * ml**2 / 8.0 / qsq * (const.MBS**2 - const.MK**2)**2
form = 'f+'
fp = self.fcn(i, self.params())[form] / self.Pphi(qsq, form)
form = 'f0'
f0 = self.fcn(i, self.params())[form] / self.Pphi(qsq, form)
#print qsq,gv.mean(ans), gv.sdev(ans)
ans = fac_overall * ( fac_plus * fp**2 + fac_zero * f0**2 ) / const.GEV_TO_PS
#print i, qsq, E, PK, fac_overall, fac_plus, fac_zero, fp, f0, ans
res.append([qsq, gv.mean(ans), gv.sdev(ans)])
return res
def __init__(self, nstates, ds=None, a_fm=None, **kwargs):
prior = {}
# Decaying states
prior['light-light:dE'] = PhysicalSplittings('pion')(nstates.n, a_fm)
prior['light-light:a'] = decay_amplitudes(nstates.n)
prior['heavy-light:dE'] = PhysicalSplittings('d')(nstates.m, a_fm)
prior['heavy-light:a'] = decay_amplitudes(nstates.m)
# Oscillating states
if nstates.no:
prior['light-light:dEo'] = PhysicalSplittings('pion_osc')(
nstates.no, a_fm)
prior['light-light:ao'] = osc_amplitudes(nstates.no)
if nstates.mo:
prior['heavy-light:dEo'] = PhysicalSplittings('d_osc')(nstates.mo,
a_fm)
prior['heavy-light:ao'] = osc_amplitudes(nstates.mo)
# Matrix elements Vnn
for key, value in vmatrix(nstates).items():
if value.size: # skip empty matrices
prior[key] = value
# Make informed guesses for ground states and the form factor Vnn[0,0].
# Estimate central values as well as possible, but keep wide priors.
if ds is not None:
for tag in ['light-light', 'heavy-light']:
mean = gv.mean(ds[tag].mass) # Central value from "meff"
err = gv.sdev(prior[f"{tag}:dE"][0])
prior[f"{tag}:dE"][0] = gv.gvar(mean, err)
mean = gv.mean(ds.v_guess) # Central value from ratio R
err = 0.5 * mean
prior['Vnn'][0, 0] = gv.gvar(mean, err)
super(FormFactorPriorD2Pi, self).__init__(mapping=prior, **kwargs)
def fit_interpolation(self, simultaneous=None):
if simultaneous is None:
simultaneous = self._simultaneous
if self._fit_interpolation is None or simultaneous != self._simultaneous:
self._simultaneous = simultaneous
#make_gvar = lambda g : gv.gvar(gv.mean(g), gv.sdev(g))
#y_data = make_gvar(1 / self.fit_data['a/w'])
make_gvar = lambda g: gv.gvar(gv.mean(g), gv.sdev(g))
if self.observable == 'w0':
data = {
self.model_info['name'] + '_interpolation':
1 / make_gvar(self.fit_data['a/w'])
}
elif self.observable == 't0':
data = {
self.model_info['name'] + '_interpolation':
make_gvar(self.fit_data['t/a^2'])
}
if simultaneous:
data[self.model_info['name']] = self.y
models = self._make_models(interpolation=True,
simultaneous=simultaneous)
prior = self._make_prior(interpolation=True,
simultaneous=simultaneous)
fitter = lsqfit.MultiFitter(models=models)
fit = fitter.lsqfit(data=data, prior=prior, fast=False, mopt=False)
self._fit_interpolation = fit
return self._fit_interpolation
def main():
# pendulum data exhibits experimental error in ability to measure theta
t = gv.gvar([
'0.10(1)', '0.20(1)', '0.30(1)', '0.40(1)', '0.50(1)',
'0.60(1)', '0.70(1)', '0.80(1)', '0.90(1)', '1.00(1)'
])
theta = gv.gvar([
'1.477(79)', '0.791(79)', '-0.046(79)', '-0.852(79)',
'-1.523(79)', '-1.647(79)', '-1.216(79)', '-0.810(79)',
'0.185(79)', '0.832(79)'
])
for t_n, theta_n in zip(t, theta):
print("{} {:>10}".format(t_n.fmt(2), theta_n.fmt(3)))
# prior: assume experimental error in ability to specify theta(0)
prior = gv.BufferDict()
prior['g/l'] = gv.gvar('40(20)')
prior['theta(0)'] = gv.gvar('1.571(50)')
prior['t'] = t
# fit function: use class Pendulum object to integrate pendulum motion
def fitfcn(p, t=None):
if t is None:
t = p['t']
pendulum = Pendulum(p['g/l'])
return pendulum(p['theta(0)'], t)
# do the fit and print results
fit = lsqfit.nonlinear_fit(data=theta, prior=prior, fcn=fitfcn)
sys.stdout = tee.tee(STDOUT, open('case-pendulum.out', 'w'))
print(fit.format(maxline=True))
sys.stdout = STDOUT
print('fit/exact for (g/l) =', fit.p['g/l'] / (2*np.pi) ** 2)
print('fit/exact for theta(0) =', fit.p['theta(0)'] / (np.pi / 2.))
if MAKE_PLOT:
# make figure (saved to file pendulum.pdf)
plt.figure(figsize=(4,3))
# start plot with data
plt.errorbar(
x=gv.mean(t), xerr=gv.sdev(t), y=gv.mean(theta), yerr=gv.sdev(theta),
fmt='k.',
)
# use best-fit function to add smooth curve for 100 points
t = np.linspace(0., 1.1, 100)
th = fitfcn(fit.p, t)
show_plot(t, th)
def main():
# pendulum data exhibits experimental error in ability to measure theta
t = gv.gvar([
'0.10(1)', '0.20(1)', '0.30(1)', '0.40(1)', '0.50(1)',
'0.60(1)', '0.70(1)', '0.80(1)', '0.90(1)', '1.00(1)'
])
theta = gv.gvar([
'1.477(79)', '0.791(79)', '-0.046(79)', '-0.852(79)',
'-1.523(79)', '-1.647(79)', '-1.216(79)', '-0.810(79)',
'0.185(79)', '0.832(79)'
])
for t_n, theta_n in zip(t, theta):
print("{} {:>10}".format(t_n.fmt(2), theta_n.fmt(3)))
# prior: assume experimental error in ability to specify theta(0)
prior = gv.BufferDict()
prior['g/l'] = gv.gvar('40(20)')
prior['theta(0)'] = gv.gvar('1.571(50)')
prior['t'] = t
# fit function: use class Pendulum object to integrate pendulum motion
def fitfcn(p, t=None):
if t is None:
t = p['t']
pendulum = Pendulum(p['g/l'])
return pendulum(p['theta(0)'], t)
# do the fit and print results
fit = lsqfit.nonlinear_fit(data=theta, prior=prior, fcn=fitfcn)
sys.stdout = tee.tee(STDOUT, open('case-pendulum.out', 'w'))
print(fit.format(maxline=True))
sys.stdout = STDOUT
print('fit/exact for (g/l) =', fit.p['g/l'] / (2*np.pi) ** 2)
print('fit/exact for theta(0) =', fit.p['theta(0)'] / (np.pi / 2.))
if MAKE_PLOT:
# make figure (saved to file pendulum.pdf)
plt.figure(figsize=(4,3))
# start plot with data
plt.errorbar(
x=gv.mean(t), xerr=gv.sdev(t), y=gv.mean(theta), yerr=gv.sdev(theta),
fmt='b.',
)
# use best-fit function to add smooth curve for 100 points
t = np.linspace(0., 1.1, 100)
th = fitfcn(fit.p, t)
show_plot(t, th)
def plot_eff_mass_fit_SM(m_e_kf,f_SM_1, par_SM_1,f_SM_2, par_SM_2):
x_plot = np.arange(1,22)
x_plot = x_plot*0.01
y_plot = []
for h in range(6):
y_plot.append (m_e_kf[:,h,0])
y_plot = gv.dataset.avg_data(y_plot,spread=True)
fig = plt.figure()
plt.errorbar(x_plot,gv.mean (y_plot) ,gv.sdev(y_plot), fmt='ok',label='data (68% CL)')
plt.fill_between (x_plot, gv.mean(1/f_SM_2(x_plot,par_SM_2))+ gv.sdev(1/f_SM_2(x_plot,par_SM_2))
,gv.mean(1/f_SM_2(x_plot,par_SM_2))-gv.sdev(1/f_SM_2(x_plot,par_SM_2)),label='quadratic fit (68% CL)'
,color ='red', alpha=0.6)
plt.fill_between (x_plot, gv.mean(1/f_SM_2(x_plot,par_SM_2))+ 2*gv.sdev(1/f_SM_2(x_plot,par_SM_2))
,gv.mean(1/f_SM_2(x_plot,par_SM_2))-2*gv.sdev(1/f_SM_2(x_plot,par_SM_2)),label='quadratic fit (95% CL)'
,color ='red', alpha=0.4)
plt.fill_between (x_plot, gv.mean(1/f_SM_1(x_plot,par_SM_1))+ gv.sdev(1/f_SM_1(x_plot,par_SM_1))
,gv.mean(1/f_SM_1(x_plot,par_SM_1))-gv.sdev(1/f_SM_1(x_plot,par_SM_1)),label='linear fit (68% CL)'
,color ='blue', alpha=0.6)
plt.fill_between (x_plot, gv.mean(1/f_SM_1(x_plot,par_SM_1))+ 2*gv.sdev(1/f_SM_1(x_plot,par_SM_1))
,gv.mean(1/f_SM_1(x_plot,par_SM_1))-2*gv.sdev(1/f_SM_1(x_plot,par_SM_1)),label='linear fit (95% CL)'
,color ='blue', alpha=0.4)
for h in range(6):
plt.plot (x_plot, m_e_kf[:,h,0],color='k', alpha=0.6)
plt.text(0.212,0.6129001102725408-0.01,'H'+str(1)+'')
plt.text(0.212,0.6249013706200439-0.008,'H'+str(2)+'')
plt.text(0.212,0.6026532762896706-0.015,'H'+str(3)+'')
plt.text(0.212,0.6341732874045016+0.008,'H'+str(4)+'')
plt.text(0.212,0.6505783121773542+0.005,'H'+str(5)+'')
plt.text(0.212,0.632353164008689-0.003,'H'+str(7)+'')
plt.xlabel ("$n$ (fm$^{-3}$)",fontsize='15')
plt.ylabel ("$m_n^{*}/m$",fontsize='15')
plt.text (0.02,0.95,'Symmetric matter',fontsize='15')
plt.xticks(np.arange(0, 0.2+0.01, 0.05),fontsize='14' )
plt.yticks(fontsize='14' )
plt.tick_params(right=True)
plt.tick_params(top=True)
plt.tick_params(direction='in')
plt.legend(loc='upper right',fontsize='14')
plt.show()
def main():
gv.ranseed([2009,2010,2011,2012,2013]) # initialize random numbers (opt.)
x,y = make_data() # make fit data
p0 = None # make larger fits go faster (opt.)
sys_stdout = sys.stdout
for nexp in range(3,6):
prior = make_prior(nexp,x)
fit = lsqfit.nonlinear_fit(data=y,fcn=f,prior=prior,p0=p0) # ,svdcut=SVDCUT)
if fit.chi2/fit.dof<1.:
p0 = fit.pmean # starting point for next fit (opt.)
fit.check_roundoff()
if nexp == 4:
sys.stdout = tee.tee(sys.stdout,open("eg2.out","w"))
print '************************************* nexp =',nexp
print fit # print the fit results
E = fit.p['E'] # best-fit parameters
a = fit.p['a']
print 'E1/E0 =',E[1]/E[0],' E2/E0 =',E[2]/E[0]
print 'a1/a0 =',a[1]/a[0],' a2/a0 =',a[2]/a[0]
sys.stdout = sys_stdout
print
#
if DO_BOOTSTRAP:
Nbs = 10 # number of bootstrap copies
outputs = {'E1/E0':[], 'E2/E0':[], 'a1/a0':[],'a2/a0':[],'E1':[],'a1':[]} # results
for bsfit in fit.bootstrap_iter(n=Nbs):
E = bsfit.pmean['E'] # best-fit parameters
a = bsfit.pmean['a']
outputs['E1/E0'].append(E[1]/E[0]) # accumulate results
outputs['E2/E0'].append(E[2]/E[0])
outputs['a1/a0'].append(a[1]/a[0])
outputs['a2/a0'].append(a[2]/a[0])
outputs['E1'].append(E[1])
outputs['a1'].append(a[1])
# print E[:2]
# print a[:2]
# print bsfit.chi2/bsfit.dof
# extract means and standard deviations from the bootstrap output
for k in outputs:
outputs[k] = gv.gvar(np.mean(outputs[k]),np.std(outputs[k]))
print 'Bootstrap results:'
print 'E1/E0 =',outputs['E1/E0'],' E2/E1 =',outputs['E2/E0']
print 'a1/a0 =',outputs['a1/a0'],' a2/a0 =',outputs['a2/a0']
print 'E1 =',outputs['E1'],' a1 =',outputs['a1']
if DO_PLOT:
print fit.format(100) # print the fit results
import pylab as pp
from gvar import mean,sdev
fity = f(x,fit.pmean)
ratio = y/fity
pp.xlim(0,21)
pp.xlabel('x')
pp.ylabel('y/f(x,p)')
pp.errorbar(x=gv.mean(x),y=gv.mean(ratio),yerr=gv.sdev(ratio),fmt='ob')
pp.plot([0.0,21.0],[1.0,1.0])
pp.show()
def main():
sys_stdout = sys.stdout
# version 1 - relative errors
sys.stdout = tee.tee(sys_stdout, open("eg7a.out", "w"))
# fit data and prior
x = np.array([1., 2., 3., 4.])
y = np.array([3.4422, 1.2929, 0.4798, 0.1725])
prior = gv.gvar(['10(1)', '1.0(1)'])
# fit function
def fcn(x, p):
return p[0] * gv.exp(-p[1] * x)
# find optimal dy
def fitargs(z):
dy = y * z
newy = gv.gvar(y, dy)
return dict(data=(x, newy), fcn=fcn, prior=prior)
fit, z = lsqfit.empbayes_fit(0.001, fitargs)
print fit.format(True)
if MAKE_PLOT:
ratio = fit.y / fcn(x, fit.pmean)
plt.errorbar(x=fit.x, y=gv.mean(ratio), yerr=gv.sdev(ratio), c='b')
plt.plot([0.5, 4.5], [1.0, 1.0], c='r')
# version 2 - additive errors
sys.stdout = tee.tee(sys_stdout, open("eg7b.out", "w"))
def fitargs(z):
dy = np.ones_like(y) * z
newy = gv.gvar(y, dy)
return dict(data=(x, newy), fcn=fcn, prior=prior)
fit, z = lsqfit.empbayes_fit(0.001, fitargs)
print fit.format(True)
if MAKE_PLOT:
ratio = fit.y / fcn(x, fit.pmean)
plt.errorbar(x=fit.x + 0.1,
y=gv.mean(ratio),
yerr=gv.sdev(ratio),
c='g')
plt.show()
def diff_decay_rate_fixed_q_sq(self, ml, qsq):
z = self.q_sq2z(qsq)
fp = self.fcn(z, self.params())['f+'] / self.Pphi(qsq, 'f+')
f0 = self.fcn(z, self.params())['f0'] / self.Pphi(qsq, 'f0')
ans_GeV = self.factor_overall(ml, qsq) * (self.factor_fplus(ml, qsq) * fp**2 +
self.factor_fzero(ml, qsq) * f0**2)
ans_PS = ans_GeV / const.GEV_TO_PS
return [qsq, gv.mean(ans_PS), gv.sdev(ans_PS)]
def main():
gv.ranseed([2009,2010,2011,2012]) # initialize random numbers (opt.)
x,y = make_data() # make fit data
p0 = None # make larger fits go faster (opt.)
for nexp in range(3,8):
print('************************************* nexp =',nexp)
prior = make_prior(nexp)
# eps = gv.gvar(1,1e-300) # use svdcut to make it independent
# prior['a'] *= eps
# y *= eps
fit = lsqfit.nonlinear_fit(data=(x,y),fcn=f,prior=prior,
p0=p0,svdcut=SVDCUT)
print(fit) # print the fit results
E = fit.p['E'] # best-fit parameters
a = fit.p['a']
print('E1/E0 =',(E[1]/E[0]).fmt(),' E2/E0 =',(E[2]/E[0]).fmt())
print('a1/a0 =',(a[1]/a[0]).fmt(),' a2/a0 =',(a[2]/a[0]).fmt())
print()
if fit.chi2/fit.dof<1.:
p0 = fit.pmean # starting point for next fit (opt.)
if DO_BOOTSTRAP:
Nbs = 10 # number of bootstrap copies
outputs = {'E1/E0':[], 'E2/E0':[], 'a1/a0':[],'a2/a0':[],'E1':[],'a1':[]} # results
for bsfit in fit.bootstrap_iter(n=Nbs):
E = bsfit.pmean['E'] # best-fit parameters
a = bsfit.pmean['a']
outputs['E1/E0'].append(E[1]/E[0]) # accumulate results
outputs['E2/E0'].append(E[2]/E[0])
outputs['a1/a0'].append(a[1]/a[0])
outputs['a2/a0'].append(a[2]/a[0])
outputs['E1'].append(E[1])
outputs['a1'].append(a[1])
# print E[:2]
# print a[:2]
# print bsfit.chi2/bsfit.dof
# extract means and standard deviations from the bootstrap output
for k in outputs:
outputs[k] = gv.dataset.avg_data(outputs[k],bstrap=True).fmt(3)
# gv.gvar(np.mean(outputs[k]),
# np.std(outputs[k])).fmt(3)
print('Bootstrap results:')
print('E1/E0 =',outputs['E1/E0'],' E2/E0 =',outputs['E2/E0'])
print('a1/a0 =',outputs['a1/a0'],' a2/a0 =',outputs['a2/a0'])
print('E1 =',outputs['E1'],' a1 =',outputs['a1'])
if DO_PLOT:
print(fit.format(100)) # print the fit results
import pylab as plt
ratio = y/f(x,fit.pmean)
plt.xlim(0,21)
plt.xlabel('x')
plt.ylabel('y/f(x,p)')
plt.errorbar(x=x,y=gv.mean(ratio),yerr=gv.sdev(ratio),fmt='ob')
plt.plot([0.0,21.0],[1.0,1.0])
plt.show()
def plot_eff_mass_fit_NM(m_e_kf,f_NM_1, par_NM_1,f_NM_2, par_NM_2):
x_plot = np.arange(1,22)
x_plot = x_plot*0.01
y_plot = []
for h in range(6):
y_plot.append (m_e_kf[:,h,1])
y_plot = gv.dataset.avg_data(y_plot,spread=True)
fig = plt.figure()
plt.errorbar(x_plot,gv.mean (y_plot) ,gv.sdev(y_plot), fmt='ok',label='data (68% CL)')
plt.fill_between (x_plot, gv.mean(1/f_NM_2(x_plot,par_NM_2))+ gv.sdev(1/f_NM_2(x_plot,par_NM_2))
,gv.mean(1/f_NM_2(x_plot,par_NM_2))-gv.sdev(1/f_NM_2(x_plot,par_NM_2)),label='quadratic fit (68% CL)'
,color ='red', alpha=0.6)
plt.fill_between (x_plot, gv.mean(1/f_NM_2(x_plot,par_NM_2))+ 2*gv.sdev(1/f_NM_2(x_plot,par_NM_2))
,gv.mean(1/f_NM_2(x_plot,par_NM_2))-2*gv.sdev(1/f_NM_2(x_plot,par_NM_2)),label='quadratic fit (95% CL)'
,color ='red', alpha=0.4)
plt.fill_between (x_plot, gv.mean(1/f_NM_1(x_plot,par_NM_1))+ gv.sdev(1/f_NM_1(x_plot,par_NM_1))
,gv.mean(1/f_NM_1(x_plot,par_NM_1))-gv.sdev(1/f_NM_1(x_plot,par_NM_1)),label='linear fit (68% CL)'
,color ='blue', alpha=0.6)
plt.fill_between (x_plot, gv.mean(1/f_NM_1(x_plot,par_NM_1))+ 2*gv.sdev(1/f_NM_1(x_plot,par_NM_1))
,gv.mean(1/f_NM_1(x_plot,par_NM_1))-2*gv.sdev(1/f_NM_1(x_plot,par_NM_1)),label='linear fit (95% CL)'
,color ='blue', alpha=0.4)
for h in range(6):
plt.plot (x_plot, m_e_kf[:,h,1],color='k', alpha=0.6)
plt.text(0.212,m_e_kf[20,0,1],'H'+str(1)+'')
plt.text(0.212,m_e_kf[20,1,1]-0.005,'H'+str(2)+'')
plt.text(0.212,m_e_kf[20,2,1],'H'+str(3)+'')
plt.text(0.212,m_e_kf[20,3,1]-0.006,'H'+str(4)+'')
plt.text(0.212,m_e_kf[20,4,1],'H'+str(5)+'')
plt.text(0.212,m_e_kf[20,5,1],'H'+str(7)+'')
#legend = plt.legend (loc='lower left')
plt.xlabel ("$n$ (fm$^{-3}$)",fontsize='15')
plt.ylabel ("$m_n^{*}/m$",fontsize='15')
plt.text (0.06,1.03,'Neutron matter',fontsize='15')
plt.xticks(np.arange(0, 0.2+0.01, 0.05),fontsize='14' )
plt.yticks(fontsize='14' )
plt.tick_params(right=True)
plt.tick_params(top=True)
plt.tick_params(direction='in')
plt.show()
def tabulate_avg(avgout, format=(6, 3)):
""" Tabulates averages and standard deviations.
tabulate_avg(...) creates a nicely formatted table displaying the
output from functions like ``dataset.Dataset.gdev``. Here ``avgout`` is
the output. Parameter ``format`` specifies the output format:
``format=(N,D)`` implies that format ``'%N.Df(%Dd)'`` is used to print
``avg,int(10**D * std_dev)``. The table is returned as a single string,
for printing.
"""
table = []
output = avgout.items()
output.sort()
for tag, avsd in output:
try:
av = avsd.mean
sd = avsd.sdev
except AttributeError:
av = gvar.mean(avsd)
sd = gvar.sdev(avsd)
lines = ''
line = '%15s' % str(tag)
try:
sdfac = 10**format[1]
fmt = (' %' + str(format[0]) + '.' + str(format[1]) + 'f(%' +
str(format[1]) + 'd)')
def avgfmt(av, sd, fmt=fmt, sdfac=sdfac):
try:
return fmt % (av, int(sdfac * sd + 0.5))
except:
return (' %g (%.4g)' % (av, sd))
##
except:
def avgfmt(av, sd):
return (' %g (%.4g)' % (av, sd))
##
na = len(av)
if len(sd) < na:
na = len(sd)
if na >= 1:
for i in xrange(na):
if len(sd.shape) == 2:
sdi = math.sqrt(sd[i][i])
else:
sdi = sd[i]
nextfield = avgfmt(av[i], sdi)
if (len(nextfield) + len(line)) > 78:
lines = lines + line + '\n'
line = ''.ljust(15) + nextfield
else:
line = line + nextfield
table.append(lines + line + '\n')
return '\n'.join(table)
def make_plot(x, y, fit, ylabel='y(x)', xmax=1.0, name='appendix1'):
global NPLT
if not MAKE_PLOTS:
return
plt.errorbar(x, gv.mean(y), gv.sdev(y), fmt='bo')
x = np.arange(0., xmax, 0.01)
yfit = f(x, fit.p)
plt.plot(x, gv.mean(yfit), 'k--')
yplus = gv.mean(yfit) + gv.sdev(yfit)
yminus = gv.mean(yfit) - gv.sdev(yfit)
plt.fill_between(x, yminus, yplus, color='0.8')
plt.xlim(0, 1)
plt.ylim(0.3, 1.9)
plt.xlabel('x')
NPLT += 1
plt.ylabel(ylabel)
plt.savefig(name + '.png', bbox_inches='tight')
plt.show()
def _valid(arr):
"""Restricts to elements which are neither infinite nor nans."""
mean = gv.mean(arr)
sdev = gv.sdev(arr)
mask = np.isfinite(mean)\
& np.isfinite(sdev)\
& ~np.isnan(mean)\
& ~np.isnan(sdev)
return arr[mask]
def main():
gv.ranseed([2009,2010,2011,2012]) # initialize random numbers (opt.)
x,y = make_data() # make fit data
p0 = None # make larger fits go faster (opt.)
for nexp in range(3,8):
print('************************************* nexp =',nexp)
prior = make_prior(nexp)
fit = lsqfit.nonlinear_fit(data=(x,y),fcn=f,prior=prior,p0=p0,svdcut=SVDCUT)
print(fit) # print the fit results
E = fit.p['E'] # best-fit parameters
a = fit.p['a']
print('E1/E0 =',(E[1]/E[0]).fmt(),' E2/E0 =',(E[2]/E[0]).fmt())
print('a1/a0 =',(a[1]/a[0]).fmt(),' a2/a0 =',(a[2]/a[0]).fmt())
print()
if fit.chi2/fit.dof<1.:
p0 = fit.pmean # starting point for next fit (opt.)
if DO_ERRORBUDGET:
outputs = OrderedDict([
('E1/E0', E[1]/E[0]), ('E2/E0', E[2]/E[0]),
('a1/a0', a[1]/a[0]), ('a2/a0', a[2]/a[0])
])
inputs = OrderedDict([
('E', fit.prior['E']), ('a', fit.prior['a']),
('y', y), ('svd', fit.svdcorrection)
])
print(fit.fmt_values(outputs))
print(fit.fmt_errorbudget(outputs,inputs))
if DO_EMPBAYES:
def fitargs(z,nexp=nexp,prior=prior,f=f,data=(x,y),p0=p0):
z = gv.exp(z)
prior['a'] = [gv.gvar(0.5,0.5*z[0]) for i in range(nexp)]
return dict(prior=prior,data=data,fcn=f,p0=p0)
##
z0 = [0.0]
fit,z = lsqfit.empbayes_fit(z0,fitargs,tol=1e-3)
print(fit) # print the optimized fit results
E = fit.p['E'] # best-fit parameters
a = fit.p['a']
print('E1/E0 =',(E[1]/E[0]).fmt(),' E2/E0 =',(E[2]/E[0]).fmt())
print('a1/a0 =',(a[1]/a[0]).fmt(),' a2/a0 =',(a[2]/a[0]).fmt())
print("prior['a'] =",fit.prior['a'][0].fmt())
print()
if DO_PLOT:
import pylab as pp
from gvar import mean,sdev
fity = f(x,fit.pmean)
ratio = y/fity
pp.xlim(0,21)
pp.xlabel('x')
pp.ylabel('y/f(x,p)')
pp.errorbar(x=x,y=mean(ratio),yerr=sdev(ratio),fmt='ob')
pp.plot([0.0,21.0],[1.0,1.0])
pp.show()
def _infer_tmax(ydata, noise_threshy):
"""Infer the maximum time with noise-to-signal below a threshold."""
if noise_threshy is None:
return len(ydata) - 1
good = gv.sdev(ydata) / gv.mean(ydata) < noise_threshy
if np.all(good):
tmax = len(ydata) - 1
else:
tmax = np.argmin(good)
return tmax
def inflate(params, frac):
"""
Inflates the width on the priors to frac*mean, unless the existing width is
already wider.
"""
for key, value in params.items():
mean = gv.mean(value)
sdev = np.maximum(frac * np.abs(mean), gv.sdev(value))
params[key] = gv.gvar(mean, sdev)
return params
def show_plot(t_array, th_array):
""" Display theta vs t plot. """
th_mean = gv.mean(th_array)
th_sdev = gv.sdev(th_array)
thp = th_mean + th_sdev
thm = th_mean - th_sdev
plt.fill_between(t_array, thp, thm, color='0.8')
plt.plot(t_array, th_mean, linewidth=0.5)
plt.xlabel('$t$')
plt.ylabel(r'$\theta(t)$')
plt.savefig('pendulum.pdf', bbox_inches='tight')
plt.show()
def show_plot(t_array, th_array):
""" Display theta vs t plot. """
th_mean = gv.mean(th_array)
th_sdev = gv.sdev(th_array)
thp = th_mean + th_sdev
thm = th_mean - th_sdev
plt.fill_between(t_array, thp, thm, color='r', alpha=0.2) # color='0.8')
plt.plot(t_array, th_mean, linewidth=0.5, color='r')
plt.xlabel('$t$')
plt.ylabel(r'$\theta(t)$')
plt.savefig('case-pendulum.png', bbox_inches='tight')
plt.show()
def tabulate_avg(avgout,format=(6,3)):
""" Tabulates averages and standard deviations.
tabulate_avg(...) creates a nicely formatted table displaying the
output from functions like ``dataset.Dataset.gdev``. Here ``avgout`` is
the output. Parameter ``format`` specifies the output format:
``format=(N,D)`` implies that format ``'%N.Df(%Dd)'`` is used to print
``avg,int(10**D * std_dev)``. The table is returned as a single string,
for printing.
"""
table = []
output = avgout.items()
output.sort()
for tag,avsd in output:
try:
av = avsd.mean
sd = avsd.sdev
except AttributeError:
av = gvar.mean(avsd)
sd = gvar.sdev(avsd)
lines = ''
line = '%15s' % str(tag)
try:
sdfac = 10**format[1]
fmt = (' %'+str(format[0])+'.'+str(format[1])+
'f(%'+str(format[1])+'d)')
def avgfmt(av,sd,fmt=fmt,sdfac=sdfac):
try:
return fmt % (av,int(sdfac*sd+0.5))
except:
return (' %g (%.4g)' % (av,sd))
##
except:
def avgfmt(av,sd):
return (' %g (%.4g)' % (av,sd))
##
na = len(av)
if len(sd)<na:
na = len(sd)
if na>=1:
for i in xrange(na):
if len(sd.shape)==2:
sdi = math.sqrt(sd[i][i])
else:
sdi = sd[i]
nextfield = avgfmt(av[i],sdi)
if (len(nextfield)+len(line))>78:
lines = lines + line + '\n'
line = ''.ljust(15) + nextfield
else:
line = line + nextfield
table.append(lines + line +'\n')
return '\n'.join(table)
def avg_quark_prop(size_list=[8, 8, 8, 8],
cfgs_list=range(200, 1200, 50),
src_type='evenodd_wall',
t0=0,
color_list=[0],
ens_tag='',
prop_tag='eoprop_',
mass=0.5,
figname='',
**lat_kwargs):
"""
This function loads the propagators calculated in :meth:`gauge_tools.examples.staggered_quark_prop`
and averages them. Most key word arguments are similar to those of :meth:`gauge_tools.examples.staggered_quark_prop`,
except for ``figname``, which if not an empyt string, is a signal to create a figure and save it as a pdf in `figname`.
"""
fname_load = lambda ind_cfg: "{}{}m{}_{}.npy".format(
ens_tag, prop_tag, mass, ind_cfg)
fname_save = "{}{}m{}_avg.p".format(ens_tag, prop_tag, mass)
import gauge_tools as gt
lat = gt.lattice(*size_list, **lat_kwargs)
props_list = []
props_projected = []
for n_cfg in cfgs_list:
prop_v_field = np.load(fname_load(n_cfg), allow_pickle=True)
props_list.append(prop_v_field)
props_projected.append(
gt.util.quark.propagator.ks_project_spatialmom(
prop_v_field, color=color_list[0]))
props_proj_gvar = gv.dataset.avg_data(props_projected)
pickle.dump(
dict(mean=gv.mean(props_proj_gvar), cov=gv.evalcov(props_proj_gvar)),
open(fname_save, 'wb'))
avg_quark_prop.props_list = props_list
avg_quark_prop.props_proj_gvar = props_proj_gvar
avg_quark_prop.lat = lat
if figname != '' and PLOTS:
plt.ion()
fig = plt.figure()
plt.errorbar(range(len(props_proj_gvar)),
np.abs(gv.mean(props_proj_gvar)),
gv.sdev(props_proj_gvar),
fmt='.',
label='interacting')
free_theory(gt,
src_type=src_type,
t0=t0,
mass=mass,
color_list=color_list,
print_=False)
plt.title('qaurk propagator in free and interacting theory')
plt.legend()
plt.yscale('log')
fig.savefig(figname, format="pdf")
def plot_static_potential(r, V, figname='', T_snap=2):
fig = plt.figure(figsize=(4, 4))
Y_mean = [V_r[T_snap] for V_r in gv.mean(V)]
Y_sdev = [V_r[T_snap] for V_r in gv.sdev(V)]
plt.errorbar(r, Y_mean, Y_sdev, fmt='.', capsize=4)
plt.xlabel(r"$R/a$")
plt.ylabel(r"$V(R)|_{%d,%d}$" % (T_snap, 1 + T_snap))
plt.xlim([min(r) - 0.2, max(r) + 0.2])
plt.grid()
plt.tight_layout()
if figname != '':
fig.savefig(figname, format="pdf")
def plot_n2s(self, ax=None, **kwargs):
"""Plot the noise-to-signal ratio."""
if ax is None:
_, ax = plt.subplots(1)
y = self.ydata
y = gv.sdev(y) / gv.mean(y) * 100
x = self.times.tdata
ax = plt.mirror(ax=ax, x=x, y=y, **kwargs)
ax.set_yscale("log")
ax.set_ylabel("n/s [%]")
ax.set_xlabel("t/a")
return ax
def make_plot(param, data, fit):
import matplotlib.pyplot as plt
plt.cla()
f = gv.cspline.CSpline(
fit.p['mknot'], fit.p['fknot'],
)
coliter = iter(['r', 'b', 'g'])
m = np.arange(1, 9, 0.1)
fm = f(m)
fmavg = gv.mean(fm)
fmplus = fmavg + gv.sdev(fm)
fmminus = fmavg - gv.sdev(fm)
plt.fill_between(m, fmplus, fmminus, color='k', alpha=0.20)
plt.plot(m, fmavg, 'k:')
# true function
fm = 1. - .3 / m - .3 / m**2
plt.plot(m, fm, 'k--')
for s in data:
plt.plot()
ainv, am = param[s]
ms = ainv * am
d = gv.mean(data[s])
derr = gv.sdev(data[s])
col = next(coliter)
plt.errorbar(x=ms, y=d, yerr=derr, fmt=col + 'o')
plt.text(ms[-1] - 0.6, d[-1], s, color=col, fontsize='x-large')
fs = gv.mean(fm)
ams = m / ainv
idx = ams < am[-1]
ams = ams[idx]
fs = gv.mean(fm[idx])
for i, ci in enumerate(fit.p['c']):
fs += ci.mean * ams ** (2 * (i + 1))
plt.plot(m[idx], fs, col + ':')
plt.xlabel('m')
plt.ylabel('f')
plt.text(8, 0.65, 'f(m)', fontsize='x-large')
plt.savefig('eg-spline.png', bbox_inches='tight')
plt.show()
def dump_results(output_dir: str,
fit: Fit,
model: CompartmentModel,
extend_days: int = 30):
"""Exports fit and model to pickle file, saves forecast as csv and saves plot
"""
now_dir = datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
dir_name = path.join(output_dir, now_dir)
if not path.exists(dir_name):
makedirs(dir_name, exist_ok=True)
# Write fit to file. Can be read with gvar.load(file)
dump(
{
"model": model,
"fit": fit
},
outputfile=path.join(dir_name, "fit.pickle"),
)
# Extend day range for next steps
xx = fit.x.copy()
if extend_days:
xx["dates"] = xx["dates"].union(
date_range(xx["dates"].max(), freq="D", periods=extend_days))
# Generate new prediction
prediction_df = model.propagate_uncertainties(xx, fit.p)
prediction_df.index = prediction_df.index.round("H")
if model.fit_start_date:
prediction_df = prediction_df.loc[model.fit_start_date:]
# Dump forecast
(prediction_df.stack().apply(
lambda el: Series(dict(mean=mean(el), sdev=sdev(el)))).reset_index(
level=1).rename(columns={
"level_1": "kind"
}).to_csv(path.join(dir_name, "forecast.csv")))
# Dump plot
fig = plot_fit(
prediction_df,
columns=(
("hospital_census", "vent_census"),
("hospital_admits", "vent_admits"),
),
data={key: fit.y.T[ii]
for ii, key in enumerate(model.fit_columns)},
)
fig.savefig(path.join(dir_name, "forecast.pdf"), bbox_inches="tight")
def test_inv(self):
m = self.make_random([[1., 0.1], [0.1, 2.]])
one = gv.gvar([['1(0)', '0(0)'], ['0(0)', '1(0)']])
invm = linalg.inv(m)
self.assertTrue(gv.equivalent(linalg.inv(invm), m))
for mm in [invm.dot(m), m.dot(invm)]:
np.testing.assert_allclose(
gv.mean(mm), [[1, 0], [0, 1]], rtol=1e-10, atol=1e-10
)
np.testing.assert_allclose(
gv.sdev(mm), [[0, 0], [0, 0]], rtol=1e-10, atol=1e-10
)
p = linalg.det(m) * linalg.det(invm)
self.assertAlmostEqual(p.mean, 1.)
self.assertGreater(1e-10, p.sdev)
def test_histogram(self):
x = gv.gvar([5., 3.], [[4., 0.2], [0.2, 1.]])
xsum = x[0] + x[1]
integ = PDFIntegrator(x)
hist = gv.PDFHistogram(xsum, nbin=40, binwidth=0.2)
integ(neval=1000, nitn=5)
def fhist(x):
return hist.count(x[0] + x[1])
r = integ(fhist, neval=1000, nitn=5, adapt=False)
bins, prob, stat, norm = hist.analyze(r)
self.assertTrue(abs(gv.mean(np.sum(prob)) - 1.) < 5. * gv.sdev(np.sum(prob)))
self.assertTrue(abs(stat.mean.mean - xsum.mean) < 5. * stat.mean.sdev)
self.assertTrue(abs(stat.sdev.mean - xsum.sdev) < 5. * stat.sdev.sdev)
self.assertTrue(abs(stat.skew.mean) < 5. * stat.skew.sdev)
self.assertTrue(abs(stat.ex_kurt.mean) < 5. * stat.ex_kurt.sdev)
def test_apply(self):
" EigenBasis EigenBasis.apply EigenBasis.unapply "
for tdata in [[1.0, 2.0, 3.0, 4.0], [2.0, 4.0, 6.0, 8.0], [0, 1.0, 2.0]]:
tdata = np.array(tdata)
G = self.make_G(tdata, keyfmt="{s1}{s2}", srcs="ab")
basis = EigenBasis(data=G, keyfmt="{s1}{s2}", srcs="ab", t=2, tdata=tdata)
np.testing.assert_allclose(basis.E, self.E)
newG = basis.apply(G, "{s1}{s2}")
newG_mean = gv.mean(newG)
np.testing.assert_allclose(newG_mean["00"], gv.exp(-self.E[0] * tdata))
np.testing.assert_allclose(newG_mean["11"], gv.exp(-self.E[1] * tdata))
np.testing.assert_allclose(newG_mean["01"], 0, atol=1e-10)
np.testing.assert_allclose(newG_mean["10"], 0, atol=1e-10)
oldG = basis.unapply(newG, "{s1}{s2}")
for k in ["aa", "ab", "ba", "bb"]:
np.testing.assert_allclose(gv.mean(oldG[k] - G[k]), 0, atol=1e-10)
np.testing.assert_allclose(gv.sdev(oldG[k] - G[k]), 0, atol=1e-10)
def main():
# pendulum data exhibits experimental error in ability to measure theta
t = [ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.]
theta = gv.gvar([
'1.477(79)', '0.791(79)', '-0.046(79)', '-0.852(79)',
'-1.523(79)', '-1.647(79)', '-1.216(79)', '-0.810(79)',
'0.185(79)', '0.832(79)'
])
# prior: assume experimental error in ability to specify theta(0)
prior = gv.BufferDict()
prior['g/l'] = (2 * math.pi) ** 2 * gv.gvar(1, 0.1)
prior['theta(0)'] = gv.gvar(math.pi / 2., 0.05)
# fit function: use class Pendulum object to integrate pendulum motion
def fitfcn(p, t=t):
pendulum = Pendulum(p['g/l'])
return pendulum(p['theta(0)'], t)
# do the fit and print results
fit = lsqfit.nonlinear_fit(data=theta, prior=prior, fcn=fitfcn)
print(fit.format(maxline=True))
print('fit/exact for (g/l) =', fit.p['g/l'] / (2*math.pi) ** 2)
print('fit/exact for theta(0) =', fit.p['theta(0)'] / (math.pi / 2.))
if MAKE_PLOT:
# make figure (saved to file pendulum.pdf)
plt.figure(figsize=(4,3))
# start plot with data
plt.errorbar(
x=t, y=gv.mean(theta), yerr=gv.sdev(theta),
fmt='k.',
)
# use best-fit function to add smooth curve for 100 points
t = np.linspace(0., 1.1, 100)
th = fitfcn(fit.p, t)
show_plot(t, th)
def test_apply(self):
" EigenBasis EigenBasis.apply EigenBasis.unapply "
for tdata in [
[1., 2., 3., 4.],
[2., 4., 6., 8.],
[0, 1., 2.],
]:
tdata = np.array(tdata)
G = self.make_G(tdata, keyfmt='{s1}{s2}', srcs='ab')
basis = EigenBasis(
data=G, keyfmt='{s1}{s2}', srcs='ab',
t=2, tdata=tdata,
)
np.testing.assert_allclose(basis.E, self.E)
newG = basis.apply(G, '{s1}{s2}')
newG_mean = gv.mean(newG)
np.testing.assert_allclose(newG_mean['00'], gv.exp(-self.E[0] * tdata))
np.testing.assert_allclose(newG_mean['11'], gv.exp(-self.E[1] * tdata))
np.testing.assert_allclose(newG_mean['01'], 0, atol=1e-10)
np.testing.assert_allclose(newG_mean['10'], 0, atol=1e-10)
oldG = basis.unapply(newG, '{s1}{s2}')
for k in ['aa', 'ab', 'ba', 'bb']:
np.testing.assert_allclose(gv.mean(oldG[k] - G[k]), 0, atol=1e-10)
np.testing.assert_allclose(gv.sdev(oldG[k] - G[k]), 0, atol=1e-10)
def plot_corr_normalized(models,data,fit,**kwargs):
"""
Get all data ready so that it can be plotted on command
Allows for dynamic cycling through plots
"""
_fnNMod = len(models)
_fnIdx = [0] ## -- index of plotted function, in array so it can be modified in functions
## -- objects to hold all plot data
## - Dat/Fit refers to the correlator data or the fit function
## - Central/Error are the central value and errors
_fnDatCentral = []
_fnDatError = []
_fnFitOnes = []
_fnFitError = []
#
## -- other objects
_fnTDataNonZero = []
_fnTFitNonZero = []
_fnTData = []
_fnTFit = []
_fnTRem = [] # number of previous timeslices removed
fig,ax = plt.subplots(1)
#
## -- setup plot function
def do_plot_normalized(idx,fig=fig):
fig.clear()
ax = fig.add_subplot(111)
key = models[idx[0]].datatag
ax.set_xlim([-1,len(_fnTData[idx[0]])])
ax.set_ylim(utp.get_option("y_limit",[0.2,1.8],**kwargs[key]))
#
## -- plot fit
ax.plot(_fnTDataNonZero[idx[0]],_fnFitOnes[idx[0]],
color=utp.get_option("color2",'b',**kwargs[key]))
ax.plot(_fnTDataNonZero[idx[0]],_fnFitError[idx[0]][0],
color=utp.get_option("color2",'g',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
ax.plot(_fnTDataNonZero[idx[0]],_fnFitError[idx[0]][1],
color=utp.get_option("color2",'g',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
## -- plot correlator data
ax.errorbar(_fnTDataNonZero[idx[0]],_fnDatCentral[idx[0]],yerr=_fnDatError[idx[0]],
mfc=utp.get_option("markerfacecolor1",'None',**kwargs[key]),
mec=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
color=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
ls=utp.get_option("linestyle1",'None',**kwargs[key]),
marker=utp.get_option("marker1",'o',**kwargs[key]),
ms=utp.get_option("markersize",6,**kwargs[key]))
ax.scatter(_fnTFitNonZero[idx[0]],
[ _fnDatCentral[idx[0]][t] for t in
list(np.array(_fnTFitNonZero[idx[0]])-np.array(_fnTRem[idx[0]])) ],
color=utp.get_option("color1",'r',**kwargs[key]),
marker=utp.get_option("marker",'o',**kwargs[key]),
s=utp.get_option("markersize",36,**kwargs[key]))
fig.suptitle(utp.get_option("plottitlefn",str(idx[0])+" default title "+str(key),**kwargs[key]),
fontsize=utp.get_option("titlesize",20,**kwargs[key]))
## -- modify some options
ax.set_xlabel(r'$t$')
ax.set_ylabel(utp.get_option("yaxistitle",r"$C(t)/C_{fit}(t)$",**kwargs[key]))
for item in ([ax.xaxis.label,ax.yaxis.label]):
# must be after setting label content (LaTeX ruins it)
item.set_fontsize(fontsize=utp.get_option("fontsize",20,**kwargs[key]))
rect =fig.patch
rect.set_facecolor('white')
if utp.get_option("to_file",False,**kwargs[key]):
save_dir = utp.get_option("fn_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("fn_save_name","fnplot-"+key+".pdf",**kwargs[key])
plt.savefig(save_dir+'/'+save_name)
if utp.get_option("to_terminal",True,**kwargs[key]):
plt.draw()
pass
#
## -- setup button press action function
def press_normalized(event,idx=_fnIdx):
#print('press_normalized', event.key)
try:
## -- manually indicate index
idx[0] = int(event.key) + (idx[0])*10
except ValueError:
if event.key==' ': ## -- space
## -- allows for replotting when changing index by typing number keys
idx[0] = idx[0] % _fnNMod
do_plot_normalized(idx)
elif event.key=='left':
idx[0] = (idx[0] - 1) % _fnNMod
do_plot_normalized(idx)
elif event.key=='right':
idx[0] = (idx[0] + 1) % _fnNMod
do_plot_normalized(idx)
elif event.key=='backspace':
## -- reset index so can manually flip through using number keys
idx[0] = 0
elif event.key=='d':
## -- dump plots into ./plotdump directory
for ix,model in zip(range(len(models)),models):
key = model.datatag
save_dir = utp.get_option("fn_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("fn_save_name","fnplot-"+key+".png",**kwargs[key])
do_plot_normalized([ix])
plt.savefig(save_dir+'/'+save_name)
do_plot_normalized(idx)
#
## --
fig.canvas.mpl_connect('key_press_event',press_normalized)
## -- save plot data
for idx,model in zip(range(len(models)),models):
key = model.datatag
_fnTData.append(model.tdata)
_fnTFit.append(model.tfit)
_fnTFit[-1] = np.append(_fnTFit[-1],list(sorted([len(_fnTData[-1]) - t for t in _fnTFit[-1]])))
## -- fit
_fnFitFunc = utp.create_fit_func(model,fit)
_fnFitMean = gv.mean(_fnFitFunc(_fnTData[-1]))
_fnTDataNonZero.append([t for t in _fnTData[-1] if np.abs(_fnFitMean[t]) > 1e-20])
_fnTFitNonZero.append([t for t in _fnTFit[-1] if np.abs(_fnFitMean[t]) > 1e-20])
_fnTRem.append([(0 if np.abs(_fnFitMean[t]) > 1e-20 else 1) for t in model.tdata])
_fnTRem[-1] = \
[sum(_fnTRem[-1][:i+1]) for i in range(len(_fnTRem[-1])) if i in _fnTFitNonZero[-1]]
_fnFitMean = gv.mean(_fnFitFunc(_fnTDataNonZero[-1]))
_fnFitSdev = list(np.array(gv.sdev(_fnFitFunc(_fnTDataNonZero[-1])))/np.array(_fnFitMean))
_fnFitOnes.append(list(np.ones(len(_fnTDataNonZero[-1]))))
_fnFitError.append([ list(np.array(_fnFitOnes[-1])-np.array(_fnFitSdev)),
list(np.array(_fnFitOnes[-1])+np.array(_fnFitSdev)) ])
## -- data
_fnDatCentral.append( list(np.array([gv.mean(data[key])[t] for t in _fnTDataNonZero[-1]])/
np.array(_fnFitMean)) )
_fnDatSdev = ( np.array([gv.sdev(data[key])[t] for t in _fnTDataNonZero[-1]])/
np.array(_fnFitMean) )
_fnDatError.append([ list(_fnDatSdev), list(_fnDatSdev) ])
## -- done saving data
if not(utp.get_option("to_terminal",True,**kwargs[key])) and\
utp.get_option("to_file",False,**kwargs[key]):
for ix in range(len(models)):
## -- loops and saves all without creating window
do_plot_normalized([ix])
else:
do_plot_normalized(_fnIdx)
def main():
gv.ranseed([2009,2010,2011,2012]) # initialize random numbers (opt.)
x,y = make_data() # make fit data
p0 = None # make larger fits go faster (opt.)
sys_stdout = sys.stdout
sys.stdout = tee.tee(sys.stdout, open("eg1.out","w"))
for nexp in range(1, 11):
prior = make_prior(nexp)
fit = lsqfit.nonlinear_fit(data=(x,y),fcn=f,prior=prior,p0=p0) #, svdcut=SVDCUT)
if fit.chi2/fit.dof<1.:
p0 = fit.pmean # starting point for next fit (opt.)
if nexp > 5 and nexp < 10:
print(".".center(73))
continue
elif nexp not in [1]:
print("")
print '************************************* nexp =',nexp
print fit.format() # print the fit results
E = fit.p['E'] # best-fit parameters
a = fit.p['a']
if nexp > 2:
print 'E1/E0 =',E[1]/E[0],' E2/E0 =',E[2]/E[0]
print 'a1/a0 =',a[1]/a[0],' a2/a0 =',a[2]/a[0]
# redo fit with 4 parameters since that is enough
prior = make_prior(4)
fit = lsqfit.nonlinear_fit(data=(x,y), fcn=f, prior=prior, p0=fit.pmean)
sys.stdout = sys_stdout
print fit
# extra data 1
print '\n--------------------- fit with extra information'
sys.stdout = tee.tee(sys_stdout, open("eg1a.out", "w"))
def ratio(p):
return p['a'][1] / p['a'][0]
newfit = lsqfit.nonlinear_fit(data=gv.gvar(1,1e-5), fcn=ratio, prior=fit.p)
print (newfit)
E = newfit.p['E']
a = newfit.p['a']
print 'E1/E0 =',E[1]/E[0],' E2/E0 =',E[2]/E[0]
print 'a1/a0 =',a[1]/a[0],' a2/a0 =',a[2]/a[0]
# alternate method for extra data
sys.stdout = tee.tee(sys_stdout, open("eg1b.out", "w"))
fit.p['a1/a0'] = fit.p['a'][1] / fit.p['a'][0]
new_data = {'a1/a0' : gv.gvar(1,1e-5)}
new_p = lsqfit.wavg([fit.p, new_data])
print 'chi2/dof = %.2f\n' % (new_p.chi2 / new_p.dof)
print 'E:', new_p['E'][:4]
print 'a:', new_p['a'][:4]
print 'a1/a0:', new_p['a1/a0']
if DO_BAYES:
# Bayesian Fit
gv.ranseed([123])
prior = make_prior(4)
fit = lsqfit.nonlinear_fit(data=(x,y), fcn=f, prior=prior, p0=fit.pmean)
sys.stdout = tee.tee(sys_stdout, open("eg1c.out", "w"))
# print fit
expval = lsqfit.BayesIntegrator(fit, limit=10.)
# adapt integrator to PDF
expval(neval=10000, nitn=10)
# calculate expectation value of function g(p)
fit_hist = gv.PDFHistogram(fit.p['E'][0])
def g(p):
parameters = [p['a'][0], p['E'][0]]
return dict(
mean=parameters,
outer=np.outer(parameters, parameters),
hist=fit_hist.count(p['E'][0]),
)
r = expval(g, neval=10000, nitn=10, adapt=False)
# print results
print r.summary()
means = r['mean']
cov = r['outer'] - np.outer(r['mean'], r['mean'])
print 'Results from Bayesian Integration:'
print 'a0: mean =', means[0], ' sdev =', cov[0,0]**0.5
print 'E0: mean =', means[1], ' sdev =', cov[1,1]**0.5
print 'covariance from Bayesian integral =', np.array2string(cov, prefix=36 * ' ')
print
print 'Results from Least-Squares Fit:'
print 'a0: mean =', fit.p['a'][0].mean, ' sdev =', fit.p['a'][0].sdev
print 'E0: mean =', fit.p['E'][0].mean, ' sdev =', fit.p['E'][0].sdev
print 'covariance from least-squares fit =', np.array2string(gv.evalcov([fit.p['a'][0], fit.p['E'][0]]), prefix=36*' ',precision=3)
sys.stdout = sys_stdout
# make histogram of E[0] probabilty
plt = fit_hist.make_plot(r['hist'])
plt.xlabel('$E_0$')
plt.ylabel('probability')
plt.savefig('eg1c.png', bbox_inches='tight')
# plt.show()
# # extra data 2
# sys.stdout = tee.tee(sys_stdout, open("eg1b.out", "w"))
# newfit = fit
# for i in range(1):
# print '\n--------------------- fit with %d extra data sets' % (i+1)
# x, ynew = make_data()
# prior = newfit.p
# newfit = lsqfit.nonlinear_fit(data=(x,ynew), fcn=f, prior=prior) # , svdcut=SVDCUT)
# print newfit
sys.stdout = sys_stdout
# def fcn(x, p):
# return f(x, p), f(x, p)
# prior = make_prior(nexp)
# fit = lsqfit.nonlinear_fit(data=(x, [y, ynew]), fcn=fcn, prior=prior, p0=newfit.pmean) # , svdcut=SVDCUT)
# print(fit)
if DO_BOOTSTRAP:
Nbs = 40 # number of bootstrap copies
outputs = {'E1/E0':[], 'E2/E0':[], 'a1/a0':[],'a2/a0':[],'E1':[],'a1':[]} # results
for bsfit in fit.bootstrap_iter(n=Nbs):
E = bsfit.pmean['E'] # best-fit parameters
a = bsfit.pmean['a']
outputs['E1/E0'].append(E[1]/E[0]) # accumulate results
outputs['E2/E0'].append(E[2]/E[0])
outputs['a1/a0'].append(a[1]/a[0])
outputs['a2/a0'].append(a[2]/a[0])
outputs['E1'].append(E[1])
outputs['a1'].append(a[1])
# print E[:2]
# print a[:2]
# print bsfit.chi2/bsfit.dof
# extract means and standard deviations from the bootstrap output
for k in outputs:
outputs[k] = gv.gvar(np.mean(outputs[k]),np.std(outputs[k]))
print 'Bootstrap results:'
print 'E1/E0 =',outputs['E1/E0'],' E2/E1 =',outputs['E2/E0']
print 'a1/a0 =',outputs['a1/a0'],' a2/a0 =',outputs['a2/a0']
print 'E1 =',outputs['E1'],' a1 =',outputs['a1']
if DO_PLOT:
import matplotlib.pyplot as plt
ratio = y / fit.fcn(x,fit.pmean)
plt.xlim(4, 21)
plt.xlabel('x')
plt.ylabel('y / f(x,p)')
plt.errorbar(x=x,y=gv.mean(ratio),yerr=gv.sdev(ratio),fmt='ob')
plt.plot([4.0, 21.0], [1.0, 1.0], 'b:')
plt.savefig('eg1.png', bbox_inches='tight')
plt.show()
def error_function(c,tmax):
## -- signal to noise
return -np.dot(gv.mean(c[1:tmax]),gv.mean(c[1:tmax]))/\
np.dot(gv.sdev(c[1:tmax]),gv.sdev(c[1:tmax]))
def main():
### 1) least-squares fit to the data
x = np.array([
0.2, 0.4, 0.6, 0.8, 1.,
1.2, 1.4, 1.6, 1.8, 2.,
2.2, 2.4, 2.6, 2.8, 3.,
3.2, 3.4, 3.6, 3.8
])
y = gv.gvar([
'0.38(20)', '2.89(20)', '0.85(20)', '0.59(20)', '2.88(20)',
'1.44(20)', '0.73(20)', '1.23(20)', '1.68(20)', '1.36(20)',
'1.51(20)', '1.73(20)', '2.16(20)', '1.85(20)', '2.00(20)',
'2.11(20)', '2.75(20)', '0.86(20)', '2.73(20)'
])
prior = make_prior()
fit = lsqfit.nonlinear_fit(data=(x, y), prior=prior, fcn=fitfcn, extend=True)
if LSQFIT_ONLY:
sys.stdout = tee.tee(STDOUT, open('case-outliers-lsq.out', 'w'))
elif not MULTI_W:
sys.stdout = tee.tee(STDOUT, open('case-outliers.out', 'w'))
print(fit)
# plot data
plt.errorbar(x, gv.mean(y), gv.sdev(y), fmt='o', c='b')
# plot fit function
xline = np.linspace(x[0], x[-1], 100)
yline = fitfcn(xline, fit.p)
plt.plot(xline, gv.mean(yline), 'k:')
yp = gv.mean(yline) + gv.sdev(yline)
ym = gv.mean(yline) - gv.sdev(yline)
plt.fill_between(xline, yp, ym, color='0.8')
plt.xlabel('x')
plt.ylabel('y')
plt.savefig('case-outliers1.png', bbox_inches='tight')
if LSQFIT_ONLY:
return
### 2) Bayesian integral with modified PDF
pdf = ModifiedPDF(data=(x, y), fcn=fitfcn, prior=prior)
# integrator for expectation values with modified PDF
expval = lsqfit.BayesIntegrator(fit, pdf=pdf)
# adapt integrator to pdf
expval(neval=1000, nitn=15)
# evaluate expectation value of g(p)
def g(p):
w = 0.5 + 0.5 * p['2w-1']
c = p['c']
return dict(w=[w, w**2], mean=c, outer=np.outer(c,c))
results = expval(g, neval=1000, nitn=15, adapt=False)
print(results.summary())
# expval.map.show_grid(15)
if MULTI_W:
sys.stdout = tee.tee(STDOUT, open('case-outliers-multi.out', 'w'))
# parameters c[i]
mean = results['mean']
cov = results['outer'] - np.outer(mean, mean)
c = mean + gv.gvar(np.zeros(mean.shape), gv.mean(cov))
print('c =', c)
print(
'corr(c) =',
np.array2string(gv.evalcorr(c), prefix=10 * ' '),
'\n',
)
# parameter w
wmean, w2mean = results['w']
wsdev = gv.mean(w2mean - wmean ** 2) ** 0.5
w = wmean + gv.gvar(np.zeros(np.shape(wmean)), wsdev)
print('w =', w, '\n')
# Bayes Factor
print('logBF =', np.log(expval.norm))
sys.stdout = STDOUT
if MULTI_W:
return
# add new fit to plot
yline = fitfcn(xline, dict(c=c))
plt.plot(xline, gv.mean(yline), 'r--')
yp = gv.mean(yline) + gv.sdev(yline)
ym = gv.mean(yline) - gv.sdev(yline)
plt.fill_between(xline, yp, ym, color='r', alpha=0.2)
plt.savefig('case-outliers2.png', bbox_inches='tight')
def main():
gv.ranseed([2009,2010,2011,2012]) # initialize random numbers (opt.)
x,y = make_data() # make fit data
p0 = None # make larger fits go faster (opt.)
for nexp in range(3,5):
print '************************************* nexp =',nexp
prior = make_prior(nexp)
fit = lsqfit.nonlinear_fit(data=(x,y),fcn=f,prior=prior,p0=p0)
print fit # print the fit results
E = fit.p['E'] # best-fit parameters
a = fit.p['a']
print 'E1/E0 =',E[1]/E[0],' E2/E0 =',E[2]/E[0]
print 'a1/a0 =',a[1]/a[0],' a2/a0 =',a[2]/a[0]
print
if fit.chi2/fit.dof<1.:
p0 = fit.pmean # starting point for next fit (opt.)
sys_stdout = sys.stdout
if DO_ERRORBUDGET:
lines = [
"E = fit.p['E']",
"a = fit.p['a']",
"print(E[1] / E[0])",
"print((E[1] / E[0]).partialsdev(fit.prior['E']))",
"print((E[1] / E[0]).partialsdev(fit.prior['a']))",
"print((E[1] / E[0]).partialsdev(y))"
]
sys.stdout = tee.tee(sys_stdout, open("eg4c.out","w"))
for line in lines:
print ">>>", line
if line[:5] == "print":
print(eval(line[5:]))
# print E[1]/E[0]
# print (E[1]/E[0]).partialsdev(fit.prior['E'])
# print (E[1]/E[0]).partialsdev(fit.prior['a'])
# print (E[1]/E[0]).partialsdev(y)
outputs = {'E1/E0':E[1]/E[0], 'E2/E0':E[2]/E[0],
'a1/a0':a[1]/a[0], 'a2/a0':a[2]/a[0]}
inputs = {'E':fit.prior['E'],'a':fit.prior['a'],'y':y}
sys.stdout = tee.tee(sys_stdout, open("eg4b.out","w"))
print fit.fmt_values(outputs)
print fit.fmt_errorbudget(outputs,inputs)
sys.stdout = sys_stdout
if DO_SIMULATIONS:
# fit simulations
sys.stdout = tee.tee(sys_stdout, open("eg4d.out","w"))
for sfit in fit.simulated_fit_iter(3):
print '************************************* simulation'
print(sfit)
sE = sfit.p['E'] # best-fit parameters
sa = sfit.p['a']
E = sfit.pexact['E']
a = sfit.pexact['a']
print 'E1/E0 =', sE[1] / sE[0], ' E2/E0 =', sE[2] / sE[0]
print 'a1/a0 =', sa[1] / sa[0], ' a2/a0 =', sa[2] / sa[0]
print '\nSimulated Fit Values - Exact Values:'
print 'E1/E0:', (sE[1] / sE[0]) - (E[1] / E[0]),\
' E2/E0:', (sE[2] / sE[0]) - (E[2] / E[0])
print 'a1/a0:', (sa[1] / sa[0]) - (a[1] / a[0]),\
' a2/a0:', (sa[2] / sa[0]) - (a[2] / a[0])
# compute chi**2 comparing fit results to exact results
sim_results = [sE[0], sE[1], sa[0], sa[1]]
exact_results = [E[0], E[1], a[0], a[1]]
chi2 = gv.chi2(sim_results, exact_results, svdcut=1e-8)
print '\nParameter chi2/dof [dof] = %.2f' % (chi2/chi2.dof), '[%d]' % chi2.dof, ' Q = %.1f' % chi2.Q
print
sys.stdout = sys_stdout
if DO_EMPBAYES:
def fitargs(z,nexp=nexp,prior=prior,f=f,data=(x,y),p0=p0):
z = gv.exp(z)
prior['a'] = [gv.gvar(0.5,0.5*z[0]) for i in range(nexp)]
return dict(prior=prior,data=data,fcn=f,p0=p0)
##
z0 = [0.0]
fit,z = lsqfit.empbayes_fit(z0,fitargs,tol=1e-3)
sys.stdout = tee.tee(sys_stdout, open("eg4a.out","w"))
print fit # print the optimized fit results
E = fit.p['E'] # best-fit parameters
a = fit.p['a']
print 'E1/E0 =',E[1]/E[0],' E2/E0 =',E[2]/E[0]
print 'a1/a0 =',a[1]/a[0],' a2/a0 =',a[2]/a[0]
# print "prior['a'] =",fit.prior['a'][0]
sys.stdout = sys_stdout
print
if DO_PLOT:
import pylab as pp
from gvar import mean,sdev
fity = f(x,fit.pmean)
ratio = y/fity
pp.xlim(0,21)
pp.xlabel('x')
pp.ylabel('y/f(x,p)')
pp.errorbar(x=x,y=mean(ratio),yerr=sdev(ratio),fmt='ob')
pp.plot([0.0,21.0],[1.0,1.0])
pp.show()
def plot_corr_adv_dl_folded(models,data,fit,req=None,**kwargs):
"""
Get all data ready so that it can be plotted on command
Allows for dynamic cycling through plots
"""
_dfNMod = len(models)
_dfIdx = [0] ## -- index of plotted function, in array so it can be modified in functions
## -- objects to hold all plot data
## - Dat/Fit refers to the correlator data or the fit function
## - Hi/Lo corresponds to the positive/negative half of the fit plot
## - Central/Error are the central value and errors
_dfDatHiCentral = []
_dfDatHiError = []
_dfDatLoCentral = []
_dfDatLoError = []
_dfFitHiCentral = []
_dfFitHiError = []
_dfFitLoCentral = []
_dfFitLoError = []
#
## -- other objects
_dfTData = []
_dfTFit = []
fig,axp = plt.subplots(1,figsize=(8,8))
#
## -- setup plot function
def do_plot_adv_dl_folded(idx,fig=fig):
fig.clear()
axp = fig.add_subplot(111)
key = models[idx[0]].datatag
axp.set_yscale('log')
axp.set_xlim([-1,len(_dfTData[idx[0]])])
axp.set_ylim(utp.get_option("y_pos_limit",[1e-8,1e0],**kwargs[key]))
plt.sca(axp)
expp = [int(np.floor(np.log10(np.abs(x)))) for x in plt.yticks()[0][2:]]
expp = ['$10^{'+str(x)+'}$' for x in expp]
plt.yticks(plt.yticks()[0][2:],expp)
axp.tick_params(axis='both', which='major', labelsize=20)
#
## -- plot fit
axp.plot(_dfTData[idx[0]],_dfFitHiCentral[idx[0]],
color=utp.get_option("color2",'b',**kwargs[key]))
axp.plot(_dfTData[idx[0]],_dfFitHiError[idx[0]][0],
color=utp.get_option("color2",'g',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
axp.plot(_dfTData[idx[0]],_dfFitHiError[idx[0]][1],
color=utp.get_option("color2",'g',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
## -- plot correlator data
(_,caps,_) = axp.errorbar(_dfTData[idx[0]],_dfDatHiCentral[idx[0]],yerr=_dfDatHiError[idx[0]],
mfc=utp.get_option("markerfacecolor1",'None',**kwargs[key]),
mec=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
color=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
ls=utp.get_option("linestyle1",'None',**kwargs[key]),
marker=utp.get_option("marker1",'o',**kwargs[key]),
ms=utp.get_option("markersize",9,**kwargs[key]),
capsize=6, elinewidth=2)
for cap in caps:
cap.set_markeredgewidth(1)
axp.scatter(_dfTFit[idx[0]],[_dfDatHiCentral[idx[0]][t] for t in _dfTFit[idx[0]]],
color=utp.get_option("color1",'r',**kwargs[key]),
marker=utp.get_option("marker",'o',**kwargs[key]),
s=utp.get_option("markersize",81,**kwargs[key]))
fig.suptitle(utp.get_option("plottitledf",str(idx[0])+" default title "+str(key),**kwargs[key]),
fontsize=utp.get_option("titlesize",20,**kwargs[key]))
## -- modify some options
axp.set_xlabel(r'$t$',fontsize=10)
axp.set_ylabel(utp.get_option("yaxistitle",r"$C(t)$",**kwargs[key]),
#fontsize=10,rotation=0,position=(0.01,0.04),labelpad=10)
fontsize=10,rotation=0)
axp.yaxis.set_label_coords(-0.07,0.04)
for item in ([axp.xaxis.label,axp.yaxis.label]):
# must be after setting label content (LaTeX ruins it)
item.set_fontsize(fontsize=utp.get_option("fontsize",30,**kwargs[key]))
rect =fig.patch
rect.set_facecolor('white')
if utp.get_option("to_file",False,**kwargs[key]):
save_dir = utp.get_option("df_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("df_save_name","dfplot-"+key+".pdf",**kwargs[key])
plt.savefig(save_dir+'/'+save_name)
#mng = plt.get_current_fig_manager()
#mng.resize(*mng.window.maxsize())
#fig.set_size_inches(5,12)
#save_dir = utp.get_option("df_save_dir","./plotdump",**kwargs[key])
#save_name = utp.get_option("df_save_name","dfplot-"+key+".pdf",**kwargs[key])
#fig.savefig(save_dir+'/'+save_name)
if utp.get_option("to_terminal",True,**kwargs[key]):
plt.draw()
pass
#
## -- setup button press action function
def press_adv_dl_folded(event,idx=_dfIdx):
#print('press_adv_dl_folded', event.key)
try:
## -- manually indicate index
idx[0] = int(event.key) + (idx[0])*10
except ValueError:
if event.key==' ': ## -- space
## -- allows for replotting when changing index by typing number keys
idx[0] = idx[0] % _dfNMod
do_plot_adv_dl_folded(idx)
elif event.key=='left':
idx[0] = (idx[0] - 1) % _dfNMod
do_plot_adv_dl_folded(idx)
elif event.key=='right':
idx[0] = (idx[0] + 1) % _dfNMod
do_plot_adv_dl_folded(idx)
elif event.key=='backspace':
## -- reset index so can manually flip through using number keys
idx[0] = 0
elif event.key=='d':
## -- dump plots into ./plotdump directory
for ix,model in zip(range(len(models)),models):
key = model.datatag
save_dir = utp.get_option("df_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("df_save_name","dfplot-"+key+".pdf",**kwargs[key])
do_plot_adv_dl_folded([ix])
plt.savefig(save_dir+'/'+save_name)
do_plot_adv_dl_folded(idx)
#
## --
fig.canvas.mpl_connect('key_press_event',press_adv_dl_folded)
## -- save plot data
for idx,model in zip(range(len(models)),models):
key = model.datatag
_dfTData.append([t for t in model.tdata if t < len(model.tdata)/2+1])
_dfTFit.append([t for t in model.tfit if t < len(model.tdata)/2+1])
## -- fit
if req is None:
_dfFitFunc = utp.mask_fit_fcn_adv(model,fit,invert=True)
else:
_dfFitFunc = utp.mask_fit_fcn_adv(model,fit,req=req,invert=False)
_dfFitMean = gv.mean(_dfFitFunc(np.array(_dfTData[-1])))
_dfFitSdev = gv.sdev(_dfFitFunc(np.array(_dfTData[-1])))
#print 'fit tdat : ',_dfTData[-1]
#print 'fit mean : ',_dfFitMean
#print 'fit sdev : ',_dfFitSdev
_dfFitHiCentral.append(
utf.pos_arr(_dfFitMean,utp.get_option("y_pos_limit",[1e-4,1e0],**kwargs[key])[0]/100) )
_dfFitHiError.append([
utf.pos_arr(np.array(_dfFitMean)-np.array(_dfFitSdev),
utp.get_option("y_pos_limit",[1e-4,1e0],**kwargs[key])[0]/1000),
utf.pos_arr(np.array(_dfFitMean)+np.array(_dfFitSdev),
utp.get_option("y_pos_limit",[1e-4,1e0],**kwargs[key])[0]/1000) ])
## -- data
if req is None:
_dfSubFunc = utp.mask_fit_fcn_adv(model,fit,invert=False)
else:
_dfSubFunc = utp.mask_fit_fcn_adv(model,fit,req=req,invert=True)
asym = (model.tp < 0)
_dfSub = _dfSubFunc(np.array(_dfTData[-1]))
_dfDatMean = gv.mean(utf.fold_data(data[key],asym)-_dfSub)
_dfDatSdev = gv.sdev(utf.fold_data(data[key],asym)-_dfSub)
#print 'data : ',utf.fold_data(data[key],asym)
#print 'subtraction: ',_dfSub
#print 'new : ',gv.gvar(_dfDatMean,_dfDatSdev)
_dfDatHiCentral.append( utf.pos_arr(_dfDatMean) )
_dfDatHiError.append(utf.pos_err(_dfDatMean,_dfDatSdev))
## -- done saving data
if not(utp.get_option("to_terminal",True,**kwargs[key])) and\
utp.get_option("to_file",False,**kwargs[key]):
for ix in range(len(models)):
## -- loops and saves all without creating window
do_plot_adv_dl_folded([ix])
else:
do_plot_adv_dl_folded(_dfIdx)
def plot_corr_double_log(models,data,fit,**kwargs):
"""
Get all data ready so that it can be plotted on command
Allows for dynamic cycling through plots
"""
_dlNMod = len(models)
_dlIdx = [0] ## -- index of plotted function, in array so it can be modified in functions
## -- objects to hold all plot data
## - Dat/Fit refers to the correlator data or the fit function
## - Hi/Lo corresponds to the positive/negative half of the fit plot
## - Central/Error are the central value and errors
_dlDatHiCentral = []
_dlDatHiError = []
_dlDatLoCentral = []
_dlDatLoError = []
_dlFitHiCentral = []
_dlFitHiError = []
_dlFitLoCentral = []
_dlFitLoError = []
#
## -- other objects
_dlTData = []
_dlTFit = []
fig,(axp,axm) = plt.subplots(2,sharex=True,figsize=(8,16))
#
## -- setup plot function
def do_plot_double_log(idx,fig=fig):
fig.clear()
axp = fig.add_subplot(211)
axm = fig.add_subplot(212,sharex=axp)
fig.subplots_adjust(hspace=0)
key = models[idx[0]].datatag
axp.set_yscale('log')
axm.set_yscale('log')
axp.set_xlim([-1,len(_dlTData[idx[0]])])
axm.set_xlim([-1,len(_dlTData[idx[0]])])
axp.set_ylim(utp.get_option("y_pos_limit",[1e-8,1e0],**kwargs[key]))
axm.set_ylim(utp.get_option("y_neg_limit",[1e-8,1e0],**kwargs[key]))
axm.set_ylim(axm.get_ylim()[::-1])
plt.sca(axp)
expp = [int(np.floor(np.log10(np.abs(x)))) for x in plt.yticks()[0][2:]]
expp = ['$10^{'+str(x)+'}$' for x in expp]
plt.yticks(plt.yticks()[0][2:],expp)
plt.sca(axm)
expm = [int(np.floor(np.log10(np.abs(x)))) for x in plt.yticks()[0][2:]]
expm = ['$-10^{'+str(x)+'}$' for x in expm]
plt.yticks(plt.yticks()[0][2:],expm)
#
## -- plot fit
axp.plot(_dlTData[idx[0]],_dlFitHiCentral[idx[0]],
color=utp.get_option("color2",'b',**kwargs[key]))
axm.plot(_dlTData[idx[0]],_dlFitLoCentral[idx[0]],
color=utp.get_option("color2",'b',**kwargs[key]))
axp.plot(_dlTData[idx[0]],_dlFitHiError[idx[0]][0],
color=utp.get_option("color2",'g',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
axm.plot(_dlTData[idx[0]],_dlFitLoError[idx[0]][0],
color=utp.get_option("color2",'g',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
axp.plot(_dlTData[idx[0]],_dlFitHiError[idx[0]][1],
color=utp.get_option("color2",'g',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
axm.plot(_dlTData[idx[0]],_dlFitLoError[idx[0]][1],
color=utp.get_option("color2",'g',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
## -- plot correlator data
axp.errorbar(_dlTData[idx[0]],_dlDatHiCentral[idx[0]],yerr=_dlDatHiError[idx[0]],
mfc=utp.get_option("markerfacecolor1",'None',**kwargs[key]),
mec=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
color=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
ls=utp.get_option("linestyle1",'None',**kwargs[key]),
marker=utp.get_option("marker1",'o',**kwargs[key]),
ms=utp.get_option("markersize",6,**kwargs[key]))
axm.errorbar(_dlTData[idx[0]],_dlDatLoCentral[idx[0]],yerr=_dlDatLoError[idx[0]],
mfc=utp.get_option("markerfacecolor1",'None',**kwargs[key]),
mec=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
color=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
ls=utp.get_option("linestyle1",'None',**kwargs[key]),
marker=utp.get_option("marker1",'o',**kwargs[key]),
ms=utp.get_option("markersize",6,**kwargs[key]))
axp.scatter(_dlTFit[idx[0]],[_dlDatHiCentral[idx[0]][t] for t in _dlTFit[idx[0]]],
color=utp.get_option("color1",'r',**kwargs[key]),
marker=utp.get_option("marker",'o',**kwargs[key]),
s=utp.get_option("markersize",36,**kwargs[key]))
axm.scatter(_dlTFit[idx[0]],[_dlDatLoCentral[idx[0]][t] for t in _dlTFit[idx[0]]],
color=utp.get_option("color1",'r',**kwargs[key]),
marker=utp.get_option("marker",'o',**kwargs[key]),
s=utp.get_option("markersize",36,**kwargs[key]))
fig.suptitle(utp.get_option("plottitledl",str(idx[0])+" default title "+str(key),**kwargs[key]),
fontsize=utp.get_option("titlesize",20,**kwargs[key]))
## -- modify some options
axm.set_xlabel(r'$t$')
axm.set_ylabel(utp.get_option("yaxistitle",r"$C(t)$",**kwargs[key]),
fontsize=30,rotation=0,position=(0.05,0.98))
for item in ([axm.xaxis.label,axm.yaxis.label]):
# must be after setting label content (LaTeX ruins it)
item.set_fontsize(fontsize=utp.get_option("fontsize",20,**kwargs[key]))
rect =fig.patch
rect.set_facecolor('white')
if utp.get_option("to_file",False,**kwargs[key]):
save_dir = utp.get_option("dl_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("dl_save_name","dlplot-"+key+".pdf",**kwargs[key])
plt.savefig(save_dir+'/'+save_name)
#mng = plt.get_current_fig_manager()
#mng.resize(*mng.window.maxsize())
#fig.set_size_inches(5,12)
#save_dir = utp.get_option("dl_save_dir","./plotdump",**kwargs[key])
#save_name = utp.get_option("dl_save_name","dlplot-"+key+".pdf",**kwargs[key])
#fig.savefig(save_dir+'/'+save_name)
if utp.get_option("to_terminal",True,**kwargs[key]):
plt.draw()
pass
#
## -- setup button press action function
def press_double_log(event,idx=_dlIdx):
#print('press_double_log', event.key)
try:
## -- manually indicate index
idx[0] = int(event.key) + (idx[0])*10
except ValueError:
if event.key==' ': ## -- space
## -- allows for replotting when changing index by typing number keys
idx[0] = idx[0] % _dlNMod
do_plot_double_log(idx)
elif event.key=='left':
idx[0] = (idx[0] - 1) % _dlNMod
do_plot_double_log(idx)
elif event.key=='right':
idx[0] = (idx[0] + 1) % _dlNMod
do_plot_double_log(idx)
elif event.key=='backspace':
## -- reset index so can manually flip through using number keys
idx[0] = 0
elif event.key=='d':
## -- dump plots into ./plotdump directory
for ix,model in zip(range(len(models)),models):
key = model.datatag
save_dir = utp.get_option("dl_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("dl_save_name","dlplot-"+key+".pdf",**kwargs[key])
do_plot_double_log([ix])
plt.savefig(save_dir+'/'+save_name)
do_plot_double_log(idx)
#
## --
fig.canvas.mpl_connect('key_press_event',press_double_log)
## -- save plot data
for idx,model in zip(range(len(models)),models):
key = model.datatag
_dlTData.append(model.tdata)
_dlTFit.append(model.tfit)
_dlTFit[-1] = np.append(_dlTFit[-1],list(sorted([len(_dlTData[-1]) - t for t in _dlTFit[-1]])))
## -- fit
_dlFitFunc = utp.create_fit_func(model,fit)
_dlFitMean = gv.mean(_dlFitFunc(_dlTData[-1]))
_dlFitSdev = gv.sdev(_dlFitFunc(_dlTData[-1]))
_dlFitHiCentral.append(
utf.pos_arr(_dlFitMean,utp.get_option("y_pos_limit",[1e-8,1e0],**kwargs[key])[0]/100) )
_dlFitLoCentral.append(
utf.neg_arr(_dlFitMean,utp.get_option("y_neg_limit",[1e-8,1e0],**kwargs[key])[0]/100) )
_dlFitHiError.append([
utf.pos_arr(np.array(_dlFitMean)-np.array(_dlFitSdev),
utp.get_option("y_pos_limit",[1e-8,1e0],**kwargs[key])[0]/1000),
utf.pos_arr(np.array(_dlFitMean)+np.array(_dlFitSdev),
utp.get_option("y_pos_limit",[1e-8,1e0],**kwargs[key])[0]/1000) ])
_dlFitLoError.append([
utf.neg_arr(np.array(_dlFitMean)-np.array(_dlFitSdev),
utp.get_option("y_neg_limit",[1e-8,1e0],**kwargs[key])[0]/1000),
utf.neg_arr(np.array(_dlFitMean)+np.array(_dlFitSdev),
utp.get_option("y_neg_limit",[1e-8,1e0],**kwargs[key])[0]/1000) ])
## -- data
_dlDatMean = gv.mean(data[key])
_dlDatSdev = gv.sdev(data[key])
_dlDatHiCentral.append( utf.pos_arr(_dlDatMean) )
_dlDatLoCentral.append( utf.neg_arr(_dlDatMean) )
_dlDatHiError.append(utf.pos_err(_dlDatMean,_dlDatSdev))
_dlDatLoError.append(utf.neg_err(_dlDatMean,_dlDatSdev))
## -- done saving data
if not(utp.get_option("to_terminal",True,**kwargs[key])) and\
utp.get_option("to_file",False,**kwargs[key]):
for ix in range(len(models)):
## -- loops and saves all without creating window
do_plot_double_log([ix])
else:
do_plot_double_log(_dlIdx)
def plot_corr_effective_mass(models,data,fit=None,req=[list(),list()],**kwargs):
"""
Get all data ready so that it can be plotted on command
Allows for dynamic cycling through plots
"""
_emNMod = len(models)
_emIdx = [0] ## -- index of plotted function, in array so it can be modified in functions
## -- objects to hold all plot data
## - Dat/Fit refers to the correlator data or the fit function
## - Central/Error are the central value and errors
_emLogRatio = []
_emLogRatioCentral = []
_emLogRatioError = []
_emLogRatioFit = []
_emFoldRatio = []
_emFoldRatioCentral= []
_emFoldRatioError = []
_emFoldRatioFit = []
_emRatioFit = []
_emRatioFitNonZero = []
_emFitCentral = []
_emFitError = []
## -- timeslice objects
_emTPosRatio = []
_emTPosFit = []
_emTPosFold = []
_emTPosFoldFit = []
#
## -- fitting options
_emFitMin = 0
_emFitMax = 0
_emSep = 0
fig,ax = plt.subplots(1,figsize=(10,8))
#
## -- setup plot function
def do_plot_corr_effective_mass(idx,fig=fig):
fig.clear()
#fig.set_size_inches(10,10) #doesn't work
ax = fig.add_subplot(111)
if print_quality:
plt.subplots_adjust(bottom=0.15,left=0.18,right=0.97,top=0.95)
else:
#plt.subplots_adjust(bottom=0.15,left=0.15,right=0.97,top=0.95)
pass
#fig.set_figheight(20) #doesn't work
#fig.set_figwidth(20)
key = models[idx[0]].datatag
ax.set_xlim([-1,df.cor_len/2])
ax.set_ylim(utp.get_option("y_limit",[0.0,1.4],**kwargs[key]))
#
# -- plot correlator data
if utp.get_option("meff_do_fold",False,**kwargs[key]):
## -- plot fit
ax.plot([t for t in _emTPosFit[idx[0]] if t < len(_emTData)/2],_emFitCentral[idx[0]],
color=utp.get_option("color3",'b',**kwargs[key]))
ax.plot([t for t in _emTPosFit[idx[0]] if t < len(_emTData)/2],_emFitError[idx[0]][0],
color=utp.get_option("color3",'b',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
ax.plot([t for t in _emTPosFit[idx[0]] if t < len(_emTData)/2],_emFitError[idx[0]][1],
color=utp.get_option("color3",'b',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
## -- _emTPosRatio not necessarily symmetric, get times correct
ax.errorbar(_emTPosFold[idx[0]],_emFoldRatioCentral[idx[0]],yerr=_emFoldRatioError[idx[0]],
mfc=utp.get_option("markerfacecolor1",'None',**kwargs[key]),
mec=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
color=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
ls=utp.get_option("linestyle1",'None',**kwargs[key]),
marker=utp.get_option("marker1",'o',**kwargs[key]),
ms=utp.get_option("markersize",10,**kwargs[key]))
ax.scatter(_emTPosFoldFit[idx[0]],gv.mean(_emFoldRatioFit[idx[0]]),
color=utp.get_option("color1",'r',**kwargs[key]),
marker=utp.get_option("marker",'o',**kwargs[key]),
s=utp.get_option("markersize",100,**kwargs[key]))
else:
## -- plot fit
ax.plot(_emTPosFit[idx[0]],_emFitCentral[idx[0]],
color=utp.get_option("color3",'b',**kwargs[key]))
ax.plot(_emTPosFit[idx[0]],_emFitError[idx[0]][0],
color=utp.get_option("color3",'b',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
ax.plot(_emTPosFit[idx[0]],_emFitError[idx[0]][1],
color=utp.get_option("color3",'b',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
## --
ax.errorbar(_emTPosRatio[idx[0]],_emLogRatioCentral[idx[0]],yerr=_emLogRatioError[idx[0]],
mfc=utp.get_option("markerfacecolor1",'None',**kwargs[key]),
mec=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
color=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
ls=utp.get_option("linestyle1",'None',**kwargs[key]),
marker=utp.get_option("marker1",'o',**kwargs[key]),
ms=utp.get_option("markersize",8,**kwargs[key]))
ax.scatter(_emTPosFit[idx[0]],gv.mean(_emLogRatioFit[idx[0]]),
color=utp.get_option("color1",'r',**kwargs[key]),
marker=utp.get_option("marker",'o',**kwargs[key]),
s=utp.get_option("markersize",64,**kwargs[key]))
fig.suptitle(utp.get_option("plottitleem",str(idx[0])+" default title "+str(key),**kwargs[key]),
fontsize=utp.get_option("titlesize",20,**kwargs[key]))
# -- modify some options
if print_quality:
ax.set_xlabel(r'$t$',fontsize=40)
if sn_ratio:
ax.set_ylabel(utp.get_option("yaxistitle",
r"$-\frac{1}{"+str(_emSep)+r"}v_{i}^{T}\,log\frac{C_{ij}(t+"+str(_emSep)+r")}{C_{ij}(t)}w_{j}$",
**kwargs[key]),fontsize=40)
else:
ax.set_ylabel(utp.get_option("yaxistitle",
r"$-\frac{1}{"+str(_emSep)+r"}\,log\frac{C_{ij}(t+"+str(_emSep)+r")}{C_{ij}(t)}$",
**kwargs[key]),fontsize=40)
plt.xticks(plt.xticks()[0],fontsize=24)
plt.yticks(plt.yticks()[0],fontsize=24)
else:
ax.set_xlabel(r'$t$')
ax.set_ylabel(utp.get_option("yaxistitle",
r"$-\frac{1}{"+str(_emSep)+r"}\,log\frac{C(t+"+str(_emSep)+r")}{C(t)}$",**kwargs[key]))
for item in ([ax.xaxis.label,ax.yaxis.label]):
# must be after setting label content (LaTeX ruins it)
item.set_fontsize(fontsize=utp.get_option("fontsize",20,**kwargs[key]))
rect =fig.patch
rect.set_facecolor('white')
if utp.get_option("to_file",False,**kwargs[key]):
save_dir = utp.get_option("em_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("em_save_name","emplot-"+key+".pdf",**kwargs[key])
plt.savefig(save_dir+'/'+save_name)
if utp.get_option("to_terminal",True,**kwargs[key]):
plt.draw()
pass
#
## -- setup button press action function
def press_effective_mass(event,idx=_emIdx):
#print('press_effective_mass', event.key)
try:
## -- manually indicate index
idx[0] = int(event.key) + (idx[0])*10
except ValueError:
if event.key==' ': ## -- space
## -- allows for replotting when changing index by typing number keys
idx[0] = idx[0] % _emNMod
do_plot_corr_effective_mass(idx)
elif event.key=='left':
idx[0] = (idx[0] - 1) % _emNMod
do_plot_corr_effective_mass(idx)
elif event.key=='right':
idx[0] = (idx[0] + 1) % _emNMod
do_plot_corr_effective_mass(idx)
elif event.key=='backspace':
## -- reset index so can manually flip through using number keys
idx[0] = 0
elif event.key=='d':
## -- dump plots into ./plotdump directory
for ix,model in zip(range(len(models)),models):
key = model.datatag
save_dir = utp.get_option("em_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("em_save_name","emplot-"+key+".png",**kwargs[key])
do_plot_corr_effective_mass([ix])
plt.savefig(save_dir+'/'+save_name)
do_plot_corr_effective_mass(idx)
#
## --
fig.canvas.mpl_connect('key_press_event',press_effective_mass)
## -- save plot data
for idx,model in zip(range(len(models)),models):
key = model.datatag
## -- parameters used in fitting
## default = 2
_emSep = utp.get_option("meff_sep",2,**kwargs[key])
## default = smallest t not included in fit
_emFitMin = utp.get_option("meff_fit_min",model.tfit[-1]+1,**kwargs[key])
## default = midpoint - sep
_emFitMax = utp.get_option("meff_fit_max",
model.tdata[-1]/2-_emSep-int(model.tdata[-1]/12),**kwargs[key])
_emTData = model.tdata
_emTFit = range(_emFitMin,_emFitMax)
_emTFit = np.append(_emTFit,list(sorted([len(_emTData) - t for t in _emTFit])))
if not(fit is None) and (len(req[0]) > 0 or len(req[1]) > 0):
_emSubFcn = utp.mask_fit_fcn(model,fit,req,invert=False)
_emSub = np.array(_emSubFcn(np.array(_emTData)))
else:
_emSub = 0
_emDataFold = utf.fold_data(data[key]-_emSub,(model.tp < 0))
#_emTDataNonZero = [t for t in _emTData if np.abs(gv.mean(data[key])[t]) > 1e-20]
#_emTDataNonZero = [t for t in range(len(_emDataFold)) if np.mean(_emDataFold[t]) > 1e-20]
#
## -- data
_emRatio = np.array(_emDataFold[_emSep:])/np.array(_emDataFold[:-_emSep])
_emTDataRatio = np.array(range(len(_emRatio)))
_emTDataNonZero = np.array([t for t in range(len(_emRatio)) if _emRatio[t] > 1e-20])
#_emRatio = np.array([-gv.log(x)/_emSep for x in _emRatio if x > 1e-20])
#_emTDataRatio =\
# [t for t in _emTData
# if (t in _emTDataNonZero) and (t <= _emTData[-1]/2 +1 - _emSep) ] # first half
#_emTDataRatio = np.append(_emTDataRatio,
# [t for t in _emTData
# if (t in _emTDataNonZero) and (t >= _emTData[-1]/2 +1 + _emSep) ] ) # second half
#_emRatio =\
# [data[key][t+_emSep]/data[key][t] for t in _emTData
# if (t in _emTDataNonZero) and (t <= _emTData[-1]/2 +1 - _emSep) ] # first half
#_emRatio = np.append(_emRatio,
# [data[key][t-_emSep]/data[key][t] for t in _emTData
# if (t in _emTDataNonZero) and (t >= _emTData[-1]/2 +1 + _emSep) ] ) # second half
## -- times
_emTPosRatio.append(
[_emTDataRatio[t] for t in range(len(_emTDataRatio)) if _emRatio[t] > 0] )
_emTPosFit.append(
[_emTDataRatio[t] for t in range(len(_emTDataRatio))
if _emRatio[t] > 0 and _emTDataRatio[t] in _emTFit] )
## -- ratios
_emLogRatio.append(
[-gv.log(_emRatio[t])/_emSep for t in range(len(_emTDataRatio)) if _emRatio[t] > 0] )
_emLogRatioFit.append(
[-gv.log(_emRatio[t])/_emSep for t in range(len(_emTDataRatio))
if (gv.mean(_emRatio[t]) > 0) and (_emTDataRatio[t] in _emTPosFit[-1])] )
_emFoldRatio.append(_emLogRatio[-1])
_emFoldRatioFit.append(_emLogRatioFit[-1])
_emTPosFold.append(_emTPosRatio[-1])
_emTPosFoldFit.append(_emTPosFit[-1])
## -- folding
#_emFoldRatio.append(list())
#_emFoldRatioFit.append(list())
#_emTPosFold.append(list())
#_emTPosFoldFit.append(list())
#for t in range(1,len(_emTData)/2):
# if not(t in _emTPosRatio[-1]) or not(len(_emTData)-t in _emTPosRatio[-1]):
# continue
# _emFoldRatio[-1].append((_emLogRatio[-1][list(_emTPosRatio[-1]).index(t)]
# +_emLogRatio[-1][list(_emTPosRatio[-1]).index(len(_emTData)-t)])/2)
# _emTPosFold[-1].append(t)
# if not(t in _emTPosFit[-1]) or not(len(_emTData)-t in _emTPosFit[-1]):
# continue
# _emFoldRatioFit[-1].append((_emLogRatio[-1][list(_emTPosRatio[-1]).index(t)]
# +_emLogRatio[-1][list(_emTPosRatio[-1]).index(len(_emTData)-t)])/2)
# _emTPosFoldFit[-1].append(t)
#for t in range(len(_emTPosFold[-1])):
# print t,_emTPosFold[-1][t],_emFoldRatio[-1][t]
#for t in range(len(_emTPosFoldFit[-1])):
# print t,_emTPosFoldFit[-1][t],_emFoldRatioFit[-1][t]
_emLogRatioCentral.append(gv.mean(_emLogRatio[-1]))
_emLogRatioError.append([ list(gv.sdev(_emLogRatio[-1])), list(gv.sdev(_emLogRatio[-1])) ])
_emFoldRatioCentral.append(gv.mean(_emFoldRatio[-1]))
_emFoldRatioError.append([ list(gv.sdev(_emFoldRatio[-1])), list(gv.sdev(_emFoldRatio[-1])) ])
## -- fit
_emRatioFit.append(lsq.wavg(_emLogRatioFit[-1]))
if utp.get_option("meff_do_fold",False,**kwargs[key]):
_emFitCentral.append([gv.mean(_emRatioFit[-1]) for t in _emTPosFit[-1] if t < len(_emTData)/2])
_emFitError.append(
[list(np.array(_emFitCentral[-1])-np.array([gv.sdev(_emRatioFit[-1])
for t in _emTPosFit[-1] if t < len(_emTData)/2])),
list(np.array(_emFitCentral[-1])+np.array([gv.sdev(_emRatioFit[-1])
for t in _emTPosFit[-1] if t < len(_emTData)/2]))])
else:
_emFitCentral.append([gv.mean(_emRatioFit[-1]) for t in _emTPosFit[-1]])
_emFitError.append(
[list(np.array(_emFitCentral[-1])-np.array([gv.sdev(_emRatioFit[-1])
for t in _emTPosFit[-1]])),
list(np.array(_emFitCentral[-1])+np.array([gv.sdev(_emRatioFit[-1])
for t in _emTPosFit[-1]]))])
print "Best plateau fits: "
for key,rfit in zip([model.datatag for model in models],_emRatioFit):
print " ",key," : ",rfit
print " ----------------- "
_emRatioFitNonZero = [x for x in _emRatioFit if not(x is None)]
print " avg : ",lsq.wavg(_emRatioFitNonZero)
## -- done saving data
if not(utp.get_option("to_terminal",True,**kwargs[key])) and\
utp.get_option("to_file",False,**kwargs[key]):
for ix in range(len(models)):
## -- loops and saves all without creating window
do_plot_corr_effective_mass([ix])
else:
do_plot_corr_effective_mass(_emIdx)
def plot_corr_effective_mass_check(models,data,fit=None,**kwargs):
"""
Get all data ready so that it can be plotted on command
Allows for dynamic cycling through plots
"""
_emNMod = len(models)
_emIdx = [0] ## -- index of plotted function, in array so it can be modified in functions
## -- objects to hold all plot data
## - Dat/Fit refers to the correlator data or the fit function
## - Central/Error are the central value and errors
_emLogRatio = []
_emLogRatioCentral = []
_emLogRatioError = []
_emLogRatioFit = []
_emRatioFit = []
_emRatioFitNonZero = []
_emFitCentral = []
_emFitError = []
## -- timeslice objects
_emTPosRatio = []
_emTPosFit = []
#
## -- fitting options
_emFitMin = 0
_emFitMax = 0
_emSep = 0
fig,ax = plt.subplots(1)
#
## -- setup plot function
def do_plot_corr_effective_mass_check(idx,fig=fig):
fig.clear()
ax = fig.add_subplot(111)
key = models[idx[0]].datatag
ax.set_ylim(utp.get_option("y_limit",[0.0,1.2],**kwargs[key]))
#
## -- plot fit
ax.plot(_emTPosFit[idx[0]],_emFitCentral[idx[0]],
color=utp.get_option("color3",'b',**kwargs[key]))
ax.plot(_emTPosFit[idx[0]],_emFitError[idx[0]][0],
color=utp.get_option("color3",'b',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
ax.plot(_emTPosFit[idx[0]],_emFitError[idx[0]][1],
color=utp.get_option("color3",'b',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
## -- plot reference
for val in df.ec_reference_lines:
vt = [val for t in _emTPosFit[idx[0]]]
ax.plot(_emTPosFit[idx[0]],vt,
color=utp.get_option("color2",'g',**kwargs[key]))
# -- plot correlator data
ax.errorbar(_emTPosRatio[idx[0]],_emLogRatioCentral[idx[0]],yerr=_emLogRatioError[idx[0]],
mfc=utp.get_option("markerfacecolor1",'None',**kwargs[key]),
mec=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
color=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
ls=utp.get_option("linestyle1",'None',**kwargs[key]),
marker=utp.get_option("marker1",'o',**kwargs[key]),
ms=utp.get_option("markersize",6,**kwargs[key]))
ax.scatter(_emTPosFit[idx[0]],gv.mean(_emLogRatioFit[idx[0]]),
color=utp.get_option("color1",'r',**kwargs[key]),
marker=utp.get_option("marker",'o',**kwargs[key]),
s=utp.get_option("markersize",36,**kwargs[key]))
fig.suptitle(utp.get_option("plottitle",str(idx[0])+" default title "+str(key),**kwargs[key]),
fontsize=utp.get_option("titlesize",20,**kwargs[key]))
# -- modify some options
ax.set_xlabel(r'$t$ slice')
ax.set_ylabel(utp.get_option("yaxistitle",
r"$-\frac{1}{"+str(_emSep)+r"}\,log\frac{C(t+"+str(_emSep)+r")}{C(t)}$",**kwargs[key]))
for item in ([ax.xaxis.label,ax.yaxis.label]):
# must be after setting label content (LaTeX ruins it)
item.set_fontsize(fontsize=utp.get_option("fontsize",20,**kwargs[key]))
rect =fig.patch
rect.set_facecolor('white')
if utp.get_option("to_file",False,**kwargs[key]):
save_dir = utp.get_option("ec_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("ec_save_name","ecplot-"+key+".pdf",**kwargs[key])
plt.savefig(save_dir+'/'+save_name)
if utp.get_option("to_terminal",True,**kwargs[key]):
plt.draw()
pass
#
## -- setup button press action function
def press_effective_mass(event,idx=_emIdx):
#print('press_effective_mass', event.key)
try:
## -- manually indicate index
idx[0] = int(event.key) + (idx[0])*10
except ValueError:
if event.key==' ': ## -- space
## -- allows for replotting when changing index by typing number keys
idx[0] = idx[0] % _emNMod
do_plot_corr_effective_mass_check(idx)
elif event.key=='left':
idx[0] = (idx[0] - 1) % _emNMod
do_plot_corr_effective_mass_check(idx)
elif event.key=='right':
idx[0] = (idx[0] + 1) % _emNMod
do_plot_corr_effective_mass_check(idx)
elif event.key=='backspace':
## -- reset index so can manually flip through using number keys
idx[0] = 0
elif event.key=='d':
## -- dump plots into ./plotdump directory
for ix,model in zip(range(len(models)),models):
key = model.datatag
save_dir = utp.get_option("ec_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("ec_save_name","ecplot-"+key+".png",**kwargs[key])
do_plot_corr_effective_mass_check([ix])
plt.savefig(save_dir+'/'+save_name)
do_plot_corr_effective_mass_check(idx)
#
## --
fig.canvas.mpl_connect('key_press_event',press_effective_mass)
## -- save plot data
for idx,model in zip(range(len(models)),models):
key = model.datatag
## -- parameters used in fitting
## default = 2
_emSep = utp.get_option("meff_sep",2,**kwargs[key])
## default = smallest t not included in fit
_emFitMin = utp.get_option("meff_fit_min",model.tfit[-1]+1,**kwargs[key])
## default = midpoint - sep
_emFitMax = utp.get_option("meff_fit_max",
model.tdata[-1]/2-_emSep-int(model.tdata[-1]/12),**kwargs[key])
_emTData = model.tdata
_emTFit = range(_emFitMin,_emFitMax)
_emTFit = np.append(_emTFit,list(sorted([len(_emTData) - t for t in _emTFit])))
_emTDataNonZero = [t for t in _emTData if np.abs(gv.mean(data[key])[t]) > 1e-20]
#
## -- data
_emTDataRatio =\
[t for t in _emTData
if (t in _emTDataNonZero) and (t <= _emTData[-1]/2 +1 - _emSep) ] # first half
_emTDataRatio = np.append(_emTDataRatio,
[t for t in _emTData
if (t in _emTDataNonZero) and (t >= _emTData[-1]/2 +1 + _emSep) ] ) # second half
_emRatio =\
[data[key][t+_emSep]/data[key][t] for t in _emTData
if (t in _emTDataNonZero) and (t <= _emTData[-1]/2 +1 - _emSep) ] # first half
_emRatio = np.append(_emRatio,
[data[key][t-_emSep]/data[key][t] for t in _emTData
if (t in _emTDataNonZero) and (t >= _emTData[-1]/2 +1 + _emSep) ] ) # second half
_emTPosRatio.append(
[_emTDataRatio[t] for t in range(len(_emTDataRatio)) if _emRatio[t] > 0] )
_emTPosFit.append(
[_emTDataRatio[t] for t in range(len(_emTDataRatio))
if _emRatio[t] > 0 and _emTDataRatio[t] in _emTFit] )
_emLogRatio.append(
[-gv.log(_emRatio[t])/_emSep for t in range(len(_emTDataRatio)) if _emRatio[t] > 0] )
_emLogRatioFit.append(
[-gv.log(_emRatio[t])/_emSep for t in range(len(_emTDataRatio))
if (gv.mean(_emRatio[t]) > 0) and (_emTDataRatio[t] in _emTPosFit[-1])] )
_emLogRatioCentral.append(gv.mean(_emLogRatio[-1]))
_emLogRatioError.append([ list(gv.sdev(_emLogRatio[-1])), list(gv.sdev(_emLogRatio[-1])) ])
## -- fit
_emRatioFit.append(lsq.wavg(_emLogRatioFit[-1]))
_emFitCentral.append([gv.mean(_emRatioFit[-1]) for t in _emTPosFit[-1]])
_emFitError.append(
[list(np.array(_emFitCentral[-1])-np.array([gv.sdev(_emRatioFit[-1]) for t in _emTPosFit[-1]])),
list(np.array(_emFitCentral[-1])+np.array([gv.sdev(_emRatioFit[-1]) for t in _emTPosFit[-1]]))]
)
print "Best plateau fits: "
for key,rfit in zip([model.datatag for model in models],_emRatioFit):
print " ",key," : ",rfit
print " ----------------- "
_emRatioFitNonZero = [x for x in _emRatioFit if not(x is None)]
print " avg : ",lsq.wavg(_emRatioFitNonZero)
## -- done saving data
if not(utp.get_option("to_terminal",True,**kwargs[key])) and\
utp.get_option("to_file",False,**kwargs[key]):
for ix in range(len(models)):
## -- loops and saves all without creating window
do_plot_corr_effective_mass_check([ix])
else:
do_plot_corr_effective_mass_check(_emIdx)
def compute_diagonal((dset,key)): print "diagonal key ",key tdat = compute_correlation_pair(dset,key,key) return (key,gv.mean(tdat[key]),gv.sdev(tdat[key]),gv.evalcorr(tdat)[key,key])
def plot_corr_adv_stacked_3pt(models,data,fit,req=None,**kwargs):
"""
Get all data ready so that it can be plotted on command
Allows for dynamic cycling through plots
"""
_p3NMod = len(models)
_p3NTsp = 0 ## -- number of source/sink separations
_p3Tsp = [] ## -- list of source/sink separations used
_p3Key = [] ## -- list of keys used, to search for different source/sink separations
_p3Idx = [0] ## -- index of plotted function, in array so it can be modified in functions
_p3ColorList = ['r','#1e90ff','g','b']
## -- objects to hold all plot data
## - Dat/Fit refers to the correlator data or the fit function
## - Central/Error are the central value and errors
_p3DatCentral = []
_p3DatError = []
_p3FitCentral = []
_p3FitError = []
#
## -- timeslice objects
_p3TData = []
_p3TFit = []
_p3TDataSub = []
_p3TFitSub = []
fig,axp = plt.subplots(1,figsize=(10,8))
if print_quality:
plt.subplots_adjust(bottom=0.18,left=0.18,right=0.97,top=0.95)
else:
plt.subplots_adjust(bottom=0.15,left=0.15,right=0.97,top=0.95)
#
## -- setup plot function
def do_plot_3pt(idx,fig=fig):
fig.clear()
axp = fig.add_subplot(111)
handles = list() ## -- handles for legend
key = _p3Key[idx[0]]
tbd = np.max([x[-1] for x in _p3TData[idx[0]]])
axp.set_xlim([-float(tbd)/2-1,float(tbd)/2+1])
#axp.set_ylim(utp.get_option("y_scale",[-2,2],**kwargs[key]))
axp.set_ylim(utp.get_option("y_scale",[plotLimit[0],plotLimit[1]],**kwargs[key]))
#
## -- plot fit
if utp.get_option("p3_do_fit",True,**kwargs[key]):
for i,tsub,fitcn in zip(range(len(_p3TFitSub[idx[0]])),
_p3TFitSub[idx[0]],_p3FitCentral[idx[0]]):
axp.plot(tsub,fitcn,color=_p3ColorList[i])
for i,tsub,fiter in zip(range(len(_p3TFitSub[idx[0]])),_p3TFitSub[idx[0]],_p3FitError[idx[0]]):
axp.plot(tsub,fiter[0],color=_p3ColorList[i],
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
axp.plot(tsub,fiter[1],color=_p3ColorList[i],
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
## -- plot correlator data
for i,tsub,datcn,dater in zip(range(len(_p3TFitSub[idx[0]])),_p3TDataSub[idx[0]],
_p3DatCentral[idx[0]],_p3DatError[idx[0]]):
(_,caps,_) = axp.errorbar(tsub,datcn,dater,
mfc=utp.get_option("markerfacecolor1",'None',**kwargs[key]),
mec=_p3ColorList[i],
color=_p3ColorList[i],
#mec=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
#color=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
ls=utp.get_option("linestyle1",'None',**kwargs[key]),
marker=utp.get_option("marker1",'o',**kwargs[key]),
ms=utp.get_option("markersize",9,**kwargs[key]),
ecolor=_p3ColorList[i],
capsize=6,elinewidth=2)
for cap in caps:
cap.set_markeredgewidth(1)
for i,tfit,tsub,datcn in zip(range(len(_p3TFit[idx[0]])),_p3TFit[idx[0]],
_p3TFitSub[idx[0]],_p3DatCentral[idx[0]]):
handle = axp.scatter(tsub,[datcn[t] for t in tfit],color=_p3ColorList[i],
marker=utp.get_option("marker",'o',**kwargs[key]),
s=utp.get_option("markersize",81,**kwargs[key]))
handles.append(handle)
fig.suptitle(utp.get_option("plottitlep3",str(idx[0])+" default title "+str(key),**kwargs[key]),
fontsize=utp.get_option("titlesize",20,**kwargs[key]))
if print_quality:
axp.set_xlabel(r'$t-\frac{T}{2}$',fontsize=40)
axp.set_ylabel(utp.get_option("yaxistitle",r"$C(t,T)$",**kwargs[key]),
#fontsize=30,rotation=0,position=(0.05,0.98))
fontsize=40,rotation='vertical')
axp.yaxis.set_label_coords(-0.10,0.5)
axp.tick_params(axis='both', which='major', labelsize=30)
plt.yticks(list(np.arange(plotLimit[0],plotLimit[1]+1e-8,plotLimit[2])),
fontsize=30)
else:
axp.set_xlabel(r'$t-\frac{T}{2}$',fontsize=30)
axp.set_ylabel(utp.get_option("yaxistitle",r"$C(t,T)$",**kwargs[key]),
#fontsize=30,rotation=0,position=(0.05,0.98))
fontsize=30,rotation=0)
#axp.yaxis.set_label_coords(-0.02,0.28)
axp.yaxis.set_label_coords(0.0,1.03)
axp.tick_params(axis='both', which='major', labelsize=24)
## -- modify some options
#for item in ([axp.xaxis.label,axp.yaxis.label]):
# # must be after setting label content (LaTeX ruins it)
# item.set_fontsize(fontsize=utp.get_option("fontsize",36,**kwargs[key]))
plt.legend(handles,["T = "+str(t) for t in _p3Tsp],fontsize=30)
rect =fig.patch
rect.set_facecolor('white')
if utp.get_option("to_file",False,**kwargs[key]):
#print "key",key,"saved to file",save_dir+'/'+save_name
save_dir = utp.get_option("p3_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("p3_save_name","p3plot-"+key+".pdf",**kwargs[key])
plt.savefig(save_dir+'/'+save_name)
if utp.get_option("to_terminal",True,**kwargs[key]):
plt.draw()
pass
#
## -- setup button press action function
def press_3pt(event,idx=_p3Idx):
try:
## -- manually indicate index
idx[0] = int(event.key) + (idx[0])*10
except ValueError:
if event.key==' ': ## -- space
## -- allows for replotting when changing index by typing number keys
idx[0] = idx[0] % len(_p3Key)
do_plot_3pt(idx)
elif event.key=='left':
idx[0] = (idx[0] - 1) % len(_p3Key)
do_plot_3pt(idx)
elif event.key=='right':
idx[0] = (idx[0] + 1) % len(_p3Key)
do_plot_3pt(idx)
elif event.key=='backspace':
## -- reset index so can manually flip through using number keys
idx[0] = 0
elif event.key=='d':
## -- dump plots into ./plotdump directory
for ix,key in zip(range(len(_p3Key)),_p3Key):
save_dir = utp.get_option("p3_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("p3_save_name","p3plot-"+key+".pdf",**kwargs[key])
do_plot_3pt([ix])
plt.savefig(save_dir+'/'+save_name)
do_plot_3pt(idx)
#
## --
fig.canvas.mpl_connect('key_press_event',press_3pt)
## -- save plot data
for idx,model in zip(range(len(models)),models):
key = model.datatag
tsep = int(key.split('t')[-1]) # tsep
tkey = 't'.join(key.split('t')[:-1]) # rest of tag
if not(tsep in _p3Tsp):
_p3Tsp.append(tsep)
_p3NTsp += 1
if not(tkey in _p3Key): ## -- append a list to everything for this new key
_p3Key.append(tkey)
_p3TFit.append(list())
_p3TData.append(list())
_p3TFitSub.append(list())
_p3TDataSub.append(list())
_p3FitCentral.append(list())
_p3FitError.append(list())
_p3DatCentral.append(list())
_p3DatError.append(list())
tidx = _p3Key.index(tkey)
_p3TFit[tidx].append(list(model.tfit))
_p3TData[tidx].append(model.tdata[:len(_p3TFit[tidx][-1])+2])
_p3TFitSub[tidx].append([t-float(len(_p3TFit[tidx][-1])+1)/2 for t in _p3TFit[tidx][-1]])
_p3TDataSub[tidx].append([t-float(len(_p3TFit[tidx][-1])+1)/2 for t in _p3TData[tidx][-1]])
## -- fit
#if False:
#_p3FitFunc = utp.create_fit_func_3pt(model,fit)
if req is None:
_p3FitFunc = utp.mask_fit_fcn(model,fit,invert=True)
else:
_p3FitFunc = utp.mask_fit_fcn(model,fit,req=req,invert=False)
_p3FitMean = gv.mean(_p3FitFunc(np.array(_p3TFit[tidx][-1])))
_p3FitSdev = gv.sdev(_p3FitFunc(np.array(_p3TFit[tidx][-1])))
_p3FitCentral[tidx].append(_p3FitMean)
_p3FitError[tidx].append([
np.array(_p3FitMean)-np.array(_p3FitSdev),
np.array(_p3FitMean)+np.array(_p3FitSdev)])
## -- data
if req is None:
_p3SubFunc = utp.mask_fit_fcn(model,fit,invert=False)
else:
_p3SubFunc = utp.mask_fit_fcn(model,fit,req=req,invert=True)
_dfSub = _p3SubFunc(np.array(_p3TData[tidx][-1]))
#print _p3TData[tidx][-1]
#print _p3TFit[tidx][-1]
#print _dfSub,data[key]
#_p3DatMean = gv.mean([data[key][t] for t in _p3TData[tidx][-1]])
#_p3DatSdev = gv.sdev([data[key][t] for t in _p3TData[tidx][-1]])
_p3DatMean = gv.mean(np.array([data[key][t] for t in _p3TData[tidx][-1]])-_dfSub)
_p3DatSdev = gv.sdev(np.array([data[key][t] for t in _p3TData[tidx][-1]])-_dfSub)
_p3DatCentral[tidx].append( _p3DatMean )
_p3DatError[tidx].append([list(_p3DatSdev),list(_p3DatSdev)])
## -- done saving data
if not(utp.get_option("to_terminal",True,**kwargs[key])) and\
utp.get_option("to_file",False,**kwargs[key]):
for ix in range(len(_p3Key)):
## -- loops and saves all without creating window
do_plot_3pt([ix])
else:
do_plot_3pt(_p3Idx)
def main():
gd.ranseed([2009,2010,2011,2012]) # initialize random numbers (opt.)
x,y = make_data() # make fit data
p0 = None # make larger fits go faster (opt.)
for nexp in range(2,8):
if nexp == 2:
sys_stdout = sys.stdout
sys.stdout = tee.tee(sys_stdout, open("eg4GBF.out","w"))
print '************************************* nexp =',nexp
prior = make_prior(nexp)
fit = lsqfit.nonlinear_fit(data=(x,y),fcn=f,prior=prior,p0=p0)
print fit # print the fit results
# E = fit.p['E'] # best-fit parameters
# a = fit.p['a']
# print 'E1/E0 =',E[1]/E[0],' E2/E0 =',E[2]/E[0]
# print 'a1/a0 =',a[1]/a[0],' a2/a0 =',a[2]/a[0]
print
if nexp == 3:
sys.stdout = sys_stdout
if fit.chi2/fit.dof<1.:
p0 = fit.pmean # starting point for next fit (opt.)
if DO_ERRORBUDGET:
print E[1]/E[0]
print (E[1]/E[0]).partialsdev(fit.prior['E'])
print (E[1]/E[0]).partialsdev(fit.prior['a'])
print (E[1]/E[0]).partialsdev(y)
outputs = {'E1/E0':E[1]/E[0], 'E2/E0':E[2]/E[0],
'a1/a0':a[1]/a[0], 'a2/a0':a[2]/a[0]}
inputs = {'E':fit.prior['E'],'a':fit.prior['a'],'y':y}
sys.stdout = tee.tee(sys_stdout, open("eg4GBFb.out","w"))
print fit.fmt_values(outputs)
print fit.fmt_errorbudget(outputs,inputs)
sys.stdout = sys_stdout
if DO_EMPBAYES:
def fitargs(z,nexp=nexp,prior=prior,f=f,data=(x,y),p0=p0):
z = gd.exp(z)
prior['a'] = [gd.gvar(0.5,0.5*z[0]) for i in range(nexp)]
return dict(prior=prior,data=data,fcn=f,p0=p0)
##
z0 = [0.0]
fit,z = lsqfit.empbayes_fit(z0,fitargs,tol=1e-3)
sys.stdout = tee.tee(sys_stdout, open("eg4GBFa.out","w"))
print fit # print the optimized fit results
E = fit.p['E'] # best-fit parameters
a = fit.p['a']
print 'E1/E0 =',E[1]/E[0],' E2/E0 =',E[2]/E[0]
print 'a1/a0 =',a[1]/a[0],' a2/a0 =',a[2]/a[0]
print "prior['a'] =",fit.prior['a'][0]
sys.stdout = sys_stdout
print
if DO_PLOT:
import pylab as pp
from gvar import mean,sdev
fity = f(x,fit.pmean)
ratio = y/fity
pp.xlim(0,21)
pp.xlabel('x')
pp.ylabel('y/f(x,p)')
pp.errorbar(x=x,y=mean(ratio),yerr=sdev(ratio),fmt='ob')
pp.plot([0.0,21.0],[1.0,1.0])
pp.show()
def wavg(dataseq, prior=None, fast=False, **kargs):
""" Weighted average of |GVar|\s or arrays/dicts of |GVar|\s.
The weighted average of several |GVar|\s is what one obtains from
a least-squares fit of the collection of |GVar|\s to the
one-parameter fit function ::
def f(p):
return N * [p[0]]
where ``N`` is the number of |GVar|\s. The average is the best-fit
value for ``p[0]``. |GVar|\s with smaller standard deviations carry
more weight than those with larger standard deviations. The averages
computed by ``wavg`` take account of correlations between the |GVar|\s.
If ``prior`` is not ``None``, it is added to the list of data
used in the average. Thus ``wavg([x2, x3], prior=x1)`` is the
same as ``wavg([x1, x2, x3])``.
Typical usage is ::
x1 = gvar.gvar(...)
x2 = gvar.gvar(...)
x3 = gvar.gvar(...)
xavg = wavg([x1, x2, x3]) # weighted average of x1, x2 and x3
where the result ``xavg`` is a |GVar| containing the weighted average.
The individual |GVar|\s in the last example can be replaced by
multidimensional distributions, represented by arrays of |GVar|\s
or dictionaries of |GVar|\s (or arrays of |GVar|\s). For example, ::
x1 = [gvar.gvar(...), gvar.gvar(...)]
x2 = [gvar.gvar(...), gvar.gvar(...)]
x3 = [gvar.gvar(...), gvar.gvar(...)]
xavg = wavg([x1, x2, x3])
# xavg[i] is wgtd avg of x1[i], x2[i], x3[i]
where each array ``x1``, ``x2`` ... must have the same shape.
The result ``xavg`` in this case is an array of |GVar|\s, where
the shape of the array is the same as that of ``x1``, etc.
Another example is ::
x1 = dict(a=[gvar.gvar(...), gvar.gvar(...)], b=gvar.gvar(...))
x2 = dict(a=[gvar.gvar(...), gvar.gvar(...)], b=gvar.gvar(...))
x3 = dict(a=[gvar.gvar(...), gvar.gvar(...)])
xavg = wavg([x1, x2, x3])
# xavg['a'][i] is wgtd avg of x1['a'][i], x2['a'][i], x3['a'][i]
# xavg['b'] is gtd avg of x1['b'], x2['b']
where different dictionaries can have (some) different keys. Here the
result ``xavg`` is a :class:`gvar.BufferDict`` having the same keys as
``x1``, etc.
Weighted averages can become costly when the number of random samples being
averaged is large (100s or more). In such cases it might be useful to set
parameter ``fast=True``. This causes ``wavg`` to estimate the weighted
average by incorporating the random samples one at a time into a
running average::
result = prior
for dataseq_i in dataseq:
result = wavg([result, dataseq_i], ...)
This method is much faster when ``len(dataseq)`` is large, and gives the
exact result when there are no correlations between different elements
of list ``dataseq``. The results are approximately correct when
``dataseq[i]`` and ``dataseq[j]`` are correlated for ``i!=j``.
:param dataseq: The |GVar|\s to be averaged. ``dataseq`` is a one-dimensional
sequence of |GVar|\s, or of arrays of |GVar|\s, or of dictionaries
containing |GVar|\s or arrays of |GVar|\s. All ``dataseq[i]`` must
have the same shape.
:param prior: Prior values for the averages, to be included in the weighted
average. Default value is ``None``, in which case ``prior`` is ignored.
:type prior: |GVar| or array/dictionary of |GVar|\s
:param fast: Setting ``fast=True`` causes ``wavg`` to compute an
approximation to the weighted average that is much faster to calculate
when averaging a large number of samples (100s or more). The default is
``fast=False``.
:type fast: bool
:param kargs: Additional arguments (e.g., ``svdcut``) to the fitter
used to do the averaging.
:type kargs: dict
Results returned by :func:`gvar.wavg` have the following extra
attributes describing the average:
.. attribute:: chi2
``chi**2`` for weighted average.
.. attribute:: dof
Effective number of degrees of freedom.
.. attribute:: Q
The probability that the ``chi**2`` could have been larger,
by chance, assuming that the data are all Gaussain and consistent
with each other. Values smaller than 0.1 or suggest that the
data are not Gaussian or are inconsistent with each other. Also
called the *p-value*.
Quality factor `Q` (or *p-value*) for fit.
.. attribute:: time
Time required to do average.
.. attribute:: svdcorrection
The *svd* corrections made to the data when ``svdcut`` is not ``None``.
.. attribute:: fit
Fit output from average.
"""
if len(dataseq) <= 0:
if prior is None:
return None
wavg.Q = 1
wavg.chi2 = 0
wavg.dof = 0
wavg.time = 0
wavg.fit = None
wavg.svdcorrection = None
if hasattr(prior, 'keys'):
return BufferDictWAvg(dataseq[0], wavg)
if numpy.shape(prior) == ():
return GVarWAvg(prior, wavg)
else:
return ArrayWAvg(numpy.asarray(prior), wavg)
elif len(dataseq) == 1 and prior is None:
wavg.Q = 1
wavg.chi2 = 0
wavg.dof = 0
wavg.time = 0
wavg.fit = None
wavg.svdcorrection = None
if hasattr(dataseq[0], 'keys'):
return BufferDictWAvg(dataseq[0], wavg)
if numpy.shape(dataseq[0]) == ():
return GVarWAvg(dataseq[0], wavg)
else:
return ArrayWAvg(numpy.asarray(dataseq[0]), wavg)
if fast:
chi2 = 0
dof = 0
time = 0
ans = prior
svdcorrection = gvar.BufferDict()
for i, dataseq_i in enumerate(dataseq):
if ans is None:
ans = dataseq_i
else:
ans = wavg([ans, dataseq_i], fast=False, **kargs)
chi2 += wavg.chi2
dof += wavg.dof
time += wavg.time
if wavg.svdcorrection is not None:
for k in wavg.svdcorrection:
svdcorrection[str(i) + ':' + k] = wavg.svdcorrection[k]
wavg.chi2 = chi2
wavg.dof = dof
wavg.time = time
wavg.Q = gammaQ(dof / 2., chi2 / 2.)
wavg.svdcorrection = svdcorrection
wavg.fit = None
ans.dof = wavg.dof
ans.Q = wavg.Q
ans.chi2 = wavg.chi2
ans.time = wavg.time
ans.svdcorrection = wavg.svdcorrection
ans.fit = wavg.fit
return ans
if hasattr(dataseq[0], 'keys'):
data = {}
keys = []
if prior is not None:
dataseq = [prior] + list(dataseq)
for dataseq_i in dataseq:
for k in dataseq_i:
if k in data:
data[k].append(dataseq_i[k])
else:
data[k] = [dataseq_i[k]]
keys.append(k)
data = gvar.BufferDict(data, keys=keys)
p0 = gvar.BufferDict()
for k in data:
p0[k] = gvar.mean(data[k][0]) + gvar.sdev(data[k][0]) / 10.
def fcn(p):
ans = gvar.BufferDict()
for k in data:
ans[k] = len(data[k]) * [p[k]]
return ans
else:
p = numpy.asarray(dataseq[0])
data = [] if prior is None else [prior]
data += [dataseqi for dataseqi in dataseq]
p0 = numpy.asarray(gvar.mean(data[0]) + gvar.sdev(data[0]) / 10.)
data = numpy.array(data)
def fcn(p):
return len(data) * [p]
fit = lsqfit.nonlinear_fit(data=data, fcn=fcn, p0=p0, **kargs)
# wavg.Q = fit.Q
# wavg.chi2 = fit.chi2
# wavg.dof = fit.dof
# wavg.time = fit.time
# wavg.svdcorrection = fit.svdcorrection
# wavg.fit = fit
if p0.shape is None:
return BufferDictWAvg(gvar.BufferDict(p0, buf=fit.p.flat), fit)
elif p0.shape == ():
return GVarWAvg(fit.p.flat[0], fit)
else:
return ArrayWAvg(fit.p.reshape(p0.shape), fit)
def plot_corr_3pt(models,data,fit,**kwargs):
"""
Get all data ready so that it can be plotted on command
Allows for dynamic cycling through plots
"""
_p3NMod = len(models)
_p3Idx = [0] ## -- index of plotted function, in array so it can be modified in functions
## -- objects to hold all plot data
## - Dat/Fit refers to the correlator data or the fit function
## - Central/Error are the central value and errors
_p3DatCentral = []
_p3DatError = []
_p3FitCentral = []
_p3FitError = []
#
## -- other objects
_p3TData = []
_p3TFit = []
fig,axp = plt.subplots(1,figsize=(8,8))
#
## -- setup plot function
def do_plot_3pt(idx,fig=fig):
fig.clear()
axp = fig.add_subplot(111)
#fig.subplots_adjust(hspace=0)
key = models[idx[0]].datatag
#axp.set_yscale('log')
#axp.set_xlim([-1,len(_p3TData[idx[0]])])
axp.set_xlim([-.5,len(_p3TFit[idx[0]])+1.5])
axp.set_ylim(utp.get_option("y_scale",[-2,2],**kwargs[key]))
#plt.sca(axp)
#expp = [int(np.floor(np.log10(np.abs(x)))) for x in plt.yticks()[0][2:]]
#expp = ['$10^{'+str(x)+'}$' for x in expp]
#plt.yticks(plt.yticks()[0][2:],expp)
#
## -- plot fit
axp.plot(_p3TData[idx[0]],_p3FitCentral[idx[0]],
color=utp.get_option("color2",'b',**kwargs[key]))
axp.plot(_p3TData[idx[0]],_p3FitError[idx[0]][0],
color=utp.get_option("color2",'g',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
axp.plot(_p3TData[idx[0]],_p3FitError[idx[0]][1],
color=utp.get_option("color2",'g',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
## -- plot correlator data
axp.errorbar(_p3TData[idx[0]],_p3DatCentral[idx[0]],yerr=_p3DatError[idx[0]],
mfc=utp.get_option("markerfacecolor1",'None',**kwargs[key]),
mec=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
color=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
ls=utp.get_option("linestyle1",'None',**kwargs[key]),
marker=utp.get_option("marker1",'o',**kwargs[key]),
ms=utp.get_option("markersize",6,**kwargs[key]))
axp.scatter(_p3TFit[idx[0]],[_p3DatCentral[idx[0]][t] for t in _p3TFit[idx[0]]],
color=utp.get_option("color1",'r',**kwargs[key]),
marker=utp.get_option("marker",'o',**kwargs[key]),
s=utp.get_option("markersize",36,**kwargs[key]))
fig.suptitle(utp.get_option("plottitlep3",str(idx[0])+" default title "+str(key),**kwargs[key]),
fontsize=utp.get_option("titlesize",20,**kwargs[key]))
## -- modify some options
for item in ([axp.xaxis.label,axp.yaxis.label]):
# must be after setting label content (LaTeX ruins it)
item.set_fontsize(fontsize=utp.get_option("fontsize",20,**kwargs[key]))
rect =fig.patch
rect.set_facecolor('white')
if utp.get_option("to_file",False,**kwargs[key]):
#print "key",key,"saved to file",save_dir+'/'+save_name
save_dir = utp.get_option("p3_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("p3_save_name","p3plot-"+key+".pdf",**kwargs[key])
plt.savefig(save_dir+'/'+save_name)
if utp.get_option("to_terminal",True,**kwargs[key]):
plt.draw()
pass
#
## -- setup button press action function
def press_3pt(event,idx=_p3Idx):
try:
## -- manually indicate index
idx[0] = int(event.key) + (idx[0])*10
except ValueError:
if event.key==' ': ## -- space
## -- allows for replotting when changing index by typing number keys
idx[0] = idx[0] % _p3NMod
do_plot_3pt(idx)
elif event.key=='left':
idx[0] = (idx[0] - 1) % _p3NMod
do_plot_3pt(idx)
elif event.key=='right':
idx[0] = (idx[0] + 1) % _p3NMod
do_plot_3pt(idx)
elif event.key=='backspace':
## -- reset index so can manually flip through using number keys
idx[0] = 0
elif event.key=='d':
## -- dump plots into ./plotdump directory
for ix,model in zip(range(len(models)),models):
key = model.datatag
save_dir = utp.get_option("p3_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("p3_save_name","p3plot-"+key+".pdf",**kwargs[key])
do_plot_3pt([ix])
plt.savefig(save_dir+'/'+save_name)
do_plot_3pt(idx)
#
## --
fig.canvas.mpl_connect('key_press_event',press_3pt)
## -- save plot data
for idx,model in zip(range(len(models)),models):
key = model.datatag
_p3TData.append(model.tdata)
_p3TFit.append(model.tfit)
#_p3TFit[-1] = np.append(_p3TFit[-1],list(sorted([len(_p3TData[-1]) - t for t in _p3TFit[-1]])))
## -- fit
_p3FitFunc = utp.create_fit_func_3pt(model,fit) ## not defined yet!
_p3FitMean = gv.mean(_p3FitFunc(_p3TData[-1]))
_p3FitSdev = gv.sdev(_p3FitFunc(_p3TData[-1]))
_p3FitCentral.append(_p3FitMean)
_p3FitError.append([
np.array(_p3FitMean)-np.array(_p3FitSdev),
np.array(_p3FitMean)+np.array(_p3FitSdev)])
## -- data
_p3DatMean = gv.mean(data[key])
_p3DatSdev = gv.sdev(data[key])
_p3DatCentral.append( _p3DatMean )
_p3DatError.append([list(_p3DatSdev),list(_p3DatSdev)])
## -- done saving data
if not(utp.get_option("to_terminal",True,**kwargs[key])) and\
utp.get_option("to_file",False,**kwargs[key]):
for ix in range(len(models)):
## -- loops and saves all without creating window
do_plot_3pt([ix])
else:
do_plot_3pt(_p3Idx)
def main():
gv.ranseed([2009, 2010, 2011, 2012]) # initialize random numbers (opt.)
x, y = make_data() # make fit data
p0 = None # make larger fits go faster (opt.)
sys_stdout = sys.stdout
for nexp in range(3, 8):
prior = make_prior(nexp)
fit = lsqfit.nonlinear_fit(data=(x, y), fcn=f, prior=prior, p0=p0, svdcut=1e-15) # ,svdcut=SVDCUT)
if fit.chi2 / fit.dof < 1.0:
p0 = fit.pmean # starting point for next fit (opt.)
if nexp == 5:
sys.stdout = tee.tee(sys_stdout, open("eg3.out", "w"))
print "************************************* nexp =", nexp
print fit # print the fit results
E = fit.p["E"] # best-fit parameters
a = fit.p["a"]
print "E1/E0 =", E[1] / E[0], " E2/E0 =", E[2] / E[0]
print "a1/a0 =", a[1] / a[0], " a2/a0 =", a[2] / a[0]
# print E[1]-E[0], E[-1]-E[-2]
# print (E[1]/E[0]).partialsdev(fit.prior['E'])
# print (E[1]/E[0]).partialsdev(fit.prior['a'])
# print (E[1]/E[0]).partialsdev(fit.y)
sys.stdout = sys_stdout
print
# sys.stdout = tee.tee(sys_stdout, open("eg3a.out", "w"))
# for i in range(1):
# print '--------------------- fit with %d extra data sets' % (i+1)
# x, y = make_data(1)
# prior = fit.p
# fit = lsqfit.nonlinear_fit(data=(x,y),fcn=f1,prior=prior, svdcut=SVDCUT)
# print fit
sys.stdout = sys_stdout
if DO_BOOTSTRAP:
Nbs = 10 # number of bootstrap copies
outputs = {"E1/E0": [], "E2/E0": [], "a1/a0": [], "a2/a0": [], "E1": [], "a1": []} # results
for bsfit in fit.bootstrap_iter(n=Nbs):
E = bsfit.pmean["E"] # best-fit parameters
a = bsfit.pmean["a"]
outputs["E1/E0"].append(E[1] / E[0]) # accumulate results
outputs["E2/E0"].append(E[2] / E[0])
outputs["a1/a0"].append(a[1] / a[0])
outputs["a2/a0"].append(a[2] / a[0])
outputs["E1"].append(E[1])
outputs["a1"].append(a[1])
# print E[:2]
# print a[:2]
# print bsfit.chi2/bsfit.dof
# extract means and standard deviations from the bootstrap output
for k in outputs:
outputs[k] = gv.gvar(np.mean(outputs[k]), np.std(outputs[k]))
print "Bootstrap results:"
print "E1/E0 =", outputs["E1/E0"], " E2/E1 =", outputs["E2/E0"]
print "a1/a0 =", outputs["a1/a0"], " a2/a0 =", outputs["a2/a0"]
print "E1 =", outputs["E1"], " a1 =", outputs["a1"]
if DO_PLOT:
print fit.format(100) # print the fit results
import pylab as pp
from gvar import mean, sdev
fity = f(x, fit.pmean)
ratio = y / fity
pp.xlim(0, 21)
pp.xlabel("x")
pp.ylabel("y/f(x,p)")
pp.errorbar(x=x, y=mean(ratio), yerr=sdev(ratio), fmt="ob")
pp.plot([0.0, 21.0], [1.0, 1.0])
pp.show()
def main():
gv.ranseed([2009,2010,2011,2012]) # initialize random numbers (opt.)
x,y = make_data() # make fit data
p0 = None # make larger fits go faster (opt.)
sys_stdout = sys.stdout
sys.stdout = tee.tee(sys.stdout, open("eg1.out","w"))
for nexp in range(3,20):
prior = make_prior(nexp)
fit = lsqfit.nonlinear_fit(data=(x,y),fcn=f,prior=prior,p0=p0) #, svdcut=SVDCUT)
if fit.chi2/fit.dof<1.:
p0 = fit.pmean # starting point for next fit (opt.)
if nexp in [8, 9, 10]:
print(".".center(73))
if nexp > 7 and nexp < 19:
continue
elif nexp not in [3]:
print("")
print '************************************* nexp =',nexp
print fit.format() # print the fit results
E = fit.p['E'] # best-fit parameters
a = fit.p['a']
print 'E1/E0 =',E[1]/E[0],' E2/E0 =',E[2]/E[0]
print 'a1/a0 =',a[1]/a[0],' a2/a0 =',a[2]/a[0]
# extra data 1
print '\n--------------------- fit with extra information'
sys.stdout = tee.tee(sys_stdout, open("eg1a.out", "w"))
def ratio(p):
return p['a'][1] / p['a'][0]
newfit = lsqfit.nonlinear_fit(data=gv.gvar(1,1e-5), fcn=ratio, prior=fit.p)
print (newfit)
# print(newfit.p['a'][1] / newfit.p['a'][0])
# print(fit.p['a'][1] / fit.p['a'][0])
# alternate method for extra data
sys.stdout = tee.tee(sys_stdout, open("eg1b.out", "w"))
fit.p['a1/a0'] = fit.p['a'][1] / fit.p['a'][0]
new_data = {'a1/a0' : gv.gvar(1,1e-5)}
new_p = lsqfit.wavg([fit.p, new_data])
print 'chi2/dof = %.2f\n' % (new_p.chi2 / new_p.dof)
print 'E:', new_p['E'][:4]
print 'a:', new_p['a'][:4]
print 'a1/a0:', new_p['a1/a0']
# # extra data 2
# sys.stdout = tee.tee(sys_stdout, open("eg1b.out", "w"))
# newfit = fit
# for i in range(1):
# print '\n--------------------- fit with %d extra data sets' % (i+1)
# x, ynew = make_data()
# prior = newfit.p
# newfit = lsqfit.nonlinear_fit(data=(x,ynew), fcn=f, prior=prior) # , svdcut=SVDCUT)
# print newfit
sys.stdout = sys_stdout
# def fcn(x, p):
# return f(x, p), f(x, p)
# prior = make_prior(nexp)
# fit = lsqfit.nonlinear_fit(data=(x, [y, ynew]), fcn=fcn, prior=prior, p0=newfit.pmean) # , svdcut=SVDCUT)
# print(fit)
if DO_BOOTSTRAP:
Nbs = 40 # number of bootstrap copies
outputs = {'E1/E0':[], 'E2/E0':[], 'a1/a0':[],'a2/a0':[],'E1':[],'a1':[]} # results
for bsfit in fit.bootstrap_iter(n=Nbs):
E = bsfit.pmean['E'] # best-fit parameters
a = bsfit.pmean['a']
outputs['E1/E0'].append(E[1]/E[0]) # accumulate results
outputs['E2/E0'].append(E[2]/E[0])
outputs['a1/a0'].append(a[1]/a[0])
outputs['a2/a0'].append(a[2]/a[0])
outputs['E1'].append(E[1])
outputs['a1'].append(a[1])
# print E[:2]
# print a[:2]
# print bsfit.chi2/bsfit.dof
# extract means and standard deviations from the bootstrap output
for k in outputs:
outputs[k] = gv.gvar(np.mean(outputs[k]),np.std(outputs[k]))
print 'Bootstrap results:'
print 'E1/E0 =',outputs['E1/E0'],' E2/E1 =',outputs['E2/E0']
print 'a1/a0 =',outputs['a1/a0'],' a2/a0 =',outputs['a2/a0']
print 'E1 =',outputs['E1'],' a1 =',outputs['a1']
if DO_PLOT:
import pylab as plt
ratio = y/fit.fcn(x,fit.pmean)
plt.xlim(0,21)
plt.xlabel('x')
plt.ylabel('y/f(x,p)')
plt.errorbar(x=x,y=gv.mean(ratio),yerr=gv.sdev(ratio),fmt='ob')
plt.plot([0.0,21.0],[1.0,1.0])
plt.show()
