def approx_solve(fname, gammas=[0.], k=-1, adj=None):
''' '''
# process the QCADesigner file
try:
cells, spacing, zones, J, _ = parse_qca_file(fname, one_zone=True)
except:
print('Failed to process QCA file: {0}'.format(fname))
return None
# convert J to specified adjacency
J = convert_adjacency(cells, spacing, J, adj=adj)
# normalize J
J /= np.max(np.abs(J))
# group each type of cell: normal = NORMAL or OUTPUT
drivers, fixeds, normals, outputs = [], [], [], []
for i, c in enumerate(cells):
if c['cf'] == CELL_FUNCTIONS['QCAD_CELL_INPUT']:
drivers.append(i)
elif c['cf'] == CELL_FUNCTIONS['QCAD_CELL_FIXED']:
fixeds.append(i)
else:
if c['cf'] == CELL_FUNCTIONS['QCAD_CELL_OUTPUT']:
outputs.append(i)
normals.append(i)
print(fixeds)
# map from output cell labels to indices in normals list
output_map = {i: n for n, i in enumerate(normals) if i in outputs}
J_d = J[drivers, :][:, normals] # matrix for mapping drivers to h
J_f = J[fixeds, :][:, normals] # matrix for mapping fixed cells to h
J_n = J[normals, :][:, normals] # J internal to set of normal cells
P_f = [(cells[i]['pol'] if 'pol' in cells[i] else 0.)
for i in fixeds] # polarization of fixed cells
h0 = np.dot(P_f, J_f).reshape([
-1,
]) # h contribution from fixed cells
# for each polarization, solve for all gammas
for pol in gen_pols(len(drivers)):
h = h0 + np.dot(pol, J_d)
for gamma in gammas:
t = time()
e_vals, e_vecs, modes = rp_solve(h, J_n, gam=gamma, verbose=True)
print('\n')
print(e_vals[0:2], time() - t)
if False:
t = time()
e_vals, e_vecs = solve(h,
J_n,
gamma=gamma,
minimal=False,
exact=False)
print(e_vals[0:2], time() - t)
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_exact(self):
'''Compute the spectrum using an exact solver'''
print('\nRunning Exact Solver method...')
t = time()
spectrum = []
for i, (gamma, ep) in enumerate(zip(self.gammas, self.eps)):
sys.stdout.write('\r{0:.2f}%'.format(i*100./self.nsteps))
sys.stdout.flush()
e_vals, e_vecs = solve(ep*self.h, ep*self.J, gamma=gamma,
more=False)
spectrum.append(e_vals)
return spectrum
def exact_solve(fname, gammas = [0.], k=-1, adj=None):
'''Exactly solve the first k eigenstates for a QCA circuit for all possible
input configurations and all specified transverse fields. Assumes all cells
have the same transverse field.'''
# process the QCADesigner file
try:
cells, spacing, zones, J, _ = parse_qca_file(fname, one_zone=True)
except:
print('Failed to process QCA file: {0}'.format(fname))
return None
# convert J to specified adjacency
J = convert_adjacency(cells, spacing, J, adj=adj)
# normalize J
J /= np.max(np.abs(J))
# group each type of cell: normal = NORMAL or OUTPUT
drivers, fixeds, normals, outputs = [], [], [], []
for i,c in enumerate(cells):
if c['cf'] == CELL_FUNCTIONS['QCAD_CELL_INPUT']:
drivers.append(i)
elif c['cf'] == CELL_FUNCTIONS['QCAD_CELL_FIXED']:
fixeds.append(i)
else:
if c['cf'] == CELL_FUNCTIONS['QCAD_CELL_OUTPUT']:
outputs.append(i)
normals.append(i)
# map from output cell labels to indices in normals list
output_map = {i: n for n, i in enumerate(normals) if i in outputs}
J_d = J[drivers, :][:, normals] # matrix for mapping drivers to h
J_f = J[fixeds, :][:, normals] # matrix for mapping fixed cells to h
J_n = J[normals, :][:, normals] # J internal to set of normal cells
P_f = [(cells[i]['pol'] if 'pol' in cells[i] else 0.) for i in fixeds] # polarization of fixed cells
h0 = np.dot(P_f, J_f).reshape([-1,]) # h contribution from fixed cells
# for each polarization, solve for all gammas
for pol in gen_pols(len(drivers)):
h = h0 + np.dot(pol, J_d)
for gamma in gammas:
e_vals, e_vecs = solve(h, J_n, gamma=gamma, minimal=True, exact=False)
# e_vecs[:,i] is the i^th eigenstate
pols = state_to_pol(e_vecs)
# pols[:,i] gives the polarizations of all cells for the i^th e-vec
print('GS: {0:.4f}'.format(e_vals[0]))
print('pols: {0}'.format(pols[:,0]))
def approx_solve(fname, gammas=[0.0], k=-1, adj=None):
""" """
# process the QCADesigner file
try:
cells, spacing, zones, J, _ = parse_qca_file(fname, one_zone=True)
except:
print("Failed to process QCA file: {0}".format(fname))
return None
# convert J to specified adjacency
J = convert_adjacency(cells, spacing, J, adj=adj)
# normalize J
J /= np.max(np.abs(J))
# group each type of cell: normal = NORMAL or OUTPUT
drivers, fixeds, normals, outputs = [], [], [], []
for i, c in enumerate(cells):
if c["cf"] == CELL_FUNCTIONS["QCAD_CELL_INPUT"]:
drivers.append(i)
elif c["cf"] == CELL_FUNCTIONS["QCAD_CELL_FIXED"]:
fixeds.append(i)
else:
if c["cf"] == CELL_FUNCTIONS["QCAD_CELL_OUTPUT"]:
outputs.append(i)
normals.append(i)
print(fixeds)
# map from output cell labels to indices in normals list
output_map = {i: n for n, i in enumerate(normals) if i in outputs}
J_d = J[drivers, :][:, normals] # matrix for mapping drivers to h
J_f = J[fixeds, :][:, normals] # matrix for mapping fixed cells to h
J_n = J[normals, :][:, normals] # J internal to set of normal cells
P_f = [(cells[i]["pol"] if "pol" in cells[i] else 0.0) for i in fixeds] # polarization of fixed cells
h0 = np.dot(P_f, J_f).reshape([-1]) # h contribution from fixed cells
# for each polarization, solve for all gammas
for pol in gen_pols(len(drivers)):
h = h0 + np.dot(pol, J_d)
for gamma in gammas:
t = time()
e_vals, e_vecs, modes = rp_solve(h, J_n, gam=gamma, verbose=True)
print("\n")
print(e_vals[0:2], time() - t)
if False:
t = time()
e_vals, e_vecs = solve(h, J_n, gamma=gamma, minimal=False, exact=False)
print(e_vals[0:2], time() - t)
def new_gamma_sweep(N, gmax=10.):
''' '''
rp_times = []
sp_times = []
N_steps = 50
gammas = np.linspace(1e-5,1, N_steps)
eps = np.linspace(1,1e-5, N_steps)
h, J = gen_wire_coefs(N)
for i, (gam,ep) in enumerate(zip(gammas,eps)):
sys.stdout.write('\r{0:.1f}%: {1}'.format(i*100/N_steps, i))
sys.stdout.flush()
t = time()
for _ in range(TRIALS):
sys.stdout.write('.')
sys.stdout.flush()
solver = RP_Solver(ep*h, ep*J, gam)
solver.solve()
rp_times.append((time()-t)/TRIALS)
print(rp_times[-1])
if N <= SP_MAX:
t = time()
for _ in range(TRIALS):
sys.stdout.write(',')
sys.stdout.flush()
e_vals, e_vecs = solve(ep*h, ep*J, gamma=gam)
sp_times.append((time()-t)/TRIALS)
plt.figure('Gamma-Sweep')
plt.plot(gammas, rp_times, 'g', linewidth=LW)
if sp_times:
plt.plot(gammas, sp_times, 'b', linewidth=LW)
plt.xlabel('s', fontsize=GS)
plt.ylabel('Run-time (s)', fontsize=FS)
plt.text(0.28, .6, 'H = s$H_T$ + (1-s) $H_P$', fontsize=20)
if SAVE:
plt.savefig(os.path.join(IMG_DIR, 'rp_wire_gamma_{0}.eps'.format(N)),
bbox_inches='tight')
plt.show()
def run_exact(self):
'''Compute the spectrum using an exact solver'''
print('\nRunning Exact Solver method...')
t = time()
spectrum = []
for i, (gamma, ep) in enumerate(zip(self.gammas, self.eps)):
sys.stdout.write('\r{0:.2f}%'.format(i * 100. / self.nsteps))
sys.stdout.flush()
e_vals, e_vecs = solve(ep * self.h,
ep * self.J,
gamma=gamma,
more=False)
spectrum.append(e_vals)
return spectrum
def wire_size_sweep(N_max):
'''compute ground and first excited band for up to N_max length
wires'''
rp_times = {'naive': [], 'local': [], 'global': []}
sp_times = []
Ns = np.arange(2, N_max + 1, int(np.ceil((N_max - 1) * 1. / 40)))
for N in Ns:
sys.stdout.write('\r{0:.1f}%: {1}'.format((N - 1) * 100 / (N_max - 1),
N))
sys.stdout.flush()
h, J = gen_wire_coefs(N)
for k in rp_times:
if k == 'naive':
chdir = None
elif k == 'global':
chdir = CACHE
elif k == 'local':
chdir = os.path.join(CACHE, str(N))
t = time()
if False:
e_vals, e_vecs, modes = rp_solve(h,
J,
gam=0.01,
cache_dir=chdir)
else:
solver = RP_Solver(h, J, gam=0, cache_dir=chdir)
solver.solve()
rp_times[k].append(time() - t)
if N <= 0:
t = time()
e_vals, e_vecs = solve(h, J, gamma=0.1)
sp_times.append(time() - t)
plt.figure('Run-times')
plt.plot(Ns, rp_times['naive'], 'b', linewidth=2)
plt.plot(Ns, rp_times['local'], 'g', linewidth=2)
plt.plot(Ns, rp_times['global'], 'r', linewidth=2)
if sp_times:
plt.plot(Ns[:len(sp_times)], sp_times, 'g', linewidth=2)
plt.xlabel('Wire length')
plt.ylabel('Run-time (s)')
plt.legend(['Naive', 'Local', 'Global'], fontsize=FS)
plt.show()
if SAVE:
plt.savefig(os.path.join(IMG_DIR, 'rp_wire_{0}.eps'.format(N_max)),
bbox_inches='tight')
def new_gamma_sweep(N, gmax=10.):
''' '''
rp_times = []
sp_times = []
N_steps = 50
gammas = np.linspace(1e-5, 1, N_steps)
eps = np.linspace(1, 1e-5, N_steps)
h, J = gen_wire_coefs(N)
for i, (gam, ep) in enumerate(zip(gammas, eps)):
sys.stdout.write('\r{0:.1f}%: {1}'.format(i * 100 / N_steps, i))
sys.stdout.flush()
t = time()
for _ in range(TRIALS):
sys.stdout.write('.')
sys.stdout.flush()
solver = RP_Solver(ep * h, ep * J, gam)
solver.solve()
rp_times.append((time() - t) / TRIALS)
print(rp_times[-1])
if N <= SP_MAX:
t = time()
for _ in range(TRIALS):
sys.stdout.write(',')
sys.stdout.flush()
e_vals, e_vecs = solve(ep * h, ep * J, gamma=gam)
sp_times.append((time() - t) / TRIALS)
plt.figure('Gamma-Sweep')
plt.plot(gammas, rp_times, 'g', linewidth=LW)
if sp_times:
plt.plot(gammas, sp_times, 'b', linewidth=LW)
plt.xlabel('s', fontsize=GS)
plt.ylabel('Run-time (s)', fontsize=FS)
plt.text(0.28, .6, 'H = s$H_T$ + (1-s) $H_P$', fontsize=20)
if SAVE:
plt.savefig(os.path.join(IMG_DIR, 'rp_wire_gamma_{0}.eps'.format(N)),
bbox_inches='tight')
plt.show()
def wire_size_sweep(N_max):
'''compute ground and first excited band for up to N_max length
wires'''
rp_times = {'naive': [], 'local': [], 'global': []}
sp_times = []
Ns = np.arange(2, N_max+1, int(np.ceil((N_max-1)*1./40)))
for N in Ns:
sys.stdout.write('\r{0:.1f}%: {1}'.format((N-1)*100/(N_max-1), N))
sys.stdout.flush()
h, J = gen_wire_coefs(N)
for k in rp_times:
if k=='naive':
chdir = None
elif k == 'global':
chdir = CACHE
elif k == 'local':
chdir = os.path.join(CACHE, str(N))
t = time()
if False:
e_vals, e_vecs, modes = rp_solve(h, J, gam=0.01, cache_dir=chdir)
else:
solver = RP_Solver(h, J, gam=0, cache_dir=chdir)
solver.solve()
rp_times[k].append(time()-t)
if N <= 0:
t = time()
e_vals, e_vecs = solve(h, J, gamma=0.1)
sp_times.append(time()-t)
plt.figure('Run-times')
plt.plot(Ns, rp_times['naive'], 'b', linewidth=2)
plt.plot(Ns, rp_times['local'], 'g', linewidth=2)
plt.plot(Ns, rp_times['global'], 'r', linewidth=2)
if sp_times:
plt.plot(Ns[:len(sp_times)], sp_times, 'g', linewidth=2)
plt.xlabel('Wire length')
plt.ylabel('Run-time (s)')
plt.legend(['Naive', 'Local', 'Global'], fontsize=FS)
plt.show()
if SAVE:
plt.savefig(os.path.join(IMG_DIR, 'rp_wire_{0}.eps'.format(N_max)),
bbox_inches='tight')
def new_wire_size_sweep(N_max):
''' '''
rp_times = []
rp_times2 = []
sp_times = []
sp_times2 = []
Ns = np.arange(2, N_max+1)
for N in Ns:
sys.stdout.write('\r{0:.1f}%: {1}'.format((N-1)*100/(N_max-1), N))
sys.stdout.flush()
h, J = gen_wire_coefs(N)
# rp solver
t = time()
for _ in range(TRIALS):
sys.stdout.write(',')
sys.stdout.flush()
solver = RP_Solver(h, J, 0)
solver.solve()
rp_times.append((time()-t)/TRIALS)
# rp solver with gamma=eps
t = time()
for _ in range(TRIALS):
sys.stdout.write('.')
sys.stdout.flush()
solver = RP_Solver(h, J, 1)
solver.solve()
rp_times2.append((time()-t)/TRIALS)
# exact solver
if N <= SP_MAX:
t = time()
for _ in range(TRIALS):
sys.stdout.write(',')
sys.stdout.flush()
e_vals, e_vecs = solve(h, J, gamma=0)
sp_times.append((time()-t)/TRIALS)
t = time()
for _ in range(TRIALS):
sys.stdout.write('.')
sys.stdout.flush()
e_vals, e_vecs = solve(h, J, gamma=1)
sp_times2.append((time()-t)/TRIALS)
# plotting
plt.figure('Run-times')
plt.plot(Ns, rp_times, 'g', linewidth=LW)
plt.plot(Ns[:len(sp_times)], sp_times, 'b', linewidth=LW)
plt.plot(Ns, rp_times2, 'g--', linewidth=LW)
plt.plot(Ns[:len(sp_times2)], sp_times2, 'b--', linewidth=LW)
plt.xlabel('Wire length', fontsize=FS)
plt.ylabel('Run-time (s)', fontsize=FS)
plt.legend(['RP-Solver', 'Exact: ARPACK'], fontsize=FS)
if SAVE:
plt.savefig(os.path.join(IMG_DIR, 'rp_wire_{0}.eps'.format(N_max)),
bbox_inches='tight')
plt.show()
def compare_spectrum(fname, gmin=0.01, gmax=.5, adj='lim'):
''' '''
try:
cells, spacing, zones, J, _ = parse_qca_file(fname, one_zone=True)
except:
print('Failed ot process QCA file: {0}'.format(fname))
return None
# convert J to specified adjacency
J = convert_adjacency(cells, spacing, J, adj=adj)
# normalize J
J /= np.max(np.abs(J))
# group each type of cell: normal = NORMAL or OUTPUT
drivers, fixeds, normals, outputs = [], [], [], []
for i,c in enumerate(cells):
if c['cf'] == CELL_FUNCTIONS['QCAD_CELL_INPUT']:
drivers.append(i)
elif c['cf'] == CELL_FUNCTIONS['QCAD_CELL_FIXED']:
fixeds.append(i)
else:
if c['cf'] == CELL_FUNCTIONS['QCAD_CELL_OUTPUT']:
outputs.append(i)
normals.append(i)
# map from output cell labels to indices in normals list
output_map = {i: n for n, i in enumerate(normals) if i in outputs}
J_d = J[drivers, :][:, normals] # matrix for mapping drivers to h
J_f = J[fixeds, :][:, normals] # matrix for mapping fixed cells to h
J_n = J[normals, :][:, normals] # J internal to set of normal cells
P_f = [(cells[i]['pol'] if 'pol' in cells[i] else 0.) for i in fixeds] # polarization of fixed cells
h0 = np.dot(P_f, J_f).reshape([-1,]) # h contribution from fixed cells
gammas = np.linspace(gmin, gmax, STEPS)
for pol in gen_pols(len(drivers)):
h = h0 + np.dot(pol, J_d)
SP_E, RP_E = [], []
times = []
for gamma in gammas:
print(gamma)
t = time()
rp_vals, rp_vecs, modes = rp_solve(h, J_n, gam=gamma,
cache_dir=CACHE)
times.append(time()-t)
sp_vals, sp_vecs = solve(h, J_n, gamma=gamma)
SP_E.append(sp_vals)
RP_E.append(rp_vals)
LSP = min(len(x) for x in SP_E)
L = min(LSP, min(len(x) for x in RP_E))
SP_E = np.array([x[:L] for x in SP_E])
RP_E = np.array([x[:L] for x in RP_E])
plt.figure('spectrum')
plt.plot(gammas, SP_E, linewidth=2)
plt.plot(gammas, RP_E, 'x', markersize=8, markeredgewidth=2)
plt.xlabel('Gamma', fontsize=FS)
plt.ylabel('Energy', fontsize=FS)
plt.title('Circuit Spectrum', fontsize=FS)
plt.show(block=False)
plt.figure('runtimes')
plt.plot(gammas, times, 'b', linewidth=2)
plt.xlabel('Gammas', fontsize=FS)
plt.ylabel('Runtime (s)', fontsize=FS)
plt.title('RP-Solver runtime', fontsize=FS)
plt.show()
def new_wire_size_sweep(N_max):
''' '''
rp_times = []
rp_times2 = []
sp_times = []
sp_times2 = []
Ns = np.arange(2, N_max + 1)
for N in Ns:
sys.stdout.write('\r{0:.1f}%: {1}'.format((N - 1) * 100 / (N_max - 1),
N))
sys.stdout.flush()
h, J = gen_wire_coefs(N)
# rp solver
t = time()
for _ in range(TRIALS):
sys.stdout.write(',')
sys.stdout.flush()
solver = RP_Solver(h, J, 0)
solver.solve()
rp_times.append((time() - t) / TRIALS)
# rp solver with gamma=eps
t = time()
for _ in range(TRIALS):
sys.stdout.write('.')
sys.stdout.flush()
solver = RP_Solver(h, J, 1)
solver.solve()
rp_times2.append((time() - t) / TRIALS)
# exact solver
if N <= SP_MAX:
t = time()
for _ in range(TRIALS):
sys.stdout.write(',')
sys.stdout.flush()
e_vals, e_vecs = solve(h, J, gamma=0)
sp_times.append((time() - t) / TRIALS)
t = time()
for _ in range(TRIALS):
sys.stdout.write('.')
sys.stdout.flush()
e_vals, e_vecs = solve(h, J, gamma=1)
sp_times2.append((time() - t) / TRIALS)
# plotting
plt.figure('Run-times')
plt.plot(Ns, rp_times, 'g', linewidth=LW)
plt.plot(Ns[:len(sp_times)], sp_times, 'b', linewidth=LW)
plt.plot(Ns, rp_times2, 'g--', linewidth=LW)
plt.plot(Ns[:len(sp_times2)], sp_times2, 'b--', linewidth=LW)
plt.xlabel('Wire length', fontsize=FS)
plt.ylabel('Run-time (s)', fontsize=FS)
plt.legend(['RP-Solver', 'Exact: ARPACK'], fontsize=FS)
if SAVE:
plt.savefig(os.path.join(IMG_DIR, 'rp_wire_{0}.eps'.format(N_max)),
bbox_inches='tight')
plt.show()
def compare_spectrum(fname, gmin=0.01, gmax=0.5, adj="lim"):
""" """
try:
cells, spacing, zones, J, _ = parse_qca_file(fname, one_zone=True)
except:
print("Failed ot process QCA file: {0}".format(fname))
return None
# convert J to specified adjacency
J = convert_adjacency(cells, spacing, J, adj=adj)
# normalize J
J /= np.max(np.abs(J))
# group each type of cell: normal = NORMAL or OUTPUT
drivers, fixeds, normals, outputs = [], [], [], []
for i, c in enumerate(cells):
if c["cf"] == CELL_FUNCTIONS["QCAD_CELL_INPUT"]:
drivers.append(i)
elif c["cf"] == CELL_FUNCTIONS["QCAD_CELL_FIXED"]:
fixeds.append(i)
else:
if c["cf"] == CELL_FUNCTIONS["QCAD_CELL_OUTPUT"]:
outputs.append(i)
normals.append(i)
# map from output cell labels to indices in normals list
output_map = {i: n for n, i in enumerate(normals) if i in outputs}
J_d = J[drivers, :][:, normals] # matrix for mapping drivers to h
J_f = J[fixeds, :][:, normals] # matrix for mapping fixed cells to h
J_n = J[normals, :][:, normals] # J internal to set of normal cells
P_f = [(cells[i]["pol"] if "pol" in cells[i] else 0.0) for i in fixeds] # polarization of fixed cells
h0 = np.dot(P_f, J_f).reshape([-1]) # h contribution from fixed cells
gammas = np.linspace(gmin, gmax, STEPS)
for pol in gen_pols(len(drivers)):
h = h0 + np.dot(pol, J_d)
SP_E, RP_E = [], []
times = []
for gamma in gammas:
print(gamma)
t = time()
rp_vals, rp_vecs, modes = rp_solve(h, J_n, gam=gamma, cache_dir=CACHE)
times.append(time() - t)
sp_vals, sp_vecs = solve(h, J_n, gamma=gamma)
SP_E.append(sp_vals)
RP_E.append(rp_vals)
LSP = min(len(x) for x in SP_E)
L = min(LSP, min(len(x) for x in RP_E))
SP_E = np.array([x[:L] for x in SP_E])
RP_E = np.array([x[:L] for x in RP_E])
plt.figure("spectrum")
plt.plot(gammas, SP_E, linewidth=2)
plt.plot(gammas, RP_E, "x", markersize=8, markeredgewidth=2)
plt.xlabel("Gamma", fontsize=FS)
plt.ylabel("Energy", fontsize=FS)
plt.title("Circuit Spectrum", fontsize=FS)
plt.show(block=False)
plt.figure("runtimes")
plt.plot(gammas, times, "b", linewidth=2)
plt.xlabel("Gammas", fontsize=FS)
plt.ylabel("Runtime (s)", fontsize=FS)
plt.title("RP-Solver runtime", fontsize=FS)
plt.show()
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))
