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)
