# Define description of the network topology
if args.LatticeTop == 'iscentroid':
description = 'voronoized jammed'
elif args.LatticeTop == 'kagome_isocent':
description = 'kagomized jammed'
elif args.LatticeTop == 'hucentroid':
description = 'voronoized hyperuniform'
elif args.LatticeTop == 'kagome_hucent':
description = 'kagomized hyperuniform'
elif args.LatticeTop == 'kagper_hucent':
description = 'kagome decoration percolation'
rootdir = '/Users/npmitchell/Dropbox/Soft_Matter/GPU/'
outdir = rootdir + 'experiments/DOS_scaling/' + args.LatticeTop + '/'
le.ensure_dir(outdir)
lp = {
'LatticeTop': args.LatticeTop,
'NH': NH,
'NV': NV,
'rootdir': rootdir,
'periodicBC': True,
}
# Collate DOS for many lattices
gc = gyro_collection.GyroCollection()
if args.LatticeTop == 'iscentroid':
gc.add_meshfn(
'/Users/npmitchell/Dropbox/Soft_Matter/GPU/networks/'+args.LatticeTop+'/'+\
args.LatticeTop+'_square_periodic_hexner_size'+str(args.NP_load)+'_conf*_NP*'+str(args.NP_load))
elif args.LatticeTop == 'kagome_isocent':
def projector_site_vs_dist_glatparam(gcoll,
omegac,
proj_XY,
plot_mag=True,
plot_diff=False,
save_plt=True,
alpha=1.0,
maxdistlines=True,
reverse_order=False,
check=True):
"""THIS HAS NOT BEEN UPDATED FOR BOTT INDEX SPECIFIC CALC
Compare the projector values at distances relative to a particular site (gyro at location proj_XY).
Parameters
----------
gcoll : GyroCollection instance
The collection of gyro_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 gyro and consider projector elements relative to this site.
plot : bool
Whether to plot magproj vs dist for all GyroLattices in gcoll
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.
"""
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(gcoll.gyro_lattices),
s=sat,
l=light)
if reverse_order:
glat_list = gcoll.gyro_lattices[::-1]
else:
glat_list = gcoll.gyro_lattices
for glat in glat_list:
proj_ind = ((glat.lattice.xy - proj_XY)[:, 0]**2 +
(glat.lattice.xy - proj_XY)[:, 1]**2).argmin()
outdir = dio.prepdir(glat.lp['meshfn'].replace('networks',
'projectors'))
outfn = outdir + glat.lp[
'LatticeTop'] + "_dist_singlept_{0:06d}".format(proj_ind) + ".pkl"
if check:
print 'identified proj_ind = ', proj_ind
newfig = plt.figure()
glat.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 + glat.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 = glat.lattice.xy - glat.lattice.xy[proj_ind]
dist = np.sqrt(xydiff[:, 0]**2 + xydiff[:, 1]**2)
print 'bottmagneticgyrofns: calculating projector...'
proj = calc_small_projector(glat, omegac, attribute=False)
outdir = dio.prepdir(glat.lp['meshfn'].replace(
'networks', 'projectors'))
le.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 + glat.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(glat.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] = glat.lattice.plot_numbered(fig=origfig, ax=origax, axis_off=False,
# title='Original lattice for proj comparison')
# origax.scatter(glat.lattice.xy[same_inds[0], 0], glat.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] = glat.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(glat.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(glat.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 gcoll (usually run from kitaev_collection)...'
mfig.savefig(outdir + glat.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 gcoll projecctors (usually run from kitaev_collection)...'
dfig.savefig(outdir + glat.lp['LatticeTop'] +
"_diffproj_singlept.png",
dpi=300)
dffig.savefig(outdir + glat.lp['LatticeTop'] +
"_diffproj_singlept_fractionaldiff.png",
dpi=300)
dfax.set_ylim(-0.1, 1)
dffig.savefig(outdir + glat.lp['LatticeTop'] +
"_diffproj_singlept_fractionaldiff_zoom.png",
dpi=300)
dfax.set_ylim(-0.02, 0.1)
dffig.savefig(outdir + glat.lp['LatticeTop'] +
"_diffproj_singlept_fractionaldiff_extrazoom.png",
dpi=300)
elif not plot_mag:
plt.show()
return dist_list, proj_list
save_ims = not args.skip_ims
save_DOS_ims = not args.skip_DOS_ims
save_DOS_pkl = args.save_DOS
check = args.check
checkout = args.checkout
# Use each value of N
for kk in range(len(Narr)):
if doNP:
N = Narr[kk]
else:
N = Narr[kk]
print '\nN = ', N
dataNdir = datadir + 'N_{0:03d}'.format(N) + '/'
le.ensure_dir(dataNdir)
NH = N
NV = N
Ns = min(NH, NV)
# Get polygon over which to sum
if LatticeTop in ['triangular', 'triangularz']:
dist = 1.
#else:
# # distance for NH=1 is dist
# if args.delta == '0.667':
# dist = 2.*le.polygon_apothem(1.0,6) # distance across one hexagon of bonds with bondlength=1
# else:
# a1, a2 = deformed_hexcell_to_hexagonal_sidelengths(args.delta,args.NH,args.NV)
# Make Lattice
def bond_length_histogram(xy,
NL,
KL,
BL,
PVx=[],
PVy=[],
fig=None,
ax=None,
outdir=None,
check=False,
savetxt=True):
"""Histogram the bond lengths of the lattice.
If fig or axis is not None, adds to that fig/axis.
Parameters
----------
xy : NP x 2 float array
positions of point set
NL : NP x max(#neighbors) int array
The ith row contains indices for the neighbors for the ith point
KL : NP x max(#neighbors) int array
spring connection/constant list, where 1 corresponds to a true connection,
0 signifies that there is not a connection, -1 signifies periodic bond
BL : array of dimension #bonds x 2
Each row is a bond and contains indices of connected points. Negative values denote particles connected
through periodic bonds.
PVx : NP x NN float array (optional, for periodic lattices)
ijth element of PVx is the x-component of the vector taking NL[i,j] to its image as seen by particle i
PVy : NP x NN float array (optional, for periodic lattices)
ijth element of PVy is the y-component of the vector taking NL[i,j] to its image as seen by particle i
fig : matplotlib figure instance or None
The figure in which to plot the bond length histogram. If None, uses current figure
ax : matplotlib axis instance or None
The axis in which to plot the histogram. If None, uses current axis.
outdir : string or None
The file path in which to save the figure, if not None
check : bool
Whether to view intermediate results
savetxt: bool
Whether to save the bin values and counts as a text file. Outdir must be specified for this to have an effect
when True.
Returns
----------
bL : Nbonds x 1 float array
bond lengths of the lattice
"""
if fig is None and ax is None:
close_fig = True
fig = plt.gcf()
fig.clf()
ax = plt.gca()
elif fig is None and ax is not None:
close_fig = False
fig = plt.gcf()
else:
close_fig = False
if outdir is not None:
infodir = outdir
saveout = True
le.ensure_dir(infodir)
else:
saveout = False
# Make dir for lattice info
BM = le.NL2BM(xy, NL, KL, PVx=PVx, PVy=PVy)
bL = le.BM2bL(NL, BM, BL)
nbonds, bins, patches = ax.hist(bL, bins=int(len(bL) * 0.5))
#ax.set_title('Bond Lengths')
ax.set_xlabel('Bond Length')
ax.set_ylabel('Frequency')
if saveout:
plt.savefig(infodir + 'bond_lengths.png')
if check:
plt.show()
if close_fig:
plt.clf()
if savetxt and saveout:
print 'Calling bond_length_histogram with savetxt == True'
print 'savetxt =', savetxt
# get centers of each bin
binc = 0.5 * (bins[1:] + bins[:-1])
MM = np.dstack((binc, nbonds))[0]
header = 'Bond length histogram: center of bin, number of bonds in that bin'
np.savetxt(infodir + 'bond_length_hist.txt',
MM,
fmt='%.18e %i',
header=header,
delimiter=',')
return bL, nbonds, bins
def plot_projector_locality_singlept(haldane_lattice,
proj_ind,
dists,
magproj,
ax=None,
save=True,
outdir=None,
network_str='none',
show=False,
alpha=1.0):
"""
Plot the locality of the projection operator wrt a point
Parameters
----------
haldane_lattice : HaldaneLattice instance
The network on which to characterize the projector
proj_ind : int
The haldane index to analyze wrt
dists : dists : NP x NP float array
Euclidean distances between points. Element i,j is the distance between particle i and j
magproj : NP x NP float array
Element i,j gives the magnitude of the projector connecting site i to particle j
evxymag : 2*NP x NP float array
Same as magproj, but with x and y components separate. So, element 2*i,j gives the magnitude of the x component
of the projector connecting site i to the full xy of particle j and element 2*i+1,j gives the
magnitude of the y component of the projector connecting site i to the full xy of particle j.
outdir : str or None
Path to save dists and magproj as pickles in outdir, also saves plots there
network_str : str
Description of the network for the title of the plot. If 'none', network_str = haldane_lattice.lp['LatticeTop'].
show : bool
Plot the result (forces a matplotlib close event)
alpha : float
opacity
"""
# Initialize plot
if ax is None:
fig, axes = leplt.initialize_1panel_fig(Wfig=90,
Hfig=None,
x0frac=0.15,
y0frac=0.15,
wsfrac=0.4,
hs=None,
vspace=5,
hspace=8,
tspace=10,
fontsize=8)
ax = axes[0]
if network_str is 'none':
network_str = haldane_lattice.lp['LatticeTop']
ax.scatter(dists[proj_ind],
np.log10(magproj[proj_ind]),
s=1,
color='k',
alpha=alpha)
ax.set_title('Locality of projection operator $P$\nfor ' + network_str +
' network')
ax.set_xlabel('Distance $|\mathbf{x}_i-\mathbf{x}_j|$')
ax.set_ylabel('$\log_{10} |P_{ij}|$')
if save:
if outdir is None:
outdir = le.prepdir(haldane_lattice.lp['meshfn'].replace(
'networks', 'projectors'))
le.ensure_dir(outdir)
plt.savefig(outdir + haldane_lattice.lp['LatticeTop'] +
'_projector_xy2_log_{0:06d}'.format(proj_ind) + '.png',
dpi=300)
ax.set_xlim(-0.5, 5)
ax.set_ylim(-3, 0)
plt.savefig(outdir + haldane_lattice.lp['LatticeTop'] +
'_projector_xy2_zoom_log_{0:06d}'.format(proj_ind) +
'.png',
dpi=300)
# save dists and magproj as pkl
outfn = outdir + haldane_lattice.lp[
'LatticeTop'] + "_dists_singlept_{0:06d}".format(proj_ind) + ".pkl"
with open(outfn, "wb") as fn:
pickle.dump(dists[proj_ind], fn)
with open(
outdir + haldane_lattice.lp['LatticeTop'] +
"_magproj_{0:06d}".format(proj_ind) + ".pkl", "wb") as fn:
pickle.dump(magproj[proj_ind], fn)
if show:
plt.show()
def plot_projector_locality(haldane_lattice,
dists,
magproj,
evxymag,
outdir=None,
network_str='none',
show=False,
alpha=None):
"""
Plot the locality of the projection operator
Parameters
----------
haldane_lattice : HaldaneLattice instance
The network on which to characterize the projector
dists : dists : NP x NP float array
Euclidean distances between points. Element i,j is the distance between particle i and j
magproj : NP x NP float array
Element i,j gives the magnitude of the projector connecting site i to particle j
evxymag : 2*NP x NP float array
Same as magproj, but with x and y components separate. So, element 2*i,j gives the magnitude of the x component
of the projector connecting site i to the full xy of particle j and element 2*i+1,j gives the
magnitude of the y component of the projector connecting site i to the full xy of particle j.
outdir : str or None
Path to save dists and magproj as pickles in outdir, also saves plots there
network_str : str
Description of the network for the title of the plot. If 'none', network_str = haldane_lattice.lp['LatticeTop'].
show : bool
Plot the result (forces a matplotlib close event)
alpha : float or None
opacity. If none, sets alpha = 3./len(dists)
"""
if alpha is None:
alpha = 3. / len(dists)
# Initialize plot
fig, ax = leplt.initialize_1panel_fig(Wfig=90,
Hfig=None,
x0frac=0.15,
y0frac=0.15,
wsfrac=0.4,
hs=None,
vspace=5,
hspace=8,
tspace=10,
fontsize=8)
# print 'np.shape(xymag) = ', np.shape(xymag)
for ind in range(len(dists)):
ax[0].scatter(dists[ind],
np.log10(evxymag[:, 2 * ind].ravel()),
s=1,
color='r',
alpha=alpha)
ax[0].scatter(dists[ind],
np.log10(evxymag[:, 2 * ind + 1].ravel()),
s=1,
color='b',
alpha=alpha)
if network_str is 'none':
network_str = haldane_lattice.lp['LatticeTop']
ax[0].set_title('Locality of projection operator $P$\nfor ' + network_str +
' network')
ax[0].set_xlabel('Distance $|\mathbf{x}_i-\mathbf{x}_j|$')
ax[0].set_ylabel('$|P_{ij}|$')
if outdir is None:
outdir = le.prepdir(haldane_lattice.lp['meshfn'].replace(
'networks', 'projectors'))
le.ensure_dir(outdir)
plt.savefig(outdir + haldane_lattice.lp['LatticeTop'] +
'_projector_log.png',
dpi=300)
ax[0].set_xlim(-0.5, 5)
ax[0].set_ylim(-3.5, 0.5)
plt.savefig(outdir + haldane_lattice.lp['LatticeTop'] +
'_projector_zoom_log.png',
dpi=300)
if show:
plt.show()
plt.clf()
# Combine x and y
# put projector magnitude on log-log plot
fig, ax = leplt.initialize_1panel_fig(Wfig=90,
Hfig=None,
x0frac=0.15,
y0frac=0.15,
wsfrac=0.4,
hs=None,
vspace=5,
hspace=8,
tspace=10,
fontsize=8)
for ind in range(len(dists)):
ax[0].scatter(dists[ind],
np.log10(magproj[ind]),
s=1,
color='k',
alpha=alpha)
ax[0].set_title('Locality of projection operator $P$\nfor ' + network_str +
' network')
ax[0].set_xlabel('Distance $|\mathbf{x}_i-\mathbf{x}_j|$')
ax[0].set_ylabel('$\log_{10} |P_{ij}|$')
if outdir is None:
outdir = le.prepdir(haldane_lattice.lp['meshfn'].replace(
'networks', 'projectors'))
le.ensure_dir(outdir)
plt.savefig(outdir + haldane_lattice.lp['LatticeTop'] +
'_projector_xy2_log.png',
dpi=300)
ax[0].set_xlim(-0.5, 5)
ax[0].set_ylim(-3.5, 0.5)
plt.savefig(outdir + haldane_lattice.lp['LatticeTop'] +
'_projector_xy2_zoom_log.png',
dpi=300)
if show:
plt.show()
plt.clf()
# save dists and magproj as pkl
with open(outdir + haldane_lattice.lp['LatticeTop'] + "_dists.pkl",
"wb") as fn:
pickle.dump(dists, fn)
with open(outdir + haldane_lattice.lp['LatticeTop'] + "_magproj.pkl",
"wb") as fn:
pickle.dump(magproj, fn)
def movie_cherns_varyloc(ccoll, title='Chern number calculation for varied positions',
filename='chern_varyloc', rootdir=None, exten='.png', max_boxfrac=None, max_boxsize=None,
xlabel=None, ylabel=None, step=0.5, fracsteps=False, framerate=3):
"""Plot the chern as a function of space for each haldane_lattice examined
Parameters
----------
ccoll : ChernCollection instance
The collection of varyloc chern calcs to make into a movie
title : str
title of the movie
filename : str
the name of the files to save
rootdir : str or None
The cproot directory to use (usually self.cp['rootdir'])
exten : str (.png, .jpg, etc)
file type extension
max_boxfrac : float
Fraction of spatial extent of the sample to use as maximum bound for kitaev sum
max_boxsize : float or None
If None, uses max_boxfrac * spatial extent of the sample asmax_boxsize
xlabel : str
label for x axis
ylabel : str
label for y axis
step : float (default=1.0)
how far apart to sample kregion vertices in varyloc
fracsteps : bool
framerate : int
The framerate at which to save the movie
max_boxfrac : float
Fraction of spatial extent of the sample to use as maximum bound for kitaev sum
max_boxsize : float or None
If None, uses max_boxfrac * spatial extent of the sample asmax_boxsize
"""
rad = 1.0
divgmap = cmaps.diverging_cmap(250, 10, l=30)
# plot it
for hlat_name in ccoll.cherns:
hlat = ccoll.cherns[hlat_name][0].haldane_lattice
if hlat.lp['shape'] == 'square':
# get extent of the network from Bounding box
Radius = np.abs(hlat.lp['BBox'][0, 0])
else:
# todo: allow different geometries
pass
# Initialize the figure
h_mm = 90
w_mm = 120
# To get space between subplots, figure out how far away ksize region needs to be, based on first chern
# Compare max ksize to be used with spatial extent of the lattice. If comparable, make hspace large.
# Otherwise, use defaults
ksize = ccoll.cherns[hlat_name][0].chern_finsize[:, 2]
cgll = ccoll.cherns[hlat_name][0].haldane_lattice.lattice
maxsz = max(np.max(cgll.xy[:, 0]) - np.min(cgll.xy[:, 0]),
np.max(cgll.xy[:, 1]) - np.min(cgll.xy[:, 1]))
if max_boxsize is not None:
ksize = ksize[ksize < max_boxsize]
else:
if max_boxfrac is not None:
max_boxsize = max_boxfrac * maxsz
ksize = ksize[ksize < max_boxsize]
else:
ksize = ksize
max_boxsize = np.max(ksize)
if max_boxsize > 0.9 * maxsz:
center0_frac = 0.3
center2_frac = 0.75
elif max_boxsize > 0.65 * maxsz:
center0_frac = 0.35
center2_frac = 0.72
elif max_boxsize > 0.55 * maxsz:
center0_frac = 0.375
center2_frac = 0.71
else:
center0_frac = 0.4
center2_frac = 0.7
fig, ax = initialize_1p5panelcbar_fig(Wfig=w_mm, Hfig=h_mm, wsfrac=0.4, wssfrac=0.4,
center0_frac=center0_frac, center2_frac=center2_frac)
# dimensions of video in pixels
final_h = 720
final_w = 960
actual_dpi = final_h / (float(h_mm) / 25.4)
# Add the network to the figure
hlat = ccoll.cherns[hlat_name][0].haldane_lattice
netvis.movie_plot_2D(hlat.lattice.xy, hlat.lattice.BL, 0 * hlat.lattice.BL[:, 0],
None, None, ax=ax[0], fig=fig, axcb=None,
xlimv='auto', ylimv='auto', climv=0.1, colorz=False, ptcolor=None, figsize='auto',
colormap='BlueBlackRed', bgcolor='#ffffff', axis_off=True, axis_equal=True,
lw=0.2)
# Add title
if title is not None:
ax[0].annotate(title, xy=(0.5, .95), xycoords='figure fraction',
horizontalalignment='center', verticalalignment='center')
if xlabel is not None:
ax[0].set_xlabel(xlabel)
if ylabel is not None:
ax[0].set_xlabel(ylabel)
# Position colorbar
sm = plt.cm.ScalarMappable(cmap=divgmap, norm=plt.Normalize(vmin=-1, vmax=1))
# fake up the array of the scalar mappable.
sm._A = []
cbar = plt.colorbar(sm, cax=ax[1], orientation='horizontal', ticks=[-1, 0, 1])
ax[1].set_xlabel(r'$\nu$')
ax[1].xaxis.set_label_position("top")
ax[2].axis('off')
# Add patches (rectangles from cherns at each site) to the figure
print 'Opening hlat_name = ', hlat_name
done = False
ind = 0
while done is False:
rectps = []
colorL = []
for chernii in ccoll.cherns[hlat_name]:
# Grab small, medium, and large circles
ksize = chernii.chern_finsize[:, 2]
if max_boxsize is not None:
ksize = ksize[ksize < max_boxsize]
else:
if max_boxfrac is not None:
cgll = chernii.haldane_lattice.lattice
maxsz = max(np.max(cgll.xy[:, 0]) - np.min(cgll.xy[:, 0]),
np.max(cgll.xy[:, 1]) - np.min(cgll.xy[:, 1]))
max_boxsize = max_boxfrac * maxsz
ksize = ksize[ksize < max_boxsize]
else:
ksize = ksize
max_boxsize = np.max(ksize)
# print 'ksize = ', ksize
# print 'max_boxsize = ', max_boxsize
xx = float(chernii.cp['poly_offset'].split('/')[0])
yy = float(chernii.cp['poly_offset'].split('/')[1])
nu = chernii.chern_finsize[:, -1]
rad = step
rect = plt.Rectangle((xx-rad*0.5, yy-rad*0.5), rad, rad, ec="none")
colorL.append(nu[ind])
rectps.append(rect)
p = PatchCollection(rectps, cmap=divgmap, alpha=1.0, edgecolors='none')
p.set_array(np.array(np.array(colorL)))
p.set_clim([-1., 1.])
# Add the patches of nu calculations for each site probed
ax[0].add_collection(p)
# Draw the kitaev cartoon in second axis with size ksize[ind]
polygon1, polygon2, polygon3 = kfns.get_kitaev_polygons(ccoll.cp['shape'], ccoll.cp['regalph'],
ccoll.cp['regbeta'], ccoll.cp['reggamma'],
ksize[ind])
patchlist = []
patchlist.append(patches.Polygon(polygon1, color='r'))
patchlist.append(patches.Polygon(polygon2, color='g'))
patchlist.append(patches.Polygon(polygon3, color='b'))
polypatches = PatchCollection(patchlist, cmap=cm.jet, alpha=0.4, zorder=99, linewidths=0.4)
colors = np.linspace(0, 1, 3)[::-1]
polypatches.set_array(np.array(colors))
ax[2].add_collection(polypatches)
ax[2].set_xlim(ax[0].get_xlim())
ax[2].set_ylim(ax[0].get_ylim())
# Save the plot
# make index string
indstr = '_{0:06d}'.format(ind)
hlat_cmesh = kfns.get_cmeshfn(ccoll.cherns[hlat_name][0].haldane_lattice.lp, rootdir=rootdir)
specstr = '_Nks' + '{0:03d}'.format(len(ksize)) + '_step' + sf.float2pstr(step) \
+ '_maxbsz' + sf.float2pstr(max_boxsize)
outdir = hlat_cmesh + '_' + hlat.lp['LatticeTop'] + '_varyloc_stills' + specstr + '/'
fnout = outdir + filename + specstr + indstr + exten
print 'saving figure: ' + fnout
le.ensure_dir(outdir)
fig.savefig(fnout, dpi=actual_dpi*2)
# Save at lower res after antialiasing
f_img = Image.open(fnout)
f_img.resize((final_w, final_h), Image.ANTIALIAS).save(fnout)
# clear patches
p.remove()
polypatches.remove()
# del p
# Update index
ind += 1
if ind == len(ksize):
done = True
# Turn into movie
imgname = outdir + filename + specstr
movname = hlat_cmesh + filename + specstr + '_mov'
subprocess.call(['./ffmpeg', '-framerate', str(int(framerate)), '-i', imgname + '_%06d' + exten, movname + '.mov',
'-vcodec', 'libx264', '-profile:v', 'main', '-crf', '12', '-threads', '0',
'-r', '30', '-pix_fmt', 'yuv420p'])
def calc_kitaev_chern_from_evs(xy,
eigval,
eigvect,
cp,
pp=None,
check=False,
contributions=False,
verbose=False,
vis_exten='.png',
contrib_exten='.pdf',
delta=2. / 3.):
"""Compute the chern number for a gyro_lattice
Parameters
----------
xy : NP x 2 float array
points of the gyro network
eigval : 2NP x 1 complex array
Eigenvalues of the system
eigvect : 2NP x 2NP complex array
Eigenvectors of the system
pp : len(gyro_lattice.lattice.xy)*2 x len(gyro_lattice.lattice.xy)*2 complex array (optional)
projection operator, if already calculated previously. If None, this function calculates this.
check : bool (optional)
Display intermediate results
contributions : bool (optional)
Compute the contribution of each individual particle to the chern result for the given summation regions
verbose : bool (optional)
Print more output on command line
vis_exten : str ('.png', '.pdf', '.jpg', etc, default = '.png')
Extension for the plotted output, if cp['save_ims'] == True
contrib_exten : str ('.png', '.pdf', '.jpg', etc, default = '.pdf')
Extension for the plotted contributions of each particle, if cp['save_ims'] == True and contributions==True
Returns
-------
chern_finsize : len(cp['ksize_frac_arr']) x 6 complex array
np.dstack((Nreg1V, ksize_frac_arr, ksize_V, ksys_sizeV, ksys_fracV, nuV))[0]
params_regs : dict
For each kitaev region size (ksize), there is a key '{0:0.3f}'.format(ksize) and value pair, of the form
params_regs['{0:0.3f}'.format(ksize)] = {'reg1': reg1, 'reg2': reg2, 'reg3': reg3,
'polygon1': polygon1, 'polygon2': polygon2, 'polygon3': polygon3,
'reg1_xy': reg1_xy, 'reg2_xy': reg2_xy, 'reg3_xy': reg3_xy}
contribs : dict or None
If contributions == True, contribs is a dictionary with values storing the contributions to the chern result for
each particle in reg1, reg2, and reg3. Contribs has keys which are '{0:0.3f}'.format(ksize) for each ksize, and
each value of contribs['{0:0.3f}'.format(ksize)] is itself a dictionary with keys 'reg1', 'reg2', 'reg3' and
values as the contributions of each particle, for particles indexed by reg1, 2, 3.
ie, contribs['{0:0.3f}'.format(ksize)] = {'reg1': cb1, 'reg2': cb2, 'reg3': cb3}
Here cb1,2,3 are (# particles in region n) x 1 complex arrays -- contributions of each particle in each region
to the total result (when summed over the other two regions)
"""
save_ims = cp['save_ims']
modsave = cp['modsave']
shape = cp['shape']
ksize_frac_arr = cp['ksize_frac_arr']
omegac = cp['omegac']
if save_ims:
# Register colormaps
lecmaps.register_colormaps()
imagedir = cp['cpmeshfn'] + 'visualization/'
le.ensure_dir(imagedir)
NP = len(xy)
if pp is None:
print 'Computing projector...'
pp = calc_projector_from_evs(eigval, eigvect, omegac)
# Initialize empty region index arrays for speedup by comparing with prev iteration
reg1 = np.array([])
reg2 = np.array([])
reg3 = np.array([])
nu = 0.0 + 0.0 * 1j
epskick = 0.001 * np.random.rand(len(xy), 2)
# Preallocate arrays
nuV = np.zeros(len(ksize_frac_arr))
Nreg1V = np.zeros(len(ksize_frac_arr))
ksize_V = np.zeros(len(ksize_frac_arr))
ksys_sizeV = np.zeros(len(ksize_frac_arr))
ksys_fracV = np.zeros(len(ksize_frac_arr))
params_regs = {}
if contributions:
contribs = {}
else:
contribs = None
# Get max(width, height) of network
maxsz = max(
np.max(xy[:, 0]) - np.min(xy[:, 0]),
np.max(xy[:, 1]) - np.min(xy[:, 1]))
# If we want to look at individual contributions from each gyro, find h first
if contributions and NP < 800:
method = '2current'
print 'constructing 2-current h_ijk...'
hh = np.einsum('jk,kl,lj->jkl', pp, pp, pp) - np.einsum(
'jl,lk,kj->jkl', pp, pp, pp)
# hh = np.zeros((len(pp), len(pp), len(pp)), dtype=complex)
# for j in range(len(pp)):
# for k in range(len(pp)):
# for l in range(len(pp)):
# hh[j, k, l] = pp[j, k] * pp[k, l] * pp[l, j] - pp[j, l] * pp[l, k] * pp[k, j]
hh *= 12 * np.pi * 1j
else:
method = 'projector'
jj = 0
# for each ksize_frac, perform sum
for kk in range(len(ksize_frac_arr)):
ksize_frac = ksize_frac_arr[kk]
ksize = ksize_frac * maxsz
if verbose:
print 'ksize = ', ksize
polygon1, polygon2, polygon3 = kfns.get_kitaev_polygons(
shape,
cp['regalph'],
cp['regbeta'],
cp['reggamma'],
ksize,
delta_pi=delta,
outerH=cp['outerH'])
if cp['polyT']:
polygon1 = np.fliplr(polygon1)
polygon2_tmp = np.fliplr(polygon3)
polygon3 = np.fliplr(polygon2)
polygon2 = polygon2_tmp
if cp['poly_offset'] != 'none' and cp['poly_offset'] is not None:
if '/' in cp['poly_offset']:
splitpo = cp['poly_offset'].split('/')
else:
splitpo = cp['poly_offset'].split('_')
# print 'split_po = ', splitpo
poly_offset = np.array([float(splitpo[0]), float(splitpo[1])])
polygon1 += poly_offset
polygon2 += poly_offset
polygon3 += poly_offset
# Save the previous reg1,2,3
r1old = reg1
r2old = reg2
r3old = reg3
reg1_xy = le.inds_in_polygon(xy + epskick, polygon1)
reg2_xy = le.inds_in_polygon(xy + epskick, polygon2)
reg3_xy = le.inds_in_polygon(xy + epskick, polygon3)
if cp['basis'] == 'XY':
reg1 = np.sort(np.vstack((2 * reg1_xy, 2 * reg1_xy + 1)).ravel())
reg2 = np.sort(np.vstack((2 * reg2_xy, 2 * reg2_xy + 1)).ravel())
reg3 = np.sort(np.vstack((2 * reg3_xy, 2 * reg3_xy + 1)).ravel())
elif cp['basis'] == 'psi':
if verbose:
print 'stacking regions with right-moving selves...'
reg1 = np.sort(np.vstack((reg1, NP + reg1)).ravel())
reg2 = np.sort(np.vstack((reg2, NP + reg2)).ravel())
reg3 = np.sort(np.vstack((reg3, NP + reg3)).ravel())
if contributions:
if method == '2current':
nu, [cb1, cb2,
cb3] = kfns.sum_kitaev_with_contributions(reg1,
reg2,
reg3,
r1old,
r2old,
r3old,
hh,
nu,
verbose=verbose)
else:
nu, [cb1, cb2,
cb3] = kfns.sum_kitaev_with_contributions_projector(
reg1,
reg2,
reg3,
r1old,
r2old,
r3old,
pp,
nu,
verbose=verbose)
contribs['{0:0.3f}'.format(ksize)] = {
'reg1': cb1,
'reg2': cb2,
'reg3': cb3
}
else:
nu = kfns.sum_kitaev_projector(reg1,
reg2,
reg3,
r1old,
r2old,
r3old,
pp,
nu,
verbose=verbose)
# print 'nu = ', nu
nuV[kk] = np.real(nu)
Nreg1V[kk] = len(reg1)
ksize_V[kk] = ksize
ksys_sizeV[kk] = len(reg1) + len(reg2) + len(reg3)
ksys_fracV[kk] = ksys_sizeV[kk] / len(xy)
# Save regions
params_regs['{0:0.3f}'.format(ksize)] = {
'reg1': reg1,
'reg2': reg2,
'reg3': reg3,
'polygon1': polygon1,
'polygon2': polygon2,
'polygon3': polygon3,
'reg1_xy': reg1_xy,
'reg2_xy': reg2_xy,
'reg3_xy': reg3_xy
}
if save_ims and (kk % modsave == 0 or kk == (len(ksize_frac_arr) - 1)):
plt.clf()
filename = 'division_lattice_regions_{0:06d}'.format(
jj) + vis_exten
# title = r'Division of lattice: $\nu = ${0:0.3f}'.format(nu.real)
# Commented out: plot just the regs and the title
# plot_chern_realspace(gyro_lattice, reg1_xy, reg2_xy, reg3_xy, polygon1, polygon2, polygon3,
# ax=None, outdir=imagedir, filename=filename, title=title, check=check)
# New way: plot the regs with title plus curve of nu vs ksize
kfns.plot_chern_realspace_2panel(xy,
ksys_fracV,
nuV,
kk,
reg1_xy,
reg2_xy,
reg3_xy,
polygon1,
polygon2,
polygon3,
outdir=imagedir,
filename=filename,
title='',
check=check)
if contributions:
# Save plot of contributions from individual gyroscopes
plt.clf()
filename = 'contributions_ksize{0:0.3f}'.format(
ksize_frac) + contrib_exten
kfns.plot_chern_contributions_experiment(xy,
reg1,
reg2,
reg3,
cb1,
cb2,
cb3,
polygon1,
polygon2,
polygon3,
basis=cp['basis'],
outdir=imagedir,
filename=filename)
jj += 1
if save_ims:
movname = cp['cpmeshfn'] + 'visualization'
imgname = imagedir + 'division_lattice_regions_'
print 'glob.glob(imgname) = ', glob.glob(imgname + '*')
print 'len(glob.glob(imgname)[0]) = ', len(glob.glob(imgname + '*'))
framerate = float(len(glob.glob(imgname + '*'))) / 7.0
print 'framerate = ', framerate
subprocess.call([
'./ffmpeg', '-framerate',
str(framerate), '-i', imgname + '%6d.png', movname + '.mov',
'-vcodec', 'libx264', '-profile:v', 'main', '-crf', '12',
'-threads', '0', '-r', '1', '-pix_fmt', 'yuv420p'
])
chern_finsize = np.dstack(
(Nreg1V, ksize_frac_arr, ksize_V, ksys_sizeV, ksys_fracV, nuV))[0]
return chern_finsize, params_regs, contribs
def save_chern(self):
# Make output directories
le.ensure_dir(self.cp['cpmeshfn'])
if self.params_regs or self.contribs is not None:
le.ensure_dir(self.cp['cpmeshfn'] + 'params_regs/')
if self.contribs is not None:
le.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'
le.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 2*NP_summed), ksys_frac, nu' + \
'for Chern calculation: basis=' + \
self.cp['basis'] + ' Omg=' + ' Omk=' + '{0:0.3f}'.format(self.gyro_lattice.lp['Omk']) +\
' Omk=' + '{0:0.3f}'.format(self.gyro_lattice.lp['Omk'])
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] * 0.5, 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 = ' + le.prepstr(
ksize)
fn = self.cp[
'cpmeshfn'] + 'params_regs/params_regs_ksize' + le.prepstr(
ksize) + '.txt'
le.save_dict(self.params_regs[ksize], fn, header)
print 'saved (many) params_regs. Last one was:', 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.gyro_lattice.lp[
'meshfn']
le.save_dict(self.gyro_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 = ' + le.prepstr(ksize)
fn = self.cp[
'cpmeshfn'] + 'contribs/contribs_ksize' + le.prepstr(
ksize) + '.txt'
le.save_dict(self.contribs[ksize], fn, header)
