Merge branch 'main' into pytato-array-context-transforms

Author: kaushikcfd

meshmode/discretization/__init__.py

@@ -632,7 +632,7 @@ def num_reference_derivative(
             isinstance(grp, InterpolatoryElementGroupBase) for grp in discr.groups
             ]):
         raise NoninterpolatoryElementGroupError(
-            "Element groups must be usuable for differentiation and interpolation.")
+            "Element groups must be usable for differentiation and interpolation.")
 
     if not ref_axes:
         return vec

meshmode/discretization/connection/modal.py

@@ -347,7 +347,7 @@ def __call__(self, ary):
         actx = ary.array_context
 
         # Evaluates the action of the Vandermonde matrix on the
-        # vector of modal coefficeints to obtain nodal values
+        # vector of modal coefficients to obtain nodal values
         @memoize_in(actx, (ModalToNodalDiscretizationConnection,
                            "evaluation_knl"))
         def keval():

meshmode/dof_array.py

@@ -127,11 +127,12 @@ class DOFArray:
     """
 
     def __init__(self, actx: Optional[ArrayContext], data: Tuple[Any]):
-        if not (actx is None or isinstance(actx, ArrayContext)):
-            raise TypeError("actx must be of type ArrayContext")
+        if __debug__:
+            if not (actx is None or isinstance(actx, ArrayContext)):
+                raise TypeError("actx must be of type ArrayContext")
 
-        if not isinstance(data, tuple):
-            raise TypeError("'data' argument must be a tuple")
+            if not isinstance(data, tuple):
+                raise TypeError("'data' argument must be a tuple")
 
         self._array_context = actx
         self._data = data
@@ -165,13 +166,18 @@ def from_list(cls, actx: Optional[ArrayContext], res_list) -> "DOFArray":
         return cls(actx, tuple(res_list))
 
     def __str__(self):
-        return str(self._data)
+        return f"DOFArray({str(self._data)})"
 
     def __repr__(self):
         return f"DOFArray({repr(self._data)})"
 
     # {{{ sequence protocol
 
+    def __bool__(self):
+        raise ValueError(
+                "The truth value of a DOFArray is not well-defined. "
+                "Use actx.np.any(x) or actx.np.all(x)")
+
     def __len__(self):
         return len(self._data)
 

meshmode/interop/firedrake/connection.py

@@ -759,7 +759,7 @@ def build_connection_to_firedrake(discr, group_nr=None, comm=None):
     by resampling at the nodes.
 
     :param discr: A :class:`~meshmode.discretization.Discretization`
-        to intialize the connection with
+        to initialize the connection with
     :param group_nr: The group number of the discretization to convert.
         If *None* there must be only one group. The selected group
         must be of type
@@ -789,7 +789,7 @@ def build_connection_to_firedrake(discr, group_nr=None, comm=None):
     # **_cell_node holds the node nrs in shape *(ncells, nunit_nodes)*
     fd_cell_node = fspace.cell_node_list
 
-    # To get the meshmode to firedrake node assocation, we need to handle
+    # To get the meshmode to firedrake node association, we need to handle
     # local vertex reordering and cell reordering.
     from pyop2.datatypes import IntType
     mm2fd_node_mapping = np.ndarray((el_group.nelements, el_group.nunit_dofs),

meshmode/mesh/processing.py

@@ -554,7 +554,7 @@ def partition_mesh(mesh, part_per_element, part_num):
     global_elem_to_part_elem = _compute_global_elem_to_part_elem(part_per_element,
                 {part_num}, mesh.element_id_dtype)
 
-    # Create new mesh groups that mimick the original mesh's groups but only contain
+    # Create new mesh groups that mimic the original mesh's groups but only contain
     # the local partition's elements
     part_mesh_groups, global_group_to_part_group, required_vertex_indices =\
                 _filter_mesh_groups(mesh.groups, queried_elems, mesh.vertex_id_dtype)

meshmode/mesh/refinement/__init__.py

@@ -26,8 +26,8 @@
 import numpy as np
 
 from meshmode.mesh.refinement.no_adjacency import RefinerWithoutAdjacency
-from meshmode.mesh.refinement.tesselate import \
-        ElementTesselationInfo, GroupRefinementRecord
+from meshmode.mesh.refinement.tessellate import \
+        ElementTessellationInfo, GroupRefinementRecord
 
 import logging
 logger = logging.getLogger(__name__)
@@ -56,16 +56,16 @@ def get_vertex_pair_to_midpoint_order(dim):
 
     @staticmethod
     def get_midpoints(group, el_tess_info, elements):
-        import meshmode.mesh.refinement.tesselate as tess
+        import meshmode.mesh.refinement.tessellate as tess
         return tess.get_group_midpoints(group, el_tess_info, elements)
 
     @staticmethod
-    def get_tesselated_nodes(group, el_tess_info, elements):
-        import meshmode.mesh.refinement.tesselate as tess
-        return tess.get_group_tesselated_nodes(group, el_tess_info, elements)
+    def get_tessellated_nodes(group, el_tess_info, elements):
+        import meshmode.mesh.refinement.tessellate as tess
+        return tess.get_group_tessellated_nodes(group, el_tess_info, elements)
 
 
-def tesselate_simplex(dim):
+def tessellate_simplex(dim):
     import modepy as mp
     shape = mp.Simplex(dim)
     space = mp.space_for_shape(shape, 2)
@@ -136,17 +136,17 @@ def __init__(self, mesh):
         self.lazy = False
         self.seen_tuple = {}
         self.group_refinement_records = []
-        seg_node_tuples, seg_result = tesselate_simplex(1)
-        tri_node_tuples, tri_result = tesselate_simplex(2)
-        tet_node_tuples, tet_result = tesselate_simplex(3)
+        seg_node_tuples, seg_result = tessellate_simplex(1)
+        tri_node_tuples, tri_result = tessellate_simplex(2)
+        tet_node_tuples, tet_result = tessellate_simplex(3)
         #quadrilateral_node_tuples = [
         #print tri_result, tet_result
         self.simplex_node_tuples = [
                 None, seg_node_tuples, tri_node_tuples, tet_node_tuples]
-        # Dimension-parameterized tesselations for refinement
+        # Dimension-parameterized tessellations for refinement
         self.simplex_result = [None, seg_result, tri_result, tet_result]
         #print tri_node_tuples, tri_result
-        #self.simplex_node_tuples, self.simplex_result = tesselatetet()
+        #self.simplex_node_tuples, self.simplex_result = tessellatetet()
         self.last_mesh = mesh
         self.last_split_elements = None
 
@@ -646,7 +646,7 @@ def check_adjacent_elements(groups, new_hanging_vertex_elements, nelements_in_gr
                         midpoints_to_find.append(iel_grp)
                         if not resampler:
                             resampler = SimplexResampler()
-                            el_tess_info = ElementTesselationInfo(
+                            el_tess_info = ElementTessellationInfo(
                                 children=self.simplex_result[grp.dim],
                                 ref_vertices=self.simplex_node_tuples[grp.dim])
                     else:
@@ -794,7 +794,7 @@ def check_adjacent_elements(groups, new_hanging_vertex_elements, nelements_in_gr
                 # if simplex
                 if is_simplex:
                     resampler = SimplexResampler()
-                    new_nodes = resampler.get_tesselated_nodes(
+                    new_nodes = resampler.get_tessellated_nodes(
                         prev_group, refinement_record.el_tess_info, to_resample)
                 else:
                     raise NotImplementedError(

meshmode/mesh/refinement/no_adjacency.py

@@ -84,13 +84,13 @@ def refine(self, refine_flags):
         if perform_vertex_updates:
             inew_vertex = mesh.nvertices
 
-        from meshmode.mesh.refinement.tesselate import (
-                get_group_tesselation_info,
+        from meshmode.mesh.refinement.tessellate import (
+                get_group_tessellation_info,
                 get_group_midpoints,
-                get_group_tesselated_nodes)
+                get_group_tessellated_nodes)
 
         for group in mesh.groups:
-            el_tess_info = get_group_tesselation_info(group)
+            el_tess_info = get_group_tessellation_info(group)
 
             # {{{ compute counts and index arrays
 
@@ -114,7 +114,7 @@ def refine(self, refine_flags):
 
             # }}}
 
-            from meshmode.mesh.refinement.tesselate import GroupRefinementRecord
+            from meshmode.mesh.refinement.tessellate import GroupRefinementRecord
             group_refinement_records.append(
                     GroupRefinementRecord(
                         el_tess_info=el_tess_info,
@@ -195,13 +195,13 @@ def refine(self, refine_flags):
             # copy over unchanged nodes
             new_nodes[:, unrefined_el_new_indices] = group.nodes[:, ~grp_flags]
 
-            tesselated_nodes = get_group_tesselated_nodes(
+            tessellated_nodes = get_group_tessellated_nodes(
                     group, el_tess_info, refining_el_old_indices)
 
             for old_iel in refining_el_old_indices:
                 new_iel_base = child_el_indices[old_iel]
                 new_nodes[:, new_iel_base:new_iel_base+nchildren, :] = \
-                        tesselated_nodes[old_iel]
+                        tessellated_nodes[old_iel]
 
             assert (~np.isnan(new_nodes)).all()
 

meshmode/mesh/refinement/tesselate.py meshmode/mesh/refinement/tessellate.pymeshmode/mesh/refinement/tesselate.py renamed to meshmode/mesh/refinement/tessellate.py

@@ -41,7 +41,7 @@
 # {{{ interface
 
 @dataclass(frozen=True)
-class ElementTesselationInfo:
+class ElementTessellationInfo:
     """Describes how one element is split into multiple child elements.
 
     .. attribute:: children
@@ -84,15 +84,15 @@ class GroupRefinementRecord:
     """
     .. attribute:: el_tess_info
 
-        An instance of :class:`ElementTesselationInfo` that describes the
-        tesselation of a single element into multiple child elements.
+        An instance of :class:`ElementTessellationInfo` that describes the
+        tessellation of a single element into multiple child elements.
 
     .. attribute:: element_mapping
 
         A mapping from the original elements to the refined child elements.
     """
 
-    el_tess_info: ElementTesselationInfo
+    el_tess_info: ElementTessellationInfo
     # FIXME: This should really be a CSR data structure.
     element_mapping: List[List[int]]
 
@@ -102,23 +102,23 @@ def get_group_midpoints(meg: MeshElementGroup, el_tess_info, elements):
     """Compute the midpoints of the vertices of the specified elements.
 
     :arg group: an instance of :class:`meshmode.mesh.MeshElementGroup`.
-    :arg el_tess_info: a :class:`ElementTesselationInfo`.
+    :arg el_tess_info: a :class:`ElementTessellationInfo`.
     :arg elements: a list of (group-relative) element numbers.
 
     :return: A :class:`dict` mapping element numbers to midpoint
         coordinates, with each value in the map having shape
         ``(ambient_dim, nmidpoints)``. The ordering of the midpoints
-        follows their ordering in the tesselation.
+        follows their ordering in the tessellation.
     """
     raise NotImplementedError(type(meg).__name__)
 
 
 @singledispatch
-def get_group_tesselated_nodes(meg: MeshElementGroup, el_tess_info, elements):
-    """Compute the nodes of the child elements according to the tesselation.
+def get_group_tessellated_nodes(meg: MeshElementGroup, el_tess_info, elements):
+    """Compute the nodes of the child elements according to the tessellation.
 
     :arg group: An instance of :class:`meshmode.mesh.MeshElementGroup`.
-    :arg el_tess_info: a :class:`ElementTesselationInfo`.
+    :arg el_tess_info: a :class:`ElementTessellationInfo`.
     :arg elements: A list of (group-relative) element numbers.
 
     :return: A :class:`dict` mapping element numbers to node
@@ -131,9 +131,9 @@ def get_group_tesselated_nodes(meg: MeshElementGroup, el_tess_info, elements):
 
 
 @singledispatch
-def get_group_tesselation_info(meg: MeshElementGroup):
+def get_group_tessellation_info(meg: MeshElementGroup):
     """
-    :returns: a :class:`ElementTesselationInfo` for the element group *meg*.
+    :returns: a :class:`ElementTessellationInfo` for the element group *meg*.
     """
     raise NotImplementedError(type(meg).__name__)
 
@@ -181,7 +181,7 @@ def _get_ref_midpoints(shape, ref_vertices):
 # }}}
 
 
-# {{{ modepy.shape tesselation and resampling
+# {{{ modepy.shape tessellation and resampling
 
 @get_group_midpoints.register(_ModepyElementGroup)
 def _(meg: _ModepyElementGroup, el_tess_info, elements):
@@ -203,7 +203,7 @@ def _(meg: _ModepyElementGroup, el_tess_info, elements):
     return dict(zip(elements, resampled_midpoints))
 
 
-@get_group_tesselated_nodes.register(_ModepyElementGroup)
+@get_group_tessellated_nodes.register(_ModepyElementGroup)
 def _(meg: _ModepyElementGroup, el_tess_info, elements):
     shape = meg._modepy_shape
     space = meg._modepy_space
@@ -232,7 +232,7 @@ def _(meg: _ModepyElementGroup, el_tess_info, elements):
             }
 
 
-@get_group_tesselation_info.register(_ModepyElementGroup)
+@get_group_tessellation_info.register(_ModepyElementGroup)
 def _(meg: _ModepyElementGroup):
     shape = meg._modepy_shape
     space = type(meg._modepy_space)(meg.dim, 2)
@@ -260,7 +260,7 @@ def _(meg: _ModepyElementGroup):
     # ensure order matches the one in midpoint_indices
     midpoint_vertex_pairs = [midpoint_to_vertex_pairs[m] for m in midpoints]
 
-    return ElementTesselationInfo(
+    return ElementTessellationInfo(
             ref_vertices=ref_vertices,
             children=np.array(mp.submesh_for_shape(shape, ref_vertices)),
             orig_vertex_indices=np.array(orig_vertex_indices),

meshmode/mesh/refinement/utils.py

@@ -42,9 +42,9 @@ def map_unit_nodes_to_children(meg: MeshElementGroup,
     :arg unit_nodes: an :class:`~numpy.ndarray` of unit nodes on the
         element type described by *meg*.
     :arg el_tess_info: a
-        :class:`~meshmode.mesh.refinement.tesselate.ElementTesselationInfo`.
+        :class:`~meshmode.mesh.refinement.tessellate.ElementTessellationInfo`.
     :returns: an :class:`~numpy.ndarray` of mapped unit nodes for each
-        child in the tesselation.
+        child in the tessellation.
     """
     raise NotImplementedError(type(meg).__name__)