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 _main(): x = np.linspace(-1, 1, 128) y = z = np.linspace(-0.25, 0.25, 8) B = viscid.zeros((x, y, z), nr_comps=3, layout='interlaced', name="B") X, Y, Z = B.get_crds("xyz", shaped=True) # pylint: disable=unused-variable xl, yl, zl = B.xl # pylint: disable=unused-variable xh, yh, zh = B.xh # pylint: disable=unused-variable xm, ym, zm = 0.5 * (B.xl + B.xh) # pylint: disable=unused-variable B['x'] = 0.0 # np.sin(1.0 * np.pi * X / (xh - xl) + 0.5 * np.pi) B['y'] = np.sin(1.0 * np.pi * X / (xh - xl) + 0.5 * np.pi) B['z'] = np.sin(1.0 * np.pi * X / (xh - xl) - 1.0 * np.pi) B += 0.33 * np.random.random_sample(B.shape) # R = viscid.a2b_rotm((1, 0, 0), (1, 0, 1)) # B[...] = np.einsum("ij,lmnj->lmni", R, B) lmn = find_minvar_lmn(B, (xl, ym, zm), (xh, ym, zm), l_basis=None) # lmn = find_minvar_lmn(B, (xl, ym, zm), (xh, ym, zm), l_basis=(0, 0, 1)) print("LMN matrix:\n", lmn, sep='') ########## from viscid.plot import vpyplot as vlt from matplotlib import pyplot as plt p0 = np.array((xm, ym, zm)).reshape((3, )) pl = p0 + 0.25 * lmn[:, 0] pm = p0 + 0.25 * lmn[:, 1] pn = p0 + 0.25 * lmn[:, 2] print("p0", p0) print("pl", pl) print("pm", pm) print("pn", pn) vlt.subplot(211) vlt.plot2d_quiver(B['z=0j']) plt.plot([p0[0], pl[0]], [p0[1], pl[1]], color='r', ls='-') plt.plot([p0[0], pm[0]], [p0[1], pm[1]], color='c', ls='-') plt.plot([p0[0], pn[0]], [p0[1], pn[1]], color='b', ls='-') plt.ylabel("Y") vlt.subplot(212) vlt.plot2d_quiver(B['y=0j']) plt.plot([p0[0], pl[0]], [p0[2], pl[2]], color='r', ls='-') plt.plot([p0[0], pm[0]], [p0[2], pm[2]], color='c', ls='-') plt.plot([p0[0], pn[0]], [p0[2], pn[2]], color='b', ls='-') plt.xlabel("X") plt.ylabel("Z") vlt.show() ########## return 0
def _main(): x = np.linspace(-1, 1, 128) y = z = np.linspace(-0.25, 0.25, 8) B = viscid.zeros((x, y, z), nr_comps=3, layout='interlaced', name="B") X, Y, Z = B.get_crds("xyz", shaped=True) # pylint: disable=unused-variable xl, yl, zl = B.xl # pylint: disable=unused-variable xh, yh, zh = B.xh # pylint: disable=unused-variable xm, ym, zm = 0.5 * (B.xl + B.xh) # pylint: disable=unused-variable B['x'] = 0.0 # np.sin(1.0 * np.pi * X / (xh - xl) + 0.5 * np.pi) B['y'] = np.sin(1.0 * np.pi * X / (xh - xl) + 0.5 * np.pi) B['z'] = np.sin(1.0 * np.pi * X / (xh - xl) - 1.0 * np.pi) B += 0.33 * np.random.random_sample(B.shape) # R = viscid.a2b_rotm((1, 0, 0), (1, 0, 1)) # B[...] = np.einsum("ij,lmnj->lmni", R, B) lmn = find_minvar_lmn(B, (xl, ym, zm), (xh, ym, zm), l_basis=None) # lmn = find_minvar_lmn(B, (xl, ym, zm), (xh, ym, zm), l_basis=(0, 0, 1)) print("LMN matrix:\n", lmn, sep='') ########## from viscid.plot import vpyplot as vlt from matplotlib import pyplot as plt p0 = np.array((xm, ym, zm)).reshape((3,)) pl = p0 + 0.25 * lmn[:, 0] pm = p0 + 0.25 * lmn[:, 1] pn = p0 + 0.25 * lmn[:, 2] print("p0", p0) print("pl", pl) print("pm", pm) print("pn", pn) vlt.subplot(211) vlt.plot2d_quiver(B['z=0j']) plt.plot([p0[0], pl[0]], [p0[1], pl[1]], color='r', ls='-') plt.plot([p0[0], pm[0]], [p0[1], pm[1]], color='c', ls='-') plt.plot([p0[0], pn[0]], [p0[1], pn[1]], color='b', ls='-') plt.ylabel("Y") vlt.subplot(212) vlt.plot2d_quiver(B['y=0j']) plt.plot([p0[0], pl[0]], [p0[2], pl[2]], color='r', ls='-') plt.plot([p0[0], pm[0]], [p0[2], pm[2]], color='c', ls='-') plt.plot([p0[0], pn[0]], [p0[2], pn[2]], color='b', ls='-') plt.xlabel("X") plt.ylabel("Z") vlt.show() ########## return 0
def main(): f = viscid.load_file("~/dev/work/tmedium/*.3d.[-1].xdmf") grid = f.get_grid() gslc = "x=-26j:12.5j, y=-15j:15j, z=-15j:15j" # gslc = "x=-12.5j:26j, y=-15j:15j, z=-15j:15j" b_cc = f['b_cc'][gslc] b_cc.name = "b_cc" b_fc = f['b_fc'][gslc] b_fc.name = "b_fc" e_cc = f['e_cc'][gslc] e_cc.name = "e_cc" e_ec = f['e_ec'][gslc] e_ec.name = "e_ec" pp = f['pp'][gslc] pp.name = 'pp' pargs = dict(logscale=True, earth=True) # vlt.clf() # ax1 = vlt.subplot(211) # vlt.plot(f['pp']['y=0j'], **pargs) # # vlt.plot(viscid.magnitude(f['b_cc']['y=0j']), **pargs) # # vlt.show() # vlt.subplot(212, sharex=ax1, sharey=ax1) # vlt.plot(viscid.magnitude(viscid.fc2cc(f['b_fc'])['y=0j']), **pargs) # vlt.show() basename = './tmediumR.3d.{0:06d}'.format(int(grid.time)) viscid.save_fields(basename + '.h5', [b_cc, b_fc, e_cc, e_ec, pp]) f2 = viscid.load_file(basename + ".xdmf") pargs = dict(logscale=True, earth=True) vlt.clf() ax1 = vlt.subplot(211) vlt.plot(f2['pp']['y=0j'], style='contour', levels=5, colorbar=None, colors='k', **pargs) vlt.plot(viscid.magnitude(f2['b_cc']['y=0j']), **pargs) vlt.subplot(212, sharex=ax1, sharey=ax1) vlt.plot(viscid.magnitude(viscid.fc2cc(f2['b_fc'])['y=0j']), **pargs) vlt.show() os.remove(basename + '.h5') os.remove(basename + '.xdmf') return 0
def main(): f = viscid.load_file("~/dev/work/tmedium/*.3d.[-1].xdmf") grid = f.get_grid() gslc = "x=-26f:12.5f, y=-15f:15f, z=-15f:15f" # gslc = "x=-12.5f:26f, y=-15f:15f, z=-15f:15f" b_cc = f['b_cc'][gslc] b_cc.name = "b_cc" b_fc = f['b_fc'][gslc] b_fc.name = "b_fc" e_cc = f['e_cc'][gslc] e_cc.name = "e_cc" e_ec = f['e_ec'][gslc] e_ec.name = "e_ec" pp = f['pp'][gslc] pp.name = 'pp' pargs = dict(logscale=True, earth=True) # vlt.clf() # ax1 = vlt.subplot(211) # vlt.plot(f['pp']['y=0f'], **pargs) # # vlt.plot(viscid.magnitude(f['b_cc']['y=0f']), **pargs) # # vlt.show() # vlt.subplot(212, sharex=ax1, sharey=ax1) # vlt.plot(viscid.magnitude(viscid.fc2cc(f['b_fc'])['y=0f']), **pargs) # vlt.show() basename = './tmediumR.3d.{0:06d}'.format(int(grid.time)) viscid.save_fields(basename + '.h5', [b_cc, b_fc, e_cc, e_ec, pp]) f2 = viscid.load_file(basename + ".xdmf") pargs = dict(logscale=True, earth=True) vlt.clf() ax1 = vlt.subplot(211) vlt.plot(f2['pp']['y=0f'], style='contour', levels=5, colorbar=None, colors='k', **pargs) vlt.plot(viscid.magnitude(f2['b_cc']['y=0f']), **pargs) vlt.subplot(212, sharex=ax1, sharey=ax1) vlt.plot(viscid.magnitude(viscid.fc2cc(f2['b_fc'])['y=0f']), **pargs) vlt.show() os.remove(basename + '.h5') os.remove(basename + '.xdmf') return 0
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 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 _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_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 _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("--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 _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 topology_bitor_clusters(fld, min_depth=1, max_depth=10, multiple=True, plot=False, sep_val=streamline.TOPOLOGY_MS_SEPARATOR, mask_limit=0b1111, periodic="00", pt_bnds=()): """Find separator as intersection of all global topologies Neighbors are bitwise ORed until at least one value matches `sep_val` which is presumably (Close | Open N | Open S | SW). This happens between min_depth and max_depth times, where the resolution of each iteration is reduced by a factor of two, ie, worst case 2**(max_depth). Args: fld (Field): Topology (bitmask) as a field min_depth (int): Iterate at least this many times max_depth (int): Iterate at most this many times multiple (bool): passed to :py:func:`viscid.cluster` sep_val (int): Value of bitmask that indicates a separator plot (bool): Make a 2D plot of Fld and the sep candidates mask_limit (int): if > 0, then bitmask fld with mask_limit, i.e., fld = fld & mask_limit (bitwise and) periodic (sequence): indicate whether that direction is periodic, and if so, whether the coordinate arrays are overlapped or not. Values can be True, False, or '+'. '+' indicates that x[0] and x[-1] are not colocated, so assume they're dx apart where dx = x[-1] - x[-2]. pt_bnd (sequence): Boundaries that come to a point, i.e., all values along that boundary are neighbors such as the poles of a sphere. Specified like "0-" for lower boundary of dimension 0 or "1+" for the upper boundary of dimension 1. Returns: ndarray: 2xN for N clusters of separator points in the same coordinates as `fld` """ pd = [False if pi == "0" else bool(pi) for pi in periodic] fld = fld.slice_reduce(":") if mask_limit: fld = np.bitwise_and(fld, mask_limit) a = fld.data x, y = fld.get_crds() for i in range(max_depth): if pd[0]: a[(0, -1), :] |= a[(-1, 0), :] if pd[1]: a[:, (0, -1)] |= a[:, (-1, 0)] a = ( a[:-1, :-1] | a[:-1, 1:] | # pylint: disable=bad-whitespace a[1:, :-1] | a[1:, 1:]) # pylint: disable=bad-whitespace x = 0.5 * (x[1:] + x[:-1]) y = 0.5 * (y[1:] + y[:-1]) # bitwise_or an entire bounary if all points are neighbors, like # at the poles of a sphere for bnd in pt_bnds: slc = [slice(None), slice(None)] slc[int(bnd[0])] = -1 if bnd[1] == "+" else 0 a[slc] = np.bitwise_or.reduce(a[slc]) indx, indy = np.where(a == sep_val) if i + 1 >= min_depth and len(indx): break pts = viscid.cluster(indx, indy, x, y, multiple=multiple, periodic=periodic) if plot: from matplotlib import pyplot as plt from viscid.plot import vpyplot as vlt vlt.clf() ax0 = vlt.subplot(121) vlt.plot(fld, title=True) vlt.subplot(122, sharex=ax0, sharey=ax0) or_fld = viscid.arrays2field((x, y), a, name="OR") vlt.plot(or_fld, title=True) _x, _y = or_fld.get_crds() plt.plot(_x[indx], _y[indy], 'ko') plt.plot(pts[0], pts[1], 'y^') plt.show() return pts
def main(): mhd_type = "C3" make_plots = 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 = 2e-6 elif mhd_type in ("F", "FORTRAN"): f = viscid.load_file("$WORK/tmedium3/*.3df.[-1]") catol = 1e-8 rtol = 7e-2 else: raise ValueError() b = f['b_cc'] b1 = f['b_fc'] e_cc = f['e_cc'] e_ec = f['e_ec'] # divb = f['divB'] # viscid.interact() if True: bD = viscid.empty_like(b) bD.data = np.array(b.data) b1D = viscid.empty_like(b1) b1D.data = np.array(b1.data) mask5 = viscid.make_spherical_mask(bD, rmax=3.5) mask1_5 = viscid.make_spherical_mask(bD, rmax=1.5) viscid.fill_dipole(bD, mask=mask5) viscid.set_in_region(bD, bD, 0.0, 0.0, mask=mask1_5, out=bD) # compare_vectors(_b, bD, make_plots=True) mask5 = viscid.make_spherical_mask(b1D, rmax=3.5) mask1_5 = viscid.make_spherical_mask(b1D, rmax=1.5) viscid.fill_dipole(b1D, mask=mask5) viscid.set_in_region(b1D, b1D, 0.0, 0.0, mask=mask1_5, out=b1D) compare_vectors(bD["x=1:-1, y=1:-1, z=1:-1"], b1D.as_cell_centered(), make_plots=True) # plt.clf() # dkwargs = dict(symmetric=True, earth=True, clim=(-1e2, 1e2)) # ax1 = plt.subplot(311) # vlt.plot(viscid.div(b1)['y=0j'], **dkwargs) # plt.subplot(312, sharex=ax1, sharey=ax1) # vlt.plot(viscid.div(b)['y=0j'], **dkwargs) # plt.subplot(313, sharex=ax1, sharey=ax1) # vlt.plot(viscid.div(b1D)['y=0j'], **dkwargs) # vlt.show() bD = b1D = mask5 = mask1_5 = None # straight up interpolate b1 to cc crds and compare with b if True: b1_cc = viscid.interp_trilin(b1, b).as_flat() viscid.set_in_region(b, b, alpha=0.0, beta=0.0, out=b, mask=viscid.make_spherical_mask(b, rmax=5.0)) viscid.set_in_region(b1_cc, b1_cc, alpha=0.0, beta=0.0, out=b1_cc, mask=viscid.make_spherical_mask(b1_cc, rmax=5.0)) compare_vectors(b, b1_cc, make_plots=True) # make div? if True: # make seeds for 1.5x supersampling b1 n = 128 seeds = viscid.Volume((5.1, -0.02, -5.0), (12.0, 0.02, 5.0), (n, 3, n)) # do interpolation onto new seeds b2 = viscid.interp_trilin(b1, seeds) div_b = viscid.div(b) div_b1 = viscid.div(b1) div_b2 = viscid.div(b2) viscid.set_in_region(div_b, div_b, alpha=0.0, beta=0.0, out=div_b, mask=viscid.make_spherical_mask(div_b, rmax=5.0)) viscid.set_in_region(div_b1, div_b1, alpha=0.0, beta=0.0, out=div_b1, mask=viscid.make_spherical_mask(div_b1, rmax=5.0)) viscid.set_in_region(div_b2, div_b2, alpha=0.0, beta=0.0, out=div_b2, mask=viscid.make_spherical_mask(div_b2, rmax=5.0)) viscid.set_in_region(divb, divb, alpha=0.0, beta=0.0, out=divb, mask=viscid.make_spherical_mask(divb, rmax=5.0)) plt.clf() ax1 = vlt.subplot(311) vlt.plot(div_b['y=0j'], symmetric=True, earth=True) vlt.subplot(312, sharex=ax1, sharey=ax1) # vlt.plot(div_b1['y=0j'], symmetric=True, earth=True) vlt.plot(div_b2['y=0j'], symmetric=True, earth=True) vlt.subplot(313, sharex=ax1, sharey=ax1) vlt.plot(divb['y=0j'], symmetric=True, earth=True) vlt.show() return 0
def main(): mhd_type = "C3" make_plots = 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 = 2e-6 elif mhd_type in ("F", "FORTRAN"): f = viscid.load_file("$WORK/tmedium3/*.3df.[-1]") catol = 1e-8 rtol = 7e-2 else: raise ValueError() b = f['b_cc'] b1 = f['b_fc'] e_cc = f['e_cc'] e_ec = f['e_ec'] # divb = f['divB'] # viscid.interact() if True: bD = viscid.empty_like(b) bD.data = np.array(b.data) b1D = viscid.empty_like(b1) b1D.data = np.array(b1.data) mask5 = viscid.make_spherical_mask(bD, rmax=3.5) mask1_5 = viscid.make_spherical_mask(bD, rmax=1.5) viscid.fill_dipole(bD, mask=mask5) viscid.set_in_region(bD, bD, 0.0, 0.0, mask=mask1_5, out=bD) # compare_vectors(_b, bD, make_plots=True) mask5 = viscid.make_spherical_mask(b1D, rmax=3.5) mask1_5 = viscid.make_spherical_mask(b1D, rmax=1.5) viscid.fill_dipole(b1D, mask=mask5) viscid.set_in_region(b1D, b1D, 0.0, 0.0, mask=mask1_5, out=b1D) compare_vectors(bD["x=1:-1, y=1:-1, z=1:-1"], b1D.as_cell_centered(), make_plots=True) # plt.clf() # dkwargs = dict(symmetric=True, earth=True, clim=(-1e2, 1e2)) # ax1 = plt.subplot(311) # vlt.plot(viscid.div(b1)['y=0j'], **dkwargs) # plt.subplot(312, sharex=ax1, sharey=ax1) # vlt.plot(viscid.div(b)['y=0j'], **dkwargs) # plt.subplot(313, sharex=ax1, sharey=ax1) # vlt.plot(viscid.div(b1D)['y=0j'], **dkwargs) # vlt.show() bD = b1D = mask5 = mask1_5 = None # straight up interpolate b1 to cc crds and compare with b if True: b1_cc = viscid.interp_trilin(b1, b).as_flat() viscid.set_in_region(b, b, alpha=0.0, beta=0.0, out=b, mask=viscid.make_spherical_mask(b, rmax=5.0)) viscid.set_in_region(b1_cc, b1_cc, alpha=0.0, beta=0.0, out=b1_cc, mask=viscid.make_spherical_mask(b1_cc, rmax=5.0)) compare_vectors(b, b1_cc, make_plots=True) # make div? if True: # make seeds for 1.5x supersampling b1 n = 128 seeds = viscid.Volume((5.1, -0.02, -5.0), (12.0, 0.02, 5.0), (n, 3, n)) # do interpolation onto new seeds b2 = viscid.interp_trilin(b1, seeds) div_b = viscid.div(b) div_b1 = viscid.div(b1) div_b2 = viscid.div(b2) viscid.set_in_region(div_b, div_b, alpha=0.0, beta=0.0, out=div_b, mask=viscid.make_spherical_mask(div_b, rmax=5.0)) viscid.set_in_region(div_b1, div_b1, alpha=0.0, beta=0.0, out=div_b1, mask=viscid.make_spherical_mask(div_b1, rmax=5.0)) viscid.set_in_region(div_b2, div_b2, alpha=0.0, beta=0.0, out=div_b2, mask=viscid.make_spherical_mask(div_b2, rmax=5.0)) viscid.set_in_region(divb, divb, alpha=0.0, beta=0.0, out=divb, mask=viscid.make_spherical_mask(divb, rmax=5.0)) plt.clf() ax1 = vlt.subplot(311) vlt.plot(div_b['y=0j'], symmetric=True, earth=True) vlt.subplot(312, sharex=ax1, sharey=ax1) # vlt.plot(div_b1['y=0j'], symmetric=True, earth=True) vlt.plot(div_b2['y=0j'], symmetric=True, earth=True) vlt.subplot(313, sharex=ax1, sharey=ax1) vlt.plot(divb['y=0j'], symmetric=True, earth=True) vlt.show() 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
def main(): mhd_type = "C" make_plots = 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 = 2e-6 elif mhd_type in ("F", "FORTRAN"): f = viscid.load_file("$WORK/tmedium3/*.3df.[-1]") catol = 1e-8 rtol = 7e-2 else: raise ValueError() do_fill_dipole = True gslc = "x=-21.2j:12j, y=-11j:11j, z=-11j:11j" b = f['b_cc'][gslc] b1 = f['b_fc'][gslc] e_cc = f['e_cc'][gslc] e_ec = f['e_ec'][gslc] if do_fill_dipole: mask = viscid.make_spherical_mask(b, rmax=3.5) viscid.fill_dipole(b, mask=mask) mask = viscid.make_spherical_mask(b1, rmax=3.5) viscid.fill_dipole(b1, mask=mask) mask = None # seeds = viscid.SphericalCap(r=1.02, ntheta=64, nphi=32, angle0=17, angle=20, # philim=(100, 260), roll=-180.0) # seeds = viscid.SphericalCap(r=1.02, ntheta=64, nphi=32, angle0=17, angle=20, # philim=(0, 10), roll=0.0) seedsN = viscid.Sphere(r=1.02, ntheta=16, nphi=16, thetalim=(15, 25), philim=(0, 300), crd_system=b) seedsS = viscid.Sphere(r=1.02, ntheta=16, nphi=16, thetalim=(155, 165), philim=(0, 300), crd_system=b) bl_kwargs = dict(ibound=0.9, obound0=(-20, -10, -10), obound1=(11, 10, 10)) # blines_cc, topo_cc = viscid.streamlines(b, seeds, **bl_kwargs) blinesN_fc, topoN_fc = viscid.streamlines(b1, seedsN, **bl_kwargs) _, topoS_fc = viscid.streamlines(b1, seedsS, output=viscid.OUTPUT_TOPOLOGY, **bl_kwargs) if True: from viscid.plot import vlab mesh = vlab.mesh_from_seeds(seedsN, scalars=topoN_fc) mesh.actor.property.backface_culling = True # vlab.plot_lines(blines_cc, scalars="#000000", tube_radius=0.03) vlab.plot_lines(blinesN_fc, scalars=viscid.topology2color(topoN_fc), opacity=0.7) vlab.plot_blue_marble(r=1.0) vlab.plot_earth_3d(radius=1.01, crd_system=b, night_only=True, opacity=0.5) vlab.show() if True: vlt.subplot(121, projection='polar') vlt.plot(topoN_fc) vlt.subplot(122, projection='polar') vlt.plot(topoS_fc) vlt.show() return 0
def topology_bitor_clusters(fld, min_depth=1, max_depth=10, multiple=True, plot=False, sep_val=streamline.TOPOLOGY_MS_SEPARATOR, mask_limit=0b1111, periodic="00", pt_bnds=()): """Find separator as intersection of all global topologies Neighbors are bitwise ORed until at least one value matches `sep_val` which is presumably (Close | Open N | Open S | SW). This happens between min_depth and max_depth times, where the resolution of each iteration is reduced by a factor of two, ie, worst case 2**(max_depth). Args: fld (Field): Topology (bitmask) as a field min_depth (int): Iterate at least this many times max_depth (int): Iterate at most this many times multiple (bool): passed to :py:func:`viscid.cluster` sep_val (int): Value of bitmask that indicates a separator plot (bool): Make a 2D plot of Fld and the sep candidates mask_limit (int): if > 0, then bitmask fld with mask_limit, i.e., fld = fld & mask_limit (bitwise and) periodic (sequence): indicate whether that direction is periodic, and if so, whether the coordinate arrays are overlapped or not. Values can be True, False, or '+'. '+' indicates that x[0] and x[-1] are not colocated, so assume they're dx apart where dx = x[-1] - x[-2]. pt_bnd (sequence): Boundaries that come to a point, i.e., all values along that boundary are neighbors such as the poles of a sphere. Specified like "0-" for lower boundary of dimension 0 or "1+" for the upper boundary of dimension 1. Returns: ndarray: 2xN for N clusters of separator points in the same coordinates as `fld` """ pd = [False if pi == "0" else bool(pi) for pi in periodic] fld = fld.slice_reduce(":") if mask_limit: fld = np.bitwise_and(fld, mask_limit) a = fld.data x, y = fld.get_crds() for i in range(max_depth): if pd[0]: a[(0, -1), :] |= a[(-1, 0), :] if pd[1]: a[:, (0, -1)] |= a[:, (-1, 0)] a = (a[ :-1, :-1] | a[ :-1, 1: ] | # pylint: disable=bad-whitespace a[1: , :-1] | a[1: , 1: ]) # pylint: disable=bad-whitespace x = 0.5 * (x[1:] + x[:-1]) y = 0.5 * (y[1:] + y[:-1]) # bitwise_or an entire bounary if all points are neighbors, like # at the poles of a sphere for bnd in pt_bnds: slc = (slice(None), slice(None)) slc[int(bnd[0])] = -1 if bnd[1] == "+" else 0 a[slc] = np.bitwise_or.reduce(a[slc]) indx, indy = np.where(a == sep_val) if i + 1 >= min_depth and len(indx): break pts = viscid.find_clusters(indx, indy, x, y, multiple=multiple, periodic=periodic) if plot: from viscid.plot import vpyplot as vlt from matplotlib import pyplot as plt vlt.clf() ax0 = vlt.subplot(121) vlt.plot(fld, title=True) vlt.subplot(122, sharex=ax0, sharey=ax0) or_fld = viscid.arrays2field((x, y), a, name="OR") vlt.plot(or_fld, title=True) _x, _y = or_fld.get_crds() plt.plot(_x[indx], _y[indy], 'ko') plt.plot(pts[0], pts[1], 'y^') plt.show() return pts
def main(): mhd_type = "C" make_plots = 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 = 2e-6 elif mhd_type in ("F", "FORTRAN"): f = viscid.load_file("$WORK/tmedium3/*.3df.[-1]") catol = 1e-8 rtol = 7e-2 else: raise ValueError() do_fill_dipole = True gslc = "x=-21.2j:12j, y=-11j:11j, z=-11j:11j" b = f['b_cc'][gslc] b1 = f['b_fc'][gslc] e_cc = f['e_cc'][gslc] e_ec = f['e_ec'][gslc] if do_fill_dipole: mask = viscid.make_spherical_mask(b, rmax=3.5) viscid.fill_dipole(b, mask=mask) mask = viscid.make_spherical_mask(b1, rmax=3.5) viscid.fill_dipole(b1, mask=mask) mask = None # seeds = viscid.SphericalCap(r=1.02, ntheta=64, nphi=32, angle0=17, angle=20, # philim=(100, 260), roll=-180.0) # seeds = viscid.SphericalCap(r=1.02, ntheta=64, nphi=32, angle0=17, angle=20, # philim=(0, 10), roll=0.0) seedsN = viscid.Sphere(r=1.02, ntheta=16, nphi=16, thetalim=(15, 25), philim=(0, 300), crd_system=b) seedsS = viscid.Sphere(r=1.02, ntheta=16, nphi=16, thetalim=(155, 165), philim=(0, 300), crd_system=b) bl_kwargs = dict(ibound=0.9, obound0=(-20, -10, -10), obound1=(11, 10, 10)) # blines_cc, topo_cc = viscid.streamlines(b, seeds, **bl_kwargs) blinesN_fc, topoN_fc = viscid.streamlines(b1, seedsN, **bl_kwargs) _, topoS_fc = viscid.streamlines(b1, seedsS, output=viscid.OUTPUT_TOPOLOGY, **bl_kwargs) if True: from viscid.plot import vlab mesh = vlab.mesh_from_seeds(seedsN, scalars=topoN_fc) mesh.actor.property.backface_culling = True # vlab.plot_lines(blines_cc, scalars="#000000", tube_radius=0.03) vlab.plot_lines(blinesN_fc, scalars=viscid.topology2color(topoN_fc), opacity=0.7) vlab.plot_blue_marble(r=1.0) vlab.plot_earth_3d(radius=1.01, crd_system=b, night_only=True, opacity=0.5) vlab.show() if True: vlt.subplot(121, projection='polar') vlt.plot(topoN_fc) vlt.subplot(122, projection='polar') vlt.plot(topoS_fc) vlt.show() return 0