def plot_ill_dos(hlat, dos_ax=None, cbar_ax=None, alpha=1.0, vmin=None, vmax=None, **kwargs): """ Parameters ---------- dos_ax : axis instance Axis on which to plot the Localization-colored DOS cbar_ax : axis instance or None axis to use for colorbar alpha : float opacity of the DOS added to the plot vmin : float minimum value for inverse localization length in colormap vmax : float maximum value for inverse localization length in colormap **kwargs: lepm.plotting.plotting.colored_DOS_plot() keyword arguments Excluding fontsize """ # Register cmaps if necessary if 'viridis' not in plt.colormaps(): lecmaps.register_colormaps() eigval = hlat.get_eigval(attribute=False) # Load or compute localization localization = hlat.get_localization(attribute=False) ill = localization[:, 2] # print 'gcollpfns: localization = ', localization # print 'gcollpfns: shape(localization) = ', np.shape(localization) # Now overlay the ipr if vmin is None: print 'setting vmin...' vmin = 0.0 if dos_ax is None: print 'dos_ax is None, initializing...' fig, dos_ax, cax, cbar = leplt.initialize_colored_DOS_plot( eigval, 'haldane', alpha=alpha, colorV=ill, colormap='viridis', linewidth=0, cax_label=r'$\lambda^{-1}$', vmin=vmin, vmax=vmax, **kwargs) else: print 'gcollpfns: calling leplt.colored_DOS_plot...' dos_ax, cbar_ax, cbar, n, bins = \ leplt.colored_DOS_plot(eigval, dos_ax, 'haldane', alpha=alpha, colorV=ill, cbar_ax=cbar_ax, colormap='viridis', linewidth=0, vmin=vmin, vmax=vmax, **kwargs) return dos_ax, cbar_ax
deltas = np.array(deltas) abds = np.array(abds) cherns = np.array(cherns) if len(abdgrid) == 0: deltagrid = deltas abdgrid = abds cherngrid = cherns else: deltagrid = np.vstack((deltagrid, deltas)) abdgrid = np.vstack((abdgrid, abds)) cherngrid = np.vstack((cherngrid, cherns)) plt.close('all') fig, ax, cax = leplt.initialize_1panel_cbar_cent() lecmaps.register_colormaps() cmap = 'bbr0' # deltagrid.reshape((len(abds), -1)) # abdgrid.reshape((len(abds), -1)) # cherngrid.reshape((len(abds), -1)) # leplt.plot_pcolormesh_scalar(deltagrid, abdgrid, cherngrid, outpath=None, cmap=cmap, vmin=-1.0, vmax=1.0) leplt.plot_pcolormesh(deltagrid / np.pi, abdgrid, cherngrid, 100, ax=ax, make_cbar=False, cmap=cmap, vmin=-1.0, vmax=1.0) # ax.scatter(deltagrid, abdgrid, c=cherngrid, cmap=cmap, vmin=-1.0, vmax=1.0) sm = leplt.empty_scalar_mappable(vmin=-1.0, vmax=1.0, cmap=cmap) cb = plt.colorbar(sm, cax=cax, orientation='horizontal') cb.set_label(label=r'Chern number, $\nu$', labelpad=-35) cb.set_ticks([-1, 0, 1]) ax.set_xlabel(r'Lattice deformation angle, $\delta/\pi$') ax.set_ylabel(r'Inversion symmetry breaking, $\Delta$') specstr = '_aol' + sf.float2pstr(lp['aoverl']) + '_Omk' + sf.float2pstr(lp['Omk'])
def plot_projector_singlept_network(hlat, evxyproj, fig=None, ax=None, cax=None, cmap='viridis', save=True, sz=15, axis_off=False, fontsize=10, **kwargs): """Plot a network with each site colored by the magnitude of its projector value relative to a point closest to proj_XY. Parameters ---------- hlat : HaldaneLattice instance evxyproj : 2 x 2*NP complex array projector components corresponding to the particle of interest. First row corresponds to x component, second to y component fig : matplotlib.pyplot figure instance ax : axis instance cax : colorbar axis instance cmap : string specifier for colormap to use **kwargs : keyword arguments for leplt.initialize_1panel_cbar_cent() Wfig=90, Hfig=None, wsfrac=0.4, hsfrac=None, cbar_pos='above', wcbarfrac=0.06, hcbarfrac=0.05, cbar_label='', vspace=8, hspace=5, tspace=10, fontsize=8 Returns ------- """ # make magproj, which has dims 1 x NP 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(int(0.5 * len(tmp))) ]).ravel() if ax is None: fig, ax, cbar_ax_tmp = leplt.initialize_1panel_cbar_cent(**kwargs) if cax is None: cbar_ax = cbar_ax_tmp else: cbar_ax = cax hlat.lattice.plot_BW_lat(fig=None, ax=ax, save=False, close=False, axis_off=axis_off, title='') if cmap not in plt.colormaps(): lecmaps.register_colormaps() colormap = plt.get_cmap(cmap) colors = colormap(magproj / np.max(magproj)) # print 'colors = ', colors ax.scatter(hlat.lattice.xy[:, 0], hlat.lattice.xy[:, 1], s=sz, c=colors, edgecolors='none', zorder=200) # create scalar mappable norm = matplotlib.colors.Normalize(vmin=0, vmax=1) sm = matplotlib.cm.ScalarMappable(cmap=colormap, norm=norm) sm._A = [] cbar = plt.colorbar(sm, cax=cbar_ax, orientation='horizontal') cbar.set_ticks([0., 0.5, 1.0]) cbar_ax.set_title(r'$P_{i0}/P_{00}$', fontsize=fontsize) return fig, ax, cbar_ax
def plot_ill_dos_overlay(gcoll, dos_ax=None, cbar_ax=None, alpha=None, vmin=None, vmax=None, **kwargs): """ Parameters ---------- dos_ax : axis instance Axis on which to plot the Localization-colored DOS **kwargs: lepm.plotting.plotting.colored_DOS_plot() keyword arguments Excluding fontsize """ gcoll.ensure_all_eigval() # Decide what alpha value to use if not provided (here, 1/N) if alpha is None: alpha = 1. / float(len(gcoll.gyro_lattices)) # Register cmaps if necessary if 'viridis' not in plt.colormaps(): cmaps.register_colormaps() # Plot the overlays for ii in range(len(gcoll.gyro_lattices)): if ii % 10 == 0: print 'Overlaying ', ii, ' of ', len(gcoll.gyro_lattices) eigval = gcoll.gyro_lattices[ii].eigval # Load or compute localization localization = gcoll.gyro_lattices[ii].get_localization( attribute=False) ill = np.zeros(len(eigval), dtype=float) ill[0:int(len(eigval) * 0.5)] = localization[:, 2][::-1] ill[int(len(eigval) * 0.5):len(eigval)] = localization[:, 2] print 'ill = ', ill # print 'gcollpfns: localization = ', localization # print 'gcollpfns: shape(localization) = ', np.shape(localization) # Now overlay the ipr if vmin is None: print 'setting vmin...' vmin = 0.0 if ii == 0 and dos_ax is None: print 'dos_ax is None, initializing...' fig, dos_ax, cax, cbar = leplt.initialize_colored_DOS_plot( eigval, 'haldane', pin=-5000, alpha=alpha, colorV=ill, colormap='viridis', linewidth=0, cax_label=r'$\lambda^{-1}$', vmin=vmin, vmax=vmax, climbars=False, **kwargs) print 'cbar_ax = ', cax if vmax is None: print 'setting vmax...' vmax = cbar.get_clim()[1] elif ii == 0: dos_ax, cbar_ax, cbar, n, bins = \ leplt.colored_DOS_plot(eigval, dos_ax, 'haldane', pin=-5000, alpha=alpha, colorV=ill, cbar_ax=cbar_ax, colormap='viridis', linewidth=0, make_cbar=True, vmin=vmin, vmax=vmax, **kwargs) if vmax is None: print 'setting vmax...' vmax = cbar.get_clim()[1] else: print 'gcollpfns: calling leplt.colored_DOS_plot...' leplt.colored_DOS_plot(eigval, dos_ax, 'haldane', pin=-5000, alpha=alpha, colorV=ill, cbar_ax=cbar_ax, colormap='viridis', linewidth=0, make_cbar=False, vmin=vmin, vmax=vmax, **kwargs) plt.pause(1) return dos_ax, cbar_ax
def plot_ipr_DOS_overlay(self, outdir=None, title=r'$D(\omega)$ for Haldane network', fname='ipr_DOS_overlay', alpha=None, FSFS=12, inverse_PR=True, show=False, close=True, initialize=True, DOS_ax=None, vmin=None, vmax=None, check=False, **kwargs): """Plot Inverse Participation Ratio of the Haldane networks and overlay them Parameters ---------- close : bool Whether to show the figure after plotting close : bool Whether to close all figure instances at the end initialize : bool If True or if DOSax is not supplied, creates a new plot for the ipr DOS image DOSax : axis instance Axis on which to plot the PR DOS, if initialize is False **kwargs: most of lepm.plotting.plotting.colored_DOS_plot() keyword arguments Excluding pin, alpha, colorV, colormap, linewidth, make_cbar, vmin, vmax Includes """ self.ensure_all_eigval() # Decide what alpha value to use if not provided (here, 1/N) if alpha is None: alpha = 1. / float(len(self.haldane_lattices)) # Register cmaps if necessary if 'viridis' not in plt.colormaps( ) or 'viridis_r' not in plt.colormaps(): cmaps.register_colormaps() # Plot the overlays for ii in range(len(self.haldane_lattices)): if ii % 10 == 0: print 'Overlaying ', ii, ' of ', len(self.haldane_lattices) eigval = self.haldane_lattices[ii].eigval # Load ipr if self.haldane_lattices[ii].ipr is None: # Attempt to load ipr directly try: ipr = self.haldane_lattices[ii].load_ipr(attribute=False) except: # To calc ipr, load eigvect if self.haldane_lattices[ii].eigvect is None: eigvect = self.haldane_lattices[ii].load_eigvect( attribute=False) else: eigvect = self.haldane_lattices[ii].eigvect ipr = self.haldane_lattices[ii].calc_ipr(eigvect=eigvect, attribute=False) # Now overlay the ipr if vmin is None and inverse_PR: print 'setting vmin...' vmin = 1.0 if ii == 0 and initialize and DOS_ax is None: if inverse_PR: fig, DOS_ax, cbar_ax, cbar = leplt.initialize_colored_DOS_plot( eigval, 'haldane', pin=-5000, alpha=alpha, colorV=ipr, colormap='viridis', fontsize=FSFS, linewidth=0, cax_label=r'$p^{-1}$', vmin=vmin, vmax=vmax, climbars=False, **kwargs) print 'cbar_ax = ', cbar_ax if vmax is None: print 'setting vmax...' vmax = cbar.get_clim()[1] else: fig, DOS_ax, cbar_ax, cbar = \ leplt.initialize_colored_DOS_plot(eigval, 'haldane', pin=-5000, alpha=alpha, colorV=1./ipr, colormap='viridis_r', fontsize=FSFS, linewidth=0, cax_label=r'$p$', climbars=False, vmin=vmin, vmax=vmax, **kwargs) if vmin is None: print 'setting vmin...' vmin = cbar.get_clim()[0] if vmax is None: print 'setting vmax...' vmax = cbar.get_clim()[1] elif ii == 0: if inverse_PR: DOS_ax, cbar_ax, cbar, n, bins = \ leplt.colored_DOS_plot(eigval, DOS_ax, 'haldane', pin=-5000, alpha=alpha, colorV=ipr, fontsize=FSFS, colormap='viridis', linewidth=0, make_cbar=True, vmin=vmin, vmax=vmax, **kwargs) if vmax is None: print 'setting vmax...' vmax = cbar.get_clim()[1] else: DOS_ax, cbar_ax, cbar, n, bins = \ leplt.colored_DOS_plot(eigval, DOS_ax, 'haldane', pin=-5000, alpha=alpha, colorV=1./ipr, fontsize=FSFS, colormap='viridis_r', linewidth=0, make_cbar=True, vmin=vmin, vmax=vmax, **kwargs) if vmin is None: print 'setting vmin...' vmin = cbar.get_clim()[0] if vmax is None: print 'setting vmax...' vmax = cbar.get_clim()[1] else: if inverse_PR: leplt.colored_DOS_plot(eigval, DOS_ax, 'haldane', pin=-5000, alpha=alpha, colorV=ipr, fontsize=FSFS, colormap='viridis', linewidth=0, make_cbar=False, vmin=vmin, vmax=vmax, **kwargs) else: leplt.colored_DOS_plot(eigval, DOS_ax, 'haldane', pin=-5000, alpha=alpha, colorV=1. / ipr, fontsize=FSFS, colormap='viridis_r', linewidth=0, make_cbar=False, vmin=vmin, vmax=vmax, **kwargs) if check: plt.pause(1) DOS_ax.set_title(title, fontsize=FSFS) if outdir is not None: print 'saving as ', outdir + fname + '.pkl' pl.dump(fig, file(outdir + fname + '.pkl', 'w')) plt.savefig(outdir + fname + '.png') plt.savefig(outdir + fname + '.pdf') if show: plt.show() if close: plt.close('all')
def plot_ipr_DOS_stack(self, outdir=None, title=r'$D(\omega)$ for Haldane network', fname='ipr_DOS_stack', vmin=None, vmax=None, alpha=None, FSFS=12, inverse_PR=True, show=False, close=True, ylabels=None, **kwargs): """Plot Inverse Participation Ratio of the Haldane networks (with DOS) and stack them in a column Parameters ---------- outdir : str or None title : str fname : str vmin : float or None vmax : float or None alpha : float or None FSFS : int inverse_PR : bool show : bool close : bool ylabels : None **kwargs: arguments passed to glat.add_ipr_to_ax() --> most of lepm.plotting.plotting.colored_DOS_plot() keyword arguments Excluding pin, alpha, colorV, colormap, linewidth, make_cbar, vmin, vmax, """ self.ensure_all_eigval() # Decide what alpha value to use if not provided (here, 1.) if alpha is None: alpha = 1. # Register cmaps if necessary if 'viridis' not in plt.colormaps( ) or 'viridis_r' not in plt.colormaps(): cmaps.register_colormaps() fig, ax = plt.subplots(len(self.haldane_lattices), 1, sharex=True, sharey=True) n_glats = len(self.haldane_lattices) # Plot the DOS xlabel = '' cax = fig.add_axes([0.93, 0.2, 0.02, 0.5]) for ii in range(n_glats): print 'Plotting ', ii, ' of ', len(self.haldane_lattices) if ii == n_glats - 1: xlabel = 'Oscillation frequency $\omega$' if ylabels is None: ylabel = '' else: ylabel = ylabels[ii] print 'inverse_PR = ', inverse_PR DOSaxis = self.haldane_lattices[ii].add_ipr_to_ax( ax[ii], alpha=alpha, inverse_PR=inverse_PR, xlabel=xlabel, ylabel=ylabel, vmax=vmax, vmin=vmin, cbar_ax=cax, **kwargs) ii += 1 ax[0].set_title(title, fontsize=FSFS) ax[0].annotate(r'$D(\omega)$', xy=(.01, .5), xycoords='figure fraction', horizontalalignment='left', verticalalignment='center', fontsize=FSFS, rotation=90) if outdir is not None: print 'saving as ', outdir + fname + '.pkl' pl.dump(fig, file(outdir + fname + '.pkl', 'w')) plt.savefig(outdir + fname + '.png') plt.savefig(outdir + fname + '.pdf') if show: plt.show() if close: plt.close('all')
def relax_overdamped_openbc(xy, timesteps, dt, modout=10, outpath=None, save_im=False, clamp_boundary=False): """Relax a system with open boundary conditions of particles by a central force, with velocity equal to Force. For the interaction, use F=(1-r)rhat for r<1, where r is the distance between particles and rhat is the vector between them. Parameters ---------- xy PV timesteps dt modout outpath : str the full path, except for the txt extension, to put the output files clamp_boundary : bool Whether to affix the boundary particles during each relaxation step Returns ------- """ xyo = copy.deepcopy(xy) # Save initial positions if outpath is not None ii = 0 time = 0. if outpath is not None: print 'saving to ', outpath + '{0:06d}'.format(ii) header = 'Relaxing (spreading) xy pts generated by gammakick procedure: t={0:0.12e}'.format(time) +\ ', dt={0:0.12e}'.format(dt) np.savetxt(outpath + '{0:08.3f}'.format(time).replace('.', 'p') + '.txt', xy, header=header) if save_im: lecmaps.register_colormaps() cmap = plt.get_cmap('viridis') for ii in (np.arange(timesteps) + 1): # Relax for a time dt if ii % modout == 0: print 'relaxing pts: ii=', ii time += dt dxy = -spreading_forces_openbc(xyo) * dt if clamp_boundary: # todo: add code for boundary clamping raise RuntimeError('Add code to clamp the boundary here!') xyo += dxy if np.mod(ii, modout) == 0 and outpath is not None: header = 'Relaxing (spreading) xy pts generated by gammakick procedure: t={0:0.12e}'.format(time) + \ ', dt={0:0.12e}'.format(dt) np.savetxt(outpath + '{0:08.3f}'.format(time).replace('.', 'p') + '.txt', xyo, header=header) if save_im: plt.scatter(xyo[:, 0], xyo[:, 1], c=cmap(float(ii) / float(timesteps)), edgecolor='none') return xyo
def relax_overdamped(xy, pv, bbox, timesteps, dt, modout=10, outpath=None, save_im=False): """Relax a system of particles by a central force, with velocity equal to Force. For the interaction, use F=(1-r)rhat for r<1, where r is the distance between particles and rhat is the vector between them. Parameters ---------- xy PV timesteps dt modout outpath : str the full path, except for the txt extension, to put the output files Returns ------- """ xyo = copy.deepcopy(xy) # Check if the bbox is a rectangle aligned with the xy axes isrect = (dh.unique_count(bbox[:, 0])[:, 1] > 1).all() and (dh.unique_count(bbox[:, 1])[:, 1] > 1).all() if isrect: minx = np.min(bbox[:, 0]) maxx = np.max(bbox[:, 0]) miny = np.min(bbox[:, 1]) maxy = np.max(bbox[:, 1]) # Since the bbox is a rectangle, we can assume one element of each of the periodic vectors is zero # Form pvx, the distance in x of the periodic vector pointing in the x dir, and similarly for y pvx = np.max(np.abs(pv[:, 0])) pvy = np.max(np.abs(pv[:, 1])) # Save initial positions if outpath is not None ii = 0 time = 0. if outpath is not None: print 'saving to ', outpath + '{0:06d}'.format(ii) header = 'Relaxing (spreading) xy pts generated by gammakick procedure: t={0:0.12e}'.format(time) +\ ', dt={0:0.12e}'.format(dt) np.savetxt(outpath + '{0:08.3f}'.format(time).replace('.', 'p') + '.txt', xy, header=header) if save_im: lecmaps.register_colormaps() cmap = plt.get_cmap('viridis') for ii in (np.arange(timesteps) + 1): # Relax for a time dt if ii % modout == 0: print 'relaxing pts: ii=', ii time += dt dxy = spreading_forces(xyo, pv) * dt xyo += dxy if isrect: # Since the bbox is a rectangle, we can just move the points outside the bounds back inside xyo[xyo[:, 0] < minx, 0] += pvx xyo[xyo[:, 1] < miny, 1] += pvy xyo[xyo[:, 0] > maxx, 0] -= pvx xyo[xyo[:, 1] > maxy, 1] -= pvy else: # The bbox is a more complicated shape, so we have to use something like matplotlib's inpoly bpath = mplpath.Path(bbox) outside = not bpath.contains_points(xy) raise RuntimeError( 'Have not included functionality for non-rectangular periodic BCs. Build that here.' ) if np.mod(ii, modout) == 0 and outpath is not None: header = 'Relaxing (spreading) xy pts generated by gammakick procedure: t={0:0.12e}'.format(time) + \ ', dt={0:0.12e}'.format(dt) np.savetxt(outpath + '{0:08.3f}'.format(time).replace('.', 'p') + '.txt', xyo, header=header) if save_im: # load and plot points time = 0. for ii in np.arange(timesteps + 1): if np.mod(ii, modout) == 0: xyo = np.loadtxt(outpath + '{0:08.3f}'.format(time).replace('.', 'p') + '.txt') plt.scatter(xyo[:, 0], xyo[:, 1], c=cmap(float(ii) / float(timesteps)), edgecolor='none') time += dt plt.savefig(outpath + 'relaxation_visualization.png') return xyo
def movie_plot_2D(xy, BL, bs=None, fname='none', title='', NL=[], KL=[], BLNNN=[], NLNNN=[], KLNNN=[], PVx=[], PVy=[], PVxydict={}, nljnnn=None, kljnnn=None, klknnn=None, ax=None, fig=None, axcb='auto', cbar_ax=None, cbar_orientation='vertical', xlimv='auto', ylimv='auto', climv=0.1, colorz=True, ptcolor=None, figsize='auto', colorpoly=False, bondcolor=None, colormap='seismic', bgcolor=None, axis_off=False, axis_equal=True, text_topleft=None, lw=-1., ptsize=10, negative_NNN_arrows=False, show=False, arrow_alpha=1.0, fontsize=8, cax_label='Strain', zorder=0, rasterized=False): """Plots (and saves if fname is not 'none') a 2D image of the lattice with colored bonds and particles colored by coordination (both optional). Parameters ---------- xy : array of dimension nx2 2D lattice of points (positions x,y) BL : array of dimension #bonds x 2 Each row is a bond and contains indices of connected points bs : array of dimension #bonds x 1 or None Strain in each bond fname : string Full path including name of the file (.png, etc), if None, will not save figure title : string The title of the frame NL : NP x NN int array (optional, for speed) Specify to speed up computation, if colorz or colorpoly or if periodic boundary conditions KL : NP x NN int array (optional, for speed) Specify to speed up computation, if colorz or colorpoly or if periodic boundary conditions BLNNN : NLNNN : KLNNN : PVx : NP x NN float array (optional, for periodic lattices and speed) ijth element of PVx is the x-component of the vector taking NL[i,j] to its image as seen by particle i If PVx and PVy are specified, PVxydict need not be specified. PVy : NP x NN float array (optional, for periodic lattices and speed) ijth element of PVy is the y-component of the vector taking NL[i,j] to its image as seen by particle i If PVx and PVy are specified, PVxydict need not be specified. PVxydict : dict (optional, for periodic lattices) dictionary of periodic bonds (keys) to periodic vectors (values) nljnnn : #pts x max(#NNN) int array or None nearest neighbor array matching NLNNN and KLNNN. nljnnn[i, j] gives the neighbor of i such that NLNNN[i, j] is the next nearest neighbor of i through the particle nljnnn[i, j] kljnnn : #pts x max(#NNN) int array or None bond array describing periodicity of bonds matching NLNNN and KLNNN. kljnnn[i, j] describes the bond type (bulk -> +1, periodic --> -1) of bond connecting i to nljnnn[i, j] klknnn : #pts x max(#NNN) int array or None bond array describing periodicity of bonds matching NLNNN and KLNNN. klknnn[i, j] describes the bond type (bulk -> +1, periodic --> -1) of bond connecting nljnnn[i, j] to NLNNN[i, j] ax: matplotlib figure axis instance Axis on which to draw the network fig: matplotlib figure instance Figure on which to draw the network axcb: matplotlib colorbar instance Colorbar to use for strains in bonds cbar_ax : axis instance Axis to use for colorbar. If colorbar instance is not already defined, use axcb instead. cbar_orientation : str ('horizontal' or 'vertical') Orientation of the colorbar xlimv: float or tuple of floats ylimv: float or tuple of floats climv : float or tuple Color limit for coloring bonds by bs colorz: bool whether to color the particles by their coordination number ptcolor: string color spec or tuple color spec or None color specification for coloring the points, if colorz is False. Default is None (no coloring of points) figsize : tuple w,h tuple in inches colorpoly : bool Whether to color in polygons formed by bonds according to the number of sides bondcolor : color specification (hexadecimal or RGB) colormap : if bondcolor is None, uses bs array to color bonds bgcolor : hex format string, rgb color spec, or None If not None, sets the bgcolor. Often used is '#d9d9d9' axis_off : bool Turn off the axis border and canvas axis_equal : bool text_topleft : str or None lw: float line width for plotting bonds. If lw == -1, then uses automatic line width to adjust for bond density.. ptsize: float size of points passed to absolute_sizer negative_NNN_arrows : bool make positive and negative NNN hoppings different color show : bool whether to show the plot after creating it arrow_alpha : float opacity of the arrow fontsize : int (default=8) fontsize for all labels cax_label : int (default='Strain') Label for the colorbar zorder : int z placement on axis (higher means bringing network to the front, lower is to the back Returns ---------- [ax,axcb] : stuff to clear after plotting """ if fig is None or fig == 'none': fig = plt.gcf() if ax is None or ax == 'none': if figsize == 'auto': plt.clf() else: fig = plt.figure(figsize=figsize) ax = plt.axes() if bs is None: bs = np.zeros_like(BL[:, 0], dtype=float) if colormap not in plt.colormaps(): lecmaps.register_colormaps() NP = len(xy) if lw == -1: if NP < 10000: lw = 0.5 s = leplt.absolute_sizer() else: lw = (10 / np.sqrt(len(xy))) if NL == [] and KL == []: if colorz or colorpoly: NL, KL = le.BL2NLandKL(BL, NP=NP, NN='min') if (BL < 0).any(): if len(PVxydict) == 0: raise RuntimeError( 'PVxydict must be supplied to display_lattice_2D() when periodic BCs exist, ' + 'if NL and KL not supplied!') else: PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL, KL) if colorz: zvals = (KL != 0).sum(1) zmed = np.median(zvals) # print 'zmed = ', zmed under1 = np.logical_and(zvals < zmed - 0.5, zvals > zmed - 1.5) over1 = np.logical_and(zvals > zmed + 0.5, zvals < zmed + 1.5) Cz = np.zeros((len(xy), 3), dtype=int) # far under black // under blue // equal white // over red // far over green Cz[under1] = [0. / 255, 50. / 255, 255. / 255] Cz[zvals == zmed] = [100. / 255, 100. / 255, 100. / 255] Cz[over1] = [255. / 255, 0. / 255, 0. / 255] Cz[zvals > zmed + 1.5] = [0. / 255, 255. / 255, 50. / 255] # Cz[zvals<zmed-1.5] = [0./255,255./255,150./255] #leave these black s = leplt.absolute_sizer() sval = min([.005, .12 / np.sqrt(len(xy))]) sizes = np.zeros(NP, dtype=float) sizes[zvals > zmed + 0.5] = sval sizes[zvals == zmed] = sval * 0.5 sizes[zvals < zmed - 0.5] = sval # topinds = zvals!=zmed ax.scatter(xy[:, 0], xy[:, 1], s=s(sizes), c=Cz, edgecolor='none', zorder=10, rasterized=rasterized) ax.axis('equal') elif ptcolor is not None and ptcolor != 'none' and ptcolor != '': if NP < 10000: # if smallish #pts, plot them # print 'xy = ', xy # plt.plot(xy[:,0],xy[:,1],'k.') s = leplt.absolute_sizer() ax.scatter(xy[:, 0], xy[:, 1], s=ptsize, alpha=0.5, facecolor=ptcolor, edgecolor='none', rasterized=rasterized) if colorpoly: # Color the polygons based on # sides # First extract polygons. To do that, if there are periodic boundaries, we need to supply as dict if PVxydict == {} and len(PVx) > 0: PVxydict = le.PVxy2PVxydict(PVx, PVy, NL, KL=KL) polygons = le.extract_polygons_lattice(xy, BL, NL=NL, KL=KL, viewmethod=True, PVxydict=PVxydict) PolyPC = le.polygons2PPC(polygons) # number of polygon sides Pno = np.array([len(polyg) for polyg in polygons], dtype=int) print 'nvis: Pno = ', Pno print 'nvis: medPno = ', np.floor(np.median(Pno)) medPno = np.floor(np.median(Pno)) uIND = np.where(Pno == medPno - 1)[0] mIND = np.where(Pno == medPno)[0] oIND = np.where(Pno == medPno + 1)[0] loIND = np.where(Pno < medPno - 1.5)[0] hiIND = np.where(Pno > medPno + 1.5)[0] print ' uIND = ', uIND print ' oIND = ', oIND print ' loIND = ', loIND print ' hiIND = ', hiIND if len(uIND) > 0: PPCu = [PolyPC[i] for i in uIND] pu = PatchCollection(PPCu, color='b', alpha=0.5) ax.add_collection(pu) if len(mIND) > 0: PPCm = [PolyPC[i] for i in mIND] pm = PatchCollection(PPCm, color=[0.5, 0.5, 0.5], alpha=0.5) ax.add_collection(pm) if len(oIND) > 0: PPCo = [PolyPC[i] for i in oIND] po = PatchCollection(PPCo, color='r', alpha=0.5) ax.add_collection(po) if len(loIND) > 0: PPClo = [PolyPC[i] for i in loIND] plo = PatchCollection(PPClo, color='k', alpha=0.5) ax.add_collection(plo) if len(hiIND) > 0: PPChi = [PolyPC[i] for i in hiIND] phi = PatchCollection(PPChi, color='g', alpha=0.5) ax.add_collection(phi) # Efficiently plot many lines in a single set of axes using LineCollection # First check if there are periodic bonds if BL.size > 0: if (BL < 0).any(): if PVx == [] or PVy == [] or PVx is None or PVy is None: raise RuntimeError( 'PVx and PVy must be supplied to display_lattice_2D when periodic BCs exist!' ) else: # get indices of periodic bonds perINDS = np.unique(np.where(BL < 0)[0]) perBL = np.abs(BL[perINDS]) # # Check # print 'perBL = ', perBL # plt.plot(xy[:,0], xy[:,1],'b.') # for i in range(len(xy)): # plt.text(xy[i,0]+0.05, xy[i,1],str(i)) # plt.show() # define the normal bonds which are not periodic normINDS = np.setdiff1d(np.arange(len(BL)), perINDS) BLtmp = BL[normINDS] bstmp = bs[normINDS] lines = [ zip(xy[BLtmp[i, :], 0], xy[BLtmp[i, :], 1]) for i in range(len(BLtmp)) ] xy_add = np.zeros((4, 2)) # Build new strain list bs_out by storing bulk lines first, then recording the strain twice # for each periodic bond since the periodic bond is at least two lines in the plot, get bs_out # ready for appending # bs_out = np.zeros(len(normINDS) + 5 * len(perINDS), dtype=float) # bs_out[0:len(normINDS)] = bstmp bs_out = bstmp.tolist() # Add periodic bond lines to image # Note that we have to be careful that a single particle can be connected to another both in the bulk # and through a periodic boundary, and perhaps through more than one periodic boundary # kk indexes perINDS to determine what the strain of each periodic bond should be # draw_perbond_count counts the number of drawn linesegments that are periodic bonds kk, draw_perbond_count = 0, 0 for row in perBL: colA = np.argwhere(NL[row[0]] == row[1]).ravel() colB = np.argwhere(NL[row[1]] == row[0]).ravel() if len(colA) > 1 or len(colB) > 1: # Look for where KL < 0 to pick out just the periodic bond(s) -- ie there # were both bulk and periodic bonds connecting row[0] to row[1] a_klneg = np.argwhere(KL[row[0]] < 0) colA = np.intersect1d(colA, a_klneg) b_klneg = np.argwhere(KL[row[1]] < 0) colB = np.intersect1d(colB, b_klneg) # print 'colA = ', colA # print 'netvis here' # sys.exit() if len(colA) > 1 or len(colB) > 1: # there are multiple periodic bonds connecting one particle to another (in different # directions). Plot each of them. for ii in range(len(colA)): print 'netvis: colA = ', colA print 'netvis: colB = ', colB # columns a and b for this ii index caii, cbii = colA[ii], colB[ii] # add xy points to the network to plot to simulate image particles xy_add[0] = xy[row[0]] xy_add[1] = xy[row[1]] + np.array( [PVx[row[0], caii], PVy[row[0], caii]]) xy_add[2] = xy[row[1]] xy_add[3] = xy[row[0]] + np.array( [PVx[row[1], cbii], PVy[row[1], cbii]]) # Make the lines to draw (dashed lines for this periodic case) lines += zip(xy_add[0:2, 0], xy_add[0:2, 1]), zip( xy_add[2:4, 0], xy_add[2:4, 1]) bs_out.append(bs[perINDS[kk]]) bs_out.append(bs[perINDS[kk]]) draw_perbond_count += 1 kk += 1 else: # print 'row = ', row # print 'NL = ', NL # print 'KL = ', KL # print 'colA, colB = ', colA, colB colA, colB = colA[0], colB[0] xy_add[0] = xy[row[0]] xy_add[1] = xy[row[1]] + np.array( [PVx[row[0], colA], PVy[row[0], colA]]) xy_add[2] = xy[row[1]] xy_add[3] = xy[row[0]] + np.array( [PVx[row[1], colB], PVy[row[1], colB]]) lines += zip(xy_add[0:2, 0], xy_add[0:2, 1]), zip( xy_add[2:4, 0], xy_add[2:4, 1]) # bs_out[2 * kk + len(normINDS)] = bs[perINDS[kk]] # bs_out[2 * kk + 1 + len(normINDS)] = bs[perINDS[kk]] bs_out.append(bs[perINDS[kk]]) bs_out.append(bs[perINDS[kk]]) draw_perbond_count += 1 kk += 1 else: colA, colB = colA[0], colB[0] xy_add[0] = xy[row[0]] xy_add[1] = xy[row[1]] + np.array( [PVx[row[0], colA], PVy[row[0], colA]]) xy_add[2] = xy[row[1]] xy_add[3] = xy[row[0]] + np.array( [PVx[row[1], colB], PVy[row[1], colB]]) lines += zip(xy_add[0:2, 0], xy_add[0:2, 1]), zip(xy_add[2:4, 0], xy_add[2:4, 1]) # bs_out[2 * kk + len(normINDS)] = bs[perINDS[kk]] # bs_out[2 * kk + 1 + len(normINDS)] = bs[perINDS[kk]] bs_out.append(bs[perINDS[kk]]) bs_out.append(bs[perINDS[kk]]) draw_perbond_count += 1 kk += 1 # replace bs by the new bs (bs_out) bs = np.array(bs_out) # store number of bulk bonds nbulk_bonds = len(normINDS) else: if len(np.shape(BL)) > 1: lines = [ zip(xy[BL[i, :], 0], xy[BL[i, :], 1]) for i in range(np.shape(BL)[0]) ] # store number of bulk bonds nbulk_bonds = len(lines) else: lines = [ zip(xy[BL[i][0]], xy[BL[i][1]]) for i in range(np.shape(BL)[0]) ] # store number of bulk bonds nbulk_bonds = 1 if isinstance(climv, tuple): cmin = climv[0] cmax = climv[1] elif isinstance(climv, float): cmin = -climv cmax = climv elif climv is None: cmin = None cmax = None if bondcolor is None: # draw the periodic bonds as dashed, regular bulk bonds as solid line_segments = LineCollection( lines[0:nbulk_bonds], # Make a sequence of x,y pairs linewidths=lw, # could iterate over list linestyles='solid', cmap=colormap, norm=plt.Normalize(vmin=cmin, vmax=cmax), zorder=zorder, rasterized=rasterized) line_segments.set_array(bs[0:nbulk_bonds]) # draw the periodic bonds as dashed, if there are any periodic_lsegs = LineCollection( lines[nbulk_bonds:], # Make a sequence of x,y pairs linewidths=lw, # could iterate over list linestyles='dashed', cmap=colormap, norm=plt.Normalize(vmin=cmin, vmax=cmax), zorder=zorder, rasterized=rasterized) periodic_lsegs.set_array(bs[nbulk_bonds:]) else: line_segments = LineCollection(lines[0:nbulk_bonds], linewidths=lw, linestyles='solid', colors=bondcolor, zorder=zorder, rasterized=rasterized) # draw the periodic bonds as dashed, if there are any periodic_lsegs = LineCollection(lines[nbulk_bonds:], linewidths=lw, linestyles='dashed', colors=bondcolor, zorder=zorder, rasterized=rasterized) ax.add_collection(line_segments) if periodic_lsegs: ax.add_collection(periodic_lsegs) # If there is only a single bond color, ignore the colorbar specification if bondcolor is None or isinstance(bondcolor, np.ndarray): if axcb == 'auto': if cbar_ax is None: print 'nvis: Instantiating colorbar...' axcb = fig.colorbar(line_segments) else: print 'nvis: Using cbar_ax to instantiate colorbar' axcb = fig.colorbar(line_segments, cax=cbar_ax, orientation=cbar_orientation) if axcb != 'none' and axcb is not None: print 'nvis: Creating colorbar...' axcb.set_label(cax_label, fontsize=fontsize) axcb.set_clim(vmin=cmin, vmax=cmax) else: # Ignore colorbar axis specification axcb = 'none' else: axcb = 'none' if len(BLNNN) > 0: # todo: add functionality for periodic NNN connections # Efficiently plot many lines in a single set of axes using LineCollection lines = [ zip(xy[BLNNN[i, :], 0], xy[BLNNN[i, :], 1]) for i in range(len(BLNNN)) ] linesNNN = LineCollection( lines, # Make a sequence of x,y pairs linewidths=lw, # could iterate over list linestyles='dashed', color='blue', zorder=100) ax.add_collection(linesNNN, rasterized=rasterized) elif len(NLNNN) > 0 and len(KLNNN) > 0: factor = 0.8 if (BL < 0).any(): print 'nvis: plotting periodic NNN...' if nljnnn is None: raise RuntimeError( 'Must supply nljnnn to plot NNN hoppings/connections') for i in range(NP): todo = np.where(KLNNN[i, :] > 1e-12)[0] for index in todo: kk = NLNNN[i, index] # Ascribe the correct periodic vector based on both PVx[i, NNind] and PVx[NNind, ind] # Note : nljnnn is # nearest neighbor array matching NLNNN and KLNNN. nljnnn[i, j] gives the neighbor of i such that # NLNNN[i, j] is the next nearest neighbor of i through the particle nljnnn[i, j] jj = nljnnn[i, index] if kljnnn[i, index] < 0 or klknnn[i, index] < 0: jind = np.where(NL[i, :] == jj)[0][0] kind = np.where(NL[jj, :] == kk)[0][0] # print 'jj = ', jj # print 'kk = ', kk # print 'jind = ', jind # print 'kind = ', kind # print 'NL[i, :] =', NL[i, :] # print 'NL[jj, :] =', NL[jj, :] # print 'PVx[i, jind] = ', PVx[i, jind] # print 'PVy[i, jind] = ', PVy[i, jind] # print 'PVx[jj, kind] = ', PVx[jj, kind] # print 'PVy[jj, kind] = ', PVy[jj, kind] dx = (xy[kk, 0] + PVx[i, jind] + PVx[jj, kind] - xy[i, 0]) * factor dy = (xy[kk, 1] + PVy[i, jind] + PVy[jj, kind] - xy[i, 1]) * factor else: dx = (xy[kk, 0] - xy[i, 0]) * factor dy = (xy[kk, 1] - xy[i, 1]) * factor ax.arrow(xy[i, 0], xy[i, 1], dx, dy, head_width=0.1, head_length=0.2, fc='b', ec='b', linestyle='dashed') # Check # print 'dx = ', dx # print 'dy = ', dy # for ind in range(NP): # plt.text(xy[ind, 0]-0.2, xy[ind, 1]-0.2, str(ind)) # plt.show() # sys.exit() else: # amount to offset clockwise nnn arrows for i in range(NP): todo = np.where(KLNNN[i, :] > 1e-12)[0] # Allow for both blue and red arrows (forward/backward), or just blue. If just blue, use no offset and # full scale factor if negative_NNN_arrows: scalef = 0.3 else: scalef = 0.8 offset = np.array([0.0, 0.0]) for ind in NLNNN[i, todo]: if negative_NNN_arrows: offset = (xy[ind, :] - xy[i, :]) * 0.5 ax.arrow(xy[i, 0] + offset[0], xy[i, 1] + offset[1], (xy[ind, 0] - xy[i, 0]) * scalef, (xy[ind, 1] - xy[i, 1]) * scalef, head_width=0.1, head_length=0.2, fc='b', ec='b', alpha=arrow_alpha) if negative_NNN_arrows: todo = np.where(KLNNN[i, :] < -1e-12)[0] for ind in NLNNN[i, todo]: offset = (xy[ind, :] - xy[i, :]) * 0.5 ax.arrow(xy[i, 0] + offset[0], xy[i, 1] + offset[1], (xy[ind, 0] - xy[i, 0]) * 0.3, (xy[ind, 1] - xy[i, 1]) * 0.3, head_width=0.1, head_length=0.2, fc='r', ec='r', alpha=arrow_alpha) if bgcolor is not None: ax.set_axis_bgcolor(bgcolor) # set limits ax.axis('scaled') if xlimv != 'auto' and xlimv is not None: if isinstance(xlimv, tuple): ax.set_xlim(xlimv[0], xlimv[1]) else: print 'nvis: setting xlimv' ax.set_xlim(-xlimv, xlimv) else: ax.set_xlim(np.min(xy[:, 0]) - 2.5, np.max(xy[:, 0]) + 2.5) if ylimv != 'auto' and ylimv is not None: if isinstance(ylimv, tuple): print 'nvis: setting ylimv to tuple' ax.set_ylim(ylimv[0], ylimv[1]) else: ax.set_ylim(-ylimv, ylimv) else: print 'nvis: setting', min(xy[:, 1]), max(xy[:, 1]) ax.set_ylim(np.min(xy[:, 1]) - 2, np.max(xy[:, 1]) + 2) if title is not None: ax.set_title(title, fontsize=fontsize) if text_topleft is not None: ax.text(0.05, .98, text_topleft, horizontalalignment='right', verticalalignment='top', transform=ax.transAxes) if axis_off: ax.axis('off') if fname != 'none' and fname != '' and fname is not None: print 'nvis: saving figure: ', fname plt.savefig(fname) if show: plt.show() return [ax, axcb]
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