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 boundary_solution(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(initializer(x_vec=nodes, eos=gas_model.eos,
**kwargs), gas_model,
temperature_seed=state_minus.temperature)
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 test_viscous_timestep(actx_factory, dim, mu, vel):
"""Test timestep size."""
actx = actx_factory()
nel_1d = 4
from meshmode.mesh.generation import generate_regular_rect_mesh
mesh = generate_regular_rect_mesh(a=(1.0, ) * dim,
b=(2.0, ) * dim,
nelements_per_axis=(nel_1d, ) * dim)
order = 1
discr = EagerDGDiscretization(actx, mesh, order=order)
zeros = discr.zeros(actx)
ones = zeros + 1.0
velocity = make_obj_array([zeros + vel for _ in range(dim)])
massval = 1
mass = massval * ones
# I *think* this energy should yield c=1.0
energy = zeros + 1.0 / (1.4 * .4)
mom = mass * velocity
species_mass = None
cv = make_conserved(dim,
mass=mass,
energy=energy,
momentum=mom,
species_mass=species_mass)
from grudge.dt_utils import characteristic_lengthscales
chlen = characteristic_lengthscales(actx, discr)
from grudge.op import nodal_min
chlen_min = nodal_min(discr, "vol", chlen)
mu = mu * chlen_min
if mu < 0:
mu = 0
tv_model = None
else:
tv_model = SimpleTransport(viscosity=mu)
eos = IdealSingleGas()
gas_model = GasModel(eos=eos, transport=tv_model)
fluid_state = make_fluid_state(cv, gas_model)
from mirgecom.viscous import get_viscous_timestep
dt_field = get_viscous_timestep(discr, fluid_state)
speed_total = fluid_state.wavespeed
dt_expected = chlen / (speed_total + (mu / chlen))
error = (dt_expected - dt_field) / dt_expected
assert actx.to_numpy(discr.norm(error, np.inf)) == 0
def my_pre_step(step, t, dt, state):
fluid_state = make_fluid_state(state, gas_model)
dv = fluid_state.dv
try:
exact = None
component_errors = None
if logmgr:
logmgr.tick_before()
from mirgecom.simutil import check_step
do_viz = check_step(step=step, interval=nviz)
do_restart = check_step(step=step, interval=nrestart)
do_health = check_step(step=step, interval=nhealth)
do_status = check_step(step=step, interval=nstatus)
if do_health:
exact = initializer(x_vec=nodes, eos=eos, time=t)
from mirgecom.simutil import compare_fluid_solutions
component_errors = compare_fluid_solutions(discr, state, exact)
health_errors = global_reduce(
my_health_check(dv.pressure, component_errors), op="lor")
if health_errors:
if rank == 0:
logger.info("Fluid solution failed health check.")
raise MyRuntimeError("Failed simulation health check.")
if do_restart:
my_write_restart(step=step, t=t, state=state)
if do_viz:
if exact is None:
exact = initializer(x_vec=nodes, eos=eos, time=t)
resid = state - exact
my_write_viz(step=step, t=t, state=state, dv=dv, exact=exact,
resid=resid)
if do_status:
if component_errors is None:
if exact is None:
exact = initializer(x_vec=nodes, eos=eos, time=t)
from mirgecom.simutil import compare_fluid_solutions
component_errors = \
compare_fluid_solutions(discr, state, exact)
my_write_status(component_errors)
except MyRuntimeError:
if rank == 0:
logger.info("Errors detected; attempting graceful exit.")
my_write_viz(step=step, t=t, state=state)
my_write_restart(step=step, t=t, state=state)
raise
dt = get_sim_timestep(discr, fluid_state, t, dt, current_cfl, t_final,
constant_cfl)
return state, dt
def test_viscous_stress_tensor(actx_factory, transport_model):
"""Test tau data structure and values against exact."""
actx = actx_factory()
dim = 3
nel_1d = 4
from meshmode.mesh.generation import generate_regular_rect_mesh
mesh = generate_regular_rect_mesh(a=(1.0, ) * dim,
b=(2.0, ) * dim,
nelements_per_axis=(nel_1d, ) * dim)
order = 1
discr = EagerDGDiscretization(actx, mesh, order=order)
nodes = thaw(actx, discr.nodes())
zeros = discr.zeros(actx)
ones = zeros + 1.0
# assemble velocities for simple, unique grad components
velocity_x = nodes[0] + 2 * nodes[1] + 3 * nodes[2]
velocity_y = 4 * nodes[0] + 5 * nodes[1] + 6 * nodes[2]
velocity_z = 7 * nodes[0] + 8 * nodes[1] + 9 * nodes[2]
velocity = make_obj_array([velocity_x, velocity_y, velocity_z])
mass = 2 * ones
energy = zeros + 2.5
mom = mass * velocity
cv = make_conserved(dim, mass=mass, energy=energy, momentum=mom)
grad_cv = op.local_grad(discr, cv)
if transport_model:
tv_model = SimpleTransport(bulk_viscosity=1.0, viscosity=0.5)
else:
tv_model = PowerLawTransport()
eos = IdealSingleGas()
gas_model = GasModel(eos=eos, transport=tv_model)
fluid_state = make_fluid_state(cv, gas_model)
mu = tv_model.viscosity(eos, cv)
lam = tv_model.volume_viscosity(eos, cv)
# Exact answer for tau
exp_grad_v = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
exp_grad_v_t = np.array([[1, 4, 7], [2, 5, 8], [3, 6, 9]])
exp_div_v = 15
exp_tau = (mu * (exp_grad_v + exp_grad_v_t) + lam * exp_div_v * np.eye(3))
from mirgecom.viscous import viscous_stress_tensor
tau = viscous_stress_tensor(fluid_state, grad_cv)
# The errors come from grad_v
assert actx.to_numpy(discr.norm(tau - exp_tau, np.inf)) < 1e-12
def my_post_step(step, t, dt, state):
cv, tseed = state
fluid_state = make_fluid_state(cv, gas_model, temperature_seed=tseed)
tseed = fluid_state.temperature
# Logmgr needs to know about EOS, dt, dim?
# imo this is a design/scope flaw
if logmgr:
set_dt(logmgr, dt)
set_sim_state(logmgr, dim, cv, eos)
logmgr.tick_after()
return make_obj_array([fluid_state.cv, tseed]), dt
def test_inviscid_mom_flux_components(actx_factory, dim, livedim):
r"""Test components of the momentum flux with constant pressure, V != 0.
Checks that the flux terms are returned in the proper order by running
only 1 non-zero velocity component at-a-time.
"""
actx = actx_factory()
eos = IdealSingleGas()
p0 = 1.0
nel_1d = 4
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)
order = 3
discr = EagerDGDiscretization(actx, mesh, order=order)
nodes = thaw(actx, discr.nodes())
tolerance = 1e-15
for livedim in range(dim):
mass = discr.zeros(actx) + 1.0 + np.dot(nodes, nodes)
mom = make_obj_array([discr.zeros(actx) for _ in range(dim)])
mom[livedim] = mass
p_exact = discr.zeros(actx) + p0
energy = (p_exact / (eos.gamma() - 1.0) +
0.5 * np.dot(mom, mom) / mass)
cv = make_conserved(dim, mass=mass, energy=energy, momentum=mom)
p = eos.pressure(cv)
from mirgecom.gas_model import GasModel, make_fluid_state
state = make_fluid_state(cv, GasModel(eos=eos))
def inf_norm(x):
return actx.to_numpy(discr.norm(x, np.inf))
assert inf_norm(p - p_exact) < tolerance
flux = inviscid_flux(state)
logger.info(f"{dim}d flux = {flux}")
vel_exact = mom / mass
# first two components should be nonzero in livedim only
assert inf_norm(flux.mass - mom) == 0
eflux_exact = (energy + p_exact) * vel_exact
assert inf_norm(flux.energy - eflux_exact) == 0
logger.info("Testing momentum")
xpmomflux = mass * np.outer(vel_exact,
vel_exact) + p_exact * np.identity(dim)
assert inf_norm(flux.momentum - xpmomflux) < tolerance
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 adiabatic_slip_state(self, discr, btag, gas_model, state_minus,
**kwargs):
"""Get the exterior solution on the boundary.
The exterior solution is set such that there will be vanishing
flux through the boundary, preserving mass, momentum (magnitude) and
energy.
rho_plus = rho_minus
v_plus = v_minus - 2 * (v_minus . n_hat) * n_hat
mom_plus = rho_plus * v_plus
E_plus = E_minus
"""
# Grab some boundary-relevant data
dim = discr.dim
actx = state_minus.array_context
# Grab a unit normal to the boundary
nhat = thaw(actx, discr.normal(btag))
# Subtract out the 2*wall-normal component
# of velocity from the velocity at the wall to
# induce an equal but opposite wall-normal (reflected) wave
# preserving the tangential component
cv_minus = state_minus.cv
ext_mom = (cv_minus.momentum -
2.0 * np.dot(cv_minus.momentum, nhat) * nhat)
# Form the external boundary solution with the new momentum
ext_cv = make_conserved(dim=dim,
mass=cv_minus.mass,
energy=cv_minus.energy,
momentum=ext_mom,
species_mass=cv_minus.species_mass)
t_seed = None if ext_cv.nspecies == 0 else state_minus.temperature
from mirgecom.gas_model import make_fluid_state
return make_fluid_state(cv=ext_cv,
gas_model=gas_model,
temperature_seed=t_seed)
def my_pre_step(step, t, dt, state):
fluid_state = make_fluid_state(state, gas_model)
dv = fluid_state.dv
try:
if logmgr:
logmgr.tick_before()
from mirgecom.simutil import check_step
do_viz = check_step(step=step, interval=nviz)
do_restart = check_step(step=step, interval=nrestart)
do_health = check_step(step=step, interval=nhealth)
if do_health:
health_errors = global_reduce(my_health_check(dv.pressure), op="lor")
if health_errors:
if rank == 0:
logger.info("Fluid solution failed health check.")
raise MyRuntimeError("Failed simulation health check.")
if do_restart:
my_write_restart(step=step, t=t, state=state)
if do_viz:
my_write_viz(step=step, t=t, state=state, dv=dv)
except MyRuntimeError:
if rank == 0:
logger.info("Errors detected; attempting graceful exit.")
my_write_viz(step=step, t=t, state=state)
my_write_restart(step=step, t=t, state=state)
raise
dt = get_sim_timestep(discr, fluid_state, t, dt, current_cfl, t_final,
constant_cfl)
return state, dt
def test_poiseuille_fluxes(actx_factory, order, kappa):
"""Test the viscous fluxes using a Poiseuille input state."""
actx = actx_factory()
dim = 2
from pytools.convergence import EOCRecorder
e_eoc_rec = EOCRecorder()
p_eoc_rec = EOCRecorder()
base_pressure = 100000.0
pressure_ratio = 1.001
mu = 42 # arbitrary
left_boundary_location = 0
right_boundary_location = 0.1
ybottom = 0.
ytop = .02
nspecies = 0
spec_diffusivity = 0 * np.ones(nspecies)
transport_model = SimpleTransport(viscosity=mu,
thermal_conductivity=kappa,
species_diffusivity=spec_diffusivity)
xlen = right_boundary_location - left_boundary_location
p_low = base_pressure
p_hi = pressure_ratio * base_pressure
dpdx = (p_low - p_hi) / xlen
rho = 1.0
eos = IdealSingleGas()
gas_model = GasModel(eos=eos, transport=transport_model)
from mirgecom.initializers import PlanarPoiseuille
initializer = PlanarPoiseuille(density=rho, mu=mu)
def _elbnd_flux(discr, compute_interior_flux, compute_boundary_flux,
int_tpair, boundaries):
return (compute_interior_flux(int_tpair) +
sum(compute_boundary_flux(btag) for btag in boundaries))
from mirgecom.flux import gradient_flux_central
def cv_flux_interior(int_tpair):
normal = thaw(actx, discr.normal(int_tpair.dd))
flux_weak = gradient_flux_central(int_tpair, normal)
dd_all_faces = int_tpair.dd.with_dtag("all_faces")
return discr.project(int_tpair.dd, dd_all_faces, flux_weak)
def cv_flux_boundary(btag):
boundary_discr = discr.discr_from_dd(btag)
bnd_nodes = thaw(actx, boundary_discr.nodes())
cv_bnd = initializer(x_vec=bnd_nodes, eos=eos)
bnd_nhat = thaw(actx, discr.normal(btag))
from grudge.trace_pair import TracePair
bnd_tpair = TracePair(btag, interior=cv_bnd, exterior=cv_bnd)
flux_weak = gradient_flux_central(bnd_tpair, bnd_nhat)
dd_all_faces = bnd_tpair.dd.with_dtag("all_faces")
return discr.project(bnd_tpair.dd, dd_all_faces, flux_weak)
for nfac in [1, 2, 4]:
npts_axis = nfac * (11, 21)
box_ll = (left_boundary_location, ybottom)
box_ur = (right_boundary_location, ytop)
mesh = _get_box_mesh(2, a=box_ll, b=box_ur, n=npts_axis)
logger.info(f"Number of {dim}d elements: {mesh.nelements}")
discr = EagerDGDiscretization(actx, mesh, order=order)
nodes = thaw(actx, discr.nodes())
def inf_norm(x):
return actx.to_numpy(discr.norm(x, np.inf))
# compute max element size
from grudge.dt_utils import h_max_from_volume
h_max = h_max_from_volume(discr)
# form exact cv
cv = initializer(x_vec=nodes, eos=eos)
cv_int_tpair = interior_trace_pair(discr, cv)
boundaries = [BTAG_ALL]
cv_flux_bnd = _elbnd_flux(discr, cv_flux_interior, cv_flux_boundary,
cv_int_tpair, boundaries)
from mirgecom.operators import grad_operator
from grudge.dof_desc import as_dofdesc
dd_vol = as_dofdesc("vol")
dd_faces = as_dofdesc("all_faces")
grad_cv = grad_operator(discr, dd_vol, dd_faces, cv, cv_flux_bnd)
xp_grad_cv = initializer.exact_grad(x_vec=nodes, eos=eos, cv_exact=cv)
xp_grad_v = 1 / cv.mass * xp_grad_cv.momentum
xp_tau = mu * (xp_grad_v + xp_grad_v.transpose())
# sanity check the gradient:
relerr_scale_e = 1.0 / inf_norm(xp_grad_cv.energy)
relerr_scale_p = 1.0 / inf_norm(xp_grad_cv.momentum)
graderr_e = inf_norm(grad_cv.energy - xp_grad_cv.energy)
graderr_p = inf_norm(grad_cv.momentum - xp_grad_cv.momentum)
graderr_e *= relerr_scale_e
graderr_p *= relerr_scale_p
assert graderr_e < 5e-7
assert graderr_p < 5e-11
zeros = discr.zeros(actx)
ones = zeros + 1
pressure = eos.pressure(cv)
# grad of p should be dp/dx
xp_grad_p = make_obj_array([dpdx * ones, zeros])
grad_p = op.local_grad(discr, pressure)
dpscal = 1.0 / np.abs(dpdx)
temperature = eos.temperature(cv)
tscal = rho * eos.gas_const() * dpscal
xp_grad_t = xp_grad_p / (cv.mass * eos.gas_const())
grad_t = op.local_grad(discr, temperature)
# sanity check
assert inf_norm(grad_p - xp_grad_p) * dpscal < 5e-9
assert inf_norm(grad_t - xp_grad_t) * tscal < 5e-9
fluid_state = make_fluid_state(cv, gas_model)
# verify heat flux
from mirgecom.viscous import conductive_heat_flux
heat_flux = conductive_heat_flux(fluid_state, grad_t)
xp_heat_flux = -kappa * xp_grad_t
assert inf_norm(heat_flux - xp_heat_flux) < 2e-8
xp_e_flux = np.dot(xp_tau, cv.velocity) - xp_heat_flux
xp_mom_flux = xp_tau
from mirgecom.viscous import viscous_flux
vflux = viscous_flux(fluid_state, grad_cv, grad_t)
efluxerr = (inf_norm(vflux.energy - xp_e_flux) / inf_norm(xp_e_flux))
momfluxerr = (inf_norm(vflux.momentum - xp_mom_flux) /
inf_norm(xp_mom_flux))
assert inf_norm(vflux.mass) == 0
e_eoc_rec.add_data_point(actx.to_numpy(h_max), efluxerr)
p_eoc_rec.add_data_point(actx.to_numpy(h_max), momfluxerr)
assert (e_eoc_rec.order_estimate() >= order - 0.5
or e_eoc_rec.max_error() < 3e-9)
assert (p_eoc_rec.order_estimate() >= order - 0.5
or p_eoc_rec.max_error() < 2e-12)
def test_inviscid_flux(actx_factory, nspecies, dim):
"""Check inviscid flux against exact expected result: Identity test.
Directly check inviscid flux routine, :func:`mirgecom.inviscid.inviscid_flux`,
against the exact expected result. This test is designed to fail if the flux
routine is broken.
The expected inviscid flux is:
F(q) = <rhoV, (E+p)V, rho(V.x.V) + pI, rhoY V>
"""
actx = actx_factory()
nel_1d = 16
from meshmode.mesh.generation import generate_regular_rect_mesh
# for dim in [1, 2, 3]:
mesh = generate_regular_rect_mesh(a=(-0.5, ) * dim,
b=(0.5, ) * dim,
nelements_per_axis=(nel_1d, ) * dim)
order = 3
discr = EagerDGDiscretization(actx, mesh, order=order)
eos = IdealSingleGas()
logger.info(f"Number of {dim}d elems: {mesh.nelements}")
def rand():
from meshmode.dof_array import DOFArray
return DOFArray(
actx,
tuple(
actx.from_numpy(np.random.rand(grp.nelements, grp.nunit_dofs))
for grp in discr.discr_from_dd("vol").groups))
mass = rand()
energy = rand()
mom = make_obj_array([rand() for _ in range(dim)])
mass_fractions = make_obj_array([rand() for _ in range(nspecies)])
species_mass = mass * mass_fractions
cv = make_conserved(dim,
mass=mass,
energy=energy,
momentum=mom,
species_mass=species_mass)
# {{{ create the expected result
p = eos.pressure(cv)
escale = (energy + p) / mass
numeq = dim + 2 + nspecies
expected_flux = np.zeros((numeq, dim), dtype=object)
expected_flux[0] = mom
expected_flux[1] = mom * escale
for i in range(dim):
for j in range(dim):
expected_flux[2 + i,
j] = (mom[i] * mom[j] / mass + (p if i == j else 0))
for i in range(nspecies):
expected_flux[dim + 2 + i] = mom * mass_fractions[i]
expected_flux = make_conserved(dim, q=expected_flux)
# }}}
from mirgecom.gas_model import GasModel, make_fluid_state
gas_model = GasModel(eos=eos)
state = make_fluid_state(cv, gas_model)
flux = inviscid_flux(state)
flux_resid = flux - expected_flux
for i in range(numeq, dim):
for j in range(dim):
assert (la.norm(flux_resid[i, j].get())) == 0.0
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)
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 _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(init(x_vec=nodes, eos=gas_model.eos,
**kwargs), gas_model)
def test_diffusive_heat_flux(actx_factory):
"""Test diffusive heat flux and values against exact."""
actx = actx_factory()
dim = 3
nel_1d = 4
from meshmode.mesh.generation import generate_regular_rect_mesh
mesh = generate_regular_rect_mesh(a=(1.0, ) * dim,
b=(2.0, ) * dim,
nelements_per_axis=(nel_1d, ) * dim)
order = 1
discr = EagerDGDiscretization(actx, mesh, order=order)
nodes = thaw(actx, discr.nodes())
zeros = discr.zeros(actx)
ones = zeros + 1.0
# assemble velocities for simple, unique grad components
velocity_x = nodes[0] + 2 * nodes[1] + 3 * nodes[2]
velocity_y = 4 * nodes[0] + 5 * nodes[1] + 6 * nodes[2]
velocity_z = 7 * nodes[0] + 8 * nodes[1] + 9 * nodes[2]
velocity = make_obj_array([velocity_x, velocity_y, velocity_z])
# assemble y so that each one has simple, but unique grad components
nspecies = 2 * dim
y = make_obj_array([ones for _ in range(nspecies)])
for idim in range(dim):
ispec = 2 * idim
y[ispec] = (ispec + 1) * (idim * dim + 1) * sum(
[(iidim + 1) * nodes[iidim] for iidim in range(dim)])
y[ispec + 1] = -y[ispec]
massval = 2
mass = massval * ones
energy = zeros + 2.5
mom = mass * velocity
species_mass = mass * y
cv = make_conserved(dim,
mass=mass,
energy=energy,
momentum=mom,
species_mass=species_mass)
grad_cv = op.local_grad(discr, cv)
mu_b = 1.0
mu = 0.5
kappa = 5.0
# assemble d_alpha so that every species has a unique j
d_alpha = np.array([(ispec + 1) for ispec in range(nspecies)])
tv_model = SimpleTransport(bulk_viscosity=mu_b,
viscosity=mu,
thermal_conductivity=kappa,
species_diffusivity=d_alpha)
eos = IdealSingleGas()
gas_model = GasModel(eos=eos, transport=tv_model)
fluid_state = make_fluid_state(cv, gas_model)
from mirgecom.viscous import diffusive_flux
j = diffusive_flux(fluid_state, grad_cv)
def inf_norm(x):
return actx.to_numpy(discr.norm(x, np.inf))
tol = 1e-10
for idim in range(dim):
ispec = 2 * idim
exact_dy = np.array([((ispec + 1) * (idim * dim + 1)) * (iidim + 1)
for iidim in range(dim)])
exact_j = -massval * d_alpha[ispec] * exact_dy
assert inf_norm(j[ispec] - exact_j) < tol
exact_j = massval * d_alpha[ispec + 1] * exact_dy
assert inf_norm(j[ispec + 1] - exact_j) < tol
def test_pyrometheus_eos(ctx_factory, mechname, dim, y0, vel):
"""Test PyrometheusMixture EOS for all available mechanisms.
Tests that the PyrometheusMixture EOS gets the same thermo properties
(p, T, e) as the Pyrometheus-native mechanism code.
"""
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
nel_1d = 4
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)
order = 4
logger.info(f"Number of elements {mesh.nelements}")
discr = EagerDGDiscretization(actx, mesh, order=order)
from meshmode.dof_array import thaw
nodes = thaw(actx, discr.nodes())
# Pyrometheus initialization
mech_cti = get_mechanism_cti(mechname)
sol = cantera.Solution(phase_id="gas", source=mech_cti)
from mirgecom.thermochemistry import make_pyrometheus_mechanism_class
prometheus_mechanism = make_pyrometheus_mechanism_class(sol)(actx.np)
nspecies = prometheus_mechanism.num_species
print(f"PrometheusMixture::Mechanism = {mechname}")
print(f"PrometheusMixture::NumSpecies = {nspecies}")
press0 = 101500.0
temp0 = 300.0
y0s = np.zeros(shape=(nspecies, ))
for i in range(1, nspecies):
y0s[i] = y0 / (10.0**i)
y0s[0] = 1.0 - np.sum(y0s[1:])
velocity = vel * np.ones(shape=(dim, ))
for fac in range(1, 7):
tempin = fac * temp0
pressin = fac * press0
print(f"Testing {mechname}(t,P) = ({tempin}, {pressin})")
ones = discr.zeros(actx) + 1.0
tin = tempin * ones
pin = pressin * ones
yin = y0s * ones
tguess = 300.0
pyro_rho = prometheus_mechanism.get_density(pin, tin, yin)
pyro_e = prometheus_mechanism.get_mixture_internal_energy_mass(
tin, yin)
pyro_t = prometheus_mechanism.get_temperature(pyro_e, tguess, yin)
pyro_p = prometheus_mechanism.get_pressure(pyro_rho, pyro_t, yin)
print(f"prom(rho, y, p, t, e) = ({pyro_rho}, {y0s}, "
f"{pyro_p}, {pyro_t}, {pyro_e})")
eos = PyrometheusMixture(prometheus_mechanism)
gas_model = GasModel(eos=eos)
initializer = MixtureInitializer(dim=dim,
nspecies=nspecies,
pressure=pyro_p,
temperature=pyro_t,
massfractions=y0s,
velocity=velocity)
cv = initializer(eos=eos, t=0, x_vec=nodes)
fluid_state = make_fluid_state(cv, gas_model, temperature_seed=tguess)
p = fluid_state.pressure
temperature = fluid_state.temperature
internal_energy = eos.get_internal_energy(temperature=tin,
species_mass_fractions=yin)
y = cv.species_mass_fractions
print(f"pyro_y = {y}")
print(f"pyro_eos.p = {p}")
print(f"pyro_eos.temp = {temperature}")
print(f"pyro_eos.e = {internal_energy}")
def inf_norm(x):
return actx.to_numpy(discr.norm(x, np.inf))
tol = 1e-14
assert inf_norm((cv.mass - pyro_rho) / pyro_rho) < tol
assert inf_norm((temperature - pyro_t) / pyro_t) < tol
assert inf_norm((internal_energy - pyro_e) / pyro_e) < tol
assert inf_norm((p - pyro_p) / pyro_p) < tol
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 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 _euler_flow_stepper(actx, parameters):
logging.basicConfig(format="%(message)s", level=logging.INFO)
mesh = parameters["mesh"]
t = parameters["time"]
order = parameters["order"]
t_final = parameters["tfinal"]
initializer = parameters["initializer"]
exittol = parameters["exittol"]
casename = parameters["casename"]
boundaries = parameters["boundaries"]
eos = parameters["eos"]
cfl = parameters["cfl"]
dt = parameters["dt"]
constantcfl = parameters["constantcfl"]
nstepstatus = parameters["nstatus"]
use_overintegration = parameters["use_overintegration"]
if t_final <= t:
return(0.0)
rank = 0
dim = mesh.dim
istep = 0
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)
cv = initializer(nodes)
gas_model = GasModel(eos=eos)
fluid_state = make_fluid_state(cv, gas_model)
sdt = cfl * get_inviscid_timestep(discr, fluid_state)
initname = initializer.__class__.__name__
eosname = eos.__class__.__name__
logger.info(
f"Num {dim}d order-{order} elements: {mesh.nelements}\n"
f"Timestep: {dt}\n"
f"Final time: {t_final}\n"
f"Status freq: {nstepstatus}\n"
f"Initialization: {initname}\n"
f"EOS: {eosname}"
)
vis = make_visualizer(discr, order)
def write_soln(state, write_status=True):
dv = eos.dependent_vars(cv=state)
expected_result = initializer(nodes, t=t)
result_resid = state - expected_result
maxerr = [np.max(np.abs(result_resid[i].get())) for i in range(dim + 2)]
mindv = [np.min(dvfld.get()) for dvfld in dv]
maxdv = [np.max(dvfld.get()) for dvfld in dv]
if write_status is True:
statusmsg = (
f"Status: Step({istep}) Time({t})\n"
f"------ P({mindv[0]},{maxdv[0]})\n"
f"------ T({mindv[1]},{maxdv[1]})\n"
f"------ dt,cfl = ({dt},{cfl})\n"
f"------ Err({maxerr})"
)
logger.info(statusmsg)
io_fields = ["cv", state]
io_fields += eos.split_fields(dim, dv)
io_fields.append(("exact_soln", expected_result))
io_fields.append(("residual", result_resid))
nameform = casename + "-{iorank:04d}-{iostep:06d}.vtu"
visfilename = nameform.format(iorank=rank, iostep=istep)
vis.write_vtk_file(visfilename, io_fields)
return maxerr
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)
filter_order = 8
eta = .5
alpha = -1.0*np.log(np.finfo(float).eps)
nummodes = int(1)
for _ in range(dim):
nummodes *= int(order + dim + 1)
nummodes /= math.factorial(int(dim))
cutoff = int(eta * order)
from mirgecom.filter import (
exponential_mode_response_function as xmrfunc,
filter_modally
)
frfunc = partial(xmrfunc, alpha=alpha, filter_order=filter_order)
while t < t_final:
if constantcfl is True:
dt = sdt
else:
cfl = dt / sdt
if nstepstatus > 0:
if istep % nstepstatus == 0:
write_soln(state=cv)
cv = rk4_step(cv, t, dt, rhs)
cv = filter_modally(discr, "vol", cutoff, frfunc, cv)
t += dt
istep += 1
sdt = cfl * get_inviscid_timestep(discr, fluid_state)
if nstepstatus > 0:
logger.info("Writing final dump.")
maxerr = max(write_soln(cv, False))
else:
expected_result = initializer(nodes, time=t)
maxerr = max_component_norm(discr, cv-expected_result, np.inf)
logger.info(f"Max Error: {maxerr}")
if maxerr > exittol:
raise ValueError("Solution failed to follow expected result.")
return(maxerr)
def get_fluid_state(cv, tseed):
return make_fluid_state(cv=cv,
gas_model=gas_model,
temperature_seed=tseed)
def test_slipwall_identity(actx_factory, dim):
"""Identity test - check for the expected boundary solution.
Checks that the slipwall implements the expected boundary solution:
rho_plus = rho_minus
v_plus = v_minus - 2 * (n_hat . v_minus) * n_hat
mom_plus = rho_plus * v_plus
E_plus = E_minus
"""
actx = actx_factory()
nel_1d = 4
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)
order = 3
discr = EagerDGDiscretization(actx, mesh, order=order)
nodes = thaw(actx, discr.nodes())
eos = IdealSingleGas()
orig = np.zeros(shape=(dim, ))
nhat = thaw(actx, discr.normal(BTAG_ALL))
gas_model = GasModel(eos=eos)
logger.info(f"Number of {dim}d elems: {mesh.nelements}")
# for velocity going along each direction
for vdir in range(dim):
vel = np.zeros(shape=(dim, ))
# for velocity directions +1, and -1
for parity in [1.0, -1.0]:
vel[vdir] = parity # Check incoming normal
initializer = Lump(dim=dim, center=orig, velocity=vel, rhoamp=0.0)
wall = AdiabaticSlipBoundary()
uniform_state = initializer(nodes)
fluid_state = make_fluid_state(uniform_state, gas_model)
def bnd_norm(vec):
return actx.to_numpy(discr.norm(vec, p=np.inf, dd=BTAG_ALL))
interior_soln = \
project_fluid_state(discr, "vol", BTAG_ALL, gas_model=gas_model,
state=fluid_state)
bnd_soln = \
wall.adiabatic_slip_state(discr, btag=BTAG_ALL, gas_model=gas_model,
state_minus=interior_soln)
from grudge.trace_pair import TracePair
bnd_pair = TracePair(BTAG_ALL,
interior=interior_soln.cv,
exterior=bnd_soln.cv)
# check that mass and energy are preserved
mass_resid = bnd_pair.int.mass - bnd_pair.ext.mass
mass_err = bnd_norm(mass_resid)
assert mass_err == 0.0
energy_resid = bnd_pair.int.energy - bnd_pair.ext.energy
energy_err = bnd_norm(energy_resid)
assert energy_err == 0.0
# check that exterior momentum term is mom_interior - 2 * mom_normal
mom_norm_comp = np.dot(bnd_pair.int.momentum, nhat)
mom_norm = nhat * mom_norm_comp
expected_mom_ext = bnd_pair.int.momentum - 2.0 * mom_norm
mom_resid = bnd_pair.ext.momentum - expected_mom_ext
mom_err = bnd_norm(mom_resid)
assert mom_err == 0.0
def test_inviscid_flux_components(actx_factory, dim):
"""Test uniform pressure case.
Checks that the Euler-internal inviscid flux routine
:func:`mirgecom.inviscid.inviscid_flux` returns exactly the expected result
with a constant pressure and no flow.
Expected inviscid flux is:
F(q) = <rhoV, (E+p)V, rho(V.x.V) + pI>
Checks that only diagonal terms of the momentum flux:
[ rho(V.x.V) + pI ] are non-zero and return the correctly calculated p.
"""
actx = actx_factory()
eos = IdealSingleGas()
p0 = 1.0
nel_1d = 4
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)
order = 3
discr = EagerDGDiscretization(actx, mesh, order=order)
eos = IdealSingleGas()
logger.info(f"Number of {dim}d elems: {mesh.nelements}")
# === this next block tests 1,2,3 dimensions,
# with single and multiple nodes/states. The
# purpose of this block is to ensure that when
# all components of V = 0, the flux recovers
# the expected values (and p0 within tolerance)
# === with V = 0, fixed P = p0
tolerance = 1e-15
nodes = thaw(actx, discr.nodes())
mass = discr.zeros(actx) + np.dot(nodes, nodes) + 1.0
mom = make_obj_array([discr.zeros(actx) for _ in range(dim)])
p_exact = discr.zeros(actx) + p0
energy = p_exact / 0.4 + 0.5 * np.dot(mom, mom) / mass
cv = make_conserved(dim, mass=mass, energy=energy, momentum=mom)
p = eos.pressure(cv)
from mirgecom.gas_model import GasModel, make_fluid_state
state = make_fluid_state(cv, GasModel(eos=eos))
flux = inviscid_flux(state)
def inf_norm(x):
return actx.to_numpy(discr.norm(x, np.inf))
assert inf_norm(p - p_exact) < tolerance
logger.info(f"{dim}d flux = {flux}")
# for velocity zero, these components should be == zero
assert inf_norm(flux.mass) == 0.0
assert inf_norm(flux.energy) == 0.0
# The momentum diagonal should be p
# Off-diagonal should be identically 0
assert inf_norm(flux.momentum - p0 * np.identity(dim)) < 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_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 main(ctx_factory=cl.create_some_context, use_logmgr=True,
use_overintegration=False,
use_leap=False, use_profiling=False, casename=None,
rst_filename=None, actx_class=PyOpenCLArrayContext):
"""Drive the example."""
cl_ctx = ctx_factory()
if casename is None:
casename = "mirgecom"
from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
num_parts = comm.Get_size()
from mirgecom.simutil import global_reduce as _global_reduce
global_reduce = partial(_global_reduce, comm=comm)
logmgr = initialize_logmgr(use_logmgr,
filename=f"{casename}.sqlite", mode="wu", mpi_comm=comm)
if use_profiling:
queue = cl.CommandQueue(
cl_ctx, properties=cl.command_queue_properties.PROFILING_ENABLE)
else:
queue = cl.CommandQueue(cl_ctx)
actx = actx_class(
queue,
allocator=cl_tools.MemoryPool(cl_tools.ImmediateAllocator(queue)))
# timestepping control
current_step = 0
if use_leap:
from leap.rk import RK4MethodBuilder
timestepper = RK4MethodBuilder("state")
else:
timestepper = rk4_step
t_final = 0.1
current_cfl = 1.0
current_dt = .01
current_t = 0
constant_cfl = False
# some i/o frequencies
nstatus = 1
nrestart = 5
nviz = 10
nhealth = 1
dim = 3
rst_path = "restart_data/"
rst_pattern = (
rst_path + "{cname}-{step:04d}-{rank:04d}.pkl"
)
if rst_filename: # read the grid from restart data
rst_filename = f"{rst_filename}-{rank:04d}.pkl"
from mirgecom.restart import read_restart_data
restart_data = read_restart_data(actx, rst_filename)
local_mesh = restart_data["local_mesh"]
local_nelements = local_mesh.nelements
global_nelements = restart_data["global_nelements"]
assert restart_data["num_parts"] == num_parts
else: # generate the grid from scratch
from meshmode.mesh.generation import generate_regular_rect_mesh
box_ll = -1
box_ur = 1
nel_1d = 16
generate_mesh = partial(generate_regular_rect_mesh, a=(box_ll,)*dim,
b=(box_ur,) * dim, nelements_per_axis=(nel_1d,)*dim)
local_mesh, global_nelements = generate_and_distribute_mesh(comm,
generate_mesh)
local_nelements = local_mesh.nelements
from grudge.dof_desc import DISCR_TAG_BASE, DISCR_TAG_QUAD
from meshmode.discretization.poly_element import \
default_simplex_group_factory, QuadratureSimplexGroupFactory
order = 1
discr = EagerDGDiscretization(
actx, local_mesh,
discr_tag_to_group_factory={
DISCR_TAG_BASE: default_simplex_group_factory(
base_dim=local_mesh.dim, order=order),
DISCR_TAG_QUAD: QuadratureSimplexGroupFactory(2*order + 1)
},
mpi_communicator=comm
)
nodes = thaw(discr.nodes(), actx)
if use_overintegration:
quadrature_tag = DISCR_TAG_QUAD
else:
quadrature_tag = None
vis_timer = None
if logmgr:
logmgr_add_cl_device_info(logmgr, queue)
logmgr_add_device_memory_usage(logmgr, queue)
logmgr_add_many_discretization_quantities(logmgr, discr, dim,
extract_vars_for_logging, units_for_logging)
vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(vis_timer)
logmgr.add_watches([
("step.max", "step = {value}, "),
("t_sim.max", "sim time: {value:1.6e} s\n"),
("min_pressure", "------- P (min, max) (Pa) = ({value:1.9e}, "),
("max_pressure", "{value:1.9e})\n"),
("t_step.max", "------- step walltime: {value:6g} s, "),
("t_log.max", "log walltime: {value:6g} s")
])
eos = IdealSingleGas()
gas_model = GasModel(eos=eos)
vel = np.zeros(shape=(dim,))
orig = np.zeros(shape=(dim,))
initializer = Lump(dim=dim, center=orig, velocity=vel, rhoamp=0.0)
wall = AdiabaticSlipBoundary()
boundaries = {BTAG_ALL: wall}
uniform_state = initializer(nodes)
acoustic_pulse = AcousticPulse(dim=dim, amplitude=1.0, width=.1,
center=orig)
if rst_filename:
current_t = restart_data["t"]
current_step = restart_data["step"]
current_cv = restart_data["cv"]
if logmgr:
from mirgecom.logging_quantities import logmgr_set_time
logmgr_set_time(logmgr, current_step, current_t)
else:
# Set the current state from time 0
current_cv = acoustic_pulse(x_vec=nodes, cv=uniform_state, eos=eos)
current_state = make_fluid_state(current_cv, gas_model)
visualizer = make_visualizer(discr)
initname = "pulse"
eosname = eos.__class__.__name__
init_message = make_init_message(dim=dim, order=order,
nelements=local_nelements,
global_nelements=global_nelements,
dt=current_dt, t_final=t_final, nstatus=nstatus,
nviz=nviz, cfl=current_cfl,
constant_cfl=constant_cfl, initname=initname,
eosname=eosname, casename=casename)
if rank == 0:
logger.info(init_message)
def my_write_viz(step, t, state, dv=None):
if dv is None:
dv = eos.dependent_vars(state)
viz_fields = [("cv", state),
("dv", dv)]
from mirgecom.simutil import write_visfile
write_visfile(discr, viz_fields, visualizer, vizname=casename,
step=step, t=t, overwrite=True, vis_timer=vis_timer)
def my_write_restart(step, t, state):
rst_fname = rst_pattern.format(cname=casename, step=step, rank=rank)
if rst_fname != rst_filename:
rst_data = {
"local_mesh": local_mesh,
"cv": state,
"t": t,
"step": step,
"order": order,
"global_nelements": global_nelements,
"num_parts": num_parts
}
from mirgecom.restart import write_restart_file
write_restart_file(actx, rst_data, rst_fname, comm)
def my_health_check(pressure):
health_error = False
from mirgecom.simutil import check_naninf_local, check_range_local
if check_naninf_local(discr, "vol", pressure) \
or check_range_local(discr, "vol", pressure, .8, 1.5):
health_error = True
logger.info(f"{rank=}: Invalid pressure data found.")
return health_error
def my_pre_step(step, t, dt, state):
fluid_state = make_fluid_state(state, gas_model)
dv = fluid_state.dv
try:
if logmgr:
logmgr.tick_before()
from mirgecom.simutil import check_step
do_viz = check_step(step=step, interval=nviz)
do_restart = check_step(step=step, interval=nrestart)
do_health = check_step(step=step, interval=nhealth)
if do_health:
health_errors = global_reduce(my_health_check(dv.pressure), op="lor")
if health_errors:
if rank == 0:
logger.info("Fluid solution failed health check.")
raise MyRuntimeError("Failed simulation health check.")
if do_restart:
my_write_restart(step=step, t=t, state=state)
if do_viz:
my_write_viz(step=step, t=t, state=state, dv=dv)
except MyRuntimeError:
if rank == 0:
logger.info("Errors detected; attempting graceful exit.")
my_write_viz(step=step, t=t, state=state)
my_write_restart(step=step, t=t, state=state)
raise
dt = get_sim_timestep(discr, fluid_state, t, dt, current_cfl, t_final,
constant_cfl)
return state, dt
def my_post_step(step, t, dt, state):
# Logmgr needs to know about EOS, dt, dim?
# imo this is a design/scope flaw
if logmgr:
set_dt(logmgr, dt)
set_sim_state(logmgr, dim, state, eos)
logmgr.tick_after()
return state, dt
def my_rhs(t, state):
fluid_state = make_fluid_state(cv=state, gas_model=gas_model)
return euler_operator(discr, state=fluid_state, time=t,
boundaries=boundaries,
gas_model=gas_model,
quadrature_tag=quadrature_tag)
current_dt = get_sim_timestep(discr, current_state, current_t, current_dt,
current_cfl, t_final, constant_cfl)
current_step, current_t, current_cv = \
advance_state(rhs=my_rhs, timestepper=timestepper,
pre_step_callback=my_pre_step,
post_step_callback=my_post_step, dt=current_dt,
state=current_cv, t=current_t, t_final=t_final)
# Dump the final data
if rank == 0:
logger.info("Checkpointing final state ...")
final_state = make_fluid_state(current_cv, gas_model)
final_dv = final_state.dv
my_write_viz(step=current_step, t=current_t, state=current_cv, dv=final_dv)
my_write_restart(step=current_step, t=current_t, state=current_cv)
if logmgr:
logmgr.close()
elif use_profiling:
print(actx.tabulate_profiling_data())
finish_tol = 1e-16
assert np.abs(current_t - t_final) < finish_tol
def main(ctx_factory=cl.create_some_context, use_logmgr=True,
use_leap=False, use_profiling=False, casename=None,
rst_filename=None, actx_class=PyOpenCLArrayContext,
log_dependent=True):
"""Drive example."""
cl_ctx = ctx_factory()
if casename is None:
casename = "mirgecom"
from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
nparts = comm.Get_size()
from mirgecom.simutil import global_reduce as _global_reduce
global_reduce = partial(_global_reduce, comm=comm)
logmgr = initialize_logmgr(use_logmgr,
filename=f"{casename}.sqlite", mode="wu", mpi_comm=comm)
if use_profiling:
queue = cl.CommandQueue(
cl_ctx, properties=cl.command_queue_properties.PROFILING_ENABLE)
else:
queue = cl.CommandQueue(cl_ctx)
actx = actx_class(
queue,
allocator=cl_tools.MemoryPool(cl_tools.ImmediateAllocator(queue)))
# timestepping control
if use_leap:
from leap.rk import RK4MethodBuilder
timestepper = RK4MethodBuilder("state")
else:
timestepper = rk4_step
t_final = 1e-8
current_cfl = 1.0
current_dt = 1e-9
current_t = 0
current_step = 0
constant_cfl = False
# some i/o frequencies
nstatus = 1
nhealth = 1
nrestart = 5
nviz = 1
dim = 2
rst_path = "restart_data/"
rst_pattern = (
rst_path + "{cname}-{step:04d}-{rank:04d}.pkl"
)
if rst_filename: # read the grid from restart data
rst_filename = f"{rst_filename}-{rank:04d}.pkl"
from mirgecom.restart import read_restart_data
restart_data = read_restart_data(actx, rst_filename)
local_mesh = restart_data["local_mesh"]
local_nelements = local_mesh.nelements
global_nelements = restart_data["global_nelements"]
assert restart_data["num_parts"] == nparts
else: # generate the grid from scratch
nel_1d = 16
box_ll = -5.0
box_ur = 5.0
from meshmode.mesh.generation import generate_regular_rect_mesh
generate_mesh = partial(generate_regular_rect_mesh, a=(box_ll,)*dim,
b=(box_ur,) * dim, nelements_per_axis=(nel_1d,)*dim)
local_mesh, global_nelements = generate_and_distribute_mesh(comm,
generate_mesh)
local_nelements = local_mesh.nelements
order = 3
discr = EagerDGDiscretization(
actx, local_mesh, order=order, mpi_communicator=comm
)
nodes = thaw(discr.nodes(), actx)
vis_timer = None
if logmgr:
logmgr_add_device_name(logmgr, queue)
logmgr_add_device_memory_usage(logmgr, queue)
vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(vis_timer)
logmgr.add_watches([
("step.max", "step = {value}, "),
("t_sim.max", "sim time: {value:1.6e} s\n"),
("t_step.max", "------- step walltime: {value:6g} s, "),
("t_log.max", "log walltime: {value:6g} s")
])
if log_dependent:
logmgr_add_many_discretization_quantities(logmgr, discr, dim,
extract_vars_for_logging,
units_for_logging)
logmgr.add_watches([
("min_pressure", "\n------- P (min, max) (Pa) = ({value:1.9e}, "),
("max_pressure", "{value:1.9e})\n"),
("min_temperature", "------- T (min, max) (K) = ({value:7g}, "),
("max_temperature", "{value:7g})\n")])
# Pyrometheus initialization
from mirgecom.mechanisms import get_mechanism_cti
mech_cti = get_mechanism_cti("uiuc")
sol = cantera.Solution(phase_id="gas", source=mech_cti)
from mirgecom.thermochemistry import make_pyrometheus_mechanism_class
pyrometheus_mechanism = make_pyrometheus_mechanism_class(sol)(actx.np)
nspecies = pyrometheus_mechanism.num_species
eos = PyrometheusMixture(pyrometheus_mechanism)
from mirgecom.gas_model import GasModel, make_fluid_state
gas_model = GasModel(eos=eos)
from pytools.obj_array import make_obj_array
y0s = np.zeros(shape=(nspecies,))
for i in range(nspecies-1):
y0s[i] = 1.0 / (10.0 ** (i + 1))
spec_sum = sum([y0s[i] for i in range(nspecies-1)])
y0s[nspecies-1] = 1.0 - spec_sum
# Mixture defaults to STP (p, T) = (1atm, 300K)
velocity = np.zeros(shape=(dim,)) + 1.0
initializer = MixtureInitializer(dim=dim, nspecies=nspecies,
massfractions=y0s, velocity=velocity)
def boundary_solution(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(initializer(x_vec=nodes, eos=gas_model.eos,
**kwargs), gas_model,
temperature_seed=state_minus.temperature)
boundaries = {
BTAG_ALL: PrescribedFluidBoundary(boundary_state_func=boundary_solution)
}
if rst_filename:
current_t = restart_data["t"]
current_step = restart_data["step"]
current_cv = restart_data["cv"]
tseed = restart_data["temperature_seed"]
if logmgr:
from mirgecom.logging_quantities import logmgr_set_time
logmgr_set_time(logmgr, current_step, current_t)
else:
# Set the current state from time 0
current_cv = initializer(x_vec=nodes, eos=eos)
tseed = 300.0
current_state = make_fluid_state(current_cv, gas_model, temperature_seed=tseed)
visualizer = make_visualizer(discr)
initname = initializer.__class__.__name__
eosname = eos.__class__.__name__
init_message = make_init_message(dim=dim, order=order,
nelements=local_nelements,
global_nelements=global_nelements,
dt=current_dt, t_final=t_final, nstatus=nstatus,
nviz=nviz, cfl=current_cfl,
constant_cfl=constant_cfl, initname=initname,
eosname=eosname, casename=casename)
if rank == 0:
logger.info(init_message)
def my_write_status(component_errors, dv=None):
from mirgecom.simutil import allsync
status_msg = (
"------- errors="
+ ", ".join("%.3g" % en for en in component_errors))
if ((dv is not None) and (not log_dependent)):
temp = dv.temperature
press = dv.pressure
from grudge.op import nodal_min_loc, nodal_max_loc
tmin = allsync(actx.to_numpy(nodal_min_loc(discr, "vol", temp)),
comm=comm, op=MPI.MIN)
tmax = allsync(actx.to_numpy(nodal_max_loc(discr, "vol", temp)),
comm=comm, op=MPI.MAX)
pmin = allsync(actx.to_numpy(nodal_min_loc(discr, "vol", press)),
comm=comm, op=MPI.MIN)
pmax = allsync(actx.to_numpy(nodal_max_loc(discr, "vol", press)),
comm=comm, op=MPI.MAX)
dv_status_msg = f"\nP({pmin}, {pmax}), T({tmin}, {tmax})"
status_msg = status_msg + dv_status_msg
if rank == 0:
logger.info(status_msg)
if rank == 0:
logger.info(status_msg)
def my_write_viz(step, t, state, dv, exact=None, resid=None):
if exact is None:
exact = initializer(x_vec=nodes, eos=eos, time=t)
if resid is None:
resid = state - exact
viz_fields = [("cv", state), ("dv", dv)]
from mirgecom.simutil import write_visfile
write_visfile(discr, viz_fields, visualizer, vizname=casename,
step=step, t=t, overwrite=True, vis_timer=vis_timer)
def my_write_restart(step, t, state, tseed):
rst_fname = rst_pattern.format(cname=casename, step=step, rank=rank)
if rst_fname != rst_filename:
rst_data = {
"local_mesh": local_mesh,
"cv": state,
"temperature_seed": tseed,
"t": t,
"step": step,
"order": order,
"global_nelements": global_nelements,
"num_parts": nparts
}
from mirgecom.restart import write_restart_file
write_restart_file(actx, rst_data, rst_fname, comm)
def my_health_check(dv, component_errors):
health_error = False
from mirgecom.simutil import check_naninf_local, check_range_local
if check_naninf_local(discr, "vol", dv.pressure) \
or check_range_local(discr, "vol", dv.pressure, 1e5, 1.1e5):
health_error = True
logger.info(f"{rank=}: Invalid pressure data found.")
exittol = .09
if max(component_errors) > exittol:
health_error = True
if rank == 0:
logger.info("Solution diverged from exact soln.")
return health_error
def my_pre_step(step, t, dt, state):
cv, tseed = state
fluid_state = make_fluid_state(cv, gas_model, temperature_seed=tseed)
dv = fluid_state.dv
try:
exact = None
component_errors = None
if logmgr:
logmgr.tick_before()
from mirgecom.simutil import check_step
do_viz = check_step(step=step, interval=nviz)
do_restart = check_step(step=step, interval=nrestart)
do_health = check_step(step=step, interval=nhealth)
do_status = check_step(step=step, interval=nstatus)
if do_health:
exact = initializer(x_vec=nodes, eos=eos, time=t)
from mirgecom.simutil import compare_fluid_solutions
component_errors = compare_fluid_solutions(discr, cv, exact)
health_errors = global_reduce(
my_health_check(dv, component_errors), op="lor")
if health_errors:
if rank == 0:
logger.info("Fluid solution failed health check.")
raise MyRuntimeError("Failed simulation health check.")
if do_restart:
my_write_restart(step=step, t=t, state=cv, tseed=tseed)
if do_viz:
if exact is None:
exact = initializer(x_vec=nodes, eos=eos, time=t)
resid = state - exact
my_write_viz(step=step, t=t, state=cv, dv=dv, exact=exact,
resid=resid)
if do_status:
if component_errors is None:
if exact is None:
exact = initializer(x_vec=nodes, eos=eos, time=t)
from mirgecom.simutil import compare_fluid_solutions
component_errors = compare_fluid_solutions(discr, cv, exact)
my_write_status(component_errors, dv=dv)
except MyRuntimeError:
if rank == 0:
logger.info("Errors detected; attempting graceful exit.")
my_write_viz(step=step, t=t, state=cv, dv=dv)
my_write_restart(step=step, t=t, state=cv, tseed=tseed)
raise
dt = get_sim_timestep(discr, fluid_state, t, dt, current_cfl, t_final,
constant_cfl)
return state, dt
def my_post_step(step, t, dt, state):
cv, tseed = state
fluid_state = make_fluid_state(cv, gas_model, temperature_seed=tseed)
tseed = fluid_state.temperature
# Logmgr needs to know about EOS, dt, dim?
# imo this is a design/scope flaw
if logmgr:
set_dt(logmgr, dt)
set_sim_state(logmgr, dim, cv, eos)
logmgr.tick_after()
return make_obj_array([fluid_state.cv, tseed]), dt
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])
current_dt = get_sim_timestep(discr, current_state, current_t, current_dt,
current_cfl, t_final, constant_cfl)
current_step, current_t, advanced_state = \
advance_state(rhs=my_rhs, timestepper=timestepper,
pre_step_callback=my_pre_step,
post_step_callback=my_post_step, dt=current_dt,
state=make_obj_array([current_state.cv,
current_state.temperature]),
t=current_t, t_final=t_final, eos=eos, dim=dim)
# Dump the final data
if rank == 0:
logger.info("Checkpointing final state ...")
current_cv, tseed = advanced_state
current_state = make_fluid_state(current_cv, gas_model, temperature_seed=tseed)
final_dv = current_state.dv
final_exact = initializer(x_vec=nodes, eos=eos, time=current_t)
final_resid = current_state.cv - final_exact
my_write_viz(step=current_step, t=current_t, state=current_cv, dv=final_dv,
exact=final_exact, resid=final_resid)
my_write_restart(step=current_step, t=current_t, state=current_state.cv,
tseed=tseed)
if logmgr:
logmgr.close()
elif use_profiling:
print(actx.tabulate_profiling_data())
finish_tol = 1e-16
assert np.abs(current_t - t_final) < finish_tol
def main(ctx_factory=cl.create_some_context,
use_logmgr=True,
use_leap=False,
use_profiling=False,
casename=None,
rst_filename=None,
actx_class=PyOpenCLArrayContext):
"""Drive the example."""
cl_ctx = ctx_factory()
if casename is None:
casename = "mirgecom"
from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
num_parts = comm.Get_size()
from mirgecom.simutil import global_reduce as _global_reduce
global_reduce = partial(_global_reduce, comm=comm)
logmgr = initialize_logmgr(use_logmgr,
filename=f"{casename}.sqlite",
mode="wu",
mpi_comm=comm)
if use_profiling:
queue = cl.CommandQueue(
cl_ctx, properties=cl.command_queue_properties.PROFILING_ENABLE)
else:
queue = cl.CommandQueue(cl_ctx)
actx = actx_class(queue,
allocator=cl_tools.MemoryPool(
cl_tools.ImmediateAllocator(queue)))
# timestepping control
current_step = 0
if use_leap:
from leap.rk import RK4MethodBuilder
timestepper = RK4MethodBuilder("state")
else:
timestepper = rk4_step
t_final = 0.01
current_cfl = 1.0
current_dt = .001
current_t = 0
constant_cfl = False
# some i/o frequencies
nrestart = 10
nstatus = 1
nviz = 10
nhealth = 10
dim = 2
if dim != 2:
raise ValueError("This example must be run with dim = 2.")
rst_path = "restart_data/"
rst_pattern = (rst_path + "{cname}-{step:04d}-{rank:04d}.pkl")
if rst_filename: # read the grid from restart data
rst_filename = f"{rst_filename}-{rank:04d}.pkl"
from mirgecom.restart import read_restart_data
restart_data = read_restart_data(actx, rst_filename)
local_mesh = restart_data["local_mesh"]
local_nelements = local_mesh.nelements
global_nelements = restart_data["global_nelements"]
assert restart_data["num_parts"] == num_parts
else: # generate the grid from scratch
nel_1d = 16
box_ll = -5.0
box_ur = 5.0
from meshmode.mesh.generation import generate_regular_rect_mesh
generate_mesh = partial(generate_regular_rect_mesh,
a=(box_ll, ) * dim,
b=(box_ur, ) * dim,
nelements_per_axis=(nel_1d, ) * dim)
local_mesh, global_nelements = generate_and_distribute_mesh(
comm, generate_mesh)
local_nelements = local_mesh.nelements
order = 3
discr = EagerDGDiscretization(actx,
local_mesh,
order=order,
mpi_communicator=comm)
nodes = thaw(discr.nodes(), actx)
vis_timer = None
if logmgr:
logmgr_add_device_name(logmgr, queue)
logmgr_add_device_memory_usage(logmgr, queue)
logmgr_add_many_discretization_quantities(logmgr, discr, dim,
extract_vars_for_logging,
units_for_logging)
vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(vis_timer)
logmgr.add_watches([
("step.max", "step = {value}, "),
("t_sim.max", "sim time: {value:1.6e} s\n"),
("min_pressure", "------- P (min, max) (Pa) = ({value:1.9e}, "),
("max_pressure", "{value:1.9e})\n"),
("t_step.max", "------- step walltime: {value:6g} s, "),
("t_log.max", "log walltime: {value:6g} s")
])
try:
logmgr.add_watches(
["memory_usage_python.max", "memory_usage_gpu.max"])
except KeyError:
pass
if use_profiling:
logmgr.add_watches(["multiply_time.max"])
# soln setup and init
eos = IdealSingleGas()
vel = np.zeros(shape=(dim, ))
orig = np.zeros(shape=(dim, ))
vel[:dim] = 1.0
initializer = Vortex2D(center=orig, velocity=vel)
gas_model = GasModel(eos=eos)
def boundary_solution(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(
initializer(x_vec=nodes, eos=gas_model.eos, **kwargs), gas_model)
boundaries = {
BTAG_ALL:
PrescribedFluidBoundary(boundary_state_func=boundary_solution)
}
if rst_filename:
current_t = restart_data["t"]
current_step = restart_data["step"]
current_cv = restart_data["cv"]
if logmgr:
from mirgecom.logging_quantities import logmgr_set_time
logmgr_set_time(logmgr, current_step, current_t)
else:
# Set the current state from time 0
current_cv = initializer(nodes)
current_state = make_fluid_state(current_cv, gas_model)
visualizer = make_visualizer(discr)
initname = initializer.__class__.__name__
eosname = eos.__class__.__name__
init_message = make_init_message(dim=dim,
order=order,
nelements=local_nelements,
global_nelements=global_nelements,
dt=current_dt,
t_final=t_final,
nstatus=nstatus,
nviz=nviz,
cfl=current_cfl,
constant_cfl=constant_cfl,
initname=initname,
eosname=eosname,
casename=casename)
if rank == 0:
logger.info(init_message)
def my_write_status(state, component_errors, cfl=None):
if cfl is None:
if constant_cfl:
cfl = current_cfl
else:
from grudge.op import nodal_max
from mirgecom.inviscid import get_inviscid_cfl
cfl = actx.to_numpy(
nodal_max(discr, "vol",
get_inviscid_cfl(discr, state, current_dt)))[()]
if rank == 0:
logger.info(f"------ {cfl=}\n"
"------- errors=" +
", ".join("%.3g" % en for en in component_errors))
def my_write_viz(step, t, state, dv=None, exact=None, resid=None):
if exact is None:
exact = initializer(x_vec=nodes, eos=eos, time=t)
if resid is None:
resid = state - exact
viz_fields = [("cv", state), ("dv", dv), ("exact", exact),
("residual", resid)]
from mirgecom.simutil import write_visfile
write_visfile(discr,
viz_fields,
visualizer,
vizname=casename,
step=step,
t=t,
overwrite=True,
vis_timer=vis_timer)
def my_write_restart(step, t, state):
rst_fname = rst_pattern.format(cname=casename, step=step, rank=rank)
if rst_fname != rst_filename:
rst_data = {
"local_mesh": local_mesh,
"cv": state,
"t": t,
"step": step,
"order": order,
"global_nelements": global_nelements,
"num_parts": num_parts
}
from mirgecom.restart import write_restart_file
write_restart_file(actx, rst_data, rst_fname, comm)
def my_health_check(pressure, component_errors):
health_error = False
from mirgecom.simutil import check_naninf_local, check_range_local
if check_naninf_local(discr, "vol", pressure) \
or check_range_local(discr, "vol", pressure, .2, 1.02):
health_error = True
logger.info(f"{rank=}: Invalid pressure data found.")
exittol = .1
if max(component_errors) > exittol:
health_error = True
if rank == 0:
logger.info("Solution diverged from exact soln.")
return health_error
def my_pre_step(step, t, dt, state):
fluid_state = make_fluid_state(state, gas_model)
cv = fluid_state.cv
dv = fluid_state.dv
try:
exact = None
component_errors = None
if logmgr:
logmgr.tick_before()
do_viz = check_step(step=step, interval=nviz)
do_restart = check_step(step=step, interval=nrestart)
do_health = check_step(step=step, interval=nhealth)
do_status = check_step(step=step, interval=nstatus)
if do_health:
exact = initializer(x_vec=nodes, eos=eos, time=t)
from mirgecom.simutil import compare_fluid_solutions
component_errors = compare_fluid_solutions(discr, cv, exact)
health_errors = global_reduce(my_health_check(
dv.pressure, component_errors),
op="lor")
if health_errors:
if rank == 0:
logger.info("Fluid solution failed health check.")
raise MyRuntimeError("Failed simulation health check.")
if do_restart:
my_write_restart(step=step, t=t, state=cv)
if do_status:
if component_errors is None:
if exact is None:
exact = initializer(x_vec=nodes, eos=eos, time=t)
from mirgecom.simutil import compare_fluid_solutions
component_errors = compare_fluid_solutions(
discr, cv, exact)
my_write_status(fluid_state, component_errors)
if do_viz:
if exact is None:
exact = initializer(x_vec=nodes, eos=eos, time=t)
resid = state - exact
my_write_viz(step=step,
t=t,
state=cv,
dv=dv,
exact=exact,
resid=resid)
except MyRuntimeError:
if rank == 0:
logger.info("Errors detected; attempting graceful exit.")
my_write_viz(step=step, t=t, state=cv)
my_write_restart(step=step, t=t, state=cv)
raise
dt = get_sim_timestep(discr, fluid_state, t, dt, current_cfl, t_final,
constant_cfl)
return state, dt
def my_post_step(step, t, dt, state):
# Logmgr needs to know about EOS, dt, dim?
# imo this is a design/scope flaw
if logmgr:
set_dt(logmgr, dt)
set_sim_state(logmgr, dim, state, eos)
logmgr.tick_after()
return state, dt
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)
current_dt = get_sim_timestep(discr, current_state, current_t, current_dt,
current_cfl, t_final, constant_cfl)
current_step, current_t, current_cv = \
advance_state(rhs=my_rhs, timestepper=timestepper,
pre_step_callback=my_pre_step,
post_step_callback=my_post_step, dt=current_dt,
state=current_state.cv, t=current_t, t_final=t_final)
# Dump the final data
if rank == 0:
logger.info("Checkpointing final state ...")
current_state = make_fluid_state(current_cv, gas_model)
final_dv = current_state.dv
final_exact = initializer(x_vec=nodes, eos=eos, time=current_t)
final_resid = current_state.cv - final_exact
my_write_viz(step=current_step,
t=current_t,
state=current_state.cv,
dv=final_dv,
exact=final_exact,
resid=final_resid)
my_write_restart(step=current_step, t=current_t, state=current_state.cv)
if logmgr:
logmgr.close()
elif use_profiling:
print(actx.tabulate_profiling_data())
finish_tol = 1e-16
assert np.abs(current_t - t_final) < finish_tol
def test_slipwall_flux(actx_factory, dim, order):
"""Check for zero boundary flux.
Check for vanishing flux across the slipwall.
"""
actx = actx_factory()
wall = AdiabaticSlipBoundary()
eos = IdealSingleGas()
gas_model = GasModel(eos=eos)
from pytools.convergence import EOCRecorder
eoc = EOCRecorder()
for nel_1d in [4, 8, 12]:
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)
discr = EagerDGDiscretization(actx, mesh, order=order)
nodes = thaw(actx, discr.nodes())
nhat = thaw(actx, discr.normal(BTAG_ALL))
h = 1.0 / nel_1d
def bnd_norm(vec):
return actx.to_numpy(discr.norm(vec, p=np.inf, dd=BTAG_ALL))
logger.info(f"Number of {dim}d elems: {mesh.nelements}")
# for velocities in each direction
err_max = 0.0
for vdir in range(dim):
vel = np.zeros(shape=(dim, ))
# for velocity directions +1, and -1
for parity in [1.0, -1.0]:
vel[vdir] = parity
from mirgecom.initializers import Uniform
initializer = Uniform(dim=dim, velocity=vel)
uniform_state = initializer(nodes)
fluid_state = make_fluid_state(uniform_state, gas_model)
interior_soln = project_fluid_state(discr,
"vol",
BTAG_ALL,
state=fluid_state,
gas_model=gas_model)
bnd_soln = wall.adiabatic_slip_state(discr,
btag=BTAG_ALL,
gas_model=gas_model,
state_minus=interior_soln)
from grudge.trace_pair import TracePair
bnd_pair = TracePair(BTAG_ALL,
interior=interior_soln.cv,
exterior=bnd_soln.cv)
state_pair = TracePair(BTAG_ALL,
interior=interior_soln,
exterior=bnd_soln)
# Check the total velocity component normal
# to each surface. It should be zero. The
# numerical fluxes cannot be zero.
avg_state = 0.5 * (bnd_pair.int + bnd_pair.ext)
err_max = max(err_max,
bnd_norm(np.dot(avg_state.momentum, nhat)))
from mirgecom.inviscid import inviscid_facial_flux
bnd_flux = inviscid_facial_flux(discr, state_pair, local=True)
err_max = max(err_max, bnd_norm(bnd_flux.mass),
bnd_norm(bnd_flux.energy))
eoc.add_data_point(h, err_max)
message = (f"EOC:\n{eoc}")
logger.info(message)
assert (eoc.order_estimate() >= order - 0.5 or eoc.max_error() < 1e-12)
