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"])