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 do_test(lines, scalars, show=False, txt=""):
viscid.logger.info('--> ' + txt)
title = txt + '\n' + "\n".join(
textwrap.wrap("scalars = {0}".format(scalars), width=50))
try:
from viscid.plot import vpyplot as vlt
from matplotlib import pyplot as plt
vlt.clf()
vlt.plot_lines(lines, scalars=scalars)
plt.title(title)
vlt.savefig(next_plot_fname(__file__, series='q2'))
if show:
vlt.show()
except ImportError:
pass
try:
from mayavi import mlab
vlab, _ = get_mvi_fig()
vlab.clf()
vlab.plot_lines3d(lines, scalars=scalars)
vlab.fancy_axes()
mlab.text(0.05, 0.05, title)
vlab.savefig(next_plot_fname(__file__, series='q3'))
if show:
vlab.show(stop=True)
except ImportError:
pass
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 do_test(lines, scalars, show=False, txt=""):
viscid.logger.info('--> ' + txt)
title = txt + '\n' + "\n".join(textwrap.wrap("scalars = {0}".format(scalars),
width=50))
try:
from matplotlib import pyplot as plt
from viscid.plot import vpyplot as vlt
vlt.clf()
vlt.plot_lines(lines, scalars=scalars)
plt.title(title)
vlt.savefig(next_plot_fname(__file__, series='q2'))
if show:
vlt.show()
except ImportError:
pass
try:
from mayavi import mlab
from viscid.plot import vlab
try:
fig = _global_ns['figure']
vlab.clf()
except KeyError:
fig = vlab.figure(size=[1200, 800], offscreen=not show,
bgcolor=(1, 1, 1), fgcolor=(0, 0, 0))
_global_ns['figure'] = fig
vlab.clf()
vlab.plot_lines3d(lines, scalars=scalars)
vlab.fancy_axes()
mlab.text(0.05, 0.05, title)
vlab.savefig(next_plot_fname(__file__, series='q3'))
if show:
vlab.show(stop=True)
except ImportError:
pass
def do_test(lines, scalars, show=False, txt=""):
viscid.logger.info('--> ' + txt)
title = txt + '\n' + "\n".join(textwrap.wrap("scalars = {0}".format(scalars),
width=50))
try:
from viscid.plot import vpyplot as vlt
from matplotlib import pyplot as plt
vlt.clf()
vlt.plot_lines(lines, scalars=scalars)
plt.title(title)
vlt.savefig(next_plot_fname(__file__, series='q2'))
if show:
vlt.show()
except ImportError:
pass
try:
from mayavi import mlab
from viscid.plot import vlab
try:
fig = _global_ns['figure']
vlab.clf()
except KeyError:
fig = vlab.figure(size=[1200, 800], offscreen=not show,
bgcolor=(1, 1, 1), fgcolor=(0, 0, 0))
_global_ns['figure'] = fig
vlab.clf()
vlab.plot_lines3d(lines, scalars=scalars)
vlab.fancy_axes()
mlab.text(0.05, 0.05, title)
vlab.savefig(next_plot_fname(__file__, series='q3'))
if show:
vlab.show(stop=True)
except ImportError:
pass
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 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
import seaborn as sns
import viscid
from viscid.plot import vpyplot as vlt
import matplotlib.pyplot as plt
f = viscid.load_file('./otico_001.3d.xdmf')
mymap = sns.diverging_palette(28, 240, s=95, l=50, as_cmap=True)
figure = plt.figure(figsize=(14, 10))
g = f.get_grid(time=12)
vlt.plot(g['bx']['z=0'], cmap=mymap, style='contourf', levels=256)
vlt.savefig('OT_bx.png')
plt.show()
def _main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--show", "--plot", action="store_true")
args = vutil.common_argparse(parser)
b, e = make_arcade(8.0, N=[64, 64, 64])
epar = viscid.project(e, b)
epar.pretty_name = "E parallel"
###############
# Calculate Xi
seeds = viscid.Volume(xl=[-10, 0.0, -10], xh=[10, 0.0, 10], n=[64, 1, 64])
b_lines, _ = viscid.calc_streamlines(b, seeds)
xi_dat = viscid.integrate_along_lines(b_lines, e, reduction='dot')
xi = seeds.wrap_field(xi_dat, name='xi', pretty_name=r"$\Xi$")
################################
# Make 2D Matplotlib plot of Xi
vlt.plot(xi,
x=(-10, 10),
y=(-10, 10),
style='contourf',
levels=256,
lin=(2e-4, 1.5718))
vlt.plot(xi,
x=(-10, 10),
y=(-10, 10),
style='contour',
colors='grey',
levels=[0.5, 1.0])
vlt.savefig(next_plot_fname(__file__))
if args.show:
vlt.show()
############################################################
# Make 3D mayavi plot of Xi and the 'brightest' field lines
# as well as some other field lines for context
try:
from viscid.plot import vlab
except ImportError:
xfail("Mayavi not installed")
vlab.figure(size=[1200, 800], offscreen=not args.show)
inds = np.argsort(xi_dat)[-64:]
inds = np.concatenate([inds, np.arange(len(xi_dat))[::71]])
s = vlab.plot_lines(b_lines[inds], scalars=epar, cmap='viridis')
vlab.mesh_from_seeds(seeds, scalars=xi, cmap='inferno')
vlab.colorbar(s, orientation='horizontal', title=epar.pretty_name)
# vlab.streamline(b, scalars=e, seedtype='sphere', seed_resolution=4,
# integration_direction='both')
oa = vlab.orientation_axes()
oa.marker.set_viewport(0.75, 0.75, 1.0, 1.0)
vlab.view(roll=0,
azimuth=90,
elevation=25,
distance=30.0,
focalpoint=[0, 2, 0])
vlab.savefig(next_plot_fname(__file__))
if args.show:
vlab.show()
try:
vlab.mlab.close()
except AttributeError:
pass
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
