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
