def configure_scheme(self):
scheme = self.scheme
kernel = Gaussian(dim=2)
tf = 0.0076
dt = self.options.cfl * self.hdx * self.dx / (141 + self.co)
if self.options.scheme == 'wcsph':
scheme.configure(h0=self.hdx * self.dx)
scheme.configure_solver(kernel=kernel,
integrator_cls=EPECIntegrator,
dt=dt,
tf=tf,
adaptive_timestep=True,
cfl=0.3,
n_damp=50,
output_at_times=[0.0008, 0.0038])
elif self.options.scheme == 'iisph':
scheme.configure_solver(kernel=kernel,
dt=dt,
tf=tf,
adaptive_timestep=True,
output_at_times=[0.0008, 0.0038])
elif self.options.scheme == 'dpsph':
scheme.configure(hdx=self.hdx, dx=self.dx, h0=self.h0, dt=dt)
scheme.configure_solver(tf=tf,
dt=dt,
output_at_times=[0.0008, 0.0038])
def setUp(self):
self.l = l = 1.0
n = 20
dx = l / n
hdx = 1.5
x, y, z = G.get_3d_block(dx, l, l, l)
h = np.ones_like(x) * hdx * dx
m = np.ones_like(x) * dx * dx * dx
V = np.zeros_like(x)
fluid = get_particle_array(name='fluid', x=x, y=y, z=z, h=h, m=m, V=V)
x, y = G.get_2d_block(dx, l, l)
z = np.ones_like(x) * (l + 5 * dx) / 2.0
z = np.concatenate([z, -z])
x = np.tile(x, 2)
y = np.tile(y, 2)
m = np.ones_like(x) * dx * dx * dx
h = np.ones_like(x) * hdx * dx
V = np.zeros_like(x)
channel = get_particle_array(name='channel',
x=x,
y=y,
z=z,
h=h,
m=m,
V=V)
self.particles = [fluid, channel]
self.kernel = get_compiled_kernel(Gaussian(dim=3))
def __init__(self,
arrays,
equations,
dim,
kernel=None,
domain_manager=None):
"""Constructor.
Parameters
----------
arrays: list(ParticleArray)
equations: list
dim: int
kernel: kernel instance.
domain_manager: DomainManager
"""
self.arrays = arrays
self.equations = equations
self.domain_manager = domain_manager
self.dim = dim
if kernel is None:
self.kernel = Gaussian(dim=dim)
else:
self.kernel = kernel
self.func_eval = AccelerationEval(arrays, equations, self.kernel)
compiler = SPHCompiler(self.func_eval, None)
compiler.compile()
self._create_nnps(arrays)
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 common_setup(self):
# create the particle arrays
L = 1.0
n = 10
dx = L / n
hdx = 1.5
self.L = L
_x = np.arange(dx / 2, L, dx)
self.vol = vol = dx * dx
# fluid particles
xx, yy = np.meshgrid(_x, _x)
x = xx.ravel()
y = yy.ravel() # particle positions
p = self._get_pressure(x, y, 0.0)
h = np.ones_like(x) * hdx * dx # smoothing lengths
m = np.ones_like(x) * vol # mass
V = np.zeros_like(x) # volumes
fluid = get_particle_array(name='fluid', x=x, y=y, h=h, m=m, V=V, p=p)
# particles and domain
self.fluid = fluid
self.domain = DomainManager(xmin=0, xmax=L, ymin=0, ymax=L,
periodic_in_x=True, periodic_in_y=True,
backend=self.backend
)
self.kernel = get_compiled_kernel(Gaussian(dim=2))
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 __init__(self,
particle_arrays,
num_points=125000,
kernel=None,
x=None,
y=None,
z=None,
domain_manager=None,
equations=None,
use_shepard=True):
"""
The x, y, z coordinates need not be specified, and if they are not,
the bounds of the interpolated domain is automatically computed and
`num_points` number of points are used in this domain uniformly placed.
Parameters
----------
particle_arrays: list
A list of particle arrays.
num_points: int
the number of points to interpolate on to.
kernel: Kernel
the kernel to use for interpolation.
x: ndarray
the x-coordinate of points on which to interpolate.
y: ndarray
the y-coordinate of points on which to interpolate.
z: ndarray
the z-coordinate of points on which to interpolate.
domain_manager: DomainManager
An optional Domain manager for periodic domains.
equations: sequence
A sequence of equations or groups. Defaults to None. This is
used only if the default interpolation equations are inadequate.
use_shepard: bool
Use Shepard interpolation for the interpolation when no equations
are specified. If False, a simple SPH interpolation is performed.
"""
self._set_particle_arrays(particle_arrays)
bounds = get_bounding_box(self.particle_arrays)
shape = get_nx_ny_nz(num_points, bounds)
self.dim = 3 - list(shape).count(1)
if kernel is None:
self.kernel = Gaussian(dim=self.dim)
else:
self.kernel = kernel
self.pa = None
self.nnps = None
self.equations = equations
self.func_eval = None
self.domain_manager = domain_manager
self.use_shepard = use_shepard
if x is None and y is None and z is None:
self.set_domain(bounds, shape)
else:
self.set_interpolation_points(x=x, y=y, z=z)
def create_solver(self):
dim = 3
kernel = Gaussian(dim=dim)
# kernel = WendlandQuintic(dim=dim)
self.wdeltap = kernel.kernel(rij=dx, h=hdx * dx)
integrator = EPECIntegrator(projectile=SolidMechStep(),
plate=SolidMechStep())
dt = 5e-10
tf = 40e-7
solver = Solver(kernel=kernel,
dim=dim,
integrator=integrator,
dt=dt,
tf=tf,
output_at_times=numpy.mgrid[0:40e-7:1e-7])
return solver
def __init__(self, dim, dst, src, kernel=None):
self.dst = dst
self.src = src
if kernel is None:
self.kernel = get_compiled_kernel(Gaussian(dim))
# create the neighbor locator object
self.nnps = nnps = NNPS(dim=dim,
particles=[dst, src],
radius_scale=self.kernel.radius_scale)
nnps.update()
def create_scheme(self):
s = WCSPHScheme(
['fluid'], [], dim=2, rho0=self.ro, c0=self.co,
h0=self.dx*self.hdx, hdx=self.hdx, gamma=7.0, alpha=0.1, beta=0.0
)
kernel = Gaussian(dim=2)
dt = 5e-6; tf = 0.0076
s.configure_solver(
kernel=kernel, integrator_cls=EPECIntegrator, dt=dt, tf=tf,
adaptive_timestep=True, cfl=0.3, n_damp=50,
output_at_times=[0.0008, 0.0038]
)
return s
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 setUp(self):
# create the particle arrays
L = 1.0
n = 100
dx = L / n
hdx = 1.5
_x = np.arange(dx / 2, L, dx)
self.vol = vol = dx * dx
# fluid particles
xx, yy = np.meshgrid(_x, _x)
x = xx.ravel()
y = yy.ravel() # particle positions
h = np.ones_like(x) * hdx * dx # smoothing lengths
m = np.ones_like(x) * vol # mass
V = np.zeros_like(x) # volumes
fluid = get_particle_array(name='fluid', x=x, y=y, h=h, m=m, V=V)
# channel particles
_y = np.arange(L + dx / 2, L + dx / 2 + 10 * dx, dx)
xx, yy = np.meshgrid(_x, _y)
xtop = xx.ravel()
ytop = yy.ravel()
_y = np.arange(-dx / 2, -dx / 2 - 10 * dx, -dx)
xx, yy = np.meshgrid(_x, _y)
xbot = xx.ravel()
ybot = yy.ravel()
x = np.concatenate((xtop, xbot))
y = np.concatenate((ytop, ybot))
h = np.ones_like(x) * hdx * dx
m = np.ones_like(x) * vol
V = np.zeros_like(x)
channel = get_particle_array(name='channel', x=x, y=y, h=h, m=m, V=V)
# particles and domain
self.particles = particles = [fluid, channel]
self.domain = domain = DomainManager(xmin=0,
xmax=L,
periodic_in_x=True)
self.kernel = get_compiled_kernel(Gaussian(dim=2))
def setUp(self):
# create the particle arrays
L = 1.0
n = 5
dx = L / n
hdx = 1.5
self.L = L
self.vol = vol = dx * dx * dx
# fluid particles
xx, yy, zz = np.mgrid[dx / 2:L:dx, dx / 2:L:dx, dx / 2:L:dx]
x = xx.ravel()
y = yy.ravel()
z = zz.ravel() # particle positions
p = self._get_pressure(x, y, z)
h = np.ones_like(x) * hdx * dx # smoothing lengths
m = np.ones_like(x) * vol # mass
V = np.zeros_like(x) # volumes
fluid = get_particle_array(name='fluid',
x=x,
y=y,
z=z,
h=h,
m=m,
V=V,
p=p)
# particles and domain
self.fluid = fluid
self.domain = DomainManager(xmin=0,
xmax=L,
ymin=0,
ymax=L,
zmin=0,
zmax=L,
periodic_in_x=True,
periodic_in_y=True,
periodic_in_z=True)
self.kernel = get_compiled_kernel(Gaussian(dim=3))
self.orig_n = self.fluid.get_number_of_particles()
self.nnps = LinkedListNNPS(dim=3,
particles=[self.fluid],
domain=self.domain,
radius_scale=self.kernel.radius_scale)
def configure_solver(self,
kernel=None,
integrator_cls=None,
extra_steppers=None,
**kw):
"""Configure the solver to be generated.
Parameters
----------
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 Gaussian
if kernel is None:
kernel = Gaussian(dim=self.dim)
steppers = {}
if extra_steppers is not None:
steppers.update(extra_steppers)
from pysph.sph.integrator import PECIntegrator
from pysph.sph.integrator_step import ADKEStep
cls = integrator_cls if integrator_cls is not None else PECIntegrator
step_cls = ADKEStep
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 create_solver(self):
print("Create our own solver.")
kernel = Gaussian(dim=2)
integrator = EPECIntegrator(fluid=WCSPHStep())
dt = 5e-6
tf = 0.0076
solver = Solver(kernel=kernel,
dim=2,
integrator=integrator,
dt=dt,
tf=tf,
adaptive_timestep=True,
cfl=0.3,
n_damp=50,
output_at_times=[0.0008, 0.0038])
return solver
class TestGaussian2D(TestCubicSpline2D):
kernel_factory = staticmethod(lambda: Gaussian(dim=2))
def test_simple(self):
self.check_kernel_at_origin(1.0 / np.pi)
def test_zeroth_kernel_moments(self):
r = self.check_kernel_moment_2d(0, 0)
self.assertAlmostEqual(r, 1.0, 3)
def test_first_grad_moment(self):
r = self.check_gradient_moment_2d(1, 0)
self.assertAlmostEqual(r[0], -1.0, 2)
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, 2)
r = self.check_gradient_moment_2d(1, 1)
self.assertAlmostEqual(r[0], 0.0, 8)
self.assertAlmostEqual(r[1], 0.0, 8)
def configure_scheme(self):
scheme = self.scheme
kernel = Gaussian(dim=2)
dt = 5e-6
tf = 0.0076
if self.options.scheme == 'wcsph':
scheme.configure_solver(kernel=kernel,
integrator_cls=EPECIntegrator,
dt=dt,
tf=tf,
adaptive_timestep=True,
cfl=0.3,
n_damp=50,
output_at_times=[0.0008, 0.0038])
elif self.options.scheme == 'iisph':
scheme.configure_solver(kernel=kernel,
dt=dt,
tf=tf,
adaptive_timestep=True,
output_at_times=[0.0008, 0.0038])
class TestGaussian1D(TestCubicSpline1D):
kernel_factory = staticmethod(lambda: Gaussian(dim=1))
def test_simple(self):
self.check_kernel_at_origin(1.0 / np.sqrt(np.pi))
def test_first_grad_moment(self):
kh = self.wrapper.radius_scale
r = self.check_grad_moment_1d(0.0, 2 * kh, 1.0, 1, xj=kh)
self.assertAlmostEqual(r, -1.0, 3)
def test_zeroth_kernel_moments(self):
kh = self.wrapper.radius_scale
# zero'th moment
r = self.check_kernel_moment_1d(-kh, kh, 1.0, 0, xj=0)
self.assertAlmostEqual(r, 1.0, 4)
# Use a non-unit h.
r = self.check_kernel_moment_1d(-kh, kh, 0.5, 0, xj=0)
self.assertAlmostEqual(r, 1.0, 4)
r = self.check_kernel_moment_1d(0.0, 2 * kh, 1.0, 0, xj=kh)
self.assertAlmostEqual(r, 1.0, 4)
def __init__(self,
arrays,
equations,
dim,
kernel=None,
domain_manager=None,
backend=None,
nnps_factory=NNPS):
"""Constructor.
Parameters
----------
arrays: list(ParticleArray)
equations: list
dim: int
kernel: kernel instance.
domain_manager: DomainManager
backend: str: indicates the backend to use.
one of ('opencl', 'cython', '', None)
nnps_factory: A factory that creates an NNPSBase instance.
"""
self.arrays = arrays
self.equations = equations
self.domain_manager = domain_manager
self.dim = dim
if kernel is None:
self.kernel = Gaussian(dim=dim)
else:
self.kernel = kernel
self.nnps_factory = nnps_factory
self.backend = backend
self.func_eval = AccelerationEval(arrays,
equations,
self.kernel,
backend=backend)
compiler = SPHCompiler(self.func_eval, None)
compiler.compile()
self._create_nnps(arrays)
def get_plate_particles():
gmsh.initialize()
gmsh.open('t.msh')
# Launch the GUI to see the results:
# if '-nopopup' not in sys.argv:
# gmsh.fltk.run()
nodeTags, nodesCoord, parametricCoord = gmsh.model.mesh.getNodes()
liquid_x = nodesCoord[1::3]
liquid_y = nodesCoord[2::3]
liquid_z = nodesCoord[0::3]
liquid_y = liquid_y + abs(min(liquid_y))
liquid_x = liquid_x + abs(min(liquid_x))
liquid_x = liquid_x[0::5] * 1e-3 - 0.002
liquid_y = liquid_y[0::5] * 1e-3 - 0.1
liquid_z = liquid_z[0::5] * 1e-3 - 0.005
print('%d Target particles' % len(liquid_x))
hf = numpy.ones_like(liquid_x) * h
mf = numpy.ones_like(liquid_x) * dx * dy * dz * ro1
rhof = numpy.ones_like(liquid_x) * ro1
csf = numpy.ones_like(liquid_x) * cs1
pa = plate = get_particle_array(name="plate",
x=liquid_x,
y=liquid_y,
z=liquid_z,
h=hf,
m=mf,
rho=rhof,
cs=csf)
# add requisite properties
# sound speed etc.
add_properties(pa, 'e')
# velocity gradient properties
add_properties(pa, 'v00', 'v01', 'v02', 'v10', 'v11', 'v12', 'v20', 'v21',
'v22')
# artificial stress properties
add_properties(pa, 'r00', 'r01', 'r02', 'r11', 'r12', 'r22')
# deviatoric stress components
add_properties(pa, 's00', 's01', 's02', 's11', 's12', 's22')
# deviatoric stress accelerations
add_properties(pa, 'as00', 'as01', 'as02', 'as11', 'as12', 'as22')
# deviatoric stress initial values
add_properties(pa, 's000', 's010', 's020', 's110', 's120', 's220')
# 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')
pa.add_constant('G', G1)
pa.add_constant('n', 4)
kernel = Gaussian(dim=3)
wdeltap = kernel.kernel(rij=dx, h=hdx * dx)
pa.add_constant('wdeltap', wdeltap)
# load balancing properties
pa.set_lb_props(list(pa.properties.keys()))
# removed S_00 and similar components
plate.v[:] = 0.0
return plate
def __init__(self,
particle_arrays,
num_points=125000,
kernel=None,
x=None,
y=None,
z=None,
domain_manager=None,
equations=None,
method='shepard'):
"""
The x, y, z coordinates need not be specified, and if they are not,
the bounds of the interpolated domain is automatically computed and
`num_points` number of points are used in this domain uniformly placed.
Parameters
----------
particle_arrays: list
A list of particle arrays.
num_points: int
the number of points to interpolate on to.
kernel: Kernel
the kernel to use for interpolation.
x: ndarray
the x-coordinate of points on which to interpolate.
y: ndarray
the y-coordinate of points on which to interpolate.
z: ndarray
the z-coordinate of points on which to interpolate.
domain_manager: DomainManager
An optional Domain manager for periodic domains.
equations: sequence
A sequence of equations or groups. Defaults to None. This is
used only if the default interpolation equations are inadequate.
method : str
String with the following allowed methods: 'shepard', 'sph',
'order1'
"""
self._set_particle_arrays(particle_arrays)
bounds = get_bounding_box(self.particle_arrays)
shape = get_nx_ny_nz(num_points, bounds)
self.dim = 3 - list(shape).count(1)
if kernel is None:
self.kernel = Gaussian(dim=self.dim)
else:
self.kernel = kernel
self.pa = None
self.nnps = None
self.equations = equations
self.func_eval = None
self.domain_manager = domain_manager
self.method = method
if method not in ['sph', 'shepard', 'order1']:
raise RuntimeError('%s method is not implemented' % (method))
if x is None and y is None and z is None:
self.set_domain(bounds, shape)
else:
self.set_interpolation_points(x=x, y=y, z=z)
def get_projectile_particles():
x, y, z = numpy.mgrid[-r:r + 1e-6:dx, -r:r + 1e-6:dx, -r:r + 1e-6:dx]
x = x.ravel()
y = y.ravel()
z = z.ravel()
d = (x * x + y * y + z * z)
keep = numpy.flatnonzero(d <= r * r)
x = x[keep]
y = y[keep]
z = z[keep]
x = x - (r + 2 * dx)
print('%d Projectile particles' % len(x))
hf = numpy.ones_like(x) * h
mf = numpy.ones_like(x) * dx * dy * dz * ro2
rhof = numpy.ones_like(x) * ro2
csf = numpy.ones_like(x) * cs2
u = numpy.ones_like(z) * v_s
pa = projectile = get_particle_array(name="projectile",
x=x,
y=y,
z=z,
h=hf,
m=mf,
rho=rhof,
cs=csf,
u=u)
# add requisite properties
# sound speed etc.
add_properties(pa, 'e')
# velocity gradient properties
add_properties(pa, 'v00', 'v01', 'v02', 'v10', 'v11', 'v12', 'v20', 'v21',
'v22')
# artificial stress properties
add_properties(pa, 'r00', 'r01', 'r02', 'r11', 'r12', 'r22')
# deviatoric stress components
add_properties(pa, 's00', 's01', 's02', 's11', 's12', 's22')
# deviatoric stress accelerations
add_properties(pa, 'as00', 'as01', 'as02', 'as11', 'as12', 'as22')
# deviatoric stress initial values
add_properties(pa, 's000', 's010', 's020', 's110', 's120', 's220')
# 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')
pa.add_constant('G', G2)
pa.add_constant('n', 4)
kernel = Gaussian(dim=3)
wdeltap = kernel.kernel(rij=dx, h=hdx * dx)
pa.add_constant('wdeltap', wdeltap)
# load balancing properties
pa.set_lb_props(list(pa.properties.keys()))
return projectile
def get_plate_particles():
xarr = numpy.arange(0, 0.002 + dx, dx)
yarr = numpy.arange(-0.020, 0.02 + dx, dx)
zarr = numpy.arange(-0.02, 0.02 + dx, dx)
x, y, z = numpy.mgrid[0:0.002 + dx:dx, -0.02:0.02 + dx:dx,
-0.02:0.02 + dx:dx]
x = x.ravel()
y = y.ravel()
z = z.ravel()
print('%d Target particles' % len(x))
hf = numpy.ones_like(x) * h
mf = numpy.ones_like(x) * dx * dy * dz * ro1
rhof = numpy.ones_like(x) * ro1
csf = numpy.ones_like(x) * cs1
pa = plate = get_particle_array(name="plate",
x=x,
y=y,
z=z,
h=hf,
m=mf,
rho=rhof,
cs=csf)
# add requisite properties
# sound speed etc.
add_properties(pa, 'e')
# velocity gradient properties
add_properties(pa, 'v00', 'v01', 'v02', 'v10', 'v11', 'v12', 'v20', 'v21',
'v22')
# artificial stress properties
add_properties(pa, 'r00', 'r01', 'r02', 'r11', 'r12', 'r22')
# deviatoric stress components
add_properties(pa, 's00', 's01', 's02', 's11', 's12', 's22')
# deviatoric stress accelerations
add_properties(pa, 'as00', 'as01', 'as02', 'as11', 'as12', 'as22')
# deviatoric stress initial values
add_properties(pa, 's000', 's010', 's020', 's110', 's120', 's220')
# 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')
pa.add_constant('G', G1)
pa.add_constant('n', 4)
kernel = Gaussian(dim=3)
wdeltap = kernel.kernel(rij=dx, h=hdx * dx)
pa.add_constant('wdeltap', wdeltap)
# load balancing properties
pa.set_lb_props(list(pa.properties.keys()))
# removed S_00 and similar components
plate.v[:] = 0.0
return plate
