def read_field_data(self): """Read 2D field """ self.xl, self.xr = self.field_range[0:2] self.zb, self.zt = self.field_range[2:4] kwargs = { "current_time": self.ct_field, "xl": self.xl, "xr": self.xr, "zb": self.zb, "zt": self.zt } fname_field = self.root_dir + 'data/' + self.var_field + '.gda' fname_Ay = self.root_dir + 'data/Ay.gda' self.x1, self.z1, data = read_2d_fields(self.pic_info, fname_field, **kwargs) ng = 5 kernel = np.ones((ng, ng)) / float(ng * ng) self.fdata1 = signal.convolve2d(data, kernel) self.x1, self.z1, self.Ay1 = read_2d_fields(self.pic_info, fname_Ay, **kwargs) self.nx1, = self.x1.shape self.nz1, = self.z1.shape self.xmax1 = np.max(self.x1) self.zmax1 = np.max(self.z1) self.xmin1 = np.min(self.x1) self.zmin1 = np.min(self.z1)
def calc_force_charge_efield_single(job_id, drange): print job_id ct = job_id data_dir = '../data/force/' mkdir_p(data_dir) force_single = np.zeros(3) kwargs = {"current_time": ct, "xl": 0, "xr": 200, "zb": -50, "zt": 50} fname1 = root_dir + 'data/ne.gda' x, z, ne_all = read_2d_fields(pic_info, fname1, **kwargs) fname2 = root_dir + 'data/ni.gda' x, z, ni_all = read_2d_fields(pic_info, fname2, **kwargs) fname = root_dir + 'data/ex.gda' x, z, ex_all = read_2d_fields(pic_info, fname, **kwargs) fname = root_dir + 'data/ey.gda' x, z, ey_all = read_2d_fields(pic_info, fname, **kwargs) fname = root_dir + 'data/ez.gda' x, z, ez_all = read_2d_fields(pic_info, fname, **kwargs) nx, = x.shape nz, = z.shape xs = int(drange[0] * nx) xe = int(drange[1] * nx) zs = int(drange[2] * nz) ze = int(drange[3] * nz) ne = ne_all[zs:ze, xs:xe] ni = ni_all[zs:ze, xs:xe] ex = ex_all[zs:ze, xs:xe] ey = ey_all[zs:ze, xs:xe] ez = ez_all[zs:ze, xs:xe] ntot = ni - ne force_single[0] = np.sum(ntot * ex) force_single[1] = np.sum(ntot * ey) force_single[2] = np.sum(ntot * ez) fname = data_dir + 'force_' + str(ct) + '.dat' force_single.tofile(fname)
def get_temperature_cut(run_name, root_dir, pic_info, ct): """get temperature cut along a line """ kwargs = {"current_time": ct, "xl": 0, "xr": 200, "zb": -1, "zt": 1} fnames_e = ['pe-xx', 'pe-yy', 'pe-zz', 'ne'] fnames_i = ['pi-xx', 'pi-yy', 'pi-zz', 'ni'] pe = 0.0 pi = 0.0 for name in fnames_e[0:3]: fname = root_dir + 'data/' + name + '.gda' x, z, data = read_2d_fields(pic_info, fname, **kwargs) pe += data fname = root_dir + 'data/' + fnames_e[3] + '.gda' x, z, nrho = read_2d_fields(pic_info, fname, **kwargs) te = pe / nrho / 3.0 for name in fnames_i[0:3]: fname = root_dir + 'data/' + name + '.gda' x, z, data = read_2d_fields(pic_info, fname, **kwargs) pi += data fname = root_dir + 'data/' + fnames_i[3] + '.gda' x, z, nrho = read_2d_fields(pic_info, fname, **kwargs) ti = pi / nrho / 3.0 nx, = x.shape nz, = z.shape return (x, z, te[nz / 2, :], ti[nz / 2, :])
def read_and_plot(ct, filename): """ Read 2D field and do contour plot. Args: ct: current time frame. filename: the file name including its path. """ kwargs = {"current_time": ct, "xl": 0, "xr": 200, "zb": -50, "zt": 50} x, z, num_rho = read_2d_fields(pic_info, filename, **kwargs) x, z, Ay = read_2d_fields(pic_info, "../data/Ay.gda", **kwargs) nx, = x.shape nz, = z.shape xmin = np.min(x) xmax = np.max(x) zmin = np.min(z) zmax = np.max(z) kwargs_plot = { "xstep": 2, "zstep": 2, "is_log": True, "vmin": -1, "vmax": 1 } xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] data = num_rho[0:nz:zstep, 0:nx:xstep] print "Maximum and minimum of the data: ", np.max(data), np.min(data) im1 = ax1.imshow( data, cmap=plt.cm.seismic, extent=[xmin, xmax, zmin, zmax], aspect='auto', origin='lower', vmin=kwargs_plot["vmin"], vmax=kwargs_plot["vmax"], interpolation='bicubic') # norm=LogNorm(vmin=kwargs_plot["vmin"], # vmax=kwargs_plot["vmax"])) ax1.contour( x[0:nx:xstep], z[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='black', linewidths=0.5) ax1.set_ylabel(r'$z/d_i$', fontdict=font, fontsize=32) ax1.set_xlabel(r'$x/d_i$', fontdict=font, fontsize=32) ax1.tick_params(labelsize=32) t_wci = current_time * pic_info.dt_fields title = r'$t = ' + "{:10.1f}".format(t_wci) + '/\Omega_{ci}$' ax1.set_title(title, fontdict=font, fontsize=32) return im1
def read_and_plot(ct, filename): """ Read 2D field and do contour plot. Args: ct: current time frame. filename: the file name including its path. """ kwargs = {"current_time": ct, "xl": 0, "xr": 200, "zb": -50, "zt": 50} x, z, num_rho = read_2d_fields(pic_info, filename, **kwargs) x, z, Ay = read_2d_fields(pic_info, "../data/Ay.gda", **kwargs) nx, = x.shape nz, = z.shape xmin = np.min(x) xmax = np.max(x) zmin = np.min(z) zmax = np.max(z) kwargs_plot = { "xstep": 2, "zstep": 2, "is_log": True, "vmin": -1, "vmax": 1 } xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] data = num_rho[0:nz:zstep, 0:nx:xstep] print "Maximum and minimum of the data: ", np.max(data), np.min(data) im1 = ax1.imshow(data, cmap=plt.cm.seismic, extent=[xmin, xmax, zmin, zmax], aspect='auto', origin='lower', vmin=kwargs_plot["vmin"], vmax=kwargs_plot["vmax"], interpolation='bicubic') # norm=LogNorm(vmin=kwargs_plot["vmin"], # vmax=kwargs_plot["vmax"])) ax1.contour(x[0:nx:xstep], z[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='black', linewidths=0.5) ax1.set_ylabel(r'$z/d_i$', fontdict=font, fontsize=32) ax1.set_xlabel(r'$x/d_i$', fontdict=font, fontsize=32) ax1.tick_params(labelsize=32) t_wci = current_time * pic_info.dt_fields title = r'$t = ' + "{:10.1f}".format(t_wci) + '/\Omega_{ci}$' ax1.set_title(title, fontdict=font, fontsize=32) return im1
def check_exb(run_dir, pic_info, tframe): """ Check calculated ExB drift """ kwargs = {"current_time": tframe, "xl": 0, "xr": pic_info.lx_di, "zb": -0.5 * pic_info.lz_di, "zt": 0.5 * pic_info.lz_di} size_one_frame = pic_info.nx * pic_info.nz * 4 fname = run_dir + "data1/vexb_x.gda" x, z, vexbx1 = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data1/vexb_y.gda" x, z, vexby1 = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data1/vexb_z.gda" x, z, vexbz1 = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data/ex.gda" x, z, ex = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data/ey.gda" x, z, ey = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data/ez.gda" x, z, ez = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data/bx.gda" x, z, bx = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data/by.gda" x, z, by = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data/bz.gda" x, z, bz = read_2d_fields(pic_info, fname, **kwargs) ib2 = 1.0 / (bx**2 + by**2 + bz**2) vexbx2 = (ey * bz - ez * by) * ib2 vexby2 = (ez * bx - ex * bz) * ib2 vexbz2 = (ex * by - ey * bx) * ib2 p1 = plt.imshow(vexbz2 - vexbz1, cmap=plt.cm.jet, # extent=[xmin, xmax, zmin, zmax], # vmin=vmin, vmax=vmax, aspect='auto', origin='lower', interpolation='bicubic') plt.show()
def plot_charge_neutrality(pic_info, current_time): """Plot compression related terms. Args: pic_info: namedtuple for the PIC simulation information. species: 'e' for electrons, 'i' for ions. current_time: current time frame. """ kwargs = { "current_time": current_time, "xl": 0, "xr": 400, "zb": -100, "zt": 100 } x, z, ne = read_2d_fields(pic_info, "../../data/ne.gda", **kwargs) x, z, ni = read_2d_fields(pic_info, "../../data/ni.gda", **kwargs) x, z, Ay = read_2d_fields(pic_info, "../../data/Ay.gda", **kwargs) nx, = x.shape nz, = z.shape width = 0.75 height = 0.76 xs = 0.12 ys = 0.95 - height gap = 0.05 fig = plt.figure(figsize=[10, 4]) ax1 = fig.add_axes([xs, ys, width, height]) kwargs_plot = {"xstep": 1, "zstep": 1, "vmin": -1, "vmax": 1} xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] p1, cbar1 = plot_2d_contour(x, z, (ni - ne) / (ne + ni), ax1, fig, **kwargs_plot) # p1.set_cmap(cmaps.inferno) p1.set_cmap(plt.cm.seismic) ax1.contour( x[0:nx:xstep], z[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='black', linewidths=0.5) ax1.set_ylabel(r'$z/d_i$', fontdict=font, fontsize=24) ax1.set_xlabel(r'$x/d_i$', fontdict=font, fontsize=24) ax1.tick_params(labelsize=20) cbar1.ax.set_ylabel(r'$(n_i-n_e)/(n_i+n_e)$', fontdict=font, fontsize=24) # cbar1.set_ticks(np.arange(-0.1, 0.15, 0.1)) cbar1.ax.tick_params(labelsize=20) if not os.path.isdir('../img/'): os.makedirs('../img/') fname = '../img/q_' + str(current_time).zfill(3) + '.jpg' fig.savefig(fname, dpi=200) plt.show()
def plot_charge_neutrality(pic_info, current_time): """Plot compression related terms. Args: pic_info: namedtuple for the PIC simulation information. species: 'e' for electrons, 'i' for ions. current_time: current time frame. """ kwargs = { "current_time": current_time, "xl": 0, "xr": 400, "zb": -100, "zt": 100 } x, z, ne = read_2d_fields(pic_info, "../../data/ne.gda", **kwargs) x, z, ni = read_2d_fields(pic_info, "../../data/ni.gda", **kwargs) x, z, Ay = read_2d_fields(pic_info, "../../data/Ay.gda", **kwargs) nx, = x.shape nz, = z.shape width = 0.75 height = 0.76 xs = 0.12 ys = 0.95 - height gap = 0.05 fig = plt.figure(figsize=[10, 4]) ax1 = fig.add_axes([xs, ys, width, height]) kwargs_plot = {"xstep": 1, "zstep": 1, "vmin": -1, "vmax": 1} xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] p1, cbar1 = plot_2d_contour(x, z, (ni - ne) / (ne + ni), ax1, fig, **kwargs_plot) # p1.set_cmap(cmaps.inferno) p1.set_cmap(plt.cm.seismic) ax1.contour(x[0:nx:xstep], z[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='black', linewidths=0.5) ax1.set_ylabel(r'$z/d_i$', fontdict=font, fontsize=24) ax1.set_xlabel(r'$x/d_i$', fontdict=font, fontsize=24) ax1.tick_params(labelsize=20) cbar1.ax.set_ylabel(r'$(n_i-n_e)/(n_i+n_e)$', fontdict=font, fontsize=24) # cbar1.set_ticks(np.arange(-0.1, 0.15, 0.1)) cbar1.ax.tick_params(labelsize=20) if not os.path.isdir('../img/'): os.makedirs('../img/') fname = '../img/q_' + str(current_time).zfill(3) + '.jpg' fig.savefig(fname, dpi=200) plt.show()
def smooth_emf(run_dir, pic_info, emf_name, tframe, coords): """ Smooth electric and magnetic field """ kwargs = { "current_time": tframe, "xl": 0, "xr": pic_info.lx_di, "zb": -0.5 * pic_info.lz_di, "zt": 0.5 * pic_info.lz_di } size_one_frame = pic_info.nx * pic_info.nz * 4 # fname = run_dir + "data/original_data/" + emf_name + ".gda" fname = run_dir + "data1/original_data/" + emf_name + ".gda" statinfo = os.stat(fname) file_size = statinfo.st_size if file_size < size_one_frame * (tframe + 1): return else: x, z, fdata = read_2d_fields(pic_info, fname, **kwargs) sigma = 5 fdata = median_filter(fdata, sigma) # fname = run_dir + "data/" + emf_name + ".gda" fname = run_dir + "data1/" + emf_name + ".gda" with open(fname, 'a+') as f: offset = size_one_frame * tframe f.seek(offset, os.SEEK_SET) fdata.tofile(f)
def histogram_field(pic_info, var_name, fname, **kwargs): """Plot a histogram of a field. Args: pic_info: namedtuple for the PIC simulation information. var_name: variable name. fname: file name. """ x, z, field_data = read_2d_fields(pic_info, fname, **kwargs) dmax = np.max(field_data) dmin = np.min(field_data) dmin = -100.0 dmax = 100.0 nb = 1000 print np.sum(field_data) bins = np.linspace(dmin, dmax, nb) hist, bin_edges = np.histogram(field_data, bins) print np.sum(hist) print 'Maximum and Minimum of the field: ', dmax, dmin fig = plt.figure(figsize=[7, 5]) width = 0.8 height = 0.8 ax = fig.add_axes([0.12, 0.15, width, height]) hist_f = np.array(hist, dtype=np.float64) hist_f /= np.max(hist_f) p1 = ax.semilogy(bins[:nb - 1], hist_f, linewidth=2) ax.tick_params(labelsize=16) ax.set_xlabel(var_name, fontdict=font, fontsize=20) qname = r'$f($' + var_name + '$)$' ax.set_ylabel(qname, fontdict=font, fontsize=20) plt.show()
def calc_reconnection_rate(base_dir): """Calculate reconnection rate. Args: base_dir: the directory base. """ pic_info = pic_information.get_pic_info(base_dir) ntf = pic_info.ntf phi = np.zeros(ntf) fname = base_dir + 'data/Ay.gda' for ct in range(ntf): kwargs = {"current_time": ct, "xl": 0, "xr": 200, "zb": -1, "zt": 1} x, z, Ay = read_2d_fields(pic_info, fname, **kwargs) nz, = z.shape # max_ay = np.max(np.sum(Ay[nz/2-1:nz/2+1, :], axis=0)/2) # min_ay = np.min(np.sum(Ay[nz/2-1:nz/2+1, :], axis=0)/2) max_ay = np.max(Ay[nz / 2 - 1:nz / 2 + 1, :]) min_ay = np.min(Ay[nz / 2 - 1:nz / 2 + 1, :]) phi[ct] = max_ay - min_ay nk = 3 phi = signal.medfilt(phi, kernel_size=nk) dtwpe = pic_info.dtwpe dtwce = pic_info.dtwce dtwci = pic_info.dtwci mime = pic_info.mime dtf_wpe = pic_info.dt_fields * dtwpe / dtwci reconnection_rate = np.gradient(phi) / dtf_wpe b0 = pic_info.b0 va = dtwce * math.sqrt(1.0 / mime) / dtwpe reconnection_rate /= b0 * va reconnection_rate[-1] = reconnection_rate[-2] tfields = pic_info.tfields return (tfields, reconnection_rate)
def values_along_cut(fname, current_time, lcorner, weights): """Values along a straight cut. Args: fname: the filename of the data. current_time: current time frame. lcorner: the indices of the lower left of the cells in which the line points are. weights: the weight for 2D linear interpolation. Returns: dvalue: the values of the data along a cut. """ kwargs = { "current_time": current_time, "xl": 0, "xr": 200, "zb": -50, "zt": 50 } x, z, data = read_2d_fields(pic_info, fname, **kwargs) tmp, npoints = lcorner.shape dvalue = np.zeros(npoints) for i in range(npoints): dvalue[i] += data[lcorner[1, i], lcorner[0, i]] * weights[0, i] dvalue[i] += data[lcorner[1, i], lcorner[0, i] + 1] * weights[1, i] dvalue[i] += data[lcorner[1, i] + 1, lcorner[0, i] + 1] * weights[2, i] dvalue[i] += data[lcorner[1, i] + 1, lcorner[0, i]] * weights[3, i] return dvalue
def bulk_energy_distribution(pic_info, species): """Get the distribution of bulk flow energy. Args: pic_info: namedtuple for the PIC simulation information. species: 'e' for electrons, 'i' for ions. """ if species == 'e': ptl_mass = 1.0 else: ptl_mass = pic_info.mime nbins = 100 ebins, nrho_bins = set_energy_density_bins(nbins) ntf = pic_info.ntf ehist = np.zeros((ntf, nbins - 1)) erho_hist = np.zeros((ntf, nbins - 1)) nhist = np.zeros((ntf, nbins - 1)) for ct in range(ntf): kwargs = {"current_time": ct, "xl": 0, "xr": 200, "zb": -50, "zt": 50} fname = "../../data/u" + species + "x.gda" x, z, ux = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/u" + species + "y.gda" x, z, uy = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/u" + species + "z.gda" x, z, uz = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/n" + species + ".gda" x, z, nrho = read_2d_fields(pic_info, fname, **kwargs) bene = 0.5 * ptl_mass * (ux * ux + uy * uy + uz * uz) bene_density = 0.5 * ptl_mass * nrho * (ux * ux + uy * uy + uz * uz) ehist[ct, :], bin_edges = np.histogram(bene, bins=ebins, density=True) erho_hist[ct, :], bin_edges = np.histogram(bene_density, bins=ebins, density=True) nhist[ct, :], bin_edges = np.histogram(nrho, bins=nrho_bins, density=True) f = open('../data/bulk_energy.dat', 'w') np.savetxt(f, ehist) f.close() f = open('../data/bulk_energy_density.dat', 'w') np.savetxt(f, erho_hist) f.close() f = open('../data/number_density.dat', 'w') np.savetxt(f, nhist) f.close()
def bulk_energy_distribution(pic_info, species): """Get the distribution of bulk flow energy. Args: pic_info: namedtuple for the PIC simulation information. species: 'e' for electrons, 'i' for ions. """ if species == 'e': ptl_mass = 1.0 else: ptl_mass = pic_info.mime nbins = 100 ebins, nrho_bins = set_energy_density_bins(nbins) ntf = pic_info.ntf ehist = np.zeros((ntf, nbins - 1)) erho_hist = np.zeros((ntf, nbins - 1)) nhist = np.zeros((ntf, nbins - 1)) for ct in range(ntf): kwargs = {"current_time": ct, "xl": 0, "xr": 200, "zb": -50, "zt": 50} fname = "../../data/u" + species + "x.gda" x, z, ux = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/u" + species + "y.gda" x, z, uy = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/u" + species + "z.gda" x, z, uz = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/n" + species + ".gda" x, z, nrho = read_2d_fields(pic_info, fname, **kwargs) bene = 0.5 * ptl_mass * (ux * ux + uy * uy + uz * uz) bene_density = 0.5 * ptl_mass * nrho * (ux * ux + uy * uy + uz * uz) ehist[ct, :], bin_edges = np.histogram(bene, bins=ebins, density=True) erho_hist[ct, :], bin_edges = np.histogram( bene_density, bins=ebins, density=True) nhist[ct, :], bin_edges = np.histogram( nrho, bins=nrho_bins, density=True) f = open('../data/bulk_energy.dat', 'w') np.savetxt(f, ehist) f.close() f = open('../data/bulk_energy_density.dat', 'w') np.savetxt(f, erho_hist) f.close() f = open('../data/number_density.dat', 'w') np.savetxt(f, nhist) f.close()
def smooth_interp_emf(run_dir, pic_info, eb_field_name, tframe, coords): """ Smooth electric and magnetic field and also interpolate them to grid locations where hydro quantities are. """ kwargs = { "current_time": tframe, "xl": 0, "xr": pic_info.lx_di, "zb": -0.5 * pic_info.lz_di, "zt": 0.5 * pic_info.lz_di } size_one_frame = pic_info.nx * pic_info.nz * 4 fname = run_dir + "data/" + eb_field_name + "_original.gda" statinfo = os.stat(fname) file_size = statinfo.st_size if file_size < size_one_frame * (tframe + 1): return else: x, z, fdata = read_2d_fields(pic_info, fname, **kwargs) if 'ex' in eb_field_name or 'bz' in eb_field_name: f = MultilinearInterpolator(coords["smin_ex_bz"], coords["smax_ex_bz"], coords["orders"], dtype=np.float32) elif 'ez' in eb_field_name or 'bx' in eb_field_name: f = MultilinearInterpolator(coords["smin_ez_bx"], coords["smax_ez_bx"], coords["orders"], dtype=np.float32) elif 'ey' in eb_field_name: f = MultilinearInterpolator(coords["smin_h"], coords["smax_h"], coords["orders"], dtype=np.float32) else: f = MultilinearInterpolator(coords["smin_by"], coords["smax_by"], coords["orders"], dtype=np.float32) f.set_values(np.atleast_2d(np.transpose(fdata).flatten())) nx = pic_info.nx nz = pic_info.nz fdata = f(coords["coord"]) fdata = np.transpose(f(coords["coord"]).reshape((nx, nz))) # only smooth electric field if any(ename in eb_field_name for ename in ['ex', 'ey', 'ez']): sigma = 3 fdata = gaussian_filter(fdata, sigma) fname = run_dir + "data/" + eb_field_name + ".gda" with open(fname, 'a+') as f: offset = size_one_frame * tframe f.seek(offset, os.SEEK_SET) fdata.tofile(f)
def update_field(self, val): self.ct = self.field_slider.val kwargs = { "current_time": self.ct, "xl": 0, "xr": 400, "zb": -100, "zt": 100 } fname = '../../data/' + var_field + '.gda' x, z, self.fdata = read_2d_fields(self.pic_info, fname, **kwargs) self.im1.set_data(self.fdata) self.fig.canvas.draw_idle()
def plot_extra_contour(self): if (self.xmax_b > self.pic_info.lx_di): ex = self.xmax_b - self.pic_info.lx_di kwargs = { "current_time": self.ct, "xl": 0, "xr": ex, "zb": self.field_range[2], "zt": self.field_range[3] } fname_field = '../../data/' + self.var_field + '.gda' fname_Ay = '../../data/Ay.gda' x, z, fdata = read_2d_fields(self.pic_info, fname_field, **kwargs) ng = 5 kernel = np.ones((ng, ng)) / float(ng * ng) fdata = signal.convolve2d(fdata, kernel) x, z, Ay = read_2d_fields(self.pic_info, fname_Ay, **kwargs) nx, = x.shape nz, = z.shape ex_grid = ex / self.pic_info.dx_di + 1 xmin = self.pic_info.lx_di xmax = xmin + ex self.im1 = self.xz_axis.imshow( fdata[0:nz:self.zst, 0:nx:self.xst], cmap=self.cmap, extent=[xmin, xmax, self.zmin1, self.zmax1], aspect='auto', origin='lower', vmin=-self.vmax, vmax=self.vmax, interpolation='bicubic') x += xmin self.xz_axis.contour( x[0:nx:self.xst], z[0:nz:self.zst], Ay[0:nz:self.zst, 0:nx:self.xst], colors='black', linewidths=0.5, levels=self.levels)
def check_exb(run_dir, pic_info, tframe): """ Check calculated ExB drift """ kwargs = { "current_time": tframe, "xl": 0, "xr": pic_info.lx_di, "zb": -0.5 * pic_info.lz_di, "zt": 0.5 * pic_info.lz_di } size_one_frame = pic_info.nx * pic_info.nz * 4 fname = run_dir + "data1/vexb_x.gda" x, z, vexbx1 = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data1/vexb_y.gda" x, z, vexby1 = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data1/vexb_z.gda" x, z, vexbz1 = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data/ex.gda" x, z, ex = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data/ey.gda" x, z, ey = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data/ez.gda" x, z, ez = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data/bx.gda" x, z, bx = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data/by.gda" x, z, by = read_2d_fields(pic_info, fname, **kwargs) fname = run_dir + "data/bz.gda" x, z, bz = read_2d_fields(pic_info, fname, **kwargs) ib2 = 1.0 / (bx**2 + by**2 + bz**2) vexbx2 = (ey * bz - ez * by) * ib2 vexby2 = (ez * bx - ex * bz) * ib2 vexbz2 = (ex * by - ey * bx) * ib2 p1 = plt.imshow( vexbz2 - vexbz1, cmap=plt.cm.jet, # extent=[xmin, xmax, zmin, zmax], # vmin=vmin, vmax=vmax, aspect='auto', origin='lower', interpolation='bicubic') plt.show()
def calc_avg_bfield(pic_info, ct, run_name, xm, base_dir='../../'): """Calculate the average magnetic field in the shock downstream Args: pic_info: namedtuple for the PIC simulation information. ct: current time frame. run_name: the simulation run name xm: the shock position in di base_dir: the root directory of the run """ xmin, xmax = 0, pic_info.lx_di xmin, xmax = 0, 105 zmin, zmax = -0.5 * pic_info.lz_di, 0.5 * pic_info.lz_di kwargs = { "current_time": ct, "xl": xmin, "xr": xmax, "zb": zmin, "zt": zmax } xmin, xmax = 0, xm fname = base_dir + 'data1/bx.gda' x, z, bx = read_2d_fields(pic_info, fname, **kwargs) fname = base_dir + 'data1/by.gda' x, z, by = read_2d_fields(pic_info, fname, **kwargs) fname = base_dir + 'data1/bz.gda' x, z, bz = read_2d_fields(pic_info, fname, **kwargs) bx_avg = np.average(bx) by_avg = np.average(by) bz_avg = np.average(bz) bavg = np.asarray([bx_avg, by_avg, bz_avg]) data_dir = '../data/b_average/' mkdir_p(data_dir) fname = data_dir + 'bavg_' + str(ct) + '.txt' bavg.tofile(fname)
def plot_extra_contour(self): if (self.xmax_b > self.pic_info.lx_di): ex = self.xmax_b - self.pic_info.lx_di kwargs = { "current_time": self.ct, "xl": 0, "xr": ex, "zb": self.field_range[2], "zt": self.field_range[3] } fname_field = '../../data/' + self.var_field + '.gda' fname_Ay = '../../data/Ay.gda' x, z, fdata = read_2d_fields(self.pic_info, fname_field, **kwargs) ng = 5 kernel = np.ones((ng, ng)) / float(ng * ng) fdata = signal.convolve2d(fdata, kernel) x, z, Ay = read_2d_fields(self.pic_info, fname_Ay, **kwargs) nx, = x.shape nz, = z.shape ex_grid = ex / self.pic_info.dx_di + 1 xmin = self.pic_info.lx_di xmax = xmin + ex self.im1 = self.xz_axis.imshow( fdata[0:nz:self.zst, 0:nx:self.xst], cmap=self.cmap, extent=[xmin, xmax, self.zmin1, self.zmax1], aspect='auto', origin='lower', vmin=-self.vmax, vmax=self.vmax, interpolation='bicubic') x += xmin self.xz_axis.contour(x[0:nx:self.xst], z[0:nz:self.zst], Ay[0:nz:self.zst, 0:nx:self.xst], colors='black', linewidths=0.5, levels=self.levels)
def update(self, val): ct = self.slider.val ratio = self.pic_info.particle_interval / self.pic_info.fields_interval kwargs = { "current_time": ct * ratio, "xl": 0, "xr": 200, "zb": -50, "zt": 50 } fname = "../../data/by.gda" x, z, data = read_2d_fields(self.pic_info, fname, **kwargs) self.im1.set_data(data) self.fig.canvas.draw_idle()
def plot_particle_phase_distribution(pic_info, ct, base_dir, run_name, species, shock_pos): """ """ particle_interval = pic_info.particle_interval tratio = particle_interval / pic_info.fields_interval ptl_tindex = ct * particle_interval / tratio xmin, xmax = 0, pic_info.lx_di xmin, xmax = 0, 105 zmin, zmax = -0.5 * pic_info.lz_di, 0.5 * pic_info.lz_di kwargs = { "current_time": ct, "xl": xmin, "xr": xmax, "zb": zmin, "zt": zmax } fname = base_dir + 'data1/vex.gda' x, z, vel = read_2d_fields(pic_info, fname, **kwargs) # nx, = x.shape # nz, = z.shape # data_cum = np.sum(vel, axis=0) / nz # data_grad = np.abs(np.gradient(data_cum)) # xs = 5 # max_index = np.argmax(data_grad[xs:]) # xm = x[max_index] xm = x[shock_pos] max_index = shock_pos pos = [xm / 2, 0.0, 0.0] nxc = max_index csizes = [max_index, pic_info.ny, pic_info.nz] # csizes = [max_index/4, pic_info.ny, pic_info.nz/4] corners, mpi_ranks = set_mpi_ranks(pic_info, pos, sizes=csizes) fig1, fig2 = get_phase_distribution(base_dir, pic_info, species, ptl_tindex, corners, mpi_ranks) fig_dir = '../img/img_phase_distribution/' + run_name + '/' mkdir_p(fig_dir) fname = fig_dir + '/vdist_para_perp_' + species + '_' + str(ct).zfill( 3) + '.jpg' fig1.savefig(fname, dpi=300) fname = fig_dir + '/vdist_para_perp_1d_' + species + '_' + str(ct).zfill( 3) + '.jpg' fig2.savefig(fname, dpi=300) # plt.show() plt.close("all")
def smooth_interp_emf(run_dir, pic_info, eb_field_name, tframe, coords): """ Smooth electric and magnetic field and also interpolate them to grid locations where hydro quantities are. """ kwargs = {"current_time": tframe, "xl": 0, "xr": pic_info.lx_di, "zb": -0.5 * pic_info.lz_di, "zt": 0.5 * pic_info.lz_di} size_one_frame = pic_info.nx * pic_info.nz * 4 fname = run_dir + "data/" + eb_field_name + "_original.gda" statinfo = os.stat(fname) file_size = statinfo.st_size if file_size < size_one_frame * (tframe + 1): return else: x, z, fdata = read_2d_fields(pic_info, fname, **kwargs) if 'ex' in eb_field_name or 'bz' in eb_field_name: f = MultilinearInterpolator(coords["smin_ex_bz"], coords["smax_ex_bz"], coords["orders"], dtype=np.float32) elif 'ez' in eb_field_name or 'bx' in eb_field_name: f = MultilinearInterpolator(coords["smin_ez_bx"], coords["smax_ez_bx"], coords["orders"], dtype=np.float32) elif 'ey' in eb_field_name: f = MultilinearInterpolator(coords["smin_h"], coords["smax_h"], coords["orders"], dtype=np.float32) else: f = MultilinearInterpolator(coords["smin_by"], coords["smax_by"], coords["orders"], dtype=np.float32) f.set_values(np.atleast_2d(np.transpose(fdata).flatten())) nx = pic_info.nx nz = pic_info.nz fdata = f(coords["coord"]) fdata = np.transpose(f(coords["coord"]).reshape((nx, nz))) # only smooth electric field if any(ename in eb_field_name for ename in ['ex', 'ey', 'ez']): sigma = 3 fdata = gaussian_filter(fdata, sigma) fname = run_dir + "data/" + eb_field_name + ".gda" with open(fname, 'a+') as f: offset = size_one_frame * tframe f.seek(offset, os.SEEK_SET) fdata.tofile(f)
def plot_particle_trajectory(fnames, species, pic_info): """Plot particle trajectory. Args: fnames: file names for the trajectory files. species: particle species. pic_info: particle information namedtuple. """ init_ft = 190 nptl = len(fnames) var_field = 'ey' var_name = '$E_y$' kwargs = {"current_time": init_ft, "xl": 0, "xr": 200, "zb": -50, "zt": 50} fname = '../../data/' + var_field + '.gda' x, z, data = read_2d_fields(pic_info, fname, **kwargs) ng = 3 kernel = np.ones((ng, ng)) / float(ng * ng) data = signal.convolve2d(data, kernel) fname = '../../data/Ay.gda' x, z, Ay = read_2d_fields(pic_info, fname, **kwargs) iptl = 393 fig_v = ParticleTrajectory(nptl, iptl, x, z, data, Ay, init_ft, var_field, var_name, species, fnames) plt.show()
def read_field_data(self): self.xl, self.xr = self.field_range[0, 0:2] self.zb, self.zt = self.field_range[0, 2:4] kwargs = { "current_time": self.ct[0], "xl": self.xl, "xr": self.xr, "zb": self.zb, "zt": self.zt } fname_field = '../../data/' + self.var_field + '.gda' fname_Ay = '../../data/Ay.gda' self.x1, self.z1, data = read_2d_fields(self.pic_info, fname_field, **kwargs) ng = 5 kernel = np.ones((ng, ng)) / float(ng * ng) self.fdata1 = signal.convolve2d(data, kernel) self.x1, self.z1, self.Ay1 = read_2d_fields(self.pic_info, fname_Ay, **kwargs) self.nx1, = self.x1.shape self.nz1, = self.z1.shape self.xl, self.xr = self.field_range[1, 0:2] self.zb, self.zt = self.field_range[1, 2:4] kwargs = { "current_time": self.ct[1], "xl": self.xl, "xr": self.xr, "zb": self.zb, "zt": self.zt } self.x2, self.z2, data = read_2d_fields(self.pic_info, fname_field, **kwargs) self.fdata2 = signal.convolve2d(data, kernel) self.x2, self.z2, self.Ay2 = read_2d_fields(self.pic_info, fname_Ay, **kwargs) self.nx2, = self.x2.shape self.nz2, = self.z2.shape self.xl, self.xr = self.field_range[2, 0:2] self.zb, self.zt = self.field_range[2, 2:4] kwargs = { "current_time": self.ct[2], "xl": self.xl, "xr": self.xr, "zb": self.zb, "zt": self.zt } self.x3, self.z3, data = read_2d_fields(self.pic_info, fname_field, **kwargs) self.fdata3 = signal.convolve2d(data, kernel) self.x3, self.z3, self.Ay3 = read_2d_fields(self.pic_info, fname_Ay, **kwargs) self.nx3, = self.x3.shape self.nz3, = self.z3.shape
def plot_number_density(run_name, root_dir, pic_info, species, ct): """Plot particle number density """ kwargs = {"current_time": ct, "xl": 0, "xr": 1000, "zb": -250, "zt": 250} fname = root_dir + 'data/n' + species + '.gda' # fname = root_dir + 'data/jy.gda' x, z, nrho = read_2d_fields(pic_info, fname, **kwargs) fname = root_dir + 'data/Ay.gda' # x, z, Ay = read_2d_fields(pic_info, fname, **kwargs) nx, = x.shape nz, = z.shape xs, ys = 0.1, 0.15 w1, h1 = 0.85, 0.8 fig = plt.figure(figsize=[10, 5]) ax1 = fig.add_axes([xs, ys, w1, h1]) kwargs_plot = {"xstep": 2, "zstep": 2, "vmin": 0.0, "vmax": 10} xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] p1 = plot_2d_contour(x, z, nrho, ax1, fig, is_cbar=0, **kwargs_plot) p1.set_cmap(plt.cm.get_cmap('jet')) # ax1.contour(x[0:nx:xstep], z[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], # colors='black', linewidths=0.5) ax1.set_xlabel(r'$x/d_i$', fontdict=font, fontsize=20) ax1.set_ylabel(r'$z/d_i$', fontdict=font, fontsize=20) ax1.tick_params(labelsize=16) t_wci = ct * pic_info.dt_fields title = r'$t = ' + "{:10.1f}".format(t_wci) + '/\Omega_{ci}$' ax1.text(0.02, 0.9, title, color='white', fontsize=20, bbox=dict(facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='left', verticalalignment='center', transform=ax1.transAxes) nrho = 'n' + species fdir = '../img/' + nrho + '/' mkdir_p(fdir) fname = fdir + nrho + '_' + str(ct) + '.jpg' fig.savefig(fname, dpi=200) plt.show()
def shock_current_sheet(): """ """ ct = 370 cts = range(10, pic_info.ntf - 1, tratio) ixs = range(pic_info.topology_x) shock_loc = np.genfromtxt( '../data/shock_pos/shock_pos.txt', dtype=np.int32) xmin, xmax = 0, 105 zmin, zmax = -0.5 * pic_info.lz_di, 0.5 * pic_info.lz_di kwargs = { "current_time": ct, "xl": xmin, "xr": xmax, "zb": zmin, "zt": zmax } fname = base_dir + 'data1/vex.gda' x, z, vx = read_2d_fields(pic_info, fname, **kwargs) xm = x[shock_loc[ct]]
def smooth_emf(run_dir, pic_info, emf_name, tframe, coords): """ Smooth electric and magnetic field """ kwargs = {"current_time": tframe, "xl": 0, "xr": pic_info.lx_di, "zb": -0.5 * pic_info.lz_di, "zt": 0.5 * pic_info.lz_di} size_one_frame = pic_info.nx * pic_info.nz * 4 # fname = run_dir + "data/original_data/" + emf_name + ".gda" fname = run_dir + "data1/original_data/" + emf_name + ".gda" statinfo = os.stat(fname) file_size = statinfo.st_size if file_size < size_one_frame * (tframe + 1): return else: x, z, fdata = read_2d_fields(pic_info, fname, **kwargs) sigma = 5 fdata = median_filter(fdata, sigma) # fname = run_dir + "data/" + emf_name + ".gda" fname = run_dir + "data1/" + emf_name + ".gda" with open(fname, 'a+') as f: offset = size_one_frame * tframe f.seek(offset, os.SEEK_SET) fdata.tofile(f)
def plot_ne_jdote(pic_info, root_dir, run_name, current_time): """ Plot electron number density and jdote Args: pic_info: namedtuple for the PIC simulation information. root_dir: simulation root directory current_time: current time frame. """ print("Time frame: %d" % current_time) smime = math.sqrt(pic_info.mime) dx = pic_info.dx_di * smime dz = pic_info.dz_di * smime lx_de = pic_info.lx_di * smime lz_de = pic_info.lz_di * smime kwargs = { "current_time": current_time, "xl": 0, "xr": lx_de, "zb": -0.5 * lx_de, "zt": 0.5 * lx_de } fname = root_dir + "data/ne.gda" x, z, ne = read_2d_fields(pic_info, fname, **kwargs) fname = root_dir + "data/Ay.gda" x, z, Ay = read_2d_fields(pic_info, fname, **kwargs) fname = root_dir + "data/ex.gda" x, z, ex = read_2d_fields(pic_info, fname, **kwargs) fname = root_dir + "data/ey.gda" x, z, ey = read_2d_fields(pic_info, fname, **kwargs) fname = root_dir + "data/ez.gda" x, z, ez = read_2d_fields(pic_info, fname, **kwargs) fname = root_dir + "data/vex.gda" x, z, vex = read_2d_fields(pic_info, fname, **kwargs) fname = root_dir + "data/vey.gda" x, z, vey = read_2d_fields(pic_info, fname, **kwargs) fname = root_dir + "data/vez.gda" x, z, vez = read_2d_fields(pic_info, fname, **kwargs) wpe_wce = pic_info.dtwce / pic_info.dtwpe va = wpe_wce / math.sqrt(pic_info.mime) vex /= va vey /= va vez /= va jdote = -ne * (ex * vex + ey * vey + ez * vez) ng = 3 kernel = np.ones((ng, ng)) / float(ng * ng) jdote = signal.convolve2d(jdote, kernel) jdote /= pic_info.b0 * va xmin, xmax = np.min(x), np.max(x) zmin, zmax = np.min(z), np.max(z) # w0, h0 = 0.41, 0.11 w0, h0 = 0.4, 0.42 xs0, ys0 = 0.06, 0.98 - h0 vgap, hgap = 0.03, 0.1 def plot_one_field(fdata, ax, text, text_color, label_bottom='on', label_left='on', ylabel=False, vmin=0, vmax=10, colormap=plt.cm.seismic, xs=xs0, ys=ys0, ay_color='k', color_bar=False): plt.tick_params(labelsize=16) p1 = ax.imshow(fdata, vmin=vmin, vmax=vmax, cmap=colormap, extent=[xmin, xmax, zmin, zmax], aspect='auto', origin='lower', interpolation='bicubic') ax.tick_params(axis='x', labelbottom=label_bottom) ax.tick_params(axis='y', labelleft=label_left) if ylabel: ax.set_ylabel(r'$z/d_i$', fontdict=font, fontsize=20) ax.contour(x, z, Ay, colors=ay_color, linewidths=0.5) ax.text(0.02, 0.85, text, color=text_color, fontsize=20, bbox=dict(facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='left', verticalalignment='center', transform=ax.transAxes) if color_bar: xs1 = xs + w0 * 1.02 w1 = w0 * 0.04 cax = fig.add_axes([xs1, ys, w1, h0]) cbar = fig.colorbar(p1, cax=cax) cbar.ax.tick_params(labelsize=16) return (p1, cbar) else: return p1 fig = plt.figure(figsize=[16, 8]) xs, ys = xs0, ys0 ax1 = fig.add_axes([xs, ys, w0, h0]) text1 = r'$n_e$' print("min and max of electron density: %f %f" % (np.min(ne), np.max(ne))) nmin, nmax = 1.0, 4.0 ax1.tick_params(axis='x', which='minor', direction='in') ax1.tick_params(axis='x', which='major', direction='in') ax1.tick_params(axis='y', which='minor', direction='in') ax1.tick_params(axis='y', which='major', direction='in') p1, cbar1 = plot_one_field(ne, ax1, text1, 'w', label_bottom='off', label_left='on', ylabel=True, vmin=nmin, vmax=nmax, colormap=plt.cm.viridis, xs=xs, ys=ys, ay_color='w', color_bar=True) cbar1.set_ticks(np.arange(nmin, nmax + 0.5, 0.5)) ys -= h0 + vgap ax2 = fig.add_axes([xs, ys, w0, h0]) vmin, vmax = -0.1, 0.1 text2 = r'$\boldsymbol{j}_e\cdot\boldsymbol{E}$' ax2.tick_params(axis='x', which='minor', direction='in') ax2.tick_params(axis='x', which='major', direction='in') ax2.tick_params(axis='y', which='minor', direction='in') ax2.tick_params(axis='y', which='major', direction='in') print("min and max of jdote: %f %f" % (np.min(jdote), np.max(jdote))) p2 = plot_one_field(jdote, ax2, text2, 'k', label_bottom='on', label_left='on', ylabel=True, vmin=vmin, vmax=vmax, colormap=plt.cm.seismic, xs=xs, ys=ys) ax2.set_xlabel(r'$x/d_i$', fontdict=font, fontsize=20) xs1 = xs + w0 * 1.02 w1 = w0 * 0.04 cax2 = fig.add_axes([xs1, ys, w1, h0]) cbar2 = fig.colorbar(p2, cax=cax2) cbar2.ax.tick_params(labelsize=16) xs = xs1 + w1 + hgap h1 = h0 * 2 + vgap w1 = 0.3 ax3 = fig.add_axes([xs, ys, w0, h1]) ax3.tick_params(axis='x', which='minor', direction='in') ax3.tick_params(axis='x', which='major', direction='in') ax3.tick_params(axis='y', which='minor', direction='in') ax3.tick_params(axis='y', which='major', direction='in') vth = pic_info.vthe gama = 1.0 / math.sqrt(1.0 - 3 * vth**2) eth = gama - 1.0 fdir = '../data/spectra/' + run_name + '/' n0 = pic_info.nx * pic_info.ny * pic_info.nz * pic_info.nppc tratio = pic_info.particle_interval // pic_info.fields_interval nt = current_time // tratio fname = fdir + 'spectrum-e.1' elin, flin, elog, flog_e = spect_fit.get_energy_distribution(fname, n0) elog_norm_e = spect_fit.get_normalized_energy('e', elog, pic_info) f_intial = fitting_funcs.func_maxwellian(elog, n0, 1.5 / eth) nacc, eacc = spect_fit.accumulated_particle_info(elog, f_intial) f_intial /= nacc[-1] ax3.loglog(elog_norm_e, f_intial, linewidth=1, color='k', linestyle='--', label='initial') for ct in range(1, nt + 1): fname = fdir + 'spectrum-e.' + str(ct) elin, flin, elog, flog_e = spect_fit.get_energy_distribution(fname, n0) nacc, eacc = spect_fit.accumulated_particle_info(elog, flog_e) flog_e /= nacc[-1] if (ct != nt): ax3.loglog(elog_norm_e, flog_e, linewidth=1, color='k') else: ax3.loglog(elog_norm_e, flog_e, linewidth=3, color='r') ax3.set_xlim([5E-2, 5E2]) ax3.set_ylim([1E-8, 2E2]) ax3.set_xlabel(r'$\varepsilon/\varepsilon_\text{th}$', fontdict=font, fontsize=20) ax3.set_ylabel(r'$f(\varepsilon)$', fontdict=font, fontsize=20) ax3.tick_params(labelsize=16) t_wci = current_time * pic_info.dt_fields title = r'$t\Omega_{ci} = ' + "{:10.1f}".format(t_wci) + '$' ax3.text(0.02, 0.05, title, color='k', fontsize=20, bbox=dict(facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='left', verticalalignment='center', transform=ax3.transAxes) fdir = '../img/img_apjl/ne_jdote/' + run_name + '/' mkdir_p(fdir) fname = fdir + 'ne_jdote_' + str(current_time) + '.jpg' fig.savefig(fname, dpi=200) plt.close()
def cal_phi_parallel(pic_info): """Calculate parallel potential defined by Jan Egedal. Args: pic_info: namedtuple for the PIC simulation information. """ kwargs = {"current_time": 160, "xl": 0, "xr": 200, "zb": -50, "zt": 50} x, z, Ay = contour_plots.read_2d_fields(pic_info, "../data/Ay.gda", **kwargs) x, z, Bx = contour_plots.read_2d_fields(pic_info, "../data/bx.gda", **kwargs) x, z, By = contour_plots.read_2d_fields(pic_info, "../data/by.gda", **kwargs) xarr, zarr, Bz = contour_plots.read_2d_fields(pic_info, "../data/bz.gda", **kwargs) x, z, Ex = contour_plots.read_2d_fields(pic_info, "../data/ex.gda", **kwargs) x, z, Ey = contour_plots.read_2d_fields(pic_info, "../data/ey.gda", **kwargs) x, z, Ez = contour_plots.read_2d_fields(pic_info, "../data/ez.gda", **kwargs) absB = np.sqrt(Bx * Bx + By * By + Bz * Bz) Epara = (Ex * Bx + Ey * By + Ez * Bz) / absB etot = np.sqrt(Ex * Ex + Ey * Ey + Ez * Ez) nx, = x.shape nz, = z.shape print nx, nz width = 0.78 height = 0.75 xs = 0.14 xe = 0.94 - xs ys = 0.9 - height #fig = plt.figure(figsize=(7,5)) fig = plt.figure(figsize=(7, 2)) ax1 = fig.add_axes([xs, ys, width, height]) kwargs_plot = {"xstep": 2, "zstep": 2} xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] #p1, cbar1 = contour_plots.plot_2d_contour(xarr, zarr, etot, # ax1, fig, **kwargs_plot) #p1.set_cmap(plt.cm.seismic) cs = ax1.contour(xarr[0:nx:xstep], zarr[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='white', linewidths=0.5, levels=np.arange(150, 252, 1)) xlist = [] zlist = [] dx_di = pic_info.dx_di dz_di = pic_info.dz_di fig, ax = plt.subplots() #fig, ax2 = plt.subplots() phi_parallel = np.zeros((nz, nx)) #for csp in cs.collections[65:70]: for csp in cs.collections[0:10]: for p in csp.get_paths(): v = p.vertices x = v[:, 0] z = v[:, 1] if (math.fabs(x[0] - x[-1]) > dx_di or math.fabs(z[0] - z[-1]) > dz_di): xlist.extend(x) zlist.extend(z) lenx = len(x) phip = np.zeros(lenx) epara = np.zeros(lenx) if (x[-1] < x[0]): x = x[::-1] z = z[::-1] for i in range(1, lenx): dx = x[i] - x[i - 1] dz = z[i] - z[i - 1] indices_bl, indices_tr, delta = grid_indices( x[i] - xarr[0], 0, z[i] - zarr[0], nx, 1, nz, dx_di, 1, dz_di) ix1 = indices_bl[0] iz1 = indices_bl[2] ix2 = indices_tr[0] iz2 = indices_tr[2] offsetx = delta[0] offsetz = delta[2] v1 = (1.0 - offsetx) * (1.0 - offsetz) v2 = offsetx * (1.0 - offsetz) v3 = offsetx * offsetz v4 = (1.0 - offsetx) * offsetz bx = Bx[iz1, ix1] * v1 + Bx[iz1, ix2] * v2 + Bx[ iz2, ix2] * v3 + Bx[iz2, ix1] * v4 by = By[iz1, ix1] * v1 + By[iz1, ix2] * v2 + By[ iz2, ix2] * v3 + By[iz2, ix1] * v4 bz = Bz[iz1, ix1] * v1 + Bz[iz1, ix2] * v2 + Bz[ iz2, ix2] * v3 + Bz[iz2, ix1] * v4 ex = Ex[iz1, ix1] * v1 + Ex[iz1, ix2] * v2 + Ex[ iz2, ix2] * v3 + Ex[iz2, ix1] * v4 ey = Ey[iz1, ix1] * v1 + Ey[iz1, ix2] * v2 + Ey[ iz2, ix2] * v3 + Ey[iz2, ix1] * v4 ez = Ez[iz1, ix1] * v1 + Ez[iz1, ix2] * v2 + Ez[ iz2, ix2] * v3 + Ez[iz2, ix1] * v4 epara[i] = Epara[iz1,ix1]*v1 + Epara[iz1,ix2]*v2 + \ Epara[iz2,ix2]*v3 + Epara[iz2,ix1]*v4 dy = by * dx / bx #btot = math.sqrt(bx*bx + by*by + bz*bz) #ds = math.sqrt(dx*dx + dy*dy + dz*dz) #print math.acos((bx*dx + by*dy + bz*dz) / (btot*ds)) phip[i] = phip[i - 1] + ex * dx + ey * dy + ez * dz ix = int(math.floor(x[i] / dx_di)) iz = int(math.floor((z[i] - zarr[0]) / dz_di)) phi_parallel[iz, ix] = phip[i] ax.plot(x, phip) #ax.plot(x, epara) print np.max(phi_parallel), np.min(phi_parallel) fig = plt.figure(figsize=(7, 2)) ax1 = fig.add_axes([xs, ys, width, height]) kwargs_plot = {"xstep": 2, "zstep": 2} xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] p1, cbar1 = contour_plots.plot_2d_contour(xarr, zarr, phi_parallel, ax1, fig, **kwargs_plot) p1.set_cmap(plt.cm.seismic) plt.show()
def plot_particle_drift(pic_info, species, current_time): """Plot compression related terms. Args: pic_info: namedtuple for the PIC simulation information. species: 'e' for electrons, 'i' for ions. current_time: current time frame. """ print(current_time) width = 0.75 height = 0.11 xs = 0.12 ys = 0.98 - height gap = 0.025 if species == 'i': vmin = -0.5 vmax = 0.5 else: vmin = -0.8 vmax = 0.8 fig = plt.figure(figsize=[10, 14]) kwargs_plot = {"xstep": 1, "zstep": 1, "vmin": vmin, "vmax": vmax} xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] ratio = pic_info.particle_interval / pic_info.fields_interval ct = (current_time + 1) * ratio kwargs = {"current_time": ct, "xl": 0, "xr": 200, "zb": -50, "zt": 50} x, z, Ay = read_2d_fields(pic_info, "../../data/Ay.gda", **kwargs) nx, = x.shape nz, = z.shape zl = nz / 4 zt = nz - zl nbands = 5 data_sum = np.zeros((nbands, nx)) data_acc = np.zeros((nbands, nx)) nb = 0 kwargs = { "current_time": current_time, "xl": 0, "xr": 200, "zb": -50, "zt": 50 } for iband in range(1, nbands + 1): fname = "../../data1/jpara_dote_" + species + "_" + str(iband).zfill( 2) + ".gda" x, z, jpara_dote = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data1/jperp_dote_" + species + "_" + str(iband).zfill( 2) + ".gda" x, z, jperp_dote = read_2d_fields(pic_info, fname, **kwargs) data = jpara_dote + jperp_dote nk = 5 kernel = np.ones((nk, nk)) / float(nk * nk) data = signal.convolve2d(data, kernel, mode='same') ax1 = fig.add_axes([xs, ys, width, height]) p1, cbar1 = plot_2d_contour(x, z[zl:zt], data[zl:zt:zstep, 0:nx:xstep], ax1, fig, **kwargs_plot) p1.set_cmap(plt.cm.seismic) ax1.contour( x[0:nx:xstep], z[zl:zt:zstep], Ay[zl:zt:zstep, 0:nx:xstep], colors='black', linewidths=0.5) ax1.set_ylabel(r'$z/d_i$', fontdict=font, fontsize=24) ax1.tick_params(labelsize=20) ax1.tick_params(axis='x', labelbottom='off') cbar1.ax.tick_params(labelsize=20) if species == 'i': cbar1.set_ticks(np.arange(-0.4, 0.5, 0.2)) else: cbar1.set_ticks(np.arange(-0.8, 0.9, 0.4)) ys -= height + gap data_sum[nb, :] = np.sum(data, axis=0) data_acc[nb, :] = np.cumsum(data_sum[nb, :]) nb += 1 dv = pic_info.dx_di * pic_info.dz_di * pic_info.mime data_sum *= dv data_acc *= dv ys0 = 0.1 height0 = ys + height - ys0 w1, h1 = fig.get_size_inches() width0 = width * 0.98 - 0.05 / w1 ax1 = fig.add_axes([xs, ys0, width0, height0]) for i in range(nb): fname = 'Band' + str(i + 1).zfill(2) # ax1.plot(x, data_sum[i, :], linewidth=2, label=fname) ax1.plot(x, data_acc[i, :], linewidth=2, label=fname) ax1.tick_params(labelsize=20) ax1.set_xlabel(r'$x/d_i$', fontdict=font, fontsize=24) ax1.set_ylabel(r'Accumulation', fontdict=font, fontsize=24) ax1.legend( loc=2, prop={'size': 20}, ncol=1, shadow=False, fancybox=False, frameon=False) if not os.path.isdir('../img/'): os.makedirs('../img/') if not os.path.isdir('../img/img_particle_drift/'): os.makedirs('../img/img_particle_drift/') fname = 'ene_gain_' + str(current_time).zfill(3) + '_' + species + '.jpg' fname = '../img/img_particle_drift/' + fname fig.savefig(fname, dpi=200) # plt.close() plt.show()
def plot_traj(filename, pic_info, species, iptl, mint, maxt): """Plot particle trajectory information. Args: filename: the filename to read the data. pic_info: namedtuple for the PIC simulation information. species: particle species. 'e' for electron. 'i' for ion. iptl: particle ID. mint, maxt: minimum and maximum time for plotting. """ ptl_traj = read_traj_data(filename) gama = np.sqrt(ptl_traj.ux**2 + ptl_traj.uy**2 + ptl_traj.uz**2 + 1.0) mime = pic_info.mime # de scale to di scale ptl_x = ptl_traj.x / math.sqrt(mime) ptl_y = ptl_traj.y / math.sqrt(mime) ptl_z = ptl_traj.z / math.sqrt(mime) # 1/wpe to 1/wci t = ptl_traj.t * pic_info.dtwci / pic_info.dtwpe xl, xr = 0, 200 zb, zt = -20, 20 kwargs = {"current_time": 50, "xl": xl, "xr": xr, "zb": zb, "zt": zt} fname = "../../data/ey.gda" x, z, data_2d = read_2d_fields(pic_info, fname, **kwargs) x, z, Ay = read_2d_fields(pic_info, "../../data/Ay.gda", **kwargs) nx, = x.shape nz, = z.shape # p1 = ax1.plot(ptl_x, gama-1.0, color='k') # ax1.set_xlabel(r'$t\Omega_{ci}$', fontdict=font) # ax1.set_ylabel(r'$E/m_ic^2$', fontdict=font) # ax1.tick_params(labelsize=20) width = 14.0 height = 8.0 fig = plt.figure(figsize=[width, height]) w1, h1 = 0.82, 0.27 xs, ys = 0.10, 0.98 - h1 ax1 = fig.add_axes([xs, ys, w1, h1]) kwargs_plot = { "xstep": 2, "zstep": 2, "is_log": False, "vmin": -1.0, "vmax": 1.0 } xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] im1, cbar1 = plot_2d_contour(x, z, data_2d, ax1, fig, **kwargs_plot) im1.set_cmap(plt.cm.seismic) ax1.contour(x[0:nx:xstep], z[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='black', linewidths=0.5) ax1.tick_params(labelsize=20) ax1.tick_params(axis='x', labelbottom='off') ax1.set_xlim([xl, xr]) ax1.set_ylim([zb, zt]) ax1.set_ylabel(r'$z/d_i$', fontdict=font) cbar1.ax.tick_params(labelsize=20) cbar1.ax.set_ylabel(r'$B_y$', fontdict=font, fontsize=24) p1 = ax1.scatter(ptl_x, ptl_z, s=0.5) # ax2 = fig.add_axes([xs, ys, w1, h1]) # p2 = ax2.plot(t, gama-1.0, color='k') # ax2.set_xlabel(r'$t\Omega_{ci}$', fontdict=font) # ax2.set_ylabel(r'$E/m_ic^2$', fontdict=font) # ax2.tick_params(labelsize=20) gap = 0.04 ys -= h1 + gap ax2 = fig.add_axes([xs, ys, w1 * 0.98 - 0.05 / width, h1]) p2 = ax2.plot(ptl_x, gama - 1.0, color='k') ax2.set_ylabel(r'$E/m_ic^2$', fontdict=font) ax2.tick_params(labelsize=20) ax2.tick_params(axis='x', labelbottom='off') xmin, xmax = ax2.get_xlim() ys -= h1 + gap ax3 = fig.add_axes([xs, ys, w1 * 0.98 - 0.05 / width, h1]) p3 = ax3.plot(ptl_x, ptl_y, color='k') ax3.set_xlabel(r'$x/d_i$', fontdict=font) ax3.set_ylabel(r'$y/d_i$', fontdict=font) ax3.tick_params(labelsize=20) ax1.set_xlim([xmin, xmax]) ax3.set_xlim([xmin, xmax]) if not os.path.isdir('../img/'): os.makedirs('../img/') dir = '../img/img_traj_' + species + '/' if not os.path.isdir(dir): os.makedirs(dir) fname = dir + 'traj_' + species + '_' + str(iptl).zfill(4) + '_1.jpg' fig.savefig(fname, dpi=300) height = 15.0 fig = plt.figure(figsize=[width, height]) w1, h1 = 0.88, 0.135 xs, ys = 0.10, 0.98 - h1 gap = 0.025 dt = t[1] - t[0] ct1 = int(mint / dt) ct2 = int(maxt / dt) ax1 = fig.add_axes([xs, ys, w1, h1]) p1 = ax1.plot(t[ct1:ct2], gama[ct1:ct2] - 1.0, color='k') ax1.set_ylabel(r'$E/m_ic^2$', fontdict=font) ax1.tick_params(labelsize=20) ax1.tick_params(axis='x', labelbottom='off') ax1.plot([mint, maxt], [0, 0], '--', color='k') ax1.text(0.4, -0.07, r'$x$', color='red', fontsize=32, bbox=dict(facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='center', verticalalignment='center', transform=ax1.transAxes) ax1.text(0.5, -0.07, r'$y$', color='green', fontsize=32, bbox=dict(facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='center', verticalalignment='center', transform=ax1.transAxes) ax1.text(0.6, -0.07, r'$z$', color='blue', fontsize=32, bbox=dict(facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='center', verticalalignment='center', transform=ax1.transAxes) ys -= h1 + gap ax2 = fig.add_axes([xs, ys, w1, h1]) p21 = ax2.plot(t[ct1:ct2], ptl_traj.ux[ct1:ct2], color='r', label=r'u_x') p22 = ax2.plot(t[ct1:ct2], ptl_traj.uy[ct1:ct2], color='g', label=r'u_y') p23 = ax2.plot(t[ct1:ct2], ptl_traj.uz[ct1:ct2], color='b', label=r'u_z') ax2.plot([mint, maxt], [0, 0], '--', color='k') ax2.set_ylabel(r'$u_x, u_y, u_z$', fontdict=font) ax2.tick_params(labelsize=20) ax2.tick_params(axis='x', labelbottom='off') kernel = 9 tmax = np.max(t) ys -= h1 + gap ax31 = fig.add_axes([xs, ys, w1, h1]) ex = signal.medfilt(ptl_traj.ex, kernel_size=(kernel)) p31 = ax31.plot(t[ct1:ct2], ex[ct1:ct2], color='r', label=r'E_x') ax31.set_ylabel(r'$E_x$', fontdict=font) ax31.tick_params(labelsize=20) ax31.tick_params(axis='x', labelbottom='off') ax31.plot([mint, maxt], [0, 0], '--', color='k') ys -= h1 + gap ax32 = fig.add_axes([xs, ys, w1, h1]) ey = signal.medfilt(ptl_traj.ey, kernel_size=(kernel)) p32 = ax32.plot(t[ct1:ct2], ey[ct1:ct2], color='g', label=r'E_y') ax32.set_ylabel(r'$E_y$', fontdict=font) ax32.tick_params(labelsize=20) ax32.tick_params(axis='x', labelbottom='off') ax32.plot([mint, maxt], [0, 0], '--', color='k') ys -= h1 + gap ax33 = fig.add_axes([xs, ys, w1, h1]) ez = signal.medfilt(ptl_traj.ez, kernel_size=(kernel)) p33 = ax33.plot(t[ct1:ct2], ez[ct1:ct2], color='b', label=r'E_z') ax33.set_ylabel(r'$E_z$', fontdict=font) ax33.tick_params(labelsize=20) ax33.tick_params(axis='x', labelbottom='off') ax33.plot([mint, maxt], [0, 0], '--', color='k') ys -= h1 + gap ax4 = fig.add_axes([xs, ys, w1, h1]) p41 = ax4.plot(t[ct1:ct2], ptl_traj.bx[ct1:ct2], color='r', label=r'B_x') p42 = ax4.plot(t[ct1:ct2], ptl_traj.by[ct1:ct2], color='g', label=r'B_y') p43 = ax4.plot(t[ct1:ct2], ptl_traj.bz[ct1:ct2], color='b', label=r'B_z') ax4.set_xlabel(r'$t\Omega_{ci}$', fontdict=font) ax4.set_ylabel(r'$B_x, B_y, B_z$', fontdict=font) ax4.tick_params(labelsize=20) ax4.plot([mint, maxt], [0, 0], '--', color='k') ax1.set_xlim([mint, maxt]) ax2.set_xlim([mint, maxt]) ax31.set_xlim([mint, maxt]) ax32.set_xlim([mint, maxt]) ax33.set_xlim([mint, maxt]) ax4.set_xlim([mint, maxt]) fname = dir + 'traj_' + species + '_' + str(iptl).zfill(4) + '_2.jpg' fig.savefig(fname, dpi=300) height = 6.0 fig = plt.figure(figsize=[width, height]) w1, h1 = 0.88, 0.4 xs, ys = 0.10, 0.97 - h1 gap = 0.05 dt = t[1] - t[0] ct1 = int(mint / dt) ct2 = int(maxt / dt) if species == 'e': charge = -1.0 else: charge = 1.0 nt, = t.shape jdote_x = ptl_traj.ux * ptl_traj.ex * charge / gama jdote_y = ptl_traj.uy * ptl_traj.ey * charge / gama jdote_z = ptl_traj.uz * ptl_traj.ez * charge / gama # jdote_x = (ptl_traj.uy * ptl_traj.bz / gama - # ptl_traj.uz * ptl_traj.by / gama + ptl_traj.ex) * charge # jdote_y = (ptl_traj.uz * ptl_traj.bx / gama - # ptl_traj.ux * ptl_traj.bz / gama + ptl_traj.ey) * charge # jdote_z = (ptl_traj.ux * ptl_traj.by / gama - # ptl_traj.uy * ptl_traj.bx / gama + ptl_traj.ez) * charge dt = np.zeros(nt) dt[0:nt - 1] = np.diff(t) jdote_x_cum = np.cumsum(jdote_x) * dt jdote_y_cum = np.cumsum(jdote_y) * dt jdote_z_cum = np.cumsum(jdote_z) * dt jdote_tot_cum = jdote_x_cum + jdote_y_cum + jdote_z_cum ax1 = fig.add_axes([xs, ys, w1, h1]) p1 = ax1.plot(t[ct1:ct2], jdote_x[ct1:ct2], color='r') p2 = ax1.plot(t[ct1:ct2], jdote_y[ct1:ct2], color='g') p3 = ax1.plot(t[ct1:ct2], jdote_z[ct1:ct2], color='b') ax1.tick_params(labelsize=20) ax1.tick_params(axis='x', labelbottom='off') ax1.plot([mint, maxt], [0, 0], '--', color='k') if species == 'e': charge = '-e' else: charge = 'e' text1 = r'$' + charge + 'u_x' + 'E_x' + '$' ax1.text(0.1, 0.1, text1, color='red', fontsize=32, bbox=dict(facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='center', verticalalignment='center', transform=ax1.transAxes) text2 = r'$' + charge + 'u_y' + 'E_y' + '$' ax1.text(0.2, 0.1, text2, color='green', fontsize=32, bbox=dict(facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='center', verticalalignment='center', transform=ax1.transAxes) text3 = r'$' + charge + 'u_z' + 'E_z' + '$' ax1.text(0.3, 0.1, text3, color='blue', fontsize=32, bbox=dict(facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='center', verticalalignment='center', transform=ax1.transAxes) ys -= h1 + gap ax2 = fig.add_axes([xs, ys, w1, h1]) p1 = ax2.plot(t[ct1:ct2], jdote_x_cum[ct1:ct2], color='r') p2 = ax2.plot(t[ct1:ct2], jdote_y_cum[ct1:ct2], color='g') p3 = ax2.plot(t[ct1:ct2], jdote_z_cum[ct1:ct2], color='b') p4 = ax2.plot(t[ct1:ct2], jdote_tot_cum[ct1:ct2], color='k') ax2.tick_params(labelsize=20) ax2.set_xlabel(r'$t\Omega_{ci}$', fontdict=font) ax2.plot([mint, maxt], [0, 0], '--', color='k') plt.show()
def calc_exb(run_dir, run_name, tframe, coords): """Calculate ExB drift velocity Args: run_dir: PIC run directory run_name: PIC run name trame: time frame coords: coordinates for different fields """ picinfo_fname = '../data/pic_info/pic_info_' + run_name + '.json' pic_info = read_data_from_json(picinfo_fname) nx = pic_info.nx nz = pic_info.nz kwargs = {"current_time": tframe, "xl": 0, "xr": pic_info.lx_di, "zb": -0.5 * pic_info.lz_di, "zt": 0.5 * pic_info.lz_di} size_one_frame = pic_info.nx * pic_info.nz * 4 sigma = 3 fname = run_dir + "data/bx.gda" _, _, bx = read_2d_fields(pic_info, fname, **kwargs) f = MultilinearInterpolator(coords["smin_ez_bx"], coords["smax_ez_bx"], coords["orders"], dtype=np.float32) f.set_values(np.atleast_2d(np.transpose(bx).flatten())) bx = np.transpose(f(coords["coord"]).reshape((nx, nz))) fname = run_dir + "data/by.gda" _, _, by = read_2d_fields(pic_info, fname, **kwargs) f = MultilinearInterpolator(coords["smin_by"], coords["smax_by"], coords["orders"], dtype=np.float32) f.set_values(np.atleast_2d(np.transpose(by).flatten())) by = np.transpose(f(coords["coord"]).reshape((nx, nz))) fname = run_dir + "data/bz.gda" _, _, bz = read_2d_fields(pic_info, fname, **kwargs) f = MultilinearInterpolator(coords["smin_ex_bz"], coords["smax_ex_bz"], coords["orders"], dtype=np.float32) f.set_values(np.atleast_2d(np.transpose(bz).flatten())) bz = np.transpose(f(coords["coord"]).reshape((nx, nz))) fname = run_dir + "data/ex.gda" _, _, ex = read_2d_fields(pic_info, fname, **kwargs) ex = gaussian_filter(ex, sigma) f = MultilinearInterpolator(coords["smin_ex_bz"], coords["smax_ex_bz"], coords["orders"], dtype=np.float32) f.set_values(np.atleast_2d(np.transpose(ex).flatten())) ex = np.transpose(f(coords["coord"]).reshape((nx, nz))) fname = run_dir + "data/ey.gda" _, _, ey = read_2d_fields(pic_info, fname, **kwargs) ey = gaussian_filter(ey, sigma) f = MultilinearInterpolator(coords["smin_h"], coords["smax_h"], coords["orders"], dtype=np.float32) f.set_values(np.atleast_2d(np.transpose(ey).flatten())) ey = np.transpose(f(coords["coord"]).reshape((nx, nz))) fname = run_dir + "data/ez.gda" _, _, ez = read_2d_fields(pic_info, fname, **kwargs) ez = gaussian_filter(ez, sigma) f = MultilinearInterpolator(coords["smin_ez_bx"], coords["smax_ez_bx"], coords["orders"], dtype=np.float32) f.set_values(np.atleast_2d(np.transpose(ez).flatten())) ez = np.transpose(f(coords["coord"]).reshape((nx, nz))) ib2 = 1.0 / (bx**2 + by**2 + bz**2) exb_x = (ey * bz - ez * by) * ib2 exb_y = (ez * bx - ex * bz) * ib2 exb_z = (ex * by - ey * bx) * ib2 fname = run_dir + "data/exb_x.gda" with open(fname, 'a+') as f: offset = size_one_frame * tframe f.seek(offset, os.SEEK_SET) exb_x.tofile(f) fname = run_dir + "data/exb_y.gda" with open(fname, 'a+') as f: offset = size_one_frame * tframe f.seek(offset, os.SEEK_SET) exb_y.tofile(f) fname = run_dir + "data/exb_z.gda" with open(fname, 'a+') as f: offset = size_one_frame * tframe f.seek(offset, os.SEEK_SET) exb_z.tofile(f)
def plot_average_energy(pic_info, species, current_time): """Plot plasma beta and number density. Args: pic_info: namedtuple for the PIC simulation information. species: 'e' for electrons, 'i' for ions. current_time: current time frame. """ kwargs = { "current_time": current_time, "xl": 0, "xr": 80, "zb": -20, "zt": 20 } fname = "../../data/n" + species + ".gda" x, z, num_rho = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/p" + species + "-xx.gda" x, z, pxx = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/p" + species + "-yy.gda" x, z, pyy = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/p" + species + "-zz.gda" x, z, pzz = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/u" + species + "x.gda" x, z, ux = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/u" + species + "y.gda" x, z, uy = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/u" + species + "z.gda" x, z, uz = read_2d_fields(pic_info, fname, **kwargs) x, z, Ay = read_2d_fields(pic_info, "../../data/Ay.gda", **kwargs) if species == 'e': ptl_mass = 1 else: ptl_mass = pic_info.mime ene_avg = (pxx + pyy + pzz) / (2.0*num_rho) + \ 0.5*(ux*ux + uy*uy + uz*uz)*ptl_mass nx, = x.shape nz, = z.shape width = 0.78 height = 0.78 xs = 0.12 ys = 0.92 - height fig = plt.figure(figsize=[10, 5]) ax1 = fig.add_axes([xs, ys, width, height]) if species == 'e': vmax = 0.2 else: vmax = 1.4 kwargs_plot = { "xstep": 2, "zstep": 2, "is_log": False, "vmin": 0.0, "vmax": vmax } xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] p1, cbar1 = plot_2d_contour(x, z, ene_avg, ax1, fig, **kwargs_plot) # p1.set_cmap(plt.cm.seismic) ax1.contour(x[0:nx:xstep], z[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='black', linewidths=0.5) ax1.set_ylabel(r'$z/d_i$', fontdict=font, fontsize=24) ax1.set_xlabel(r'$x/d_i$', fontdict=font, fontsize=24) ax1.tick_params(labelsize=20) fname = r'$E_{avg}$' cbar1.ax.set_ylabel(fname, fontdict=font, fontsize=24) # cbar1.set_ticks(np.arange(0.0, 0.22, 0.05)) # cbar1.ax.set_yticklabels(['$0.2$', '$1.0$', '$5.0$']) cbar1.ax.tick_params(labelsize=20) t_wci = current_time * pic_info.dt_fields title = r'$t = ' + "{:10.1f}".format(t_wci) + '/\Omega_{ci}$' ax1.set_title(title, fontdict=font, fontsize=24) if not os.path.isdir('../img_num_rho/'): os.makedirs('../img_num_rho/') fname = '../img_num_rho/ene_avg_' + species + '_' + \ str(current_time).zfill(3) + '.jpg' fig.savefig(fname, dpi=300) plt.show()
def bulk_energy(pic_info, species, current_time): """Bulk energy and internal energy. Args: pic_info: namedtuple for the PIC simulation information. species: 'e' for electrons, 'i' for ions. current_time: current time frame. """ kwargs = { "current_time": current_time, "xl": 0, "xr": 200, "zb": -20, "zt": 20 } fname = "../../data/u" + species + "x.gda" x, z, ux = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/u" + species + "y.gda" x, z, uy = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/u" + species + "z.gda" x, z, uz = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/n" + species + ".gda" x, z, nrho = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/p" + species + "-xx.gda" x, z, pxx = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/p" + species + "-yy.gda" x, z, pyy = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/p" + species + "-zz.gda" x, z, pzz = read_2d_fields(pic_info, fname, **kwargs) x, z, Ay = read_2d_fields(pic_info, "../../data/Ay.gda", **kwargs) if species == 'e': ptl_mass = 1.0 else: ptl_mass = pic_info.mime internal_ene = (pxx + pyy + pzz) * 0.5 bulk_ene = 0.5 * ptl_mass * nrho * (ux**2 + uy**2 + uz**2) # gama = 1.0 / np.sqrt(1.0 - (ux**2 + uy**2 + uz**2)) # gama = np.sqrt(1.0 + ux**2 + uy**2 + uz**2) # bulk_ene2 = (gama - 1) * ptl_mass * nrho # print np.sum(bulk_ene), np.sum(bulk_ene2) nx, = x.shape nz, = z.shape width = 0.75 height = 0.23 xs = 0.12 ys = 0.93 - height fig = plt.figure(figsize=[10, 6]) ax1 = fig.add_axes([xs, ys, width, height]) kwargs_plot = { "xstep": 1, "zstep": 1, "is_log": True, "vmin": 0.1, "vmax": 10.0 } xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] p1, cbar1 = plot_2d_contour(x, z, bulk_ene / internal_ene, ax1, fig, **kwargs_plot) p1.set_cmap(plt.cm.seismic) ax1.contour( x[0:nx:xstep], z[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='white', linewidths=0.5) ax1.set_ylabel(r'$z/d_i$', fontdict=font, fontsize=24) # ax1.set_xlabel(r'$x/d_i$', fontdict=font, fontsize=24) ax1.tick_params(axis='x', labelbottom='off') ax1.tick_params(labelsize=20) cbar1.ax.set_ylabel(r'$K/u$', fontdict=font, fontsize=24) cbar1.ax.tick_params(labelsize=20) t_wci = current_time * pic_info.dt_fields title = r'$t = ' + "{:10.1f}".format(t_wci) + '/\Omega_{ci}$' ax1.set_title(title, fontdict=font, fontsize=24) ys -= height + 0.05 ax2 = fig.add_axes([xs, ys, width, height]) if species == 'e': vmax = 0.2 else: vmax = 0.8 kwargs_plot = {"xstep": 1, "zstep": 1, "vmin": 0, "vmax": vmax} xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] p2, cbar2 = plot_2d_contour(x, z, bulk_ene, ax2, fig, **kwargs_plot) p2.set_cmap(plt.cm.nipy_spectral) ax2.contour( x[0:nx:xstep], z[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='white', linewidths=0.5) ax2.set_ylabel(r'$z/d_i$', fontdict=font, fontsize=24) ax2.tick_params(axis='x', labelbottom='off') ax2.tick_params(labelsize=20) cbar2.ax.set_ylabel(r'$K$', fontdict=font, fontsize=24) if species == 'e': cbar2.set_ticks(np.arange(0, 0.2, 0.04)) else: cbar2.set_ticks(np.arange(0, 0.9, 0.2)) cbar2.ax.tick_params(labelsize=20) ys -= height + 0.05 ax3 = fig.add_axes([xs, ys, width, height]) kwargs_plot = {"xstep": 1, "zstep": 1, "vmin": 0, "vmax": 0.8} xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] p3, cbar3 = plot_2d_contour(x, z, internal_ene, ax3, fig, **kwargs_plot) p3.set_cmap(plt.cm.nipy_spectral) ax3.contour( x[0:nx:xstep], z[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='white', linewidths=0.5) ax3.set_ylabel(r'$z/d_i$', fontdict=font, fontsize=24) ax3.set_xlabel(r'$x/d_i$', fontdict=font, fontsize=24) ax3.tick_params(labelsize=20) cbar3.ax.set_ylabel(r'$u$', fontdict=font, fontsize=24) cbar3.set_ticks(np.arange(0, 0.9, 0.2)) cbar3.ax.tick_params(labelsize=20) # plt.show() if not os.path.isdir('../img/'): os.makedirs('../img/') if not os.path.isdir('../img/img_bulk_internal/'): os.makedirs('../img/img_bulk_internal/') dir = '../img/img_bulk_internal/' fname = 'bulk_internal' + str(current_time).zfill( 3) + '_' + species + '.jpg' fname = dir + fname fig.savefig(fname, dpi=400) plt.close()
def bulk_energy_change_rate(pic_info, species, current_time): """Bulk energy change rate. Args: pic_info: namedtuple for the PIC simulation information. species: 'e' for electrons, 'i' for ions. current_time: current time frame. """ kwargs = { "current_time": current_time - 1, "xl": 0, "xr": 200, "zb": -15, "zt": 15 } fname = "../../data/u" + species + "x.gda" x, z, ux = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/u" + species + "y.gda" x, z, uy = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/u" + species + "z.gda" x, z, uz = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/n" + species + ".gda" x, z, nrho = read_2d_fields(pic_info, fname, **kwargs) if species == 'e': ptl_mass = 1.0 else: ptl_mass = pic_info.mime bulk_ene1 = 0.5 * ptl_mass * nrho * (ux**2 + uy**2 + uz**2) kwargs = { "current_time": current_time + 1, "xl": 0, "xr": 200, "zb": -15, "zt": 15 } fname = "../../data/u" + species + "x.gda" x, z, ux = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/u" + species + "y.gda" x, z, uy = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/u" + species + "z.gda" x, z, uz = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/n" + species + ".gda" x, z, nrho = read_2d_fields(pic_info, fname, **kwargs) bulk_ene2 = 0.5 * ptl_mass * nrho * (ux**2 + uy**2 + uz**2) kwargs = { "current_time": current_time, "xl": 0, "xr": 200, "zb": -15, "zt": 15 } x, z, Ay = read_2d_fields(pic_info, "../../data/Ay.gda", **kwargs) bulk_ene_rate = bulk_ene2 - bulk_ene1 nx, = x.shape nz, = z.shape width = 0.75 height = 0.7 xs = 0.12 ys = 0.9 - height fig = plt.figure(figsize=[10, 4]) ax1 = fig.add_axes([xs, ys, width, height]) kwargs_plot = {"xstep": 1, "zstep": 1, "vmin": 0.1, "vmax": -0.1} xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] p1, cbar1 = plot_2d_contour(x, z, bulk_ene_rate, ax1, fig, **kwargs_plot) p1.set_cmap(plt.cm.seismic) ax1.contour( x[0:nx:xstep], z[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='black', linewidths=0.5) ax1.set_ylabel(r'$z/d_i$', fontdict=font, fontsize=24) ax1.set_xlabel(r'$x/d_i$', fontdict=font, fontsize=24) ax1.tick_params(labelsize=24) cbar1.ax.set_ylabel(r'$K/u$', fontdict=font, fontsize=24) cbar1.ax.tick_params(labelsize=24) t_wci = current_time * pic_info.dt_fields title = r'$t = ' + "{:10.1f}".format(t_wci) + '/\Omega_{ci}$' ax1.set_title(title, fontdict=font, fontsize=24) plt.show()
def plot_traj(filename, pic_info, species, iptl, mint, maxt): """Plot particle trajectory information. Args: filename: the filename to read the data. pic_info: namedtuple for the PIC simulation information. species: particle species. 'e' for electron. 'i' for ion. iptl: particle ID. mint, maxt: minimum and maximum time for plotting. """ ptl_traj = read_traj_data(filename) gama = np.sqrt(ptl_traj.ux**2 + ptl_traj.uy**2 + ptl_traj.uz**2 + 1.0) mime = pic_info.mime # de scale to di scale ptl_x = ptl_traj.x / math.sqrt(mime) ptl_y = ptl_traj.y / math.sqrt(mime) ptl_z = ptl_traj.z / math.sqrt(mime) # 1/wpe to 1/wci t = ptl_traj.t * pic_info.dtwci / pic_info.dtwpe xl, xr = 0, 200 zb, zt = -20, 20 kwargs = {"current_time": 50, "xl": xl, "xr": xr, "zb": zb, "zt": zt} fname = "../../data/ey.gda" x, z, data_2d = read_2d_fields(pic_info, fname, **kwargs) x, z, Ay = read_2d_fields(pic_info, "../../data/Ay.gda", **kwargs) nx, = x.shape nz, = z.shape # p1 = ax1.plot(ptl_x, gama-1.0, color='k') # ax1.set_xlabel(r'$t\Omega_{ci}$', fontdict=font) # ax1.set_ylabel(r'$E/m_ic^2$', fontdict=font) # ax1.tick_params(labelsize=20) width = 14.0 height = 8.0 fig = plt.figure(figsize=[width, height]) w1, h1 = 0.82, 0.27 xs, ys = 0.10, 0.98 - h1 ax1 = fig.add_axes([xs, ys, w1, h1]) kwargs_plot = { "xstep": 2, "zstep": 2, "is_log": False, "vmin": -1.0, "vmax": 1.0 } xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] im1, cbar1 = plot_2d_contour(x, z, data_2d, ax1, fig, **kwargs_plot) im1.set_cmap(plt.cm.seismic) ax1.contour( x[0:nx:xstep], z[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='black', linewidths=0.5) ax1.tick_params(labelsize=20) ax1.tick_params(axis='x', labelbottom='off') ax1.set_xlim([xl, xr]) ax1.set_ylim([zb, zt]) ax1.set_ylabel(r'$z/d_i$', fontdict=font) cbar1.ax.tick_params(labelsize=20) cbar1.ax.set_ylabel(r'$B_y$', fontdict=font, fontsize=24) p1 = ax1.scatter(ptl_x, ptl_z, s=0.5) # ax2 = fig.add_axes([xs, ys, w1, h1]) # p2 = ax2.plot(t, gama-1.0, color='k') # ax2.set_xlabel(r'$t\Omega_{ci}$', fontdict=font) # ax2.set_ylabel(r'$E/m_ic^2$', fontdict=font) # ax2.tick_params(labelsize=20) gap = 0.04 ys -= h1 + gap ax2 = fig.add_axes([xs, ys, w1 * 0.98 - 0.05 / width, h1]) p2 = ax2.plot(ptl_x, gama - 1.0, color='k') ax2.set_ylabel(r'$E/m_ic^2$', fontdict=font) ax2.tick_params(labelsize=20) ax2.tick_params(axis='x', labelbottom='off') xmin, xmax = ax2.get_xlim() ys -= h1 + gap ax3 = fig.add_axes([xs, ys, w1 * 0.98 - 0.05 / width, h1]) p3 = ax3.plot(ptl_x, ptl_y, color='k') ax3.set_xlabel(r'$x/d_i$', fontdict=font) ax3.set_ylabel(r'$y/d_i$', fontdict=font) ax3.tick_params(labelsize=20) ax1.set_xlim([xmin, xmax]) ax3.set_xlim([xmin, xmax]) if not os.path.isdir('../img/'): os.makedirs('../img/') dir = '../img/img_traj_' + species + '/' if not os.path.isdir(dir): os.makedirs(dir) fname = dir + 'traj_' + species + '_' + str(iptl).zfill(4) + '_1.jpg' fig.savefig(fname, dpi=300) height = 15.0 fig = plt.figure(figsize=[width, height]) w1, h1 = 0.88, 0.135 xs, ys = 0.10, 0.98 - h1 gap = 0.025 dt = t[1] - t[0] ct1 = int(mint / dt) ct2 = int(maxt / dt) ax1 = fig.add_axes([xs, ys, w1, h1]) p1 = ax1.plot(t[ct1:ct2], gama[ct1:ct2] - 1.0, color='k') ax1.set_ylabel(r'$E/m_ic^2$', fontdict=font) ax1.tick_params(labelsize=20) ax1.tick_params(axis='x', labelbottom='off') ax1.plot([mint, maxt], [0, 0], '--', color='k') ax1.text( 0.4, -0.07, r'$x$', color='red', fontsize=32, bbox=dict( facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='center', verticalalignment='center', transform=ax1.transAxes) ax1.text( 0.5, -0.07, r'$y$', color='green', fontsize=32, bbox=dict( facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='center', verticalalignment='center', transform=ax1.transAxes) ax1.text( 0.6, -0.07, r'$z$', color='blue', fontsize=32, bbox=dict( facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='center', verticalalignment='center', transform=ax1.transAxes) ys -= h1 + gap ax2 = fig.add_axes([xs, ys, w1, h1]) p21 = ax2.plot(t[ct1:ct2], ptl_traj.ux[ct1:ct2], color='r', label=r'u_x') p22 = ax2.plot(t[ct1:ct2], ptl_traj.uy[ct1:ct2], color='g', label=r'u_y') p23 = ax2.plot(t[ct1:ct2], ptl_traj.uz[ct1:ct2], color='b', label=r'u_z') ax2.plot([mint, maxt], [0, 0], '--', color='k') ax2.set_ylabel(r'$u_x, u_y, u_z$', fontdict=font) ax2.tick_params(labelsize=20) ax2.tick_params(axis='x', labelbottom='off') kernel = 9 tmax = np.max(t) ys -= h1 + gap ax31 = fig.add_axes([xs, ys, w1, h1]) ex = signal.medfilt(ptl_traj.ex, kernel_size=(kernel)) p31 = ax31.plot(t[ct1:ct2], ex[ct1:ct2], color='r', label=r'E_x') ax31.set_ylabel(r'$E_x$', fontdict=font) ax31.tick_params(labelsize=20) ax31.tick_params(axis='x', labelbottom='off') ax31.plot([mint, maxt], [0, 0], '--', color='k') ys -= h1 + gap ax32 = fig.add_axes([xs, ys, w1, h1]) ey = signal.medfilt(ptl_traj.ey, kernel_size=(kernel)) p32 = ax32.plot(t[ct1:ct2], ey[ct1:ct2], color='g', label=r'E_y') ax32.set_ylabel(r'$E_y$', fontdict=font) ax32.tick_params(labelsize=20) ax32.tick_params(axis='x', labelbottom='off') ax32.plot([mint, maxt], [0, 0], '--', color='k') ys -= h1 + gap ax33 = fig.add_axes([xs, ys, w1, h1]) ez = signal.medfilt(ptl_traj.ez, kernel_size=(kernel)) p33 = ax33.plot(t[ct1:ct2], ez[ct1:ct2], color='b', label=r'E_z') ax33.set_ylabel(r'$E_z$', fontdict=font) ax33.tick_params(labelsize=20) ax33.tick_params(axis='x', labelbottom='off') ax33.plot([mint, maxt], [0, 0], '--', color='k') ys -= h1 + gap ax4 = fig.add_axes([xs, ys, w1, h1]) p41 = ax4.plot(t[ct1:ct2], ptl_traj.bx[ct1:ct2], color='r', label=r'B_x') p42 = ax4.plot(t[ct1:ct2], ptl_traj.by[ct1:ct2], color='g', label=r'B_y') p43 = ax4.plot(t[ct1:ct2], ptl_traj.bz[ct1:ct2], color='b', label=r'B_z') ax4.set_xlabel(r'$t\Omega_{ci}$', fontdict=font) ax4.set_ylabel(r'$B_x, B_y, B_z$', fontdict=font) ax4.tick_params(labelsize=20) ax4.plot([mint, maxt], [0, 0], '--', color='k') ax1.set_xlim([mint, maxt]) ax2.set_xlim([mint, maxt]) ax31.set_xlim([mint, maxt]) ax32.set_xlim([mint, maxt]) ax33.set_xlim([mint, maxt]) ax4.set_xlim([mint, maxt]) fname = dir + 'traj_' + species + '_' + str(iptl).zfill(4) + '_2.jpg' fig.savefig(fname, dpi=300) height = 6.0 fig = plt.figure(figsize=[width, height]) w1, h1 = 0.88, 0.4 xs, ys = 0.10, 0.97 - h1 gap = 0.05 dt = t[1] - t[0] ct1 = int(mint / dt) ct2 = int(maxt / dt) if species == 'e': charge = -1.0 else: charge = 1.0 nt, = t.shape jdote_x = ptl_traj.ux * ptl_traj.ex * charge / gama jdote_y = ptl_traj.uy * ptl_traj.ey * charge / gama jdote_z = ptl_traj.uz * ptl_traj.ez * charge / gama # jdote_x = (ptl_traj.uy * ptl_traj.bz / gama - # ptl_traj.uz * ptl_traj.by / gama + ptl_traj.ex) * charge # jdote_y = (ptl_traj.uz * ptl_traj.bx / gama - # ptl_traj.ux * ptl_traj.bz / gama + ptl_traj.ey) * charge # jdote_z = (ptl_traj.ux * ptl_traj.by / gama - # ptl_traj.uy * ptl_traj.bx / gama + ptl_traj.ez) * charge dt = np.zeros(nt) dt[0:nt - 1] = np.diff(t) jdote_x_cum = np.cumsum(jdote_x) * dt jdote_y_cum = np.cumsum(jdote_y) * dt jdote_z_cum = np.cumsum(jdote_z) * dt jdote_tot_cum = jdote_x_cum + jdote_y_cum + jdote_z_cum ax1 = fig.add_axes([xs, ys, w1, h1]) p1 = ax1.plot(t[ct1:ct2], jdote_x[ct1:ct2], color='r') p2 = ax1.plot(t[ct1:ct2], jdote_y[ct1:ct2], color='g') p3 = ax1.plot(t[ct1:ct2], jdote_z[ct1:ct2], color='b') ax1.tick_params(labelsize=20) ax1.tick_params(axis='x', labelbottom='off') ax1.plot([mint, maxt], [0, 0], '--', color='k') if species == 'e': charge = '-e' else: charge = 'e' text1 = r'$' + charge + 'u_x' + 'E_x' + '$' ax1.text( 0.1, 0.1, text1, color='red', fontsize=32, bbox=dict( facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='center', verticalalignment='center', transform=ax1.transAxes) text2 = r'$' + charge + 'u_y' + 'E_y' + '$' ax1.text( 0.2, 0.1, text2, color='green', fontsize=32, bbox=dict( facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='center', verticalalignment='center', transform=ax1.transAxes) text3 = r'$' + charge + 'u_z' + 'E_z' + '$' ax1.text( 0.3, 0.1, text3, color='blue', fontsize=32, bbox=dict( facecolor='none', alpha=1.0, edgecolor='none', pad=10.0), horizontalalignment='center', verticalalignment='center', transform=ax1.transAxes) ys -= h1 + gap ax2 = fig.add_axes([xs, ys, w1, h1]) p1 = ax2.plot(t[ct1:ct2], jdote_x_cum[ct1:ct2], color='r') p2 = ax2.plot(t[ct1:ct2], jdote_y_cum[ct1:ct2], color='g') p3 = ax2.plot(t[ct1:ct2], jdote_z_cum[ct1:ct2], color='b') p4 = ax2.plot(t[ct1:ct2], jdote_tot_cum[ct1:ct2], color='k') ax2.tick_params(labelsize=20) ax2.set_xlabel(r'$t\Omega_{ci}$', fontdict=font) ax2.plot([mint, maxt], [0, 0], '--', color='k') plt.show()
def calc_power_spectrum_vel(pic_info, ct, species, run_name, shock_pos, base_dir='../../'): """Calculate power spectrum using velocities Args: pic_info: namedtuple for the PIC simulation information. ct: current time frame. species: particle species run_name: the simulation run name shock_pos: the shock position in cell index base_dir: the root directory of the run """ xmin, xmax = 0, pic_info.lx_di xmin, xmax = 0, 105 zmin, zmax = -0.5 * pic_info.lz_di, 0.5 * pic_info.lz_di kwargs = { "current_time": ct, "xl": xmin, "xr": xmax, "zb": zmin, "zt": zmax } fname = base_dir + 'data1/vex.gda' x, z, vel = read_2d_fields(pic_info, fname, **kwargs) nx, = x.shape nz, = z.shape xm = x[shock_pos] xmin, xmax = 0, xm fname = base_dir + 'data1/v' + species + 'x.gda' x, z, vx = read_2d_fields(pic_info, fname, **kwargs) fname = base_dir + 'data1/v' + species + 'y.gda' x, z, vy = read_2d_fields(pic_info, fname, **kwargs) fname = base_dir + 'data1/v' + species + 'z.gda' x, z, vz = read_2d_fields(pic_info, fname, **kwargs) smime = math.sqrt(pic_info.mime) lx = np.max(x) - np.min(x) lz = np.max(z) - np.min(z) vx_k = np.fft.rfft2(vx) vy_k = np.fft.rfft2(vy) vz_k = np.fft.rfft2(vz) v2_k = np.absolute(vx_k)**2 + np.absolute(vy_k)**2 + np.absolute(vz_k)**2 xstep = lx / nx kx = np.fft.fftfreq(nx, xstep) idx = np.argsort(kx) zstep = lz / nz kz = np.fft.fftfreq(nz, zstep) idz = np.argsort(kz) print np.min(kx), np.max(kx), np.min(kz), np.max(kz) kxs, kzs = np.meshgrid(kx[:nx // 2 + 1], kz) ks = np.sqrt(kxs * kxs + kzs * kzs) kmin, kmax = np.min(ks), np.max(ks) kbins = np.linspace(kmin, kmax, nx // 2 + 1, endpoint=True) ps, kbins_edges = np.histogram( ks, bins=kbins, weights=v2_k * ks, normed=True) w1, h1 = 0.8, 0.8 xs, ys = 0.15, 0.95 - h1 fig = plt.figure(figsize=[7, 5]) ax1 = fig.add_axes([xs, ys, w1, h1]) ax1.loglog(kbins_edges[:-1], ps, linewidth=2) # psm = np.argmax(ps) psm = 4 pindex = -5.0 / 3 power_k = kbins[psm:]**pindex shift = 400 if species is 'electron': ax1.loglog( kbins[psm:psm + shift], power_k[:shift] * 0.5 / power_k[0], linestyle='--', linewidth=2, color='k') else: ax1.loglog( kbins[psm:psm + shift], power_k[:shift] * 10 / power_k[0], linestyle='--', linewidth=2, color='k') power_index = "{%0.1f}" % pindex # tname = r'$\sim k^{' + power_index + '}$' tname = r'$\sim k^{-5/3}$' ax1.text( 0.4, 0.8, tname, color='black', fontsize=24, horizontalalignment='left', verticalalignment='center', transform=ax1.transAxes) ax1.tick_params(labelsize=16) ax1.set_xlabel(r'$kd_i$', fontdict=font, fontsize=20) ax1.set_ylabel(r'$E_V(k)$', fontdict=font, fontsize=20) ax1.set_xlim([1E-2, 3E1]) if species is 'electron': ax1.set_ylim([1E-2, 0.5]) else: ax1.set_ylim([1E-2, 5]) fig_dir = '../img/img_power_spectrum/' + run_name + '/' mkdir_p(fig_dir) # fname = fig_dir + '/ps_vel_' + species + str(ct).zfill(3) + '.jpg' # fig.savefig(fname, dpi=300) plt.show()
def plot_ptl_traj(filename, pic_info, species, iptl, mint, maxt): """Plot particle trajectory information. Args: filename: the filename to read the data. pic_info: namedtuple for the PIC simulation information. species: particle species. 'e' for electron. 'i' for ion. iptl: particle ID. mint, maxt: minimum and maximum time for plotting. """ ptl_traj = read_traj_data(filename) gama = np.sqrt(ptl_traj.ux**2 + ptl_traj.uy**2 + ptl_traj.uz**2 + 1.0) mime = pic_info.mime # de scale to di scale ptl_x = ptl_traj.x / math.sqrt(mime) ptl_y = ptl_traj.y / math.sqrt(mime) ptl_z = ptl_traj.z / math.sqrt(mime) # 1/wpe to 1/wci t = ptl_traj.t * pic_info.dtwci / pic_info.dtwpe xl, xr = 0, 50 zb, zt = -20, 20 kwargs = {"current_time": 65, "xl": xl, "xr": xr, "zb": zb, "zt": zt} fname = "../../data/uex.gda" x, z, uex = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/ne.gda" x, z, ne = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/uix.gda" x, z, uix = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/ni.gda" x, z, ni = read_2d_fields(pic_info, fname, **kwargs) ux = (uex * ne + uix * ni * pic_info.mime) / (ne + ni * pic_info.mime) x, z, Ay = read_2d_fields(pic_info, "../../data/Ay.gda", **kwargs) nx, = x.shape nz, = z.shape width = 8.0 height = 8.0 fig = plt.figure(figsize=[width, height]) w1, h1 = 0.74, 0.42 xs, ys = 0.13, 0.98 - h1 ax1 = fig.add_axes([xs, ys, w1, h1]) kwargs_plot = { "xstep": 2, "zstep": 2, "is_log": False, "vmin": -1.0, "vmax": 1.0 } xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] va = 0.2 # Alfven speed im1, cbar1 = plot_2d_contour(x, z, ux / va, ax1, fig, **kwargs_plot) im1.set_cmap(plt.cm.seismic) ax1.contour( x[0:nx:xstep], z[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='black', linewidths=0.5) ax1.tick_params(labelsize=20) ax1.tick_params(axis='x', labelbottom='off') ax1.set_xlim([xl, xr]) ax1.set_ylim([zb, zt]) ax1.set_ylabel(r'$z/d_i$', fontdict=font) cbar1.ax.tick_params(labelsize=20) cbar1.ax.set_ylabel(r'$u_x/V_A$', fontdict=font, fontsize=24) tstop = 1990 p1 = ax1.plot(ptl_x[0:tstop], ptl_z[0:tstop], linewidth=2, color='k') gap = 0.04 ys -= h1 + gap ax2 = fig.add_axes([xs, ys, w1 * 0.98 - 0.05 / width, h1]) eth = pic_info.vthi**2 * 3 p2 = ax2.plot( ptl_x[0:tstop], (gama[0:tstop] - 1.0) / eth, color='k', linewidth=2) ax2.set_xlabel(r'$x/d_i$', fontdict=font) ax2.set_ylabel(r'$E/E_{\text{thi}}$', fontdict=font) ax2.tick_params(labelsize=20) # ax2.tick_params(axis='x', labelbottom='off') xmin, xmax = ax1.get_xlim() ax2.set_xlim([xmin, xmax]) if not os.path.isdir('../img/'): os.makedirs('../img/') fname = '../img/' + 'traj_' + species + '_' + str(iptl).zfill(4) + '_1.jpg' fig.savefig(fname, dpi=300) plt.show()
def trace_field_line(pic_info): """Calculate parallel potential defined by Jan Egedal. Args: pic_info: namedtuple for the PIC simulation information. """ kwargs = {"current_time": 40, "xl": 0, "xr": 200, "zb": -50, "zt": 50} x, z, Ay = contour_plots.read_2d_fields(pic_info, "../data/Ay.gda", **kwargs) x, z, Bx = contour_plots.read_2d_fields(pic_info, "../data/bx.gda", **kwargs) x, z, Bz = contour_plots.read_2d_fields(pic_info, "../data/bz.gda", **kwargs) xarr, zarr, Bz = contour_plots.read_2d_fields(pic_info, "../data/bz.gda", **kwargs) x, z, Ex = contour_plots.read_2d_fields(pic_info, "../data/ex.gda", **kwargs) x, z, Ez = contour_plots.read_2d_fields(pic_info, "../data/ez.gda", **kwargs) nx, = x.shape nz, = z.shape print nx, nz x0 = 199.0 z0 = 45.0 i = int(x0 / pic_info.dx_di) k = int(z0 / pic_info.dz_di) # x0 = xarr[i] # z0 = zarr[k] - zarr[0] # nstep = 0 # xlist = [x0] # zlist = [z0] # dx_di = pic_info.dx_di # dz_di = pic_info.dz_di # deltas = math.sqrt(dx_di**2 + dz_di**2)*0.1 # hds = deltas * 0.5 # total_lengh = 0 # x = x0 # z = z0 # while (x > xarr[0] and x < xarr[-1] and z > 0 # and z < (zarr[-1]-zarr[0]) and total_lengh < 1E2): # deltax1, deltaz1, x1, z1, ex, ez = middle_step_rk4(x, z, nx, nz, # dx_di, dz_di, Bx, Bz, Ex, Ez, hds) # deltax2, deltaz2, x2, z2, ex, ez = middle_step_rk4(x1, z1, nx, nz, # dx_di, dz_di, Bx, Bz, Ex, Ez, hds) # deltax3, deltaz3, x3, z3, ex, ez = middle_step_rk4(x, z, nx, nz, # dx_di, dz_di, Bx, Bz, Ex, Ez, deltas) # deltax4, deltaz4, x4, z4, ex, ez = middle_step_rk4(x, z, nx, nz, # dx_di, dz_di, Bx, Bz, Ex, Ez, hds) # # x += deltas/6 * (deltax1 + 2*deltax2 + 2*deltax3 + deltax4) # z += deltas/6 * (deltaz1 + 2*deltaz2 + 2*deltaz3 + deltaz4) # total_lengh += deltas # xlist.append(x) # zlist.append(z) # nstep += 1 # length = math.sqrt((x-x0)**2 + (z-z0)**2) # if (length < dx_di and nstep > 20): # print length # break dx_di = pic_info.dx_di dz_di = pic_info.dz_di #deltas = math.sqrt(dx_di**2 + dz_di**2) #hds = deltas * 0.5 hmax = dx_di * 100 h = hmax / 4.0 # Cash-Karp parameters a = [0.0, 0.2, 0.3, 0.6, 1.0, 0.875] b = [[], [0.2], [3.0 / 40.0, 9.0 / 40.0], [0.3, -0.9, 1.2], [-11.0 / 54.0, 2.5, -70.0 / 27.0, 35.0 / 27.0], [ 1631.0 / 55296.0, 175.0 / 512.0, 575.0 / 13824.0, 44275.0 / 110592.0, 253.0 / 4096.0 ]] c = [37.0 / 378.0, 0.0, 250.0 / 621.0, 125.0 / 594.0, 0.0, 512.0 / 1771.0] dc = [ c[0] - 2825.0 / 27648.0, c[1] - 0.0, c[2] - 18575.0 / 48384.0, c[3] - 13525.0 / 55296.0, c[4] - 277.00 / 14336.0, c[5] - 0.25 ] def F(t, x, z): indices_bl, indices_tr, delta = grid_indices(x, 0, z, nx, 1, nz, dx_di, 1, dz_di) ix1 = indices_bl[0] iz1 = indices_bl[2] ix2 = indices_tr[0] iz2 = indices_tr[2] offsetx = delta[0] offsetz = delta[2] v1 = (1.0 - offsetx) * (1.0 - offsetz) v2 = offsetx * (1.0 - offsetz) v3 = offsetx * offsetz v4 = (1.0 - offsetx) * offsetz if (ix1 < nx and ix2 < nx and iz1 < nz and iz2 < nz): bx = Bx[iz1, ix1] * v1 + Bx[iz1, ix2] * v2 + Bx[ iz2, ix2] * v3 + Bx[iz2, ix1] * v4 bz = Bz[iz1, ix1] * v1 + Bz[iz1, ix2] * v2 + Bz[ iz2, ix2] * v3 + Bz[iz2, ix1] * v4 ex = Ex[iz1, ix1] * v1 + Ex[iz1, ix2] * v2 + Ex[ iz2, ix2] * v3 + Ex[iz2, ix1] * v4 ez = Ez[iz1, ix1] * v1 + Ez[iz1, ix2] * v2 + Ez[ iz2, ix2] * v3 + Ez[iz2, ix1] * v4 absB = math.sqrt(bx**2 + bz**2) deltax1 = bx / absB deltaz1 = bz / absB else: ex = 0 ez = 0 deltax1 = 0 deltaz1 = 0 return (deltax1, deltaz1, ex, ez) tol = 1e-5 x0 = xarr[i] - xarr[0] z0 = zarr[k] - zarr[0] y = [x0, z0] nstep = 0 xlist = [x0] zlist = [z0] t = 0 x = x0 z = z0 while (x > 0 and x < (xarr[-1] - xarr[0]) and z > 0 and z < (zarr[-1] - zarr[0]) and t < 4E2): # Compute k[i] function values. kx = [None] * 6 kz = [None] * 6 kx[0], kz[0], ex0, ez0 = F(t, x, z) kx[1], kz[1], ex1, ez1 = F(t + a[1] * h, x + h * (kx[0] * b[1][0]), z + h * (kz[0] * b[1][0])) kx[2], kz[2], ex2, ez2 = F(t + a[2] * h, x + h * (kx[0] * b[2][0] + kx[1] * b[2][1]), z + h * (kz[0] * b[2][0] + kz[1] * b[2][1])) kx[3], kz[3], ex3, ez3 = F( t + a[3] * h, x + h * (kx[0] * b[3][0] + kx[1] * b[3][1] + kx[2] * b[3][2]), z + h * (kz[0] * b[3][0] + kz[1] * b[3][1] + kz[2] * b[3][2])) kx[4], kz[4], ex4, ez4 = F( t + a[4] * h, x + h * (kx[0] * b[4][0] + kx[1] * b[4][1] + kx[2] * b[4][2] + kx[3] * b[4][3]), z + h * (kz[0] * b[4][0] + kz[1] * b[4][1] + kz[2] * b[4][2] + kz[3] * b[4][3])) kx[5], kz[5], ex5, ez5 = F( t + a[5] * h, x + h * (kx[0] * b[5][0] + kx[1] * b[5][1] + kx[2] * b[5][2] + kx[3] * b[5][3] + kx[4] * b[5][4]), z + h * (kz[0] * b[5][0] + kz[1] * b[5][1] + kz[2] * b[5][2] + kz[3] * b[5][3] + kz[4] * b[5][4])) # Estimate current error and current maximum error. E = norm([ h * (kx[0] * dc[0] + kx[1] * dc[1] + kx[2] * dc[2] + kx[3] * dc[3] + kx[4] * dc[4] + kx[5] * dc[5]), h * (kz[0] * dc[0] + kz[1] * dc[1] + kz[2] * dc[2] + kz[3] * dc[3] + kz[4] * dc[4] + kz[5] * dc[5]) ]) Emax = tol * max(norm(y), 1.0) # Update solution if error is OK. if E < Emax: t += h y[0] += h * (kx[0] * c[0] + kx[1] * c[1] + kx[2] * c[2] + kx[3] * c[3] + kx[4] * c[4] + kx[5] * c[5]) y[1] += h * (kz[0] * c[0] + kz[1] * c[1] + kz[2] * c[2] + kz[3] * c[3] + kz[4] * c[4] + kz[5] * c[5]) x = y[0] z = y[1] xlist.append(x) zlist.append(z) #out += [(t, list(y))] # Update step size if E > 0.0: h = min(hmax, 0.85 * h * (Emax / E)**0.2) width = 0.78 height = 0.75 xs = 0.14 xe = 0.94 - xs ys = 0.9 - height #fig = plt.figure(figsize=(7,5)) fig = plt.figure(figsize=(7, 2)) ax1 = fig.add_axes([xs, ys, width, height]) kwargs_plot = {"xstep": 2, "zstep": 2} xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] p1, cbar1 = contour_plots.plot_2d_contour(xarr, zarr, Ay, ax1, fig, **kwargs_plot) p1.set_cmap(plt.cm.seismic) # cs = ax1.contour(xarr[0:nx:xstep], zarr[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], # colors='white', linewidths=0.5, levels=np.arange(0, 252, 1)) p2 = ax1.plot(xlist, zlist + zarr[0], color='black') #cbar1.set_ticks(np.arange(-0.8, 1.0, 0.4)) #ax1.tick_params(axis='x', labelbottom='off') plt.show()
def rho_bands_2d(plot_config, show_plot=True): """Plot densities for energetic particles in the 2D simulation """ pic_run = plot_config["pic_run"] species = plot_config["species"] tframe = plot_config["tframe"] picinfo_fname = '../data/pic_info/pic_info_' + pic_run + '.json' pic_info = read_data_from_json(picinfo_fname) pic_run_dir = pic_info.run_dir if species == 'e': vth = pic_info.vthe else: vth = pic_info.vthi nbins = 1000 ndata = nbins + 3 # including magnetic field tindex = pic_info.particle_interval * tframe gama = 1.0 / math.sqrt(1.0 - 3 * vth**2) eth = gama - 1.0 ebins = np.logspace(-6, 4, nbins) ebins /= eth xmin, xmax = 0, pic_info.lx_di zmin, zmax = -pic_info.lz_di * 0.5, pic_info.lz_di * 0.5 nx, nz = pic_info.nx, pic_info.nz smime = math.sqrt(pic_info.mime) dx_de = pic_info.dx_di * smime dy_de = pic_info.dy_di * smime dz_de = pic_info.dz_di * smime kwargs = { "current_time": tframe, "xl": 0, "xr": pic_info.lx_di, "zb": -pic_info.lz_di, "zt": pic_info.lz_di } # fname = pic_run_dir + "data/Ay.gda" # x, z, Ay = read_2d_fields(pic_info, fname, **kwargs) fname = pic_run_dir + "data/bx.gda" x, z, bx = read_2d_fields(pic_info, fname, **kwargs) fname = pic_run_dir + "data/by.gda" x, z, by = read_2d_fields(pic_info, fname, **kwargs) fname = pic_run_dir + "data/bz.gda" x, z, bz = read_2d_fields(pic_info, fname, **kwargs) ib = 1.0 / np.sqrt(bx**2 + by**2 + bz**2) bx = bx * ib by = by * ib bz = bz * ib kappax = (bx * np.gradient(bx, axis=1) / dx_de + bz * np.gradient(bx, axis=0) / dz_de) kappay = (bx * np.gradient(by, axis=1) / dx_de + bz * np.gradient(by, axis=0) / dz_de) kappaz = (bx * np.gradient(bz, axis=1) / dx_de + bz * np.gradient(bz, axis=0) / dz_de) fname = pic_run_dir + "data/vex.gda" x, z, vex = read_2d_fields(pic_info, fname, **kwargs) fname = pic_run_dir + "data/vey.gda" x, z, vey = read_2d_fields(pic_info, fname, **kwargs) fname = pic_run_dir + "data/vez.gda" x, z, vez = read_2d_fields(pic_info, fname, **kwargs) fname = pic_run_dir + "data/vix.gda" x, z, vix = read_2d_fields(pic_info, fname, **kwargs) fname = pic_run_dir + "data/viy.gda" x, z, viy = read_2d_fields(pic_info, fname, **kwargs) fname = pic_run_dir + "data/viz.gda" x, z, viz = read_2d_fields(pic_info, fname, **kwargs) fname = pic_run_dir + "data/ne.gda" x, z, ne = read_2d_fields(pic_info, fname, **kwargs) fname = pic_run_dir + "data/ni.gda" x, z, ni = read_2d_fields(pic_info, fname, **kwargs) inrho = 1.0 / (ne + ni * pic_info.mime) vx = (ne * vex + ni * vix * pic_info.mime) * inrho vy = (ne * vey + ni * viy * pic_info.mime) * inrho vz = (ne * vez + ni * viz * pic_info.mime) * inrho vdot_kappa = vx * kappax + vy * kappay + vz * kappaz nbands = 7 nreduce = 16 nxr = pic_info.nx // nreduce nzr = pic_info.nz // nreduce ntot = np.zeros((nzr, nxr)) nhigh = np.zeros((nzr, nxr)) fig = plt.figure(figsize=[14, 7]) rect0 = [0.055, 0.75, 0.4, 0.20] hgap, vgap = 0.09, 0.025 if species == 'e': nmins = [1E-1, 1E-2, 5E-3, 1E-3, 6E-5, 2E-5, 6E-6] nmaxs = [5E0, 1E0, 5E-1, 1E-1, 6E-3, 2E-3, 6E-4] else: nmins = [1E-1, 2E-2, 1E-2, 5E-3, 5E-4, 5E-5, 1.2E-5] nmaxs = [5E0, 2E0, 1E0, 5E-1, 5E-2, 5E-3, 1.2E-3] nmins = np.asarray(nmins) / 10 nmaxs = np.asarray(nmaxs) / 10 axs = [] rects = [] nrows = (nbands + 1) // 2 for iband in range(nbands + 1): row = iband % nrows col = iband // nrows if row == 0: rect = np.copy(rect0) rect[0] += (rect[2] + hgap) * col ax = fig.add_axes(rect) ax.set_ylim([-20, 20]) ax.tick_params(bottom=True, top=True, left=True, right=True) ax.tick_params(axis='x', which='minor', direction='in') ax.tick_params(axis='x', which='major', direction='in') ax.tick_params(axis='y', which='minor', direction='in') ax.tick_params(axis='y', which='major', direction='in') if row < nrows - 1: ax.tick_params(axis='x', labelbottom=False) else: ax.set_xlabel(r'$x/d_i$', fontsize=16) if col == 0: ax.set_ylabel(r'$z/d_i$', fontsize=16) ax.tick_params(labelsize=12) axs.append(ax) rects.append(np.copy(rect)) rect[1] -= rect[3] + vgap band_break = 4 for iband in range(nbands): print("Energy band: %d" % iband) if iband < band_break: ax = axs[iband] rect = rects[iband] else: ax = axs[iband + 1] rect = rects[iband + 1] fname = (pic_run_dir + "data-smooth2/n" + species + "_" + str(iband) + "_" + str(tindex) + ".gda") nrho = np.fromfile(fname, dtype=np.float32) nrho = nrho.reshape((nzr, nxr)) if iband >= 5: nhigh += nrho ntot += nrho nmin, nmax = nmins[iband], nmaxs[iband] p1 = ax.imshow(nrho + 1E-10, extent=[xmin, xmax, zmin, zmax], norm=LogNorm(vmin=nmin, vmax=nmax), cmap=plt.cm.inferno, aspect='auto', origin='lower', interpolation='bicubic') # ax.contour(x, z, Ay, colors='w', linewidths=0.5) if iband == 0: label1 = r'$n(\varepsilon < 10\varepsilon_\text{th})$' elif iband > 0 and iband < nbands - 1: label1 = (r'$n(' + str(2**(iband - 1) * 10) + r'\varepsilon_\text{th} < ' + r'\varepsilon < ' + str(2**iband * 10) + r'\varepsilon_\text{th})$') else: label1 = (r'$n(\varepsilon > ' + str(2**(nbands - 2) * 10) + r'\varepsilon_\text{th})$') ax.text(0.98, 0.87, label1, color='k', fontsize=16, bbox=dict(facecolor='w', alpha=0.75, edgecolor='none', boxstyle="round,pad=0.1"), horizontalalignment='right', verticalalignment='center', transform=ax.transAxes) twci = math.ceil((tframe * pic_info.dt_fields) / 0.1) * 0.1 text1 = r'$t\Omega_{ci}=' + ("{%0.0f}" % twci) + '$' if iband == 0: # ax.set_title(text1, fontsize=16) xpos = (rect[2] + hgap * 0.5) / rect[2] ax.text(xpos, 1.1, text1, color='k', fontsize=16, bbox=dict(facecolor='w', alpha=0.75, edgecolor='none', boxstyle="round,pad=0.1"), horizontalalignment='center', verticalalignment='center', transform=ax.transAxes) rect_cbar = np.copy(rect) rect_cbar[0] += rect[2] + 0.01 rect_cbar[2] = 0.007 cbar_ax = fig.add_axes(rect_cbar) cbar = fig.colorbar(p1, cax=cbar_ax, extend='both') cbar.ax.tick_params(labelsize=12) ax = axs[band_break] rect = rects[band_break] vmin, vmax = -1.0, 1.0 knorm = 100 p1 = ax.imshow(vdot_kappa * knorm, extent=[xmin, xmax, zmin, zmax], vmin=vmin, vmax=vmax, cmap=plt.cm.seismic, aspect='auto', origin='lower', interpolation='bicubic') # ax.contour(x, z, Ay, colors='k', linewidths=0.5) ax.tick_params(labelsize=12) label1 = r'$' + str(knorm) + r'\boldsymbol{v}\cdot\boldsymbol{\kappa}$' ax.text(0.98, 0.87, label1, color='w', fontsize=16, bbox=dict(facecolor='k', alpha=0.5, edgecolor='none', boxstyle="round,pad=0.1"), horizontalalignment='right', verticalalignment='center', transform=ax.transAxes) rect_cbar = np.copy(rect) rect_cbar[0] += rect[2] + 0.01 rect_cbar[2] = 0.007 cbar_ax = fig.add_axes(rect_cbar) cbar = fig.colorbar(p1, cax=cbar_ax, extend='both') cbar.set_ticks(np.linspace(-1, 1, num=5)) cbar.ax.tick_params(labelsize=12) fdir = '../img/open_bc/rho_bands_2d/' + pic_run + '/' mkdir_p(fdir) fname = (fdir + 'nrho_bands_' + species + '_' + str(tframe) + ".jpg") fig.savefig(fname, dpi=200) if show_plot: plt.show() else: plt.close()
def plot_ptl_traj(filename, pic_info, species, iptl, mint, maxt): """Plot particle trajectory information. Args: filename: the filename to read the data. pic_info: namedtuple for the PIC simulation information. species: particle species. 'e' for electron. 'i' for ion. iptl: particle ID. mint, maxt: minimum and maximum time for plotting. """ ptl_traj = read_traj_data(filename) gama = np.sqrt(ptl_traj.ux**2 + ptl_traj.uy**2 + ptl_traj.uz**2 + 1.0) mime = pic_info.mime # de scale to di scale ptl_x = ptl_traj.x / math.sqrt(mime) ptl_y = ptl_traj.y / math.sqrt(mime) ptl_z = ptl_traj.z / math.sqrt(mime) # 1/wpe to 1/wci t = ptl_traj.t * pic_info.dtwci / pic_info.dtwpe xl, xr = 0, 50 zb, zt = -20, 20 kwargs = {"current_time": 65, "xl": xl, "xr": xr, "zb": zb, "zt": zt} fname = "../../data/uex.gda" x, z, uex = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/ne.gda" x, z, ne = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/uix.gda" x, z, uix = read_2d_fields(pic_info, fname, **kwargs) fname = "../../data/ni.gda" x, z, ni = read_2d_fields(pic_info, fname, **kwargs) ux = (uex * ne + uix * ni * pic_info.mime) / (ne + ni * pic_info.mime) x, z, Ay = read_2d_fields(pic_info, "../../data/Ay.gda", **kwargs) nx, = x.shape nz, = z.shape width = 8.0 height = 8.0 fig = plt.figure(figsize=[width, height]) w1, h1 = 0.74, 0.42 xs, ys = 0.13, 0.98 - h1 ax1 = fig.add_axes([xs, ys, w1, h1]) kwargs_plot = { "xstep": 2, "zstep": 2, "is_log": False, "vmin": -1.0, "vmax": 1.0 } xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] va = 0.2 # Alfven speed im1, cbar1 = plot_2d_contour(x, z, ux / va, ax1, fig, **kwargs_plot) im1.set_cmap(plt.cm.seismic) ax1.contour(x[0:nx:xstep], z[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='black', linewidths=0.5) ax1.tick_params(labelsize=20) ax1.tick_params(axis='x', labelbottom='off') ax1.set_xlim([xl, xr]) ax1.set_ylim([zb, zt]) ax1.set_ylabel(r'$z/d_i$', fontdict=font) cbar1.ax.tick_params(labelsize=20) cbar1.ax.set_ylabel(r'$u_x/V_A$', fontdict=font, fontsize=24) tstop = 1990 p1 = ax1.plot(ptl_x[0:tstop], ptl_z[0:tstop], linewidth=2, color='k') gap = 0.04 ys -= h1 + gap ax2 = fig.add_axes([xs, ys, w1 * 0.98 - 0.05 / width, h1]) eth = pic_info.vthi**2 * 3 p2 = ax2.plot(ptl_x[0:tstop], (gama[0:tstop] - 1.0) / eth, color='k', linewidth=2) ax2.set_xlabel(r'$x/d_i$', fontdict=font) ax2.set_ylabel(r'$E/E_{\text{thi}}$', fontdict=font) ax2.tick_params(labelsize=20) # ax2.tick_params(axis='x', labelbottom='off') xmin, xmax = ax1.get_xlim() ax2.set_xlim([xmin, xmax]) if not os.path.isdir('../img/'): os.makedirs('../img/') fname = '../img/' + 'traj_' + species + '_' + str(iptl).zfill(4) + '_1.jpg' fig.savefig(fname, dpi=300) plt.show()
def calc_power_spectrum_mag(pic_info, ct, run_name, shock_pos, base_dir='../../'): """calculate power spectrum using magnetic fields Args: pic_info: namedtuple for the PIC simulation information. ct: current time frame. """ xmin, xmax = 0, pic_info.lx_di xmin, xmax = 0, 105 zmin, zmax = -0.5 * pic_info.lz_di, 0.5 * pic_info.lz_di kwargs = { "current_time": ct, "xl": xmin, "xr": xmax, "zb": zmin, "zt": zmax } fname = base_dir + 'data1/vex.gda' x, z, vel = read_2d_fields(pic_info, fname, **kwargs) nx, = x.shape nz, = z.shape # data_cum = np.sum(vel, axis=0) / nz # data_grad = np.abs(np.gradient(data_cum)) # xs = 5 # max_index = np.argmax(data_grad[xs:]) # xm = x[max_index] xm = x[shock_pos] xmin, xmax = 0, xm fname = base_dir + 'data1/bx.gda' x, z, bx = read_2d_fields(pic_info, fname, **kwargs) fname = base_dir + 'data1/by.gda' x, z, by = read_2d_fields(pic_info, fname, **kwargs) fname = base_dir + 'data1/bz.gda' x, z, bz = read_2d_fields(pic_info, fname, **kwargs) smime = math.sqrt(pic_info.mime) lx = np.max(x) - np.min(x) lz = np.max(z) - np.min(z) bx_k = np.fft.rfft2(bx) by_k = np.fft.rfft2(by) bz_k = np.fft.rfft2(bz) b2_k = np.absolute(bx_k)**2 + np.absolute(by_k)**2 + np.absolute(bz_k)**2 xstep = lx / nx kx = np.fft.fftfreq(nx, xstep) idx = np.argsort(kx) zstep = lz / nz kz = np.fft.fftfreq(nz, zstep) idz = np.argsort(kz) print np.min(kx), np.max(kx), np.min(kz), np.max(kz) kxs, kzs = np.meshgrid(kx[:nx // 2 + 1], kz) ks = np.sqrt(kxs * kxs + kzs * kzs) # kmin, kmax = np.min(ks), np.max(ks) # kbins = np.linspace(kmin, kmax, nx//2+1, endpoint=True) kmin = 1E-2 kmax = np.max(ks) kmin_log, kmax_log = math.log10(kmin), math.log10(kmax) kbins = 10**np.linspace(kmin_log, kmax_log, 64, endpoint=True) ps, kbins_edges = np.histogram( ks, bins=kbins, weights=b2_k * ks, density=True) w1, h1 = 0.8, 0.8 xs, ys = 0.15, 0.95 - h1 fig = plt.figure(figsize=[7, 5]) ax1 = fig.add_axes([xs, ys, w1, h1]) for index, k in np.ndenumerate(kbins): pass # print index, k psm = 25 # pindex = -5.0/3.0 pindex = -2.0 power_k = kbins[psm:]**pindex shift = 22 ax1.loglog(kbins_edges[:-1], ps, linewidth=2) ax1.loglog( kbins[psm:psm + shift], power_k[:shift] * 2 / power_k[0], linestyle='--', linewidth=2, color='k') # power_index = "{%0.2f}" % pindex power_index = '-2.0' tname = r'$\sim k^{' + power_index + '}$' ax1.text( 0.45, 0.7, tname, color='black', fontsize=24, horizontalalignment='left', verticalalignment='center', transform=ax1.transAxes) ax1.tick_params(labelsize=16) ax1.set_xlabel(r'$kd_i$', fontdict=font, fontsize=20) ax1.set_ylabel(r'$E_B(k)$', fontdict=font, fontsize=20) ax1.set_xlim([1E-2, 3E1]) ax1.set_ylim([1E-3, 3E1]) fig_dir = '../img/img_power_spectrum/' + run_name + '/' mkdir_p(fig_dir) fname = fig_dir + '/ps_mag_' + str(ct).zfill(3) + '.jpg' fig.savefig(fname, dpi=300) # plt.show() plt.close()
def calc_power_spectrum(pic_info, ct, species, run_name, xmin, xmax, base_dir='../../', single_file=True): """Calculate power spectrum of compressible mode and incompressible mode Args: pic_info: namedtuple for the PIC simulation information. ct: current time frame. species: particle species run_name: the simulation run name xmin, xmax: the spatial range of the field data base_dir: the root directory of the run """ zmin, zmax = -0.5 * pic_info.lz_di, 0.5 * pic_info.lz_di if single_file: kwargs = { "current_time": ct, "xl": xmin, "xr": xmax, "zb": zmin, "zt": zmax } fname = base_dir + 'data1/v' + species + 'x.gda' x, z, vx = read_2d_fields(pic_info, fname, **kwargs) fname = base_dir + 'data1/v' + species + 'y.gda' x, z, vy = read_2d_fields(pic_info, fname, **kwargs) fname = base_dir + 'data1/v' + species + 'z.gda' x, z, vz = read_2d_fields(pic_info, fname, **kwargs) else: kwargs = { "current_time": 0, "xl": xmin, "xr": xmax, "zb": zmin, "zt": zmax } tframe = str(fields_interval * ct) fname = base_dir + 'data/vex_' + tframe + '.gda' fname = base_dir + 'data/v' + species + 'x_' + tframe + '.gda' x, z, vx = read_2d_fields(pic_info, fname, **kwargs) fname = base_dir + 'data/v' + species + 'y_' + tframe + '.gda' x, z, vy = read_2d_fields(pic_info, fname, **kwargs) fname = base_dir + 'data/v' + species + 'z_' + tframe + '.gda' x, z, vz = read_2d_fields(pic_info, fname, **kwargs) nx, = x.shape nz, = z.shape smime = math.sqrt(pic_info.mime) lx = np.max(x) - np.min(x) lz = np.max(z) - np.min(z) vx_k = np.fft.rfft2(vx) vy_k = np.fft.rfft2(vy) vz_k = np.fft.rfft2(vz) xstep = lx / nx kx = np.fft.fftfreq(nx, xstep) idx = np.argsort(kx) zstep = lz / nz kz = np.fft.fftfreq(nz, zstep) idz = np.argsort(kz) print np.min(kx), np.max(kx), np.min(kz), np.max(kz) print nx, nz kxs, kzs = np.meshgrid(kx[:nx // 2 + 1], kz) k = np.sqrt(kxs * kxs + kzs * kzs) vkpara = div0(vx_k * kxs + vz_k * kzs, k) vkperp_x = div0(-vy_k * kzs, k) vkperp_y = div0(vx_k * kzs - vz_k * kxs, k) vkperp_z = div0(vy_k * kxs, k) v2_k = np.absolute(vx_k)**2 + np.absolute(vy_k)**2 + np.absolute(vz_k)**2 v2_kpara = np.absolute(vkpara)**2 v2_kperp = np.absolute(vkperp_x)**2 + np.absolute(vkperp_y)**2 + \ np.absolute(vkperp_z)**2 kxs, kzs = np.meshgrid(kx[:nx // 2 + 1], kz) ks = np.sqrt(kxs * kxs + kzs * kzs) kmin, kmax = np.min(ks), np.max(ks) kmin = 1E-2 kmin_log = math.log10(kmin) kmax_log = math.log10(kmax) # kbins = np.linspace(kmin, kmax, 256, endpoint=True) kbins = 10**np.linspace(kmin_log, kmax_log, 39, endpoint=True) ps, kbins_edges = np.histogram(ks, bins=kbins, weights=v2_k * ks) ps_para, kbins_edges = np.histogram(ks, bins=kbins, weights=v2_kpara * ks) ps_perp, kbins_edges = np.histogram(ks, bins=kbins, weights=v2_kperp * ks) power1 = ps / np.diff(kbins_edges) power2 = ps_para / np.diff(kbins_edges) power3 = ps_perp / np.diff(kbins_edges) # print power1 # print (power1 + 1E-5) / (power2 + power3 + 1E-5) # print (np.sum(ps)) / (np.sum(ps_para) + np.sum(ps_perp)) # print (np.sum(ps*np.diff(kbins_edges))) # print (np.sum(ps_para*np.diff(kbins_edges))) # print (np.sum(ps_perp*np.diff(kbins_edges))) return (kbins_edges, power1, power2, power3)
def parallel_potential(pic_info): """Calculate parallel potential defined by Jan Egedal. Args: pic_info: namedtuple for the PIC simulation information. """ kwargs = {"current_time": 40, "xl": 0, "xr": 200, "zb": -50, "zt": 50} x, z, Ay = contour_plots.read_2d_fields(pic_info, "../data/Ay.gda", **kwargs) x, z, Ex = contour_plots.read_2d_fields(pic_info, "../data/ex.gda", **kwargs) x, z, Ey = contour_plots.read_2d_fields(pic_info, "../data/ey.gda", **kwargs) x, z, Ez = contour_plots.read_2d_fields(pic_info, "../data/ez.gda", **kwargs) x, z, Bx = contour_plots.read_2d_fields(pic_info, "../data/bx.gda", **kwargs) x, z, By = contour_plots.read_2d_fields(pic_info, "../data/by.gda", **kwargs) xarr, zarr, Bz = contour_plots.read_2d_fields(pic_info, "../data/bz.gda", **kwargs) absB = np.sqrt(Bx**2 + By**2 + Bz**2) Epara = (Ex * Bx + Ey * By + Ez * Bz) / absB nx, = x.shape nz, = z.shape phi_parallel = np.zeros((nz, nx)) dx_di = pic_info.dx_di dz_di = pic_info.dz_di #deltas = math.sqrt(dx_di**2 + dz_di**2) #hds = deltas * 0.5 hmax = dx_di * 100 h = hmax / 4.0 # Cash-Karp parameters a = [0.0, 0.2, 0.3, 0.6, 1.0, 0.875] b = [[], [0.2], [3.0 / 40.0, 9.0 / 40.0], [0.3, -0.9, 1.2], [-11.0 / 54.0, 2.5, -70.0 / 27.0, 35.0 / 27.0], [ 1631.0 / 55296.0, 175.0 / 512.0, 575.0 / 13824.0, 44275.0 / 110592.0, 253.0 / 4096.0 ]] c = [37.0 / 378.0, 0.0, 250.0 / 621.0, 125.0 / 594.0, 0.0, 512.0 / 1771.0] dc = [ c[0] - 2825.0 / 27648.0, c[1] - 0.0, c[2] - 18575.0 / 48384.0, c[3] - 13525.0 / 55296.0, c[4] - 277.00 / 14336.0, c[5] - 0.25 ] def F(t, x, z): indices_bl, indices_tr, delta = grid_indices(x, 0, z, nx, 1, nz, dx_di, 1, dz_di) ix1 = indices_bl[0] iz1 = indices_bl[2] ix2 = indices_tr[0] iz2 = indices_tr[2] offsetx = delta[0] offsetz = delta[2] v1 = (1.0 - offsetx) * (1.0 - offsetz) v2 = offsetx * (1.0 - offsetz) v3 = offsetx * offsetz v4 = (1.0 - offsetx) * offsetz if (ix1 < nx and ix2 < nx and iz1 < nz and iz2 < nz): bx = Bx[iz1, ix1] * v1 + Bx[iz1, ix2] * v2 + Bx[ iz2, ix2] * v3 + Bx[iz2, ix1] * v4 by = By[iz1, ix1] * v1 + By[iz1, ix2] * v2 + By[ iz2, ix2] * v3 + By[iz2, ix1] * v4 bz = Bz[iz1, ix1] * v1 + Bz[iz1, ix2] * v2 + Bz[ iz2, ix2] * v3 + Bz[iz2, ix1] * v4 ex = Ex[iz1, ix1] * v1 + Ex[iz1, ix2] * v2 + Ex[ iz2, ix2] * v3 + Ex[iz2, ix1] * v4 ey = Ey[iz1, ix1] * v1 + Ey[iz1, ix2] * v2 + Ey[ iz2, ix2] * v3 + Ey[iz2, ix1] * v4 ez = Ez[iz1, ix1] * v1 + Ez[iz1, ix2] * v2 + Ez[ iz2, ix2] * v3 + Ez[iz2, ix1] * v4 absB = math.sqrt(bx**2 + bz**2) deltax1 = bx / absB deltay1 = by * deltax1 / bx deltaz1 = bz / absB else: ex = 0 ey = 0 ez = 0 deltax1 = 0 deltay1 = 0 deltaz1 = 0 return (deltax1, deltay1, deltaz1, ex, ey, ez) tol = 1e-5 for i in range(2900, 3300): print i x0 = xarr[i] - xarr[0] #for k in range(0,nz,8): for k in range(950, 1098): z0 = zarr[k] - zarr[0] y = [x0, z0] nstep = 0 xlist = [x0] zlist = [z0] t = 0 x = x0 z = z0 while (x >= 0 and x <= (xarr[-1] - xarr[0]) and z >= 0 and z <= (zarr[-1] - zarr[0]) and t < 4E2): # Compute k[i] function values. kx = [None] * 6 ky = [None] * 6 kz = [None] * 6 kx[0], ky[0], kz[0], ex0, ey0, ez0 = F(t, x, z) kx[1], ky[1], kz[1], ex1, ey1, ez1 = F( t + a[1] * h, x + h * (kx[0] * b[1][0]), z + h * (kz[0] * b[1][0])) kx[2], ky[2], kz[2], ex2, ey2, ez2 = F( t + a[2] * h, x + h * (kx[0] * b[2][0] + kx[1] * b[2][1]), z + h * (kz[0] * b[2][0] + kz[1] * b[2][1])) kx[3], ky[3], kz[3], ex3, ey3, ez3 = F( t + a[3] * h, x + h * (kx[0] * b[3][0] + kx[1] * b[3][1] + kx[2] * b[3][2]), z + h * (kz[0] * b[3][0] + kz[1] * b[3][1] + kz[2] * b[3][2])) kx[4], ky[4], kz[4], ex4, ey4, ez4 = F( t + a[4] * h, x + h * (kx[0] * b[4][0] + kx[1] * b[4][1] + kx[2] * b[4][2] + kx[3] * b[4][3]), z + h * (kz[0] * b[4][0] + kz[1] * b[4][1] + kz[2] * b[4][2] + kz[3] * b[4][3])) kx[5], ky[5], kz[5], ex5, ey5, ez5 = F( t + a[5] * h, x + h * (kx[0] * b[5][0] + kx[1] * b[5][1] + kx[2] * b[5][2] + kx[3] * b[5][3] + kx[4] * b[5][4]), z + h * (kz[0] * b[5][0] + kz[1] * b[5][1] + kz[2] * b[5][2] + kz[3] * b[5][3] + kz[4] * b[5][4])) # Estimate current error and current maximum error. E = norm([ h * (kx[0] * dc[0] + kx[1] * dc[1] + kx[2] * dc[2] + kx[3] * dc[3] + kx[4] * dc[4] + kx[5] * dc[5]), h * (kz[0] * dc[0] + kz[1] * dc[1] + kz[2] * dc[2] + kz[3] * dc[3] + kz[4] * dc[4] + kz[5] * dc[5]) ]) Emax = tol * max(norm(y), 1.0) # Update solution if error is OK. if E < Emax: t += h dx = h * (kx[0] * c[0] + kx[1] * c[1] + kx[2] * c[2] + kx[3] * c[3] + kx[4] * c[4] + kx[5] * c[5]) dy = h * (ky[0] * c[0] + ky[1] * c[1] + ky[2] * c[2] + ky[3] * c[3] + ky[4] * c[4] + ky[5] * c[5]) dz = h * (kz[0] * c[0] + kz[1] * c[1] + kz[2] * c[2] + kz[3] * c[3] + kz[4] * c[4] + kz[5] * c[5]) y[0] += dx y[1] += dz x = y[0] z = y[1] xlist.append(x) zlist.append(z) phi_parallel[k, i] += \ h*(kx[0]*c[0]*ex0+kx[1]*c[1]*ex1+kx[2]*c[2]*ex2+ \ kx[3]*c[3]*ex3+kx[4]*c[4]*ex4+kx[5]*c[5]*ex5) + \ h*(ky[0]*c[0]*ey0+ky[1]*c[1]*ey1+ky[2]*c[2]*ey2+ \ ky[3]*c[3]*ey3+ky[4]*c[4]*ey4+ky[5]*c[5]*ey5) + \ h*(kz[0]*c[0]*ez0+kz[1]*c[1]*ez1+kz[2]*c[2]*ez2+ \ kz[3]*c[3]*ez3+kz[4]*c[4]*ez4+kz[5]*c[5]*ez5) #out += [(t, list(y))] # Update step size if E > 0.0: h = min(hmax, 0.85 * h * (Emax / E)**0.2) if (t > 395): phi_parallel[k, i] = 0 # # deltax1, deltaz1, x1, z1, ex1, ez1 = middle_step_rk4(x, z, nx, nz, # dx_di, dz_di, Bx, Bz, Ex, Ez, hds) # deltax2, deltaz2, x2, z2, ex2, ez2 = middle_step_rk4(x1, z1, nx, nz, # dx_di, dz_di, Bx, Bz, Ex, Ez, hds) # deltax3, deltaz3, x3, z3, ex3, ez3 = middle_step_rk4(x, z, nx, nz, # dx_di, dz_di, Bx, Bz, Ex, Ez, deltas) # deltax4, deltaz4, x4, z4, ex4, ez4 = middle_step_rk4(x, z, nx, nz, # dx_di, dz_di, Bx, Bz, Ex, Ez, hds) # # deltax = deltas/6 * (deltax1 + 2*deltax2 + 2*deltax3 + deltax4) # deltaz = deltas/6 * (deltaz1 + 2*deltaz2 + 2*deltaz3 + deltaz4) # x += deltax # z += deltaz # total_lengh += deltas # xlist.append(x) # zlist.append(z) # nstep += 1 # phi_parallel[k, i] += deltas/6 * (ex1*deltax1 + ez1*deltaz1 + # 2.0*ex2*deltax2 + 2.0*ez2*deltaz2 + # 2.0*ex3*deltax3 + 2.0*ez3*deltaz3 + # ex4*deltax4 + ez4*deltaz4) # length = math.sqrt((x-x0)**2 + (z-z0)**2) # if (length < dx_di and nstep > 20): # phi_parallel[k, i] = 0 # break # #print k, nstep, total_lengh # phi_parallel = np.fromfile('phi_parallel.dat') # phi_parallel.tofile('phi_parallel.dat') # print np.max(phi_parallel), np.min(phi_parallel) width = 0.78 height = 0.75 xs = 0.14 xe = 0.94 - xs ys = 0.9 - height #fig = plt.figure(figsize=(7,5)) fig = plt.figure(figsize=(7, 2)) ax1 = fig.add_axes([xs, ys, width, height]) #kwargs_plot = {"xstep":2, "zstep":2, "vmin":-0.05, "vmax":0.05} kwargs_plot = {"xstep": 1, "zstep": 1, "vmin": -0.2, "vmax": 0.2} #kwargs_plot = {"xstep":1, "zstep":1, "vmin":-0.05, "vmax":0.05} xstep = kwargs_plot["xstep"] zstep = kwargs_plot["zstep"] phi_parallel = np.reshape(phi_parallel, (nz, nx)) p1, cbar1 = contour_plots.plot_2d_contour(xarr, zarr, phi_parallel, ax1, fig, **kwargs_plot) # xmin = np.min(xarr) # zmin = np.min(zarr) # xmax = np.max(xarr) # zmax = np.max(zarr) # p1 = ax1.imshow(phi_parallel[0:nz:8, 0:nx:8], cmap=plt.cm.jet, # extent=[xmin, xmax, zmin, zmax], # aspect='auto', origin='lower', # vmin=kwargs_plot["vmin"], vmax=kwargs_plot["vmax"], # interpolation='quadric') p1.set_cmap(plt.cm.seismic) cs = ax1.contour(xarr[0:nx:xstep], zarr[0:nz:zstep], Ay[0:nz:zstep, 0:nx:xstep], colors='black', linewidths=0.5, levels=np.arange(1, 250, 10)) #cbar1.set_ticks(np.arange(-0.8, 1.0, 0.4)) #ax1.tick_params(axis='x', labelbottom='off') plt.show()
self.valtext.set_text(self.valfmt % discrete_val) if self.drawon: self.ax.figure.canvas.draw() self.val = discrete_val if self.previous_val != discrete_val: self.previous_val = discrete_val if not self.eventson: return for cid, func in self.observers.iteritems(): func(discrete_val) if __name__ == '__main__': # pic_info = pic_information.get_pic_info('../../') base_directory = '/net/scratch2/guofan/for_Xiaocan/sigma100-lx300/' run_name = 'sigma100-lx300' picinfo_fname = '../data/pic_info/pic_info_' + run_name + '.json' pic_info = read_data_from_json(picinfo_fname) ratio = pic_info.particle_interval / pic_info.fields_interval ct = 5 kwargs = {"current_time": 40, "xl": 0, "xr": 300, "zb": -75, "zt": 75} fname = base_directory + "/data/bx.gda" x, z, bx = read_2d_fields(pic_info, fname, **kwargs) fname = base_directory + "/data/by.gda" x, z, by = read_2d_fields(pic_info, fname, **kwargs) fname = base_directory + "/data/bz.gda" x, z, bz = read_2d_fields(pic_info, fname, **kwargs) data = np.sqrt(bx * bx + by * by + bz * bz) fig_v = viewer_2d(data, x, z, pic_info, base_directory) plt.show()
def calc_power_spectrum_vel_comp(pic_info, ct, species, run_name, xshock, base_dir='../../', single_file=True): """Calculate power spectrum of compressible mode and incompressible mode Args: pic_info: namedtuple for the PIC simulation information. ct: current time frame. species: particle species run_name: the simulation run name xshock: the shock position along the x-direction in di base_dir: the root directory of the run """ xmin, xmax = 0, pic_info.lx_di xmin, xmax = 0, 105 zmin, zmax = -0.5 * pic_info.lz_di, 0.5 * pic_info.lz_di xmin, xmax = 0, xshock if single_file: kwargs = { "current_time": ct, "xl": xmin, "xr": xmax, "zb": zmin, "zt": zmax } fname = base_dir + 'data1/v' + species + 'x.gda' x, z, vx = read_2d_fields(pic_info, fname, **kwargs) fname = base_dir + 'data1/v' + species + 'y.gda' x, z, vy = read_2d_fields(pic_info, fname, **kwargs) fname = base_dir + 'data1/v' + species + 'z.gda' x, z, vz = read_2d_fields(pic_info, fname, **kwargs) else: kwargs = { "current_time": 0, "xl": xmin, "xr": xmax, "zb": zmin, "zt": zmax } fields_interval = pic_info.fields_interval tframe = str(fields_interval * ct) fname = base_dir + 'data/v' + species + 'x_' + tframe + '.gda' x, z, vx = read_2d_fields(pic_info, fname, **kwargs) fname = base_dir + 'data/v' + species + 'y_' + tframe + '.gda' x, z, vy = read_2d_fields(pic_info, fname, **kwargs) fname = base_dir + 'data/v' + species + 'z_' + tframe + '.gda' x, z, vz = read_2d_fields(pic_info, fname, **kwargs) nx, = x.shape nz, = z.shape smime = math.sqrt(pic_info.mime) lx = np.max(x) - np.min(x) lz = np.max(z) - np.min(z) vx_k = np.fft.rfft2(vx) vy_k = np.fft.rfft2(vy) vz_k = np.fft.rfft2(vz) xstep = lx / nx kx = np.fft.fftfreq(nx, xstep) idx = np.argsort(kx) zstep = lz / nz kz = np.fft.fftfreq(nz, zstep) idz = np.argsort(kz) print np.min(kx), np.max(kx), np.min(kz), np.max(kz) kxs, kzs = np.meshgrid(kx[:nx // 2 + 1], kz) k = np.sqrt(kxs * kxs + kzs * kzs) vkpara = div0(vx_k * kxs + vz_k * kzs, k) vkperp_x = div0(-vy_k * kzs, k) vkperp_y = div0(vx_k * kzs - vz_k * kxs, k) vkperp_z = div0(vy_k * kxs, k) v2_k = np.absolute(vx_k)**2 + np.absolute(vy_k)**2 + np.absolute(vz_k)**2 v2_kpara = np.absolute(vkpara)**2 v2_kperp = np.absolute(vkperp_x)**2 + np.absolute(vkperp_y)**2 + \ np.absolute(vkperp_z)**2 kxs, kzs = np.meshgrid(kx[:nx // 2 + 1], kz) ks = np.sqrt(kxs * kxs + kzs * kzs) kmin, kmax = np.min(ks), np.max(ks) kmin = 1E-2 kmin_log = math.log10(kmin) kmax_log = math.log10(kmax) # kbins = np.linspace(kmin, kmax, 256, endpoint=True) kbins = 10**np.linspace(kmin_log, kmax_log, 64, endpoint=True) ps, kbins_edges = np.histogram(ks, bins=kbins, weights=v2_k * ks) ps_para, kbins_edges = np.histogram(ks, bins=kbins, weights=v2_kpara * ks) ps_perp, kbins_edges = np.histogram(ks, bins=kbins, weights=v2_kperp * ks) power1 = ps / np.diff(kbins_edges) power2 = ps_para / np.diff(kbins_edges) power3 = ps_perp / np.diff(kbins_edges) # print power1 # print (power1 + 1E-5) / (power2 + power3 + 1E-5) # print (np.sum(ps)) / (np.sum(ps_para) + np.sum(ps_perp)) # print (np.sum(ps*np.diff(kbins_edges))) # print (np.sum(ps_para*np.diff(kbins_edges))) # print (np.sum(ps_perp*np.diff(kbins_edges))) w1, h1 = 0.8, 0.8 xs, ys = 0.15, 0.95 - h1 fig = plt.figure(figsize=[7, 5]) ax1 = fig.add_axes([xs, ys, w1, h1]) ax1.loglog(kbins_edges[:-1], power1, linewidth=2, label='Total') ax1.loglog(kbins_edges[:-1], power2, linewidth=2, label='Compressible') ax1.loglog(kbins_edges[:-1], power3, linewidth=2, label='Incompressible') # psm = np.argmax(ps) psm = 5 pindex = -5.0 / 3 power_k = kbins[psm:]**pindex shift = 20 if species is 'electron': ax1.loglog( kbins[psm:psm + shift], power_k[:shift] * 0.5 / power_k[0], linestyle='--', linewidth=2, color='k') else: index_s = 20 index_ps = index_s - psm ax1.loglog( kbins[index_s:index_s + shift], power_k[index_ps:shift + index_ps] * 1E12 / power_k[index_ps], linestyle='--', linewidth=2, color='k') power_index = "{%0.1f}" % pindex # tname = r'$\sim k^{' + power_index + '}$' tname = r'$\sim k^{-5/3}$' ax1.text( 0.72, 0.6, tname, color='black', fontsize=24, horizontalalignment='left', verticalalignment='center', transform=ax1.transAxes) ax1.tick_params(labelsize=16) ax1.set_xlabel(r'$kd_i$', fontdict=font, fontsize=20) ax1.set_ylabel(r'$E_V(k)$', fontdict=font, fontsize=20) ax1.set_xlim([1E-2, 3E1]) if species is 'electron': ax1.set_ylim([1E-2, 0.5]) else: ax1.set_xlim([1E-2, 1E0]) ax1.set_ylim([5E9, 5E12]) leg = ax1.legend( loc=1, prop={'size': 16}, ncol=1, shadow=False, fancybox=False, frameon=False) fig_dir = '../img/img_power_spectrum/' + run_name + '/' mkdir_p(fig_dir) fname = fig_dir + '/ps_comp_' + species + str(ct).zfill(3) + '.jpg' fig.savefig(fname, dpi=200) plt.close()