def create_solver(self):
kernel = CubicSpline(dim=2)
integrator = EPECIntegrator(cylinder = RK2StepRigidBody())
solver = Solver(kernel=kernel, dim=2, integrator=integrator, tf=0.52,
dt=5e-4, adaptive_timestep=False )
solver.set_print_freq(10)
return solver
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 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 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 configure_solver(self,
kernel=None,
integrator_cls=None,
extra_steppers=None,
**kw):
from pysph.base.kernels import QuinticSpline
if kernel is None:
kernel = QuinticSpline(dim=self.dim)
steppers = {}
if extra_steppers is not None:
steppers.update(extra_steppers)
step_cls = PCISPHStep
for fluid in self.fluids:
if fluid not in steppers:
steppers[fluid] = step_cls(self.show_itercount)
cls = PCISPHIntegrator if integrator_cls is None else integrator_cls
integrator = cls(**steppers)
from pysph.solver.solver import Solver
self.solver = Solver(dim=self.dim,
integrator=integrator,
kernel=kernel,
output_at_times=[0, 0.2, 0.4, 0.8],
**kw)
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)
def configure_solver(self,
kernel=None,
integrator_cls=None,
extra_steppers=None,
**kw):
from pysph.base.kernels import Gaussian
if kernel is None:
kernel = Gaussian(dim=self.dim)
if hasattr(kernel, 'fkern'):
self.fkern = kernel.fkern
else:
self.fkern = 1.0
steppers = {}
if extra_steppers is not None:
steppers.update(extra_steppers)
from pysph.sph.integrator import PECIntegrator
cls = integrator_cls if integrator_cls is not None else PECIntegrator
step_cls = PECStep
for name in self.fluids:
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 configure_solver(self,
kernel=None,
integrator_cls=None,
extra_steppers=None,
**kw):
import pysph.base.kernels as kern
if kernel is None:
kernel = kern.QuinticSpline(dim=self.dim)
steppers = {}
if extra_steppers is not None:
steppers.update(extra_steppers)
step_cls = SISPHStep
if self.gtvf:
step_cls = SISPHGTVFStep
for fluid in self.fluids:
if fluid not in steppers:
steppers[fluid] = step_cls()
if integrator_cls is not None:
cls = integrator_cls
else:
cls = SISPHIntegrator
integrator = cls(**steppers)
from pysph.solver.solver import Solver
self.solver = Solver(dim=self.dim,
integrator=integrator,
kernel=kernel,
**kw)
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 create_solver(self):
kernel = WendlandQuintic(dim=2)
integrator = PECIntegrator(fluid=TransportVelocityStep())
solver = Solver(
kernel=kernel, dim=dim, integrator=integrator,
dt=dt, tf=tf, adaptive_timestep=False)
return solver
def create_solver(self):
kernel = QuinticSpline(dim=2)
integrator = EPECIntegrator(fluid=TransportVelocityStep())
solver = Solver(
kernel=kernel, dim=dim, integrator=integrator,
dt=dt, tf=tf, adaptive_timestep=False,
output_at_times=[0., 0.08, 0.16, 0.26])
return solver
def create_solver(self):
kernel = QuinticSpline(dim=2)
integrator = PECIntegrator(liquid=TransportVelocityStep(),
gas=TransportVelocityStep())
solver = Solver(
kernel=kernel, dim=dim, integrator=integrator,
dt=dt, tf=tf, adaptive_timestep=False)
return solver
def create_solver(self):
kernel = WendlandQuintic(dim=dim)
integrator = EPECIntegrator(fluid=WCSPHStep(),
obstacle=RK2StepRigidBody(),
boundary=WCSPHStep())
solver = Solver(kernel=kernel, dim=dim, integrator=integrator,
tf=tf, dt=dt, adaptive_timestep=True, n_damp=0)
return solver
def configure_solver(self,
kernel=None,
integrator_cls=None,
extra_steppers=None,
**kw):
"""Configure the solver to be generated.
This is to be called before `get_solver` is called.
Parameters
----------
dim : int
Number of dimensions.
kernel : Kernel instance.
Kernel to use, if none is passed a default one is used.
integrator_cls : pysph.sph.integrator.Integrator
Integrator class to use, use sensible default if none is
passed.
extra_steppers : dict
Additional integration stepper instances as a dict.
**kw : extra arguments
Any additional keyword args are passed to the solver instance.
"""
from pysph.base.kernels import QuinticSpline
from pysph.sph.integrator import PECIntegrator
if kernel is None:
kernel = QuinticSpline(dim=self.dim)
steppers = {}
if extra_steppers is not None:
steppers.update(extra_steppers)
step_cls = EDACTVFStep if self.use_tvf else EDACStep
cls = integrator_cls if integrator_cls is not None else PECIntegrator
for fluid in self.fluids:
if fluid not in steppers:
steppers[fluid] = step_cls()
iom = self.inlet_outlet_manager
if iom is not None:
iom_stepper = iom.get_stepper(self, cls)
print(iom_stepper)
for name in iom_stepper:
steppers[name] = iom_stepper[name]
integrator = cls(**steppers)
from pysph.solver.solver import Solver
self.solver = Solver(dim=self.dim,
integrator=integrator,
kernel=kernel,
**kw)
if iom is not None:
iom.setup_iom(dim=self.dim, kernel=kernel)
def create_solver(self):
kernel = WendlandQuintic(dim=2)
integrator = PECIntegrator(fluid=VerletSymplecticWCSPHStep())
solver = Solver(kernel=kernel,
dim=dim,
integrator=integrator,
dt=dt,
tf=tf,
adaptive_timestep=False)
return solver
def create_solver(self):
"""Set up the default integrator for fiber particles."""
kernel = QuinticSpline(dim=3)
integrator = EPECIntegrator(
fiber1=TransportVelocityStep(),
fiber2=TransportVelocityStep())
solver = Solver(
kernel=kernel, dim=3, integrator=integrator, dt=self.dt,
tf=self.tf, N=200)
return solver
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 create_solver(self):
# Create the kernel
#kernel = Gaussian(dim=2)
kernel = QuinticSpline(dim=2)
integrator = PECIntegrator(fluid=WCSPHStep())
# Create a solver.
solver = Solver(kernel=kernel, dim=2, integrator=integrator,
tf=tf, dt=dt, output_at_times=output_at_times)
return solver
def test_solver_dumps_output_given_output_at_times_landing_exactly(self):
# Given
dt = 0.1
self.integrator.compute_time_step.return_value = dt
tf = 3.0
pfreq = 10
output_at_times = np.concatenate(
(np.arange(0, 1.21, 0.2), np.arange(1.25, 1.51, 0.05)))
solver = Solver(integrator=self.integrator,
tf=tf,
dt=dt,
output_at_times=output_at_times)
solver.set_print_freq(pfreq)
solver.acceleration_evals = [self.a_eval]
solver.particles = []
# When
record = []
record_dt = []
def _mock_dump_output():
# Record the time at which the solver dumped anything
record.append(solver.t)
# This smells but ...
sd = solver._get_solver_data()
record_dt.append(sd['dt'])
solver.dump_output = mock.Mock(side_effect=_mock_dump_output)
solver.solve(show_progress=False)
# Then
expected = np.concatenate(
(np.arange(0, 1.21, 0.2), np.arange(1.25, 1.49,
0.05), [1.5, 1.7, 2.7, 3.0]))
error_message = "Expected %s, got %s" % (expected, record)
self.assertEqual(len(expected), len(record), error_message)
self.assertTrue(
np.max(np.abs(expected - record)) < 1e-12, error_message)
self.assertEqual(33, solver.count)
# The final timestep should not be a tiny one due to roundoff.
self.assertTrue(solver.dt > 0.1 * 0.25)
npt.assert_array_almost_equal([0.1] * len(record_dt),
record_dt,
decimal=12)
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 = 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 = 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 create_solver(self):
kernel = WendlandQuintic(dim=2)
integrator = EPECIntegrator(fluid=WCSPHStep(),
block=RK2StepRigidBody())
solver = Solver(kernel=kernel,
dim=2,
integrator=integrator,
tf=tf,
dt=dt,
adaptive_timestep=False)
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 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 = 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 = 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=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 test_solver_dumps_output_given_output_at_times(self):
# Given
dt = 0.1
self.integrator.compute_time_step.return_value = dt
tf = 10.05
pfreq = 5
output_at_times = [0.3, 0.35]
solver = Solver(integrator=self.integrator,
tf=tf,
dt=dt,
output_at_times=output_at_times)
solver.set_print_freq(pfreq)
solver.acceleration_eval = self.a_eval
solver.particles = []
# When
record = []
record_dt = []
def _mock_dump_output():
# Record the time at which the solver dumped anything
record.append(solver.t)
# This smells but ...
sd = solver._get_solver_data()
record_dt.append(sd['dt'])
solver.dump_output = mock.Mock(side_effect=_mock_dump_output)
solver.solve(show_progress=False)
# Then
expected = np.asarray([0.0, 0.3, 0.35] +
np.arange(0.45, 10.1, 0.5).tolist() + [10.05])
error_message = "Expected %s, got %s" % (expected, record)
self.assertEqual(len(expected), len(record), error_message)
self.assertTrue(
np.max(np.abs(expected - record)) < 1e-12, error_message)
self.assertEqual(101, solver.count)
# The final timestep should not be a tiny one due to roundoff.
self.assertTrue(solver.dt > 0.1 * 0.25)
npt.assert_array_almost_equal([0.1] * len(record_dt),
record_dt,
decimal=12)
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
return [fluid,]
# domain for periodicity
domain = DomainManager(xmin=0, xmax=L, ymin=0, ymax=L,
periodic_in_x=True, periodic_in_y=True)
# Create the application.
app = Application(domain=domain)
# Create the kernel
kernel = WendlandQuintic(dim=2)
integrator = EulerIntegrator(fluid=EulerStep())
# Create a solver.
solver = Solver(kernel=kernel, dim=2, integrator=integrator)
# Setup default parameters.
solver.set_time_step(1e-3)
solver.set_final_time(T)
equations = [
# Update velocities and advect
Group(
equations=[
MixingVelocityUpdate(
dest='fluid', sources=None, T=T),
Advect(dest='fluid', sources=None)
])
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)
# add the equations
equations = [
# Properties computed set from the current state
Group(
equations=[
# p
bar.add_property(name)
return [bar, plate]
# create the Application
app = Application()
# kernel
kernel = WendlandQuintic(dim=2)
wdeltap = kernel.kernel(rij=dx, h=hdx*dx)
# integrator
integrator = PECIntegrator(bar=SolidMechStep())
# Create a solver
solver = Solver(kernel=kernel, dim=2, integrator=integrator)
# default parameters
dt = 1e-9
tf = 2.5e-5
solver.set_time_step(dt)
solver.set_final_time(tf)
# add the equations
equations = [
# Properties computed set from the current state
Group(
equations=[
# p
MieGruneisenEOS(dest='bar', sources=None, r0=r0, c0=C, S=S),