def intensity_1d(self, intensity, ms=20., lw=2., fs=20., title=r'$|\psi^{(j)}|^2$'): ''' Plot intensity for 1D lattices. :param intensity: np.array. Field intensity. :param ms: Positive Float. Default value 20. Markersize. :param lw: Positive Float. Default value 2. Linewith, connect sublattice sites. :param fs: Positive Float. Default value 20. Font size. :param title: String. Default value 'Intensity'. Figure title. ''' error_handling.ndarray(intensity, 'intensity', self.sys.lat.sites) error_handling.empty_ndarray(self.sys.lat.coor, 'sys.get_lattice') error_handling.positive_real(ms, 'ms') error_handling.positive_real(lw, 'lw') error_handling.positive_real(fs, 'fs') error_handling.string(title, 'title') fig, ax = plt.subplots() ax.set_xlabel('$j$', fontsize=fs) ax.set_ylabel(title, fontsize=fs) ax.set_title(title, fontsize=fs) for t, c in zip(self.sys.lat.tags, self.colors): plt.plot(self.sys.lat.coor['x'][self.sys.lat.coor['tag'] == t], intensity[self.sys.lat.coor['tag'] == t], '-o', color=c, ms=ms, lw=lw) plt.xlim([-1., self.sys.lat.sites]) plt.ylim([0., np.max(intensity)+.05]) fig.set_tight_layout(True) plt.draw() return fig
def get_propagation(self, ham, psi_init, steps, dz, norm=False): """ Get the time evolution. :param ham: sparse.csr_matrix. Tight-Binding Hamilonian. :param psi_init: np.ndarray. Initial state. :param steps: Positive Integer. Number of steps. :param dz: Positive number. Step. :param norm: Boolean. Default value True. Normalize the norm to 1 at each step. """ error_handling.empty_ham(ham) error_handling.ndarray(psi_init, "psi_init", self.lat.sites) error_handling.positive_int(steps, "steps") error_handling.positive_real(dz, "dz") error_handling.boolean(norm, "norm") self.steps = steps self.dz = dz self.prop = np.empty((self.lat.sites, self.steps), "c16") self.prop[:, 0] = psi_init diag = 1j * np.ones(self.lat.sites, "c16") A = (sparse.diags(diag, 0) - 0.5 * self.dz * ham).toarray() B = (sparse.diags(diag, 0) + 0.5 * self.dz * ham).toarray() mat = np.dot(LA.inv(A), B) for i in range(1, self.steps): self.prop[:, i] = np.dot(mat, self.prop[:, i - 1]) if norm: self.prop[:, i] /= np.abs(self.prop[:, i]).sum()
def get_propagation(self, ham, psi_init, steps, dz, norm=False): ''' Get the time evolution. :param ham: sparse.csr_matrix. Tight-Binding Hamilonian. :param psi_init: np.ndarray. Initial state. :param steps: Positive Integer. Number of steps. :param dz: Positive number. Step. :param norm: Boolean. Default value True. Normalize the norm to 1 at each step. ''' error_handling.empty_ham(ham) error_handling.ndarray(psi_init, 'psi_init', self.lat.sites) error_handling.positive_int(steps, 'steps') error_handling.positive_real(dz, 'dz') error_handling.boolean(norm, 'norm') self.steps = steps self.dz = dz self.prop = np.empty((self.lat.sites, self.steps), 'c16') self.prop[:, 0] = psi_init diag = 1j*np.ones(self.lat.sites, 'c16') A = (sparse.diags(diag, 0) - 0.5 * self.dz * ham).toarray() B = (sparse.diags(diag, 0) + 0.5 * self.dz * ham).toarray() mat = (np.dot(LA.inv(A), B)) for i in range(1, self.steps): self.prop[:, i] = np.dot(mat, self.prop[:, i-1]) if norm: self.prop[:, i] /= np.abs(self.prop[:, i]).sum()
def intensity_disk(self, intensity, s=200., fs=20., lims=None, figsize=None, title=r'$|\psi|^2$'): ''' Plot the intensity. Colormap with identical disk shape. :param intensity: np.array.Field intensity. :param s: Default value 200. Disk size. :param fs: Default value 20. Font size. :param lims: List. Default value None. Colormap limits. :param figsize: Tuple. Default value None. Figure size. :param title: String. Default value '$|\psi_n|^2$'. Title. :returns: * **fig** -- Figure. ''' error_handling.empty_ndarray(self.sys.lat.coor, 'sys.get_lattice') error_handling.ndarray(intensity, 'intensity', self.sys.lat.sites) error_handling.positive_real(s, 's') error_handling.positive_real(fs, 'fs') error_handling.tuple_2elem(figsize, 'figsize') error_handling.string(title, 'title') fig, ax = plt.subplots(figsize=figsize) plt.title(title, fontsize=fs + 5) map_red = plt.get_cmap('Reds') if lims is None: lims = [0., np.max(intensity)] y_ticks = ['0', 'max'] else: y_ticks = lims plt.scatter(self.sys.lat.coor['x'], self.sys.lat.coor['y'], c=intensity, s=s, cmap=map_red, vmin=lims[0], vmax=lims[1]) cbar = plt.colorbar(ticks=lims) ax.set_xticks([]) ax.set_yticks([]) ax.set_xlim( np.min(self.sys.lat.coor['x']) - 1., np.max(self.sys.lat.coor['x']) + 1.) ax.set_ylim( np.min(self.sys.lat.coor['y']) - 1., np.max(self.sys.lat.coor['y']) + 1.) cbar.ax.set_yticklabels([y_ticks[0], y_ticks[1]]) cbar.ax.tick_params(labelsize=fs) ax.set_aspect('equal') fig.set_tight_layout(True) plt.draw() return fig
def intensity_area(self, intensity, s=1000., lw=1., fs=20., plt_hop=False, figsize=None, title=r'$|\psi|^2$'): ''' Plot the intensity. Intensity propotional to disk shape. :param intensity: np.array. Intensity. :param s: Positive Float. Default value 1000. Circle size given by s * intensity. :param lw: Positive Float. Default value 1. Hopping linewidths. :param fs: Positive Float. Default value 20. Fontsize. :param plt_hop: Boolean. Default value False. Plot hoppings. :param figsize: Tuple. Default value None. Figure size. :param title: String. Default value '$|\psi_{ij}|^2$'. Figure title. :returns: * **fig** -- Figure. ''' error_handling.empty_ndarray(self.sys.lat.coor, 'sys.get_lattice') error_handling.ndarray(intensity, 'intensity', self.sys.lat.sites) error_handling.positive_real(s, 's') error_handling.positive_real(fs, 'fs') error_handling.boolean(plt_hop, 'plt_hop') error_handling.tuple_2elem(figsize, 'figsize') error_handling.string(title, 'title') fig, ax = plt.subplots() ax.set_xlabel('$i$', fontsize=fs) ax.set_ylabel('$j$', fontsize=fs) ax.set_title(title, fontsize=fs) if plt_hop: plt.plot([self.sys.lat.coor['x'][self.sys.hop['i'][:]], self.sys.lat.coor['x'][self.sys.hop['j'][:]]], [self.sys.lat.coor['y'][self.sys.hop['i'][:]], self.sys.lat.coor['y'][self.sys.hop['j'][:]]], 'k', lw=lw) for tag, color in zip(self.sys.lat.tags, self.colors): plt.scatter(self.sys.lat.coor['x'][self.sys.lat.coor['tag'] == tag], self.sys.lat.coor['y'][self.sys.lat.coor['tag'] == tag], s=100*s*intensity[self.sys.lat.coor['tag'] == tag], c=color, alpha=0.5) ax.set_aspect('equal') ax.axis('off') x_lim = [np.min(self.sys.lat.coor['x'])-2., np.max(self.sys.lat.coor['x'])+2.] y_lim = [np.min(self.sys.lat.coor['y'])-2., np.max(self.sys.lat.coor['y'])+2.] ax.set_xlim(x_lim) ax.set_ylim(y_lim) fig.set_tight_layout(True) plt.draw() return fig
def get_pumping(self, hams, psi_init, steps, dz, norm=True): ''' Get the time evolution with adiabatic pumpings. :param hams: List of sparse.csr_matrices. Tight-Binding Hamilonians. :param psi_init: np.ndarray. Initial state. :param steps: Positive integer. Number of steps. :param dz: Positive number. Step. :param norm: Boolean. Default value True. Normalize the norm to 1 at each step. ''' error_handling.get_pump(hams) error_handling.ndarray(psi_init, 'psi_init', self.lat.sites) error_handling.positive_int(steps, 'steps') error_handling.positive_real(dz, 'dz') error_handling.boolean(norm, 'norm') self.steps = steps self.dz = dz no = len(hams) self.prop = np.empty((self.lat.sites, self.steps), 'c16') self.prop[:, 0] = psi_init diag = 1j * np.ones(self.lat.sites, 'c16') delta = self.steps // (1 + no) A = (sparse.diags(diag, 0) - 0.5 * self.dz * hams[0]).toarray() B = (sparse.diags(diag, 0) + 0.5 * self.dz * hams[0]).toarray() mat = (np.dot(LA.inv(A), B)) # before pumping for i in range(1, delta): self.prop[:, i] = np.dot(mat, self.prop[:, i-1]) if norm: self.prop[:, i] /= np.abs(self.prop[:, i]).sum() # pumping c = np.linspace(0, 1, delta) for j in range(0, no-1): for i in range(0, delta): ham = (1-c[i])*hams[j]+c[i]*hams[j+1] A = (sparse.diags(diag, 0) - 0.5 * self.dz * ham).toarray() B = (sparse.diags(diag, 0) + 0.5 * self.dz * ham).toarray() mat = (np.dot(LA.inv(A), B)) self.prop[:, (j+1)*delta+i] = np.dot(mat, self.prop[:, (j+1)*delta+i-1]) if norm: self.prop[:, (j+1)*delta+i] /= \ np.abs(self.prop[:, (j+1)*delta+i]).sum() # after pumping j = no for i in range(0, self.steps - no*delta): self.prop[:, no*delta+i] = np.dot(mat, self.prop[:, no*delta+i-1]) if norm: self.prop[:, no*delta+i] /= np.abs(self.prop[:, no*delta+i]).sum()
def get_pumping(self, hams, psi_init, steps, dz, norm=True): """ Get the time evolution with adiabatic pumpings. :param hams: List of sparse.csr_matrices. Tight-Binding Hamilonians. :param psi_init: np.ndarray. Initial state. :param steps: Positive integer. Number of steps. :param dz: Positive number. Step. :param norm: Boolean. Default value True. Normalize the norm to 1 at each step. """ error_handling.get_pump(hams) error_handling.ndarray(psi_init, "psi_init", self.lat.sites) error_handling.positive_int(steps, "steps") error_handling.positive_real(dz, "dz") error_handling.boolean(norm, "norm") self.steps = steps self.dz = dz no = len(hams) self.prop = np.empty((self.lat.sites, self.steps), "c16") self.prop[:, 0] = psi_init diag = 1j * np.ones(self.lat.sites, "c16") delta = self.steps // (1 + no) A = (sparse.diags(diag, 0) - 0.5 * self.dz * hams[0]).toarray() B = (sparse.diags(diag, 0) + 0.5 * self.dz * hams[0]).toarray() mat = np.dot(LA.inv(A), B) # before pumping for i in range(1, delta): self.prop[:, i] = np.dot(mat, self.prop[:, i - 1]) if norm: self.prop[:, i] /= np.abs(self.prop[:, i]).sum() # pumping c = np.linspace(0, 1, delta) for j in range(0, no - 1): for i in range(0, delta): ham = (1 - c[i]) * hams[j] + c[i] * hams[j + 1] A = (sparse.diags(diag, 0) - 0.5 * self.dz * ham).toarray() B = (sparse.diags(diag, 0) + 0.5 * self.dz * ham).toarray() mat = np.dot(LA.inv(A), B) self.prop[:, (j + 1) * delta + i] = np.dot(mat, self.prop[:, (j + 1) * delta + i - 1]) if norm: self.prop[:, (j + 1) * delta + i] /= np.abs(self.prop[:, (j + 1) * delta + i]).sum() # after pumping j = no for i in range(0, self.steps - no * delta): self.prop[:, no * delta + i] = np.dot(mat, self.prop[:, no * delta + i - 1]) if norm: self.prop[:, no * delta + i] /= np.abs(self.prop[:, no * delta + i]).sum()
def intensity_disk(self, intensity, s=200., fs=20., lims=None, figsize=None, title=r'$|\psi|^2$'): ''' Plot the intensity. Colormap with identical disk shape. :param intensity: np.array.Field intensity. :param s: Default value 200. Disk size. :param fs: Default value 20. Font size. :param lims: List. Default value None. Colormap limits. :param figsize: Tuple. Default value None. Figure size. :param title: String. Default value '$|\psi_n|^2$'. Title. :returns: * **fig** -- Figure. ''' error_handling.empty_ndarray(self.sys.lat.coor, 'sys.get_lattice') error_handling.ndarray(intensity, 'intensity', self.sys.lat.sites) error_handling.positive_real(s, 's') error_handling.positive_real(fs, 'fs') error_handling.tuple_2elem(figsize, 'figsize') error_handling.string(title, 'title') fig, ax = plt.subplots(figsize=figsize) plt.title(title, fontsize=fs+5) map_red = plt.get_cmap('Reds') if lims is None: lims = [0., np.max(intensity)] y_ticks = ['0', 'max'] else: y_ticks = lims plt.scatter(self.sys.lat.coor['x'], self.sys.lat.coor['y'], c=intensity, s=s, cmap=map_red, vmin=lims[0], vmax=lims[1]) cbar = plt.colorbar(ticks=lims) ax.set_xticks([]) ax.set_yticks([]) ax.set_xlim(np.min(self.sys.lat.coor['x'])-1., np.max(self.sys.lat.coor['x'])+1.) ax.set_ylim(np.min(self.sys.lat.coor['y'])-1., np.max(self.sys.lat.coor['y'])+1.) cbar.ax.set_yticklabels([y_ticks[0], y_ticks[1]]) cbar.ax.tick_params(labelsize=fs) ax.set_aspect('equal') fig.set_tight_layout(True) plt.draw() return fig
def intensity_1d(self, intensity, ms=20., lw=2., fs=20., title=r'$|\psi^{(j)}|^2$'): ''' Plot intensity for 1D lattices. :param intensity: np.array. Field intensity. :param ms: Positive Float. Default value 20. Markersize. :param lw: Positive Float. Default value 2. Linewith, connect sublattice sites. :param fs: Positive Float. Default value 20. Font size. :param title: String. Default value 'Intensity'. Figure title. ''' error_handling.ndarray(intensity, 'intensity', self.sys.lat.sites) error_handling.empty_ndarray(self.sys.lat.coor, 'sys.get_lattice') error_handling.positive_real(ms, 'ms') error_handling.positive_real(lw, 'lw') error_handling.positive_real(fs, 'fs') error_handling.string(title, 'title') fig, ax = plt.subplots() ax.set_xlabel('$j$', fontsize=fs) ax.set_ylabel(title, fontsize=fs) ax.set_title(title, fontsize=fs) for t, c in zip(self.sys.lat.tags, self.colors): plt.plot(self.sys.lat.coor['x'][self.sys.lat.coor['tag'] == t], intensity[self.sys.lat.coor['tag'] == t], '-o', color=c, ms=ms, lw=lw) plt.xlim([-1., self.sys.lat.sites]) plt.ylim([0., np.max(intensity) + .05]) fig.set_tight_layout(True) plt.draw() return fig
def intensity_area(self, intensity, s=1000., lw=1., fs=20., plt_hop=False, figsize=None, title=r'$|\psi|^2$'): ''' Plot the intensity. Intensity propotional to disk shape. :param intensity: np.array. Intensity. :param s: Positive Float. Default value 1000. Circle size given by s * intensity. :param lw: Positive Float. Default value 1. Hopping linewidths. :param fs: Positive Float. Default value 20. Fontsize. :param plt_hop: Boolean. Default value False. Plot hoppings. :param figsize: Tuple. Default value None. Figure size. :param title: String. Default value '$|\psi_{ij}|^2$'. Figure title. :returns: * **fig** -- Figure. ''' error_handling.empty_ndarray(self.sys.lat.coor, 'sys.get_lattice') error_handling.ndarray(intensity, 'intensity', self.sys.lat.sites) error_handling.positive_real(s, 's') error_handling.positive_real(fs, 'fs') error_handling.boolean(plt_hop, 'plt_hop') error_handling.tuple_2elem(figsize, 'figsize') error_handling.string(title, 'title') fig, ax = plt.subplots() ax.set_xlabel('$i$', fontsize=fs) ax.set_ylabel('$j$', fontsize=fs) ax.set_title(title, fontsize=fs) if plt_hop: plt.plot([ self.sys.lat.coor['x'][self.sys.hop['i'][:]], self.sys.lat.coor['x'][self.sys.hop['j'][:]] ], [ self.sys.lat.coor['y'][self.sys.hop['i'][:]], self.sys.lat.coor['y'][self.sys.hop['j'][:]] ], 'k', lw=lw) for tag, color in zip(self.sys.lat.tags, self.colors): plt.scatter( self.sys.lat.coor['x'][self.sys.lat.coor['tag'] == tag], self.sys.lat.coor['y'][self.sys.lat.coor['tag'] == tag], s=100 * s * intensity[self.sys.lat.coor['tag'] == tag], c=color, alpha=0.5) ax.set_aspect('equal') ax.axis('off') x_lim = [ np.min(self.sys.lat.coor['x']) - 2., np.max(self.sys.lat.coor['x']) + 2. ] y_lim = [ np.min(self.sys.lat.coor['y']) - 2., np.max(self.sys.lat.coor['y']) + 2. ] ax.set_xlim(x_lim) ax.set_ylim(y_lim) fig.set_tight_layout(True) plt.draw() return fig