def setup_particle_mass_field(self, ptype): name = "particle_mass" if ptype in self.ds.particle_unions: add_union_field(self, ptype, name, "code_mass") return constants = nested_dict_get(self.ds.parameters, ("Particle", ptype, "constants"), default=[]) if not constants: names = [] else: if not isinstance(constants[0], tuple): constants = (constants, ) names = [c[0] for c in constants] if "mass" in names: val = constants[names.index("mass")][2] val = self.ds.quan(val, self.ds.mass_unit) if self.ds.cosmological_simulation: val = val / self.ds.domain_dimensions.prod() def _pmass(field, data): return val * data[ptype, "particle_ones"] self.add_field( (ptype, name), function=_pmass, units="code_mass", sampling_type="particle", )
def test_nested_dict_get(): rs = np.random.RandomState(47988) keys = [] my_dict = None for _ in range(5): k = str(rs.randint(0, high=1000000)) if my_dict is None: v = str(rs.randint(0, high=1000000)) keys.append(v) my_dict = {k: v} else: my_dict = {k: my_dict} keys.append(k) keys.reverse() assert nested_dict_get(my_dict, keys[:-1]) == keys[-1] my_def = "devron" assert nested_dict_get(my_dict, "system", default=my_def) == my_def
def _set_code_unit_attributes(self): if self.cosmological_simulation: box_size = self.parameters["Physics"]["cosmology"][ "comoving_box_size"] k = cosmology_get_units( self.hubble_constant, self.omega_matter, box_size, self.parameters["Physics"]["cosmology"]["initial_redshift"], self.current_redshift, ) # Now some CGS values setdefaultattr(self, "length_unit", self.quan(box_size, "Mpccm/h")) setdefaultattr( self, "mass_unit", self.quan(k["urho"], "g/cm**3") * (self.length_unit.in_cgs())**3, ) setdefaultattr(self, "velocity_unit", self.quan(k["uvel"], "cm/s")) else: p = self.parameters for d, u in zip(("length", "time"), ("cm", "s")): val = nested_dict_get(p, ("Units", d), default=1) setdefaultattr(self, f"{d}_unit", self.quan(val, u)) mass = nested_dict_get(p, ("Units", "mass")) if mass is None: density = nested_dict_get(p, ("Units", "density")) if density is not None: mass = density * self.length_unit**3 else: mass = 1 setdefaultattr(self, "mass_unit", self.quan(mass, "g")) setdefaultattr(self, "velocity_unit", self.length_unit / self.time_unit) magnetic_unit = np.sqrt(4 * np.pi * self.mass_unit / (self.time_unit**2 * self.length_unit)) magnetic_unit = np.float64(magnetic_unit.in_cgs()) setdefaultattr(self, "magnetic_unit", self.quan(magnetic_unit, "gauss"))
def setup_particle_mass_field(self, ptype): fname = "particle_mass" if ptype in self.ds.particle_unions: add_union_field(self, ptype, fname, "code_mass") return pdict = self.ds.parameters.get("Particle", None) if pdict is None: return constants = nested_dict_get(pdict, (ptype, "constants"), default=()) if not constants: return # constants should be a tuple consisting of multiple tuples of (name, type, value). # When there is only one entry, the enclosing tuple gets stripped, so we put it back. if not isinstance(constants[0], tuple): constants = (constants,) names = [c[0] for c in constants] if "mass" not in names: return val = constants[names.index("mass")][2] * self.ds.mass_unit if not self.ds.index.io._particle_mass_is_mass: val = val * get_particle_mass_correction(self.ds) def _pmass(field, data): return val * data[ptype, "particle_ones"] self.add_field( (ptype, fname), function=_pmass, units="code_mass", sampling_type="particle", )
def uses_dual_energy_formalism(self): for name in ["ppm", "mhd_vlct"]: param = nested_dict_get(self.ds.parameters, ("Method", name), None) if (param is not None) and param.get("dual_energy", False): return True return False
def test_nested_dict_get_real_none(): my_dict = {"a": None} response = nested_dict_get(my_dict, "a", default="fail") assert response is None
def _parse_parameter_file(self): """ Parses the parameter file and establishes the various dictionaries. """ f = open(self.parameter_filename) # get dimension from first block name b0, fn0 = f.readline().strip().split() level0, left0, right0 = get_block_info(b0, min_dim=0) root_blocks = get_root_blocks(b0) f.close() self.dimensionality = left0.size self._periodicity = tuple(np.ones(self.dimensionality, dtype=bool)) lcfn = self.parameter_filename[:-len(self._suffix)] + ".libconfig" if os.path.exists(lcfn): with open(lcfn) as lf: self.parameters = libconf.load(lf) cosmo = nested_dict_get(self.parameters, ("Physics", "cosmology")) if cosmo is not None: self.cosmological_simulation = 1 co_pars = [ "hubble_constant_now", "omega_matter_now", "omega_lambda_now", "comoving_box_size", "initial_redshift", ] co_dict = { attr: nested_dict_get(self.parameters, ("Physics", "cosmology", attr)) for attr in co_pars } for attr in [ "hubble_constant", "omega_matter", "omega_lambda" ]: setattr(self, attr, co_dict[f"{attr}_now"]) # Current redshift is not stored, so it's not possible # to set all cosmological units yet. # Get the time units and use that to figure out redshift. k = cosmology_get_units( self.hubble_constant, self.omega_matter, co_dict["comoving_box_size"], co_dict["initial_redshift"], 0, ) setdefaultattr(self, "time_unit", self.quan(k["utim"], "s")) co = Cosmology( hubble_constant=self.hubble_constant, omega_matter=self.omega_matter, omega_lambda=self.omega_lambda, ) else: self.cosmological_simulation = 0 else: self.cosmological_simulation = 0 fh = h5py.File(os.path.join(self.directory, fn0), "r") self.domain_left_edge = fh.attrs["lower"] self.domain_right_edge = fh.attrs["upper"] # all blocks are the same size ablock = fh[list(fh.keys())[0]] self.current_time = ablock.attrs["time"][0] self.parameters["current_cycle"] = ablock.attrs["cycle"][0] gsi = ablock.attrs["enzo_GridStartIndex"] gei = ablock.attrs["enzo_GridEndIndex"] self.ghost_zones = gsi[0] self.root_block_dimensions = root_blocks self.active_grid_dimensions = gei - gsi + 1 self.grid_dimensions = ablock.attrs["enzo_GridDimension"] self.domain_dimensions = root_blocks * self.active_grid_dimensions fh.close() if self.cosmological_simulation: self.current_redshift = co.z_from_t(self.current_time * self.time_unit) self._periodicity += (False, ) * (3 - self.dimensionality) self.gamma = nested_dict_get(self.parameters, ("Field", "gamma"))