def test_perspective_lens(self):
sc = Scene()
cam = sc.add_camera(self.ds, lens_type='perspective')
cam.position = self.ds.arr(np.array([1.0, 1.0, 1.0]), 'code_length')
vol = VolumeSource(self.ds, field=self.field)
tf = vol.transfer_function
tf.grey_opacity = True
sc.add_source(vol)
sc.render()
sc.save('test_perspective_%s.png' % self.field[1], sigma_clip=6.0)
def test_points_vr(self):
ds = fake_random_ds(64)
dd = ds.sphere(ds.domain_center, 0.45 * ds.domain_width[0])
ds.field_info[ds.field_list[0]].take_log = False
sc = Scene()
cam = sc.add_camera(ds)
cam.resolution = (512, 512)
vr = VolumeSource(dd, field=ds.field_list[0])
vr.transfer_function.clear()
vr.transfer_function.grey_opacity = False
vr.transfer_function.map_to_colormap(0.0,
1.0,
scale=10.,
colormap="Reds")
sc.add_source(vr)
cam.set_width(1.8 * ds.domain_width)
cam.lens.setup_box_properties(cam)
# DRAW SOME POINTS
npoints = 1000
vertices = np.random.random([npoints, 3])
colors = np.random.random([npoints, 4])
colors[:, 3] = 0.10
points_source = PointSource(vertices, colors=colors)
sc.add_source(points_source)
im = sc.render()
im.write_png("points.png")
return im
def test_composite_vr(self):
ds = fake_random_ds(64)
dd = ds.sphere(ds.domain_center, 0.45 * ds.domain_width[0])
ds.field_info[ds.field_list[0]].take_log = False
sc = Scene()
cam = sc.add_camera(ds)
cam.resolution = (512, 512)
vr = VolumeSource(dd, field=ds.field_list[0])
vr.transfer_function.clear()
vr.transfer_function.grey_opacity = True
vr.transfer_function.map_to_colormap(0.0, 1.0, scale=10.0, colormap="Reds")
sc.add_source(vr)
cam.set_width(1.8 * ds.domain_width)
cam.lens.setup_box_properties(cam)
# Create Arbitrary Z-buffer
empty = cam.lens.new_image(cam)
z = np.empty(empty.shape[:2], dtype="float64")
# Let's put a blue plane right through the center
z[:] = cam.width[2] / 2.0
empty[:, :, 2] = 1.0 # Set blue to 1's
empty[:, :, 3] = 1.0 # Set alpha to 1's
zbuffer = ZBuffer(empty, z)
zsource = OpaqueSource()
zsource.set_zbuffer(zbuffer)
sc.add_source(zsource)
im = sc.render()
im.write_png("composite.png")
def test_spherical_lens(self):
sc = Scene()
cam = sc.add_camera(self.ds, lens_type='spherical')
cam.resolution = [512, 256]
cam.position = self.ds.arr(np.array([0.6, 0.5, 0.5]), 'code_length')
vol = VolumeSource(self.ds, field=self.field)
tf = vol.transfer_function
tf.grey_opacity = True
sc.add_source(vol)
sc.render()
sc.save('test_spherical_%s.png' % self.field[1], sigma_clip=6.0)
def test_plane_lens(self):
dd = self.ds.sphere(self.ds.domain_center,
self.ds.domain_width[0] / 10)
sc = Scene()
cam = sc.add_camera(dd, lens_type='plane-parallel')
cam.set_width(self.ds.domain_width * 1e-2)
v, c = self.ds.find_max('density')
vol = VolumeSource(dd, field=self.field)
tf = vol.transfer_function
tf.grey_opacity = True
sc.add_source(vol)
sc.render()
sc.save('test_plane_%s.png' % self.field[1], sigma_clip=6.0)
def test_fisheye_lens(self):
dd = self.ds.sphere(self.ds.domain_center,
self.ds.domain_width[0] / 10)
sc = Scene()
cam = sc.add_camera(dd, lens_type='fisheye')
cam.lens.fov = 360.0
cam.set_width(self.ds.domain_width)
v, c = self.ds.find_max('density')
cam.set_position(c - 0.0005 * self.ds.domain_width)
vol = VolumeSource(dd, field=self.field)
tf = vol.transfer_function
tf.grey_opacity = True
sc.add_source(vol)
sc.render()
sc.save('test_fisheye_%s.png' % self.field[1], sigma_clip=6.0)
def test_perspective_lens(self):
sc = Scene()
cam = sc.add_camera(self.ds, lens_type="perspective")
cam.position = self.ds.arr(np.array([1.0, 1.0, 1.0]), "code_length")
vol = create_volume_source(self.ds, field=self.field)
tf = vol.transfer_function
tf.grey_opacity = True
sc.add_source(vol)
sc.save(f"test_perspective_{self.field[1]}.png", sigma_clip=6.0)
def test_spherical_lens(self):
sc = Scene()
cam = sc.add_camera(self.ds, lens_type="spherical")
cam.resolution = [256, 128]
cam.position = self.ds.arr(np.array([0.6, 0.5, 0.5]), "code_length")
vol = VolumeSource(self.ds, field=self.field)
tf = vol.transfer_function
tf.grey_opacity = True
sc.add_source(vol)
sc.save("test_spherical_%s.png" % self.field[1], sigma_clip=6.0)
def test_stereoperspective_lens(self):
sc = Scene()
cam = sc.add_camera(self.ds, lens_type="stereo-perspective")
cam.resolution = [1024, 512]
cam.position = self.ds.arr(np.array([0.7, 0.7, 0.7]), "code_length")
vol = VolumeSource(self.ds, field=self.field)
tf = vol.transfer_function
tf.grey_opacity = True
sc.add_source(vol)
sc.save("test_stereoperspective_%s.png" % self.field[1], sigma_clip=6.0)
def test_plane_lens(self):
dd = self.ds.sphere(self.ds.domain_center, self.ds.domain_width[0] / 10)
sc = Scene()
cam = sc.add_camera(dd, lens_type="plane-parallel")
cam.set_width(self.ds.domain_width * 1e-2)
v, c = self.ds.find_max("density")
vol = create_volume_source(dd, field=self.field)
tf = vol.transfer_function
tf.grey_opacity = True
sc.add_source(vol)
sc.save(f"test_plane_{self.field[1]}.png", sigma_clip=6.0)
def test_stereospherical_lens(self):
w = (self.ds.domain_width).in_units("code_length")
w = self.ds.arr(w, "code_length")
sc = Scene()
cam = sc.add_camera(self.ds, lens_type="stereo-spherical")
cam.resolution = [256, 256]
cam.position = self.ds.arr(np.array([0.6, 0.5, 0.5]), "code_length")
vol = create_volume_source(self.ds, field=self.field)
tf = vol.transfer_function
tf.grey_opacity = True
sc.add_source(vol)
sc.save(f"test_stereospherical_{self.field[1]}.png", sigma_clip=6.0)
def test_fisheye_lens(self):
dd = self.ds.sphere(self.ds.domain_center, self.ds.domain_width[0] / 10)
sc = Scene()
cam = sc.add_camera(dd, lens_type="fisheye")
cam.lens.fov = 360.0
cam.set_width(self.ds.domain_width)
v, c = self.ds.find_max("density")
cam.set_position(c - 0.0005 * self.ds.domain_width)
vol = create_volume_source(dd, field=self.field)
tf = vol.transfer_function
tf.grey_opacity = True
sc.add_source(vol)
sc.save(f"test_fisheye_{self.field[1]}.png", sigma_clip=6.0)
def test_bounding_volume_hierarchy():
ds = yt.load(fn)
vertices = ds.index.meshes[0].connectivity_coords
indices = ds.index.meshes[0].connectivity_indices - 1
ad = ds.all_data()
field_data = ad["connect1", "diffused"]
bvh = BVH(vertices, indices, field_data)
sc = Scene()
cam = Camera(sc)
cam.set_position(np.array([8.0, 8.0, 8.0]))
cam.focus = np.array([0.0, 0.0, 0.0])
origins, direction = get_rays(cam)
image = np.empty(800 * 800, np.float64)
test_ray_trace(image, origins, direction, bvh)
image = image.reshape((800, 800))
return image
def composite_mesh_render(engine):
ytcfg["yt", "ray_tracing_engine"] = engine
ds = data_dir_load(hex8)
sc = Scene()
cam = sc.add_camera(ds)
cam.focus = ds.arr([0.0, 0.0, 0.0], 'code_length')
cam.set_position(ds.arr([-3.0, 3.0, -3.0], 'code_length'),
ds.arr([0.0, -1.0, 0.0], 'dimensionless'))
cam.set_width = ds.arr([8.0, 8.0, 8.0], 'code_length')
cam.resolution = (800, 800)
ms1 = MeshSource(ds, ('connect1', 'diffused'))
ms2 = MeshSource(ds, ('connect2', 'diffused'))
sc.add_source(ms1)
sc.add_source(ms2)
im = sc.render()
return compare(ds, im, "%s_composite_mesh_render" % engine)
def doit(plotfile):
ds = yt.load(plotfile)
ds.periodicity = (True, True, True)
field = ('boxlib', 'radial_velocity')
ds._get_field_info(field).take_log = False
sc = Scene()
# add a volume: select a sphere
center = (0, 0, 0)
R = (5.e8, 'cm')
dd = ds.sphere(center, R)
vol = VolumeSource(dd, field=field)
vol.use_ghost_zones = True
sc.add_source(vol)
# transfer function
vals = [-5.e6, -2.5e6, -1.25e6, 1.25e6, 2.5e6, 5.e6]
sigma = 3.e5
tf = yt.ColorTransferFunction((min(vals), max(vals)))
tf.clear()
cm = "coolwarm"
for v in vals:
tf.sample_colormap(v, sigma**2, colormap=cm) #, alpha=0.2)
sc.get_source(0).transfer_function = tf
cam = sc.add_camera(ds, lens_type="perspective")
cam.resolution = (1280, 720)
cam.position = 1.5*ds.arr(np.array([5.e8, 5.e8, 5.e8]), 'cm')
# look toward the center -- we are dealing with an octant
center = ds.domain_left_edge
normal = (center - cam.position)
normal /= np.sqrt(normal.dot(normal))
cam.switch_orientation(normal_vector=normal,
north_vector=[0., 0., 1.])
cam.set_width(ds.domain_width)
#sc.annotate_axes()
#sc.annotate_domain(ds)
sc.render()
sc.save("subchandra_test.png", sigma_clip=6.0)
sc.save_annotated("subchandra_test_annotated.png",
text_annotate=[[(0.05, 0.05),
"t = {}".format(ds.current_time.d),
dict(horizontalalignment="left")],
[(0.5,0.95),
"Maestro simulation of He convection on a white dwarf",
dict(color="y", fontsize="24",
horizontalalignment="center")]])
def doit(plotfile):
ds = yt.load(plotfile)
ds.periodicity = (True, True, True)
cm = "coolwarm"
field = ('boxlib', 'density')
ds._get_field_info(field).take_log = True
sc = Scene()
# add a volume: select a sphere
vol = VolumeSource(ds, field=field)
sc.add_source(vol)
# transfer function
vals = [-1, 0, 1, 2, 4, 5, 6, 7]
#vals = [0.1, 1.0, 10, 100., 1.e4, 1.e5, 1.e6, 1.e7]
sigma = 0.1
tf = yt.ColorTransferFunction((min(vals), max(vals)))
tf.clear()
cm = "coolwarm"
cm = "spectral"
for v in vals:
if v < 4:
alpha = 0.1
else:
alpha = 0.5
tf.sample_colormap(v, sigma**2, colormap=cm, alpha=alpha)
sc.get_source(0).transfer_function = tf
cam = Camera(ds, lens_type="perspective")
cam.resolution = (1280, 720)
cam.position = 1.5*ds.arr(np.array([0.0, 5.e9, 5.e9]), 'cm')
# look toward the center -- we are dealing with an octant
center = 0.5*(ds.domain_left_edge + ds.domain_right_edge)
normal = (center - cam.position)
normal /= np.sqrt(normal.dot(normal))
cam.switch_orientation(normal_vector=normal,
north_vector=[0., 0., 1.])
cam.set_width(ds.domain_width)
sc.camera = cam
#sc.annotate_axes()
#sc.annotate_domain(ds)
pid = plotfile.split("plt")[1]
sc.render()
sc.save("wdmerger_{}.png".format(pid), sigma_clip=6.0)
sc.save_annotated("wdmerger_annotated_{}.png".format(pid),
text_annotate=[[(0.05, 0.05),
"t = {:.3f}".format(float(ds.current_time.d)),
dict(horizontalalignment="left")],
[(0.5,0.95),
"Castro simulation of merging white dwarfs",
dict(color="y", fontsize="24",
horizontalalignment="center")]])
def test_scene_and_camera_attributes():
ds = fake_random_ds(64, length_unit=2, bbox=np.array([[-1, 1], [-1, 1], [-1, 1]]))
sc = Scene()
cam = sc.add_camera(ds)
# test that initial values are correct in code units
assert_equal(cam.width, ds.arr([3, 3, 3], "code_length"))
assert_equal(cam.position, ds.arr([1, 1, 1], "code_length"))
assert_equal(cam.focus, ds.arr([0, 0, 0], "code_length"))
# test setting the attributes in various ways
attribute_values = [
(1, ds.arr([2, 2, 2], "code_length"),),
([1], ds.arr([2, 2, 2], "code_length"),),
([1, 2], RuntimeError,),
([1, 1, 1], ds.arr([2, 2, 2], "code_length"),),
((1, "code_length"), ds.arr([1, 1, 1], "code_length"),),
(((1, "code_length"), (1, "code_length")), RuntimeError,),
(((1, "cm"), (2, "cm"), (3, "cm")), ds.arr([0.5, 1, 1.5], "code_length"),),
(2 * u.cm, ds.arr([1, 1, 1], "code_length"),),
(ds.arr(2, "cm"), ds.arr([1, 1, 1], "code_length"),),
([2 * u.cm], ds.arr([1, 1, 1], "code_length"),),
([1, 2, 3] * u.cm, ds.arr([0.5, 1, 1.5], "code_length"),),
([1, 2] * u.cm, RuntimeError,),
([u.cm * w for w in [1, 2, 3]], ds.arr([0.5, 1, 1.5], "code_length"),),
]
# define default values to avoid accidentally setting focus = position
default_values = {
"focus": [0, 0, 0],
"position": [4, 4, 4],
"width": [1, 1, 1],
}
attribute_list = list(default_values.keys())
for attribute in attribute_list:
for other_attribute in [a for a in attribute_list if a != attribute]:
setattr(cam, other_attribute, default_values[other_attribute])
for attribute_value, expected_result in attribute_values:
try:
# test properties
setattr(cam, attribute, attribute_value)
assert_almost_equal(getattr(cam, attribute), expected_result)
except RuntimeError:
assert expected_result is RuntimeError
try:
# test setters/getters
getattr(cam, "set_%s" % attribute)(attribute_value)
assert_almost_equal(
getattr(cam, "get_%s" % attribute)(), expected_result
)
except RuntimeError:
assert expected_result is RuntimeError
resolution_values = (
(512, (512, 512),),
((512, 512), (512, 512),),
((256, 512), (256, 512),),
((256, 256, 256), RuntimeError),
)
for resolution_value, expected_result in resolution_values:
try:
# test properties
cam.resolution = resolution_value
assert_equal(cam.resolution, expected_result)
except RuntimeError:
assert expected_result is RuntimeError
try:
# test setters/getters
cam.set_resolution(resolution_value)
assert_equal(cam.get_resolution(), expected_result)
except RuntimeError:
assert expected_result is RuntimeError
for lens_type in valid_lens_types:
cam.set_lens(lens_type)
# See issue #1287
cam.focus = [0, 0, 0]
cam_pos = [1, 0, 0]
north_vector = [0, 1, 0]
cam.set_position(cam_pos, north_vector)
cam_pos = [0, 1, 0]
north_vector = [0, 0, 1]
cam.set_position(cam_pos, north_vector)
import yt
from yt.visualization.volume_rendering.api import Scene, VolumeSource
import numpy as np
field = ("gas", "density")
# normal_vector points from camera to the center of tbe final projection.
# Now we look at the positive x direction.
normal_vector = [1., 0., 0.]
# north_vector defines the "top" direction of the projection, which is
# positive z direction here.
north_vector = [0., 0., 1.]
# Follow the simple_volume_rendering cookbook for the first part of this.
ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
sc = Scene()
vol = VolumeSource(ds, field=field)
tf = vol.transfer_function
tf.grey_opacity = True
# Plane-parallel lens
cam = sc.add_camera(ds, lens_type='plane-parallel')
# Set the resolution of tbe final projection.
cam.resolution = [250, 250]
# Set the location of the camera to be (x=0.2, y=0.5, z=0.5)
# For plane-parallel lens, the location info along the normal_vector (here
# is x=0.2) is ignored.
cam.position = ds.arr(np.array([0.2, 0.5, 0.5]), 'code_length')
# Set the orientation of the camera.
cam.switch_orientation(normal_vector=normal_vector, north_vector=north_vector)
# Set the width of the camera, where width[0] and width[1] specify the length and
def doit(plotfile, fname):
ds = yt.load(plotfile)
cm = "gist_rainbow"
if fname == "vz":
field = ('gas', 'velocity_z')
use_log = False
vals = [-1.e7, -5.e6, 5.e6, 1.e7]
sigma = 5.e5
fmt = None
cm = "coolwarm"
elif fname == "magvel":
field = ('gas', 'velocity_magnitude')
use_log = True
vals = [1.e5, 3.16e5, 1.e6, 3.16e6, 1.e7]
sigma = 0.1
elif fname == "enucdot":
field = ('boxlib', 'enucdot')
use_log = True
vals = [1.e16, 3.162e16, 1.e17, 3.162e17, 1.e18]
vals = list(10.0**numpy.array([16.5, 17.0, 17.5, 18.0, 18.5]))
sigma = 0.05
fmt = "%.3g"
# this is hackish, but there seems to be no better way to set whether
# you are rendering logs
ds._get_field_info(field).take_log = use_log
# hack periodicity
ds.periodicity = (True, True, True)
mi = min(vals)
ma = max(vals)
if use_log:
mi, ma = np.log10(mi), np.log10(ma)
print mi, ma
# setup the scene and camera
sc = Scene()
cam = Camera(ds, lens_type="perspective")
# Set up the camera parameters: center, looking direction, width, resolution
center = (ds.domain_right_edge + ds.domain_left_edge)/2.0
xmax, ymax, zmax = ds.domain_right_edge
# this shows something face on
c = np.array([-8.0*xmax, center[1], center[2]])
# the normal vector should be pointing back through the center
L = center.d - c
L = L/np.sqrt((L**2).sum())
north_vector=[0.0,0.0,1.0]
cam.position = ds.arr(c)
cam.switch_orientation(normal_vector=L, north_vector=north_vector)
cam.set_width(ds.domain_width*4)
cam.resolution = (720,720)
# create the volume source
vol = VolumeSource(ds, field=field)
# Instantiate the ColorTransferfunction.
tf = vol.transfer_function
tf = ColorTransferFunction((mi, ma))
#tf.grey_opacity=True
for v in vals:
if use_log:
tf.sample_colormap(math.log10(v), sigma**2, colormap=cm) #, alpha=0.2)
else:
print v
tf.sample_colormap(v, sigma**2, colormap=cm) #, alpha=0.2)
sc.camera = cam
sc.add_source(vol)
sc.render("test_perspective.png", clip_ratio=6.0)
def surface_mesh_render():
images = []
ds = fake_tetrahedral_ds()
for field in ds.field_list:
if field[0] == 'all':
continue
sc = Scene()
sc.add_source(MeshSource(ds, field))
sc.add_camera()
im = sc.render()
images.append(im)
ds = fake_hexahedral_ds()
for field in ds.field_list:
if field[0] == 'all':
continue
sc = Scene()
sc.add_source(MeshSource(ds, field))
sc.add_camera()
im = sc.render()
images.append(im)
return images
# Hack: because rendering likes log fields ...
## create positive_radial_velocity and negative_radial_velocity fields.
## must do this before opening dataset
@derived_field(name='pos_radial_velocity', units='cm/s')
def _pos_radial_velocity(field, data):
return np.maximum(data[('boxlib','radial_velocity')], 1.0e-99)
@derived_field(name='neg_radial_velocity', units='cm/s')
def _neg_radial_velocity(field, data):
return np.maximum(-data[('boxlib','radial_velocity')], 1.0e-99)
# Open Dataset
ds = yt.load(args.infile)
core = ds.sphere(ds.domain_center, (0.25e8, 'cm'))
# Create Scene
sc = Scene()
# Create Sources
so_enuc = VolumeSource(core, ('boxlib','enucdot'))
so_pos_vrad = VolumeSource(core, 'pos_radial_velocity')
so_neg_vrad = VolumeSource(core, 'neg_radial_velocity')
# Assign Transfer Functions to Sources
tfh_en = TransferFunctionHelper(ds)
tfh_en.set_field(('boxlib','enucdot'))
tfh_en.set_log(True)
tfh_en.set_bounds()
tfh_en.build_transfer_function()
tfh_en.tf.add_layers(10, colormap='black_green', w=0.01)
tfh_en.grey_opacity = False
tfh_en.plot('{}_tfun_enuc.png'.format(args.infile), profile_field=('boxlib','enucdot'))
# initialize the yt-specific data structure (ds)
# for more info read:
# http://yt-project.org/docs/dev/reference/api/generated/yt.frontends.stream.data_structures.load_uniform_grid.html?highlight=load_uniform_grid
# please note here the length unit should be different for three axis
# i used the unit for z-axis here for all three
# since yt's unit system only support one uniform unit for the 3-D space
ds = yt.load_uniform_grid(data,
dom.shape,
length_unit=0.20800511,
bbox=bbox,
nprocs=64)
# initialize the yt scene
sc = Scene()
vol = VolumeSource(ds, field=field)
# camera position
#hc = ds.arr([hx, hy, hz], 'cm') # hydrogen location
hc = ds.arr([19.13987520, 19.13987520, 82.13300000], 'cm') # hydrogen location
# Find the bounds in log space of for your field
dd = ds.all_data()
mi, ma = dd.quantities.extrema(field)
if use_log:
mi, ma = np.log10(mi), np.log10(ma)
# instantiating the ColorTransferfunction
tf = yt.ColorTransferFunction((mi, ma))
'''
def test_composite_vr(self):
ds = fake_random_ds(64)
dd = ds.sphere(ds.domain_center, 0.45*ds.domain_width[0])
ds.field_info[ds.field_list[0]].take_log=False
sc = Scene()
cam = sc.add_camera(ds)
cam.resolution = (512, 512)
vr = VolumeSource(dd, field=ds.field_list[0])
vr.transfer_function.clear()
vr.transfer_function.grey_opacity=True
vr.transfer_function.map_to_colormap(0.0, 1.0, scale=3.0, colormap="Reds")
sc.add_source(vr)
cam.set_width( 1.8*ds.domain_width )
cam.lens.setup_box_properties(cam)
# DRAW SOME LINES
npoints = 100
vertices = np.random.random([npoints, 2, 3])
colors = np.random.random([npoints, 4])
colors[:, 3] = 0.10
box_source = BoxSource(ds.domain_left_edge,
ds.domain_right_edge,
color=[1.0, 1.0, 1.0, 1.0])
sc.add_source(box_source)
LE = ds.domain_left_edge + np.array([0.1,0.,0.3])*ds.domain_left_edge.uq
RE = ds.domain_right_edge-np.array([0.1,0.2,0.3])*ds.domain_left_edge.uq
color = np.array([0.0, 1.0, 0.0, 0.10])
box_source = BoxSource(LE, RE, color=color)
sc.add_source(box_source)
line_source = LineSource(vertices, colors)
sc.add_source(line_source)
im = sc.render()
im = ImageArray(im.d)
im.write_png("composite.png")
return im
import numpy as np
import yt
from yt.visualization.volume_rendering.api import Scene, create_volume_source
ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
# create a scene and add volume sources to it
sc = Scene()
# Add density
field = "density"
vol = create_volume_source(ds, field=field)
vol.use_ghost_zones = True
tf = yt.ColorTransferFunction([-28, -25])
tf.clear()
tf.add_layers(4, 0.02, alpha=np.logspace(-3, -1, 4), colormap="winter")
vol.set_transfer_function(tf)
sc.add_source(vol)
# Add temperature
field = "temperature"
vol2 = create_volume_source(ds, field=field)
vol2.use_ghost_zones = True
def test_orientation():
ds = fake_vr_orientation_test_ds()
sc = Scene()
vol = VolumeSource(ds, field=('gas', 'density'))
sc.add_source(vol)
tf = vol.transfer_function
tf = ColorTransferFunction((0.1, 1.0))
tf.sample_colormap(1.0, 0.01, colormap="coolwarm")
tf.sample_colormap(0.8, 0.01, colormap="coolwarm")
tf.sample_colormap(0.6, 0.01, colormap="coolwarm")
tf.sample_colormap(0.3, 0.01, colormap="coolwarm")
n_frames = 1
orientations = [[-0.3, -0.1, 0.8]]
theta = np.pi / n_frames
decimals = 12
test_name = "vr_orientation"
for lens_type in ['plane-parallel', 'perspective']:
frame = 0
cam = sc.add_camera(ds, lens_type=lens_type)
cam.resolution = (1000, 1000)
cam.position = ds.arr(np.array([-4., 0., 0.]), 'code_length')
cam.switch_orientation(normal_vector=[1., 0., 0.],
north_vector=[0., 0., 1.])
cam.set_width(ds.domain_width * 2.)
desc = '%s_%04d' % (lens_type, frame)
test1 = VRImageComparisonTest(sc, ds, desc, decimals)
test1.answer_name = test_name
yield test1
for i in range(n_frames):
frame += 1
center = ds.arr([0, 0, 0], 'code_length')
cam.yaw(theta, rot_center=center)
desc = 'yaw_%s_%04d' % (lens_type, frame)
test2 = VRImageComparisonTest(sc, ds, desc, decimals)
test2.answer_name = test_name
yield test2
for i in range(n_frames):
frame += 1
theta = np.pi / n_frames
center = ds.arr([0, 0, 0], 'code_length')
cam.pitch(theta, rot_center=center)
desc = 'pitch_%s_%04d' % (lens_type, frame)
test3 = VRImageComparisonTest(sc, ds, desc, decimals)
test3.answer_name = test_name
yield test3
for i in range(n_frames):
frame += 1
theta = np.pi / n_frames
center = ds.arr([0, 0, 0], 'code_length')
cam.roll(theta, rot_center=center)
desc = 'roll_%s_%04d' % (lens_type, frame)
test4 = VRImageComparisonTest(sc, ds, desc, decimals)
test4.answer_name = test_name
yield test4
center = [0.5, 0.5, 0.5]
width = [1.0, 1.0, 1.0]
for i, orientation in enumerate(orientations):
image = off_axis_projection(ds,
center,
orientation,
width,
512,
"density",
no_ghost=False)
def offaxis_image_func(filename_prefix):
return image.write_image(filename_prefix)
test5 = GenericImageTest(ds, offaxis_image_func, decimals)
test5.prefix = "oap_orientation_{}".format(i)
test5.answer_name = test_name
yield test5
import yt
from yt.visualization.volume_rendering.api import Scene, VolumeSource
filePath = "Sedov_3d/sedov_hdf5_chk_0003"
ds = yt.load(filePath)
ds.periodicity = (True, True, True)
sc = Scene()
# set up camera
cam = sc.add_camera(ds, lens_type="perspective")
cam.resolution = [400, 400]
cam.position = ds.arr([1, 1, 1], "cm")
cam.switch_orientation()
# add rendering of density field
dens = VolumeSource(ds, field="dens")
dens.use_ghost_zones = True
sc.add_source(dens)
sc.save("density.png", sigma_clip=6)
# add rendering of x-velocity field
vel = VolumeSource(ds, field="velx")
vel.use_ghost_zones = True
sc.add_source(vel)
sc.save("density_any_velocity.png", sigma_clip=6)
def doit(plotfile):
ds = yt.load(plotfile)
ds.periodicity = (True, True, True)
field = ('boxlib', 'density')
ds._get_field_info(field).take_log = True
sc = Scene()
# add a volume: select a sphere
vol = VolumeSource(ds, field=field)
vol.use_ghost_zones = True
sc.add_source(vol)
# transfer function
vals = [-1, 0, 1, 2, 3, 4, 5, 6, 7]
#vals = [0.1, 1.0, 10, 100., 1.e4, 1.e5, 1.e6, 1.e7]
sigma = 0.1
tf = yt.ColorTransferFunction((min(vals), max(vals)))
tf.clear()
cm = "coolwarm"
cm = "spectral"
for v in vals:
if v < 3:
alpha = 0.1
else:
alpha = 0.5
tf.sample_colormap(v, sigma**2, colormap=cm, alpha=alpha)
sc.get_source(0).transfer_function = tf
cam = sc.add_camera(ds, lens_type="perspective")
cam.resolution = (1920, 1080)
cam.position = 1.5 * ds.arr(np.array([0.0, 5.e9, 5.e9]), 'cm')
# look toward the center -- we are dealing with an octant
center = 0.5 * (ds.domain_left_edge + ds.domain_right_edge)
normal = (center - cam.position)
normal /= np.sqrt(normal.dot(normal))
cam.switch_orientation(normal_vector=normal, north_vector=[0., 0., 1.])
cam.set_width(ds.domain_width)
#sc.annotate_axes()
#sc.annotate_domain(ds)
pid = plotfile.split("plt")[1]
sc.render()
sc.save("wdmerger_{}_new.png".format(pid), sigma_clip=6.0)
sc.save_annotated(
"wdmerger_annotated_{}_new.png".format(pid),
text_annotate=
[[(0.05, 0.05), "t = {:.3f} s".format(float(ds.current_time.d)),
dict(horizontalalignment="left")],
[(0.5, 0.95),
"Castro simulation of merging white dwarfs (0.6 $M_\odot$ + 0.9 $M_\odot$)",
dict(color="y", fontsize="22", horizontalalignment="center")],
[(0.95, 0.05), "M. Katz et al.",
dict(color="w", fontsize="16", horizontalalignment="right")]])
'--alpha_ones',
action='store_true',
help='If supplied, set the transfer function values to ones.')
parser.add_argument('-res',
'--resolution',
type=int,
default=2048,
help='Resolution for output plot.')
args = parser.parse_args()
# Open Dataset
ds = yt.load(args.infile)
core = ds.sphere(ds.domain_center, (args.rup, 'cm'))
# Create Scene
sc = Scene()
# Create Sources
so_circum_vel = VolumeSource(core, ('boxlib', 'circum_velocity'))
mag_vel_bounds = np.array([1.0e1, 1.0e6])
mag_vel_sigma = 0.08
nlayers = 6
if args.alpha_ones:
alphavec = np.ones(nlayers)
else:
alphavec = np.logspace(-5, 0, nlayers)
tfh = TransferFunctionHelper(ds)
tfh.set_field(('boxlib', 'circum_velocity'))
def doit(plotfile):
ds = yt.load(plotfile)
ds.periodicity = (True, True, True)
field = ('boxlib', 'radial_velocity')
ds._get_field_info(field).take_log = False
sc = Scene()
# add a volume: select a sphere
center = (0, 0, 0)
R = (5.e8, 'cm')
dd = ds.sphere(center, R)
vol = VolumeSource(dd, field=field)
vol.use_ghost_zones = True
sc.add_source(vol)
# transfer function
vals = [-5.e6, -2.5e6, -1.25e6, 1.25e6, 2.5e6, 5.e6]
sigma = 3.e5
tf = yt.ColorTransferFunction((min(vals), max(vals)))
tf.clear()
cm = "coolwarm"
for v in vals:
tf.sample_colormap(v, sigma**2, colormap=cm) #, alpha=0.2)
sc.get_source(0).transfer_function = tf
cam = sc.add_camera(ds, lens_type="perspective")
cam.resolution = (1280, 720)
cam.position = 1.5 * ds.arr(np.array([5.e8, 5.e8, 5.e8]), 'cm')
# look toward the center -- we are dealing with an octant
center = ds.domain_left_edge
normal = (center - cam.position)
normal /= np.sqrt(normal.dot(normal))
cam.switch_orientation(normal_vector=normal, north_vector=[0., 0., 1.])
cam.set_width(ds.domain_width)
#sc.annotate_axes()
#sc.annotate_domain(ds)
sc.render()
sc.save("subchandra_test.png", sigma_clip=6.0)
sc.save_annotated(
"subchandra_test_annotated.png",
text_annotate=[[(0.05, 0.05), "t = {}".format(ds.current_time.d),
dict(horizontalalignment="left")],
[(0.5, 0.95),
"Maestro simulation of He convection on a white dwarf",
dict(color="y",
fontsize="24",
horizontalalignment="center")]])
parser.add_argument('-alpha_ones', '--alpha_ones', action='store_true', help='If supplied, set the transfer function values to ones.')
parser.add_argument('-res', '--resolution', type=int, default=2048, help='Resolution for output plot.')
parser.add_argument('-dry', '--dry_run', action='store_true', help='Plot only the transfer functions and quit.')
args = parser.parse_args()
# Workaround
@derived_field(name='abs_ye_asymmetry', units='')
def _abs_ye_asymmetry(field, data):
return np.absolute(data['electron_fraction_asymmetry'])
# Open Dataset
ds = yt.load(args.infile)
core = ds.sphere(ds.domain_center, (args.rup, 'cm'))
# Create Scene
sc = Scene()
# Create Sources
so = VolumeSource(core, 'abs_ye_asymmetry')
bounds = np.array([args.ye_asym_minimum, args.ye_asym_maximum])
log_min = np.log10(args.ye_asym_minimum)
log_max = np.log10(args.ye_asym_maximum)
sigma = args.ye_sigma
nlayers = args.num_layers
if args.alpha_ones:
alphavec = np.ones(nlayers)
else:
alphavec = np.logspace(-3, 0, num=nlayers, endpoint=True)
def test_lazy_volume_source_construction(self):
sc = Scene()
source = create_volume_source(self.ds.all_data(), "density")
assert source._volume is None
assert source._transfer_function is None
source.tfh.bounds = (0.1, 1)
source.set_log(False)
assert not source.log_field
assert source.transfer_function.x_bounds == [0.1, 1]
assert source._volume is None
source.set_log(True)
assert source.log_field
assert source.transfer_function.x_bounds == [-1, 0]
assert source._volume is None
source.transfer_function = None
source.tfh.bounds = None
ad = self.ds.all_data()
np.testing.assert_allclose(
source.transfer_function.x_bounds,
np.log10(ad.quantities.extrema("density")),
)
assert source.tfh.log == source.log_field
source.set_field("velocity_x")
source.set_log(False)
assert source.transfer_function.x_bounds == list(
ad.quantities.extrema("velocity_x")
)
assert source._volume is None
source.set_field("density")
assert source.volume is not None
assert not source.volume._initialized
assert source.volume.fields is None
del source.volume
assert source._volume is None
sc.add_source(source)
sc.add_camera()
sc.render()
assert source.volume is not None
assert source.volume._initialized
assert source.volume.fields == [("gas", "density")]
assert source.volume.log_fields == [True]
source.set_field("velocity_x")
source.set_log(False)
sc.render()
assert source.volume is not None
assert source.volume._initialized
assert source.volume.fields == [("gas", "velocity_x")]
assert source.volume.log_fields == [False]
# Hack: because rendering likes log fields ...
## create positive_radial_velocity and negative_radial_velocity fields.
## must do this before opening dataset
@derived_field(name='pos_radial_velocity', units='cm/s')
def _pos_radial_velocity(field, data):
return np.maximum(data[('boxlib','radial_velocity')], 1.0e-99)
@derived_field(name='neg_radial_velocity', units='cm/s')
def _neg_radial_velocity(field, data):
return np.maximum(-data[('boxlib','radial_velocity')], 1.0e-99)
# Open Dataset
ds = yt.load(args.infile)
core = ds.sphere(ds.domain_center, (args.rup, 'cm'))
# Create Scene
sc = Scene()
# Create Sources
#so_enuc = VolumeSource(core, ('boxlib','enucdot'))
so_pos_vrad = VolumeSource(core, 'pos_radial_velocity')
so_neg_vrad = VolumeSource(core, 'neg_radial_velocity')
# Assign Transfer Functions to Sources
# tfh_en = TransferFunctionHelper(ds)
# tfh_en.set_field(('boxlib','enucdot'))
# tfh_en.set_log(True)
# tfh_en.set_bounds()
# tfh_en.build_transfer_function()
# tfh_en.tf.add_layers(10, colormap='black_green', w=0.01)
# tfh_en.grey_opacity = False
# tfh_en.plot('{}_tfun_enuc.png'.format(args.infile), profile_field=('boxlib','enucdot'))
import yt
from yt.visualization.volume_rendering.api import Scene, create_volume_source
field = ("gas", "density")
# normal_vector points from camera to the center of the final projection.
# Now we look at the positive x direction.
normal_vector = [1.0, 0.0, 0.0]
# north_vector defines the "top" direction of the projection, which is
# positive z direction here.
north_vector = [0.0, 0.0, 1.0]
# Follow the simple_volume_rendering cookbook for the first part of this.
ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
sc = Scene()
vol = create_volume_source(ds, field=field)
tf = vol.transfer_function
tf.grey_opacity = True
# Plane-parallel lens
cam = sc.add_camera(ds, lens_type="plane-parallel")
# Set the resolution of the final projection.
cam.resolution = [250, 250]
# Set the location of the camera to be (x=0.2, y=0.5, z=0.5)
# For plane-parallel lens, the location info along the normal_vector (here
# is x=0.2) is ignored.
cam.position = ds.arr(np.array([0.2, 0.5, 0.5]), "code_length")
# Set the orientation of the camera.
cam.switch_orientation(normal_vector=normal_vector, north_vector=north_vector)
# Set the width of the camera, where width[0] and width[1] specify the length and
# Hack: because rendering likes log fields ...
## create positive_radial_velocity and negative_radial_velocity fields.
## must do this before opening dataset
@derived_field(name='pos_enucdot', units='erg/(g*s)')
def _pos_radial_velocity(field, data):
return np.maximum(data[('boxlib','enucdot')], yt.YTQuantity(1.0e-99, 'erg/(g*s)'))
@derived_field(name='neg_enucdot', units='erg/(g*s)')
def _neg_radial_velocity(field, data):
return np.maximum(-data[('boxlib','enucdot')], yt.YTQuantity(1.0e-99, 'erg/(g*s)'))
# Open Dataset
ds = yt.load(args.infile)
core = ds.sphere(ds.domain_center, (args.rup, 'cm'))
# Create Scene
sc = Scene()
# Create Sources
so_pos_enuc = VolumeSource(core, 'pos_enucdot')
so_neg_enuc = VolumeSource(core, 'neg_enucdot')
# Get maximum values for alpha settings
pos_maxv = np.ceil(np.log10(core.max('pos_enucdot')))
neg_maxv = np.ceil(np.log10(core.max('neg_enucdot')))
rat_neg_pos = 10.0**(neg_maxv-pos_maxv)
# Assign Transfer Functions to Sources
mag_enuc_sigma = 0.1
tfh = TransferFunctionHelper(ds)
tfh.set_field('pos_enucdot')
def vol_render_density(outfile, ds):
"""Volume render the density given a yt dataset."""
import numpy as np
import yt
import matplotlib
matplotlib.use('agg')
from yt.visualization.volume_rendering.api import Scene, VolumeSource
import matplotlib.pyplot as plt
ds.periodicity = (True, True, True)
field = ('boxlib', 'density')
ds._get_field_info(field).take_log = True
sc = Scene()
# Add a volume: select a sphere
vol = VolumeSource(ds, field=field)
vol.use_ghost_zones = True
sc.add_source(vol)
# Transfer function
vals = [-1, 0, 1, 2, 3, 4, 5, 6, 7]
sigma = 0.1
tf = yt.ColorTransferFunction((min(vals), max(vals)))
tf.clear()
cm = "spectral"
for v in vals:
if v < 3:
alpha = 0.1
else:
alpha = 0.5
tf.sample_colormap(v, sigma**2, colormap=cm, alpha=alpha)
sc.get_source(0).transfer_function = tf
cam = sc.add_camera(ds, lens_type="perspective")
cam.resolution = (1920, 1080)
center = 0.5 * (ds.domain_left_edge + ds.domain_right_edge)
width = ds.domain_width
# Set the camera so that we're looking down on the xy plane from a 45
# degree angle. We reverse the y-coordinate since yt seems to use the
# opposite orientation convention to us (where the primary should be
# on the left along the x-axis). We'll scale the camera position based
# on a zoom factor proportional to the width of the domain.
zoom_factor = 0.75
cam_position = np.array([
center[0], center[1] - zoom_factor * width[1],
center[2] + zoom_factor * width[2]
])
cam.position = zoom_factor * ds.arr(cam_position, 'cm')
# Set the normal vector so that we look toward the center.
normal = (center - cam.position)
normal /= np.sqrt(normal.dot(normal))
cam.switch_orientation(normal_vector=normal, north_vector=[0.0, 0.0, 1.0])
cam.set_width(width)
# Render the image.
sc.render()
# Save the image without annotation.
sc.save(outfile, sigma_clip=6.0)
# Save the image with a colorbar.
sc.save_annotated(outfile.replace(".png", "_colorbar.png"), sigma_clip=6.0)
# Save the image with a colorbar and the current time.
sc.save_annotated(outfile.replace(".png", "_colorbar_time.png"),
sigma_clip=6.0,
text_annotate=[[
(0.05, 0.925),
"t = {:.2f} s".format(float(ds.current_time.d)),
dict(horizontalalignment="left", fontsize="20")
]])
def doit(plotfile):
ds = yt.load(plotfile)
ds.periodicity = (True, True, True)
field = ('gas', 'velocity_z')
ds._get_field_info(field).take_log = False
sc = Scene()
# add a volume: select a sphere
#center = (0, 0, 0)
#R = (5.e8, 'cm')
#dd = ds.sphere(center, R)
vol = VolumeSource(ds, field=field)
vol.use_ghost_zones = True
sc.add_source(vol)
# transfer function
vals = [-1.e7, -5.e6, 5.e6, 1.e7]
sigma = 5.e5
tf = yt.ColorTransferFunction((min(vals), max(vals)))
tf.clear()
cm = "coolwarm"
for v in vals:
tf.sample_colormap(v, sigma**2, colormap=cm) #, alpha=0.2)
sc.get_source(0).transfer_function = tf
cam = sc.add_camera(ds, lens_type="perspective")
cam.resolution = (1920, 1080)
center = 0.5*(ds.domain_left_edge + ds.domain_right_edge)
cam.position = [2.5*ds.domain_right_edge[0],
2.5*ds.domain_right_edge[1],
center[2]+0.25*ds.domain_right_edge[2]]
# look toward the center -- we are dealing with an octant
normal = (center - cam.position)
normal /= np.sqrt(normal.dot(normal))
cam.switch_orientation(normal_vector=normal,
north_vector=[0., 0., 1.])
cam.set_width(ds.domain_width)
sc.camera = cam
#sc.annotate_axes(alpha=0.05)
#sc.annotate_domain(ds, color=np.array([0.05, 0.05, 0.05, 0.05]))
#sc.annotate_grids(ds, alpha=0.05)
sc.render()
sc.save("{}_radvel".format(plotfile), sigma_clip=4.0)
sc.save_annotated("{}_radvel_annotated.png".format(plotfile),
sigma_clip=4.0,
text_annotate=[[(0.05, 0.05),
"t = {}".format(ds.current_time.d),
dict(horizontalalignment="left")],
[(0.5,0.95),
"Maestro simulation of convection in a mixed H/He XRB",
dict(color="y", fontsize="24",
horizontalalignment="center")]])
args = parser.parse_args()
# Open Dataset
ds = yt.load(args.infile)
core = ds.sphere(ds.domain_center, (args.rup, 'cm'))
# Load urca-specific fields
ushell_fields = UrcaShellFields()
ushell_fields.setup(ds)
# Get the field from the dataset
field, field_short_name = DatasetHelpers.get_field(ds, args.field)
assert (field)
# Create Scene
sc = Scene()
# Create Sources
so = VolumeSource(core, field)
bounds = np.array([args.minimum, args.maximum])
log_min = np.log10(args.minimum)
log_max = np.log10(args.maximum)
sigma = args.sigma
nlayers = args.num_layers
if args.alpha_ones:
alphavec = np.ones(nlayers)
else:
alphavec = np.logspace(-3, 0, num=nlayers, endpoint=True)
def test_orientation():
ds = fake_vr_orientation_test_ds()
sc = Scene()
vol = create_volume_source(ds, field=("gas", "density"))
sc.add_source(vol)
tf = vol.transfer_function
tf = ColorTransferFunction((0.1, 1.0))
tf.sample_colormap(1.0, 0.01, colormap="coolwarm")
tf.sample_colormap(0.8, 0.01, colormap="coolwarm")
tf.sample_colormap(0.6, 0.01, colormap="coolwarm")
tf.sample_colormap(0.3, 0.01, colormap="coolwarm")
n_frames = 1
orientations = [[-0.3, -0.1, 0.8]]
theta = np.pi / n_frames
test_name = "vr_orientation"
for lens_type, decimals in [("perspective", 12), ("plane-parallel", 2)]:
# set a much lower precision for plane-parallel tests, see
# https://github.com/yt-project/yt/issue/3069
# https://github.com/yt-project/yt/pull/3068
# https://github.com/yt-project/yt/pull/3294
frame = 0
cam = sc.add_camera(ds, lens_type=lens_type)
cam.resolution = (1000, 1000)
cam.position = ds.arr(np.array([-4.0, 0.0, 0.0]), "code_length")
cam.switch_orientation(normal_vector=[1.0, 0.0, 0.0],
north_vector=[0.0, 0.0, 1.0])
cam.set_width(ds.domain_width * 2.0)
desc = "%s_%04d" % (lens_type, frame)
test1 = VRImageComparisonTest(sc, ds, desc, decimals)
test1.answer_name = test_name
yield test1
for _ in range(n_frames):
frame += 1
center = ds.arr([0, 0, 0], "code_length")
cam.yaw(theta, rot_center=center)
desc = "yaw_%s_%04d" % (lens_type, frame)
test2 = VRImageComparisonTest(sc, ds, desc, decimals)
test2.answer_name = test_name
yield test2
for _ in range(n_frames):
frame += 1
theta = np.pi / n_frames
center = ds.arr([0, 0, 0], "code_length")
cam.pitch(theta, rot_center=center)
desc = "pitch_%s_%04d" % (lens_type, frame)
test3 = VRImageComparisonTest(sc, ds, desc, decimals)
test3.answer_name = test_name
yield test3
for _ in range(n_frames):
frame += 1
theta = np.pi / n_frames
center = ds.arr([0, 0, 0], "code_length")
cam.roll(theta, rot_center=center)
desc = "roll_%s_%04d" % (lens_type, frame)
test4 = VRImageComparisonTest(sc, ds, desc, decimals)
test4.answer_name = test_name
yield test4
center = [0.5, 0.5, 0.5]
width = [1.0, 1.0, 1.0]
for i, orientation in enumerate(orientations):
image = off_axis_projection(ds,
center,
orientation,
width,
512, ("gas", "density"),
no_ghost=False)
def offaxis_image_func(filename_prefix):
return image.write_image(filename_prefix)
test5 = GenericImageTest(ds, offaxis_image_func, decimals)
test5.prefix = f"oap_orientation_{i}"
test5.answer_name = test_name
yield test5
def doit(plotfile):
ds = yt.load(plotfile)
ds.periodicity = (True, True, True)
field = ('boxlib', 'radial_velocity')
ds._get_field_info(field).take_log = False
sc = Scene()
# add a volume: select a sphere
#center = (0, 0, 0)
#R = (5.e8, 'cm')
#dd = ds.sphere(center, R)
vol = VolumeSource(ds, field=field)
vol.use_ghost_zones = True
sc.add_source(vol)
# transfer function
vals = [-5.e6, -2.5e6, -1.25e6, 1.25e6, 2.5e6, 5.e6]
sigma = 3.e5
tf = yt.ColorTransferFunction((min(vals), max(vals)))
tf.clear()
cm = "coolwarm"
for v in vals:
tf.sample_colormap(v, sigma**2, colormap=cm) #, alpha=0.2)
sc.get_source(0).transfer_function = tf
cam = sc.add_camera(ds, lens_type="perspective")
cam.resolution = (1080, 1080)
cam.position = 1.0*ds.domain_right_edge
# look toward the center -- we set this depending on whether the plotfile
# indicates it was an octant
try: octant = ds.parameters["octant"]
except: octant = True
if octant:
center = ds.domain_left_edge
else:
center = 0.5*(ds.domain_left_edge + ds.domain_right_edge)
# unit vector connecting center and camera
normal = (center - cam.position)
normal /= np.sqrt(normal.dot(normal))
cam.switch_orientation(normal_vector=normal,
north_vector=[0., 0., 1.])
cam.set_width(ds.domain_width)
#sc.annotate_axes(alpha=0.05)
#sc.annotate_domain(ds, color=np.array([0.05, 0.05, 0.05, 0.05]))
#sc.annotate_grids(ds, alpha=0.05)
sc.render()
sc.save("{}_radvel".format(plotfile), sigma_clip=6.0)
sc.save_annotated("{}_radvel_annotated.png".format(plotfile),
text_annotate=[[(0.05, 0.05),
"t = {}".format(ds.current_time.d),
dict(horizontalalignment="left")],
[(0.5,0.95),
"Maestro simulation of He convection on a white dwarf",
dict(color="y", fontsize="24",
horizontalalignment="center")]])
