def my_rhs(t, state):
cv, tseed = state
fluid_state = make_fluid_state(cv, gas_model, temperature_seed=tseed)
return make_obj_array(
[euler_operator(discr, state=fluid_state, time=t,
boundaries=boundaries, gas_model=gas_model),
0*tseed])
def my_rhs(t, state):
fluid_state = make_fluid_state(state, gas_model)
return euler_operator(discr,
state=fluid_state,
time=t,
boundaries=boundaries,
gas_model=gas_model)
def test_lump_rhs(actx_factory, dim, order):
"""Test the inviscid rhs using the non-trivial mass lump case.
The case is tested against the analytic expressions of the RHS.
Checks several different orders and refinement levels to check error behavior.
"""
actx = actx_factory()
tolerance = 1e-10
maxxerr = 0.0
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
for nel_1d in [4, 8, 12]:
from meshmode.mesh.generation import (
generate_regular_rect_mesh, )
mesh = generate_regular_rect_mesh(
a=(-5, ) * dim,
b=(5, ) * dim,
nelements_per_axis=(nel_1d, ) * dim,
)
logger.info(f"Number of elements: {mesh.nelements}")
discr = EagerDGDiscretization(actx, mesh, order=order)
nodes = thaw(actx, discr.nodes())
# Init soln with Lump and expected RHS = 0
center = np.zeros(shape=(dim, ))
velocity = np.zeros(shape=(dim, ))
lump = Lump(dim=dim, center=center, velocity=velocity)
lump_soln = lump(nodes)
boundaries = {
BTAG_ALL: PrescribedInviscidBoundary(fluid_solution_func=lump)
}
inviscid_rhs = euler_operator(discr,
eos=IdealSingleGas(),
boundaries=boundaries,
cv=lump_soln,
time=0.0)
expected_rhs = lump.exact_rhs(discr, cv=lump_soln, time=0)
err_max = discr.norm((inviscid_rhs - expected_rhs).join(), np.inf)
if err_max > maxxerr:
maxxerr = err_max
eoc_rec.add_data_point(1.0 / nel_1d, err_max)
logger.info(f"Max error: {maxxerr}")
logger.info(f"Error for (dim,order) = ({dim},{order}):\n" f"{eoc_rec}")
assert (eoc_rec.order_estimate() >= order - 0.5
or eoc_rec.max_error() < tolerance)
def test_vortex_rhs(actx_factory, order):
"""Test the inviscid rhs using the non-trivial 2D isentropic vortex.
The case is configured to yield rhs = 0. Checks several different orders
and refinement levels to check error behavior.
"""
actx = actx_factory()
dim = 2
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
from meshmode.mesh.generation import generate_regular_rect_mesh
for nel_1d in [32, 48, 64]:
mesh = generate_regular_rect_mesh(
a=(-5, ) * dim,
b=(5, ) * dim,
nelements_per_axis=(nel_1d, ) * dim,
)
logger.info(f"Number of {dim}d elements: {mesh.nelements}")
discr = EagerDGDiscretization(actx, mesh, order=order)
nodes = thaw(actx, discr.nodes())
# Init soln with Vortex and expected RHS = 0
vortex = Vortex2D(center=[0, 0], velocity=[0, 0])
vortex_soln = vortex(nodes)
boundaries = {
BTAG_ALL: PrescribedInviscidBoundary(fluid_solution_func=vortex)
}
inviscid_rhs = euler_operator(discr,
eos=IdealSingleGas(),
boundaries=boundaries,
cv=vortex_soln,
time=0.0)
err_max = discr.norm(inviscid_rhs.join(), np.inf)
eoc_rec.add_data_point(1.0 / nel_1d, err_max)
logger.info(f"Error for (dim,order) = ({dim},{order}):\n" f"{eoc_rec}")
assert (eoc_rec.order_estimate() >= order - 0.5
or eoc_rec.max_error() < 1e-11)
def my_rhs(t, state):
cv, tseed = state
from mirgecom.gas_model import make_fluid_state
fluid_state = make_fluid_state(cv=cv,
gas_model=gas_model,
temperature_seed=tseed)
return make_obj_array([
euler_operator(discr,
state=fluid_state,
time=t,
boundaries=boundaries,
gas_model=gas_model,
quadrature_tag=quadrature_tag) +
eos.get_species_source_terms(cv, fluid_state.temperature),
0 * tseed
])
def my_rhs(t, state):
# check for some troublesome output types
inf_exists = not np.isfinite(discr.norm(state, np.inf))
if inf_exists:
if rank == 0:
logging.info("Non-finite values detected in simulation, exiting...")
# dump right now
viz_fields = [("sponge_sigma", gen_sponge())]
sim_checkpoint(discr=discr, visualizer=visualizer, eos=eos,
q=state, vizname=casename,
step=999999999, t=t, dt=current_dt,
nviz=1, exittol=exittol,
constant_cfl=constant_cfl, comm=comm, vis_timer=vis_timer,
overwrite=True,s0=s0_sc,kappa=kappa_sc,
viz_fields=viz_fields)
exit()
return ( euler_operator(discr, q=state, t=t,boundaries=boundaries, eos=eos)
+ artificial_viscosity(discr,t=t, r=state, eos=eos, boundaries=boundaries,
alpha=alpha_sc, s0=s0_sc, kappa=kappa_sc)
+ sponge(q=state, q_ref=ref_state, sigma=sponge_sigma))
def test_vortex_rhs(actx_factory, order, use_overintegration):
"""Test the inviscid rhs using the non-trivial 2D isentropic vortex.
The case is configured to yield rhs = 0. Checks several different orders
and refinement levels to check error behavior.
"""
actx = actx_factory()
dim = 2
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
from meshmode.mesh.generation import generate_regular_rect_mesh
for nel_1d in [32, 48, 64]:
mesh = generate_regular_rect_mesh(
a=(-5,) * dim, b=(5,) * dim, nelements_per_axis=(nel_1d,) * dim,
)
logger.info(
f"Number of {dim}d elements: {mesh.nelements}"
)
from grudge.dof_desc import DISCR_TAG_BASE, DISCR_TAG_QUAD
from meshmode.discretization.poly_element import \
default_simplex_group_factory, QuadratureSimplexGroupFactory
discr = EagerDGDiscretization(
actx, mesh,
discr_tag_to_group_factory={
DISCR_TAG_BASE: default_simplex_group_factory(
base_dim=dim, order=order),
DISCR_TAG_QUAD: QuadratureSimplexGroupFactory(2*order + 1)
}
)
if use_overintegration:
quadrature_tag = DISCR_TAG_QUAD
else:
quadrature_tag = None
nodes = thaw(discr.nodes(), actx)
# Init soln with Vortex and expected RHS = 0
vortex = Vortex2D(center=[0, 0], velocity=[0, 0])
vortex_soln = vortex(nodes)
gas_model = GasModel(eos=IdealSingleGas())
fluid_state = make_fluid_state(vortex_soln, gas_model)
def _vortex_boundary(discr, btag, gas_model, state_minus, **kwargs):
actx = state_minus.array_context
bnd_discr = discr.discr_from_dd(btag)
nodes = thaw(bnd_discr.nodes(), actx)
return make_fluid_state(vortex(x_vec=nodes, **kwargs), gas_model)
boundaries = {
BTAG_ALL: PrescribedFluidBoundary(boundary_state_func=_vortex_boundary)
}
inviscid_rhs = euler_operator(
discr, state=fluid_state, gas_model=gas_model, boundaries=boundaries,
time=0.0, quadrature_tag=quadrature_tag)
err_max = max_component_norm(discr, inviscid_rhs, np.inf)
eoc_rec.add_data_point(1.0 / nel_1d, err_max)
logger.info(
f"Error for (dim,order) = ({dim},{order}):\n"
f"{eoc_rec}"
)
assert (
eoc_rec.order_estimate() >= order - 0.5
or eoc_rec.max_error() < 1e-11
)
def my_rhs(t, state):
return euler_operator(discr,
cv=state,
t=t,
boundaries=boundaries,
eos=eos)
def test_multilump_rhs(actx_factory, dim, order, v0, use_overintegration):
"""Test the Euler rhs using the non-trivial 1, 2, and 3D mass lump case.
The case is tested against the analytic expressions of the RHS. Checks several
different orders and refinement levels to check error behavior.
"""
actx = actx_factory()
nspecies = 10
tolerance = 1e-8
maxxerr = 0.0
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
for nel_1d in [4, 8, 12]:
from meshmode.mesh.generation import (
generate_regular_rect_mesh,
)
mesh = generate_regular_rect_mesh(
a=(-1,) * dim, b=(1,) * dim, nelements_per_axis=(nel_1d,) * dim,
)
logger.info(f"Number of elements: {mesh.nelements}")
from grudge.dof_desc import DISCR_TAG_BASE, DISCR_TAG_QUAD
from meshmode.discretization.poly_element import \
default_simplex_group_factory, QuadratureSimplexGroupFactory
discr = EagerDGDiscretization(
actx, mesh,
discr_tag_to_group_factory={
DISCR_TAG_BASE: default_simplex_group_factory(
base_dim=dim, order=order),
DISCR_TAG_QUAD: QuadratureSimplexGroupFactory(2*order + 1)
}
)
if use_overintegration:
quadrature_tag = DISCR_TAG_QUAD
else:
quadrature_tag = None
nodes = thaw(discr.nodes(), actx)
centers = make_obj_array([np.zeros(shape=(dim,)) for i in range(nspecies)])
spec_y0s = np.ones(shape=(nspecies,))
spec_amplitudes = np.ones(shape=(nspecies,))
velocity = np.zeros(shape=(dim,))
velocity[0] = v0
rho0 = 2.0
lump = MulticomponentLump(dim=dim, nspecies=nspecies, rho0=rho0,
spec_centers=centers, velocity=velocity,
spec_y0s=spec_y0s, spec_amplitudes=spec_amplitudes)
lump_soln = lump(nodes)
gas_model = GasModel(eos=IdealSingleGas())
fluid_state = make_fluid_state(lump_soln, gas_model)
def _my_boundary(discr, btag, gas_model, state_minus, **kwargs):
actx = state_minus.array_context
bnd_discr = discr.discr_from_dd(btag)
nodes = thaw(bnd_discr.nodes(), actx)
return make_fluid_state(lump(x_vec=nodes, **kwargs), gas_model)
boundaries = {
BTAG_ALL: PrescribedFluidBoundary(boundary_state_func=_my_boundary)
}
inviscid_rhs = euler_operator(
discr, state=fluid_state, gas_model=gas_model, boundaries=boundaries,
time=0.0, quadrature_tag=quadrature_tag
)
expected_rhs = lump.exact_rhs(discr, cv=lump_soln, time=0)
print(f"inviscid_rhs = {inviscid_rhs}")
print(f"expected_rhs = {expected_rhs}")
err_max = actx.to_numpy(
discr.norm((inviscid_rhs-expected_rhs), np.inf))
if err_max > maxxerr:
maxxerr = err_max
eoc_rec.add_data_point(1.0 / nel_1d, err_max)
logger.info(f"Max error: {maxxerr}")
logger.info(
f"Error for (dim,order) = ({dim},{order}):\n"
f"{eoc_rec}"
)
assert (
eoc_rec.order_estimate() >= order - 0.5
or eoc_rec.max_error() < tolerance
)
def op(state):
fluid_state = make_fluid_state(state, gas_model)
return euler_operator(discr, gas_model=gas_model,
boundaries=boundaries, state=fluid_state)
def test_uniform_rhs(actx_factory, nspecies, dim, order):
"""Test the inviscid rhs using a trivial constant/uniform state.
This state should yield rhs = 0 to FP. The test is performed for 1, 2,
and 3 dimensions, with orders 1, 2, and 3, with and without passive species.
"""
actx = actx_factory()
tolerance = 1e-9
from pytools.convergence import EOCRecorder
eoc_rec0 = EOCRecorder()
eoc_rec1 = EOCRecorder()
# for nel_1d in [4, 8, 12]:
for nel_1d in [4, 8]:
from meshmode.mesh.generation import generate_regular_rect_mesh
mesh = generate_regular_rect_mesh(a=(-0.5, ) * dim,
b=(0.5, ) * dim,
nelements_per_axis=(nel_1d, ) * dim)
logger.info(f"Number of {dim}d elements: {mesh.nelements}")
discr = EagerDGDiscretization(actx, mesh, order=order)
zeros = discr.zeros(actx)
ones = zeros + 1.0
mass_input = discr.zeros(actx) + 1
energy_input = discr.zeros(actx) + 2.5
mom_input = make_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
num_equations = dim + 2 + len(species_mass_input)
cv = make_conserved(dim,
mass=mass_input,
energy=energy_input,
momentum=mom_input,
species_mass=species_mass_input)
expected_rhs = make_conserved(
dim,
q=make_obj_array([discr.zeros(actx)
for i in range(num_equations)]))
boundaries = {BTAG_ALL: DummyBoundary()}
inviscid_rhs = euler_operator(discr,
eos=IdealSingleGas(),
boundaries=boundaries,
cv=cv,
time=0.0)
rhs_resid = inviscid_rhs - expected_rhs
rho_resid = rhs_resid.mass
rhoe_resid = rhs_resid.energy
mom_resid = rhs_resid.momentum
rhoy_resid = rhs_resid.species_mass
rho_rhs = inviscid_rhs.mass
rhoe_rhs = inviscid_rhs.energy
rhov_rhs = inviscid_rhs.momentum
rhoy_rhs = inviscid_rhs.species_mass
logger.info(f"rho_rhs = {rho_rhs}\n"
f"rhoe_rhs = {rhoe_rhs}\n"
f"rhov_rhs = {rhov_rhs}\n"
f"rhoy_rhs = {rhoy_rhs}\n")
assert discr.norm(rho_resid, np.inf) < tolerance
assert discr.norm(rhoe_resid, np.inf) < tolerance
for i in range(dim):
assert discr.norm(mom_resid[i], np.inf) < tolerance
for i in range(nspecies):
assert discr.norm(rhoy_resid[i], np.inf) < tolerance
err_max = discr.norm(rho_resid, np.inf)
eoc_rec0.add_data_point(1.0 / nel_1d, err_max)
# set a non-zero, but uniform velocity component
for i in range(len(mom_input)):
mom_input[i] = discr.zeros(actx) + (-1.0)**i
cv = make_conserved(dim,
mass=mass_input,
energy=energy_input,
momentum=mom_input,
species_mass=species_mass_input)
boundaries = {BTAG_ALL: DummyBoundary()}
inviscid_rhs = euler_operator(discr,
eos=IdealSingleGas(),
boundaries=boundaries,
cv=cv,
time=0.0)
rhs_resid = inviscid_rhs - expected_rhs
rho_resid = rhs_resid.mass
rhoe_resid = rhs_resid.energy
mom_resid = rhs_resid.momentum
rhoy_resid = rhs_resid.species_mass
assert discr.norm(rho_resid, np.inf) < tolerance
assert discr.norm(rhoe_resid, np.inf) < tolerance
for i in range(dim):
assert discr.norm(mom_resid[i], np.inf) < tolerance
for i in range(nspecies):
assert discr.norm(rhoy_resid[i], np.inf) < tolerance
err_max = discr.norm(rho_resid, np.inf)
eoc_rec1.add_data_point(1.0 / nel_1d, err_max)
logger.info(f"V == 0 Errors:\n{eoc_rec0}" f"V != 0 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)
def rhs(t, q):
fluid_state = make_fluid_state(q, gas_model)
return euler_operator(discr, fluid_state, boundaries=boundaries,
gas_model=gas_model, time=t,
quadrature_tag=quadrature_tag)
def rhs(t, q):
return euler_operator(discr,
eos=eos,
boundaries=boundaries,
cv=q,
time=t)
def test_multilump_rhs(actx_factory, dim, order, v0):
"""Test the Euler rhs using the non-trivial 1, 2, and 3D mass lump case.
The case is tested against the analytic expressions of the RHS. Checks several
different orders and refinement levels to check error behavior.
"""
actx = actx_factory()
nspecies = 10
tolerance = 1e-8
maxxerr = 0.0
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
for nel_1d in [4, 8, 16]:
from meshmode.mesh.generation import (
generate_regular_rect_mesh, )
mesh = generate_regular_rect_mesh(
a=(-1, ) * dim,
b=(1, ) * dim,
nelements_per_axis=(nel_1d, ) * dim,
)
logger.info(f"Number of elements: {mesh.nelements}")
discr = EagerDGDiscretization(actx, mesh, order=order)
nodes = thaw(actx, discr.nodes())
centers = make_obj_array(
[np.zeros(shape=(dim, )) for i in range(nspecies)])
spec_y0s = np.ones(shape=(nspecies, ))
spec_amplitudes = np.ones(shape=(nspecies, ))
velocity = np.zeros(shape=(dim, ))
velocity[0] = v0
rho0 = 2.0
lump = MulticomponentLump(dim=dim,
nspecies=nspecies,
rho0=rho0,
spec_centers=centers,
velocity=velocity,
spec_y0s=spec_y0s,
spec_amplitudes=spec_amplitudes)
lump_soln = lump(nodes)
boundaries = {
BTAG_ALL: PrescribedInviscidBoundary(fluid_solution_func=lump)
}
inviscid_rhs = euler_operator(discr,
eos=IdealSingleGas(),
boundaries=boundaries,
cv=lump_soln,
time=0.0)
expected_rhs = lump.exact_rhs(discr, cv=lump_soln, time=0)
print(f"inviscid_rhs = {inviscid_rhs}")
print(f"expected_rhs = {expected_rhs}")
err_max = discr.norm((inviscid_rhs - expected_rhs).join(), np.inf)
if err_max > maxxerr:
maxxerr = err_max
eoc_rec.add_data_point(1.0 / nel_1d, err_max)
logger.info(f"Max error: {maxxerr}")
logger.info(f"Error for (dim,order) = ({dim},{order}):\n" f"{eoc_rec}")
assert (eoc_rec.order_estimate() >= order - 0.5
or eoc_rec.max_error() < tolerance)
def my_rhs(t, state):
return (euler_operator(
discr, cv=state, time=t, boundaries=boundaries, eos=eos) +
eos.get_species_source_terms(state))
def test_uniform_rhs(actx_factory, nspecies, dim, order, use_overintegration):
"""Test the inviscid rhs using a trivial constant/uniform state.
This state should yield rhs = 0 to FP. The test is performed for 1, 2,
and 3 dimensions, with orders 1, 2, and 3, with and without passive species.
"""
actx = actx_factory()
tolerance = 1e-9
from pytools.convergence import EOCRecorder
eoc_rec0 = EOCRecorder()
eoc_rec1 = EOCRecorder()
# for nel_1d in [4, 8, 12]:
for nel_1d in [4, 8]:
from meshmode.mesh.generation import generate_regular_rect_mesh
mesh = generate_regular_rect_mesh(
a=(-0.5,) * dim, b=(0.5,) * dim, nelements_per_axis=(nel_1d,) * dim
)
logger.info(
f"Number of {dim}d elements: {mesh.nelements}"
)
from grudge.dof_desc import DISCR_TAG_BASE, DISCR_TAG_QUAD
from meshmode.discretization.poly_element import \
default_simplex_group_factory, QuadratureSimplexGroupFactory
discr = EagerDGDiscretization(
actx, mesh,
discr_tag_to_group_factory={
DISCR_TAG_BASE: default_simplex_group_factory(
base_dim=dim, order=order),
DISCR_TAG_QUAD: QuadratureSimplexGroupFactory(2*order + 1)
}
)
if use_overintegration:
quadrature_tag = DISCR_TAG_QUAD
else:
quadrature_tag = None
zeros = discr.zeros(actx)
ones = zeros + 1.0
mass_input = discr.zeros(actx) + 1
energy_input = discr.zeros(actx) + 2.5
mom_input = make_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
num_equations = dim + 2 + len(species_mass_input)
cv = make_conserved(
dim, mass=mass_input, energy=energy_input, momentum=mom_input,
species_mass=species_mass_input)
gas_model = GasModel(eos=IdealSingleGas())
fluid_state = make_fluid_state(cv, gas_model)
expected_rhs = make_conserved(
dim, q=make_obj_array([discr.zeros(actx)
for i in range(num_equations)])
)
boundaries = {BTAG_ALL: DummyBoundary()}
inviscid_rhs = euler_operator(discr, state=fluid_state, gas_model=gas_model,
boundaries=boundaries, time=0.0,
quadrature_tag=quadrature_tag)
rhs_resid = inviscid_rhs - expected_rhs
rho_resid = rhs_resid.mass
rhoe_resid = rhs_resid.energy
mom_resid = rhs_resid.momentum
rhoy_resid = rhs_resid.species_mass
rho_rhs = inviscid_rhs.mass
rhoe_rhs = inviscid_rhs.energy
rhov_rhs = inviscid_rhs.momentum
rhoy_rhs = inviscid_rhs.species_mass
logger.info(
f"rho_rhs = {rho_rhs}\n"
f"rhoe_rhs = {rhoe_rhs}\n"
f"rhov_rhs = {rhov_rhs}\n"
f"rhoy_rhs = {rhoy_rhs}\n"
)
def inf_norm(x):
return actx.to_numpy(discr.norm(x, np.inf))
assert inf_norm(rho_resid) < tolerance
assert inf_norm(rhoe_resid) < tolerance
for i in range(dim):
assert inf_norm(mom_resid[i]) < tolerance
for i in range(nspecies):
assert inf_norm(rhoy_resid[i]) < tolerance
err_max = inf_norm(rho_resid)
eoc_rec0.add_data_point(1.0 / nel_1d, err_max)
# set a non-zero, but uniform velocity component
for i in range(len(mom_input)):
mom_input[i] = discr.zeros(actx) + (-1.0) ** i
cv = make_conserved(
dim, mass=mass_input, energy=energy_input, momentum=mom_input,
species_mass=species_mass_input)
gas_model = GasModel(eos=IdealSingleGas())
fluid_state = make_fluid_state(cv, gas_model)
boundaries = {BTAG_ALL: DummyBoundary()}
inviscid_rhs = euler_operator(discr, state=fluid_state, gas_model=gas_model,
boundaries=boundaries, time=0.0)
rhs_resid = inviscid_rhs - expected_rhs
rho_resid = rhs_resid.mass
rhoe_resid = rhs_resid.energy
mom_resid = rhs_resid.momentum
rhoy_resid = rhs_resid.species_mass
assert inf_norm(rho_resid) < tolerance
assert inf_norm(rhoe_resid) < tolerance
for i in range(dim):
assert inf_norm(mom_resid[i]) < tolerance
for i in range(nspecies):
assert inf_norm(rhoy_resid[i]) < tolerance
err_max = inf_norm(rho_resid)
eoc_rec1.add_data_point(1.0 / nel_1d, err_max)
logger.info(
f"V == 0 Errors:\n{eoc_rec0}"
f"V != 0 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
)
def op(state):
return euler_operator(discr, eos, boundaries, state)
