def save_bott_txt(self):
"""Save the bott to disk as a txt file
Returns
-------
None
"""
# Make output directories
print 'saving chern to: ', self.cp['cpmeshfn']
dio.ensure_dir(self.cp['cpmeshfn'])
# Save the chern calculation to cp['cpmeshfn']
if self.bott is None:
raise RuntimeError(
'Cannot save bott calculation since it has not been computed!')
# Save bott parameters
fn = self.cp['cpmeshfn'] + 'bott_params.txt'
header = 'Parameters for bott calculation'
dio.save_dict(self.cp, fn, header)
# Save chern_finsize
fn = self.cp['cpmeshfn'] + 'bott.txt'
print 'saving chern_finsize to ', fn
with open(fn, "w") as txtfile:
txtfile.write('{0:0.18e}'.format(self.bott))
# Save lattice parameters too for convenience (gives info about disorder, spinning speeds etc)
print 'saving lattice_params...'
header = 'Lattice parameters, copied from meshfn: ' + self.haldane_lattice.lp[
'meshfn']
dio.save_dict(self.haldane_lattice.lp,
self.cp['cpmeshfn'] + 'lattice_params.txt', header)
def save_normal_modes_Nashgyro(gyro_lattice,
datadir='auto',
dispersion=[],
sim_type='gyro',
rm_images=True,
gapims_only=False,
save_into_subdir=False,
overwrite=True,
color='pr',
do_bc=False):
"""
Plot the normal modes of a coupled gyros with fixed pivot points and make a movie of them.
Note that b and c are built INTO the signs of OmK and Omg.
--> b (0 -> 'hang', 1 -> 'stand').
--> c (0 -> aligned with a, 1 -> aligned with a)
Parameters
----------
datadir: string
directory where simulation data is stored
R : NP x dim array
position array in 2d (3d might work with 3rd dim ignored)
NL : NP x NN array
Neighbor list
KL : NP x NN array
spring connectivity array
OmK : float or NP x NN array
OmK (spring frequency array, for Nash limit: (-1)^(c+b)kl^2/Iw'
Omg : float or NP x 1 array
gravitational frequency array, for Nash limit: (-1)^(c+1)mgl/Iw
params : dict
parameters dictionary
dispersion : array or list
dispersion relation of...
rm_images : bool
Whether or not to delete all the images after a movie has been made of the DOS
gapims_only : bool
Whether to just plot modes near the middle of the DOS frequency range
save_into_subdir: bool
Whether to save the movie in the same sudir where the DOS/ directory (containing the frames) is placed.
"""
glat = gyro_lattice
NP = len(glat.lattice.xy)
print 'Getting eigenvals/vects of dynamical matrix...'
# Find eigval/vect
eigval, eigvect = glat.get_eigval_eigvect()
OmK = glat.OmK
Omg = glat.Omg
# prepare DOS output dir
if datadir == 'auto':
datadir = glat.lp['meshfn']
if 'meshfn_exten' in glat.lp:
exten = glat.lp['meshfn_exten']
elif glat.lp['dcdisorder']:
# there should be meshfn_exten defined in lp, but since there is not, we make it here
if glat.lp['V0_pin_gauss'] > 0:
exten = '_pinV' + sf.float2pstr(glat.lp['V0_pin_gauss']) + \
'_strV' + sf.float2pstr(glat.lp['V0_spring_gauss'])
elif glat.lp['V0_pin_flat'] > 0:
exten = '_pinVf' + sf.float2pstr(glat.lp['V0_pin_flat']) + \
'_strVf' + sf.float2pstr(glat.lp['V0_spring_flat'])
else:
exten = ''
DOSdir = datadir + 'DOS' + exten + '/'
dio.ensure_dir(DOSdir)
#####################################
# Prepare for plotting
#####################################
print 'Preparing plot settings...'
omg, omk, do_bc_determined, bcstr, btmp, ctmp, pin = determine_bc_pin(
Omg, OmK)
do_bc = do_bc and do_bc_determined
# Options for how to color the DOS header
if color == 'pr':
ipr = glat.get_ipr()
colorV = 1. / ipr
lw = 0
cbar_label = r'$p$'
colormap = 'viridis_r'
elif color == 'ipr':
ipr = glat.get_ipr()
colorV = ipr
lw = 0
cbar_label = r'$p^{-1}$'
colormap = 'viridis'
elif color == 'ill':
ill = glat.get_ill()
colorV = ill
cbar_label = r'$\lambda^{-1}$'
lw = 0
colormap = 'viridis'
else:
colorV = None
lw = 1.
cbar_label = ''
colormap = 'viridis'
print 'plotting...'
fig, DOS_ax, eig_ax = leplt.initialize_eigvect_DOS_header_plot(
eigval,
glat.lattice.xy,
sim_type=sim_type,
colorV=colorV,
colormap=colormap,
linewidth=lw,
cax_label=cbar_label,
cbar_nticks=2,
cbar_tickfmt='%0.3f')
dostitle = r'$\Omega_g = $' + '{0:0.2f}'.format(glat.lp['Omg'])
if glat.lp['ABDelta']:
dostitle += r'$\pm$' + '{0:0.2f}'.format(glat.lp['ABDelta'])
dostitle += r' $\Omega_k=$' + '{0:0.2f}'.format(glat.lp['Omk'])
DOS_ax.set_title(dostitle)
glat.lattice.plot_BW_lat(fig=fig,
ax=eig_ax,
save=False,
close=False,
axis_off=False,
title='')
# Make strings for spring, pin, k, and g values
if do_bc:
springstr_Hz = '{0:.03f}'.format(omk[0] / (2. * np.pi))
pinstr_Hz = '{0:.03f}'.format(omg[0] / (2. * np.pi))
else:
springstr_Hz = ''
pinstr_Hz = ''
if springstr_Hz != '' and pinstr_Hz != '':
text2show = 'spring = ' + springstr_Hz + ' Hz, pin = ' + pinstr_Hz + ' Hz\n' + '\n' + bcstr
fig.text(0.4,
0.1,
text2show,
horizontalalignment='center',
verticalalignment='center')
# Add schematic of hanging/standing top spinning with dir
if do_bc:
schem_ax = plt.axes([0.85, 0.0, .025 * 5, .025 * 7], axisbg='w')
# drawing
schem_ax.plot([0., 0.2], [1 - btmp, btmp], 'k-')
schem_ax.scatter([0.2], [btmp], s=150, c='k')
schem_ax.arrow(0.2,
btmp,
-(-1)**ctmp * 0.06,
0.3 * (-1)**(btmp + ctmp),
head_width=0.3,
head_length=0.1,
fc='b',
ec='b')
wave_x = np.arange(-0.07 * 5, 0.0, 0.001)
wave_y = 0.1 * np.sin(wave_x * 100) + 1. - btmp
schem_ax.plot(wave_x, wave_y, 'k-')
schem_ax.set_xlim(-0.1 * 5, .21 * 5)
schem_ax.set_ylim(-0.1 * 7, .21 * 7)
schem_ax.axis('off')
#####################################
# SAVE eigenvals/vects as images
#####################################
# First check that we actually need to make the images: if rm_images == True and the movie exists, then stop if
# overwrite==False
# Construct movname
names = DOSdir.split('/')[0:-1]
# Construct movie name from datadir path string
movname = ''
for ii in range(len(names)):
if ii < len(names) - 1:
movname += names[ii] + '/'
else:
if save_into_subdir:
movname += names[ii] + '/' + names[ii] + '_DOS'
else:
movname += names[ii]
# movname += '_DOS' + gyro_lattice.lp['meshfn_exten']
if not (not overwrite and rm_images and glob.glob(movname + '.mov')):
done_pngs = len(glob.glob(DOSdir + 'DOS_*.png'))
# check if normal modes have already been done
if not done_pngs:
# decide on which eigs to plot
totN = len(eigval)
if gapims_only:
middle = int(round(totN * 0.25))
ngap = int(round(np.sqrt(totN)))
todo = range(middle - ngap, middle + ngap)
else:
todo = range(int(round(len(eigval) * 0.5)))
if done_pngs < len(todo):
dmyi = 0
for ii in todo:
if np.mod(ii, 50) == 0:
print 'plotting eigvect ', ii, ' of ', len(eigval)
# glat.lattice.plot_BW_lat(fig=fig, ax=DOS_ax, save=False, close=False, axis_off=False, title='')
fig, [scat_fg, scat_fg2, p, f_mark, lines_12_st], cw_ccw = \
leplt.construct_eigvect_DOS_plot(glat.lattice.xy, fig, DOS_ax, eig_ax, eigval, eigvect,
ii, sim_type, glat.lattice.NL, glat.lattice.KL,
marker_num=0, color_scheme='default', sub_lattice=-1)
plt.savefig(DOSdir + 'DOS_' + '{0:05}'.format(dmyi) +
'.png')
scat_fg.remove()
scat_fg2.remove()
p.remove()
f_mark.remove()
lines_12_st.remove()
dmyi += 1
fig.clf()
plt.close('all')
######################
# Save DOS as movie
######################
imgname = DOSdir + 'DOS_'
subprocess.call([
'./ffmpeg', '-i', imgname + '%05d.png', movname + '.mov', '-vcodec',
'libx264', '-profile:v', 'main', '-crf', '12', '-threads', '0', '-r',
'100', '-pix_fmt', 'yuv420p'
])
if rm_images:
# Delete the original images
if not save_into_subdir:
print 'Deleting folder ' + DOSdir
subprocess.call(['rm', '-r', DOSdir])
else:
print 'Deleting folder contents ' + DOSdir + 'DOS_*.png'
subprocess.call(['rm', '-r', DOSdir + 'DOS_*.png'])
def le_plot_gyros(xy, xy0, NL, KL, BM, params, t, ii, name, fig, ax, outdir, climv='auto', exaggerate=1.0,
dpi=300, fontsize=12, title='', **kwargs):
"""Plots a single gyroscopic lattice time step using timestep plot.
Parameters
----------
t : float
time stamp for image
ii : int
index to name file ( ie 'name_000ii.png')
name : string
the name of the file (before _index.png)
fig : matplotlib.pyplot figure handle, or 'none'
the figure on which to plot the gyros. If 'none', uses plt.gcf() and clears figure.
ax : matplotlib.pyplot axis handle, or 'none'
the axis on which to plot the gyros. If 'none', uses plt.gca()
outdir : string
The output directory for the image
climv : float or tuple
Color limit for coloring bonds by bond strain, overriddes params['climv'] if climv!='auto'
If 'climv' is not a key in params, and climv=='auto', then uses default min/max.
If 'climv' is a key in params, and climv=='auto', then uses params['climv'].
exaggerate : float (default 1.0 --> in which case it is ignored)
Exaggerate the displacements of each particle from its initial position by this factor. Ignored if == 1.0
dpi : float
pixels per inch, resolution of saved plot
**kwargs: Additional timestep_plot() keyword arguments
color_particles='k', fontsize=14, linewidth=2
Returns
----------
"""
# If fig and ax are not supplied, declare them
if fig is None or fig == 'none':
fig = plt.gcf()
plt.clf()
if ax is None or ax == 'none':
ax = plt.gca()
# make output dir
outdir = dio.prepdir(outdir)
dio.ensure_dir(outdir)
# set range of window from first values
if 'xlimv' in params:
xlimv = params['xlimv']
if 'ylimv' in params:
ylimv = params['ylimv']
else:
ylimv = (xlimv - max(xy0[:, 0])) + np.ceil(max(xy0[:, 1]))
else:
xlimv = np.ceil(max(xy0[:, 0]) * 5./ 4.)
ylimv = (xlimv - max(xy0[:, 0])) + max(xy0[:, 1])
# save current data as stills
index = '{0:08d}'.format(ii)
outname = outdir + '/' + name + '_' + index + '.png'
BL = le.NL2BL(NL, KL)
# print 'BL = ', BL
suptitle = copy.deepcopy(title)
if 'prestrain' in params:
prestrain = params['prestrain']
else:
prestrain = 0.
if 'shrinkrate' in params:
shrinkrate = params['shrinkrate']
title = 't = ' + '%07.0f' % t + ' a = ' + '%07.5f' % (1. - shrinkrate * t - prestrain)
elif 'prestrain' in params:
shrinkrate = 0.0
title = 't = ' + '%07.0f' % t + ' a = ' + '%07.5f' % (1. - prestrain)
else:
shrinkrate = 0.0
title = 't = ' + '%07.0f' % t + r' $\Omega_g^{-1}$'
if exaggerate != 1.0:
title += ' amplified ' + str(int(exaggerate)) + 'x '
if 'Omk' in params and params['Omk'] != -1.:
title += '\n' + r'$\Omega_g$=' + '{0:.3f}'.format(params['Omg'])
if 'Omg' in params and params['Omk'] != -1.:
title += r' $\Omega_k$=' + '{0:.3f}'.format(params['Omk'][0, 0])
if 'split_spin' in params:
title += ' NV=' + str(int(params['NV']))
if 'split_k' in params:
title += r' $k_s$=' + str(params['split_k'])
# title +='\n'
# if params['BCtype'] == 'excite':
# title += r' $\omega_d$ = ' + '{0:.3f}'.format(params['frequency'])
if 'eta' in params:
if params['eta'] != 0.000:
title += r' $\eta$=' + '{0:.3f}'.format(params['eta'])
# calculate strain
# bs = bond_strain_list(xy,BL,bL0)
# if exaggerate==1.0:
# movie_plot_2D_gyros(xy, BL, bs, outname, title, xlimv, ylimv, climv)
# else:
# xye = xy0+(xy-xy0)*exaggerate
# movie_plot_2D_gyros(xye, BL, bs, outname, title, xlimv, ylimv, climv)
if climv == 'auto':
if 'climv' in params:
climv = params['climv']
[scat_fg, lines_st, p] = leplt.timestep_plot(xy, xy0, NL, KL, BM, ax=ax, factor=exaggerate, amp=climv, title=title,
fontsize=fontsize, suptitle=suptitle, **kwargs)
# print 'color_particles = ', scat_fg
ax.set_xlim(-xlimv, xlimv)
ax.set_ylim(-ylimv, ylimv)
plt.savefig(outname, dpi=dpi)
# clear_array = [scat_fg, lines_st, p]
# for i in range(len(clear_array)):
# clear_array[i].remove()
return [scat_fg, lines_st, p]
def mode_scaling_tune_junction(lp, args, nmode=None):
"""First plot scaling for all modes as junction coupling is increased. Then, plot the nth mode as the
scaling parameter evolves (typically the bond strength between particles that are nearer than some threshold).
Example usage:
python gyro_lattice_class.py -mode_scaling_tune_junction -LT hexjunction2triads -N 1 -OmKspec union0p000in0p100 -alph 0.1 -periodic
python gyro_lattice_class.py -mode_scaling_tune_junction -LT spindle -N 2 -OmKspec union0p000in0p100 -alph 0.0 -periodic -aratio 0.1
python gyro_lattice_class.py -mode_scaling_tune_junction -LT spindle -N 4 -OmKspec union0p000in0p100 -alph 0.0 -periodic -aratio 0.1
python ./build/make_lattice.py -LT spindle -N 1 -periodic -check -skip_polygons -skip_gyroDOS -aratio 0.1
python ./build/make_lattice.py -LT spindle -N 2 -periodic -check -skip_polygons -skip_gyroDOS -aratio 0.1
python ./build/make_lattice.py -LT spindle -N 4 -periodic -skip_polygons -skip_gyroDOS -aratio 0.1
python ./build/make_lattice.py -LT spindle -N 6 -periodic -skip_polygons -skip_gyroDOS -aratio 0.1 -check
python ./build/make_lattice.py -LT spindle -N 8 -periodic -skip_polygons -skip_gyroDOS -aratio 0.1 -check
Parameters
----------
lp
args
nmode : int, int list, or None
Returns
-------
"""
nkvals = 50
if lp['LatticeTop'] in ['hexjunctiontriad', 'spindle', 'hexjunction2triads']:
kvals = -np.unique(np.round(np.logspace(-1, 1., nkvals), 2)) # [::-1]
dist_thres = lp['OmKspec'].split('union')[-1].split('in')[-1]
lpmaster = copy.deepcopy(lp)
lat = lattice_class.Lattice(lp)
lat.load()
if nmode is None:
todo = np.arange(len(lat.xy[:, 0]))
elif type(nmode) == int:
todo = [nmode]
else:
todo = nmode
##########################################################################
outfn = dio.prepdir(lat.lp['meshfn']) + 'glat_eigval_scaling_tune_junction'
eigvals, first = [], True
for (kval, dmyi) in zip(kvals, np.arange(len(kvals))):
lp = copy.deepcopy(lpmaster)
lp['OmKspec'] = 'union' + sf.float2pstr(kval, ndigits=3) + 'in' + dist_thres
# lat = lattice_class.Lattice(lp)
glat = GyroLattice(lat, lp)
eigval, eigvect = glat.eig_vals_vects(attribute=True)
if first:
eigvals = np.zeros((len(kvals), len(eigval)), dtype=float)
eigvals[dmyi, :] = np.imag(eigval)
first = False
# Plot flow of modes
print 'eigvals = ', eigvals
fig, axes = leplt.initialize_2panel_centy(Wfig=90, Hfig=65, x0frac=0.17, wsfrac=0.38)
ax, ax1 = axes[0], axes[1]
ymax = np.max(eigvals, axis=1)
for kk in range(int(0.5 * len(eigvals[0])), len(eigvals[0])):
ydat = eigvals[:, kk]
ax.loglog(np.abs(kvals), ydat, 'b-')
ax.set_ylim(ymin=0.1)
ax.set_ylabel('frequency, $\omega$')
ax.set_xlabel("coupling, $\Omega_k'$")
if lp['LatticeTop'] == 'hexjunction2triads':
ax.text(0.5, 0.9, 'Spectrum formation \n in double honeycomb junction',
ha='center', va='center', transform=fig.transFigure)
elif lp['LatticeTop'] == 'spindle':
if lp['NH'] == lp['NV']:
nstr = str(int(lp['NH']))
else:
nstr = str(int(lp['NH'])) + ', ' + str(int(lp['NV']))
ax.text(0.5, 0.9, 'Spectrum formation \n ' + r'in spindle lattice ($N=$' + nstr + ')',
ha='center', va='center', transform=fig.transFigure)
lat.plot_BW_lat(fig=fig, ax=ax1, save=False, close=False, title='')
plt.savefig(outfn + '_kmin' + sf.float2pstr(np.min(kvals)) + '_kmax' + sf.float2pstr(np.max(kvals)) + '.pdf')
plt.show()
##########################################################################
for ii in todo:
modefn = dio.prepdir(lat.lp['meshfn']) + 'glat_mode_scaling_tune_junction_mode{0:05d}'.format(ii) +\
'_nkvals{0:04}'.format(nkvals) + '.mov'
globmodefn = glob.glob(modefn)
if not globmodefn:
modedir = dio.prepdir(lat.lp['meshfn']) + 'glat_mode_scaling_tune_junction_mode{0:05d}/'.format(ii)
dio.ensure_dir(modedir)
previous_ev = None
first = True
dmyi = 0
for kval in kvals:
lp = copy.deepcopy(lpmaster)
lp['OmKspec'] = 'union' + sf.float2pstr(kval, ndigits=3) + 'in' + dist_thres
# lat = lattice_class.Lattice(lp)
glat = GyroLattice(lat, lp)
eigval, eigvect = glat.eig_vals_vects(attribute=True)
# plot the nth mode
# fig, DOS_ax, eax = leplt.initialize_eigvect_DOS_header_plot(eigval, glat.lattice.xy,
# sim_type='gyro', cbar_nticks=2,
# cbar_tickfmt='%0.3f')
fig, dos_ax, eax, ax1, cbar_ax = \
leplt.initialize_eigvect_DOS_header_twinplot(eigval, glat.lattice.xy, sim_type='gyro',
ax0_pos=[0.0, 0.10, 0.6, 0.60],
ax1_pos=[0.6, 0.15, 0.3, 0.60],
header_pos=[0.1, 0.78, 0.4, 0.20],
xlabel_pad=8, fontsize=8)
# Get the theta that minimizes the difference between the present and previous eigenvalue
if previous_ev is not None:
realxy = np.real(previous_ev)
thetas, eigvects = gdh.phase_fix_nth_gyro(glat.eigvect, ngyro=0, basis='XY')
modenum = gdh.phase_difference_minimum(eigvects, realxy, basis='XY')
# print 'thetas = ', thetas
# if theta < 1e-9:
# print 'problem with theta'
# sys.exit()
else:
thetas, eigvects = gdh.phase_fix_nth_gyro(glat.eigvect, ngyro=0, basis='XY')
modenum = ii
glat.lattice.plot_BW_lat(fig=fig, ax=eax, save=False, close=False, axis_off=False, title='')
fig, [scat_fg, scat_fg2, pp, f_mark, lines_12_st], cw_ccw = \
leplt.construct_eigvect_DOS_plot(glat.lattice.xy, fig, dos_ax, eax, eigval, eigvects,
modenum, 'gyro', glat.lattice.NL, glat.lattice.KL,
marker_num=0, color_scheme='default', sub_lattice=-1,
amplify=1., title='')
# fig, ax_tmp, [scat_fg, pp, f_mark, lines12_st] = \
# glat.plot_eigvect_excitation(ii, eigval=eigval, eigvect=eigvect, ax=eax, plot_lat=first,
# theta=theta, normalization=1.0) # color=lecmaps.blue())
# Store this current eigvector as 'previous_ev'
previous_ev = eigvects[modenum]
# scat_fg.remove()
# scat_fg2.remove()
# pp.remove()
# if f_mark is not None:
# f_mark.remove()
# lines_12_st.remove()
# eax.cla()
# Plot where in evolution we are tracking
ngyros = int(np.shape(eigvals)[1] * 0.5)
halfev = eigvals[:, ngyros:]
for row in halfev.T:
ax1.loglog(np.abs(kvals), row, 'b-')
trackmark = ax1.plot(np.abs(kval), np.abs(np.imag(eigval))[modenum], 'ro')
ax1.set_xlabel(r"vertex coupling, $\Omega_k'$")
ax1.set_ylabel(r"frequency, $\omega$")
dos_ax.set_xlim(xmin=0)
plt.savefig(modedir + 'DOS_' + '{0:05}'.format(dmyi) + '.png', dpi=200)
dmyi += 1
first = False
# Make movie
imgname = modedir + 'DOS_'
movname = modedir[:-1] + '_nkvals{0:04}'.format(nkvals)
lemov.make_movie(imgname, movname, indexsz='05', framerate=5, rm_images=True, save_into_subdir=True,
imgdir=modedir)
def data2stills_2Dgyros(datadir,
simoutdir,
params,
framedir_name='stills',
init_skip=10,
climv=0.1,
numbering='adopt',
rough=False,
roughmov=True,
exaggerate=1.0,
rm_stills=True,
resolution=150,
figsize='auto',
color_particles='k',
DOSexcite=None,
lp=None,
framerate=10,
mov_exten='',
title='',
dos_meshfn_dir=None,
movname=None,
lw=2,
**kwargs):
"""Converts a list of data into a stack of png images of gyroscopic lattice using timestep_plot for each timestep.
Parameters
----------
simoutdir : string
The output directory for the simulation (contains subdirs for xyv, KL)
params : dict
Parameters dictionary
framedir_name : string
Subdirectory of simoutdir in which to save movie images
vsaved : bool
whether the velocites are recorded (vsaved = False for Nash gyros, True for gHST, for example)
init_skip : int
One out of every init_skip frames will be written first, then the intermittent frames will be written, to see
briefly what happens
climv : float or tuple
Color limit for coloring bonds by bond strain
numbering : 'natural' or 'adopt' (default = 'adopt')
Use indexing '0','1','2','3',... or adopt the index of the input file.
rough : boolean
Plot every init_skip files ONLY? (if False, writes every init_skip files first, then does the rest)
exaggerate : float (default 1.0 --> in which case it is ignored)
Exaggerate the displacements of each particle from its initial position by this factor. Ignored if == 1.0
rm_stills : bool
Whether or not to delete the stills after making them.
DOSexcite : tuple of floats or None
(excitation frequency, stdev time), or else None if DOS plot is not desired
lp : dict
Lattice parameters. If not None, then if eigval is not found in main dir, attempts to load eigval from gyro
network, but will not compute it
framerate : int or float (optional, default=10)
framerate for movie
mov_exten : str (optional)
additional description to append to movie name, if movname is None
movname : str or None
Name or full path with name of movie to output of the simulation
**kwargs : keyword arguments for leplt.timestep_plot()
such as bgcolor, cmap (the strain colormap), color_particles, mimic_expt
Returns
----------
"""
plt.close('all')
print 'Running data2stills_2Dgyros with DOSexcite = ', DOSexcite
# get dirs
# vsaved denotes whether the velocites are recorded
# vsaved = False for Nash gyros, True for gHST, for example
print 'simoutdir = ', simoutdir
try:
xypath = sorted(glob.glob(simoutdir + 'xyv/'))[0]
vsaved = True
except IndexError:
xypath = sorted(glob.glob(simoutdir + 'xy/'))[0]
vsaved = False
# list files
xyfiles = sorted(glob.glob(xypath + '*.txt'))
# load setup
NLfile = sorted(glob.glob(datadir + 'NL.txt'))[0]
NL = np.loadtxt(NLfile, dtype='int', delimiter=',')
xy0file = sorted(glob.glob(datadir + 'xy.txt'))[0]
xy0 = np.loadtxt(xy0file, delimiter=',', usecols=(0, 1))
if 'deform' in params:
if params['deform']:
deform_xy0 = True
xy0path = sorted(glob.glob(simoutdir + 'xy0/'))[0]
xy0files = sorted(glob.glob(xy0path + '*.txt'))
else:
deform_xy0 = False
xy0files = []
try:
KLpath = sorted(glob.glob(simoutdir + 'KL/'))[0]
KLfiles = sorted(glob.glob(KLpath + '*.txt'))
if KLfiles:
print 'found KLfiles --> update KL each timestep'
update_KL_each_timestep = True
KL = np.loadtxt(KLfiles[0], delimiter=',')
else:
print 'KLfiles =', KLfiles, '\n --> do not update KL'
update_KL_each_timestep = False
KL = np.loadtxt(datadir + 'KL.txt', dtype='int', delimiter=',')
BM0 = le.NL2BM(xy0, NL, KL)
except IndexError:
print 'no KLfiles --> do not update KL'
update_KL_each_timestep = False
KL = np.loadtxt(datadir + 'KL.txt', dtype='int', delimiter=',')
BM0 = le.NL2BM(xy0, NL, KL)
if 'h' in params:
hh = params['h']
elif 'hh' in params:
hh = params['hh']
else:
hfile = sorted(glob.glob(datadir + 'h.txt'))[0]
hh = np.loadtxt(hfile)
# get base name from xyfile
name = 'still'
if vsaved:
# name = (xyfiles[0].split('/')[-1]).split('xyv')[0]
try:
x, y, vx, vy = np.loadtxt(xyfiles[0], delimiter=',', unpack=True)
except:
x, y, z, vx, vy, vz = np.loadtxt(xyfiles[0],
delimiter=',',
unpack=True)
else:
# name = (xyfiles[0].split('/')[-1]).split('xy')[0]
try:
'''Data is 2D'''
x, y = np.loadtxt(xyfiles[0], delimiter=',', unpack=True)
except:
try:
'''Data is 3D'''
x, y, z = np.loadtxt(xyfiles[0], delimiter=',', unpack=True)
except:
'''Data is X,Y,dX,dY'''
X, Y, dX, dY = np.loadtxt(xyfiles[0],
delimiter=',',
unpack=True)
# get length of index string from xyfile
index_sz = str(len((xyfiles[0].split('_')[-1]).split('.')[0]))
# make output dir
outdir = simoutdir + framedir_name + '/'
dio.ensure_dir(outdir)
# set range of window from first values
xlimv = np.ceil(max(x) * 5. / 4.)
ylimv = np.ceil(max(y) * 5. / 4.)
# Initial bond list and
# count initial bonds (double counted)
# nzcount = np.count_nonzero(KL)
BL0 = le.NL2BL(NL, KL)
bo = le.bond_length_list(xy0, BL0)
# make list of indices to plot-- first sparse then dense
do1 = [0] + range(0, len(xyfiles), init_skip)
# Set up figure
if figsize == 'auto':
fig = plt.gcf()
plt.clf()
else:
plt.close('all')
fig = plt.figure(figsize=figsize)
print 'DOSexcite = ', DOSexcite
if DOSexcite is not None:
# Load DOS eigvals:
eigvalpklglob = glob.glob(datadir + 'eigval.pkl')
if eigvalpklglob:
with open(datadir + 'eigval.pkl', "rb") as input_file:
eigval = cPickle.load(input_file)
eval_loaded = True
else:
print 'Did not find eigval in simulation dir (datadir), attempting to load based on supplied meshfn...'
# If you want to load eigvals from a lattice other than the one being simulated, put a "pointer file"
# txt file with the path to that meshfn in your simulation directory: for ex, put 'meshfn_eigvals.txt'
# in the simdir, with contents '/Users/username/...path.../hexagonal_square_delta0p667_...000010_x_000010/'
if dos_meshfn_dir is None or dos_meshfn_dir == 'none':
dos_meshfn_dir = datadir
meshfn_specfn = glob.glob(
dio.prepdir(dos_meshfn_dir) + 'meshfn_eig*.txt')
print 'dos_meshfn_dir = ', dos_meshfn_dir
print 'meshfn_specfn = ', meshfn_specfn
if meshfn_specfn:
with open(meshfn_specfn[0], 'r') as myfile:
meshfn = myfile.read().replace('\n', '')
if lp is not None:
# Build correct eigval to load based on lp (gyro lattice parameters) by grabbing lp[meshfn_exten]
import lepm.lattice_class
import lepm.gyro_lattice_class
# lp = {'LatticeTop': params['LatticeTop'], 'meshfn': params['meshfn']}
lat = lepm.lattice_class.Lattice(lp=lp)
lat.load()
mlat = lepm.magnetic_gyro_lattice_class.MagneticGyroLattice(
lat, lp)
eigvalfn = dio.prepdir(
meshfn) + 'eigval' + mlat.lp['meshfn_exten'] + '.pkl'
else:
print 'since no lp supplied, assuming eigval is default in datadir...'
eigvalfn = dio.prepdir(meshfn) + 'eigval_magnetic.pkl'
with open(eigvalfn, "rb") as fn:
eigval = cPickle.load(fn)
eval_loaded = True
else:
print 'plotting.time_domain_magnetic: Did not find eigval or eigval pointer file in datadir, ' + \
'attempting to load based on lp...'
if lp is not None:
print 'Loading based on lp...'
# No eigval saved in lattice GyroLattice's meshfn, seeking alternative
import lepm.lattice_class
import lepm.gyro_lattice_class
# lp = {'LatticeTop': params['LatticeTop'], 'meshfn': params['meshfn']}
lat = lepm.lattice_class.Lattice(lp=lp)
lat.load()
print 'lp = ', lp
print 'lp[Omk] = ', lp['Omk']
mlat = lepm.magnetic_gyro_lattice_class.MagneticGyroLattice(
lat, lp)
eigval = mlat.load_eigval()
if eigval is None:
eigval = mlat.get_eigval()
print 'Calculated eigval based on supplied GyroLattice instance, using lp dictionary.'
else:
print 'Loaded eigval from disk, from a location determined by the lp dictionary.'
eval_loaded = True
else:
eval_loaded = False
raise RuntimeError(
'Did not supply lp and eigval is not in datadir!')
if eval_loaded:
# Attempt to load ipr for network
iprglob = glob.glob(datadir + 'ipr.pkl')
if iprglob:
with open(datadir + 'ipr.pkl', "rb") as input_file:
ipr = cPickle.load(input_file)
colorV = 1. / ipr
linewidth = 0
cax_label = r'$p$'
colormap = 'viridis_r'
vmin_hdr = None
vmax_hdr = None
cbar_ticklabels = None
cbar_nticks = 4
else:
locglob = glob.glob(datadir + 'localization*.txt')
if locglob:
localization = np.loadtxt(locglob[0], delimiter=',')
ill = localization[:, 2]
ill_full = np.zeros(len(eigval), dtype=float)
ill_full[0:int(len(eigval) * 0.5)] = ill[::-1]
ill_full[int(len(eigval) * 0.5):len(eigval)] = ill
colorV = ill_full
linewidth = 0
cax_label = r'$\lambda^{-1}$'
colormap = 'viridis'
vmin_hdr = 0.0
vmax_hdr = 1. / (np.max(np.abs(xy0.ravel())))
cbar_ticklabels = ['0', r'$1/L$', r'$2/L$']
cbar_nticks = 3
else:
print 'plotting.time_domain_magnetic: Did not find ipr in simulation dir (datadir), ' +\
'attempting to load based on supplied meshfn...'
# First seek directly supplied files in the simulation datadir
meshfn_specfn = glob.glob(datadir + 'meshfn_*ipr.txt')
if meshfn_specfn:
with open(meshfn_specfn[0], 'r') as myfile:
meshfn = myfile.read().replace('\n', '')
with open(
dio.prepdir(meshfn) + 'ipr' +
lp['meshfn_exten'] + '.pkl', "rb") as fn:
ipr = cPickle.load(fn)
colorV = 1. / ipr
cax_label = r'$p$'
colormap = 'viridis_r'
linewidth = 0
vmin_hdr = None
vmax_hdr = None
cbar_ticklabels = None
cbar_nticks = 4
else:
print '\n\n\nComputing localization from supplied meshfn\n\n\n'
if dos_meshfn_dir is None or dos_meshfn_dir == 'none':
dos_meshfn_dir = datadir
meshfn_specfn = glob.glob(
dio.prepdir(dos_meshfn_dir) +
'meshfn_*localization.txt')
print 'meshfn_specfn = ', meshfn_specfn
if meshfn_specfn:
with open(meshfn_specfn[0], 'r') as myfile:
meshfn = myfile.read().replace('\n', '')
if lp is not None:
print 'Loading based on lp...'
import lepm.lattice_class
import lepm.gyro_lattice_class
# lp = {'LatticeTop': params['LatticeTop'], 'meshfn': params['meshfn']}
lat = lepm.lattice_class.Lattice(lp=lp)
lat.load()
mlat = lepm.magnetic_gyro_lattice_class.MagneticGyroLattice(
lat, lp)
loczfn = dio.prepdir(
meshfn) + 'localization' + mlat.lp[
'meshfn_exten'] + '.txt'
specmeshfn_xy = lat.xy
else:
print 'plotting.time_domain_magnetic: no lp supplied, assuming default lattice ' +\
'params to load localization in attempt to load localization...'
loczfn = dio.prepdir(
meshfn) + 'localization_magnetic.txt'
try:
specmeshfn_xy = np.loadtxt(meshfn +
'_xy.txt')
except:
specmeshfn_xy = np.loadtxt(meshfn +
'_xy.txt',
delimiter=',')
localization = np.loadtxt(loczfn, delimiter=',')
ill = localization[:, 2]
ill_full = np.zeros(len(eigval), dtype=float)
ill_full[0:int(len(eigval) * 0.5)] = ill[::-1]
ill_full[int(len(eigval) * 0.5):len(eigval)] = ill
colorV = ill_full
linewidth = 0
cax_label = r'$\lambda^{-1}$'
colormap = 'viridis'
vmin_hdr = 0.0
vmax_hdr = 1. / (np.max(
np.abs(specmeshfn_xy.ravel())))
cbar_ticklabels = ['0', r'$1/L$', r'$2/L$']
cbar_nticks = 3
else:
print 'plotting.time_domain_magnetic: Did not find ipr or localization in datadirs,' +\
' attempting to load based on lp...'
if lp is not None:
print 'Loading based on lp...'
import lepm.lattice_class
import lepm.gyro_lattice_class
# lp = {'LatticeTop': params['LatticeTop'], 'meshfn': params['meshfn']}
lat = lepm.lattice_class.Lattice(lp=lp)
lat.load()
mlat = lepm.magnetic_gyro_lattice_class.MagneticGyroLattice(
lat, lp)
if mlat.lp['periodicBC']:
localization = mlat.get_localization()
ill = localization[:, 2]
ill_full = np.zeros(len(eigval),
dtype=float)
ill_full[0:int(len(eigval) *
0.5)] = ill[::-1]
ill_full[int(len(eigval) *
0.5):len(eigval)] = ill
colorV = ill_full
cax_label = r'$\lambda^{-1}$'
vmin_hdr = 0.0
vmax_hdr = 1. / (np.max(np.abs(
xy0.ravel())))
else:
ipr = mlat.get_ipr()
colorV = 1. / ipr
cax_label = r'$p$'
colormap = 'viridis_r'
vmin_hdr = None
vmax_hdr = None
cbar_ticklabels = None
cbar_nticks = 4
linewidth = 0
else:
print 'Did not supply lp and neither ipr nor localization are in datadir!'
colorV = None
linewidth = 1
cax_label = ''
colormap = 'viridis'
vmin_hdr = None
vmax_hdr = None
cbar_ticklabels = None
cbar_nticks = 4
plt.close('all')
if np.max(xy0[:, 0]) - np.min(
xy0[:, 0]) > 2.0 * (np.max(xy0[:, 1]) - np.min(xy0[:, 1])):
# Plot will be very wide, so initialize a wide plot (landscape 16:9)
orientation = 'landscape'
# Note: header axis is [0.30, 0.80, 0.45, 0.18]
if title == '' or title is None:
ax_pos = [0.1, 0.05, 0.8, 0.54]
cbar_pos = [0.79, 0.80, 0.012, 0.15]
else:
ax_pos = [0.1, 0.03, 0.8, 0.50]
cbar_pos = [0.79, 0.70, 0.012, 0.15]
else:
# Plot will be roughly square or tall, so initialize a portfolio-style plot
orientation = 'portrait'
if title == '' or title is None:
ax_pos = [0.1, 0.10, 0.8, 0.60]
cbar_pos = [0.79, 0.80, 0.012, 0.15]
else:
ax_pos = [0.1, 0.03, 0.8, 0.60]
cbar_pos = [0.79, 0.75, 0.012, 0.15]
# Determine line width
if len(xy0) > 2000:
lw = 1
else:
lw = 2
if cax_label == r'$\lambda^{-1}$':
if 'penrose' in lp['LatticeTop']:
dos_ylabel = 'Density of states, ' + r'$D(\omega)$' + '\nfor periodic approximant'
else:
dos_ylabel = 'Density of states, ' + r'$D(\omega)$' + '\nfor periodic system'
ylabel_pad = 30
ylabel_rot = 90
else:
dos_ylabel = r'$D(\omega)$'
ylabel_pad = 20
ylabel_rot = 0
print 'plt.get_fignums() = ', plt.get_fignums()
fig, DOS_ax, ax = \
leplt.initialize_eigvect_DOS_header_plot(eigval, xy0, sim_type='gyro',
page_orientation=orientation,
ax_pos=ax_pos, cbar_pos=cbar_pos,
colorV=colorV, vmin=vmin_hdr, vmax=vmax_hdr,
DOSexcite=DOSexcite, linewidth=linewidth,
cax_label=cax_label, colormap=colormap,
cbar_nticks=cbar_nticks,
cbar_tickfmt='%0.2f', cbar_ticklabels=cbar_ticklabels,
cbar_labelpad=17,
yaxis_ticks=[], ylabel=dos_ylabel,
ylabel_rot=ylabel_rot, ylabel_pad=ylabel_pad,
nbins=120, xlabel_pad=15)
# DOSexcite = (frequency, sigma_time)
# amp(x) = exp[- acoeff * time**2]
# amp(k) = sqrt(pi/acoeff) * exp[- pi**2 * k**2 / acoeff]
# So 1/(2 * sigma_freq**2) = pi**2 /acoeff
# So sqrt(acoeff/(2 * pi**2)) = sigma_freq
# sigmak = 1./DOSexcite[1]
# xlims = DOS_ax.get_xlim()
# ktmp = np.linspace(xlims[0], xlims[1], 300)
# gaussk = 0.8 * DOS_ax.get_ylim()[1] * np.exp(-(ktmp - DOSexcite[0])**2 / (2. * sigmak))
# DOS_ax.plot(ktmp, gaussk, 'r-')
# plt.sca(ax)
else:
print 'Could not find eigval.pkl to load for DOS portion of data2stills plots!'
ax = plt.gca()
else:
ax = plt.gca()
# Check for evolving rest lengths in params
if 'prestrain' in params:
prestrain = params['prestrain']
else:
prestrain = 0.
if 'shrinkrate' in params:
shrinkrate = params['shrinkrate']
else:
shrinkrate = 0.0
if roughmov:
print 'creating rough gyro movie...'
tdgyros.stills2mov_gyro(fig,
ax,
do1,
xyfiles,
KLfiles,
xy0files,
xy0,
NL,
KL,
BM0,
params,
hh,
numbering,
index_sz,
outdir,
name,
simoutdir,
update_KL_each_timestep,
deform_xy0,
exaggerate,
xlimv,
ylimv,
climv,
resolution,
color_particles,
shrinkrate,
prestrain,
framerate=float(framerate) / 5.,
mov_exten='_rough',
linewidth=lw,
startind=0,
title=title,
show_bonds=False,
**kwargs)
# Now do detailed movie if rough is False
if not rough:
print 'creating fine gyro movie (not skipping any frames)...'
doall = [0] + range(0, len(xyfiles))
# do2 = list(set(doall)-set(do1))
# ftodo = do1 + do2
print 'tdmagnetic: exiting here since it is broken here'
# sys.exit()
tdgyros.stills2mov_gyro(fig,
ax,
doall,
xyfiles,
KLfiles,
xy0files,
xy0,
NL,
KL,
BM0,
params,
hh,
numbering,
index_sz,
outdir,
name,
simoutdir,
update_KL_each_timestep,
deform_xy0,
exaggerate,
xlimv,
ylimv,
climv,
resolution,
color_particles,
shrinkrate,
prestrain,
framerate=framerate,
mov_exten=mov_exten,
linewidth=lw,
startind=0,
title=title,
movname=movname,
show_bonds=False,
**kwargs)
if rm_stills:
# Delete the original images
print 'Deleting folder ' + simoutdir + 'stills/'
subprocess.call(['rm', '-r', simoutdir + 'stills/'])
elif hostname[0:10] == 'nsit-dhcp-' or hostname[0:10] == 'npmitchell':
rootdir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/'
cprootdir = '/Volumes/research4TB/Soft_Matter/GPU/'
elif hostname == 'Messiaen.local' or hostname[0:8] == 'wireless':
rootdir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/'
cprootdir = '/Volumes/research2TB/Soft_Matter/GPU/'
if not os.path.isdir(cprootdir):
cprootdir = '/Users/npmitchell/Desktop/data_local/GPU/'
elif hostname[0:5] == 'cvpn-':
rootdir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/'
cprootdir = '/Volumes/research2TB/Soft_Matter/GPU/'
else:
rootdir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/'
outdir = rootdir + 'experiments/DOS_scaling/' + args.LatticeTop + '/'
dio.ensure_dir(outdir)
print 'cprootdir = ', cprootdir
dcdisorder = args.V0_pin_gauss > 0 or args.V0_spring_gauss > 0
lp = {'LatticeTop': args.LatticeTop,
'shape': shape,
'NH': NH,
'NV': NV,
'NP_load': args.NP_load,
'rootdir': rootdir,
'phi_lattice': args.phi_lattice,
'delta_lattice': args.delta_lattice,
'theta': args.theta,
'eta': args.eta,
'x1': args.x1,
def plot_cherns_vary_param(self, param_type='glat', sz_param_nu=None,
reverse=False, param='percolation_density',
title='Chern index calculation', xlabel=None):
"""Plot chern indices with x axis being the parameter which is varying between networks.
If there are multiple chern calculations of a particular lattice, average nu over them all.
Parameters
----------
param_type : str ('glat' or 'lat')
Whether we are varying a lattice parameter (different lattices) or a gyrolattice parameter (same lattice,
different physics)
sz_param_nu : None or 'glat' or ('lat' or 'lp' -- last two do same thing)
string specifier for how to vary params
reverse : bool
Compute cherns for GyroLattice instances in self.mgyro_collection in reverse order
param : string
string specifier for GyroLattice parameter to vary between networks; key for mglat.lp dict
title : str
title of the plot
xlabel : str
xlabel, if desired to be other than default for param (ie, param.replace('_', ' '))
"""
if sz_param_nu is None:
if param_type == 'lat' or param_type == 'lp':
param_nu = self.collect_cherns_vary_lpparam(param=param, reverse=reverse)
elif param_type == 'glat':
param_nu = self.collect_cherns_vary_glatparam(param=param, reverse=reverse)
else:
raise RuntimeError("param_type argument passed is not 'glat' or 'lat/lp'")
# Plot it as colormap
plt.close('all')
paramV = param_nu[:, 0]
nu = param_nu[:, 1]
# Make figure
import lepm.plotting.plotting as leplt
fig, ax = leplt.initialize_1panel_centered_fig(wsfrac=0.5, tspace=4)
if xlabel is None:
xlabel = param.replace('_', ' ')
# Plot the curve
# first sort the paramV values
if isinstance(paramV[0], float):
si = np.argsort(paramV)
else:
si = np.arange(len(paramV), dtype=int)
ax.plot(paramV[si], nu[si], '.-')
ax.set_xlabel(xlabel)
# Add title
ax.text(0.5, 0.95, title, transform=fig.transFigure, ha='center', va='center')
# Save the plot
if param_type == 'glat':
outdir = rootdir + 'kspace_cherns_mgyro/chern_glatparam/' + param + '/'
dio.ensure_dir(outdir)
# Add meshfn name to the output filename
outbase = self.cherns[self.cherns.items()[0][0]][0].mgyro_lattice.lp['meshfn']
if outbase[-1] == '/':
outbase = outbase[:-1]
outbase = outbase.split('/')[-1]
outd_ex = self.cherns[self.cherns.items()[0][0]][0].mgyro_lattice.lp['meshfn_exten']
# If the parameter name is part of the meshfn_exten, replace its value with XXX in
# the meshfnexten part of outdir.
mfestr = glat_param2meshfnexten_name(param)
if mfestr in outd_ex:
'param is in meshfn_exten, splitting...'
# split the outdir by the param string
od_split = outd_ex.split(mfestr)
# split the second part by the value of the param string and the rest
od2val_rest = od_split[1].split('_')
odrest = od_split[1].split(od2val_rest[0])[1]
print 'odrest = ', odrest
print 'od2val_rest = ', od2val_rest
outd_ex = od_split[0] + param + 'XXX'
outd_ex += odrest
print 'outd_ex = ', outd_ex
else:
outd_ex += '_' + param + 'XXX'
elif param_type == 'lat':
outdir = rootdir + 'kspace_cherns_mgyro/chern_lpparam/' + param + '/'
outbase = self.cherns[self.cherns.items()[0][0]][0].mgyro_lattice.lp['meshfn']
# Take apart outbase to parse out the parameter that is varying
mfestr = lat_param2meshfn_name(param)
if mfestr in outbase :
'param is in meshfn_exten, splitting...'
# split the outdir by the param string
od_split = outbase.split(mfestr)
# split the second part by the value of the param string and the rest
od2val_rest = od_split[1].split('_')
odrest = od_split[1].split(od2val_rest[0])[1]
print 'odrest = ', odrest
print 'od2val_rest = ', od2val_rest
outd_ex = od_split[0] + param + 'XXX'
outd_ex += odrest
print 'outd_ex = ', outd_ex
else:
outbase += '_' + param + 'XXX'
outd_ex = self.cherns[self.cherns.items()[0][0]][0].mgyro_lattice.lp['meshfn_exten']
dio.ensure_dir(outdir)
fname = outdir + outbase
fname += '_chern_' + param + '_Ncoll' + '{0:03d}'.format(len(self.mgyro_collection.mgyro_lattices))
fname += outd_ex
print 'saving to ' + fname + '.png'
plt.savefig(fname + '.png')
plt.clf()
def twistbcs(lp):
"""Load a periodic lattice from file, twist the BCs by phases theta_twist and phi_twist with vals finely spaced
between 0 and 2pi. Then compute the berry curvature associated with |alpha(theta, phi)>
Example usage:
python haldane_lattice_class.py -twistbcs -N 3 -LT hexagonal -shape square -periodic
Parameters
----------
lp
Returns
-------
"""
lp['periodicBC'] = True
meshfn = le.find_meshfn(lp)
lp['meshfn'] = meshfn
lat = lattice_class.Lattice(lp)
lat.load()
# Make a big array of the eigvals: N x N x thetav x phiv
# thetav = np.arange(0., 2. * np.pi, 0.5)
# phiv = np.arange(0., 2. * np.pi, 0.5)
# First just test for two values of theta and two of phi
thetav = [0., 0.01]
phiv = [0., 0.01]
eigvects = {}
ii = 0
for theta in thetav:
eigvects[ii] = {}
jj = 0
for phi in phiv:
lpnew = copy.deepcopy(lp)
lpnew['theta_twist'] = theta
lpnew['phi_twist'] = phi
hlat = HaldaneLattice(lat, lpnew)
ev, evec = hlat.get_eigval_eigvect(attribute=True)
if ii == 0 and jj == 0:
eigval = copy.deepcopy(ev)
ill = hlat.get_ill()
eigvects[ii][jj] = evec
jj += 1
ii += 1
# Dot the derivs of eigvects together
# Ensure that there is a nonzero-amplitude wannier with matching phase
dtheta = eigvects[1][0] - eigvects[0][0]
dphi = eigvects[0][1] - eigvects[0][0]
thetamov_fn = dio.prepdir(
hlat.lp['meshfn']
) + 'twistbc_theta' + hlat.lp['meshfn_exten'] + '_dos_ev.mov'
if not glob.glob(thetamov_fn):
# Plot differences
fig, DOS_ax, eig_ax = leplt.initialize_eigvect_DOS_header_plot(
ev,
hlat.lattice.xy,
sim_type='haldane',
colorV=ill,
colormap='viridis',
linewidth=0,
cax_label=r'$\xi^{-1}$',
cbar_nticks=2,
xlabel_pad=10,
ylabel_pad=10,
cbar_tickfmt='%0.3f')
DOS_ax.set_title(r'$\partial_\phi \psi$')
hlat.lattice.plot_BW_lat(fig=fig,
ax=eig_ax,
save=False,
close=False,
axis_off=False,
title='')
outdir = dio.prepdir(
hlat.lp['meshfn']
) + 'twistbc_theta' + hlat.lp['meshfn_exten'] + '/'
dio.ensure_dir(outdir)
for ii in range(len(ev)):
fig, [scat_fg, scat_fg2, p, f_mark, lines_12_st], cw_ccw = \
hlatpfns.construct_haldane_eigvect_DOS_plot(hlat.lattice.xy, fig, DOS_ax, eig_ax, eigval,
dtheta, ii, hlat.lattice.NL, hlat.lattice.KL,
marker_num=0, color_scheme='default', normalization=1.)
print 'saving theta ', ii
plt.savefig(outdir + 'dos_ev' + '{0:05}'.format(ii) + '.png')
scat_fg.remove()
scat_fg2.remove()
p.remove()
f_mark.remove()
lines_12_st.remove()
plt.close('all')
imgname = outdir + 'dos_ev'
movname = dio.prepdir(
hlat.lp['meshfn']
) + 'twistbc_theta' + hlat.lp['meshfn_exten'] + '_dos_ev'
lemov.make_movie(imgname, movname, rm_images=False)
phimov_fn = dio.prepdir(
hlat.lp['meshfn']
) + 'twistbc_phi' + hlat.lp['meshfn_exten'] + '_dos_ev.mov'
if not glob.glob(phimov_fn):
fig, DOS_ax, eig_ax = leplt.initialize_eigvect_DOS_header_plot(
ev,
hlat.lattice.xy,
sim_type='haldane',
colorV=ill,
colormap='viridis',
linewidth=0,
cax_label=r'$\xi^{-1}$',
cbar_nticks=2,
xlabel_pad=10,
ylabel_pad=10,
cbar_tickfmt='%0.3f')
DOS_ax.set_title(r'$\partial_\phi \psi$')
outdir = dio.prepdir(
hlat.lp['meshfn']) + 'twistbc_phi' + hlat.lp['meshfn_exten'] + '/'
dio.ensure_dir(outdir)
for ii in range(len(ev)):
fig, [scat_fg, scat_fg2, p, f_mark, lines_12_st], cw_ccw = \
hlatpfns.construct_haldane_eigvect_DOS_plot(hlat.lattice.xy, fig, DOS_ax, eig_ax, eigval,
dphi, ii, hlat.lattice.NL, hlat.lattice.KL,
marker_num=0, color_scheme='default', normalization=1.)
print 'saving phi ', ii
plt.savefig(outdir + 'dos_ev' + '{0:05}'.format(ii) + '.png')
scat_fg.remove()
scat_fg2.remove()
p.remove()
f_mark.remove()
lines_12_st.remove()
plt.close('all')
imgname = outdir + 'dos_ev'
movname = dio.prepdir(
hlat.lp['meshfn']
) + 'twistbc_phi' + hlat.lp['meshfn_exten'] + '_dos_ev'
lemov.make_movie(imgname, movname, rm_images=False)
# Check
# print 'shape(dtheta) = ', np.shape(dtheta)
# print 'shape(dphi) = ', np.shape(dphi)
# le.plot_complex_matrix(dtheta, show=True, name='dtheta')
# le.plot_complex_matrix(dphi, show=True, name='dphi')
fig, ax = leplt.initialize_nxmpanel_fig(4, 1, wsfrac=0.6, x0frac=0.3)
# < dphi | dtheta >
dpdt = np.einsum('ij...,ij...->i...', dtheta, dphi.conj())
# < dtheta | dphi >
dtdp = np.einsum('ij...,ij...->i...', dphi, dtheta.conj())
print 'dtdp = ', dtdp
ax[0].plot(np.arange(len(dtdp)), dtdp, '-')
ax[1].plot(np.arange(len(dpdt)), dpdt, '-')
hc = 2. * np.pi * 1j * (dpdt - dtdp)
ax[2].plot(np.arange(len(lat.xy)), hc, '.-')
# Plot cumulative sum
sumhc = np.cumsum(hc)
ax[3].plot(np.arange(len(lat.xy)), sumhc, '.-')
ax[2].set_xlabel(r'Eigvect number')
ax[0].set_ylabel(
r'$\langle \partial_{\theta} \alpha_i | \partial_{\phi} \alpha_i \rangle$'
)
ax[2].set_xlabel(r'Eigvect number')
ax[1].set_ylabel(
r'$\langle \partial_{\phi} \alpha_i | \partial_{\theta} \alpha_i \rangle$'
)
ax[2].set_xlabel(r'Eigvect number')
ax[2].set_ylabel(r'$c_H$')
ax[3].set_xlabel(r'Eigvect number')
ax[3].set_ylabel(r'$\sum_{E_\alpha < E_c} c_H$')
outdir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/twistbc_test/'
dio.ensure_dir(outdir)
print 'saving ', outdir + 'test' + hlat.lp['meshfn_exten'] + '.png'
plt.savefig(outdir + 'test' + hlat.lp['meshfn_exten'] + '.png')
# ### Now do the same thing but with different values of theta, phi
# First just test for two values of theta and two of phi
thetav = [1., 1.01]
phiv = [1., 1.01]
eigvects = {}
ii = 0
for theta in thetav:
eigvects[ii] = {}
jj = 0
for phi in phiv:
lpnew = copy.deepcopy(lp)
lpnew['theta_twist'] = theta
lpnew['phi_twist'] = phi
hlat = HaldaneLattice(lat, lpnew)
ev, evec = hlat.get_eigval_eigvect(attribute=True)
if ii == 0 and jj == 0:
eigval = copy.deepcopy(ev)
ill = hlat.get_ill()
eigvects[ii][jj] = evec
jj += 1
ii += 1
# Dot the derivs of eigvects together
dtheta = eigvects[1][0] - eigvects[0][0]
dphi = eigvects[0][1] - eigvects[0][0]
# Plot differences
thetamov_fn = dio.prepdir(
hlat.lp['meshfn']
) + 'twistbc_theta' + hlat.lp['meshfn_exten'] + '_dos_ev.mov'
if not glob.glob(thetamov_fn):
fig, DOS_ax, eig_ax = leplt.initialize_eigvect_DOS_header_plot(
ev,
hlat.lattice.xy,
sim_type='haldane',
colorV=ill,
colormap='viridis',
linewidth=0,
cax_label=r'$\xi^{-1}$',
cbar_nticks=2,
xlabel_pad=10,
ylabel_pad=10,
cbar_tickfmt='%0.3f')
DOS_ax.set_title(r'$\partial_\theta \psi$')
hlat.lattice.plot_BW_lat(fig=fig,
ax=eig_ax,
save=False,
close=False,
axis_off=False,
title='')
outdir = dio.prepdir(
hlat.lp['meshfn']
) + 'twistbc_theta' + hlat.lp['meshfn_exten'] + '/'
dio.ensure_dir(outdir)
for ii in range(len(ev)):
fig, [scat_fg, scat_fg2, p, f_mark, lines_12_st], cw_ccw = \
hlatpfns.construct_haldane_eigvect_DOS_plot(hlat.lattice.xy, fig, DOS_ax, eig_ax, eigval,
dtheta, ii, hlat.lattice.NL, hlat.lattice.KL,
marker_num=0, color_scheme='default', normalization=1.)
print 'saving theta ', ii
plt.savefig(outdir + 'dos_ev' + '{0:05}'.format(ii) + '.png')
scat_fg.remove()
scat_fg2.remove()
p.remove()
f_mark.remove()
lines_12_st.remove()
plt.close('all')
imgname = outdir + 'dos_ev'
movname = dio.prepdir(
hlat.lp['meshfn']
) + 'twistbc_theta' + hlat.lp['meshfn_exten'] + '_dos_ev'
lemov.make_movie(imgname, movname, rm_images=False)
# Now do phi
phimov_fn = dio.prepdir(
hlat.lp['meshfn']
) + 'twistbc_phi' + hlat.lp['meshfn_exten'] + '_dos_ev.mov'
if not glob.glob(phimov_fn):
fig, DOS_ax, eig_ax = leplt.initialize_eigvect_DOS_header_plot(
ev,
hlat.lattice.xy,
sim_type='haldane',
colorV=ill,
colormap='viridis',
linewidth=0,
cax_label=r'$\xi^{-1}$',
cbar_nticks=2,
xlabel_pad=10,
ylabel_pad=10,
cbar_tickfmt='%0.3f')
DOS_ax.set_title(r'$\partial_\phi \psi$')
hlat.lattice.plot_BW_lat(fig=fig,
ax=eig_ax,
save=False,
close=False,
axis_off=False,
title='')
outdir = dio.prepdir(
hlat.lp['meshfn']) + 'twistbc_phi' + hlat.lp['meshfn_exten'] + '/'
dio.ensure_dir(outdir)
for ii in range(len(ev)):
fig, [scat_fg, scat_fg2, p, f_mark, lines_12_st], cw_ccw = \
hlatpfns.construct_haldane_eigvect_DOS_plot(hlat.lattice.xy, fig, DOS_ax, eig_ax, eigval,
dphi, ii, hlat.lattice.NL, hlat.lattice.KL,
marker_num=0, color_scheme='default', normalization=1.)
print 'saving phi ', ii
plt.savefig(outdir + 'dos_ev' + '{0:05}'.format(ii) + '.png')
scat_fg.remove()
scat_fg2.remove()
p.remove()
f_mark.remove()
lines_12_st.remove()
plt.close('all')
imgname = outdir + 'dos_ev'
movname = dio.prepdir(
hlat.lp['meshfn']
) + 'twistbc_phi' + hlat.lp['meshfn_exten'] + '_dos_ev'
lemov.make_movie(imgname, movname, rm_images=False)
# Check
# print 'shape(dtheta) = ', np.shape(dtheta)
# print 'shape(dphi) = ', np.shape(dphi)
# le.plot_complex_matrix(dtheta, show=True, name='dtheta')
# le.plot_complex_matrix(dphi, show=True, name='dphi')
fig, ax = leplt.initialize_nxmpanel_fig(4, 1, wsfrac=0.6, x0frac=0.3)
# < dphi | dtheta >
dpdt = np.einsum('ij...,ij...->i...', dtheta, dphi.conj())
# < dtheta | dphi >
dtdp = np.einsum('ij...,ij...->i...', dphi, dtheta.conj())
print 'dtdp = ', dtdp
ax[0].plot(np.arange(len(dtdp)), dtdp, '-')
ax[1].plot(np.arange(len(dpdt)), dpdt, '-')
hc = 2. * np.pi * 1j * (dpdt - dtdp)
ax[2].plot(np.arange(len(lat.xy)), hc, '.-')
# Plot cumulative sum
sumhc = np.cumsum(hc)
ax[3].plot(np.arange(len(lat.xy)), sumhc, '.-')
ax[2].set_xlabel(r'Eigvect number')
ax[0].set_ylabel(
r'$\langle \partial_{\theta} \alpha_i | \partial_{\phi} \alpha_i \rangle$'
)
ax[2].set_xlabel(r'Eigvect number')
ax[1].set_ylabel(
r'$\langle \partial_{\phi} \alpha_i | \partial_{\theta} \alpha_i \rangle$'
)
ax[2].set_xlabel(r'Eigvect number')
ax[2].set_ylabel(r'$c_H$')
ax[3].set_xlabel(r'Eigvect number')
ax[3].set_ylabel(r'$\sum_{E_\alpha < E_c} c_H$')
outdir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/twistbc_test/'
dio.ensure_dir(outdir)
plt.savefig(outdir + 'test' + hlat.lp['meshfn_exten'] + '_theta1p0.png')
sys.exit()
########################################
# Now test for more theta values, more phi values
thetav = np.arange(0., 0.14, 0.1)
phiv = np.arange(0., 0.14, 0.1)
eigvects = np.zeros((len(lat.xy), len(lat.xy), len(thetav), len(phiv)),
dtype=complex)
ii = 0
for theta in thetav:
jj = 0
for phi in phiv:
lpnew = copy.deepcopy(lp)
lpnew['theta_twist'] = theta
lpnew['phi_twist'] = phi
hlat = HaldaneLattice(lat, lpnew)
ev, evec = hlat.get_eigval_eigvect()
eigvects[:, :, ii, jj] = evec
jj += 1
ii += 1
# Dot the derivs of eigvects together
print 'eigvects = ', eigvects
dtheta = np.diff(eigvects, axis=2)
dphi = np.diff(eigvects, axis=3)
print 'dtheta = ', dtheta
print 'shape(dtheta) = ', np.shape(dtheta)
print 'shape(dphi) = ', np.shape(dphi)
le.plot_complex_matrix(dtheta[:, :, 0, 0], show=True)
le.plot_complex_matrix(dphi[:, :, 0, 0], show=True)
dtheta = dtheta[:, :, :, 0:np.shape(dtheta)[3] - 1]
dphi = dphi[:, :, 0:np.shape(dphi)[2] - 1, :]
print 'shape(dtheta) = ', np.shape(dtheta)
print 'shape(dphi) = ', np.shape(dphi)
for ii in range(np.shape(dtheta)[-1]):
le.plot_complex_matrix(dtheta[:, :, ii, 0], show=True)
fig, ax = leplt.initialize_nxmpanel_fig(3, 1)
for ii in range(np.shape(dphi)[-1]):
for jj in range(np.shape(dphi)[-1]):
# < dphi | dtheta >
dpdt = np.dot(dtheta[:, :, ii, jj], dphi[:, :, ii, jj].conj().T)
# < dtheta | dphi >
dtdp = np.dot(dphi[:, :, ii, jj], dtheta[:, :, ii, jj].conj().T)
print 'np.shape(dpdt) = ', np.shape(dpdt)
print 'np.shape(dtdp) = ', np.shape(dtdp)
ax[0].plot(np.arange(len(dtdp)), dtdp, '-')
ax[1].plot(np.arange(len(dpdt)), dpdt, '-')
hc = 2. * np.pi * 1j * (dpdt - dtdp)
ax[2].plot(np.arange(len(lat.xy)), hc, '.-')
ax[0].set_xlabel(r'$\theta$')
ax[0].set_ylabel(
r'$\langle \partial_{\theta} \alpha_i | \partial_{\phi} \alpha_i \rangle$'
)
ax[1].set_xlabel(r'$\phi$')
ax[1].set_ylabel(
r'$\langle \partial_{\phi} \alpha_i | \partial_{\theta} \alpha_i \rangle$'
)
ax[2].set_xlabel(r'Eigvect number')
ax[2].set_ylabel(r'$\partial_{\phi} \alpha_i$')
plt.show()
def draw_edge_localization_plots(hlat,
elocz,
eigval,
eigvect,
outdir=None,
alpha=1.0,
fontsize=12):
"""Draw plots of each normal mode excitation with colormap behind it denoting the fitted exponential localization
Parameters
----------
hlat : HaldaneLattice instance
The gyro lattice whose modes we plot
elocz : NP x 5 float array (ie, int(len(eigval)*0.5) x 5 float array)
edge localization fit details: A, K, uncertainty_A, covariance_AK, uncertainty_K
eigval : 2*N x 1 complex array
eigenvalues of the matrix, sorted by order of imaginary components
eigvect : typically 2*N x 2*N complex array
eigenvectors of the matrix, sorted by order of imaginary components of eigvals
Eigvect is stored as NModes x NP*2 array, with x and y components alternating, like:
x0, y0, x1, y1, ... xNP, yNP.
outdir : str or None
the output directory to use for saving localization plots. If None, uses pwd as ouput dir
alpha : float
The opacity of the excitation ellipses
fontsize : int
The fontsize to use for labels, etc
Returns
-------
fig, dos_ax, ax
"""
if outdir is None:
print 'Outputting images in current working directory...'
outdir = './'
else:
dio.ensure_dir(outdir)
ipr = hlat.get_ipr()
# Get third largest value for ipr vmax
# ipr_vmax = np.max(1. / ipr.sort())[3]
ipr_vmax = float(np.floor(10 * heapq.nlargest(6, 1. / ipr)[-1])) / 10.
fig, dos_ax, ax = leplt.initialize_eigvect_DOS_header_plot(
eigval,
hlat.lattice.xy,
sim_type='haldane',
preset_cbar=True,
colorV=1. / ipr,
colormap='viridis_r',
norm=None,
facecolor='#80D080',
nbins=75,
fontsize=fontsize,
vmin=0.0,
vmax=ipr_vmax,
linewidth=0,
make_cbar=True,
climbars=True,
xlabel='Energy $E/t_1$',
ylabel=r'$D(E)$',
ylabel_pad=20,
cax_label=r'$p$',
cbar_labelpad=10,
ticks=[0., ipr_vmax],
cbar_nticks=None,
cbar_tickfmt=None,
orientation='vertical',
cbar_orientation='vertical',
invert_xaxis=False,
yaxis_tickright=False,
yaxis_ticks=None,
ylabel_right=False,
ylabel_rot=0,
DOSexcite=None,
DOSexcite_color='r')
# Make axis for showing quality of fit
x0 = 0.1
y0 = 0.2
w = 0.8
h = 0.2
ax.set_position([x0, y0, w, h])
eax_w = 0.5
eax_h = 0.15
eax_x0 = x0 + (w - eax_w) * 0.5
eax_y0 = y0 + h * 1.7
exp_ax = fig.add_axes([eax_x0, eax_y0, eax_w, eax_h])
hlat.lattice.plot_BW_lat(fig=fig,
ax=ax,
meshfn='none',
save=False,
close=False,
axis_off=True,
title='')
# If periodic, use LL to plot localization fit assuming periodic boundaries
if hlat.lp['periodicBC']:
if hlat.lp['periodic_strip']:
magevecs = np.abs(eigvect)
# Also get distance of each particle from boundary
bseg_tuple = hlat.lattice.get_boundary_linesegs()
xydists = []
for bsegs in bseg_tuple:
xydists.append(
linesegs.mindist_from_multiple_linesegs(
hlat.lattice.xy, bsegs))
# Convert list xydists into NP x 2 array
xydists = np.dstack(tuple(xydists))[0]
else:
# There are two periodic vectos, so there can be no boundary --> exit with error
raise RuntimeError(
'Cannot compute distance to boundary in a fully periodic sample '
+ '--> there is no boundary.')
else:
# Not periodic, no LL, so use lattice boundary to connect consecutive linesegments
magevecs = hlat.calc_magevecs(eigvect)
bndry_segs = hlat.lattice.get_boundary_linesegs()
xydists = linesegs.mindist_from_multiple_linesegs(
hlat.lattice.xy, bndry_segs)
# Get the xlims and ylims for plotting the exponential decay fit
xlims_fit = [-0.1, np.max(xydists.ravel()) + 1]
xlims = [
np.min(hlat.lattice.xy[:, 0]) - 1,
np.max(hlat.lattice.xy[:, 0]) + 1
]
ylims = [
np.min(hlat.lattice.xy[:, 1]) - 1,
np.max(hlat.lattice.xy[:, 1]) + 1
]
dmyi = 0
# Look at all states
todo = np.hstack((np.array([0]), np.arange(len(eigval))))
for en in todo:
fig, [scat_fg, pp, f_mark, lines12_st] =\
plot_eigvect_excitation_haldane(hlat.lattice.xy, fig, dos_ax, ax, eigval, eigvect, en,
marker_num=0, black_t0lines=True)
locz = elocz[en]
if hlat.lp['periodic_strip']:
localz_handle = plot_edge_localization_heatmap_periodicstrip(
locz, bseg_tuple, ax, xlims=xlims, ylims=ylims, alpha=1.0)
title = ax.get_title()
# Draw the exponential localization fit
plt_handle, fit_handle = plot_localization_dists(
locz,
xydists[:, int(locz[5] % 2)],
magevecs[en],
exp_ax,
xlims=xlims_fit)
else:
# assuming no periodicity
localz_handle = plot_edge_localization_heatmap(locz,
bndry_segs,
ax,
xlims=xlims,
ylims=ylims,
alpha=1.0)
title = ax.get_title()
# Draw the exponential localization fit
plt_handle, fit_handle = plot_localization_dists(locz,
xydists,
magevecs[en],
exp_ax,
xlims=xlims_fit)
ax.set_title(title + r', $|\psi(r)| \approx$ $($' +
'{0:0.3f}'.format(locz[0]) + r'$\pm$' +
'{0:0.3f}'.format(locz[2]) + r'$)$ ' + r'$\exp[($' +
'{0:0.3f}'.format(locz[1]) + r'$\pm$' +
'{0:0.3f}'.format(locz[4]) + '$)\, r]$',
fontsize=fontsize)
# Add axis labels
exp_ax.set_xlabel('Distance from boundary, $r$', fontsize=12)
exp_ax.set_ylabel('Excitation, $|\psi|$', fontsize=12)
# Save this image
outname = outdir + 'localization_edge' + hlat.lp[
'meshfn_exten'] + '_{0:06d}'.format(en) + '.png'
print 'saving image to ', outname
plt.savefig(outname)
# cleanup
localz_handle.remove()
scat_fg.remove()
pp.remove()
f_mark.remove()
lines12_st.remove()
if hlat.lp['periodic_strip']:
exp_ax.cla()
del localz_handle
del scat_fg
del pp
del f_mark
del lines12_st
dmyi += 1
return fig, dos_ax, ax
def build_jammed(lp):
"""Use bonds from jammed packing --> already near isostatic, but can't tune above it, only below.
Parameters
----------
lp
Returns
-------
"""
# Use bonds from jammed packing --> already near isostatic, but can't tune above it, only below.
shape = lp['shape']
nh = lp['NH']
nv = lp['NV']
networkdir = dio.ensure_dir(lp['rootdir']) + 'networks/'
print('Loading isostatic file to build jammed lattice...')
# Now load
use_hexner = (lp['source'] == 'hexner')
if use_hexner:
print 'lp[periodicBC] = ', lp['periodicBC']
points, BL, LLv, numberstr, sizestr, lp = load_hexner_jammed(
lp, BL_load=True)
sourcestr = '_hexner'
else:
# Use Stephan Ulrich's lattices
if lp['periodicBC']:
RuntimeError('Not sure if Stephan Ulrich lattices are periodic!')
zindex = '{0:03d}'.format(int(lp['loadlattice_z']))
number = '{0:03d}'.format(int(lp['conf']))
points = np.loadtxt(networkdir + 'isostatic_source/isostatic_homog_z' +
zindex + '_conf' + number + '_nodes.txt')
BL = np.loadtxt(networkdir + 'isostatic_source/isostatic_homog_z' +
zindex + '_conf' + number + '_bonds.txt',
usecols=(0, 1),
dtype=int)
sourcestr = '_ulrich_homog'
print 'BL[100] = ', BL[100]
# Loaded BL uses indexing starting at 1, not 0
BL -= 1
print 'BL[100] = ', BL[100]
numberstr = number[1:]
if check:
le.display_lattice_2D(points,
np.abs(BL),
title='points and bonds loaded, before pruning')
xy = points - np.mean(points, axis=0)
NL, KL = le.BL2NLandKL(BL, NN='min')
# Remove any points with no bonds
print 'Removing points without any bonds...'
keep = KL.any(axis=1)
xy, NL, KL, BL = le.remove_pts(keep, xy, BL, NN='min')
print 'len(xy) = ', len(xy)
if check:
le.display_lattice_2D(
xy,
np.abs(BL),
title='Before tuning z (down) and before fixing PBCs')
if lp['cutz_method'] == 'random':
NL, KL, BL = le.cut_bonds_z_random(xy,
NL,
KL,
BL,
lp['target_z'],
bulk_determination='Endpts')
elif lp['cutz_method'] == 'highest':
NL, KL, BL = le.cut_bonds_z_highest(xy,
NL,
KL,
BL,
lp['target_z'],
check=check)
elif lp['cutz_method'] == 'none':
pass
if lp['periodicBC'] or lp['NP_load'] > 0:
print 'Building periodicBC PVs...'
lp['periodicBC'] = True
LL = (LLv, LLv)
polygon = 0.5 * np.array([[-LLv, -LLv], [LLv, -LLv], [LLv, LLv],
[-LLv, LLv]])
BBox = polygon
PV = np.array([[LLv, 0.0], [LLv, LLv], [LLv, -LLv], [0.0, 0.0],
[0.0, LLv], [0.0, -LLv], [-LLv, 0.0], [-LLv, LLv],
[-LLv, -LLv]])
PVxydict = le.BL2PVxydict(BL, xy, PV)
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
if lp['check']:
le.display_lattice_2D(xy,
BL,
NL=NL,
KL=KL,
PVx=PVx,
PVy=PVy,
title='Checking periodic BCs',
close=False,
colorz=False)
for ii in range(len(xy)):
plt.text(xy[ii, 0] + 0.1, xy[ii, 1], str(ii))
plt.plot(xy[:, 0], xy[:, 1], 'go')
plt.show()
else:
polygon = blf.auto_polygon(shape, nh, nv, eps=0.00)
BBox = polygon
print('Trimming lattice to be NH x NV...')
keep = np.logical_and(
abs(xy[:, 0]) < nh * 0.5,
abs(xy[:, 1]) < nv * 0.5)
print "Check that if lp['NP_load'] !=0 then len(keep) == len(xy):", len(
keep) == len(xy)
xy, NL, KL, BL = le.remove_pts(keep, xy, BL, NN='min')
LL = (nh, nv)
PVx = []
PVy = []
PVxydict = {}
z = le.compute_bulk_z(xy, NL, KL, BL)
print 'FOUND z = ', z
if lp['periodicBC']:
periodicBCstr = '_periodicBC'
else:
periodicBCstr = ''
print('Defining lattice_exten...')
lattice_exten = 'jammed_' + shape + sourcestr + periodicBCstr + '_z' + '{0:0.03f}'.format(z) + '_conf' + \
numberstr + '_zmethod' + lp['cutz_method']
LV = 'none'
UC = 'none'
LVUC = 'none'
return xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp
def projector_site_vs_dist_hlatparam(hcoll,
omegac,
proj_XY,
plot_mag=True,
plot_diff=False,
save_plt=True,
alpha=1.0,
maxdistlines=True,
reverse_order=False,
check=True):
"""
Compare the projector values at distances relative to a particular site (site at location proj_XY).
Parameters
----------
hcoll : HaldaneCollection instance
The collection of haldane_lattices for which to compare projectors as fn of distance from a given site.
omegac : float
Cutoff frequency for the projector
proj_XY : 2 x 1 float numpy array
The location at which to find the nearest site and consider projector elements relative to this site.
plot : bool
Whether to plot magproj vs dist for all HaldaneLattices in hcoll
check : bool
Display intermediate results
Returns
-------
dist_list : list of NP x NP float arrays
Euclidean distances between points. Element i,j is the distance between particle i and j
proj_list : list of evxyprojs (2 x 2*NP float arrays)
Each element is like magproj, but with x and y components separate.
So, element 0,2*j gives the magnitude of the x component of the projector connecting the site in question
to the x component of particle j and element 1,2*j+1 gives the
magnitude of the y component of the projector connecting the site in question to the y component of particle j.
"""
raise RuntimeError(
"Haven't finished this code yet! Need to adapt to Haldane lattice structure"
)
proj_list = []
dist_list = []
kk = 0
if plot_mag:
# magnitude plot
mfig, magax, mcbar = leplt.initialize_1panel_cbar_fig()
if plot_diff:
# difference plot
dfig, dax, dcbar = leplt.initialize_1panel_cbar_fig()
# difference fraction plot
dffig, dfax, dfcbar = leplt.initialize_1panel_cbar_fig()
if maxdistlines:
maxdist = []
sat = 1
light = 0.6
colors = lecmaps.husl_palette(n_colors=len(hcoll.haldane_lattices),
s=sat,
l=light)
if reverse_order:
hlat_list = hcoll.haldane_lattices[::-1]
else:
hlat_list = hcoll.haldane_lattices
for hlat in hlat_list:
proj_ind = ((hlat.lattice.xy - proj_XY)[:, 0]**2 +
(hlat.lattice.xy - proj_XY)[:, 1]**2).argmin()
outdir = dio.prepdir(hlat.lp['meshfn'].replace('networks',
'projectors'))
outfn = outdir + hlat.lp[
'LatticeTop'] + "_dist_singlept_{0:06d}".format(proj_ind) + ".pkl"
if check:
print 'identified proj_ind = ', proj_ind
newfig = plt.figure()
hlat.lattice.plot_numbered(ax=plt.gca())
# attempt to load
if glob.glob(outfn):
with open(outfn, "rb") as fn:
dist = pickle.load(fn)
outfn = outdir + hlat.lp[
'LatticeTop'] + "_evxyproj_singlept_{0:06d}".format(
proj_ind) + ".pkl"
with open(outfn, "rb") as fn:
evxyproj = pickle.load(fn)
else:
# compute dists and evxyproj_proj_ind
xydiff = hlat.lattice.xy - hlat.lattice.xy[proj_ind]
dist = np.sqrt(xydiff[:, 0]**2 + xydiff[:, 1]**2)
print 'calculating projector...'
proj = calc_projector(hlat, omegac, attribute=False)
outdir = dio.prepdir(hlat.lp['meshfn'].replace(
'networks', 'projectors'))
dio.ensure_dir(outdir)
# save dist as pickle
with open(outfn, "wb") as fn:
pickle.dump(dist, fn)
# evxyproj has dims 2 xlen(evect)
evxyproj = np.dstack(
(proj[2 * proj_ind, :], proj[2 * proj_ind + 1, :]))[0].T
# save evxyproj as pickle
outfn = outdir + hlat.lp[
'LatticeTop'] + "_evxyproj_singlept_{0:06d}".format(
proj_ind) + ".pkl"
with open(outfn, "wb") as fn:
pickle.dump(evxyproj, fn)
proj_list.append(evxyproj)
dist_list.append(dist)
if plot_mag:
tmp = np.sqrt(
np.abs(evxyproj[0]).ravel()**2 +
np.abs(evxyproj[1]).ravel()**2)
magproj = np.array([
np.sqrt(tmp[2 * ind].ravel()**2 + tmp[2 * ind + 1].ravel()**2)
for ind in range(len(dist))
])
magax.scatter(dist,
np.log10(magproj),
s=1,
color=colors[kk],
alpha=alpha)
if plot_diff:
if kk > 0:
# find particles that are the same as in the reference network
same_inds = np.where(le.dist_pts(hlat.lattice.xy, xy0) == 0)
# Order them by distance
current = np.array(
[[2 * same_inds[0][ii], 2 * same_inds[0][ii] + 1]
for ii in range(len(same_inds[0]))])
current = current.ravel()
orig = np.array(
[[2 * same_inds[1][ii], 2 * same_inds[1][ii] + 1]
for ii in range(len(same_inds[0]))])
orig = orig.ravel()
# if check:
# origfig = plt.figure()
# origax = origfig.gca()
# [origax, origaxcb] = hlat.lattice.plot_numbered(fig=origfig, ax=origax, axis_off=False,
# title='Original lattice for proj comparison')
# origax.scatter(hlat.lattice.xy[same_inds[0], 0], hlat.lattice.xy[same_inds[0], 1])
# plt.pause(5)
# plt.close()
if len(current) > 0:
evxydiff = evxyproj[:, current] - evxyproj0[:, orig]
tmp = np.sqrt(
np.abs(evxydiff[0]).ravel()**2 +
np.abs(evxydiff[1]).ravel()**2)
magdiff = np.array([
np.sqrt(tmp[2 * ind].ravel()**2 +
tmp[2 * ind + 1].ravel()**2)
for ind in range(len(same_inds[0]))
])
# magnitude of fractional difference
magfdiff = np.array([
magdiff[same_inds[0][ii]] / mag0[same_inds[1][ii]]
for ii in range(len(same_inds[0]))
])
dax.scatter(dist[same_inds[0]],
magdiff,
s=1,
color=colors[kk],
alpha=alpha)
dfax.scatter(dist[same_inds[0]],
magfdiff,
s=1,
color=colors[kk],
alpha=alpha)
if maxdistlines:
maxdist.append(np.max(dist[same_inds[0]]))
else:
origfig = plt.figure()
origax = origfig.gca()
[origax, origaxcb] = hlat.lattice.plot_numbered(
fig=origfig,
ax=origax,
axis_off=False,
title='Original lattice for proj comparison')
origfig.show()
plt.close()
evxyproj0 = copy.deepcopy(evxyproj)
xy0 = copy.deepcopy(hlat.lattice.xy)
tmp = np.sqrt(
np.abs(evxyproj[0]).ravel()**2 +
np.abs(evxyproj[1]).ravel()**2)
mag0 = np.array([
np.sqrt(tmp[2 * ind].ravel()**2 +
tmp[2 * ind + 1].ravel()**2)
for ind in range(len(dist))
])
kk += 1
# Save plots
outsplit = dio.prepdir(hlat.lp['meshfn'].replace('networks',
'projectors')).split('/')
outdir = '/'
for sdir in outsplit[0:-2]:
outdir += sdir + '/'
outdir += '/'
if plot_mag:
if maxdistlines and plot_diff:
ylims = magax.get_ylim()
print 'ylims = ', ylims
ii = 1
for dd in maxdist:
magax.plot([dd, dd],
np.array([ylims[0], ylims[1]]),
'-',
color=colors[ii])
ii += 1
magax.set_title('Magnitude of projector vs distance')
magax.set_xlabel(r'$|\mathbf{x}_i - \mathbf{x}_0|$')
magax.set_ylabel(r'$|P_{i0}|$')
# make a scalar mappable for colorbar'
husl_cmap = lecmaps.husl_cmap(s=sat, l=light)
sm = plt.cm.ScalarMappable(cmap=husl_cmap,
norm=plt.Normalize(vmin=0, vmax=1))
sm._A = []
cbar = plt.colorbar(sm, cax=mcbar, ticks=[0, 1])
cbar.ax.set_ylabel(r'$\alpha$', rotation=0)
if save_plt:
print 'kfns: saving magnitude comparison plot for hcoll (usually run from kitaev_collection)...'
mfig.savefig(outdir + hlat.lp['LatticeTop'] +
"_magproj_singlept.png",
dpi=300)
else:
plt.show()
if plot_diff:
dax.set_title('Projector differences')
dax.set_xlabel(r'$|\mathbf{x}_i - \mathbf{x}_0|$')
dax.set_ylabel(r'$|\Delta P_{i0}|$')
# make a scalar mappable for colorbar'
husl_cmap = lecmaps.husl_cmap(s=sat, l=light)
sm = plt.cm.ScalarMappable(cmap=husl_cmap,
norm=plt.Normalize(vmin=0, vmax=1))
sm._A = []
cbar = plt.colorbar(sm, cax=dcbar, ticks=[0, 1])
cbar.ax.set_ylabel(r'$\alpha$', rotation=0)
if maxdistlines:
# Grab ylimits for setting after adding lines
ylims = dax.get_ylim()
df_ylims = dfax.get_ylim()
ii = 1
for dd in maxdist:
dax.plot([dd, dd],
np.array([-0.05, -0.005]),
'-',
color=colors[ii])
dfax.plot([dd, dd],
np.array([df_ylims[0], -0.01]),
'-',
color=colors[ii])
ii += 1
dax.set_ylim(-0.05, ylims[1])
dfax.set_ylim(df_ylims[0], df_ylims[1])
# now do fractional difference magnitude plot
dfax.set_title('Fractional projector differences')
dfax.set_xlabel(r'$|\mathbf{x}_i - \mathbf{x}_0|$')
dfax.set_ylabel(r'$|\Delta P_{i0}|/|P_{i0}|$')
# make a scalar mappable for colorbar'
cbar = plt.colorbar(sm, cax=dfcbar, ticks=[0, 1])
cbar.ax.set_ylabel(r'$\alpha$', rotation=0)
if save_plt:
print 'kfns: saving diff plot for hcoll projecctors (usually run from kitaev_collection)...'
dfig.savefig(outdir + hlat.lp['LatticeTop'] +
"_diffproj_singlept.png",
dpi=300)
dffig.savefig(outdir + hlat.lp['LatticeTop'] +
"_diffproj_singlept_fractionaldiff.png",
dpi=300)
dfax.set_ylim(-0.1, 1)
dffig.savefig(outdir + hlat.lp['LatticeTop'] +
"_diffproj_singlept_fractionaldiff_zoom.png",
dpi=300)
dfax.set_ylim(-0.02, 0.1)
dffig.savefig(outdir + hlat.lp['LatticeTop'] +
"_diffproj_singlept_fractionaldiff_extrazoom.png",
dpi=300)
elif not plot_mag:
plt.show()
return dist_list, proj_list
description = 'kagomized hyperuniform'
elif args.LatticeTop == 'kagper_hucent':
description = 'kagome decoration percolation'
if socket.gethostname()[0:6] == 'midway':
rootdir = '/home/npmitchell/scratch-midway/'
cp_rootdir = rootdir
elif socket.gethostname()[0:8] == 'Messiaen' or socket.gethostname()[0:5] == 'cvpn-':
rootdir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/'
cp_rootdir = '/Users/npmitchell/Desktop/GPU/'
else:
rootdir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/'
cp_rootdir = '/Volumes/research4TB/Soft_Matter/GPU/'
outdir = rootdir + 'experiments/DOS_scaling/' + args.LatticeTop + '/'
dio.ensure_dir(outdir)
dcdisorder = args.V0_pin_gauss > 0 or args.V0_spring_gauss > 0
lp = {'LatticeTop': args.LatticeTop,
'shape': shape,
'NH': NH,
'NV': NV,
'NP_load': args.NP_load,
'rootdir': rootdir,
'phi_lattice': args.phi_lattice,
'delta_lattice': args.delta_lattice,
'theta': args.theta,
'eta': args.eta,
'x1': x1,
'x2': x2,
lemov.make_movie(imgname, movname, indexsz='04', framerate=15)
# Parameters
# number of sampling points
nx = 200
ny = 300
full3dplot = False
saveims = True
fontsize = 20
tick_fontsize = 16
maindir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/haldane_model/'
outdir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/haldane_model/t2_movie/'
outdir_dab = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/haldane_model/DeltaAB_movie/'
outdir_dabt2 = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/haldane_model/DeltaAB_movie_t20p20/'
dio.ensure_dir(outdir)
dio.ensure_dir(outdir_dab)
dio.ensure_dir(outdir_dabt2)
# hopping strengths
t1 = 1.
t2max = 0.20
t2arr = np.arange(0, t2max + 1e-9, 0.01)
mmarr = np.arange(0, 3 * t2max + 1e-9, 0.01)
mm = 0.
# Create movie and image sequence
movie_varyDeltaAB(t1,
0.,
mmarr,
nx,
ny,
def polygon_phases_tune_junction(lp, args, nmode=None):
"""Plot the phase differences ccw around each polygon in the network for many glats as junction coupling
is increased. Do this for the nth mode as the scaling parameter evolves
(typically the bond strength between particles that are nearer than some threshold).
Example usage:
python gyro_lattice_class.py -polygon_phases_tune_junction -LT hexjunction2triads -N 1 -OmKspec union0p000in0p100 -alph 0.1 -periodic
python gyro_lattice_class.py -polygon_phases_tune_junction -LT spindle -N 2 -OmKspec union0p000in0p100 -alph 0.0 -periodic -aratio 0.1
python gyro_lattice_class.py -polygon_phases_tune_junction -LT spindle -N 4 -OmKspec union0p000in0p100 -alph 0.0 -periodic -aratio 0.1
# for making lattices
python ./build/make_lattice.py -LT spindle -N 4 -periodic -skip_gyroDOS -aratio 0.1
Parameters
----------
lp
args
nmode : int, int list, or None
Returns
-------
"""
cmap = lecmaps.ensure_cmap('bbr0')
nkvals = 50
if lp['LatticeTop'] in ['hexjunctiontriad', 'spindle', 'hexjunction2triads']:
kvals = -np.unique(np.round(np.logspace(-1, 1., nkvals), 2)) # [::-1]
dist_thres = lp['OmKspec'].split('union')[-1].split('in')[-1]
lpmaster = copy.deepcopy(lp)
lat = lattice_class.Lattice(lp)
lat.load()
if nmode is None:
todo = np.arange(len(lat.xy[:, 0]))
elif type(nmode) == int:
todo = [nmode]
else:
todo = nmode
##########################################################################
# First collect eigenvalue flow
eigvals, first = [], True
for (kval, dmyi) in zip(kvals, np.arange(len(kvals))):
lp = copy.deepcopy(lpmaster)
lp['OmKspec'] = 'union' + sf.float2pstr(kval, ndigits=3) + 'in' + dist_thres
# lat = lattice_class.Lattice(lp)
glat = GyroLattice(lat, lp)
eigval, eigvect = glat.eig_vals_vects(attribute=True)
if first:
eigvals = np.zeros((len(kvals), len(eigval)), dtype=float)
eigvals[dmyi, :] = np.imag(eigval)
first = False
##########################################################################
lp = copy.deepcopy(lpmaster)
glat = GyroLattice(lat, lp)
# add meshfn without OmKspecunion part
mfe = glat.lp['meshfn_exten']
if mfe[0:13] == '_OmKspecunion':
meshfnextenstr = mfe.split(mfe.split('_')[1])[-1]
else:
raise RuntimeError('Handle this case here -- should be easy: split meshfn_exten to pop OmKspec out')
for ii in todo[::-1]:
modefn = dio.prepdir(lat.lp['meshfn']) + 'glat_mode_phases_scaling_tune_junction_mode{0:05d}'.format(ii) +\
meshfnextenstr + '_nkvals{0:04}'.format(nkvals) + '.mov'
globmodefn = glob.glob(modefn)
if not globmodefn:
modedir = dio.prepdir(lat.lp['meshfn']) + 'glat_mode_phases_tune_junction_mode{0:05d}'.format(ii) + \
meshfnextenstr + '/'
dio.ensure_dir(modedir)
previous_ev = None
first = True
dmyi = 0
for kval in kvals:
lp = copy.deepcopy(lpmaster)
lp['OmKspec'] = 'union' + sf.float2pstr(kval, ndigits=3) + 'in' + dist_thres
# lat = lattice_class.Lattice(lp)
glat = GyroLattice(lat, lp)
eigval, eigvect = glat.eig_vals_vects(attribute=True)
# plot the nth mode
# fig, DOS_ax, eax = leplt.initialize_eigvect_DOS_header_plot(eigval, glat.lattice.xy,
# sim_type='gyro', cbar_nticks=2,
# cbar_tickfmt='%0.3f')
fig, dos_ax, eax, ax1, cbar_ax = \
leplt.initialize_eigvect_DOS_header_twinplot(eigval, glat.lattice.xy, sim_type='gyro',
ax0_pos=[0.0, 0.10, 0.45, 0.55],
ax1_pos=[0.65, 0.15, 0.3, 0.60],
header_pos=[0.1, 0.78, 0.4, 0.20],
xlabel_pad=8, fontsize=8)
cax = plt.axes([0.455, 0.10, 0.02, 0.55])
# Get the theta that minimizes the difference between the present and previous eigenvalue
# IN ORDER TO CONNECT MODES PROPERLY
if previous_ev is not None:
realxy = np.real(previous_ev)
thetas, eigvects = gdh.phase_fix_nth_gyro(glat.eigvect, ngyro=0, basis='XY')
# only look at neighboring modes
# (presumes sufficient resolution to disallow simultaneous crossings)
mmin = max(modenum - 2, 0)
mmax = min(modenum + 2, len(eigvects))
modenum = gdh.phase_difference_minimum(eigvects[mmin:mmax], realxy, basis='XY')
modenum += mmin
# print 'thetas = ', thetas
# if theta < 1e-9:
# print 'problem with theta'
# sys.exit()
else:
thetas, eigvects = gdh.phase_fix_nth_gyro(glat.eigvect, ngyro=0, basis='XY')
modenum = ii
# Plot the lattice with bonds
glat.lattice.plot_BW_lat(fig=fig, ax=eax, save=False, close=False, axis_off=False, title='')
# plot excitation
fig, [scat_fg, scat_fg2, pp, f_mark, lines_12_st], cw_ccw = \
leplt.construct_eigvect_DOS_plot(glat.lattice.xy, fig, dos_ax, eax, eigval, eigvects,
modenum, 'gyro', glat.lattice.NL, glat.lattice.KL,
marker_num=0, color_scheme='default', sub_lattice=-1,
amplify=1., title='')
# Plot the polygons colored by phase
polys = glat.lattice.get_polygons()
patches, colors = [], []
for poly in polys:
addv = np.array([0., 0.])
# build up positions, taking care of periodic boundaries
xys = np.zeros_like(glat.lattice.xy[poly], dtype=float)
xys[0] = glat.lattice.xy[poly[0]]
for (site, qq) in zip(poly[1:], range(len(poly) - 1)):
if latfns.bond_is_periodic(poly[qq], site, glat.lattice.BL):
toadd = latfns.get_periodic_vector(poly[qq], site,
glat.lattice.PVx, glat.lattice.PVy,
glat.lattice.NL, glat.lattice.KL)
if np.shape(toadd)[0] > 1:
raise RuntimeError('Handle the case of multiple periodic bonds between ii jj here')
else:
addv += toadd[0]
xys[qq + 1] = glat.lattice.xy[site] + addv
print 'site, poly[qq - 1] = ', (site, poly[qq])
print 'addv = ', addv
xys = np.array(xys)
polygon = Polygon(xys, True)
patches.append(polygon)
# Check the polygon
# plt.close('all')
# plt.plot(xys[:, 0], xys[:, 1], 'b-')
# plt.show()
# Get mean phase difference in this polygon
# Use weighted arithmetic mean of (cos(angle), sin(angle)), then take the arctangent.
yinds = 2 * np.array(poly) + 1
xinds = 2 * np.array(poly)
weights = glatfns.calc_magevecs_full(eigvect[modenum])
# To take mean, follow
# https://en.wikipedia.org/wiki/Mean_of_circular_quantities#Mean_of_angles
# with weights from
# https://en.wikipedia.org/wiki/Weighted_arithmetic_mean#Mathematical_definition
# First take differences in angles
phis = np.arctan2(np.real(eigvects[modenum, yinds]), np.real(eigvects[modenum, xinds]))
print 'phis = ', phis
phis = np.mod(phis, np.pi * 2)
print 'phis = ', phis
# Now convert to vectors, take mean of both x and y components. Then grab atan2(y,x) of result.
xx, yy = np.mean(np.cos(np.diff(phis))), np.mean(np.sin(np.diff(phis)))
dphi = np.arctan2(yy, xx)
print 'dphi = ', dphi
colors.append(dphi)
# sys.exit()
pp = PatchCollection(patches, alpha=0.4, cmap=cmap)
pp.set_array(np.array(colors))
eax.add_collection(pp)
pp.set_clim([-np.pi, np.pi])
cbar = fig.colorbar(pp, cax=cax)
# Store this current eigvector as 'previous_ev'
previous_ev = eigvects[modenum]
# Plot where in evolution we are tracking
ngyros = int(np.shape(eigvals)[1] * 0.5)
halfev = eigvals[:, ngyros:]
for row in halfev.T:
ax1.loglog(np.abs(kvals), row, 'b-')
trackmark = ax1.plot(np.abs(kval), np.abs(np.imag(eigval))[modenum], 'ro')
ax1.set_xlabel(r"vertex coupling, $\Omega_k'$")
ax1.set_ylabel(r"frequency, $\omega$")
eax.xaxis.set_ticks([])
eax.yaxis.set_ticks([])
cbar.set_ticks([-np.pi, 0, np.pi])
cbar.set_ticklabels([r'-$\pi$', 0, r'$\pi$'])
cbar.set_label(r'phase, $\Delta \phi$')
dos_ax.set_xlim(xmin=0)
plt.savefig(modedir + 'DOS_' + '{0:05}'.format(dmyi) + '.png', dpi=200)
# remove plotted excitation
scat_fg.remove()
scat_fg2.remove()
pp.remove()
if f_mark is not None:
f_mark.remove()
lines_12_st.remove()
eax.cla()
dmyi += 1
first = False
# Make movie
imgname = modedir + 'DOS_'
movname = modedir[:-1] + '_nkvals{0:04}'.format(nkvals)
lemov.make_movie(imgname, movname, indexsz='05', framerate=5, rm_images=True, save_into_subdir=True,
imgdir=modedir)
def save_normal_modes_haldane(haldane_lattice,
datadir='auto',
rm_images=True,
gapims_only=False,
save_into_subdir=False,
overwrite=True,
color='pr'):
"""
Plot the normal modes of a haldane model lattice with fixed pivot points and make a movie of them.
Parameters
----------
haldane_lattice : HaldaneLattice() instance
the complex-NNN hopping lattice for which to plot the normal modes
datadir: string
directory where simulation data is stored
rm_images : bool
Whether or not to delete all the images after a movie has been made of the DOS
gapims_only : bool
Whether to just plot modes near the middle of the DOS frequency range
save_into_subdir: bool
Whether to save the movie in the same sudir where the DOS/ directory (containing the frames) is placed.
"""
hlat = haldane_lattice
NP = len(hlat.lattice.xy)
print 'Getting eigenvals/vects of dynamical matrix...'
# Find eigval/vect
eigval, eigvect = hlat.get_eigval_eigvect()
t2 = hlat.t2
pin = hlat.pin
# prepare DOS output dir
if datadir == 'auto':
datadir = hlat.lp['meshfn']
if 'meshfn_exten' in hlat.lp:
exten = hlat.lp['meshfn_exten']
elif hlat.lp['dcdisorder']:
raise RuntimeError(
'lemov: Since dcdisorder is True, there should be a meshfn_exten in lp'
)
# there should be meshfn_exten defined in lp, but since there is not, we make it here
# exten = 'pin_mean' + sf.float2pstr(hlat.lp['pin']) + \
# '_pinV' + sf.float2pstr(hlat.lp['V0_pin_gauss']) + \
# '_strV' + sf.float2pstr(hlat.lp['V0_spring_gauss'])
else:
exten = ''
DOSdir = datadir + 'DOS_haldane' + exten + '/'
dio.ensure_dir(DOSdir)
#####################################
# Prepare for plotting
#####################################
print 'Preparing plot settings...'
# Options for how to color the DOS header
if color == 'pr':
ipr = hlat.get_ipr()
colorV = 1. / ipr
lw = 0
cbar_label = r'$p$'
colormap = 'viridis_r'
elif color == 'ipr':
ipr = hlat.get_ipr()
colorV = ipr
lw = 0
cbar_label = r'$p^{-1}$'
colormap = 'viridis'
elif color == 'ill':
ill = hlat.get_ill()
colorV = ill
cbar_label = r'$\lambda^{-1}$'
lw = 0
colormap = 'viridis'
else:
colorV = None
lw = 1.
cbar_label = ''
colormap = 'viridis'
print 'plotting...'
fig, DOS_ax, eig_ax = leplt.initialize_eigvect_DOS_header_plot(
eigval,
hlat.lattice.xy,
sim_type='haldane',
colorV=colorV,
colormap=colormap,
linewidth=lw,
cax_label=cbar_label,
cbar_nticks=2,
xlabel_pad=10,
ylabel_pad=10,
cbar_tickfmt='%0.3f')
dostitle = r'$V = $' + '{0:0.2f}'.format(hlat.lp['pin'])
if hlat.lp['ABDelta']:
dostitle += r'$\pm$' + '{0:0.2f}'.format(hlat.lp['ABDelta'])
elif hlat.lp['V0_pin_gauss']:
dostitle += r'$\pm \sigma$, with $\sigma = $' + '{0:0.2f}'.format(
hlat.lp['V0_pin_gauss'])
dostitle += r' $t_1=$' + '{0:0.2f}'.format(hlat.lp['t1'])
if abs(hlat.lp['t2a']) > 1e-7:
dostitle += r' $t_2=$' + '{0:0.2f}'.format(
hlat.lp['t2a']) + r'+$i$' + '{0:0.2f}'.format(hlat.lp['t2'])
else:
dostitle += r' $t_2=$' + '{0:0.2f}'.format(hlat.lp['t2'])
DOS_ax.set_title(dostitle)
hlat.lattice.plot_BW_lat(fig=fig,
ax=eig_ax,
save=False,
close=False,
axis_off=False,
title='')
#####################################
# SAVE eigenvals/vects as images
#####################################
# First check that we actually need to make the images: if rm_images == True and the movie exists, then stop if
# overwrite==False
# Construct movname
names = DOSdir.split('/')[0:-1]
# Construct movie name from datadir path string
movname = ''
for ii in range(len(names)):
if ii < len(names) - 1:
movname += names[ii] + '/'
else:
if save_into_subdir:
movname += names[ii] + '/' + names[
ii] + '_DOS' + haldane_lattice.lp['meshfn_exten']
else:
movname += names[ii]
if not (not overwrite and rm_images and glob.glob(movname + '.mov')):
done_pngs = len(glob.glob(DOSdir + 'DOS_*.png'))
# check if normal modes have already been done
if not done_pngs:
# decide on which eigs to plot
totN = len(eigval)
if gapims_only:
middle = int(round(totN * 0.25))
ngap = int(round(np.sqrt(totN)))
todo = range(middle - ngap, middle + ngap)
else:
todo = range(int(len(eigval)))
if done_pngs < len(todo):
dmyi = 0
for ii in todo:
if np.mod(ii, 50) == 0:
print 'plotting eigvect ', ii, ' of ', len(eigval)
# hlat.lattice.plot_BW_lat(fig=fig, ax=DOS_ax, save=False, close=False, axis_off=False, title='')
fig, [scat_fg, scat_fg2, p, f_mark, lines_12_st], cw_ccw = \
hlatpfns.construct_haldane_eigvect_DOS_plot(hlat.lattice.xy, fig, DOS_ax, eig_ax, eigval,
eigvect, ii, hlat.lattice.NL, hlat.lattice.KL,
marker_num=0, color_scheme='default')
plt.savefig(DOSdir + 'DOS_' + '{0:05}'.format(dmyi) +
'.png')
scat_fg.remove()
scat_fg2.remove()
p.remove()
f_mark.remove()
lines_12_st.remove()
dmyi += 1
fig.clf()
plt.close('all')
######################
# Save DOS as movie
######################
imgname = DOSdir + 'DOS_'
subprocess.call([
'./ffmpeg', '-i', imgname + '%05d.png', movname + '.mov', '-vcodec',
'libx264', '-profile:v', 'main', '-crf', '12', '-threads', '0', '-r',
'100', '-pix_fmt', 'yuv420p'
])
if rm_images:
# Delete the original images
if not save_into_subdir:
print 'Deleting folder ' + DOSdir
subprocess.call(['rm', '-r', DOSdir])
else:
print 'Deleting folder contents ' + DOSdir + 'DOS_*.png'
subprocess.call(['rm', '-r', DOSdir + 'DOS_*.png'])
def save_normal_modes_twisty(tlat,
datadir='auto',
sim_type='xywz',
rm_images=True,
save_into_subdir=False,
overwrite=True,
color='pr',
do_bc=False):
"""
Plot the normal modes of a coupled gyros with fixed pivot points and make a movie of them.
Parameters
----------
tlat : TwistyLattice instance
with attributes lp, Omg, xy_inner
datadir: string
directory where simulation data is stored
rm_images : bool
Whether or not to delete all the images after a movie has been made of the DOS
save_into_subdir: bool
Whether to save the movie in the same sudir where the DOS/ directory (containing the frames) is placed.
"""
NP = len(tlat.xy_inner)
print 'Getting eigenvals/vects of dynamical matrix...'
# Find eigval/vect
eigval, eigvect = tlat.get_eigval_eigvect()
# prepare DOS output dir
if datadir == 'auto':
datadir = tlat.lp['meshfn']
if 'meshfn_exten' in tlat.lp:
exten = tlat.lp['meshfn_exten']
else:
raise RuntimeError('No meshfn_exten in tlat.lp')
DOSdir = datadir + 'DOS' + exten + '/'
dio.ensure_dir(DOSdir)
#####################################
# Prepare for plotting
#####################################
print 'Preparing plot settings...'
# Options for how to color the DOS header
if color == 'pr' or len(tlat.lattice.xy) < 3:
ipr = tlat.get_ipr()
colorV = 1. / ipr
lw = 0
cbar_label = r'$p$'
colormap = 'viridis_r'
elif color == 'ipr':
ipr = tlat.get_ipr()
colorV = ipr
lw = 0
cbar_label = r'$p^{-1}$'
colormap = 'viridis'
elif color == 'ill':
ill = tlat.get_ill()
colorV = ill
cbar_label = r'$\lambda^{-1}$'
lw = 0
colormap = 'viridis'
else:
colorV = None
lw = 1.
cbar_label = ''
colormap = 'viridis'
print 'plotting...'
fig, DOS_ax, eig_ax = leplt.initialize_eigvect_DOS_header_plot(
eigval,
tlat.lattice.xy,
sim_type=sim_type,
colorV=colorV,
colormap=colormap,
linewidth=lw,
cax_label=cbar_label,
cbar_nticks=2,
cbar_tickfmt='%0.3f')
dostitle = r'$k = $' + '{0:0.2f}'.format(tlat.lp['kk'])
if tlat.lp['ABDelta_k']:
dostitle += r'$\pm$' + '{0:0.2f}'.format(tlat.lp['ABDelta_k'])
dostitle += r' $g = $' + '{0:0.2f}'.format(tlat.lp['gg'])
if tlat.lp['ABDelta_g']:
dostitle += r'$\pm$' + '{0:0.2f}'.format(tlat.lp['ABDelta_g'])
dostitle += r' $c = $' + '{0:0.2f}'.format(tlat.lp['cc'])
if tlat.lp['ABDelta_c']:
dostitle += r'$\pm$' + '{0:0.2f}'.format(tlat.lp['ABDelta_c'])
DOS_ax.set_title(dostitle)
tlat.lattice.plot_BW_lat(fig=fig,
ax=eig_ax,
save=False,
close=False,
axis_off=False,
title='')
# Make strings for spring, pin, k, and g values
text2show = tlat.lp['meshfn_exten'][1:]
fig.text(0.01,
0.01,
text2show,
horizontalalignment='left',
verticalalignment='bottom')
#####################################
# SAVE eigenvals/vects as images
#####################################
# First check that we actually need to make the images: if rm_images == True and the movie exists, then stop if
# overwrite==False
# Construct movname
names = DOSdir.split('/')[0:-1]
# Construct movie name from datadir path string
movname = ''
for ii in range(len(names)):
if ii < len(names) - 1:
movname += names[ii] + '/'
else:
if save_into_subdir:
movname += names[ii] + '/' + names[ii] + '_DOS'
else:
movname += names[ii]
# movname += '_DOS' + gyro_lattice.lp['meshfn_exten']
if not (not overwrite and rm_images and glob.glob(movname + '.mov')):
done_pngs = len(glob.glob(DOSdir + 'DOS_*.png'))
# check if normal modes have already been done
if not done_pngs:
# decide on which eigs to plot
todo = np.arange(len(eigval))
todo_subset = np.setdiff1d(todo, np.arange(done_pngs))
todo_subset = np.hstack((np.array([todo_subset[0]]), todo_subset))
# print 'todo = ', todo_subset
# sys.exit()
if done_pngs < len(todo):
dmyi = 0
for ii in todo_subset:
if np.mod(ii, 50) == 0:
print 'plotting eigvect ', ii, ' of ', len(eigval)
# tlat.lattice.plot_BW_lat(fig=fig, ax=DOS_ax, save=False, close=False, axis_off=False, title='')
fig, [scat_fg, scat_fg2, f_mark, polygons, tiltgons], cw_ccw = \
twistyplt.construct_eigvect_DOS_plot(tlat.xy_inner, fig, DOS_ax, eig_ax, eigval, eigvect,
ii, sim_type, tlat.NL_t, tlat.KL_t,
marker_num=0, color_scheme='default', sub_lattice=-1)
plt.savefig(DOSdir + 'DOS_' + '{0:05}'.format(ii) + '.png')
scat_fg.remove()
scat_fg2.remove()
polygons.remove()
tiltgons.remove()
# for pp in polygons:
# pp.remove()
# for tt in tiltgons:
# tt.remove()
f_mark.remove()
# plt.show()
# sys.exit()
# lines_12_st.remove()
# eig_ax.cla()
if ii > 0:
dmyi += 1
fig.clf()
plt.close('all')
print 'eigvect = ', eigvect
######################
# Save DOS as movie
######################
imgname = DOSdir + 'DOS_'
subprocess.call([
'./ffmpeg', '-i', imgname + '%05d.png', movname + '.mov', '-vcodec',
'libx264', '-profile:v', 'main', '-crf', '12', '-threads', '0', '-r',
'100', '-pix_fmt', 'yuv420p'
])
if rm_images:
# Delete the original images
if not save_into_subdir:
print 'Deleting folder ' + DOSdir
subprocess.call(['rm', '-r', DOSdir])
else:
print 'Deleting folder contents ' + DOSdir + 'DOS_*.png'
subprocess.call(['rm', '-r', DOSdir + 'DOS_*.png'])
def save_normal_modes_mass(mass_lattice,
datadir='auto',
rm_images=True,
save_into_subdir=False,
overwrite=True,
color='pr',
start_number=0):
"""
Plot the normal modes of a coupled gyros with fixed pivot points and make a movie of them.
Note that b and c are built INTO the signs of OmK and Omg.
--> b (0 -> 'hang', 1 -> 'stand').
--> c (0 -> aligned with a, 1 -> aligned with a)
Parameters
----------
mass_lattice : MassLattice instance
with attributes including .lattice, .lp, etc
datadir: string
directory where simulation data is stored
rm_images : bool
Whether or not to delete all the images after a movie has been made of the DOS
gapims_only : bool
Whether to just plot modes near the middle of the DOS frequency range
save_into_subdir: bool
Whether to save the movie in the same sudir where the DOS/ directory (containing the frames) is placed.
"""
mlat = mass_lattice
NP = len(mlat.lattice.xy)
print 'Getting eigenvals/vects of dynamical matrix...'
# Find eigval/vect
eigval, eigvect = mlat.get_eigval_eigvect()
kk = mlat.kk
mass = mlat.mass
# prepare DOS output dir
if datadir == 'auto':
datadir = mlat.lp['meshfn']
if 'meshfn_exten' in mlat.lp:
exten = mlat.lp['meshfn_exten']
elif mlat.lp['dcdisorder']:
# there should be meshfn_exten defined in lp, but since there is not, we make it here
if 'V0_pin_gauss' in mlat.lp:
if mlat.lp['V0_pin_gauss'] > 0:
exten = '_pinV' + sf.float2pstr(mlat.lp['V0_pin_gauss']) + \
'_strV' + sf.float2pstr(mlat.lp['V0_spring_gauss'])
if 'V0_pin_flat' in mlat.lp:
if mlat.lp['V0_pin_flat'] > 0:
exten = '_pinVf' + sf.float2pstr(mlat.lp['V0_pin_flat']) + \
'_strVf' + sf.float2pstr(mlat.lp['V0_spring_flat'])
else:
exten = ''
DOSdir = datadir + 'DOS' + exten + '/'
dio.ensure_dir(DOSdir)
#####################################
# Prepare for plotting
#####################################
# Options for how to color the DOS header
if color == 'pr':
ipr = mlat.get_ipr()
colorV = 1. / ipr
lw = 0
cbar_label = r'$p$'
colormap = 'viridis_r'
elif color == 'ipr':
ipr = mlat.get_ipr()
colorV = ipr
lw = 0
cbar_label = r'$p^{-1}$'
colormap = 'viridis'
elif color == 'ill':
ill = mlat.get_ill()
colorV = ill
cbar_label = r'$\lambda^{-1}$'
lw = 0
colormap = 'viridis'
else:
colorV = None
lw = 1.
cbar_label = ''
colormap = 'viridis'
print 'plotting...'
# print 'lemov: eigval = ', eigval
# plt.plot(np.arange(len(eigval)), eigval, '.-')
# plt.show()
# sys.exit()
fig, DOS_ax, eig_ax = leplt.initialize_eigvect_DOS_header_plot(
eigval,
mlat.lattice.xy,
sim_type='mass',
colorV=colorV,
colormap=colormap,
linewidth=lw,
cax_label=cbar_label,
cbar_nticks=2,
cbar_tickfmt='%0.3f')
dostitle = r'$m = $' + '{0:0.2f}'.format(mlat.lp['mass'])
if mlat.lp['ABDelta']:
dostitle += r'$\pm$' + '{0:0.2f}'.format(mlat.lp['ABDelta'])
dostitle += r' $k=$' + '{0:0.2f}'.format(mlat.lp['kk'])
DOS_ax.set_title(dostitle)
mlat.lattice.plot_BW_lat(fig=fig,
ax=eig_ax,
save=False,
close=False,
axis_off=False,
title='')
#####################################
# SAVE eigenvals/vects as images
#####################################
# First check that we actually need to make the images: if rm_images == True and the movie exists, then stop if
# overwrite==False
# Construct movname
names = DOSdir.split('/')[0:-1]
# Construct movie name from datadir path string
movname = ''
for ii in range(len(names)):
if ii < len(names) - 1:
movname += names[ii] + '/'
else:
if save_into_subdir:
movname += names[ii] + '/' + names[ii] + '_DOS'
else:
movname += names[ii]
# movname += '_DOS' + gyro_lattice.lp['meshfn_exten']
if not (not overwrite and rm_images and glob.glob(movname + '.mov')):
done_pngs = len(glob.glob(DOSdir + 'DOS_*.png'))
# check if normal modes have already been done
if not done_pngs:
# decide on which eigs to plot
totN = len(eigval)
todo = range(int(round(len(eigval))))
if done_pngs < len(todo):
dmyi = 0
for ii in todo:
if np.mod(ii, 50) == 0:
print 'plotting eigvect ', ii, ' of ', len(eigval)
# mlat.lattice.plot_BW_lat(fig=fig, ax=DOS_ax, save=False, close=False, axis_off=False, title='')
fig, [scat_fg, scat_fg2, p, f_mark, lines_12_st], cw_ccw = \
leplt.construct_eigvect_DOS_plot(mlat.lattice.xy, fig, DOS_ax, eig_ax, eigval, eigvect,
ii, 'mass', mlat.lattice.NL, mlat.lattice.KL,
marker_num=0, color_scheme='default', sub_lattice=-1)
plt.savefig(DOSdir + 'DOS_' + '{0:05}'.format(dmyi) +
'.png')
scat_fg.remove()
scat_fg2.remove()
p.remove()
f_mark.remove()
lines_12_st.remove()
dmyi += 1
fig.clf()
plt.close('all')
######################
# Save DOS as movie
######################
imgname = DOSdir + 'DOS_'
subprocess.call([
'./ffmpeg', '-i', imgname + '%05d.png', movname + '.mov', '-vcodec',
'libx264', '-profile:v', 'main', '-crf', '12', '-threads', '0', '-r',
'100', '-pix_fmt', 'yuv420p', '-start_number',
str(start_number)
])
if rm_images:
# Delete the original images
if not save_into_subdir:
print 'Deleting folder ' + DOSdir
subprocess.call(['rm', '-r', DOSdir])
else:
print 'Deleting folder contents ' + DOSdir + 'DOS_*.png'
subprocess.call(['rm', '-r', DOSdir + 'DOS_*.png'])
def dispersion_abtransition(lp,
save_plots=True,
return_omegas=False,
abvals=None,
fullspectrum=False):
"""
Parameters
----------
lp : dictionary
lattice parameter dictionary
return_omegas : bool
Return a list of the frequencies in the dispersion
abvals : n x 1 float array or list
The Delta_AB values for each spectrum
Returns
-------
"""
# prepare the values of inversion symmetry breaking
if abvals is None:
# abvals = np.arange(0, 2.4, 0.1)
abvals = np.arange(0, 1.0, 0.025)
# Prepare magnetic gyro lattice
meshfn = le.find_meshfn(lp)
lp['meshfn'] = meshfn
lpmaster = copy.deepcopy(lp)
# create a place to put images
outdir = dio.prepdir(
meshfn) + 'dispersion_abtransition_aol' + sf.float2pstr(
lp['aoverl']) + '/'
dio.ensure_dir(outdir)
fs = 20
if return_omegas:
omegas_out = []
kx_out = []
ky_out = []
# go through each ab and make the image
ii = 0
for ab in abvals:
lp = copy.deepcopy(lpmaster)
lp['ABDelta'] = ab
lat = lattice_class.Lattice(lp)
lat.load(check=lp['check'])
glat = MagneticGyroLattice(lat, lp)
# glat.get_eigval_eigvect(attribute=True)
fig, ax = leplt.initialize_portrait(ax_pos=[0.12, 0.2, 0.76, 0.6])
omegas, kx, ky = glat.infinite_dispersion(save=False,
nkxvals=50,
nkyvals=50,
outdir=outdir,
save_plot=False)
if return_omegas:
omegas_out.append(omegas)
kx_out.append(kx)
ky_out.append(ky)
if save_plots:
# plot and save it
title = r'$\Delta_{AB} =$' + '{0:0.2f}'.format(ab)
for jj in range(len(ky)):
for kk in range(len(omegas[0, jj, :])):
ax.plot(kx,
omegas[:, jj, kk],
'k-',
lw=max(0.5, 30. / (len(kx) * len(ky))))
ax.set_title(title, fontsize=fs)
ax.set_xlabel(r'$k$ $[\langle \ell \rangle ^{-1}]$', fontsize=fs)
ax.set_ylabel(r'$\omega$', fontsize=fs)
for tick in ax.xaxis.get_major_ticks():
tick.label.set_fontsize(fs)
for tick in ax.yaxis.get_major_ticks():
tick.label.set_fontsize(fs)
if ii == 0:
ylims = ax.get_ylim()
if fullspectrum:
ax.set_ylim(-ylims[1] * 1.2, ylims[1] * 1.2)
else:
ax.set_ylim(0., ylims[1] * 1.2)
# Save it
name = outdir + 'dispersion{0:04d}'.format(ii)
plt.savefig(name + '.png', dpi=300)
plt.close('all')
ii += 1
# Save a movie of the dispersions
movname = dio.prepdir(
meshfn) + 'dispersion_abtrans' + glat.lp['meshfn_exten']
if save_plots:
# Turn images into a movie
imgname = outdir + 'dispersion'
lemov.make_movie(imgname,
movname,
indexsz='04',
framerate=4,
imgdir=outdir,
rm_images=True,
save_into_subdir=True)
if return_omegas:
# Save the gap bounds and return the arrays of kx, ky, and omega
omegas, kx, ky = np.array(omegas_out), np.array(kx_out), np.array(
ky_out)
# Get gap bounds:
botmin = []
botmax = []
topmin = []
topmax = []
for band in omegas:
botmin.append(np.min(band[:, :, 2]))
botmax.append(np.max(band[:, :, 2]))
topmin.append(np.min(band[:, :, 3]))
topmax.append(np.max(band[:, :, 3]))
botmin = np.array(botmin)
botmax = np.array(botmax)
topmin = np.array(topmin)
topmax = np.array(topmax)
gapbounds = np.dstack((abvals, botmin, botmax, topmin, topmax))[0]
outfn = movname + '_gapbounds.txt'
print 'saving to ', outfn
header = 'Delta_AB, band min frequency, band max frequency, band 2 min, band 2 max...'
np.savetxt(outfn, gapbounds, header=header)
plot_gapbounds(abvals, gapbounds, movname + '_gapbounds.png', lp)
return omegas, kx, ky
else:
return None
def draw_edge_localization_plots(glat, elocz, eigval, eigvect, outdir=None, alpha=1.0, fontsize=12):
"""Draw plots of each normal mode excitation with colormap behind it denoting the fitted exponential localization
Parameters
----------
glat : GyroLattice instance
The gyro lattice whose modes we plot
elocz : NP x 5 float array (ie, int(len(eigval)*0.5) x 5 float array)
edge localization fit details: A, K, uncertainty_A, covariance_AK, uncertainty_K
eigval : 2*N x 1 complex array
eigenvalues of the matrix, sorted by order of imaginary components
eigvect : typically 2*N x 2*N complex array
eigenvectors of the matrix, sorted by order of imaginary components of eigvals
Eigvect is stored as NModes x NP*2 array, with x and y components alternating, like:
x0, y0, x1, y1, ... xNP, yNP.
outdir : str or None
the output directory to use for saving localization plots. If None, uses pwd as ouput dir
alpha : float
The opacity of the excitation ellipses
fontsize : int
The fontsize to use for labels, etc
Returns
-------
fig, dos_ax, ax
"""
if outdir is None:
print 'Outputting images in current working directory...'
outdir = './'
else:
dio.ensure_dir(outdir)
ipr = glat.get_ipr()
# Get third largest value for ipr vmax
# ipr_vmax = np.max(1. / ipr.sort())[3]
ipr_vmax = float(np.floor(10 * heapq.nlargest(6, 1. / ipr)[-1])) / 10.
inds = np.arange(int(0.5 * len(eigval)), len(eigval))
fig, dos_ax, ax = leplt.initialize_eigvect_DOS_header_plot(eigval[inds], glat.lattice.xy,
sim_type='gyro',
preset_cbar=True,
colorV=1. / ipr[inds], colormap='viridis_r',
norm=None,
facecolor='#80D080', nbins=75, fontsize=fontsize,
vmin=0.0, vmax=ipr_vmax,
linewidth=0,
make_cbar=True, climbars=True,
xlabel='Oscillation frequency $\omega/\Omega_g$',
ylabel=r'$D(\omega)$', ylabel_pad=20,
cax_label=r'$p$',
cbar_labelpad=10, ticks=[0., ipr_vmax],
cbar_nticks=None,
cbar_tickfmt=None,
orientation='vertical', cbar_orientation='vertical',
invert_xaxis=False, yaxis_tickright=False,
yaxis_ticks=None, ylabel_right=False, ylabel_rot=0,
DOSexcite=None, DOSexcite_color='r')
# Make axis for showing quality of fit
x0 = 0.1
y0 = 0.2
w = 0.8
h = 0.2
ax.set_position([x0, y0, w, h])
eax_w = 0.5
eax_h = 0.15
eax_x0 = x0 + (w - eax_w) * 0.5
eax_y0 = y0 + h * 1.7
exp_ax = fig.add_axes([eax_x0, eax_y0, eax_w, eax_h])
glat.lattice.plot_BW_lat(fig=fig, ax=ax, meshfn='none', save=False, close=False, axis_off=True, title='')
# If fully periodic, escape
if glat.lp['periodicBC'] and not glat.lp['periodic_strip']:
# There are two periodic vectos, so there can be no boundary --> exit with error
raise RuntimeError('Cannot compute distance to boundary in a periodic sample --> there is no boundary.')
# Compute magnitude of excitation at each site
magevecs = glat.calc_magevecs(eigvect)
# Also get distance of each particle from boundary
bndry_segs = glat.lattice.get_boundary_linesegs()
if isinstance(bndry_segs, tuple):
xydists = []
for bsegii in bndry_segs:
xydists.append(linesegs.mindist_from_multiple_linesegs(glat.lattice.xy, bsegii))
# Convert list xydists into NP x 2 array
xydists = np.dstack(tuple(xydists))[0]
else:
# There is only one boundary, so use lattice boundary to connect consecutive linesegments
xydists = linesegs.mindist_from_multiple_linesegs(glat.lattice.xy, bndry_segs)
# Check if there are multiple boundaries
multiple_boundaries = len(np.shape(xydists)) > 1
# Get the xlims and ylims for plotting the exponential decay fit
xlims_fit = [-0.1, np.max(xydists.ravel()) + 1]
xlims = [np.min(glat.lattice.xy[:, 0]) - 1, np.max(glat.lattice.xy[:, 0]) + 1]
ylims = [np.min(glat.lattice.xy[:, 1]) - 1, np.max(glat.lattice.xy[:, 1]) + 1]
# defining dmyi to be -1 so that the zeroth frame (first one saved) gets done twice to fix formatting
dmyi = -1
# Look at all states with positive frequency
todo = np.hstack((np.array([int(len(eigval) * 0.5)]), np.arange(int(len(eigval) * 0.5), len(eigval))))
for en in todo:
if en % 10 == 0:
print 'glat_plottingfns: eigval = ', dmyi, '/', len(todo)
# magind is the index of current eigval as seen by an array that knows only about the top half of
# the eigenvectors.
magind = int(en - len(eigval) * 0.5)
fig, [scat_fg, pp, f_mark, lines12_st] =\
leplt.plot_eigvect_excitation(glat.lattice.xy, fig, dos_ax, ax, eigval, eigvect, en,
marker_num=0, black_t0lines=True)
locz = elocz[magind]
if multiple_boundaries:
localz_handle = plot_edge_localization_heatmap_periodicstrip(locz, bndry_segs, ax, xlims=xlims,
ylims=ylims, alpha=1.0)
title = ax.get_title()
# Draw the exponential localization fit
plt_handle, fit_handle = plot_localization_dists(locz, xydists[:, int(locz[5] % 2)], magevecs[magind],
exp_ax, xlims=xlims_fit)
else:
# assuming no periodicity
# Plot heat map for decay from min distance to any boundary segments
localz_handle = plot_edge_localization_heatmap(locz, bndry_segs, ax, xlims=xlims, ylims=ylims, alpha=1.0)
title = ax.get_title()
# Draw the exponential localization fit
# If there are multiple boundaries, pick out the one that distances are fit from
if len(np.shape(xydists)) > 1:
xydists_temp = xydists[:, int(locz[5] % 2)]
else:
xydists_temp = xydists
plt_handle, fit_handle = plot_localization_dists(locz, xydists_temp, magevecs[en], exp_ax, xlims=xlims_fit)
ax.set_title(title + r', $|\psi(r)| \approx$ $($' +
'{0:0.3f}'.format(locz[0]) + r'$\pm$' + '{0:0.3f}'.format(locz[2]) + r'$)$ ' +
r'$\exp[($' + '{0:0.3f}'.format(locz[1]) + r'$\pm$' + '{0:0.3f}'.format(locz[4]) + '$)\, r]$',
fontsize=fontsize)
# labels for the localization fit
exp_ax.set_xlabel('Distance from boundary, $x$', fontsize=12)
exp_ax.set_ylabel('Excitation, $|\psi|$', fontsize=12)
# Save this image
if en % 10 == 0:
print 'saving image to ', outdir + 'localization' + glat.lp['meshfn_exten'] + \
'_{0:06d}'.format(max(0, dmyi)) + '.png'
plt.savefig(outdir + 'localization' + glat.lp['meshfn_exten'] + '_{0:06d}'.format(max(0, dmyi)) + '.png')
# cleanup
localz_handle.remove()
scat_fg.remove()
pp.remove()
f_mark.remove()
lines12_st.remove()
exp_ax.cla()
del localz_handle
del scat_fg
del pp
del f_mark
del lines12_st
dmyi += 1
return fig, dos_ax, ax
print '\n\nWe are on Midway!\n\n\n\n'
rootdir = '/home/npmitchell/scratch-midway/'
cprootdir = '/home/npmitchell/scratch-midway/'
elif socket.gethostname()[0:10] == 'nsit-dhcp-':
rootdir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/'
cprootdir = '/Volumes/research4TB/Soft_Matter/GPU/'
elif socket.gethostname() == 'Messiaen.local':
rootdir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/'
cprootdir = '/Volumes/research4TB/Soft_Matter/GPU/'
if not glob.glob(cprootdir):
cprootdir = '/Volumes/research2TB/Soft_Matter/GPU/'
if not glob.glob(cprootdir):
cprootdir = '/Users/npmitchell/Desktop/data_local/GPU/'
if not glob.glob(cprootdir):
if not glob.glob(cprootdir):
dio.ensure_dir(cprootdir)
elif socket.gethostname()[0:5] == 'cvpn-':
rootdir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/'
cprootdir = '/Volumes/research2TB/Soft_Matter/GPU/'
else:
rootdir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/'
lp = {
'LatticeTop': args.LatticeTop,
'shape': shape,
'NH': NH,
'NV': NV,
'NP_load': args.NP_load,
'rootdir': rootdir,
'phi_lattice': args.phi_lattice,
'delta_lattice': '{0:0.3f}'.format(args.delta_lattice),
import lepm.structure as struct
nksteps = 200
klim_frac = 0.1
LL = (float(nh), float(nv))
print 'LL = ', LL
gammav = np.arange(0.1, 1., 0.2)
epsv = [1e-15, 1e-11, 1e-7, 1e-3, 1., 10]
colorv = lecmaps.husl_palette(len(epsv))
# Naming
seriesname = 'structure/nksteps{0:03d}'.format(nksteps) + '_sz{0:04d}'.format(nh) + '{0:04d}'.format(nv) + \
'_klim' + sf.float2pstr(klim_frac) + 'LL'
caloutdir = args.rootdir + 'calibration/' + seriesname + '/'
datoutdir = args.rootdir + 'calibration_data/' + seriesname + '/'
dio.ensure_dir(caloutdir)
dio.ensure_dir(datoutdir)
kk = 0
for gamma in gammav:
kk = 0
ymax = 0.
fig, ax = leplt.initialize_1panel_fig(wsfrac=0.45,
hsfrac=0.35,
y0frac=0.14,
x0frac=0.17)
for eps in epsv:
fn = datoutdir + 'gamma' + sf.float2pstr(
gamma) + '_epsilon{0:0.0e}'.format(eps) + '.pkl'
globfn = glob.glob(fn)
if globfn:
def save_chern(self):
# Make output directories
print 'saving chern to: ', self.cp['cpmeshfn']
dio.ensure_dir(self.cp['cpmeshfn'])
# if self.params_regs or self.contribs is not None:
# dio.ensure_dir(self.cp['cpmeshfn'] + 'params_regs/')
# if self.contribs is not None:
# dio.ensure_dir(self.cp['cpmeshfn'] + 'contribs/')
# Save the chern calculation to cp['cpmeshfn']
if self.chern_finsize is None:
raise RuntimeError(
'Cannot save chern calculation since it has not been computed!'
)
# Save chern parameters
fn = self.cp['cpmeshfn'] + 'chern_params.txt'
header = 'Parameters for chern calculation'
dio.save_dict(self.cp, fn, header)
# Save chern_finsize
fn = self.cp['cpmeshfn'] + 'chern_finsize.txt'
header = 'Nreg1, ksize_frac, ksize, ksys_size (note this is NP_summed), ksys_frac, nu' + \
'for Chern calculation: basis=' + \
self.cp['basis'] + ' pin=' + '{0:0.3f}'.format(self.haldane_lattice.lp['pin']) + \
' V0_pin_gauss=' + '{0:0.3f}'.format(self.haldane_lattice.lp['V0_pin_gauss']) + \
' t1=' + '{0:0.3f}'.format(self.haldane_lattice.lp['t1']) +\
' t2=' + '{0:0.3f}'.format(self.haldane_lattice.lp['t2'])
print 'saving chern_finsize to ', fn
np.savetxt(fn, self.chern_finsize, delimiter=',', header=header)
# Save chern_finsize as a plot
plt.clf()
plt.plot(self.chern_finsize[:, -2], self.chern_finsize[:, -1], 'o-')
plt.title('Chern number versus system size')
plt.xlabel('Fraction of system size in sum')
plt.ylabel('Chern number')
plt.savefig(self.cp['cpmeshfn'] + 'chern_finsize_ksizeSum.png')
plt.close('all')
# Save kitaev region parameters for each ksize
# if self.params_regs or self.contribs is not None:
# for ksize in self.params_regs:
# header = 'Indices of kitaev regions: ksize = ' + sf.prepstr(ksize)
# fn = self.cp['cpmeshfn']+'params_regs/params_regs_ksize' + sf.prepstr(ksize) + '.txt'
# dio.save_dict(self.params_regs[ksize], fn, header)
#
# print 'saved (many) params_regs. Last one was:', fn
# Save kitaev region parameters as pkl
with open(self.cp['cpmeshfn'] + 'params_regs.pkl', "wb") as fn:
pickle.dump(self.params_regs, fn)
# Save lattice parameters too for convenience (gives info about disorder, spinning speeds etc)
print 'saving lattice_params...'
header = 'Lattice parameters, copied from meshfn: ' + self.haldane_lattice.lp[
'meshfn']
dio.save_dict(self.haldane_lattice.lp,
self.cp['cpmeshfn'] + 'lattice_params.txt', header)
if self.contribs is not None:
# Save kitaev region parameters for each ksize
# for ksize in self.contribs:
# header = 'Saving contribs for ksize = ' + sf.prepstr(ksize)
# fn = self.cp['cpmeshfn'] + 'contribs/contribs_ksize' + sf.prepstr(ksize) + '.txt'
# dio.save_dict(self.contribs[ksize], fn, header)
with open(self.cp['cpmeshfn'] + 'contribs.pkl', "wb") as fn:
pickle.dump(self.contribs, fn)
def calc_chern(matk,
cp,
lattice,
appendstr=None,
verbose=True,
bz_cutoff=1e14,
kxy=None,
overwrite=False,
signed_norm=False):
"""Compute the chern number using the wedge product of the projector
Parameters
----------
kchern : KChernGyro class instance
kspace Chern calculation class
bz_cutoff : float
if BZ has a dimension larger than bz_cutoff, then we return zero chern number and no bands
Returns
-------
kchern.chern
"""
# this is really the only function you need to change to do a different kind of lattice.
# mM, vertex_points, od, fn, ar = lf.honeycomb_sheared(tvals, delta, phi, ons, base_dir)
# matk = glatkfns.lambda_matrix_kspace(kchern.gyro_lattice, eps=1e-10)
bzvtcs = lattice.get_bz(attribute=True)
# Define the brillouin zone polygon
bzarea = dh.polygon_area(bzvtcs)
# Check if a similar results file exists --> new data is appended to the old data, if it exists
savedir = cp['cpmeshfn']
dio.ensure_dir(savedir)
savefn, cp, search_density_fn = prepare_chern_filename(cp,
appendstr=appendstr)
print 'established savefn: ', cp['savefn']
if kxy is None:
globs = sorted(glob.glob(search_density_fn))
# Obtain the filename with the density that is smaller than the requested one
if globs and not overwrite:
densities = np.array([
int(
globfn.split('density')[-1].split('.pkl')[0].split('_')[0])
for globfn in globs
])
if (densities < cp['density']).any():
biggestsmall = densities[densities < cp['density']][-1]
smallerfn = savedir + 'kspacechern_density{0:07d}'.format(
biggestsmall)
if cp['ortho']:
smallerfn += '_ortho'
if 'deriv_res' in cp:
if cp['deriv_res'] != 1e-5:
smallerfn += '_dres{0:0.3e}'.format(
cp['deriv_res']).replace('-',
'n').replace('.', 'p')
smallerfn += appendstr
smallerfn += '.pkl'
else:
smallerfn = False
else:
smallerfn = False
if verbose:
print 'kchern_gyro_fns: looking for saved file ' + savefn
if os.path.isfile(savefn) and overwrite:
if verbose:
print 'kchern_gyro_fns: chern file exists, overwriting: ', savefn
# initialize empty lists to be filled up
kkx, kky = [], []
bands, traces = [], []
npts = int(cp['density'] * bzarea)
elif os.path.isfile(savefn):
# File of same size exists
chern = load_chern(cp, appendstr=appendstr, verbose=True)
print 'generalized_kchern_fns: loaded chern, returning chern'
return chern
elif smallerfn:
if verbose:
print 'kchern_gyro_fns: chern file with smaller density exists, loading to append...'
with open(smallerfn, 'rb') as of:
data = pkl.load(of)
# Convert contents to lists so that we can append to them
bands = list(data['bands'])
kkx = list(data['kx'])
kky = list(data['ky'])
traces = list(data['traces'])
# figure out how many points to append to reach desired density
npts = int(cp['density'] * bzarea) - len(kkx)
else:
if verbose:
print 'generalized_kchern_fns: no chern file with smaller density exists, computing from scratch...'
# initialize empty lists to be filled up
kkx, kky = [], []
bands, traces = [], []
npts = int(cp['density'] * bzarea)
# Make the kx, ky points to add to current results
# Handle cases where the BZ is too elongated to populate in reasonable time
try:
kxy = dh.generate_random_xy_in_polygon(npts, bzvtcs, sorted=True)
if len(kxy) == 0:
if (bzvtcs > bz_cutoff).any():
print 'The BZ is too large to fill with kvec points'
kkx, kky = np.zeros(10), np.zeros(10)
bv = np.zeros(2 * len(lattice.xy[:, 0]))
bands = np.nan * np.ones(2 * len(lattice.xy[:, 0]))
traces = np.nan * np.ones((2 * len(lattice.xy[:, 0]), 10))
dat_dict = {
'kx': kkx,
'ky': kky,
'chern': bv,
'bands': bands,
'traces': traces,
'bzvtcs': bzvtcs
}
chern = dat_dict
return chern
else:
print 'generalized_kchern_fns: bzvtcs = ', bzvtcs
print 'generalized_kchern_fns: kxy = ', kxy
raise RuntimeError(
'Could not generate random xy in polygon, but BZ is not larger than cutoff in any dim.'
)
except ValueError:
print 'The BZ is too large to fill with kvec points'
if (np.abs(bzvtcs) > bz_cutoff).any():
print 'The BZ is too large to fill with kvec points'
kkx, kky = np.zeros(10), np.zeros(10)
bv = np.zeros(2 * len(lattice.xy[:, 0]))
bands = np.nan * np.ones(2 * len(lattice.xy[:, 0]))
traces = np.nan * np.ones((2 * len(lattice.xy[:, 0]), 10))
dat_dict = {
'kx': kkx,
'ky': kky,
'chern': bv,
'bands': bands,
'traces': traces,
'bzvtcs': bzvtcs
}
chern = dat_dict
return chern
else:
print 'kchern_gyro_fns: bzvtcs = ', bzvtcs
print 'bz_cutoff = ', bz_cutoff
# print 'generalized_kchern_fns: kxy = ', kxy
raise RuntimeError(
'Could not generate random xy in polygon, but BZ is not larger than cutoff in any dim.'
)
dat_dict = {
'kx': kkx,
'ky': kky,
'chern': bv,
'bands': bands,
'traces': traces,
'bzvtcs': bzvtcs
}
else:
# kxy is supplied -- compute at those locations
print 'kxy is supplied, computing berry at supplied points'
kkx, kky = [], []
bands, traces = [], []
start_time = time.time()
for ii in range(len(kxy)):
# time for evaluating point index ii
tpi = []
# Display how much time is left
if ii % 4000 == 1999 and verbose:
end_time = time.time()
tpi.append(abs((start_time - end_time) / (ii + 1)))
total_time = np.mean(tpi) * len(kxy)
printstr = 'Estimated time remaining: ' + '%0.2f s' % (
total_time - (end_time - start_time))
printstr += ', ii = ' + str(ii + 1) + '/' + str(len(kxy))
print printstr
eigval, tr = calc_bands(matk,
kxy[ii, 0],
kxy[ii, 1],
h=cp['deriv_res'],
ortho=cp['ortho'],
signed_norm=signed_norm)
kkx.append(kxy[ii, 0])
kky.append(kxy[ii, 1])
traces.append(tr)
bands.append(eigval)
bands = np.array(bands)
traces = np.array(traces)
kkx = np.array(kkx)
kky = np.array(kky)
bv = []
if verbose:
print 'kchern_gyro_fns: np.shape(bands) = ', np.shape(bands)
print 'kchern_gyro_fns: np.shape(traces) = ', np.shape(traces)
for ii in range(len(bands[0])):
chern = ((1j / (2. * np.pi)) * np.mean(traces[:, ii]) * bzarea
) # chern numbers for bands
bv.append(chern)
dat_dict = {
'kx': kkx,
'ky': kky,
'chern': bv,
'bands': bands,
'traces': traces,
'bzvtcs': bzvtcs
}
chern = dat_dict
return chern
def le_plot_gHST(xy, NL, KL, BM, params, t, ii, name, outdir, climv=0.1, xlimv='auto',
exaggerate=1.0, PlanarLimit=False):
"""Plots a gliding heavy symmetric top network
Parameters
----------
xy : NP x 5 array
positions of pivots (x,y) and euler angles for all HSTs
t : float
time stamp for image
ii : int
index for naming
name : string
the name of the file (before _index.png)
outdir : string
The output directory for the image
climv : float or tuple
Color limit for coloring bonds by bond strain
xlimv
exaggerate : float (default 1.0 --> in which case it is ignored)
Exaggerate the displacements of each particle from its initial position by this factor. Ignored if == 1.0
PlanarLimit : bool
Returns
----------
"""
# make output dir
outdir = dio.prepdir(outdir)
dio.ensure_dir(outdir)
# set range of window from first values
if xlimv == 'auto':
xlimv = params['xlimv']
ylimv = xlimv
# save current data as stills
index = '{0:08d}'.format(ii)
outname = outdir + '/' + name + '_' + index + '.png'
BL = NL2BL(NL, KL)
if 'prestrain' in params:
prestrain = params['prestrain']
else:
prestrain = 0.
if 'shrinkrate' in params:
shrinkrate = params['shrinkrate']
title = 't = ' + '%09.1f' % t + ' a = ' + '%07.5f' % (1. - shrinkrate * t - prestrain)
elif 'prestrain' in params:
shrinkrate = 0.0
title = 't = ' + '%09.1f' % t + ' a = ' + '%07.5f' % (1. - prestrain)
else:
shrinkrate = 0.0
title = 't = ' + '%09.1f' % t
if exaggerate != 1.0:
title += ' magnify=' + str(exaggerate)
if 'Omg' in params:
title += '\n' + r'$\Omega_g$=' + '{0:.3f}'.format(params['Omg'])
if 'OmK' in params:
title += r' $\Omega_k$=' + '{0:.3f}'.format(params['OmK'])
if 'g' in params:
gstr = str(params['g'])
if len(gstr.split('.')[1]) > 3:
gstr = '{0:.3f}'.format(params['g'])
title += '\n' + r'$g$=' + gstr
if 'k' in params:
kstr = str(params['k'])
if len(kstr.split('.')[1]) > 3:
kstr = '{0:.3f}'.format(params['k'])
title += r' $k$=' + kstr
if 'Mm' in params:
try:
mstr = str(params['Mm'][0])
if len(mstr.split('.')[1]) > 3:
mstr = '{0:.3f}'.format(params['Mm'][0])
title += r' $m$=' + mstr
except:
mstr = str(params['Mm'])
if len(mstr.split('.')[1]) > 3:
mstr = '{0:.3f}'.format(params['Mm'])
title += r' $m$=' + mstr
if 'l' in params:
try:
lstr = str(params['l'][0])
if len(lstr.split('.')[1]) > 3:
lstr = '{0:.3f}'.format(params['l'][0])
title += r' $l$=' + lstr
except:
lstr = str(params['l'])
if len(lstr.split('.')[1]) > 3:
lstr = '{0:.3f}'.format(params['l'])
title += r' $l$=' + lstr
if 'w3' in params:
try:
if (params['w3'] - params['w3'][0] < 1e-5).all():
wstr = str(params['w3'][0])
if len(lstr.split('.')[1]) > 3:
wstr = '{0:.3f}'.format(params['w3'][0])
title += r' $\omega_3$=' + wstr
# Otherwise, don't print w3: it is heterogeneous
except:
wstr = str(params['w3'])
if len(wstr.split('.')[1]) > 3:
wstr = '{0:.3f}'.format(params['w3'])
title += r' $\omega_3$=' + wstr
if params['BCtype'] == 'excite':
title += r' $\omega_d$=' + '{0:.5f}'.format(params['frequency'])
# calculate strain
# bs = bond_strain_list(xy,BL,bL0)
# if exaggerate==1.0:
# movie_plot_2D_gyros(xy, BL, bs, outname, title, xlimv, ylimv, climv)
# else:
# xye = xy0+(xy-xy0)*exaggerate
# movie_plot_2D_gyros(xye, BL, bs, outname, title, xlimv, ylimv, climv)
# set limits
fig = plt.gcf()
plt.clf()
ax = plt.gca()
ax.set_xlim(-xlimv, xlimv)
ax.set_ylim(-ylimv, ylimv)
if PlanarLimit:
gHST_plot_PL(xy, NL, KL, BM, params, factor=exaggerate, climv=climv, title=title)
else:
gHST_plot(xy, NL, KL, BM, params, factor=exaggerate, climv=climv, title=title)
plt.savefig(outname)
def calc_chern(kchern, verbose=True):
"""Compute the chern number using the wedge product of the projector
Parameters
----------
kchern : KChernGyro class instance
kspace Chern calculation class
Returns
-------
"""
# Unpack kchern a bit
cp = kchern.cp
# this is really the only function you need to change to do a different kind of lattice.
# mM, vertex_points, od, fn, ar = lf.honeycomb_sheared(tvals, delta, phi, ons, base_dir)
matk = glatkfns.lambda_matrix_kspace(kchern.gyro_lattice, eps=1e-10)
bzvtcs = kchern.gyro_lattice.lattice.get_bz(attribute=True)
# set the directory for saving images and data. The function above actually creates these directories for you.
# I know this isn't exaclty ideal.
bzarea = dh.polygon_area(bzvtcs)
# Check if a similar results file exists --> new data is appended to the old data, if it exists
savedir = cp['cpmeshfn']
dio.ensure_dir(savedir)
savefn = savedir + 'kspacechern_density{0:07d}.pkl'.format(cp['density'])
globs = sorted(glob.glob(savedir + 'kspacechern_density*.pkl'))
# Obtain the filename with the density that is smaller than the requested one
if globs:
densities = np.array([
int(globfn.split('density')[-1].split('.pkl')[0])
for globfn in globs
])
if (densities < cp['density']).any():
biggestsmall = densities[densities < cp['density']][-1]
smallerfn = savedir + 'kspacechern_density{0:07d}.pkl'.format(
biggestsmall)
else:
smallerfn = False
else:
smallerfn = False
if verbose:
print 'kchern_gyro_fns: looking for saved file ' + savefn
if os.path.isfile(savefn):
if verbose:
print 'kchern_gyro_fns: chern file exists, overwriting: ', savefn
# initialize empty lists to be filled up
kkx, kky = [], []
bands, traces = [], []
npts = int(cp['density'] * bzarea)
elif smallerfn:
if verbose:
print 'kchern_gyro_fns: chern file with smaller density exists, loading to append...'
with open(smallerfn, 'rb') as of:
data = pkl.load(of)
# Convert contents to lists so that we can append to them
bands = list(data['bands'])
kkx = list(data['kx'])
kky = list(data['ky'])
traces = list(data['traces'])
# figure out how many points to append to reach desired density
npts = int(cp['density'] * bzarea) - len(kkx)
else:
# initialize empty lists to be filled up
kkx, kky = [], []
bands, traces = [], []
npts = int(cp['density'] * bzarea)
# Make the kx, ky points to add to current results
kxy = dh.generate_random_xy_in_polygon(npts, bzvtcs, sorted=True)
start_time = time.time()
for ii in range(len(kxy)):
# time for evaluating point index ii
tpi = []
# Display how much time is left
if ii % 4000 == 1999 and verbose:
end_time = time.time()
tpi.append(abs((start_time - end_time) / (ii + 1)))
total_time = np.mean(tpi) * len(kxy)
printstr = 'Estimated time remaining: ' + '%0.2f s' % (
total_time - (end_time - start_time))
printstr += ', ii = ' + str(ii + 1) + '/' + str(len(kxy))
print printstr
eigval, tr = calc_bands(matk, kxy[ii, 0], kxy[ii, 1])
kkx.append(kxy[ii, 0])
kky.append(kxy[ii, 1])
traces.append(tr)
bands.append(eigval)
bands = np.array(bands)
traces = np.array(traces)
kkx = np.array(kkx)
kky = np.array(kky)
bv = []
if verbose:
print 'kchern_gyro_fns: np.shape(bands) = ', np.shape(bands)
print 'kchern_gyro_fns: np.shape(traces) = ', np.shape(traces)
for ii in range(len(bands[0])):
chern = ((1j / (2. * np.pi)) * np.mean(traces[:, ii]) * bzarea
) # chern numbers for bands
bv.append(chern)
dat_dict = {
'kx': kkx,
'ky': kky,
'chern': bv,
'bands': bands,
'traces': traces,
'bzvtcs': bzvtcs
}
kchern.chern = dat_dict
return kchern.chern
def dispersion_abtransition(lp, invert_bg=False, color1=None, color2=None, color_thres=None,
nkxvals=50, dab_step=0.005, dpi=100, plot_positive_only=True, ab_max=2.6):
"""
Parameters
----------
lp
Returns
-------
"""
if invert_bg:
plt.style.use('dark_background')
if invert_bg:
if color1 is None:
# blue
color1 = '#70a6ff'
if color2 is None:
# red
color2 = '#ff7777' # '#90354c'
# print 'color1, 2 = ', color1, color2
# sys.exit()
else:
cmap = lecmaps.diverging_cmap(250, 10, l=30)
color1 = cmap(0.)
color2 = cmap(1.)
meshfn = le.find_meshfn(lp)
lp['meshfn'] = meshfn
lpmaster = copy.deepcopy(lp)
ablist = np.arange(0, ab_max + dab_step, dab_step)
# create a place to put images
outdir = dio.prepdir(meshfn) + 'dispersion_abtransition/'
dio.ensure_dir(outdir)
fs = 20
# go through each ab and make the image
ii = 0
for ab in ablist:
print 'ab = ', ab
lp = copy.deepcopy(lpmaster)
lp['ABDelta'] = ab
lat = lattice_class.Lattice(lp)
lat.load(check=lp['check'])
glat = GyroLattice(lat, lp)
# glat.get_eigval_eigvect(attribute=True)
fig, ax = leplt.initialize_portrait(ax_pos=[0.12, 0.2, 0.76, 0.6])
omegas, kx, ky = glat.infinite_dispersion(save=False, nkxvals=nkxvals, nkyvals=50, outdir=outdir, save_plot=False)
# plot and save it
title = r'$\Delta_{AB} =$' + '{0:0.2f}'.format(ab)
for jj in range(len(ky)):
for kk in range(len(omegas[0, jj, :])):
if color_thres is None or ab > 0.26:
if invert_bg:
ax.plot(kx, omegas[:, jj, kk], 'w-', lw=max(1., 30. / (len(kx) * len(ky))))
else:
ax.plot(kx, omegas[:, jj, kk], 'k-', lw=max(1., 30. / (len(kx) * len(ky))))
else:
# if positive frequencies, color top band blue
if len(np.where(omegas[:, jj, kk] > 0)[0]) > 0.5 * len(omegas[:, jj, kk]):
# color top band blue
if len(np.where(np.abs(omegas[:, jj, kk]) > color_thres)[0]) > 0.5 * len(omegas[:, jj, kk]):
ax.plot(kx, omegas[:, jj, kk], '-', lw=max(1., 30. / (len(kx) * len(ky))), color=color1)
else:
ax.plot(kx, omegas[:, jj, kk], '-', lw=max(1., 30. / (len(kx) * len(ky))), color=color2)
# if negative frequencies, color bottom band blue
if len(np.where(omegas[:, jj, kk] < 0)[0]) > 0.5 * len(omegas[:, jj, kk]):
# color bottom band blue
if len(np.where(np.abs(omegas[:, jj, kk]) > color_thres)[0]) > 0.5 * len(omegas[:, jj, kk]):
ax.plot(kx, omegas[:, jj, kk], '-', lw=max(1., 30. / (len(kx) * len(ky))), color=color2)
else:
ax.plot(kx, omegas[:, jj, kk], '-', lw=max(1., 30. / (len(kx) * len(ky))), color=color1)
ax.text(0.5, 1.15, title, fontsize=fs, ha='center', va='center', transform=ax.transAxes)
ax.set_xlim(-np.pi, np.pi)
ax.xaxis.set_ticks([-np.pi, 0, np.pi])
ax.xaxis.set_ticklabels([r'$-\pi$', 0, r'$\pi$'])
ax.set_xlabel(r'$k_x$', fontsize=fs)
ax.set_ylabel(r'$\omega$', fontsize=fs)
for tick in ax.xaxis.get_major_ticks():
tick.label.set_fontsize(fs)
for tick in ax.yaxis.get_major_ticks():
tick.label.set_fontsize(fs)
if ii == 0:
ylims = ax.get_ylim()
if plot_positive_only:
ax.set_ylim(0., ylims[1])
else:
ax.set_ylim(ylims[0], ylims[1])
# Save it
name = outdir + 'dispersion{0:04d}'.format(ii)
plt.savefig(name + '.png', dpi=dpi)
plt.close('all')
ii += 1
# Turn images into a movie
imgname = outdir + 'dispersion'
movname = dio.prepdir(meshfn) + 'dispersion_abtrans' + glat.lp['meshfn_exten']
lemov.make_movie(imgname, movname, indexsz='04', framerate=10, imgdir=outdir, rm_images=True,
save_into_subdir=True)
