def coreFunc(n_steps):
"""function for multiprocessing support
Required Inputs
n_steps :: int :: the number of LF steps
"""
model = Model(x0.copy(),
pot,
step_size=step_size,
n_steps=n_steps,
accept_kwargs={'get_delta_hs': True})
model.sampler.accept.store_acceptance = True
prob = 1.
delta_hs = 1.
av_dh = -1
accept_rates = []
delta_hs = []
samples = []
while av_dh < 0:
model.run(n_samples=n_samples, n_burn_in=n_burn_in)
accept_rates += model.sampler.accept.accept_rates[n_burn_in:]
delta_hs += model.sampler.accept.delta_hs[n_burn_in:]
samples.append(model.samples.copy())
av_dh = np.mean(delta_hs)
if av_dh < 0: tqdm.write('running again -ve av_dh')
accept_rates = np.asarray(accept_rates)
samples = np.concatenate(tuple(samples), axis=0)
prob = accept_rates.mean()
meas_av_exp_dh = np.asscalar((1. / np.exp(delta_hs)).mean())
# ans = errors.uWerr(accept_rates) # get errors
# f_aav, f_diff, _, itau, itau_diff, _, acns = ans # extract data
mean = accept_rates.mean()
err = np.std(accept_rates) / np.sqrt(n_samples)
th_err = np.std(accept_rates) / np.sqrt(n_samples)
theory = acceptance(dtau=step_size, delta_h=av_dh)
return mean, theory, err, th_err
file_name = __file__
pot = KG(m=m)
n, dim = 20, 1
x0 = np.random.random((n,)*dim)
spacing = 1.
# number of samples/burnin per point
n_samples, n_burn_in = 100000, 1000
mixing_angles = np.array([.5*np.pi])
min_step = 0.2
max_step = 0.7
data_res = 100
plot_res = 1000
step_sizes = np.linspace(min_step, max_step, data_res)
separations = np.arange(500)
# theoretical functions
tintTh = lambda dtau,pacc: ihmc(float(dtau*n_steps*m), float(pacc))
paccTn = lambda dtau: acceptance(dtau=dtau, tau=dtau*n_steps, n=n, m=m)
opTh = None
main(x0, pot, file_name, n_samples, n_burn_in,
mixing_angles, step_sizes,
separations = separations, opFn = magnetisation_sq,
tintTh=tintTh, paccTh = paccTn, opTh = opTh,
plot_res=plot_res,
n_steps = n_steps, save = True)
sites = 20
n_steps = 1
dtau = 0.1
tau = n_steps * dtau
mass = 1
a['subtitle'] = r"Lattice: " \
+ r"${}$; $a={:.1f}; \delta\tau={:.1f}; n={}; M=10^7$".format(
(sites,), n_steps, dtau, n_steps)
# add integrated autocorrelation theory
# format :: {'lines':lines, 'x':angle_fracs, 'subtitle':subtitle, 'op_name':op_name}
# lines are [[y, err, label],..., [y, err, label]]
from theory.autocorrelations import M2_Fix, M2_Exp
from theory.acceptance import acceptance
x = a['x'] # fractions of pi
pacc = a['lines'][3][0][0] # 3rd key, 0th line, y-value
m = M2_Exp(tau=tau, m=1)
y = np.asarray([
m.integrated(tau=tau, m=mass, pa=pa_i, theta=theta * np.pi)
for theta, pa_i in zip(x, pacc)
])
a['lines'][0].append([y, None, r'Theory'])
y = np.full(x.shape, acceptance(tau=tau, dtau=dtau, m=mass, n=sites))
a['lines'][3].append([y, None, r'Theory'])
plot(save=saveOrDisplay(save, file_name), **a)
n, dim = 20, 1
x0 = np.random.random((n, ) * dim)
spacing = 1.0
n_samples, n_burn_in = 10000, 50
c_len = 500
mixing_angles = [.5 * np.pi]
angle_labels = [r'\frac{\pi}{2}']
separations = range(c_len)
opFn = lambda samples: twoPoint(samples, separation=0)
op_name = r'$\hat{O} = x^2$'
op_theory = x2_1df(mu=pot.m, n=x0.size, a=spacing, sep=0)
pacc_theory = acceptance(dtau=step_size, tau=tau, n=x0.size, m=pot.m)
acFunc = lambda t, pa, theta: hmc(pa, tau * m, 1. / tau, t)
print '> Trajectory Length: tau: {}'.format(tau)
print '> Step Size: {}'.format(step_size)
print '> Theoretical <x^2>: {}'.format(op_theory)
print '> Theoretical <P_acc>: {}'.format(pacc_theory)
if '__main__' == __name__:
routine.main(x0,
pot,
file_name,
n_samples=n_samples,
n_burn_in=n_burn_in,
spacing=spacing,
step_size = .1
n_steps = 1
points = 100
tau = n_steps * step_size
n_samples, n_burn_in = 1000, 20
angle_fracs = np.linspace(0, .02, points, True)
opFn = lambda samples: twoPoint(samples, separation=0)
op_name = r'$\hat{O}_{pq} = \phi_0^2$'
# theoretical calculations
op_theory = x2_1df(mu=pot.m, n=x0.size, a=spacing, sep=0)
pacc_theory = acceptance(dtau=step_size,
tau=tau,
n=x0.size,
m=pot.m,
t=tau * n_samples)
acth = AC_Theory(tau=n_steps * step_size, m=pot.m)
iTauTheory = acth.integrated
if '__main__' == __name__:
intac.main(x0,
pot,
file_name,
n_samples=n_samples,
n_burn_in=n_burn_in,
spacing=spacing,
step_size=step_size,
n_steps=n_steps,
opFn=opFn,
spacing = 1.
# number of samples/burnin per point
n_samples, n_burn_in = 100000, 1000
mixing_angles = np.array([np.pi / 8.])
min_step = 0.1
max_step = 0.7
data_res = 100
plot_res = 1000
step_sizes = np.linspace(min_step, max_step, data_res)
separations = np.arange(500)
# theoretical functions
tintTh = None
paccTn = lambda dtau: acceptance(dtau=dtau, tau=dtau * 1, n=n, m=m)
opTh = lambda null: x2_1df(m, n, spacing, 0)
main(x0,
pot,
file_name,
n_samples,
n_burn_in,
mixing_angles,
step_sizes,
separations=separations,
opFn=x_sq,
tintTh=tintTh,
paccTh=paccTn,
opTh=opTh,
plot_res=plot_res,
