def _vorticity_y(field, data): f = (data[ftype, "velocity_x"][sl_center,sl_center,sl_right] - data[ftype, "velocity_x"][sl_center,sl_center,sl_left]) \ / (div_fac*just_one(data["index", "dz"])) f -= (data[ftype, "velocity_z"][sl_right,sl_center,sl_center] - data[ftype, "velocity_z"][sl_left,sl_center,sl_center]) \ / (div_fac*just_one(data["index", "dx"])) new_field = data.ds.arr(np.zeros_like(data[ftype, "velocity_z"], dtype=np.float64), f.units) new_field[sl_center, sl_center, sl_center] = f return new_field
def _divergence(field, data): ds = div_fac * just_one(data["index", "dx"]) f = data[xn][sl_right,1:-1,1:-1]/ds f -= data[xn][sl_left ,1:-1,1:-1]/ds ds = div_fac * just_one(data["index", "dy"]) f += data[yn][1:-1,sl_right,1:-1]/ds f -= data[yn][1:-1,sl_left ,1:-1]/ds ds = div_fac * just_one(data["index", "dz"]) f += data[zn][1:-1,1:-1,sl_right]/ds f -= data[zn][1:-1,1:-1,sl_left ]/ds new_field = data.ds.arr(np.zeros(data[xn].shape, dtype=np.float64), f.units) new_field[1:-1,1:-1,1:-1] = f return new_field
def _store_fields(self, storage_object, field_data, **kwargs): root_only = kwargs.get("root_only", True) if not field_data: return root_field_data = dict([(field, just_one(field_data[field])) for field in field_data]) if not root_only: storage_object._tree_field_data.update(field_data) storage_object._root_field_data.update(root_field_data)
def test_just_one(): # Check that behaviour of this function is consistent before and after refactor # PR 2893 for unit in ["mm", "cm", "km", "pc", "g", "kg", "M_sun"]: obj = YTArray([0.0, 1.0], unit) expected = YTQuantity(obj.flat[0], obj.units, registry=obj.units.registry) jo = just_one(obj) assert jo == expected
def _set_code_unit_attributes(self): """ Generates the conversion to various physical _units based on the parameter file """ # This should be improved. h5f = h5py.File(self.parameter_filename, "r") for field_name in h5f["/field_types"]: current_field = h5f["/field_types/%s" % field_name] if 'field_to_cgs' in current_field.attrs: field_conv = current_field.attrs['field_to_cgs'] self.field_units[field_name] = just_one(field_conv) elif 'field_units' in current_field.attrs: field_units = current_field.attrs['field_units'] if isinstance(field_units, str): current_field_units = current_field.attrs['field_units'] else: current_field_units = \ just_one(current_field.attrs['field_units']) self.field_units[field_name] = current_field_units else: self.field_units[field_name] = "" if "dataset_units" in h5f: for unit_name in h5f["/dataset_units"]: current_unit = h5f["/dataset_units/%s" % unit_name] value = current_unit.value unit = current_unit.attrs["unit"] setattr(self, unit_name, self.quan(value, unit)) if unit_name in h5f["/field_types"]: if unit_name in self.field_units: mylog.warning( "'field_units' was overridden by 'dataset_units/%s'" % (unit_name)) self.field_units[unit_name] = unit else: self.length_unit = self.quan(1.0, "cm") self.mass_unit = self.quan(1.0, "g") self.time_unit = self.quan(1.0, "s") h5f.close()
def _averaged_field(field, data): nx, ny, nz = data[(ftype, basename)].shape new_field = data.ds.arr(np.zeros((nx-2, ny-2, nz-2), dtype=np.float64), (just_one(data[(ftype, basename)]) * just_one(data[(ftype, weight)])).units) weight_field = data.ds.arr(np.zeros((nx-2, ny-2, nz-2), dtype=np.float64), data[(ftype, weight)].units) i_i, j_i, k_i = np.mgrid[0:3, 0:3, 0:3] for i, j, k in zip(i_i.ravel(), j_i.ravel(), k_i.ravel()): sl = (slice(i, nx-(2-i)), slice(j, ny-(2-j)), slice(k, nz-(2-k))) new_field += data[(ftype, basename)][sl] * data[(ftype, weight)][sl] weight_field += data[(ftype, weight)][sl] # Now some fancy footwork new_field2 = data.ds.arr(np.zeros((nx, ny, nz)), data[(ftype, basename)].units) new_field2[1:-1, 1:-1, 1:-1] = new_field / weight_field return new_field2
def _averaged_field(field, data): nx, ny, nz = data[(ftype, basename)].shape new_field = data.ds.arr(np.zeros((nx-2, ny-2, nz-2), dtype=np.float64), (just_one(data[(ftype, basename)]) * just_one(data[(ftype, weight)])).units) weight_field = data.ds.arr(np.zeros((nx-2, ny-2, nz-2), dtype=np.float64), data[(ftype, weight)].units) i_i, j_i, k_i = np.mgrid[0:3, 0:3, 0:3] for i, j, k in zip(i_i.ravel(), j_i.ravel(), k_i.ravel()): sl = [slice(i, nx-(2-i)), slice(j, ny-(2-j)), slice(k, nz-(2-k))] new_field += data[(ftype, basename)][sl] * data[(ftype, weight)][sl] weight_field += data[(ftype, weight)][sl] # Now some fancy footwork new_field2 = data.ds.arr(np.zeros((nx, ny, nz)), data[(ftype, basename)].units) new_field2[1:-1, 1:-1, 1:-1] = new_field / weight_field return new_field2
def _set_code_unit_attributes(self): """ Generates the conversion to various physical _units based on the parameter file """ # This should be improved. h5f = h5py.File(self.parameter_filename, "r") for field_name in h5f["/field_types"]: current_field = h5f["/field_types/%s" % field_name] if 'field_to_cgs' in current_field.attrs: field_conv = current_field.attrs['field_to_cgs'] self.field_units[field_name] = just_one(field_conv) elif 'field_units' in current_field.attrs: field_units = current_field.attrs['field_units'] if isinstance(field_units, str): current_field_units = current_field.attrs['field_units'] else: current_field_units = \ just_one(current_field.attrs['field_units']) self.field_units[field_name] = current_field_units else: self.field_units[field_name] = "" if "dataset_units" in h5f: for unit_name in h5f["/dataset_units"]: current_unit = h5f["/dataset_units/%s" % unit_name] value = current_unit.value unit = current_unit.attrs["unit"] setattr(self, unit_name, self.quan(value, unit)) if unit_name in h5f["/field_types"]: if unit_name in self.field_units: mylog.warning("'field_units' was overridden by 'dataset_units/%s'" % (unit_name)) self.field_units[unit_name] = unit else: self.length_unit = self.quan(1.0, "cm") self.mass_unit = self.quan(1.0, "g") self.time_unit = self.quan(1.0, "s") h5f.close()
def _averaged_field(field, data): def atleast_4d(array): if array.ndim == 3: return array[..., None] else: return array nx, ny, nz, ngrids = atleast_4d(data[(ftype, basename)]).shape new_field = data.ds.arr( np.zeros((nx - 2, ny - 2, nz - 2, ngrids), dtype=np.float64), (just_one(data[(ftype, basename)]) * just_one(data[(ftype, weight)])).units, ) weight_field = data.ds.arr( np.zeros((nx - 2, ny - 2, nz - 2, ngrids), dtype=np.float64), data[(ftype, weight)].units, ) i_i, j_i, k_i = np.mgrid[0:3, 0:3, 0:3] for i, j, k in zip(i_i.ravel(), j_i.ravel(), k_i.ravel()): sl = ( slice(i, nx - (2 - i)), slice(j, ny - (2 - j)), slice(k, nz - (2 - k)), ) new_field += ( atleast_4d(data[(ftype, basename)])[sl] * atleast_4d(data[(ftype, weight)])[sl] ) weight_field += atleast_4d(data[(ftype, weight)])[sl] # Now some fancy footwork new_field2 = data.ds.arr( np.zeros((nx, ny, nz, ngrids)), data[(ftype, basename)].units ) new_field2[1:-1, 1:-1, 1:-1] = new_field / weight_field if data[(ftype, basename)].ndim == 3: return new_field2[..., 0] else: return new_field2
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.geometry != "cartesian": raise NotImplementedError( "shear is only supported in cartesian geometries") try: vx = data[ftype, "relative_velocity_x"] vy = data[ftype, "relative_velocity_y"] except YTFieldNotFound as e: raise YTDimensionalityError( "shear computation requires 2 velocity components") from e 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 try: 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 except YTFieldNotFound: # the absence of a z velocity component is not blocking pass 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
def _parse_parameter_file(self): self._handle = h5py.File(self.parameter_filename, mode="r") if "data_software" in self._handle["gridded_data_format"].attrs: self.data_software = self._handle["gridded_data_format"].attrs[ "data_software" ] else: self.data_software = "unknown" sp = self._handle["/simulation_parameters"].attrs if self.geometry is None: geometry = just_one(sp.get("geometry", 0)) try: self.geometry = GEOMETRY_TRANS[geometry] except KeyError as e: raise YTGDFUnknownGeometry(geometry) from e self.parameters.update(sp) self.domain_left_edge = sp["domain_left_edge"][:] self.domain_right_edge = sp["domain_right_edge"][:] self.domain_dimensions = sp["domain_dimensions"][:] refine_by = sp["refine_by"] if refine_by is None: refine_by = 2 self.refine_by = refine_by self.dimensionality = sp["dimensionality"] self.current_time = sp["current_time"] self.unique_identifier = sp["unique_identifier"] self.cosmological_simulation = sp["cosmological_simulation"] if sp["num_ghost_zones"] != 0: raise RuntimeError self.num_ghost_zones = sp["num_ghost_zones"] self.field_ordering = sp["field_ordering"] self.boundary_conditions = sp["boundary_conditions"][:] self._periodicity = tuple(bnd == 0 for bnd in self.boundary_conditions[::2]) if self.cosmological_simulation: self.current_redshift = sp["current_redshift"] self.omega_lambda = sp["omega_lambda"] self.omega_matter = sp["omega_matter"] self.hubble_constant = sp["hubble_constant"] else: self.current_redshift = 0.0 self.omega_lambda = 0.0 self.omega_matter = 0.0 self.hubble_constant = 0.0 self.cosmological_simulation = 0 self.parameters["Time"] = 1.0 # Hardcode time conversion for now. # Hardcode for now until field staggering is supported. self.parameters["HydroMethod"] = 0 self._handle.close() del self._handle
def _parse_parameter_file(self): self._handle = h5py.File(self.parameter_filename, "r") if 'data_software' in self._handle['gridded_data_format'].attrs: self.data_software = \ self._handle['gridded_data_format'].attrs['data_software'] else: self.data_software = "unknown" sp = self._handle["/simulation_parameters"].attrs if self.geometry is None: geometry = just_one(sp.get("geometry", 0)) try: self.geometry = GEOMETRY_TRANS[geometry] except KeyError: raise YTGDFUnknownGeometry(geometry) self.parameters.update(sp) self.domain_left_edge = sp["domain_left_edge"][:] self.domain_right_edge = sp["domain_right_edge"][:] self.domain_dimensions = sp["domain_dimensions"][:] refine_by = sp["refine_by"] if refine_by is None: refine_by = 2 self.refine_by = refine_by self.dimensionality = sp["dimensionality"] self.current_time = sp["current_time"] self.unique_identifier = sp["unique_identifier"] self.cosmological_simulation = sp["cosmological_simulation"] if sp["num_ghost_zones"] != 0: raise RuntimeError self.num_ghost_zones = sp["num_ghost_zones"] self.field_ordering = sp["field_ordering"] self.boundary_conditions = sp["boundary_conditions"][:] p = [bnd == 0 for bnd in self.boundary_conditions[::2]] self.periodicity = ensure_tuple(p) if self.cosmological_simulation: self.current_redshift = sp["current_redshift"] self.omega_lambda = sp["omega_lambda"] self.omega_matter = sp["omega_matter"] self.hubble_constant = sp["hubble_constant"] else: self.current_redshift = self.omega_lambda = self.omega_matter = \ self.hubble_constant = self.cosmological_simulation = 0.0 self.parameters['Time'] = 1.0 # Hardcode time conversion for now. # Hardcode for now until field staggering is supported. self.parameters["HydroMethod"] = 0 self._handle.close() del self._handle
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
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: dvydx = (data[ftype, "velocity_y"][sl_right,sl_center,sl_center] - data[ftype, "velocity_y"][sl_left,sl_center,sl_center]) \ / (div_fac*just_one(data["index", "dx"])) dvxdy = (data[ftype, "velocity_x"][sl_center,sl_right,sl_center] - data[ftype, "velocity_x"][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: dvzdy = (data[ftype, "velocity_z"][sl_center,sl_right,sl_center] - data[ftype, "velocity_z"][sl_center,sl_left,sl_center]) \ / (div_fac*just_one(data["index", "dy"])) dvydz = (data[ftype, "velocity_y"][sl_center,sl_center,sl_right] - data[ftype, "velocity_y"][sl_center,sl_center,sl_left]) \ / (div_fac*just_one(data["index", "dz"])) f += (dvzdy + dvydz)**2.0 del dvzdy, dvydz dvxdz = (data[ftype, "velocity_x"][sl_center,sl_center,sl_right] - data[ftype, "velocity_x"][sl_center,sl_center,sl_left]) \ / (div_fac*just_one(data["index", "dz"])) dvzdx = (data[ftype, "velocity_z"][sl_right,sl_center,sl_center] - data[ftype, "velocity_z"][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