def main(N, cache_dir=None):
'''Generate and test a problem with N spins'''
if WIRE:
h, J, gam = generate_wire(N)
else:
h, J, gam = generate_prob(N)
t = time()
if N < 18:
print('Exact solution...')
e_vals, e_vecs = solve(h, J, gamma=gam)
print(e_vals[:2])
print('Runtime: {0:.3f} (s)'.format(time()-t))
t = time()
solver = RP_Solver(h, J, gam, verbose=False, cache_dir=cache_dir)
solver.solve()
print('\n'*3)
print('New RP solution:')
print(solver.node.Es[:2])
print('Runtime: {0:.3f} (s)'.format(time()-t))
msolver = RP_Solver(h, J, gam)
t = time()
modes = solver.node.modes
msolver.mode_solve(modes)
print('\n'*3)
print('Mode solved:')
print(msolver.node.Es[:2])
print('Runtime: {0:.3f} (s)'.format(time()-t))
f = lambda x: np.round(x,2)
print(solver.node.Hx.shape)
print(msolver.node.Hx.shape)
Dx = solver.node.Hx - msolver.node.Hx
print('Dx diffs...')
for i,j in np.transpose(np.nonzero(Dx)):
print('\t{0}:{1} :: {2:.3f}'.format(i,j,Dx[i,j]))
# resolve
for _ in range(TRIALS):
t = time()
nx, nz = solver.ground_fields()
solver = RP_Solver(h, J, gam, nx=nx, nz=nz, verbose=False, cache_dir=cache_dir)
solver.solve()
print('\n'*3)
print('New RP solution:')
print(solver.node.Es[:2])
print('Runtime: {0:.3f} (s)'.format(time()-t))
def run_rp2(self, rp_steps, caching, cache_dir):
'''Compute the spectrum using the new RP-Solver'''
print('\nRunning New RP-Solver method...')
t = time()
if caching:
cache_dir = CACHE2 if cache_dir is None else cache_dir
else:
cache_dir = None
spectrum = []
for i, (gam, ep) in enumerate(zip(self.gammas, self.eps)):
sys.stdout.write('\r{0:.2f}%'.format(i * 100. / self.nsteps))
sys.stdout.flush()
ep = max(ep, EPS_MIN)
solver = RP_Solver(ep * self.h,
ep * self.J,
gam,
cache_dir=cache_dir)
solver.solve()
e_vals, e_vecs = solver.node.evd()
spectrum.append(list(e_vals))
return spectrum
# split schedule into iso-field steps
rp_steps = max(1, rp_steps)
niso = int(np.ceil(len(self.gammas) * 1. / rp_steps))
isos = []
for i in range(rp_steps):
gams = self.gammas[i * niso:(i + 1) * niso]
eps = self.eps[i * niso:(i + 1) * niso]
isos.append((gams, eps))
# solve spectrum within each iso-step
spectrum = []
i = 0
for gammas, eps in isos:
i += 1
# solve first problem is iso-step
gam, ep = gammas[0], max(eps[0], EPS_MIN)
solver = RP_Solver(ep * self.h,
ep * self.J,
gam,
cache_dir=cache_dir)
solver.solve()
e_vals, e_vecs = solver.node.evd()
spectrum.append(list(e_vals))
nx, nz = solver.get_current_fields()
modes = solver.node.modes
# solve remaining problems is iso-step
for gam, ep in zip(gammas[1:], eps[1:]):
i += 1
sys.stdout.write('\r{0:.2f}%'.format(i * 100. / self.nsteps))
sys.stdout.flush()
ep = max(ep, EPS_MIN)
solver = RP_Solver(ep * self.h,
ep * self.J,
gam,
nx=nx,
nz=nz,
cache_dir=cache_dir)
solver.mode_solve(modes)
spectrum.append(list(solver.node.e_vals))
return spectrum
def run_rp2(self, rp_steps, caching, cache_dir):
'''Compute the spectrum using the new RP-Solver'''
print('\nRunning New RP-Solver method...')
t = time()
if caching:
cache_dir = CACHE2 if cache_dir is None else cache_dir
else:
cache_dir = None
spectrum = []
for i, (gam, ep) in enumerate(zip(self.gammas, self.eps)):
sys.stdout.write('\r{0:.2f}%'.format(i*100./self.nsteps))
sys.stdout.flush()
ep = max(ep, EPS_MIN)
solver = RP_Solver(ep*self.h, ep*self.J, gam,
cache_dir=cache_dir)
solver.solve()
e_vals, e_vecs = solver.node.evd()
spectrum.append(list(e_vals))
return spectrum
# split schedule into iso-field steps
rp_steps = max(1, rp_steps)
niso = int(np.ceil(len(self.gammas)*1./rp_steps))
isos = []
for i in range(rp_steps):
gams = self.gammas[i*niso:(i+1)*niso]
eps = self.eps[i*niso:(i+1)*niso]
isos.append((gams, eps))
# solve spectrum within each iso-step
spectrum = []
i = 0
for gammas, eps in isos:
i += 1
# solve first problem is iso-step
gam, ep = gammas[0], max(eps[0], EPS_MIN)
solver = RP_Solver(ep*self.h, ep*self.J, gam,
cache_dir=cache_dir)
solver.solve()
e_vals, e_vecs = solver.node.evd()
spectrum.append(list(e_vals))
nx, nz = solver.get_current_fields()
modes = solver.node.modes
# solve remaining problems is iso-step
for gam, ep in zip(gammas[1:], eps[1:]):
i += 1
sys.stdout.write('\r{0:.2f}%'.format(i*100./self.nsteps))
sys.stdout.flush()
ep = max(ep, EPS_MIN)
solver = RP_Solver(ep*self.h, ep*self.J, gam,
nx=nx, nz=nz, cache_dir=cache_dir)
solver.mode_solve(modes)
spectrum.append(list(solver.node.e_vals))
return spectrum
def main(N, cache_dir=None):
'''Generate and test a problem with N spins'''
if WIRE:
h, J, gam = generate_wire(N)
else:
h, J, gam = generate_prob(N)
t = time()
if N < 18:
print('Exact solution...')
e_vals, e_vecs = solve(h, J, gamma=gam)
print(e_vals[:2])
print('Runtime: {0:.3f} (s)'.format(time() - t))
t = time()
solver = RP_Solver(h, J, gam, verbose=False, cache_dir=cache_dir)
solver.solve()
print('\n' * 3)
print('New RP solution:')
print(solver.node.Es[:2])
print('Runtime: {0:.3f} (s)'.format(time() - t))
msolver = RP_Solver(h, J, gam)
t = time()
modes = solver.node.modes
msolver.mode_solve(modes)
print('\n' * 3)
print('Mode solved:')
print(msolver.node.Es[:2])
print('Runtime: {0:.3f} (s)'.format(time() - t))
f = lambda x: np.round(x, 2)
print(solver.node.Hx.shape)
print(msolver.node.Hx.shape)
Dx = solver.node.Hx - msolver.node.Hx
print('Dx diffs...')
for i, j in np.transpose(np.nonzero(Dx)):
print('\t{0}:{1} :: {2:.3f}'.format(i, j, Dx[i, j]))
# resolve
for _ in range(TRIALS):
t = time()
nx, nz = solver.ground_fields()
solver = RP_Solver(h,
J,
gam,
nx=nx,
nz=nz,
verbose=False,
cache_dir=cache_dir)
solver.solve()
print('\n' * 3)
print('New RP solution:')
print(solver.node.Es[:2])
print('Runtime: {0:.3f} (s)'.format(time() - t))
