def create_solver(self):
self.cm = cm = ParallelCellManager(self.pas, self.cell_size,
self.cell_size)
#print 'num_cells:', len(cm.cells_dict)
cm.load_balancing = False # balancing will be done manually
cm.dimension = self.dim
self.lb = lb = self.cm.load_balancer = LoadBalancer(
parallel_cell_manager=self.cm)
lb.skip_iteration = 1
lb.threshold_ratio = 10.
lb.lb_max_iteration = 10
lb.setup()
def create_cell_manager(options):
print 'creating cell manager', options
# create a parallel cell manager.
cell_manager = ParallelCellManager(arrays_to_bin=[],
max_cell_scale=options.max_cell_scale,
dimension=2,
load_balancing=False,
initialize=False)
# enable load balancing
cell_manager.load_balancer = LoadBalancer(
parallel_cell_manager=cell_manager)
cell_manager.load_balancer.skip_iteration = 1
cell_manager.load_balancer.threshold_ratio = 10.
for i, pa in enumerate(create_particles(options)):
cell_manager.arrays_to_bin.append(pa)
print 'parray %d:' % i, pa.get_number_of_particles()
cell_manager.initialize()
print 'num_particles', cell_manager.get_number_of_particles()
return cell_manager
# logging setup
# logging setup
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
def __init__(self,
arrays=[],
in_parallel=False,
variable_h=False,
load_balancing=True,
update_particles=True,
locator_type=SPHNeighborLocator,
periodic_domain=None,
min_cell_size=-1):
""" Constructor
Parameters:
-----------
arrays -- list of particle arrays in the simulation
in_parallel -- flag for parallel runs
variable_h -- flag for variable smoothing lengths
load_balancing -- flag for dynamic load balancing.
periodic_domain -- the periodic domain for periodicity
"""
# set the flags
self.variable_h = variable_h
self.in_parallel = in_parallel
self.load_balancing = load_balancing
self.locator_type = locator_type
# Some sanity checks on the input arrays.
assert len(arrays) > 0, "Particles must be given some arrays!"
prec = arrays[0].cl_precision
msg = "All arrays must have the same cl_precision"
for arr in arrays[1:]:
assert arr.cl_precision == prec, msg
self.arrays = arrays
self.kernel = None
# create the cell manager
if not in_parallel:
self.cell_manager = CellManager(arrays_to_bin=arrays,
min_cell_size=min_cell_size,
periodic_domain=periodic_domain)
else:
self.cell_manager = ParallelCellManager(
arrays_to_bin=arrays, load_balancing=load_balancing)
self.pid = self.cell_manager.pid
# create the nnps manager
self.nnps_manager = NNPSManager(cell_manager=self.cell_manager,
variable_h=variable_h,
locator_type=self.locator_type)
# set defaults
self.correction_manager = None
self.misc_prop_update_functions = []
# call an update on the particles (i.e index)
if update_particles:
self.update()
# logging setup
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)
# 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]})
