def get(b, d, n):
"""Get the results for the given parameters"""
print("Running with: B = " + str(b) + " D = " + str(d) + " N = " + str(n))
nn = int(n * (n + 1) / 2)
cd(b, d, n)
E, eigenvectors, index, c_max, H = \
eigensystem.get(return_eigv=True, return_index=True,
return_cmax=True, return_H=True)
# All available colors
colors = ('black', 'red', 'teal', 'blue', 'orange', 'olive', 'magenta',
'cyan', 'Brown', 'Goldenrod', 'Green', 'Violet')
ir_reps, colormap = eigensystem.levels(E, index[c_max], colors=colors)
# Build eigenvalue string
# If the colormap element corresponding to the i-th eigenvalue is empty,
# skip adding \color
eigenvalues = ', '.join(
optional_color(format_float(E[i]), colormap[i]) for i in range(E.size))
return nn, H, E, eigenvalues, eigenvectors, index, c_max, ir_reps, \
colors, colormap
def main(b, d, n, delta_n, st_epsilon, lvl_epsilon, cut=0):
print("Running with: B = " + str(b) + " D = " + str(d) + " N = " + str(n))
cd(b, d, n)
start = timer()
E, ket = eigensystem.get(return_ket=True)
# Select irreducible representations
# ir_reps = eigensystem.levels(E, ket)
# Select only the stable levels
# stable_levels = diff.stable(E, ir_reps, b, d, n, delta_n)
stable_levels = diff.stable(E, b, d, n, delta_n, st_epsilon)
# Reduce the number of stable levels to check the convergence
stable_levels = int((1 - cut) * stable_levels)
E = E[:stable_levels]
# Select irreducible representations
ir_reps = eigensystem.levels(E, ket, lvl_epsilon)
stop = timer()
print('Get data:', stop - start, 'seconds')
rebde = open('rebde.dat', 'w')
reuna = open('reuna.dat', 'w')
reuns = open('reuns.dat', 'w')
# Write only one level corresponding to the bidimensional representation
skip_next = False
for i in range(E.size):
n1 = ket[i][0]
n2 = ket[i][1]
if ir_reps[i] == 2: # bidimensional representation (rebde)
if not skip_next:
rebde.write('{0:.18f}'.format(E[i]) + '\t' + str(n1) + '\t' +
str(n2) + '\n')
skip_next = True
else:
skip_next = False
else:
if n2 % 2: # unidimensional anti-symmetric representation
reuna.write('{0:.18f}'.format(E[i]) + '\t' + str(n1) + '\t' +
str(n2) + '\n')
else: # unidimensional symmetric representation
reuns.write('{0:.18f}'.format(E[i]) + '\t' + str(n1) + '\t' +
str(n2) + '\n')
rebde.close()
reuna.close()
reuns.close()
os.chdir("../../Scripts")
print("Done\n")
def main(b, d, n):
"""Create bar plots for eigenvectors"""
cd(b, d, n)
# Get states
E, eigenvectors, ket, index = \
eigensystem.get(return_eigv=True, return_ket=True,
return_index=True)
# Get the index array that sorts the eigenvector coefficients
# such that n1 + n2 is increasing
sort_idx = np.argsort(index.sum(axis=1))
# Sort the eigenvector coefficients
eigenvectors = eigenvectors[:, sort_idx]
# stable_levels = np.load('cache.npy') # get cached stable levels
no_eigv = 40 # number of eigenvectors to plot
# Select the states corresponding to stable levels
E = E[:no_eigv]
eigenvectors = eigenvectors[:no_eigv]
ket = ket[:no_eigv]
# Get irreducible representation index
ir_reps = eigensystem.levels(E, ket)
# Build irreducible representation string
reps = 'reuns', 'reuna', 'rebde'
ir_str = [reps[i] for i in ir_reps]
# Compute energy plot parameters
k = index[sort_idx].sum(axis=1) # n1 + n2
w = 1 / (k + 1) - 0.01 # bar widths
r = [j for i in range(n + 1) for j in range(i)]
x = k - 0.5 + r / (k + 1) # positions
d_no = 0 # number of duplicate states
clean_dir('eigenvectors')
for i in range(eigenvectors.shape[0]):
eigv_len = no_signif_el(eigenvectors[i])
minor_ticks = np.arange(0, eigv_len, 0.5)
# Plot label
label = 'E = ' + str(E[i]) + '\n' + '$\\left|' + \
str(ket[i][0]) + '\\,' + str(ket[i][1]) + '\\right\\rangle$\t' + \
ir_str[i]
fname = str(ket[i][0]) + ' ' + str(ket[i][1]) # filename
index_plot(eigenvectors[i], eigv_len, label, index, sort_idx, fname,
d_no)
energy_plot(eigenvectors[i], eigv_len, x, w, label, index, sort_idx,
fname, d_no)
def main(b, d, n):
cd(b, d, n)
# Get states
E, eigenvectors, ket = eigensystem.get(return_eigv=True, return_ket=True)
# Select stable levels
st_idx = int(np.loadtxt('stable.txt')[0])
E, eigenvectors, ket = E[:st_idx], eigenvectors[:st_idx], ket[:st_idx]
if b:
# Get irreducible representations
ir_reps = eigensystem.levels(E, ket)
rebde = np.loadtxt('rebde.dat', usecols=(0, ))
reuna = np.loadtxt('reuna.dat', usecols=(0, ))
reuns = np.loadtxt('reuns.dat', usecols=(0, ))
# Compute participation ratio for each representation
P_b = compute_p(eigenvectors, condition=np.where(ir_reps == 2))
P_a = compute_p(eigenvectors, condition=np.where(ir_reps == 1))
P_s = compute_p(eigenvectors, condition=np.where(ir_reps == 0))
# Plot the participation ratio for each representation
plt.scatter(rebde, P_b[::2], s=1, label='$\Gamma_b$')
plt.scatter(reuna, P_a, s=1, label='$\Gamma_a$', color='r')
plt.scatter(reuns, P_s, s=1, label='$\Gamma_s$', color='y')
plt.xlabel('$E$')
plt.ylabel('Participation ratio')
plt.legend()
plt.savefig('participation_ratio_rep.pdf')
plt.close()
# Plot the difference between the states of the bidimensional
# representation
plt.plot(rebde,
P_b[::2] - P_b[1::2],
lw=0.7,
label='$\Gamma_{b1} - \Gamma_{b2}$')
plt.xlabel('$E$')
plt.ylabel('$\\Delta$Participation ratio')
plt.legend()
plt.savefig('participation_ratio_rebde.pdf')
plt.close()
else:
# P = 1 / (eigenvectors[0].size * np.sum(eigenvectors**4, axis=1))
P = compute_p(eigenvectors)
plt.scatter(E, P, s=1)
plt.xlabel('$E$')
plt.ylabel('Participation ratio')
plt.savefig('participation_ratio.pdf')
plt.close()
def difference(E1, b, d, n, delta_n, ir_reps1=np.empty(0)):
"""Return the differences between the energy levels and of the
structure of the irreducible representations (optional) for the given
diagonalization basis and n + delta_n"""
# Load the energy levels in the second basis
os.chdir("../B" + str(b) + " D" + str(d) + " N" + str(n + delta_n))
E2, ket2 = eigensystem.get(return_ket=True)
if ir_reps1.size:
ir_reps2 = eigensystem.levels(E2, ket2)
if E2.size > E1.size:
E_diff = (E2[:E1.size] - E1) / E1
if ir_reps1.size:
ir_diff = ir_reps2[:ir_reps1.size] - ir_reps1
else:
E_diff = (E1[:E2.size] - E2) / E2
if ir_reps1.size:
ir_diff = ir_reps1[:ir_reps2.size] - ir_reps2
os.chdir("../B" + str(b) + " D" + str(d) + " N" + str(n))
if ir_reps1.size == 0:
return np.abs(E_diff)
return np.abs(E_diff), ir_diff
def main(b, d, n, delta_n, st_epsilon, lvl_epsilon, stable_only=True):
start = timer()
tools.cd(b, d, n)
# Get data
E, ket = eigensystem.get(return_ket=True)
ir_reps = eigensystem.levels(E, ket, lvl_epsilon)
if stable_only: # choose all levels or only the stable ones
stable_levels = int(np.loadtxt('stable.txt')[0])
E = E[:stable_levels]
rebde = np.loadtxt('rebde.dat', usecols=(0, ), unpack=True)
reuna = np.loadtxt('reuna.dat', usecols=(0, ), unpack=True)
reuns = np.loadtxt('reuns.dat', usecols=(0, ), unpack=True)
# Bi-directional search
E_in_rebde = np.in1d(E, rebde, assume_unique=False)
E_in_reuna = np.in1d(E, reuna, assume_unique=False)
E_in_reuns = np.in1d(E, reuns, assume_unique=False)
rebde_in_E = np.in1d(rebde, E, assume_unique=False)
reuna_in_E = np.in1d(reuna, E, assume_unique=False)
reuns_in_E = np.in1d(reuns, E, assume_unique=False)
if E.size < max(rebde.size, reuna.size, reuns.size):
rebde = rebde[:E.size]
reuna = reuna[:E.size]
reuns = reuns[:E.size]
rebde_in_E = rebde_in_E[:E.size]
reuna_in_E = reuna_in_E[:E.size]
reuns_in_E = reuns_in_E[:E.size]
# Padding
rebde = np.pad(rebde, pad_width=(0, E.size - rebde.size), mode='constant')
reuna = np.pad(reuna, pad_width=(0, E.size - reuna.size), mode='constant')
reuns = np.pad(reuns, pad_width=(0, E.size - reuns.size), mode='constant')
rebde_in_E = np.pad(rebde_in_E,
pad_width=(False, E.size - rebde_in_E.size),
mode='constant')
reuna_in_E = np.pad(reuna_in_E,
pad_width=(False, E.size - reuna_in_E.size),
mode='constant')
reuns_in_E = np.pad(reuns_in_E,
pad_width=(False, E.size - reuns_in_E.size),
mode='constant')
files = np.array([
E, rebde, reuna, reuns, E_in_rebde, E_in_reuna, E_in_reuns, rebde_in_E,
reuna_in_E, reuns_in_E
])
with open("table.tex", "w") as f:
f.write("\\documentclass{article}\n\n")
f.write("\\usepackage[margin=0.2in]{geometry}\n")
f.write("\\usepackage{longtable}\n")
f.write("\\usepackage[table]{xcolor}\n\n")
f.write("\\begin{document}\n\n")
f.write("\\begin{longtable}{" + " | ".join(["c"] * 4) + "}\n")
f.write("energy levels & rebde.dat & reuna.dat & reuns.dat\t\\\\\n")
f.write("\\hline\n\\endfirsthead\n")
for row in range(files.shape[1]):
# Find the representation of the energy level
c = 0
for x in range(1, 4):
if files[x + 3][row]:
c = x
line = color(c, True) + '{:.18f}'.format(files[0][row]) + " & " + \
" & ".join(color(x, files[x + 6][row]) +
'{:.18f}'.format(files[x][row])
for x in range(1, 4))
f.write('\t' + line + " \\\\\n")
f.write("\\end{longtable}")
f.write("\n\n\\end{document}")
os.chdir("../../Scripts")
end = timer()
print('total: ', end - start)
def main(b, d, n):
cd(b, d, n)
# Get states
E, eigenvectors, ket = eigensystem.get(return_eigv=True, return_ket=True)
# Select stable levels
st_idx = int(np.loadtxt('stable.txt')[0])
E, eigenvectors, ket = E[:st_idx], eigenvectors[:st_idx], ket[:st_idx]
# Get reference states
cd(0.0, d, n)
E_ref, eigenvectors_ref, ket_ref = eigensystem.get(return_eigv=True,
return_ket=True)
# Select stable reference levels
st_idx = int(np.loadtxt('stable.txt')[0])
E_ref, eigenvectors_ref, ket_ref = E_ref[:st_idx], \
eigenvectors_ref[:st_idx], ket_ref[:st_idx]
# Reference participation ratio
P_ref = compute_p(eigenvectors_ref)
# Find the index of the states with energy closest to the reference ones
# idx = np.searchsorted(E, E_ref)
# idx = np.clip(idx, 1, len(E) - 1)
# left = E[idx - 1]
# right = E[idx]
# idx -= E_ref - left < right - E_ref
# Compute the participation ratio
P = compute_p(eigenvectors)
cd(b, d, n)
ylim = ()
ylim = plot(E,
P,
E_ref,
P_ref,
label='$B=' + str(b) + '$',
fname='participation_ratio_cmp.pdf')
# Get irreducible representations
ir_reps = eigensystem.levels(E, ket)
rebde = np.loadtxt('rebde.dat', usecols=(0, ))
reuna = np.loadtxt('reuna.dat', usecols=(0, ))
reuns = np.loadtxt('reuns.dat', usecols=(0, ))
# Compute participation ratio for each representation
P_b = compute_p(eigenvectors, condition=np.where(ir_reps == 2))
P_a = compute_p(eigenvectors, condition=np.where(ir_reps == 1))
P_s = compute_p(eigenvectors, condition=np.where(ir_reps == 0))
# Plot the participation ratio for each representation
plot(rebde,
P_b[::2],
E_ref,
P_ref,
label='$\Gamma_b$',
ylim=ylim,
fname='participation_ratio_cmp_rebde.pdf')
plot(reuna,
P_a,
E_ref,
P_ref,
label='$\Gamma_a$',
ylim=ylim,
fname='participation_ratio_cmp_reuna.pdf')
plot(reuns,
P_s,
E_ref,
P_ref,
label='$\Gamma_s$',
ylim=ylim,
fname='participation_ratio_cmp_reuns.pdf')