This is a list of many of the fields available in yt. We have attempted to include most of the fields that are accessible through the plugin system, as well as the fields that are known by the frontends, however it is possible to generate many more permutations, particularly through vector operations. For more information about the fields framework, see Fields in yt.
Some fields are recognized by specific frontends only. These are typically
fields like density and temperature that have their own names and units in
the different frontend datasets. Often, these fields are aliased to their
yt-named counterpart fields (typically ‘gas’ fieldtypes). For example, in
the FLASH
frontend, the dens
field (i.e. (flash, dens)
) is aliased
to the gas field density (i.e. (gas, density)
), similarly (flash, velx)
is aliased to (gas, velocity_x)
, and so on. In what follows, if a field
is aliased it will be noted.
Try using the ds.field_list
and ds.derived_field_list
to view the
native and derived fields available for your dataset respectively. For example
to display the native fields in alphabetical order:
To figure out out what all of the field types here mean, see Field types known to yt.
Table of Contents
- Particle Type: True
Field Source
def particle_mesh_ids(field, data):
pos = data[ptype, coord_name]
ids = np.zeros(pos.shape[0], dtype="float64") - 1
# This is float64 in name only. It will be properly cast inside the
# deposit operation.
#_ids = ids.view("float64")
data.deposit(pos, [ids], method = "mesh_id")
return data.apply_units(ids, "")
- Units:
- Particle Type: True
Field Source
def _particle_angular_momentum(field, data):
return data[ptype, "particle_mass"] \
* data[ptype, "particle_specific_angular_momentum"]
- Units:
- Particle Type: True
Field Source
def _magnitude(field, data):
fn = field_components[0]
mag = data[fn] * data[fn]
for idim in range(1, registry.ds.dimensionality):
fn = field_components[idim]
mag += data[fn] * data[fn]
return np.sqrt(mag)
- Units:
- Particle Type: True
Field Source
def _particle_angular_momentum_x(field, data):
return data[ptype, "particle_mass"] * \
data[ptype, "particle_specific_angular_momentum_x"]
- Units:
- Particle Type: True
Field Source
def _particle_angular_momentum_y(field, data):
return data[ptype, "particle_mass"] * \
data[ptype, "particle_specific_angular_momentum_y"]
- Units:
- Particle Type: True
Field Source
def _particle_angular_momentum_z(field, data):
return data[ptype, "particle_mass"] * \
data[ptype, "particle_specific_angular_momentum_z"]
- Particle Type: True
Field Source
def particle_ones(field, data):
v = np.ones(data[ptype, mass_name].shape, dtype="float64")
return data.apply_units(v, field.units)
- Units:
- Particle Type: True
Field Source
def particle_vectors(field, data):
v = [data[_ptype, name].in_units(field.units)
for name in names]
c = np.column_stack(v)
return data.apply_units(c, field.units)
- Units:
- Particle Type: True
Field Source
def _particle_spherical_velocity_radius(field, data):
"""
Radial component of the particles' velocity vectors in spherical coords
based on the provided field parameters for 'normal', 'center', and
'bulk_velocity',
"""
normal = data.get_field_parameter('normal')
center = data.get_field_parameter('center')
bv = data.get_field_parameter("bulk_velocity")
pos = spos
pos = YTArray([data[ptype, pos % ax] for ax in "xyz"])
vel = svel
vel = YTArray([data[ptype, vel % ax] for ax in "xyz"])
theta = get_sph_theta(pos, center)
phi = get_sph_phi(pos, center)
pos = pos - np.reshape(center, (3, 1))
vel = vel - np.reshape(bv, (3, 1))
sphr = get_sph_r_component(vel, theta, phi, normal)
return sphr
- Units:
- Particle Type: True
Field Source
def _particle_radius(field, data):
return get_radius(data, "particle_position_")
- Units:
- Particle Type: True
Field Source
def _particle_specific_angular_momentum(field, data):
"""
Calculate the angular of a particle velocity. Returns a vector for each
particle.
"""
if data.has_field_parameter("bulk_velocity"):
bv = data.get_field_parameter("bulk_velocity")
else: bv = np.zeros(3, dtype=np.float64)
xv = data[ptype, svel % 'x'] - bv[0]
yv = data[ptype, svel % 'y'] - bv[1]
zv = data[ptype, svel % 'z'] - bv[2]
center = data.get_field_parameter('center')
coords = YTArray([data[ptype, spos % 'x'],
data[ptype, spos % 'y'],
data[ptype, spos % 'z']], dtype=np.float64)
new_shape = tuple([3] + [1]*(len(coords.shape)-1))
r_vec = coords - np.reshape(center,new_shape)
v_vec = YTArray([xv,yv,zv], dtype=np.float64)
return np.cross(r_vec, v_vec, axis=0)
- Units:
- Particle Type: True
Field Source
def _magnitude(field, data):
fn = field_components[0]
mag = data[fn] * data[fn]
for idim in range(1, registry.ds.dimensionality):
fn = field_components[idim]
mag += data[fn] * data[fn]
return np.sqrt(mag)
- Units:
- Particle Type: True
Field Source
def _particle_specific_angular_momentum_x(field, data):
if data.has_field_parameter("bulk_velocity"):
bv = data.get_field_parameter("bulk_velocity")
else: bv = np.zeros(3, dtype=np.float64)
center = data.get_field_parameter('center')
y = data[ptype, spos % "y"] - center[1]
z = data[ptype, spos % "z"] - center[2]
yv = data[ptype, svel % "y"] - bv[1]
zv = data[ptype, svel % "z"] - bv[2]
return yv*z - zv*y
- Units:
- Particle Type: True
Field Source
def _particle_specific_angular_momentum_y(field, data):
if data.has_field_parameter("bulk_velocity"):
bv = data.get_field_parameter("bulk_velocity")
else: bv = np.zeros(3, dtype=np.float64)
center = data.get_field_parameter('center')
x = data[ptype, spos % "x"] - center[0]
z = data[ptype, spos % "z"] - center[2]
xv = data[ptype, svel % "x"] - bv[0]
zv = data[ptype, svel % "z"] - bv[2]
return -(xv*z - zv*x)
- Units:
- Particle Type: True
Field Source
def _particle_specific_angular_momentum_z(field, data):
if data.has_field_parameter("bulk_velocity"):
bv = data.get_field_parameter("bulk_velocity")
else: bv = np.zeros(3, dtype=np.float64)
center = data.get_field_parameter('center')
x = data[ptype, spos % "x"] - center[0]
y = data[ptype, spos % "y"] - center[1]
xv = data[ptype, svel % "x"] - bv[0]
yv = data[ptype, svel % "y"] - bv[1]
return xv*y - yv*x
- Units:
- Particle Type: True
Field Source
def _particle_spherical_position_phi(field, data):
"""
Phi component of the particles' position vectors in spherical coords
on the provided field parameters for 'normal', 'center', and
'bulk_velocity',
"""
normal = data.get_field_parameter('normal')
center = data.get_field_parameter('center')
bv = data.get_field_parameter("bulk_velocity")
pos = spos
pos = YTArray([data[ptype, pos % ax] for ax in "xyz"])
theta = get_sph_theta(pos, center)
phi = get_sph_phi(pos, center)
pos = pos - np.reshape(center, (3, 1))
sphp = get_sph_phi_component(pos, phi, normal)
return sphp
- Units:
- Particle Type: True
Field Source
def _particle_spherical_position_radius(field, data):
"""
Radial component of the particles' position vectors in spherical coords
on the provided field parameters for 'normal', 'center', and
'bulk_velocity',
"""
normal = data.get_field_parameter('normal')
center = data.get_field_parameter('center')
bv = data.get_field_parameter("bulk_velocity")
pos = spos
pos = YTArray([data[ptype, pos % ax] for ax in "xyz"])
theta = get_sph_theta(pos, center)
phi = get_sph_phi(pos, center)
pos = pos - np.reshape(center, (3, 1))
sphr = get_sph_r_component(pos, theta, phi, normal)
return sphr
- Units:
- Particle Type: True
Field Source
def _particle_spherical_position_theta(field, data):
"""
Theta component of the particles' position vectors in spherical coords
on the provided field parameters for 'normal', 'center', and
'bulk_velocity',
"""
normal = data.get_field_parameter('normal')
center = data.get_field_parameter('center')
bv = data.get_field_parameter("bulk_velocity")
pos = spos
pos = YTArray([data[ptype, pos % ax] for ax in "xyz"])
theta = get_sph_theta(pos, center)
phi = get_sph_phi(pos, center)
pos = pos - np.reshape(center, (3, 1))
spht = get_sph_theta_component(pos, theta, phi, normal)
return spht
- Units:
- Particle Type: True
Field Source
def _particle_spherical_velocity_phi(field, data):
"""
Phi component of the particles' velocity vectors in spherical coords
based on the provided field parameters for 'normal', 'center', and
'bulk_velocity',
"""
normal = data.get_field_parameter('normal')
center = data.get_field_parameter('center')
bv = data.get_field_parameter("bulk_velocity")
pos = YTArray([data[ptype, spos % ax] for ax in "xyz"])
vel = YTArray([data[ptype, svel % ax] for ax in "xyz"])
theta = get_sph_theta(pos, center)
phi = get_sph_phi(pos, center)
pos = pos - np.reshape(center, (3, 1))
vel = vel - np.reshape(bv, (3, 1))
sphp = get_sph_phi_component(vel, phi, normal)
return sphp
- Units:
- Particle Type: True
Field Source
def _particle_spherical_velocity_radius(field, data):
"""
Radial component of the particles' velocity vectors in spherical coords
based on the provided field parameters for 'normal', 'center', and
'bulk_velocity',
"""
normal = data.get_field_parameter('normal')
center = data.get_field_parameter('center')
bv = data.get_field_parameter("bulk_velocity")
pos = spos
pos = YTArray([data[ptype, pos % ax] for ax in "xyz"])
vel = svel
vel = YTArray([data[ptype, vel % ax] for ax in "xyz"])
theta = get_sph_theta(pos, center)
phi = get_sph_phi(pos, center)
pos = pos - np.reshape(center, (3, 1))
vel = vel - np.reshape(bv, (3, 1))
sphr = get_sph_r_component(vel, theta, phi, normal)
return sphr
- Units:
- Particle Type: True
Field Source
def _particle_spherical_velocity_theta(field, data):
"""
Theta component of the particles' velocity vectors in spherical coords
based on the provided field parameters for 'normal', 'center', and
'bulk_velocity',
"""
normal = data.get_field_parameter('normal')
center = data.get_field_parameter('center')
bv = data.get_field_parameter("bulk_velocity")
pos = spos
pos = YTArray([data[ptype, pos % ax] for ax in "xyz"])
vel = svel
vel = YTArray([data[ptype, vel % ax] for ax in "xyz"])
theta = get_sph_theta(pos, center)
phi = get_sph_phi(pos, center)
pos = pos - np.reshape(center, (3, 1))
vel = vel - np.reshape(bv, (3, 1))
spht = get_sph_theta_component(vel, theta, phi, normal)
return spht
- Units:
- Particle Type: True
Field Source
def particle_vectors(field, data):
v = [data[_ptype, name].in_units(field.units)
for name in names]
c = np.column_stack(v)
return data.apply_units(c, field.units)
- Units:
- Particle Type: True
Field Source
def _particle_velocity_magnitude(field, data):
""" M{|v|} """
bulk_velocity = data.get_field_parameter("bulk_velocity")
if bulk_velocity is None:
bulk_velocity = np.zeros(3)
return np.sqrt((data[ptype, svel % 'x'] - bulk_velocity[0])**2
+ (data[ptype, svel % 'y'] - bulk_velocity[1])**2
+ (data[ptype, svel % 'z'] - bulk_velocity[2])**2 )
- Units:
- Particle Type: False
Field Source
def particle_cic(field, data):
pos = data[ptype, coord_name]
d = data.deposit(pos, [data[ptype, mass_name]], method = "cic")
d = data.apply_units(d, data[ptype, mass_name].units)
d /= data["index", "cell_volume"]
return d
- Units:
- Particle Type: False
Field Source
def _deposit_field(field, data):
"""
Create a grid field for particle quantities weighted by particle
mass, using cloud-in-cell deposit.
"""
pos = data[ptype, "particle_position"]
# Get back into density
pden = data[ptype, 'particle_mass']
top = data.deposit(pos, [data[(ptype, fname)]*pden], method=method)
bottom = data.deposit(pos, [pden], method=method)
top[bottom == 0] = 0.0
bnz = bottom.nonzero()
top[bnz] /= bottom[bnz]
d = data.ds.arr(top, input_units=units)
return d
- Units:
- Particle Type: False
Field Source
def _deposit_field(field, data):
"""
Create a grid field for particle quantities weighted by particle
mass, using cloud-in-cell deposit.
"""
pos = data[ptype, "particle_position"]
# Get back into density
pden = data[ptype, 'particle_mass']
top = data.deposit(pos, [data[(ptype, fname)]*pden], method=method)
bottom = data.deposit(pos, [pden], method=method)
top[bottom == 0] = 0.0
bnz = bottom.nonzero()
top[bnz] /= bottom[bnz]
d = data.ds.arr(top, input_units=units)
return d
- Units:
- Particle Type: False
Field Source
def _deposit_field(field, data):
"""
Create a grid field for particle quantities weighted by particle
mass, using cloud-in-cell deposit.
"""
pos = data[ptype, "particle_position"]
# Get back into density
pden = data[ptype, 'particle_mass']
top = data.deposit(pos, [data[(ptype, fname)]*pden], method=method)
bottom = data.deposit(pos, [pden], method=method)
top[bottom == 0] = 0.0
bnz = bottom.nonzero()
top[bnz] /= bottom[bnz]
d = data.ds.arr(top, input_units=units)
return d
- Particle Type: False
Field Source
def particle_count(field, data):
pos = data[ptype, coord_name]
d = data.deposit(pos, method = "count")
d = data.ds.arr(d, input_units = "cm**-3")
return data.apply_units(d, field.units)
- Units:
- Particle Type: False
Field Source
def particle_density(field, data):
pos = data[ptype, coord_name]
mass = data[ptype, mass_name]
pos.convert_to_units("code_length")
mass.convert_to_units("code_mass")
d = data.deposit(pos, [data[ptype, mass_name]], method = "sum")
d = data.ds.arr(d, "code_mass")
d /= data["index", "cell_volume"]
return d
- Units:
- Particle Type: False
Field Source
def particle_mass(field, data):
pos = data[ptype, coord_name]
pmass = data[ptype, mass_name].in_units(field.units)
d = data.deposit(pos, [pmass], method = "sum")
return data.apply_units(d, field.units)
- Units:
- Particle Type: False
Field Source
def _deposit_field(field, data):
"""
Create a grid field for particle quantities weighted by particle
mass, using cloud-in-cell deposit.
"""
pos = data[ptype, "particle_position"]
# Get back into density
pden = data[ptype, 'particle_mass']
top = data.deposit(pos, [data[(ptype, fname)]*pden], method=method)
bottom = data.deposit(pos, [pden], method=method)
top[bottom == 0] = 0.0
bnz = bottom.nonzero()
top[bnz] /= bottom[bnz]
d = data.ds.arr(top, input_units=units)
return d
- Units:
- Particle Type: False
Field Source
def _deposit_field(field, data):
"""
Create a grid field for particle quantities weighted by particle
mass, using cloud-in-cell deposit.
"""
pos = data[ptype, "particle_position"]
# Get back into density
pden = data[ptype, 'particle_mass']
top = data.deposit(pos, [data[(ptype, fname)]*pden], method=method)
bottom = data.deposit(pos, [pden], method=method)
top[bottom == 0] = 0.0
bnz = bottom.nonzero()
top[bnz] /= bottom[bnz]
d = data.ds.arr(top, input_units=units)
return d
- Units:
- Particle Type: False
Field Source
def _deposit_field(field, data):
"""
Create a grid field for particle quantities weighted by particle
mass, using cloud-in-cell deposit.
"""
pos = data[ptype, "particle_position"]
# Get back into density
pden = data[ptype, 'particle_mass']
top = data.deposit(pos, [data[(ptype, fname)]*pden], method=method)
bottom = data.deposit(pos, [pden], method=method)
top[bottom == 0] = 0.0
bnz = bottom.nonzero()
top[bnz] /= bottom[bnz]
d = data.ds.arr(top, input_units=units)
return d
- Units:
- Particle Type: False
Field Source
def particle_cic(field, data):
pos = data[ptype, coord_name]
d = data.deposit(pos, [data[ptype, mass_name]], method = "cic")
d = data.apply_units(d, data[ptype, mass_name].units)
d /= data["index", "cell_volume"]
return d
- Units:
- Particle Type: False
Field Source
def _deposit_field(field, data):
"""
Create a grid field for particle quantities weighted by particle
mass, using cloud-in-cell deposit.
"""
pos = data[ptype, "particle_position"]
# Get back into density
pden = data[ptype, 'particle_mass']
top = data.deposit(pos, [data[(ptype, fname)]*pden], method=method)
bottom = data.deposit(pos, [pden], method=method)
top[bottom == 0] = 0.0
bnz = bottom.nonzero()
top[bnz] /= bottom[bnz]
d = data.ds.arr(top, input_units=units)
return d
- Units:
- Particle Type: False
Field Source
def _deposit_field(field, data):
"""
Create a grid field for particle quantities weighted by particle
mass, using cloud-in-cell deposit.
"""
pos = data[ptype, "particle_position"]
# Get back into density
pden = data[ptype, 'particle_mass']
top = data.deposit(pos, [data[(ptype, fname)]*pden], method=method)
bottom = data.deposit(pos, [pden], method=method)
top[bottom == 0] = 0.0
bnz = bottom.nonzero()
top[bnz] /= bottom[bnz]
d = data.ds.arr(top, input_units=units)
return d
- Units:
- Particle Type: False
Field Source
def _deposit_field(field, data):
"""
Create a grid field for particle quantities weighted by particle
mass, using cloud-in-cell deposit.
"""
pos = data[ptype, "particle_position"]
# Get back into density
pden = data[ptype, 'particle_mass']
top = data.deposit(pos, [data[(ptype, fname)]*pden], method=method)
bottom = data.deposit(pos, [pden], method=method)
top[bottom == 0] = 0.0
bnz = bottom.nonzero()
top[bnz] /= bottom[bnz]
d = data.ds.arr(top, input_units=units)
return d
- Particle Type: False
Field Source
def particle_count(field, data):
pos = data[ptype, coord_name]
d = data.deposit(pos, method = "count")
d = data.ds.arr(d, input_units = "cm**-3")
return data.apply_units(d, field.units)
- Units:
- Particle Type: False
Field Source
def particle_density(field, data):
pos = data[ptype, coord_name]
mass = data[ptype, mass_name]
pos.convert_to_units("code_length")
mass.convert_to_units("code_mass")
d = data.deposit(pos, [data[ptype, mass_name]], method = "sum")
d = data.ds.arr(d, "code_mass")
d /= data["index", "cell_volume"]
return d
- Units:
- Particle Type: False
Field Source
def particle_mass(field, data):
pos = data[ptype, coord_name]
pmass = data[ptype, mass_name].in_units(field.units)
d = data.deposit(pos, [pmass], method = "sum")
return data.apply_units(d, field.units)
- Units:
- Particle Type: False
Field Source
def _deposit_field(field, data):
"""
Create a grid field for particle quantities weighted by particle
mass, using cloud-in-cell deposit.
"""
pos = data[ptype, "particle_position"]
# Get back into density
pden = data[ptype, 'particle_mass']
top = data.deposit(pos, [data[(ptype, fname)]*pden], method=method)
bottom = data.deposit(pos, [pden], method=method)
top[bottom == 0] = 0.0
bnz = bottom.nonzero()
top[bnz] /= bottom[bnz]
d = data.ds.arr(top, input_units=units)
return d
- Units:
- Particle Type: False
Field Source
def _deposit_field(field, data):
"""
Create a grid field for particle quantities weighted by particle
mass, using cloud-in-cell deposit.
"""
pos = data[ptype, "particle_position"]
# Get back into density
pden = data[ptype, 'particle_mass']
top = data.deposit(pos, [data[(ptype, fname)]*pden], method=method)
bottom = data.deposit(pos, [pden], method=method)
top[bottom == 0] = 0.0
bnz = bottom.nonzero()
top[bnz] /= bottom[bnz]
d = data.ds.arr(top, input_units=units)
return d
- Units:
- Particle Type: False
Field Source
def _deposit_field(field, data):
"""
Create a grid field for particle quantities weighted by particle
mass, using cloud-in-cell deposit.
"""
pos = data[ptype, "particle_position"]
# Get back into density
pden = data[ptype, 'particle_mass']
top = data.deposit(pos, [data[(ptype, fname)]*pden], method=method)
bottom = data.deposit(pos, [pden], method=method)
top[bottom == 0] = 0.0
bnz = bottom.nonzero()
top[bnz] /= bottom[bnz]
d = data.ds.arr(top, input_units=units)
return d
- Units:
- Particle Type: False
Field Source
def _default_nuclei_density(field, data):
element = field.name[1][:field.name[1].find("_")]
return data["gas", "density"] * _primordial_mass_fraction[element] / \
ChemicalFormula(element).weight / amu_cgs
- Units:
- Particle Type: False
Field Source
def _default_nuclei_density(field, data):
element = field.name[1][:field.name[1].find("_")]
return data["gas", "density"] * _primordial_mass_fraction[element] / \
ChemicalFormula(element).weight / amu_cgs
- Units:
- Particle Type: False
Field Source
def _alfven_speed(field,data):
"""This assumes that your front end has provided Bx, By, Bz in
units of Gauss. If you use MKS, make sure to write your own
alfven_speed field to deal with non-unitary \mu_0.
"""
return data[ftype,'magnetic_field_strength']/np.sqrt(4.*np.pi*data[ftype,'density'])
- Units:
- Particle Type: False
Field Source
def _magnitude(field, data):
fn = field_components[0]
mag = data[fn] * data[fn]
for idim in range(1, registry.ds.dimensionality):
fn = field_components[idim]
mag += data[fn] * data[fn]
return np.sqrt(mag)
- Units:
- Particle Type: False
Field Source
def _angular_momentum_x(field, data):
return data[ftype, "cell_mass"] \
* data[ftype, "specific_angular_momentum_x"]
- Units:
- Particle Type: False
Field Source
def _angular_momentum_y(field, data):
return data[ftype, "cell_mass"] \
* data[ftype, "specific_angular_momentum_y"]
- Units:
- Particle Type: False
Field Source
def _angular_momentum_z(field, data):
return data[ftype, "cell_mass"] \
* data[ftype, "specific_angular_momentum_z"]
- Units:
- Particle Type: False
Field Source
def _averaged_field(field, data):
nx, ny, nz = data[(ftype, basename)].shape
new_field = data.ds.arr(np.zeros((nx-2, ny-2, nz-2), dtype=np.float64),
(just_one(data[(ftype, basename)]) *
just_one(data[(ftype, weight)])).units)
weight_field = data.ds.arr(np.zeros((nx-2, ny-2, nz-2), dtype=np.float64),
data[(ftype, weight)].units)
i_i, j_i, k_i = np.mgrid[0:3, 0:3, 0:3]
for i, j, k in zip(i_i.ravel(), j_i.ravel(), k_i.ravel()):
sl = [slice(i, nx-(2-i)), slice(j, ny-(2-j)), slice(k, nz-(2-k))]
new_field += data[(ftype, basename)][sl] * \
data[(ftype, weight)][sl]
weight_field += data[(ftype, weight)][sl]
# Now some fancy footwork
new_field2 = data.ds.arr(np.zeros((nx, ny, nz)),
data[(ftype, basename)].units)
new_field2[1:-1, 1:-1, 1:-1] = new_field / weight_field
return new_field2
- Units:
- Particle Type: False
Field Source
def _magnitude(field, data):
fn = field_components[0]
mag = data[fn] * data[fn]
for idim in range(1, registry.ds.dimensionality):
fn = field_components[idim]
mag += data[fn] * data[fn]
return np.sqrt(mag)
- Units:
- Particle Type: False
Field Source
def _baroclinic_vorticity_x(field, data):
rho2 = data[ftype, "density"].astype(np.float64)**2
return (data[ftype, "pressure_gradient_y"] *
data[ftype, "density_gradient_z"] -
data[ftype, "pressure_gradient_z"] *
data[ftype, "density_gradient_z"]) / rho2
- Units:
- Particle Type: False
Field Source
def _baroclinic_vorticity_y(field, data):
rho2 = data[ftype, "density"].astype(np.float64)**2
return (data[ftype, "pressure_gradient_z"] *
data[ftype, "density_gradient_x"] -
data[ftype, "pressure_gradient_x"] *
data[ftype, "density_gradient_z"]) / rho2
- Units:
- Particle Type: False
Field Source
def _baroclinic_vorticity_z(field, data):
rho2 = data[ftype, "density"].astype(np.float64)**2
return (data[ftype, "pressure_gradient_x"] *
data[ftype, "density_gradient_y"] -
data[ftype, "pressure_gradient_y"] *
data[ftype, "density_gradient_x"]) / rho2
- Particle Type: False
Field Source
def _baryon_overdensity(field, data):
if not hasattr(data.ds, "cosmological_simulation") or \
not data.ds.cosmological_simulation:
raise NeedsConfiguration("cosmological_simulation", 1)
omega_baryon = data.get_field_parameter("omega_baryon")
if omega_baryon is None:
raise NeedsParameter("omega_baryon")
co = data.ds.cosmology
# critical_density(z) ~ omega_lambda + omega_matter * (1 + z)^3
# mean matter density(z) ~ omega_matter * (1 + z)^3
return data[ftype, "density"] / omega_baryon / co.critical_density(0.0) / \
(1.0 + data.ds.current_redshift)**3
- Units:
- Particle Type: False
Field Source
def _cell_mass(field, data):
return data[ftype, "density"] * data["index", "cell_volume"]
- Particle Type: False
Field Source
def _chandra_emissivity(field, data):
logT0 = np.log10(data[ftype, "temperature"].to_ndarray().astype(np.float64)) - 7
# we get rid of the units here since this is a fit and not an
# analytical expression
return data.ds.arr(data[ftype, "number_density"].to_ndarray().astype(np.float64)**2
* (10**(- 0.0103 * logT0**8 + 0.0417 * logT0**7
- 0.0636 * logT0**6 + 0.1149 * logT0**5
- 0.3151 * logT0**4 + 0.6655 * logT0**3
- 1.1256 * logT0**2 + 1.0026 * logT0**1
- 0.6984 * logT0)
+ data[ftype, "metallicity"].to_ndarray() *
10**( 0.0305 * logT0**11 - 0.0045 * logT0**10
- 0.3620 * logT0**9 + 0.0513 * logT0**8
+ 1.6669 * logT0**7 - 0.3854 * logT0**6
- 3.3604 * logT0**5 + 0.4728 * logT0**4
+ 4.5774 * logT0**3 - 2.3661 * logT0**2
- 1.6667 * logT0**1 - 0.2193 * logT0)),
"") # add correct units here
- Units:
- Particle Type: False
Field Source
def _courant_time_step(field, data):
t1 = data["index", "dx"] / (data[ftype, "sound_speed"]
+ np.abs(data[ftype, "velocity_x"]))
t2 = data["index", "dy"] / (data[ftype, "sound_speed"]
+ np.abs(data[ftype, "velocity_y"]))
t3 = data["index", "dz"] / (data[ftype, "sound_speed"]
+ np.abs(data[ftype, "velocity_z"]))
tr = np.minimum(np.minimum(t1, t2), t3)
return tr
- Units:
- Particle Type: False
Field Source
def _cp_val(field, data):
vec = data.get_field_parameter("cp_%s_vec" % (ax))
bv = data.get_field_parameter("bulk_%s" % basename)
if bv == None: bv = np.zeros(3)
tr = (data[xn] - bv[0]) * vec[0]
tr += (data[yn] - bv[1]) * vec[1]
tr += (data[zn] - bv[2]) * vec[2]
return tr
- Units:
- Particle Type: False
Field Source
def _cp_val(field, data):
vec = data.get_field_parameter("cp_%s_vec" % (ax))
bv = data.get_field_parameter("bulk_%s" % basename)
if bv == None: bv = np.zeros(3)
tr = (data[xn] - bv[0]) * vec[0]
tr += (data[yn] - bv[1]) * vec[1]
tr += (data[zn] - bv[2]) * vec[2]
return tr
- Units:
- Particle Type: False
Field Source
def _cp_val(field, data):
vec = data.get_field_parameter("cp_%s_vec" % (ax))
bv = data.get_field_parameter("bulk_%s" % basename)
if bv == None: bv = np.zeros(3)
tr = (data[xn] - bv[0]) * vec[0]
tr += (data[yn] - bv[1]) * vec[1]
tr += (data[zn] - bv[2]) * vec[2]
return tr
- Units:
- Particle Type: False
Field Source
def _cylindrical_radial(field, data):
normal = data.get_field_parameter("normal")
vectors = obtain_rv_vec(data, (xn, yn, zn),
"bulk_%s" % basename)
theta = resize_vector(data["index", 'cylindrical_theta'], vectors)
return get_cyl_r_component(vectors, theta, normal)
- Units:
- Particle Type: False
Field Source
def _cylindrical_radial_absolute(field, data):
return np.abs(_cylindrical_radial(field, data))
- Units:
- Particle Type: False
Field Source
def _cylindrical_tangential(field, data):
normal = data.get_field_parameter("normal")
vectors = obtain_rv_vec(data, (xn, yn, zn),
"bulk_%s" % basename)
theta = data["index", 'cylindrical_theta'].copy()
theta = np.tile(theta, (3,) + (1,)*len(theta.shape))
return get_cyl_theta_component(vectors, theta, normal)
- Units:
- Particle Type: False
Field Source
def _cylindrical_tangential_absolute(field, data):
return np.abs(_cylindrical_tangential(field, data))
- Units:
- Particle Type: False
Field Source
def _magnitude(field, data):
fn = field_components[0]
mag = data[fn] * data[fn]
for idim in range(1, registry.ds.dimensionality):
fn = field_components[idim]
mag += data[fn] * data[fn]
return np.sqrt(mag)
- Units:
- Particle Type: False
Field Source
def func(field, data):
ds = div_fac * data["index", "dx"]
f = data[grad_field][slice_3dr]/ds[slice_3d]
f -= data[grad_field][slice_3dl]/ds[slice_3d]
new_field = data.ds.arr(np.zeros_like(data[grad_field], dtype=np.float64),
f.units)
new_field[slice_3d] = f
return new_field
- Units:
- Particle Type: False
Field Source
def func(field, data):
ds = div_fac * data["index", "dx"]
f = data[grad_field][slice_3dr]/ds[slice_3d]
f -= data[grad_field][slice_3dl]/ds[slice_3d]
new_field = data.ds.arr(np.zeros_like(data[grad_field], dtype=np.float64),
f.units)
new_field[slice_3d] = f
return new_field
- Units:
- Particle Type: False
Field Source
def func(field, data):
ds = div_fac * data["index", "dx"]
f = data[grad_field][slice_3dr]/ds[slice_3d]
f -= data[grad_field][slice_3dl]/ds[slice_3d]
new_field = data.ds.arr(np.zeros_like(data[grad_field], dtype=np.float64),
f.units)
new_field[slice_3d] = f
return new_field
- Units:
- Particle Type: False
Field Source
def _dynamical_time(field, data):
"""
sqrt(3 pi / (16 G rho))
"""
return np.sqrt(3.0 * np.pi / (16.0 * G * data[ftype, "density"]))
- Units:
- Particle Type: False
Field Source
def _entropy(field, data):
mw = data.get_field_parameter("mu")
if mw is None:
mw = 1.0
mw *= mh
gammam1 = 2./3.
tr = data[ftype,"kT"] / ((data[ftype, "density"]/mw)**gammam1)
return data.apply_units(tr, field.units)
- Units:
- Particle Type: False
Field Source
def _jeans_mass(field, data):
MJ_constant = (((5.0 * kboltz) / (G * mh)) ** (1.5)) * \
(3.0 / (4.0 * np.pi)) ** (0.5)
u = (MJ_constant * \
((data[ftype, "temperature"] /
data[ftype, "mean_molecular_weight"])**(1.5)) * \
(data[ftype, "density"]**(-0.5)))
return u
- Units:
- Particle Type: False
Field Source
def _kT(field, data):
return (kboltz*data[ftype, "temperature"]).in_units("keV")
- Units:
- Particle Type: False
Field Source
def _kin_energy(field, data):
return 0.5*data[ftype, "density"] * ( data[ftype, "velocity_x"]**2.0
+ data[ftype, "velocity_y"]**2.0
+ data[ftype, "velocity_z"]**2.0 )
- Units:
- Particle Type: False
Field Source
def _mach_alfven(field,data):
return data[ftype,'velocity_magnitude']/data[ftype,'alfven_speed']
- Particle Type: False
Field Source
def _mach_number(field, data):
""" M{|v|/c_sound} """
return data[ftype, "velocity_magnitude"] / data[ftype, "sound_speed"]
- Units:
- Particle Type: False
Field Source
def _magnetic_energy(field,data):
"""This assumes that your front end has provided Bx, By, Bz in
units of Gauss. If you use MKS, make sure to write your own
magnetic_energy field to deal with non-unitary \mu_0.
"""
return (data[ftype,"magnetic_field_x"]**2 +
data[ftype,"magnetic_field_y"]**2 +
data[ftype,"magnetic_field_z"]**2)/(8*np.pi)
- Units:
- Particle Type: False
Field Source
def _magnetic_field_poloidal(field,data):
normal = data.get_field_parameter("normal")
d = data[ftype,'magnetic_field_x']
Bfields = data.ds.arr(
[data[ftype,'magnetic_field_x'],
data[ftype,'magnetic_field_y'],
data[ftype,'magnetic_field_z']],
d.units)
theta = data["index", 'spherical_theta']
phi = data["index", 'spherical_phi']
return get_sph_theta_component(Bfields, theta, phi, normal)
- Units:
- Particle Type: False
Field Source
def _magnetic_field_strength(field,data):
"""This assumes that your front end has provided Bx, By, Bz in
units of Gauss. If you use MKS, make sure to write your own
PlasmaBeta field to deal with non-unitary \mu_0.
"""
return np.sqrt(8.*np.pi*data[ftype,"magnetic_energy"])
- Units:
- Particle Type: False
Field Source
def _magnetic_field_toroidal(field,data):
normal = data.get_field_parameter("normal")
d = data[ftype,'magnetic_field_x']
Bfields = data.ds.arr(
[data[ftype,'magnetic_field_x'],
data[ftype,'magnetic_field_y'],
data[ftype,'magnetic_field_z']],
d.units)
phi = data["index", 'spherical_phi']
return get_sph_phi_component(Bfields, phi, normal)
- Units:
- Particle Type: False
Field Source
def _magnetic_pressure(field,data):
return data[ftype,'magnetic_energy']
- Units:
- Particle Type: False
Field Source
def _matter_density(field, data):
return data[ftype, "density"] + \
data[ftype, "dark_matter_density"]
- Units:
- Particle Type: False
Field Source
def _matter_mass(field, data):
return data[ftype, "matter_density"] * data["index", "cell_volume"]
- Particle Type: False
Field Source
def _matter_overdensity(field, data):
if not hasattr(data.ds, "cosmological_simulation") or \
not data.ds.cosmological_simulation:
raise NeedsConfiguration("cosmological_simulation", 1)
co = data.ds.cosmology
# critical_density(z) ~ omega_lambda + omega_matter * (1 + z)^3
# mean density(z) ~ omega_matter * (1 + z)^3
return data[ftype, "matter_density"] / data.ds.omega_matter / \
co.critical_density(0.0) / \
(1.0 + data.ds.current_redshift)**3
- Units:
- Particle Type: False
Field Source
def _mazzotta_weighting(field, data):
# Spectroscopic-like weighting field for galaxy clusters
# Only useful as a weight_field for temperature, metallicity, velocity
return data["density"]*data["density"]*data["kT"]**-0.25/mh/mh
- Particle Type: False
Field Source
def _mean_molecular_weight(field, data):
return (data[ftype, "density"] / (mh * data[ftype, "number_density"]))
- Units:
- Particle Type: False
Field Source
def _metal_mass(field, data):
return data[ftype, "metal_density"] * data["index", "cell_volume"]
- Units:
- Particle Type: False
Field Source
def _metallicity(field, data):
tr = data[ftype, "metal_density"] / data[ftype, "density"]
tr /= metallicity_sun
return data.apply_units(tr, "Zsun")
- Particle Type: False
Field Source
def _overdensity(field, data):
if not hasattr(data.ds, "cosmological_simulation") or \
not data.ds.cosmological_simulation:
raise NeedsConfiguration("cosmological_simulation", 1)
co = data.ds.cosmology
return data[ftype, "matter_density"] / \
co.critical_density(data.ds.current_redshift)
- Particle Type: False
Field Source
def _plasma_beta(field,data):
"""This assumes that your front end has provided Bx, By, Bz in
units of Gauss. If you use MKS, make sure to write your own
plasma_beta field to deal with non-unitary \mu_0.
"""
return data[ftype,'pressure']/data[ftype,'magnetic_energy']
- Units:
- Particle Type: False
Field Source
def _magnitude(field, data):
fn = field_components[0]
mag = data[fn] * data[fn]
for idim in range(1, registry.ds.dimensionality):
fn = field_components[idim]
mag += data[fn] * data[fn]
return np.sqrt(mag)
- Units:
- Particle Type: False
Field Source
def func(field, data):
ds = div_fac * data["index", "dx"]
f = data[grad_field][slice_3dr]/ds[slice_3d]
f -= data[grad_field][slice_3dl]/ds[slice_3d]
new_field = data.ds.arr(np.zeros_like(data[grad_field], dtype=np.float64),
f.units)
new_field[slice_3d] = f
return new_field
- Units:
- Particle Type: False
Field Source
def func(field, data):
ds = div_fac * data["index", "dx"]
f = data[grad_field][slice_3dr]/ds[slice_3d]
f -= data[grad_field][slice_3dl]/ds[slice_3d]
new_field = data.ds.arr(np.zeros_like(data[grad_field], dtype=np.float64),
f.units)
new_field[slice_3d] = f
return new_field
- Units:
- Particle Type: False
Field Source
def func(field, data):
ds = div_fac * data["index", "dx"]
f = data[grad_field][slice_3dr]/ds[slice_3d]
f -= data[grad_field][slice_3dl]/ds[slice_3d]
new_field = data.ds.arr(np.zeros_like(data[grad_field], dtype=np.float64),
f.units)
new_field[slice_3d] = f
return new_field
- Particle Type: False
Field Source
def _radial_mach_number(field, data):
""" Radial component of M{|v|/c_sound} """
tr = data[ftype, "radial_velocity"] / data[ftype, "sound_speed"]
return np.abs(tr)
- Units:
- Particle Type: False
Field Source
def _radial(field, data):
normal = data.get_field_parameter("normal")
vectors = obtain_rv_vec(data, (xn, yn, zn),
"bulk_%s" % basename)
theta = data['index', 'spherical_theta']
phi = data['index', 'spherical_phi']
rv = get_sph_r_component(vectors, theta, phi, normal)
# Now, anywhere that radius is in fact zero, we want to zero out our
# return values.
rv[np.isnan(theta)] = 0.0
return rv
- Units:
- Particle Type: False
Field Source
def _radial_absolute(field, data):
return np.abs(data[ftype, "radial_%s" % basename])
- Units:
- Particle Type: False
Field Source
def _shear(field, data):
"""
Shear is defined as [(dvx/dy + dvy/dx)^2 + (dvz/dy + dvy/dz)^2 +
(dvx/dz + dvz/dx)^2 ]^(0.5)
where dvx/dy = [vx(j-1) - vx(j+1)]/[2dy]
and is in units of s^(-1)
(it's just like vorticity except add the derivative pairs instead
of subtracting them)
"""
if data.ds.dimensionality > 1:
dvydx = (data[ftype, "velocity_y"][sl_right,sl_center,sl_center] -
data[ftype, "velocity_y"][sl_left,sl_center,sl_center]) \
/ (div_fac*just_one(data["index", "dx"]))
dvxdy = (data[ftype, "velocity_x"][sl_center,sl_right,sl_center] -
data[ftype, "velocity_x"][sl_center,sl_left,sl_center]) \
/ (div_fac*just_one(data["index", "dy"]))
f = (dvydx + dvxdy)**2.0
del dvydx, dvxdy
if data.ds.dimensionality > 2:
dvzdy = (data[ftype, "velocity_z"][sl_center,sl_right,sl_center] -
data[ftype, "velocity_z"][sl_center,sl_left,sl_center]) \
/ (div_fac*just_one(data["index", "dy"]))
dvydz = (data[ftype, "velocity_y"][sl_center,sl_center,sl_right] -
data[ftype, "velocity_y"][sl_center,sl_center,sl_left]) \
/ (div_fac*just_one(data["index", "dz"]))
f += (dvzdy + dvydz)**2.0
del dvzdy, dvydz
dvxdz = (data[ftype, "velocity_x"][sl_center,sl_center,sl_right] -
data[ftype, "velocity_x"][sl_center,sl_center,sl_left]) \
/ (div_fac*just_one(data["index", "dz"]))
dvzdx = (data[ftype, "velocity_z"][sl_right,sl_center,sl_center] -
data[ftype, "velocity_z"][sl_left,sl_center,sl_center]) \
/ (div_fac*just_one(data["index", "dx"]))
f += (dvxdz + dvzdx)**2.0
del dvxdz, dvzdx
np.sqrt(f, out=f)
new_field = data.ds.arr(np.zeros_like(data[ftype, "velocity_x"]), f.units)
new_field[sl_center, sl_center, sl_center] = f
return new_field
- Units:
- Particle Type: False
Field Source
def _shear_criterion(field, data):
"""
Divide by c_s to leave shear in units of cm**-1, which
can be compared against the inverse of the local cell size (1/dx)
to determine if refinement should occur.
"""
return data[ftype, "shear"] / data[ftype, "sound_speed"]
- Particle Type: False
Field Source
def _shear_mach(field, data):
"""
Dimensionless shear (shear_mach) is defined nearly the same as shear,
except that it is scaled by the local dx/dy/dz and the local sound speed.
So it results in a unitless quantity that is effectively measuring
shear in mach number.
In order to avoid discontinuities created by multiplying by dx/dy/dz at
grid refinement boundaries, we also multiply by 2**GridLevel.
Shear (Mach) = [(dvx + dvy)^2 + (dvz + dvy)^2 +
(dvx + dvz)^2 ]^(0.5) / c_sound
"""
if data.ds.dimensionality > 1:
dvydx = (data[ftype, "velocity_y"][sl_right,sl_center,sl_center] -
data[ftype, "velocity_y"][sl_left,sl_center,sl_center]) \
/ div_fac
dvxdy = (data[ftype, "velocity_x"][sl_center,sl_right,sl_center] -
data[ftype, "velocity_x"][sl_center,sl_left,sl_center]) \
/ div_fac
f = (dvydx + dvxdy)**2.0
del dvydx, dvxdy
if data.ds.dimensionality > 2:
dvzdy = (data[ftype, "velocity_z"][sl_center,sl_right,sl_center] -
data[ftype, "velocity_z"][sl_center,sl_left,sl_center]) \
/ div_fac
dvydz = (data[ftype, "velocity_y"][sl_center,sl_center,sl_right] -
data[ftype, "velocity_y"][sl_center,sl_center,sl_left]) \
/ div_fac
f += (dvzdy + dvydz)**2.0
del dvzdy, dvydz
dvxdz = (data[ftype, "velocity_x"][sl_center,sl_center,sl_right] -
data[ftype, "velocity_x"][sl_center,sl_center,sl_left]) \
/ div_fac
dvzdx = (data[ftype, "velocity_z"][sl_right,sl_center,sl_center] -
data[ftype, "velocity_z"][sl_left,sl_center,sl_center]) \
/ div_fac
f += (dvxdz + dvzdx)**2.0
del dvxdz, dvzdx
f *= (2.0**data["index", "grid_level"][sl_center, sl_center, sl_center] /
data[ftype, "sound_speed"][sl_center, sl_center, sl_center])**2.0
np.sqrt(f, out=f)
new_field = data.ds.arr(np.zeros_like(data[ftype, "velocity_x"]), f.units)
new_field[sl_center, sl_center, sl_center] = f
return new_field
- Units:
- Particle Type: False
Field Source
def _sound_speed(field, data):
tr = data.ds.gamma * data[ftype, "pressure"] / data[ftype, "density"]
return np.sqrt(tr)
- Units:
- Particle Type: False
Field Source
def _magnitude(field, data):
fn = field_components[0]
mag = data[fn] * data[fn]
for idim in range(1, registry.ds.dimensionality):
fn = field_components[idim]
mag += data[fn] * data[fn]
return np.sqrt(mag)
- Units:
- Particle Type: False
Field Source
def _specific_angular_momentum_x(field, data):
xv, yv, zv = obtain_velocities(data, ftype)
rv = obtain_rvec(data)
rv = np.rollaxis(rv, 0, len(rv.shape))
rv = data.ds.arr(rv, input_units = data["index", "x"].units)
return yv * rv[...,2] - zv * rv[...,1]
- Units:
- Particle Type: False
Field Source
def _specific_angular_momentum_y(field, data):
xv, yv, zv = obtain_velocities(data, ftype)
rv = obtain_rvec(data)
rv = np.rollaxis(rv, 0, len(rv.shape))
rv = data.ds.arr(rv, input_units = data["index", "x"].units)
return - (xv * rv[...,2] - zv * rv[...,0])
- Units:
- Particle Type: False
Field Source
def _specific_angular_momentum_z(field, data):
xv, yv, zv = obtain_velocities(data, ftype)
rv = obtain_rvec(data)
rv = np.rollaxis(rv, 0, len(rv.shape))
rv = data.ds.arr(rv, input_units = data["index", "x"].units)
return xv * rv[...,1] - yv * rv[...,0]
- Units:
- Particle Type: False
Field Source
def _sz_kinetic(field, data):
scale = 0.88 * sigma_thompson / mh / clight
vel_axis = data.get_field_parameter("axis")
if vel_axis > 2:
raise NeedsParameter(["axis"])
vel = data[ftype, "velocity_%s" % ({0: "x", 1: "y", 2: "z"}[vel_axis])]
return scale * vel * data[ftype, "density"]
- Units:
- Particle Type: False
Field Source
def _szy(field, data):
scale = 0.88 / mh * kboltz / (me * clight*clight) * sigma_thompson
return scale * data[ftype, "density"] * data[ftype, "temperature"]
- Particle Type: False
Field Source
def _tangential_over_magnitude(field, data):
tr = data[ftype, "tangential_%s" % basename] / \
data[ftype, "%s_magnitude" % basename]
return np.abs(tr)
- Units:
- Particle Type: False
Field Source
def _tangential(field, data):
return np.sqrt(data[ftype, "%s_magnitude" % basename]**2.0
- data[ftype, "radial_%s" % basename]**2.0)
- Units:
- Particle Type: False
Field Source
def _divergence(field, data):
ds = div_fac * just_one(data["index", "dx"])
f = data[xn][sl_right,1:-1,1:-1]/ds
f -= data[xn][sl_left ,1:-1,1:-1]/ds
ds = div_fac * just_one(data["index", "dy"])
f += data[yn][1:-1,sl_right,1:-1]/ds
f -= data[yn][1:-1,sl_left ,1:-1]/ds
ds = div_fac * just_one(data["index", "dz"])
f += data[zn][1:-1,1:-1,sl_right]/ds
f -= data[zn][1:-1,1:-1,sl_left ]/ds
new_field = data.ds.arr(np.zeros(data[xn].shape, dtype=np.float64),
f.units)
new_field[1:-1,1:-1,1:-1] = f
return new_field
- Units:
- Particle Type: False
Field Source
def _divergence_abs(field, data):
return np.abs(data[ftype, "%s_divergence" % basename])
- Units:
- Particle Type: False
Field Source
def _magnitude(field, data):
fn = field_components[0]
mag = data[fn] * data[fn]
for idim in range(1, registry.ds.dimensionality):
fn = field_components[idim]
mag += data[fn] * data[fn]
return np.sqrt(mag)
- Units:
- Particle Type: False
Field Source
def _vorticity_growth_magnitude(field, data):
result = np.sqrt(data[ftype, "vorticity_growth_x"]**2 +
data[ftype, "vorticity_growth_y"]**2 +
data[ftype, "vorticity_growth_z"]**2)
dot = data.ds.arr(np.zeros(result.shape), "")
for ax in "xyz":
dot += (data[ftype, "vorticity_%s" % ax] *
data[ftype, "vorticity_growth_%s" % ax]).to_ndarray()
result = np.sign(dot) * result
return result
- Units:
- Particle Type: False
Field Source
def _vorticity_growth_magnitude_absolute(field, data):
return np.sqrt(data[ftype, "vorticity_growth_x"]**2 +
data[ftype, "vorticity_growth_y"]**2 +
data[ftype, "vorticity_growth_z"]**2)
- Units:
- Particle Type: False
Field Source
def _vorticity_growth_timescale(field, data):
domegax_dt = data[ftype, "vorticity_x"] / data[ftype, "vorticity_growth_x"]
domegay_dt = data[ftype, "vorticity_y"] / data[ftype, "vorticity_growth_y"]
domegaz_dt = data[ftype, "vorticity_z"] / data[ftype, "vorticity_growth_z"]
return np.sqrt(domegax_dt**2 + domegay_dt**2 + domegaz_dt**2)
- Units:
- Particle Type: False
Field Source
def _vorticity_growth_x(field, data):
return -data[ftype, "vorticity_stretching_x"] - \
data[ftype, "baroclinic_vorticity_x"]
- Units:
- Particle Type: False
Field Source
def _vorticity_growth_y(field, data):
return -data[ftype, "vorticity_stretching_y"] - \
data[ftype, "baroclinic_vorticity_y"]
- Units:
- Particle Type: False
Field Source
def _vorticity_growth_z(field, data):
return -data[ftype, "vorticity_stretching_z"] - \
data[ftype, "baroclinic_vorticity_z"]
- Units:
- Particle Type: False
Field Source
def _magnitude(field, data):
fn = field_components[0]
mag = data[fn] * data[fn]
for idim in range(1, registry.ds.dimensionality):
fn = field_components[idim]
mag += data[fn] * data[fn]
return np.sqrt(mag)
- Units:
- Particle Type: False
Field Source
def _vorticity_radiation_pressure_growth_magnitude(field, data):
result = np.sqrt(data[ftype, "vorticity_radiation_pressure_growth_x"]**2 +
data[ftype, "vorticity_radiation_pressure_growth_y"]**2 +
data[ftype, "vorticity_radiation_pressure_growth_z"]**2)
dot = data.ds.arr(np.zeros(result.shape), "")
for ax in "xyz":
dot += (data[ftype, "vorticity_%s" % ax] *
data[ftype, "vorticity_growth_%s" % ax]).to_ndarray()
result = np.sign(dot) * result
return result
- Units:
- Particle Type: False
Field Source
def _vorticity_radiation_pressure_growth_magnitude_absolute(field, data):
return np.sqrt(data[ftype, "vorticity_radiation_pressure_growth_x"]**2 +
data[ftype, "vorticity_radiation_pressure_growth_y"]**2 +
data[ftype, "vorticity_radiation_pressure_growth_z"]**2)
- Units:
- Particle Type: False
Field Source
def _vorticity_radiation_pressure_growth_timescale(field, data):
domegax_dt = data[ftype, "vorticity_x"] / \
data[ftype, "vorticity_radiation_pressure_growth_x"]
domegay_dt = data[ftype, "vorticity_y"] / \
data[ftype, "vorticity_radiation_pressure_growth_y"]
domegaz_dt = data[ftype, "vorticity_z"] / \
data[ftype, "vorticity_radiation_pressure_growth_z"]
return np.sqrt(domegax_dt**2 + domegay_dt**2 + domegaz_dt**2)
- Units:
- Particle Type: False
Field Source
def _vorticity_radiation_pressure_growth_x(field, data):
return -data[ftype, "vorticity_stretching_x"] - \
data[ftype, "baroclinic_vorticity_x"] \
-data[ftype, "vorticity_radiation_pressure_x"]
- Units:
- Particle Type: False
Field Source
def _vorticity_radiation_pressure_growth_y(field, data):
return -data[ftype, "vorticity_stretching_y"] - \
data[ftype, "baroclinic_vorticity_y"] \
-data[ftype, "vorticity_radiation_pressure_y"]
- Units:
- Particle Type: False
Field Source
def _vorticity_radiation_pressure_growth_z(field, data):
return -data[ftype, "vorticity_stretching_z"] - \
data[ftype, "baroclinic_vorticity_z"] \
-data[ftype, "vorticity_radiation_pressure_z"]
- Units:
- Particle Type: False
Field Source
def _magnitude(field, data):
fn = field_components[0]
mag = data[fn] * data[fn]
for idim in range(1, registry.ds.dimensionality):
fn = field_components[idim]
mag += data[fn] * data[fn]
return np.sqrt(mag)
- Units:
- Particle Type: False
Field Source
def _vorticity_radiation_pressure_x(field, data):
rho = data[ftype, "density"].astype(np.float64)
return (data[ftype, "radiation_acceleration_y"] *
data[ftype, "density_gradient_z"] -
data[ftype, "radiation_acceleration_z"] *
data[ftype, "density_gradient_y"]) / rho
- Units:
- Particle Type: False
Field Source
def _vorticity_radiation_pressure_y(field, data):
rho = data[ftype, "density"].astype(np.float64)
return (data[ftype, "radiation_acceleration_z"] *
data[ftype, "density_gradient_x"] -
data[ftype, "radiation_acceleration_x"] *
data[ftype, "density_gradient_z"]) / rho
- Units:
- Particle Type: False
Field Source
def _vorticity_radiation_pressure_z(field, data):
rho = data[ftype, "density"].astype(np.float64)
return (data[ftype, "radiation_acceleration_x"] *
data[ftype, "density_gradient_y"] -
data[ftype, "radiation_acceleration_y"] *
data[ftype, "density_gradient_x"]) / rho
- Units:
- Particle Type: False
Field Source
def _squared(field, data):
fn = field_components[0]
squared = data[fn] * data[fn]
for idim in range(1, registry.ds.dimensionality):
fn = field_components[idim]
squared += data[fn] * data[fn]
return squared
- Units:
- Particle Type: False
Field Source
def _magnitude(field, data):
fn = field_components[0]
mag = data[fn] * data[fn]
for idim in range(1, registry.ds.dimensionality):
fn = field_components[idim]
mag += data[fn] * data[fn]
return np.sqrt(mag)
- Units:
- Particle Type: False
Field Source
def _vorticity_stretching_x(field, data):
return data[ftype, "velocity_divergence"] * data[ftype, "vorticity_x"]
- Units:
- Particle Type: False
Field Source
def _vorticity_stretching_y(field, data):
return data[ftype, "velocity_divergence"] * data[ftype, "vorticity_y"]
- Units:
- Particle Type: False
Field Source
def _vorticity_stretching_z(field, data):
return data[ftype, "velocity_divergence"] * data[ftype, "vorticity_z"]
- Units:
- Particle Type: False
Field Source
def _vorticity_x(field, data):
f = (data[ftype, "velocity_z"][sl_center,sl_right,sl_center] -
data[ftype, "velocity_z"][sl_center,sl_left,sl_center]) \
/ (div_fac*just_one(data["index", "dy"]).in_cgs())
f -= (data[ftype, "velocity_y"][sl_center,sl_center,sl_right] -
data[ftype, "velocity_y"][sl_center,sl_center,sl_left]) \
/ (div_fac*just_one(data["index", "dz"].in_cgs()))
new_field = data.ds.arr(np.zeros_like(data[ftype, "velocity_z"],
dtype=np.float64),
f.units)
new_field[sl_center, sl_center, sl_center] = f
return new_field
- Units:
- Particle Type: False
Field Source
def _vorticity_y(field, data):
f = (data[ftype, "velocity_x"][sl_center,sl_center,sl_right] -
data[ftype, "velocity_x"][sl_center,sl_center,sl_left]) \
/ (div_fac*just_one(data["index", "dz"]))
f -= (data[ftype, "velocity_z"][sl_right,sl_center,sl_center] -
data[ftype, "velocity_z"][sl_left,sl_center,sl_center]) \
/ (div_fac*just_one(data["index", "dx"]))
new_field = data.ds.arr(np.zeros_like(data[ftype, "velocity_z"],
dtype=np.float64),
f.units)
new_field[sl_center, sl_center, sl_center] = f
return new_field
- Units:
- Particle Type: False
Field Source
def _vorticity_z(field, data):
f = (data[ftype, "velocity_y"][sl_right,sl_center,sl_center] -
data[ftype, "velocity_y"][sl_left,sl_center,sl_center]) \
/ (div_fac*just_one(data["index", "dx"]))
f -= (data[ftype, "velocity_x"][sl_center,sl_right,sl_center] -
data[ftype, "velocity_x"][sl_center,sl_left,sl_center]) \
/ (div_fac*just_one(data["index", "dy"]))
new_field = data.ds.arr(np.zeros_like(data[ftype, "velocity_z"],
dtype=np.float64),
f.units)
new_field[sl_center, sl_center, sl_center] = f
return new_field
- Units:
- Particle Type: False
Field Source
def _weak_lensing_convergence(field, data):
if not hasattr(data.ds, "cosmological_simulation") or \
not data.ds.cosmological_simulation:
raise NeedsConfiguration("cosmological_simulation", 1)
co = data.ds.cosmology
observer_redshift = data.get_field_parameter('observer_redshift')
source_redshift = data.get_field_parameter('source_redshift')
# observer to lens
dl = co.angular_diameter_distance(observer_redshift, data.ds.current_redshift)
# observer to source
ds = co.angular_diameter_distance(observer_redshift, source_redshift)
# lens to source
dls = co.angular_diameter_distance(data.ds.current_redshift, source_redshift)
# removed the factor of 1 / a to account for the fact that we are projecting
# with a proper distance.
return (1.5 * (co.hubble_constant / speed_of_light_cgs)**2 * (dl * dls / ds) * \
data[ftype, "matter_overdensity"]).in_units("1/cm")
- Particle Type: False
Field Source
def _xray_emissivity(field, data):
# old scaling coefficient was 2.168e60
return data.ds.arr(data[ftype, "density"].to_ndarray().astype(np.float64)**2
* data[ftype, "temperature"].to_ndarray()**0.5,
"") # add correct units here
- Units:
- Particle Type: False
Field Source
def _cell_volume(field, data):
rv = data["index", "dx"].copy(order='K')
rv *= data["index", "dy"]
rv *= data["index", "dz"]
return rv
- Units:
- Particle Type: False
Field Source
def _cylindrical_r(field, data):
normal = data.get_field_parameter("normal")
coords = get_periodic_rvec(data)
return data.ds.arr(get_cyl_r(coords, normal), "code_length").in_cgs()
- Particle Type: False
Field Source
def _cylindrical_theta(field, data):
normal = data.get_field_parameter("normal")
coords = get_periodic_rvec(data)
return get_cyl_theta(coords, normal)
- Units:
- Particle Type: False
Field Source
def _cylindrical_z(field, data):
normal = data.get_field_parameter("normal")
coords = get_periodic_rvec(data)
return data.ds.arr(get_cyl_z(coords, normal), "code_length").in_cgs()
- Particle Type: False
Field Source
def _disk_angle(field, data):
return data["index", "spherical_theta"]
- Units:
- Particle Type: False
Field Source
def _dds(field, data):
rv = data.ds.arr(data.fwidth[...,axi].copy(), units)
return data._reshape_vals(rv)
- Units:
- Particle Type: False
Field Source
def _dds(field, data):
rv = data.ds.arr(data.fwidth[...,axi].copy(), units)
return data._reshape_vals(rv)
- Units:
- Particle Type: False
Field Source
def _dds(field, data):
rv = data.ds.arr(data.fwidth[...,axi].copy(), units)
return data._reshape_vals(rv)
- Particle Type: False
Field Source
def _grid_indices(field, data):
return np.ones(data["index", "ones"].shape)*(data.id-data._id_offset)
- Particle Type: False
Field Source
def _grid_level(field, data):
return np.ones(data.ActiveDimensions)*(data.Level)
- Units:
- Particle Type: False
Field Source
def _height(field, data):
return data["index", "cylindrical_z"]
- Particle Type: False
Field Source
def _ones(field, data):
arr = np.ones(data.ires.shape, dtype="float64")
if data._spatial:
return data._reshape_vals(arr)
return data.apply_units(arr, field.units)
- Units:
- Particle Type: False
Field Source
def _ones_over_dx(field, data):
return np.ones(data["index", "ones"].shape,
dtype="float64")/data["index", "dx"]
- Units:
- Particle Type: False
Field Source
def _radius(field, data):
return get_radius(data, "")
- Particle Type: False
Field Source
def _spherical_phi(field, data):
normal = data.get_field_parameter("normal")
coords = get_periodic_rvec(data)
return get_sph_phi(coords, normal)
- Units:
- Particle Type: False
Field Source
def _spherical_r(field, data):
coords = get_periodic_rvec(data)
return data.ds.arr(get_sph_r(coords), "code_length").in_cgs()
- Particle Type: False
Field Source
def _spherical_theta(field, data):
normal = data.get_field_parameter("normal")
coords = get_periodic_rvec(data)
return get_sph_theta(coords, normal)
- Particle Type: False
Field Source
def _virial_radius_fraction(field, data):
virial_radius = data.get_field_parameter("virial_radius")
return data["radius"] / virial_radius
- Units:
- Particle Type: False
Field Source
def _coords(field, data):
rv = data.ds.arr(data.fcoords[...,axi].copy(), units)
return data._reshape_vals(rv)
- Units:
- Particle Type: False
Field Source
def _coords(field, data):
rv = data.ds.arr(data.fcoords[...,axi].copy(), units)
return data._reshape_vals(rv)
- Units:
- Particle Type: False
Field Source
def _coords(field, data):
rv = data.ds.arr(data.fcoords[...,axi].copy(), units)
return data._reshape_vals(rv)
- Particle Type: False
Field Source
def _zeros(field, data):
arr = np.zeros(data["index", "ones"].shape, dtype='float64')
return data.apply_units(arr, field.units)
- Particle Type: True
Field Source
def particle_mesh_ids(field, data):
pos = data[ptype, coord_name]
ids = np.zeros(pos.shape[0], dtype="float64") - 1
# This is float64 in name only. It will be properly cast inside the
# deposit operation.
#_ids = ids.view("float64")
data.deposit(pos, [ids], method = "mesh_id")
return data.apply_units(ids, "")
- Units:
- Particle Type: True
Field Source
def _particle_angular_momentum(field, data):
return data[ptype, "particle_mass"] \
* data[ptype, "particle_specific_angular_momentum"]
- Units:
- Particle Type: True
Field Source
def _magnitude(field, data):
fn = field_components[0]
mag = data[fn] * data[fn]
for idim in range(1, registry.ds.dimensionality):
fn = field_components[idim]
mag += data[fn] * data[fn]
return np.sqrt(mag)
- Units:
- Particle Type: True
Field Source
def _particle_angular_momentum_x(field, data):
return data[ptype, "particle_mass"] * \
data[ptype, "particle_specific_angular_momentum_x"]
- Units:
- Particle Type: True
Field Source
def _particle_angular_momentum_y(field, data):
return data[ptype, "particle_mass"] * \
data[ptype, "particle_specific_angular_momentum_y"]
- Units:
- Particle Type: True
Field Source
def _particle_angular_momentum_z(field, data):
return data[ptype, "particle_mass"] * \
data[ptype, "particle_specific_angular_momentum_z"]
- Particle Type: True
Field Source
def particle_ones(field, data):
v = np.ones(data[ptype, mass_name].shape, dtype="float64")
return data.apply_units(v, field.units)
- Units:
- Particle Type: True
Field Source
def particle_vectors(field, data):
v = [data[_ptype, name].in_units(field.units)
for name in names]
c = np.column_stack(v)
return data.apply_units(c, field.units)
- Units:
- Particle Type: True
Field Source
def _particle_spherical_velocity_radius(field, data):
"""
Radial component of the particles' velocity vectors in spherical coords
based on the provided field parameters for 'normal', 'center', and
'bulk_velocity',
"""
normal = data.get_field_parameter('normal')
center = data.get_field_parameter('center')
bv = data.get_field_parameter("bulk_velocity")
pos = spos
pos = YTArray([data[ptype, pos % ax] for ax in "xyz"])
vel = svel
vel = YTArray([data[ptype, vel % ax] for ax in "xyz"])
theta = get_sph_theta(pos, center)
phi = get_sph_phi(pos, center)
pos = pos - np.reshape(center, (3, 1))
vel = vel - np.reshape(bv, (3, 1))
sphr = get_sph_r_component(vel, theta, phi, normal)
return sphr
- Units:
- Particle Type: True
Field Source
def _particle_radius(field, data):
return get_radius(data, "particle_position_")
- Units:
- Particle Type: True
Field Source
def _particle_specific_angular_momentum(field, data):
"""
Calculate the angular of a particle velocity. Returns a vector for each
particle.
"""
if data.has_field_parameter("bulk_velocity"):
bv = data.get_field_parameter("bulk_velocity")
else: bv = np.zeros(3, dtype=np.float64)
xv = data[ptype, svel % 'x'] - bv[0]
yv = data[ptype, svel % 'y'] - bv[1]
zv = data[ptype, svel % 'z'] - bv[2]
center = data.get_field_parameter('center')
coords = YTArray([data[ptype, spos % 'x'],
data[ptype, spos % 'y'],
data[ptype, spos % 'z']], dtype=np.float64)
new_shape = tuple([3] + [1]*(len(coords.shape)-1))
r_vec = coords - np.reshape(center,new_shape)
v_vec = YTArray([xv,yv,zv], dtype=np.float64)
return np.cross(r_vec, v_vec, axis=0)
- Units:
- Particle Type: True
Field Source
def _magnitude(field, data):
fn = field_components[0]
mag = data[fn] * data[fn]
for idim in range(1, registry.ds.dimensionality):
fn = field_components[idim]
mag += data[fn] * data[fn]
return np.sqrt(mag)
- Units:
- Particle Type: True
Field Source
def _particle_specific_angular_momentum_x(field, data):
if data.has_field_parameter("bulk_velocity"):
bv = data.get_field_parameter("bulk_velocity")
else: bv = np.zeros(3, dtype=np.float64)
center = data.get_field_parameter('center')
y = data[ptype, spos % "y"] - center[1]
z = data[ptype, spos % "z"] - center[2]
yv = data[ptype, svel % "y"] - bv[1]
zv = data[ptype, svel % "z"] - bv[2]
return yv*z - zv*y
- Units:
- Particle Type: True
Field Source
def _particle_specific_angular_momentum_y(field, data):
if data.has_field_parameter("bulk_velocity"):
bv = data.get_field_parameter("bulk_velocity")
else: bv = np.zeros(3, dtype=np.float64)
center = data.get_field_parameter('center')
x = data[ptype, spos % "x"] - center[0]
z = data[ptype, spos % "z"] - center[2]
xv = data[ptype, svel % "x"] - bv[0]
zv = data[ptype, svel % "z"] - bv[2]
return -(xv*z - zv*x)
- Units:
- Particle Type: True
Field Source
def _particle_specific_angular_momentum_z(field, data):
if data.has_field_parameter("bulk_velocity"):
bv = data.get_field_parameter("bulk_velocity")
else: bv = np.zeros(3, dtype=np.float64)
center = data.get_field_parameter('center')
x = data[ptype, spos % "x"] - center[0]
y = data[ptype, spos % "y"] - center[1]
xv = data[ptype, svel % "x"] - bv[0]
yv = data[ptype, svel % "y"] - bv[1]
return xv*y - yv*x
- Units:
- Particle Type: True
Field Source
def _particle_spherical_position_phi(field, data):
"""
Phi component of the particles' position vectors in spherical coords
on the provided field parameters for 'normal', 'center', and
'bulk_velocity',
"""
normal = data.get_field_parameter('normal')
center = data.get_field_parameter('center')
bv = data.get_field_parameter("bulk_velocity")
pos = spos
pos = YTArray([data[ptype, pos % ax] for ax in "xyz"])
theta = get_sph_theta(pos, center)
phi = get_sph_phi(pos, center)
pos = pos - np.reshape(center, (3, 1))
sphp = get_sph_phi_component(pos, phi, normal)
return sphp
- Units:
- Particle Type: True
Field Source
def _particle_spherical_position_radius(field, data):
"""
Radial component of the particles' position vectors in spherical coords
on the provided field parameters for 'normal', 'center', and
'bulk_velocity',
"""
normal = data.get_field_parameter('normal')
center = data.get_field_parameter('center')
bv = data.get_field_parameter("bulk_velocity")
pos = spos
pos = YTArray([data[ptype, pos % ax] for ax in "xyz"])
theta = get_sph_theta(pos, center)
phi = get_sph_phi(pos, center)
pos = pos - np.reshape(center, (3, 1))
sphr = get_sph_r_component(pos, theta, phi, normal)
return sphr
- Units:
- Particle Type: True
Field Source
def _particle_spherical_position_theta(field, data):
"""
Theta component of the particles' position vectors in spherical coords
on the provided field parameters for 'normal', 'center', and
'bulk_velocity',
"""
normal = data.get_field_parameter('normal')
center = data.get_field_parameter('center')
bv = data.get_field_parameter("bulk_velocity")
pos = spos
pos = YTArray([data[ptype, pos % ax] for ax in "xyz"])
theta = get_sph_theta(pos, center)
phi = get_sph_phi(pos, center)
pos = pos - np.reshape(center, (3, 1))
spht = get_sph_theta_component(pos, theta, phi, normal)
return spht
- Units:
- Particle Type: True
Field Source
def _particle_spherical_velocity_phi(field, data):
"""
Phi component of the particles' velocity vectors in spherical coords
based on the provided field parameters for 'normal', 'center', and
'bulk_velocity',
"""
normal = data.get_field_parameter('normal')
center = data.get_field_parameter('center')
bv = data.get_field_parameter("bulk_velocity")
pos = YTArray([data[ptype, spos % ax] for ax in "xyz"])
vel = YTArray([data[ptype, svel % ax] for ax in "xyz"])
theta = get_sph_theta(pos, center)
phi = get_sph_phi(pos, center)
pos = pos - np.reshape(center, (3, 1))
vel = vel - np.reshape(bv, (3, 1))
sphp = get_sph_phi_component(vel, phi, normal)
return sphp
- Units:
- Particle Type: True
Field Source
def _particle_spherical_velocity_radius(field, data):
"""
Radial component of the particles' velocity vectors in spherical coords
based on the provided field parameters for 'normal', 'center', and
'bulk_velocity',
"""
normal = data.get_field_parameter('normal')
center = data.get_field_parameter('center')
bv = data.get_field_parameter("bulk_velocity")
pos = spos
pos = YTArray([data[ptype, pos % ax] for ax in "xyz"])
vel = svel
vel = YTArray([data[ptype, vel % ax] for ax in "xyz"])
theta = get_sph_theta(pos, center)
phi = get_sph_phi(pos, center)
pos = pos - np.reshape(center, (3, 1))
vel = vel - np.reshape(bv, (3, 1))
sphr = get_sph_r_component(vel, theta, phi, normal)
return sphr
- Units:
- Particle Type: True
Field Source
def _particle_spherical_velocity_theta(field, data):
"""
Theta component of the particles' velocity vectors in spherical coords
based on the provided field parameters for 'normal', 'center', and
'bulk_velocity',
"""
normal = data.get_field_parameter('normal')
center = data.get_field_parameter('center')
bv = data.get_field_parameter("bulk_velocity")
pos = spos
pos = YTArray([data[ptype, pos % ax] for ax in "xyz"])
vel = svel
vel = YTArray([data[ptype, vel % ax] for ax in "xyz"])
theta = get_sph_theta(pos, center)
phi = get_sph_phi(pos, center)
pos = pos - np.reshape(center, (3, 1))
vel = vel - np.reshape(bv, (3, 1))
spht = get_sph_theta_component(vel, theta, phi, normal)
return spht
- Units:
- Particle Type: True
Field Source
def particle_vectors(field, data):
v = [data[_ptype, name].in_units(field.units)
for name in names]
c = np.column_stack(v)
return data.apply_units(c, field.units)
- Units:
- Particle Type: True
Field Source
def _particle_velocity_magnitude(field, data):
""" M{|v|} """
bulk_velocity = data.get_field_parameter("bulk_velocity")
if bulk_velocity is None:
bulk_velocity = np.zeros(3)
return np.sqrt((data[ptype, svel % 'x'] - bulk_velocity[0])**2
+ (data[ptype, svel % 'y'] - bulk_velocity[1])**2
+ (data[ptype, svel % 'z'] - bulk_velocity[2])**2 )
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘art’, ‘Density’) | ![]() |
density |
0 | |
(‘art’, ‘TotalEnergy’) | ![]() |
total_energy |
0 | |
(‘art’, ‘XMomentumDensity’) | ![]() |
momentum_x |
0 | |
(‘art’, ‘YMomentumDensity’) | ![]() |
momentum_y |
0 | |
(‘art’, ‘ZMomentumDensity’) | ![]() |
momentum_z |
0 | |
(‘art’, ‘Pressure’) | pressure |
0 | ||
(‘art’, ‘Gamma’) | gamma |
0 | ||
(‘art’, ‘GasEnergy’) | ![]() |
thermal_energy |
0 | |
(‘art’, ‘MetalDensitySNII’) | ![]() |
metal_ii_density |
0 | |
(‘art’, ‘MetalDensitySNIa’) | ![]() |
metal_ia_density |
0 | |
(‘art’, ‘PotentialNew’) | potential |
0 | ||
(‘art’, ‘PotentialOld’) | gas_potential |
0 | ||
(‘io’, ‘particle_position_x’) | ![]() |
1 | ||
(‘io’, ‘particle_position_y’) | ![]() |
1 | ||
(‘io’, ‘particle_position_z’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_x’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_y’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_z’) | ![]() |
1 | ||
(‘io’, ‘particle_mass’) | ![]() |
1 | ||
(‘io’, ‘particle_index’) | 1 | |||
(‘io’, ‘particle_species’) | particle_type |
1 | ||
(‘io’, ‘particle_creation_time’) | ![]() |
1 | ||
(‘io’, ‘particle_mass_initial’) | ![]() |
1 | ||
(‘io’, ‘particle_metallicity1’) | 1 | |||
(‘io’, ‘particle_metallicity2’) | 1 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘artio’, ‘HVAR_GAS_DENSITY’) | ![]() |
density |
0 | |
(‘artio’, ‘HVAR_GAS_ENERGY’) | ![]() |
total_energy |
0 | |
(‘artio’, ‘HVAR_INTERNAL_ENERGY’) | ![]() |
thermal_energy |
0 | |
(‘artio’, ‘HVAR_PRESSURE’) | pressure |
0 | ||
(‘artio’, ‘HVAR_MOMENTUM_X’) | ![]() |
momentum_x |
0 | |
(‘artio’, ‘HVAR_MOMENTUM_Y’) | ![]() |
momentum_y |
0 | |
(‘artio’, ‘HVAR_MOMENTUM_Z’) | ![]() |
momentum_z |
0 | |
(‘artio’, ‘HVAR_GAMMA’) | gamma |
0 | ||
(‘artio’, ‘HVAR_METAL_DENSITY_Ia’) | ![]() |
metal_ia_density |
0 | |
(‘artio’, ‘HVAR_METAL_DENSITY_II’) | ![]() |
metal_ii_density |
0 | |
(‘artio’, ‘VAR_POTENTIAL’) | potential |
0 | ||
(‘artio’, ‘VAR_POTENTIAL_HYDRO’) | gas_potential |
0 | ||
(‘io’, ‘POSITION_X’) | ![]() |
particle_position_x |
1 | |
(‘io’, ‘POSITION_Y’) | ![]() |
particle_position_y |
1 | |
(‘io’, ‘POSITION_Z’) | ![]() |
particle_position_z |
1 | |
(‘io’, ‘VELOCITY_X’) | ![]() |
particle_velocity_x |
1 | |
(‘io’, ‘VELOCITY_Y’) | ![]() |
particle_velocity_y |
1 | |
(‘io’, ‘VELOCITY_Z’) | ![]() |
particle_velocity_z |
1 | |
(‘io’, ‘MASS’) | ![]() |
particle_mass |
1 | |
(‘io’, ‘PID’) | particle_index |
1 | ||
(‘io’, ‘SPECIES’) | particle_type |
1 | ||
(‘io’, ‘BIRTH_TIME’) | 1 | |||
(‘io’, ‘INITIAL_MASS’) | ![]() |
initial_mass |
1 | |
(‘io’, ‘METALLICITY_SNIa’) | metallicity_snia |
1 | ||
(‘io’, ‘METALLICITY_SNII’) | metallicity_snii |
1 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘athena’, ‘density’) | ![]() |
density |
0 | |
(‘athena’, ‘cell_centered_B_x’) | ![]() |
magnetic_field_x |
0 | |
(‘athena’, ‘cell_centered_B_y’) | ![]() |
magnetic_field_y |
0 | |
(‘athena’, ‘cell_centered_B_z’) | ![]() |
magnetic_field_z |
0 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘boxlib’, ‘density’) | ![]() |
density |
0 | |
(‘boxlib’, ‘eden’) | ![]() |
energy_density |
0 | |
(‘boxlib’, ‘xmom’) | ![]() |
momentum_x |
0 | |
(‘boxlib’, ‘ymom’) | ![]() |
momentum_y |
0 | |
(‘boxlib’, ‘zmom’) | ![]() |
momentum_z |
0 | |
(‘boxlib’, ‘temperature’) | ![]() |
temperature |
0 | |
(‘boxlib’, ‘Temp’) | ![]() |
temperature |
0 | |
(‘boxlib’, ‘x_velocity’) | ![]() |
velocity_x |
0 | |
(‘boxlib’, ‘y_velocity’) | ![]() |
velocity_y |
0 | |
(‘boxlib’, ‘z_velocity’) | ![]() |
velocity_z |
0 | |
(‘boxlib’, ‘xvel’) | ![]() |
velocity_x |
0 | |
(‘boxlib’, ‘yvel’) | ![]() |
velocity_y |
0 | |
(‘boxlib’, ‘zvel’) | ![]() |
velocity_z |
0 | |
(‘io’, ‘particle_mass’) | ![]() |
1 | ||
(‘io’, ‘particle_position_x’) | ![]() |
1 | ||
(‘io’, ‘particle_position_y’) | ![]() |
1 | ||
(‘io’, ‘particle_position_z’) | ![]() |
1 | ||
(‘io’, ‘particle_momentum_x’) | ![]() |
1 | ||
(‘io’, ‘particle_momentum_y’) | ![]() |
1 | ||
(‘io’, ‘particle_momentum_z’) | ![]() |
1 | ||
(‘io’, ‘particle_angmomen_x’) | ![]() |
1 | ||
(‘io’, ‘particle_angmomen_y’) | ![]() |
1 | ||
(‘io’, ‘particle_angmomen_z’) | ![]() |
1 | ||
(‘io’, ‘particle_id’) | particle_index |
1 | ||
(‘io’, ‘particle_mdot’) | ![]() |
1 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘boxlib’, ‘density’) | ![]() |
density |
0 | ![]() |
(‘boxlib’, ‘xmom’) | ![]() |
momentum_x |
0 | ![]() |
(‘boxlib’, ‘ymom’) | ![]() |
momentum_y |
0 | ![]() |
(‘boxlib’, ‘zmom’) | ![]() |
momentum_z |
0 | ![]() |
(‘boxlib’, ‘x_velocity’) | ![]() |
velocity_x |
0 | ![]() |
(‘boxlib’, ‘y_velocity’) | ![]() |
velocity_y |
0 | ![]() |
(‘boxlib’, ‘z_velocity’) | ![]() |
velocity_z |
0 | ![]() |
(‘boxlib’, ‘rho_E’) | ![]() |
energy_density |
0 | ![]() |
(‘boxlib’, ‘rho_e’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘Temp’) | ![]() |
temperature |
0 | ![]() |
(‘boxlib’, ‘grav_x’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘grav_y’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘grav_z’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘pressure’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘kineng’) | ![]() |
kinetic_energy |
0 | ![]() |
(‘boxlib’, ‘soundspeed’) | ![]() |
sound_speed |
0 | ![]() |
(‘boxlib’, ‘Machnumber’) | mach_number |
0 | ![]() |
|
(‘boxlib’, ‘entropy’) | ![]() |
entropy |
0 | ![]() |
(‘boxlib’, ‘magvort’) | ![]() |
vorticity_magnitude |
0 | ![]() |
(‘boxlib’, ‘divu’) | ![]() |
velocity_divergence |
0 | ![]() |
(‘boxlib’, ‘eint_E’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘eint_e’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘magvel’) | ![]() |
velocity_magnitude |
0 | ![]() |
(‘boxlib’, ‘radvel’) | ![]() |
radial_velocity |
0 | ![]() |
(‘boxlib’, ‘magmom’) | ![]() |
momentum_magnitude |
0 | ![]() |
(‘boxlib’, ‘maggrav’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘phiGrav’) | ![]() |
0 | ![]() |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘boxlib’, ‘density’) | ![]() |
density |
0 | |
(‘boxlib’, ‘x_vel’) | ![]() |
velocity_x |
0 | ![]() |
(‘boxlib’, ‘y_vel’) | ![]() |
velocity_y |
0 | ![]() |
(‘boxlib’, ‘z_vel’) | ![]() |
velocity_z |
0 | ![]() |
(‘boxlib’, ‘magvel’) | ![]() |
velocity_magnitude |
0 | ![]() |
(‘boxlib’, ‘radial_velocity’) | ![]() |
radial_velocity |
0 | ![]() |
(‘boxlib’, ‘circum_velocity’) | ![]() |
tangential_velocity |
0 | ![]() |
(‘boxlib’, ‘tfromp’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘tfromh’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘Machnumber’) | mach_number |
0 | ![]() |
|
(‘boxlib’, ‘S’) | ![]() |
0 | ||
(‘boxlib’, ‘ad_excess’) | 0 | ![]() |
||
(‘boxlib’, ‘deltaT’) | 0 | ![]() |
||
(‘boxlib’, ‘deltagamma’) | 0 | ![]() |
||
(‘boxlib’, ‘deltap’) | 0 | ![]() |
||
(‘boxlib’, ‘divw0’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘entropy’) | ![]() |
entropy |
0 | ![]() |
(‘boxlib’, ‘entropypert’) | 0 | ![]() |
||
(‘boxlib’, ‘enucdot’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘Hext’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘gpi_x’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘gpi_y’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘gpi_z’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘h’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘h0’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘momentum’) | ![]() |
momentum_magnitude |
0 | ![]() |
(‘boxlib’, ‘p0’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘p0pluspi’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘pi’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘pioverp0’) | 0 | ![]() |
||
(‘boxlib’, ‘rho0’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘rhoh’) | ![]() |
enthalpy_density |
0 | ![]() |
(‘boxlib’, ‘rhoh0’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘rhohpert’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘rhopert’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘soundspeed’) | ![]() |
sound_speed |
0 | |
(‘boxlib’, ‘sponge’) | 0 | |||
(‘boxlib’, ‘tpert’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘vort’) | ![]() |
vorticity_magnitude |
0 | ![]() |
(‘boxlib’, ‘w0_x’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘w0_y’) | ![]() |
0 | ![]() |
|
(‘boxlib’, ‘w0_z’) | ![]() |
0 | ![]() |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘boxlib’, ‘density’) | ![]() |
density |
0 | |
(‘boxlib’, ‘eden’) | ![]() |
energy_density |
0 | |
(‘boxlib’, ‘xmom’) | ![]() |
momentum_x |
0 | |
(‘boxlib’, ‘ymom’) | ![]() |
momentum_y |
0 | |
(‘boxlib’, ‘zmom’) | ![]() |
momentum_z |
0 | |
(‘boxlib’, ‘temperature’) | ![]() |
temperature |
0 | |
(‘boxlib’, ‘Temp’) | ![]() |
temperature |
0 | |
(‘boxlib’, ‘x_velocity’) | ![]() |
velocity_x |
0 | |
(‘boxlib’, ‘y_velocity’) | ![]() |
velocity_y |
0 | |
(‘boxlib’, ‘z_velocity’) | ![]() |
velocity_z |
0 | |
(‘boxlib’, ‘xvel’) | ![]() |
velocity_x |
0 | |
(‘boxlib’, ‘yvel’) | ![]() |
velocity_y |
0 | |
(‘boxlib’, ‘zvel’) | ![]() |
velocity_z |
0 | |
(‘io’, ‘particle_mass’) | ![]() |
1 | ||
(‘io’, ‘particle_position_x’) | ![]() |
1 | ||
(‘io’, ‘particle_position_y’) | ![]() |
1 | ||
(‘io’, ‘particle_position_z’) | ![]() |
1 | ||
(‘io’, ‘particle_momentum_x’) | ![]() |
1 | ||
(‘io’, ‘particle_momentum_y’) | ![]() |
1 | ||
(‘io’, ‘particle_momentum_z’) | ![]() |
1 | ||
(‘io’, ‘particle_angmomen_x’) | ![]() |
1 | ||
(‘io’, ‘particle_angmomen_y’) | ![]() |
1 | ||
(‘io’, ‘particle_angmomen_z’) | ![]() |
1 | ||
(‘io’, ‘particle_id’) | particle_index |
1 | ||
(‘io’, ‘particle_mdot’) | ![]() |
1 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘chombo’, ‘density’) | ![]() |
density Density |
0 | |
(‘chombo’, ‘potential’) | ![]() |
potential Potential |
0 | |
(‘chombo’, ‘gravitational_field_x’) | ![]() |
0 | ||
(‘chombo’, ‘gravitational_field_y’) | ![]() |
0 | ||
(‘chombo’, ‘gravitational_field_z’) | ![]() |
0 | ||
(‘io’, ‘particle_mass’) | ![]() |
1 | ||
(‘io’, ‘particle_position_x’) | ![]() |
1 | ||
(‘io’, ‘particle_position_y’) | ![]() |
1 | ||
(‘io’, ‘particle_position_z’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_x’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_y’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_z’) | ![]() |
1 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘chombo’, ‘density’) | ![]() |
density |
0 | |
(‘chombo’, ‘energy-density’) | ![]() |
energy_density |
0 | |
(‘chombo’, ‘radiation-energy-density’) | ![]() |
radiation_energy_density |
0 | |
(‘chombo’, ‘X-momentum’) | ![]() |
momentum_x |
0 | |
(‘chombo’, ‘Y-momentum’) | ![]() |
momentum_y |
0 | |
(‘chombo’, ‘Z-momentum’) | ![]() |
momentum_z |
0 | |
(‘chombo’, ‘temperature’) | ![]() |
temperature |
0 | |
(‘chombo’, ‘X-magnfield’) | ![]() |
magnetic_field_x |
0 | |
(‘chombo’, ‘Y-magnfield’) | ![]() |
magnetic_field_y |
0 | |
(‘chombo’, ‘Z-magnfield’) | ![]() |
magnetic_field_z |
0 | |
(‘io’, ‘particle_mass’) | ![]() |
1 | ||
(‘io’, ‘particle_position_x’) | ![]() |
1 | ||
(‘io’, ‘particle_position_y’) | ![]() |
1 | ||
(‘io’, ‘particle_position_z’) | ![]() |
1 | ||
(‘io’, ‘particle_momentum_x’) | ![]() |
1 | ||
(‘io’, ‘particle_momentum_y’) | ![]() |
1 | ||
(‘io’, ‘particle_momentum_z’) | ![]() |
1 | ||
(‘io’, ‘particle_angmomen_x’) | ![]() |
1 | ||
(‘io’, ‘particle_angmomen_y’) | ![]() |
1 | ||
(‘io’, ‘particle_angmomen_z’) | ![]() |
1 | ||
(‘io’, ‘particle_mlast’) | ![]() |
1 | ||
(‘io’, ‘particle_r’) | ![]() |
1 | ||
(‘io’, ‘particle_mdeut’) | ![]() |
1 | ||
(‘io’, ‘particle_n’) | 1 | |||
(‘io’, ‘particle_mdot’) | ![]() |
1 | ||
(‘io’, ‘particle_burnstate’) | 1 | |||
(‘io’, ‘particle_luminosity’) | 1 | |||
(‘io’, ‘particle_id’) | particle_index |
1 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘chombo’, ‘rho’) | ![]() |
density |
0 | |
(‘chombo’, ‘prs’) | ![]() |
pressure |
0 | |
(‘chombo’, ‘vx1’) | ![]() |
velocity_x |
0 | |
(‘chombo’, ‘vx2’) | ![]() |
velocity_y |
0 | |
(‘chombo’, ‘vx3’) | ![]() |
velocity_z |
0 | |
(‘chombo’, ‘bx1’) | ![]() |
magnetic_field_x |
0 | |
(‘chombo’, ‘bx2’) | ![]() |
magnetic_field_y |
0 | |
(‘chombo’, ‘bx3’) | ![]() |
magnetic_field_z |
0 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘io’, ‘Mass’) | ![]() |
particle_mass |
1 | |
(‘io’, ‘Masses’) | ![]() |
particle_mass |
1 | |
(‘io’, ‘Coordinates’) | ![]() |
particle_position |
1 | |
(‘io’, ‘Velocity’) | ![]() |
particle_velocity |
1 | |
(‘io’, ‘Velocities’) | ![]() |
particle_velocity |
1 | |
(‘io’, ‘ParticleIDs’) | particle_index |
1 | ||
(‘io’, ‘InternalEnergy’) | thermal_energy |
1 | ||
(‘io’, ‘SmoothingLength’) | ![]() |
smoothing_length |
1 | |
(‘io’, ‘Density’) | ![]() |
density |
1 | |
(‘io’, ‘MaximumTemperature’) | ![]() |
1 | ||
(‘io’, ‘Temperature’) | ![]() |
temperature |
1 | |
(‘io’, ‘Epsilon’) | ![]() |
1 | ||
(‘io’, ‘Metals’) | ![]() |
metallicity |
1 | |
(‘io’, ‘Metallicity’) | ![]() |
metallicity |
1 | |
(‘io’, ‘Phi’) | ![]() |
1 | ||
(‘io’, ‘FormationTime’) | ![]() |
creation_time |
1 | |
(‘io’, ‘Metallicity_00’) | metallicity |
1 | ||
(‘io’, ‘Metallicity_01’) | He_fraction |
1 | ||
(‘io’, ‘Metallicity_02’) | C_fraction |
1 | ||
(‘io’, ‘Metallicity_03’) | N_fraction |
1 | ||
(‘io’, ‘Metallicity_04’) | O_fraction |
1 | ||
(‘io’, ‘Metallicity_05’) | Ne_fraction |
1 | ||
(‘io’, ‘Metallicity_06’) | Mg_fraction |
1 | ||
(‘io’, ‘Metallicity_07’) | Si_fraction |
1 | ||
(‘io’, ‘Metallicity_08’) | S_fraction |
1 | ||
(‘io’, ‘Metallicity_09’) | Ca_fraction |
1 | ||
(‘io’, ‘Metallicity_10’) | Fe_fraction |
1 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘enzo’, ‘Cooling_Time’) | ![]() |
cooling_time |
0 | |
(‘enzo’, ‘Dengo_Cooling_Rate’) | ![]() |
0 | ||
(‘enzo’, ‘Grackle_Cooling_Rate’) | ![]() |
0 | ||
(‘enzo’, ‘HI_kph’) | ![]() |
0 | ||
(‘enzo’, ‘HeI_kph’) | ![]() |
0 | ||
(‘enzo’, ‘HeII_kph’) | ![]() |
0 | ||
(‘enzo’, ‘H2I_kdiss’) | ![]() |
0 | ||
(‘enzo’, ‘Bx’) | ![]() |
magnetic_field_x |
0 | |
(‘enzo’, ‘By’) | ![]() |
magnetic_field_y |
0 | |
(‘enzo’, ‘Bz’) | ![]() |
magnetic_field_z |
0 | |
(‘enzo’, ‘RadAccel1’) | ![]() |
radiation_acceleration_x |
0 | |
(‘enzo’, ‘RadAccel2’) | ![]() |
radiation_acceleration_y |
0 | |
(‘enzo’, ‘RadAccel3’) | ![]() |
radiation_acceleration_z |
0 | |
(‘enzo’, ‘Dark_Matter_Density’) | ![]() |
dark_matter_density |
0 | |
(‘enzo’, ‘Temperature’) | ![]() |
temperature |
0 | |
(‘enzo’, ‘Dust_Temperature’) | ![]() |
dust_temperature |
0 | |
(‘enzo’, ‘x-velocity’) | ![]() |
velocity_x |
0 | |
(‘enzo’, ‘y-velocity’) | ![]() |
velocity_y |
0 | |
(‘enzo’, ‘z-velocity’) | ![]() |
velocity_z |
0 | |
(‘enzo’, ‘RaySegments’) | ray_segments |
0 | ||
(‘enzo’, ‘PhotoGamma’) | ![]() |
photo_gamma |
0 | |
(‘enzo’, ‘PotentialField’) | ![]() |
gravitational_potential |
0 | |
(‘enzo’, ‘Density’) | ![]() |
density |
0 | |
(‘enzo’, ‘Metal_Density’) | ![]() |
metal_density |
0 | |
(‘enzo’, ‘SN_Colour’) | ![]() |
0 | ||
(‘enzo’, ‘Electron_Density’) | ![]() |
0 | ||
(‘io’, ‘particle_position_x’) | ![]() |
1 | ||
(‘io’, ‘particle_position_y’) | ![]() |
1 | ||
(‘io’, ‘particle_position_z’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_x’) | ![]() |
particle_velocity_x |
1 | |
(‘io’, ‘particle_velocity_y’) | ![]() |
particle_velocity_y |
1 | |
(‘io’, ‘particle_velocity_z’) | ![]() |
particle_velocity_z |
1 | |
(‘io’, ‘creation_time’) | ![]() |
1 | ||
(‘io’, ‘dynamical_time’) | ![]() |
1 | ||
(‘io’, ‘metallicity_fraction’) | ![]() |
1 | ||
(‘io’, ‘metallicity’) | 1 | |||
(‘io’, ‘particle_type’) | 1 | |||
(‘io’, ‘particle_index’) | 1 | |||
(‘io’, ‘particle_mass’) | ![]() |
particle_mass |
1 | |
(‘io’, ‘GridID’) | 1 | |||
(‘io’, ‘identifier’) | particle_index |
1 | ||
(‘io’, ‘level’) | 1 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘flash’, ‘velx’) | ![]() |
velocity_x |
0 | |
(‘flash’, ‘vely’) | ![]() |
velocity_y |
0 | |
(‘flash’, ‘velz’) | ![]() |
velocity_z |
0 | |
(‘flash’, ‘dens’) | ![]() |
density |
0 | |
(‘flash’, ‘temp’) | ![]() |
temperature |
0 | |
(‘flash’, ‘pres’) | ![]() |
pressure |
0 | |
(‘flash’, ‘gpot’) | ![]() |
gravitational_potential |
0 | |
(‘flash’, ‘gpol’) | ![]() |
0 | ||
(‘flash’, ‘tion’) | ![]() |
0 | ||
(‘flash’, ‘tele’) | ![]() |
0 | ||
(‘flash’, ‘trad’) | ![]() |
0 | ||
(‘flash’, ‘pion’) | ![]() |
0 | ||
(‘flash’, ‘pele’) | ![]() |
0 | ![]() |
|
(‘flash’, ‘prad’) | ![]() |
0 | ![]() |
|
(‘flash’, ‘eion’) | ![]() |
0 | ![]() |
|
(‘flash’, ‘eele’) | ![]() |
0 | ![]() |
|
(‘flash’, ‘erad’) | ![]() |
0 | ![]() |
|
(‘flash’, ‘pden’) | ![]() |
0 | ||
(‘flash’, ‘depo’) | ![]() |
0 | ||
(‘flash’, ‘ye’) | 0 | ![]() |
||
(‘flash’, ‘magp’) | ![]() |
0 | ||
(‘flash’, ‘divb’) | ![]() |
0 | ||
(‘flash’, ‘game’) | 0 | ![]() |
||
(‘flash’, ‘gamc’) | 0 | ![]() |
||
(‘flash’, ‘flam’) | 0 | |||
(‘flash’, ‘absr’) | 0 | ![]() |
||
(‘flash’, ‘emis’) | 0 | ![]() |
||
(‘flash’, ‘cond’) | 0 | ![]() |
||
(‘flash’, ‘dfcf’) | 0 | ![]() |
||
(‘flash’, ‘fllm’) | 0 | ![]() |
||
(‘flash’, ‘pipe’) | 0 | ![]() |
||
(‘flash’, ‘tite’) | 0 | ![]() |
||
(‘flash’, ‘dbgs’) | 0 | ![]() |
||
(‘flash’, ‘cham’) | 0 | ![]() |
||
(‘flash’, ‘targ’) | 0 | ![]() |
||
(‘flash’, ‘sumy’) | 0 | |||
(‘flash’, ‘mgdc’) | 0 | ![]() |
||
(‘flash’, ‘magx’) | ![]() |
magnetic_field_x |
0 | ![]() |
(‘flash’, ‘magy’) | ![]() |
magnetic_field_y |
0 | ![]() |
(‘flash’, ‘magz’) | ![]() |
magnetic_field_z |
0 | ![]() |
(‘io’, ‘particle_posx’) | ![]() |
particle_position_x |
1 | |
(‘io’, ‘particle_posy’) | ![]() |
particle_position_y |
1 | |
(‘io’, ‘particle_posz’) | ![]() |
particle_position_z |
1 | |
(‘io’, ‘particle_velx’) | ![]() |
particle_velocity_x |
1 | |
(‘io’, ‘particle_vely’) | ![]() |
particle_velocity_y |
1 | |
(‘io’, ‘particle_velz’) | ![]() |
particle_velocity_z |
1 | |
(‘io’, ‘particle_tag’) | particle_index |
1 | ||
(‘io’, ‘particle_mass’) | ![]() |
particle_mass |
1 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘io’, ‘Mass’) | ![]() |
particle_mass |
1 | |
(‘io’, ‘Masses’) | ![]() |
particle_mass |
1 | |
(‘io’, ‘Coordinates’) | ![]() |
particle_position |
1 | |
(‘io’, ‘Velocity’) | ![]() |
particle_velocity |
1 | |
(‘io’, ‘Velocities’) | ![]() |
particle_velocity |
1 | |
(‘io’, ‘ParticleIDs’) | particle_index |
1 | ||
(‘io’, ‘InternalEnergy’) | thermal_energy |
1 | ||
(‘io’, ‘SmoothingLength’) | ![]() |
smoothing_length |
1 | |
(‘io’, ‘Density’) | ![]() |
density |
1 | |
(‘io’, ‘MaximumTemperature’) | ![]() |
1 | ||
(‘io’, ‘Temperature’) | ![]() |
temperature |
1 | |
(‘io’, ‘Epsilon’) | ![]() |
1 | ||
(‘io’, ‘Metals’) | ![]() |
metallicity |
1 | |
(‘io’, ‘Metallicity’) | ![]() |
metallicity |
1 | |
(‘io’, ‘Phi’) | ![]() |
1 | ||
(‘io’, ‘FormationTime’) | ![]() |
creation_time |
1 | |
(‘io’, ‘Metallicity_00’) | metallicity |
1 | ||
(‘io’, ‘Metallicity_01’) | He_fraction |
1 | ||
(‘io’, ‘Metallicity_02’) | C_fraction |
1 | ||
(‘io’, ‘Metallicity_03’) | N_fraction |
1 | ||
(‘io’, ‘Metallicity_04’) | O_fraction |
1 | ||
(‘io’, ‘Metallicity_05’) | Ne_fraction |
1 | ||
(‘io’, ‘Metallicity_06’) | Mg_fraction |
1 | ||
(‘io’, ‘Metallicity_07’) | Si_fraction |
1 | ||
(‘io’, ‘Metallicity_08’) | S_fraction |
1 | ||
(‘io’, ‘Metallicity_09’) | Ca_fraction |
1 | ||
(‘io’, ‘Metallicity_10’) | Fe_fraction |
1 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘gdf’, ‘density’) | ![]() |
density |
0 | |
(‘gdf’, ‘specific_energy’) | ![]() |
thermal_energy |
0 | |
(‘gdf’, ‘pressure’) | ![]() |
pressure |
0 | |
(‘gdf’, ‘temperature’) | ![]() |
temperature |
0 | |
(‘gdf’, ‘velocity_x’) | ![]() |
velocity_x |
0 | |
(‘gdf’, ‘velocity_y’) | ![]() |
velocity_y |
0 | |
(‘gdf’, ‘velocity_z’) | ![]() |
velocity_z |
0 | |
(‘gdf’, ‘mag_field_x’) | ![]() |
magnetic_field_x |
0 | |
(‘gdf’, ‘mag_field_y’) | ![]() |
magnetic_field_y |
0 | |
(‘gdf’, ‘mag_field_z’) | ![]() |
magnetic_field_z |
0 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘io’, ‘particle_identifier’) | 1 | |||
(‘io’, ‘particle_position_x’) | ![]() |
1 | ||
(‘io’, ‘particle_position_y’) | ![]() |
1 | ||
(‘io’, ‘particle_position_z’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_x’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_y’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_z’) | ![]() |
1 | ||
(‘io’, ‘particle_mass’) | ![]() |
1 | ![]() |
|
(‘io’, ‘virial_radius’) | ![]() |
1 | ![]() |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘io’, ‘Mass’) | ![]() |
particle_mass |
1 | |
(‘io’, ‘Masses’) | ![]() |
particle_mass |
1 | |
(‘io’, ‘Coordinates’) | ![]() |
particle_position |
1 | |
(‘io’, ‘Velocity’) | ![]() |
particle_velocity |
1 | |
(‘io’, ‘Velocities’) | ![]() |
particle_velocity |
1 | |
(‘io’, ‘ParticleIDs’) | particle_index |
1 | ||
(‘io’, ‘InternalEnergy’) | thermal_energy |
1 | ||
(‘io’, ‘SmoothingLength’) | ![]() |
smoothing_length |
1 | |
(‘io’, ‘Density’) | ![]() |
density |
1 | |
(‘io’, ‘MaximumTemperature’) | ![]() |
1 | ||
(‘io’, ‘Temperature’) | ![]() |
temperature |
1 | |
(‘io’, ‘Epsilon’) | ![]() |
1 | ||
(‘io’, ‘Metals’) | ![]() |
metallicity |
1 | |
(‘io’, ‘Metallicity’) | ![]() |
metallicity |
1 | |
(‘io’, ‘Phi’) | ![]() |
1 | ||
(‘io’, ‘FormationTime’) | ![]() |
creation_time |
1 | |
(‘io’, ‘Metallicity_00’) | metallicity |
1 | ||
(‘io’, ‘Metallicity_01’) | He_fraction |
1 | ||
(‘io’, ‘Metallicity_02’) | C_fraction |
1 | ||
(‘io’, ‘Metallicity_03’) | N_fraction |
1 | ||
(‘io’, ‘Metallicity_04’) | O_fraction |
1 | ||
(‘io’, ‘Metallicity_05’) | Ne_fraction |
1 | ||
(‘io’, ‘Metallicity_06’) | Mg_fraction |
1 | ||
(‘io’, ‘Metallicity_07’) | Si_fraction |
1 | ||
(‘io’, ‘Metallicity_08’) | S_fraction |
1 | ||
(‘io’, ‘Metallicity_09’) | Ca_fraction |
1 | ||
(‘io’, ‘Metallicity_10’) | Fe_fraction |
1 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘io’, ‘CenterOfMass_0’) | ![]() |
particle_position_x |
1 | |
(‘io’, ‘CenterOfMass_1’) | ![]() |
particle_position_y |
1 | |
(‘io’, ‘CenterOfMass_2’) | ![]() |
particle_position_z |
1 | |
(‘io’, ‘CenterOfMassVelocity_0’) | ![]() |
particle_velocity_x |
1 | |
(‘io’, ‘CenterOfMassVelocity_1’) | ![]() |
particle_velocity_y |
1 | |
(‘io’, ‘CenterOfMassVelocity_2’) | ![]() |
particle_velocity_z |
1 | |
(‘io’, ‘Mass’) | ![]() |
particle_mass |
1 | |
(‘io’, ‘Halo_M_Crit200’) | ![]() |
Virial Mass |
1 | |
(‘io’, ‘Halo_M_Crit2500’) | ![]() |
1 | ||
(‘io’, ‘Halo_M_Crit500’) | ![]() |
1 | ||
(‘io’, ‘Halo_M_Mean200’) | ![]() |
1 | ||
(‘io’, ‘Halo_M_Mean2500’) | ![]() |
1 | ||
(‘io’, ‘Halo_M_Mean500’) | ![]() |
1 | ||
(‘io’, ‘Halo_M_TopHat200’) | ![]() |
1 | ||
(‘io’, ‘Halo_R_Crit200’) | ![]() |
Virial Radius |
1 | |
(‘io’, ‘Halo_R_Crit2500’) | ![]() |
1 | ||
(‘io’, ‘Halo_R_Crit500’) | ![]() |
1 | ||
(‘io’, ‘Halo_R_Mean200’) | ![]() |
1 | ||
(‘io’, ‘Halo_R_Mean2500’) | ![]() |
1 | ||
(‘io’, ‘Halo_R_Mean500’) | ![]() |
1 | ||
(‘io’, ‘Halo_R_TopHat200’) | ![]() |
1 | ||
(‘io’, ‘BH_Mass’) | ![]() |
1 | ||
(‘io’, ‘Stars/Mass’) | ![]() |
1 | ||
(‘io’, ‘BH_Mdot’) | ![]() |
1 | ||
(‘io’, ‘StarFormationRate’) | ![]() |
1 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘ramses’, ‘Density’) | ![]() |
density |
0 | |
(‘ramses’, ‘x-velocity’) | ![]() |
velocity_x |
0 | |
(‘ramses’, ‘y-velocity’) | ![]() |
velocity_y |
0 | |
(‘ramses’, ‘z-velocity’) | ![]() |
velocity_z |
0 | |
(‘ramses’, ‘Pressure’) | ![]() |
pressure |
0 | |
(‘ramses’, ‘Metallicity’) | metallicity |
0 | ||
(‘io’, ‘particle_position_x’) | ![]() |
1 | ||
(‘io’, ‘particle_position_y’) | ![]() |
1 | ||
(‘io’, ‘particle_position_z’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_x’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_y’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_z’) | ![]() |
1 | ||
(‘io’, ‘particle_mass’) | ![]() |
1 | ||
(‘io’, ‘particle_identifier’) | particle_index |
1 | ||
(‘io’, ‘particle_refinement_level’) | 1 | |||
(‘io’, ‘particle_age’) | ![]() |
1 | ||
(‘io’, ‘particle_metallicity’) | 1 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘io’, ‘particle_identifier’) | 1 | |||
(‘io’, ‘particle_position_x’) | ![]() |
1 | ||
(‘io’, ‘particle_position_y’) | ![]() |
1 | ||
(‘io’, ‘particle_position_z’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_x’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_y’) | ![]() |
1 | ||
(‘io’, ‘particle_velocity_z’) | ![]() |
1 | ||
(‘io’, ‘particle_corevel_x’) | ![]() |
1 | ||
(‘io’, ‘particle_corevel_y’) | ![]() |
1 | ||
(‘io’, ‘particle_corevel_z’) | ![]() |
1 | ||
(‘io’, ‘particle_bulkvel_x’) | ![]() |
1 | ||
(‘io’, ‘particle_bulkvel_y’) | ![]() |
1 | ||
(‘io’, ‘particle_bulkvel_z’) | ![]() |
1 | ||
(‘io’, ‘particle_mass’) | ![]() |
1 | ![]() |
|
(‘io’, ‘virial_radius’) | ![]() |
1 | ![]() |
|
(‘io’, ‘child_r’) | ![]() |
1 | ||
(‘io’, ‘vmax_r’) | ![]() |
1 | ||
(‘io’, ‘mgrav’) | 1 | |||
(‘io’, ‘vmax’) | ![]() |
1 | ![]() |
|
(‘io’, ‘rvmax’) | ![]() |
1 | ||
(‘io’, ‘rs’) | ![]() |
1 | ![]() |
|
(‘io’, ‘klypin_rs’) | ![]() |
1 | ![]() |
|
(‘io’, ‘vrms’) | ![]() |
1 | ![]() |
|
(‘io’, ‘Jx’) | 1 | ![]() |
||
(‘io’, ‘Jy’) | 1 | ![]() |
||
(‘io’, ‘Jz’) | 1 | ![]() |
||
(‘io’, ‘energy’) | 1 | |||
(‘io’, ‘spin’) | 1 | ![]() |
||
(‘io’, ‘alt_m1’) | ![]() |
1 | ||
(‘io’, ‘alt_m2’) | ![]() |
1 | ||
(‘io’, ‘alt_m3’) | ![]() |
1 | ||
(‘io’, ‘alt_m4’) | ![]() |
1 | ||
(‘io’, ‘Xoff’) | 1 | |||
(‘io’, ‘Voff’) | 1 | |||
(‘io’, ‘b_to_a’) | 1 | ![]() |
||
(‘io’, ‘c_to_a’) | 1 | ![]() |
||
(‘io’, ‘Ax’) | 1 | ![]() |
||
(‘io’, ‘Ay’) | 1 | ![]() |
||
(‘io’, ‘Az’) | 1 | ![]() |
||
(‘io’, ‘b_to_a2’) | 1 | |||
(‘io’, ‘c_to_a2’) | 1 | |||
(‘io’, ‘A2x’) | 1 | ![]() |
||
(‘io’, ‘A2y’) | 1 | ![]() |
||
(‘io’, ‘A2z’) | 1 | ![]() |
||
(‘io’, ‘bullock_spin’) | 1 | ![]() |
||
(‘io’, ‘kin_to_pot’) | 1 | ![]() |
||
(‘io’, ‘m_pe_b’) | 1 | |||
(‘io’, ‘m_pe_d’) | 1 | |||
(‘io’, ‘num_p’) | 1 | ![]() |
||
(‘io’, ‘num_child_particles’) | 1 | ![]() |
||
(‘io’, ‘p_start’) | 1 | |||
(‘io’, ‘desc’) | 1 | |||
(‘io’, ‘flags’) | 1 | |||
(‘io’, ‘n_core’) | 1 | |||
(‘io’, ‘min_pos_err’) | 1 | |||
(‘io’, ‘min_vel_err’) | 1 | |||
(‘io’, ‘min_bulkvel_err’) | 1 |
field name | units | aliases | particle? | display name |
---|---|---|---|---|
(‘io’, ‘Mass’) | ![]() |
particle_mass |
1 | |
(‘io’, ‘Masses’) | ![]() |
particle_mass |
1 | |
(‘io’, ‘Coordinates’) | ![]() |
particle_position |
1 | |
(‘io’, ‘Velocity’) | ![]() |
particle_velocity |
1 | |
(‘io’, ‘Velocities’) | ![]() |
particle_velocity |
1 | |
(‘io’, ‘ParticleIDs’) | particle_index |
1 | ||
(‘io’, ‘InternalEnergy’) | thermal_energy |
1 | ||
(‘io’, ‘SmoothingLength’) | ![]() |
smoothing_length |
1 | |
(‘io’, ‘Density’) | ![]() |
density |
1 | |
(‘io’, ‘MaximumTemperature’) | ![]() |
1 | ||
(‘io’, ‘Temperature’) | ![]() |
temperature |
1 | |
(‘io’, ‘Epsilon’) | ![]() |
1 | ||
(‘io’, ‘Metals’) | ![]() |
metallicity |
1 | |
(‘io’, ‘Metallicity’) | ![]() |
metallicity |
1 | |
(‘io’, ‘Phi’) | ![]() |
1 | ||
(‘io’, ‘FormationTime’) | ![]() |
creation_time |
1 | |
(‘io’, ‘Metallicity_00’) | metallicity |
1 | ||
(‘io’, ‘Metallicity_01’) | He_fraction |
1 | ||
(‘io’, ‘Metallicity_02’) | C_fraction |
1 | ||
(‘io’, ‘Metallicity_03’) | N_fraction |
1 | ||
(‘io’, ‘Metallicity_04’) | O_fraction |
1 | ||
(‘io’, ‘Metallicity_05’) | Ne_fraction |
1 | ||
(‘io’, ‘Metallicity_06’) | Mg_fraction |
1 | ||
(‘io’, ‘Metallicity_07’) | Si_fraction |
1 | ||
(‘io’, ‘Metallicity_08’) | S_fraction |
1 | ||
(‘io’, ‘Metallicity_09’) | Ca_fraction |
1 | ||
(‘io’, ‘Metallicity_10’) | Fe_fraction |
1 | ||
(‘io’, ‘uDotFB’) | ![]() |
uDotFB |
1 | |
(‘io’, ‘acc’) | ![]() |
acc |
1 | |
(‘io’, ‘c’) | ![]() |
c |
1 | |
(‘io’, ‘uDotDiff’) | ![]() |
uDotDiff |
1 | |
(‘io’, ‘FeMassFrac’) | ![]() |
FeMassFrac |
1 | |
(‘io’, ‘timeform’) | ![]() |
timeform |
1 | |
(‘io’, ‘uDot’) | ![]() |
uDot |
1 | |
(‘io’, ‘accg’) | ![]() |
accg |
1 | |
(‘io’, ‘uDotHydro’) | ![]() |
uDotHydro |
1 | |
(‘io’, ‘uDotPdV’) | ![]() |
uDotPdV |
1 | |
(‘io’, ‘uDotAV’) | ![]() |
uDotAV |
1 | |
(‘io’, ‘HI’) | ![]() |
HI |
1 | |
(‘io’, ‘coolontime’) | ![]() |
coolontime |
1 | |
(‘io’, ‘HeII’) | ![]() |
HeII |
1 | |
(‘io’, ‘HII’) | ![]() |
HII |
1 | |
(‘io’, ‘massform’) | ![]() |
massform |
1 | |
(‘io’, ‘OxMassFrac’) | ![]() |
OxMassFrac |
1 | |
(‘io’, ‘HeI’) | ![]() |
HeI |
1 |
Contents