def test_cgs_equivalent(): """ Check cgs equivalent of a unit. """ Msun_cgs = mass_sun_grams Mpc_cgs = cm_per_mpc u1 = Unit("Msun * Mpc**-3") u2 = Unit("g * cm**-3") u3 = u1.get_cgs_equivalent() yield assert_true, u2.expr == u3.expr yield assert_true, u2 == u3 yield assert_allclose, u1.cgs_value, Msun_cgs / Mpc_cgs**3, 1e-12 yield assert_true, u2.cgs_value == 1 yield assert_true, u3.cgs_value == 1 mass_density = mass / length**3 yield assert_true, u1.dimensions == mass_density yield assert_true, u2.dimensions == mass_density yield assert_true, u3.dimensions == mass_density yield assert_allclose, get_conversion_factor(u1, u3)[0], \ Msun_cgs / Mpc_cgs**3, 1e-12
def setup_particle_fields(self, ptype, ftype='gas', num_neighbors=64 ): skip_output_units = ("code_length",) for f, (units, aliases, dn) in sorted(self.known_particle_fields): units = self.ds.field_units.get((ptype, f), units) if (f in aliases or ptype not in self.ds.particle_types_raw) and \ units not in skip_output_units: u = Unit(units, registry = self.ds.unit_registry) output_units = str(u.get_cgs_equivalent()) else: output_units = units if (ptype, f) not in self.field_list: continue self.add_output_field((ptype, f), units = units, particle_type = True, display_name = dn, output_units = output_units) for alias in aliases: self.alias((ptype, alias), (ptype, f), units = output_units) # We'll either have particle_position or particle_position_[xyz] if (ptype, "particle_position") in self.field_list or \ (ptype, "particle_position") in self.field_aliases: particle_scalar_functions(ptype, "particle_position", "particle_velocity", self) else: # We need to check to make sure that there's a "known field" that # overlaps with one of the vector fields. For instance, if we are # in the Stream frontend, and we have a set of scalar position # fields, they will overlap with -- and be overridden by -- the # "known" vector field that the frontend creates. So the easiest # thing to do is to simply remove the on-disk field (which doesn't # exist) and replace it with a derived field. if (ptype, "particle_position") in self and \ self[ptype, "particle_position"]._function == NullFunc: self.pop((ptype, "particle_position")) particle_vector_functions(ptype, ["particle_position_%s" % ax for ax in 'xyz'], ["particle_velocity_%s" % ax for ax in 'xyz'], self) particle_deposition_functions(ptype, "particle_position", "particle_mass", self) standard_particle_fields(self, ptype) # Now we check for any leftover particle fields for field in sorted(self.field_list): if field in self: continue if not isinstance(field, tuple): raise RuntimeError if field[0] not in self.ds.particle_types: continue self.add_output_field(field, units = self.ds.field_units.get(field, ""), particle_type = True) self.setup_smoothed_fields(ptype, num_neighbors=num_neighbors, ftype=ftype)
def setup_particle_fields(self, ptype, ftype='gas', num_neighbors=64): skip_output_units = () for f, (units, aliases, dn) in sorted(self.known_particle_fields): units = self.ds.field_units.get((ptype, f), units) if (f in aliases or ptype not in self.ds.particle_types_raw) and \ units not in skip_output_units: u = Unit(units, registry=self.ds.unit_registry) output_units = str(u.get_cgs_equivalent()) else: output_units = units if (ptype, f) not in self.field_list: continue self.add_output_field((ptype, f), units=units, particle_type=True, display_name=dn, output_units=output_units, take_log=False) for alias in aliases: self.alias((ptype, alias), (ptype, f), units=output_units) # We'll either have particle_position or particle_position_[xyz] if (ptype, "particle_position") in self.field_list or \ (ptype, "particle_position") in self.field_aliases: particle_scalar_functions(ptype, "particle_position", "particle_velocity", self) else: # We need to check to make sure that there's a "known field" that # overlaps with one of the vector fields. For instance, if we are # in the Stream frontend, and we have a set of scalar position # fields, they will overlap with -- and be overridden by -- the # "known" vector field that the frontend creates. So the easiest # thing to do is to simply remove the on-disk field (which doesn't # exist) and replace it with a derived field. if (ptype, "particle_position") in self and \ self[ptype, "particle_position"]._function == NullFunc: self.pop((ptype, "particle_position")) particle_vector_functions( ptype, ["particle_position_%s" % ax for ax in 'xyz'], ["particle_velocity_%s" % ax for ax in 'xyz'], self) particle_deposition_functions(ptype, "particle_position", "particle_mass", self) standard_particle_fields(self, ptype) # Now we check for any leftover particle fields for field in sorted(self.field_list): if field in self: continue if not isinstance(field, tuple): raise RuntimeError if field[0] not in self.ds.particle_types: continue self.add_output_field(field, units=self.ds.field_units.get(field, ""), particle_type=True) self.setup_smoothed_fields(ptype, num_neighbors=num_neighbors, ftype=ftype)
def alias(self, alias_name, original_name, units=None): if original_name not in self: return if units is None: # We default to CGS here, but in principle, this can be pluggable # as well. u = Unit(self[original_name].units, registry=self.ds.unit_registry) units = str(u.get_cgs_equivalent()) self.field_aliases[alias_name] = original_name self.add_field(alias_name, function=TranslationFunc(original_name), particle_type=self[original_name].particle_type, display_name=self[original_name].display_name, units=units)
def alias(self, alias_name, original_name, units = None): if original_name not in self: return if units is None: # We default to CGS here, but in principle, this can be pluggable # as well. u = Unit(self[original_name].units, registry = self.ds.unit_registry) units = str(u.get_cgs_equivalent()) self.field_aliases[alias_name] = original_name self.add_field(alias_name, function = TranslationFunc(original_name), particle_type = self[original_name].particle_type, display_name = self[original_name].display_name, units = units)
def setup_particle_fields(self, ptype, ftype="gas", num_neighbors=64): skip_output_units = () for f, (units, aliases, dn) in sorted(self.known_particle_fields): units = self.ds.field_units.get((ptype, f), units) if (f in aliases or ptype not in self.ds.particle_types_raw ) and units not in skip_output_units: u = Unit(units, registry=self.ds.unit_registry) output_units = str(u.get_cgs_equivalent()) else: output_units = units if (ptype, f) not in self.field_list: continue self.add_output_field( (ptype, f), sampling_type="particle", units=units, display_name=dn, output_units=output_units, take_log=False, ) for alias in aliases: self.alias((ptype, alias), (ptype, f), units=output_units) ppos_fields = [f"particle_position_{ax}" for ax in "xyz"] pvel_fields = [f"particle_velocity_{ax}" for ax in "xyz"] particle_vector_functions(ptype, ppos_fields, pvel_fields, self) particle_deposition_functions(ptype, "particle_position", "particle_mass", self) standard_particle_fields(self, ptype) # Now we check for any leftover particle fields for field in sorted(self.field_list): if field in self: continue if not isinstance(field, tuple): raise RuntimeError if field[0] not in self.ds.particle_types: continue self.add_output_field( field, sampling_type="particle", units=self.ds.field_units.get(field, ""), ) self.setup_smoothed_fields(ptype, num_neighbors=num_neighbors, ftype=ftype)