def test_solver_honors_set_time_step(self):
# Given
dt = 0.1
tf = 1.0
pfreq = 1
solver = Solver(integrator=self.integrator,
tf=tf,
dt=dt,
adaptive_timestep=False)
solver.set_print_freq(pfreq)
solver.acceleration_evals = [self.a_eval]
solver.particles = []
record = []
def _mock_dump_output():
# Record the time at which the solver dumped anything
record.append(solver.t)
solver.dump_output = mock.Mock(side_effect=_mock_dump_output)
# When
solver.set_time_step(0.2)
solver.solve(show_progress=False)
# Then
expected = np.asarray([0.0, 0.2, 0.4, 0.6, 0.8, 1.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)
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 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 = Gaussian(dim=dim)
# kernel = WendlandQuintic(dim=dim)
integrator = EPECIntegrator(projectile=SolidMechStep(),
plate=SolidMechStep())
solver = Solver(kernel=kernel, dim=dim, integrator=integrator)
dt = 1e-9
tf = 8e-5
solver.set_time_step(dt)
solver.set_final_time(tf)
solver.set_print_freq(100)
return solver
def create_solver(self):
kernel = Gaussian(dim=2)
#kernel = WendlandQuintic(dim=2)
self.wdeltap = kernel.kernel(rij=dx, h=hdx * dx)
integrator = EPECIntegrator(projectile=SolidMechStep(),
plate=SolidMechStep())
solver = Solver(kernel=kernel, dim=2, 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 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 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 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)
# 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
IsothermalEOS(dest='solid', sources=None, rho0=rho0, c0=c0),
# vi,j : requires properties v00, v01, v10, v11
VelocityGradient2D(dest='solid', sources=['solid',]),
# rij : requires properties r00, r01, r02, r11, r12, r22,
# s00, s01, s02, s11, s12, s22
app = Application()
# Create the kernel
kernel = CubicSpline(dim=2)
# Create the Integrator. Currently, PySPH supports multi-stage,
# predictor corrector and a TVD-RK3 integrators.
integrator = EulerIntegrator(fluid=IISPHStep())
# Create a solver.
solver = Solver(kernel=kernel, dim=dim, integrator=integrator,
dt=dt, tf=tf, adaptive_timestep=True,
fixed_h=False)
solver.set_print_freq(10)
# create the equations
equations = [
#####################################################################
# "Predict advection" step as per algorithm 1 in paper.
Group(equations=[
NumberDensity(dest='boundary', sources=['boundary']),
]
),
Group(
equations=[
SummationDensity(dest='fluid', sources=['fluid']),
],
real=False
integrator = EulerIntegrator(fluid=IISPHStep())
# Construct the solver. Use the output_at_times list to specify instants of
# time at which the output solution is required.
dt = 2e-4;
tf = 0.0075
solver = Solver(kernel=kernel, dim=2, integrator=integrator,
dt=dt, tf=tf, adaptive_timestep=False,
cfl=0.05,
output_at_times=[0.0033, 0.0052])
# select True if you want to dump out remote particle properties in
# parallel runs. This can be over-ridden with the --output-remote
# command line option
solver.set_output_only_real(True)
solver.set_print_freq(5)
# Define the SPH equations used to solve this problem
equations = [
#####################################################################
# "Predict advection" step as per algorithm 1 in paper.
Group(
equations=[
SummationDensity(dest='fluid', sources=['fluid']),
],
real=False
),
Group(
equations=[
