def dispersion_abtransition_gapbounds(lp, abvals=None): """ Parameters ---------- lp 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) meshfn = le.find_meshfn(lp) lat = lattice_class.Lattice(lp) lat.load(check=lp['check']) lp['ABDelta'] = np.max(abvals) mglat = MagneticGyroLattice(lat, lp) outname = dio.prepdir(meshfn) + 'dispersion_abtrans' + mglat.lp[ 'meshfn_exten'] + '_gapbounds' gapbounds_glob = glob.glob(outname + '.txt') if gapbounds_glob: # Load the text file and save the image gapbounds = np.loadtxt(outname + '.txt') plot_gapbounds(gapbounds[:, 0], gapbounds[:, 1:], outname + '.png', lp) else: # Compute the dispersions and save the image (occurs inside dispersion_abtransition omegas, kx, ky = dispersion_abtransition(lp, save_plots=False, return_omegas=True)
def dice_glat(lp, args): """make the OmK arrays to load when computing cherns for diced networks Example usage: python run_series.py -pro gyro_lattice_class -opts LT/hexagonal/-N/11/-shape/square/-dice_glat/-gridspacing/3.0 -var weakbond_val n1.0:0.1:0.05 Parameters ---------- lp args Returns ------- """ import lepm.line_segments as lsegs # Create a glat with bonds that are weakened in a gridlike fashion (bonds crossing gridlines are weak) meshfn = le.find_meshfn(lp) lp['meshfn'] = meshfn lat = lattice_class.Lattice(lp) lat.load() # Find where bonds cross gridlines gridspacing = args.gridspacing lp['OmKspec'] = 'gridlines{0:0.2f}'.format(gridspacing).replace('.', 'p') + \ 'strong{0:0.3f}'.format(lp['Omk']).replace('.', 'p').replace('-', 'n') + \ 'weak{0:0.3f}'.format(args.weakbond_val).replace('.', 'p').replace('-', 'n') maxval = max(np.max(np.abs(lat.xy[:, 0])), np.max(np.abs(lat.xy[:, 1]))) + 1 gridright = np.arange(gridspacing, maxval, gridspacing) gridleft = -gridright gridvals = np.hstack((gridleft, 0, gridright)) # Draw grid gridlinesH = np.array([[-maxval, gridv, maxval, gridv] for gridv in gridvals]) gridlinesV = np.array([[gridv, -maxval, gridv, maxval] for gridv in gridvals]) gridsegs = np.vstack((gridlinesH, gridlinesV)) print 'np.shape(gridlines) = ', np.shape(gridsegs) # Make the bond linesegments xy = lat.xy bondsegs = np.array([[xy[b[0], 0], xy[b[0], 1], xy[b[1], 0], xy[b[1], 1]] for b in lat.BL]) # get crossings print 'gridsegs = ', gridsegs does_intersect = lsegs.linesegs_intersect_linesegs(bondsegs, gridsegs) tmp_glat = GyroLattice(lat, lp) OmK = copy.deepcopy(tmp_glat.OmK) print 'Altering weak bonds --> ', args.weakbond_val for bond in lat.BL[does_intersect]: OmK[bond[0], np.where(lat.NL[bond[0]] == bond[1])] = args.weakbond_val glat = GyroLattice(lat, lp, OmK=OmK) glat.plot_OmK() if args.dice_eigval: glat.save_eigval_eigvect() glat.save_DOSmovie()
def localization(lp, args): """Load a periodic lattice from file, provide physics, and seek exponential localization of modes Example usage: python run_series.py -pro gyro_lattice_class -opts LT/hucentroid/-periodic/-NP/20/-localization/-save_eig -var AB 0.0:0.05:1.0 python run_series.py -pro gyro_lattice_class -opts LT/hyperuniform/-periodic/-NP/50/-localization/-save_eig -var Vpin 0.1/0.5/1.0/2.0/4.0/6.0 python run_series.py -pro gyro_lattice_class -opts LT/hyperuniform/-periodic/-NP/50/-DOSmovie/-save_eig -var Vpin 0.1/0.5/1.0/2.0/4.0/6.0 """ meshfn = le.find_meshfn(lp) lp['meshfn'] = meshfn lat = lattice_class.Lattice(lp) lat.load() extent = 2 * max(np.max(lat.xy[:, 0]), np.max(lat.xy[:, 1])) glat = GyroLattice(lat, lp) glat.save_localization(attribute=True, save_images=args.save_images, save_eigvect_eigval=args.save_eig) glat.plot_ill_dos(vmax=4. / extent, xlim=(0., 14.), ticks=[0, 2. / extent, 4. / extent], cbar_ticklabels=[0, r'$2/L$', r'$4/L$'], cbar_labelpad=15)
def ensure_all_gyro_lattices(self): """Ensure that all gyro lattices called for by self.meshfns are loaded. """ # todo: add the ability to change glat.lp parameters (like Omk) at function call-- specify as list of lp's or as single lp print 'Ensuring all gyro lattices...' for ii in range(len(self.meshfns)): meshfn = self.meshfns[ii] if isinstance(meshfn, list): try: meshfn = meshfn[0] except IndexError: print 'self.meshfns = ', self.meshfns print 'meshfn = ', meshfn raise IndexError('list index out of range') print 'Ensuring ', meshfn try: self.gyro_lattices[ii] append_glat = False except IndexError: append_glat = True try: # Check if lp['meshfn'] of gyro_lattice matches meshfn self.gyro_lattices[ii].lp['meshfn'] # print('Already have gyro_lattice defined for ii='+str(ii)+': ', test) except IndexError: lp = le.load_params(dio.prepdir(meshfn), 'lattice_params') lat = lattice_class.Lattice(lp=lp) lat.load(meshfn=meshfn) lp['Omk'] = -1.0 lp['Omg'] = -1.0 if append_glat: self.gyro_lattices.append( gyro_lattice_class.GyroLattice(lat, lp)) else: self.gyro_lattices[ii] = gyro_lattice_class.GyroLattice( lat, lp) glat = gyro_lattice_class.GyroLattice( lat, self.gyro_lattices[ii].lp) self.gyro_lattices[ii] = glat
""" # Collate botts for one lattice with a mgyro_lattice parameter that varies between instances of that lattice lp_master = copy.deepcopy(lp) paramV = sf.string_sequence_to_numpy_array(args.paramV, dtype=float) if args.lpparam == 'delta': # vary delta between lattices deltaV = np.arange(0.7, 1.31, 0.1) deltaV = np.hstack((0.667, deltaV)) bmgcollcoll = BottMagneticGyroCollectionCollection() for delta in deltaV: lp = copy.deepcopy(lp_master) lp['delta_lattice'] = '{0:0.3f}'.format(delta) meshfn = le.find_meshfn(lp) lp['meshfn'] = meshfn print '\n\n\nlp[meshfn] = ', lp['meshfn'] lat = lattice_class.Lattice(lp) lat.load() mgc = magnetic_gyro_collection.MagneticGyroCollection() lp_submaster = copy.deepcopy(lp) # Need only to add one single mgryo_lattice # for glatpval in paramV: # lpii = copy.deepcopy(lp_submaster) # lpii[args.glatparam] = glatpval # mglat = magnetic_gyro_lattice_class.MagneticGyroLattice(lat, lpii) # mglat.load() # mgc.add_mgyro_lattice(mglat) lpii = copy.deepcopy(lp_submaster) lpii[args.glatparam] = paramV[0] mglat = magnetic_gyro_lattice_class.MagneticGyroLattice(lat, lpii) mglat.load() mgc.add_mgyro_lattice(mglat)
'origin': origin, 'NP_load': args.NP_load, 'percolation_density': args.percolation_density, 'thres': args.thres, 'trimbound_thres': args.trimbound_thres, 'aratio': args.aratio, 'ABDelta': args.ABDelta, 'spreading_time': args.spreading_time, 'spreading_dt': args.spreading_dt, 'kicksz': args.kicksz, 'intparam': args.intparam, } ####################### print 'LatticeTop = ', latticetop lattice = lattice_class.Lattice(lp) print '\nBuilding lattice...' lattice.build() print '\nSaving lattice...' lattice.save(skip_polygons=args.skip_polygons, check=lp['check']) if args.nice_plot: print 'Saving nice BW plot...' lattice.plot_BW_lat(meshfn=dio.prepdir(lattice.lp['meshfn'])) infodir = lattice.lp['meshfn'] + '/' if args.bondL_histogram: print 'Creating bond length histogram...' lattice.bond_length_histogram(fig=None, ax=None, outdir=infodir,
dmyk = 0 for netconf in netconfv: print 'considering network configuration = ', netconf for pinconf in confv: lpnew = copy.deepcopy(lp) cpnew = copy.deepcopy(cp) lpnew['NH'] = int(np.sqrt(NN)) lpnew['NV'] = int(np.sqrt(NN)) lpnew['NP_load'] = NN lpnew['conf'] = netconf lpnew['pinconf'] = pinconf lpnew['V0_pin_gauss'] = vpin # cpnew['omegac'] = bcfns.gap_midpoints_honeycomb(delta * np.pi) lat = lattice_class.Lattice(lp=lpnew) try: lat.load() except IOError: lat.build() lat.save(skip_polygons=True) nsitesii = len(lat.xy) print 'kk, ii, jj, dmyk = ', kk, ii, jj, dmyk print 'vpin->', vpin, ' NN->', NN glat = gyro_lattice_class.GyroLattice(lat, lp=lpnew) chern = kitaev_chern_class.KitaevChern(glat, cp=cpnew) chern.get_kitaev_chern(skip_paramsregs=True)
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
'theta_lattice': args.theta, 'eta': args.eta, 'huID': args.hyperuniform_number, 'z': args.target_z, 'Ndefects': args.Ndefects, 'Bvec': args.Bvec, 'dislocxy': (args.dislocation_xy.split('/')), 'cutz_method': args.cutz_method, 'origin': np.array([0., 0.]), 'source': 'hexner', 'percolation_density': args.percolation_density, } lat = lattice_class.Lattice(lp=lp, xy=np.array([]), NL=np.array([]), KL=np.array([]), BL=np.array([]), polygons=None) lat.load() # xyload, NLload, KLload, meshfn = le.find_lattice(lp) # xy = xyload.astype(float) # NL = NLload.astype(int) # KL = KLload.astype(int) # BL = le.NL2BL(NL, KL) xy = lat.xy NL = lat.NL KL = lat.KL BL = lat.BL meshfn = lat.lp['meshfn']
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 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 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 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)
def gap_scaling(lp, args): """ Parameters ---------- lp args Returns ------- """ par1 = 'delta' par1v = np.pi * np.arange(0.667, 1.25, 0.3) par2 = 'Omg' par2v = np.arange(1.0, 100., 10.) ** 2 if args.N == 10: print 'set N == 10: choosing ev1, ev2' ev1 = 299 ev2 = 300 elif args.N == 8: print 'set N == 8: choosing ev1, ev2' ev1 = 191 ev2 = 192 elif args.N == 6: print 'set N == 6: choosing ev1, ev2' ev1 = 107 ev2 = 108 gapsz = np.zeros((len(par1v), len(par2v)), dtype=float) eigvals = np.zeros((2, len(par2v)), dtype=float) kk = 0 for p1 in par1v: lp[par1] = p1 lat = lattice_class.Lattice(lp) print 'Building lattice...' lat.build() diff = np.zeros(len(par2v)) jj = 0 for p2 in par2v: lp[par2] = p2 glat = GyroLattice(lat, lp) eigval, eigvect = glat.eig_vals_vects(attribute=False) print 'eigval[ev1] = ', eigval[ev1] print 'eigval[ev2] = ', eigval[ev2] sys.exit() eigvals[0, jj] = np.imag(eigval[ev1]) eigvals[1, jj] = np.imag(eigval[ev2]) diff[jj] = np.abs(np.imag(eigval[ev1] - eigval[ev2])) jj += 1 gapsz[kk] = diff plt.plot(par2v, np.log10(abs(diff)), '.-', label=str(par1v)) plt.xlabel(r'$\Omega_g$') plt.ylabel(r'Gap width $\log_{10} W$') # plt.pause(0.01) plt.show() plt.clf() print 'par2v = ', par2v # print 'eigvals = ', eigvals plt.plot(par2v, eigvals[0], '.-') plt.plot(par2v, eigvals[1], '.-') plt.show() kk += 1 plt.show()
def build_select_region(lp): """ Parameters ---------- lp Returns ------- """ lpnew = copy.deepcopy(lp) lpnew['LatticeTop'] = lp['LatticeTop'].split('selregion_')[-1] lpnew['check'] = False print 'lpnew[LatticeTop] = ', lpnew['LatticeTop'] lattice = lattice_class.Lattice(lpnew) print '\nBuilding lattice...' lattice.build() # xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten = build_kagome_isocent(lp) xy = lattice.xy NL = lattice.NL KL = lattice.KL BL = lattice.BL PVx = lattice.PVx PVy = lattice.PVy PVxydict = lattice.PVxydict try: LVUC = lattice.lp['LVUC'] LV = lattice.lp['LV'] UC = lattice.lp['UC'] except: LVUC = 'none' LV = 'none' UC = 'none' LL = lattice.lp['LL'] old_lattice_exten = lattice.lp['lattice_exten'] # Display lattice ax = le.display_lattice_2D(xy, BL, NL=NL, KL=KL, PVxydict=PVxydict, PVx=PVx, PVy=PVy, title='Choose roi polygon', xlimv=None, ylimv=None, colorz=True, ptcolor=None, ptsize=10, close=False, colorpoly=False, viewmethod=False, labelinds=False, colormap='BlueBlackRed', bgcolor='#FFFFFF', axis_off=False, linewidth=0.0, edgecolors=None, check=False) # let user draw ROI roi = roipoly(ax=ax, roicolor='r') print 'roi = ', roi print 'x = ', roi.allxpoints print 'y = ', roi.allypoints roi = np.dstack((roi.allxpoints, roi.allypoints))[0] inpoly = dh.inds_in_polygon(xy, roi) print 'inpoly = ', inpoly if lp['check']: plt.plot(xy[inpoly, 0], xy[inpoly, 1], 'b.') plt.show() xy, NL, KL, BL = le.remove_pts(inpoly, xy, BL, check=lp['check']) if lp['periodicBC']: PV = le.PVxydict2PV(PVxydict) PVxydict = le.BL2PVxydict(BL, xy, PV) # If cropping the points has cut off all periodic BCs, update lp to reflect this if len(PVxydict) == 0: lp['periodicBC'] = False if LVUC is not None and LVUC is not 'none': LVUC = LVUC[inpoly] BBox = roi lattice_exten = 'selregion_' + old_lattice_exten + '_NP{0:06d}'.format( len(xy)) xy -= np.mean(xy, axis=0) if lp['check']: ax = le.display_lattice_2D(xy, BL, NL=NL, KL=KL, PVxydict=PVxydict, PVx=PVx, PVy=PVy, title='Cropped network', xlimv=None, ylimv=None, colorz=True, ptcolor=None, ptsize=10, close=False, colorpoly=False, viewmethod=False, labelinds=False, colormap='BlueBlackRed', bgcolor='#FFFFFF', axis_off=False, linewidth=0.0, edgecolors=None, check=False) return xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp