warp-lang 1.1.0__py3-none-manylinux2014_x86_64.whl → 1.2.1__py3-none-manylinux2014_x86_64.whl

warp/fem/space/__init__.py

@@ -9,53 +9,24 @@ import warp.fem.polynomial as _polynomial
 
 from .function_space import FunctionSpace
 from .topology import SpaceTopology
-from .basis_space import BasisSpace, PointBasisSpace
+from .basis_space import BasisSpace, PointBasisSpace, ShapeBasisSpace, make_discontinuous_basis_space
 from .collocated_function_space import CollocatedFunctionSpace
+from .shape import ElementBasis, get_shape_function
+
+from .grid_2d_function_space import make_grid_2d_space_topology
+
+from .grid_3d_function_space import make_grid_3d_space_topology
+
+from .trimesh_2d_function_space import make_trimesh_2d_space_topology
+
+from .tetmesh_function_space import make_tetmesh_space_topology
+
+from .quadmesh_2d_function_space import make_quadmesh_2d_space_topology
+
+from .hexmesh_function_space import make_hexmesh_space_topology
+
+from .nanogrid_function_space import make_nanogrid_space_topology
 
-from .grid_2d_function_space import (
-    GridPiecewiseConstantBasis,
-    GridBipolynomialBasisSpace,
-    GridDGBipolynomialBasisSpace,
-    GridSerendipityBasisSpace,
-    GridDGSerendipityBasisSpace,
-    GridDGPolynomialBasisSpace,
-)
-from .grid_3d_function_space import (
-    GridTripolynomialBasisSpace,
-    GridDGTripolynomialBasisSpace,
-    Grid3DPiecewiseConstantBasis,
-    Grid3DSerendipityBasisSpace,
-    Grid3DDGSerendipityBasisSpace,
-    Grid3DDGPolynomialBasisSpace,
-)
-from .trimesh_2d_function_space import (
-    Trimesh2DPiecewiseConstantBasis,
-    Trimesh2DPolynomialBasisSpace,
-    Trimesh2DDGPolynomialBasisSpace,
-    Trimesh2DNonConformingPolynomialBasisSpace,
-)
-from .tetmesh_function_space import (
-    TetmeshPiecewiseConstantBasis,
-    TetmeshPolynomialBasisSpace,
-    TetmeshDGPolynomialBasisSpace,
-    TetmeshNonConformingPolynomialBasisSpace,
-)
-from .quadmesh_2d_function_space import (
-    Quadmesh2DPiecewiseConstantBasis,
-    Quadmesh2DBipolynomialBasisSpace,
-    Quadmesh2DDGBipolynomialBasisSpace,
-    Quadmesh2DSerendipityBasisSpace,
-    Quadmesh2DDGSerendipityBasisSpace,
-    Quadmesh2DPolynomialBasisSpace,
-)
-from .hexmesh_function_space import (
-    HexmeshPiecewiseConstantBasis,
-    HexmeshTripolynomialBasisSpace,
-    HexmeshDGTripolynomialBasisSpace,
-    HexmeshSerendipityBasisSpace,
-    HexmeshDGSerendipityBasisSpace,
-    HexmeshPolynomialBasisSpace,
-)
 
 from .partition import SpacePartition, make_space_partition
 from .restriction import SpaceRestriction
@@ -105,17 +76,6 @@ def make_space_restriction(
     )
 
 
-class ElementBasis(Enum):
-    """Choice of basis function to equip individual elements"""
-
-    LAGRANGE = 0
-    """Lagrange basis functions :math:`P_k` for simplices, tensor products :math:`Q_k` for squares and cubes"""
-    SERENDIPITY = 1
-    """Serendipity elements :math:`S_k`, corresponding to Lagrange nodes with interior points removed (for degree <= 3)"""
-    NONCONFORMING_POLYNOMIAL = 2
-    """Simplex Lagrange basis functions :math:`P_{kd}` embedded into non conforming reference elements (e.g. squares or cubes). Discontinuous only."""
-
-
 def make_polynomial_basis_space(
     geo: _geometry.Geometry,
     degree: int = 1,
@@ -141,110 +101,35 @@ def make_polynomial_basis_space(
 
     if element_basis is None:
         element_basis = ElementBasis.LAGRANGE
+    elif element_basis == ElementBasis.SERENDIPITY and degree == 1:
+        # Degree-1 serendipity is always equivalent to Lagrange
+        element_basis = ElementBasis.LAGRANGE
+
+    shape = get_shape_function(geo.reference_cell(), geo.dimension, degree, element_basis, family)
+
+    if discontinuous or degree == 0 or element_basis == ElementBasis.NONCONFORMING_POLYNOMIAL:
+        return make_discontinuous_basis_space(geo, shape)
 
+    topology = None
     if isinstance(base_geo, _geometry.Grid2D):
-        if degree == 0:
-            return GridPiecewiseConstantBasis(geo)
-
-        if element_basis == ElementBasis.SERENDIPITY and degree > 1:
-            if discontinuous:
-                return GridDGSerendipityBasisSpace(geo, degree=degree, family=family)
-            else:
-                return GridSerendipityBasisSpace(geo, degree=degree, family=family)
-
-        if element_basis == ElementBasis.NONCONFORMING_POLYNOMIAL:
-            return GridDGPolynomialBasisSpace(geo, degree=degree)
-
-        if discontinuous:
-            return GridDGBipolynomialBasisSpace(geo, degree=degree, family=family)
-        else:
-            return GridBipolynomialBasisSpace(geo, degree=degree, family=family)
-
-    if isinstance(base_geo, _geometry.Grid3D):
-        if degree == 0:
-            return Grid3DPiecewiseConstantBasis(geo)
-
-        if element_basis == ElementBasis.SERENDIPITY and degree > 1:
-            if discontinuous:
-                return Grid3DDGSerendipityBasisSpace(geo, degree=degree, family=family)
-            else:
-                return Grid3DSerendipityBasisSpace(geo, degree=degree, family=family)
-
-        if element_basis == ElementBasis.NONCONFORMING_POLYNOMIAL:
-            return Grid3DDGPolynomialBasisSpace(geo, degree=degree)
-
-        if discontinuous:
-            return GridDGTripolynomialBasisSpace(geo, degree=degree, family=family)
-        else:
-            return GridTripolynomialBasisSpace(geo, degree=degree, family=family)
-
-    if isinstance(base_geo, _geometry.Trimesh2D):
-        if degree == 0:
-            return Trimesh2DPiecewiseConstantBasis(geo)
-
-        if element_basis == ElementBasis.SERENDIPITY and degree > 2:
-            raise NotImplementedError("Serendipity variant not implemented yet")
-
-        if element_basis == ElementBasis.NONCONFORMING_POLYNOMIAL:
-            return Trimesh2DNonConformingPolynomialBasisSpace(geo, degree=degree)
-
-        if discontinuous:
-            return Trimesh2DDGPolynomialBasisSpace(geo, degree=degree)
-        else:
-            return Trimesh2DPolynomialBasisSpace(geo, degree=degree)
-
-    if isinstance(base_geo, _geometry.Tetmesh):
-        if degree == 0:
-            return TetmeshPiecewiseConstantBasis(geo)
-
-        if element_basis == ElementBasis.SERENDIPITY and degree > 2:
-            raise NotImplementedError("Serendipity variant not implemented yet")
-
-        if element_basis == ElementBasis.NONCONFORMING_POLYNOMIAL:
-            return TetmeshNonConformingPolynomialBasisSpace(geo, degree=degree)
-
-        if discontinuous:
-            return TetmeshDGPolynomialBasisSpace(geo, degree=degree)
-        else:
-            return TetmeshPolynomialBasisSpace(geo, degree=degree)
-
-    if isinstance(base_geo, _geometry.Quadmesh2D):
-        if degree == 0:
-            return Quadmesh2DPiecewiseConstantBasis(geo)
-
-        if element_basis == ElementBasis.SERENDIPITY and degree > 1:
-            if discontinuous:
-                return Quadmesh2DDGSerendipityBasisSpace(geo, degree=degree, family=family)
-            else:
-                return Quadmesh2DSerendipityBasisSpace(geo, degree=degree, family=family)
-
-        if element_basis == ElementBasis.NONCONFORMING_POLYNOMIAL:
-            return Quadmesh2DPolynomialBasisSpace(geo, degree=degree)
-
-        if discontinuous:
-            return Quadmesh2DDGBipolynomialBasisSpace(geo, degree=degree, family=family)
-        else:
-            return Quadmesh2DBipolynomialBasisSpace(geo, degree=degree, family=family)
-
-    if isinstance(base_geo, _geometry.Hexmesh):
-        if degree == 0:
-            return HexmeshPiecewiseConstantBasis(geo)
-
-        if element_basis == ElementBasis.SERENDIPITY and degree > 1:
-            if discontinuous:
-                return HexmeshDGSerendipityBasisSpace(geo, degree=degree, family=family)
-            else:
-                return HexmeshSerendipityBasisSpace(geo, degree=degree, family=family)
-
-        if element_basis == ElementBasis.NONCONFORMING_POLYNOMIAL:
-            return HexmeshPolynomialBasisSpace(geo, degree=degree)
-
-        if discontinuous:
-            return HexmeshDGTripolynomialBasisSpace(geo, degree=degree, family=family)
-        else:
-            return HexmeshTripolynomialBasisSpace(geo, degree=degree, family=family)
-
-    raise NotImplementedError()
+        topology = make_grid_2d_space_topology(geo, shape)
+    elif isinstance(base_geo, _geometry.Grid3D):
+        topology = make_grid_3d_space_topology(geo, shape)
+    elif isinstance(base_geo, _geometry.Trimesh2D):
+        topology = make_trimesh_2d_space_topology(geo, shape)
+    elif isinstance(base_geo, _geometry.Tetmesh):
+        topology = make_tetmesh_space_topology(geo, shape)
+    elif isinstance(base_geo, _geometry.Quadmesh2D):
+        topology = make_quadmesh_2d_space_topology(geo, shape)
+    elif isinstance(base_geo, _geometry.Hexmesh):
+        topology = make_hexmesh_space_topology(geo, shape)
+    elif isinstance(base_geo, _geometry.Nanogrid):
+        topology = make_nanogrid_space_topology(geo, shape)
+
+    if topology is None:
+        raise NotImplementedError(f"Unsupported geometry type {geo.name}")
+
+    return ShapeBasisSpace(topology, shape)
 
 
 def make_collocated_function_space(

warp/fem/space/basis_space.py

@@ -394,6 +394,40 @@ class TraceBasisSpace(BasisSpace):
         return self._topo == other._topo
 
 
+class PiecewiseConstantBasisSpace(ShapeBasisSpace):
+    class Trace(TraceBasisSpace):
+        def make_node_coords_in_element(self):
+            # Makes the single node visible to all sides; useful for interpolating on boundaries
+            # For higher-order non-conforming elements direct interpolation on boundary is not possible,
+            # need to do proper integration then solve with mass matrix
+
+            CENTER_COORDS = Coords(self.geometry.reference_side().center())
+
+            @cache.dynamic_func(suffix=self._basis.name)
+            def trace_node_coords_in_element(
+                geo_side_arg: self.geometry.SideArg,
+                basis_arg: self.BasisArg,
+                element_index: ElementIndex,
+                node_index_in_elt: int,
+            ):
+                return CENTER_COORDS
+
+            return trace_node_coords_in_element
+
+    def trace(self):
+        return PiecewiseConstantBasisSpace.Trace(self)
+
+
+def make_discontinuous_basis_space(geometry: Geometry, shape: ShapeFunction):
+    topology = DiscontinuousSpaceTopology(geometry, shape.NODES_PER_ELEMENT)
+
+    if shape.NODES_PER_ELEMENT == 1:
+        # piecewise-constant space
+        return PiecewiseConstantBasisSpace(topology=topology, shape=shape)
+
+    return ShapeBasisSpace(topology=topology, shape=shape)
+
+
 class PointBasisSpace(BasisSpace):
     """An unstructured :class:`BasisSpace` that is non-zero at a finite set of points only.
 

warp/fem/space/collocated_function_space.py

@@ -36,7 +36,7 @@ class CollocatedFunctionSpace(FunctionSpace):
         self.element_outer_weight_gradient = self._basis.make_element_outer_weight_gradient()
 
         # For backward compatibility
-        if hasattr(basis, "node_grid"):
+        if hasattr(basis.topology, "node_grid"):
             self.node_grid = basis.node_grid
         if hasattr(basis, "node_triangulation"):
             self.node_triangulation = basis.node_triangulation

warp/fem/space/grid_2d_function_space.py

@@ -3,22 +3,22 @@ import numpy as np
 import warp as wp
 from warp.fem import cache
 from warp.fem.geometry import Grid2D
-from warp.fem.polynomial import Polynomial, is_closed
-from warp.fem.types import Coords, ElementIndex
+from warp.fem.polynomial import is_closed
+from warp.fem.types import ElementIndex
 
-from .basis_space import ShapeBasisSpace, TraceBasisSpace
 from .shape import (
-    ConstantShapeFunction,
     ShapeFunction,
     SquareBipolynomialShapeFunctions,
-    SquareNonConformingPolynomialShapeFunctions,
     SquareSerendipityShapeFunctions,
 )
-from .topology import DiscontinuousSpaceTopologyMixin, SpaceTopology, forward_base_topology
+from .topology import SpaceTopology, forward_base_topology
 
 
 class Grid2DSpaceTopology(SpaceTopology):
     def __init__(self, grid: Grid2D, shape: ShapeFunction):
+        if not is_closed(shape.family):
+            raise ValueError("A closed polynomial family is required to define a continuous function space")
+
         super().__init__(grid, shape.NODES_PER_ELEMENT)
         self._shape = shape
 
@@ -37,53 +37,6 @@ class Grid2DSpaceTopology(SpaceTopology):
         return Grid2D._from_2d_index(x_stride, corner)
 
 
-class Grid2DDiscontinuousSpaceTopology(
-    DiscontinuousSpaceTopologyMixin,
-    Grid2DSpaceTopology,
-):
-    pass
-
-
-class Grid2DBasisSpace(ShapeBasisSpace):
-    def __init__(self, topology: Grid2DSpaceTopology, shape: ShapeFunction):
-        super().__init__(topology, shape)
-
-        self._grid: Grid2D = topology.geometry
-
-
-class GridPiecewiseConstantBasis(Grid2DBasisSpace):
-    def __init__(self, grid: Grid2D):
-        shape = ConstantShapeFunction(grid.reference_cell(), space_dimension=2)
-        topology = Grid2DDiscontinuousSpaceTopology(grid, shape)
-        super().__init__(shape=shape, topology=topology)
-
-        if isinstance(grid, Grid2D):
-            self.node_grid = self._node_grid
-
-    def _node_grid(self):
-        res = self._grid.res
-
-        X = (np.arange(0, res[0], dtype=float) + 0.5) * self._grid.cell_size[0] + self._grid.origin[0]
-        Y = (np.arange(0, res[1], dtype=float) + 0.5) * self._grid.cell_size[1] + self._grid.origin[1]
-        return np.meshgrid(X, Y, indexing="ij")
-
-    class Trace(TraceBasisSpace):
-        @wp.func
-        def _node_coords_in_element(
-            side_arg: Grid2D.SideArg,
-            basis_arg: Grid2DBasisSpace.BasisArg,
-            element_index: ElementIndex,
-            node_index_in_element: int,
-        ):
-            return Coords(0.5, 0.0, 0.0)
-
-        def make_node_coords_in_element(self):
-            return self._node_coords_in_element
-
-    def trace(self):
-        return GridPiecewiseConstantBasis.Trace(self)
-
-
 class GridBipolynomialSpaceTopology(Grid2DSpaceTopology):
     def __init__(self, grid: Grid2D, shape: SquareBipolynomialShapeFunctions):
         super().__init__(grid, shape)
@@ -119,30 +72,8 @@ class GridBipolynomialSpaceTopology(Grid2DSpaceTopology):
 
         return element_node_index
 
-
-class GridBipolynomialBasisSpace(Grid2DBasisSpace):
-    def __init__(
-        self,
-        grid: Grid2D,
-        degree: int,
-        family: Polynomial,
-    ):
-        if family is None:
-            family = Polynomial.LOBATTO_GAUSS_LEGENDRE
-
-        if not is_closed(family):
-            raise ValueError("A closed polynomial family is required to define a continuous function space")
-
-        shape = SquareBipolynomialShapeFunctions(degree, family=family)
-        topology = forward_base_topology(GridBipolynomialSpaceTopology, grid, shape)
-
-        super().__init__(topology, shape)
-
-        if isinstance(grid, Grid2D):
-            self.node_grid = self._node_grid
-
     def _node_grid(self):
-        res = self._grid.res
+        res = self.geometry.res
 
         cell_coords = np.array(self._shape.LOBATTO_COORDS)[:-1]
 
@@ -161,22 +92,6 @@ class GridBipolynomialBasisSpace(Grid2DBasisSpace):
         return np.meshgrid(X, Y, indexing="ij")
 
 
-class GridDGBipolynomialBasisSpace(Grid2DBasisSpace):
-    def __init__(
-        self,
-        grid: Grid2D,
-        degree: int,
-        family: Polynomial,
-    ):
-        if family is None:
-            family = Polynomial.LOBATTO_GAUSS_LEGENDRE
-
-        shape = SquareBipolynomialShapeFunctions(degree, family=family)
-        topology = Grid2DDiscontinuousSpaceTopology(grid, shape)
-
-        super().__init__(shape=shape, topology=topology)
-
-
 class GridSerendipitySpaceTopology(Grid2DSpaceTopology):
     def __init__(self, grid: Grid2D, shape: SquareSerendipityShapeFunctions):
         super().__init__(grid, shape)
@@ -223,45 +138,11 @@ class GridSerendipitySpaceTopology(Grid2DSpaceTopology):
         return element_node_index
 
 
-class GridSerendipityBasisSpace(Grid2DBasisSpace):
-    def __init__(
-        self,
-        grid: Grid2D,
-        degree: int,
-        family: Polynomial,
-    ):
-        if family is None:
-            family = Polynomial.LOBATTO_GAUSS_LEGENDRE
-
-        shape = SquareSerendipityShapeFunctions(degree, family=family)
-        topology = forward_base_topology(GridSerendipitySpaceTopology, grid, shape=shape)
-
-        super().__init__(topology=topology, shape=shape)
-
-
-class GridDGSerendipityBasisSpace(Grid2DBasisSpace):
-    def __init__(
-        self,
-        grid: Grid2D,
-        degree: int,
-        family: Polynomial,
-    ):
-        if family is None:
-            family = Polynomial.LOBATTO_GAUSS_LEGENDRE
-
-        shape = SquareSerendipityShapeFunctions(degree, family=family)
-        topology = Grid2DDiscontinuousSpaceTopology(grid, shape=shape)
-
-        super().__init__(topology=topology, shape=shape)
-
+def make_grid_2d_space_topology(grid: Grid2D, shape: ShapeFunction):
+    if isinstance(shape, SquareSerendipityShapeFunctions):
+        return forward_base_topology(GridSerendipitySpaceTopology, grid, shape)
 
-class GridDGPolynomialBasisSpace(Grid2DBasisSpace):
-    def __init__(
-        self,
-        grid: Grid2D,
-        degree: int,
-    ):
-        shape = SquareNonConformingPolynomialShapeFunctions(degree)
-        topology = Grid2DDiscontinuousSpaceTopology(grid, shape=shape)
+    if isinstance(shape, SquareBipolynomialShapeFunctions):
+        return forward_base_topology(GridBipolynomialSpaceTopology, grid, shape)
 
-        super().__init__(topology=topology, shape=shape)
+    raise ValueError(f"Unsupported shape function {shape.name}")

warp/fem/space/grid_3d_function_space.py

@@ -3,23 +3,25 @@ import numpy as np
 import warp as wp
 from warp.fem import cache
 from warp.fem.geometry import Grid3D
-from warp.fem.polynomial import Polynomial, is_closed
-from warp.fem.types import Coords, ElementIndex
+from warp.fem.polynomial import is_closed
+from warp.fem.types import ElementIndex
 
-from .basis_space import ShapeBasisSpace, TraceBasisSpace
-from .shape import ConstantShapeFunction, ShapeFunction
-from .shape.cube_shape_function import (
-    CubeNonConformingPolynomialShapeFunctions,
+from .shape import (
     CubeSerendipityShapeFunctions,
     CubeTripolynomialShapeFunctions,
+    ShapeFunction,
 )
-from .topology import DiscontinuousSpaceTopologyMixin, SpaceTopology, forward_base_topology
+from .topology import SpaceTopology, forward_base_topology
 
 
 class Grid3DSpaceTopology(SpaceTopology):
     def __init__(self, grid: Grid3D, shape: ShapeFunction):
+        if not is_closed(shape.family):
+            raise ValueError("A closed polynomial family is required to define a continuous function space")
+
         super().__init__(grid, shape.NODES_PER_ELEMENT)
         self._shape = shape
+        self._grid = grid
 
     @wp.func
     def _vertex_coords(vidx_in_cell: int):
@@ -37,52 +39,6 @@ class Grid3DSpaceTopology(SpaceTopology):
         return Grid3D._from_3d_index(strides, corner)
 
 
-class Grid3DDiscontinuousSpaceTopology(
-    DiscontinuousSpaceTopologyMixin,
-    Grid3DSpaceTopology,
-):
-    pass
-
-
-class Grid3DBasisSpace(ShapeBasisSpace):
-    def __init__(self, topology: Grid3DSpaceTopology, shape: ShapeFunction):
-        super().__init__(topology, shape)
-
-        self._grid: Grid3D = topology.geometry
-
-
-class Grid3DPiecewiseConstantBasis(Grid3DBasisSpace):
-    def __init__(self, grid: Grid3D):
-        shape = ConstantShapeFunction(grid.reference_cell(), space_dimension=3)
-        topology = Grid3DDiscontinuousSpaceTopology(grid, shape)
-        super().__init__(shape=shape, topology=topology)
-
-        if isinstance(grid, Grid3D):
-            self.node_grid = self._node_grid
-
-    def _node_grid(self):
-        X = (np.arange(0, self.geometry.res[0], dtype=float) + 0.5) * self._grid.cell_size[0] + self._grid.bounds_lo[0]
-        Y = (np.arange(0, self.geometry.res[1], dtype=float) + 0.5) * self._grid.cell_size[1] + self._grid.bounds_lo[1]
-        Z = (np.arange(0, self.geometry.res[2], dtype=float) + 0.5) * self._grid.cell_size[2] + self._grid.bounds_lo[2]
-        return np.meshgrid(X, Y, Z, indexing="ij")
-
-    class Trace(TraceBasisSpace):
-        @wp.func
-        def _node_coords_in_element(
-            side_arg: Grid3D.SideArg,
-            basis_arg: Grid3DBasisSpace.BasisArg,
-            element_index: ElementIndex,
-            node_index_in_element: int,
-        ):
-            return Coords(0.5, 0.5, 0.0)
-
-        def make_node_coords_in_element(self):
-            return self._node_coords_in_element
-
-    def trace(self):
-        return Grid3DPiecewiseConstantBasis.Trace(self)
-
-
 class GridTripolynomialSpaceTopology(Grid3DSpaceTopology):
     def __init__(self, grid: Grid3D, shape: CubeTripolynomialShapeFunctions):
         super().__init__(grid, shape)
@@ -123,30 +79,8 @@ class GridTripolynomialSpaceTopology(Grid3DSpaceTopology):
 
         return element_node_index
 
-
-class GridTripolynomialBasisSpace(Grid3DBasisSpace):
-    def __init__(
-        self,
-        grid: Grid3D,
-        degree: int,
-        family: Polynomial,
-    ):
-        if family is None:
-            family = Polynomial.LOBATTO_GAUSS_LEGENDRE
-
-        if not is_closed(family):
-            raise ValueError("A closed polynomial family is required to define a continuous function space")
-
-        shape = CubeTripolynomialShapeFunctions(degree, family=family)
-        topology = forward_base_topology(GridTripolynomialSpaceTopology, grid, shape)
-
-        super().__init__(topology, shape)
-
-        if isinstance(grid, Grid3D):
-            self.node_grid = self._node_grid
-
     def _node_grid(self):
-        res = self._grid.res
+        res = self.geometry.res
 
         cell_coords = np.array(self._shape.LOBATTO_COORDS)[:-1]
 
@@ -171,44 +105,6 @@ class GridTripolynomialBasisSpace(Grid3DBasisSpace):
         return np.meshgrid(X, Y, Z, indexing="ij")
 
 
-class GridDGTripolynomialBasisSpace(Grid3DBasisSpace):
-    def __init__(
-        self,
-        grid: Grid3D,
-        degree: int,
-        family: Polynomial,
-    ):
-        if family is None:
-            family = Polynomial.LOBATTO_GAUSS_LEGENDRE
-
-        shape = CubeTripolynomialShapeFunctions(degree, family=family)
-        topology = Grid3DDiscontinuousSpaceTopology(grid, shape)
-
-        super().__init__(shape=shape, topology=topology)
-
-    def node_grid(self):
-        res = self._grid.res
-
-        cell_coords = np.array(self._shape.LOBATTO_COORDS)
-
-        grid_coords_x = np.repeat(np.arange(0, res[0], dtype=float), len(cell_coords)) + np.tile(
-            cell_coords, reps=res[0]
-        )
-        X = grid_coords_x * self._grid.cell_size[0] + self._grid.origin[0]
-
-        grid_coords_y = np.repeat(np.arange(0, res[1], dtype=float), len(cell_coords)) + np.tile(
-            cell_coords, reps=res[1]
-        )
-        Y = grid_coords_y * self._grid.cell_size[1] + self._grid.origin[1]
-
-        grid_coords_z = np.repeat(np.arange(0, res[2], dtype=float), len(cell_coords)) + np.tile(
-            cell_coords, reps=res[2]
-        )
-        Z = grid_coords_z * self._grid.cell_size[2] + self._grid.origin[2]
-
-        return np.meshgrid(X, Y, Z, indexing="ij")
-
-
 class Grid3DSerendipitySpaceTopology(Grid3DSpaceTopology):
     def __init__(self, grid: Grid3D, shape: CubeSerendipityShapeFunctions):
         super().__init__(grid, shape)
@@ -261,45 +157,11 @@ class Grid3DSerendipitySpaceTopology(Grid3DSpaceTopology):
         return element_node_index
 
 
-class Grid3DSerendipityBasisSpace(Grid3DBasisSpace):
-    def __init__(
-        self,
-        grid: Grid3D,
-        degree: int,
-        family: Polynomial,
-    ):
-        if family is None:
-            family = Polynomial.LOBATTO_GAUSS_LEGENDRE
-
-        shape = CubeSerendipityShapeFunctions(degree, family=family)
-        topology = forward_base_topology(Grid3DSerendipitySpaceTopology, grid, shape=shape)
-
-        super().__init__(topology=topology, shape=shape)
-
-
-class Grid3DDGSerendipityBasisSpace(Grid3DBasisSpace):
-    def __init__(
-        self,
-        grid: Grid3D,
-        degree: int,
-        family: Polynomial,
-    ):
-        if family is None:
-            family = Polynomial.LOBATTO_GAUSS_LEGENDRE
-
-        shape = CubeSerendipityShapeFunctions(degree, family=family)
-        topology = Grid3DDiscontinuousSpaceTopology(grid, shape=shape)
-
-        super().__init__(topology=topology, shape=shape)
-
+def make_grid_3d_space_topology(grid: Grid3D, shape: ShapeFunction):
+    if isinstance(shape, CubeSerendipityShapeFunctions):
+        return forward_base_topology(Grid3DSerendipitySpaceTopology, grid, shape)
 
-class Grid3DDGPolynomialBasisSpace(Grid3DBasisSpace):
-    def __init__(
-        self,
-        grid: Grid3D,
-        degree: int,
-    ):
-        shape = CubeNonConformingPolynomialShapeFunctions(degree)
-        topology = Grid3DDiscontinuousSpaceTopology(grid, shape=shape)
+    if isinstance(shape, CubeTripolynomialShapeFunctions):
+        return forward_base_topology(GridTripolynomialSpaceTopology, grid, shape)
 
-        super().__init__(topology=topology, shape=shape)
+    raise ValueError(f"Unsupported shape function {shape.name}")