def setup_fluid_fields(self):
from yt.fields.magnetic_field import \
setup_magnetic_field_aliases
for field in self.ds.stream_handler.field_units:
units = self.ds.stream_handler.field_units[field]
if units != '': self.add_output_field(field, units=units)
setup_magnetic_field_aliases(self, "stream", ["magnetic_field_%s" % ax for ax in "xyz"])
def setup_fluid_fields(self):
def _v1(field, data):
return data["gas", "moment_1"] / data["gas", "density"]
def _v2(field, data):
return data["gas", "moment_2"] / data["gas", "density"]
def _v3(field, data):
return data["gas", "moment_3"] / data["gas", "density"]
unit_system = self.ds.unit_system
aliases = direction_aliases[self.ds.geometry]
for idir, alias, func in zip("123", aliases, (_v1, _v2, _v3)):
if not ("amrvac", "m%s" % idir) in self.field_list:
break
self.add_field(("gas", "velocity_%s" % alias),
function=func,
units=unit_system['velocity'],
dimensions=dimensions.velocity,
sampling_type="cell")
self.alias(("gas", "velocity_%s" % idir),
("gas", "velocity_%s" % alias),
units=unit_system["velocity"])
self.alias(("gas", "moment_%s" % alias),
("gas", "moment_%s" % idir),
units=unit_system["density"] * unit_system["velocity"])
setup_magnetic_field_aliases(self, "amrvac",
["mag%s" % ax for ax in "xyz"])
def setup_fluid_fields(self):
self.setup_energy_field()
setup_magnetic_field_aliases(self, "enzoe", [f"bfield_{ax}" for ax in "xyz"])
self.alias(
("gas", "total_energy"),
("gas", "specific_total_energy"),
deprecate=("4.0.0", "4.1.0"),
)
def setup_fluid_fields(self):
"""Defines which derived mesh fields to create.
If a field can not be calculated, it will simply be skipped.
"""
# Set up aliases first so the setup for poynting can use them
if len(self._mag_fields) > 0:
setup_magnetic_field_aliases(self, "openPMD", self._mag_fields)
setup_poynting_vector(self)
def setup_fluid_fields(self):
from yt.fields.magnetic_field import \
setup_magnetic_field_aliases
for field in self.ds.stream_handler.field_units:
if field[0] in self.ds.particle_types:
continue
units = self.ds.stream_handler.field_units[field]
if units != '':
self.add_output_field(field, sampling_type="cell", units=units)
setup_magnetic_field_aliases(
self, "stream", ["magnetic_field_%s" % ax for ax in "xyz"])
def setup_fluid_fields(self):
from yt.fields.magnetic_field import \
setup_magnetic_field_aliases
unit_system = self.ds.unit_system
# Add velocity fields
vel_prefix = "velocity"
for i, comp in enumerate(self.ds.coordinates.axis_order):
vel_field = ("athena_pp", "vel%d" % (i+1))
mom_field = ("athena_pp", "mom%d" % (i+1))
if vel_field in self.field_list:
self.add_output_field(vel_field, sampling_type="cell", units="code_length/code_time")
self.alias(("gas","%s_%s" % (vel_prefix, comp)), vel_field,
units=unit_system["velocity"])
elif mom_field in self.field_list:
self.add_output_field(mom_field, sampling_type="cell",
units="code_mass/code_time/code_length**2")
self.add_field(("gas","%s_%s" % (vel_prefix, comp)), sampling_type="cell",
function=velocity_field(i+1), units=unit_system["velocity"])
# Figure out thermal energy field
if ("athena_pp","press") in self.field_list:
self.add_output_field(("athena_pp","press"), sampling_type="cell",
units=pres_units)
self.alias(("gas","pressure"),("athena_pp","press"),
units=unit_system["pressure"])
def _thermal_energy(field, data):
return data["athena_pp","press"] / \
(data.ds.gamma-1.)/data["athena_pp","rho"]
self.add_field(("gas","thermal_energy"), sampling_type="cell",
function=_thermal_energy,
units=unit_system["specific_energy"])
elif ("athena_pp","Etot") in self.field_list:
self.add_output_field(("athena_pp","Etot"), sampling_type="cell",
units=pres_units)
def _thermal_energy(field, data):
eint = data["athena_pp", "Etot"] - data["gas","kinetic_energy"]
if ("athena_pp", "B1") in self.field_list:
eint -= data["gas","magnetic_energy"]
return eint/data["athena_pp","dens"]
self.add_field(("gas","thermal_energy"), sampling_type="cell",
function=_thermal_energy,
units=unit_system["specific_energy"])
# Add temperature field
def _temperature(field, data):
if data.has_field_parameter("mu"):
mu = data.get_field_parameter("mu")
else:
mu = 0.6
return (data["gas","pressure"]/data["gas","density"])*mu*mh/kboltz
self.add_field(("gas", "temperature"), sampling_type="cell", function=_temperature,
units=unit_system["temperature"])
setup_magnetic_field_aliases(self, "athena_pp", ["Bcc%d" % ax for ax in (1,2,3)])
def setup_fluid_fields(self):
from yt.fields.magnetic_field import setup_magnetic_field_aliases
# Now we conditionally load a few other things.
params = self.ds.parameters
multi_species = params.get("MultiSpecies", None)
dengo = params.get("DengoChemistryModel", 0)
if multi_species is None:
multi_species = params["Physics"]["AtomicPhysics"]["MultiSpecies"]
if multi_species > 0 or dengo == 1:
self.setup_species_fields()
self.setup_energy_field()
setup_magnetic_field_aliases(self, "enzo", [f"B{ax}" for ax in "xyz"])
def setup_fluid_fields(self):
from yt.fields.magnetic_field import setup_magnetic_field_aliases
unit_system = self.ds.unit_system
def _thermal_energy_density(field, data):
try:
return (data[("chombo", "energy-density")] -
data[("gas", "kinetic_energy_density")] -
data[("gas", "magnetic_energy_density")])
except YTFieldNotFound:
return (data[("chombo", "energy-density")] -
data[("gas", "kinetic_energy_density")])
def _specific_thermal_energy(field, data):
return data[("gas", "thermal_energy_density")] / data[("gas",
"density")]
def _magnetic_energy_density(field, data):
ret = data[("chombo", "X-magnfield")]**2
if data.ds.dimensionality > 1:
ret = ret + data[("chombo", "Y-magnfield")]**2
if data.ds.dimensionality > 2:
ret = ret + data[("chombo", "Z-magnfield")]**2
return ret / 8.0 / np.pi
def _specific_magnetic_energy(field, data):
return data[("gas", "specific_magnetic_energy")] / data[
("gas", "density")]
def _kinetic_energy_density(field, data):
p2 = data[("chombo", "X-momentum")]**2
if data.ds.dimensionality > 1:
p2 = p2 + data[("chombo", "Y-momentum")]**2
if data.ds.dimensionality > 2:
p2 = p2 + data[("chombo", "Z-momentum")]**2
return 0.5 * p2 / data[("gas", "density")]
def _specific_kinetic_energy(field, data):
return data[("gas", "kinetic_energy_density")] / data[("gas",
"density")]
def _temperature(field, data):
c_v = data.ds.quan(data.ds.parameters["radiation.const_cv"],
"erg/g/K")
return data[("gas", "specific_thermal_energy")] / c_v
def _get_vel(axis):
def velocity(field, data):
return (data[("gas", f"momentum_density_{axis}")] /
data[("gas", "density")])
return velocity
for ax in "xyz":
self.add_field(
("gas", f"velocity_{ax}"),
sampling_type="cell",
function=_get_vel(ax),
units=unit_system["velocity"],
)
self.add_field(
("gas", "specific_thermal_energy"),
sampling_type="cell",
function=_specific_thermal_energy,
units=unit_system["specific_energy"],
)
self.add_field(
("gas", "thermal_energy_density"),
sampling_type="cell",
function=_thermal_energy_density,
units=unit_system["pressure"],
)
self.add_field(
("gas", "kinetic_energy_density"),
sampling_type="cell",
function=_kinetic_energy_density,
units=unit_system["pressure"],
)
self.add_field(
("gas", "specific_kinetic_energy"),
sampling_type="cell",
function=_specific_kinetic_energy,
units=unit_system["specific_energy"],
)
self.add_field(
("gas", "magnetic_energy_density"),
sampling_type="cell",
function=_magnetic_energy_density,
units=unit_system["pressure"],
)
self.add_field(
("gas", "specific_magnetic_energy"),
sampling_type="cell",
function=_specific_magnetic_energy,
units=unit_system["specific_energy"],
)
self.add_field(
("gas", "temperature"),
sampling_type="cell",
function=_temperature,
units=unit_system["temperature"],
)
setup_magnetic_field_aliases(self, "chombo",
[f"{ax}-magnfield" for ax in "XYZ"])
def setup_fluid_fields(self):
from yt.fields.magnetic_field import \
setup_magnetic_field_aliases
setup_magnetic_field_aliases(self, "gdf", ["magnetic_field_%s" % ax for ax in "xyz"])
def setup_fluid_fields(self):
from yt.fields.magnetic_field import \
setup_magnetic_field_aliases
setup_magnetic_field_aliases(self, "chombo",
["bx%s" % ax for ax in [1, 2, 3]])
def setup_fluid_fields(self):
from yt.fields.magnetic_field import setup_magnetic_field_aliases
setup_magnetic_field_aliases(self, "chombo",
[f"bx{ax}" for ax in [1, 2, 3]])
def setup_fluid_fields(self):
from yt.fields.magnetic_field import setup_magnetic_field_aliases
unit_system = self.ds.unit_system
# Adopt FLASH 4.6 value for Na
Na = self.ds.quan(6.022140857e23, "g**-1")
for i in range(1, 1000):
self.add_output_field(
("flash", f"r{i:03}"),
sampling_type="cell",
units="",
display_name=f"Energy Group {i}",
)
# Add energy fields
def ekin(data):
ek = data["flash", "velx"]**2
if data.ds.dimensionality >= 2:
ek += data["flash", "vely"]**2
if data.ds.dimensionality == 3:
ek += data["flash", "velz"]**2
return 0.5 * ek
if ("flash", "ener") in self.field_list:
self.add_output_field(
("flash", "ener"),
sampling_type="cell",
units="code_length**2/code_time**2",
)
self.alias(
("gas", "specific_total_energy"),
("flash", "ener"),
units=unit_system["specific_energy"],
)
else:
def _ener(field, data):
ener = data["flash", "eint"] + ekin(data)
try:
ener += data["flash", "magp"] / data["flash", "dens"]
except Exception:
pass
return ener
self.add_field(
("gas", "specific_total_energy"),
sampling_type="cell",
function=_ener,
units=unit_system["specific_energy"],
)
if ("flash", "eint") in self.field_list:
self.add_output_field(
("flash", "eint"),
sampling_type="cell",
units="code_length**2/code_time**2",
)
self.alias(
("gas", "specific_thermal_energy"),
("flash", "eint"),
units=unit_system["specific_energy"],
)
else:
def _eint(field, data):
eint = data["flash", "ener"] - ekin(data)
try:
eint -= data["flash", "magp"] / data["flash", "dens"]
except Exception:
pass
return eint
self.add_field(
("gas", "specific_thermal_energy"),
sampling_type="cell",
function=_eint,
units=unit_system["specific_energy"],
)
## Derived FLASH Fields
if ("flash", "abar") in self.field_list:
self.alias(("gas", "mean_molecular_weight"), ("flash", "abar"))
elif ("flash", "sumy") in self.field_list:
def _abar(field, data):
return 1.0 / data["flash", "sumy"]
self.add_field(
("gas", "mean_molecular_weight"),
sampling_type="cell",
function=_abar,
units="",
)
elif "eos_singlespeciesa" in self.ds.parameters:
def _abar(field, data):
return data.ds.parameters["eos_singlespeciesa"] * data["index",
"ones"]
self.add_field(
("gas", "mean_molecular_weight"),
sampling_type="cell",
function=_abar,
units="",
)
if ("flash", "sumy") in self.field_list:
def _nele(field, data):
return data["flash", "dens"] * data["flash", "ye"] * Na
self.add_field(
("gas", "El_number_density"),
sampling_type="cell",
function=_nele,
units=unit_system["number_density"],
)
def _nion(field, data):
return data["flash", "dens"] * data["flash", "sumy"] * Na
self.add_field(
("gas", "ion_number_density"),
sampling_type="cell",
function=_nion,
units=unit_system["number_density"],
)
def _number_density(field, data):
return (data["gas", "El_number_density"] +
data["gas", "ion_number_density"])
else:
def _number_density(field, data):
return data["flash",
"dens"] * Na / data["gas", "mean_molecular_weight"]
self.add_field(
("gas", "number_density"),
sampling_type="cell",
function=_number_density,
units=unit_system["number_density"],
)
setup_magnetic_field_aliases(self, "flash",
[f"mag{ax}" for ax in "xyz"])
def setup_fluid_fields(self):
from yt.fields.magnetic_field import \
setup_magnetic_field_aliases
unit_system = self.ds.unit_system
def _thermal_energy_density(field, data):
try:
return data["energy-density"] - data["kinetic_energy"] - \
data["magnetic_energy"]
except YTFieldNotFound:
return data['energy-density'] - data["kinetic_energy"]
def _thermal_energy(field, data):
return data['thermal_energy_density'] / data['density']
def _magnetic_energy(field, data):
ret = data["X-magnfield"]**2
if data.ds.dimensionality > 1:
ret = ret + data["Y-magnfield"]**2
if data.ds.dimensionality > 2:
ret = ret + data["Z-magnfield"]**2
return ret / 8.0 / np.pi
def _specific_magnetic_energy(field, data):
return data['specific_magnetic_energy'] / data['density']
def _kinetic_energy(field, data):
p2 = data['X-momentum']**2
if data.ds.dimensionality > 1:
p2 = p2 + data["Y-momentum"]**2
if data.ds.dimensionality > 2:
p2 = p2 + data["Z-momentum"]**2
return 0.5 * p2 / data['density']
def _specific_kinetic_energy(field, data):
return data['kinetic_energy'] / data['density']
def _temperature(field, data):
c_v = data.ds.quan(data.ds.parameters['radiation.const_cv'],
'erg/g/K')
return (data["thermal_energy"] / c_v)
def _get_vel(axis):
def velocity(field, data):
return data["momentum_%s" % axis] / data["density"]
return velocity
for ax in 'xyz':
self.add_field(("gas", "velocity_%s" % ax),
sampling_type="cell",
function=_get_vel(ax),
units=unit_system["velocity"])
self.add_field(("gas", "thermal_energy"),
sampling_type="cell",
function=_thermal_energy,
units=unit_system["specific_energy"])
self.add_field(("gas", "thermal_energy_density"),
sampling_type="cell",
function=_thermal_energy_density,
units=unit_system["pressure"])
self.add_field(("gas", "kinetic_energy"),
sampling_type="cell",
function=_kinetic_energy,
units=unit_system["pressure"])
self.add_field(("gas", "specific_kinetic_energy"),
sampling_type="cell",
function=_specific_kinetic_energy,
units=unit_system["specific_energy"])
self.add_field(("gas", "magnetic_energy"),
sampling_type="cell",
function=_magnetic_energy,
units=unit_system["pressure"])
self.add_field(("gas", "specific_magnetic_energy"),
sampling_type="cell",
function=_specific_magnetic_energy,
units=unit_system["specific_energy"])
self.add_field(("gas", "temperature"),
sampling_type="cell",
function=_temperature,
units=unit_system["temperature"])
setup_magnetic_field_aliases(self, "chombo",
["%s-magnfield" % ax for ax in "XYZ"])
def setup_fluid_fields(self):
def _v1(field, data):
return data["gas", "moment_1"] / data["gas", "density"]
def _v2(field, data):
return data["gas", "moment_2"] / data["gas", "density"]
def _v3(field, data):
return data["gas", "moment_3"] / data["gas", "density"]
us = self.ds.unit_system
aliases = direction_aliases[self.ds.geometry]
for idir, alias, func in zip("123", aliases, (_v1, _v2, _v3)):
if not ("amrvac", "m%s" % idir) in self.field_list:
break
self.add_field(("gas", "velocity_%s" % alias),
function=func,
units=us['velocity'],
dimensions=dimensions.velocity,
sampling_type="cell")
self.alias(("gas", "velocity_%s" % idir),
("gas", "velocity_%s" % alias),
units=us["velocity"])
self.alias(("gas", "moment_%s" % alias),
("gas", "moment_%s" % idir),
units=us["density"] * us["velocity"])
setup_magnetic_field_aliases(self, "amrvac",
["mag%s" % ax for ax in "xyz"])
# fields with nested dependencies are defined thereafter by increasing level of complexity
# kinetic pressure is given by 0.5 * rho * v**2
def _kinetic_energy_density(field, data):
# devnote : have a look at issue 1301
return 0.5 * data['gas', 'density'] * data['gas',
'velocity_magnitude']**2
self.add_field(("gas", "kinetic_energy_density"),
function=_kinetic_energy_density,
units=us["density"] * us["velocity"]**2,
dimensions=dimensions.density * dimensions.velocity**2,
sampling_type="cell")
# magnetic energy density
if ('amrvac', 'b1') in self.field_list:
def _magnetic_energy_density(field, data):
emag = 0.5 * data['gas', 'magnetic_1']**2
for idim in '23':
if not ('amrvac', 'b%s' % idim) in self.field_list:
break
emag += 0.5 * data['gas', 'magnetic_%s' % idim]**2
# important note: in AMRVAC the magnetic field is defined in units where mu0 = 1, such that
# Emag = 0.5*B**2 instead of Emag = 0.5*B**2 / mu0
# To correctly transform the dimensionality from gauss**2 -> rho*v**2, we have to take mu0 into account.
# If we divide here, units when adding the field should be us["density"]*us["velocity"]**2
# If not, they should be us["magnetic_field"]**2 and division should happen elsewhere.
emag /= 4 * np.pi
# divided by mu0 = 4pi in cgs, yt handles 'mks' and 'code' unit systems internally.
return emag
self.add_field(
('gas', 'magnetic_energy_density'),
function=_magnetic_energy_density,
units=us["density"] * us["velocity"]**2,
dimensions=dimensions.density * dimensions.velocity**2,
sampling_type='cell')
# Adding the thermal pressure field.
# In AMRVAC we have multiple physics possibilities:
# - if HD/MHD + energy equation, pressure is (gamma-1)*(e - ekin (- emag)) for (M)HD
# - if HD/MHD but solve_internal_e is true in parfile, pressure is (gamma-1)*e for both
# - if (m)hd_energy is false in parfile (isothermal), pressure is c_adiab * rho**gamma
def _full_thermal_pressure_HD(field, data):
# important note : energy density and pressure are actually expressed in the same unit
pthermal = (data.ds.gamma -
1) * (data['gas', 'energy_density'] -
data['gas', 'kinetic_energy_density'])
return pthermal
def _full_thermal_pressure_MHD(field, data):
pthermal = _full_thermal_pressure_HD(field, data) \
- (data.ds.gamma - 1) * data["gas", "magnetic_energy_density"]
return pthermal
def _polytropic_thermal_pressure(field, data):
return (data.ds.gamma - 1) * data['gas', 'energy_density']
def _adiabatic_thermal_pressure(field, data):
return data.ds._c_adiab * data["gas", "density"]**data.ds.gamma
pressure_recipe = None
if ("amrvac", "e") in self.field_list:
if self.ds._e_is_internal:
pressure_recipe = _polytropic_thermal_pressure
mylog.info('Using polytropic EoS for thermal pressure.')
elif ('amrvac', 'b1') in self.field_list:
pressure_recipe = _full_thermal_pressure_MHD
mylog.info('Using full MHD energy for thermal pressure.')
else:
pressure_recipe = _full_thermal_pressure_HD
mylog.info('Using full HD energy for thermal pressure.')
elif self.ds._c_adiab is not None:
pressure_recipe = _adiabatic_thermal_pressure
mylog.info(
'Using adiabatic EoS for thermal pressure (isothermal).')
mylog.warning(
'If you used usr_set_pthermal you should redefine the thermal_pressure field.'
)
if pressure_recipe is not None:
self.add_field(
('gas', 'thermal_pressure'),
function=pressure_recipe,
units=us['density'] * us['velocity']**2,
dimensions=dimensions.density * dimensions.velocity**2,
sampling_type='cell')
# sound speed and temperature depend on thermal pressure
def _sound_speed(field, data):
return np.sqrt(data.ds.gamma *
data["gas", "thermal_pressure"] /
data["gas", "density"])
self.add_field(("gas", "sound_speed"),
function=_sound_speed,
units=us["velocity"],
dimensions=dimensions.velocity,
sampling_type="cell")
else:
mylog.warning(
"e not found and no parfile passed, can not set thermal_pressure."
)
def setup_fluid_fields(self):
pc = self.ds.units.physical_constants
from yt.fields.magnetic_field import setup_magnetic_field_aliases
unit_system = self.ds.unit_system
unit_system.registry = self.ds.unit_registry # TODO: Why do I need this?!
if self.ds.srhd:
c2 = pc.clight * pc.clight
c = pc.clight.in_units("code_length / code_time")
if self.ds.eos == 4:
fgen = SRHDFields(self.ds.eos, 0.0, c.d)
else:
fgen = SRHDFields(self.ds.eos, self.ds.gamma, c.d)
def _sound_speed(field, data):
out = fgen.sound_speed(data["gamer", "Temp"].d)
return data.ds.arr(out,
"code_velocity").to(unit_system["velocity"])
def _gamma(field, data):
out = fgen.gamma_field(data["gamer", "Temp"].d)
return data.ds.arr(out, "dimensionless")
# coordinate frame density
self.alias(
("gas", "frame_density"),
("gamer", "Dens"),
units=unit_system["density"],
)
self.add_field(("gas", "gamma"),
sampling_type="cell",
function=_gamma,
units="")
# 4-velocity spatial components
def four_velocity_xyz(u):
def _four_velocity(field, data):
out = fgen.four_velocity_xyz(
data["gamer", f"Mom{u.upper()}"].d,
data["gamer", "Dens"].d,
data["gamer", "Temp"].d,
)
return data.ds.arr(out, "code_velocity").to(
unit_system["velocity"])
return _four_velocity
for u in "xyz":
self.add_field(
("gas", f"four_velocity_{u}"),
sampling_type="cell",
function=four_velocity_xyz(u),
units=unit_system["velocity"],
)
# lorentz factor
def _lorentz_factor(field, data):
out = fgen.lorentz_factor(
data["gamer", "Dens"].d,
data["gamer", "MomX"].d,
data["gamer", "MomY"].d,
data["gamer", "MomZ"].d,
data["gamer", "Temp"].d,
)
return data.ds.arr(out, "dimensionless")
self.add_field(
("gas", "lorentz_factor"),
sampling_type="cell",
function=_lorentz_factor,
units="",
)
# velocity
def velocity_xyz(v):
def _velocity(field, data):
out = fgen.velocity_xyz(
data["gamer", "Dens"].d,
data["gamer", "MomX"].d,
data["gamer", "MomY"].d,
data["gamer", "MomZ"].d,
data["gamer", "Temp"].d,
data["gamer", f"Mom{v.upper()}"].d,
)
return data.ds.arr(out, "code_velocity").to(
unit_system["velocity"])
return _velocity
for v in "xyz":
self.add_field(
("gas", f"velocity_{v}"),
sampling_type="cell",
function=velocity_xyz(v),
units=unit_system["velocity"],
)
# density
def _density(field, data):
dens = fgen.density(
data["gamer", "Dens"].d,
data["gamer", "MomX"].d,
data["gamer", "MomY"].d,
data["gamer", "MomZ"].d,
data["gamer", "Temp"].d,
)
return data.ds.arr(dens, rho_units).to(unit_system["density"])
self.add_field(
("gas", "density"),
sampling_type="cell",
function=_density,
units=unit_system["density"],
)
# pressure
def _pressure(field, data):
out = fgen.pressure(
data["gamer", "Dens"].d,
data["gamer", "MomX"].d,
data["gamer", "MomY"].d,
data["gamer", "MomZ"].d,
data["gamer", "Temp"].d,
)
return data.ds.arr(out, pre_units).to(unit_system["pressure"])
# thermal energy per mass (i.e., specific)
def _specific_thermal_energy(field, data):
out = fgen.specific_thermal_energy(
data["gamer", "Dens"].d,
data["gamer", "MomX"].d,
data["gamer", "MomY"].d,
data["gamer", "MomZ"].d,
data["gamer", "Temp"].d,
)
return data.ds.arr(out, "code_length**2 / code_time**2").to(
unit_system["specific_energy"])
# total energy per mass
def _specific_total_energy(field, data):
E = data["gamer", "Engy"] + data["gamer", "Dens"] * c2
return E / data["gamer", "Dens"]
def _kinetic_energy_density(field, data):
out = fgen.kinetic_energy_density(
data["gamer", "Dens"].d,
data["gamer", "MomX"].d,
data["gamer", "MomY"].d,
data["gamer", "MomZ"].d,
data["gamer", "Temp"].d,
)
return data.ds.arr(out, erg_units).to(unit_system["pressure"])
self.add_field(
("gas", "kinetic_energy_density"),
sampling_type="cell",
function=_kinetic_energy_density,
units=unit_system["pressure"],
)
self.add_field(
("gas", "kinetic_energy_density"),
sampling_type="cell",
function=_kinetic_energy_density,
units=unit_system["pressure"],
)
self.add_field(
("gas", "sound_speed"),
sampling_type="cell",
function=_sound_speed,
units=unit_system["velocity"],
)
def _mach_number(field, data):
out = fgen.mach_number(
data["gamer", "Dens"].d,
data["gamer", "MomX"].d,
data["gamer", "MomY"].d,
data["gamer", "MomZ"].d,
data["gamer", "Temp"].d,
)
return data.ds.arr(out, "dimensionless")
self.add_field(
("gas", "mach_number"),
sampling_type="cell",
function=_mach_number,
units="",
)
else:
# density
self.alias(("gas", "density"), ("gamer", "Dens"),
units=unit_system["density"])
# velocity
def velocity_xyz(v):
def _velocity(field, data):
return data["gas",
f"momentum_density_{v}"] / data["gas",
"density"]
return _velocity
for v in "xyz":
self.add_field(
("gas", f"velocity_{v}"),
sampling_type="cell",
function=velocity_xyz(v),
units=unit_system["velocity"],
)
# ====================================================
# note that yt internal fields assume
# [specific_thermal_energy] = [energy per mass]
# [kinetic_energy_density] = [energy per volume]
# [magnetic_energy_density] = [energy per volume]
# and we further adopt
# [specific_total_energy] = [energy per mass]
# [total_energy_density] = [energy per volume]
# ====================================================
# thermal energy per volume
def et(data):
ek = (0.5 *
(data["gamer", "MomX"]**2 + data["gamer", "MomY"]**2 +
data["gamer", "MomZ"]**2) / data["gamer", "Dens"])
Et = data["gamer", "Engy"] - ek
if self.ds.mhd:
# magnetic_energy is a yt internal field
Et -= data["gas", "magnetic_energy_density"]
return Et
# thermal energy per mass (i.e., specific)
def _specific_thermal_energy(field, data):
return et(data) / data["gamer", "Dens"]
# total energy per mass
def _specific_total_energy(field, data):
return data["gamer", "Engy"] / data["gamer", "Dens"]
# pressure
def _pressure(field, data):
return et(data) * (data.ds.gamma - 1.0)
self.add_field(
("gas", "specific_thermal_energy"),
sampling_type="cell",
function=_specific_thermal_energy,
units=unit_system["specific_energy"],
)
self.add_field(
("gas", "specific_total_energy"),
sampling_type="cell",
function=_specific_total_energy,
units=unit_system["specific_energy"],
)
self.add_field(
("gas", "pressure"),
sampling_type="cell",
function=_pressure,
units=unit_system["pressure"],
)
# mean molecular weight
if hasattr(self.ds, "mu"):
def _mu(field, data):
return data.ds.mu * data["index", "ones"]
self.add_field(
("gas", "mean_molecular_weight"),
sampling_type="cell",
function=_mu,
units="",
)
# temperature
def _temperature(field, data):
return (data.ds.mu * data["gas", "pressure"] * pc.mh /
(data["gas", "density"] * pc.kb))
self.add_field(
("gas", "temperature"),
sampling_type="cell",
function=_temperature,
units=unit_system["temperature"],
)
# magnetic field aliases --> magnetic_field_x/y/z
if self.ds.mhd:
setup_magnetic_field_aliases(self, "gamer",
[f"CCMag{v}" for v in "XYZ"])
def setup_fluid_fields(self):
self.setup_energy_field()
setup_magnetic_field_aliases(self, "enzoe", [f"bfield_{ax}" for ax in "xyz"])
def setup_gas_particle_fields(self, ptype):
super(GizmoFieldInfo, self).setup_gas_particle_fields(ptype)
def _h_p0_density(field, data):
x_H = 1.0 - data[(ptype, "He_metallicity")] - data[(ptype,
"metallicity")]
return (x_H * data[(ptype, "density")] *
data[(ptype, "NeutralHydrogenAbundance")])
self.add_field(
(ptype, "H_p0_density"),
sampling_type="particle",
function=_h_p0_density,
units=self.ds.unit_system["density"],
)
add_species_field_by_density(self, ptype, "H")
def _h_p1_density(field, data):
x_H = 1.0 - data[(ptype, "He_metallicity")] - data[(ptype,
"metallicity")]
return (x_H * data[(ptype, "density")] *
(1.0 - data[(ptype, "NeutralHydrogenAbundance")]))
self.add_field(
(ptype, "H_p1_density"),
sampling_type="particle",
function=_h_p1_density,
units=self.ds.unit_system["density"],
)
add_species_field_by_density(self, ptype, "H_p1")
def _nuclei_mass_density_field(field, data):
species = field.name[1][:field.name[1].find("_")]
return data[ptype, "density"] * data[ptype,
"%s_metallicity" % species]
for species in ["H", "H_p0", "H_p1"]:
for suf in ["_density", "_number_density"]:
field = "%s%s" % (species, suf)
self.alias(("gas", field), (ptype, field))
if (ptype, "ElectronAbundance") in self.field_list:
def _el_number_density(field, data):
return (data[ptype, "ElectronAbundance"] *
data[ptype, "H_number_density"])
self.add_field(
(ptype, "El_number_density"),
sampling_type="particle",
function=_el_number_density,
units=self.ds.unit_system["number_density"],
)
self.alias(("gas", "El_number_density"),
(ptype, "El_number_density"))
for species in self.nuclei_names:
self.add_field(
(ptype, "%s_nuclei_mass_density" % species),
sampling_type="particle",
function=_nuclei_mass_density_field,
units=self.ds.unit_system["density"],
)
for suf in ["_nuclei_mass_density", "_metallicity"]:
field = "%s%s" % (species, suf)
self.alias(("gas", field), (ptype, field))
def _metal_density_field(field, data):
return data[ptype, "metallicity"] * data[ptype, "density"]
self.add_field(
(ptype, "metal_density"),
sampling_type="local",
function=_metal_density_field,
units=self.ds.unit_system["density"],
)
self.alias(("gas", "metal_density"), (ptype, "metal_density"))
magnetic_field = "MagneticField"
if (ptype, magnetic_field) in self.field_list:
setup_magnetic_field_aliases(self, ptype, magnetic_field)
def setup_gas_particle_fields(self, ptype):
super(GizmoFieldInfo, self).setup_gas_particle_fields(ptype)
def _h_density(field, data):
x_H = 1.0 - data[(ptype, "He_metallicity")] - \
data[(ptype, "metallicity")]
return x_H * data[(ptype, "density")] * \
data[(ptype, "NeutralHydrogenAbundance")]
self.add_field((ptype, "H_density"),
sampling_type="particle",
function=_h_density,
units=self.ds.unit_system["density"])
add_species_field_by_density(self, ptype, "H", particle_type=True)
for suffix in ["density", "fraction", "mass", "number_density"]:
self.alias((ptype, "H_p0_%s" % suffix), (ptype, "H_%s" % suffix))
def _h_p1_density(field, data):
x_H = 1.0 - data[(ptype, "He_metallicity")] - \
data[(ptype, "metallicity")]
return x_H * data[(ptype, "density")] * \
(1.0 - data[(ptype, "NeutralHydrogenAbundance")])
self.add_field((ptype, "H_p1_density"),
sampling_type="particle",
function=_h_p1_density,
units=self.ds.unit_system["density"])
add_species_field_by_density(self, ptype, "H_p1", particle_type=True)
def _nuclei_mass_density_field(field, data):
species = field.name[1][:field.name[1].find("_")]
return data[ptype, "density"] * \
data[ptype, "%s_metallicity" % species]
num_neighbors = 64
for species in ['H', 'H_p0', 'H_p1']:
for suf in ["_density", "_number_density"]:
field = "%s%s" % (species, suf)
fn = add_volume_weighted_smoothed_field(
ptype, "particle_position", "particle_mass",
"smoothing_length", "density", field, self, num_neighbors)
self.alias(("gas", field), fn[0])
for species in self.nuclei_names:
self.add_field((ptype, "%s_nuclei_mass_density" % species),
sampling_type="particle",
function=_nuclei_mass_density_field,
units=self.ds.unit_system["density"])
for suf in ["_nuclei_mass_density", "_metallicity"]:
field = "%s%s" % (species, suf)
fn = add_volume_weighted_smoothed_field(
ptype, "particle_position", "particle_mass",
"smoothing_length", "density", field, self, num_neighbors)
self.alias(("gas", field), fn[0])
magnetic_field = "MagneticField"
if (ptype, magnetic_field) in self.field_list:
setup_magnetic_field_aliases(self,
ptype,
magnetic_field,
ftype=ptype)
def setup_fluid_fields(self):
from yt.fields.magnetic_field import setup_magnetic_field_aliases
unit_system = self.ds.unit_system
# velocity
def velocity_xyz(v):
def _velocity(field, data):
return data["gas", "momentum_%s" % v] / data["gas", "density"]
return _velocity
for v in "xyz":
self.add_field(("gas", "velocity_%s" % v),
sampling_type="cell",
function=velocity_xyz(v),
units=unit_system["velocity"])
# ============================================================================
# note that yt internal fields assume
# [thermal_energy] = [energy per mass]
# [kinetic_energy] = [energy per volume]
# [magnetic_energy] = [energy per volume]
# and we further adopt
# [total_energy] = [energy per mass]
# [total_energy_per_volume] = [energy per volume]
# ============================================================================
# kinetic energy per volume
def ek(data):
return 0.5 * (data["gamer", "MomX"]**2 + data["gamer", "MomY"]**2 +
data["gamer", "MomZ"]**2) / data["gamer", "Dens"]
# thermal energy per volume
def et(data):
Et = data["gamer", "Engy"] - ek(data)
if self.ds.mhd:
# magnetic_energy is a yt internal field
Et -= data["gas", "magnetic_energy"]
return Et
# thermal energy per mass (i.e., specific)
def _thermal_energy(field, data):
return et(data) / data["gamer", "Dens"]
self.add_field(("gas", "thermal_energy"),
sampling_type="cell",
function=_thermal_energy,
units=unit_system["specific_energy"])
# total energy per mass
def _total_energy(field, data):
return data["gamer", "Engy"] / data["gamer", "Dens"]
self.add_field(("gas", "total_energy"),
sampling_type="cell",
function=_total_energy,
units=unit_system["specific_energy"])
# pressure
def _pressure(field, data):
return et(data) * (data.ds.gamma - 1.0)
self.add_field(("gas", "pressure"),
sampling_type="cell",
function=_pressure,
units=unit_system["pressure"])
# temperature
def _temperature(field, data):
return data.ds.mu*mh*data["gas","pressure"] / \
(data["gas","density"]*boltzmann_constant_cgs)
self.add_field(("gas", "temperature"),
sampling_type="cell",
function=_temperature,
units=unit_system["temperature"])
# magnetic field aliases --> magnetic_field_x/y/z
if self.ds.mhd:
setup_magnetic_field_aliases(self, "gamer",
["CCMag%s" % v for v in "XYZ"])
def setup_fluid_fields(self):
from yt.fields.magnetic_field import \
setup_magnetic_field_aliases
unit_system = self.ds.unit_system
# Add velocity fields
for comp in "xyz":
vel_field = ("athena", "velocity_%s" % comp)
mom_field = ("athena", "momentum_%s" % comp)
if vel_field in self.field_list:
self.add_output_field(vel_field, units="code_length/code_time")
self.alias(("gas", "velocity_%s" % comp),
vel_field,
units=unit_system["velocity"])
elif mom_field in self.field_list:
self.add_output_field(
mom_field, units="code_mass/code_time/code_length**2")
self.add_field(("gas", "velocity_%s" % comp),
function=velocity_field(comp),
units=unit_system["velocity"])
# Add pressure, energy, and temperature fields
def ekin1(data):
return 0.5 * (data["athena", "momentum_x"]**2 +
data["athena", "momentum_y"]**2 +
data["athena", "momentum_z"]**2) / data["athena",
"density"]
def ekin2(data):
return 0.5 * (data["athena", "velocity_x"]**2 +
data["athena", "velocity_y"]**2 +
data["athena", "velocity_z"]**2) * data["athena",
"density"]
def emag(data):
return 0.5 * (data["cell_centered_B_x"]**2 +
data["cell_centered_B_y"]**2 +
data["cell_centered_B_z"]**2)
def eint_from_etot(data):
eint = data["athena", "total_energy"]
eint -= ekin1(data)
if ("athena", "cell_centered_B_x") in self.field_list:
eint -= emag(data)
return eint
def etot_from_pres(data):
etot = data["athena", "pressure"] / (data.ds.gamma - 1.)
etot += ekin2(data)
if ("athena", "cell_centered_B_x") in self.field_list:
etot += emag(data)
return etot
if ("athena", "pressure") in self.field_list:
self.add_output_field(("athena", "pressure"), units=pres_units)
self.alias(("gas", "pressure"), ("athena", "pressure"),
units=unit_system["pressure"])
def _thermal_energy(field, data):
return data["athena","pressure"] / \
(data.ds.gamma-1.)/data["athena","density"]
self.add_field(("gas", "thermal_energy"),
function=_thermal_energy,
units=unit_system["specific_energy"])
def _total_energy(field, data):
return etot_from_pres(data) / data["athena", "density"]
self.add_field(("gas", "total_energy"),
function=_total_energy,
units=unit_system["specific_energy"])
elif ("athena", "total_energy") in self.field_list:
self.add_output_field(("athena", "total_energy"), units=pres_units)
def _pressure(field, data):
return eint_from_etot(data) * (data.ds.gamma - 1.0)
self.add_field(("gas", "pressure"),
function=_pressure,
units=unit_system["pressure"])
def _thermal_energy(field, data):
return eint_from_etot(data) / data["athena", "density"]
self.add_field(("gas", "thermal_energy"),
function=_thermal_energy,
units=unit_system["specific_energy"])
def _total_energy(field, data):
return data["athena", "total_energy"] / data["athena",
"density"]
self.add_field(("gas", "total_energy"),
function=_total_energy,
units=unit_system["specific_energy"])
def _temperature(field, data):
if data.has_field_parameter("mu"):
mu = data.get_field_parameter("mu")
else:
mu = 0.6
return mu * mh * data["gas", "pressure"] / data["gas",
"density"] / kboltz
self.add_field(("gas", "temperature"),
function=_temperature,
units=unit_system["temperature"])
setup_magnetic_field_aliases(
self, "athena", ["cell_centered_B_%s" % ax for ax in "xyz"])
def setup_fluid_fields(self):
from yt.fields.magnetic_field import \
setup_magnetic_field_aliases
unit_system = self.ds.unit_system
for i in range(1, 1000):
self.add_output_field(("flash", "r{0:03}".format(i)),
sampling_type="cell",
units="",
display_name="Energy Group {0}".format(i))
# Add energy fields
def ekin(data):
ek = data["flash", "velx"]**2
if data.ds.dimensionality >= 2:
ek += data["flash", "vely"]**2
if data.ds.dimensionality == 3:
ek += data["flash", "velz"]**2
return 0.5 * ek
if ("flash", "ener") in self.field_list:
self.add_output_field(("flash", "ener"),
sampling_type="cell",
units="code_length**2/code_time**2")
self.alias(("gas", "total_energy"), ("flash", "ener"),
units=unit_system["specific_energy"])
else:
def _ener(field, data):
ener = data["flash", "eint"] + ekin(data)
try:
ener += data["flash", "magp"] / data["flash", "dens"]
except Exception:
pass
return ener
self.add_field(("gas", "total_energy"),
sampling_type="cell",
function=_ener,
units=unit_system["specific_energy"])
if ("flash", "eint") in self.field_list:
self.add_output_field(("flash", "eint"),
sampling_type="cell",
units="code_length**2/code_time**2")
self.alias(("gas", "thermal_energy"), ("flash", "eint"),
units=unit_system["specific_energy"])
else:
def _eint(field, data):
eint = data["flash", "ener"] - ekin(data)
try:
eint -= data["flash", "magp"] / data["flash", "dens"]
except Exception:
pass
return eint
self.add_field(("gas", "thermal_energy"),
sampling_type="cell",
function=_eint,
units=unit_system["specific_energy"])
## Derived FLASH Fields
def _nele(field, data):
Na_code = data.ds.quan(Na, '1/code_mass')
return data["flash", "dens"] * data["flash", "ye"] * Na_code
self.add_field(('flash', 'nele'),
sampling_type="cell",
function=_nele,
units="code_length**-3")
self.add_field(('flash', 'edens'),
sampling_type="cell",
function=_nele,
units="code_length**-3")
def _nion(field, data):
Na_code = data.ds.quan(Na, '1/code_mass')
return data["flash", "dens"] * data["flash", "sumy"] * Na_code
self.add_field(('flash', 'nion'),
sampling_type="cell",
function=_nion,
units="code_length**-3")
if ("flash", "abar") in self.field_list:
self.add_output_field(("flash", "abar"),
sampling_type="cell",
units="1")
else:
def _abar(field, data):
return 1.0 / data["flash", "sumy"]
self.add_field(("flash", "abar"),
sampling_type="cell",
function=_abar,
units="1")
def _number_density(fields, data):
return (data["nele"] + data["nion"])
self.add_field(("gas", "number_density"),
sampling_type="cell",
function=_number_density,
units=unit_system["number_density"])
setup_magnetic_field_aliases(self, "flash",
["mag%s" % ax for ax in "xyz"])
def setup_fluid_fields(self):
from yt.fields.magnetic_field import setup_magnetic_field_aliases
unit_system = self.ds.unit_system
# velocity
def velocity_xyz(v):
def _velocity(field, data):
return data["gas", f"momentum_{v}"] / data["gas", "density"]
return _velocity
for v in "xyz":
self.add_field(
("gas", f"velocity_{v}"),
sampling_type="cell",
function=velocity_xyz(v),
units=unit_system["velocity"],
)
# ============================================================================
# note that yt internal fields assume
# [thermal_energy] = [energy per mass]
# [kinetic_energy] = [energy per volume]
# [magnetic_energy] = [energy per volume]
# and we further adopt
# [total_energy] = [energy per mass]
# [total_energy_per_volume] = [energy per volume]
# ============================================================================
# kinetic energy per volume
def ek(data):
return (0.5 *
(data["gamer", "MomX"]**2 + data["gamer", "MomY"]**2 +
data["gamer", "MomZ"]**2) / data["gamer", "Dens"])
# thermal energy per volume
def et(data):
Et = data["gamer", "Engy"] - ek(data)
if self.ds.mhd:
# magnetic_energy is a yt internal field
Et -= data["gas", "magnetic_energy"]
return Et
# thermal energy per mass (i.e., specific)
def _thermal_energy(field, data):
return et(data) / data["gamer", "Dens"]
self.add_field(
("gas", "thermal_energy"),
sampling_type="cell",
function=_thermal_energy,
units=unit_system["specific_energy"],
)
# total energy per mass
def _total_energy(field, data):
return data["gamer", "Engy"] / data["gamer", "Dens"]
self.add_field(
("gas", "total_energy"),
sampling_type="cell",
function=_total_energy,
units=unit_system["specific_energy"],
)
# pressure
def _pressure(field, data):
return et(data) * (data.ds.gamma - 1.0)
self.add_field(
("gas", "pressure"),
sampling_type="cell",
function=_pressure,
units=unit_system["pressure"],
)
# mean molecular weight
if hasattr(self.ds, "mu"):
def _mu(field, data):
return data.ds.mu * data["index", "ones"]
self.add_field(
("gas", "mean_molecular_weight"),
sampling_type="cell",
function=_mu,
units="",
)
# temperature
def _temperature(field, data):
return (data.ds.mu * data["gas", "pressure"] * mh /
(data["gas", "density"] * kb))
self.add_field(
("gas", "temperature"),
sampling_type="cell",
function=_temperature,
units=unit_system["temperature"],
)
# magnetic field aliases --> magnetic_field_x/y/z
if self.ds.mhd:
setup_magnetic_field_aliases(self, "gamer",
[f"CCMag{v}" for v in "XYZ"])
def setup_gas_particle_fields(self, ptype):
super().setup_gas_particle_fields(ptype)
if (ptype, "InternalEnergy") in self.field_list:
def _pressure(field, data):
return ((data.ds.gamma - 1.0) * data[ptype, "density"] *
data[ptype, "InternalEnergy"])
self.add_field(
(ptype, "pressure"),
function=_pressure,
sampling_type="particle",
units=self.ds.unit_system["pressure"],
)
if (ptype, "GFM_Metals_00") in self.field_list:
self.nuclei_names = metal_elements
self.species_names = ["H"]
if (ptype, "NeutralHydrogenAbundance") in self.field_list:
self.species_names += ["H_p0", "H_p1"]
self.species_names += metal_elements
if (ptype, "MagneticField") in self.field_list:
setup_magnetic_field_aliases(self, ptype, "MagneticField")
if (ptype, "NeutralHydrogenAbundance") in self.field_list:
def _h_p0_fraction(field, data):
return (data[ptype, "GFM_Metals_00"] *
data[ptype, "NeutralHydrogenAbundance"])
self.add_field(
(ptype, "H_p0_fraction"),
sampling_type="particle",
function=_h_p0_fraction,
units="",
)
def _h_p1_fraction(field, data):
return data[ptype, "GFM_Metals_00"] * (
1.0 - data[ptype, "NeutralHydrogenAbundance"])
self.add_field(
(ptype, "H_p1_fraction"),
sampling_type="particle",
function=_h_p1_fraction,
units="",
)
add_species_field_by_fraction(self, ptype, "H_p0")
add_species_field_by_fraction(self, ptype, "H_p1")
for species in ["H", "H_p0", "H_p1"]:
for suf in ["_density", "_number_density"]:
field = f"{species}{suf}"
self.alias(("gas", field), (ptype, field))
self.alias(("gas", "H_nuclei_density"),
("gas", "H_number_density"))
if (ptype, "ElectronAbundance") in self.field_list:
def _el_number_density(field, data):
return (data[ptype, "ElectronAbundance"] *
data[ptype, "H_number_density"])
self.add_field(
(ptype, "El_number_density"),
sampling_type="particle",
function=_el_number_density,
units=self.ds.unit_system["number_density"],
)
self.alias(("gas", "El_number_density"),
(ptype, "El_number_density"))
def setup_fluid_fields(self):
from yt.fields.magnetic_field import setup_magnetic_field_aliases
setup_magnetic_field_aliases(self, "gdf",
[f"magnetic_field_{ax}" for ax in "xyz"])
def setup_fluid_fields(self):
from yt.fields.magnetic_field import setup_magnetic_field_aliases
unit_system = self.ds.unit_system
# Add velocity fields
for comp in "xyz":
vel_field = ("athena", "velocity_%s" % comp)
mom_field = ("athena", "momentum_%s" % comp)
if vel_field in self.field_list:
self.add_output_field(
vel_field, sampling_type="cell", units="code_length/code_time"
)
self.alias(
("gas", "velocity_%s" % comp),
vel_field,
units=unit_system["velocity"],
)
elif mom_field in self.field_list:
self.add_output_field(
mom_field,
sampling_type="cell",
units="code_mass/code_time/code_length**2",
)
self.add_field(
("gas", "velocity_%s" % comp),
sampling_type="cell",
function=velocity_field(comp),
units=unit_system["velocity"],
)
# Add pressure, energy, and temperature fields
def eint_from_etot(data):
eint = data["athena", "total_energy"].copy()
eint -= data["gas", "kinetic_energy"]
if ("athena", "cell_centered_B_x") in self.field_list:
eint -= data["gas", "magnetic_energy"]
return eint
def etot_from_pres(data):
etot = data["athena", "pressure"].copy()
etot /= data.ds.gamma - 1.0
etot += data["gas", "kinetic_energy"]
if ("athena", "cell_centered_B_x") in self.field_list:
etot += data["gas", "magnetic_energy"]
return etot
if ("athena", "pressure") in self.field_list:
self.add_output_field(
("athena", "pressure"), sampling_type="cell", units=pres_units
)
self.alias(
("gas", "pressure"),
("athena", "pressure"),
units=unit_system["pressure"],
)
def _thermal_energy(field, data):
return (
data["athena", "pressure"]
/ (data.ds.gamma - 1.0)
/ data["athena", "density"]
)
self.add_field(
("gas", "thermal_energy"),
sampling_type="cell",
function=_thermal_energy,
units=unit_system["specific_energy"],
)
def _total_energy(field, data):
return etot_from_pres(data) / data["athena", "density"]
self.add_field(
("gas", "total_energy"),
sampling_type="cell",
function=_total_energy,
units=unit_system["specific_energy"],
)
elif ("athena", "total_energy") in self.field_list:
self.add_output_field(
("athena", "total_energy"), sampling_type="cell", units=pres_units
)
def _thermal_energy(field, data):
return eint_from_etot(data) / data["athena", "density"]
self.add_field(
("gas", "thermal_energy"),
sampling_type="cell",
function=_thermal_energy,
units=unit_system["specific_energy"],
)
def _total_energy(field, data):
return data["athena", "total_energy"] / data["athena", "density"]
self.add_field(
("gas", "total_energy"),
sampling_type="cell",
function=_total_energy,
units=unit_system["specific_energy"],
)
# Add temperature field
def _temperature(field, data):
return (
data.ds.mu
* data["gas", "pressure"]
/ data["gas", "density"]
* mh
/ kboltz
)
self.add_field(
("gas", "temperature"),
sampling_type="cell",
function=_temperature,
units=unit_system["temperature"],
)
setup_magnetic_field_aliases(
self, "athena", ["cell_centered_B_%s" % ax for ax in "xyz"]
)
def setup_gas_particle_fields(self, ptype):
super().setup_gas_particle_fields(ptype)
# Since the AREPO gas "particles" are Voronoi cells, we can
# define a volume here
def _volume(field, data):
return data[ptype, "mass"] / data[ptype, "density"]
self.add_field(
(ptype, "cell_volume"),
function=_volume,
sampling_type="local",
units=self.ds.unit_system["volume"],
)
if (ptype, "InternalEnergy") in self.field_list:
def _pressure(field, data):
return ((data.ds.gamma - 1.0) * data[ptype, "density"] *
data[ptype, "InternalEnergy"])
self.add_field(
(ptype, "pressure"),
function=_pressure,
sampling_type="particle",
units=self.ds.unit_system["pressure"],
)
self.alias((ptype, "pressure"), ("gas", "pressure"))
if (ptype, "GFM_Metals_00") in self.field_list:
self.nuclei_names = metal_elements
self.species_names = ["H"]
if (ptype, "NeutralHydrogenAbundance") in self.field_list:
self.species_names += ["H_p0", "H_p1"]
self.species_names += metal_elements
if (ptype, "MagneticField") in self.field_list:
setup_magnetic_field_aliases(self, ptype, "MagneticField")
if (ptype, "NeutralHydrogenAbundance") in self.field_list:
def _h_p0_fraction(field, data):
return (data[ptype, "GFM_Metals_00"] *
data[ptype, "NeutralHydrogenAbundance"])
self.add_field(
(ptype, "H_p0_fraction"),
sampling_type="particle",
function=_h_p0_fraction,
units="",
)
def _h_p1_fraction(field, data):
return data[ptype, "GFM_Metals_00"] * (
1.0 - data[ptype, "NeutralHydrogenAbundance"])
self.add_field(
(ptype, "H_p1_fraction"),
sampling_type="particle",
function=_h_p1_fraction,
units="",
)
add_species_field_by_fraction(self, ptype, "H_p0")
add_species_field_by_fraction(self, ptype, "H_p1")
for species in ["H", "H_p0", "H_p1"]:
for suf in ["_density", "_number_density"]:
field = f"{species}{suf}"
self.alias(("gas", field), (ptype, field))
self.alias(("gas", "H_nuclei_density"),
("gas", "H_number_density"))
if (ptype, "ElectronAbundance") in self.field_list:
def _el_number_density(field, data):
return (data[ptype, "ElectronAbundance"] *
data[ptype, "H_number_density"])
self.add_field(
(ptype, "El_number_density"),
sampling_type="particle",
function=_el_number_density,
units=self.ds.unit_system["number_density"],
)
self.alias(("gas", "El_number_density"),
(ptype, "El_number_density"))
if (ptype, "CosmicRaySpecificEnergy") in self.field_list:
self.alias(
(ptype, "specific_cosmic_ray_energy"),
("gas", "specific_cosmic_ray_energy"),
)
def _cr_energy_density(field, data):
return (data["PartType0", "specific_cosmic_ray_energy"] *
data["gas", "density"])
self.add_field(
("gas", "cosmic_ray_energy_density"),
_cr_energy_density,
sampling_type="local",
units=self.ds.unit_system["pressure"],
)
self.alias(
("PartType0", "specific_cr_energy"),
("PartType0", "specific_cosmic_ray_energy"),
deprecate=("4.1.0", "4.2.0"),
)
self.alias(
("gas", "cr_energy_density"),
("gas", "cosmic_ray_energy_density"),
deprecate=("4.1.0", "4.2.0"),
)
def _cr_pressure(field, data):
return (data.ds.gamma_cr - 1.0) * data["gas",
"cr_energy_density"]
self.add_field(
("gas", "cosmic_ray_pressure"),
_cr_pressure,
sampling_type="local",
units=self.ds.unit_system["pressure"],
)
def setup_fluid_fields(self):
setup_magnetic_field_aliases(self, "amrvac",
[f"mag{ax}" for ax in "xyz"])
self._setup_velocity_fields() # gas velocities
self._setup_dust_fields() # dust derived fields (including velocities)
# fields with nested dependencies are defined thereafter
# by increasing level of complexity
us = self.ds.unit_system
def _kinetic_energy_density(field, data):
# devnote : have a look at issue 1301
return 0.5 * data["gas", "density"] * data["gas",
"velocity_magnitude"]**2
self.add_field(
("gas", "kinetic_energy_density"),
function=_kinetic_energy_density,
units=us["density"] * us["velocity"]**2,
dimensions=dimensions.density * dimensions.velocity**2,
sampling_type="cell",
)
# magnetic energy density
if ("amrvac", "b1") in self.field_list:
def _magnetic_energy_density(field, data):
emag = 0.5 * data["gas", "magnetic_1"]**2
for idim in "23":
if not ("amrvac", f"b{idim}") in self.field_list:
break
emag += 0.5 * data["gas", f"magnetic_{idim}"]**2
# in AMRVAC the magnetic field is defined in units where mu0 = 1,
# such that
# Emag = 0.5*B**2 instead of Emag = 0.5*B**2 / mu0
# To correctly transform the dimensionality from gauss**2 -> rho*v**2,
# we have to take mu0 into account. If we divide here, units when adding
# the field should be us["density"]*us["velocity"]**2.
# If not, they should be us["magnetic_field"]**2 and division should
# happen elsewhere.
emag /= 4 * np.pi
# divided by mu0 = 4pi in cgs,
# yt handles 'mks' and 'code' unit systems internally.
return emag
self.add_field(
("gas", "magnetic_energy_density"),
function=_magnetic_energy_density,
units=us["density"] * us["velocity"]**2,
dimensions=dimensions.density * dimensions.velocity**2,
sampling_type="cell",
)
# Adding the thermal pressure field.
# In AMRVAC we have multiple physics possibilities:
# - if HD/MHD + energy equation P = (gamma-1)*(e - ekin (- emag)) for (M)HD
# - if HD/MHD but solve_internal_e is true in parfile, P = (gamma-1)*e for both
# - if (m)hd_energy is false in parfile (isothermal), P = c_adiab * rho**gamma
def _full_thermal_pressure_HD(field, data):
# energy density and pressure are actually expressed in the same unit
pthermal = (data.ds.gamma -
1) * (data["gas", "energy_density"] -
data["gas", "kinetic_energy_density"])
return pthermal
def _full_thermal_pressure_MHD(field, data):
pthermal = (
_full_thermal_pressure_HD(field, data) -
(data.ds.gamma - 1) * data["gas", "magnetic_energy_density"])
return pthermal
def _polytropic_thermal_pressure(field, data):
return (data.ds.gamma - 1) * data["gas", "energy_density"]
def _adiabatic_thermal_pressure(field, data):
return data.ds._c_adiab * data["gas", "density"]**data.ds.gamma
pressure_recipe = None
if ("amrvac", "e") in self.field_list:
if self.ds._e_is_internal:
pressure_recipe = _polytropic_thermal_pressure
mylog.info("Using polytropic EoS for thermal pressure.")
elif ("amrvac", "b1") in self.field_list:
pressure_recipe = _full_thermal_pressure_MHD
mylog.info("Using full MHD energy for thermal pressure.")
else:
pressure_recipe = _full_thermal_pressure_HD
mylog.info("Using full HD energy for thermal pressure.")
elif self.ds._c_adiab is not None:
pressure_recipe = _adiabatic_thermal_pressure
mylog.info(
"Using adiabatic EoS for thermal pressure (isothermal).")
mylog.warning("If you used usr_set_pthermal you should "
"redefine the thermal_pressure field.")
if pressure_recipe is not None:
self.add_field(
("gas", "thermal_pressure"),
function=pressure_recipe,
units=us["density"] * us["velocity"]**2,
dimensions=dimensions.density * dimensions.velocity**2,
sampling_type="cell",
)
# sound speed and temperature depend on thermal pressure
def _sound_speed(field, data):
return np.sqrt(data.ds.gamma *
data["gas", "thermal_pressure"] /
data["gas", "density"])
self.add_field(
("gas", "sound_speed"),
function=_sound_speed,
units=us["velocity"],
dimensions=dimensions.velocity,
sampling_type="cell",
)
else:
mylog.warning(
"e not found and no parfile passed, can not set thermal_pressure."
)
def setup_fluid_fields(self):
pc = self.ds.units.physical_constants
from yt.fields.magnetic_field import setup_magnetic_field_aliases
unit_system = self.ds.unit_system
if self.ds.srhd:
c2 = pc.clight * pc.clight
if self.ds.eos == 4:
# adiabatic (effective) gamma
def _gamma(field, data):
kT = data["gamer", "Temp"]
x = 2.25 * kT / np.sqrt(2.25 * kT * kT + 1.0)
c_p = 2.5 + x
c_v = 1.5 + x
return c_p / c_v
def htilde(data):
kT = data["gamer", "Temp"]
x = 2.25 * kT * kT
ht = 2.5 * kT + x / (1.0 + np.sqrt(x + 1.0))
return ht * c2
def _sound_speed(field, data):
h = htilde(data) / c2 + 1.0
kT = data["gamer", "Temp"]
cs2 = kT / (3.0 * h)
cs2 *= (5.0 * h - 8.0 * kT) / (h - kT)
return pc.clight * np.sqrt(cs2)
else:
# adiabatic gamma
def _gamma(field, data):
return self.ds.gamma * data["gas", "ones"]
def htilde(data):
kT = data["gamer", "Temp"]
g = data["gas", "gamma"]
ht = g * kT / (g - 1.0)
return ht * c2
def _sound_speed(field, data):
h = htilde(data) / c2 + 1.0
cs2 = data["gas", "gamma"] / h * data["gamer", "Temp"]
return pc.clight * np.sqrt(cs2)
# coordinate frame density
self.alias(
("gas", "frame_density"),
("gamer", "Dens"),
units=unit_system["density"],
)
self.add_field(("gas", "gamma"),
sampling_type="cell",
function=_gamma,
units="")
# 4-velocity spatial components
def four_velocity_xyz(u):
def _four_velocity(field, data):
ui = data["gas", f"momentum_density_{u}"] * c2
ui /= data["gas", "frame_density"] * (htilde(data) + c2)
return ui
return _four_velocity
for u in "xyz":
self.add_field(
("gas", f"four_velocity_{u}"),
sampling_type="cell",
function=four_velocity_xyz(u),
units=unit_system["velocity"],
)
# lorentz factor
def _lorentz_factor(field, data):
u2 = data["gas", "four_velocity_magnitude"]**2
return np.sqrt(1.0 + u2 / c2)
self.add_field(
("gas", "lorentz_factor"),
sampling_type="cell",
function=_lorentz_factor,
units="",
)
# velocity
def velocity_xyz(v):
def _velocity(field, data):
return (data["gas", f"four_velocity_{v}"] /
data["gas", "lorentz_factor"])
return _velocity
for v in "xyz":
self.add_field(
("gas", f"velocity_{v}"),
sampling_type="cell",
function=velocity_xyz(v),
units=unit_system["velocity"],
)
# density
def _density(field, data):
return data["gas", "frame_density"] / data["gas",
"lorentz_factor"]
self.add_field(
("gas", "density"),
sampling_type="cell",
function=_density,
units=unit_system["density"],
)
# pressure
def _pressure(field, data):
return data["gas", "density"] * c2 * data["gamer", "Temp"]
# thermal energy per mass (i.e., specific)
def _specific_thermal_energy(field, data):
eps = data["gas", "density"] * htilde(data) - data["gas",
"pressure"]
return eps / data["gas", "density"]
# total energy per mass
def _specific_total_energy(field, data):
E = data["gamer", "Engy"] + data["gamer", "Dens"] * c2
return E / data["gamer", "Dens"]
def _kinetic_energy_density(field, data):
u2 = data["gas", "four_velocity_magnitude"]**2
gm1 = u2 / c2 / (data["gas", "lorentz_factor"] + 1.0)
h = htilde(data) + c2
return gm1 * (data["gamer", "Dens"] * h +
data["gas", "pressure"])
self.add_field(
("gas", "kinetic_energy_density"),
sampling_type="cell",
function=_kinetic_energy_density,
units=unit_system["pressure"],
)
self.add_field(
("gas", "sound_speed"),
sampling_type="cell",
function=_sound_speed,
units=unit_system["velocity"],
)
def _mach_number(field, data):
c_s = data["gas", "sound_speed"]
u_s = c_s / np.sqrt(1.0 - c_s * c_s / c2)
return data["gas", "four_velocity_magnitude"] / u_s
self.add_field(
("gas", "mach_number"),
sampling_type="cell",
function=_mach_number,
units="",
)
else:
# density
self.alias(
("gas", "density"),
("gamer", "Dens"),
units=unit_system["density"],
)
# velocity
def velocity_xyz(v):
def _velocity(field, data):
return data["gas",
f"momentum_density_{v}"] / data["gas",
"density"]
return _velocity
for v in "xyz":
self.add_field(
("gas", f"velocity_{v}"),
sampling_type="cell",
function=velocity_xyz(v),
units=unit_system["velocity"],
)
# ====================================================
# note that yt internal fields assume
# [specific_thermal_energy] = [energy per mass]
# [kinetic_energy_density] = [energy per volume]
# [magnetic_energy_density] = [energy per volume]
# and we further adopt
# [specific_total_energy] = [energy per mass]
# [total_energy_density] = [energy per volume]
# ====================================================
# thermal energy per volume
def et(data):
ek = (0.5 *
(data["gamer", "MomX"]**2 + data["gamer", "MomY"]**2 +
data["gamer", "MomZ"]**2) / data["gamer", "Dens"])
Et = data["gamer", "Engy"] - ek
if self.ds.mhd:
# magnetic_energy is a yt internal field
Et -= data["gas", "magnetic_energy_density"]
return Et
# thermal energy per mass (i.e., specific)
def _specific_thermal_energy(field, data):
return et(data) / data["gamer", "Dens"]
# total energy per mass
def _specific_total_energy(field, data):
return data["gamer", "Engy"] / data["gamer", "Dens"]
# pressure
def _pressure(field, data):
return et(data) * (data.ds.gamma - 1.0)
self.add_field(
("gas", "specific_thermal_energy"),
sampling_type="cell",
function=_specific_thermal_energy,
units=unit_system["specific_energy"],
)
self.add_field(
("gas", "specific_total_energy"),
sampling_type="cell",
function=_specific_total_energy,
units=unit_system["specific_energy"],
)
self.add_field(
("gas", "pressure"),
sampling_type="cell",
function=_pressure,
units=unit_system["pressure"],
)
# mean molecular weight
if hasattr(self.ds, "mu"):
def _mu(field, data):
return data.ds.mu * data["index", "ones"]
self.add_field(
("gas", "mean_molecular_weight"),
sampling_type="cell",
function=_mu,
units="",
)
# temperature
def _temperature(field, data):
return (data.ds.mu * data["gas", "pressure"] * pc.mh /
(data["gas", "density"] * pc.kb))
self.add_field(
("gas", "temperature"),
sampling_type="cell",
function=_temperature,
units=unit_system["temperature"],
)
# magnetic field aliases --> magnetic_field_x/y/z
if self.ds.mhd:
setup_magnetic_field_aliases(self, "gamer",
[f"CCMag{v}" for v in "XYZ"])
