def test_facial_flux(actx_factory, order, dim):
"""Check the flux across element faces by
prescribing states (q) with known fluxes. Only
uniform states are tested currently - ensuring
that the Lax-Friedrichs flux terms which are
proportional to jumps in state data vanish.
Since the returned fluxes use state data which
has been interpolated to-and-from the element
faces, this test is grid-dependent.
"""
actx = actx_factory()
tolerance = 1e-14
p0 = 1.0
from meshmode.mesh.generation import generate_regular_rect_mesh
from pytools.convergence import EOCRecorder
eoc_rec0 = EOCRecorder()
eoc_rec1 = EOCRecorder()
for nel_1d in [4, 8, 12]:
mesh = generate_regular_rect_mesh(a=(-0.5, ) * dim,
b=(0.5, ) * dim,
n=(nel_1d, ) * dim)
logger.info(f"Number of elements: {mesh.nelements}")
discr = EagerDGDiscretization(actx, mesh, order=order)
mass_input = discr.zeros(actx) + 1.0
energy_input = discr.zeros(actx) + 2.5
mom_input = flat_obj_array(
[discr.zeros(actx) for i in range(discr.dim)])
fields = join_conserved(dim,
mass=mass_input,
energy=energy_input,
momentum=mom_input)
from mirgecom.euler import _facial_flux
interior_face_flux = _facial_flux(discr,
eos=IdealSingleGas(),
q_tpair=interior_trace_pair(
discr, fields))
from functools import partial
fnorm = partial(discr.norm, p=np.inf, dd="all_faces")
iff_split = split_conserved(dim, interior_face_flux)
assert fnorm(iff_split.mass) < tolerance
assert fnorm(iff_split.energy) < tolerance
# The expected pressure 1.0 (by design). And the flux diagonal is
# [rhov_x*v_x + p] (etc) since we have zero velocities it's just p.
#
# The off-diagonals are zero. We get a {ndim}-vector for each
# dimension, the flux for the x-component of momentum (for example) is:
# f_momx = < 1.0, 0 , 0> , then we return f_momx .dot. normal, which
# can introduce negative values.
#
# (Explanation courtesy of Mike Campbell,
# https://github.com/illinois-ceesd/mirgecom/pull/44#discussion_r463304292)
momerr = fnorm(iff_split.momentum) - p0
assert momerr < tolerance
eoc_rec0.add_data_point(1.0 / nel_1d, momerr)
# Check the boundary facial fluxes as called on a boundary
dir_mass = discr.project("vol", BTAG_ALL, mass_input)
dir_e = discr.project("vol", BTAG_ALL, energy_input)
dir_mom = discr.project("vol", BTAG_ALL, mom_input)
dir_bval = join_conserved(dim,
mass=dir_mass,
energy=dir_e,
momentum=dir_mom)
dir_bc = join_conserved(dim,
mass=dir_mass,
energy=dir_e,
momentum=dir_mom)
boundary_flux = _facial_flux(discr,
eos=IdealSingleGas(),
q_tpair=TracePair(BTAG_ALL,
interior=dir_bval,
exterior=dir_bc))
bf_split = split_conserved(dim, boundary_flux)
assert fnorm(bf_split.mass) < tolerance
assert fnorm(bf_split.energy) < tolerance
momerr = fnorm(bf_split.momentum) - p0
assert momerr < tolerance
eoc_rec1.add_data_point(1.0 / nel_1d, momerr)
message = (f"standalone Errors:\n{eoc_rec0}"
f"boundary Errors:\n{eoc_rec1}")
logger.info(message)
assert (eoc_rec0.order_estimate() >= order - 0.5
or eoc_rec0.max_error() < 1e-9)
assert (eoc_rec1.order_estimate() >= order - 0.5
or eoc_rec1.max_error() < 1e-9)
def test_facial_flux(actx_factory, nspecies, order, dim):
"""Check the flux across element faces.
The flux is checked by prescribing states (q) with known fluxes. Only uniform
states are tested currently - ensuring that the Lax-Friedrichs flux terms which
are proportional to jumps in state data vanish.
Since the returned fluxes use state data which has been interpolated
to-and-from the element faces, this test is grid-dependent.
"""
actx = actx_factory()
tolerance = 1e-14
p0 = 1.0
from meshmode.mesh.generation import generate_regular_rect_mesh
from pytools.convergence import EOCRecorder
eoc_rec0 = EOCRecorder()
eoc_rec1 = EOCRecorder()
for nel_1d in [4, 8, 12]:
mesh = generate_regular_rect_mesh(a=(-0.5, ) * dim,
b=(0.5, ) * dim,
nelements_per_axis=(nel_1d, ) * dim)
logger.info(f"Number of elements: {mesh.nelements}")
discr = EagerDGDiscretization(actx, mesh, order=order)
zeros = discr.zeros(actx)
ones = zeros + 1.0
mass_input = discr.zeros(actx) + 1.0
energy_input = discr.zeros(actx) + 2.5
mom_input = flat_obj_array(
[discr.zeros(actx) for i in range(discr.dim)])
mass_frac_input = flat_obj_array(
[ones / ((i + 1) * 10) for i in range(nspecies)])
species_mass_input = mass_input * mass_frac_input
cv = make_conserved(dim,
mass=mass_input,
energy=energy_input,
momentum=mom_input,
species_mass=species_mass_input)
from grudge.trace_pair import interior_trace_pairs
cv_interior_pairs = interior_trace_pairs(discr, cv)
# Check the boundary facial fluxes as called on an interior boundary
# eos = IdealSingleGas()
from mirgecom.gas_model import (GasModel, make_fluid_state)
gas_model = GasModel(eos=IdealSingleGas())
from mirgecom.gas_model import make_fluid_state_trace_pairs
state_tpairs = make_fluid_state_trace_pairs(cv_interior_pairs,
gas_model)
interior_state_pair = state_tpairs[0]
from mirgecom.inviscid import inviscid_facial_flux
interior_face_flux = \
inviscid_facial_flux(discr, state_tpair=interior_state_pair)
def inf_norm(data):
if len(data) > 0:
return actx.to_numpy(discr.norm(data, np.inf, dd="all_faces"))
else:
return 0.0
assert inf_norm(interior_face_flux.mass) < tolerance
assert inf_norm(interior_face_flux.energy) < tolerance
assert inf_norm(interior_face_flux.species_mass) < tolerance
# The expected pressure is 1.0 (by design). And the flux diagonal is
# [rhov_x*v_x + p] (etc) since we have zero velocities it's just p.
#
# The off-diagonals are zero. We get a {ndim}-vector for each
# dimension, the flux for the x-component of momentum (for example) is:
# f_momx = < 1.0, 0 , 0> , then we return f_momx .dot. normal, which
# can introduce negative values.
#
# (Explanation courtesy of Mike Campbell,
# https://github.com/illinois-ceesd/mirgecom/pull/44#discussion_r463304292)
nhat = thaw(actx, discr.normal("int_faces"))
mom_flux_exact = discr.project("int_faces", "all_faces", p0 * nhat)
print(f"{mom_flux_exact=}")
print(f"{interior_face_flux.momentum=}")
momerr = inf_norm(interior_face_flux.momentum - mom_flux_exact)
assert momerr < tolerance
eoc_rec0.add_data_point(1.0 / nel_1d, momerr)
# Check the boundary facial fluxes as called on a domain boundary
dir_mass = discr.project("vol", BTAG_ALL, mass_input)
dir_e = discr.project("vol", BTAG_ALL, energy_input)
dir_mom = discr.project("vol", BTAG_ALL, mom_input)
dir_mf = discr.project("vol", BTAG_ALL, species_mass_input)
dir_bc = make_conserved(dim,
mass=dir_mass,
energy=dir_e,
momentum=dir_mom,
species_mass=dir_mf)
dir_bval = make_conserved(dim,
mass=dir_mass,
energy=dir_e,
momentum=dir_mom,
species_mass=dir_mf)
state_tpair = TracePair(BTAG_ALL,
interior=make_fluid_state(dir_bval, gas_model),
exterior=make_fluid_state(dir_bc, gas_model))
boundary_flux = inviscid_facial_flux(discr, state_tpair=state_tpair)
assert inf_norm(boundary_flux.mass) < tolerance
assert inf_norm(boundary_flux.energy) < tolerance
assert inf_norm(boundary_flux.species_mass) < tolerance
nhat = thaw(actx, discr.normal(BTAG_ALL))
mom_flux_exact = discr.project(BTAG_ALL, "all_faces", p0 * nhat)
momerr = inf_norm(boundary_flux.momentum - mom_flux_exact)
assert momerr < tolerance
eoc_rec1.add_data_point(1.0 / nel_1d, momerr)
logger.info(f"standalone Errors:\n{eoc_rec0}"
f"boundary Errors:\n{eoc_rec1}")
assert (eoc_rec0.order_estimate() >= order - 0.5
or eoc_rec0.max_error() < 1e-9)
assert (eoc_rec1.order_estimate() >= order - 0.5
or eoc_rec1.max_error() < 1e-9)