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)