def create_equations(self):
equations = [
Group(equations=[
TaitEOS(dest='fluid', sources=None, rho0=self.ro, c0=self.co,
gamma=7.0),
TaitEOS(dest='tank', sources=None, rho0=self.ro, c0=self.co,
gamma=7.0),
], real=False),
Group(equations=[
SummationDensityShepardFilter(
dest='fluid',
sources=['fluid', 'tank'], ),
# SummationDensityShepardFilter(
# dest='tank',
# sources=['fluid', 'tank'], ),
SummationDensity(
dest='tank',
sources=['fluid', 'tank'], ),
MomentumEquation(dest='fluid', sources=['fluid', 'tank'],
alpha=self.alpha, beta=0.0, c0=self.co,
gy=-9.81),
XSPHCorrection(dest='fluid', sources=['fluid', 'tank']),
]),
]
return equations
def test_crksph_symmetric(self):
# Given
pa = self.pa
dest = 'fluid'
sources = ['fluid']
pa.add_property('zero_mom')
pa.add_property('first_mom', stride=3)
pa.rho[:] = 1.0
eqs = [
Group(equations=[
SummationDensity(dest=dest, sources=sources),
]),
Group(equations=[
CRKSPHPreStep(dest=dest, sources=sources, dim=self.dim)
]),
Group(equations=[
CRKSPHSymmetric(dest=dest, sources=sources,
dim=self.dim, tol=1000.0),
GradPhiSymm(dest=dest, sources=sources),
VerifyCRKSPH(dest=dest, sources=sources)
])
]
a_eval = self._make_accel_eval(eqs)
# When
a_eval.evaluate(0.0, 0.1)
# Then
np.testing.assert_array_almost_equal(pa.zero_mom, 1.0)
np.testing.assert_array_almost_equal(pa.first_mom, 0.0)
# Here all we can test is that the total acceleration is zero.
print(pa.gradu)
self.assertAlmostEqual(np.sum(pa.gradu[::3]), 0.0)
self.assertAlmostEqual(np.sum(pa.gradu[1::3]), 0.0)
def test_gradient_correction(self):
# Given
pa = self.pa
dest = 'fluid'
sources = ['fluid']
eqs = [
Group(equations=[
SummationDensity(dest=dest, sources=sources),
]),
Group(equations=[
GradientCorrectionPreStep(dest=dest, sources=sources,
dim=self.dim)
]),
Group(equations=[
GradientCorrection(dest=dest, sources=sources,
dim=self.dim, tol=100.0),
GradPhi(dest=dest, sources=sources)
])
]
a_eval = self._make_accel_eval(eqs)
# When
a_eval.evaluate(0.0, 0.1)
# Then
np.testing.assert_array_almost_equal(pa.gradu, self.expect)
def test_update_nnps_is_called_on_gpu(self):
# Given
equations = [
Group(equations=[
SummationDensity(dest='fluid', sources=['fluid']),
],
update_nnps=True),
Group(equations=[EqWithTime(dest='fluid', sources=['fluid'])]),
]
# When
a_eval = self._make_accel_eval(equations)
# Then
h = a_eval.c_acceleration_eval.helper
assert len(h.calls) == 5
call = h.calls[0]
assert call['type'] == 'kernel'
assert call['loop'] is False
call = h.calls[1]
assert call['type'] == 'kernel'
assert call['loop'] is True
call = h.calls[2]
assert call['type'] == 'method'
assert call['method'] == 'update_nnps'
call = h.calls[3]
assert call['type'] == 'kernel'
assert call['loop'] is False
call = h.calls[4]
assert call['type'] == 'kernel'
assert call['loop'] is True
def setUp(self):
from pysph.sph.basic_equations import SummationDensity
from pysph.sph.wc.basic import TaitEOS
self.group = CythonGroup(
[SummationDensity('f', ['f']),
TaitEOS('f', None, rho0=1.0, c0=1.0, gamma=1.4, p0=1.0)]
)
def test_crksph(self):
# Given
pa = self.pa
dest = 'fluid'
sources = ['fluid']
pa.add_property('zero_mom')
pa.add_property('first_mom', stride=3)
pa.rho[:] = 1.0
eqs = [
Group(equations=[
SummationDensity(dest=dest, sources=sources),
]),
Group(equations=[
CRKSPHPreStep(dest=dest, sources=sources, dim=self.dim)
]),
Group(equations=[
CRKSPH(dest=dest, sources=sources,
dim=self.dim, tol=1000.0),
GradPhi(dest=dest, sources=sources),
VerifyCRKSPH(dest=dest, sources=sources)
])
]
a_eval = self._make_accel_eval(eqs)
# When
a_eval.evaluate(0.0, 0.1)
# Then
np.testing.assert_array_almost_equal(pa.zero_mom, 1.0)
np.testing.assert_array_almost_equal(pa.first_mom, 0.0)
np.testing.assert_array_almost_equal(pa.gradu, self.expect)
def _compile_acceleration_eval(self, arrays):
names = [x.name for x in self.particle_arrays]
if self.equations is None:
if self.method == 'shepard':
equations = [
InterpolateFunction(dest='interpolate', sources=names)
]
elif self.method == 'sph':
equations = [InterpolateSPH(dest='interpolate', sources=names)]
else:
equations = [
Group(equations=[
SummationDensity(dest=name, sources=names)
for name in names
],
real=False),
Group(equations=[
SPHFirstOrderApproximationPreStep(dest='interpolate',
sources=names,
dim=self.dim)
],
real=True),
Group(equations=[
SPHFirstOrderApproximation(dest='interpolate',
sources=names,
dim=self.dim)
],
real=True)
]
else:
equations = self.equations
self.func_eval = AccelerationEval(arrays, equations, self.kernel)
compiler = SPHCompiler(self.func_eval, None)
compiler.compile()
def test_should_raise_runtime_error_when_invalid_dest_source(self):
# Given
f = get_particle_array(name='f')
# When
eq = SummationDensity(dest='fluid', sources=['f'])
# Then
self.assertRaises(RuntimeError, check_equation_array_properties, eq,
[f])
# When
eq = SummationDensity(dest='f', sources=['fluid'])
# Then
self.assertRaises(RuntimeError, check_equation_array_properties, eq,
[f])
def setUp(self):
x = np.linspace(0, 1, 10)
dx = x[1] - x[0]
self.dx = dx
m = np.ones_like(x)
h = np.ones_like(x) * dx
self.src = get_particle_array(name='src', x=x, m=m, h=h)
self.equations = [SummationDensity(dest='dest', sources=['src'])]
def test_update_nnps_should_only_be_called_once_per_group(self):
# Given
eqs = [
SummationDensity(dest='f1', sources=['f1', 'f2']),
SummationDensity(dest='f2', sources=['f1', 'f2']),
]
equations = [Group(equations=eqs, update_nnps=True)]
# When
a_eval = self._make_accel_eval(equations)
# Then
h = a_eval.c_acceleration_eval.helper
update_nnps = [
call for call in h.calls if call['method'] == 'update_nnps'
]
self.assertEqual(len(update_nnps), 1)
def test_should_pass_when_properties_exist(self):
# Given
f = get_particle_array(name='f')
# When
eq = SummationDensity(dest='f', sources=['f'])
# Then
check_equation_array_properties(eq, [f])
def get_equations(self):
from pysph.sph.equation import Group
from pysph.sph.basic_equations import SummationDensity
from pysph.sph.gas_dynamics.basic import (IdealGasEOS,
ADKEAccelerations,
SummationDensityADKE)
from pysph.sph.gas_dynamics.boundary_equations import WallBoundary
equations = []
g1 = []
for solid in self.solids:
g1.append(WallBoundary(solid, sources=self.fluids))
equations.append(Group(equations=g1))
g2 = []
for fluid in self.fluids:
g2.append(
SummationDensityADKE(fluid,
sources=self.fluids + self.solids,
k=self.k,
eps=self.eps))
equations.append(Group(g2, update_nnps=True, iterate=False))
g3 = []
for solid in self.solids:
g3.append(WallBoundary(solid, sources=self.fluids))
equations.append(Group(equations=g3))
g4 = []
for fluid in self.fluids:
g4.append(SummationDensity(fluid, self.fluids + self.solids))
equations.append(Group(g4))
g5 = []
for solid in self.solids:
g5.append(WallBoundary(solid, sources=self.fluids))
equations.append(Group(equations=g5))
g6 = []
for elem in self.fluids + self.solids:
g6.append(IdealGasEOS(elem, sources=None, gamma=self.gamma))
equations.append(Group(equations=g6))
g7 = []
for fluid in self.fluids:
g7.append(
ADKEAccelerations(dest=fluid,
sources=self.fluids + self.solids,
alpha=self.alpha,
beta=self.beta,
g1=self.g1,
g2=self.g2,
k=self.k,
eps=self.eps))
equations.append(Group(equations=g7))
return equations
def create_equations(self):
equations = [
Group(equations=[
BodyForce(dest='cube', sources=None, gy=-9.81),
SummationDensity(dest='cube', sources=['fluid', 'cube'])
],
real=False),
Group(equations=[
TaitEOSHGCorrection(dest='cube',
sources=None,
rho0=self.solid_rho,
c0=self.co,
gamma=7.0),
TaitEOSHGCorrection(dest='fluid',
sources=None,
rho0=self.ro,
c0=self.co,
gamma=7.0),
TaitEOSHGCorrection(dest='tank',
sources=None,
rho0=self.ro,
c0=self.co,
gamma=7.0),
],
real=False),
Group(equations=[
ContinuityEquation(
dest='fluid',
sources=['fluid', 'tank', 'cube'],
),
ContinuityEquation(
dest='tank',
sources=['fluid', 'tank', 'cube'],
),
MomentumEquation(dest='fluid',
sources=['fluid', 'tank', 'cube'],
alpha=self.alpha,
beta=0.0,
c0=self.co,
gy=-9.81),
LiuFluidForce(
dest='fluid',
sources=['cube'],
),
XSPHCorrection(dest='fluid', sources=['fluid', 'tank']),
]),
Group(equations=[
RigidBodyCollision(dest='cube', sources=['tank'], kn=1e5)
]),
Group(equations=[RigidBodyMoments(dest='cube', sources=None)]),
Group(equations=[RigidBodyMotion(dest='cube', sources=None)]),
]
return equations
def test_invalid_kwarg_raises_error(self):
# Given
x = np.linspace(0, 1, 10)
pa = get_particle_array(name='fluid', x=x)
equations = [SummationDensity(dest='fluid', sources=['fluid'])]
kernel = QuinticSpline(dim=1)
a_eval = AccelerationEval([pa], equations, kernel=kernel)
a_helper = AccelerationEvalCythonHelper(a_eval)
# When/Then
integrator = PECIntegrator(f=WCSPHStep())
self.assertRaises(RuntimeError, IntegratorCythonHelper, integrator,
a_helper)
def test_precomputed_should_work_on_gpu(self):
# Given
pa = self.pa
equations = [SummationDensity(dest='fluid', sources=['fluid'])]
a_eval = self._make_accel_eval(equations)
# When
a_eval.compute(0.1, 0.1)
# Then
expect = np.asarray([7.357, 9.0, 9., 9., 9., 9., 9., 9., 9., 7.357])
pa.gpu.pull('rho')
print(pa.rho, pa.gpu.rho)
self.assertTrue(np.allclose(expect, pa.rho, atol=1e-2))
def test_update_nnps_should_only_be_called_once_per_group(self):
# Given
eqs = [
SummationDensity(dest='f1', sources=['f1', 'f2']),
SummationDensity(dest='f2', sources=['f1', 'f2']),
]
equations = [Group(equations=eqs, update_nnps=True)]
a_eval = self._make_accel_eval(equations)
# This is quite ugly, it is not easy to mock out the set_nnps on an
# acceleration eval as that requires a Cython object and not a mock
# instance.
profile_info = get_profile_info()
n_up_dom = profile_info[0]['Integrator.update_domain']['calls']
n_up = profile_info[0]['nnps.update']['calls']
# When
a_eval.compute(0.1, 0.1)
# Then
profile_info = get_profile_info()
ncall = profile_info[0]['Integrator.update_domain']['calls']
self.assertEqual(ncall, n_up_dom + 1)
ncall = profile_info[0]['nnps.update']['calls']
self.assertEqual(ncall, n_up + 1)
def get_equations(self):
from pysph.sph.basic_equations import SummationDensity
all = self.fluids
equations = []
eq0 = []
for fluid in self.fluids:
eq0.append(
MomentumEquationViscosity(dest=fluid,
sources=all,
nu=self.nu,
gx=self.gx,
gy=self.gy,
gz=self.gz))
equations.append(Group(equations=eq0))
eq1, g2 = [], []
for fluid in self.fluids:
eq1.append(Predict(dest=fluid, sources=None))
g2.append(Group(equations=eq1, update_nnps=True))
eq2 = []
for fluid in self.fluids:
eq2.append(SummationDensity(dest=fluid, sources=all))
g2.append(Group(equations=eq2, real=False))
eq3 = []
for fluid in self.fluids:
eq3.append(ComputePressure(dest=fluid, sources=all,
rho0=self.rho0))
g2.append(Group(equations=eq3, real=True))
eq4 = []
for fluid in self.fluids:
eq4.append(
MomentumEquationPressureGradient(dest=fluid,
sources=all,
rho0=self.rho0,
tolerance=self.tolerance,
debug=self.debug), )
g2.append(Group(equations=eq4, real=True))
equations.append(
Group(equations=g2,
iterate=True,
max_iterations=500,
min_iterations=2))
return equations
def test_should_support_loop_all_and_loop(self):
# Given
pa = self.pa
equations = [SummationDensity(dest='fluid', sources=['fluid'])]
a_eval = self._make_accel_eval(equations)
a_eval.compute(0.1, 0.1)
ref_rho = pa.rho.copy()
# When
pa.rho[:] = 0.0
equations = [LoopAllEquation(dest='fluid', sources=['fluid'])]
a_eval = self._make_accel_eval(equations)
a_eval.compute(0.1, 0.1)
# Then
# 2*ref_rho as we are doing both the loop and loop_all to test if
# both are called.
self.assertTrue(np.allclose(pa.rho, 2.0*ref_rho))
def create_equations(self):
equations = [
Group(equations=[
BodyForce(dest='cube', sources=None, gy=-9.81),
],
real=False),
Group(equations=[
SummationDensity(
dest='fluid',
sources=['fluid'],
),
SummationDensityBoundary(
dest='fluid', sources=['tank', 'cube'], fluid_rho=1000.0)
]),
# Tait equation of state
Group(equations=[
TaitEOSHGCorrection(dest='fluid',
sources=None,
rho0=self.ro,
c0=self.co,
gamma=7.0),
],
real=False),
Group(equations=[
MomentumEquation(dest='fluid',
sources=['fluid'],
alpha=self.alpha,
beta=0.0,
c0=self.co,
gy=-9.81),
AkinciRigidFluidCoupling(dest='fluid',
sources=['cube', 'tank']),
XSPHCorrection(dest='fluid', sources=['fluid', 'tank']),
]),
Group(equations=[
RigidBodyCollision(
dest='cube', sources=['tank', 'cube'], kn=1e5)
]),
Group(equations=[RigidBodyMoments(dest='cube', sources=None)]),
Group(equations=[RigidBodyMotion(dest='cube', sources=None)]),
]
return equations
def test_precomputed_should_work_on_gpu_with_double(self):
orig = get_config().use_double
def _cleanup():
get_config().use_double = orig
get_config().use_double = True
self.addCleanup(_cleanup)
# Given
pa = self.pa
equations = [SummationDensity(dest='fluid', sources=['fluid'])]
a_eval = self._make_accel_eval(equations)
# When
a_eval.compute(0.1, 0.1)
# Then
expect = np.asarray([7.357, 9.0, 9., 9., 9., 9., 9., 9., 9., 7.357])
pa.gpu.pull('rho')
print(pa.rho, pa.gpu.rho)
self.assertTrue(np.allclose(expect, pa.rho, atol=1e-2))
def test_get_equations_with_converged(self):
pytest.importorskip('pysph.base.gpu_nnps')
from pysph.sph.acceleration_eval_opencl_helper import \
get_equations_with_converged
# Given
se = SimpleEquation(dest='fluid', sources=['fluid'])
se1 = SimpleEquation(dest='fluid', sources=['fluid'])
sd = SummationDensity(dest='fluid', sources=['fluid'])
me = MixedTypeEquation(dest='fluid', sources=['fluid'])
eq_t = EqWithTime(dest='fluid', sources=['fluid'])
g = Group(equations=[
Group(equations=[Group(equations=[se, sd])],
iterate=True,
max_iterations=10),
Group(equations=[me, eq_t, se1]),
], )
# When
eqs = get_equations_with_converged(g)
# Then
assert eqs == [se, se1]
def get_equations(self):
from pysph.sph.equation import Group
from pysph.sph.wc.transport_velocity import (
SummationDensity, StateEquation, MomentumEquationPressureGradient,
MomentumEquationArtificialViscosity, MomentumEquationViscosity,
MomentumEquationArtificialStress, SolidWallPressureBC,
SolidWallNoSlipBC, SetWallVelocity)
equations = []
all = self.fluids + self.solids
g1 = []
for fluid in self.fluids:
g1.append(SummationDensity(dest=fluid, sources=all))
equations.append(Group(equations=g1, real=False))
g2 = []
for fluid in self.fluids:
g2.append(
StateEquation(dest=fluid,
sources=None,
p0=self.p0,
rho0=self.rho0,
b=1.0))
for solid in self.solids:
g2.append(SetWallVelocity(dest=solid, sources=self.fluids))
equations.append(Group(equations=g2, real=False))
g3 = []
for solid in self.solids:
g3.append(
SolidWallPressureBC(dest=solid,
sources=self.fluids,
b=1.0,
rho0=self.rho0,
p0=self.p0,
gx=self.gx,
gy=self.gy,
gz=self.gz))
equations.append(Group(equations=g3, real=False))
g4 = []
for fluid in self.fluids:
g4.append(
MomentumEquationPressureGradient(dest=fluid,
sources=all,
pb=self.pb,
gx=self.gx,
gy=self.gy,
gz=self.gz,
tdamp=self.tdamp))
if self.alpha > 0.0:
g4.append(
MomentumEquationArtificialViscosity(dest=fluid,
sources=all,
c0=self.c0,
alpha=self.alpha))
if self.nu > 0.0:
g4.append(
MomentumEquationViscosity(dest=fluid,
sources=self.fluids,
nu=self.nu))
if len(self.solids) > 0:
g4.append(
SolidWallNoSlipBC(dest=fluid,
sources=self.solids,
nu=self.nu))
g4.append(
MomentumEquationArtificialStress(dest=fluid,
sources=self.fluids))
equations.append(Group(equations=g4))
return equations
def create_equations(self):
equations = [
Group(
equations=[
BodyForce(dest='cube', sources=None, gy=-9.81),
BodyForce(dest='wood', sources=None, gy=-9.81),
BodyForce(dest='small_tank', sources=None, gy=-9.81),
BodyForce(dest='outside', sources=None, gy=-9.81),
SummationDensity(dest='cube', sources=['fluid', 'cube']),
SummationDensity(dest='wood', sources=['fluid', 'wood']),
SummationDensity(dest='small_tank',
sources=['fluid', 'small_tank']),
SummationDensity(dest='outside',
sources=['fluid', 'outside'])
# NumberDensity(dest='cube', sources=['cube']),
],
real=False),
Group(equations=[
TaitEOSHGCorrection(dest='wood',
sources=None,
rho0=self.wood_rho,
c0=self.co,
gamma=7.0),
TaitEOSHGCorrection(dest='cube',
sources=None,
rho0=self.solid_rho,
c0=self.co,
gamma=7.0),
TaitEOSHGCorrection(dest='fluid',
sources=None,
rho0=self.ro,
c0=self.co,
gamma=7.0),
TaitEOSHGCorrection(dest='big_tank',
sources=None,
rho0=self.ro,
c0=self.co,
gamma=7.0),
TaitEOSHGCorrection(dest='small_tank',
sources=None,
rho0=self.wood_rho,
c0=self.co,
gamma=7.0),
TaitEOSHGCorrection(dest='outside',
sources=None,
rho0=self.ro,
c0=self.co,
gamma=7.0),
],
real=False),
Group(equations=[
ContinuityEquation(
dest='fluid',
sources=[
'fluid', 'small_tank', 'cube', 'wood', 'big_tank',
'outside'
],
),
ContinuityEquation(
dest='big_tank',
sources=[
'fluid', 'big_tank', 'cube', 'wood', 'small_tank',
'outside'
],
),
MomentumEquation(dest='fluid',
sources=['fluid', 'big_tank'],
alpha=self.alpha,
beta=0.0,
c0=self.co,
gy=-9.81),
LiuFluidForce(
dest='fluid',
sources=['cube'],
),
LiuFluidForce(
dest='fluid',
sources=['wood'],
),
LiuFluidForce(
dest='fluid',
sources=['small_tank'],
),
LiuFluidForce(
dest='fluid',
sources=['outside'],
),
# PressureRigidBody(dest='fluid', sources=['cube'],
# rho0=1500),
XSPHCorrection(dest='fluid', sources=['fluid', 'big_tank']),
]),
Group(equations=[
RigidBodyCollision(
dest='cube',
sources=['big_tank', 'wood', 'small_tank', 'outside'],
kn=1e6)
]),
Group(equations=[RigidBodyMoments(dest='cube', sources=None)]),
Group(equations=[RigidBodyMotion(dest='cube', sources=None)]),
Group(equations=[
RigidBodyCollision(
dest='wood',
sources=['big_tank', 'cube', 'small_tank', 'outside'],
kn=1e6)
]),
Group(equations=[RigidBodyMoments(dest='wood', sources=None)]),
Group(equations=[RigidBodyMotion(dest='wood', sources=None)]),
Group(equations=[
RigidBodyCollision(
dest='small_tank',
sources=['big_tank', 'cube', 'wood', 'outside'],
kn=1e6)
]),
Group(
equations=[RigidBodyMoments(dest='small_tank', sources=None)]),
Group(
equations=[RigidBodyMotion(dest='small_tank', sources=None)]),
Group(equations=[
RigidBodyCollision(
dest='outside',
sources=['big_tank', 'cube', 'small_tank', 'wood'],
kn=1e6)
]),
Group(equations=[RigidBodyMoments(dest='outside', sources=None)]),
Group(equations=[RigidBodyMotion(dest='outside', sources=None)]),
]
return equations
def get_equations(self):
from pysph.sph.equation import Group
from pysph.sph.gas_dynamics.basic import (
ScaleSmoothingLength, UpdateSmoothingLengthFromVolume,
SummationDensity, IdealGasEOS, MPMAccelerations)
equations = []
# Find the optimal 'h'
if self.adaptive_h_scheme == 'mpm':
g1 = []
for fluid in self.fluids:
g1.append(
SummationDensity(dest=fluid,
sources=self.fluids,
k=self.kernel_factor,
density_iterations=True,
dim=self.dim,
htol=1e-3))
equations.append(
Group(equations=g1,
update_nnps=True,
iterate=True,
max_iterations=50))
elif self.adaptive_h_scheme == 'gsph':
group = []
for fluid in self.fluids:
group.append(
ScaleSmoothingLength(dest=fluid, sources=None, factor=2.0))
equations.append(Group(equations=group, update_nnps=True))
group = []
for fluid in self.fluids:
group.append(
SummationDensity(dest=fluid,
sources=self.fluids,
dim=self.dim))
equations.append(Group(equations=group, update_nnps=False))
group = []
for fluid in self.fluids:
group.append(
UpdateSmoothingLengthFromVolume(dest=fluid,
sources=None,
k=self.kernel_factor,
dim=self.dim))
equations.append(Group(equations=group, update_nnps=True))
group = []
for fluid in self.fluids:
group.append(
SummationDensity(dest=fluid,
sources=self.fluids,
dim=self.dim))
equations.append(Group(equations=group, update_nnps=False))
# Done with finding the optimal 'h'
g2 = []
for fluid in self.fluids:
g2.append(IdealGasEOS(dest=fluid, sources=None, gamma=self.gamma))
equations.append(Group(equations=g2))
g3 = []
for fluid in self.fluids:
g3.append(
MPMAccelerations(dest=fluid,
sources=self.fluids,
alpha1_min=self.alpha1,
alpha2_min=self.alpha2,
beta=self.beta,
update_alpha1=self.update_alpha1,
update_alpha2=self.update_alpha2))
equations.append(Group(equations=g3))
return equations
def get_equations(self):
from pysph.sph.equation import Group
from pysph.sph.wc.basic import (MomentumEquation, TaitEOS,
TaitEOSHGCorrection,
UpdateSmoothingLengthFerrari)
from pysph.sph.wc.basic import (ContinuityEquationDeltaSPH,
MomentumEquationDeltaSPH)
from pysph.sph.basic_equations import \
(ContinuityEquation, SummationDensity, XSPHCorrection)
from pysph.sph.wc.viscosity import LaminarViscosity
equations = []
g1 = []
all = self.fluids + self.solids
if self.summation_density:
g0 = []
for name in self.fluids:
g0.append(SummationDensity(dest=name, sources=all))
equations.append(Group(equations=g0, real=False))
for name in self.fluids:
g1.append(
TaitEOS(dest=name,
sources=None,
rho0=self.rho0,
c0=self.c0,
gamma=self.gamma))
if self.hg_correction:
# This correction applies only to solids.
for name in self.solids:
g1.append(
TaitEOSHGCorrection(dest=name,
sources=None,
rho0=self.rho0,
c0=self.c0,
gamma=self.gamma))
equations.append(Group(equations=g1, real=False))
g2 = []
for name in self.solids:
g2.append(ContinuityEquation(dest=name, sources=self.fluids))
for name in self.fluids:
if self.delta_sph:
other = all[:]
other.remove(name)
g2.append(
ContinuityEquationDeltaSPH(dest=name,
sources=[name],
c0=self.c0,
delta=self.delta))
if len(other) > 0:
g2.append(ContinuityEquation(dest=name, sources=other))
g2.append(
MomentumEquationDeltaSPH(
dest=name,
sources=[name],
rho0=self.rho0,
c0=self.c0,
alpha=self.alpha,
gx=self.gx,
gy=self.gy,
gz=self.gz,
))
if len(other) > 0:
g2.append(
MomentumEquation(
dest=name,
sources=other,
c0=self.c0,
alpha=self.alpha,
beta=self.beta,
gx=self.gx,
gy=self.gy,
gz=self.gz,
tensile_correction=self.tensile_correction))
g2.append(XSPHCorrection(dest=name, sources=[name]))
else:
if not self.summation_density:
g2.append(ContinuityEquation(dest=name, sources=all))
g2.extend([
MomentumEquation(
dest=name,
sources=all,
alpha=self.alpha,
beta=self.beta,
gx=self.gx,
gy=self.gy,
gz=self.gz,
c0=self.c0,
tensile_correction=self.tensile_correction),
XSPHCorrection(dest=name, sources=[name])
])
if abs(self.nu) > 1e-14:
eq = LaminarViscosity(dest=name,
sources=self.fluids,
nu=self.nu)
g2.insert(-1, eq)
equations.append(Group(equations=g2))
if self.update_h:
g3 = [
UpdateSmoothingLengthFerrari(dest=x,
sources=None,
dim=self.dim,
hdx=self.hdx) for x in self.fluids
]
equations.append(Group(equations=g3, real=False))
return equations
def create_equations(self):
equations = [
SummationDensity(dest='fluid',
sources=['inlet', 'outlet', 'fluid'])
]
return equations
