Update diffusion operator, examples, and tests

examples/heat-source-mpi.py

@@ -31,9 +31,8 @@
 from meshmode.mesh import BTAG_ALL, BTAG_NONE  # noqa
 
 from grudge.eager import EagerDGDiscretization
-from grudge import sym as grudge_sym
 from grudge.shortcuts import make_visualizer
-from grudge.dof_desc import QTAG_NONE
+from grudge.dof_desc import DISCR_TAG_BASE, DTAG_BOUNDARY
 from mirgecom.integrators import rk4_step
 from mirgecom.diffusion import (
     diffusion_operator,
@@ -99,17 +98,19 @@ def main():
     nodes = thaw(actx, discr.nodes())
 
     boundaries = {
-        grudge_sym.DTAG_BOUNDARY("dirichlet"): DirichletDiffusionBoundary(0.),
-        grudge_sym.DTAG_BOUNDARY("neumann"): NeumannDiffusionBoundary(0.)
+        DTAG_BOUNDARY("dirichlet"): DirichletDiffusionBoundary(0.),
+        DTAG_BOUNDARY("neumann"): NeumannDiffusionBoundary(0.)
     }
 
     u = discr.zeros(actx)
 
     vis = make_visualizer(discr)
 
     def rhs(t, u):
-        return (diffusion_operator(
-            discr, quad_tag=QTAG_NONE, alpha=1, boundaries=boundaries, u=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))
 
     rank = comm.Get_rank()

mirgecom/diffusion.py

@@ -48,7 +48,7 @@ def gradient_flux(discr, quad_tag, u_tpair):
     actx = u_tpair.int.array_context
 
     dd = u_tpair.dd
-    dd_quad = dd.with_qtag(quad_tag)
+    dd_quad = dd.with_discr_tag(quad_tag)
     dd_allfaces_quad = dd_quad.with_dtag("all_faces")
 
     normal_quad = thaw(actx, discr.normal(dd_quad))
@@ -68,7 +68,7 @@ def diffusion_flux(discr, quad_tag, alpha_tpair, grad_u_tpair):
     actx = grad_u_tpair.int[0].array_context
 
     dd = grad_u_tpair.dd
-    dd_quad = dd.with_qtag(quad_tag)
+    dd_quad = dd.with_discr_tag(quad_tag)
     dd_allfaces_quad = dd_quad.with_dtag("all_faces")
 
     normal_quad = thaw(actx, discr.normal(dd_quad))
@@ -191,7 +191,7 @@ def get_gradient_flux(self, discr, quad_tag, dd, alpha, u):  # noqa: D102
         return gradient_flux(discr, quad_tag, u_tpair)
 
     def get_diffusion_flux(self, discr, quad_tag, dd, alpha, grad_u):  # noqa: D102
-        dd_quad = dd.with_qtag(quad_tag)
+        dd_quad = dd.with_discr_tag(quad_tag)
         dd_allfaces_quad = dd_quad.with_dtag("all_faces")
         # Compute the flux directly instead of constructing an external grad_u value
         # (and the associated TracePair); this approach is simpler in the

test/test_diffusion.py

@@ -32,7 +32,7 @@
     DirichletDiffusionBoundary,
     NeumannDiffusionBoundary)
 from meshmode.dof_array import thaw, DOFArray
-from grudge.dof_desc import DTAG_BOUNDARY, QTAG_NONE
+from grudge.dof_desc import DTAG_BOUNDARY, DISCR_TAG_BASE, DISCR_TAG_QUAD
 
 from meshmode.array_context import (  # noqa
     pytest_generate_tests_for_pyopencl_array_context
@@ -264,11 +264,13 @@ def test_diffusion_accuracy(actx_factory, problem, nsteps, dt, scales, order,
         from meshmode.discretization.poly_element import \
                 QuadratureSimplexGroupFactory, \
                 PolynomialWarpAndBlendGroupFactory
-        discr = EagerDGDiscretization(actx, mesh,
-                quad_tag_to_group_factory={
-                    QTAG_NONE: PolynomialWarpAndBlendGroupFactory(order),
-                    "quad": QuadratureSimplexGroupFactory(3*order),
-                    })
+        discr = EagerDGDiscretization(
+            actx, mesh,
+            discr_tag_to_group_factory={
+                DISCR_TAG_BASE: PolynomialWarpAndBlendGroupFactory(order),
+                DISCR_TAG_QUAD: QuadratureSimplexGroupFactory(3*order),
+            }
+        )
 
         nodes = thaw(actx, discr.nodes())
 
@@ -278,12 +280,12 @@ def sym_eval(expr, t):
         alpha = sym_eval(p.sym_alpha, 0.)
 
         if isinstance(alpha, DOFArray):
-            quad_tag = "quad"
+            discr_tag = DISCR_TAG_QUAD
         else:
-            quad_tag = QTAG_NONE
+            discr_tag = DISCR_TAG_BASE
 
         def get_rhs(t, u):
-            return (diffusion_operator(discr, quad_tag=quad_tag, alpha=alpha,
+            return (diffusion_operator(discr, quad_tag=discr_tag, alpha=alpha,
                     boundaries=p.get_boundaries(discr, actx, t), u=u)
                 + sym_eval(sym_f, t))
 
@@ -369,7 +371,7 @@ def test_diffusion_discontinuous_alpha(actx_factory, order, visualize=False):
 
     def get_rhs(t, u):
         return diffusion_operator(
-            discr, quad_tag=QTAG_NONE, alpha=alpha, boundaries=boundaries, u=u)
+            discr, quad_tag=DISCR_TAG_BASE, alpha=alpha, boundaries=boundaries, u=u)
 
     rhs = get_rhs(0, u_steady)
 
@@ -459,7 +461,7 @@ def sym_eval_mirgecom(expr):
             u_mirgecom = sym_eval_mirgecom(p.sym_u)
 
             diffusion_u_mirgecom = diffusion_operator(discr_mirgecom,
-                quad_tag=QTAG_NONE, alpha=discr_mirgecom.zeros(actx)+1.,
+                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)
@@ -528,7 +530,7 @@ def sym_eval(expr):
 
     boundaries = p.get_boundaries(discr, actx, t)
 
-    diffusion_u1 = diffusion_operator(discr, quad_tag=QTAG_NONE, alpha=alpha,
+    diffusion_u1 = diffusion_operator(discr, quad_tag=DISCR_TAG_BASE, alpha=alpha,
         boundaries=boundaries, u=u1)
 
     assert isinstance(diffusion_u1, DOFArray)
@@ -542,8 +544,10 @@ def sym_eval(expr):
     boundaries_vector = [boundaries, boundaries]
     u_vector = make_obj_array([u1, u2])
 
-    diffusion_u_vector = diffusion_operator(discr, quad_tag=QTAG_NONE, alpha=alpha,
-        boundaries=boundaries_vector, u=u_vector)
+    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,)