pp = Pretty_Plotter()
pp._teXify() # LaTeX
pp.params['text.latex.preamble'] = r"\usepackage{amsmath}"
pp._updateRC()
fig = plt.figure(figsize=(8, 8)) # make plot
ax = []
ax.append(fig.add_subplot(111))
ax[0].set_title(
r'Checking stability of $g_W(\tau_W)$ for $\tau_W = \lim_{g_{\text{int}}\to 0} \left[\ln\left(1+\frac{1}{g_{\text{int}}}\right)\right]^{-1}$',
fontsize=pp.ttfont)
ax[0].set_ylabel(r'$g_W(\tau_W) = e^{-1/\tau_W} - \tau_W$')
ax[0].set_xlabel(r'$g_{\text{int}}$')
x = np.linspace(-.2, .1, 1000)
ax[0].plot(x,
np.exp(-1. / np.log(1. + 1. / x.clip(0))) - x,
label=r'$1/0$ = np.inf',
linewidth=2.,
alpha=.4)
ax[0].plot(x,
np.exp(-1. / np.log(1. + 1. / x.clip(np.finfo(float).eps))) - x,
label=r"$1/0$ = `eps'",
linewidth=2.,
alpha=.4)
ax[0].legend(loc='best', shadow=True, fontsize=pp.axfont)
pp.save_or_show(saveOrDisplay(save, __file__), PLOT_LOC)
minor_yticks = np.linspace(0, .05, 5*2+1, endpoint=True)
ax.xaxis.set_ticks(minor_xticks, minor = True)
ax.yaxis.set_ticks(minor_yticks, minor = True)
# Specify different settings for major and minor grids
ax.grid(which = 'minor', alpha = 0.3)
ax.grid(which = 'major', alpha = 0.7)
# im = np.asarray(Image.open('results/figures/archive/misc_appendixA3_acorr_img.png'))
# store.store(im, __file__, '_img')
im = store.load('results/data/numpy_objs/misc_appendixA3_acorr_img.json')
ax.imshow(im, extent=xlim+ylim, aspect='auto', label = r'paper')
m = 0.01
r = iter([np.sqrt(3)*m, .5*m*(3*np.sqrt(3)+np.sqrt(15)), .5*m*(3*np.sqrt(3)-np.sqrt(15))])
f = M2_Exp(next(r), m)
x = np.linspace(0, 1000, 1000, True)
plt.plot(x, f.eval(x), linewidth=4., color='red', alpha=0.6, linestyle="--",
label = r'$r = \sqrt{3}m$')
plt.plot(x, f.eval(x, tau=1/next(r)), linewidth=4., color='green', alpha=0.6, linestyle="--",
label = r'$r = \frac{m}{2}(3\sqrt{3} + \sqrt{15})$')
plt.plot(x, f.eval(x, tau=1/next(r)), linewidth=4., color='blue', alpha=0.6, linestyle="--",
label = r'$r = \frac{m}{2}(3\sqrt{3} - \sqrt{15})$')
ax.legend(loc='lower right', shadow=True, fancybox=True)
pp.save_or_show(saveOrDisplay(save, file_name), PLOT_LOC)
def main(x0, pot, file_name, n_samples, n_burn_in,
mixing_angles, step_sizes, separations, opFn ,n_steps = 1,
tintTh=None, paccTh = None, opTh = None, plot_res=1000,
save = False):
"""A wrapper function
Required Inputs
x0 :: np.array :: initial position input to the HMC algorithm
pot :: potential class :: defined in hmc.potentials
file_name :: string :: the final plot will be saved with a similar name if save=True
n_samples :: int :: number of HMC samples
n_burn_in :: int :: number of burn in samples
mixing_angles :: iterable :: mixing angles for the HMC algorithm
angle_labels :: list :: list of labels for the angles provided
opFn :: func :: function for autocorellations - takes one input: samples
op_name :: str :: name of opFn for plotting
separations :: iterable :: lengths of autocorellations
max_sep :: float :: define the max separation
Optional Inputs
rand_steps :: bool :: probability of with prob
step_size :: float :: MDMC step size
n_steps :: int :: number of MDMC steps
spacing :: float :: lattice spacing
acFunc :: func :: function for evaluating autocorrelations
save :: bool :: True saves the plot, False prints to the screen
"""
# required declarations. If no lines are provided this still allows iteration for 0 times
lines = {} # contains the label as the key and a tuple as (x,y) data in the entry
acs = {}
rng = np.random.RandomState()
print 'Running Model: {}'.format(file_name)
def coreFunc(a):
"""runs the below for an angle, a
Allows multiprocessing across a range of values for a
"""
i,d,a = a
model = Model(x0, pot=pot, rng=rng, step_size = d,
n_steps = n_steps, rand_steps=False)
c = acorr.Autocorrelations_1d(model)
c.runModel(n_samples=n_samples, n_burn_in=n_burn_in, mixing_angle = a, verbose=False, verb_pos=i)
acs = c.getAcorr(separations, opFn, norm = False)
# get parameters generated
pacc = c.model.p_acc
pacc_err = np.std(c.model.sampler.accept.accept_rates)
ans = errors.uWerr(c.op_samples, acorr=acs) # get errors
op_av, op_diff, _, itau, itau_diff, _, acns = ans # extract data
w = errors.getW(itau, itau_diff, n=n_samples) # get window length
if not np.isnan(w):
acns_err = errors.acorrnErr(acns, w, n_samples) # get error estimates
acs = acns
else:
acns_err = np.full(acs.shape, np.nan)
itau = itau_diff = np.nan
return op_av, op_diff, acs, acns_err, itau, itau_diff, pacc, pacc_err, w
# use multiprocessings
elms = step_sizes.size*mixing_angles.size
combinations = np.zeros((elms,3))
combinations[:,1:] = np.array(np.meshgrid(step_sizes, mixing_angles)).T.reshape(-1,2)
combinations[:,0] = np.arange(elms)
ans = prll_map(coreFunc, combinations, verbose=True)
print 'Finished Running Model: {}'.format(file_name)
# results have now been obtained. This operation is a dimension shuffle
# Currently the first iterable dimension contains one copy of each item
# Want to split into separate arrays each of length n
op_av, op_diff, acs, acns_err, itau, itau_diff, pacc, pacc_err, w = zip(*ans)
op_av = np.array(op_av)
op_diff = np.array(op_diff)
acs = np.array(acs)
acns_err = np.array(acns_err)
itau = np.array(itau)
itau_diff = np.array(itau_diff)
pacc = np.array(pacc)
pacc_err = np.array(pacc_err).ravel()
w = np.array(w)
# Bundle all data ready for Plot() and store data as .pkl or .json for future use
all_plot = {'itau':(step_sizes, itau, itau_diff),
'pacc':(step_sizes, pacc, pacc_err),
'acorr':(step_sizes, acs, acns_err),
'op':(step_sizes, op_av, op_diff)
}
max_step = step_sizes[-1]
min_step = step_sizes[0]
step_sizes_th = np.linspace(min_step, max_step, plot_res)
if paccTh is not None:
accs = np.asarray(map(paccTh,step_sizes_th))
all_plot['pacc_th'] = (step_sizes_th, accs)
if tintTh is not None:
# itau = np.asarray([tintTh(dtau,acc) for dtau, acc in zip(step_sizes_th, pacc)])
# itau_hi = np.asarray([tintTh(dtau,acc) for dtau, acc in zip(step_sizes_th, pacc+pacc_err)])
# itau_lo = np.asarray([tintTh(dtau,acc) for dtau, acc in zip(step_sizes_th, pacc-pacc_err)])
# all_plot['tint_th'] = (step_sizes_th, itau, itau_hi, itau_lo)
itau = np.asarray([tintTh(dtau,acc) for dtau, acc in zip(step_sizes_th, accs)])
all_plot['tint_th'] = (step_sizes_th, itau)
# do the same for the X^2 operators
if opTh is not None:
all_plot['op_th'] = (step_sizes_th, np.asarray(map(opTh,step_sizes_th)))
store.store(all_plot, file_name, '_allPlot')
plot(save = saveOrDisplay(save, file_name), **all_plot)
# assert that the autocorrelation routine is the same
av_xx = comparison_xx.mean()
norm = ((comparison_xx-av_xx)**2).mean()
my_acorr = np.asarray(map(lambda s: myAcorr(comparison_xx, av_xx, s), np.asarray(separations)))
christian_class = Christian_Autocorrelation(comparison_xx)
christian_acorr = christian_class.acf()[:c_len]
christian_acorr = np.asarray(christian_acorr)
diffs = christian_acorr[:my_acorr.size] - my_acorr
print " > av. difference: {}".format(diffs.mean())
print 'Checking integration window calculation:'
christian_tint, christian_dtint, christian_w = christian_class.tauintW(False)
_,_,my_w = windowing(comparison_xx, av_xx, 1.0, comparison_xx.size, fast=True)
print "Christian Window:{}".format(christian_w)
print "My Window:{}".format(my_w)
ans = uWerr(comparison_xx, acorr=my_acorr) # get errors
_, _, _, itau, itau_diff, _, acns = ans # extract data
my_w = getW(itau, itau_diff, n=comparison_xx.size) # get window length
my_err = acorrnErr(acns, my_w, comparison_xx.size) # get autocorr errors
christian_acorr = np.asarray(christian_acorr)
christian_err = acorrnErr(christian_acorr, christian_w, comparison_xx.size)
all_plot = preparePlot(christian_acorr[:2*my_w], acns[:2*my_w], my_err[:2*my_w], christian_err[:2*my_w])
store(all_plot, file_name, '_allPlot')
plot(save = saveOrDisplay(save, file_name+"_compareAc"), **all_plot)
# th = Theory(tau=tau, m=m)
# vFn = lambda x: th.eval(t=x, pa=pa, theta=np.pi/2)/th.eval(t=0, pa=pa, theta=np.pi/2.)
#
# l = a['lines'].keys()[0]
# x, f0 = a['lines'][l]
# f1 = vFn(x)
# a['lines'][l] = (x, f1)
# n = 100
# k = a['acns'].keys()[0]
# x,y, e = a['acns'][k]
# del a['acns'][k]
# k =r'Measured data for $C_{\mathscr{M}^2}$'
# a['acns'][k] = x[:n], y[:n], e[:n]
#
# from scipy.optimize import curve_fit
# fn = lambda x, a, b, c: a*np.cos(b*x)**2+c
# fit,cov = curve_fit(fn, x[:20], y[:20])
#
# l = a['lines'].keys()[0]
# x, f0 = a['lines'][l]
# del a['lines'][l]
# l = r'Theory: $C_{\mathscr{M}^2}(s; \langle\rho\rangle_t = 0.99; \vartheta = \frac{\pi}{2})$'
# a['lines'][l] = (x, f0)
#
# f1 = fn(x, *fit)
# cos = r'${:3.2f}\cos^2{:3.2f}s+{:3.2f}$'.format(*fit)
# a['lines'][cos] = (x, f1)
plot(save=saveOrDisplay(save, file_name), **a)
if __name__ == '__main__':
d = './correlations/ref_code/' # grab uWerr data from Matlab script
with open(d + '/uWerr_out.dat') as f:
actual = json.load(f)
actual['itau_aav'] = np.loadtxt(d + 'uWerr_out_tauintFbb.dat')
actual['acorr'] = np.loadtxt(d + 'uWerr_out_gammaFbb.dat')
a = np.loadtxt(d + 'actime_tint20_samples.dat')
# run the uWerr from here
value, dvalue, ddvalue, tauint, dtauint, y, y2 = uWerr(a)
res = {
'value': value,
'dvalue': dvalue,
'ddvalue': ddvalue,
'dtauint': dtauint,
'tauint': tauint,
# 'CFbbopt':c_aav,
'itau_aav': y,
'acorr': y2
}
w = np.around((ddvalue / dvalue)**2 * a.size - .5, 0)
w2 = np.around((dtauint / tauint / 2.)**2 * a.size - .5 + tauint, 0)
assert w == w2 # sanity check
for k in sorted(res.keys()):
print 'Param:{:8s} my code:{:8.4E}, UF:{:8.4E}, change: {:6.5f}%'.format(
k, np.average(res[k]), np.average(actual[k]),
np.average((res[k] - actual[k]) / res[k] * 100.))
plot(res, actual, save=saveOrDisplay(save, file_name))
print 'Exp Residues', me.res
print 'Exp Constant', me.const
print
t = np.linspace(0, 10, 1000)
fE = lambda t: np.real(
np.asarray(
[a_i * np.exp(b_i * t)
for a_i, b_i in zip(me.res, me.poles)]).sum(0))
mu = np.cos(m * tau)**2
r, p, k = residuez([mu, 0], [1, -np.cos(m * tau)**2])
fF = lambda t: np.real(
np.sum(k) + np.asarray(
[a_i / b_i * b_i**(t / tau) for a_i, b_i in zip(r, p)]).sum(0))
lines = {
0: [(t, fE(t), r'\verb|scipy.signal.residuez()|'),
(t, me.eval(t), r'Analytical partial fractioning')],
1: [(t, fF(t), r'\verb|scipy.signal.residuez()|'),
(t, mf.eval(t), r'Analytical partial fractioning')]
}
app = r"$\tau={:4.2f};m={:3.1f}$".format(tau, m)
subtitles = {
0: "Exponentially Distributed Trajectories " + app,
1: "Fixed Trajectories " + app
}
plot(lines, subtitles, save=saveOrDisplay(save, file_name))
