def run_test_iof(f, main__file__, show=False): vlt.clf() fac_tot = 1e9 * f["fac_tot"] plot_args = dict(projection="polar", lin=[-300, 300], bounding_lat=35.0, drawcoastlines=True, # for basemap only title="Total FAC\n", gridec='gray', label_lat=True, label_mlt=True, colorbar=True, cbar_kwargs=dict(pad=0.15) # pad the colorbar away from the plot ) ax1 = vlt.subplot(121, projection='polar') vlt.plot(fac_tot, ax=ax1, hemisphere='north', **plot_args) ax1.annotate('(a)', xy=(0, 0), textcoords="axes fraction", xytext=(-0.1, 1.0), fontsize=18) ax2 = vlt.subplot(122, projection='polar') plot_args['gridec'] = False vlt.plot(fac_tot, ax=ax2, hemisphere="south", style="contourf", levels=50, extend="both", **plot_args) ax2.annotate('(b)', xy=(0, 0), textcoords="axes fraction", xytext=(-0.1, 1.0), fontsize=18) vlt.auto_adjust_subplots(subplot_params=dict()) plt.gcf().set_size_inches(8, 4) plt.savefig(next_plot_fname(main__file__)) if show: vlt.mplshow()
def run_test_3d(f, main__file__, show=False): vlt.clf() slc = "x=-20f:12f, y=0f" plot_kwargs = dict(title=True, earth=True) vlt.subplot(141) vlt.plot(f['pp'], slc, logscale=True, **plot_kwargs) vlt.subplot(142) vlt.plot(viscid.magnitude(f['bcc']), slc, logscale=True, **plot_kwargs) vlt.plot2d_quiver(f['v'][slc], step=5, color='y', pivot='mid', width=0.03, scale=600) vlt.subplot(143) vlt.plot(f['jy'], slc, clim=(-0.005, 0.005), **plot_kwargs) vlt.streamplot(f['v'][slc], linewidth=0.3) vlt.subplot(144) vlt.plot(f['jy'], "x=7f:12f, y=0f, z=0f") plt.suptitle("3D File") vlt.auto_adjust_subplots(subplot_params=dict(top=0.9, wspace=1.3)) plt.gcf().set_size_inches(10, 4) vlt.savefig(next_plot_fname(main__file__)) if show: vlt.show()
def run_div_test(fld, exact, title='', show=False, ignore_inexact=False): t0 = time() result_numexpr = viscid.div(fld, preferred="numexpr", only=False) t1 = time() logger.info("numexpr magnitude runtime: %g", t1 - t0) result_diff = viscid.diff(result_numexpr, exact)['x=1:-1, y=1:-1, z=1:-1'] if not ignore_inexact and not (result_diff.data < 5e-5).all(): logger.warning("numexpr result is far from the exact result") logger.info("min/max(abs(numexpr - exact)): %g / %g", np.min(result_diff.data), np.max(result_diff.data)) planes = ["y=0j", "z=0j"] nrows = 2 ncols = len(planes) _, axes = plt.subplots(nrows, ncols, squeeze=False) for i, p in enumerate(planes): vlt.plot(result_numexpr, p, ax=axes[0, i], show=False) vlt.plot(result_diff, p, ax=axes[1, i], show=False) plt.suptitle(title) vlt.auto_adjust_subplots(subplot_params=dict(top=0.9)) plt.savefig(next_plot_fname(__file__)) if show: vlt.mplshow()
def run_test_2d(f, main__file__, show=False): vlt.clf() slc = "x=-20j:12j, y=0j" plot_kwargs = dict(title=True, earth=True) vlt.subplot(141) vlt.plot(f['pp'], slc, logscale=True, **plot_kwargs) vlt.plot(np.abs(f['psi']), style='contour', logscale=True, levels=30, linewidths=0.8, colors='grey', linestyles='solid', colorbar=None, x=(-20, 12)) vlt.subplot(142) vlt.plot(viscid.magnitude(f['bcc']), slc, logscale=True, **plot_kwargs) vlt.plot2d_quiver(f['v'][slc], step=5, color='y', pivot='mid', width=0.03, scale=600) vlt.subplot(143) vlt.plot(f['jy'], slc, clim=[-0.005, 0.005], **plot_kwargs) vlt.streamplot(f['v'][slc], linewidth=0.3) vlt.subplot(144) vlt.plot(f['jy'], "x=7j:12j, y=0j, z=0j") plt.suptitle("2D File") vlt.auto_adjust_subplots(subplot_params=dict(top=0.9, wspace=1.3)) plt.gcf().set_size_inches(10, 4) vlt.savefig(next_plot_fname(main__file__)) if show: vlt.show()
def _main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--show", "--plot", action="store_true") args = vutil.common_argparse(parser) f = viscid.load_file(os.path.join(sample_dir, 'vpic_sample', 'global.vpc')) # some slices that are good to check vlt.clf() vlt.plot(f['bx']['x=:32.01j']) plt.close() vlt.clf() vlt.plot(f['bx']['x=:33.0j']) plt.close() _, axes = vlt.subplots(2, 2, figsize=(8, 4)) for i, ti in enumerate([0, -1]): f.activate_time(ti) vlt.plot(f['n_e']['y=0j'], symmetric=False, ax=axes[0, i]) vlt.plot(f['bx']['y=0j'], symmetric=True, ax=axes[1, i]) axes[0, i].set_title(f.get_grid().time) vlt.auto_adjust_subplots() plt.savefig(next_plot_fname(__file__)) if args.show: vlt.show() plt.close() return 0
def _main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--show", "--plot", action="store_true") args = viscid.vutil.common_argparse(parser) # args.show = True t = viscid.linspace_datetime64('2006-06-10 12:30:00.0', '2006-06-10 12:33:00.0', 16) tL = viscid.as_datetime64('2006-06-10 12:31:00.0') tR = viscid.as_datetime64('2006-06-10 12:32:00.0') y = np.linspace(2 * np.pi, 4 * np.pi, 12) ### plots with a datetime64 axis f0 = viscid.ones([t, y], crd_names='ty', center='node') T, Y = f0.get_crds(shaped=True) f0.data += np.arange(T.size).reshape(T.shape) f0.data += np.cos(Y) fig = plt.figure(figsize=(10, 5)) # 1D plot vlt.subplot(121) vlt.plot(f0[tL:tR]['y=0'], marker='^') plt.xlim(*viscid.as_datetime(t[[0, -1]]).tolist()) # 2D plot vlt.subplot(122) vlt.plot(f0, x=(t[0], t[-1])) plt.suptitle("datetime64") vlt.auto_adjust_subplots(subplot_params=dict(top=0.9)) plt.savefig(next_plot_fname(__file__)) if args.show: vlt.show() plt.close(fig) ### plots with a timedelta64 axis tL = tL - t[0] tR = tR - t[0] t = t - t[0] f0 = viscid.ones([t, y], crd_names='ty', center='node') T, Y = f0.get_crds(shaped=True) f0.data += np.arange(T.size).reshape(T.shape) f0.data += np.cos(Y) fig = plt.figure(figsize=(10, 5)) # 1D plot vlt.subplot(121) vlt.plot(f0[tL:tR]['y=0'], marker='^') plt.xlim(*viscid.as_datetime(t[[0, -1]]).tolist()) # 2D plot vlt.subplot(122) vlt.plot(f0, x=(t[0], t[-1])) plt.suptitle("timedelta64") vlt.auto_adjust_subplots(subplot_params=dict(top=0.9)) plt.savefig(next_plot_fname(__file__)) if args.show: vlt.show() plt.close(fig) return 0
def run_mpl_testA(show=False): logger.info("2D cell centered tests") x = np.array(np.linspace(-10, 10, 100), dtype=dtype) y = np.array(np.linspace(-10, 10, 120), dtype=dtype) z = np.array(np.linspace(-1, 1, 2), dtype=dtype) fld_s = viscid.empty([x, y, z], center='cell') Xcc, Ycc, Zcc = fld_s.get_crds_cc(shaped=True) # pylint: disable=unused-variable fld_s[:, :, :] = np.sin(Xcc) + np.cos(Ycc) _, axes = plt.subplots(4, 1, squeeze=False) vlt.plot(fld_s, "y=20j", ax=axes[0, 0], show=False, plot_opts="lin_0") vlt.plot(fld_s, "x=0j:20j,y=0j:5j", ax=axes[1, 0], earth=True, show=False, plot_opts="x_-10_0,y_0_7") vlt.plot(fld_s, "y=0j", ax=axes[2, 0], show=False, plot_opts="lin_-1_1") vlt.plot(fld_s, "z=0j,x=-20j:0j", ax=axes[3, 0], earth=True, show=False, plot_opts="lin_-5_5") plt.suptitle("2d cell centered") vlt.auto_adjust_subplots() plt.savefig(next_plot_fname(__file__)) if show: vlt.mplshow()
def run_mpl_testB(show=False): logger.info("3D node centered tests") x = np.array(np.linspace(-10, 10, 100), dtype=dtype) y = np.array(np.linspace(-10, 10, 120), dtype=dtype) z = np.array(np.linspace(-10, 10, 140), dtype=dtype) fld_s = viscid.empty([x, y, z], center='node') X, Y, Z = fld_s.get_crds_nc(shaped=True) # pylint: disable=W0612 fld_s[:, :, :] = np.sin(X) + np.cos(Y) - np.cos(Z) # print("shape: ", fld_s.data.shape) _, axes = plt.subplots(4, 1, squeeze=False) vlt.plot(fld_s, "z=0,x=:30", ax=axes[0, 0], earth=True, plot_opts="lin_0") vlt.plot(fld_s, "z=0.75j,x=-4:-1,y=-3j:3j", ax=axes[1, 0], earth=True) vlt.plot(fld_s, "x=-0.5j:,y=-3j:3j,z=0j", ax=axes[2, 0], earth=True) vlt.plot(fld_s, "x=0.0j,y=-5.0j:5.0j", ax=axes[3, 0], earth=True, plot_opts="log,g") plt.suptitle("3d node centered") vlt.auto_adjust_subplots() plt.savefig(next_plot_fname(__file__)) if show: vlt.mplshow()
def _main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--show", "--plot", action="store_true") args = vutil.common_argparse(parser) ####### test 5-moment uniform grids gk_uniform = viscid.load_file(os.path.join(sample_dir, 'sample_gkeyll_uniform_q_*.h5')) _, axes = plt.subplots(1, 2, figsize=(9, 3)) for i, grid in enumerate(gk_uniform.iter_times(":")): vlt.plot(grid['rho_i'], logscale=True, style='contourf', levels=128, ax=axes[i]) seeds = viscid.Line((-1.2, 0, 0), (1.4, 0, 0), 8) b_lines, _ = viscid.calc_streamlines(grid['b'], seeds, method='euler1', max_length=20.0) vlt.plot2d_lines(b_lines, scalars='#000000', symdir='z', linewidth=1.0) plt.title(grid.format_time('.02f')) vlt.auto_adjust_subplots() plt.suptitle("Uniform Gkeyll Dataset") plt.savefig(next_plot_fname(__file__)) if args.show: plt.show() plt.clf() return 0
def run_mpl_testB(show=False): logger.info("3D node centered tests") x = np.array(np.linspace(-10, 10, 100), dtype=dtype) y = np.array(np.linspace(-10, 10, 120), dtype=dtype) z = np.array(np.linspace(-10, 10, 140), dtype=dtype) fld_s = viscid.empty([x, y, z], center='node') X, Y, Z = fld_s.get_crds_nc(shaped=True) # pylint: disable=W0612 fld_s[:, :, :] = np.sin(X) + np.cos(Y) - np.cos(Z) # print("shape: ", fld_s.data.shape) nrows = 4 ncols = 1 plt.subplot2grid((nrows, ncols), (0, 0)) vlt.plot(fld_s, "z=0,x=:30", earth=True, plot_opts="lin_0") plt.subplot2grid((nrows, ncols), (1, 0)) vlt.plot(fld_s, "z=0.75f,x=-4:-1,y=-3f:3f", earth=True) plt.subplot2grid((nrows, ncols), (2, 0)) vlt.plot(fld_s, "x=-0.5f:,y=-3f:3f,z=0f", earth=True) plt.subplot2grid((nrows, ncols), (3, 0)) vlt.plot(fld_s, "x=0.0f,y=-5.0f:5.0f", earth=True, plot_opts="log,g") plt.suptitle("3d node centered") vlt.auto_adjust_subplots() plt.savefig(next_plot_fname(__file__)) if show: vlt.mplshow()
def _main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--show", "--plot", action="store_true") args = vutil.common_argparse(parser) ####### test 5-moment uniform grids gk_uniform = viscid.load_file(os.path.join(sample_dir, 'sample_gkeyll_uniform_q_*.h5')) plt.figure(figsize=(9, 3)) for i, grid in enumerate(gk_uniform.iter_times(":")): plt.subplot2grid((1, 2), (0, i)) vlt.plot(grid['rho_i'], logscale=True, style='contourf', levels=128) seeds = viscid.Line((-1.2, 0, 0), (1.4, 0, 0), 8) b_lines, _ = viscid.calc_streamlines(grid['b'], seeds, method='euler1', max_length=20.0) vlt.plot2d_lines(b_lines, scalars='#000000', symdir='z', linewidth=1.0) plt.title(grid.format_time('.02f')) vlt.auto_adjust_subplots() plt.suptitle("Uniform Gkeyll Dataset") plt.savefig(next_plot_fname(__file__)) if args.show: plt.show() plt.clf() return 0
def run_mag_test(fld, title="", show=False): vx, vy, vz = fld.component_views() # pylint: disable=W0612 vx, vy, vz = fld.component_fields() try: t0 = time() mag_ne = viscid.magnitude(fld, preferred="numexpr", only=False) t1 = time() logger.info("numexpr mag runtime: %g", t1 - t0) except viscid.verror.BackendNotFound: xfail("Numexpr is not installed") planes = ["z=0", "y=0"] nrows = 4 ncols = len(planes) _, axes = plt.subplots(nrows, ncols, sharex=True, sharey=True, squeeze=False) for ind, p in enumerate(planes): vlt.plot(vx, p, ax=axes[0, ind], show=False) vlt.plot(vy, p, ax=axes[1, ind], show=False) vlt.plot(vz, p, ax=axes[2, ind], show=False) vlt.plot(mag_ne, p, ax=axes[3, ind], show=False) plt.suptitle(title) vlt.auto_adjust_subplots(subplot_params=dict(top=0.9, right=0.9)) plt.gcf().set_size_inches(6, 7) plt.savefig(next_plot_fname(__file__)) if show: vlt.mplshow()
def _main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--show", "--plot", action="store_true") args = vutil.common_argparse(parser) ####### test binary files f_bin = viscid.load_file(os.path.join(sample_dir, 'ath_sample.*.bin')) for i, grid in enumerate(f_bin.iter_times(":")): plt.subplot2grid((2, 2), (0, i)) vlt.plot(grid['bx']) plt.subplot2grid((2, 2), (1, i)) vlt.plot(grid['by']) plt.suptitle("athena bin (binary) files") vlt.auto_adjust_subplots(subplot_params=dict(top=0.9)) plt.savefig(next_plot_fname(__file__)) if args.show: vlt.show() plt.clf() ####### test ascii files f_tab = viscid.load_file(os.path.join(sample_dir, 'ath_sample.*.tab')) for i, grid in enumerate(f_tab.iter_times(":")): plt.subplot2grid((2, 2), (0, i)) vlt.plot(grid['bx']) plt.subplot2grid((2, 2), (1, i)) vlt.plot(grid['by']) plt.suptitle("athena tab (ascii) files") vlt.auto_adjust_subplots(subplot_params=dict(top=0.9)) plt.savefig(next_plot_fname(__file__)) if args.show: vlt.show() plt.clf() return 0
def run_test_3d(f, main__file__, show=False): vlt.clf() slc = "x=-20j:12j, y=0j" plot_kwargs = dict(title=True, earth=True) vlt.subplot(141) vlt.plot(f['pp'], slc, logscale=True, **plot_kwargs) vlt.subplot(142) vlt.plot(viscid.magnitude(f['bcc']), slc, logscale=True, **plot_kwargs) vlt.plot2d_quiver(f['v'][slc], step=5, color='y', pivot='mid', width=0.03, scale=600) vlt.subplot(143) vlt.plot(f['jy'], slc, clim=(-0.005, 0.005), **plot_kwargs) vlt.streamplot(f['v'][slc], linewidth=0.3) vlt.subplot(144) vlt.plot(f['jy'], "x=7j:12j, y=0j, z=0j") plt.suptitle("3D File") vlt.auto_adjust_subplots(subplot_params=dict(top=0.9, wspace=1.3)) plt.gcf().set_size_inches(10, 4) vlt.savefig(next_plot_fname(main__file__)) if show: vlt.show()
def run_mpl_testA(show=False): logger.info("2D cell centered tests") x = np.array(np.linspace(-10, 10, 100), dtype=dtype) y = np.array(np.linspace(-10, 10, 120), dtype=dtype) z = np.array(np.linspace(-1, 1, 2), dtype=dtype) fld_s = viscid.empty([x, y, z], center='cell') Xcc, Ycc, Zcc = fld_s.get_crds_cc(shaped=True) # pylint: disable=unused-variable fld_s[:, :, :] = np.sin(Xcc) + np.cos(Ycc) nrows = 4 ncols = 1 plt.subplot2grid((nrows, ncols), (0, 0)) vlt.plot(fld_s, "y=20f", show=False, plot_opts="lin_0") plt.subplot2grid((nrows, ncols), (1, 0)) vlt.plot(fld_s, "x=0f:20f,y=0f:5f", earth=True, show=False, plot_opts="x_-10_0,y_0_7") plt.subplot2grid((nrows, ncols), (2, 0)) vlt.plot(fld_s, "y=0f", show=False, plot_opts="lin_-1_1") plt.subplot2grid((nrows, ncols), (3, 0)) vlt.plot(fld_s, "z=0f,x=-20f:0f", earth=True, show=False, plot_opts="lin_-5_5") plt.suptitle("2d cell centered") vlt.auto_adjust_subplots() plt.savefig(next_plot_fname(__file__)) if show: vlt.mplshow()
def _main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--show", "--plot", action="store_true") args = vutil.common_argparse(parser) ####### test binary files f_bin = viscid.load_file(os.path.join(sample_dir, 'ath_sample.*.bin')) _, axes = plt.subplots(2, 2) for i, grid in enumerate(f_bin.iter_times(":")): vlt.plot(grid['bx'], ax=axes[0, i]) vlt.plot(grid['by'], ax=axes[1, i]) plt.suptitle("athena bin (binary) files") vlt.auto_adjust_subplots(subplot_params=dict(top=0.9)) plt.savefig(next_plot_fname(__file__)) if args.show: vlt.show() plt.close() ####### test ascii files f_tab = viscid.load_file(os.path.join(sample_dir, 'ath_sample.*.tab')) _, axes = plt.subplots(2, 2) for i, grid in enumerate(f_tab.iter_times(":")): vlt.plot(grid['bx'], ax=axes[0, i]) vlt.plot(grid['by'], ax=axes[1, i]) plt.suptitle("athena tab (ascii) files") vlt.auto_adjust_subplots(subplot_params=dict(top=0.9)) plt.savefig(next_plot_fname(__file__)) if args.show: vlt.show() plt.close() return 0
def _main(): f = viscid.load_file('~/dev/work/xi_fte_001/*.3d.*.xdmf') time_slice = ':' times = np.array([grid.time for grid in f.iter_times(time_slice)]) # XYZ coordinates of virtual satelites in warped "plasma sheet coords" x_sat_psc = np.linspace(-30, 0, 31) # X (GSE == PSC) y_sat_psc = np.linspace(-10, 10, 21) # Y (GSE == PSC) z_sat_psc = np.linspace(-2, 2, 5) # Z in PSC (z=0 is the plasma sheet) # the GSE z location of the virtual satelites in the warped plasma sheet # coordinates, so sat_z_gse_ts['x=5j, y=1j, z=0j'] would give the # plasma sheet location at x=5.0, y=1.0 # These fields depend on time because the plasma sheet moves in time sat_z_gse_ts = viscid.zeros([times, x_sat_psc, y_sat_psc, z_sat_psc], crd_names='txyz', center='node', name='PlasmaSheetZ_GSE') vx_ts = viscid.zeros_like(sat_z_gse_ts) bz_ts = viscid.zeros_like(sat_z_gse_ts) for itime, grid in enumerate(f.iter_times(time_slice)): print("Processing time slice", itime, grid.time) gse_slice = 'x=-35j:0j, y=-15j:15j, z=-6j:6j' bx = grid['bx'][gse_slice] bx_argmin = np.argmin(bx**2, axis=2) z_gse = bx.get_crd('z') # ps_zloc_gse is the plasma sheet z location along the GGCM grid x/y ps_z_gse = viscid.zeros_like(bx[:, :, 0:1]) ps_z_gse[...] = z_gse[bx_argmin] # Note: Here you could apply a gaussian filter to # ps_z_gse[:, :, 0].data in order to smooth the surface # if desired. Scipy / Scikit-Image have some functions # that do this # ok, we found the plasma sheet z GSE location on the actual GGCM # grid, but we just want a subset of that grid for our virtual # satelites, so just interpolate the ps z location to our subset ps_z_gse_subset = viscid.interp_trilin(ps_z_gse, sat_z_gse_ts[itime, :, :, 0:1], wrap=True) # now we know the plasma sheet z location in GSE, and how far # apart we want the satelites in z, so put those two things together # to get a bunch of satelite locations sat_z_gse_ts[itime] = ps_z_gse_subset.data + z_sat_psc.reshape(1, 1, -1) # make a seed generator that we can use to fill the vx and bz # time series for this instant in time sat_loc_gse = sat_z_gse_ts[itime].get_points() sat_loc_gse[2, :] = sat_z_gse_ts[itime].data.reshape(-1) # slicing the field before doing the interpolation makes this # faster for hdf5 data, but probably for other data too vx_ts[itime] = viscid.interp_trilin(grid['vx'][gse_slice], sat_loc_gse, wrap=False ).reshape(vx_ts.shape[1:]) bz_ts[itime] = viscid.interp_trilin(grid['bz'][gse_slice], sat_loc_gse, wrap=False ).reshape(bz_ts.shape[1:]) # 2d plots of the plasma sheet z location to make sure we did the # interpolation correctly if False: # pylint: disable=using-constant-test from viscid.plot import vpyplot as vlt fig, (ax0, ax1) = vlt.subplots(2, 1) # pylint: disable=unused-variable vlt.plot(ps_z_gse, ax=ax0, clim=(-5, 5)) vlt.plot(ps_z_gse_subset, ax=ax1, clim=(-5, 5)) vlt.auto_adjust_subplots() vlt.show() # make a 3d plot of the plasma sheet surface to verify that it # makes sense if True: # pylint: disable=using-constant-test from viscid.plot import vlab fig = vlab.figure(size=(1280, 800), bgcolor=(1, 1, 1), fgcolor=(0, 0, 0)) vlab.clf() # plot the plasma sheet coloured by vx # Note: points closer to x = 0 are unsightly since the plasma # sheet criteria starts to fall apart on the flanks, so # just remove the first few rows ps_z_gse_tail = ps_z_gse['x=:-2.25j'] ps_mesh_shape = [3, ps_z_gse_tail.shape[0], ps_z_gse_tail.shape[1]] ps_pts = ps_z_gse_tail.get_points().reshape(ps_mesh_shape) ps_pts[2, :, :] = ps_z_gse_tail[:, :, 0] plasma_sheet = viscid.RectilinearMeshPoints(ps_pts) ps_vx = viscid.interp_trilin(grid['vx'][gse_slice], plasma_sheet) _ = vlab.mesh_from_seeds(plasma_sheet, scalars=ps_vx) vx_clim = (-1400, 1400) vx_cmap = 'viridis' vlab.colorbar(title='Vx', clim=vx_clim, cmap=vx_cmap, nb_labels=5) # plot satelite locations as dots colored by Vx with the same # limits and color as the plasma sheet mesh sat3d = vlab.points3d(sat_loc_gse[0], sat_loc_gse[1], sat_loc_gse[2], vx_ts[itime].data.reshape(-1), scale_mode='none', scale_factor=0.2) vlab.apply_cmap(sat3d, clim=vx_clim, cmap=vx_cmap) # plot Earth for reference cotr = viscid.Cotr(dip_tilt=0.0) # pylint: disable=not-callable vlab.plot_blue_marble(r=1.0, lines=False, ntheta=64, nphi=128, rotate=cotr, crd_system='mhd') vlab.plot_earth_3d(radius=1.01, night_only=True, opacity=0.5, crd_system='gse') vlab.view(azimuth=45, elevation=70, distance=35.0, focalpoint=[-9, 3, -1]) vlab.savefig('plasma_sheet_3d_{0:02d}.png'.format(itime)) vlab.show() try: vlab.mlab.close(fig) except TypeError: pass # this happens if the figure is already closed # now do what we will with the time series... this is not a good # presentation of this data, but you get the idea from viscid.plot import vpyplot as vlt fig, axes = vlt.subplots(4, 4, figsize=(12, 12)) for ax_row, yloc in zip(axes, np.linspace(-5, 5, len(axes))[::-1]): for ax, xloc in zip(ax_row, np.linspace(4, 7, len(ax_row))): vlt.plot(vx_ts['x={0}j, y={1}j, z=0j'.format(xloc, yloc)], ax=ax) ax.set_ylabel('') vlt.plt.title('x = {0:g}, y = {1:g}'.format(xloc, yloc)) vlt.plt.suptitle('Vx [km/s]') vlt.auto_adjust_subplots() vlt.show() return 0
def _main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--notwo", dest='notwo', action="store_true") parser.add_argument("--nothree", dest='nothree', action="store_true") parser.add_argument("--show", "--plot", action="store_true") args = viscid.vutil.common_argparse(parser, default_verb=0) plot2d = not args.notwo plot3d = not args.nothree # ################################################# # viscid.logger.info("Testing field lines on 2d field...") B = viscid.make_dipole(twod=True) line = viscid.seed.Line((0.2, 0.0, 0.0), (1.0, 0.0, 0.0), 10) obound0 = np.array([-4, -4, -4], dtype=B.data.dtype) obound1 = np.array([4, 4, 4], dtype=B.data.dtype) run_test(B, line, plot2d=plot2d, plot3d=plot3d, title='2D', show=args.show, ibound=0.07, obound0=obound0, obound1=obound1) ################################################# viscid.logger.info("Testing field lines on 3d field...") B = viscid.make_dipole(m=[0.2, 0.3, -0.9]) sphere = viscid.seed.Sphere((0.0, 0.0, 0.0), 2.0, ntheta=20, nphi=10) obound0 = np.array([-4, -4, -4], dtype=B.data.dtype) obound1 = np.array([4, 4, 4], dtype=B.data.dtype) run_test(B, sphere, plot2d=plot2d, plot3d=plot3d, title='3D', show=args.show, ibound=0.12, obound0=obound0, obound1=obound1, method=viscid.RK12) # The Remainder of this test makes sure higher order methods are indeed # more accurate than lower order methods... this could find a bug in # the integrators ################################################## # test accuracy of streamlines in an ideal dipole cotr = viscid.Cotr(dip_tilt=15.0, dip_gsm=21.0) # pylint: disable=not-callable m = cotr.get_dipole_moment(crd_system='gse') seeds = viscid.seed.Sphere((0.0, 0.0, 0.0), 2.0, pole=-m, ntheta=25, nphi=25, thetalim=(5, 90), philim=(5, 360), phi_endpoint=False) B = viscid.make_dipole(m=m, crd_system='gse', n=(256, 256, 256), l=(-25, -25, -25), h=(25, 25, 25), dtype='f8') seeds_xyz = seeds.get_points() # seeds_lsp = viscid.xyz2lsrlp(seeds_xyz, cotr=cotr, crd_system=B)[(0, 3), :] seeds_lsp = viscid.xyz2lsrlp(seeds_xyz, cotr=cotr, crd_system=B)[(0, 3), :] e1_lines, e1_lsps, t_e1 = lines_and_lsps(B, seeds, method='euler1', ibound=1.0, cotr=cotr) rk2_lines, rk2_lsps, t_rk2 = lines_and_lsps(B, seeds, method='rk2', ibound=1.0, cotr=cotr) rk4_lines, rk4_lsps, t_rk4 = lines_and_lsps(B, seeds, method='rk4', ibound=1.0, cotr=cotr) e1a_lines, e1a_lsps, t_e1a = lines_and_lsps(B, seeds, method='euler1a', ibound=1.0, cotr=cotr) rk12_lines, rk12_lsps, t_rk12 = lines_and_lsps(B, seeds, method='rk12', ibound=1.0, cotr=cotr) rk45_lines, rk45_lsps, t_rk45 = lines_and_lsps(B, seeds, method='rk45', ibound=1.0, cotr=cotr) def _calc_rel_diff(_lsp, _ideal_lsp, _d): _diffs = [] for _ilsp, _iideal in zip(_lsp, _ideal_lsp.T): _a = _ilsp[_d, :] _b = _iideal[_d] _diffs.append((_a - _b) / _b) return _diffs lshell_diff_e1 = _calc_rel_diff(e1_lsps, seeds_lsp, 0) phi_diff_e1 = _calc_rel_diff(e1_lsps, seeds_lsp, 1) lshell_diff_rk2 = _calc_rel_diff(rk2_lsps, seeds_lsp, 0) phi_diff_rk2 = _calc_rel_diff(rk2_lsps, seeds_lsp, 1) lshell_diff_rk4 = _calc_rel_diff(rk4_lsps, seeds_lsp, 0) phi_diff_rk4 = _calc_rel_diff(rk4_lsps, seeds_lsp, 1) lshell_diff_e1a = _calc_rel_diff(e1a_lsps, seeds_lsp, 0) phi_diff_e1a = _calc_rel_diff(e1a_lsps, seeds_lsp, 1) lshell_diff_rk12 = _calc_rel_diff(rk12_lsps, seeds_lsp, 0) phi_diff_rk12 = _calc_rel_diff(rk12_lsps, seeds_lsp, 1) lshell_diff_rk45 = _calc_rel_diff(rk45_lsps, seeds_lsp, 0) phi_diff_rk45 = _calc_rel_diff(rk45_lsps, seeds_lsp, 1) methods = [ 'Euler 1', 'Runge Kutta 2', 'Runge Kutta 4', 'Euler 1 Adaptive Step', 'Runge Kutta 12 Adaptive Step', 'Runge Kutta 45 Adaptive Step' ] wall_ts = [t_e1, t_rk2, t_rk4, t_e1a, t_rk12, t_rk45] all_lines = [ e1_lines, rk2_lines, rk4_lines, e1a_lines, rk12_lines, rk45_lines ] all_lshell_diffs = [ lshell_diff_e1, lshell_diff_rk2, lshell_diff_rk4, lshell_diff_e1a, lshell_diff_rk12, lshell_diff_rk45 ] lshell_diffs = [ np.abs(np.concatenate(lshell_diff_e1, axis=0)), np.abs(np.concatenate(lshell_diff_rk2, axis=0)), np.abs(np.concatenate(lshell_diff_rk4, axis=0)), np.abs(np.concatenate(lshell_diff_e1a, axis=0)), np.abs(np.concatenate(lshell_diff_rk12, axis=0)), np.abs(np.concatenate(lshell_diff_rk45, axis=0)) ] phi_diffs = [ np.abs(np.concatenate(phi_diff_e1, axis=0)), np.abs(np.concatenate(phi_diff_rk2, axis=0)), np.abs(np.concatenate(phi_diff_rk4, axis=0)), np.abs(np.concatenate(phi_diff_e1a, axis=0)), np.abs(np.concatenate(phi_diff_rk12, axis=0)), np.abs(np.concatenate(phi_diff_rk45, axis=0)) ] npts = [len(lsd) for lsd in lshell_diffs] lshell_75 = [np.percentile(lsdiff, 75) for lsdiff in lshell_diffs] # # 3D DEBUG PLOT:: for really getting under the covers # vlab.clf() # earth1 = viscid.seed.Sphere((0.0, 0.0, 0.0), 1.0, pole=-m, ntheta=60, nphi=120, # thetalim=(15, 165), philim=(0, 360)) # ls1 = viscid.xyz2lsrlp(earth1.get_points(), cotr=cotr, crd_system='gse')[0, :] # earth2 = viscid.seed.Sphere((0.0, 0.0, 0.0), 2.0, pole=-m, ntheta=60, nphi=120, # thetalim=(15, 165), philim=(0, 360)) # ls2 = viscid.xyz2lsrlp(earth2.get_points(), cotr=cotr, crd_system='gse')[0, :] # earth4 = viscid.seed.Sphere((0.0, 0.0, 0.0), 4.0, pole=-m, ntheta=60, nphi=120, # thetalim=(15, 165), philim=(0, 360)) # ls4 = viscid.xyz2lsrlp(earth4.get_points(), cotr=cotr, crd_system='gse')[0, :] # clim = [2.0, 6.0] # vlab.mesh_from_seeds(earth1, scalars=ls1, clim=clim, logscale=True) # vlab.mesh_from_seeds(earth2, scalars=ls2, clim=clim, logscale=True, opacity=0.5) # vlab.mesh_from_seeds(earth4, scalars=ls2, clim=clim, logscale=True, opacity=0.25) # vlab.plot3d_lines(e1_lines, scalars=[_e1_lsp[0, :] for _e1_lsp in e1_lsps], # clim=clim, logscale=True) # vlab.colorbar(title="L-Shell") # vlab.show() assert lshell_75[1] < lshell_75[0], "RK2 should have less error than Euler" assert lshell_75[2] < lshell_75[1], "RK4 should have less error than RK2" assert lshell_75[3] < lshell_75[ 0], "Euler 1a should have less error than Euler 1" assert lshell_75[4] < lshell_75[ 0], "RK 12 should have less error than Euler 1" assert lshell_75[5] < lshell_75[1], "RK 45 should have less error than RK2" try: if not plot2d: raise ImportError from matplotlib import pyplot as plt from viscid.plot import vpyplot as vlt # stats on error for all points on all lines _ = plt.figure(figsize=(15, 8)) ax1 = vlt.subplot(121) v = plt.violinplot(lshell_diffs, showextrema=False, showmedians=False, vert=False) colors = set_violin_colors(v) xl, xh = plt.gca().get_xlim() for i, txt, c in zip(count(), methods, colors): t_txt = ", took {0:.2e} seconds".format(wall_ts[i]) stat_txt = format_data_range(lshell_diffs[i]) plt.text(xl + 0.35 * (xh - xl), i + 1.15, txt + t_txt, color=c) plt.text(xl + 0.35 * (xh - xl), i + 0.85, stat_txt, color=c) ax1.get_yaxis().set_visible(False) plt.title('L-Shell') plt.xlabel('Relative Difference from Ideal (as fraction)') ax2 = vlt.subplot(122) v = plt.violinplot(phi_diffs, showextrema=False, showmedians=False, vert=False) colors = set_violin_colors(v) xl, xh = plt.gca().get_xlim() for i, txt, c in zip(count(), methods, colors): t_txt = ", took {0:.2e} seconds".format(wall_ts[i]) stat_txt = format_data_range(phi_diffs[i]) plt.text(xl + 0.35 * (xh - xl), i + 1.15, txt + t_txt, color=c) plt.text(xl + 0.35 * (xh - xl), i + 0.85, stat_txt, color=c) ax2.get_yaxis().set_visible(False) plt.title('Longitude') plt.xlabel('Relative Difference from Ideal (as fraction)') vlt.auto_adjust_subplots() vlt.savefig(next_plot_fname(__file__, series='q2')) if args.show: vlt.show() # stats for ds for all points on all lines _ = plt.figure(figsize=(10, 8)) ax1 = vlt.subplot(111) ds = [ np.concatenate([ np.linalg.norm(_l[:, 1:] - _l[:, :-1], axis=0) for _l in lines ]) for lines in all_lines ] v = plt.violinplot(ds, showextrema=False, showmedians=False, vert=False) colors = set_violin_colors(v) xl, xh = plt.gca().get_xlim() for i, txt, c in zip(count(), methods, colors): stat_txt = format_data_range(ds[i]) plt.text(xl + 0.01 * (xh - xl), i + 1.15, txt, color=c) plt.text(xl + 0.01 * (xh - xl), i + 0.85, stat_txt, color=c) ax1.get_yaxis().set_visible(False) plt.xscale('log') plt.title('Step Size') plt.xlabel('Absolute Step Size') vlt.savefig(next_plot_fname(__file__, series='q2')) if args.show: vlt.show() # random other information _ = plt.figure(figsize=(13, 10)) ## wall time for each method vlt.subplot(221) plt.scatter(range(len(methods)), wall_ts, color=colors, s=150, marker='s', edgecolors='none') for i, meth in enumerate(methods): meth = meth.replace(" Adaptive Step", "\nAdaptive Step") plt.annotate(meth, (i, wall_ts[i]), xytext=(0, 15.0), color=colors[i], horizontalalignment='center', verticalalignment='bottom', textcoords='offset points') plt.ylabel("Wall Time (s)") x_padding = 0.5 plt.xlim(-x_padding, len(methods) - x_padding) yl, yh = np.min(wall_ts), np.max(wall_ts) y_padding = 0.4 * (yh - yl) plt.ylim(yl - y_padding, yh + y_padding) plt.gca().get_xaxis().set_visible(False) for _which in ('right', 'top'): plt.gca().spines[_which].set_color('none') ## number of points calculated for each method vlt.subplot(222) plt.scatter(range(len(methods)), npts, color=colors, s=150, marker='s', edgecolors='none') for i, meth in enumerate(methods): meth = meth.replace(" Adaptive Step", "\nAdaptive Step") plt.annotate(meth, (i, npts[i]), xytext=(0, 15.0), color=colors[i], horizontalalignment='center', verticalalignment='bottom', textcoords='offset points') plt.ylabel("Number of Streamline Points Calculated") x_padding = 0.5 plt.xlim(-x_padding, len(methods) - x_padding) yl, yh = np.min(npts), np.max(npts) y_padding = 0.4 * (yh - yl) plt.ylim(yl - y_padding, yh + y_padding) plt.gca().get_xaxis().set_visible(False) for _which in ('right', 'top'): plt.gca().spines[_which].set_color('none') ## Wall time per segment, this should show the overhead of the method vlt.subplot(223) wall_t_per_seg = np.asarray(wall_ts) / np.asarray(npts) plt.scatter(range(len(methods)), wall_t_per_seg, color=colors, s=150, marker='s', edgecolors='none') for i, meth in enumerate(methods): meth = meth.replace(" Adaptive Step", "\nAdaptive Step") plt.annotate(meth, (i, wall_t_per_seg[i]), xytext=(0, 15.0), color=colors[i], horizontalalignment='center', verticalalignment='bottom', textcoords='offset points') plt.ylabel("Wall Time Per Line Segment") x_padding = 0.5 plt.xlim(-x_padding, len(methods) - x_padding) yl, yh = np.min(wall_t_per_seg), np.max(wall_t_per_seg) y_padding = 0.4 * (yh - yl) plt.ylim(yl - y_padding, yh + y_padding) plt.gca().get_xaxis().set_visible(False) plt.gca().xaxis.set_major_formatter(viscid.plot.mpl_extra.steve_axfmt) for _which in ('right', 'top'): plt.gca().spines[_which].set_color('none') ## 75th percentile of l-shell error for each method vlt.subplot(224) plt.scatter(range(len(methods)), lshell_75, color=colors, s=150, marker='s', edgecolors='none') plt.yscale('log') for i, meth in enumerate(methods): meth = meth.replace(" Adaptive Step", "\nAdaptive Step") plt.annotate(meth, (i, lshell_75[i]), xytext=(0, 15.0), color=colors[i], horizontalalignment='center', verticalalignment='bottom', textcoords='offset points') plt.ylabel("75th Percentile of Relative L-Shell Error") x_padding = 0.5 plt.xlim(-x_padding, len(methods) - x_padding) ymin, ymax = np.min(lshell_75), np.max(lshell_75) plt.ylim(0.75 * ymin, 2.5 * ymax) plt.gca().get_xaxis().set_visible(False) for _which in ('right', 'top'): plt.gca().spines[_which].set_color('none') vlt.auto_adjust_subplots(subplot_params=dict(wspace=0.25, hspace=0.15)) vlt.savefig(next_plot_fname(__file__, series='q2')) if args.show: vlt.show() except ImportError: pass try: if not plot3d: raise ImportError from viscid.plot import vlab try: fig = _global_ns['figure'] vlab.clf() except KeyError: fig = vlab.figure(size=[1200, 800], offscreen=not args.show, bgcolor=(1, 1, 1), fgcolor=(0, 0, 0)) _global_ns['figure'] = fig for i, method in zip(count(), methods): # if i in (3, 4): # next_plot_fname(__file__, series='q3') # print(i, "::", [line.shape[1] for line in all_lines[i]]) # # continue vlab.clf() _lshell_diff = [np.abs(s) for s in all_lshell_diffs[i]] vlab.plot3d_lines(all_lines[i], scalars=_lshell_diff) vlab.colorbar(title="Relative L-Shell Error (as fraction)") vlab.title(method, size=0.5) vlab.orientation_axes() vlab.view(azimuth=40, elevation=140, distance=80.0, focalpoint=[0, 0, 0]) vlab.savefig(next_plot_fname(__file__, series='q3')) if args.show: vlab.show() except ImportError: pass # prevent weird xorg bad-instructions on tear down if 'figure' in _global_ns and _global_ns['figure'] is not None: from viscid.plot import vlab vlab.mlab.close(_global_ns['figure']) return 0
def _do_multiplot(tind, grid, plot_vars=None, global_popts=None, kwopts=None, share_axes=False, show=False, subplot_params=None, first_run_result=None, first_run=False, **kwargs): import matplotlib.pyplot as plt from viscid.plot import vpyplot as vlt logger.info("Plotting timestep: %d, %g", tind, grid.time) if plot_vars is None: raise ValueError("No plot_vars given to `_do_multiplot` :(") if kwargs: logger.info("Unused kwargs: {0}".format(kwargs)) if kwopts is None: kwopts = {} transpose = kwopts.get("transpose", False) plot_size = kwopts.get("plot_size", None) dpi = kwopts.get("dpi", None) out_prefix = kwopts.get("out_prefix", None) out_format = kwopts.get("out_format", "png") selection = kwopts.get("selection", None) timeformat = kwopts.get("timeformat", ".02f") tighten = kwopts.get("tighten", False) # wicked hacky # subplot_params = kwopts.get("subplot_params", _subplot_params) # nrows = len(plot_vars) nrows = len([pv[0] for pv in plot_vars if not pv[0].startswith('^')]) ncols = 1 if transpose: nrows, ncols = ncols, nrows if nrows == 0: logger.warn("I have no variables to plot") return fig = plt.gcf() if plot_size is not None: fig.set_size_inches(*plot_size, forward=True) if dpi is not None: fig.set_dpi(dpi) shareax = None this_row = -1 for i, fld_meta in enumerate(plot_vars): if not fld_meta[0].startswith('^'): this_row += 1 same_axis = False else: same_axis = True fld_name_meta = fld_meta[0].lstrip('^') fld_name_split = fld_name_meta.split(',') if '=' in fld_name_split[0]: # if fld_name is actually an equation, assume # there's no slice, and commas are part of the # equation fld_name = ",".join(fld_name_split) fld_slc = "" else: fld_name = fld_name_split[0] fld_slc = ",".join(fld_name_split[1:]) if selection is not None: # fld_slc += ",{0}".format(selection) if fld_slc != "": fld_slc = ",".join([fld_slc, selection]) else: fld_slc = selection if fld_slc.strip() == "": fld_slc = None # print("fld_time:", fld.time) if this_row < 0: raise ValueError("first plot can't begin with a +") row = this_row col = 0 if transpose: row, col = col, row if not same_axis: ax = plt.subplot2grid((nrows, ncols), (row, col), sharex=shareax, sharey=shareax) if i == 0 and share_axes: shareax = ax if "plot_opts" not in fld_meta[1]: fld_meta[1]["plot_opts"] = global_popts elif global_popts is not None: fld_meta[1]["plot_opts"] = "{0},{1}".format( fld_meta[1]["plot_opts"], global_popts) with grid.get_field(fld_name, slc=fld_slc) as fld: vlt.plot(fld, masknan=True, **fld_meta[1]) # print("fld cache", grid[fld_meta[0]]._cache) if timeformat and timeformat.lower() != "none": plt.suptitle(grid.format_time(timeformat)) # for adjusting subplots / tight_layout and applying the various # hacks to keep plots from dancing around in movies if not subplot_params and first_run_result: subplot_params = first_run_result if tighten: tighten = dict(rect=[0, 0.03, 1, 0.90]) ret = vlt.auto_adjust_subplots(tight_layout=tighten, subplot_params=subplot_params) if not first_run: ret = None if out_prefix: plt.savefig("{0}_{1:06d}.{2}".format(out_prefix, tind + 1, out_format)) if show: plt.show() plt.clf() return ret
def _main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--prof", action="store_true") parser.add_argument("--show", "--plot", action="store_true") args = vutil.common_argparse(parser) b = viscid.make_dipole(l=(-5, -5, -5), h=(5, 5, 5), n=(255, 255, 127), m=(0, 0, -1)) b2 = np.sum(b * b, axis=b.nr_comp) if args.prof: print("Without boundaries") viscid.timeit(viscid.grad, b2, bnd=False, timeit_repeat=10, timeit_print_stats=True) print("With boundaries") viscid.timeit(viscid.grad, b2, bnd=True, timeit_repeat=10, timeit_print_stats=True) grad_b2 = viscid.grad(b2) grad_b2.pretty_name = r"$\nabla$ B$^2$" conv = viscid.convective_deriv(b) conv.pretty_name = r"(B $\cdot \nabla$) B" _ = plt.figure(figsize=(9, 4.2)) ax1 = vlt.subplot(231) vlt.plot(b2['z=0f'], logscale=True) vlt.plot(b2['z=0f'], logscale=True, style='contour', levels=10, colors='grey') # vlt.plot2d_quiver(viscid.normalize(b['z=0f']), step=16, pivot='mid') ax2 = vlt.subplot(234) vlt.plot(b2['y=0f'], logscale=True) vlt.plot(b2['y=0f'], logscale=True, style='contour', levels=10, colors='grey') vlt.plot2d_quiver(viscid.normalize(b['y=0f'], preferred='numpy'), step=16, pivot='mid') vlt.subplot(232, sharex=ax1, sharey=ax1) vlt.plot(1e-4 + viscid.magnitude(grad_b2['z=0f']), logscale=True) vlt.plot(1e-4 + viscid.magnitude(grad_b2['z=0f']), logscale=True, style='contour', levels=10, colors='grey') vlt.plot2d_quiver(viscid.normalize(grad_b2['z=0f']), step=16, pivot='mid') vlt.subplot(235, sharex=ax2, sharey=ax2) vlt.plot(1e-4 + viscid.magnitude(grad_b2['y=0f']), logscale=True) vlt.plot(1e-4 + viscid.magnitude(grad_b2['y=0f']), logscale=True, style='contour', levels=10, colors='grey') vlt.plot2d_quiver(viscid.normalize(grad_b2['y=0f']), step=16, pivot='mid') vlt.subplot(233, sharex=ax1, sharey=ax1) vlt.plot(viscid.magnitude(conv['z=0f']), logscale=True) vlt.plot(viscid.magnitude(conv['z=0f']), logscale=True, style='contour', levels=10, colors='grey') vlt.plot2d_quiver(viscid.normalize(conv['z=0f']), step=16, pivot='mid') vlt.subplot(236, sharex=ax2, sharey=ax2) vlt.plot(viscid.magnitude(conv['y=0f']), logscale=True) vlt.plot(viscid.magnitude(conv['y=0f']), logscale=True, style='contour', levels=10, colors='grey') vlt.plot2d_quiver(viscid.normalize(conv['y=0f']), step=16, pivot='mid') vlt.auto_adjust_subplots() plt.savefig(next_plot_fname(__file__)) if args.show: vlt.show() return 0
def _do_multiplot(tind, grid, plot_vars=None, global_popts=None, kwopts=None, share_axes=False, show=False, subplot_params=None, first_run_result=None, first_run=False, **kwargs): from viscid.plot import vpyplot as vlt import matplotlib.pyplot as plt logger.info("Plotting timestep: %d, %g", tind, grid.time) if plot_vars is None: raise ValueError("No plot_vars given to `_do_multiplot` :(") if kwargs: logger.info("Unused kwargs: {0}".format(kwargs)) if kwopts is None: kwopts = {} transpose = kwopts.get("transpose", False) plot_size = kwopts.get("plot_size", None) dpi = kwopts.get("dpi", None) out_prefix = kwopts.get("out_prefix", None) out_format = kwopts.get("out_format", "png") selection = kwopts.get("selection", None) timeformat = kwopts.get("timeformat", ".02f") tighten = kwopts.get("tighten", False) # wicked hacky # subplot_params = kwopts.get("subplot_params", _subplot_params) # nrows = len(plot_vars) nrows = len([pv[0] for pv in plot_vars if not pv[0].startswith('^')]) ncols = 1 if transpose: nrows, ncols = ncols, nrows if nrows == 0: logger.warning("I have no variables to plot") return fig = plt.gcf() if plot_size is not None: fig.set_size_inches(*plot_size, forward=True) if dpi is not None: fig.set_dpi(dpi) shareax = None this_row = -1 for i, fld_meta in enumerate(plot_vars): if not fld_meta[0].startswith('^'): this_row += 1 same_axis = False else: same_axis = True fld_name_meta = fld_meta[0].lstrip('^') fld_name_split = fld_name_meta.split(',') if '=' in fld_name_split[0]: # if fld_name is actually an equation, assume # there's no slice, and commas are part of the # equation fld_name = ",".join(fld_name_split) fld_slc = "" else: fld_name = fld_name_split[0] fld_slc = ",".join(fld_name_split[1:]) if selection is not None: # fld_slc += ",{0}".format(selection) if fld_slc != "": fld_slc = ",".join([fld_slc, selection]) else: fld_slc = selection if fld_slc.strip() == "": fld_slc = Ellipsis # print("fld_time:", fld.time) if this_row < 0: raise ValueError("first plot can't begin with a +") row = this_row col = 0 if transpose: row, col = col, row if not same_axis: ax = plt.subplot2grid((nrows, ncols), (row, col), sharex=shareax, sharey=shareax) if i == 0 and share_axes: shareax = ax if "plot_opts" not in fld_meta[1]: fld_meta[1]["plot_opts"] = global_popts elif global_popts is not None: fld_meta[1]["plot_opts"] = "{0},{1}".format( fld_meta[1]["plot_opts"], global_popts) with grid.get_field(fld_name, slc=fld_slc) as fld: vlt.plot(fld, masknan=True, **fld_meta[1]) # print("fld cache", grid[fld_meta[0]]._cache) if timeformat and timeformat.lower() != "none": plt.suptitle(grid.format_time(timeformat)) # for adjusting subplots / tight_layout and applying the various # hacks to keep plots from dancing around in movies if not subplot_params and first_run_result: subplot_params = first_run_result if tighten: tighten = dict(rect=[0, 0.03, 1, 0.90]) ret = vlt.auto_adjust_subplots(tight_layout=tighten, subplot_params=subplot_params) if not first_run: ret = None if out_prefix: plt.savefig("{0}_{1:06d}.{2}".format(out_prefix, tind + 1, out_format)) if show: plt.show() plt.clf() return ret
def main(): mhd_type = "C" make_plots = 1 test_fc = 1 test_ec = 1 test_div = 1 test_interp = 1 test_streamline = 1 mhd_type = mhd_type.upper() if mhd_type.startswith("C"): if mhd_type in ("C", ): f = viscid.load_file("$WORK/tmedium/*.3d.[-1].xdmf") elif mhd_type in ("C2", "C3"): f = viscid.load_file("$WORK/tmedium2/*.3d.[-1].xdmf") else: raise ValueError() catol = 1e-8 rtol = 5e-6 elif mhd_type in ("F", "FORTRAN"): f = viscid.load_file("$WORK/tmedium3/*.3df.[-1]") catol = 1e-8 rtol = 7e-2 else: raise ValueError() ISLICE = slice(None) # ISLICE = 'y=0f:0.15f' # ################# # # test out fc2cc if test_fc: b = f['b'][ISLICE] b1 = f['b1'][ISLICE] compare_vectors(b, b1, viscid.fc2cc, catol=catol, rtol=rtol, make_plots=make_plots) ################# # test out ec2cc if test_ec: e_cc = f['e_cc'][ISLICE] e_ec = f['e_ec'][ISLICE] if mhd_type not in ("F", "FORTRAN"): compare_vectors(e_cc, e_ec, viscid.ec2cc, catol=catol, rtol=rtol, make_plots=make_plots) ################# # test out divfc # Note: Relative error on Div B is meaningless b/c the coordinates # are not the same up to order (dx/4) I think. You can see this # since (fcdiv - divb_trimmed) is both noisy and stripy if test_div: bnd = 0 if mhd_type not in ("F", "FORTRAN"): b1 = f['b1'][ISLICE] divb = f['divB'][ISLICE] if bnd: trimmed = divb else: trimmed = divb['x=1:-1, y=1:-1, z=1:-1'] b1mag = viscid.magnitude(viscid.fc2cc(b1, bnd=bnd)) divb1 = viscid.div_fc(b1, bnd=bnd) viscid.set_in_region(trimmed, trimmed, alpha=0.0, beta=0.0, out=trimmed, mask=viscid.make_spherical_mask(trimmed, rmax=5.0)) viscid.set_in_region(divb1, divb1, alpha=0.0, beta=0.0, out=divb1, mask=viscid.make_spherical_mask(divb1, rmax=5.0)) reldiff = (divb1 - trimmed) / b1mag reldiff = reldiff["x=1:-1, y=1:-1, z=1:-1"] reldiff.name = divb1.name + " - " + trimmed.name reldiff.pretty_name = divb1.pretty_name + " - " + trimmed.pretty_name abs_max_rel_diff = np.nanmax(np.abs(reldiff)) max_crd_diff = [0.0] * 3 for i, d in enumerate('xyz'): max_crd_diff[i] = np.max(trimmed.get_crd(d) - divb1.get_crd(d)) print("divB max absolute relative diff: {0:.3e} " "(crds: X: {1[0]:.3e}, Y: {1[1]:.3e}, Z: {1[2]:.3e})" "".format(abs_max_rel_diff, max_crd_diff)) # plot differences? if make_plots: ax1 = plt.subplot(311) vlt.plot(divb['y=0f'], symmetric=True, earth=True) plt.subplot(312, sharex=ax1, sharey=ax1) vlt.plot(divb1['y=0f'], symmetric=True, earth=True) plt.subplot(313, sharex=ax1, sharey=ax1) vlt.plot(reldiff['y=0f'], symmetric=True, earth=True) vlt.show() # Since the coordinates will be different by order dx^2 (i think), # there is no way to compare the divB from simulation with the # one we get here. However, they should be the same up to a few %, and # down to noise level with stripes of enhanced noise. These stripes # are the errors in the coordinate values (since the output only # gives us weird nc = averaged cc locations) # # if abs_max_rel_diff > rtol or np.any(np.abs(max_crd_diff) > catol): # raise RuntimeError("Tolerance exceeded on divB calculation") if test_streamline: b_cc = f['b_cc']['x=-40f:12f, y=-15f:15f, z=-15f:15f'] b_fc = f['b_fc']['x=-40f:12f, y=-15f:15f, z=-15f:15f'] cotr = viscid.cotr.Cotr() r_mask = 3.0 # set b_cc to dipole inside some sphere isphere_mask = viscid.make_spherical_mask(b_cc, rmax=r_mask) moment = cotr.get_dipole_moment(crd_system=b_cc) viscid.fill_dipole(b_cc, m=moment, mask=isphere_mask) # set b_fc to dipole inside some sphere isphere_mask = viscid.make_spherical_mask(b_fc, rmax=r_mask) moment = cotr.get_dipole_moment(crd_system=b_fc) viscid.fill_dipole(b_fc, m=moment, mask=isphere_mask) seeds = viscid.Volume([-10, 0, -5], [10, 0, 5], (16, 1, 3)) sl_kwargs = dict(ibound=1.0, method=viscid.EULER1A) lines_cc, topo_cc = viscid.calc_streamlines(b_cc, seeds, **sl_kwargs) lines_fc, topo_fc = viscid.calc_streamlines(b_fc, seeds, **sl_kwargs) if make_plots: plt.figure(figsize=(10, 6)) ax0 = plt.subplot(211) topo_cc_colors = viscid.topology2color(topo_cc) vlt.plot(f['pp']['y=0f'], logscale=True, earth=True, cmap='plasma') vlt.plot2d_lines(lines_cc, topo_cc_colors, symdir='y') ax0 = plt.subplot(212, sharex=ax0, sharey=ax0) topo_fc_colors = viscid.topology2color(topo_fc) vlt.plot(f['pp']['y=0f'], logscale=True, earth=True, cmap='plasma') vlt.plot2d_lines(lines_fc, topo_fc_colors, symdir='y') plt.xlim(-20, 10) plt.ylim(-10, 10) vlt.auto_adjust_subplots() vlt.show() if test_interp: # test interpolation with E . B / B b_cc = f['b_cc'] b_fc = f['b_fc'] e_cc = f['e_cc'] e_ec = f['e_ec'] cotr = viscid.cotr.Cotr() r_mask = 3.0 # set b_cc to dipole inside some sphere isphere_mask = viscid.make_spherical_mask(b_cc, rmax=r_mask) moment = cotr.get_dipole_moment(crd_system=b_cc) viscid.fill_dipole(b_cc, m=moment, mask=isphere_mask) # set b_fc to dipole inside some sphere isphere_mask = viscid.make_spherical_mask(b_fc, rmax=r_mask) moment = cotr.get_dipole_moment(crd_system=b_fc) viscid.fill_dipole(b_fc, m=moment, mask=isphere_mask) # zero out e_cc inside some sphere viscid.set_in_region(e_cc, e_cc, alpha=0.0, beta=0.0, out=e_cc, mask=viscid.make_spherical_mask(e_cc, rmax=r_mask)) # zero out e_ec inside some sphere viscid.set_in_region(e_ec, e_ec, alpha=0.0, beta=0.0, out=e_ec, mask=viscid.make_spherical_mask(e_ec, rmax=r_mask)) tmp = viscid.empty([ np.linspace(-10, 10, 64), np.linspace(-10, 10, 64), np.linspace(-10, 10, 64) ], center="Cell") b_cc_interp = viscid.interp_linear(b_cc, tmp) b_fc_interp = viscid.interp_linear(b_fc, tmp) e_cc_interp = viscid.interp_linear(e_cc, tmp) e_ec_interp = viscid.interp_linear(e_ec, tmp) epar_cc = viscid.dot(e_cc_interp, b_cc_interp) / viscid.magnitude(b_cc_interp) epar_ecfc = viscid.dot(e_ec_interp, b_fc_interp) / viscid.magnitude(b_fc_interp) if make_plots: # plt.figure() # ax0 = plt.subplot(121) # vlt.plot(b_cc['x']['y=0f'], clim=(-40, 40)) # plt.subplot(122, sharex=ax0, sharey=ax0) # vlt.plot(b_fc['x']['y=0f'], clim=(-40, 40)) # vlt.show() plt.figure(figsize=(14, 5)) ax0 = plt.subplot(131) vlt.plot(epar_cc['y=0f'], symmetric=True, cbarlabel="Epar CC") plt.subplot(132, sharex=ax0, sharey=ax0) vlt.plot(epar_ecfc['y=0f'], symmetric=True, cbarlabel="Epar ECFC") plt.subplot(133, sharex=ax0, sharey=ax0) vlt.plot(((epar_cc - epar_ecfc) / epar_cc)['y=0f'], clim=(-10, 10), cbarlabel="Rel Diff") vlt.auto_adjust_subplots() vlt.show() return 0
def main(): mhd_type = "C" make_plots = 1 test_fc = 1 test_ec = 1 test_div = 1 test_interp = 1 test_streamline = 1 mhd_type = mhd_type.upper() if mhd_type.startswith("C"): if mhd_type in ("C",): f = viscid.load_file("$WORK/tmedium/*.3d.[-1].xdmf") elif mhd_type in ("C2", "C3"): f = viscid.load_file("$WORK/tmedium2/*.3d.[-1].xdmf") else: raise ValueError() catol = 1e-8 rtol = 5e-6 elif mhd_type in ("F", "FORTRAN"): f = viscid.load_file("$WORK/tmedium3/*.3df.[-1]") catol = 1e-8 rtol = 7e-2 else: raise ValueError() ISLICE = slice(None) # ISLICE = 'y=0j:0.15j' # ################# # # test out fc2cc if test_fc: b = f['b'][ISLICE] b1 = f['b1'][ISLICE] compare_vectors(b, b1, viscid.fc2cc, catol=catol, rtol=rtol, make_plots=make_plots) ################# # test out ec2cc if test_ec: e_cc = f['e_cc'][ISLICE] e_ec = f['e_ec'][ISLICE] if mhd_type not in ("F", "FORTRAN"): compare_vectors(e_cc, e_ec, viscid.ec2cc, catol=catol, rtol=rtol, make_plots=make_plots) ################# # test out divfc # Note: Relative error on Div B is meaningless b/c the coordinates # are not the same up to order (dx/4) I think. You can see this # since (fcdiv - divb_trimmed) is both noisy and stripy if test_div: bnd = 0 if mhd_type not in ("F", "FORTRAN"): b1 = f['b1'][ISLICE] divb = f['divB'][ISLICE] if bnd: trimmed = divb else: trimmed = divb['x=1:-1, y=1:-1, z=1:-1'] b1mag = viscid.magnitude(viscid.fc2cc(b1, bnd=bnd)) divb1 = viscid.div_fc(b1, bnd=bnd) viscid.set_in_region(trimmed, trimmed, alpha=0.0, beta=0.0, out=trimmed, mask=viscid.make_spherical_mask(trimmed, rmax=5.0)) viscid.set_in_region(divb1, divb1, alpha=0.0, beta=0.0, out=divb1, mask=viscid.make_spherical_mask(divb1, rmax=5.0)) reldiff = (divb1 - trimmed) / b1mag reldiff = reldiff["x=1:-1, y=1:-1, z=1:-1"] reldiff.name = divb1.name + " - " + trimmed.name reldiff.pretty_name = divb1.pretty_name + " - " + trimmed.pretty_name abs_max_rel_diff = np.nanmax(np.abs(reldiff)) max_crd_diff = [0.0] * 3 for i, d in enumerate('xyz'): max_crd_diff[i] = np.max(trimmed.get_crd(d) - divb1.get_crd(d)) print("divB max absolute relative diff: {0:.3e} " "(crds: X: {1[0]:.3e}, Y: {1[1]:.3e}, Z: {1[2]:.3e})" "".format(abs_max_rel_diff, max_crd_diff)) # plot differences? if make_plots: ax1 = plt.subplot(311) vlt.plot(divb['y=0j'], symmetric=True, earth=True) plt.subplot(312, sharex=ax1, sharey=ax1) vlt.plot(divb1['y=0j'], symmetric=True, earth=True) plt.subplot(313, sharex=ax1, sharey=ax1) vlt.plot(reldiff['y=0j'], symmetric=True, earth=True) vlt.show() # Since the coordinates will be different by order dx^2 (i think), # there is no way to compare the divB from simulation with the # one we get here. However, they should be the same up to a few %, and # down to noise level with stripes of enhanced noise. These stripes # are the errors in the coordinate values (since the output only # gives us weird nc = averaged cc locations) # # if abs_max_rel_diff > rtol or np.any(np.abs(max_crd_diff) > catol): # raise RuntimeError("Tolerance exceeded on divB calculation") if test_streamline: b_cc = f['b_cc']['x=-40j:12j, y=-15j:15j, z=-15j:15j'] b_fc = f['b_fc']['x=-40j:12j, y=-15j:15j, z=-15j:15j'] cotr = viscid.cotr.Cotr() r_mask = 3.0 # set b_cc to dipole inside some sphere isphere_mask = viscid.make_spherical_mask(b_cc, rmax=r_mask) moment = cotr.get_dipole_moment(crd_system=b_cc) viscid.fill_dipole(b_cc, m=moment, mask=isphere_mask) # set b_fc to dipole inside some sphere isphere_mask = viscid.make_spherical_mask(b_fc, rmax=r_mask) moment = cotr.get_dipole_moment(crd_system=b_fc) viscid.fill_dipole(b_fc, m=moment, mask=isphere_mask) seeds = viscid.Volume([-10, 0, -5], [10, 0, 5], (16, 1, 3)) sl_kwargs = dict(ibound=1.0, method=viscid.EULER1A) lines_cc, topo_cc = viscid.calc_streamlines(b_cc, seeds, **sl_kwargs) lines_fc, topo_fc = viscid.calc_streamlines(b_fc, seeds, **sl_kwargs) if make_plots: plt.figure(figsize=(10, 6)) ax0 = plt.subplot(211) topo_cc_colors = viscid.topology2color(topo_cc) vlt.plot(f['pp']['y=0j'], logscale=True, earth=True, cmap='plasma') vlt.plot2d_lines(lines_cc, topo_cc_colors, symdir='y') ax0 = plt.subplot(212, sharex=ax0, sharey=ax0) topo_fc_colors = viscid.topology2color(topo_fc) vlt.plot(f['pp']['y=0j'], logscale=True, earth=True, cmap='plasma') vlt.plot2d_lines(lines_fc, topo_fc_colors, symdir='y') plt.xlim(-20, 10) plt.ylim(-10, 10) vlt.auto_adjust_subplots() vlt.show() if test_interp: # test interpolation with E . B / B b_cc = f['b_cc'] b_fc = f['b_fc'] e_cc = f['e_cc'] e_ec = f['e_ec'] cotr = viscid.cotr.Cotr() r_mask = 3.0 # set b_cc to dipole inside some sphere isphere_mask = viscid.make_spherical_mask(b_cc, rmax=r_mask) moment = cotr.get_dipole_moment(crd_system=b_cc) viscid.fill_dipole(b_cc, m=moment, mask=isphere_mask) # set b_fc to dipole inside some sphere isphere_mask = viscid.make_spherical_mask(b_fc, rmax=r_mask) moment = cotr.get_dipole_moment(crd_system=b_fc) viscid.fill_dipole(b_fc, m=moment, mask=isphere_mask) # zero out e_cc inside some sphere viscid.set_in_region(e_cc, e_cc, alpha=0.0, beta=0.0, out=e_cc, mask=viscid.make_spherical_mask(e_cc, rmax=r_mask)) # zero out e_ec inside some sphere viscid.set_in_region(e_ec, e_ec, alpha=0.0, beta=0.0, out=e_ec, mask=viscid.make_spherical_mask(e_ec, rmax=r_mask)) tmp = viscid.empty([np.linspace(-10, 10, 64), np.linspace(-10, 10, 64), np.linspace(-10, 10, 64)], center="Cell") b_cc_interp = viscid.interp_linear(b_cc, tmp) b_fc_interp = viscid.interp_linear(b_fc, tmp) e_cc_interp = viscid.interp_linear(e_cc, tmp) e_ec_interp = viscid.interp_linear(e_ec, tmp) epar_cc = viscid.dot(e_cc_interp, b_cc_interp) / viscid.magnitude(b_cc_interp) epar_ecfc = viscid.dot(e_ec_interp, b_fc_interp) / viscid.magnitude(b_fc_interp) if make_plots: # plt.figure() # ax0 = plt.subplot(121) # vlt.plot(b_cc['x']['y=0j'], clim=(-40, 40)) # plt.subplot(122, sharex=ax0, sharey=ax0) # vlt.plot(b_fc['x']['y=0j'], clim=(-40, 40)) # vlt.show() plt.figure(figsize=(14, 5)) ax0 = plt.subplot(131) vlt.plot(epar_cc['y=0j'], symmetric=True, cbarlabel="Epar CC") plt.subplot(132, sharex=ax0, sharey=ax0) vlt.plot(epar_ecfc['y=0j'], symmetric=True, cbarlabel="Epar ECFC") plt.subplot(133, sharex=ax0, sharey=ax0) vlt.plot(((epar_cc - epar_ecfc) / epar_cc)['y=0j'], clim=(-10, 10), cbarlabel="Rel Diff") vlt.auto_adjust_subplots() vlt.show() return 0
def _main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--notwo", dest='notwo', action="store_true") parser.add_argument("--nothree", dest='nothree', action="store_true") parser.add_argument("--show", "--plot", action="store_true") args = viscid.vutil.common_argparse(parser, default_verb=0) plot2d = not args.notwo plot3d = not args.nothree # ################################################# # viscid.logger.info("Testing field lines on 2d field...") B = viscid.make_dipole(twod=True) line = viscid.seed.Line((0.2, 0.0, 0.0), (1.0, 0.0, 0.0), 10) obound0 = np.array([-4, -4, -4], dtype=B.data.dtype) obound1 = np.array([4, 4, 4], dtype=B.data.dtype) run_test(B, line, plot2d=plot2d, plot3d=plot3d, title='2D', show=args.show, ibound=0.07, obound0=obound0, obound1=obound1) ################################################# viscid.logger.info("Testing field lines on 3d field...") B = viscid.make_dipole(m=[0.2, 0.3, -0.9]) sphere = viscid.seed.Sphere((0.0, 0.0, 0.0), 2.0, ntheta=20, nphi=10) obound0 = np.array([-4, -4, -4], dtype=B.data.dtype) obound1 = np.array([4, 4, 4], dtype=B.data.dtype) run_test(B, sphere, plot2d=plot2d, plot3d=plot3d, title='3D', show=args.show, ibound=0.12, obound0=obound0, obound1=obound1, method=viscid.RK12) # The Remainder of this test makes sure higher order methods are indeed # more accurate than lower order methods... this could find a bug in # the integrators ################################################## # test accuracy of streamlines in an ideal dipole cotr = viscid.Cotr(dip_tilt=15.0, dip_gsm=21.0) # pylint: disable=not-callable m = cotr.get_dipole_moment(crd_system='gse') seeds = viscid.seed.Sphere((0.0, 0.0, 0.0), 2.0, pole=-m, ntheta=25, nphi=25, thetalim=(5, 90), philim=(5, 360), phi_endpoint=False) B = viscid.make_dipole(m=m, crd_system='gse', n=(256, 256, 256), l=(-25, -25, -25), h=(25, 25, 25), dtype='f8') seeds_xyz = seeds.get_points() # seeds_lsp = viscid.xyz2lsrlp(seeds_xyz, cotr=cotr, crd_system=B)[(0, 3), :] seeds_lsp = viscid.xyz2lsrlp(seeds_xyz, cotr=cotr, crd_system=B)[(0, 3), :] e1_lines, e1_lsps, t_e1 = lines_and_lsps(B, seeds, method='euler1', ibound=1.0, cotr=cotr) rk2_lines, rk2_lsps, t_rk2 = lines_and_lsps(B, seeds, method='rk2', ibound=1.0, cotr=cotr) rk4_lines, rk4_lsps, t_rk4 = lines_and_lsps(B, seeds, method='rk4', ibound=1.0, cotr=cotr) e1a_lines, e1a_lsps, t_e1a = lines_and_lsps(B, seeds, method='euler1a', ibound=1.0, cotr=cotr) rk12_lines, rk12_lsps, t_rk12 = lines_and_lsps(B, seeds, method='rk12', ibound=1.0, cotr=cotr) rk45_lines, rk45_lsps, t_rk45 = lines_and_lsps(B, seeds, method='rk45', ibound=1.0, cotr=cotr) def _calc_rel_diff(_lsp, _ideal_lsp, _d): _diffs = [] for _ilsp, _iideal in zip(_lsp, _ideal_lsp.T): _a = _ilsp[_d, :] _b = _iideal[_d] _diffs.append((_a - _b) / _b) return _diffs lshell_diff_e1 = _calc_rel_diff(e1_lsps, seeds_lsp, 0) phi_diff_e1 = _calc_rel_diff(e1_lsps, seeds_lsp, 1) lshell_diff_rk2 = _calc_rel_diff(rk2_lsps, seeds_lsp, 0) phi_diff_rk2 = _calc_rel_diff(rk2_lsps, seeds_lsp, 1) lshell_diff_rk4 = _calc_rel_diff(rk4_lsps, seeds_lsp, 0) phi_diff_rk4 = _calc_rel_diff(rk4_lsps, seeds_lsp, 1) lshell_diff_e1a = _calc_rel_diff(e1a_lsps, seeds_lsp, 0) phi_diff_e1a = _calc_rel_diff(e1a_lsps, seeds_lsp, 1) lshell_diff_rk12 = _calc_rel_diff(rk12_lsps, seeds_lsp, 0) phi_diff_rk12 = _calc_rel_diff(rk12_lsps, seeds_lsp, 1) lshell_diff_rk45 = _calc_rel_diff(rk45_lsps, seeds_lsp, 0) phi_diff_rk45 = _calc_rel_diff(rk45_lsps, seeds_lsp, 1) methods = ['Euler 1', 'Runge Kutta 2', 'Runge Kutta 4', 'Euler 1 Adaptive Step', 'Runge Kutta 12 Adaptive Step', 'Runge Kutta 45 Adaptive Step'] wall_ts = [t_e1, t_rk2, t_rk4, t_e1a, t_rk12, t_rk45] all_lines = [e1_lines, rk2_lines, rk4_lines, e1a_lines, rk12_lines, rk45_lines] all_lshell_diffs = [lshell_diff_e1, lshell_diff_rk2, lshell_diff_rk4, lshell_diff_e1a, lshell_diff_rk12, lshell_diff_rk45] lshell_diffs = [np.abs(np.concatenate(lshell_diff_e1, axis=0)), np.abs(np.concatenate(lshell_diff_rk2, axis=0)), np.abs(np.concatenate(lshell_diff_rk4, axis=0)), np.abs(np.concatenate(lshell_diff_e1a, axis=0)), np.abs(np.concatenate(lshell_diff_rk12, axis=0)), np.abs(np.concatenate(lshell_diff_rk45, axis=0))] phi_diffs = [np.abs(np.concatenate(phi_diff_e1, axis=0)), np.abs(np.concatenate(phi_diff_rk2, axis=0)), np.abs(np.concatenate(phi_diff_rk4, axis=0)), np.abs(np.concatenate(phi_diff_e1a, axis=0)), np.abs(np.concatenate(phi_diff_rk12, axis=0)), np.abs(np.concatenate(phi_diff_rk45, axis=0))] npts = [len(lsd) for lsd in lshell_diffs] lshell_75 = [np.percentile(lsdiff, 75) for lsdiff in lshell_diffs] # # 3D DEBUG PLOT:: for really getting under the covers # vlab.clf() # earth1 = viscid.seed.Sphere((0.0, 0.0, 0.0), 1.0, pole=-m, ntheta=60, nphi=120, # thetalim=(15, 165), philim=(0, 360)) # ls1 = viscid.xyz2lsrlp(earth1.get_points(), cotr=cotr, crd_system='gse')[0, :] # earth2 = viscid.seed.Sphere((0.0, 0.0, 0.0), 2.0, pole=-m, ntheta=60, nphi=120, # thetalim=(15, 165), philim=(0, 360)) # ls2 = viscid.xyz2lsrlp(earth2.get_points(), cotr=cotr, crd_system='gse')[0, :] # earth4 = viscid.seed.Sphere((0.0, 0.0, 0.0), 4.0, pole=-m, ntheta=60, nphi=120, # thetalim=(15, 165), philim=(0, 360)) # ls4 = viscid.xyz2lsrlp(earth4.get_points(), cotr=cotr, crd_system='gse')[0, :] # clim = [2.0, 6.0] # vlab.mesh_from_seeds(earth1, scalars=ls1, clim=clim, logscale=True) # vlab.mesh_from_seeds(earth2, scalars=ls2, clim=clim, logscale=True, opacity=0.5) # vlab.mesh_from_seeds(earth4, scalars=ls2, clim=clim, logscale=True, opacity=0.25) # vlab.plot3d_lines(e1_lines, scalars=[_e1_lsp[0, :] for _e1_lsp in e1_lsps], # clim=clim, logscale=True) # vlab.colorbar(title="L-Shell") # vlab.show() assert lshell_75[1] < lshell_75[0], "RK2 should have less error than Euler" assert lshell_75[2] < lshell_75[1], "RK4 should have less error than RK2" assert lshell_75[3] < lshell_75[0], "Euler 1a should have less error than Euler 1" assert lshell_75[4] < lshell_75[0], "RK 12 should have less error than Euler 1" assert lshell_75[5] < lshell_75[1], "RK 45 should have less error than RK2" try: if not plot2d: raise ImportError from viscid.plot import vpyplot as vlt from matplotlib import pyplot as plt # stats on error for all points on all lines _ = plt.figure(figsize=(15, 8)) ax1 = vlt.subplot(121) v = plt.violinplot(lshell_diffs, showextrema=False, showmedians=False, vert=False) colors = set_violin_colors(v) xl, xh = plt.gca().get_xlim() for i, txt, c in zip(count(), methods, colors): t_txt = ", took {0:.2e} seconds".format(wall_ts[i]) stat_txt = format_data_range(lshell_diffs[i]) plt.text(xl + 0.35 * (xh - xl), i + 1.15, txt + t_txt, color=c) plt.text(xl + 0.35 * (xh - xl), i + 0.85, stat_txt, color=c) ax1.get_yaxis().set_visible(False) plt.title('L-Shell') plt.xlabel('Relative Difference from Ideal (as fraction)') ax2 = vlt.subplot(122) v = plt.violinplot(phi_diffs, showextrema=False, showmedians=False, vert=False) colors = set_violin_colors(v) xl, xh = plt.gca().get_xlim() for i, txt, c in zip(count(), methods, colors): t_txt = ", took {0:.2e} seconds".format(wall_ts[i]) stat_txt = format_data_range(phi_diffs[i]) plt.text(xl + 0.35 * (xh - xl), i + 1.15, txt + t_txt, color=c) plt.text(xl + 0.35 * (xh - xl), i + 0.85, stat_txt, color=c) ax2.get_yaxis().set_visible(False) plt.title('Longitude') plt.xlabel('Relative Difference from Ideal (as fraction)') vlt.auto_adjust_subplots() vlt.savefig(next_plot_fname(__file__, series='q2')) if args.show: vlt.show() # stats for ds for all points on all lines _ = plt.figure(figsize=(10, 8)) ax1 = vlt.subplot(111) ds = [np.concatenate([np.linalg.norm(_l[:, 1:] - _l[:, :-1], axis=0) for _l in lines]) for lines in all_lines] v = plt.violinplot(ds, showextrema=False, showmedians=False, vert=False) colors = set_violin_colors(v) xl, xh = plt.gca().get_xlim() for i, txt, c in zip(count(), methods, colors): stat_txt = format_data_range(ds[i]) plt.annotate(txt, xy=(0.55, i / len(methods) + 0.1), color=c, xycoords='axes fraction') plt.annotate(stat_txt, xy=(0.55, i / len(methods) + 0.04), color=c, xycoords='axes fraction') ax1.get_yaxis().set_visible(False) plt.xscale('log') plt.title('Step Size') plt.xlabel('Absolute Step Size') vlt.savefig(next_plot_fname(__file__, series='q2')) if args.show: vlt.show() # random other information _ = plt.figure(figsize=(13, 10)) ## wall time for each method vlt.subplot(221) plt.scatter(range(len(methods)), wall_ts, color=colors, s=150, marker='s', edgecolors='none') for i, meth in enumerate(methods): meth = meth.replace(" Adaptive Step", "\nAdaptive Step") plt.annotate(meth, (i, wall_ts[i]), xytext=(0, 15.0), color=colors[i], horizontalalignment='center', verticalalignment='bottom', textcoords='offset points') plt.ylabel("Wall Time (s)") x_padding = 0.5 plt.xlim(-x_padding, len(methods) - x_padding) yl, yh = np.min(wall_ts), np.max(wall_ts) y_padding = 0.4 * (yh - yl) plt.ylim(yl - y_padding, yh + y_padding) plt.gca().get_xaxis().set_visible(False) for _which in ('right', 'top'): plt.gca().spines[_which].set_color('none') ## number of points calculated for each method vlt.subplot(222) plt.scatter(range(len(methods)), npts, color=colors, s=150, marker='s', edgecolors='none') for i, meth in enumerate(methods): meth = meth.replace(" Adaptive Step", "\nAdaptive Step") plt.annotate(meth, (i, npts[i]), xytext=(0, 15.0), color=colors[i], horizontalalignment='center', verticalalignment='bottom', textcoords='offset points') plt.ylabel("Number of Streamline Points Calculated") x_padding = 0.5 plt.xlim(-x_padding, len(methods) - x_padding) yl, yh = np.min(npts), np.max(npts) y_padding = 0.4 * (yh - yl) plt.ylim(yl - y_padding, yh + y_padding) plt.gca().get_xaxis().set_visible(False) for _which in ('right', 'top'): plt.gca().spines[_which].set_color('none') ## Wall time per segment, this should show the overhead of the method vlt.subplot(223) wall_t_per_seg = np.asarray(wall_ts) / np.asarray(npts) plt.scatter(range(len(methods)), wall_t_per_seg, color=colors, s=150, marker='s', edgecolors='none') for i, meth in enumerate(methods): meth = meth.replace(" Adaptive Step", "\nAdaptive Step") plt.annotate(meth, (i, wall_t_per_seg[i]), xytext=(0, 15.0), color=colors[i], horizontalalignment='center', verticalalignment='bottom', textcoords='offset points') plt.ylabel("Wall Time Per Line Segment") x_padding = 0.5 plt.xlim(-x_padding, len(methods) - x_padding) yl, yh = np.min(wall_t_per_seg), np.max(wall_t_per_seg) y_padding = 0.4 * (yh - yl) plt.ylim(yl - y_padding, yh + y_padding) plt.gca().get_xaxis().set_visible(False) plt.gca().xaxis.set_major_formatter(viscid.plot.mpl_extra.steve_axfmt) for _which in ('right', 'top'): plt.gca().spines[_which].set_color('none') ## 75th percentile of l-shell error for each method vlt.subplot(224) plt.scatter(range(len(methods)), lshell_75, color=colors, s=150, marker='s', edgecolors='none') plt.yscale('log') for i, meth in enumerate(methods): meth = meth.replace(" Adaptive Step", "\nAdaptive Step") plt.annotate(meth, (i, lshell_75[i]), xytext=(0, 15.0), color=colors[i], horizontalalignment='center', verticalalignment='bottom', textcoords='offset points') plt.ylabel("75th Percentile of Relative L-Shell Error") x_padding = 0.5 plt.xlim(-x_padding, len(methods) - x_padding) ymin, ymax = np.min(lshell_75), np.max(lshell_75) plt.ylim(0.75 * ymin, 2.5 * ymax) plt.gca().get_xaxis().set_visible(False) for _which in ('right', 'top'): plt.gca().spines[_which].set_color('none') vlt.auto_adjust_subplots(subplot_params=dict(wspace=0.25, hspace=0.15)) vlt.savefig(next_plot_fname(__file__, series='q2')) if args.show: vlt.show() except ImportError: pass try: if not plot3d: raise ImportError from viscid.plot import vlab try: fig = _global_ns['figure'] vlab.clf() except KeyError: fig = vlab.figure(size=[1200, 800], offscreen=not args.show, bgcolor=(1, 1, 1), fgcolor=(0, 0, 0)) _global_ns['figure'] = fig for i, method in zip(count(), methods): # if i in (3, 4): # next_plot_fname(__file__, series='q3') # print(i, "::", [line.shape[1] for line in all_lines[i]]) # # continue vlab.clf() _lshell_diff = [np.abs(s) for s in all_lshell_diffs[i]] vlab.plot3d_lines(all_lines[i], scalars=_lshell_diff) vlab.colorbar(title="Relative L-Shell Error (as fraction)") vlab.title(method, size=0.5) vlab.orientation_axes() vlab.view(azimuth=40, elevation=140, distance=80.0, focalpoint=[0, 0, 0]) vlab.savefig(next_plot_fname(__file__, series='q3')) if args.show: vlab.show() except ImportError: pass # prevent weird xorg bad-instructions on tear down if 'figure' in _global_ns and _global_ns['figure'] is not None: from viscid.plot import vlab vlab.mlab.close(_global_ns['figure']) return 0
def _main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--prof", action="store_true") parser.add_argument("--show", "--plot", action="store_true") args = vutil.common_argparse(parser) b = viscid.make_dipole(l=(-5, -5, -5), h=(5, 5, 5), n=(255, 255, 127), m=(0, 0, -1)) b2 = np.sum(b * b, axis=b.nr_comp) if args.prof: print("Without boundaries") viscid.timeit(viscid.grad, b2, bnd=False, timeit_repeat=10, timeit_print_stats=True) print("With boundaries") viscid.timeit(viscid.grad, b2, bnd=True, timeit_repeat=10, timeit_print_stats=True) grad_b2 = viscid.grad(b2) grad_b2.pretty_name = r"$\nabla$ B$^2$" conv = viscid.convective_deriv(b) conv.pretty_name = r"(B $\cdot \nabla$) B" _ = plt.figure(figsize=(9, 4.2)) ax1 = vlt.subplot(231) vlt.plot(b2['z=0j'], logscale=True) vlt.plot(b2['z=0j'], logscale=True, style='contour', levels=10, colors='grey') # vlt.plot2d_quiver(viscid.normalize(b['z=0j']), step=16, pivot='mid') ax2 = vlt.subplot(234) vlt.plot(b2['y=0j'], logscale=True) vlt.plot(b2['y=0j'], logscale=True, style='contour', levels=10, colors='grey') vlt.plot2d_quiver(viscid.normalize(b['y=0j'], preferred='numpy'), step=16, pivot='mid') vlt.subplot(232, sharex=ax1, sharey=ax1) vlt.plot(1e-4 + viscid.magnitude(grad_b2['z=0j']), logscale=True) vlt.plot(1e-4 + viscid.magnitude(grad_b2['z=0j']), logscale=True, style='contour', levels=10, colors='grey') vlt.plot2d_quiver(viscid.normalize(grad_b2['z=0j']), step=16, pivot='mid') vlt.subplot(235, sharex=ax2, sharey=ax2) vlt.plot(1e-4 + viscid.magnitude(grad_b2['y=0j']), logscale=True) vlt.plot(1e-4 + viscid.magnitude(grad_b2['y=0j']), logscale=True, style='contour', levels=10, colors='grey') vlt.plot2d_quiver(viscid.normalize(grad_b2['y=0j']), step=16, pivot='mid') vlt.subplot(233, sharex=ax1, sharey=ax1) vlt.plot(viscid.magnitude(conv['z=0j']), logscale=True) vlt.plot(viscid.magnitude(conv['z=0j']), logscale=True, style='contour', levels=10, colors='grey') vlt.plot2d_quiver(viscid.normalize(conv['z=0j']), step=16, pivot='mid') vlt.subplot(236, sharex=ax2, sharey=ax2) vlt.plot(viscid.magnitude(conv['y=0j']), logscale=True) vlt.plot(viscid.magnitude(conv['y=0j']), logscale=True, style='contour', levels=10, colors='grey') vlt.plot2d_quiver(viscid.normalize(conv['y=0j']), step=16, pivot='mid') vlt.auto_adjust_subplots() plt.savefig(next_plot_fname(__file__)) if args.show: vlt.show() return 0