def create_equations(self):
eqns = self.scheme.get_equations()
n = len(eqns)
tol = 1.0
if self.kernel_corr == 'grad-corr':
eqn1 = Group(
equations=[GradientCorrectionPreStep('fluid', ['fluid'])],
real=False)
for i in range(n):
eqn2 = GradientCorrection('fluid', ['fluid'], 2, tol)
eqns[i].equations.insert(0, eqn2)
eqns.insert(0, eqn1)
elif self.kernel_corr == 'mixed-corr':
eqn1 = Group(
equations=[MixedKernelCorrectionPreStep('fluid', ['fluid'])],
real=False)
for i in range(n):
eqn2 = GradientCorrection('fluid', ['fluid'], 2, tol)
eqns[i].equations.insert(0, eqn2)
eqns.insert(0, eqn1)
elif self.kernel_corr == 'crksph':
eqn1 = Group(equations=[CRKSPHPreStep('fluid', ['fluid'])],
real=False)
for i in range(n):
eqn2 = CRKSPH('fluid', ['fluid'], 2, tol)
eqns[i].equations.insert(0, eqn2)
eqns.insert(0, eqn1)
return eqns
def create_equations(self):
adami_equations = [
Group(
equations=[SummationDensity(dest='fluid', sources=['fluid'])],
real=False),
Group(equations=[
StateEquation(dest='fluid', sources=None, rho0=rho0, p0=p0),
],
real=False),
Group(equations=[
AdamiColorGradient(dest='fluid', sources=['fluid']),
],
real=False),
Group(equations=[
AdamiReproducingDivergence(dest='fluid',
sources=['fluid'],
dim=2),
],
real=False),
Group(equations=[
MomentumEquationPressureGradient(dest='fluid',
sources=['fluid'],
pb=p0),
MomentumEquationViscosityAdami(dest='fluid',
sources=['fluid']),
CSFSurfaceTensionForceAdami(
dest='fluid',
sources=None,
)
], )
]
return adami_equations
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 create_equations(self):
equations = [
Group(equations=[
TaitEOS(dest='fluid',
sources=None,
rho0=self.rho0,
c0=self.c0,
gamma=7.0),
TaitEOS(dest='solid',
sources=None,
rho0=self.rho0,
c0=self.c0,
gamma=7.0)
],
real=False),
Group(equations=[
ContinuityEquation(dest='solid', sources=['fluid']),
ContinuityEquation(dest='fluid', sources=['solid', 'fluid']),
MomentumEquation(dest='fluid',
sources=['fluid', 'solid'],
alpha=self.aplha,
beta=self.beta,
gy=-1 * self.g,
c=self.c0),
XSPHCorrection(dest='fluid', sources=['fluid'])
]),
]
return equations
def create_equations(self):
adami_equations = [
Group(equations=[
SummationDensity(dest='fluid', sources=['fluid', 'wall']),
SummationDensity(dest='wall', sources=['fluid', 'wall']),
],),
Group(equations=[
StateEquation(dest='fluid', sources=None, rho0=rho0,
p0=p0),
SolidWallPressureBCnoDensity(dest='wall', sources=['fluid']),
],),
Group(equations=[
AdamiColorGradient(dest='fluid', sources=['fluid', 'wall']),
],
),
Group(equations=[
AdamiReproducingDivergence(dest='fluid', sources=['fluid', 'wall'],
dim=2),
],),
Group(
equations=[
MomentumEquationPressureGradient(
dest='fluid', sources=['fluid', 'wall'], pb=p0),
MomentumEquationViscosityAdami(
dest='fluid', sources=['fluid']),
CSFSurfaceTensionForceAdami(
dest='fluid', sources=None),
SolidWallNoSlipBC(dest='fluid', sources=['wall'], nu=nu0),
], )
]
return adami_equations
def create_equations(self):
equations = [
Group(equations=[
BodyForce2d(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=[
RigidBodyCollision2d(
dest='cube', sources=['tank', 'cube'], kn=1e5)
]),
Group(equations=[SumUpExternalForces(dest='cube', sources=None)]),
]
return equations
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=[
ContinuityEquation(
dest='fluid',
sources=['fluid', 'tank', 'cube'],),
ContinuityEquation(
dest='tank',
sources=['fluid', 'tank', 'cube'], ),
MomentumEquation(dest='fluid', sources=['fluid', 'tank'],
alpha=self.alpha, beta=0.0, c0=self.co,
gy=-9.81),
SolidForceOnFluid(dest='fluid', sources=['cube']),
XSPHCorrection(dest='fluid', sources=['fluid', 'tank']),
]),
Group(equations=[
BodyForce(dest='cube', sources=None, gy=-9.81),
FluidForceOnSolid(dest='cube', sources=['fluid']),
# RigidBodyCollision(
# dest='cube',
# sources=['tank'],
# kn=1e5,
# en=0.5, )
]),
Group(equations=[RigidBodyMoments(dest='cube', sources=None)]),
Group(equations=[RigidBodyMotion(dest='cube', sources=None)]),
]
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 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 create_equations(self):
equations = [
Group(equations=[
LiuFluidForce(
dest='fluid',
sources=None,
),
XSPHCorrection(dest='fluid', sources=[
'fluid',
]),
TaitEOS(dest='fluid',
sources=None,
rho0=1000,
c0=1498,
gamma=7.0),
],
real=False),
Group(equations=[
ContinuityEquation(dest='fluid', sources=[
'fluid',
]),
MomentumEquation(dest='fluid',
sources=['fluid'],
alpha=0.1,
beta=0.0,
c0=1498,
gy=-9.81),
XSPHCorrection(dest='fluid', sources=['fluid']),
]),
]
return equations
def create_equations(self):
adami_equations = [
Group(equations=[
SummationDensity(dest='fluid', sources=['fluid', 'wall']),
SummationDensity(dest='wall', sources=['fluid', 'wall']),
# Density_correction(dest='wall', sources=['fluid', 'wall']),
]),
Group(equations=[
TaitEOS(dest='fluid',
sources=None,
rho0=rho1,
c0=c0,
gamma=7,
p0=p1),
SolidWallPressureBCnoDensity(dest='wall', sources=['fluid']),
]),
Group(equations=[
ColorGradientAdami(dest='fluid', sources=['fluid', 'wall']),
]),
Group(equations=[
ConstructStressMatrix(
dest='fluid', sources=None, sigma=sigma, d=2)
]),
Group(equations=[
MomentumEquationPressureGradientAdami(
dest='fluid', sources=['fluid', 'wall']),
# MomentumEquation(dest='fluid', sources=['fluid', 'wall'], c0=c0, alpha=0.0, beta=0.0, tensile_correction=True),
MomentumEquationViscosityAdami(dest='fluid', sources=['fluid']
),
SurfaceForceAdami(dest='fluid', sources=['fluid', 'wall']),
SolidWallNoSlipBC(dest='fluid', sources=['wall'], nu=nu0)
]),
]
return adami_equations
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 create_equations(self):
equations = [
Group(equations=[
Group(equations=[
GatherDensityEvalNextIteration(dest='fluid',
sources=['fluid']),
]),
Group(equations=[NonDimensionalDensityResidual(dest='fluid')]),
Group(equations=[UpdateSmoothingLength(dim=dim, dest='fluid')],
update_nnps=True),
Group(equations=[
CheckConvergenceDensityResidual(dest='fluid')
], )
],
iterate=True,
max_iterations=10),
Group(equations=[
CorrectionFactorVariableSmoothingLength(dest='fluid',
sources=['fluid'])
]),
Group(equations=[
DaughterVelocityEval(
rhow=rho_w, dest='fluid', sources=['fluid'])
]),
Group(equations=[SWEOS(dest='fluid')]),
Group(equations=[
ParticleAcceleration(
dim=dim, dest='fluid', sources=['fluid'], u_only=True),
]),
Group(equations=[
CheckForParticlesToSplit(
dest='fluid', h_max=self.h_max, A_max=self.A_max)
]),
]
return equations
def create_equations(self):
'''
Set-up governing equations
'''
equations = [
Group(equations=[
EOS_DPSPH(dest='fluid',
sources=['fluid'],
rho0=self.rho0,
c0=self.c0)
],
real=False),
Group(equations=[
RenormalizationTensor2D_DPSPH(dest='fluid',
sources=['fluid'],
dim=2),
RDGC_DPSPH(dest='fluid', sources=['fluid'], dim=2),
ContinuityEquation_RDGC_DPSPH(dest='fluid',
sources=['fluid'],
delta=0.1,
c0=self.c0,
H=self.h0,
dim=2),
MomentumEquation_DPSPH(dest='fluid',
sources=['fluid'],
dim=2,
mu=self.mu)
],
real=True)
]
return equations
def create_equations(self):
equations = [
Group(equations=[
TaitEOS(dest='fluid',
sources=None,
rho0=1000,
c0=self.co,
gamma=7.0),
TaitEOS(dest='wall',
sources=None,
rho0=1000,
c0=self.co,
gamma=7.0),
],
real=False),
Group(equations=[
ContinuityEquation(dest='fluid', sources=['fluid', 'wall']),
ContinuityEquation(dest='wall', sources=['fluid', 'wall']),
MomentumEquation(dest='fluid',
sources=['fluid', 'wall'],
alpha=self.alpha,
beta=0.0,
c0=self.co,
gy=-9.81),
XSPHCorrection(dest='fluid', sources=['fluid']),
]),
]
return equations
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 test_should_stop_iteration_with_max_iteration_on_gpu(self):
pa = self.pa
class SillyEquation(Equation):
def loop(self, d_idx, d_au, s_idx, s_m):
d_au[d_idx] += s_m[s_idx]
def converged(self):
return 0
equations = [Group(
equations=[
Group(
equations=[SillyEquation(dest='fluid', sources=['fluid'])]
),
Group(
equations=[SillyEquation(dest='fluid', sources=['fluid'])]
),
],
iterate=True, max_iterations=2,
)]
a_eval = self._make_accel_eval(equations)
# When
a_eval.compute(0.1, 0.1)
# Then
expect = np.asarray([3., 4., 5., 5., 5., 5., 5., 5., 4., 3.])*4.0
pa.gpu.pull('au')
self.assertListEqual(list(pa.au), list(expect))
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 _get_sph_eval(self, kind):
from pysph.tools.sph_evaluator import SPHEvaluator
from pysph.sph.equation import Group
if self._sph_eval is None:
arr = self.array
eqns = []
name = arr.name
if 'vmax' not in arr.constants.keys():
arr.add_constant('vmax', [0.0])
if 'dpos' not in arr.properties.keys():
arr.add_property('dpos', stride=3)
if kind == 'simple':
const = 0.04 if not self.parameter else self.parameter
eqns.append(
Group(equations=[SimpleShift(name, [name], const=const)],
update_nnps=True))
elif kind == 'fickian':
const = 4 if not self.parameter else self.parameter
eqns.append(
Group(equations=[
FickianShift(name, [name], fickian_const=const)
],
update_nnps=True))
if self.correct_velocity:
if 'gradv' not in arr.properties.keys():
arr.add_property('gradv', stride=9)
eqns.append(Group(equations=[CorrectVelocities(name, [name])]))
sph_eval = SPHEvaluator(arrays=[arr],
equations=eqns,
dim=self.dim,
kernel=self.kernel)
return sph_eval
else:
return self._sph_eval
def _create_io_eval(self):
if self.io_eval is None:
from pysph.sph.equation import Group
from pysph.tools.sph_evaluator import SPHEvaluator
o_name = self.outlet_pa.name
f_name = self.source_pa.name
eqns = []
eqns.append(Group(equations=[
IOEvaluate(
o_name, [], x=self.x, y=self.y, z=self.z, xn=self.xn,
yn=self.yn, zn=self.zn, maxdist=self.length)],
real=False, update_nnps=False))
eqns.append(Group(equations=[
IOEvaluate(
f_name, [], x=self.x, y=self.y, z=self.z, xn=self.xn,
yn=self.yn, zn=self.zn,)], real=False, update_nnps=False))
arrays = [self.outlet_pa] + [self.source_pa]
io_eval = SPHEvaluator(arrays=arrays, equations=eqns, dim=self.dim,
kernel=self.kernel)
return io_eval
else:
return self.io_eval
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 create_equations(self):
eqns = self.scheme.get_equations()
if self.options.scheme == 'iisph' or self.options.scheme == 'sisph':
return eqns
if self.options.scheme == 'gtvf':
return eqns
n = len(eqns)
if self.kernel_corr == 'grad-corr':
eqn1 = Group(equations=[
GradientCorrectionPreStep('fluid', ['fluid', 'boundary'])
], real=False)
for i in range(n):
eqn2 = GradientCorrection('fluid', ['fluid', 'boundary'])
eqns[i].equations.insert(0, eqn2)
eqns.insert(0, eqn1)
elif self.kernel_corr == 'mixed-corr':
eqn1 = Group(equations=[
MixedKernelCorrectionPreStep('fluid', ['fluid', 'boundary'])
], real=False)
for i in range(n):
eqn2 = GradientCorrection('fluid', ['fluid', 'boundary'])
eqns[i].equations.insert(0, eqn2)
eqns.insert(0, eqn1)
elif self.kernel_corr == 'crksph':
eqn1 = Group(equations=[
CRKSPHPreStep('fluid', ['fluid', 'boundary']),
CRKSPHPreStep('boundary', ['fluid', 'boundary'])
], real=False)
for i in range(n):
eqn2 = CRKSPH('fluid', ['fluid', 'boundary'])
eqn3 = CRKSPH('boundary', ['fluid', 'boundary'])
eqns[i].equations.insert(0, eqn3)
eqns[i].equations.insert(0, eqn2)
eqns.insert(0, eqn1)
return eqns
def create_equations(self):
"""Set up equations.
Body force is necessary to reset fx,fy,fz, although
not body force is applied.
"""
equations = [
Group(equations=[
BodyForce(dest='ellipsoid', sources=None),
NumberDensity(dest='ellipsoid', sources=['ellipsoid']),
NumberDensity(dest='walls', sources=['walls'])
]),
# Tait equation of state
Group(equations=[
TaitEOS(dest='fluid',
sources=None,
rho0=self.rho,
c0=self.co,
gamma=7.0),
TaitEOSHGCorrection(dest='ellipsoid',
sources=None,
rho0=self.rho,
c0=self.co,
gamma=7.0),
TaitEOSHGCorrection(dest='walls',
sources=None,
rho0=self.rho,
c0=self.co,
gamma=7.0),
],
real=False),
Group(equations=[
ContinuityEquation(dest='fluid',
sources=['fluid', 'walls', 'ellipsoid']),
ContinuityEquation(dest='ellipsoid', sources=['fluid']),
ContinuityEquation(dest='walls', sources=['fluid']),
LaminarViscosity(
dest='fluid', sources=['fluid', 'walls'], nu=self.nu),
MomentumEquation(dest='fluid',
sources=['fluid', 'walls'],
alpha=self.alpha,
beta=0.0,
c0=self.co),
ViscosityRigidBody(dest='fluid',
sources=['ellipsoid'],
nu=self.nu,
rho0=self.rho),
PressureRigidBody(dest='fluid',
sources=['ellipsoid'],
rho0=self.rho),
XSPHCorrection(dest='fluid', sources=['fluid']),
]),
Group(
equations=[RigidBodyMoments(dest='ellipsoid', sources=None)]),
Group(equations=[RigidBodyMotion(dest='ellipsoid', sources=None)]),
]
return equations
def create_equations(self):
'''
Set-up governing equations
'''
equations = [
Group(equations=[
IsothermalEOS(dest='fluid',
sources=['fluid'],
rho0=self.rho0,
c0=self.c0,
p0=0.0),
GradientCorrectionPreStep(dest='fluid',
sources=['fluid'],
dim=2),
],
real=False),
Group(
equations=[
GradientCorrection(dest='fluid',
sources=['fluid'],
dim=2,
tol=0.1),
ContinuityEquationDeltaSPHPreStep(dest='fluid',
sources=['fluid']),
#PST_PreStep_1(dest='fluid', sources=['fluid'], dim=2, boundedFlow=self.PST_boundedFlow),
#PST_PreStep_2(dest='fluid', sources=['fluid'], dim=2, H=self.h0, boundedFlow=self.PST_boundedFlow),
],
real=False),
Group(
equations=[
PST(dest='fluid',
sources=['fluid'],
H=self.h0,
dt=self.dt,
dx=self.dx,
Uc0=self.PST_Uc0,
Rh=self.PSR_Rh,
boundedFlow=self.PST_boundedFlow),
ContinuityEquation(dest='fluid', sources=['fluid']),
ContinuityEquationDeltaSPH(dest='fluid',
sources=['fluid'],
c0=self.c0,
delta=0.1),
LaminarViscosityDeltaSPHPreStep(dest='fluid',
sources=['fluid']),
#LaminarViscosity(dest='fluid', sources=['fluid'], nu=self.nu),
LaminarViscosityDeltaSPH(dest='fluid',
sources=['fluid'],
dim=2,
rho0=self.rho0,
nu=self.nu),
Spatial_Acceleration(dest='fluid', sources=['fluid']),
],
real=True),
]
return equations
def create_equations(self):
equations = [
Group(equations=[
BodyForce(dest='body', sources=None, gz=gz),
RigidBodyCollision(dest='body', sources=['tank'], kn=1e4, en=1)
]),
Group(equations=[RigidBodyMoments(dest='body', sources=None)]),
Group(equations=[RigidBodyMotion(dest='body', sources=None)]),
]
return equations
def create_equations(self):
equations = [
Group(equations=[
BodyForce2d(dest='body', sources=None, gy=-9.81),
RigidBodyCollision2d(
dest='body', sources=['tank'], kn=1e7, en=0.2)
]),
Group(equations=[SumUpExternalForces(dest='body', sources=None)]),
]
return equations
def create_equations(self):
adami_equations = [
Group(equations=[
SummationDensity(dest='liquid',
sources=['liquid', 'wall', 'gas']),
SummationDensity(dest='gas', sources=['liquid', 'wall', 'gas'
]),
SummationDensity(dest='wall',
sources=['liquid', 'wall', 'gas'])
]),
Group(equations=[
TaitEOS(dest='liquid',
sources=None,
rho0=rho1,
c0=c0,
gamma=1,
p0=p1),
TaitEOS(
dest='gas', sources=None, rho0=rho2, c0=c0, gamma=1,
p0=p1),
SolidWallPressureBCnoDensity(dest='wall',
sources=['liquid', 'gas']),
]),
Group(equations=[
ColorGradientAdami(dest='liquid',
sources=['liquid', 'wall', 'gas']),
ColorGradientAdami(dest='gas',
sources=['liquid', 'wall', 'gas']),
]),
Group(equations=[
ConstructStressMatrix(
dest='liquid', sources=None, sigma=sigma, d=2),
ConstructStressMatrix(
dest='gas', sources=None, sigma=sigma, d=2)
]),
Group(equations=[
MomentumEquationPressureGradientAdami(
dest='liquid', sources=['liquid', 'wall', 'gas']),
MomentumEquationPressureGradientAdami(
dest='gas', sources=['liquid', 'wall', 'gas']),
MomentumEquationViscosityAdami(dest='liquid',
sources=['liquid', 'gas']),
MomentumEquationViscosityAdami(dest='gas',
sources=['liquid', 'gas']),
SurfaceForceAdami(dest='liquid',
sources=['liquid', 'wall', 'gas']),
SurfaceForceAdami(dest='gas',
sources=['liquid', 'wall', 'gas']),
SolidWallNoSlipBC(dest='liquid', sources=['wall'], nu=nu1),
SolidWallNoSlipBC(dest='gas', sources=['wall'], nu=nu2),
]),
]
return adami_equations
def create_equations(self):
equations = [
Group(equations=[
BodyForce(dest='body', sources=None, gz=gz),
RigidBodyCollision(
dest='body', sources=['tank'], k=1.0, d=2.0, eta=0.1, kt=0.1
)]
),
Group(equations=[RigidBodyMoments(dest='body', sources=None)]),
Group(equations=[RigidBodyMotion(dest='body', sources=None)]),
]
return equations
def create_equations(self):
equations = [
Group(equations=[
BodyForce(dest='ball', sources=None, gy=gz),
HertzRigidBody(dest='ball',
sources=['wall', 'ball', 'temp_wall'],
mu=0.45)
]),
Group(equations=[RigidBodyMoments(dest='ball', sources=None)]),
Group(equations=[RigidBodyMotion(dest='ball', sources=None)]),
]
return equations
def get_equations(self):
from pysph.sph.equation import Group
from pysph.sph.basic_equations import (ContinuityEquation,
MonaghanArtificialViscosity,
XSPHCorrection,
VelocityGradient2D)
from pysph.sph.solid_mech.basic import (IsothermalEOS,
MomentumEquationWithStress,
HookesDeviatoricStressRate,
MonaghanArtificialStress)
equations = []
g1 = []
all = self.solids + self.elastic_solids
for elastic_solid in self.elastic_solids:
g1.append(
# p
IsothermalEOS(elastic_solid, sources=None))
g1.append(
# vi,j : requires properties v00, v01, v10, v11
VelocityGradient2D(dest=elastic_solid, sources=all))
g1.append(
# rij : requires properties r00, r01, r02, r11, r12, r22,
# s00, s01, s02, s11, s12, s22
MonaghanArtificialStress(dest=elastic_solid,
sources=None,
eps=self.artificial_stress_eps))
equations.append(Group(equations=g1))
g2 = []
for elastic_solid in self.elastic_solids:
g2.append(ContinuityEquation(dest=elastic_solid, sources=all), )
g2.append(
# au, av
MomentumEquationWithStress(dest=elastic_solid, sources=all), )
g2.append(
# au, av
MonaghanArtificialViscosity(dest=elastic_solid,
sources=all,
alpha=self.alpha,
beta=self.beta), )
g2.append(
# a_s00, a_s01, a_s11
HookesDeviatoricStressRate(dest=elastic_solid, sources=None), )
g2.append(
# ax, ay, az
XSPHCorrection(dest=elastic_solid,
sources=[elastic_solid],
eps=self.xsph_eps), )
equations.append(Group(g2))
return equations
def test_post_loop_code(self):
from pysph.base.kernels import CubicSpline
k = CubicSpline(dim=3)
e1 = TestEq1('f', ['f'])
e2 = TestEq2('f', ['f'])
g = Group([e1, e2])
# First get the equation wrappers so the equation names are setup.
w = g.get_equation_wrappers()
result = g.get_post_loop_code(k)
expect = dedent('''\
self.test_eq10.post_loop(d_idx, d_h)
''')
msg = 'EXPECTED:\n%s\nGOT:\n%s'%(expect, result)
self.assertEqual(result, expect, msg)
def test_loop_code(self):
from pysph.base.kernels import CubicSpline
k = CubicSpline(dim=3)
e1 = TestEq1('f', ['f'])
e2 = TestEq2('f', ['f'])
g = Group([e1, e2])
# First get the equation wrappers so the equation names are setup.
w = g.get_equation_wrappers()
result = g.get_loop_code(k)
expect = dedent('''\
HIJ = 0.5*(d_h[d_idx] + s_h[s_idx])
XIJ[0] = d_x[d_idx] - s_x[s_idx]
XIJ[1] = d_y[d_idx] - s_y[s_idx]
XIJ[2] = d_z[d_idx] - s_z[s_idx]
R2IJ = XIJ[0]*XIJ[0] + XIJ[1]*XIJ[1] + XIJ[2]*XIJ[2]
RIJ = sqrt(R2IJ)
WIJ = self.kernel.kernel(XIJ, RIJ, HIJ)
self.test_eq10.loop(WIJ)
self.test_eq20.loop(d_idx, s_idx)
''')
msg = 'EXPECTED:\n%s\nGOT:\n%s'%(expect, result)
self.assertEqual(result, expect, msg)
