def _compute_results(self):
from pysph.solver.utils import iter_output
from collections import defaultdict
data = defaultdict(list)
for sd, array in iter_output(self.output_files, 'fluid'):
_t = sd['t']
data['t'].append(_t)
m, u, v, x, y = array.get('m', 'u', 'v', 'x', 'y')
vmag2 = u**2 + v**2
mom = np.sum(m*np.sqrt(vmag2))
data['ke'].append(0.5*np.sum(m*vmag2))
data['xmax'].append(x.max())
data['ymax'].append(y.max())
a, A, po, _xe, _ye = exact_solution(_t, n=0)
data['minor'].append(a)
data['major'].append(1.0/a)
data['xe'].append(_xe)
data['ye'].append(_ye)
data['y'].append(y)
data['x'].append(x)
data['mom'].append(mom)
for key in data:
data[key] = np.asarray(data[key])
fname = os.path.join(self.output_dir, 'results.npz')
np.savez(fname, **data)
def post_process(self):
if len(self.output_files) == 0:
return
from pysph.solver.utils import iter_output
files = self.output_files
t, amplitude = [], []
for sd, array in iter_output(files, 'plate'):
_t = sd['t']
t.append(_t)
amplitude.append(array.y[array.amplitude_idx[0]])
import matplotlib
import os
matplotlib.use('Agg')
from matplotlib import pyplot as plt
plt.clf()
plt.plot(t, amplitude)
plt.xlabel('t')
plt.ylabel('Amplitude')
plt.legend()
fig = os.path.join(self.output_dir, "amplitude.png")
plt.savefig(fig, dpi=300)
def post_process(self, info_fname):
info = self.read_info(info_fname)
if len(self.output_files) == 0:
return
from pysph.solver.utils import iter_output
t, x_max = [], []
factor = np.sqrt(2.0 * 9.81 / fluid_column_width)
files = self.output_files
for sd, array in iter_output(files, 'fluid'):
t.append(sd['t'] * factor)
x = array.get('x')
x_max.append(x.max())
t, x_max = list(map(np.asarray, (t, x_max)))
fname = os.path.join(self.output_dir, 'results.npz')
np.savez(fname, t=t, x_max=x_max)
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
from pysph.examples import db_exp_data as dbd
plt.plot(t, x_max, label='Computed')
te, xe = dbd.get_koshizuka_oka_data()
plt.plot(te, xe, 'o', label='Koshizuka & Oka (1996)')
plt.xlim(0, 0.7 * factor)
plt.ylim(0, 4.5)
plt.xlabel('$T$')
plt.ylabel('$Z/L$')
plt.legend(loc='upper left')
plt.savefig(os.path.join(self.output_dir, 'x_vs_t.png'), dpi=300)
plt.close()
def combined_loghist(file_loc, ax=None, cond=0.0, Bins=20, **plot_kwargs):
if ax == None:
ax = plt.gca()
files = get_files(file_loc)
df = np.array([])
cnt = 0
for solver_data, fluid in iter_output(files, 'fluid'):
if cnt == 0:
cnt = 1
else:
df = np.concatenate([df, fluid.DRh])
cnt += 1
cnt -= 1
hist, bins = np.histogram(df, bins=Bins)
hist_norm = hist / cnt
width = 0.9 * (bins[1] - bins[0])
center = (bins[:-1] + bins[1:]) / 2
#ax.bar(center, hist_norm, align='center', width=width, log=True)
plot_loghist(df, bins=Bins, ax=ax, log=True)
temp = (df <= cond).sum()
res = round(temp * 100 / len(df), 3)
return res
def post_process(self, info_fname):
self.read_info(info_fname)
if len(self.output_files) == 0:
return
from pysph.solver.utils import iter_output
import matplotlib.pyplot as plt
from pysph.examples import db_exp_data as dbd
from pysph.tools.interpolator import Interpolator
import os
H = self.geom.fluid_column_height
factor_y = 1 / (ro * 9.81 * H)
factor_x = np.sqrt(9.81 / H)
t1, t3, data_p1, data_p3 = dbd.get_kleefsman_data()
files = self.output_files
t = []
p0 = []
x_probe = self.geom.obstacle_center_x - self.geom.obstacle_length * 0.5
p_x = np.repeat(x_probe, 2)
p_y = np.repeat(0, 2)
p_z = np.array([0.021, 0.101])
for sd, arrays1, arrays2, arrays3 in iter_output(
files, "fluid", "obstacle", "boundary"):
t.append(sd["t"] * factor_x)
interp = Interpolator([arrays1, arrays2, arrays3],
x=p_x,
y=p_y,
z=p_z,
method="shepard")
p0.append(interp.interpolate('p') * factor_y)
fname = os.path.join(self.output_dir, 'results.npz')
t, p0 = list(map(np.asarray, (t, p0)))
np.savez(fname, t=t, p0=p0)
p1 = p0[:, 0]
p3 = p0[:, 1]
fig1 = plt.figure()
plt.plot(t, p1, label="p1 computed", figure=fig1)
plt.plot(t1, data_p1, label="Kleefsman et al.", figure=fig1)
plt.legend()
plt.ylabel(r"$\frac{P}{\rho gH}$")
plt.xlabel(r"$t \sqrt{\frac{g}{H}} $")
plt.title("P1")
plt.savefig(os.path.join(self.output_dir, 'p1_vs_t.png'))
fig2 = plt.figure()
plt.plot(t, p3, label="p3 computed", figure=fig2)
plt.plot(t3, data_p3, label="Kleefsman et al.", figure=fig2)
plt.legend()
plt.ylabel(r"$\frac{P}{\rho gH}$")
plt.xlabel(r"$t \sqrt{\frac{g}{H}} $")
plt.title("P3")
plt.savefig(os.path.join(self.output_dir, 'p3_vs_t.png'))
def get_ke_history(files, array_name):
t, ke = [], []
for sd, array in utils.iter_output(files, array_name):
t.append(sd['t'])
m, u, v, w = array.get('m', 'u', 'v', 'w')
_ke = 0.5 * np.sum(m * (u**2 + v**2 + w**2))
ke.append(_ke)
return np.asarray(t), np.asarray(ke)
def post_process(self, info_fname):
import os
info = self.read_info(info_fname)
if len(self.output_files) == 0:
return
from pysph.solver.utils import iter_output
files = self.output_files
t, xa, ya, r_err = [], [], [], []
for sd, array in iter_output(files, 'fluid'):
_t = sd['t']
t.append(_t)
x, y = array.get('x', 'y')
xa.append(x[0])
ya.append(y[0])
err = np.abs(np.sqrt(x[0] * x[0] + y[0] * y[0]) - self.R)
r_err.append(err)
t = np.array(t)
xa = np.array(xa)
ya = np.array(ya)
r_err = np.array(r_err)
fname = os.path.join(self.output_dir, 'results.npz')
np.savez(fname, t=t, x=xa, y=ya, r_err=r_err)
import matplotlib
matplotlib.use('Agg')
if self.INT == "eul":
tle = "Euler Integrator"
else:
tle = "RK-4 Integrator"
from matplotlib import pyplot as plt
plt.clf()
plt.plot(t, xa, label='x')
plt.plot(t, ya, label='y')
plt.plot(t, self.R * np.cos(t), label='exact x')
plt.plot(t, self.R * np.sin(t), label='exact y')
plt.xlabel('t')
plt.legend()
plt.title(tle)
fig = os.path.join(self.output_dir, "error_position.png")
plt.savefig(fig, dpi=300)
plt.clf()
plt.plot(t, np.sqrt(xa * xa + ya * ya), label='radius')
plt.plot(t, self.R * np.ones_like(t), label='exact radius')
plt.xlabel('t')
plt.legend()
plt.title(tle)
fig = os.path.join(self.output_dir, "error_radius.png")
plt.savefig(fig, dpi=300)
def post_process(self, info_fname):
"""
Comparing wave height 0.05 m to the left of the tank
"""
self.read_info(info_fname)
if len(self.output_files) == 0:
return
from pysph.solver.utils import iter_output
import matplotlib.pyplot as plt
from cyarray.api import UIntArray
from pysph.base import nnps
files = self.output_files
wave_height, t = [], []
for sd, arrays1, arrays2 in iter_output(files, 'fluid', 'solid'):
t.append(sd['t'])
x_left = arrays2.x.min()
probe_x = x_left + 0.05 + self.dx * (n_layers - 1)
probe_y = np.linspace(0, arrays1.y.max(), 50)
probe = get_particle_array(x=probe_x * np.ones_like(probe_y),
y=probe_y)
pa_list = [arrays1, probe]
nps = nnps.LinkedListNNPS(dim=2, particles=pa_list, radius_scale=1)
src_index, dst_index = 0, 1
nps.set_context(src_index=0, dst_index=1)
nbrs = UIntArray()
wh = 0.0
for i in range(len(probe_y)):
nps.get_nearest_particles(src_index, dst_index, i, nbrs)
neighbours = nbrs.get_npy_array()
for j in range(len(neighbours)):
if arrays1.y[neighbours[j]] > wh:
wh = arrays1.y[neighbours[j]]
wave_height.append(wh)
wave_height = np.array(wave_height)
wave_height = wave_height - h
import pysph.examples.st_exp_data as st
exp_t, exp_H = st.get_bouscasse_data()
T = 2 * pi / omega
t = np.array(t) / T
plt.plot(t, wave_height, label="Computed")
plt.scatter(exp_t, exp_H, label="Experiment: Bouscasse et al, 2013")
plt.xlabel("t/T")
plt.ylabel("Wave Height (m)")
plt.xlim(8.5, 11)
plt.legend()
plt.savefig(os.path.join(self.output_dir, 'H_vs_t.png'))
plt.show()
def post_processing(self):
files = get_files('test_7_output')
t = []
y1 = []
y2 = []
for solver_data, al, copper in iter_output(files, 'al', 'copper'):
t.append(solver_data['t'])
y1.append(-al.wz[0])
y2.append(-copper.wz[0])
print("Done")
print(y1)
print(y2)
def post_processing(self):
files = get_files('big_simulation_output')
t = []
y1 = []
for solver_data, cube in iter_output(files, 'cube'):
t.append(solver_data['t'])
y1.append(cube.cm[1])
print("Done")
dat = np.array([t, y1])
dat = dat.T
print(dat)
np.savetxt('data.txt', dat, delimiter=',')
def post_processing(self):
files = get_files('test_4_output')
t = []
y1 = []
for solver_data, sand, wall in iter_output(files, 'sand', 'wall'):
t.append(solver_data['t'])
y1.append(sand.wz[0])
print("Done")
target = open('output.txt', 'a+')
target.write(str(y1[-1]))
target.close()
print(y1[-1])
def post_process(self, info_fname):
self.read_info(info_fname)
if len(self.output_files) == 0:
return
from pysph.solver.utils import iter_output
import matplotlib.pyplot as plt
from pysph.examples import db_exp_data as dbd
from pysph.tools.interpolator import Interpolator
import os
exp_vt, exp_v, exp_ft, exp_f = dbd.get_yeh_petroff_data()
files = self.output_files
t = []
u = []
# Velocity probe location
vp_x = 0.814
vp_y = 0.0
vp_z = 0.026
for sd, arrays in iter_output(files, "fluid"):
t.append(sd["t"])
interp = Interpolator([arrays],
x=vp_x,
y=vp_y,
z=vp_z,
method="shepard")
u.append(interp.interpolate('u'))
u = np.array(u)
fname = os.path.join(self.output_dir, 'results.npz')
t, u = list(map(np.asarray, (t, u)))
np.savez(fname, t=t, u=u)
t = np.array(t) - 0.238
figure_1 = plt.figure()
plt.plot(t, u, label="Computed", figure=figure_1)
plt.scatter(exp_vt,
exp_v,
label="Experiment, Yeh and Petroff",
marker="^",
figure=figure_1,
color=(0, 0, 0))
plt.legend()
plt.ylabel("Horizontal Velocity (m/s)")
plt.xlabel("Time (s)")
left, right = plt.xlim()
plt.xlim(left, 1.4)
plt.savefig(os.path.join(self.output_dir, 'v_vs_t.png'))
plt.show()
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 post_processing(self):
files = get_files('stacked-particles_output')
t = []
y1 = []
y2 = []
for solver_data, sand, in iter_output(files, 'sand'):
t.append(solver_data['t'])
y1.append(sand.y[0])
y2.append(sand.y[1])
print("Done")
plt.plot(t, y1)
# plt.plot(t, y2)
plt.show()
def post_processing(self):
files = get_files('test_3_output')
t = []
y1 = []
y2 = []
for solver_data, mg, al in iter_output(files, 'mg', 'al'):
t.append(solver_data['t'])
y2.append(-mg.u[0])
y1.append(-al.u[0])
print("Done")
print(y1)
print(y1[-1] / 3.9)
print(y2[-1] / 3.9)
def post_processing(self):
files = get_files('test_2_output')
t = []
y1 = []
y2 = []
for solver_data, mg, al in iter_output(files, 'mg', 'al'):
t.append(solver_data['t'])
y1.append(-mg.fx[0])
y2.append(-al.fx[0])
print("Done")
plt.plot(t, y1)
plt.plot(t, y2)
plt.title("Force in overlap")
plt.xlabel("time")
plt.ylabel("Force")
plt.show()
def post_processing(self):
files = get_files('dcdem_output')
t = []
y1 = []
y2 = []
for solver_data, glass, lime in iter_output(files, 'glass', 'lime'):
t.append(solver_data['t'])
y1.append(-glass.fx[0])
y2.append(-lime.fx[0])
print("Done")
plt.plot(t, y1)
plt.plot(t, y2)
plt.title("Force in overlap")
plt.xlabel("time")
plt.ylabel("Force")
plt.show()
def _plot_force_vs_t(self):
from pysph.solver.utils import iter_output
prop = [
'awhat', 'auhat', 'avhat', 'wg', 'vg', 'ug', 'uf', 'vf', 'wf',
'wij', 'vmag'
]
# We find the force of the solid on the fluid and the opposite of that
# is the force on the solid. Note that the assumption is that the solid
# is far from the inlet and outlet so those are ignored.
sph_eval = self._get_force_evaluator()
t, cd, cl = [], [], []
for sd, arrays in iter_output(self.output_files):
fluid = arrays['fluid']
solid = arrays['solid']
for p in prop:
solid.add_property(p)
fluid.add_property(p)
t.append(sd['t'] * diameter / umax)
sph_eval.update_particle_arrays([solid, fluid])
sph_eval.evaluate()
cd.append(
np.sum(solid.au * solid.m) / (0.5 * rho * umax**2 * diameter))
cl.append(
np.sum(solid.av * solid.m) / (0.5 * rho * umax**2 * diameter))
t, cd, cl = list(map(np.asarray, (t, cd, cl)))
# Now plot the results.
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
plt.figure()
plt.plot(t, cd, label=r'$C_d$')
plt.plot(t, cl, label=r'$C_l$')
plt.xlabel(r'$t$')
plt.ylabel('$C_d$/$C_l$')
plt.legend()
fig = os.path.join(self.output_dir, "lift_drag_vs_t.png")
plt.savefig(fig, dpi=300)
plt.close()
return t, cd, cl
def post_process(self, info_fname):
self.read_info(info_fname)
if len(self.output_files) == 0:
return
from pysph.solver.utils import iter_output
import matplotlib.pyplot as plt
from pysph.examples import db_exp_data as dbd
from pysph.tools.interpolator import Interpolator
H = 1.0
factor_y = 1 / (ro * g * H)
factor_x = np.sqrt(g / H)
data_t, data_p0 = dbd.get_buchner_data()
files = self.output_files
t = []
p0 = []
for sd, arrays1, arrays2 in iter_output(files, "fluid", "boundary"):
t.append(sd["t"] * factor_x)
interp = Interpolator([arrays1, arrays2],
x=[container_width],
y=[H * 0.2],
method=self.interp_method)
p0.append(interp.interpolate('p') * factor_y)
plt.plot(t, p0, label="Computed")
fname = os.path.join(self.output_dir, 'results.npz')
t, p0 = list(map(np.asarray, (t, p0)))
np.savez(fname, t=t, p0=p0)
plt.scatter(data_t,
data_p0,
color=(0, 0, 0),
label="Experiment (Buchner, 2002)")
plt.legend()
plt.ylabel(r"$\frac{P}{\rho gH}$")
plt.xlabel(r"$t \sqrt{\frac{g}{H}}$")
plt.savefig(os.path.join(self.output_dir, 'p_vs_t.png'))
def post_processing(self):
files = get_files('test_6_output')
t = []
u1 = []
v1 = []
u2 = []
v2 = []
for solver_data, al, nylon in iter_output(files, 'al', 'nylon'):
t.append(solver_data['t'])
u1.append(-al.u[0])
v1.append(-al.v[0])
u2.append(-nylon.u[0])
v2.append(-nylon.v[0])
print("Done")
# aluminium
print('aluminium')
print(u1)
print(v1)
print(v1[-1] / u1[-1])
# nylon
print('nylon')
print(u2)
print(v2)
print(v2[-1] / u2[-1])
def _plot_cd_vs_t(self):
from pysph.solver.utils import iter_output, load
from pysph.tools.sph_evaluator import SPHEvaluator
from pysph.sph.equation import Group
from pysph.sph.wc.transport_velocity import (SetWallVelocity,
MomentumEquationPressureGradient, SolidWallNoSlipBC,
SolidWallPressureBC, VolumeSummation)
data = load(self.output_files[0])
solid = data['arrays']['solid']
fluid = data['arrays']['fluid']
x, y = solid.x.copy(), solid.y.copy()
cx = 0.5 * L; cy = 0.5 * H
inside = np.sqrt((x-cx)**2 + (y-cy)**2) <= a
dest = solid.extract_particles(inside.nonzero()[0])
# We use the same equations for this as the simulation, except that we
# do not include the acceleration terms as these are externally
# imposed. The goal of these is to find the force of the fluid on the
# cylinder, thus, gx=0.0 is used in the following.
equations = [
Group(
equations=[
VolumeSummation(
dest='fluid', sources=['fluid', 'solid']
),
VolumeSummation(
dest='solid', sources=['fluid', 'solid']
),
], real=False),
Group(
equations=[
SetWallVelocity(dest='solid', sources=['fluid']),
], real=False),
Group(
equations=[
SolidWallPressureBC(dest='solid', sources=['fluid'],
gx=0.0, b=1.0, rho0=rho0, p0=p0),
], real=False),
Group(
equations=[
# Pressure gradient terms
MomentumEquationPressureGradient(
dest='fluid', sources=['solid'], gx=0.0, pb=pb),
SolidWallNoSlipBC(
dest='fluid', sources=['solid'], nu=nu),
], real=True),
]
sph_eval = SPHEvaluator(
arrays=[dest, fluid], equations=equations, dim=2,
kernel=QuinticSpline(dim=2)
)
t, cd = [], []
for sd, fluid in iter_output(self.output_files, 'fluid'):
fluid.remove_property('vmag2')
t.append(sd['t'])
sph_eval.update_particle_arrays([dest, fluid])
sph_eval.evaluate()
Fx = np.sum(-fluid.au*fluid.m)
cd.append(Fx/(nu*rho0*Umax))
t, cd = list(map(np.asarray, (t, cd)))
# Now plot the results.
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
f = plt.figure()
plt.plot(t, cd)
plt.xlabel('$t$'); plt.ylabel(r'$C_D$')
fig = os.path.join(self.output_dir, "cd_vs_t.png")
plt.savefig(fig, dpi=300)
plt.close()
return t, cd
def post_process(self, info_file_or_dir):
try:
import matplotlib as mpl
mpl.use('pgf')
from matplotlib import pyplot as plt
except ImportError:
print("Post processing requires matplotlib.")
return
time = []
F = []
for sd, array in iter_output(self.output_files, 'top_wall'):
t = sd['t']
time.append(t)
p, x = array.get('p', 'x')
xmin = min(x)
force = 0.0
for press, pos in zip(p, x):
if pos < xmin + dx / 4:
force += press * dx * dx
F.append(force)
csv_file = os.path.join(self.output_dir, "force.csv")
np.savetxt(csv_file, np.c_[time, F], delimiter=',')
plt.figure()
plt.plot(time, F, '-k')
plt.title("Compression Force")
plt.xlabel('Time t in s')
plt.ylabel('Force F in N')
plt.tight_layout()
pdf_fig = os.path.join(self.output_dir, "force.pdf")
plt.savefig(pdf_fig)
try:
tex_fig = os.path.join(self.output_dir, "force.tex")
from matplotlib2tikz import save as tikz_save
tikz_save(tex_fig)
except ImportError:
print("Did not write tikz figure.")
# plot radius
time = []
R = []
for sd, array in iter_output(self.output_files, 'fluid'):
t = sd['t']
time.append(t)
y, z = array.get('y', 'z')
R.append(max(np.sqrt(y**2 + z**2)))
csv_file = os.path.join(self.output_dir, "radius.csv")
np.savetxt(csv_file, np.c_[time, R], delimiter=',')
plt.figure()
plt.plot(time, R, '-k')
plt.title("Radius (max. radial position of particle)")
plt.xlabel('Time t in s')
plt.ylabel('Radius R in m')
plt.tight_layout()
pdf_fig = os.path.join(self.output_dir, "radius.pdf")
plt.savefig(pdf_fig)
try:
tex_fig = os.path.join(self.output_dir, "radius.tex")
from matplotlib2tikz import save as tikz_save
tikz_save(tex_fig)
except ImportError:
print("Did not write tikz figure.")
# plot pressure at center
time = []
press = []
for sd, array in iter_output(self.output_files, 'fluid'):
t = sd['t']
time.append(t)
p, y, z = array.get('p', 'y', 'z')
idx = np.where(np.sqrt(y**2 + z**2) < 0.1 * self.D)
press.append(np.average(p[idx]))
csv_file = os.path.join(self.output_dir, "pressure.csv")
np.savetxt(csv_file, np.c_[time, press], delimiter=',')
plt.figure()
plt.plot(time, press, '-k')
plt.title("Pressure at center")
plt.xlabel('Time t in s')
plt.ylabel('Pressure p in Pa')
plt.tight_layout()
pdf_fig = os.path.join(self.output_dir, "pressure.pdf")
plt.savefig(pdf_fig)
try:
tex_fig = os.path.join(self.output_dir, "pressure.tex")
from matplotlib2tikz import save as tikz_save
tikz_save(tex_fig)
except ImportError:
print("Did not write tikz figure.")
def post_process(self, info_fname):
self.read_info(info_fname)
if len(self.output_files) == 0:
return
from pysph.solver.utils import iter_output
import matplotlib.pyplot as plt
from pysph.examples import st_exp_data as st
from pysph.tools.interpolator import Interpolator
files = self.output_files
t = []
p0 = []
xc0 = 0.0
for sd, arrays1, arrays2 in iter_output(files, "fluid", "boundary"):
t.append(sd["t"])
xc = arrays2.x.mean()
if sd["t"] == 0:
xc0 = xc
# Point 1: Bottom right corner of the tank
# Point 2: Top right corner of the tank
# Point 3: Bottom left corner of the tank
if xc > xc0:
z1 = arrays2.z.min()
x2 = arrays2.x.max()
x1 = arrays2.x[np.where(arrays2.z == z1)[0][0]]
z2 = arrays2.x[np.where(arrays2.x == x2)[0][0]]
angle = np.arctan((z2 - z1) / (x2 - x1))
x3 = arrays2.x.min()
z3 = arrays2.z[np.where(arrays2.x == x3)[0][0]]
if xc <= xc0:
z2 = arrays2.z.max()
x1 = arrays2.x.max()
x2 = arrays2.x[np.where(arrays2.z == z2)[0][0]]
z1 = arrays2.z[np.where(arrays2.x == x1)[0][0]]
angle = np.arctan((z2 - z1) / (x2 - x1)) + pi
z3 = arrays2.z.min()
x3 = arrays2.x[np.where(arrays2.z == z3)[0][0]]
if x3 - x1 == 0:
vec = np.array([-1, 0])
else:
vec = np.array([x3 - x1, z3 - z1])
vec = vec / np.linalg.norm(vec)
dx = self.dx
# Probes at 0.17 m above Point 1 and 0.45 m above Point 3
x_probe = [
x1 + 0.17 * cos(angle) + 3.25 * dx * vec[0],
x3 + 0.45 * cos(angle) - 3.25 * dx * vec[0]
]
z_probe = [
z1 + 0.17 * sin(angle) + 3.25 * dx * vec[1],
z3 + 0.45 * sin(angle) - 3.25 * dx * vec[1]
]
y_probe = [0, 0]
interp = Interpolator([arrays1, arrays2],
x=x_probe,
y=y_probe,
z=z_probe,
method=self.interp_method)
p0.append(interp.interpolate('p'))
p0 = np.array(p0)
p2 = p0.T[0] / 1000
p8 = p0.T[1] / 1000
p2_avg, p8_avg = p2, p8
fname = os.path.join(self.output_dir, 'results.npz')
t, p0 = list(map(np.asarray, (t, p0)))
np.savez(fname, t=t, p0=p0)
exp_t2, exp_p2, exp_t8, exp_p8 = st.get_au_pitch_data()
figure_1 = plt.figure()
# Probe 2
plt.plot(t[:-10], p2_avg[:-10], label="Computed", figure=figure_1)
plt.scatter(exp_t2,
exp_p2,
color=(0, 0, 0),
label="Experiment (Akyildiz and Unal, 2006)",
figure=figure_1)
plt.title("P2 v/s t")
plt.legend()
plt.ylabel("Pressue [KPa]")
plt.xlabel("Time [s]")
plt.xlim(3, 10)
plt.savefig(os.path.join(self.output_dir, 'p2_vs_t.png'))
plt.show()
figure_2 = plt.figure()
# Probe 8
plt.plot(t, p8_avg, label="Computed", figure=figure_2)
plt.scatter(exp_t8,
exp_p8,
color=(0, 0, 0),
label="Experiment (Akyildiz and Unal, 2006)",
figure=figure_2)
plt.title("P8 v/s t")
plt.legend()
plt.ylabel("Pressue [KPa]")
plt.xlabel("Time [s]")
plt.xlim(3, 10)
plt.savefig(os.path.join(self.output_dir, 'p8_vs_t.png'))
plt.show()
def post_process(self, info_fname):
info = self.read_info(info_fname)
if len(self.output_files) == 0:
return
from pysph.solver.utils import iter_output
decay_rate = -8.0 * np.pi**2 / self.re
U = self.U
files = self.output_files
t, ke, ke_ex, decay, linf, l1, p_l1 = [], [], [], [], [], [], []
for sd, array in iter_output(files, 'fluid'):
_t = sd['t']
t.append(_t)
x, y, m, u, v, p = self._get_post_process_props(array)
u_e, v_e, p_e = exact_solution(U, decay_rate, _t, x, y)
vmag2 = u**2 + v**2
vmag = np.sqrt(vmag2)
ke.append(0.5 * np.sum(m * vmag2))
vmag2_e = u_e**2 + v_e**2
vmag_e = np.sqrt(vmag2_e)
ke_ex.append(0.5 * np.sum(m * vmag2_e))
vmag_max = vmag.max()
decay.append(vmag_max)
theoretical_max = U * np.exp(decay_rate * _t)
linf.append(abs((vmag_max - theoretical_max) / theoretical_max))
l1_err = np.average(np.abs(vmag - vmag_e))
avg_vmag_e = np.average(np.abs(vmag_e))
# scale the error by the maximum velocity.
l1.append(l1_err / avg_vmag_e)
p_e_max = np.abs(p_e).max()
p_error = np.average(np.abs(p - p_e)) / p_e_max
p_l1.append(p_error)
t, ke, ke_ex, decay, l1, linf, p_l1 = list(
map(np.asarray, (t, ke, ke_ex, decay, l1, linf, p_l1)))
decay_ex = U * np.exp(decay_rate * t)
fname = os.path.join(self.output_dir, 'results.npz')
np.savez(fname,
t=t,
ke=ke,
ke_ex=ke_ex,
decay=decay,
linf=linf,
l1=l1,
p_l1=p_l1,
decay_ex=decay_ex)
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
plt.clf()
plt.semilogy(t, decay_ex, label="exact")
plt.semilogy(t, decay, label="computed")
plt.xlabel('t')
plt.ylabel('max velocity')
plt.legend()
fig = os.path.join(self.output_dir, "decay.png")
plt.savefig(fig, dpi=300)
plt.clf()
plt.plot(t, linf)
plt.xlabel('t')
plt.ylabel(r'$L_\infty$ error')
fig = os.path.join(self.output_dir, "linf_error.png")
plt.savefig(fig, dpi=300)
plt.clf()
plt.plot(t, l1, label="error")
plt.xlabel('t')
plt.ylabel(r'$L_1$ error')
fig = os.path.join(self.output_dir, "l1_error.png")
plt.savefig(fig, dpi=300)
plt.clf()
plt.plot(t, p_l1, label="error")
plt.xlabel('t')
plt.ylabel(r'$L_1$ error for $p$')
fig = os.path.join(self.output_dir, "p_l1_error.png")
plt.savefig(fig, dpi=300)
def _plot_force_vs_t(self):
from pysph.solver.utils import iter_output, load
from pysph.tools.sph_evaluator import SPHEvaluator
from pysph.sph.equation import Group
from pysph.base.kernels import QuinticSpline
from pysph.sph.wc.transport_velocity import (
MomentumEquationPressureGradient, SummationDensity,
SetWallVelocity)
data = load(self.output_files[0])
solid = data['arrays']['solid']
fluid = data['arrays']['fluid']
prop = [
'awhat', 'auhat', 'avhat', 'wg', 'vg', 'ug', 'V', 'uf', 'vf', 'wf',
'wij', 'vmag', 'pavg', 'nnbr', 'auf', 'avf', 'awf'
]
for p in prop:
solid.add_property(p)
fluid.add_property(p)
# We find the force of the solid on the fluid and the opposite of that
# is the force on the solid. Note that the assumption is that the solid
# is far from the inlet and outlet so those are ignored.
print(self.nu, p0, self.dc, rho)
equations = [
Group(equations=[
SummationDensity(dest='fluid', sources=['fluid', 'solid']),
SummationDensity(dest='solid', sources=['fluid', 'solid']),
SetWallVelocity(dest='solid', sources=['fluid']),
],
real=False),
Group(
equations=[
# Pressure gradient terms
MomentumEquationPressureGradient(dest='solid',
sources=['fluid'],
pb=p0),
SolidWallNoSlipBCReverse(dest='solid',
sources=['fluid'],
nu=self.nu),
],
real=True),
]
sph_eval = SPHEvaluator(arrays=[solid, fluid],
equations=equations,
dim=2,
kernel=QuinticSpline(dim=2))
t, cd, cl = [], [], []
import gc
print(self.dc, self.dx, self.nu)
print('fxf', 'fxp', 'fyf', 'fyp', 'cd', 'cl', 't')
for sd, arrays in iter_output(self.output_files[:]):
fluid = arrays['fluid']
solid = arrays['solid']
for p in prop:
solid.add_property(p)
fluid.add_property(p)
t.append(sd['t'])
sph_eval.update_particle_arrays([solid, fluid])
sph_eval.evaluate()
fxp = sum(solid.m * solid.au)
fyp = sum(solid.m * solid.av)
fxf = sum(solid.m * solid.auf)
fyf = sum(solid.m * solid.avf)
fx = fxf + fxp
fy = fyf + fyp
cd.append(fx / (0.5 * rho * umax**2 * self.dc))
cl.append(fy / (0.5 * rho * umax**2 * self.dc))
print(fxf, fxp, fyf, fyp, cd[-1], cl[-1], t[-1])
gc.collect()
t, cd, cl = list(map(np.asarray, (t, cd, cl)))
# Now plot the results.
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
plt.figure()
plt.plot(t, cd, label=r'$C_d$')
plt.plot(t, cl, label=r'$C_l$')
plt.xlabel(r'$t$')
plt.ylabel('cd/cl')
plt.legend()
plt.grid()
fig = os.path.join(self.output_dir, "force_vs_t.png")
plt.savefig(fig, dpi=300)
plt.close()
return t, cd, cl
