def _setup_nounits_units(self): z = 0 mylog.warning("Setting 1.0 in code units to be 1.0 cm") if not self.has_key("TimeUnits"): mylog.warning("No time units. Setting 1.0 = 1 second.") self.conversion_factors["Time"] = 1.0 for unit in mpc_conversion.keys(): self.units[unit] = mpc_conversion[unit] / mpc_conversion["cm"]
def cartesian_grid_to_yt_stream(grid, xmin, xmax, ymin, ymax, zmin, zmax, dust_id=0): nz, ny, nx = grid.shape grids = [grid.quantities] left_edge = np.array([[xmin, ymin, zmin]], dtype=np.float64) right_edge = np.array([[xmax, ymax, zmax]], dtype=np.float64) dimensions = np.array([[nx, ny, nz]], dtype=np.int32) level_ids = np.array([[0]], dtype=np.int32).reshape((1, 1)) parent_ids = None particle_count = np.zeros((1, 1), dtype='int32') processor_ids = np.zeros(1) # Determine fields fields = grid.quantities.keys() # Set up StreamHandler handler = stream.StreamHandler( left_edge[:], right_edge[:], dimensions[:], level_ids[:], parent_ids, particle_count[:], processor_ids[:], StreamFieldData(fields), HyperionIOHandler(grids, dust_id), ) handler.name = 'hyperion' handler.domain_left_edge = np.array([xmin, ymin, zmin]) handler.domain_right_edge = np.array([xmax, ymax, zmax]) handler.refine_by = 2 handler.dimensionality = 3 handler.domain_dimensions = np.array([nx, ny, nz]) handler.simulation_time = 0.0 handler.cosmology_simulation = 0 spf = stream.StreamStaticOutput(handler) spf.units["cm"] = 1.0 spf.units["unitary"] = 1.0 / ( (spf.domain_right_edge - spf.domain_left_edge).max()) spf.units['1'] = 1.0 box_in_mpc = 1.0 / mpc_conversion['cm'] for unit in mpc_conversion.keys(): spf.units[unit] = mpc_conversion[unit] * box_in_mpc return spf
def cartesian_grid_to_yt_stream(grid, xmin, xmax, ymin, ymax, zmin, zmax, dust_id=0): nz, ny, nx = grid.shape grids = [grid.quantities] left_edge = np.array([[xmin, ymin, zmin]], dtype=np.float64) right_edge = np.array([[xmax, ymax, zmax]], dtype=np.float64) dimensions = np.array([[nx, ny, nz]], dtype=np.int32) level_ids = np.array([[0]], dtype=np.int32).reshape((1, 1)) parent_ids = None particle_count = np.zeros((1, 1), dtype='int32') processor_ids = np.zeros(1) # Determine fields fields = grid.quantities.keys() # Set up StreamHandler handler = stream.StreamHandler( left_edge[:], right_edge[:], dimensions[:], level_ids[:], parent_ids, particle_count[:], processor_ids[:], StreamFieldData(fields), HyperionIOHandler(grids, dust_id), ) handler.name = 'hyperion' handler.domain_left_edge = np.array([xmin, ymin, zmin]) handler.domain_right_edge = np.array([xmax, ymax, zmax]) handler.refine_by = 2 handler.dimensionality = 3 handler.domain_dimensions = np.array([nx, ny, nz]) handler.simulation_time = 0.0 handler.cosmology_simulation = 0 spf = stream.StreamStaticOutput(handler) spf.units["cm"] = 1.0 spf.units["unitary"] = 1.0 / ((spf.domain_right_edge - spf.domain_left_edge).max()) spf.units['1'] = 1.0 box_in_mpc = 1.0 / mpc_conversion['cm'] for unit in mpc_conversion.keys(): spf.units[unit] = mpc_conversion[unit] * box_in_mpc return spf
def amr_grid_to_yt_stream(levels, dust_id=0): # Try and guess the refinement ratio - if it is not constant, then # we can't use yt if len(levels) == 0 or len(levels[0].grids) == 0: raise Exception("Need at least one level with one grid to convert to a yt object") elif len(levels) == 1: refine = 2 else: dx = [] dy = [] dz = [] for ilevel, level in enumerate(levels): for igrid, grid in enumerate(level.grids): gdx = (grid.xmax - grid.xmin) / float(grid.nx) gdy = (grid.ymax - grid.ymin) / float(grid.ny) gdz = (grid.zmax - grid.zmin) / float(grid.nz) if igrid == 0: dx.append(gdx) dy.append(gdy) dz.append(gdz) else: if not almost_equal(dx[-1], gdx): raise Exception("dx scale differs between grids in level %i (expected %g and got %g)" % (ilevel, dx[-1], gdx)) if not almost_equal(dy[-1], gdy): raise Exception("dy scale differs between grids in level %i (expected %g and got %g)" % (ilevel, dy[-1], gdy)) if not almost_equal(dz[-1], gdz): raise Exception("dz scale differs between grids in level %i (expected %g and got %g)" % (ilevel, dz[-1], gdz)) dx = np.array(dx) dy = np.array(dy) dz = np.array(dz) refine_x = dx[:-1] / dx[1:] refine_y = dy[:-1] / dy[1:] refine_z = dz[:-1] / dz[1:] for i in range(len(levels) - 1): if abs(refine_x[i] - round(refine_x[i])) > 1.e-5: raise Exception("refinement ratio is not an integer (%g)" % refine_x[i]) if abs(refine_y[i] - round(refine_y[i])) > 1.e-5: raise Exception("refinement ratio is not an integer (%g)" % refine_y[i]) if abs(refine_z[i] - round(refine_z[i])) > 1.e-5: raise Exception("refinement ratio is not an integer (%g)" % refine_z[i]) refine_x = np.round(refine_x).astype(int) refine_y = np.round(refine_y).astype(int) refine_z = np.round(refine_z).astype(int) if not np.all(np.hstack([refine_x, refine_y, refine_z]) == refine_x[0]): raise Exception("refinement ratio changes between levels and/or directions (x = %s, y = %s, z = %s)" % (str(refine_x), str(refine_y), str(refine_z))) refine = int(refine_x[0]) xmin = ymin = zmin = +np.inf xmax = ymax = zmax = -np.inf left_edge = [] right_edge = [] dimensions = [] level_ids = [] n_grids = 0 grids = [] for ilevel, level in enumerate(levels): for grid in level.grids: left_edge.append([grid.xmin, grid.ymin, grid.zmin]) right_edge.append([grid.xmax, grid.ymax, grid.zmax]) dimensions.append([grid.nx, grid.ny, grid.nz]) level_ids.append(ilevel) n_grids += 1 xmin = min(xmin, grid.xmin) xmax = max(xmax, grid.xmax) ymin = min(ymin, grid.ymin) ymax = max(ymax, grid.ymax) zmin = min(zmin, grid.zmin) zmax = max(zmax, grid.zmax) grids.append(grid.quantities) left_edge = np.array(left_edge, dtype=np.float64) right_edge = np.array(right_edge, dtype=np.float64) dimensions = np.array(dimensions, dtype=np.int32) # The reshape is necessary due to a strange Numpy bug level_ids = np.array(level_ids, dtype=np.int32).reshape((len(level_ids), 1)) parent_ids = None particle_count = np.zeros((n_grids, 1), dtype='int32') processor_ids = np.zeros(n_grids) grid = levels[0].grids[0] # Determine domain resolution dx = (grid.xmax - grid.xmin) / float(grid.nx) nx = int(round((xmax - xmin) / dx)) dy = (grid.ymax - grid.ymin) / float(grid.ny) ny = int(round((ymax - ymin) / dy)) dz = (grid.zmax - grid.zmin) / float(grid.nz) nz = int(round((zmax - zmin) / dz)) # Determine fields fields = grid.quantities.keys() # Set up StreamHandler handler = stream.StreamHandler( left_edge[:], right_edge[:], dimensions[:], level_ids[:], parent_ids, particle_count[:], processor_ids[:], StreamFieldData(fields), HyperionIOHandler(grids, dust_id), ) handler.name = 'hyperion' handler.domain_left_edge = np.array([xmin, ymin, zmin]) handler.domain_right_edge = np.array([xmax, ymax, zmax]) handler.refine_by = refine handler.dimensionality = 3 handler.domain_dimensions = np.array([nx, ny, nz]) handler.simulation_time = 0.0 handler.cosmology_simulation = 0 spf = stream.StreamStaticOutput(handler) spf.units["cm"] = 1.0 spf.units["unitary"] = 1.0 / ((spf.domain_right_edge - spf.domain_left_edge).max()) spf.units['1'] = 1.0 box_in_mpc = 1.0 / mpc_conversion['cm'] for unit in mpc_conversion.keys(): spf.units[unit] = mpc_conversion[unit] * box_in_mpc return spf
def octree_grid_to_yt_stream(grid, dust_id=0): xmin = grid.x - grid.dx xmax = grid.x + grid.dx ymin = grid.y - grid.dy ymax = grid.y + grid.dy zmin = grid.z - grid.dz zmax = grid.z + grid.dz e, i = edge_list(grid.refined, xmin, xmax, ymin, ymax, zmin, zmax) e = np.array(e) left_edge = e[:, ::2].astype(np.float64) right_edge = e[:, 1::2].astype(np.float64) dimensions = np.ones((np.sum(grid.refined), 3), dtype=np.int32) * 2 level_ids = np.array(level_list(grid.refined)[0], dtype=np.int32) level_ids = level_ids.reshape((len(level_ids), 1)) n_grids = np.sum(grid.refined) parent_ids = None particle_count = np.zeros((n_grids, 1), dtype='int32') processor_ids = np.zeros(n_grids) # Determine fields fields = grid.quantities.keys() # Set up StreamHandler quantities = {} for field in grid.quantities: quantities[field] = decompose_quantity(grid.refined, grid.quantities[field][dust_id])[0] handler = stream.StreamHandler( left_edge[:], right_edge[:], dimensions[:], level_ids[:], parent_ids, particle_count[:], processor_ids[:], StreamFieldData(fields), HyperionIOHandlerOct(quantities), ) handler.name = 'hyperion' handler.domain_left_edge = np.array([xmin, ymin, zmin]) handler.domain_right_edge = np.array([xmax, ymax, zmax]) handler.refine_by = 2 handler.dimensionality = 3 handler.domain_dimensions = np.array([2, 2, 2]) handler.simulation_time = 0.0 handler.cosmology_simulation = 0 spf = stream.StreamStaticOutput(handler) spf.units["cm"] = 1.0 spf.units["unitary"] = 1.0 / ((spf.domain_right_edge - spf.domain_left_edge).max()) spf.units['1'] = 1.0 box_in_mpc = 1.0 / mpc_conversion['cm'] for unit in mpc_conversion.keys(): spf.units[unit] = mpc_conversion[unit] * box_in_mpc return spf
def amr_grid_to_yt_stream(levels, dust_id=0): # Try and guess the refinement ratio - if it is not constant, then # we can't use yt if len(levels) == 0 or len(levels[0].grids) == 0: raise Exception( "Need at least one level with one grid to convert to a yt object") elif len(levels) == 1: refine = 2 else: dx = [] dy = [] dz = [] for ilevel, level in enumerate(levels): for igrid, grid in enumerate(level.grids): gdx = (grid.xmax - grid.xmin) / float(grid.nx) gdy = (grid.ymax - grid.ymin) / float(grid.ny) gdz = (grid.zmax - grid.zmin) / float(grid.nz) if igrid == 0: dx.append(gdx) dy.append(gdy) dz.append(gdz) else: if not almost_equal(dx[-1], gdx): raise Exception( "dx scale differs between grids in level %i (expected %g and got %g)" % (ilevel, dx[-1], gdx)) if not almost_equal(dy[-1], gdy): raise Exception( "dy scale differs between grids in level %i (expected %g and got %g)" % (ilevel, dy[-1], gdy)) if not almost_equal(dz[-1], gdz): raise Exception( "dz scale differs between grids in level %i (expected %g and got %g)" % (ilevel, dz[-1], gdz)) dx = np.array(dx) dy = np.array(dy) dz = np.array(dz) refine_x = dx[:-1] / dx[1:] refine_y = dy[:-1] / dy[1:] refine_z = dz[:-1] / dz[1:] for i in range(len(levels) - 1): if abs(refine_x[i] - round(refine_x[i])) > 1.e-5: raise Exception("refinement ratio is not an integer (%g)" % refine_x[i]) if abs(refine_y[i] - round(refine_y[i])) > 1.e-5: raise Exception("refinement ratio is not an integer (%g)" % refine_y[i]) if abs(refine_z[i] - round(refine_z[i])) > 1.e-5: raise Exception("refinement ratio is not an integer (%g)" % refine_z[i]) refine_x = np.round(refine_x).astype(int) refine_y = np.round(refine_y).astype(int) refine_z = np.round(refine_z).astype(int) if not np.all( np.hstack([refine_x, refine_y, refine_z]) == refine_x[0]): raise Exception( "refinement ratio changes between levels and/or directions (x = %s, y = %s, z = %s)" % (str(refine_x), str(refine_y), str(refine_z))) refine = int(refine_x[0]) xmin = ymin = zmin = +np.inf xmax = ymax = zmax = -np.inf left_edge = [] right_edge = [] dimensions = [] level_ids = [] n_grids = 0 grids = [] for ilevel, level in enumerate(levels): for grid in level.grids: left_edge.append([grid.xmin, grid.ymin, grid.zmin]) right_edge.append([grid.xmax, grid.ymax, grid.zmax]) dimensions.append([grid.nx, grid.ny, grid.nz]) level_ids.append(ilevel) n_grids += 1 xmin = min(xmin, grid.xmin) xmax = max(xmax, grid.xmax) ymin = min(ymin, grid.ymin) ymax = max(ymax, grid.ymax) zmin = min(zmin, grid.zmin) zmax = max(zmax, grid.zmax) grids.append(grid.quantities) left_edge = np.array(left_edge, dtype=np.float64) right_edge = np.array(right_edge, dtype=np.float64) dimensions = np.array(dimensions, dtype=np.int32) # The reshape is necessary due to a strange Numpy bug level_ids = np.array(level_ids, dtype=np.int32).reshape( (len(level_ids), 1)) parent_ids = None particle_count = np.zeros((n_grids, 1), dtype='int32') processor_ids = np.zeros(n_grids) grid = levels[0].grids[0] # Determine domain resolution dx = (grid.xmax - grid.xmin) / float(grid.nx) nx = int(round((xmax - xmin) / dx)) dy = (grid.ymax - grid.ymin) / float(grid.ny) ny = int(round((ymax - ymin) / dy)) dz = (grid.zmax - grid.zmin) / float(grid.nz) nz = int(round((zmax - zmin) / dz)) # Determine fields fields = grid.quantities.keys() # Set up StreamHandler handler = stream.StreamHandler( left_edge[:], right_edge[:], dimensions[:], level_ids[:], parent_ids, particle_count[:], processor_ids[:], StreamFieldData(fields), HyperionIOHandler(grids, dust_id), ) handler.name = 'hyperion' handler.domain_left_edge = np.array([xmin, ymin, zmin]) handler.domain_right_edge = np.array([xmax, ymax, zmax]) handler.refine_by = refine handler.dimensionality = 3 handler.domain_dimensions = np.array([nx, ny, nz]) handler.simulation_time = 0.0 handler.cosmology_simulation = 0 spf = stream.StreamStaticOutput(handler) spf.units["cm"] = 1.0 spf.units["unitary"] = 1.0 / ( (spf.domain_right_edge - spf.domain_left_edge).max()) spf.units['1'] = 1.0 box_in_mpc = 1.0 / mpc_conversion['cm'] for unit in mpc_conversion.keys(): spf.units[unit] = mpc_conversion[unit] * box_in_mpc return spf
def octree_grid_to_yt_stream(grid, dust_id=0): xmin = grid.x - grid.dx xmax = grid.x + grid.dx ymin = grid.y - grid.dy ymax = grid.y + grid.dy zmin = grid.z - grid.dz zmax = grid.z + grid.dz e, i = edge_list(grid.refined, xmin, xmax, ymin, ymax, zmin, zmax) e = np.array(e) left_edge = e[:, ::2].astype(np.float64) right_edge = e[:, 1::2].astype(np.float64) dimensions = np.ones((np.sum(grid.refined), 3), dtype=np.int32) * 2 level_ids = np.array(level_list(grid.refined)[0], dtype=np.int32) level_ids = level_ids.reshape((len(level_ids), 1)) n_grids = np.sum(grid.refined) parent_ids = None particle_count = np.zeros((n_grids, 1), dtype='int32') processor_ids = np.zeros(n_grids) # Determine fields fields = grid.quantities.keys() # Set up StreamHandler quantities = {} for field in grid.quantities: quantities[field] = decompose_quantity( grid.refined, grid.quantities[field][dust_id])[0] handler = stream.StreamHandler( left_edge[:], right_edge[:], dimensions[:], level_ids[:], parent_ids, particle_count[:], processor_ids[:], StreamFieldData(fields), HyperionIOHandlerOct(quantities), ) handler.name = 'hyperion' handler.domain_left_edge = np.array([xmin, ymin, zmin]) handler.domain_right_edge = np.array([xmax, ymax, zmax]) handler.refine_by = 2 handler.dimensionality = 3 handler.domain_dimensions = np.array([2, 2, 2]) handler.simulation_time = 0.0 handler.cosmology_simulation = 0 spf = stream.StreamStaticOutput(handler) spf.units["cm"] = 1.0 spf.units["unitary"] = 1.0 / ( (spf.domain_right_edge - spf.domain_left_edge).max()) spf.units['1'] = 1.0 box_in_mpc = 1.0 / mpc_conversion['cm'] for unit in mpc_conversion.keys(): spf.units[unit] = mpc_conversion[unit] * box_in_mpc return spf