def flux(self):
from hedge.flux import (
make_normal,
FluxVectorPlaceholder,
flux_max)
from pymbolic.primitives import IfPositive
d = self.dimensions
w = FluxVectorPlaceholder((1+d)+1)
u = w[0]
v = w[1:d+1]
c = w[1+d]
normal = make_normal(self.dimensions)
if self.flux_type == "central":
return (u.int*numpy.dot(v.int, normal )
+ u.ext*numpy.dot(v.ext, normal)) * 0.5
elif self.flux_type == "lf":
n_vint = numpy.dot(normal, v.int)
n_vext = numpy.dot(normal, v.ext)
return 0.5 * (n_vint * u.int + n_vext * u.ext) \
- 0.5 * (u.ext - u.int) \
* flux_max(c.int, c.ext)
elif self.flux_type == "upwind":
return (
IfPositive(numpy.dot(normal, v.avg),
numpy.dot(normal, v.int) * u.int, # outflow
numpy.dot(normal, v.ext) * u.ext, # inflow
))
else:
raise ValueError, "invalid flux type"
def flux_num(self, q, fluxes, bdry_tag_state_flux):
n = self.len_q
d = len(fluxes)
fvph = FluxVectorPlaceholder(n*(d+1)+1)
speed_ph = fvph[0]
state_ph = fvph[1:n+1]
fluxes_ph = [fvph[i*n+1:(i+1)*n+1] for i in range(1,d+1)]
normal = make_normal(d)
flux_strong = 0.5*sum(n_i*(f_i.ext-f_i.int) for n_i, f_i in zip(normal, fluxes_ph))
if self.flux_type == "central":
pass
elif self.flux_type == "lf":
penalty = flux_max(speed_ph.int,speed_ph.ext)*(state_ph.ext-state_ph.int)
flux_strong = 0.5 * penalty + flux_strong
else:
raise ValueError("Invalid flux type '%s'" % self.flux_type)
flux_op = get_flux_operator(flux_strong)
int_operand = join_fields(self.wave_speed(q), q, *fluxes)
return (flux_op(int_operand)
+sum(flux_op(BoundaryPair(int_operand, join_fields(0, bdry_state, *bdry_fluxes), tag))
for tag, bdry_state, bdry_fluxes in bdry_tag_state_flux))
def flux(self):
from hedge.flux import (make_normal, FluxVectorPlaceholder, flux_max)
from pymbolic.primitives import IfPositive
d = self.dimensions
w = FluxVectorPlaceholder((1 + d) + 1)
u = w[0]
v = w[1:d + 1]
c = w[1 + d]
normal = make_normal(self.dimensions)
if self.flux_type == "central":
return (u.int * numpy.dot(v.int, normal) +
u.ext * numpy.dot(v.ext, normal)) * 0.5
elif self.flux_type == "lf":
n_vint = numpy.dot(normal, v.int)
n_vext = numpy.dot(normal, v.ext)
return 0.5 * (n_vint * u.int + n_vext * u.ext) \
- 0.5 * (u.ext - u.int) \
* flux_max(c.int, c.ext)
elif self.flux_type == "upwind":
return (IfPositive(
numpy.dot(normal, v.avg),
numpy.dot(normal, v.int) * u.int, # outflow
numpy.dot(normal, v.ext) * u.ext, # inflow
))
else:
raise ValueError, "invalid flux type"
def make_lax_friedrichs_flux(wave_speed, state, fluxes, bdry_tags_states_and_fluxes,
strong):
from pytools.obj_array import join_fields
from hedge.flux import make_normal, FluxVectorPlaceholder, flux_max
n = len(state)
d = len(fluxes)
normal = make_normal(d)
fvph = FluxVectorPlaceholder(len(state)*(1+d)+1)
wave_speed_ph = fvph[0]
state_ph = fvph[1:1+n]
fluxes_ph = [fvph[1+i*n:1+(i+1)*n] for i in range(1, d+1)]
penalty = flux_max(wave_speed_ph.int,wave_speed_ph.ext)*(state_ph.ext-state_ph.int)
if not strong:
num_flux = 0.5*(sum(n_i*(f_i.int+f_i.ext) for n_i, f_i in zip(normal, fluxes_ph))
- penalty)
else:
num_flux = 0.5*(sum(n_i*(f_i.int-f_i.ext) for n_i, f_i in zip(normal, fluxes_ph))
+ penalty)
from hedge.optemplate import get_flux_operator
flux_op = get_flux_operator(num_flux)
int_operand = join_fields(wave_speed, state, *fluxes)
from hedge.optemplate import BoundaryPair
return (flux_op(int_operand)
+ sum(
flux_op(BoundaryPair(int_operand,
join_fields(0, bdry_state, *bdry_fluxes), tag))
for tag, bdry_state, bdry_fluxes in bdry_tags_states_and_fluxes))
def make_lax_friedrichs_flux(wave_speed, state, fluxes,
bdry_tags_states_and_fluxes, strong):
from pytools.obj_array import join_fields
from hedge.flux import make_normal, FluxVectorPlaceholder, flux_max
n = len(state)
d = len(fluxes)
normal = make_normal(d)
fvph = FluxVectorPlaceholder(len(state) * (1 + d) + 1)
wave_speed_ph = fvph[0]
state_ph = fvph[1:1 + n]
fluxes_ph = [fvph[1 + i * n:1 + (i + 1) * n] for i in range(1, d + 1)]
penalty = flux_max(wave_speed_ph.int,
wave_speed_ph.ext) * (state_ph.ext - state_ph.int)
if not strong:
num_flux = 0.5 * (sum(n_i * (f_i.int + f_i.ext)
for n_i, f_i in zip(normal, fluxes_ph)) -
penalty)
else:
num_flux = 0.5 * (sum(n_i * (f_i.int - f_i.ext)
for n_i, f_i in zip(normal, fluxes_ph)) +
penalty)
from hedge.optemplate import get_flux_operator
flux_op = get_flux_operator(num_flux)
int_operand = join_fields(wave_speed, state, *fluxes)
from hedge.optemplate import BoundaryPair
return (flux_op(int_operand) + sum(
flux_op(
BoundaryPair(int_operand, join_fields(0, bdry_state, *bdry_fluxes),
tag))
for tag, bdry_state, bdry_fluxes in bdry_tags_states_and_fluxes))
