def slice_create(ds,field,center="c",width=(5000,"km"),debug=False,axis=None):
""" Creates a slice and returns 2D numpy array of such."""
resolution = 1600
if axis is None: # TODO: Adjust for 1D/2D
axis = yt.funcs.fix_axis("x",ds) # default for 3D
if debug:
resolution = 100 # lower resolution for faster debugging
(bounds, center, display_center) = get_window_parameters(axis, center, width, ds)
slc = ds.slice(axis, center[axis],center=center)
frb = slc.to_frb(width, resolution)
return frb[field]
def run(self):
rv = {}
ds = self.ds
for i, axis in enumerate(ds.coordinates.axis_order):
(bounds, center, display_center) = pw.get_window_parameters(
axis, ds.domain_center, None, ds)
slc = ds.slice(axis, center[i])
xax = ds.coordinates.axis_name[ds.coordinates.x_axis[axis]]
yax = ds.coordinates.axis_name[ds.coordinates.y_axis[axis]]
pix_x = ds.coordinates.pixelize(axis, slc, xax, bounds, (512, 512))
pix_y = ds.coordinates.pixelize(axis, slc, yax, bounds, (512, 512))
# Wipe out invalid values (fillers)
pix_x[~np.isfinite(pix_x)] = 0.0
pix_y[~np.isfinite(pix_y)] = 0.0
rv[f"{axis}_x"] = pix_x
rv[f"{axis}_y"] = pix_y
return rv
def run(self):
rv = {}
ds = self.ds
for i, axis in enumerate(ds.coordinates.axis_order):
(bounds, center, display_center) = \
pw.get_window_parameters(axis, ds.domain_center, None, ds)
slc = ds.slice(axis, center[i])
xax = ds.coordinates.axis_name[ds.coordinates.x_axis[axis]]
yax = ds.coordinates.axis_name[ds.coordinates.y_axis[axis]]
pix_x = ds.coordinates.pixelize(axis, slc, xax, bounds, (512, 512))
pix_y = ds.coordinates.pixelize(axis, slc, yax, bounds, (512, 512))
# Wipe out all NaNs
pix_x[np.isnan(pix_x)] = 0.0
pix_y[np.isnan(pix_y)] = 0.0
rv['%s_x' % axis] = pix_x
rv['%s_y' % axis] = pix_y
return rv
def axial_pixelization(ds):
r"""
This test is typically used once per geometry or coordinates type.
Feed it a dataset, and it checks that the results of basic pixelization
don't change.
"""
for i, axis in enumerate(ds.coordinates.axis_order):
(bounds, center, display_center) = \
pw.get_window_parameters(axis, ds.domain_center, None, ds)
slc = ds.slice(axis, center[i])
xax = ds.coordinates.axis_name[ds.coordinates.x_axis[axis]]
yax = ds.coordinates.axis_name[ds.coordinates.y_axis[axis]]
pix_x = ds.coordinates.pixelize(axis, slc, xax, bounds, (512, 512))
pix_y = ds.coordinates.pixelize(axis, slc, yax, bounds, (512, 512))
# Wipe out all NaNs
pix_x[np.isnan(pix_x)] = 0.0
pix_y[np.isnan(pix_y)] = 0.0
pix_x
pix_y
return pix_x, pix_y
def frb_create(self,ds,field,debug=False,axis=None,fieldid=0,resolution=1600,imagetype="slice",
method="integrate",**kwargs):
""" Creates a slice and returns 2D numpy array of such.
fieldid: Specify as integer >=1 to save as secondary field under given identifier."""
if axis is None: # TODO: Adjust for 1D/2D
axis = yt.funcs.fix_axis("x",ds) # default for 3D
if debug:
resolution = 100 # lower resolution for faster debugging
(bounds, center, display_center) = get_window_parameters(axis, kwargs["center"], kwargs["width"], ds)
keyid = ""
if fieldid>0:
keyid += "_%i"%fieldid
self.params["extent"] = bounds
data_source = ds.all_data()
data_source.set_field_parameter("flameprops",flameprops)
if imagetype=="slice":
p = ds.slice(axis, center[axis],center=center,data_source=data_source)
else:
p = ds.proj(field,axis,center=center,data_source=data_source,method=method)
frb = p.to_frb(kwargs["width"], resolution)
return frb[field]
def sim_frame_varAnimation(frame_args):
def _amr_grid(all):
if not int(frame_args.amrGrid):
return None
g = []
for b, _ in all.blocks:
g.append([
[float(b.LeftEdge[0] / 100), float(b.RightEdge[0] / 100)],
[float(b.LeftEdge[1] / 100), float(b.RightEdge[1] / 100)],
])
return g
_init_yt()
from yt.visualization import plot_window
from yt.visualization.fixed_resolution import FixedResolutionBuffer
f = frame_args.var
ds = yt.load(str(_h5_file_list(frame_args.run_dir)[frame_args.frameIndex]))
axis = ['x', 'y', 'z'].index(frame_args.axis)
(bounds, center, display_center) = plot_window.get_window_parameters(axis, 'c', None, ds)
slc = ds.slice(axis, center[axis], center=center)
all = ds.all_data()
dim = ds.domain_dimensions
scale = 2 ** all.max_level
if axis == 0:
buff_size = (dim[1] * scale, dim[2] * scale)
elif axis == 1:
buff_size = (dim[0] * scale, dim[2] * scale)
else:
buff_size = (dim[0] * scale, dim[1] * scale)
#TODO(pjm): antialis=True is important to get grid aligned?
d = FixedResolutionBuffer(slc, bounds, buff_size, True)[f]
l = PKDict(
cartesian=PKDict(
x=PKDict(x='y', y='z'),
y=PKDict(x='z', y='x'),
z=PKDict(x='x', y='y'),
),
cylindrical=PKDict(
r=PKDict(x='theta', y='z'),
z=PKDict(x='r', y='theta'),
theta=PKDict(x='r', y='z'),
),
polar=PKDict(
r=PKDict(x='phi', y='z'),
phi=PKDict(x='r', y='z'),
z=PKDict(x='r', y='phi'),
),
spherical=PKDict(
r=PKDict(x='theta', y='phi'),
theta=PKDict(x='r', y='phi'),
phi=PKDict(x='r', y='theta'),
),
)
g = frame_args.sim_in.models.Grid_GridMain.geometry
aspect_ratio = buff_size[1] / buff_size[0]
return PKDict(
global_max=float(frame_args.vmax) if frame_args.vmax else None,
global_min=float(frame_args.vmin) if frame_args.vmin else None,
subtitle='Time: {}, Plot {}'.format(
_time_and_units(ds.parameters['time']),
frame_args.frameIndex + 1,
),
title='{}'.format(f),
x_label=f'{l[g][frame_args.axis].x} [m]',
x_range=[ds.parameters['xmin'] / 100, ds.parameters['xmax'] / 100, d.shape[1]],
y_label=f'{l[g][frame_args.axis].y} [m]',
y_range=[ds.parameters['ymin'] / 100, ds.parameters['ymax'] / 100, d.shape[0]],
z_matrix=d.tolist(),
amr_grid=_amr_grid(all),
aspectRatio=aspect_ratio,
summaryData=PKDict(
aspectRatio=aspect_ratio,
),
)
