def test_amr_kdtree_coverage(): return #TESTDISABLED domain_dims = (32, 32, 32) data = np.zeros(domain_dims) + 0.25 fo = [ ic.CoredSphere(0.05, 0.3, [0.7, 0.4, 0.75], {"density": (0.25, 100.0)}) ] rc = [fm.flagging_method_registry["overdensity"](8.0)] ug = load_uniform_grid({"density": data}, domain_dims, 1.0) ds = refine_amr(ug, rc, fo, 5) kd = AMRKDTree(ds) volume = kd.count_volume() yield assert_equal, volume, \ np.prod(ds.domain_right_edge - ds.domain_left_edge) cells = kd.count_cells() true_cells = ds.all_data().quantities['TotalQuantity']('Ones')[0] yield assert_equal, cells, true_cells # This largely reproduces the AMRKDTree.tree.check_tree() functionality tree_ok = True for node in kd.tree.trunk.depth_traverse(): if node.grid is None: continue grid = ds.index.grids[node.grid - kd._id_offset] dds = grid.dds gle = grid.LeftEdge nle = node.get_left_edge() nre = node.get_right_edge() li = np.rint((nle - gle) / dds).astype('int32') ri = np.rint((nre - gle) / dds).astype('int32') dims = (ri - li).astype('int32') tree_ok *= np.all(grid.LeftEdge <= nle) tree_ok *= np.all(grid.RightEdge >= nre) tree_ok *= np.all(dims > 0) yield assert_equal, True, tree_ok
def test_amr_kdtree_coverage(): return #TESTDISABLED domain_dims = (32, 32, 32) data = np.zeros(domain_dims) + 0.25 fo = [ic.CoredSphere(0.05, 0.3, [0.7, 0.4, 0.75], {"density": (0.25, 100.0)})] rc = [fm.flagging_method_registry["overdensity"](8.0)] ug = load_uniform_grid({"density": data}, domain_dims, 1.0) ds = refine_amr(ug, rc, fo, 5) kd = AMRKDTree(ds) volume = kd.count_volume() yield assert_equal, volume, \ np.prod(ds.domain_right_edge - ds.domain_left_edge) cells = kd.count_cells() true_cells = ds.all_data().quantities['TotalQuantity']('Ones')[0] yield assert_equal, cells, true_cells # This largely reproduces the AMRKDTree.tree.check_tree() functionality tree_ok = True for node in depth_traverse(kd.tree.trunk): if node.grid is None: continue grid = ds.index.grids[node.grid - kd._id_offset] dds = grid.dds gle = grid.LeftEdge nle = get_left_edge(node) nre = get_right_edge(node) li = np.rint((nle-gle)/dds).astype('int32') ri = np.rint((nre-gle)/dds).astype('int32') dims = (ri - li).astype('int32') tree_ok *= np.all(grid.LeftEdge <= nle) tree_ok *= np.all(grid.RightEdge >= nre) tree_ok *= np.all(dims > 0) yield assert_equal, True, tree_ok
def test_particle_generator(): # First generate our pf domain_dims = (128, 128, 128) dens = np.zeros(domain_dims) + 0.1 temp = 4. * np.ones(domain_dims) fields = { "density": (dens, 'code_mass/code_length**3'), "temperature": (temp, 'K') } ug = load_uniform_grid(fields, domain_dims, 1.0) fo = [ ic.BetaModelSphere(1.0, 0.1, 0.5, [0.5, 0.5, 0.5], {"density": (10.0)}) ] rc = [fm.flagging_method_registry["overdensity"](4.0)] ds = refine_amr(ug, rc, fo, 3) # Now generate particles from density field_list = [("io", "particle_position_x"), ("io", "particle_position_y"), ("io", "particle_position_z"), ("io", "particle_index"), ("io", "particle_gas_density")] num_particles = 1000000 field_dict = {("gas", "density"): ("io", "particle_gas_density")} sphere = ds.sphere(ds.domain_center, 0.45) particles1 = WithDensityParticleGenerator(ds, sphere, num_particles, field_list) particles1.assign_indices() particles1.map_grid_fields_to_particles(field_dict) # Test to make sure we ended up with the right number of particles per grid particles1.apply_to_stream() particles_per_grid1 = [grid.NumberOfParticles for grid in ds.index.grids] yield assert_equal, particles_per_grid1, particles1.NumberOfParticles particles_per_grid1 = [ len(grid["particle_position_x"]) for grid in ds.index.grids ] yield assert_equal, particles_per_grid1, particles1.NumberOfParticles tags = uconcatenate([grid["particle_index"] for grid in ds.index.grids]) assert (np.unique(tags).size == num_particles) # Set up a lattice of particles pdims = np.array([64, 64, 64]) def new_indices(): # We just add new indices onto the existing ones return np.arange((np.product(pdims))) + num_particles le = np.array([0.25, 0.25, 0.25]) re = np.array([0.75, 0.75, 0.75]) new_field_list = field_list + [("io", "particle_gas_temperature")] new_field_dict = { ("gas", "density"): ("io", "particle_gas_density"), ("gas", "temperature"): ("io", "particle_gas_temperature") } particles2 = LatticeParticleGenerator(ds, pdims, le, re, new_field_list) particles2.assign_indices(function=new_indices) particles2.map_grid_fields_to_particles(new_field_dict) #Test lattice positions xpos = np.unique(particles2["io", "particle_position_x"]) ypos = np.unique(particles2["io", "particle_position_y"]) zpos = np.unique(particles2["io", "particle_position_z"]) xpred = np.linspace(le[0], re[0], num=pdims[0], endpoint=True) ypred = np.linspace(le[1], re[1], num=pdims[1], endpoint=True) zpred = np.linspace(le[2], re[2], num=pdims[2], endpoint=True) assert_almost_equal(xpos, xpred) assert_almost_equal(ypos, ypred) assert_almost_equal(zpos, zpred) #Test the number of particles again particles2.apply_to_stream() particles_per_grid2 = [grid.NumberOfParticles for grid in ds.index.grids] yield assert_equal, particles_per_grid2, particles1.NumberOfParticles + particles2.NumberOfParticles [grid.field_data.clear() for grid in ds.index.grids] particles_per_grid2 = [ len(grid["particle_position_x"]) for grid in ds.index.grids ] yield assert_equal, particles_per_grid2, particles1.NumberOfParticles + particles2.NumberOfParticles #Test the uniqueness of tags tags = np.concatenate([grid["particle_index"] for grid in ds.index.grids]) tags.sort() yield assert_equal, tags, np.arange((np.product(pdims) + num_particles)) # Test that the old particles have zero for the new field old_particle_temps = [ grid["particle_gas_temperature"][:particles_per_grid1[i]] for i, grid in enumerate(ds.index.grids) ] test_zeros = [ np.zeros((particles_per_grid1[i])) for i, grid in enumerate(ds.index.grids) ] yield assert_equal, old_particle_temps, test_zeros #Now dump all of these particle fields out into a dict pdata = {} dd = ds.all_data() for field in new_field_list: pdata[field] = dd[field] #Test the "from-list" generator and particle field clobber particles3 = FromListParticleGenerator(ds, num_particles + np.product(pdims), pdata) particles3.apply_to_stream(clobber=True) #Test the number of particles again particles_per_grid3 = [grid.NumberOfParticles for grid in ds.index.grids] yield assert_equal, particles_per_grid3, particles1.NumberOfParticles + particles2.NumberOfParticles particles_per_grid2 = [ len(grid["particle_position_z"]) for grid in ds.index.grids ] yield assert_equal, particles_per_grid3, particles1.NumberOfParticles + particles2.NumberOfParticles
def test_stream_particles(): num_particles = 100000 domain_dims = (64, 64, 64) dens = np.random.random(domain_dims) x = np.random.uniform(size=num_particles) y = np.random.uniform(size=num_particles) z = np.random.uniform(size=num_particles) m = np.ones(num_particles) # Field operators and cell flagging methods fo = [] fo.append(ic.TopHatSphere(0.1, [0.2, 0.3, 0.4], {"density": 2.0})) fo.append(ic.TopHatSphere(0.05, [0.7, 0.4, 0.75], {"density": 20.0})) rc = [fm.flagging_method_registry["overdensity"](1.0)] # Check that all of this runs ok without particles ug0 = load_uniform_grid({"density": dens}, domain_dims, 1.0, nprocs=8) amr0 = refine_amr(ug0, rc, fo, 3) grid_data = [] for grid in amr0.index.grids: data = dict( left_edge=grid.LeftEdge, right_edge=grid.RightEdge, level=grid.Level, dimensions=grid.ActiveDimensions, ) for field in amr0.field_list: data[field] = grid[field] grid_data.append(data) amr0 = load_amr_grids(grid_data, domain_dims) # Now add particles fields1 = { "density": dens, "particle_position_x": x, "particle_position_y": y, "particle_position_z": z, "particle_mass": m, } fields2 = fields1.copy() ug1 = load_uniform_grid(fields1, domain_dims, 1.0) ug2 = load_uniform_grid(fields2, domain_dims, 1.0, nprocs=8) # Check to make sure the number of particles is the same number_of_particles1 = np.sum([grid.NumberOfParticles for grid in ug1.index.grids]) number_of_particles2 = np.sum([grid.NumberOfParticles for grid in ug2.index.grids]) assert_equal(number_of_particles1, num_particles) assert_equal(number_of_particles1, number_of_particles2) for grid in ug2.index.grids: tot_parts = grid["io", "particle_position_x"].size tot_all_parts = grid["all", "particle_position_x"].size assert tot_parts == grid.NumberOfParticles assert tot_all_parts == grid.NumberOfParticles # Check to make sure the fields have been defined correctly for ptype in ("all", "io"): assert ( ug1._get_field_info(ptype, "particle_position_x").sampling_type == "particle" ) assert ( ug1._get_field_info(ptype, "particle_position_y").sampling_type == "particle" ) assert ( ug1._get_field_info(ptype, "particle_position_z").sampling_type == "particle" ) assert ug1._get_field_info(ptype, "particle_mass").sampling_type == "particle" assert not ug1._get_field_info("gas", "density").sampling_type == "particle" for ptype in ("all", "io"): assert ( ug2._get_field_info(ptype, "particle_position_x").sampling_type == "particle" ) assert ( ug2._get_field_info(ptype, "particle_position_y").sampling_type == "particle" ) assert ( ug2._get_field_info(ptype, "particle_position_z").sampling_type == "particle" ) assert ug2._get_field_info(ptype, "particle_mass").sampling_type == "particle" assert not ug2._get_field_info("gas", "density").sampling_type == "particle" # Now refine this amr1 = refine_amr(ug1, rc, fo, 3) for field in sorted(ug1.field_list): assert field in amr1.field_list grid_data = [] for grid in amr1.index.grids: data = dict( left_edge=grid.LeftEdge, right_edge=grid.RightEdge, level=grid.Level, dimensions=grid.ActiveDimensions, ) for field in amr1.field_list: if field[0] not in ("all", "nbody"): data[field] = grid[field] grid_data.append(data) amr2 = load_amr_grids(grid_data, domain_dims) # Check everything again number_of_particles1 = [grid.NumberOfParticles for grid in amr1.index.grids] number_of_particles2 = [grid.NumberOfParticles for grid in amr2.index.grids] assert_equal(np.sum(number_of_particles1), num_particles) assert_equal(number_of_particles1, number_of_particles2) for grid in amr1.index.grids: tot_parts = grid["io", "particle_position_x"].size tot_all_parts = grid["all", "particle_position_x"].size assert tot_parts == grid.NumberOfParticles assert tot_all_parts == grid.NumberOfParticles for grid in amr2.index.grids: tot_parts = grid["io", "particle_position_x"].size tot_all_parts = grid["all", "particle_position_x"].size assert tot_parts == grid.NumberOfParticles assert tot_all_parts == grid.NumberOfParticles assert ( amr1._get_field_info("all", "particle_position_x").sampling_type == "particle" ) assert ( amr1._get_field_info("all", "particle_position_y").sampling_type == "particle" ) assert ( amr1._get_field_info("all", "particle_position_z").sampling_type == "particle" ) assert amr1._get_field_info("all", "particle_mass").sampling_type == "particle" assert not amr1._get_field_info("gas", "density").sampling_type == "particle" assert ( amr2._get_field_info("all", "particle_position_x").sampling_type == "particle" ) assert ( amr2._get_field_info("all", "particle_position_y").sampling_type == "particle" ) assert ( amr2._get_field_info("all", "particle_position_z").sampling_type == "particle" ) assert amr2._get_field_info("all", "particle_mass").sampling_type == "particle" assert not amr2._get_field_info("gas", "density").sampling_type == "particle" # Now perform similar checks, but with multiple particle types num_dm_particles = 30000 xd = np.random.uniform(size=num_dm_particles) yd = np.random.uniform(size=num_dm_particles) zd = np.random.uniform(size=num_dm_particles) md = np.ones(num_dm_particles) num_star_particles = 20000 xs = np.random.uniform(size=num_star_particles) ys = np.random.uniform(size=num_star_particles) zs = np.random.uniform(size=num_star_particles) ms = 2.0 * np.ones(num_star_particles) dens = np.random.random(domain_dims) fields3 = { "density": dens, ("dm", "particle_position_x"): xd, ("dm", "particle_position_y"): yd, ("dm", "particle_position_z"): zd, ("dm", "particle_mass"): md, ("star", "particle_position_x"): xs, ("star", "particle_position_y"): ys, ("star", "particle_position_z"): zs, ("star", "particle_mass"): ms, } fields4 = fields3.copy() ug3 = load_uniform_grid(fields3, domain_dims, 1.0) ug4 = load_uniform_grid(fields4, domain_dims, 1.0, nprocs=8) # Check to make sure the number of particles is the same number_of_particles3 = np.sum([grid.NumberOfParticles for grid in ug3.index.grids]) number_of_particles4 = np.sum([grid.NumberOfParticles for grid in ug4.index.grids]) assert_equal(number_of_particles3, num_dm_particles + num_star_particles) assert_equal(number_of_particles3, number_of_particles4) for grid in ug4.index.grids: tot_parts = grid["dm", "particle_position_x"].size tot_parts += grid["star", "particle_position_x"].size tot_all_parts = grid["all", "particle_position_x"].size assert tot_parts == grid.NumberOfParticles assert tot_all_parts == grid.NumberOfParticles # Check to make sure the fields have been defined correctly for ptype in ("dm", "star"): assert ( ug3._get_field_info(ptype, "particle_position_x").sampling_type == "particle" ) assert ( ug3._get_field_info(ptype, "particle_position_y").sampling_type == "particle" ) assert ( ug3._get_field_info(ptype, "particle_position_z").sampling_type == "particle" ) assert ug3._get_field_info(ptype, "particle_mass").sampling_type == "particle" assert ( ug4._get_field_info(ptype, "particle_position_x").sampling_type == "particle" ) assert ( ug4._get_field_info(ptype, "particle_position_y").sampling_type == "particle" ) assert ( ug4._get_field_info(ptype, "particle_position_z").sampling_type == "particle" ) assert ug4._get_field_info(ptype, "particle_mass").sampling_type == "particle" # Now refine this amr3 = refine_amr(ug3, rc, fo, 3) for field in sorted(ug3.field_list): assert field in amr3.field_list grid_data = [] for grid in amr3.index.grids: data = dict( left_edge=grid.LeftEdge, right_edge=grid.RightEdge, level=grid.Level, dimensions=grid.ActiveDimensions, ) for field in amr3.field_list: if field[0] not in ("all", "nbody"): data[field] = grid[field] grid_data.append(data) amr4 = load_amr_grids(grid_data, domain_dims) # Check everything again number_of_particles3 = [grid.NumberOfParticles for grid in amr3.index.grids] number_of_particles4 = [grid.NumberOfParticles for grid in amr4.index.grids] assert_equal(np.sum(number_of_particles3), num_star_particles + num_dm_particles) assert_equal(number_of_particles3, number_of_particles4) for ptype in ("dm", "star"): assert ( amr3._get_field_info(ptype, "particle_position_x").sampling_type == "particle" ) assert ( amr3._get_field_info(ptype, "particle_position_y").sampling_type == "particle" ) assert ( amr3._get_field_info(ptype, "particle_position_z").sampling_type == "particle" ) assert amr3._get_field_info(ptype, "particle_mass").sampling_type == "particle" assert ( amr4._get_field_info(ptype, "particle_position_x").sampling_type == "particle" ) assert ( amr4._get_field_info(ptype, "particle_position_y").sampling_type == "particle" ) assert ( amr4._get_field_info(ptype, "particle_position_z").sampling_type == "particle" ) assert amr4._get_field_info(ptype, "particle_mass").sampling_type == "particle" for grid in amr3.index.grids: tot_parts = grid["dm", "particle_position_x"].size tot_parts += grid["star", "particle_position_x"].size tot_all_parts = grid["all", "particle_position_x"].size assert tot_parts == grid.NumberOfParticles assert tot_all_parts == grid.NumberOfParticles for grid in amr4.index.grids: tot_parts = grid["dm", "particle_position_x"].size tot_parts += grid["star", "particle_position_x"].size tot_all_parts = grid["all", "particle_position_x"].size assert tot_parts == grid.NumberOfParticles assert tot_all_parts == grid.NumberOfParticles
def test_stream_particles() : num_particles = 100000 domain_dims = (64, 64, 64) dens = np.random.random(domain_dims) x = np.random.uniform(size=num_particles) y = np.random.uniform(size=num_particles) z = np.random.uniform(size=num_particles) m = np.ones((num_particles)) # Field operators and cell flagging methods fo = [] fo.append(ic.TopHatSphere(0.1, [0.2,0.3,0.4],{"density": 2.0})) fo.append(ic.TopHatSphere(0.05, [0.7,0.4,0.75],{"density": 20.0})) rc = [fm.flagging_method_registry["overdensity"](1.0)] # Check that all of this runs ok without particles ug0 = load_uniform_grid({"density": dens}, domain_dims, 1.0, nprocs=8) amr0 = refine_amr(ug0, rc, fo, 3) grid_data = [] for grid in amr0.index.grids : data = dict(left_edge = grid.LeftEdge, right_edge = grid.RightEdge, level = grid.Level, dimensions = grid.ActiveDimensions, number_of_particles = grid.NumberOfParticles) for field in amr0.field_list : data[field] = grid[field] grid_data.append(data) amr0 = load_amr_grids(grid_data, domain_dims, 1.0) # Now add particles fields1 = {"density": dens, "particle_position_x": x, "particle_position_y": y, "particle_position_z": z, "particle_mass": m, "number_of_particles": num_particles} fields2 = fields1.copy() ug1 = load_uniform_grid(fields1, domain_dims, 1.0) ug2 = load_uniform_grid(fields2, domain_dims, 1.0, nprocs=8) # Check to make sure the number of particles is the same number_of_particles1 = np.sum([grid.NumberOfParticles for grid in ug1.index.grids]) number_of_particles2 = np.sum([grid.NumberOfParticles for grid in ug2.index.grids]) yield assert_equal, number_of_particles1, num_particles yield assert_equal, number_of_particles1, number_of_particles2 # Check to make sure the fields have been defined correctly for ptype in ("all", "io"): assert ug1._get_field_info(ptype, "particle_position_x").particle_type assert ug1._get_field_info(ptype, "particle_position_y").particle_type assert ug1._get_field_info(ptype, "particle_position_z").particle_type assert ug1._get_field_info(ptype, "particle_mass").particle_type assert not ug1._get_field_info("gas", "density").particle_type for ptype in ("all", "io"): assert ug2._get_field_info(ptype, "particle_position_x").particle_type assert ug2._get_field_info(ptype, "particle_position_y").particle_type assert ug2._get_field_info(ptype, "particle_position_z").particle_type assert ug2._get_field_info(ptype, "particle_mass").particle_type assert not ug2._get_field_info("gas", "density").particle_type # Now refine this amr1 = refine_amr(ug1, rc, fo, 3) for field in sorted(ug1.field_list): yield assert_equal, (field in amr1.field_list), True grid_data = [] for grid in amr1.index.grids : data = dict(left_edge = grid.LeftEdge, right_edge = grid.RightEdge, level = grid.Level, dimensions = grid.ActiveDimensions, number_of_particles = grid.NumberOfParticles) for field in amr1.field_list : data[field] = grid[field] grid_data.append(data) amr2 = load_amr_grids(grid_data, domain_dims, 1.0) # Check everything again number_of_particles1 = [grid.NumberOfParticles for grid in amr1.index.grids] number_of_particles2 = [grid.NumberOfParticles for grid in amr2.index.grids] yield assert_equal, np.sum(number_of_particles1), num_particles yield assert_equal, number_of_particles1, number_of_particles2 assert amr1._get_field_info("all", "particle_position_x").particle_type assert amr1._get_field_info("all", "particle_position_y").particle_type assert amr1._get_field_info("all", "particle_position_z").particle_type assert amr1._get_field_info("all", "particle_mass").particle_type assert not amr1._get_field_info("gas", "density").particle_type assert amr2._get_field_info("all", "particle_position_x").particle_type assert amr2._get_field_info("all", "particle_position_y").particle_type assert amr2._get_field_info("all", "particle_position_z").particle_type assert amr2._get_field_info("all", "particle_mass").particle_type assert not amr2._get_field_info("gas", "density").particle_type
def test_stream_particles(): num_particles = 100000 domain_dims = (64, 64, 64) dens = np.random.random(domain_dims) x = np.random.uniform(size=num_particles) y = np.random.uniform(size=num_particles) z = np.random.uniform(size=num_particles) m = np.ones((num_particles)) # Field operators and cell flagging methods fo = [] fo.append(ic.TopHatSphere(0.1, [0.2, 0.3, 0.4], {"density": 2.0})) fo.append(ic.TopHatSphere(0.05, [0.7, 0.4, 0.75], {"density": 20.0})) rc = [fm.flagging_method_registry["overdensity"](1.0)] # Check that all of this runs ok without particles ug0 = load_uniform_grid({"density": dens}, domain_dims, 1.0, nprocs=8) amr0 = refine_amr(ug0, rc, fo, 3) grid_data = [] for grid in amr0.index.grids: data = dict(left_edge=grid.LeftEdge, right_edge=grid.RightEdge, level=grid.Level, dimensions=grid.ActiveDimensions, number_of_particles=grid.NumberOfParticles) for field in amr0.field_list: data[field] = grid[field] grid_data.append(data) amr0 = load_amr_grids(grid_data, domain_dims, 1.0) # Now add particles fields1 = { "density": dens, "particle_position_x": x, "particle_position_y": y, "particle_position_z": z, "particle_mass": m, "number_of_particles": num_particles } fields2 = fields1.copy() ug1 = load_uniform_grid(fields1, domain_dims, 1.0) ug2 = load_uniform_grid(fields2, domain_dims, 1.0, nprocs=8) # Check to make sure the number of particles is the same number_of_particles1 = np.sum( [grid.NumberOfParticles for grid in ug1.index.grids]) number_of_particles2 = np.sum( [grid.NumberOfParticles for grid in ug2.index.grids]) yield assert_equal, number_of_particles1, num_particles yield assert_equal, number_of_particles1, number_of_particles2 # Check to make sure the fields have been defined correctly for ptype in ("all", "io"): assert ug1._get_field_info(ptype, "particle_position_x").particle_type assert ug1._get_field_info(ptype, "particle_position_y").particle_type assert ug1._get_field_info(ptype, "particle_position_z").particle_type assert ug1._get_field_info(ptype, "particle_mass").particle_type assert not ug1._get_field_info("gas", "density").particle_type for ptype in ("all", "io"): assert ug2._get_field_info(ptype, "particle_position_x").particle_type assert ug2._get_field_info(ptype, "particle_position_y").particle_type assert ug2._get_field_info(ptype, "particle_position_z").particle_type assert ug2._get_field_info(ptype, "particle_mass").particle_type assert not ug2._get_field_info("gas", "density").particle_type # Now refine this amr1 = refine_amr(ug1, rc, fo, 3) for field in sorted(ug1.field_list): yield assert_equal, (field in amr1.field_list), True grid_data = [] for grid in amr1.index.grids: data = dict(left_edge=grid.LeftEdge, right_edge=grid.RightEdge, level=grid.Level, dimensions=grid.ActiveDimensions, number_of_particles=grid.NumberOfParticles) for field in amr1.field_list: data[field] = grid[field] grid_data.append(data) amr2 = load_amr_grids(grid_data, domain_dims, 1.0) # Check everything again number_of_particles1 = [ grid.NumberOfParticles for grid in amr1.index.grids ] number_of_particles2 = [ grid.NumberOfParticles for grid in amr2.index.grids ] yield assert_equal, np.sum(number_of_particles1), num_particles yield assert_equal, number_of_particles1, number_of_particles2 assert amr1._get_field_info("all", "particle_position_x").particle_type assert amr1._get_field_info("all", "particle_position_y").particle_type assert amr1._get_field_info("all", "particle_position_z").particle_type assert amr1._get_field_info("all", "particle_mass").particle_type assert not amr1._get_field_info("gas", "density").particle_type assert amr2._get_field_info("all", "particle_position_x").particle_type assert amr2._get_field_info("all", "particle_position_y").particle_type assert amr2._get_field_info("all", "particle_position_z").particle_type assert amr2._get_field_info("all", "particle_mass").particle_type assert not amr2._get_field_info("gas", "density").particle_type
def test_particle_generator(): # First generate our dataset domain_dims = (32, 32, 32) dens = np.zeros(domain_dims) + 0.1 temp = 4.0 * np.ones(domain_dims) fields = { "density": (dens, "code_mass/code_length**3"), "temperature": (temp, "K") } ug = load_uniform_grid(fields, domain_dims, 1.0) fo = [ ic.BetaModelSphere(1.0, 0.1, 0.5, [0.5, 0.5, 0.5], {"density": (10.0)}) ] rc = [fm.flagging_method_registry["overdensity"](4.0)] ds = refine_amr(ug, rc, fo, 3) # Now generate particles from density field_list = [ ("io", "particle_position_x"), ("io", "particle_position_y"), ("io", "particle_position_z"), ("io", "particle_index"), ("io", "particle_gas_density"), ] num_particles = 10000 field_dict = {("gas", "density"): ("io", "particle_gas_density")} sphere = ds.sphere(ds.domain_center, 0.45) particles1 = WithDensityParticleGenerator(ds, sphere, num_particles, field_list) particles1.assign_indices() particles1.map_grid_fields_to_particles(field_dict) # Test to make sure we ended up with the right number of particles per grid particles1.apply_to_stream() particles_per_grid1 = [grid.NumberOfParticles for grid in ds.index.grids] assert_equal(particles_per_grid1, particles1.NumberOfParticles) particles_per_grid1 = [ len(grid["particle_position_x"]) for grid in ds.index.grids ] assert_equal(particles_per_grid1, particles1.NumberOfParticles) tags = uconcatenate([grid["particle_index"] for grid in ds.index.grids]) assert np.unique(tags).size == num_particles del tags # Set up a lattice of particles pdims = np.array([32, 32, 32]) def new_indices(): # We just add new indices onto the existing ones return np.arange((np.product(pdims))) + num_particles le = np.array([0.25, 0.25, 0.25]) re = np.array([0.75, 0.75, 0.75]) particles2 = LatticeParticleGenerator(ds, pdims, le, re, field_list) particles2.assign_indices(function=new_indices) particles2.map_grid_fields_to_particles(field_dict) # Test lattice positions xpos = np.unique(particles2["io", "particle_position_x"]) ypos = np.unique(particles2["io", "particle_position_y"]) zpos = np.unique(particles2["io", "particle_position_z"]) xpred = np.linspace(le[0], re[0], num=pdims[0], endpoint=True) ypred = np.linspace(le[1], re[1], num=pdims[1], endpoint=True) zpred = np.linspace(le[2], re[2], num=pdims[2], endpoint=True) assert_almost_equal(xpos, xpred) assert_almost_equal(ypos, ypred) assert_almost_equal(zpos, zpred) del xpos, ypos, zpos del xpred, ypred, zpred # Test the number of particles again particles2.apply_to_stream() particles_per_grid2 = [grid.NumberOfParticles for grid in ds.index.grids] assert_equal(particles_per_grid2, particles1.NumberOfParticles + particles2.NumberOfParticles) [grid.field_data.clear() for grid in ds.index.grids] particles_per_grid2 = [ len(grid["particle_position_x"]) for grid in ds.index.grids ] assert_equal(particles_per_grid2, particles1.NumberOfParticles + particles2.NumberOfParticles) # Test the uniqueness of tags tags = np.concatenate([grid["particle_index"] for grid in ds.index.grids]) tags.sort() assert_equal(tags, np.arange((np.product(pdims) + num_particles))) del tags # Now dump all of these particle fields out into a dict pdata = {} dd = ds.all_data() for field in field_list: pdata[field] = dd[field] # Test the "from-list" generator and particle field overwrite num_particles3 = num_particles + np.product(pdims) particles3 = FromListParticleGenerator(ds, num_particles3, pdata) particles3.apply_to_stream(overwrite=True) # Test the number of particles again particles_per_grid3 = [grid.NumberOfParticles for grid in ds.index.grids] assert_equal(particles_per_grid3, particles1.NumberOfParticles + particles2.NumberOfParticles) particles_per_grid2 = [ len(grid["particle_position_z"]) for grid in ds.index.grids ] assert_equal(particles_per_grid3, particles1.NumberOfParticles + particles2.NumberOfParticles) assert_equal(particles_per_grid2, particles_per_grid3) # Test adding in particles with a different particle type num_star_particles = 20000 pdata2 = { ("star", "particle_position_x"): np.random.uniform(size=num_star_particles), ("star", "particle_position_y"): np.random.uniform(size=num_star_particles), ("star", "particle_position_z"): np.random.uniform(size=num_star_particles), } particles4 = FromListParticleGenerator(ds, num_star_particles, pdata2, ptype="star") particles4.apply_to_stream() dd = ds.all_data() assert dd["star", "particle_position_x"].size == num_star_particles assert dd["io", "particle_position_x"].size == num_particles3 assert dd[ "all", "particle_position_x"].size == num_star_particles + num_particles3 del pdata del pdata2 del ds del particles1 del particles2 del particles4 del fields del dens del temp
def test_particle_generator(): # First generate our dataset domain_dims = (128, 128, 128) dens = np.zeros(domain_dims) + 0.1 temp = 4.*np.ones(domain_dims) fields = {"density": (dens, 'code_mass/code_length**3'), "temperature": (temp, 'K')} ug = load_uniform_grid(fields, domain_dims, 1.0) fo = [ic.BetaModelSphere(1.0,0.1,0.5,[0.5,0.5,0.5],{"density":(10.0)})] rc = [fm.flagging_method_registry["overdensity"](4.0)] ds = refine_amr(ug, rc, fo, 3) # Now generate particles from density field_list = [("io", "particle_position_x"), ("io", "particle_position_y"), ("io", "particle_position_z"), ("io", "particle_index"), ("io", "particle_gas_density")] num_particles = 1000000 field_dict = {("gas", "density"): ("io", "particle_gas_density")} sphere = ds.sphere(ds.domain_center, 0.45) particles1 = WithDensityParticleGenerator(ds, sphere, num_particles, field_list) particles1.assign_indices() particles1.map_grid_fields_to_particles(field_dict) # Test to make sure we ended up with the right number of particles per grid particles1.apply_to_stream() particles_per_grid1 = [grid.NumberOfParticles for grid in ds.index.grids] yield assert_equal, particles_per_grid1, particles1.NumberOfParticles particles_per_grid1 = [len(grid["particle_position_x"]) for grid in ds.index.grids] yield assert_equal, particles_per_grid1, particles1.NumberOfParticles tags = uconcatenate([grid["particle_index"] for grid in ds.index.grids]) assert(np.unique(tags).size == num_particles) # Set up a lattice of particles pdims = np.array([64,64,64]) def new_indices() : # We just add new indices onto the existing ones return np.arange((np.product(pdims)))+num_particles le = np.array([0.25,0.25,0.25]) re = np.array([0.75,0.75,0.75]) new_field_list = field_list + [("io", "particle_gas_temperature")] new_field_dict = {("gas", "density"): ("io", "particle_gas_density"), ("gas", "temperature"): ("io", "particle_gas_temperature")} particles2 = LatticeParticleGenerator(ds, pdims, le, re, new_field_list) particles2.assign_indices(function=new_indices) particles2.map_grid_fields_to_particles(new_field_dict) #Test lattice positions xpos = np.unique(particles2["io", "particle_position_x"]) ypos = np.unique(particles2["io", "particle_position_y"]) zpos = np.unique(particles2["io", "particle_position_z"]) xpred = np.linspace(le[0],re[0],num=pdims[0],endpoint=True) ypred = np.linspace(le[1],re[1],num=pdims[1],endpoint=True) zpred = np.linspace(le[2],re[2],num=pdims[2],endpoint=True) assert_almost_equal( xpos, xpred) assert_almost_equal( ypos, ypred) assert_almost_equal( zpos, zpred) #Test the number of particles again particles2.apply_to_stream() particles_per_grid2 = [grid.NumberOfParticles for grid in ds.index.grids] yield assert_equal, particles_per_grid2, particles1.NumberOfParticles+particles2.NumberOfParticles [grid.field_data.clear() for grid in ds.index.grids] particles_per_grid2 = [len(grid["particle_position_x"]) for grid in ds.index.grids] yield assert_equal, particles_per_grid2, particles1.NumberOfParticles+particles2.NumberOfParticles #Test the uniqueness of tags tags = np.concatenate([grid["particle_index"] for grid in ds.index.grids]) tags.sort() yield assert_equal, tags, np.arange((np.product(pdims)+num_particles)) # Test that the old particles have zero for the new field old_particle_temps = [grid["particle_gas_temperature"][:particles_per_grid1[i]] for i, grid in enumerate(ds.index.grids)] test_zeros = [np.zeros((particles_per_grid1[i])) for i, grid in enumerate(ds.index.grids)] yield assert_equal, old_particle_temps, test_zeros #Now dump all of these particle fields out into a dict pdata = {} dd = ds.all_data() for field in new_field_list : pdata[field] = dd[field] #Test the "from-list" generator and particle field clobber particles3 = FromListParticleGenerator(ds, num_particles+np.product(pdims), pdata) particles3.apply_to_stream(clobber=True) #Test the number of particles again particles_per_grid3 = [grid.NumberOfParticles for grid in ds.index.grids] yield assert_equal, particles_per_grid3, particles1.NumberOfParticles+particles2.NumberOfParticles particles_per_grid2 = [len(grid["particle_position_z"]) for grid in ds.index.grids] yield assert_equal, particles_per_grid3, particles1.NumberOfParticles+particles2.NumberOfParticles