def post_process(self, info_fname):
self.read_info(info_fname)
if len(self.output_files) == 0:
return
from pysph.tools.interpolator import Interpolator
from pysph.solver.utils import iter_output
files = self.output_files
y = np.linspace(0, 0.9, 20)
x = np.ones_like(y)
interp = None
t, p, p_ex = [], [], []
for sd, arrays in iter_output(files):
fluid, solid = arrays['fluid'], arrays['solid']
if interp is None:
interp = Interpolator([fluid, solid], x=x, y=y)
else:
interp.update_particle_arrays([fluid, solid])
t.append(sd['t'])
p.append(interp.interpolate('p'))
g = 1.0 * damping_factor(t[-1], tdamp)
p_ex.append(abs(rho0 * H * g))
t, p, p_ex = list(map(np.asarray, (t, p, p_ex)))
res = os.path.join(self.output_dir, 'results.npz')
np.savez(res, t=t, p=p, p_ex=p_ex, y=y)
import matplotlib
matplotlib.use('Agg')
pmax = abs(0.9 * rho0 * gy)
from matplotlib import pyplot as plt
plt.plot(t, p[:, 0] / pmax, 'o-')
plt.xlabel(r'$t$')
plt.ylabel(r'$p$')
fig = os.path.join(self.output_dir, 'p_bottom.png')
plt.savefig(fig, dpi=300)
plt.clf()
output_at = np.arange(0.25, 2.1, 0.25)
count = 0
for i in range(len(t)):
if abs(t[i] - output_at[count]) < 1e-8:
plt.plot(y, p[i] / pmax, 'o', label='t=%.2f' % t[i])
plt.plot(y, p_ex[i] * (H - y) / (H * pmax), 'k-')
count += 1
plt.xlabel('$y$')
plt.ylabel('$p$')
plt.legend()
fig = os.path.join(self.output_dir, 'p_vs_y.png')
plt.savefig(fig, dpi=300)
def test_should_be_able_to_update_particle_arrays(self):
# Given
pa = self._make_2d_grid()
pa_new = self._make_2d_grid()
pa_new.p[:] = np.cos(pa_new.x * np.pi)
ip = Interpolator([pa], num_points=1000, domain_manager=self._domain)
p = ip.interpolate('p')
# When.
ip.update_particle_arrays([pa_new])
p = ip.interpolate('p')
# Then.
expect = np.cos(ip.x * np.pi)
np.testing.assert_allclose(p, expect, rtol=5e-3)
def test_should_be_able_to_update_particle_arrays(self):
# Given
pa = self._make_2d_grid()
pa_new = self._make_2d_grid()
pa_new.p[:] = 10.0
ip = Interpolator([pa], num_points=1000)
p = ip.interpolate('p')
# When.
ip.update_particle_arrays([pa_new])
p = ip.interpolate('p')
# Then.
expect = np.ones_like(p) * 10.0
self.assertTrue(np.allclose(p, expect))
def test_should_be_able_to_update_particle_arrays(self):
# Given
pa = self._make_2d_grid()
pa_new = self._make_2d_grid()
pa_new.p[:] = 10.0
ip = Interpolator([pa], num_points=1000)
p = ip.interpolate('p')
# When.
ip.update_particle_arrays([pa_new])
p = ip.interpolate('p')
# Then.
expect = np.ones_like(p)*10.0
self.assertTrue(np.allclose(p, expect))
def get_data():
error_u = {}
error_v = {}
for kernel in ['cs', 'g', 'qs', 'wq']:
for nx in [50, 100, 200]:
for hdx in [1.0, 1.5, 2.0]:
sub_dir = kernel + '_' + str(hdx) + '_' + str(nx)
files = []
for fil in os.listdir(cwd + '/' + sub_dir):
if fil.endswith(".npz") and fil != 'results.npz':
files.append(fil)
f_num = [int(f.split('_')[1].split('.')[0]) for f in files]
zipped = zip(f_num, files)
last_file = sorted(zipped)[-1][1]
data = load(sub_dir + '/' + last_file)
_x = np.linspace(0, 1, nx)
xx, yy = np.meshgrid(_x, _x)
interp = Interpolator(list(data['arrays'].values()),
x=xx,
y=yy)
ui = np.zeros_like(xx)
vi = np.zeros_like(xx)
interp.update_particle_arrays(list(data['arrays'].values()))
_u = interp.interpolate('u')
_v = interp.interpolate('v')
_u.shape = nx, nx
_v.shape = nx, nx
ui += _u
vi += _v
particle = data['arrays']
fluid = particle['fluid']
u = fluid.u
v = fluid.v
ui = np.ravel(ui)
vi = np.ravel(vi)
error_u[sub_dir] = l2_error(ui, u)
error_v[sub_dir] = l2_error(vi, v)
return error_u, error_v
def _plot_velocity(self):
from pysph.tools.interpolator import Interpolator
from pysph.solver.utils import load
from pysph.examples.ghia_cavity_data import get_u_vs_y, get_v_vs_x
# interpolated velocities
_x = np.linspace(0, 1, 101)
xx, yy = np.meshgrid(_x, _x)
# take the last solution data
fname = self.output_files[-1]
data = load(fname)
tf = data['solver_data']['t']
interp = Interpolator(list(data['arrays'].values()), x=xx, y=yy)
ui = np.zeros_like(xx)
vi = np.zeros_like(xx)
# Average out the velocities over the last n_avg timesteps
for fname in self.output_files[-self.n_avg:]:
data = load(fname)
tf = data['solver_data']['t']
interp.update_particle_arrays(list(data['arrays'].values()))
_u = interp.interpolate('u')
_v = interp.interpolate('v')
_u.shape = 101, 101
_v.shape = 101, 101
ui += _u
vi += _v
ui /= self.n_avg
vi /= self.n_avg
# velocity magnitude
self.vmag = vmag = np.sqrt(ui**2 + vi**2)
import matplotlib.pyplot as plt
f = plt.figure()
plt.streamplot(
xx,
yy,
ui,
vi,
density=(2, 2), #linewidth=5*vmag/vmag.max(),
color=vmag)
plt.xlim(0, 1)
plt.ylim(0, 1)
plt.colorbar()
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.title('Streamlines at %s seconds' % tf)
fig = os.path.join(self.output_dir, 'streamplot.png')
plt.savefig(fig, dpi=300)
f = plt.figure()
ui_c = ui[:, 50]
vi_c = vi[50]
s1 = plt.subplot(211)
s1.plot(ui_c, _x, label='Computed')
y, data = get_u_vs_y()
if self.re in data:
s1.plot(data[self.re],
y,
'o',
fillstyle='none',
label='Ghia et al.')
s1.set_xlabel(r'$v_x$')
s1.set_ylabel(r'$y$')
s1.legend()
s2 = plt.subplot(212)
s2.plot(_x, vi_c, label='Computed')
x, data = get_v_vs_x()
if self.re in data:
s2.plot(x,
data[self.re],
'o',
fillstyle='none',
label='Ghia et al.')
s2.set_xlabel(r'$x$')
s2.set_ylabel(r'$v_y$')
s2.legend()
fig = os.path.join(self.output_dir, 'centerline.png')
plt.savefig(fig, dpi=300)
return _x, ui, vi, ui_c, vi_c
class LEDCube(Application):
def initialize(self):
self.interpolator = None
def create_particles(self):
nb = 2
nx = 1.0 / dx
sl = slice(-nb * dx, 1 + nb * dx, (nx + 2 * nb) * 1j)
x, y, z = np.mgrid[sl, sl, sl]
x, y, z = (np.ravel(t) for t in (x, y, z))
inside = (x > 0) & (x < 1) & (y > 0) & (y < 1) & (z > 0) & (z < 1)
outside = ~inside
water = inside & (z < water_height)
# the fluid.
h0 = hdx * dx
m = dx * dx * dx * rho
one_f = np.ones_like(x[water])
fluid = get_particle_array_wcsph(name='fluid',
x=x[water],
y=y[water],
z=z[water],
rho=rho * one_f,
h=h0 * one_f,
m=m * one_f)
one_s = np.ones_like(x[outside])
solid = get_particle_array_wcsph(name='solid',
x=x[outside],
y=y[outside],
z=z[outside],
rho=rho * one_s,
h=h0 * one_s,
m=m * one_s)
led = get_particle_array_wcsph(name='led',
x=x[inside],
y=y[inside],
z=z[inside])
return [fluid, solid, led]
def create_scheme(self):
s = WCSPHScheme(['fluid'], ['solid'],
dim=3,
rho0=1000,
c0=c0,
h0=hdx * dx,
hdx=hdx,
gz=-9.81,
alpha=0.25,
beta=0.0,
gamma=7,
hg_correction=True,
tensile_correction=False)
extra_steppers = dict(solid=OneStageRigidBodyStep(),
led=OneStageRigidBodyStep())
s.configure_solver(extra_steppers=extra_steppers, tf=10.0, dt=dt)
return s
def create_equations(self):
eqs = self.scheme.get_equations()
eqs[0].equations.append(CubeMotion(dest='solid', sources=['solid']))
eqs[0].equations.append(CubeMotion(dest='led', sources=['led']))
return eqs
def post_step(self, solver):
if solver.count % 5 == 0:
self._create_interpolator()
rho = self.interpolator.interpolate('rho')
print(rho)
def _create_interpolator(self):
led = self.particles[2]
if self.interpolator is None:
from pysph.tools.interpolator import Interpolator
# This is as per the order returned in create_particles.
self.interpolator = Interpolator(self.particles,
x=led.x,
y=led.y,
z=led.z)
else:
self.interpolator.update_particle_arrays(self.particles)
self.interpolator.set_interpolation_points(x=led.x,
y=led.y,
z=led.z)
