def test_clump_field_parameters(): """ Make sure clump finding on fields with field parameters works. """ def _also_density(field, data): factor = data.get_field_parameter("factor") return factor * data["density"] ds = data_dir_load(i30) ds.add_field("also_density", function=_also_density, units=ds.fields.gas.density.units, sampling_type="cell", validators=[ValidateParameter("factor")]) data_source = ds.disk([0.5, 0.5, 0.5], [0., 0., 1.], (8, 'kpc'), (1, 'kpc')) data_source.set_field_parameter("factor", 1) step = 2.0 field = ("gas", "density") c_min = 10**np.floor(np.log10(data_source[field]).min()) c_max = 10**np.floor(np.log10(data_source[field]).max() + 1) master_clump_1 = Clump(data_source, ("gas", "density")) master_clump_1.add_validator("min_cells", 20) master_clump_2 = Clump(data_source, ("gas", "also_density")) master_clump_2.add_validator("min_cells", 20) find_clumps(master_clump_1, c_min, c_max, step) find_clumps(master_clump_2, c_min, c_max, step) leaf_clumps_1 = get_lowest_clumps(master_clump_1) leaf_clumps_2 = get_lowest_clumps(master_clump_2) for c1, c2 in zip(leaf_clumps_1, leaf_clumps_2): assert_array_equal(c1["gas", "density"], c2["gas", "density"])
def test_arbitrary_field_parameters(): def _test_field(field, data): par = data.get_field_parameter('test_parameter') return par * data['all', 'particle_mass'] ds = fake_random_ds(64, nprocs=8, particles=16**2) ds.add_field(('all', 'test_field'), units='g', function=_test_field, sampling_type='particle', validators=[ValidateParameter('test_parameter')]) agrid = ds.arbitrary_grid([0.4, 0.4, 0.4], [0.99, 0.99, 0.99], dims=[32, 32, 32]) agrid.set_field_parameter('test_parameter', 2) assert_array_equal(2*agrid['all', 'particle_mass'], agrid['all', 'test_field'])
def test_arbitrary_field_parameters(): def _test_field(field, data): par = data.get_field_parameter("test_parameter") return par * data["all", "particle_mass"] ds = fake_random_ds(64, nprocs=8, particles=16 ** 2) ds.add_field( ("all", "test_field"), units="g", function=_test_field, sampling_type="particle", validators=[ValidateParameter("test_parameter")], ) agrid = ds.arbitrary_grid([0.4, 0.4, 0.4], [0.99, 0.99, 0.99], dims=[32, 32, 32]) agrid.set_field_parameter("test_parameter", 2) assert_array_equal(2 * agrid["all", "particle_mass"], agrid["all", "test_field"])
def setup_magnetic_field_fields(registry, ftype="gas", slice_info=None): def _magnetic_energy(field, data): """This assumes that your front end has provided Bx, By, Bz in units of Gauss. If you use MKS, make sure to write your own magnetic_energy field to deal with non-unitary \mu_0. """ return (data[ftype, "magnetic_field_x"]**2 + data[ftype, "magnetic_field_y"]**2 + data[ftype, "magnetic_field_z"]**2) / (8 * np.pi) registry.add_field((ftype, "magnetic_energy"), function=_magnetic_energy, units="erg / cm**3") def _plasma_beta(field, data): """This assumes that your front end has provided Bx, By, Bz in units of Gauss. If you use MKS, make sure to write your own PlasmaBeta field to deal with non-unitary \mu_0. """ return data[ftype, 'pressure'] / data[ftype, 'magnetic_energy'] registry.add_field((ftype, "plasma_beta"), function=_plasma_beta, units="") def _magnetic_pressure(field, data): return data[ftype, 'magnetic_energy'] registry.add_field((ftype, "magnetic_pressure"), function=_magnetic_pressure, units="erg / cm**3") def _magnetic_field_strength(field, data): return np.sqrt(8. * np.pi * data[ftype, "magnetic_energy"]) registry.add_field((ftype, "magnetic_field_strength"), function=_magnetic_field_strength, units="gauss") def _magnetic_field_poloidal(field, data): normal = data.get_field_parameter("normal") d = data[ftype, 'magnetic_field_x'] Bfields = data.ds.arr([ data[ftype, 'magnetic_field_x'], data[ftype, 'magnetic_field_y'], data[ftype, 'magnetic_field_z'] ], d.units) theta = data["index", 'spherical_theta'] phi = data["index", 'spherical_phi'] return get_sph_theta_component(Bfields, theta, phi, normal) registry.add_field((ftype, "magnetic_field_poloidal"), function=_magnetic_field_poloidal, units="gauss", validators=[ValidateParameter("normal")]) def _magnetic_field_toroidal(field, data): normal = data.get_field_parameter("normal") d = data[ftype, 'magnetic_field_x'] Bfields = data.ds.arr([ data[ftype, 'magnetic_field_x'], data[ftype, 'magnetic_field_y'], data[ftype, 'magnetic_field_z'] ], d.units) phi = data["index", 'spherical_phi'] return get_sph_phi_component(Bfields, phi, normal) registry.add_field((ftype, "magnetic_field_toroidal"), function=_magnetic_field_toroidal, units="gauss", validators=[ValidateParameter("normal")])
def setup_magnetic_field_fields(registry, ftype="gas", slice_info=None): ds = registry.ds unit_system = ds.unit_system pc = registry.ds.units.physical_constants axis_names = registry.ds.coordinates.axis_order if (ftype, f"magnetic_field_{axis_names[0]}") not in registry: return u = registry[ftype, f"magnetic_field_{axis_names[0]}"].units def mag_factors(dims): if dims == dimensions.magnetic_field_cgs: return 4.0 * np.pi elif dims == dimensions.magnetic_field_mks: return ds.units.physical_constants.mu_0 def _magnetic_field_strength(field, data): xm = f"relative_magnetic_field_{axis_names[0]}" ym = f"relative_magnetic_field_{axis_names[1]}" zm = f"relative_magnetic_field_{axis_names[2]}" B2 = (data[ftype, xm])**2 + (data[ftype, ym])**2 + (data[ftype, zm])**2 return np.sqrt(B2) registry.add_field( (ftype, "magnetic_field_strength"), sampling_type="local", function=_magnetic_field_strength, validators=[ValidateParameter("bulk_magnetic_field")], units=u, ) def _magnetic_energy_density(field, data): B = data[ftype, "magnetic_field_strength"] return 0.5 * B * B / mag_factors(B.units.dimensions) registry.add_field( (ftype, "magnetic_energy_density"), sampling_type="local", function=_magnetic_energy_density, units=unit_system["pressure"], ) registry.alias( (ftype, "magnetic_energy"), (ftype, "magnetic_energy_density"), deprecate=("4.0.0", "4.1.0"), ) def _plasma_beta(field, data): return data[ftype, "pressure"] / data[ftype, "magnetic_energy_density"] registry.add_field((ftype, "plasma_beta"), sampling_type="local", function=_plasma_beta, units="") def _magnetic_pressure(field, data): return data[ftype, "magnetic_energy_density"] registry.add_field( (ftype, "magnetic_pressure"), sampling_type="local", function=_magnetic_pressure, units=unit_system["pressure"], ) if registry.ds.geometry == "cartesian": def _magnetic_field_poloidal(field, data): normal = data.get_field_parameter("normal") Bfields = ustack([ data[ftype, "relative_magnetic_field_x"], data[ftype, "relative_magnetic_field_y"], data[ftype, "relative_magnetic_field_z"], ]) theta = data["index", "spherical_theta"] phi = data["index", "spherical_phi"] return get_sph_theta_component(Bfields, theta, phi, normal) def _magnetic_field_toroidal(field, data): normal = data.get_field_parameter("normal") Bfields = ustack([ data[ftype, "relative_magnetic_field_x"], data[ftype, "relative_magnetic_field_y"], data[ftype, "relative_magnetic_field_z"], ]) phi = data["index", "spherical_phi"] return get_sph_phi_component(Bfields, phi, normal) elif registry.ds.geometry == "cylindrical": def _magnetic_field_poloidal(field, data): bm = data.get_field_parameter("bulk_magnetic_field") r = data["index", "r"] z = data["index", "z"] d = np.sqrt(r * r + z * z) rax = axis_names.find("r") zax = axis_names.find("z") return (data[ftype, "magnetic_field_r"] - bm[rax]) * (r / d) + ( data[ftype, "magnetic_field_z"] - bm[zax]) * (z / d) def _magnetic_field_toroidal(field, data): ax = axis_names.find("theta") bm = data.get_field_parameter("bulk_magnetic_field") return data[ftype, "magnetic_field_theta"] - bm[ax] elif registry.ds.geometry == "spherical": def _magnetic_field_poloidal(field, data): ax = axis_names.find("theta") bm = data.get_field_parameter("bulk_magnetic_field") return data[ftype, "magnetic_field_theta"] - bm[ax] def _magnetic_field_toroidal(field, data): ax = axis_names.find("phi") bm = data.get_field_parameter("bulk_magnetic_field") return data[ftype, "magnetic_field_phi"] - bm[ax] else: # Unidentified geometry--set to None _magnetic_field_toroidal = None _magnetic_field_poloidal = None registry.add_field( (ftype, "magnetic_field_poloidal"), sampling_type="local", function=_magnetic_field_poloidal, units=u, validators=[ ValidateParameter("normal"), ValidateParameter("bulk_magnetic_field"), ], ) registry.add_field( (ftype, "magnetic_field_toroidal"), sampling_type="local", function=_magnetic_field_toroidal, units=u, validators=[ ValidateParameter("normal"), ValidateParameter("bulk_magnetic_field"), ], ) def _alfven_speed(field, data): B = data[ftype, "magnetic_field_strength"] return B / np.sqrt( mag_factors(B.units.dimensions) * data[ftype, "density"]) registry.add_field( (ftype, "alfven_speed"), sampling_type="local", function=_alfven_speed, units=unit_system["velocity"], ) def _mach_alfven(field, data): return data[ftype, "velocity_magnitude"] / data[ftype, "alfven_speed"] registry.add_field( (ftype, "mach_alfven"), sampling_type="local", function=_mach_alfven, units="dimensionless", ) b_units = registry.ds.quan(1.0, u).units if dimensions.current_mks in b_units.dimensions.free_symbols: rm_scale = pc.qp.to("C", "SI")**3 / (4.0 * np.pi * pc.eps_0) else: rm_scale = pc.qp**3 / pc.clight rm_scale *= registry.ds.quan( 1.0, "rad") / (2.0 * np.pi * pc.me**2 * pc.clight**3) rm_units = registry.ds.quan(1.0, "rad/m**2").units / unit_system["length"] def _rotation_measure(field, data): return (rm_scale * data[ftype, "magnetic_field_los"] * data[ftype, "El_number_density"]) registry.add_field( (ftype, "rotation_measure"), sampling_type="local", function=_rotation_measure, units=rm_units, validators=[ValidateParameter("axis", {"axis": [0, 1, 2]})], )
def setup_fluid_vector_fields(registry, ftype="gas", slice_info=None): # Current implementation for gradient is not valid for curvilinear geometries if is_curvilinear(registry.ds.geometry): return unit_system = registry.ds.unit_system # slice_info would be the left, the right, and the factor. # For example, with the old Enzo-ZEUS fields, this would be: # slice(None, -2, None) # slice(1, -1, None) # 1.0 # Otherwise, we default to a centered difference. if slice_info is None: sl_left = slice(None, -2, None) sl_right = slice(2, None, None) div_fac = 2.0 else: sl_left, sl_right, div_fac = slice_info sl_center = slice(1, -1, None) def _baroclinic_vorticity_x(field, data): rho2 = data[ftype, "density"].astype(np.float64)**2 return (data[ftype, "pressure_gradient_y"] * data[ftype, "density_gradient_z"] - data[ftype, "pressure_gradient_z"] * data[ftype, "density_gradient_z"]) / rho2 def _baroclinic_vorticity_y(field, data): rho2 = data[ftype, "density"].astype(np.float64)**2 return (data[ftype, "pressure_gradient_z"] * data[ftype, "density_gradient_x"] - data[ftype, "pressure_gradient_x"] * data[ftype, "density_gradient_z"]) / rho2 def _baroclinic_vorticity_z(field, data): rho2 = data[ftype, "density"].astype(np.float64)**2 return (data[ftype, "pressure_gradient_x"] * data[ftype, "density_gradient_y"] - data[ftype, "pressure_gradient_y"] * data[ftype, "density_gradient_x"]) / rho2 bv_validators = [ ValidateSpatial(1, [(ftype, "density"), (ftype, "pressure")]) ] for ax in 'xyz': n = "baroclinic_vorticity_%s" % ax registry.add_field((ftype, n), sampling_type="cell", function=eval("_%s" % n), validators=bv_validators, units=unit_system["frequency"]**2) create_magnitude_field(registry, "baroclinic_vorticity", unit_system["frequency"]**2, ftype=ftype, slice_info=slice_info, validators=bv_validators) def _vorticity_x(field, data): vz = data[ftype, "relative_velocity_z"] vy = data[ftype, "relative_velocity_y"] f = ((vz[sl_center, sl_right, sl_center] - vz[sl_center, sl_left, sl_center]) / (div_fac * just_one(data["index", "dy"]))) f -= ((vy[sl_center, sl_center, sl_right] - vy[sl_center, sl_center, sl_left]) / (div_fac * just_one(data["index", "dz"]))) new_field = data.ds.arr(np.zeros_like(vz, dtype=np.float64), f.units) new_field[sl_center, sl_center, sl_center] = f return new_field def _vorticity_y(field, data): vx = data[ftype, "relative_velocity_x"] vz = data[ftype, "relative_velocity_z"] f = ((vx[sl_center, sl_center, sl_right] - vx[sl_center, sl_center, sl_left]) / (div_fac * just_one(data["index", "dz"]))) f -= ((vz[sl_right, sl_center, sl_center] - vz[sl_left, sl_center, sl_center]) / (div_fac * just_one(data["index", "dx"]))) new_field = data.ds.arr(np.zeros_like(vz, dtype=np.float64), f.units) new_field[sl_center, sl_center, sl_center] = f return new_field def _vorticity_z(field, data): vx = data[ftype, "relative_velocity_x"] vy = data[ftype, "relative_velocity_y"] f = ((vy[sl_right, sl_center, sl_center] - vx[sl_left, sl_center, sl_center]) / (div_fac * just_one(data["index", "dx"]))) f -= ((vx[sl_center, sl_right, sl_center] - vx[sl_center, sl_left, sl_center]) / (div_fac * just_one(data["index", "dy"]))) new_field = data.ds.arr(np.zeros_like(vy, dtype=np.float64), f.units) new_field[sl_center, sl_center, sl_center] = f return new_field vort_validators = [ ValidateSpatial(1, [(ftype, "velocity_%s" % d) for d in 'xyz']), ValidateParameter('bulk_velocity') ] for ax in 'xyz': n = "vorticity_%s" % ax registry.add_field((ftype, n), sampling_type="cell", function=eval("_%s" % n), units=unit_system["frequency"], validators=vort_validators) create_magnitude_field(registry, "vorticity", unit_system["frequency"], ftype=ftype, slice_info=slice_info, validators=vort_validators) create_squared_field(registry, "vorticity", unit_system["frequency"]**2, ftype=ftype, slice_info=slice_info, validators=vort_validators) def _vorticity_stretching_x(field, data): return data[ftype, "velocity_divergence"] * data[ftype, "vorticity_x"] def _vorticity_stretching_y(field, data): return data[ftype, "velocity_divergence"] * data[ftype, "vorticity_y"] def _vorticity_stretching_z(field, data): return data[ftype, "velocity_divergence"] * data[ftype, "vorticity_z"] for ax in 'xyz': n = "vorticity_stretching_%s" % ax registry.add_field((ftype, n), sampling_type="cell", function=eval("_%s" % n), units=unit_system["frequency"]**2, validators=vort_validators) create_magnitude_field(registry, "vorticity_stretching", unit_system["frequency"]**2, ftype=ftype, slice_info=slice_info, validators=vort_validators) def _vorticity_growth_x(field, data): return -data[ftype, "vorticity_stretching_x"] - \ data[ftype, "baroclinic_vorticity_x"] def _vorticity_growth_y(field, data): return -data[ftype, "vorticity_stretching_y"] - \ data[ftype, "baroclinic_vorticity_y"] def _vorticity_growth_z(field, data): return -data[ftype, "vorticity_stretching_z"] - \ data[ftype, "baroclinic_vorticity_z"] for ax in 'xyz': n = "vorticity_growth_%s" % ax registry.add_field((ftype, n), sampling_type="cell", function=eval("_%s" % n), units=unit_system["frequency"]**2, validators=vort_validators) def _vorticity_growth_magnitude(field, data): result = np.sqrt(data[ftype, "vorticity_growth_x"]**2 + data[ftype, "vorticity_growth_y"]**2 + data[ftype, "vorticity_growth_z"]**2) dot = data.ds.arr(np.zeros(result.shape), "") for ax in "xyz": dot += (data[ftype, "vorticity_%s" % ax] * data[ftype, "vorticity_growth_%s" % ax]).to_ndarray() result = np.sign(dot) * result return result registry.add_field((ftype, "vorticity_growth_magnitude"), sampling_type="cell", function=_vorticity_growth_magnitude, units=unit_system["frequency"]**2, validators=vort_validators, take_log=False) def _vorticity_growth_magnitude_absolute(field, data): return np.sqrt(data[ftype, "vorticity_growth_x"]**2 + data[ftype, "vorticity_growth_y"]**2 + data[ftype, "vorticity_growth_z"]**2) registry.add_field((ftype, "vorticity_growth_magnitude_absolute"), sampling_type="cell", function=_vorticity_growth_magnitude_absolute, units=unit_system["frequency"]**2, validators=vort_validators) def _vorticity_growth_timescale(field, data): domegax_dt = data[ftype, "vorticity_x"] / data[ftype, "vorticity_growth_x"] domegay_dt = data[ftype, "vorticity_y"] / data[ftype, "vorticity_growth_y"] domegaz_dt = data[ftype, "vorticity_z"] / data[ftype, "vorticity_growth_z"] return np.sqrt(domegax_dt**2 + domegay_dt**2 + domegaz_dt**2) registry.add_field((ftype, "vorticity_growth_timescale"), sampling_type="cell", function=_vorticity_growth_timescale, units=unit_system["time"], validators=vort_validators) ######################################################################## # With radiation pressure ######################################################################## def _vorticity_radiation_pressure_x(field, data): rho = data[ftype, "density"].astype(np.float64) return (data[ftype, "radiation_acceleration_y"] * data[ftype, "density_gradient_z"] - data[ftype, "radiation_acceleration_z"] * data[ftype, "density_gradient_y"]) / rho def _vorticity_radiation_pressure_y(field, data): rho = data[ftype, "density"].astype(np.float64) return (data[ftype, "radiation_acceleration_z"] * data[ftype, "density_gradient_x"] - data[ftype, "radiation_acceleration_x"] * data[ftype, "density_gradient_z"]) / rho def _vorticity_radiation_pressure_z(field, data): rho = data[ftype, "density"].astype(np.float64) return (data[ftype, "radiation_acceleration_x"] * data[ftype, "density_gradient_y"] - data[ftype, "radiation_acceleration_y"] * data[ftype, "density_gradient_x"]) / rho vrp_validators = [ ValidateSpatial(1, [(ftype, "density"), (ftype, "radiation_acceleration_x"), (ftype, "radiation_acceleration_y"), (ftype, "radiation_acceleration_z")]) ] for ax in 'xyz': n = "vorticity_radiation_pressure_%s" % ax registry.add_field((ftype, n), sampling_type="cell", function=eval("_%s" % n), units=unit_system["frequency"]**2, validators=vrp_validators) create_magnitude_field(registry, "vorticity_radiation_pressure", unit_system["frequency"]**2, ftype=ftype, slice_info=slice_info, validators=vrp_validators) def _vorticity_radiation_pressure_growth_x(field, data): return -data[ftype, "vorticity_stretching_x"] - \ data[ftype, "baroclinic_vorticity_x"] \ -data[ftype, "vorticity_radiation_pressure_x"] def _vorticity_radiation_pressure_growth_y(field, data): return -data[ftype, "vorticity_stretching_y"] - \ data[ftype, "baroclinic_vorticity_y"] \ -data[ftype, "vorticity_radiation_pressure_y"] def _vorticity_radiation_pressure_growth_z(field, data): return -data[ftype, "vorticity_stretching_z"] - \ data[ftype, "baroclinic_vorticity_z"] \ -data[ftype, "vorticity_radiation_pressure_z"] for ax in 'xyz': n = "vorticity_radiation_pressure_growth_%s" % ax registry.add_field((ftype, n), sampling_type="cell", function=eval("_%s" % n), units=unit_system["frequency"]**2, validators=vrp_validators) def _vorticity_radiation_pressure_growth_magnitude(field, data): result = np.sqrt( data[ftype, "vorticity_radiation_pressure_growth_x"]**2 + data[ftype, "vorticity_radiation_pressure_growth_y"]**2 + data[ftype, "vorticity_radiation_pressure_growth_z"]**2) dot = data.ds.arr(np.zeros(result.shape), "") for ax in "xyz": dot += (data[ftype, "vorticity_%s" % ax] * data[ftype, "vorticity_growth_%s" % ax]).to_ndarray() result = np.sign(dot) * result return result registry.add_field( (ftype, "vorticity_radiation_pressure_growth_magnitude"), sampling_type="cell", function=_vorticity_radiation_pressure_growth_magnitude, units=unit_system["frequency"]**2, validators=vrp_validators, take_log=False) def _vorticity_radiation_pressure_growth_magnitude_absolute(field, data): return np.sqrt( data[ftype, "vorticity_radiation_pressure_growth_x"]**2 + data[ftype, "vorticity_radiation_pressure_growth_y"]**2 + data[ftype, "vorticity_radiation_pressure_growth_z"]**2) registry.add_field( (ftype, "vorticity_radiation_pressure_growth_magnitude_absolute"), sampling_type="cell", function=_vorticity_radiation_pressure_growth_magnitude_absolute, units="s**(-2)", validators=vrp_validators) def _vorticity_radiation_pressure_growth_timescale(field, data): domegax_dt = data[ftype, "vorticity_x"] / \ data[ftype, "vorticity_radiation_pressure_growth_x"] domegay_dt = data[ftype, "vorticity_y"] / \ data[ftype, "vorticity_radiation_pressure_growth_y"] domegaz_dt = data[ftype, "vorticity_z"] / \ data[ftype, "vorticity_radiation_pressure_growth_z"] return np.sqrt(domegax_dt**2 + domegay_dt**2 + domegaz_dt**2) registry.add_field( (ftype, "vorticity_radiation_pressure_growth_timescale"), sampling_type="cell", function=_vorticity_radiation_pressure_growth_timescale, units=unit_system["time"], validators=vrp_validators) def _shear(field, data): """ Shear is defined as [(dvx/dy + dvy/dx)^2 + (dvz/dy + dvy/dz)^2 + (dvx/dz + dvz/dx)^2 ]^(0.5) where dvx/dy = [vx(j-1) - vx(j+1)]/[2dy] and is in units of s^(-1) (it's just like vorticity except add the derivative pairs instead of subtracting them) """ if data.ds.dimensionality > 1: vx = data[ftype, "relative_velocity_x"] vy = data[ftype, "relative_velocity_y"] dvydx = ((vy[sl_right, sl_center, sl_center] - vy[sl_left, sl_center, sl_center]) / (div_fac * just_one(data["index", "dx"]))) dvxdy = ((vx[sl_center, sl_right, sl_center] - vx[sl_center, sl_left, sl_center]) / (div_fac * just_one(data["index", "dy"]))) f = (dvydx + dvxdy)**2.0 del dvydx, dvxdy if data.ds.dimensionality > 2: vz = data[ftype, "relative_velocity_z"] dvzdy = ((vz[sl_center, sl_right, sl_center] - vz[sl_center, sl_left, sl_center]) / (div_fac * just_one(data["index", "dy"]))) dvydz = ((vy[sl_center, sl_center, sl_right] - vy[sl_center, sl_center, sl_left]) / (div_fac * just_one(data["index", "dz"]))) f += (dvzdy + dvydz)**2.0 del dvzdy, dvydz dvxdz = ((vx[sl_center, sl_center, sl_right] - vx[sl_center, sl_center, sl_left]) / (div_fac * just_one(data["index", "dz"]))) dvzdx = ((vz[sl_right, sl_center, sl_center] - vz[sl_left, sl_center, sl_center]) / (div_fac * just_one(data["index", "dx"]))) f += (dvxdz + dvzdx)**2.0 del dvxdz, dvzdx np.sqrt(f, out=f) new_field = data.ds.arr(np.zeros_like(data[ftype, "velocity_x"]), f.units) new_field[sl_center, sl_center, sl_center] = f return new_field registry.add_field((ftype, "shear"), sampling_type="cell", function=_shear, validators=[ ValidateSpatial(1, [(ftype, "velocity_x"), (ftype, "velocity_y"), (ftype, "velocity_z")]), ValidateParameter('bulk_velocity') ], units=unit_system["frequency"]) def _shear_criterion(field, data): """ Divide by c_s to leave shear in units of length**-1, which can be compared against the inverse of the local cell size (1/dx) to determine if refinement should occur. """ return data[ftype, "shear"] / data[ftype, "sound_speed"] registry.add_field((ftype, "shear_criterion"), sampling_type="cell", function=_shear_criterion, units=unit_system["length"]**-1, validators=[ ValidateSpatial(1, [(ftype, "sound_speed"), (ftype, "velocity_x"), (ftype, "velocity_y"), (ftype, "velocity_z")]) ]) def _shear_mach(field, data): """ Dimensionless shear (shear_mach) is defined nearly the same as shear, except that it is scaled by the local dx/dy/dz and the local sound speed. So it results in a unitless quantity that is effectively measuring shear in mach number. In order to avoid discontinuities created by multiplying by dx/dy/dz at grid refinement boundaries, we also multiply by 2**GridLevel. Shear (Mach) = [(dvx + dvy)^2 + (dvz + dvy)^2 + (dvx + dvz)^2 ]^(0.5) / c_sound """ if data.ds.dimensionality > 1: vx = data[ftype, "relative_velocity_x"] vy = data[ftype, "relative_velocity_y"] dvydx = (vy[sl_right, sl_center, sl_center] - vy[sl_left, sl_center, sl_center]) / div_fac dvxdy = (vx[sl_center, sl_right, sl_center] - vx[sl_center, sl_left, sl_center]) / div_fac f = (dvydx + dvxdy)**2.0 del dvydx, dvxdy if data.ds.dimensionality > 2: vz = data[ftype, "relative_velocity_z"] dvzdy = (vz[sl_center, sl_right, sl_center] - vz[sl_center, sl_left, sl_center]) / div_fac dvydz = (vy[sl_center, sl_center, sl_right] - vy[sl_center, sl_center, sl_left]) / div_fac f += (dvzdy + dvydz)**2.0 del dvzdy, dvydz dvxdz = (vx[sl_center, sl_center, sl_right] - vx[sl_center, sl_center, sl_left]) / div_fac dvzdx = (vz[sl_right, sl_center, sl_center] - vz[sl_left, sl_center, sl_center]) / div_fac f += (dvxdz + dvzdx)**2.0 del dvxdz, dvzdx f *= ( 2.0**data["index", "grid_level"][sl_center, sl_center, sl_center] / data[ftype, "sound_speed"][sl_center, sl_center, sl_center])**2.0 np.sqrt(f, out=f) new_field = data.ds.arr(np.zeros_like(vx), f.units) new_field[sl_center, sl_center, sl_center] = f return new_field vs_fields = [(ftype, "sound_speed"), (ftype, "velocity_x"), (ftype, "velocity_y"), (ftype, "velocity_z")] registry.add_field((ftype, "shear_mach"), sampling_type="cell", function=_shear_mach, units="", validators=[ ValidateSpatial(1, vs_fields), ValidateParameter('bulk_velocity') ])
ValidateGridType, \ ValidateParameter, \ ValidateSpatial, \ NeedsParameter from astropy.table import Table , Column def _Disk_H(field, data): center = data.get_field_parameter('center') z = data["z"] - center[2] return np.abs(z) yt.add_field("Disk_H", function=_Disk_H, units="pc", take_log=False, validators=[ValidateParameter('center')]) def _radial_velocity(field,data): if data.has_field_parameter("bulk_velocity"): bv = data.get_field_parameter("bulk_velocity").in_units("cm/s") else: bv = data.ds.arr(np.zeros(3), "cm/s") xv = data["gas","velocity_x"] - bv[0] yv = data["gas","velocity_y"] - bv[1] center = data.get_field_parameter('center') x_hat = data["x"] - center[0] y_hat = data["y"] - center[1] r = np.sqrt(x_hat*x_hat+y_hat*y_hat) x_hat /= r y_hat /= r return xv*x_hat+yv*y_hat
def setup_magnetic_field_fields(registry, ftype="gas", slice_info=None): unit_system = registry.ds.unit_system axis_names = registry.ds.coordinates.axis_order if (ftype, "magnetic_field_%s" % axis_names[0]) not in registry: return u = registry[ftype, "magnetic_field_%s" % axis_names[0]].units def _magnetic_field_strength(field, data): B2 = (data[ftype, "magnetic_field_%s" % axis_names[0]]**2 + data[ftype, "magnetic_field_%s" % axis_names[1]]**2 + data[ftype, "magnetic_field_%s" % axis_names[2]]**2) return np.sqrt(B2) registry.add_field((ftype, "magnetic_field_strength"), sampling_type="cell", function=_magnetic_field_strength, units=u) def _magnetic_energy(field, data): B = data[ftype, "magnetic_field_strength"] return 0.5 * B * B / mag_factors[B.units.dimensions] registry.add_field((ftype, "magnetic_energy"), sampling_type="cell", function=_magnetic_energy, units=unit_system["pressure"]) def _plasma_beta(field, data): return data[ftype, 'pressure'] / data[ftype, 'magnetic_energy'] registry.add_field((ftype, "plasma_beta"), sampling_type="cell", function=_plasma_beta, units="") def _magnetic_pressure(field, data): return data[ftype, 'magnetic_energy'] registry.add_field((ftype, "magnetic_pressure"), sampling_type="cell", function=_magnetic_pressure, units=unit_system["pressure"]) if registry.ds.geometry == "cartesian": def _magnetic_field_poloidal(field, data): normal = data.get_field_parameter("normal") d = data[ftype, 'magnetic_field_x'] Bfields = data.ds.arr([ data[ftype, 'magnetic_field_x'], data[ftype, 'magnetic_field_y'], data[ftype, 'magnetic_field_z'] ], d.units) theta = data["index", 'spherical_theta'] phi = data["index", 'spherical_phi'] return get_sph_theta_component(Bfields, theta, phi, normal) def _magnetic_field_toroidal(field, data): normal = data.get_field_parameter("normal") d = data[ftype, 'magnetic_field_x'] Bfields = data.ds.arr([ data[ftype, 'magnetic_field_x'], data[ftype, 'magnetic_field_y'], data[ftype, 'magnetic_field_z'] ], d.units) phi = data["index", 'spherical_phi'] return get_sph_phi_component(Bfields, phi, normal) elif registry.ds.geometry == "cylindrical": def _magnetic_field_poloidal(field, data): r = data["index", "r"] z = data["index", "z"] d = np.sqrt(r * r + z * z) return (data[ftype, "magnetic_field_r"] * (r / d) + data[ftype, "magnetic_field_z"] * (z / d)) def _magnetic_field_toroidal(field, data): return data[ftype, "magnetic_field_theta"] elif registry.ds.geometry == "spherical": def _magnetic_field_poloidal(field, data): return data[ftype, "magnetic_field_theta"] def _magnetic_field_toroidal(field, data): return data[ftype, "magnetic_field_phi"] else: # Unidentified geometry--set to None _magnetic_field_toroidal = None _magnetic_field_poloidal = None registry.add_field((ftype, "magnetic_field_poloidal"), sampling_type="cell", function=_magnetic_field_poloidal, units=u, validators=[ValidateParameter("normal")]) registry.add_field((ftype, "magnetic_field_toroidal"), sampling_type="cell", function=_magnetic_field_toroidal, units=u, validators=[ValidateParameter("normal")]) def _alfven_speed(field, data): B = data[ftype, 'magnetic_field_strength'] return B / np.sqrt( mag_factors[B.units.dimensions] * data[ftype, 'density']) registry.add_field((ftype, "alfven_speed"), sampling_type="cell", function=_alfven_speed, units=unit_system["velocity"]) def _mach_alfven(field, data): return data[ftype, 'velocity_magnitude'] / data[ftype, 'alfven_speed'] registry.add_field((ftype, "mach_alfven"), sampling_type="cell", function=_mach_alfven, units="dimensionless")
def standard_particle_fields(registry, ptype, spos = "particle_position_%s", svel = "particle_velocity_%s"): # This function will set things up based on the scalar fields and standard # yt field names. def _particle_velocity_magnitude(field, data): """ M{|v|} """ bulk_velocity = data.get_field_parameter("bulk_velocity") if bulk_velocity is None: bulk_velocity = np.zeros(3) return np.sqrt((data[ptype, svel % 'x'] - bulk_velocity[0])**2 + (data[ptype, svel % 'y'] - bulk_velocity[1])**2 + (data[ptype, svel % 'z'] - bulk_velocity[2])**2 ) registry.add_field((ptype, "particle_velocity_magnitude"), function=_particle_velocity_magnitude, particle_type=True, take_log=False, units="cm/s") def _particle_specific_angular_momentum(field, data): """ Calculate the angular of a particle velocity. Returns a vector for each particle. """ if data.has_field_parameter("bulk_velocity"): bv = data.get_field_parameter("bulk_velocity") else: bv = np.zeros(3, dtype=np.float64) xv = data[ptype, svel % 'x'] - bv[0] yv = data[ptype, svel % 'y'] - bv[1] zv = data[ptype, svel % 'z'] - bv[2] center = data.get_field_parameter('center') coords = YTArray([data[ptype, spos % 'x'], data[ptype, spos % 'y'], data[ptype, spos % 'z']], dtype=np.float64) new_shape = tuple([3] + [1]*(len(coords.shape)-1)) r_vec = coords - np.reshape(center,new_shape) v_vec = YTArray([xv,yv,zv], dtype=np.float64) return np.cross(r_vec, v_vec, axis=0) registry.add_field((ptype, "particle_specific_angular_momentum"), function=_particle_specific_angular_momentum, particle_type=True, units="cm**2/s", validators=[ValidateParameter("center")]) def _particle_specific_angular_momentum_x(field, data): if data.has_field_parameter("bulk_velocity"): bv = data.get_field_parameter("bulk_velocity") else: bv = np.zeros(3, dtype=np.float64) center = data.get_field_parameter('center') y = data[ptype, spos % "y"] - center[1] z = data[ptype, spos % "z"] - center[2] yv = data[ptype, svel % "y"] - bv[1] zv = data[ptype, svel % "z"] - bv[2] return yv*z - zv*y registry.add_field((ptype, "particle_specific_angular_momentum_x"), function=_particle_specific_angular_momentum_x, particle_type=True, units="cm**2/s", validators=[ValidateParameter("center")]) def _particle_specific_angular_momentum_y(field, data): if data.has_field_parameter("bulk_velocity"): bv = data.get_field_parameter("bulk_velocity") else: bv = np.zeros(3, dtype=np.float64) center = data.get_field_parameter('center') x = data[ptype, spos % "x"] - center[0] z = data[ptype, spos % "z"] - center[2] xv = data[ptype, svel % "x"] - bv[0] zv = data[ptype, svel % "z"] - bv[2] return -(xv*z - zv*x) registry.add_field((ptype, "particle_specific_angular_momentum_y"), function=_particle_specific_angular_momentum_y, particle_type=True, units="cm**2/s", validators=[ValidateParameter("center")]) def _particle_specific_angular_momentum_z(field, data): if data.has_field_parameter("bulk_velocity"): bv = data.get_field_parameter("bulk_velocity") else: bv = np.zeros(3, dtype=np.float64) center = data.get_field_parameter('center') x = data[ptype, spos % "x"] - center[0] y = data[ptype, spos % "y"] - center[1] xv = data[ptype, svel % "x"] - bv[0] yv = data[ptype, svel % "y"] - bv[1] return xv*y - yv*x registry.add_field((ptype, "particle_specific_angular_momentum_z"), function=_particle_specific_angular_momentum_z, particle_type=True, units="cm**2/s", validators=[ValidateParameter("center")]) create_magnitude_field(registry, "particle_specific_angular_momentum", "cm**2/s", ftype=ptype, particle_type=True) def _particle_angular_momentum_x(field, data): return data[ptype, "particle_mass"] * \ data[ptype, "particle_specific_angular_momentum_x"] registry.add_field((ptype, "particle_angular_momentum_x"), function=_particle_angular_momentum_x, units="g*cm**2/s", particle_type=True, validators=[ValidateParameter('center')]) def _particle_angular_momentum_y(field, data): return data[ptype, "particle_mass"] * \ data[ptype, "particle_specific_angular_momentum_y"] registry.add_field((ptype, "particle_angular_momentum_y"), function=_particle_angular_momentum_y, units="g*cm**2/s", particle_type=True, validators=[ValidateParameter('center')]) def _particle_angular_momentum_z(field, data): return data[ptype, "particle_mass"] * \ data[ptype, "particle_specific_angular_momentum_z"] registry.add_field((ptype, "particle_angular_momentum_z"), function=_particle_angular_momentum_z, units="g*cm**2/s", particle_type=True, validators=[ValidateParameter('center')]) def _particle_angular_momentum(field, data): return data[ptype, "particle_mass"] \ * data[ptype, "particle_specific_angular_momentum"] registry.add_field((ptype, "particle_angular_momentum"), function=_particle_angular_momentum, particle_type=True, units="g*cm**2/s", validators=[ValidateParameter("center")]) create_magnitude_field(registry, "particle_angular_momentum", "g*cm**2/s", ftype=ptype, particle_type=True) from .field_functions import \ get_radius def _particle_radius(field, data): return get_radius(data, "particle_position_") registry.add_field((ptype, "particle_radius"), function=_particle_radius, validators=[ValidateParameter("center")], units="cm", particle_type = True, display_name = "Particle Radius") def _particle_spherical_position_radius(field, data): """ Radial component of the particles' position vectors in spherical coords on the provided field parameters for 'normal', 'center', and 'bulk_velocity', """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') bv = data.get_field_parameter("bulk_velocity") pos = spos pos = YTArray([data[ptype, pos % ax] for ax in "xyz"]) theta = get_sph_theta(pos, center) phi = get_sph_phi(pos, center) pos = pos - np.reshape(center, (3, 1)) sphr = get_sph_r_component(pos, theta, phi, normal) return sphr registry.add_field((ptype, "particle_spherical_position_radius"), function=_particle_spherical_position_radius, particle_type=True, units="cm", validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_position_theta(field, data): """ Theta component of the particles' position vectors in spherical coords on the provided field parameters for 'normal', 'center', and 'bulk_velocity', """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') bv = data.get_field_parameter("bulk_velocity") pos = spos pos = YTArray([data[ptype, pos % ax] for ax in "xyz"]) theta = get_sph_theta(pos, center) phi = get_sph_phi(pos, center) pos = pos - np.reshape(center, (3, 1)) spht = get_sph_theta_component(pos, theta, phi, normal) return spht registry.add_field((ptype, "particle_spherical_position_theta"), function=_particle_spherical_position_theta, particle_type=True, units="cm", validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_position_phi(field, data): """ Phi component of the particles' position vectors in spherical coords on the provided field parameters for 'normal', 'center', and 'bulk_velocity', """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') bv = data.get_field_parameter("bulk_velocity") pos = spos pos = YTArray([data[ptype, pos % ax] for ax in "xyz"]) theta = get_sph_theta(pos, center) phi = get_sph_phi(pos, center) pos = pos - np.reshape(center, (3, 1)) sphp = get_sph_phi_component(pos, phi, normal) return sphp registry.add_field((ptype, "particle_spherical_position_phi"), function=_particle_spherical_position_phi, particle_type=True, units="cm", validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_velocity_radius(field, data): """ Radial component of the particles' velocity vectors in spherical coords based on the provided field parameters for 'normal', 'center', and 'bulk_velocity', """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') bv = data.get_field_parameter("bulk_velocity") pos = spos pos = YTArray([data[ptype, pos % ax] for ax in "xyz"]) vel = svel vel = YTArray([data[ptype, vel % ax] for ax in "xyz"]) theta = get_sph_theta(pos, center) phi = get_sph_phi(pos, center) pos = pos - np.reshape(center, (3, 1)) vel = vel - np.reshape(bv, (3, 1)) sphr = get_sph_r_component(vel, theta, phi, normal) return sphr registry.add_field((ptype, "particle_spherical_velocity_radius"), function=_particle_spherical_velocity_radius, particle_type=True, units="cm/s", validators=[ValidateParameter("normal"), ValidateParameter("center")]) # This is simply aliased to "particle_spherical_velocity_radius" # for ease of use. registry.add_field((ptype, "particle_radial_velocity"), function=_particle_spherical_velocity_radius, particle_type=True, units="cm/s", validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_velocity_theta(field, data): """ Theta component of the particles' velocity vectors in spherical coords based on the provided field parameters for 'normal', 'center', and 'bulk_velocity', """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') bv = data.get_field_parameter("bulk_velocity") pos = spos pos = YTArray([data[ptype, pos % ax] for ax in "xyz"]) vel = svel vel = YTArray([data[ptype, vel % ax] for ax in "xyz"]) theta = get_sph_theta(pos, center) phi = get_sph_phi(pos, center) pos = pos - np.reshape(center, (3, 1)) vel = vel - np.reshape(bv, (3, 1)) spht = get_sph_theta_component(vel, theta, phi, normal) return spht registry.add_field((ptype, "particle_spherical_velocity_theta"), function=_particle_spherical_velocity_theta, particle_type=True, units="cm/s", validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_velocity_phi(field, data): """ Phi component of the particles' velocity vectors in spherical coords based on the provided field parameters for 'normal', 'center', and 'bulk_velocity', """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') bv = data.get_field_parameter("bulk_velocity") pos = YTArray([data[ptype, spos % ax] for ax in "xyz"]) vel = YTArray([data[ptype, svel % ax] for ax in "xyz"]) theta = get_sph_theta(pos, center) phi = get_sph_phi(pos, center) pos = pos - np.reshape(center, (3, 1)) vel = vel - np.reshape(bv, (3, 1)) sphp = get_sph_phi_component(vel, phi, normal) return sphp registry.add_field((ptype, "particle_spherical_velocity_phi"), function=_particle_spherical_velocity_phi, particle_type=True, units="cm/s", validators=[ValidateParameter("normal"), ValidateParameter("center")])
tr = data.ds.gamma * data["gas", "pressure"] / data["gas", "density"] return tr def _sound_speed_rep(field, data): tr = data.ds.gamma * data["gas", "pressure"] / data["gas", "density"] return 1.0/np.sqrt(tr) def _sound_speed_rep_2(field, data): tr = data.ds.gamma * data["gas", "pressure"] / data["gas", "density"] return 1.0/tr yt.add_field("Disk_H", function=_Disk_H, units="pc", take_log=False, validators=[ValidateParameter('center')]) yt.add_field(("gas", "vz_squared"),function=_vz_squared,units="km**2/s**2") yt.add_field(("gas", "vz"),function=_vz,units="km/s") yt.add_field("sound_speed", function=_sound_speed, units=r"km/s") yt.add_field("sound_speed_rep", function=_sound_speed_rep, units=r"s/km") yt.add_field("sound_speed_2", function=_sound_speed_2, units=r"km**2/s**2") yt.add_field("sound_speed_rep_2", function=_sound_speed_rep_2, units=r"s**2/km**2") yt.add_field(("gas", "px"),function=_px,units="g/s/cm**2") yt.add_field(("gas", "py"),function=_py,units="g/s/cm**2") yt.add_field(("gas", "pz"),function=_pz,units="g/s/cm**2") yt.add_field(("gas", "sturb"),function=_sturb,units="km/s",validators=vort_validators) yt.add_field(("gas", "vturb"),function=_vturb,units="km/s",validators=vort_validators) yt.add_field(("gas", "wturb"),function=_vturb,units="km/s",validators=vort_validators) def Turbulence_1D(name): if os.path.isfile(name+'_turb_1D.npy'):
def _SToverSJ(field, data): fprops = data.get_field_parameter("flameprops", default=None) #alpha = fprops.get_value(data["density"],"density jump at the end of 12C-burning zone") alpha = fprops.get_value(data["density"], "12C fluid expansion factor") return data["flamespeed"] / (data["soundspeed"] / alpha) yt.add_field(("flash", "SToverSCJ"), function=_SToverSJ, units="", sampling_type="cell", display_name=r"$S_\mathrm{T}/S_\mathrm{CJ}$", validators=[ ValidateParameter(['flameprops'], {"flameprops": [flameprops]}) ]) def _velocityz(field, data): return data["velz"] yt.add_field(("flash", "velocityz"), function=_velocityz, units="cm/s", sampling_type="cell", display_name="z-Velocity") def _velocityx(field, data):
def standard_particle_fields(registry, ptype, spos="particle_position_%s", svel="particle_velocity_%s"): unit_system = registry.ds.unit_system def _particle_velocity_magnitude(field, data): """ M{|v|} """ return np.sqrt(data[ptype, 'relative_%s' % (svel % 'x')]**2 + data[ptype, 'relative_%s' % (svel % 'y')]**2 + data[ptype, 'relative_%s' % (svel % 'z')]**2) registry.add_field((ptype, "particle_velocity_magnitude"), sampling_type="particle", function=_particle_velocity_magnitude, take_log=False, units=unit_system["velocity"]) def _particle_specific_angular_momentum(field, data): """Calculate the angular of a particle velocity. Returns a vector for each particle. """ center = data.get_field_parameter('center') pos, vel, normal = get_angular_momentum_components( ptype, data, spos, svel) L, r_vec, v_vec = modify_reference_frame(center, normal, P=pos, V=vel) # adding in the unit registry allows us to have a reference to the # dataset and thus we will always get the correct units after applying # the cross product. return ucross(r_vec, v_vec, registry=data.ds.unit_registry) registry.add_field((ptype, "particle_specific_angular_momentum"), sampling_type="particle", function=_particle_specific_angular_momentum, units=unit_system["specific_angular_momentum"], validators=[ValidateParameter("center")]) def _get_spec_ang_mom_comp(axi, ax, _ptype): def _particle_specific_angular_momentum_component(field, data): return data[_ptype, "particle_specific_angular_momentum"][:, axi] def _particle_angular_momentum_component(field, data): return data[_ptype, "particle_mass"] * \ data[ptype, "particle_specific_angular_momentum_%s" % ax] return _particle_specific_angular_momentum_component, \ _particle_angular_momentum_component for axi, ax in enumerate("xyz"): f, v = _get_spec_ang_mom_comp(axi, ax, ptype) registry.add_field( (ptype, "particle_specific_angular_momentum_%s" % ax), sampling_type="particle", function=f, units=unit_system["specific_angular_momentum"], validators=[ValidateParameter("center")]) registry.add_field((ptype, "particle_angular_momentum_%s" % ax), sampling_type="particle", function=v, units=unit_system["angular_momentum"], validators=[ValidateParameter('center')]) def _particle_angular_momentum(field, data): am = data[ptype, "particle_mass"] * data[ ptype, "particle_specific_angular_momentum"].T return am.T registry.add_field((ptype, "particle_angular_momentum"), sampling_type="particle", function=_particle_angular_momentum, units=unit_system["angular_momentum"], validators=[ValidateParameter("center")]) create_magnitude_field(registry, "particle_angular_momentum", unit_system["angular_momentum"], ftype=ptype, particle_type=True) def _particle_radius(field, data): """The spherical radius component of the particle positions Relative to the coordinate system defined by the *normal* vector, and *center* field parameters. """ return get_radius(data, "particle_position_", field.name[0]) registry.add_field((ptype, "particle_radius"), sampling_type="particle", function=_particle_radius, units=unit_system["length"], validators=[ValidateParameter("center")]) def _relative_particle_position(field, data): """The cartesian particle positions in a rotated reference frame Relative to the coordinate system defined by the *normal* vector and *center* field parameters. Note that the orientation of the x and y axes are arbitrary. """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') pos = data.ds.arr([data[ptype, spos % ax] for ax in "xyz"]).T L, pos = modify_reference_frame(center, normal, P=pos) return pos def _particle_position_relative(field, data): if not isinstance(data, FieldDetector): issue_deprecation_warning( "The 'particle_position_relative' field has been deprecated in " + "favor of 'relative_particle_position'.") if isinstance(field.name, tuple): return data[field.name[0], 'relative_particle_position'] else: return data['relative_particle_position'] for name, func in zip( ["particle_position_relative", "relative_particle_position"], [_particle_position_relative, _relative_particle_position]): registry.add_field((ptype, name), sampling_type="particle", function=func, units=unit_system["length"], validators=[ ValidateParameter("normal"), ValidateParameter("center") ]) def _relative_particle_velocity(field, data): """The vector particle velocities in an arbitrary coordinate system Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. Note that the orientation of the x and y axes are arbitrary. """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') bv = data.get_field_parameter("bulk_velocity") vel = data.ds.arr([ data[ptype, svel % ax] - bv[iax] for iax, ax in enumerate("xyz") ]).T L, vel = modify_reference_frame(center, normal, V=vel) return vel def _particle_velocity_relative(field, data): if not isinstance(data, FieldDetector): issue_deprecation_warning( "The 'particle_velocity_relative' field has been deprecated in " + "favor of 'relative_particle_velocity'.") if isinstance(field.name, tuple): return data[field.name[0], 'relative_particle_velocity'] else: return data['relative_particle_velocity'] for name, func in zip( ["particle_velocity_relative", "relative_particle_velocity"], [_particle_velocity_relative, _relative_particle_velocity]): registry.add_field((ptype, name), sampling_type="particle", function=func, units=unit_system["velocity"], validators=[ ValidateParameter("normal"), ValidateParameter("center") ]) def _get_coord_funcs_relative(axi, _ptype): def _particle_pos_rel(field, data): return data[_ptype, "relative_particle_position"][:, axi] def _particle_vel_rel(field, data): return data[_ptype, "relative_particle_velocity"][:, axi] return _particle_vel_rel, _particle_pos_rel for axi, ax in enumerate("xyz"): v, p = _get_coord_funcs_relative(axi, ptype) registry.add_field((ptype, "particle_velocity_relative_%s" % ax), sampling_type="particle", function=v, units="code_velocity") registry.add_field((ptype, "particle_position_relative_%s" % ax), sampling_type="particle", function=p, units="code_length") registry.add_field((ptype, "relative_particle_velocity_%s" % ax), sampling_type="particle", function=v, units="code_velocity") registry.add_field((ptype, "relative_particle_position_%s" % ax), sampling_type="particle", function=p, units="code_length") # this is just particle radius but we add it with an alias for the sake of # consistent naming registry.add_field( (ptype, "particle_position_spherical_radius"), sampling_type="particle", function=_particle_radius, units=unit_system["length"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_position_radius(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, 'particle_position_spherical_radius'] registry.add_field( (ptype, "particle_spherical_position_radius"), sampling_type="particle", function=_particle_spherical_position_radius, units=unit_system["length"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_position_spherical_theta(field, data): """The spherical theta coordinate of the particle positions. Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') pos = data['relative_particle_position'].T return data.ds.arr(get_sph_theta(pos, normal), "") registry.add_field( (ptype, "particle_position_spherical_theta"), sampling_type="particle", function=_particle_position_spherical_theta, units="", validators=[ValidateParameter("center"), ValidateParameter("normal")]) def _particle_spherical_position_theta(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, 'particle_position_spherical_theta'] registry.add_field( (ptype, "particle_spherical_position_theta"), sampling_type="particle", function=_particle_spherical_position_theta, units="", validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_position_spherical_phi(field, data): """The spherical phi component of the particle positions Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') pos = data['relative_particle_position'].T return data.ds.arr(get_sph_phi(pos, normal), "") registry.add_field( (ptype, "particle_position_spherical_phi"), sampling_type="particle", function=_particle_position_spherical_phi, units="", validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_position_phi(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, 'particle_position_spherical_phi'] registry.add_field( (ptype, "particle_spherical_position_phi"), sampling_type="particle", function=_particle_spherical_position_phi, units="", validators=[ValidateParameter("center"), ValidateParameter("normal")]) def _particle_velocity_spherical_radius(field, data): """The spherical radius component of the particle velocities in an arbitrary coordinate system Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') pos = data['relative_particle_position'].T vel = data['relative_particle_velocity'].T theta = get_sph_theta(pos, normal) phi = get_sph_phi(pos, normal) sphr = get_sph_r_component(vel, theta, phi, normal) return sphr registry.add_field( (ptype, "particle_velocity_spherical_radius"), sampling_type="particle", function=_particle_velocity_spherical_radius, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_velocity_radius(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, 'particle_velocity_spherical_radius'] registry.add_field( (ptype, "particle_spherical_velocity_radius"), sampling_type="particle", function=_particle_spherical_velocity_radius, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) # particel_velocity_spherical_radius is simply aliased to # "particle_radial_velocity" for convenience registry.add_field( (ptype, "particle_radial_velocity"), sampling_type="particle", function=_particle_spherical_velocity_radius, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_velocity_spherical_theta(field, data): """The spherical theta component of the particle velocities in an arbitrary coordinate system Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') pos = data['relative_particle_position'].T vel = data['relative_particle_velocity'].T theta = get_sph_theta(pos, normal) phi = get_sph_phi(pos, normal) spht = get_sph_theta_component(vel, theta, phi, normal) return spht registry.add_field( (ptype, "particle_velocity_spherical_theta"), sampling_type="particle", function=_particle_velocity_spherical_theta, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_velocity_theta(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, 'particle_velocity_spherical_theta'] registry.add_field( (ptype, "particle_spherical_velocity_theta"), sampling_type="particle", function=_particle_spherical_velocity_theta, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_velocity_spherical_phi(field, data): """The spherical phi component of the particle velocities Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') pos = data['relative_particle_position'].T vel = data['relative_particle_velocity'].T phi = get_sph_phi(pos, normal) sphp = get_sph_phi_component(vel, phi, normal) return sphp registry.add_field( (ptype, "particle_velocity_spherical_phi"), sampling_type="particle", function=_particle_velocity_spherical_phi, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_velocity_phi(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, 'particle_spherical_velocity_theta'] registry.add_field( (ptype, "particle_spherical_velocity_phi"), sampling_type="particle", function=_particle_spherical_velocity_phi, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_position_cylindrical_radius(field, data): """The cylindrical radius component of the particle positions Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') pos = data['relative_particle_position'].T return data.ds.arr(get_cyl_r(pos, normal), 'code_length') registry.add_field( (ptype, "particle_position_cylindrical_radius"), sampling_type="particle", function=_particle_position_cylindrical_radius, units=unit_system["length"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_position_cylindrical_theta(field, data): """The cylindrical theta component of the particle positions Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') pos = data['relative_particle_position'].T return data.ds.arr(get_cyl_theta(pos, normal), "") registry.add_field( (ptype, "particle_position_cylindrical_theta"), sampling_type="particle", function=_particle_position_cylindrical_theta, units="", validators=[ValidateParameter("center"), ValidateParameter("normal")]) def _particle_position_cylindrical_z(field, data): """The cylindrical z component of the particle positions Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') pos = data['relative_particle_position'].T return data.ds.arr(get_cyl_z(pos, normal), 'code_length') registry.add_field( (ptype, "particle_position_cylindrical_z"), sampling_type="particle", function=_particle_position_cylindrical_z, units=unit_system["length"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_velocity_cylindrical_radius(field, data): """The cylindrical radius component of the particle velocities Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') pos = data['relative_particle_position'].T vel = data['relative_particle_velocity'].T theta = get_cyl_theta(pos, normal) cylr = get_cyl_r_component(vel, theta, normal) return cylr registry.add_field( (ptype, "particle_velocity_cylindrical_radius"), sampling_type="particle", function=_particle_velocity_cylindrical_radius, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_velocity_cylindrical_theta(field, data): """The cylindrical theta component of the particle velocities Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') pos = data['relative_particle_position'].T vel = data['relative_particle_velocity'].T theta = get_cyl_theta(pos, normal) cylt = get_cyl_theta_component(vel, theta, normal) return cylt registry.add_field( (ptype, "particle_velocity_cylindrical_theta"), sampling_type="particle", function=_particle_velocity_cylindrical_theta, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_cylindrical_velocity_theta(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, 'particle_velocity_cylindrical_theta'] registry.add_field( (ptype, "particle_cylindrical_velocity_theta"), sampling_type="particle", function=_particle_cylindrical_velocity_theta, units="cm/s", validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_velocity_cylindrical_z(field, data): """The cylindrical z component of the particle velocities Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') vel = data['relative_particle_velocity'].T cylz = get_cyl_z_component(vel, normal) return cylz registry.add_field( (ptype, "particle_velocity_cylindrical_z"), sampling_type="particle", function=_particle_velocity_cylindrical_z, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_cylindrical_velocity_z(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, "particle_velocity_cylindrical_z"] registry.add_field( (ptype, "particle_cylindrical_velocity_z"), sampling_type="particle", function=_particle_cylindrical_velocity_z, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")])
def setup_magnetic_field_fields(registry, ftype="gas", slice_info=None): unit_system = registry.ds.unit_system if (ftype, "magnetic_field_x") not in registry: return u = registry[ftype, "magnetic_field_x"].units def _magnetic_field_strength(field, data): B2 = (data[ftype, "magnetic_field_x"]**2 + data[ftype, "magnetic_field_y"]**2 + data[ftype, "magnetic_field_z"]**2) return np.sqrt(B2) registry.add_field((ftype, "magnetic_field_strength"), function=_magnetic_field_strength, units=u) def _magnetic_energy(field, data): B = data[ftype, "magnetic_field_strength"] return 0.5 * B * B / mag_factors[B.units.dimensions] registry.add_field((ftype, "magnetic_energy"), function=_magnetic_energy, units=unit_system["pressure"]) def _plasma_beta(field, data): return data[ftype, 'pressure'] / data[ftype, 'magnetic_energy'] registry.add_field((ftype, "plasma_beta"), function=_plasma_beta, units="") def _magnetic_pressure(field, data): return data[ftype, 'magnetic_energy'] registry.add_field((ftype, "magnetic_pressure"), function=_magnetic_pressure, units=unit_system["pressure"]) def _magnetic_field_poloidal(field, data): normal = data.get_field_parameter("normal") d = data[ftype, 'magnetic_field_x'] Bfields = data.ds.arr([ data[ftype, 'magnetic_field_x'], data[ftype, 'magnetic_field_y'], data[ftype, 'magnetic_field_z'] ], d.units) theta = data["index", 'spherical_theta'] phi = data["index", 'spherical_phi'] return get_sph_theta_component(Bfields, theta, phi, normal) registry.add_field((ftype, "magnetic_field_poloidal"), function=_magnetic_field_poloidal, units=u, validators=[ValidateParameter("normal")]) def _magnetic_field_toroidal(field, data): normal = data.get_field_parameter("normal") d = data[ftype, 'magnetic_field_x'] Bfields = data.ds.arr([ data[ftype, 'magnetic_field_x'], data[ftype, 'magnetic_field_y'], data[ftype, 'magnetic_field_z'] ], d.units) phi = data["index", 'spherical_phi'] return get_sph_phi_component(Bfields, phi, normal) registry.add_field((ftype, "magnetic_field_toroidal"), function=_magnetic_field_toroidal, units=u, validators=[ValidateParameter("normal")]) def _alfven_speed(field, data): B = data[ftype, 'magnetic_field_strength'] return B / np.sqrt( mag_factors[B.units.dimensions] * data[ftype, 'density']) registry.add_field((ftype, "alfven_speed"), function=_alfven_speed, units=unit_system["velocity"]) def _mach_alfven(field, data): return data[ftype, 'velocity_magnitude'] / data[ftype, 'alfven_speed'] registry.add_field((ftype, "mach_alfven"), function=_mach_alfven, units="dimensionless")
def setup_magnetic_field_fields(registry, ftype="gas", slice_info=None): unit_system = registry.ds.unit_system axis_names = registry.ds.coordinates.axis_order if (ftype, "magnetic_field_%s" % axis_names[0]) not in registry: return u = registry[ftype, "magnetic_field_%s" % axis_names[0]].units def _magnetic_field_strength(field, data): xm = "relative_magnetic_field_%s" % axis_names[0] ym = "relative_magnetic_field_%s" % axis_names[1] zm = "relative_magnetic_field_%s" % axis_names[2] B2 = (data[ftype, xm])**2 + (data[ftype, ym])**2 + (data[ftype, zm])**2 return handle_mks_cgs(np.sqrt(B2), field.units) registry.add_field((ftype, "magnetic_field_strength"), sampling_type="cell", function=_magnetic_field_strength, validators=[ValidateParameter('bulk_magnetic_field')], units=u) def _magnetic_energy(field, data): B = data[ftype, "magnetic_field_strength"] return 0.5 * B * B / mag_factors[B.units.dimensions] registry.add_field((ftype, "magnetic_energy"), sampling_type="cell", function=_magnetic_energy, units=unit_system["pressure"]) def _plasma_beta(field, data): return data[ftype, 'pressure'] / data[ftype, 'magnetic_energy'] registry.add_field((ftype, "plasma_beta"), sampling_type="cell", function=_plasma_beta, units="") def _magnetic_pressure(field, data): return data[ftype, 'magnetic_energy'] registry.add_field((ftype, "magnetic_pressure"), sampling_type="cell", function=_magnetic_pressure, units=unit_system["pressure"]) if registry.ds.geometry == "cartesian": def _magnetic_field_poloidal(field, data): normal = data.get_field_parameter("normal") Bfields = ustack([ data[ftype, 'relative_magnetic_field_x'], data[ftype, 'relative_magnetic_field_y'], data[ftype, 'relative_magnetic_field_z'] ]) theta = data["index", 'spherical_theta'] phi = data["index", 'spherical_phi'] return get_sph_theta_component(Bfields, theta, phi, normal) def _magnetic_field_toroidal(field, data): normal = data.get_field_parameter("normal") Bfields = ustack([ data[ftype, 'relative_magnetic_field_x'], data[ftype, 'relative_magnetic_field_y'], data[ftype, 'relative_magnetic_field_z'] ]) phi = data["index", 'spherical_phi'] return get_sph_phi_component(Bfields, phi, normal) elif registry.ds.geometry == "cylindrical": def _magnetic_field_poloidal(field, data): bm = handle_mks_cgs( data.get_field_parameter("bulk_magnetic_field"), field.units) r = data["index", "r"] z = data["index", "z"] d = np.sqrt(r * r + z * z) rax = axis_names.find('r') zax = axis_names.find('z') return ((data[ftype, "magnetic_field_r"] - bm[rax]) * (r / d) + (data[ftype, "magnetic_field_z"] - bm[zax]) * (z / d)) def _magnetic_field_toroidal(field, data): ax = axis_names.find('theta') bm = handle_mks_cgs( data.get_field_parameter("bulk_magnetic_field"), field.units) return data[ftype, "magnetic_field_theta"] - bm[ax] elif registry.ds.geometry == "spherical": def _magnetic_field_poloidal(field, data): ax = axis_names.find('theta') bm = handle_mks_cgs( data.get_field_parameter("bulk_magnetic_field"), field.units) return data[ftype, "magnetic_field_theta"] - bm[ax] def _magnetic_field_toroidal(field, data): ax = axis_names.find('phi') bm = handle_mks_cgs( data.get_field_parameter("bulk_magnetic_field"), field.units) return data[ftype, "magnetic_field_phi"] - bm[ax] else: # Unidentified geometry--set to None _magnetic_field_toroidal = None _magnetic_field_poloidal = None registry.add_field((ftype, "magnetic_field_poloidal"), sampling_type="cell", function=_magnetic_field_poloidal, units=u, validators=[ ValidateParameter("normal"), ValidateParameter("bulk_magnetic_field") ]) registry.add_field((ftype, "magnetic_field_toroidal"), sampling_type="cell", function=_magnetic_field_toroidal, units=u, validators=[ ValidateParameter("normal"), ValidateParameter("bulk_magnetic_field") ]) def _alfven_speed(field, data): B = data[ftype, 'magnetic_field_strength'] return B / np.sqrt( mag_factors[B.units.dimensions] * data[ftype, 'density']) registry.add_field((ftype, "alfven_speed"), sampling_type="cell", function=_alfven_speed, units=unit_system["velocity"]) def _mach_alfven(field, data): return data[ftype, 'velocity_magnitude'] / data[ftype, 'alfven_speed'] registry.add_field((ftype, "mach_alfven"), sampling_type="cell", function=_mach_alfven, units="dimensionless")
def standard_particle_fields( registry, ptype, spos="particle_position_%s", svel="particle_velocity_%s" ): unit_system = registry.ds.unit_system def _particle_velocity_magnitude(field, data): """ M{|v|} """ return np.sqrt( data[ptype, f"relative_{svel % 'x'}"] ** 2 + data[ptype, f"relative_{svel % 'y'}"] ** 2 + data[ptype, f"relative_{svel % 'z'}"] ** 2 ) registry.add_field( (ptype, "particle_velocity_magnitude"), sampling_type="particle", function=_particle_velocity_magnitude, take_log=False, units=unit_system["velocity"], ) def _particle_specific_angular_momentum(field, data): """Calculate the angular of a particle velocity. Returns a vector for each particle. """ center = data.get_field_parameter("center") pos, vel, normal = get_angular_momentum_components(ptype, data, spos, svel) L, r_vec, v_vec = modify_reference_frame(center, normal, P=pos, V=vel) # adding in the unit registry allows us to have a reference to the # dataset and thus we will always get the correct units after applying # the cross product. return ucross(r_vec, v_vec, registry=data.ds.unit_registry) registry.add_field( (ptype, "particle_specific_angular_momentum"), sampling_type="particle", function=_particle_specific_angular_momentum, units=unit_system["specific_angular_momentum"], validators=[ValidateParameter("center")], ) def _get_spec_ang_mom_comp(axi, ax, _ptype): def _particle_specific_angular_momentum_component(field, data): return data[_ptype, "particle_specific_angular_momentum"][:, axi] def _particle_angular_momentum_component(field, data): return ( data[_ptype, "particle_mass"] * data[ptype, f"particle_specific_angular_momentum_{ax}"] ) return ( _particle_specific_angular_momentum_component, _particle_angular_momentum_component, ) for axi, ax in enumerate("xyz"): f, v = _get_spec_ang_mom_comp(axi, ax, ptype) registry.add_field( (ptype, f"particle_specific_angular_momentum_{ax}"), sampling_type="particle", function=f, units=unit_system["specific_angular_momentum"], validators=[ValidateParameter("center")], ) registry.add_field( (ptype, f"particle_angular_momentum_{ax}"), sampling_type="particle", function=v, units=unit_system["angular_momentum"], validators=[ValidateParameter("center")], ) def _particle_angular_momentum(field, data): am = ( data[ptype, "particle_mass"] * data[ptype, "particle_specific_angular_momentum"].T ) return am.T registry.add_field( (ptype, "particle_angular_momentum"), sampling_type="particle", function=_particle_angular_momentum, units=unit_system["angular_momentum"], validators=[ValidateParameter("center")], ) create_magnitude_field( registry, "particle_angular_momentum", unit_system["angular_momentum"], sampling_type="particle", ftype=ptype, ) def _particle_radius(field, data): """The spherical radius component of the particle positions Relative to the coordinate system defined by the *normal* vector, and *center* field parameters. """ return get_radius(data, "particle_position_", field.name[0]) registry.add_field( (ptype, "particle_radius"), sampling_type="particle", function=_particle_radius, units=unit_system["length"], validators=[ValidateParameter("center")], ) def _relative_particle_position(field, data): """The cartesian particle positions in a rotated reference frame Relative to the coordinate system defined by *center* field parameter. Note that the orientation of the x and y axes are arbitrary. """ field_names = [(ptype, f"particle_position_{ax}") for ax in "xyz"] return obtain_position_vector(data, field_names=field_names).T registry.add_field( (ptype, "relative_particle_position"), sampling_type="particle", function=_relative_particle_position, units=unit_system["length"], validators=[ValidateParameter("normal"), ValidateParameter("center")], ) def _relative_particle_velocity(field, data): """The vector particle velocities in an arbitrary coordinate system Relative to the coordinate system defined by the *bulk_velocity* vector field parameter. Note that the orientation of the x and y axes are arbitrary. """ field_names = [(ptype, f"particle_velocity_{ax}") for ax in "xyz"] return obtain_relative_velocity_vector(data, field_names=field_names).T registry.add_field( (ptype, "relative_particle_velocity"), sampling_type="particle", function=_relative_particle_velocity, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")], ) def _get_coord_funcs_relative(axi, _ptype): def _particle_pos_rel(field, data): return data[_ptype, "relative_particle_position"][:, axi] def _particle_vel_rel(field, data): return data[_ptype, "relative_particle_velocity"][:, axi] return _particle_vel_rel, _particle_pos_rel for axi, ax in enumerate("xyz"): v, p = _get_coord_funcs_relative(axi, ptype) registry.add_field( (ptype, f"particle_velocity_relative_{ax}"), sampling_type="particle", function=v, units="code_velocity", ) registry.add_field( (ptype, f"particle_position_relative_{ax}"), sampling_type="particle", function=p, units="code_length", ) registry.add_field( (ptype, f"relative_particle_velocity_{ax}"), sampling_type="particle", function=v, units="code_velocity", ) registry.add_field( (ptype, f"relative_particle_position_{ax}"), sampling_type="particle", function=p, units="code_length", ) # this is just particle radius but we add it with an alias for the sake of # consistent naming registry.add_field( (ptype, "particle_position_spherical_radius"), sampling_type="particle", function=_particle_radius, units=unit_system["length"], validators=[ValidateParameter("normal"), ValidateParameter("center")], ) registry.alias( (ptype, "particle_spherical_position_radius"), (ptype, "particle_position_spherical_radius"), deprecate=("4.0.0", "4.1.0"), ) def _particle_position_spherical_theta(field, data): """The spherical theta coordinate of the particle positions. Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") pos = data["relative_particle_position"].T return data.ds.arr(get_sph_theta(pos, normal), "") registry.add_field( (ptype, "particle_position_spherical_theta"), sampling_type="particle", function=_particle_position_spherical_theta, units="", validators=[ValidateParameter("center"), ValidateParameter("normal")], ) registry.alias( (ptype, "particle_spherical_position_theta"), (ptype, "particle_position_spherical_theta"), deprecate=("4.0.0", "4.1.0"), ) def _particle_position_spherical_phi(field, data): """The spherical phi component of the particle positions Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") pos = data["relative_particle_position"].T return data.ds.arr(get_sph_phi(pos, normal), "") registry.add_field( (ptype, "particle_position_spherical_phi"), sampling_type="particle", function=_particle_position_spherical_phi, units="", validators=[ValidateParameter("normal"), ValidateParameter("center")], ) registry.alias( (ptype, "particle_spherical_position_phi"), (ptype, "particle_position_spherical_phi"), deprecate=("4.0.0", "4.1.0"), ) def _particle_velocity_spherical_radius(field, data): """The spherical radius component of the particle velocities in an arbitrary coordinate system Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") pos = data["relative_particle_position"].T vel = data["relative_particle_velocity"].T theta = get_sph_theta(pos, normal) phi = get_sph_phi(pos, normal) sphr = get_sph_r_component(vel, theta, phi, normal) return sphr registry.add_field( (ptype, "particle_velocity_spherical_radius"), sampling_type="particle", function=_particle_velocity_spherical_radius, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")], ) registry.alias( (ptype, "particle_spherical_velocity_radius"), (ptype, "particle_velocity_spherical_radius"), deprecate=("4.0.0", "4.1.0"), ) registry.alias( (ptype, "particle_radial_velocity"), (ptype, "particle_velocity_spherical_radius"), ) def _particle_velocity_spherical_theta(field, data): """The spherical theta component of the particle velocities in an arbitrary coordinate system Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") pos = data["relative_particle_position"].T vel = data["relative_particle_velocity"].T theta = get_sph_theta(pos, normal) phi = get_sph_phi(pos, normal) spht = get_sph_theta_component(vel, theta, phi, normal) return spht registry.add_field( (ptype, "particle_velocity_spherical_theta"), sampling_type="particle", function=_particle_velocity_spherical_theta, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")], ) registry.alias( (ptype, "particle_spherical_velocity_theta"), (ptype, "particle_velocity_spherical_theta"), deprecate=("4.0.0", "4.1.0"), ) def _particle_velocity_spherical_phi(field, data): """The spherical phi component of the particle velocities Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") pos = data["relative_particle_position"].T vel = data["relative_particle_velocity"].T phi = get_sph_phi(pos, normal) sphp = get_sph_phi_component(vel, phi, normal) return sphp registry.add_field( (ptype, "particle_velocity_spherical_phi"), sampling_type="particle", function=_particle_velocity_spherical_phi, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")], ) registry.alias( (ptype, "particle_spherical_velocity_phi"), (ptype, "particle_velocity_spherical_phi"), deprecate=("4.0.0", "4.1.0"), ) def _particle_position_cylindrical_radius(field, data): """The cylindrical radius component of the particle positions Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") pos = data["relative_particle_position"].T pos.convert_to_units("code_length") return data.ds.arr(get_cyl_r(pos, normal), "code_length") registry.add_field( (ptype, "particle_position_cylindrical_radius"), sampling_type="particle", function=_particle_position_cylindrical_radius, units=unit_system["length"], validators=[ValidateParameter("normal"), ValidateParameter("center")], ) def _particle_position_cylindrical_theta(field, data): """The cylindrical theta component of the particle positions Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") pos = data["relative_particle_position"].T return data.ds.arr(get_cyl_theta(pos, normal), "") registry.add_field( (ptype, "particle_position_cylindrical_theta"), sampling_type="particle", function=_particle_position_cylindrical_theta, units="", validators=[ValidateParameter("center"), ValidateParameter("normal")], ) def _particle_position_cylindrical_z(field, data): """The cylindrical z component of the particle positions Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") pos = data["relative_particle_position"].T pos.convert_to_units("code_length") return data.ds.arr(get_cyl_z(pos, normal), "code_length") registry.add_field( (ptype, "particle_position_cylindrical_z"), sampling_type="particle", function=_particle_position_cylindrical_z, units=unit_system["length"], validators=[ValidateParameter("normal"), ValidateParameter("center")], ) def _particle_velocity_cylindrical_radius(field, data): """The cylindrical radius component of the particle velocities Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") pos = data["relative_particle_position"].T vel = data["relative_particle_velocity"].T theta = get_cyl_theta(pos, normal) cylr = get_cyl_r_component(vel, theta, normal) return cylr registry.add_field( (ptype, "particle_velocity_cylindrical_radius"), sampling_type="particle", function=_particle_velocity_cylindrical_radius, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")], ) def _particle_velocity_cylindrical_theta(field, data): """The cylindrical theta component of the particle velocities Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") pos = data["relative_particle_position"].T vel = data["relative_particle_velocity"].T theta = get_cyl_theta(pos, normal) cylt = get_cyl_theta_component(vel, theta, normal) return cylt registry.add_field( (ptype, "particle_velocity_cylindrical_theta"), sampling_type="particle", function=_particle_velocity_cylindrical_theta, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")], ) registry.alias( (ptype, "particle_cylindrical_velocity_theta"), (ptype, "particle_velocity_cylindrical_theta"), deprecate=("4.0.0", "4.1.0"), ) def _particle_velocity_cylindrical_z(field, data): """The cylindrical z component of the particle velocities Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") vel = data["relative_particle_velocity"].T cylz = get_cyl_z_component(vel, normal) return cylz registry.add_field( (ptype, "particle_velocity_cylindrical_z"), sampling_type="particle", function=_particle_velocity_cylindrical_z, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")], ) registry.alias( (ptype, "particle_cylindrical_velocity_z"), (ptype, "particle_velocity_cylindrical_z"), deprecate=("4.0.0", "4.1.0"), )
def standard_particle_fields(registry, ptype, spos="particle_position_%s", svel="particle_velocity_%s"): unit_system = registry.ds.unit_system # This function will set things up based on the scalar fields and standard # yt field names. # data.get_field_parameter("bulk_velocity") defaults to YTArray([0,0,0] cm/s) def _particle_velocity_magnitude(field, data): """ M{|v|} """ bulk_velocity = data.get_field_parameter("bulk_velocity") return np.sqrt((data[ptype, svel % 'x'] - bulk_velocity[0])**2 + (data[ptype, svel % 'y'] - bulk_velocity[1])**2 + (data[ptype, svel % 'z'] - bulk_velocity[2])**2) registry.add_field((ptype, "particle_velocity_magnitude"), function=_particle_velocity_magnitude, particle_type=True, take_log=False, units=unit_system["velocity"]) def _particle_specific_angular_momentum(field, data): """ Calculate the angular of a particle velocity. Returns a vector for each particle. """ center = data.get_field_parameter('center') pos, vel, normal, bv = get_angular_momentum_components( ptype, data, spos, svel) L, r_vec, v_vec = modify_reference_frame(center, normal, P=pos, V=vel) # adding in the unit registry allows us to have a reference to the dataset # and thus we will always get the correct units after applying the cross product. return -ucross(r_vec, v_vec, registry=data.ds.unit_registry) registry.add_field((ptype, "particle_specific_angular_momentum"), function=_particle_specific_angular_momentum, particle_type=True, units=unit_system["specific_angular_momentum"], validators=[ValidateParameter("center")]) def _get_spec_ang_mom_comp(axi, ax, _ptype): def _particle_specific_angular_momentum_component(field, data): return data[_ptype, "particle_specific_angular_momentum"][:, axi] def _particle_angular_momentum_component(field, data): return data[_ptype, "particle_mass"] * \ data[ptype, "particle_specific_angular_momentum_%s" % ax] return _particle_specific_angular_momentum_component, \ _particle_angular_momentum_component for axi, ax in enumerate("xyz"): f, v = _get_spec_ang_mom_comp(axi, ax, ptype) registry.add_field( (ptype, "particle_specific_angular_momentum_%s" % ax), particle_type=True, function=f, units=unit_system["specific_angular_momentum"], validators=[ValidateParameter("center")]) registry.add_field((ptype, "particle_angular_momentum_%s" % ax), function=v, units=unit_system["angular_momentum"], particle_type=True, validators=[ValidateParameter('center')]) def _particle_angular_momentum(field, data): am = data[ptype, "particle_mass"] * data[ ptype, "particle_specific_angular_momentum"].T return am.T registry.add_field((ptype, "particle_angular_momentum"), function=_particle_angular_momentum, particle_type=True, units=unit_system["angular_momentum"], validators=[ValidateParameter("center")]) create_magnitude_field(registry, "particle_angular_momentum", unit_system["angular_momentum"], ftype=ptype, particle_type=True) def _particle_radius(field, data): """The spherical radius component of the particle positions Relative to the coordinate system defined by the *normal* vector, and *center* field parameters. """ return get_radius(data, "particle_position_") registry.add_field((ptype, "particle_radius"), function=_particle_radius, units=unit_system["length"], particle_type=True, validators=[ValidateParameter("center")]) def _particle_position_relative(field, data): """The cartesian particle positions in a rotated reference frame Relative to the coordinate system defined by the *normal* vector and *center* field parameters. Note that the orientation of the x and y axes are arbitrary. """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') pos = data.ds.arr([data[ptype, spos % ax] for ax in "xyz"]).T L, pos = modify_reference_frame(center, normal, P=pos) return pos registry.add_field( (ptype, "particle_position_relative"), function=_particle_position_relative, particle_type=True, units=unit_system["length"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_velocity_relative(field, data): """The vector particle velocities in an arbitrary coordinate system Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. Note that the orientation of the x and y axes are arbitrary. """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') bv = data.get_field_parameter("bulk_velocity") vel = data.ds.arr([ data[ptype, svel % ax] - bv[iax] for iax, ax in enumerate("xyz") ]).T L, vel = modify_reference_frame(center, normal, V=vel) return vel registry.add_field( (ptype, "particle_velocity_relative"), function=_particle_velocity_relative, particle_type=True, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _get_coord_funcs_relative(axi, _ptype): def _particle_pos_rel(field, data): return data[_ptype, "particle_position_relative"][:, axi] def _particle_vel_rel(field, data): return data[_ptype, "particle_velocity_relative"][:, axi] return _particle_vel_rel, _particle_pos_rel for axi, ax in enumerate("xyz"): v, p = _get_coord_funcs_relative(axi, ptype) registry.add_field((ptype, "particle_velocity_relative_%s" % ax), particle_type=True, function=v, units="code_velocity") registry.add_field((ptype, "particle_position_relative_%s" % ax), particle_type=True, function=p, units="code_length") # this is just particle radius but we add it with an alias for the sake of # consistent naming registry.add_field( (ptype, "particle_position_spherical_radius"), function=_particle_radius, particle_type=True, units=unit_system["length"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_position_radius(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, 'particle_position_spherical_radius'] registry.add_field( (ptype, "particle_spherical_position_radius"), function=_particle_spherical_position_radius, particle_type=True, units=unit_system["length"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_position_spherical_theta(field, data): """The spherical theta coordinate of the particle positions. Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") center = data.get_field_parameter("center") pos = data.ds.arr([data[ptype, spos % ax] for ax in "xyz"]) pos = pos - np.reshape(center, (3, 1)) return data.ds.arr(get_sph_theta(pos, normal), "") registry.add_field( (ptype, "particle_position_spherical_theta"), function=_particle_position_spherical_theta, particle_type=True, units="", validators=[ValidateParameter("center"), ValidateParameter("normal")]) def _particle_spherical_position_theta(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, 'particle_position_spherical_theta'] registry.add_field( (ptype, "particle_spherical_position_theta"), function=_particle_spherical_position_theta, particle_type=True, units="", validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_position_spherical_phi(field, data): """The spherical phi component of the particle positions Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") center = data.get_field_parameter("center") pos = data.ds.arr([data[ptype, spos % ax] for ax in "xyz"]) pos = pos - np.reshape(center, (3, 1)) return data.ds.arr(get_sph_phi(pos, normal), "") registry.add_field( (ptype, "particle_position_spherical_phi"), function=_particle_position_spherical_phi, particle_type=True, units="", validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_position_phi(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, 'particle_position_spherical_phi'] registry.add_field( (ptype, "particle_spherical_position_phi"), function=_particle_spherical_position_phi, particle_type=True, units="", validators=[ValidateParameter("center"), ValidateParameter("normal")]) def _particle_velocity_spherical_radius(field, data): """The spherical radius component of the particle velocities in an arbitrary coordinate system Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') bv = data.get_field_parameter("bulk_velocity") pos = data.ds.arr([data[ptype, spos % ax] for ax in "xyz"]) vel = data.ds.arr([data[ptype, svel % ax] for ax in "xyz"]) pos = pos - np.reshape(center, (3, 1)) vel = vel - np.reshape(bv, (3, 1)) theta = get_sph_theta(pos, normal) phi = get_sph_phi(pos, normal) sphr = get_sph_r_component(vel, theta, phi, normal) return sphr registry.add_field( (ptype, "particle_velocity_spherical_radius"), function=_particle_velocity_spherical_radius, particle_type=True, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_velocity_radius(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, 'particle_velocity_spherical_radius'] registry.add_field( (ptype, "particle_spherical_velocity_radius"), function=_particle_spherical_velocity_radius, particle_type=True, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) # particel_velocity_spherical_radius is simply aliased to # "particle_radial_velocity" for convenience registry.add_field( (ptype, "particle_radial_velocity"), function=_particle_spherical_velocity_radius, particle_type=True, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_velocity_spherical_theta(field, data): """The spherical theta component of the particle velocities in an arbitrary coordinate system Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') bv = data.get_field_parameter("bulk_velocity") pos = data.ds.arr([data[ptype, spos % ax] for ax in "xyz"]) vel = data.ds.arr([data[ptype, svel % ax] for ax in "xyz"]) pos = pos - np.reshape(center, (3, 1)) vel = vel - np.reshape(bv, (3, 1)) theta = get_sph_theta(pos, normal) phi = get_sph_phi(pos, normal) spht = get_sph_theta_component(vel, theta, phi, normal) return spht registry.add_field( (ptype, "particle_velocity_spherical_theta"), function=_particle_velocity_spherical_theta, particle_type=True, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_velocity_theta(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, 'particle_velocity_spherical_theta'] registry.add_field( (ptype, "particle_spherical_velocity_theta"), function=_particle_spherical_velocity_theta, particle_type=True, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_velocity_spherical_phi(field, data): """The spherical phi component of the particle velocities Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') bv = data.get_field_parameter("bulk_velocity") pos = data.ds.arr([data[ptype, spos % ax] for ax in "xyz"]) vel = data.ds.arr([data[ptype, svel % ax] for ax in "xyz"]) phi = get_sph_phi(pos, normal) pos = pos - np.reshape(center, (3, 1)) vel = vel - np.reshape(bv, (3, 1)) sphp = get_sph_phi_component(vel, phi, normal) return sphp registry.add_field( (ptype, "particle_velocity_spherical_phi"), function=_particle_velocity_spherical_phi, particle_type=True, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_spherical_velocity_phi(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, 'particle_spherical_velocity_theta'] registry.add_field( (ptype, "particle_spherical_velocity_phi"), function=_particle_spherical_velocity_phi, particle_type=True, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_position_cylindrical_radius(field, data): """The cylindrical radius component of the particle positions Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") center = data.get_field_parameter('center') pos = data.ds.arr([data[ptype, spos % ax] for ax in "xyz"]) pos = pos - np.reshape(center, (3, 1)) return data.ds.arr(get_cyl_r(pos, normal), 'code_length') registry.add_field( (ptype, "particle_position_cylindrical_radius"), function=_particle_position_cylindrical_radius, units=unit_system["length"], particle_type=True, validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_position_cylindrical_theta(field, data): """The cylindrical theta component of the particle positions Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") center = data.get_field_parameter('center') pos = data.ds.arr([data[ptype, spos % ax] for ax in "xyz"]) pos = pos - np.reshape(center, (3, 1)) return data.ds.arr(get_cyl_theta(pos, normal), "") registry.add_field( (ptype, "particle_position_cylindrical_theta"), function=_particle_position_cylindrical_theta, particle_type=True, units="", validators=[ValidateParameter("center"), ValidateParameter("normal")]) def _particle_position_cylindrical_z(field, data): """The cylindrical z component of the particle positions Relative to the coordinate system defined by the *normal* vector and *center* field parameters. """ normal = data.get_field_parameter("normal") center = data.get_field_parameter('center') pos = data.ds.arr([data[ptype, spos % ax] for ax in "xyz"]) pos = pos - np.reshape(center, (3, 1)) return data.ds.arr(get_cyl_z(pos, normal), 'code_length') registry.add_field( (ptype, "particle_position_cylindrical_z"), function=_particle_position_cylindrical_z, units=unit_system["length"], particle_type=True, validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_velocity_cylindrical_radius(field, data): """The cylindrical radius component of the particle velocities Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') bv = data.get_field_parameter("bulk_velocity") pos = data.ds.arr([data[ptype, spos % ax] for ax in "xyz"]) vel = data.ds.arr([data[ptype, svel % ax] for ax in "xyz"]) pos = pos - np.reshape(center, (3, 1)) vel = vel - np.reshape(bv, (3, 1)) theta = get_cyl_theta(pos, normal) cylr = get_cyl_r_component(vel, theta, normal) return cylr registry.add_field( (ptype, "particle_velocity_cylindrical_radius"), function=_particle_velocity_cylindrical_radius, particle_type=True, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_velocity_cylindrical_theta(field, data): """The cylindrical theta component of the particle velocities Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') bv = data.get_field_parameter("bulk_velocity") pos = data.ds.arr([data[ptype, spos % ax] for ax in "xyz"]) vel = data.ds.arr([data[ptype, svel % ax] for ax in "xyz"]) pos = pos - np.reshape(center, (3, 1)) vel = vel - np.reshape(bv, (3, 1)) theta = get_cyl_theta(pos, normal) cylt = get_cyl_theta_component(vel, theta, normal) return cylt registry.add_field( (ptype, "particle_velocity_cylindrical_theta"), function=_particle_velocity_cylindrical_theta, particle_type=True, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_cylindrical_velocity_theta(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, 'particle_velocity_cylindrical_theta'] registry.add_field( (ptype, "particle_cylindrical_velocity_theta"), function=_particle_cylindrical_velocity_theta, particle_type=True, units="cm/s", validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_velocity_cylindrical_z(field, data): """The cylindrical z component of the particle velocities Relative to the coordinate system defined by the *normal* vector, *bulk_velocity* vector and *center* field parameters. """ normal = data.get_field_parameter('normal') center = data.get_field_parameter('center') bv = data.get_field_parameter("bulk_velocity") pos = data.ds.arr([data[ptype, spos % ax] for ax in "xyz"]) vel = data.ds.arr([data[ptype, svel % ax] for ax in "xyz"]) pos = pos - np.reshape(center, (3, 1)) vel = vel - np.reshape(bv, (3, 1)) cylz = get_cyl_z_component(vel, normal) return cylz registry.add_field( (ptype, "particle_velocity_cylindrical_z"), function=_particle_velocity_cylindrical_z, particle_type=True, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")]) def _particle_cylindrical_velocity_z(field, data): """This field is deprecated and will be removed in a future release""" return data[ptype, "particle_velocity_cylindrical_z"] registry.add_field( (ptype, "particle_cylindrical_velocity_z"), function=_particle_cylindrical_velocity_z, particle_type=True, units=unit_system["velocity"], validators=[ValidateParameter("normal"), ValidateParameter("center")])
mass = data[('particle_mass')].in_units('Msun') age = np.array(data[('age')].in_units('Myr')) tdyn = np.array(data[('dynamical_time')].in_units('Myr')) T = (age) / tdyn T[np.where(T > 100)] = 100 f = (1 - fej * (1 - (1 + T) * np.exp(-T))) mass = mass / f return mass yt.add_field("Disk_H", function=_Disk_H, units="pc", take_log=False, validators=[ValidateParameter('center')]) yt.add_field("Disk_Radius", function=_Disk_Radius, units="cm", take_log=False, validators=[ValidateParameter('center')]) yt.add_field(("gas", "vz_squared"), function=_vz_squared, units="km**2/s**2") yt.add_field(("gas", "vz"), function=_vz, units="km/s") yt.add_field("sound_speed", function=_sound_speed, units=r"km/s") yt.add_field("sound_speed_rep", function=_sound_speed_rep, units=r"s/km") yt.add_field("sound_speed_2", function=_sound_speed_2, units=r"km**2/s**2") yt.add_field("sound_speed_rep_2", function=_sound_speed_rep_2, units=r"s**2/km**2") yt.add_field(("gas", "px"), function=_px, units="g/s/cm**2") yt.add_field(("gas", "py"), function=_py, units="g/s/cm**2")