def test_dump_and_load_with_constants(self):
x = np.linspace(0, 1.0, 10)
y = x * 2.0
pa = get_particle_array_wcsph(name='fluid',
x=x,
y=y,
constants={
'c1': 1.0,
'c2': [2.0, 3.0]
})
pa.add_property('A', data=2.0, stride=2)
pa.set_output_arrays(['x', 'y', 'A'])
fname = self._get_filename('simple')
dump(fname, [pa], solver_data={})
data = load(fname)
arrays = data['arrays']
pa1 = arrays['fluid']
self.assertListEqual(list(sorted(pa.properties.keys())),
list(sorted(pa1.properties.keys())))
self.assertListEqual(list(sorted(pa.constants.keys())),
list(sorted(pa1.constants.keys())))
self.assertTrue(np.allclose(pa.x, pa1.x, atol=1e-14))
self.assertTrue(np.allclose(pa.y, pa1.y, atol=1e-14))
self.assertTrue(np.allclose(pa.A, pa1.A, atol=1e-14))
self.assertTrue(np.allclose(pa.c1, pa1.c1, atol=1e-14))
self.assertTrue(np.allclose(pa.c2, pa1.c2, atol=1e-14))
def _handle_particle_array_updates(self):
# Called when the particle array helper fires an updated event.
if self._particle_array_updated and self._file_name:
sd = self._solver_data
arrays = [x.particle_array for x in self.particle_arrays]
dump(self._file_name, arrays, sd)
self._particle_array_updated = False
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 dump_output(self):
"""Dump the simulation results to file
The arrays used for printing are determined by the particle
array's `output_property_arrays` data attribute. For debugging
it is sometimes nice to have all the arrays (including
accelerations) saved. This can be chosen from using the
command line option `--detailed-output`
Output data Format:
A single file named as: <fname>_<rank>_<iteration_count>.npz
The data is saved as a Python dictionary with two keys:
`solver_data` : Solver meta data like time, dt and iteration number
`arrays` : A dictionary keyed on particle array names and with
particle properties as value.
Example:
You can load the data output by PySPH like so:
>>> from pysph.solver.utils import load
>>> data = load('output_directory/filename_x_xxx.npz')
>>> solver_data = data['solver_data']
>>> arrays = data['arrays']
>>> fluid = arrays['fluid']
>>> ...
In the above example, it is assumed that the output file
contained an array named fluid.
"""
if self.disable_output:
return
if self.rank == 0:
msg = 'Writing output at time %g, iteration %d, dt = %g' % (
self.t, self.count, self.dt)
logger.info(msg)
fname = os.path.join(self.output_directory,
self.fname + '_' + str(self.count))
comm = None
if self.parallel_output_mode == "collected" and self.in_parallel:
comm = self.comm
dump(fname,
self.particles,
self._get_solver_data(),
detailed_output=self.detailed_output,
only_real=self.output_only_real,
mpi_comm=comm,
compress=self.compress_output)
def _handle_particle_array_updates(self):
# Called when the particle array helper fires an updated event.
if self._particle_array_updated and self._file_name:
sd = self._solver_data
arrays = [x.particle_array for x in self.particle_arrays]
detailed = self._requires_detailed_output(arrays)
dump(self._file_name, arrays, sd, detailed_output=detailed,
only_real=False)
self._particle_array_updated = False
def test_dump_and_load_with_partial_data_dump(self):
x = np.linspace(0, 1.0, 10)
y = x*2.0
pa = get_particle_array_wcsph(name='fluid', x=x, y=y)
pa.set_output_arrays(['x', 'y'])
fname = self._get_filename('simple')
dump(fname, [pa], solver_data={})
data = load(fname)
arrays = data['arrays']
pa1 = arrays['fluid']
self.assertListEqual(list(sorted(pa.properties.keys())),
list(sorted(pa1.properties.keys())))
self.assertTrue(np.allclose(pa.x, pa1.x, atol=1e-14))
self.assertTrue(np.allclose(pa.y, pa1.y, atol=1e-14))
def test_dump_and_load_works_by_default(self):
x = np.linspace(0, 1.0, 10)
y = x*2.0
dt = 1.0
pa = get_particle_array(name='fluid', x=x, y=y)
fname = self._get_filename('simple')
dump(fname, [pa], solver_data={'dt': dt})
data = load(fname)
solver_data = data['solver_data']
arrays = data['arrays']
pa1 = arrays['fluid']
self.assertListEqual(list(solver_data.keys()), ['dt'])
self.assertListEqual(list(sorted(pa.properties.keys())),
list(sorted(pa1.properties.keys())))
self.assertTrue(np.allclose(pa.x, pa1.x, atol=1e-14))
self.assertTrue(np.allclose(pa.y, pa1.y, atol=1e-14))
def test_that_output_array_information_is_saved(self):
# Given
x = np.linspace(0, 1.0, 10)
y = x*2.0
pa = get_particle_array(name='fluid', x=x, y=y, u=3*x)
# When
output_arrays = ['x', 'y', 'u']
pa.set_output_arrays(output_arrays)
fname = self._get_filename('simple')
dump(fname, [pa], solver_data={})
data = load(fname)
pa1 = data['arrays']['fluid']
# Then.
self.assertEqual(set(pa.output_property_arrays), set(output_arrays))
self.assertEqual(set(pa1.output_property_arrays), set(output_arrays))
def test_dump_and_load_works_with_compress(self):
x = np.linspace(0, 1.0, 10)
y = x*2.0
dt = 1.0
pa = get_particle_array(name='fluid', x=x, y=y)
fname = self._get_filename('simple')
dump(fname, [pa], solver_data={'dt': dt})
fnamez = self._get_filename('simplez')
dump(fnamez, [pa], solver_data={'dt': dt}, compress=True)
# Check that the file size is indeed smaller
self.assertTrue(os.stat(fnamez).st_size < os.stat(fname).st_size)
data = load(fnamez)
solver_data = data['solver_data']
arrays = data['arrays']
pa1 = arrays['fluid']
self.assertListEqual(list(solver_data.keys()), ['dt'])
self.assertListEqual(list(sorted(pa.properties.keys())),
list(sorted(pa1.properties.keys())))
self.assertTrue(np.allclose(pa.x, pa1.x, atol=1e-14))
self.assertTrue(np.allclose(pa.y, pa1.y, atol=1e-14))
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), \
"Expected %s, got %s"%(expect, pa1.x)
finally:
shutil.rmtree(root)
