def create_solver(self): kernel = CubicSpline(dim=2) self.wdeltap = kernel.kernel(rij=dx, h=hdx * dx) integrator = PECIntegrator(solid=SolidMechStep()) solver = Solver(kernel=kernel, dim=2, integrator=integrator) dt = 1e-8 tf = 5e-5 solver.set_time_step(dt) solver.set_final_time(tf) solver.set_print_freq(500) return solver
def create_solver(self): dim = 3 kernel = CubicSpline(dim=dim) # kernel = WendlandQuintic(dim=dim) self.wdeltap = kernel.kernel(rij=dx, h=hdx * dx) integrator = EPECIntegrator(fluid=WCSPHStep()) solver = Solver(kernel=kernel, dim=dim, integrator=integrator) dt = 1e-9 tf = 8e-6 solver.set_time_step(dt) solver.set_final_time(tf) solver.set_print_freq(100) return solver
def main(): # Create the application. app = Application() dim = 1 # Create the kernel kernel = CubicSpline(dim=dim) # Create the integrator. integrator = EulerIntegrator(fluid=DummyStepper()) solver = Solver(kernel=kernel, dim=dim, integrator=integrator) solver.set_time_step(0.1) solver.set_final_time(0.1) equations = [TotalMass(dest='fluid', sources=['fluid'])] app.setup( solver=solver, equations=equations, particle_factory=create_particles) # There is no need to write any output as the test below # computes the total mass. solver.set_disable_output(True) app.run() fluid = solver.particles[0] err = fluid.total_mass[0] - 10.0 assert abs(err) < 1e-16, "Error: %s" % err
def create_solver(self): """Create Solver with min. time step from CFL and viscous step.""" kernel = CubicSpline(dim=3) integrator = EPECIntegrator(fluid=WCSPHStep(), walls=WCSPHStep(), ellipsoid=RK2StepRigidBody()) h = self.hdx * self.dx dt_cfl = 0.4 * h / (1.1 * self.co) dt_viscous = 0.125 * h**2 / self.nu dt = min(dt_viscous, dt_cfl) print("dt_cfl: %s" % dt_cfl) print("dt_viscous: %s" % dt_viscous) print("DT: %s" % dt) tf = 12 solver = Solver( kernel=kernel, dim=3, integrator=integrator, dt=dt, tf=tf, adaptive_timestep=False, ) return solver
def _make_accel_eval(self, equations): kernel = CubicSpline(dim=self.dim) seval = SPHEvaluator( arrays=[self.pa], equations=equations, dim=self.dim, kernel=kernel ) return seval
def configure_solver(self, kernel=None, integrator_cls=None, extra_steppers=None, **kw): from pysph.base.kernels import CubicSpline if kernel is None: kernel = CubicSpline(dim=self.dim) steppers = {} if extra_steppers is not None: steppers.update(extra_steppers) from pysph.sph.integrator import PECIntegrator, TVDRK3Integrator from pysph.sph.integrator_step import WCSPHStep, WCSPHTVDRK3Step cls = integrator_cls if integrator_cls is not None else PECIntegrator step_cls = WCSPHTVDRK3Step if cls is TVDRK3Integrator else WCSPHStep for name in self.fluids + self.solids: if name not in steppers: steppers[name] = step_cls() integrator = cls(**steppers) from pysph.solver.solver import Solver if 'dt' not in kw: kw['dt'] = self.get_timestep() self.solver = Solver(dim=self.dim, integrator=integrator, kernel=kernel, **kw)
class TestCubicSpline2D(TestKernelBase): kernel_factory = staticmethod(lambda: CubicSpline(dim=2)) def test_simple(self): self.check_kernel_at_origin(10. / (7 * np.pi)) def test_zeroth_kernel_moments(self): r = self.check_kernel_moment_2d(0, 0) self.assertAlmostEqual(r, 1.0, 7) def test_first_kernel_moment(self): r = self.check_kernel_moment_2d(0, 1) self.assertAlmostEqual(r, 0.0, 7) r = self.check_kernel_moment_2d(1, 0) self.assertAlmostEqual(r, 0.0, 7) r = self.check_kernel_moment_2d(1, 1) self.assertAlmostEqual(r, 0.0, 7) def test_zeroth_grad_moments(self): r = self.check_gradient_moment_2d(0, 0) self.assertAlmostEqual(r[0], 0.0, 7) self.assertAlmostEqual(r[1], 0.0, 7) def test_first_grad_moment(self): r = self.check_gradient_moment_2d(1, 0) self.assertAlmostEqual(r[0], -1.0, 6) self.assertAlmostEqual(r[1], 0.0, 8) r = self.check_gradient_moment_2d(0, 1) self.assertAlmostEqual(r[0], 0.0, 8) self.assertAlmostEqual(r[1], -1.0, 6) r = self.check_gradient_moment_2d(1, 1) self.assertAlmostEqual(r[0], 0.0, 8) self.assertAlmostEqual(r[1], 0.0, 8)
def compute_fluid_elevation(particles): one_time_equations = [ Group( equations=[ FluidBottomElevation(dest='fluid', sources=['bed']) ] ), Group( equations=[ GradientCorrectionPreStep(dest='bed', sources=['bed']) ] ), Group( equations=[ GradientCorrection(dest='bed', sources=['bed']) ] ), Group( equations=[ BedGradient(dest='bed', sources=['bed']), ] ), Group( equations=[ BedCurvature(dest='bed', sources=['bed']), ] ), ] kernel = CubicSpline(dim=2) sph_eval = SPHEvaluator(particles, one_time_equations, dim=2, kernel=kernel) sph_eval.evaluate()
def configure_solver(self, kernel=None, integrator_cls=None, extra_steppers=None, **kw): from pysph.base.kernels import CubicSpline if kernel is None: kernel = CubicSpline(dim=self.dim) steppers = {} if extra_steppers is not None: steppers.update(extra_steppers) from pysph.sph.integrator import EPECIntegrator from pysph.sph.integrator_step import SolidMechStep cls = integrator_cls if integrator_cls is not None else EPECIntegrator step_cls = SolidMechStep for name in self.elastic_solids: if name not in steppers: steppers[name] = step_cls() integrator = cls(**steppers) from pysph.solver.solver import Solver self.solver = Solver(dim=self.dim, integrator=integrator, kernel=kernel, **kw)
def compute_initial_props(particles): one_time_equations = [Group(equations=[SWEOS(dest='fluid')], )] kernel = CubicSpline(dim=1) sph_eval = SPHEvaluator(particles, one_time_equations, dim=1, kernel=kernel) sph_eval.evaluate()
def create_solver(self): kernel = CubicSpline(dim=dim) integrator = EPECIntegrator(body=RK2StepRigidBody()) solver = Solver(kernel=kernel, dim=dim, integrator=integrator, dt=dt, tf=tf, adaptive_timestep=False) solver.set_print_freq(10) return solver
def configure_scheme(self): s = self.scheme scheme = self.options.scheme if scheme == 'wcsph': s.configure(h0=self.h0, hdx=self.hdx) elif scheme == 'edac': s.configure(h=self.h0) step = dict(cube=RK2StepRigidBody()) s.configure_solver(kernel=CubicSpline(dim=2), dt=self.dt, tf=3.0, adaptive_timestep=False, extra_steppers=step)
def create_solver(self): kernel = CubicSpline(dim=2) integrator = PECIntegrator(fluid=TransportVelocityStep()) solver = Solver(kernel=kernel, dim=dim, integrator=integrator, dt=dt, tf=tf, adaptive_timestep=False) return solver
def configure_scheme(self): scheme = self.scheme kernel = CubicSpline(dim=self.dim) tf = 5. dt = 1e-3 scheme.configure() scheme.configure_solver(kernel=kernel, integrator_cls=EPECIntegrator, dt=dt, tf=tf)
def create_solver(self): kernel = CubicSpline(dim=1) integrator = SWEIntegrator(fluid=SWEStep()) tf = 10 solver = Solver(kernel=kernel, dim=1, integrator=integrator, cfl=0.3, adaptive_timestep=True, tf=tf) return solver
def create_solver(self): kernel = CubicSpline(dim=2) integrator = SWEIntegrator(fluid=SWEStep()) dt = 1e-4 tf = 1e-4 solver = Solver(kernel=kernel, dim=2, integrator=integrator, dt=dt, tf=tf) return solver
def _setup_integrator(self, equations, integrator): kernel = CubicSpline(dim=1) arrays = [self.pa] a_eval = AccelerationEval(particle_arrays=arrays, equations=equations, kernel=kernel) comp = SPHCompiler(a_eval, integrator=integrator) comp.compile() nnps = LinkedListNNPS(dim=kernel.dim, particles=arrays) a_eval.set_nnps(nnps) integrator.set_nnps(nnps)
def configure_scheme(self): s = self.scheme scheme = self.options.scheme if scheme == 'wcsph': s.configure(h0=self.h0, hdx=self.hdx) elif scheme == 'aha': s.configure(h0=self.h0) elif scheme == 'edac': s.configure(h=self.h0) s.configure_solver(kernel=CubicSpline(dim=2), dt=self.dt, tf=1.2, adaptive_timestep=False)
def create_solver(self): kernel = CubicSpline(dim=2) integrator = EulerIntegrator(fluid=EulerStep(),solid=EulerStep()) dt = 0.125 * 0.125 * self.h / self.c0 tf = 2 solver = Solver(kernel=kernel, dim=2, integrator=integrator, dt=dt, tf=tf, adaptive_timestep=True, cfl=0.05, n_damp=50) return solver
def create_solver(self): kernel = CubicSpline(dim=1) integrator = SWEIntegrator(fluid=SWEStep()) tf = 60 solver = Solver(kernel=kernel, dim=1, integrator=integrator, cfl=0.3, adaptive_timestep=True, output_at_times=[10, 20, 30, 40, 50, 60], tf=tf) return solver
def create_solver(self): kernel = CubicSpline(dim=2) integrator = EPECIntegrator(mg=DEMStep(), al=DEMStep()) dt = 1e-7 print("DT: %s" % dt) tf = 0.0013 solver = Solver(kernel=kernel, dim=2, integrator=integrator, dt=dt, tf=tf, adaptive_timestep=False) return solver
def create_solver(self): kernel = CubicSpline(dim=2) integrator = PECIntegrator(fluid=WCSPHStep()) dt = 5e-6 tf = 0.0076 solver = Solver(kernel=kernel, dim=2, integrator=integrator, dt=dt, tf=tf) return solver
def create_solver(self): kernel = CubicSpline(dim=2) integrator = EPECIntegrator(fluid=WCSPHStep()) dt = 0.125 * self.dx * self.hdx / (self.co * 1.1) / 2. print("DT: %s" % dt) tf = 0.5 solver = Solver(kernel=kernel, dim=2, integrator=integrator, dt=dt, tf=tf, adaptive_timestep=False) return solver
def configure_scheme(self): s = self.scheme hdx = self.hdx kernel = CubicSpline(dim=dim) h0 = self.dx * hdx s.configure(h0=h0, hdx=hdx) dt = 0.125 * h0 / c0 s.configure_solver(kernel=kernel, integrator_cls=EPECIntegrator, tf=tf, dt=dt, adaptive_timestep=True)
def create_solver(self): kernel = CubicSpline(dim=2) integrator = SWEIntegrator(fluid=SWEStep()) tf = 1.0 solver = Solver(kernel=kernel, dim=2, integrator=integrator, cfl=0.3, adaptive_timestep=True, output_at_times=(0.1, 0.2, 0.3), tf=tf) return solver
def create_solver(self): kernel = CubicSpline(dim=2) integrator = SWEIntegrator(inlet=SWEInletOutletStep(), fluid=SWEStep()) tf = 22.51 solver = Solver(kernel=kernel, dim=2, integrator=integrator, cfl=0.4, adaptive_timestep=True, output_at_times=(10, 12, 14, 15, 16, 17, 18, 20), tf=tf) return solver
def _make_accel_eval(self, equations, cache_nnps=False): arrays = [self.pa] kernel = CubicSpline(dim=self.dim) a_eval = AccelerationEval( particle_arrays=arrays, equations=equations, kernel=kernel ) comp = SPHCompiler(a_eval, integrator=None) comp.compile() nnps = NNPS(dim=kernel.dim, particles=arrays, cache=cache_nnps) nnps.update() a_eval.set_nnps(nnps) return a_eval
def create_particles(self): spacing = self.spacing # spacing = 2*5cm x, y = numpy.mgrid[-self.ro:self.ro:self.dx, -self.ro:self.ro:self.dx] x = x.ravel() y = y.ravel() d = (x * x + y * y) ro = self.ro ri = self.ri keep = numpy.flatnonzero((ri * ri <= d) * (d < ro * ro)) x = x[keep] y = y[keep] x = numpy.concatenate([x - spacing, x + spacing]) y = numpy.concatenate([y, y]) dx = self.dx hdx = self.hdx m = numpy.ones_like(x) * dx * dx h = numpy.ones_like(x) * hdx * dx rho = numpy.ones_like(x) # create the particle array kernel = CubicSpline(dim=2) self.wdeltap = kernel.kernel(rij=dx, h=self.h) pa = get_particle_array_elastic_dynamics( name="solid", x=x + spacing, y=y, m=m, rho=rho, h=h, constants=dict( wdeltap=self.wdeltap, n=4, rho_ref=self.rho0, E=self.E, nu=self.nu)) print('Ellastic Collision with %d particles' % (x.size)) print("Shear modulus G = %g, Young's modulus = %g, Poisson's ratio =%g" % (pa.G, pa.E, pa.nu)) u_f = 0.059 pa.u = pa.cs * u_f * (2 * (x < 0) - 1) return [pa]
def create_solver(self): kernel = CubicSpline(dim=2) integrator = EPECIntegrator(fluid=WCSPHStep()) solver = Solver(kernel=kernel, dim=2, integrator=integrator, dt=self.dt, tf=self.tf, pfreq=10) return solver
def create_solver(self): kernel = CubicSpline(dim=2) integrator = EPECIntegrator(fluid=EDACStep()) dt = 0.125 * self.h0 / c0 self.scheme.configure(h=self.h0) solver = Solver(kernel=kernel, dim=2, integrator=integrator, tf=tf, dt=dt) return solver
# standard acceleration variables add_properties(pa, 'arho', 'au', 'av', 'aw', 'ax', 'ay', 'az', 'ae') # initial values add_properties(pa, 'rho0', 'u0', 'v0', 'w0', 'x0', 'y0', 'z0', 'e0') # load balancing properties pa.set_lb_props( pa.properties.keys() ) return [pa,] # create the Application app = Application() # kernel kernel = CubicSpline(dim=2) wdeltap = kernel.kernel(rij=dx, h=hdx*dx) # integrator integrator = PECIntegrator(solid=SolidMechStep()) # Create a solver solver = Solver(kernel=kernel, dim=2, integrator=integrator) # default parameters dt = 1e-8 tf = 5e-5 solver.set_time_step(dt) solver.set_final_time(tf) solver.set_print_freq(500)