def test_plot_2d():
# Cartesian
ds = fake_random_ds((32, 32, 1), fields=('temperature', ), units=('K', ))
slc = SlicePlot(ds,
"z", ["temperature"],
width=(0.2, "unitary"),
center=[0.4, 0.3, 0.5])
slc2 = plot_2d(ds,
"temperature",
width=(0.2, "unitary"),
center=[0.4, 0.3])
slc3 = plot_2d(ds,
"temperature",
width=(0.2, "unitary"),
center=ds.arr([0.4, 0.3], "cm"))
assert_array_equal(slc.frb['temperature'], slc2.frb['temperature'])
assert_array_equal(slc.frb['temperature'], slc3.frb['temperature'])
# Cylindrical
ds = data_dir_load(WD)
slc = SlicePlot(ds, "theta", ["density"], width=(30000.0, "km"))
slc2 = plot_2d(ds, "density", width=(30000.0, "km"))
assert_array_equal(slc.frb['density'], slc2.frb['density'])
# Spherical
ds = data_dir_load(blast_wave)
slc = SlicePlot(ds, "phi", ["density"], width=(1, "unitary"))
slc2 = plot_2d(ds, "density", width=(1, "unitary"))
assert_array_equal(slc.frb['density'], slc2.frb['density'])
def test_timestamp_callback():
with _cleanup_fname() as prefix:
ax = 'z'
vector = [1.0, 1.0, 1.0]
ds = fake_amr_ds(fields=("density", ))
p = ProjectionPlot(ds, ax, "density")
p.annotate_timestamp()
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, "density")
p.annotate_timestamp()
assert_fname(p.save(prefix)[0])
p = OffAxisSlicePlot(ds, vector, "density")
p.annotate_timestamp()
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_timestamp(corner='lower_right',
redshift=True,
draw_inset_box=True)
p.save(prefix)
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density", ), geometry="spherical")
p = ProjectionPlot(ds, "r", "density")
p.annotate_timestamp(coord_system="data")
assert_raises(YTDataTypeUnsupported, p.save, prefix)
p = ProjectionPlot(ds, "r", "density")
p.annotate_timestamp(coord_system="axis")
assert_fname(p.save(prefix)[0])
def test_arrow_callback():
with _cleanup_fname() as prefix:
ax = 'z'
vector = [1.0,1.0,1.0]
ds = fake_amr_ds(fields = ("density",))
p = ProjectionPlot(ds, ax, "density")
p.annotate_arrow([0.5,0.5,0.5])
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, "density")
p.annotate_arrow([0.5,0.5,0.5])
assert_fname(p.save(prefix)[0])
p = OffAxisSlicePlot(ds, vector, "density")
p.annotate_arrow([0.5,0.5,0.5])
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_arrow([0.5,0.5], coord_system='axis', length=0.05)
p.annotate_arrow([[0.5,0.6],[0.5,0.6],[0.5,0.6]], coord_system='data', length=0.05)
p.annotate_arrow([[0.5,0.6,0.8],[0.5,0.6,0.8],[0.5,0.6,0.8]], coord_system='data', length=0.05)
p.annotate_arrow([[0.5,0.6,0.8],[0.5,0.6,0.8]], coord_system='axis', length=0.05)
p.annotate_arrow([[0.5,0.6,0.8],[0.5,0.6,0.8]], coord_system='figure', length=0.05)
p.annotate_arrow([[0.5,0.6,0.8],[0.5,0.6,0.8]], coord_system='plot', length=0.05)
p.save(prefix)
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields = ("density",), geometry="spherical")
p = ProjectionPlot(ds, "r", "density")
p.annotate_arrow([0.5,0.5,0.5])
assert_raises(YTDataTypeUnsupported, p.save, prefix)
p = ProjectionPlot(ds, "r", "density")
p.annotate_arrow([0.5,0.5], coord_system="axis")
assert_fname(p.save(prefix)[0])
def test_marker_callback():
with _cleanup_fname() as prefix:
ax = 'z'
vector = [1.0,1.0,1.0]
ds = fake_amr_ds(fields = ("density",))
p = ProjectionPlot(ds, ax, "density")
p.annotate_marker([0.5,0.5,0.5])
yield assert_fname, p.save(prefix)[0]
p = SlicePlot(ds, ax, "density")
p.annotate_marker([0.5,0.5,0.5])
yield assert_fname, p.save(prefix)[0]
p = OffAxisSlicePlot(ds, vector, "density")
p.annotate_marker([0.5,0.5,0.5])
yield assert_fname, p.save(prefix)[0]
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_marker([0.5,0.5], coord_system='axis', marker='*')
p.save(prefix)
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields = ("density",), geometry="spherical")
p = ProjectionPlot(ds, "r", "density")
p.annotate_marker([0.5,0.5,0.5])
yield assert_raises, YTDataTypeUnsupported, p.save, prefix
p = ProjectionPlot(ds, "r", "density")
p.annotate_marker([0.5,0.5], coord_system="axis")
yield assert_fname, p.save(prefix)[0]
def test_marker_callback():
with _cleanup_fname() as prefix:
ax = 'z'
vector = [1.0,1.0,1.0]
ds = fake_amr_ds(fields = ("density",))
p = ProjectionPlot(ds, ax, "density")
p.annotate_marker([0.5,0.5,0.5])
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, "density")
p.annotate_marker([0.5,0.5,0.5])
assert_fname(p.save(prefix)[0])
p = OffAxisSlicePlot(ds, vector, "density")
p.annotate_marker([0.5,0.5,0.5])
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
coord = ds.arr([0.75, 0.75, 0.75], 'unitary')
coord.convert_to_units('kpc')
p.annotate_marker(coord, coord_system='data')
p.annotate_marker([0.5,0.5], coord_system='axis', marker='*')
p.annotate_marker([[0.5,0.6],[0.5,0.6],[0.5,0.6]], coord_system='data')
p.annotate_marker([[0.5,0.6,0.8],[0.5,0.6,0.8],[0.5,0.6,0.8]], coord_system='data')
p.annotate_marker([[0.5,0.6,0.8],[0.5,0.6,0.8]], coord_system='axis')
p.annotate_marker([[0.5,0.6,0.8],[0.5,0.6,0.8]], coord_system='figure')
p.annotate_marker([[0.5,0.6,0.8],[0.5,0.6,0.8]], coord_system='plot')
p.save(prefix)
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields = ("density",), geometry="spherical")
p = ProjectionPlot(ds, "r", "density")
p.annotate_marker([0.5,0.5,0.5])
assert_raises(YTDataTypeUnsupported, p.save, prefix)
p = ProjectionPlot(ds, "r", "density")
p.annotate_marker([0.5,0.5], coord_system="axis")
assert_fname(p.save(prefix)[0])
def test_scale_callback():
with _cleanup_fname() as prefix:
ax = 'z'
vector = [1.0,1.0,1.0]
ds = fake_amr_ds(fields = ("density",))
p = ProjectionPlot(ds, ax, "density")
p.annotate_scale()
yield assert_fname, p.save(prefix)[0]
p = SlicePlot(ds, ax, "density")
p.annotate_scale()
yield assert_fname, p.save(prefix)[0]
p = OffAxisSlicePlot(ds, vector, "density")
p.annotate_scale()
yield assert_fname, p.save(prefix)[0]
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_scale(corner='upper_right', coeff=10., unit='kpc')
yield assert_fname, p.save(prefix)[0]
p = SlicePlot(ds, "x", "density")
p.annotate_scale(text_args={"size": 24})
yield assert_fname, p.save(prefix)[0]
p = SlicePlot(ds, "x", "density")
p.annotate_scale(text_args={"font": 24})
yield assert_raises, YTPlotCallbackError
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields = ("density",), geometry="spherical")
p = ProjectionPlot(ds, "r", "density")
p.annotate_scale()
yield assert_raises, YTDataTypeUnsupported, p.save, prefix
p = ProjectionPlot(ds, "r", "density")
p.annotate_scale(coord_system="axis")
yield assert_raises, YTDataTypeUnsupported, p.save, prefix
def test_ray_callback():
with _cleanup_fname() as prefix:
ax = "z"
vector = [1.0, 1.0, 1.0]
ds = fake_amr_ds(fields=("density",), units=("g/cm**3",))
ray = ds.ray((0.1, 0.2, 0.3), (0.6, 0.8, 0.5))
oray = ds.ortho_ray(0, (0.3, 0.4))
p = ProjectionPlot(ds, ax, ("gas", "density"))
p.annotate_ray(oray)
p.annotate_ray(ray)
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, ("gas", "density"))
p.annotate_ray(oray)
p.annotate_ray(ray)
assert_fname(p.save(prefix)[0])
p = OffAxisSlicePlot(ds, vector, ("gas", "density"))
p.annotate_ray(oray)
p.annotate_ray(ray)
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", ("gas", "density"))
p.annotate_ray(oray)
p.annotate_ray(ray, color="red")
p.save(prefix)
check_axis_manipulation(p, prefix)
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density",), units=("g/cm**3",), geometry="spherical")
ray = ds.ray((0.1, 0.2, 0.3), (0.6, 0.8, 0.5))
oray = ds.ortho_ray(0, (0.3, 0.4))
p = ProjectionPlot(ds, "r", ("gas", "density"))
assert_raises(YTDataTypeUnsupported, p.annotate_ray, oray)
assert_raises(YTDataTypeUnsupported, p.annotate_ray, ray)
def test_line_callback():
with _cleanup_fname() as prefix:
ax = "z"
vector = [1.0, 1.0, 1.0]
ds = fake_amr_ds(fields=("density",), units=("g/cm**3",))
p = ProjectionPlot(ds, ax, ("gas", "density"))
p.annotate_line([0.1, 0.1, 0.1], [0.5, 0.5, 0.5])
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, ("gas", "density"))
p.annotate_line([0.1, 0.1, 0.1], [0.5, 0.5, 0.5])
assert_fname(p.save(prefix)[0])
p = OffAxisSlicePlot(ds, vector, ("gas", "density"))
p.annotate_line([0.1, 0.1, 0.1], [0.5, 0.5, 0.5])
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", ("gas", "density"))
p.annotate_line([0.1, 0.1], [0.5, 0.5], coord_system="axis", color="red")
p.save(prefix)
check_axis_manipulation(p, prefix)
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density",), units=("g/cm**3",), geometry="spherical")
p = ProjectionPlot(ds, "r", ("gas", "density"))
assert_raises(
YTDataTypeUnsupported, p.annotate_line, [0.1, 0.1, 0.1], [0.5, 0.5, 0.5]
)
p.annotate_line([0.1, 0.1], [0.5, 0.5], coord_system="axis")
assert_fname(p.save(prefix)[0])
def test_particles_callback():
with _cleanup_fname() as prefix:
ax = 'z'
ds = fake_amr_ds(fields=("density", ), particles=1)
p = ProjectionPlot(ds, ax, "density")
p.annotate_particles((10, "Mpc"))
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, "density")
p.annotate_particles((10, "Mpc"))
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
ad = ds.all_data()
p.annotate_particles((10, "Mpc"),
p_size=1.0,
col="k",
marker="o",
stride=1,
ptype="all",
alpha=1.0,
data_source=ad)
p.save(prefix)
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density", ), geometry="spherical")
p = ProjectionPlot(ds, "r", "density")
p.annotate_particles((10, "Mpc"))
assert_raises(YTDataTypeUnsupported, p.save, prefix)
def test_grids_callback():
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields = ("density",))
for ax in 'xyz':
p = ProjectionPlot(ds, ax, "density")
p.annotate_grids()
assert_fname(p.save(prefix)[0])
p = ProjectionPlot(ds, ax, "density", weight_field="density")
p.annotate_grids()
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, "density")
p.annotate_grids()
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_grids(alpha=0.7, min_pix=10, min_pix_ids=30,
draw_ids=True, periodic=False, min_level=2,
max_level=3, cmap="gist_stern")
p.save(prefix)
with _cleanup_fname() as prefix:
ds = load(cyl_2d)
slc = SlicePlot(ds, "theta", "density")
slc.annotate_grids()
assert_fname(slc.save(prefix)[0])
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields = ("density",), geometry="spherical")
p = SlicePlot(ds, "r", "density")
p.annotate_grids(alpha=0.7, min_pix=10, min_pix_ids=30,
draw_ids=True, periodic=False, min_level=2,
max_level=3, cmap="gist_stern")
assert_raises(YTDataTypeUnsupported, p.save, prefix)
def test_sphere_callback():
with _cleanup_fname() as prefix:
ax = "z"
vector = [1.0, 1.0, 1.0]
ds = fake_amr_ds(fields=("density",))
p = ProjectionPlot(ds, ax, "density")
p.annotate_sphere([0.5, 0.5, 0.5], 0.1)
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, "density")
p.annotate_sphere([0.5, 0.5, 0.5], 0.1)
assert_fname(p.save(prefix)[0])
p = OffAxisSlicePlot(ds, vector, "density")
p.annotate_sphere([0.5, 0.5, 0.5], 0.1)
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_sphere([0.5, 0.5], 0.1, coord_system="axis", text="blah")
p.save(prefix)
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density",), geometry="spherical")
p = ProjectionPlot(ds, "r", "density")
p.annotate_sphere([0.5, 0.5, 0.5], 0.1)
assert_raises(YTDataTypeUnsupported, p.save, prefix)
p = ProjectionPlot(ds, "r", "density")
p.annotate_sphere([0.5, 0.5], 0.1, coord_system="axis", text="blah")
assert_fname(p.save(prefix)[0])
def test_line_integral_convolution_callback():
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density", "velocity_x", "velocity_y",
"velocity_z"))
for ax in 'xyz':
p = ProjectionPlot(ds, ax, "density")
p.annotate_line_integral_convolution("velocity_x", "velocity_y")
assert_fname(p.save(prefix)[0])
p = ProjectionPlot(ds, ax, "density", weight_field="density")
p.annotate_line_integral_convolution("velocity_x", "velocity_y")
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, "density")
p.annotate_line_integral_convolution("velocity_x", "velocity_y")
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_line_integral_convolution("velocity_x",
"velocity_y",
kernellen=100.,
lim=(0.4, 0.7),
cmap=ytcfg.get(
"yt", "default_colormap"),
alpha=0.9,
const_alpha=True)
p.save(prefix)
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density", "velocity_r", "velocity_theta",
"velocity_phi"),
geometry="spherical")
p = SlicePlot(ds, "r", "density")
p.annotate_line_integral_convolution("velocity_theta", "velocity_phi")
assert_raises(YTDataTypeUnsupported, p.save, prefix)
def test_text_callback():
with _cleanup_fname() as prefix:
ax = 'z'
vector = [1.0, 1.0, 1.0]
ds = fake_amr_ds(fields=("density", ))
p = ProjectionPlot(ds, ax, "density")
p.annotate_text([0.5, 0.5, 0.5], 'dinosaurs!')
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, "density")
p.annotate_text([0.5, 0.5, 0.5], 'dinosaurs!')
assert_fname(p.save(prefix)[0])
p = OffAxisSlicePlot(ds, vector, "density")
p.annotate_text([0.5, 0.5, 0.5], 'dinosaurs!')
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_text([0.5, 0.5],
'dinosaurs!',
coord_system='axis',
text_args={'color': 'red'})
p.save(prefix)
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density", ), geometry="spherical")
p = ProjectionPlot(ds, "r", "density")
p.annotate_text([0.5, 0.5, 0.5], 'dinosaurs!')
assert_raises(YTDataTypeUnsupported, p.save, prefix)
p = ProjectionPlot(ds, "r", "density")
p.annotate_text([0.5, 0.5],
'dinosaurs!',
coord_system='axis',
text_args={'color': 'red'})
assert_fname(p.save(prefix)[0])
def test_cell_edges_callback():
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density", ))
for ax in 'xyz':
p = ProjectionPlot(ds, ax, "density")
p.annotate_cell_edges()
assert_fname(p.save(prefix)[0])
p = ProjectionPlot(ds, ax, "density", weight_field="density")
p.annotate_cell_edges()
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, "density")
p.annotate_cell_edges()
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_cell_edges(alpha=0.7, line_width=0.9, color=(0.0, 1.0, 1.0))
p.save(prefix)
with _cleanup_fname() as prefix:
ds = load(cyl_2d)
slc = SlicePlot(ds, "theta", "density")
slc.annotate_cell_edges()
assert_fname(slc.save(prefix)[0])
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density", ), geometry="spherical")
p = SlicePlot(ds, "r", "density")
p.annotate_cell_edges()
assert_raises(YTDataTypeUnsupported, p.save, prefix)
def test_quiver_callback():
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density", "velocity_x", "velocity_y",
"velocity_z"))
for ax in 'xyz':
p = ProjectionPlot(ds, ax, "density")
p.annotate_quiver("velocity_x", "velocity_y")
yield assert_fname, p.save(prefix)[0]
p = ProjectionPlot(ds, ax, "density", weight_field="density")
p.annotate_quiver("velocity_x", "velocity_y")
yield assert_fname, p.save(prefix)[0]
p = SlicePlot(ds, ax, "density")
p.annotate_quiver("velocity_x", "velocity_y")
yield assert_fname, p.save(prefix)[0]
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_quiver("velocity_x",
"velocity_y",
factor=8,
scale=0.5,
scale_units="inches",
normalize=True,
bv_x=0.5 * u.cm / u.s,
bv_y=0.5 * u.cm / u.s)
p.save(prefix)
def test_text_callback():
with _cleanup_fname() as prefix:
ax = "z"
vector = [1.0, 1.0, 1.0]
ds = fake_amr_ds(fields=("density",), units=("g/cm**3",))
p = ProjectionPlot(ds, ax, ("gas", "density"))
p.annotate_text([0.5, 0.5, 0.5], "dinosaurs!")
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, ("gas", "density"))
p.annotate_text([0.5, 0.5, 0.5], "dinosaurs!")
assert_fname(p.save(prefix)[0])
p = OffAxisSlicePlot(ds, vector, ("gas", "density"))
p.annotate_text([0.5, 0.5, 0.5], "dinosaurs!")
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", ("gas", "density"))
p.annotate_text(
[0.5, 0.5], "dinosaurs!", coord_system="axis", text_args={"color": "red"}
)
p.save(prefix)
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density",), units=("g/cm**3",), geometry="spherical")
p = ProjectionPlot(ds, "r", ("gas", "density"))
p.annotate_text([0.5, 0.5, 0.5], "dinosaurs!")
assert_raises(YTDataTypeUnsupported, p.save, prefix)
p = ProjectionPlot(ds, "r", ("gas", "density"))
p.annotate_text(
[0.5, 0.5], "dinosaurs!", coord_system="axis", text_args={"color": "red"}
)
assert_fname(p.save(prefix)[0])
def test_ray_callback():
with _cleanup_fname() as prefix:
ax = 'z'
vector = [1.0, 1.0, 1.0]
ds = fake_amr_ds(fields=("density", ))
ray = ds.ray((0.1, 0.2, 0.3), (.6, .8, .5))
oray = ds.ortho_ray(0, (0.3, 0.4))
p = ProjectionPlot(ds, ax, "density")
p.annotate_ray(oray)
p.annotate_ray(ray)
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, "density")
p.annotate_ray(oray)
p.annotate_ray(ray)
assert_fname(p.save(prefix)[0])
p = OffAxisSlicePlot(ds, vector, "density")
p.annotate_ray(oray)
p.annotate_ray(ray)
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_ray(oray)
p.annotate_ray(ray, plot_args={'color': 'red'})
p.save(prefix)
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density", ), geometry="spherical")
ray = ds.ray((0.1, 0.2, 0.3), (0.6, 0.8, 0.5))
oray = ds.ortho_ray(0, (0.3, 0.4))
p = ProjectionPlot(ds, "r", "density")
p.annotate_ray(oray)
assert_raises(YTDataTypeUnsupported, p.save, prefix)
p = ProjectionPlot(ds, "r", "density")
p.annotate_ray(ray)
assert_raises(YTDataTypeUnsupported, p.save, prefix)
def test_velocity_callback():
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density", "velocity_x", "velocity_y",
"velocity_z"))
for ax in 'xyz':
p = ProjectionPlot(ds, ax, "density", weight_field="density")
p.annotate_velocity()
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, "density")
p.annotate_velocity()
assert_fname(p.save(prefix)[0])
# Test for OffAxis Slice
p = SlicePlot(ds, [1, 1, 0], 'density', north_vector=[0, 0, 1])
p.annotate_velocity(factor=40, normalize=True)
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_velocity(factor=8,
scale=0.5,
scale_units="inches",
normalize=True)
assert_fname(p.save(prefix)[0])
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density", "velocity_r", "velocity_theta",
"velocity_phi"),
geometry="spherical")
p = ProjectionPlot(ds, "r", "density")
p.annotate_velocity(factor=40, normalize=True)
assert_raises(YTDataTypeUnsupported, p.save, prefix)
def test_magnetic_callback():
with _cleanup_fname() as prefix:
ds = fake_amr_ds(
fields=(
"density",
"magnetic_field_x",
"magnetic_field_y",
"magnetic_field_z",
)
)
for ax in "xyz":
p = ProjectionPlot(ds, ax, "density", weight_field="density")
p.annotate_magnetic_field()
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, "density")
p.annotate_magnetic_field()
assert_fname(p.save(prefix)[0])
# Test for OffAxis Slice
p = SlicePlot(ds, [1, 1, 0], "density", north_vector=[0, 0, 1])
p.annotate_magnetic_field(factor=40, normalize=True)
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_magnetic_field(
factor=8, scale=0.5, scale_units="inches", normalize=True
)
assert_fname(p.save(prefix)[0])
with _cleanup_fname() as prefix:
ds = load(cyl_2d)
slc = SlicePlot(ds, "theta", "magnetic_field_strength")
slc.annotate_magnetic_field()
assert_fname(slc.save(prefix)[0])
with _cleanup_fname() as prefix:
ds = load(cyl_3d)
for ax in ["r", "z", "theta"]:
slc = SlicePlot(ds, ax, "magnetic_field_strength")
slc.annotate_magnetic_field()
assert_fname(slc.save(prefix)[0])
slc = ProjectionPlot(ds, ax, "magnetic_field_strength")
slc.annotate_magnetic_field()
assert_fname(slc.save(prefix)[0])
with _cleanup_fname() as prefix:
ds = fake_amr_ds(
fields=(
"density",
"magnetic_field_r",
"magnetic_field_theta",
"magnetic_field_phi",
),
geometry="spherical",
)
p = ProjectionPlot(ds, "r", "density")
p.annotate_magnetic_field(
factor=8, scale=0.5, scale_units="inches", normalize=True
)
assert_raises(YTDataTypeUnsupported, p.save, prefix)
def test_grids_callback():
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density",), units=("g/cm**3",))
for ax in "xyz":
p = ProjectionPlot(ds, ax, ("gas", "density"))
p.annotate_grids()
assert_fname(p.save(prefix)[0])
p = ProjectionPlot(
ds, ax, ("gas", "density"), weight_field=("gas", "density")
)
p.annotate_grids()
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, ("gas", "density"))
p.annotate_grids()
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", ("gas", "density"))
p.annotate_grids(
alpha=0.7,
min_pix=10,
min_pix_ids=30,
draw_ids=True,
id_loc="upper right",
periodic=False,
min_level=2,
max_level=3,
cmap="gist_stern",
)
p.save(prefix)
with _cleanup_fname() as prefix:
ds = load(cyl_2d)
slc = SlicePlot(ds, "theta", ("gas", "density"))
slc.annotate_grids()
assert_fname(slc.save(prefix)[0])
check_axis_manipulation(slc, prefix)
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density",), units=("g/cm**3",), geometry="spherical")
p = SlicePlot(ds, "r", ("gas", "density"))
kwargs = dict(
alpha=0.7,
min_pix=10,
min_pix_ids=30,
draw_ids=True,
id_loc="upper right",
periodic=False,
min_level=2,
max_level=3,
cmap="gist_stern",
)
assert_raises(YTDataTypeUnsupported, p.annotate_grids, **kwargs)
def test_contour_callback():
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields = ("density", "temperature"))
for ax in 'xyz':
p = ProjectionPlot(ds, ax, "density")
p.annotate_contour("temperature")
assert_fname(p.save(prefix)[0])
p = ProjectionPlot(ds, ax, "density", weight_field="density")
p.annotate_contour("temperature")
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, "density")
p.annotate_contour("temperature") # BREAKS WITH ndarray
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_contour("temperature", ncont=10, factor=8,
take_log=False, clim=(0.4, 0.6),
plot_args={'linewidths':2.0}, label=True,
text_args={'text-size':'x-large'})
p.save(prefix)
p = SlicePlot(ds, "x", "density")
s2 = ds.slice(0, 0.2)
p.annotate_contour("temperature", ncont=10, factor=8,
take_log=False, clim=(0.4, 0.6),
plot_args={'linewidths':2.0}, label=True,
text_args={'text-size':'x-large'},
data_source=s2)
p.save(prefix)
with _cleanup_fname() as prefix:
ds = load(cyl_2d)
slc = SlicePlot(ds, "theta", "plasma_beta")
slc.annotate_contour("plasma_beta",
ncont=2,
factor=7.,
take_log=False,
clim=(1.e-1,1.e1),
label=True,
plot_args={"colors": ("c","w"), "linewidths": 1},
text_args={"fmt": "%1.1f"})
assert_fname(slc.save(prefix)[0])
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields = ("density", "temperature"),
geometry="spherical")
p = SlicePlot(ds, "r", "density")
p.annotate_contour("temperature", ncont=10, factor=8,
take_log=False, clim=(0.4, 0.6),
plot_args={'linewidths':2.0}, label=True,
text_args={'text-size':'x-large'})
assert_raises(YTDataTypeUnsupported, p.save, prefix)
def test_contour_callback():
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density", "temperature"))
for ax in 'xyz':
p = ProjectionPlot(ds, ax, "density")
p.annotate_contour("temperature")
assert_fname(p.save(prefix)[0])
p = ProjectionPlot(ds, ax, "density", weight_field="density")
p.annotate_contour("temperature")
assert_fname(p.save(prefix)[0])
p = SlicePlot(ds, ax, "density")
p.annotate_contour("temperature") # BREAKS WITH ndarray
assert_fname(p.save(prefix)[0])
# Now we'll check a few additional minor things
p = SlicePlot(ds, "x", "density")
p.annotate_contour("temperature",
ncont=10,
factor=8,
take_log=False,
clim=(0.4, 0.6),
plot_args={'lw': 2.0},
label=True,
text_args={'text-size': 'x-large'})
p.save(prefix)
p = SlicePlot(ds, "x", "density")
s2 = ds.slice(0, 0.2)
p.annotate_contour("temperature",
ncont=10,
factor=8,
take_log=False,
clim=(0.4, 0.6),
plot_args={'lw': 2.0},
label=True,
text_args={'text-size': 'x-large'},
data_source=s2)
p.save(prefix)
with _cleanup_fname() as prefix:
ds = fake_amr_ds(fields=("density", "temperature"),
geometry="spherical")
p = SlicePlot(ds, "r", "density")
p.annotate_contour("temperature",
ncont=10,
factor=8,
take_log=False,
clim=(0.4, 0.6),
plot_args={'lw': 2.0},
label=True,
text_args={'text-size': 'x-large'})
assert_raises(YTDataTypeUnsupported, p.save, prefix)
def test_mesh_lines_callback():
with _cleanup_fname() as prefix:
ds = fake_hexahedral_ds()
for field in ds.field_list:
sl = SlicePlot(ds, 1, field)
sl.annotate_mesh_lines(plot_args={'color': 'black'})
assert_fname(sl.save(prefix)[0])
ds = fake_tetrahedral_ds()
for field in ds.field_list:
sl = SlicePlot(ds, 1, field)
sl.annotate_mesh_lines(plot_args={'color': 'black'})
assert_fname(sl.save(prefix)[0])
def test_mesh_lines_callback():
with _cleanup_fname() as prefix:
ds = fake_hexahedral_ds()
for field in ds.field_list:
sl = SlicePlot(ds, 1, field)
sl.annotate_mesh_lines(color="black")
assert_fname(sl.save(prefix)[0])
ds = fake_tetrahedral_ds()
for field in ds.field_list:
sl = SlicePlot(ds, 1, field)
sl.annotate_mesh_lines(color="black")
assert_fname(sl.save(prefix)[0])
check_axis_manipulation(sl, prefix) # only test the final field
def test_on_off_compare():
# fake density field that varies in the x-direction only
den = np.arange(32 ** 3) / 32 ** 2 + 1
den = den.reshape(32, 32, 32)
den = np.array(den, dtype=np.float64)
data = dict(density=(den, "g/cm**3"))
bbox = np.array([[-1.5, 1.5], [-1.5, 1.5], [-1.5, 1.5]])
ds = load_uniform_grid(data, den.shape, length_unit="Mpc", bbox=bbox, nprocs=64)
sl_on = SlicePlot(ds, "z", [("gas", "density")])
L = [0, 0, 1]
north_vector = [0, 1, 0]
sl_off = OffAxisSlicePlot(
ds, L, ("gas", "density"), center=[0, 0, 0], north_vector=north_vector
)
assert_array_almost_equal(
sl_on.frb[("gas", "density")], sl_off.frb[("gas", "density")]
)
sl_on.set_buff_size((800, 400))
sl_on._recreate_frb()
sl_off.set_buff_size((800, 400))
sl_off._recreate_frb()
assert_array_almost_equal(
sl_on.frb[("gas", "density")], sl_off.frb[("gas", "density")]
)
def test_symlog_colorbar():
ds = fake_random_ds(16)
def _thresh_density(field, data):
wh = data[("gas", "density")] < 0.5
ret = data[("gas", "density")]
ret[wh] = 0
return ret
def _neg_density(field, data):
return -data[("gas", "threshold_density")]
ds.add_field(
("gas", "threshold_density"),
function=_thresh_density,
units="g/cm**3",
sampling_type="cell",
)
ds.add_field(
("gas", "negative_density"),
function=_neg_density,
units="g/cm**3",
sampling_type="cell",
)
for field in [
("gas", "density"),
("gas", "threshold_density"),
("gas", "negative_density"),
]:
plot = SlicePlot(ds, 2, field)
plot.set_log(field, True, linthresh=0.1)
with tempfile.NamedTemporaryFile(suffix="png") as f:
plot.save(f.name)
def test_set_background_color():
ds = fake_random_ds(32)
plot = SlicePlot(ds, 2, ("gas", "density"))
plot.set_background_color(("gas", "density"), "red")
plot._setup_plots()
ax = plot.plots[("gas", "density")].axes
assert_equal(ax.get_facecolor(), (1.0, 0.0, 0.0, 1.0))
def test_frb_regen():
ds = fake_random_ds(32)
slc = SlicePlot(ds, 2, ("gas", "density"))
slc.set_buff_size(1200)
assert_equal(slc.frb[("gas", "density")].shape, (1200, 1200))
slc.set_buff_size((400.0, 200.7))
assert_equal(slc.frb[("gas", "density")].shape, (200, 400))
def setUp(self):
if self.ds is None:
self.ds = fake_random_ds(64)
self.slc = SlicePlot(self.ds, 0, "density")
self.tmpdir = tempfile.mkdtemp()
self.curdir = os.getcwd()
os.chdir(self.tmpdir)
def test_symlog_colorbar():
ds = fake_random_ds(16)
def _thresh_density(field, data):
wh = data['density'] < 0.5
ret = data['density']
ret[wh] = 0
return ret
def _neg_density(field, data):
return -data['threshold_density']
ds.add_field('threshold_density',
function=_thresh_density,
units='g/cm**3',
sampling_type='cell')
ds.add_field('negative_density',
function=_neg_density,
units='g/cm**3',
sampling_type='cell')
for field in ['density', 'threshold_density', 'negative_density']:
plot = SlicePlot(ds, 2, field)
plot.set_log(field, True, linthresh=0.1)
with tempfile.NamedTemporaryFile(suffix='png') as f:
plot.save(f.name)
