def flux(self, q):
from pytools import delta
return [ # one entry for each flux direction
cse(join_fields(
# flux rho
self.rho_u(q)[i],
# flux E
cse(self.e(q)+self.cse_p(q))*self.cse_u(q)[i],
# flux rho_u
make_obj_array([
self.rho_u(q)[i]*self.cse_u(q)[j]
+ delta(i,j) * self.cse_p(q)
for j in range(self.dimensions)
])
), "%s_flux" % AXES[i])
for i in range(self.dimensions)]
def flux(self, q):
from pytools import delta
return [ # one entry for each flux direction
cse(join_fields(
# flux rho
self.rho_u(q)[i],
# flux E
cse(self.e(q)+self.cse_p(q))*self.cse_u(q)[i],
# flux rho_u
make_obj_array([
self.rho_u(q)[i]*self.cse_u(q)[j]
+ delta(i,j) * self.cse_p(q)
for j in range(self.dimensions)
])
), "%s_flux" % AXES[i])
for i in range(self.dimensions)]
def tau(self, to_quad_op, state, mu=None):
faceq_state = self.faceq_state()
dimensions = self.dimensions
# {{{ compute gradient of u ---------------------------------------
# Use the product rule to compute the gradient of
# u from the gradient of (rho u). This ensures we don't
# compute the derivatives twice.
from pytools.obj_array import with_object_array_or_scalar
dq = with_object_array_or_scalar(to_quad_op, self.grad_of_state())
q = cse(to_quad_op(state))
du = numpy.zeros((dimensions, dimensions), dtype=object)
for i in range(dimensions):
for j in range(dimensions):
du[i, j] = cse(
(dq[i + 2, j] - self.cse_u(q)[i] * dq[0, j]) / self.rho(q),
"du%d_d%s" % (i, AXES[j]))
# }}}
# {{{ put together viscous stress tau -----------------------------
from pytools import delta
if mu is None:
mu = self.get_mu(q, to_quad_op)
tau = numpy.zeros((dimensions, dimensions), dtype=object)
for i in range(dimensions):
for j in range(dimensions):
tau[i, j] = cse(
mu *
cse(du[i, j] + du[j, i] -
2 / self.dimensions * delta(i, j) * numpy.trace(du)),
"tau_%d%d" % (i, j))
return tau
def tau(self, to_quad_op, state, mu=None):
faceq_state = self.faceq_state()
dimensions = self.dimensions
# {{{ compute gradient of u ---------------------------------------
# Use the product rule to compute the gradient of
# u from the gradient of (rho u). This ensures we don't
# compute the derivatives twice.
from pytools.obj_array import with_object_array_or_scalar
dq = with_object_array_or_scalar(
to_quad_op, self.grad_of_state())
q = cse(to_quad_op(state))
du = numpy.zeros((dimensions, dimensions), dtype=object)
for i in range(dimensions):
for j in range(dimensions):
du[i,j] = cse(
(dq[i+2,j] - self.cse_u(q)[i] * dq[0,j]) / self.rho(q),
"du%d_d%s" % (i, AXES[j]))
# }}}
# {{{ put together viscous stress tau -----------------------------
from pytools import delta
if mu is None:
mu = self.get_mu(q, to_quad_op)
tau = numpy.zeros((dimensions, dimensions), dtype=object)
for i in range(dimensions):
for j in range(dimensions):
tau[i,j] = cse(mu * cse(du[i,j] + du[j,i] -
2/self.dimensions * delta(i,j) * numpy.trace(du)),
"tau_%d%d" % (i, j))
return tau
def find_jump_term(kernel, arg_provider):
from sumpy.kernel import (AxisTargetDerivative,
DirectionalSourceDerivative,
DirectionalTargetDerivative, DerivativeBase)
tgt_derivatives = []
src_derivatives = []
while isinstance(kernel, DerivativeBase):
if isinstance(kernel, AxisTargetDerivative):
tgt_derivatives.append(kernel.axis)
kernel = kernel.kernel
elif isinstance(kernel, DirectionalTargetDerivative):
tgt_derivatives.append(kernel.dir_vec_name)
kernel = kernel.kernel
elif isinstance(kernel, DirectionalSourceDerivative):
src_derivatives.append(kernel.dir_vec_name)
kernel = kernel.kernel
else:
raise RuntimeError("derivative type '%s' not understood" %
type(kernel))
tgt_count = len(tgt_derivatives)
src_count = len(src_derivatives)
info = arg_provider
if src_count == 0:
if tgt_count == 0:
return 0
elif tgt_count == 1:
tgt_derivative, = tgt_derivatives
if isinstance(tgt_derivative, int):
# axis derivative
return info.side / 2 * info.normal[
tgt_derivative] * info.density
else:
# directional derivative
return (info.side / 2 *
np.dot(info.normal, getattr(info, tgt_derivative)) *
info.density)
elif tgt_count == 2:
i, j = tgt_derivatives
assert isinstance(i, int)
assert isinstance(j, int)
from pytools import delta
return (-info.side * info.mean_curvature / 2 *
(-delta(i, j) + 2 * info.normal[i] * info.normal[j]) *
info.density + info.side / 2 *
(info.normal[i] * info.tangent[j] +
info.normal[j] * info.tangent[i]) * info.density_prime)
elif src_count == 1:
src_derivative_name, = src_derivatives
if tgt_count == 0:
return (-info.side / 2 *
np.dot(info.normal, getattr(info, src_derivative_name)) *
info.density)
elif tgt_count == 1:
from warnings import warn
warn(
"jump terms for mixed derivatives (1 src+1 tgt) only available "
"for the double-layer potential")
i, = tgt_derivatives
assert isinstance(i, int)
return (-info.side / 2 * info.tangent[i] * info.density_prime)
raise ValueError("don't know jump term for %d "
"target and %d source derivatives" %
(tgt_count, src_count))
def find_jump_term(kernel, arg_provider):
from sumpy.kernel import (
AxisTargetDerivative,
DirectionalSourceDerivative,
DirectionalTargetDerivative,
DerivativeBase)
tgt_derivatives = []
src_derivatives = []
while isinstance(kernel, DerivativeBase):
if isinstance(kernel, AxisTargetDerivative):
tgt_derivatives.append(kernel.axis)
kernel = kernel.kernel
elif isinstance(kernel, DirectionalTargetDerivative):
tgt_derivatives.append(kernel.dir_vec_name)
kernel = kernel.kernel
elif isinstance(kernel, DirectionalSourceDerivative):
src_derivatives.append(kernel.dir_vec_name)
kernel = kernel.kernel
else:
raise RuntimeError("derivative type '%s' not understood"
% type(kernel))
tgt_count = len(tgt_derivatives)
src_count = len(src_derivatives)
info = arg_provider
if src_count == 0:
if tgt_count == 0:
return 0
elif tgt_count == 1:
tgt_derivative, = tgt_derivatives
if isinstance(tgt_derivative, int):
# axis derivative
return info.side/2 * info.normal[tgt_derivative] * info.density
else:
# directional derivative
return (info.side/2
* np.dot(info.normal, getattr(info, tgt_derivative))
* info.density)
elif tgt_count == 2:
i, j = tgt_derivatives
assert isinstance(i, int)
assert isinstance(j, int)
from pytools import delta
return (
- info.side * info.mean_curvature / 2
* (-delta(i, j) + 2*info.normal[i]*info.normal[j])
* info.density
+ info.side / 2
* (info.normal[i]*info.tangent[j]
+ info.normal[j]*info.tangent[i])
* info.density_prime)
elif src_count == 1:
src_derivative_name, = src_derivatives
if tgt_count == 0:
return (
- info.side/2
* np.dot(info.normal, getattr(info, src_derivative_name))
* info.density)
elif tgt_count == 1:
from warnings import warn
warn("jump terms for mixed derivatives (1 src+1 tgt) only available "
"for the double-layer potential")
i, = tgt_derivatives
assert isinstance(i, int)
return (
- info.side/2
* info.tangent[i]
* info.density_prime)
raise ValueError("don't know jump term for %d "
"target and %d source derivatives" % (tgt_count, src_count))
