def op_template(self, sensor_scaling=None, viscosity_only=False):
u = self.cse_u
rho = self.cse_rho
rho_u = self.rho_u
p = self.p
e = self.e
# {{{ artificial diffusion
def make_artificial_diffusion():
if self.artificial_viscosity_mode not in ["diffusion"]:
return 0
dq = self.grad_of_state()
return make_obj_array([
self.div(
to_vol_quad(self.sensor())*to_vol_quad(dq[i]),
to_int_face_quad(self.sensor())*to_int_face_quad(dq[i]))
for i in range(dq.shape[0])])
# }}}
# {{{ state setup
volq_flux = self.flux(self.volq_state())
faceq_flux = self.flux(self.faceq_state())
from hedge.optemplate.primitives import CFunction
sqrt = CFunction("sqrt")
speed = self.characteristic_velocity_optemplate(self.state())
has_viscosity = not is_zero(self.get_mu(self.state(), to_quad_op=None))
# }}}
# {{{ operator assembly -----------------------------------------------
from hedge.flux.tools import make_lax_friedrichs_flux
from hedge.optemplate.operators import InverseMassOperator
from hedge.optemplate.tools import make_stiffness_t
primitive_bcs_as_quad_conservative = dict(
(tag, self.primitive_to_conservative(to_bdry_quad(bc)))
for tag, bc in
self.get_primitive_boundary_conditions().iteritems())
def get_bc_tuple(tag):
state = self.state()
bc = make_obj_array([
self.get_boundary_condition_for(tag, s_i) for s_i in state])
return tag, bc, self.flux(bc)
first_order_part = InverseMassOperator()(
numpy.dot(make_stiffness_t(self.dimensions), volq_flux)
- make_lax_friedrichs_flux(
wave_speed=cse(to_int_face_quad(speed), "emax_c"),
state=self.faceq_state(), fluxes=faceq_flux,
bdry_tags_states_and_fluxes=[
get_bc_tuple(tag) for tag in self.get_boundary_tags()],
strong=False))
if viscosity_only:
first_order_part = 0*first_order_part
result = join_fields(
first_order_part
+ self.make_second_order_part()
+ make_artificial_diffusion()
+ self.make_extra_terms(),
speed)
if self.source is not None:
result = result + join_fields(
make_sym_vector("source_vect", len(self.state())),
# extra field for speed
0)
return result
def op_template(self, with_sensor):
from hedge.optemplate import (Field, make_stiffness_t, make_nabla,
InverseMassOperator,
ElementwiseMaxOperator,
get_flux_operator)
from hedge.optemplate.operators import (
QuadratureGridUpsampler, QuadratureInteriorFacesGridUpsampler)
to_quad = QuadratureGridUpsampler("quad")
to_if_quad = QuadratureInteriorFacesGridUpsampler("quad")
u = Field("u")
u0 = Field("u0")
# boundary conditions -------------------------------------------------
minv_st = make_stiffness_t(self.dimensions)
nabla = make_nabla(self.dimensions)
m_inv = InverseMassOperator()
def flux(u):
return u**2 / 2
#return u0*u
emax_u = self.characteristic_velocity_optemplate(u)
from hedge.flux.tools import make_lax_friedrichs_flux
from pytools.obj_array import make_obj_array
num_flux = make_lax_friedrichs_flux(
#u0,
to_if_quad(emax_u),
make_obj_array([to_if_quad(u)]),
[make_obj_array([flux(to_if_quad(u))])],
[],
strong=False)[0]
from hedge.second_order import SecondDerivativeTarget
if self.viscosity is not None or with_sensor:
viscosity_coeff = 0
if with_sensor:
viscosity_coeff += Field("sensor")
if isinstance(self.viscosity, float):
viscosity_coeff += self.viscosity
elif self.viscosity is None:
pass
else:
raise TypeError("unsupported type of viscosity coefficient")
# strong_form here allows IPDG to reuse the value of grad u.
grad_tgt = SecondDerivativeTarget(self.dimensions,
strong_form=True,
operand=u)
self.viscosity_scheme.grad(grad_tgt,
bc_getter=None,
dirichlet_tags=[],
neumann_tags=[])
div_tgt = SecondDerivativeTarget(self.dimensions,
strong_form=False,
operand=viscosity_coeff *
grad_tgt.minv_all)
self.viscosity_scheme.div(div_tgt,
bc_getter=None,
dirichlet_tags=[],
neumann_tags=[])
viscosity_bit = div_tgt.minv_all
else:
viscosity_bit = 0
return m_inv((minv_st[0](flux(to_quad(u)))) - num_flux) \
+ viscosity_bit
def op_template(self, with_sensor):
from hedge.optemplate import (
Field,
make_stiffness_t,
make_nabla,
InverseMassOperator,
ElementwiseMaxOperator,
get_flux_operator)
from hedge.optemplate.operators import (
QuadratureGridUpsampler,
QuadratureInteriorFacesGridUpsampler)
to_quad = QuadratureGridUpsampler("quad")
to_if_quad = QuadratureInteriorFacesGridUpsampler("quad")
u = Field("u")
u0 = Field("u0")
# boundary conditions -------------------------------------------------
minv_st = make_stiffness_t(self.dimensions)
nabla = make_nabla(self.dimensions)
m_inv = InverseMassOperator()
def flux(u):
return u**2/2
#return u0*u
emax_u = self.characteristic_velocity_optemplate(u)
from hedge.flux.tools import make_lax_friedrichs_flux
from pytools.obj_array import make_obj_array
num_flux = make_lax_friedrichs_flux(
#u0,
to_if_quad(emax_u),
make_obj_array([to_if_quad(u)]),
[make_obj_array([flux(to_if_quad(u))])],
[], strong=False)[0]
from hedge.second_order import SecondDerivativeTarget
if self.viscosity is not None or with_sensor:
viscosity_coeff = 0
if with_sensor:
viscosity_coeff += Field("sensor")
if isinstance(self.viscosity, float):
viscosity_coeff += self.viscosity
elif self.viscosity is None:
pass
else:
raise TypeError("unsupported type of viscosity coefficient")
# strong_form here allows IPDG to reuse the value of grad u.
grad_tgt = SecondDerivativeTarget(
self.dimensions, strong_form=True,
operand=u)
self.viscosity_scheme.grad(grad_tgt, bc_getter=None,
dirichlet_tags=[], neumann_tags=[])
div_tgt = SecondDerivativeTarget(
self.dimensions, strong_form=False,
operand=viscosity_coeff*grad_tgt.minv_all)
self.viscosity_scheme.div(div_tgt,
bc_getter=None,
dirichlet_tags=[], neumann_tags=[])
viscosity_bit = div_tgt.minv_all
else:
viscosity_bit = 0
return m_inv((minv_st[0](flux(to_quad(u)))) - num_flux) \
+ viscosity_bit
def op_template(self, sensor_scaling=None, viscosity_only=False):
u = self.cse_u
rho = self.cse_rho
rho_u = self.rho_u
p = self.p
e = self.e
# {{{ artificial diffusion
def make_artificial_diffusion():
if self.artificial_viscosity_mode not in ["diffusion"]:
return 0
dq = self.grad_of_state()
return make_obj_array([
self.div(
to_vol_quad(self.sensor()) * to_vol_quad(dq[i]),
to_int_face_quad(self.sensor()) * to_int_face_quad(dq[i]))
for i in range(dq.shape[0])
])
# }}}
# {{{ state setup
volq_flux = self.flux(self.volq_state())
faceq_flux = self.flux(self.faceq_state())
from hedge.optemplate.primitives import CFunction
sqrt = CFunction("sqrt")
speed = self.characteristic_velocity_optemplate(self.state())
has_viscosity = not is_zero(self.get_mu(self.state(), to_quad_op=None))
# }}}
# {{{ operator assembly -----------------------------------------------
from hedge.flux.tools import make_lax_friedrichs_flux
from hedge.optemplate.operators import InverseMassOperator
from hedge.optemplate.tools import make_stiffness_t
primitive_bcs_as_quad_conservative = dict(
(tag, self.primitive_to_conservative(to_bdry_quad(bc))) for tag, bc
in self.get_primitive_boundary_conditions().iteritems())
def get_bc_tuple(tag):
state = self.state()
bc = make_obj_array(
[self.get_boundary_condition_for(tag, s_i) for s_i in state])
return tag, bc, self.flux(bc)
first_order_part = InverseMassOperator()(
numpy.dot(make_stiffness_t(self.dimensions), volq_flux) -
make_lax_friedrichs_flux(
wave_speed=cse(to_int_face_quad(speed), "emax_c"),
state=self.faceq_state(),
fluxes=faceq_flux,
bdry_tags_states_and_fluxes=[
get_bc_tuple(tag) for tag in self.get_boundary_tags()
],
strong=False))
if viscosity_only:
first_order_part = 0 * first_order_part
result = join_fields(
first_order_part + self.make_second_order_part() +
make_artificial_diffusion() + self.make_extra_terms(), speed)
if self.source is not None:
result = result + join_fields(
make_sym_vector("source_vect", len(self.state())),
# extra field for speed
0)
return result