def compare_vectors(cc_fld, ecfc_fld, to_cc_fn, catol=1e-8, rtol=2.2e-6,
trim_slc='x=1:-1, y=1:-1, z=1:-1', make_plots=False):
trimmed = cc_fld[trim_slc]
cc = to_cc_fn(ecfc_fld)
reldiff = (cc - trimmed) / viscid.magnitude(trimmed)
reldiff = reldiff["x=1:-1, y=1:-1, z=1:-1"]
reldiff.name = cc.name + " - " + trimmed.name
reldiff.pretty_name = cc.pretty_name + " - " + trimmed.pretty_name
comp_beyond_limit = [False] * 3
for i, d in enumerate('xyz'):
abs_max_rel_diff = np.nanmax(np.abs(reldiff[d]))
max_crd_diff = np.max(trimmed.get_crd(d) - cc.get_crd(d))
print("{0}{1}, max absolute relative diff: {2:.3e} ({1} crds: {3:.1e})"
"".format(cc_fld.name, d, abs_max_rel_diff, max_crd_diff))
if abs_max_rel_diff > rtol or abs(max_crd_diff) > catol:
comp_beyond_limit[i] = True
# plot differences?
if make_plots:
ax1 = mpl.plt.subplot(311)
mpl.plot(cc_fld[d]['y=0f'], symmetric=True, earth=True)
mpl.plt.subplot(312, sharex=ax1, sharey=ax1)
mpl.plot(cc[d]['y=0f'], symmetric=True, earth=True)
mpl.plt.subplot(313, sharex=ax1, sharey=ax1)
mpl.plot(reldiff[d]['y=0f'], symmetric=True, earth=True)
mpl.show()
if any(comp_beyond_limit):
raise RuntimeError("Tolerance exceeded on ->CC accuracy")
def run_test_2d(f, main__file__, show=False):
mpl.clf()
slc = "x=-20f:12f, y=0f"
plot_kwargs = dict(title=True, earth=True)
mpl.subplot(141)
mpl.plot(f['pp'], slc, logscale=True, **plot_kwargs)
mpl.plot(np.abs(f['psi']), style='contour', logscale=True, levels=30,
linewidths=0.8, colors='grey', linestyles='solid', cbar=None,
x=(-20, 12))
mpl.subplot(142)
mpl.plot(viscid.magnitude(f['bcc']), slc, logscale=True, **plot_kwargs)
mpl.plot2d_quiver(f['v'][slc], step=5, color='y', pivot='mid', width=0.03,
scale=600)
mpl.subplot(143)
mpl.plot(f['jy'], slc, clim=[-0.005, 0.005], **plot_kwargs)
mpl.streamplot(f['v'][slc], linewidth=0.3)
mpl.subplot(144)
mpl.plot(f['jy'], "x=7f:12f, y=0f, z=0f")
mpl.plt.suptitle("2D File")
mpl.auto_adjust_subplots(subplot_params=dict(top=0.9, wspace=1.3))
mpl.plt.gcf().set_size_inches(10, 4)
mpl.savefig(next_plot_fname(main__file__))
if show:
mpl.show()
def compare_vectors(orig_fld, cmp_fld, catol=1e-8, rtol=2e-6,
trim_slc='x=2:-2, y=2:-2, z=2:-2', make_plots=False):
# mag_shape = list(orig_fld.sshape) + [1]
mag = viscid.magnitude(orig_fld) # .data.reshape(mag_shape)
reldiff = (cmp_fld - orig_fld) / mag
reldiff = reldiff[trim_slc]
reldiff.name = cmp_fld.name + " - " + orig_fld.name
reldiff.pretty_name = cmp_fld.pretty_name + " - " + orig_fld.pretty_name
comp_beyond_limit = [False] * 3
for i, d in enumerate('xyz'):
abs_max_rel_diff = np.nanmax(np.abs(reldiff[d]))
max_crd_diff = np.max(orig_fld.get_crd(d) - cmp_fld.get_crd(d))
print("{0}{1}, max absolute relative diff: {2:.3e} ({1} crds: {3:.1e})"
"".format(cmp_fld.name, d, abs_max_rel_diff, max_crd_diff))
if abs_max_rel_diff > rtol or abs(max_crd_diff) > catol:
comp_beyond_limit[i] = True
# plot differences?
if make_plots:
mpl.plt.clf()
ax1 = mpl.plt.subplot(311)
mpl.plot(orig_fld[d]['y=0f'], symmetric=True, earth=True)
mpl.plt.subplot(312, sharex=ax1, sharey=ax1)
mpl.plot(cmp_fld[d]['y=0f'], symmetric=True, earth=True)
mpl.plt.subplot(313, sharex=ax1, sharey=ax1)
mpl.plot(reldiff[d]['y=0f'], symmetric=True, earth=True)
mpl.show()
def guess_dipole_moment(b, r=2.0, strength=DEFAULT_STRENGTH, cap_angle=40,
cap_ntheta=121, cap_nphi=121, plot=False):
"""guess dipole moment from a B field"""
viscid.warn("guess_dipole_moment doesn't seem to do better than 1.6 "
"degrees, you may want to use cotr instead.")
cap = seed.SphericalCap(r=r, angle=cap_angle, ntheta=cap_ntheta,
nphi=cap_nphi)
b_cap = interp_trilin(b, cap)
# FIXME: this doesn't get closer than 1.6 deg @ (theta, mu) = (0, 7.5)
# so maybe the index is incorrect somehow?
idx = np.argmax(viscid.magnitude(b_cap).data)
pole = cap.points()[:, idx]
# FIXME: it should be achievabe to get strength from the magimum magnitude,
# up to the direction
pole = strength * pole / np.linalg.norm(pole)
# # not sure where 0.133 comes from, this is probably not correct
# pole *= 0.133 * np.dot(pole, b_cap.data.reshape(-1, 3)[idx, :]) * r**3
if plot:
from viscid.plot import mpl
mpl.plot(viscid.magnitude(b_cap))
mpl.plot(viscid.magnitude(b_cap), style='contour', levels=10,
colors='k', colorbar=False, ax=mpl.plt.gca())
mpl.show()
return pole
def main():
parser = argparse.ArgumentParser(description="Test divergence")
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 = mpl.plt.figure(figsize=(10, 5))
# 1D plot
mpl.subplot(121)
mpl.plot(f0[tL:tR]["y=0"], marker="^")
mpl.plt.xlim(*viscid.as_datetime(t[[0, -1]]).tolist())
# 2D plot
mpl.subplot(122)
mpl.plot(f0, x=(t[0], t[-1]))
mpl.plt.suptitle("datetime64")
mpl.auto_adjust_subplots(subplot_params=dict(top=0.9))
mpl.plt.savefig(next_plot_fname(__file__))
if args.show:
mpl.show()
mpl.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 = mpl.plt.figure(figsize=(10, 5))
# 1D plot
mpl.subplot(121)
mpl.plot(f0[tL:tR]["y=0"], marker="^")
mpl.plt.xlim(*viscid.as_datetime(t[[0, -1]]).tolist())
# 2D plot
mpl.subplot(122)
mpl.plot(f0, x=(t[0], t[-1]), y=(y[0], y[-1]))
mpl.plt.suptitle("timedelta64")
mpl.auto_adjust_subplots(subplot_params=dict(top=0.9))
mpl.plt.savefig(next_plot_fname(__file__))
if args.show:
mpl.show()
mpl.plt.close(fig)
return 0
def run_test(show=False):
f = viscid.load_file(sample_dir + "/amr.xdmf")
plot_kwargs = dict(patchec="y")
mpl.plot(f["f"], "z=0.0f", **plot_kwargs)
mpl.plt.savefig(next_plot_fname(__file__))
if show:
mpl.show()
def run_test(fld, seeds, kind, show=False):
mpl.plt.clf()
mpl.plot(viscid.interp(fld, seeds, kind=kind))
mpl.plt.title(kind)
mpl.plt.savefig(next_plot_fname(__file__))
if show:
mpl.show()
def main():
parser = argparse.ArgumentParser(description="Test xdmf")
parser.add_argument("--show", "--plot", action="store_true")
args = vutil.common_argparse(parser)
f = viscid.load_file(sample_dir + '/test.asc')
mpl.plot(f['c1'], show=False)
mpl.plt.savefig(next_plot_fname(__file__))
if args.show:
mpl.show()
def main():
parser = argparse.ArgumentParser(description="Test quasi potential")
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
mpl.plot(xi, x=(-10, 10), y=(-10, 10), style='contourf', levels=256,
lin=(2e-4, 1.5718))
mpl.plot(xi, x=(-10, 10), y=(-10, 10), style='contour', colors='grey',
levels=[0.5, 1.0])
mpl.savefig(next_plot_fname(__file__))
if args.show:
mpl.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 mvi
except ImportError:
xfail("Mayavi not installed")
mvi.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 = mvi.plot_lines(b_lines[inds], scalars=epar, cmap='viridis')
mvi.mesh_from_seeds(seeds, scalars=xi, cmap='inferno')
mvi.colorbar(s, orientation='horizontal', title=epar.pretty_name)
# mvi.streamline(b, scalars=e, seedtype='sphere', seed_resolution=4,
# integration_direction='both')
oa = mvi.orientation_axes()
oa.marker.set_viewport(0.75, 0.75, 1.0, 1.0)
mvi.view(roll=0, azimuth=90, elevation=25, distance=30.0,
focalpoint=[0, 2, 0])
mvi.savefig(next_plot_fname(__file__))
if args.show:
mvi.show()
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.make_rotation_matrix((0, 0, 0), (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 mpl
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)
mpl.subplot(211)
mpl.plot2d_quiver(B['z=0f'])
mpl.plt.plot([p0[0], pl[0]], [p0[1], pl[1]], color='r', ls='-')
mpl.plt.plot([p0[0], pm[0]], [p0[1], pm[1]], color='c', ls='-')
mpl.plt.plot([p0[0], pn[0]], [p0[1], pn[1]], color='b', ls='-')
mpl.plt.ylabel("Y")
mpl.subplot(212)
mpl.plot2d_quiver(B['y=0f'])
mpl.plt.plot([p0[0], pl[0]], [p0[2], pl[2]], color='r', ls='-')
mpl.plt.plot([p0[0], pm[0]], [p0[2], pm[2]], color='c', ls='-')
mpl.plt.plot([p0[0], pn[0]], [p0[2], pn[2]], color='b', ls='-')
mpl.plt.xlabel("X")
mpl.plt.ylabel("Z")
mpl.show()
##########
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)
# mpl.clf()
# ax1 = mpl.subplot(211)
# mpl.plot(f['pp']['y=0f'], **pargs)
# # mpl.plot(viscid.magnitude(f['b_cc']['y=0f']), **pargs)
# # mpl.show()
# mpl.subplot(212, sharex=ax1, sharey=ax1)
# mpl.plot(viscid.magnitude(viscid.fc2cc(f['b_fc'])['y=0f']), **pargs)
# mpl.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)
mpl.clf()
ax1 = mpl.subplot(211)
mpl.plot(f2['pp']['y=0f'], style='contour', levels=5, colorbar=None,
colors='k', **pargs)
mpl.plot(viscid.magnitude(f2['b_cc']['y=0f']), **pargs)
mpl.subplot(212, sharex=ax1, sharey=ax1)
mpl.plot(viscid.magnitude(viscid.fc2cc(f2['b_fc'])['y=0f']), **pargs)
mpl.show()
os.remove(basename + '.h5')
os.remove(basename + '.xdmf')
return 0
def run_test_3d(f, main__file__, show=False):
mpl.clf()
slc = "x=-20f:12f, y=0f"
plot_kwargs = dict(title=True, earth=True)
mpl.subplot(141)
mpl.plot(f['pp'], slc, logscale=True, **plot_kwargs)
mpl.subplot(142)
mpl.plot(viscid.magnitude(f['bcc']), slc, logscale=True, **plot_kwargs)
mpl.plot2d_quiver(f['v'][slc], step=5, color='y', pivot='mid', width=0.03,
scale=600)
mpl.subplot(143)
mpl.plot(f['jy'], slc, clim=(-0.005, 0.005), **plot_kwargs)
mpl.streamplot(f['v'][slc], linewidth=0.3)
mpl.subplot(144)
mpl.plot(f['jy'], "x=7f:12f, y=0f, z=0f")
mpl.plt.suptitle("3D File")
mpl.auto_adjust_subplots(subplot_params=dict(top=0.9, wspace=1.3))
mpl.plt.gcf().set_size_inches(10, 4)
mpl.savefig(next_plot_fname(main__file__))
if show:
mpl.show()
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(sample_dir + '/ath_sample.*.bin')
for i, grid in enumerate(f_bin.iter_times(":")):
plt.subplot2grid((2, 2), (0, i))
mpl.plot(grid['bx'])
plt.subplot2grid((2, 2), (1, i))
mpl.plot(grid['by'])
mpl.plt.suptitle("athena bin (binary) files")
mpl.auto_adjust_subplots(subplot_params=dict(top=0.9))
mpl.plt.savefig(next_plot_fname(__file__))
if args.show:
mpl.show()
plt.clf()
####### test ascii files
f_tab = viscid.load_file(sample_dir + '/ath_sample.*.tab')
for i, grid in enumerate(f_tab.iter_times(":")):
plt.subplot2grid((2, 2), (0, i))
mpl.plot(grid['bx'])
plt.subplot2grid((2, 2), (1, i))
mpl.plot(grid['by'])
mpl.plt.suptitle("athena tab (ascii) files")
mpl.auto_adjust_subplots(subplot_params=dict(top=0.9))
mpl.plt.savefig(next_plot_fname(__file__))
if args.show:
mpl.show()
plt.clf()
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.2f:12f, y=-11f:11f, z=-11f:11f"
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 mvi
mesh = mvi.mesh_from_seeds(seedsN, scalars=topoN_fc)
mesh.actor.property.backface_culling = True
# mvi.plot_lines(blines_cc, scalars="#000000", tube_radius=0.03)
mvi.plot_lines(blinesN_fc, scalars=viscid.topology2color(topoN_fc),
opacity=0.7)
mvi.plot_blue_marble(r=1.0)
mvi.plot_earth_3d(radius=1.01, crd_system=b, night_only=True,
opacity=0.5)
mvi.show()
if True:
mpl.subplot(121, projection='polar')
mpl.plot(topoN_fc)
mpl.subplot(122, projection='polar')
mpl.plot(topoS_fc)
mpl.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)
# mpl.plt.clf()
# dkwargs = dict(symmetric=True, earth=True, clim=(-1e2, 1e2))
# ax1 = mpl.plt.subplot(311)
# mpl.plot(viscid.div(b1)['y=0f'], **dkwargs)
# mpl.plt.subplot(312, sharex=ax1, sharey=ax1)
# mpl.plot(viscid.div(b)['y=0f'], **dkwargs)
# mpl.plt.subplot(313, sharex=ax1, sharey=ax1)
# mpl.plot(viscid.div(b1D)['y=0f'], **dkwargs)
# mpl.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))
mpl.plt.clf()
ax1 = mpl.subplot(311)
mpl.plot(div_b['y=0f'], symmetric=True, earth=True)
mpl.subplot(312, sharex=ax1, sharey=ax1)
# mpl.plot(div_b1['y=0f'], symmetric=True, earth=True)
mpl.plot(div_b2['y=0f'], symmetric=True, earth=True)
mpl.subplot(313, sharex=ax1, sharey=ax1)
mpl.plot(divb['y=0f'], symmetric=True, earth=True)
mpl.show()
return 0
def main():
parser = argparse.ArgumentParser()
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
# plot2d = True
# plot3d = True
# args.show = True
img = np.load(sample_dir + "/logo.npy")
x = np.linspace(-1, 1, img.shape[0])
y = np.linspace(-1, 1, img.shape[1])
z = np.linspace(-1, 1, img.shape[2])
logo = viscid.arrays2field(img, [x, y, z])
if 1:
viscid.logger.info('Testing Line...')
seeds = viscid.Line([-1, -1, 0], [1, 1, 2], n=5)
run_test(logo, seeds, plot2d=plot2d, plot3d=plot3d, show=args.show)
if 1:
viscid.logger.info('Testing Plane...')
seeds = viscid.Plane([0.0, 0.0, 0.0], [1, 1, 1], [1, 0, 0], 2, 2,
nl=160, nm=170, NL_are_vectors=True)
run_test(logo, seeds, plot2d=plot2d, plot3d=plot3d, show=args.show)
if 1:
viscid.logger.info('Testing Volume...')
seeds = viscid.Volume([-0.8, -0.8, -0.8], [0.8, 0.8, 0.8],
n=[64, 64, 3])
# note: can't make a 2d plot of the volume w/o a slice
run_test(logo, seeds, plot2d=False, plot3d=plot3d, add_title="3d",
show=args.show)
if 1:
viscid.logger.info('Testing Volume (with ignorable dim)...')
seeds = viscid.Volume([-0.8, -0.8, 0.0], [0.8, 0.8, 0.0],
n=[64, 64, 1])
run_test(logo, seeds, plot2d=plot2d, plot3d=plot3d, add_title="2d",
show=args.show)
if 1:
viscid.logger.info('Testing Spherical Sphere (phi, theta)...')
seeds = viscid.Sphere([0, 0, 0], r=1.0, ntheta=160, nphi=170,
pole=[-1, -1, -1], theta_phi=False)
run_test(logo, seeds, plot2d=plot2d, plot3d=plot3d, add_title="PT",
show=args.show)
if 1:
viscid.logger.info('Testing Spherical Sphere (theta, phi)...')
seeds = viscid.Sphere([0, 0, 0], r=1.0, ntheta=160, nphi=170,
pole=[-1, -1, -1], theta_phi=True)
run_test(logo, seeds, plot2d=plot2d, plot3d=plot3d, add_title="TP",
show=args.show)
if 1:
viscid.logger.info('Testing Spherical Cap (phi, theta)...')
seeds = viscid.SphericalCap(p0=[0, 0, 0], r=1.0, ntheta=64, nphi=80,
pole=[-1, -1, -1], theta_phi=False)
run_test(logo, seeds, plot2d=plot2d, plot3d=plot3d, add_title="PT",
view_kwargs=dict(azimuth=180, elevation=180), show=args.show)
if 1:
viscid.logger.info('Testing Spherical Cap (theta, phi)...')
seeds = viscid.SphericalCap(p0=[0, 0, 0], r=1.0, ntheta=64, nphi=80,
pole=[-1, -1, -1], theta_phi=True)
run_test(logo, seeds, plot2d=plot2d, plot3d=plot3d, add_title="TP",
view_kwargs=dict(azimuth=180, elevation=180), show=args.show)
if 1:
viscid.logger.info('Testing Spherical Patch...')
seeds = viscid.SphericalPatch(p0=[0, 0, 0], p1=[0, -0, -1],
max_alpha=30.0, max_beta=59.9,
nalpha=65, nbeta=80, r=0.5, roll=45.0)
run_test(logo, seeds, plot2d=plot2d, plot3d=plot3d, show=args.show)
if 1:
viscid.logger.info('Testing RectilinearMeshPoints...')
f = viscid.load_file(sample_dir + '/sample_xdmf.3d.[-1].xdmf')
slc = 'x=-40f:12f, y=-10f:10f, z=-10f:10f'
b = f['b'][slc]
z = b.get_crd('z')
sheet_iz = np.argmin(b['x']**2, axis=2)
sheet_pts = b['z=0:1'].get_points()
sheet_pts[2, :] = z[sheet_iz].reshape(-1)
isphere_mask = np.sum(sheet_pts[:2, :]**2, axis=0) < 5**2
day_mask = sheet_pts[0:1, :] > -1.0
sheet_pts[2, :] = np.choose(isphere_mask, [sheet_pts[2, :], 0])
sheet_pts[2, :] = np.choose(day_mask, [sheet_pts[2, :], 0])
nx, ny, _ = b.sshape
sheet_seed = viscid.RectilinearMeshPoints(sheet_pts.reshape(3, nx, ny))
vx_sheet = viscid.interp_nearest(f['vx'], sheet_seed)
try:
if not plot2d:
raise ImportError
from viscid.plot import mpl
mpl.clf()
mpl.plot(vx_sheet, symmetric=True)
mpl.plt.savefig(next_plot_fname(__file__, series='2d'))
if args.show:
mpl.show()
except ImportError:
pass
try:
if not plot3d:
raise ImportError
from viscid.plot import mvi
mvi.clf()
mesh = mvi.mesh_from_seeds(sheet_seed, scalars=vx_sheet,
clim=(-400, 400))
mvi.plot_earth_3d(crd_system=b)
mvi.view(azimuth=+90.0 + 45.0, elevation=90.0 - 25.0,
distance=30.0, focalpoint=(-10.0, +1.0, +1.0))
mvi.title("RectilinearMeshPoints")
mvi.savefig(next_plot_fname(__file__, series='3d'))
if args.show:
mvi.show()
except ImportError:
pass
return 0
def main():
parser = argparse.ArgumentParser(description="Test grad")
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=(256, 256, 128),
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"
_ = mpl.plt.figure(figsize=(9, 4.2))
ax1 = mpl.subplot(231)
mpl.plot(b2['z=0f'], logscale=True)
mpl.plot(b2['z=0f'], logscale=True, style='contour', levels=10, colors='grey')
# mpl.plot2d_quiver(viscid.normalize(b['z=0f']), step=16, pivot='mid')
ax2 = mpl.subplot(234)
mpl.plot(b2['y=0f'], logscale=True)
mpl.plot(b2['y=0f'], logscale=True, style='contour', levels=10, colors='grey')
mpl.plot2d_quiver(viscid.normalize(b['y=0f'], preferred='numpy'),
step=16, pivot='mid')
mpl.subplot(232, sharex=ax1, sharey=ax1)
mpl.plot(1e-4 + viscid.magnitude(grad_b2['z=0f']), logscale=True)
mpl.plot(1e-4 + viscid.magnitude(grad_b2['z=0f']), logscale=True,
style='contour', levels=10, colors='grey')
mpl.plot2d_quiver(viscid.normalize(grad_b2['z=0f']), step=16, pivot='mid')
mpl.subplot(235, sharex=ax2, sharey=ax2)
mpl.plot(1e-4 + viscid.magnitude(grad_b2['y=0f']), logscale=True)
mpl.plot(1e-4 + viscid.magnitude(grad_b2['y=0f']), logscale=True,
style='contour', levels=10, colors='grey')
mpl.plot2d_quiver(viscid.normalize(grad_b2['y=0f']), step=16, pivot='mid')
mpl.subplot(233, sharex=ax1, sharey=ax1)
mpl.plot(viscid.magnitude(conv['z=0f']), logscale=True)
mpl.plot(viscid.magnitude(conv['z=0f']), logscale=True,
style='contour', levels=10, colors='grey')
mpl.plot2d_quiver(viscid.normalize(conv['z=0f']), step=16, pivot='mid')
mpl.subplot(236, sharex=ax2, sharey=ax2)
mpl.plot(viscid.magnitude(conv['y=0f']), logscale=True)
mpl.plot(viscid.magnitude(conv['y=0f']), logscale=True,
style='contour', levels=10, colors='grey')
mpl.plot2d_quiver(viscid.normalize(conv['y=0f']), step=16, pivot='mid')
mpl.auto_adjust_subplots()
mpl.plt.savefig(next_plot_fname(__file__))
if args.show:
mpl.show()
def _get_sep_pts_bisect(
fld,
seed,
trace_opts=None,
min_depth=3,
max_depth=7,
plot=False,
perimeter_check=perimeter_check_bitwise_or,
make_3d=True,
start_uneven=False,
_base_quadrent="",
_uneven_mask=0,
_first_recurse=True,
):
if len(_base_quadrent) == max_depth:
return [_base_quadrent] # causes pylint to complain
if trace_opts is None:
trace_opts = dict()
nx, ny = seed.uv_shape
(xlim, ylim) = seed.uv_extent
if _first_recurse and start_uneven:
_uneven_mask = UNEVEN_MASK
if _first_recurse and plot:
from viscid.plot import mvi
from viscid.plot import mpl
mpl.clf()
_, all_topo = viscid.calc_streamlines(fld, seed, **trace_opts)
mpl.plot(np.bitwise_and(all_topo, 15), show=False)
verts, arr = seed.wrap_mesh(all_topo.data)
mvi.mesh(verts[0], verts[1], verts[2], scalars=arr, opacity=0.75)
# quadrents and lines are indexed as follows...
# directions are counter clackwise around the quadrent with
# lower index (which matters for lines which are shared among
# more than one quadrent, aka, lines 1,2,6,7). Notice that even
# numbered lines are horizontal, like the interstate system :)
# -<--10-----<-8---
# | ^ ^
# 11 2 9 3 7
# \/ | |
# --<-2-----<-6----
# | ^ ^
# 3 0 1 1 5
# \/ | |
# ----0->-----4->--
# find low(left), mid(center), and high(right) crds in x and y
low_quad = "{0}{1:x}".format(_base_quadrent, 0 | _uneven_mask)
high_quad = "{0}{1:x}".format(_base_quadrent, 3 | _uneven_mask)
xl, xm, yl, ym = _quadrent_limits(low_quad, xlim, ylim)
_, xh, _, yh = _quadrent_limits(high_quad, xlim, ylim)
segsx, segsy = [None] * 12, [None] * 12
topo = [None] * 12
nxm, nym = nx // 2, ny // 2
# make all the line segments
segsx[0], segsy[0] = np.linspace(xl, xm, nxm), np.linspace(yl, yl, nxm)
segsx[1], segsy[1] = np.linspace(xm, xm, nym), np.linspace(yl, ym, nym)
segsx[2], segsy[2] = np.linspace(xm, xl, nxm), np.linspace(ym, ym, nxm)
segsx[3], segsy[3] = np.linspace(xl, xl, nym), np.linspace(ym, yl, nym)
segsx[4], segsy[4] = np.linspace(xm, xh, nxm), np.linspace(yl, yl, nxm)
segsx[5], segsy[5] = np.linspace(xh, xh, nym), np.linspace(yl, ym, nym)
segsx[6], segsy[6] = np.linspace(xh, xm, nxm), np.linspace(ym, ym, nxm)
segsx[7], segsy[7] = np.linspace(xh, xh, nym), np.linspace(ym, yh, nym)
segsx[8], segsy[8] = np.linspace(xh, xm, nxm), np.linspace(yh, yh, nxm)
segsx[9], segsy[9] = np.linspace(xm, xm, nym), np.linspace(ym, yh, nym)
segsx[10], segsy[10] = np.linspace(xm, xl, nxm), np.linspace(yh, yh, nxm)
segsx[11], segsy[11] = np.linspace(xl, xl, nym), np.linspace(yh, ym, nym)
allx = np.concatenate(segsx)
ally = np.concatenate(segsy)
# print("plot::", _base_quadrent, '|', _uneven_mask, '|', len(allx), len(ally))
pts3d = seed.to_3d(seed.uv_to_local(np.array([allx, ally])))
_, all_topo = viscid.calc_streamlines(fld, pts3d, **trace_opts)
topo[0] = all_topo[: len(segsx[0])]
cnt = len(topo[0])
for i, segx in zip(count(1), segsx[1:]):
topo[i] = all_topo[cnt : cnt + len(segx)]
# print("??", i, cnt, cnt + len(segx), np.bitwise_and.reduce(topo[i]))
cnt += len(topo[i])
# assemble the lines into the four quadrents
quad_topo = [None] * 4
# all arrays snip off the last element since those are
# duplicated by the next line... reversed arrays do the
# snipping with -1:0:-1
quad_topo[0] = np.concatenate([topo[0][:-1], topo[1][:-1], topo[2][:-1], topo[3][:-1]])
quad_topo[1] = np.concatenate([topo[4][:-1], topo[5][:-1], topo[6][:-1], topo[1][-1:0:-1]])
quad_topo[2] = np.concatenate([topo[2][-1:0:-1], topo[9][:-1], topo[10][:-1], topo[11][:-1]])
quad_topo[3] = np.concatenate([topo[6][-1:0:-1], topo[7][:-1], topo[8][:-1], topo[9][-1:0:-1]])
# now that the quad arrays are populated, decide which quadrents
# still contain the separator (could be > 1)
required_uneven_subquads = False
ret = []
for i in range(4):
if perimeter_check(quad_topo[i]):
next_quad = "{0}{1:x}".format(_base_quadrent, i | _uneven_mask)
subquads = _get_sep_pts_bisect(
fld,
seed,
trace_opts=trace_opts,
min_depth=min_depth,
max_depth=max_depth,
plot=plot,
_base_quadrent=next_quad,
_uneven_mask=0,
_first_recurse=False,
)
ret += subquads
if len(ret) == 0:
perimeter = np.concatenate(
[
topo[0][::-1],
topo[4][::-1],
topo[5][::-1],
topo[7][::-1],
topo[8][::-1],
topo[10][::-1],
topo[11][::-1],
topo[3][::-1],
]
)
if _uneven_mask:
if len(_base_quadrent) > min_depth:
print("sep trace issue, but min depth reached: {0} > {1}" "".format(len(_base_quadrent), min_depth))
ret = [_base_quadrent]
else:
print("sep trace issue, the separator ended prematurely")
elif perimeter_check(perimeter):
ret = _get_sep_pts_bisect(
fld,
seed,
trace_opts=trace_opts,
min_depth=min_depth,
max_depth=max_depth,
plot=plot,
_base_quadrent=_base_quadrent,
_uneven_mask=UNEVEN_MASK,
_first_recurse=False,
)
required_uneven_subquads = True
if plot and not required_uneven_subquads:
from viscid.plot import mvi
from viscid.plot import mpl
_pts3d = seed.to_3d(seed.uv_to_local(np.array([allx, ally])))
mvi.points3d(_pts3d[0], _pts3d[1], _pts3d[2], all_topo.data.reshape(-1), scale_mode="none", scale_factor=0.02)
mpl.plt.scatter(
allx, ally, color=np.bitwise_and(all_topo, 15), vmin=0, vmax=15, marker="o", edgecolor="y", s=40
)
if _first_recurse:
# turn quadrent strings into locations
xc = np.empty(len(ret))
yc = np.empty(len(ret))
for i, r in enumerate(ret):
xc[i], yc[i] = _quadrent_center(r, xlim, ylim)
pts_uv = np.array([xc, yc])
if plot:
from viscid.plot import mvi
from viscid.plot import mpl
mpl.plt.plot(pts_uv[0], pts_uv[1], "y*", ms=20, markeredgecolor="k", markeredgewidth=1.0)
mpl.show(block=False)
mvi.show(stop=True)
# return seed.to_3d(seed.uv_to_local(pts_uv))
# if pts_uv.size == 0:
# return None
if make_3d:
return seed.uv_to_3d(pts_uv)
else:
return pts_uv
else:
return ret
def benchmark_streamline(precompile=True, profile=True, scale=True, plot=True):
which = "streamline"
print(which)
print('-' * len(which))
f0, seeds = make_vector_fld()
print("Timing", which)
sl_kwargs = dict(ibound=3.7, ds0=0.020)
lines, _ = viscid.streamlines(f0, seeds, **sl_kwargs)
nsegs_cython = np.sum([line.shape[1] for line in lines])
lines = None
ft_stats, cy_stats = dict(), dict()
bench_output_type = viscid.OUTPUT_TOPOLOGY
sl_kwargs.update(output=bench_output_type)
retFT = viscid.timeit(fort_topology,
f0,
seeds,
timeit_repeat=6,
timeit_stats=ft_stats)
_, retCY = viscid.timeit(viscid.streamlines,
f0,
seeds,
timeit_repeat=6,
timeit_stats=cy_stats,
**sl_kwargs)
fort_per_seg = ft_stats['min'] / retFT.get_info('nsegs')
cy_per_seg = cy_stats['min'] / nsegs_cython
print("Segs Fortran", retFT.get_info('nsegs'))
print("Segs Cython ", nsegs_cython)
print("Fortran took {0:.3g} sec/seg".format(fort_per_seg))
print("Cython took {0:.3g} sec/seg".format(cy_per_seg))
print_seedup("Cython", cy_per_seg, "Fortran", fort_per_seg, prefix="@ ")
if plot:
from viscid.plot import mpl
mpl.clf()
mpl.subplot(121, projection='polar')
mpl.plot(retCY, hemisphere='north')
mpl.subplot(122, projection='polar')
mpl.plot(retCY, hemisphere='south')
mpl.show()
if scale:
thetas = np.logspace(np.log10(3), np.log10(144), 8).astype('i')
cy_nsegs = [None] * len(thetas)
fort_nsegs = [None] * len(thetas)
cy_mintime = [None] * len(thetas)
fort_mintime = [None] * len(thetas)
for i, ntheta in enumerate(thetas):
seeds = viscid.Sphere(r=10.0, ntheta=ntheta, nphi=32)
_stats = dict()
topo = viscid.timeit(fort_topology,
f0,
seeds,
timeit_repeat=5,
timeit_stats=_stats,
timeit_quiet=True)
fort_nsegs[i] = topo.get_info('nsegs')
fort_mintime[i] = _stats['min']
_, topo = viscid.timeit(viscid.calc_streamlines,
f0,
seeds,
ibound=3.7,
ds0=0.020,
output=bench_output_type,
timeit_repeat=5,
timeit_stats=_stats,
timeit_quiet=True)
lines, _ = viscid.streamlines(f0, seeds, ibound=3.7, ds0=0.020)
cy_nsegs[i] = np.sum([line.shape[1] for line in lines])
cy_mintime[i] = _stats['min']
from viscid.plot import mpl
mpl.clf()
mpl.plt.plot(cy_nsegs, cy_mintime, label="Cython")
mpl.plt.plot(fort_nsegs, fort_mintime, label="Fortran")
mpl.plt.legend(loc=0)
mpl.plt.xlabel('Number of segments calculated')
mpl.plt.ylabel('time to calculate')
mpl.show()
mpl.clf()
cy_tperseg = np.array(cy_mintime) / np.array(cy_nsegs)
fort_tperseg = np.array(fort_mintime) / np.array(fort_nsegs)
mpl.plt.plot(thetas, cy_tperseg / fort_tperseg, label="over cython")
mpl.plt.xlabel('ntheta')
mpl.plt.ylabel('Fortran Speedup')
mpl.show()
def _main():
f = viscid.load_file("$WORK/xi_fte_001/*.3d.[4050f].xdmf")
mp = get_mp_info(f['pp'], f['b'], f['j'], f['e_cc'], fit='mp_xloc',
slc="x=6.5f:10.5f, y=-4f:4f, z=-4.8f:3f", cache=False)
y, z = mp['pp_max_xloc'].meshgrid_flat(prune=True)
x = mp['pp_max_xloc'].data.reshape(-1)
Y, Z = mp['pp_max_xloc'].meshgrid(prune=True)
x2 = paraboloid(Y, Z, *mp['paraboloid'][0])
skip = 117
n = paraboloid_normal(Y, Z, *mp['paraboloid'][0]).reshape(3, -1)[:, ::skip]
minvar_y = Y.reshape(-1)[::skip]
minvar_z = Z.reshape(-1)[::skip]
minvar_n = np.zeros([3, len(minvar_y)])
for i in range(minvar_n.shape[0]):
p0 = [0.0, minvar_y[i], minvar_z[i]]
p0[0] = mp['pp_max_xloc']['y={0[0]}f, z={0[1]}f'.format(p0)]
minvar_n[:, i] = viscid.find_minvar_lmn_around(f['b'], p0, l=2.0, n=64)[2, :]
# 2d plots, normals don't look normal in the matplotlib projection
if False: # pylint: disable=using-constant-test
from viscid.plot import mpl
normals = paraboloid_normal(Y, Z, *mp['paraboloid'][0])
p0 = np.array([x2, Y, Z]).reshape(3, -1)
p1 = p0 + normals.reshape(3, -1)
mpl.scatter_3d(np.vstack([x, y, z])[:, ::skip], equal=True)
for i in range(0, p0.shape[1], skip):
mpl.plt.gca().plot([p0[0, i], p1[0, i]],
[p0[1, i], p1[1, i]],
[p0[2, i], p1[2, i]], color='c')
# z2 = _ellipsiod(X, Y, *popt)
mpl.plt.gca().plot_surface(Y, Z, x2, color='r')
mpl.show()
# mayavi 3d plots, normals look better here
if True: # pylint: disable=using-constant-test
from viscid.plot import mvi
mvi.points3d(x[::skip], y[::skip], z[::skip], scale_factor=0.25,
color=(0.0, 0.0, 1.0))
mp_width = mp['mp_width']['x=0']
mp_sheath_edge = mp['mp_sheath_edge']['x=0']
mp_sphere_edge = mp_sheath_edge - mp_width
mvi.mesh(x2, Y, Z, scalars=mp_width.data)
mvi.mesh(mp_sheath_edge.data, Y, Z, opacity=0.75, color=(0.75, ) * 3)
mvi.mesh(mp_sphere_edge.data, Y, Z, opacity=0.75, color=(0.75, ) * 3)
n = paraboloid_normal(Y, Z, *mp['paraboloid'][0]).reshape(3, -1)[:, ::skip]
mvi.quiver3d(x2.reshape(-1)[::skip],
Y.reshape(-1)[::skip],
Z.reshape(-1)[::skip],
n[0], n[1], n[2], color=(1, 0, 0))
mvi.quiver3d(x2.reshape(-1)[::skip],
Y.reshape(-1)[::skip],
Z.reshape(-1)[::skip],
minvar_n[0], minvar_n[1], minvar_n[2], color=(0, 0, 1))
mvi.show()
def main():
mhd_type = "C"
make_plots = 1
test_fc = 1
test_ec = 1
test_div = 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 = 2.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()
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 = mpl.plt.subplot(311)
mpl.plot(divb['y=0f'], symmetric=True, earth=True)
mpl.plt.subplot(312, sharex=ax1, sharey=ax1)
mpl.plot(divb1['y=0f'], symmetric=True, earth=True)
mpl.plt.subplot(313, sharex=ax1, sharey=ax1)
mpl.plot(reldiff['y=0f'], symmetric=True, earth=True)
mpl.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")
return 0
def benchmark_streamline(precompile=True, profile=True, scale=True, plot=True):
which = "streamline"
print(which)
print('-' * len(which))
f0, seeds = make_vector_fld()
print("Timing", which)
sl_kwargs = dict(ibound=3.7, ds0=0.020)
lines, _ = viscid.streamlines(f0, seeds, **sl_kwargs)
nsegs_cython = np.sum([line.shape[1] for line in lines])
lines = None
ft_stats, cy_stats = dict(), dict()
bench_output_type = viscid.OUTPUT_TOPOLOGY
sl_kwargs.update(output=bench_output_type)
retFT = viscid.timeit(fort_topology, f0, seeds, timeit_repeat=6,
timeit_stats=ft_stats)
_, retCY = viscid.timeit(viscid.streamlines, f0, seeds, timeit_repeat=6,
timeit_stats=cy_stats, **sl_kwargs)
fort_per_seg = ft_stats['min'] / retFT.get_info('nsegs')
cy_per_seg = cy_stats['min'] / nsegs_cython
print("Segs Fortran", retFT.get_info('nsegs'))
print("Segs Cython ", nsegs_cython)
print("Fortran took {0:.3g} sec/seg".format(fort_per_seg))
print("Cython took {0:.3g} sec/seg".format(cy_per_seg))
print_seedup("Cython", cy_per_seg, "Fortran", fort_per_seg, prefix="@ ")
if plot:
from viscid.plot import mpl
mpl.clf()
mpl.subplot(121, projection='polar')
mpl.plot(retCY, hemisphere='north')
mpl.subplot(122, projection='polar')
mpl.plot(retCY, hemisphere='south')
mpl.show()
if scale:
thetas = np.logspace(np.log10(3), np.log10(144), 8).astype('i')
cy_nsegs = [None] * len(thetas)
fort_nsegs = [None] * len(thetas)
cy_mintime = [None] * len(thetas)
fort_mintime = [None] * len(thetas)
for i, ntheta in enumerate(thetas):
seeds = viscid.Sphere(r=10.0, ntheta=ntheta, nphi=32)
_stats = dict()
topo = viscid.timeit(fort_topology, f0, seeds, timeit_repeat=5,
timeit_stats=_stats, timeit_quiet=True)
fort_nsegs[i] = topo.get_info('nsegs')
fort_mintime[i] = _stats['min']
_, topo = viscid.timeit(viscid.calc_streamlines, f0, seeds,
ibound=3.7, ds0=0.020, output=bench_output_type,
timeit_repeat=5, timeit_stats=_stats,
timeit_quiet=True)
lines, _ = viscid.streamlines(f0, seeds, ibound=3.7, ds0=0.020)
cy_nsegs[i] = np.sum([line.shape[1] for line in lines])
cy_mintime[i] = _stats['min']
from viscid.plot import mpl
mpl.clf()
mpl.plt.plot(cy_nsegs, cy_mintime, label="Cython")
mpl.plt.plot(fort_nsegs, fort_mintime, label="Fortran")
mpl.plt.legend(loc=0)
mpl.plt.xlabel('Number of segments calculated')
mpl.plt.ylabel('time to calculate')
mpl.show()
mpl.clf()
cy_tperseg = np.array(cy_mintime) / np.array(cy_nsegs)
fort_tperseg = np.array(fort_mintime) / np.array(fort_nsegs)
mpl.plt.plot(thetas, cy_tperseg / fort_tperseg, label="over cython")
mpl.plt.xlabel('ntheta')
mpl.plt.ylabel('Fortran Speedup')
mpl.show()
