def rhs(t, u):
return (diffusion_operator(discr,
quad_tag=DISCR_TAG_BASE,
alpha=1,
boundaries=boundaries,
u=u) +
actx.np.exp(-np.dot(nodes, nodes) / source_width**2))
def get_rhs(t, u):
return (
diffusion_operator(discr,
quad_tag=discr_tag,
alpha=alpha,
boundaries=p.get_boundaries(discr, actx, t),
u=u) + sym_eval(sym_f, t))
def get_rhs(t, u):
result = (
diffusion_operator(discr,
alpha=p.alpha,
boundaries=p.get_boundaries(discr, actx, t),
u=u) + sym_eval(sym_f, t))
return result
def get_rhs(t, u):
alpha = p.get_alpha(nodes, t, u)
if isinstance(alpha, DOFArray):
discr_tag = DISCR_TAG_QUAD
else:
discr_tag = DISCR_TAG_BASE
return (
diffusion_operator(discr,
quad_tag=discr_tag,
alpha=alpha,
boundaries=p.get_boundaries(discr, actx, t),
u=u) + _sym_eval(sym_f, x=nodes, t=t))
def op(alpha, u):
return diffusion_operator(
discr, DISCR_TAG_BASE, alpha, boundaries, u)
def test_diffusion_obj_array_vectorize(actx_factory):
"""
Checks that the diffusion operator can be called with either scalars or object
arrays for `u`.
"""
actx = actx_factory()
p = get_decaying_trig(1, 2.)
assert isinstance(p.sym_alpha, Number)
sym_u1 = p.sym_u
sym_u2 = 2 * p.sym_u
sym_diffusion_u1 = sym_diffusion(p.dim, p.sym_alpha, sym_u1)
sym_diffusion_u2 = sym_diffusion(p.dim, p.sym_alpha, sym_u2)
n = 128
mesh = p.get_mesh(n)
from grudge.eager import EagerDGDiscretization
discr = EagerDGDiscretization(actx, mesh, order=4)
nodes = thaw(actx, discr.nodes())
t = 1.23456789
def sym_eval(expr):
return sym.EvaluationMapper({"x": nodes, "t": t})(expr)
alpha = sym_eval(p.sym_alpha)
u1 = sym_eval(sym_u1)
u2 = sym_eval(sym_u2)
boundaries = p.get_boundaries(discr, actx, t)
diffusion_u1 = diffusion_operator(discr,
quad_tag=DISCR_TAG_BASE,
alpha=alpha,
boundaries=boundaries,
u=u1)
assert isinstance(diffusion_u1, DOFArray)
expected_diffusion_u1 = sym_eval(sym_diffusion_u1)
rel_linf_err = (discr.norm(diffusion_u1 - expected_diffusion_u1, np.inf) /
discr.norm(expected_diffusion_u1, np.inf))
assert rel_linf_err < 1.e-5
boundaries_vector = [boundaries, boundaries]
u_vector = make_obj_array([u1, u2])
diffusion_u_vector = diffusion_operator(discr,
quad_tag=DISCR_TAG_BASE,
alpha=alpha,
boundaries=boundaries_vector,
u=u_vector)
assert isinstance(diffusion_u_vector, np.ndarray)
assert diffusion_u_vector.shape == (2, )
expected_diffusion_u_vector = make_obj_array(
[sym_eval(sym_diffusion_u1),
sym_eval(sym_diffusion_u2)])
rel_linf_err = (
discr.norm(diffusion_u_vector - expected_diffusion_u_vector, np.inf) /
discr.norm(expected_diffusion_u_vector, np.inf))
assert rel_linf_err < 1.e-5
def test_diffusion_compare_to_nodal_dg(actx_factory,
problem,
order,
print_err=False):
"""Compares diffusion operator to Hesthaven/Warburton Nodal-DG code."""
pytest.importorskip("oct2py")
actx = actx_factory()
p = problem
assert p.dim == 1
assert p.sym_alpha == 1.
from meshmode.interop.nodal_dg import download_nodal_dg_if_not_present
download_nodal_dg_if_not_present()
sym_diffusion_u = sym_diffusion(p.dim, p.sym_alpha, p.sym_u)
for n in [4, 8, 16, 32, 64]:
mesh = p.get_mesh(n)
from meshmode.interop.nodal_dg import NodalDGContext
with NodalDGContext("./nodal-dg/Codes1.1") as ndgctx:
ndgctx.set_mesh(mesh, order=order)
t = 1.23456789
from grudge.eager import EagerDGDiscretization
discr_mirgecom = EagerDGDiscretization(actx, mesh, order=order)
nodes_mirgecom = thaw(actx, discr_mirgecom.nodes())
def sym_eval_mirgecom(expr):
return sym.EvaluationMapper({
"x": nodes_mirgecom,
"t": t
})(expr)
u_mirgecom = sym_eval_mirgecom(p.sym_u)
diffusion_u_mirgecom = diffusion_operator(
discr_mirgecom,
quad_tag=DISCR_TAG_BASE,
alpha=discr_mirgecom.zeros(actx) + 1.,
boundaries=p.get_boundaries(discr_mirgecom, actx, t),
u=u_mirgecom)
discr_ndg = ndgctx.get_discr(actx)
nodes_ndg = thaw(actx, discr_ndg.nodes())
def sym_eval_ndg(expr):
return sym.EvaluationMapper({"x": nodes_ndg, "t": t})(expr)
u_ndg = sym_eval_ndg(p.sym_u)
ndgctx.push_dof_array("u", u_ndg)
ndgctx.octave.push("t", t)
ndgctx.octave.eval("[rhs] = HeatCRHS1D(u,t)", verbose=False)
diffusion_u_ndg = ndgctx.pull_dof_array(actx, "rhs")
def inf_norm(f):
return actx.np.linalg.norm(f, np.inf)
err = (inf_norm(diffusion_u_mirgecom - diffusion_u_ndg) /
inf_norm(diffusion_u_ndg))
if print_err:
diffusion_u_exact = sym_eval_mirgecom(sym_diffusion_u)
err_exact = (
inf_norm(diffusion_u_mirgecom - diffusion_u_exact) /
inf_norm(diffusion_u_exact))
print(err, err_exact)
assert err < 1e-9
def get_rhs(t, u):
return diffusion_operator(discr,
quad_tag=DISCR_TAG_BASE,
alpha=alpha,
boundaries=boundaries,
u=u)
def test_diffusion_obj_array_vectorize(actx_factory):
"""
Checks that the diffusion operator can be called with either scalars or object
arrays for `u`.
"""
actx = actx_factory()
p = DecayingTrig(1, 2.)
sym_x = pmbl.make_sym_vector("x", p.dim)
sym_t = pmbl.var("t")
def get_u1(x, t):
return p.get_solution(x, t)
def get_u2(x, t):
return 2 * p.get_solution(x, t)
sym_u1 = get_u1(sym_x, sym_t)
sym_u2 = get_u2(sym_x, sym_t)
sym_alpha1 = p.get_alpha(sym_x, sym_t, sym_u1)
sym_alpha2 = p.get_alpha(sym_x, sym_t, sym_u2)
assert isinstance(sym_alpha1, Number)
assert isinstance(sym_alpha2, Number)
alpha = sym_alpha1
sym_diffusion_u1 = sym_diffusion(p.dim, alpha, sym_u1)
sym_diffusion_u2 = sym_diffusion(p.dim, alpha, sym_u2)
n = 128
mesh = p.get_mesh(n)
from grudge.eager import EagerDGDiscretization
discr = EagerDGDiscretization(actx, mesh, order=4)
nodes = thaw(actx, discr.nodes())
t = 1.23456789
u1 = get_u1(nodes, t)
u2 = get_u2(nodes, t)
alpha = p.get_alpha(nodes, t, u1)
boundaries = p.get_boundaries(discr, actx, t)
diffusion_u1 = diffusion_operator(discr,
quad_tag=DISCR_TAG_BASE,
alpha=alpha,
boundaries=boundaries,
u=u1)
assert isinstance(diffusion_u1, DOFArray)
expected_diffusion_u1 = _sym_eval(sym_diffusion_u1, x=nodes, t=t)
rel_linf_err = actx.to_numpy(
discr.norm(diffusion_u1 - expected_diffusion_u1, np.inf) /
discr.norm(expected_diffusion_u1, np.inf))
assert rel_linf_err < 1.e-5
boundaries_vector = [boundaries, boundaries]
u_vector = make_obj_array([u1, u2])
diffusion_u_vector = diffusion_operator(discr,
quad_tag=DISCR_TAG_BASE,
alpha=alpha,
boundaries=boundaries_vector,
u=u_vector)
assert isinstance(diffusion_u_vector, np.ndarray)
assert diffusion_u_vector.shape == (2, )
expected_diffusion_u_vector = make_obj_array([
_sym_eval(sym_diffusion_u1, x=nodes, t=t),
_sym_eval(sym_diffusion_u2, x=nodes, t=t)
])
rel_linf_err = actx.to_numpy(
discr.norm(diffusion_u_vector - expected_diffusion_u_vector, np.inf) /
discr.norm(expected_diffusion_u_vector, np.inf))
assert rel_linf_err < 1.e-5
