def _load(self, fname): data = numpy.load(fname, encoding='bytes', allow_pickle=True) if 'version' not in data.files: msg = "Wrong file type! No version number recorded." raise RuntimeError(msg) ret = {} ret["arrays"] = {} version = data['version'] solver_data = _get_dict_from_arrays(data["solver_data"]) ret["solver_data"] = solver_data if version == 1: arrays = _get_dict_from_arrays(data["arrays"]) for array_name in arrays: array = get_particle_array(name=array_name, **arrays[array_name]) ret["arrays"][array_name] = array elif version == 2: particles = _get_dict_from_arrays(data["particles"]) for array_name, array_info in particles.items(): for prop, data in array_info['arrays'].items(): array_info['properties'][prop]['data'] = data array = ParticleArray(name=array_name, constants=array_info["constants"], **array_info["properties"]) array.set_output_arrays( array_info.get('output_property_arrays', [])) ret["arrays"][array_name] = array else: raise RuntimeError("Version not understood!") return ret
def test_that_all_properties_are_found_with_multiple_arrays(self): x = np.linspace(0, 1, 10) pa1 = ParticleArray(name='f', x=x) pa2 = ParticleArray(name='b', y=x) result = get_all_array_names([pa1, pa2]) self.assertEqual(len(result), 3) self.assertEqual(result['DoubleArray'], set(('x', 'y'))) self.assertEqual(result['IntArray'], set(('pid', 'tag'))) self.assertEqual(result['UIntArray'], set(('gid', )))
def create_particles(): x = np.linspace(0, 10, 10) m = np.ones_like(x) y = np.zeros_like(x) z = np.zeros_like(x) h = np.ones_like(x) * 0.2 fluid = ParticleArray(name='fluid', x=x, y=y, z=z, m=m, h=h) fluid.add_constant('total_mass', 0.0) return [fluid]
def get_particle_array_combined(self, idx, procs=None): ''' get a single particle array with combined data from all procs specifying processes is currently not implemented ''' if procs is None: procs = range(self.comm.size) pa = self.solver.particles.arrays[idx] pas = self.comm.gather(pa) pa = ParticleArray(name=pa.name) for p in pas: pa.append_parray(p) return pa
def remove_repeated_points(x, y, z, dx_triangle): EPS = np.finfo(float).eps pa_mesh = ParticleArray(name='mesh', x=x, y=y, z=z, h=EPS) pa_grid = ParticleArray(name='grid', x=x, y=y, z=z, h=EPS) pa_mesh.add_property(name='min_idx') equation = [FindRepeatedPoints(dest='mesh', sources=['grid'])] sph_eval = SPHEvaluator([pa_mesh, pa_grid], equation, dim=3) sph_eval.evaluate() idx = list(set(pa_mesh.min_idx)) idx = np.array(idx, dtype=int) return pa_mesh.x[idx], pa_mesh.y[idx], pa_mesh.z[idx]
def _get_particles(self, grp): particles = {} for name, prop_array in grp.items(): output_array = [] const_grp = prop_array['constants'] arrays_grp = prop_array['arrays'] constants = self._get_constants(const_grp) array = ParticleArray(_to_str(name), constants=constants) for pname, h5obj in arrays_grp.items(): prop_name = _to_str(h5obj.attrs['name']) type_ = _to_str(h5obj.attrs['type']) default = h5obj.attrs['default'] stride = h5obj.attrs.get('stride', 1) if h5obj.attrs['stored']: output_array.append(_to_str(pname)) array.add_property(prop_name, type=type_, default=default, data=numpy.array(h5obj), stride=stride) else: array.add_property(prop_name, type=type_, stride=stride) array.set_output_arrays(output_array) particles[str(name)] = array return particles
def test_that_all_types_are_detected_correctly(self): x = np.linspace(0, 1, 10) pa = ParticleArray(name='f', x=x) pa.remove_property('pid') info = get_all_array_names([pa]) result = get_known_types_for_arrays(info) expect = {'d_gid': KnownType("unsigned int*"), 'd_tag': KnownType("int*"), 'd_x': KnownType("double*"), 's_gid': KnownType("unsigned int*"), 's_tag': KnownType("int*"), 's_x': KnownType("double*")} for key in expect: self.assertEqual(repr(result[key]), repr(expect[key]))
def t(self): ret = {} da = DoubleArray() pa = ParticleArray() kernel = kernels.CubicSplineKernel(3) get_time = time.time for N in Ns: x = numpy.arange(N) z = y = numpy.zeros(N) mu = m = rho = numpy.ones(N) h = 2*m da = DoubleArray(N) da2 = DoubleArray(N) da.set_data(z) da2.set_data(z) pa = get_particle_array(x=x, y=y, z=z, h=h, mu=mu, rho=rho, m=m, tmp=z, tx=z, ty=m, tz=z, nx=m, ny=z, nz=z, u=z, v=z, w=z, ubar=z, vbar=z, wbar=z, q=m) pb = get_particle_array(x=x+0.1**0.5, y=y, z=z, h=h, mu=mu, rho=rho, m=m, tmp=z, tx=m, ty=z, tz=z, nx=z, ny=m, nz=z, u=z, v=z, w=z, ubar=z, vbar=z, wbar=z, q=m) particles = Particles(arrays=[pa, pb]) func = func_getter.get_func(pa, pb) calc = SPHCalc(particles, [pa], pb, kernel, [func], ['tmp']*func.num_outputs) print cls.__name__ t = get_time() calc.sph('tmp', 'tmp', 'tmp') t = get_time() - t nam = '%s'%(cls.__name__) ret[nam +' /%d'%(N)] = t/N return ret
def test_setup_outputs(self): """ """ dg = DummyGenerator() dg._setup_outputs() self.assertEqual(len(dg.output_particle_arrays), 1) oa = dg.output_particle_arrays[0] self.assertEqual(oa.properties.has_key('x'), True) self.assertEqual(oa.properties.has_key('y'), True) self.assertEqual(oa.properties.has_key('z'), True) self.assertEqual(oa.properties.has_key('m'), True) self.assertEqual(oa.properties.has_key('rho'), True) self.assertEqual(oa.properties.has_key('h'), True) p = ParticleArray(x={'data': [1, 2, 3]}) dg = DummyGenerator() dg.output_particle_arrays.append(p) dg._setup_outputs() self.assertEqual(len(dg.output_particle_arrays), 1) self.assertEqual(dg.output_particle_arrays[0], p) oa = p self.assertEqual(oa.properties.has_key('x'), True) self.assertEqual(oa.properties.has_key('y'), True) self.assertEqual(oa.properties.has_key('z'), True) self.assertEqual(oa.properties.has_key('m'), True) self.assertEqual(oa.properties.has_key('rho'), True) self.assertEqual(oa.properties.has_key('h'), True)
def main(): comm = mpi.COMM_WORLD rank = comm.Get_rank() size = comm.Get_size() root = mkdtemp() filename = join(root, 'test.npz') x = np.ones(5, dtype=float)*rank pa = ParticleArray(name='fluid', constants={'c1': 0.0, 'c2': [0.0, 0.0]}, x=x) try: dump(filename, [pa], {}, mpi_comm=comm) if rank == 0: data = load(filename) pa1 = data["arrays"]["fluid"] assert_lists_same(pa.properties.keys(), pa1.properties.keys()) assert_lists_same(pa.constants.keys(), pa1.constants.keys()) expect = np.ones(5*size) for i in range(size): expect[5*i:5*(i+1)] = i assert np.allclose(pa1.x, expect, atol=1e-14), \ "Expected %s, got %s" % (expect, pa1.x) finally: shutil.rmtree(root)
def test_get_points_from_mgrid(self): """Find neighbouring particles around a unit cube""" h = 0.1 cube_fname = self._generate_cube_stl() x, y, z, x_list, y_list, z_list, mesh = \ G._get_stl_mesh(cube_fname, h, uniform=True) pa_mesh = ParticleArray(name='mesh', x=x, y=y, z=z, h=h) offset = h x_grid, y_grid, z_grid = np.meshgrid( np.arange(x.min() - offset, x.max() + offset, h), np.arange(y.min() - offset, y.max() + offset, h), np.arange(z.min() - offset, z.max() + offset, h)) pa_grid = ParticleArray(name='grid', x=x_grid, y=y_grid, z=z_grid, h=h) x_grid, y_grid, z_grid = G.get_points_from_mgrid( pa_grid, pa_mesh, x_list, y_list, z_list, 1, h, mesh) for i in range(x.shape[0]): assert ((x[i]**2 + y[i]**2 + z[i]**2) <= 4)
def test_get_points_from_mgrid(self): """Find neighbouring particles around a unit cube""" h = 0.1 x_cube, y_cube, z_cube, cells, normals, vectors = cube_data() x, y, z, x_list, y_list, z_list, vectors = \ G._get_surface_mesh(x_cube, y_cube, z_cube, cells, h, uniform=True) pa_mesh = ParticleArray(name='mesh', x=x, y=y, z=z, h=h) offset = h x_grid, y_grid, z_grid = np.meshgrid( np.arange(x.min() - offset, x.max() + offset, h), np.arange(y.min() - offset, y.max() + offset, h), np.arange(z.min() - offset, z.max() + offset, h)) pa_grid = ParticleArray(name='grid', x=x_grid, y=y_grid, z=z_grid, h=h) x_grid, y_grid, z_grid = G.get_points_from_mgrid( pa_grid, pa_mesh, x_list, y_list, z_list, 1, h, vectors, normals) for i in range(x.shape[0]): assert ((x[i]**2 + y[i]**2 + z[i]**2) <= 4)
def get_particle_array(name="", **props): """Return a particle array""" nprops = len(props) np = 0 prop_dict = {} for prop in props.keys(): data = numpy.asarray(props[prop]) np = data.size if prop in ['pid', 'type', 'tag']: prop_dict[prop] = {'data': data, 'type': 'int', 'name': prop} elif prop in ['gid']: prop_dict[prop] = { 'data': data.astype(numpy.uint32), 'type': 'unsigned int', 'name': prop } else: prop_dict[prop] = {'data': data, 'type': 'double', 'name': prop} default_props = ['x', 'y', 'z', 'h', 'rho', 'gid', 'tag', 'type', 'pid'] for prop in default_props: if not prop in prop_dict: if prop in ["type", "tag", "pid"]: prop_dict[prop] = {'name': prop, 'type': 'int', 'default': 0} elif prop in ['gid']: data = numpy.ones(shape=np, dtype=numpy.uint32) data[:] = UINT_MAX prop_dict[prop] = { 'name': prop, 'type': 'unsigned int', 'data': data } else: prop_dict[prop] = { 'name': prop, 'type': 'double', 'default': 0 } # create the particle array pa = ParticleArray(name="", **prop_dict) return pa
def _load(self, fname): def _get_dict_from_arrays(arrays): arrays.shape = (1,) return arrays[0] data = numpy.load(fname) if 'version' not in data.files: msg = "Wrong file type! No version number recorded." raise RuntimeError(msg) ret = {} ret["arrays"] = {} version = data['version'] solver_data = _get_dict_from_arrays(data["solver_data"]) ret["solver_data"] = solver_data if version == 1: arrays = _get_dict_from_arrays(data["arrays"]) for array_name in arrays: array = get_particle_array(name=array_name, **arrays[array_name]) ret["arrays"][array_name] = array elif version == 2: particles = _get_dict_from_arrays(data["particles"]) for array_name, array_info in particles.items(): array = ParticleArray(name=array_name, constants=array_info["constants"], **array_info["arrays"]) array.set_output_arrays( array_info.get('output_property_arrays', []) ) for prop, prop_info in array_info["properties"].items(): if prop not in array_info["arrays"]: array.add_property(**prop_info) ret["arrays"][array_name] = array else: raise RuntimeError("Version not understood!") return ret
def create_particles(options): if options.type == "square": # create the square block of particles. start_point = Point(0, 0, 0) end_point = Point(options.square_width, options.square_width, 0) parray = ParticleArray() if rank == 0: rg = RectangleGenerator(start_point=start_point, end_point=end_point, particle_spacing_x1=options.particle_spacing, particle_spacing_x2=options.particle_spacing, density_computation_mode=Dcm.Set_Constant, particle_density=1000.0, mass_computation_mode=Mcm.Compute_From_Density, particle_h=options.particle_radius, kernel=CubicSplineKernel(2), filled=True) tmp = rg.get_particles() parray.append_parray(tmp) if rank != 0: # add some necessary properties to the particle array. parray.add_property({'name':'x'}) parray.add_property({'name':'y'}) parray.add_property({'name':'z'}) parray.add_property({'name':'h', 'default':options.particle_radius}) parray.add_property({'name':'rho', 'default':1000.}) parray.add_property({'name':'pid'}) parray.add_property({'name':'_tmp', 'default':0.0}) parray.add_property({'name':'m'}) else: parray.add_property({'name':'_tmp'}) parray.add_property({'name':'pid', 'default':0.0}) return [parray] elif options.type == "dam_break": dam_wall = ParticleArray() dam_fluid = ParticleArray() if rank == 0: radius = 0.2 dam_width=10.0 dam_height=7.0 solid_particle_h=radius dam_particle_spacing=radius/9. solid_particle_mass=1.0 origin_x=origin_y=0.0 fluid_particle_h=radius fluid_density=1000. fluid_column_height=3.0 fluid_column_width=2.0 fluid_particle_spacing=radius # generate the left wall - a line lg = LineGenerator(particle_mass=solid_particle_mass, mass_computation_mode=Mcm.Set_Constant, density_computation_mode=Dcm.Ignore, particle_h=solid_particle_h, start_point=Point(0, 0, 0), end_point=Point(0, dam_height, 0), particle_spacing=dam_particle_spacing) tmp = lg.get_particles() dam_wall.append_parray(tmp) # generate one half of the base lg.start_point = Point(dam_particle_spacing, 0, 0) lg.end_point = Point(dam_width/2, 0, 0) tmp = lg.get_particles() dam_wall.append_parray(tmp) # generate particles for the left column of fluid. rg = RectangleGenerator( start_point=Point(origin_x+2.0*solid_particle_h, origin_y+2.0*solid_particle_h, 0.0), end_point=Point(origin_x+2.0*solid_particle_h+fluid_column_width, origin_y+2.0*solid_particle_h+fluid_column_height, 0.0), particle_spacing_x1=fluid_particle_spacing, particle_spacing_x2=fluid_particle_spacing, density_computation_mode=Dcm.Set_Constant, mass_computation_mode=Mcm.Compute_From_Density, particle_density=1000., particle_h=fluid_particle_h, kernel=CubicSplineKernel(2), filled=True) dam_fluid = rg.get_particles() # generate the right wall - a line lg = LineGenerator(particle_mass=solid_particle_mass, mass_computation_mode=Mcm.Set_Constant, density_computation_mode=Dcm.Ignore, particle_h=solid_particle_h, start_point=Point(dam_width, 0, 0), end_point=Point(dam_width, dam_height, 0), particle_spacing=dam_particle_spacing) tmp = lg.get_particles() dam_wall.append_parray(tmp) # generate the right half of the base lg.start_point = Point(dam_width/2.+dam_particle_spacing, 0, 0) lg.end_point = Point(dam_width, 0, 0) tmp = lg.get_particles() dam_wall.append_parray(tmp) for parray in [dam_fluid, dam_wall]: if rank != 0: # add some necessary properties to the particle array. parray.add_property({'name':'x'}) parray.add_property({'name':'y'}) parray.add_property({'name':'z'}) parray.add_property({'name':'h', 'default':options.particle_radius}) parray.add_property({'name':'rho', 'default':1000.}) parray.add_property({'name':'pid'}) parray.add_property({'name':'_tmp', 'default':0.0}) parray.add_property({'name':'m'}) else: parray.add_property({'name':'_tmp'}) parray.add_property({'name':'pid', 'default':0.0}) return [dam_fluid, dam_wall]
log_file_name = '/tmp/log_pysph_'+str(rank) logging.basicConfig(level=logging.DEBUG, filename=log_file_name, filemode='w') logger.addHandler(logging.StreamHandler()) # local imports from pysph.base.particle_array import ParticleArray from pysph.parallel.parallel_cell import ParallelCellManager from pysph.solver.basic_generators import RectangleGenerator from pysph.base.cell import INT_INF from pysph.base.point import * pcm = ParallelCellManager(initialize=False, dimension=2) parray = ParticleArray(name='parray') if rank == 0: lg = RectangleGenerator(particle_spacing_x1=0.1, particle_spacing_x2=0.1) x, y, z = lg.get_coords() parray.add_property({'name':'x', 'data':x}) parray.add_property({'name':'y', 'data':y}) parray.add_property({'name':'z', 'data':z}) parray.add_property({'name':'h'}) parray.align_particles() parray.h[:] = 0.1 else: parray.add_property({'name':'x'}) parray.add_property({'name':'y'})
def create_particles(options): if options.type == "square": # create the square block of particles. start_point = Point(0, 0, 0) end_point = Point(options.square_width, options.square_width, 0) parray = ParticleArray() if rank == 0: rg = RectangleGenerator( start_point=start_point, end_point=end_point, particle_spacing_x1=options.particle_spacing, particle_spacing_x2=options.particle_spacing, density_computation_mode=Dcm.Set_Constant, particle_density=1000.0, mass_computation_mode=Mcm.Compute_From_Density, particle_h=options.particle_radius, kernel=CubicSplineKernel(2), filled=True) tmp = rg.get_particles() parray.append_parray(tmp) if rank != 0: # add some necessary properties to the particle array. parray.add_property({'name': 'x'}) parray.add_property({'name': 'y'}) parray.add_property({'name': 'z'}) parray.add_property({ 'name': 'h', 'default': options.particle_radius }) parray.add_property({'name': 'rho', 'default': 1000.}) parray.add_property({'name': 'pid'}) parray.add_property({'name': '_tmp', 'default': 0.0}) parray.add_property({'name': 'm'}) else: parray.add_property({'name': '_tmp'}) parray.add_property({'name': 'pid', 'default': 0.0}) return [parray] elif options.type == "dam_break": dam_wall = ParticleArray() dam_fluid = ParticleArray() if rank == 0: radius = 0.2 dam_width = 10.0 dam_height = 7.0 solid_particle_h = radius dam_particle_spacing = radius / 9. solid_particle_mass = 1.0 origin_x = origin_y = 0.0 fluid_particle_h = radius fluid_density = 1000. fluid_column_height = 3.0 fluid_column_width = 2.0 fluid_particle_spacing = radius # generate the left wall - a line lg = LineGenerator(particle_mass=solid_particle_mass, mass_computation_mode=Mcm.Set_Constant, density_computation_mode=Dcm.Ignore, particle_h=solid_particle_h, start_point=Point(0, 0, 0), end_point=Point(0, dam_height, 0), particle_spacing=dam_particle_spacing) tmp = lg.get_particles() dam_wall.append_parray(tmp) # generate one half of the base lg.start_point = Point(dam_particle_spacing, 0, 0) lg.end_point = Point(dam_width / 2, 0, 0) tmp = lg.get_particles() dam_wall.append_parray(tmp) # generate particles for the left column of fluid. rg = RectangleGenerator( start_point=Point(origin_x + 2.0 * solid_particle_h, origin_y + 2.0 * solid_particle_h, 0.0), end_point=Point( origin_x + 2.0 * solid_particle_h + fluid_column_width, origin_y + 2.0 * solid_particle_h + fluid_column_height, 0.0), particle_spacing_x1=fluid_particle_spacing, particle_spacing_x2=fluid_particle_spacing, density_computation_mode=Dcm.Set_Constant, mass_computation_mode=Mcm.Compute_From_Density, particle_density=1000., particle_h=fluid_particle_h, kernel=CubicSplineKernel(2), filled=True) dam_fluid = rg.get_particles() # generate the right wall - a line lg = LineGenerator(particle_mass=solid_particle_mass, mass_computation_mode=Mcm.Set_Constant, density_computation_mode=Dcm.Ignore, particle_h=solid_particle_h, start_point=Point(dam_width, 0, 0), end_point=Point(dam_width, dam_height, 0), particle_spacing=dam_particle_spacing) tmp = lg.get_particles() dam_wall.append_parray(tmp) # generate the right half of the base lg.start_point = Point(dam_width / 2. + dam_particle_spacing, 0, 0) lg.end_point = Point(dam_width, 0, 0) tmp = lg.get_particles() dam_wall.append_parray(tmp) for parray in [dam_fluid, dam_wall]: if rank != 0: # add some necessary properties to the particle array. parray.add_property({'name': 'x'}) parray.add_property({'name': 'y'}) parray.add_property({'name': 'z'}) parray.add_property({ 'name': 'h', 'default': options.particle_radius }) parray.add_property({'name': 'rho', 'default': 1000.}) parray.add_property({'name': 'pid'}) parray.add_property({'name': '_tmp', 'default': 0.0}) parray.add_property({'name': 'm'}) else: parray.add_property({'name': '_tmp'}) parray.add_property({'name': 'pid', 'default': 0.0}) return [dam_fluid, dam_wall]
import logging logger = logging.getLogger() log_file_name = '/tmp/log_pysph_' + str(rank) logging.basicConfig(level=logging.DEBUG, filename=log_file_name, filemode='w') logger.addHandler(logging.StreamHandler()) # local imports from pysph.base.particle_array import ParticleArray from pysph.parallel.parallel_cell import ParallelCellManager from pysph.solver.basic_generators import LineGenerator from pysph.base.cell import INT_INF from pysph.base.point import * pcm = ParallelCellManager(initialize=False, dimension=1) parray = ParticleArray(name='parray') if rank == 0: lg = LineGenerator(start_point=Point(0, 0, 0), end_point=Point(1.0, 0, 0), particle_spacing=0.01) x, y, z = lg.get_coords() parray.add_property({'name': 'x', 'data': x}) parray.add_property({'name': 'y', 'data': y}) parray.add_property({'name': 'z', 'data': z}) parray.add_property({'name': 'h'}) parray.align_particles() parray.h[:] = 0.01 else: parray.add_property({'name': 'x'})
lg = LineGenerator(particle_spacing=0.5) lg.start_point.x = 0.0 lg.end_point.x = 10.0 lg.start_point.y = lg.start_point.z = 0.0 lg.end_point.y = lg.end_point.z = 0.0 x, y, z = lg.get_coords() num_particles = len(x) logger.info('Num particles : %d'%(len(x))) parray = ParticleArray(name='p1', x={'data':x}, y={'data':y}, z={'data':z}, h={'data':None, 'default':0.5}) # add parray to the cell manager parray.add_property({'name':'u'}) parray.add_property({'name':'v'}) parray.add_property({'name':'w'}) parray.add_property({'name':'rho'}) parray.add_property({'name':'p'}) parray = LoadBalancer.distribute_particles(parray, num_procs, 1.0)[rank] pcm.add_array_to_bin(parray) np = pcm.arrays_to_bin[0].num_real_particles
def test(): pcm = ParallelCellManager(initialize=False) # create 2 particles, one with proc 0 another with proc 1 lg = LineGenerator(particle_spacing=0.5) lg.start_point.x = 0.0 lg.end_point.x = 10.0 lg.start_point.y = lg.start_point.z = 0.0 lg.end_point.y = lg.end_point.z = 0.0 x, y, z = lg.get_coords() num_particles = len(x) logger.info('Num particles : %d'%(len(x))) parray = ParticleArray(name='p1', x={'data':x}, y={'data':y}, z={'data':z}, h={'data':None, 'default':0.5}) # add parray to the cell manager parray.add_property({'name':'u'}) parray.add_property({'name':'v'}) parray.add_property({'name':'w'}) parray.add_property({'name':'rho'}) parray.add_property({'name':'p'}) parray = LoadBalancer.distribute_particles(parray, num_procs, 1.0)[rank] pcm.add_array_to_bin(parray) np = pcm.arrays_to_bin[0].num_real_particles nptot = comm.bcast(comm.reduce(np)) assert nptot == num_particles pcm.initialize() np = pcm.arrays_to_bin[0].num_real_particles nptot = comm.bcast(comm.reduce(np)) assert nptot == num_particles pcm.set_jump_tolerance(INT_INF()) logger.debug('%d: num_cells=%d'%(rank,len(pcm.cells_dict))) logger.debug('%d:'%rank + ('\n%d '%rank).join([str(c) for c in pcm.cells_dict.values()])) # on processor 0 move all particles from one of its cell to the next cell if rank == 0: cell = pcm.cells_dict.get(list(pcm.proc_map.cell_map.values()[0])[0]) logger.debug('Cell is %s'%(cell)) indices = [] cell.get_particle_ids(indices) indices = indices[0] logger.debug('Num particles in Cell is %d'%(indices.length)) parr = cell.arrays_to_bin[0] x, y, z = parr.get('x', 'y', 'z', only_real_particles=False) logger.debug(str(len(x)) + str(x)) logger.debug(str(indices.length) + str(indices.get_npy_array())) for i in range(indices.length): x[indices[i]] += cell.cell_size parr.set_dirty(True) pcm.update_status() logger.debug('Calling cell manager update') logger.debug('Is dirty %s'%(pcm.is_dirty)) pcm.update() np = pcm.arrays_to_bin[0].num_real_particles nptot = comm.bcast(comm.reduce(np)) assert nptot == num_particles #logger.debug('hierarchy :%s'%(pcm.hierarchy_list)) logger.debug('cells : %s'%(pcm.cells_dict)) logger.debug('num particles : %d'%(parray.get_number_of_particles())) logger.debug('real particles : %d'%(parray.num_real_particles))
logging.basicConfig(level=logging.DEBUG, filename=log_file_name, filemode='w') logger.addHandler(logging.StreamHandler()) # local imports from pysph.base.particle_array import ParticleArray from pysph.parallel.parallel_cell import ParallelCellManager from pysph.solver.basic_generators import LineGenerator from pysph.base.cell import INT_INF from pysph.base.point import * pcm = ParallelCellManager(initialize=False) # create two particles, one with proc 0 another with proc 1 if rank == 0: parray = ParticleArray() parray.add_property({'name':'x', 'data':[0.4]}) parray.add_property({'name':'h', 'data':[0.1]}) elif rank == 1: parray = ParticleArray() parray.add_property({'name':'x', 'data':[1.2]}) parray.add_property({'name':'h', 'data':[0.1]}) elif rank == 2: parray = ParticleArray() parray.add_property({'name':'x', 'data':[2.0]}) parray.add_property({'name':'h', 'data':[0.1]}) parray.add_property({'name':'y'}) parray.add_property({'name':'z'}) parray.add_property({'name':'t'}) parray.align_particles()
log_file_name = '/tmp/log_pysph_' + str(rank) logging.basicConfig(level=logging.DEBUG, filename=log_file_name, filemode='w') logger.addHandler(logging.StreamHandler()) # local imports from pysph.base.particle_array import ParticleArray from pysph.parallel.parallel_cell import ParallelCellManager from pysph.solver.basic_generators import LineGenerator from pysph.base.cell import INT_INF from pysph.base.point import * pcm = ParallelCellManager(initialize=False) # create two particles, one with proc 0 another with proc 1 if rank == 0: parray = ParticleArray() parray.add_property({'name': 'x', 'data': [0.4]}) parray.add_property({'name': 'h', 'data': [0.1]}) elif rank == 1: parray = ParticleArray() parray.add_property({'name': 'x', 'data': [1.2]}) parray.add_property({'name': 'h', 'data': [0.1]}) elif rank == 2: parray = ParticleArray() parray.add_property({'name': 'x', 'data': [2.0]}) parray.add_property({'name': 'h', 'data': [0.1]}) parray.add_property({'name': 'y'}) parray.add_property({'name': 'z'}) parray.add_property({'name': 't'}) parray.align_particles()
from pysph.solver.utils import dump, load def assert_lists_same(l1, l2): expect = list(sorted(l1)) result = list(sorted(l2)) assert l1 == l2, "Expected %s, got %s"%(l1, l2) comm = mpi.COMM_WORLD rank = comm.Get_rank() size = comm.Get_size() root = mkdtemp() filename = join(root, 'test.npz') x = np.ones(5, dtype=float)*rank pa = ParticleArray(name='fluid', constants={'c1': 0.0, 'c2': [0.0, 0.0]}, x=x) try: dump(filename, [pa], {}, mpi_comm=comm) if rank == 0: data = load(filename) pa1 = data["arrays"]["fluid"] assert_lists_same(pa.properties.keys(), pa1.properties.keys()) assert_lists_same(pa.constants.keys(), pa1.constants.keys()) expect = np.ones(5*size) for i in range(size): expect[5*i:5*(i+1)] = i assert np.allclose(pa1.x, expect, atol=1e-14), \
log_file_name = "/tmp/log_pysph_" + str(rank) logging.basicConfig(level=logging.DEBUG, filename=log_file_name, filemode="w") logger.addHandler(logging.StreamHandler()) # local imports from pysph.base.particle_array import ParticleArray from pysph.parallel.parallel_cell import ParallelCellManager from pysph.solver.basic_generators import LineGenerator from pysph.base.cell import INT_INF from pysph.base.point import * pcm = ParallelCellManager(initialize=False) # create two particles, one with proc 0 another with proc 1 if rank == 0: parray = ParticleArray() parray.add_property({"name": "x", "data": [0.4]}) parray.add_property({"name": "h", "data": [0.1]}) elif rank == 1: parray = ParticleArray() parray.add_property({"name": "x", "data": [1.2]}) parray.add_property({"name": "h", "data": [0.1]}) elif rank == 2: parray = ParticleArray() parray.add_property({"name": "x", "data": [2.0]}) parray.add_property({"name": "h", "data": [0.1]}) parray.add_property({"name": "y"}) parray.add_property({"name": "z"}) parray.add_property({"name": "t"}) parray.align_particles()
log_file_name = "/tmp/log_pysph_" + str(rank) logging.basicConfig(level=logging.DEBUG, filename=log_file_name, filemode="w") logger.addHandler(logging.StreamHandler()) # local imports from pysph.base.particle_array import ParticleArray from pysph.parallel.parallel_cell import ParallelCellManager from pysph.solver.basic_generators import LineGenerator from pysph.base.cell import INT_INF from pysph.base.point import * pcm = ParallelCellManager(initialize=False, dimension=1) parray = ParticleArray(name="parray") if rank == 0: lg = LineGenerator(start_point=Point(0, 0, 0), end_point=Point(1.0, 0, 0), particle_spacing=0.01) x, y, z = lg.get_coords() parray.add_property({"name": "x", "data": x}) parray.add_property({"name": "y", "data": y}) parray.add_property({"name": "z", "data": z}) parray.add_property({"name": "h"}) parray.align_particles() parray.h[:] = 0.01 else: parray.add_property({"name": "x"}) parray.add_property({"name": "y"}) parray.add_property({"name": "z"})
lg = LineGenerator(particle_spacing=0.5) lg.start_point.x = 0.0 lg.end_point.x = 10.0 lg.start_point.y = lg.start_point.z = 0.0 lg.end_point.y = lg.end_point.z = 0.0 x, y, z = lg.get_coords() num_particles = len(x) logger.info('Num particles : %d' % (len(x))) parray = ParticleArray(name='p1', x={'data': x}, y={'data': y}, z={'data': z}, h={ 'data': None, 'default': 0.5 }) # add parray to the cell manager parray.add_property({'name': 'u'}) parray.add_property({'name': 'v'}) parray.add_property({'name': 'w'}) parray.add_property({'name': 'rho'}) parray.add_property({'name': 'p'}) parray = LoadBalancer.distribute_particles(parray, num_procs, 1.0)[rank] pcm.add_array_to_bin(parray) np = pcm.arrays_to_bin[0].num_real_particles