warp-lang 1.4.1__py3-none-macosx_10_13_universal2.whl → 1.5.0__py3-none-macosx_10_13_universal2.whl

warp/fem/space/shape/triangle_shape_function.py

@@ -4,6 +4,8 @@ import warp as wp
 from warp.fem import cache
 from warp.fem.types import Coords
 
+from .shape_function import ShapeFunction
+
 
 def _triangle_node_index(tx: int, ty: int, degree: int):
     VERTEX_NODE_COUNT = 3
@@ -34,17 +36,43 @@ def _triangle_node_index(tx: int, ty: int, degree: int):
     return vertex_edge_node_count + _triangle_node_index(tx - 1, ty - 1, degree - 3)
 
 
-class Triangle2DPolynomialShapeFunctions:
+class TriangleShapeFunction(ShapeFunction):
     VERTEX = wp.constant(0)
     EDGE = wp.constant(1)
     INTERIOR = wp.constant(2)
 
+    VERTEX_NODE_COUNT: int
+    """Number of shape function nodes per vertex"""
+
+    EDGE_NODE_COUNT: int
+    """Number of shape function nodes per triangle edge (excluding vertex nodes)"""
+
+    INTERIOR_NODE_COUNT: int
+    """Number of shape function nodes per triangle (excluding edge and vertex nodes)"""
+
+    @staticmethod
+    def node_type_and_index(node_index_in_elt: int):
+        pass
+
+    @wp.func
+    def _vertex_coords(vidx: int):
+        return wp.vec2(
+            float(vidx == 1),
+            float(vidx == 2),
+        )
+
+
+class TrianglePolynomialShapeFunctions(TriangleShapeFunction):
     def __init__(self, degree: int):
         self.ORDER = wp.constant(degree)
 
         self.NODES_PER_ELEMENT = wp.constant((degree + 1) * (degree + 2) // 2)
         self.NODES_PER_SIDE = wp.constant(degree + 1)
 
+        self.VERTEX_NODE_COUNT = wp.constant(1)
+        self.EDGE_NODE_COUNT = wp.constant(degree - 1)
+        self.INTERIOR_NODE_COUNT = wp.constant(max(0, degree - 2) * max(0, degree - 1) // 2)
+
         triangle_coords = np.empty((self.NODES_PER_ELEMENT, 2), dtype=int)
 
         for tx in range(degree + 1):
@@ -68,7 +96,7 @@ class Triangle2DPolynomialShapeFunctions:
         def node_triangle_coordinates(
             node_index_in_elt: int,
         ):
-            return wp.vec2i(NODE_TRIANGLE_COORDS[node_index_in_elt, 0], NODE_TRIANGLE_COORDS[node_index_in_elt, 1])
+            return NODE_TRIANGLE_COORDS[node_index_in_elt]
 
         return cache.get_func(node_triangle_coordinates, self.name)
 
@@ -79,12 +107,12 @@ class Triangle2DPolynomialShapeFunctions:
             node_index_in_elt: int,
         ):
             if node_index_in_elt < 3:
-                return Triangle2DPolynomialShapeFunctions.VERTEX, node_index_in_elt
+                return TrianglePolynomialShapeFunctions.VERTEX, node_index_in_elt
 
             if node_index_in_elt < 3 * ORDER:
-                return Triangle2DPolynomialShapeFunctions.EDGE, (node_index_in_elt - 3)
+                return TrianglePolynomialShapeFunctions.EDGE, (node_index_in_elt - 3)
 
-            return Triangle2DPolynomialShapeFunctions.INTERIOR, (node_index_in_elt - 3 * ORDER)
+            return TrianglePolynomialShapeFunctions.INTERIOR, (node_index_in_elt - 3 * ORDER)
 
         return cache.get_func(node_type_and_index, self.name)
 
@@ -125,9 +153,9 @@ class Triangle2DPolynomialShapeFunctions:
         def node_quadrature_weight(node_index_in_element: int):
             node_type, type_index = self.node_type_and_type_index(node_index_in_element)
 
-            if node_type == Triangle2DPolynomialShapeFunctions.VERTEX:
+            if node_type == TrianglePolynomialShapeFunctions.VERTEX:
                 return VERTEX_WEIGHT
-            elif node_type == Triangle2DPolynomialShapeFunctions.EDGE:
+            elif node_type == TrianglePolynomialShapeFunctions.EDGE:
                 return EDGE_WEIGHT
 
             return INTERIOR_WEIGHT
@@ -153,7 +181,7 @@ class Triangle2DPolynomialShapeFunctions:
         def trace_node_quadrature_weight(node_index_in_element: int):
             node_type, type_index = self.node_type_and_type_index(node_index_in_element)
 
-            return wp.select(node_type == Triangle2DPolynomialShapeFunctions.VERTEX, EDGE_WEIGHT, VERTEX_WEIGHT)
+            return wp.select(node_type == TrianglePolynomialShapeFunctions.VERTEX, EDGE_WEIGHT, VERTEX_WEIGHT)
 
         return trace_node_quadrature_weight
 
@@ -172,7 +200,7 @@ class Triangle2DPolynomialShapeFunctions:
         ):
             node_type, type_index = self.node_type_and_type_index(node_index_in_elt)
 
-            if node_type == Triangle2DPolynomialShapeFunctions.VERTEX:
+            if node_type == TrianglePolynomialShapeFunctions.VERTEX:
                 # Vertex
                 return coords[type_index] * (2.0 * coords[type_index] - 1.0)
 
@@ -187,11 +215,11 @@ class Triangle2DPolynomialShapeFunctions:
         ):
             node_type, type_index = self.node_type_and_type_index(node_index_in_elt)
 
-            if node_type == Triangle2DPolynomialShapeFunctions.VERTEX:
+            if node_type == TrianglePolynomialShapeFunctions.VERTEX:
                 # Vertex
                 return 0.5 * coords[type_index] * (3.0 * coords[type_index] - 1.0) * (3.0 * coords[type_index] - 2.0)
 
-            elif node_type == Triangle2DPolynomialShapeFunctions.EDGE:
+            elif node_type == TrianglePolynomialShapeFunctions.EDGE:
                 # Edge
                 edge = type_index // 2
                 k = type_index - 2 * edge
@@ -233,7 +261,7 @@ class Triangle2DPolynomialShapeFunctions:
 
             dw_dc = wp.vec3(0.0)
 
-            if node_type == Triangle2DPolynomialShapeFunctions.VERTEX:
+            if node_type == TrianglePolynomialShapeFunctions.VERTEX:
                 # Vertex
                 dw_dc[type_index] = 4.0 * coords[type_index] - 1.0
 
@@ -255,13 +283,13 @@ class Triangle2DPolynomialShapeFunctions:
 
             dw_dc = wp.vec3(0.0)
 
-            if node_type == Triangle2DPolynomialShapeFunctions.VERTEX:
+            if node_type == TrianglePolynomialShapeFunctions.VERTEX:
                 # Vertex
                 dw_dc[type_index] = (
                     0.5 * 27.0 * coords[type_index] * coords[type_index] - 9.0 * coords[type_index] + 1.0
                 )
 
-            elif node_type == Triangle2DPolynomialShapeFunctions.EDGE:
+            elif node_type == TrianglePolynomialShapeFunctions.EDGE:
                 # Edge
                 edge = type_index // 2
                 k = type_index - 2 * edge
@@ -318,9 +346,9 @@ class Triangle2DPolynomialShapeFunctions:
         return cells[np.newaxis, :], np.array([cell_type], dtype=np.int8)
 
 
-class Triangle2DNonConformingPolynomialShapeFunctions:
+class TriangleNonConformingPolynomialShapeFunctions(ShapeFunction):
     def __init__(self, degree: int):
-        self._tri_shape = Triangle2DPolynomialShapeFunctions(degree=degree)
+        self._tri_shape = TrianglePolynomialShapeFunctions(degree=degree)
         self.ORDER = self._tri_shape.ORDER
         self.NODES_PER_ELEMENT = self._tri_shape.NODES_PER_ELEMENT
 
@@ -346,7 +374,7 @@ class Triangle2DNonConformingPolynomialShapeFunctions:
 
     @property
     def name(self) -> str:
-        return f"Tri_P{self.ORDER}d"
+        return f"Tri_dP{self.ORDER}"
 
     def make_node_quadrature_weight(self):
         # Intrinsic quadrature -- precomputed integral of node shape functions
@@ -373,9 +401,9 @@ class Triangle2DNonConformingPolynomialShapeFunctions:
         def node_quadrature_weight(node_index_in_element: int):
             node_type, type_index = self._tri_shape.node_type_and_type_index(node_index_in_element)
 
-            if node_type == Triangle2DPolynomialShapeFunctions.VERTEX:
+            if node_type == TrianglePolynomialShapeFunctions.VERTEX:
                 return VERTEX_WEIGHT
-            elif node_type == Triangle2DPolynomialShapeFunctions.EDGE:
+            elif node_type == TrianglePolynomialShapeFunctions.EDGE:
                 return EDGE_WEIGHT
 
             return INTERIOR_WEIGHT
@@ -436,3 +464,194 @@ class Triangle2DNonConformingPolynomialShapeFunctions:
             return INV_TRI_SCALE * grad
 
         return element_inner_weight_gradient
+
+
+class TriangleNedelecFirstKindShapeFunctions(TriangleShapeFunction):
+    value = ShapeFunction.Value.CovariantVector
+
+    def __init__(self, degree: int):
+        if degree != 1:
+            raise NotImplementedError("Only linear Nédélec implemented right now")
+
+        self.ORDER = wp.constant(degree)
+
+        self.NODES_PER_ELEMENT = wp.constant(3)
+        self.NODES_PER_SIDE = wp.constant(1)
+
+        self.VERTEX_NODE_COUNT = wp.constant(0)
+        self.EDGE_NODE_COUNT = wp.constant(1)
+        self.INTERIOR_NODE_COUNT = wp.constant(0)
+
+        self.node_type_and_type_index = self._get_node_type_and_type_index()
+
+    @property
+    def name(self) -> str:
+        return f"TriN1_{self.ORDER}"
+
+    def _get_node_type_and_type_index(self):
+        @cache.dynamic_func(suffix=self.name)
+        def node_type_and_index(
+            node_index_in_elt: int,
+        ):
+            return TriangleShapeFunction.EDGE, node_index_in_elt
+
+        return node_type_and_index
+
+    def make_node_coords_in_element(self):
+        @cache.dynamic_func(suffix=self.name)
+        def node_coords_in_element(
+            node_index_in_elt: int,
+        ):
+            coords = Coords(0.5)
+            coords[(node_index_in_elt + 2) % 3] = 0.0
+            return coords
+
+        return node_coords_in_element
+
+    def make_node_quadrature_weight(self):
+        NODES_PER_ELEMENT = self.NODES_PER_ELEMENT
+
+        @cache.dynamic_func(suffix=self.name)
+        def node_quadrature_weight(node_index_in_element: int):
+            return 1.0 / float(NODES_PER_ELEMENT)
+
+        return node_quadrature_weight
+
+    def make_trace_node_quadrature_weight(self):
+        NODES_PER_SIDE = self.NODES_PER_SIDE
+
+        @cache.dynamic_func(suffix=self.name)
+        def trace_node_quadrature_weight(node_index_in_element: int):
+            return 1.0 / float(NODES_PER_SIDE)
+
+        return trace_node_quadrature_weight
+
+    @wp.func
+    def _vertex_coords(vidx: int):
+        return wp.vec2(
+            float(vidx == 1),
+            float(vidx == 2),
+        )
+
+    def make_element_inner_weight(self):
+        ORDER = self.ORDER
+
+        def element_inner_weight_linear(
+            coords: Coords,
+            node_index_in_elt: int,
+        ):
+            x = wp.vec2(coords[1], coords[2])
+            p = self._vertex_coords((node_index_in_elt + 2) % 3)
+
+            d = x - p
+            return wp.vec2(-d[1], d[0])
+
+        if ORDER == 1:
+            return cache.get_func(element_inner_weight_linear, self.name)
+
+        return None
+
+    def make_element_inner_weight_gradient(self):
+        ROT = wp.constant(wp.mat22f(0.0, -1.0, 1.0, 0.0))
+
+        def element_inner_weight_gradient_linear(
+            coords: Coords,
+            node_index_in_elt: int,
+        ):
+            return ROT
+
+        if self.ORDER == 1:
+            return cache.get_func(element_inner_weight_gradient_linear, self.name)
+
+        return None
+
+
+class TriangleRaviartThomasShapeFunctions(TriangleShapeFunction):
+    value = ShapeFunction.Value.ContravariantVector
+
+    def __init__(self, degree: int):
+        if degree != 1:
+            raise NotImplementedError("Only linear Raviart-Thomas implemented right now")
+
+        self.ORDER = wp.constant(degree)
+
+        self.NODES_PER_ELEMENT = wp.constant(3)
+        self.NODES_PER_SIDE = wp.constant(1)
+
+        self.VERTEX_NODE_COUNT = wp.constant(0)
+        self.EDGE_NODE_COUNT = wp.constant(1)
+        self.INTERIOR_NODE_COUNT = wp.constant(0)
+
+        self.node_type_and_type_index = self._get_node_type_and_type_index()
+
+    @property
+    def name(self) -> str:
+        return f"TriRT_{self.ORDER}"
+
+    def _get_node_type_and_type_index(self):
+        @cache.dynamic_func(suffix=self.name)
+        def node_type_and_index(
+            node_index_in_elt: int,
+        ):
+            return TriangleShapeFunction.EDGE, node_index_in_elt
+
+        return node_type_and_index
+
+    def make_node_coords_in_element(self):
+        @cache.dynamic_func(suffix=self.name)
+        def node_coords_in_element(
+            node_index_in_elt: int,
+        ):
+            coords = Coords(0.5)
+            coords[(node_index_in_elt + 2) % 3] = 0.0
+            return coords
+
+        return node_coords_in_element
+
+    def make_node_quadrature_weight(self):
+        NODES_PER_ELEMENT = self.NODES_PER_ELEMENT
+
+        @cache.dynamic_func(suffix=self.name)
+        def node_quadrature_weight(node_index_in_element: int):
+            return 1.0 / float(NODES_PER_ELEMENT)
+
+        return node_quadrature_weight
+
+    def make_trace_node_quadrature_weight(self):
+        NODES_PER_SIDE = self.NODES_PER_SIDE
+
+        @cache.dynamic_func(suffix=self.name)
+        def trace_node_quadrature_weight(node_index_in_element: int):
+            return 1.0 / float(NODES_PER_SIDE)
+
+        return trace_node_quadrature_weight
+
+    def make_element_inner_weight(self):
+        ORDER = self.ORDER
+
+        def element_inner_weight_linear(
+            coords: Coords,
+            node_index_in_elt: int,
+        ):
+            x = wp.vec2(coords[1], coords[2])
+            p = self._vertex_coords((node_index_in_elt + 2) % 3)
+
+            d = x - p
+            return d
+
+        if ORDER == 1:
+            return cache.get_func(element_inner_weight_linear, self.name)
+
+        return None
+
+    def make_element_inner_weight_gradient(self):
+        def element_inner_weight_gradient_linear(
+            coords: Coords,
+            node_index_in_elt: int,
+        ):
+            return wp.identity(n=2, dtype=float)
+
+        if self.ORDER == 1:
+            return cache.get_func(element_inner_weight_gradient_linear, self.name)
+
+        return None

warp/fem/space/tetmesh_function_space.py

@@ -6,6 +6,7 @@ from warp.fem.types import ElementIndex
 from .shape import (
     ShapeFunction,
     TetrahedronPolynomialShapeFunctions,
+    TetrahedronShapeFunction,
 )
 from .topology import SpaceTopology, forward_base_topology
 
@@ -15,6 +16,7 @@ class TetmeshTopologyArg:
     tet_edge_indices: wp.array2d(dtype=int)
     tet_face_indices: wp.array2d(dtype=int)
     face_vertex_indices: wp.array(dtype=wp.vec3i)
+    face_tet_indices: wp.array(dtype=wp.vec2i)
 
     vertex_count: int
     edge_count: int
@@ -27,13 +29,14 @@ class TetmeshSpaceTopology(SpaceTopology):
     def __init__(
         self,
         mesh: Tetmesh,
-        shape: ShapeFunction,
-        need_tet_edge_indices: bool = True,
-        need_tet_face_indices: bool = True,
+        shape: TetrahedronShapeFunction,
     ):
+        self._shape = shape
         super().__init__(mesh, shape.NODES_PER_ELEMENT)
         self._mesh = mesh
-        self._shape = shape
+
+        need_tet_edge_indices = self._shape.EDGE_NODE_COUNT > 0
+        need_tet_face_indices = self._shape.FACE_NODE_COUNT > 0
 
         if need_tet_edge_indices:
             self._tet_edge_indices = self._mesh.tet_edge_indices
@@ -47,12 +50,20 @@ class TetmeshSpaceTopology(SpaceTopology):
         else:
             self._tet_face_indices = wp.empty(shape=(0, 0), dtype=int)
 
+        self.element_node_index = self._make_element_node_index()
+        self.element_node_sign = self._make_element_node_sign()
+
+    @property
+    def name(self):
+        return f"{self.geometry.name}_{self._shape.name}"
+
     @cache.cached_arg_value
     def topo_arg_value(self, device):
         arg = TetmeshTopologyArg()
         arg.tet_face_indices = self._tet_face_indices.to(device)
         arg.tet_edge_indices = self._tet_edge_indices.to(device)
         arg.face_vertex_indices = self._mesh.face_vertex_indices.to(device)
+        arg.face_tet_indices = self._mesh.face_tet_indices.to(device)
 
         arg.vertex_count = self._mesh.vertex_count()
         arg.face_count = self._mesh.side_count()
@@ -126,31 +137,19 @@ class TetmeshSpaceTopology(SpaceTopology):
             t1_face = TetmeshSpaceTopology._find_face_index_in_tet(face_vtx, t1_vtx)
             tet_face_indices[t1, t1_face] = e
 
-
-class TetmeshPolynomialSpaceTopology(TetmeshSpaceTopology):
-    def __init__(self, mesh: Tetmesh, shape: TetrahedronPolynomialShapeFunctions):
-        super().__init__(mesh, shape, need_tet_edge_indices=shape.ORDER >= 2, need_tet_face_indices=shape.ORDER >= 3)
-
-        self.element_node_index = self._make_element_node_index()
-
     def node_count(self) -> int:
-        ORDER = self._shape.ORDER
-        INTERIOR_NODES_PER_EDGE = max(0, ORDER - 1)
-        INTERIOR_NODES_PER_FACE = max(0, ORDER - 2) * max(0, ORDER - 1) // 2
-        INTERIOR_NODES_PER_CELL = max(0, ORDER - 3) * max(0, ORDER - 2) * max(0, ORDER - 1) // 6
-
         return (
-            self._mesh.vertex_count()
-            + self._mesh.edge_count() * INTERIOR_NODES_PER_EDGE
-            + self._mesh.side_count() * INTERIOR_NODES_PER_FACE
-            + self._mesh.cell_count() * INTERIOR_NODES_PER_CELL
+            self._mesh.vertex_count() * self._shape.VERTEX_NODE_COUNT
+            + self._mesh.edge_count() * self._shape.EDGE_NODE_COUNT
+            + self._mesh.side_count() * self._shape.FACE_NODE_COUNT
+            + self._mesh.cell_count() * self._shape.INTERIOR_NODE_COUNT
         )
 
     def _make_element_node_index(self):
-        ORDER = self._shape.ORDER
-        INTERIOR_NODES_PER_EDGE = wp.constant(max(0, ORDER - 1))
-        INTERIOR_NODES_PER_FACE = wp.constant(max(0, ORDER - 2) * max(0, ORDER - 1) // 2)
-        INTERIOR_NODES_PER_CELL = wp.constant(max(0, ORDER - 3) * max(0, ORDER - 2) * max(0, ORDER - 1) // 6)
+        VERTEX_NODE_COUNT = self._shape.VERTEX_NODE_COUNT
+        INTERIOR_NODES_PER_EDGE = self._shape.EDGE_NODE_COUNT
+        INTERIOR_NODES_PER_FACE = self._shape.FACE_NODE_COUNT
+        INTERIOR_NODES_PER_CELL = self._shape.INTERIOR_NODE_COUNT
 
         @cache.dynamic_func(suffix=self.name)
         def element_node_index(
@@ -162,9 +161,11 @@ class TetmeshPolynomialSpaceTopology(TetmeshSpaceTopology):
             node_type, type_index = self._shape.node_type_and_type_index(node_index_in_elt)
 
             if node_type == TetrahedronPolynomialShapeFunctions.VERTEX:
-                return geo_arg.tet_vertex_indices[element_index][type_index]
+                vertex = type_index // VERTEX_NODE_COUNT
+                vertex_node = type_index - VERTEX_NODE_COUNT * vertex
+                return geo_arg.tet_vertex_indices[element_index][vertex] * VERTEX_NODE_COUNT + vertex_node
 
-            global_offset = topo_arg.vertex_count
+            global_offset = topo_arg.vertex_count * VERTEX_NODE_COUNT
 
             if node_type == TetrahedronPolynomialShapeFunctions.EDGE:
                 edge = type_index // INTERIOR_NODES_PER_EDGE
@@ -173,14 +174,8 @@ class TetmeshPolynomialSpaceTopology(TetmeshSpaceTopology):
                 global_edge_index = topo_arg.tet_edge_indices[element_index][edge]
 
                 # Test if we need to swap edge direction
-                if INTERIOR_NODES_PER_EDGE > 1:
-                    if edge < 3:
-                        c1 = edge
-                        c2 = (edge + 1) % 3
-                    else:
-                        c1 = edge - 3
-                        c2 = 3
-
+                if wp.static(INTERIOR_NODES_PER_EDGE > 1):
+                    c1, c2 = TetrahedronShapeFunction.edge_vidx(edge)
                     if geo_arg.tet_vertex_indices[element_index][c1] > geo_arg.tet_vertex_indices[element_index][c2]:
                         edge_node = INTERIOR_NODES_PER_EDGE - 1 - edge_node
 
@@ -194,7 +189,7 @@ class TetmeshPolynomialSpaceTopology(TetmeshSpaceTopology):
 
                 global_face_index = topo_arg.tet_face_indices[element_index][face]
 
-                if INTERIOR_NODES_PER_FACE == 3:
+                if wp.static(INTERIOR_NODES_PER_FACE == 3):
                     # Hard code for P4 case, 3 nodes per face
                     # Higher orders would require rotating triangle coordinates, this is not supported yet
 
@@ -216,9 +211,46 @@ class TetmeshPolynomialSpaceTopology(TetmeshSpaceTopology):
 
         return element_node_index
 
+    def _make_element_node_sign(self):
+        INTERIOR_NODES_PER_EDGE = self._shape.EDGE_NODE_COUNT
+        INTERIOR_NODES_PER_FACE = self._shape.FACE_NODE_COUNT
+
+        @cache.dynamic_func(suffix=self.name)
+        def element_node_sign(
+            geo_arg: self.geometry.CellArg,
+            topo_arg: TetmeshTopologyArg,
+            element_index: ElementIndex,
+            node_index_in_elt: int,
+        ):
+            node_type, type_index = self._shape.node_type_and_type_index(node_index_in_elt)
+
+            if wp.static(INTERIOR_NODES_PER_EDGE > 0):
+                if node_type == TetrahedronShapeFunction.EDGE:
+                    edge = type_index // INTERIOR_NODES_PER_EDGE
+                    c1, c2 = TetrahedronShapeFunction.edge_vidx(edge)
+
+                    return wp.select(
+                        geo_arg.tet_vertex_indices[element_index][c1] > geo_arg.tet_vertex_indices[element_index][c2],
+                        1.0,
+                        -1.0,
+                    )
+
+            if wp.static(INTERIOR_NODES_PER_FACE > 0):
+                if node_type == TetrahedronShapeFunction.FACE:
+                    face = type_index // INTERIOR_NODES_PER_FACE
+
+                    global_face_index = topo_arg.tet_face_indices[element_index][face]
+                    inner = topo_arg.face_tet_indices[global_face_index][0]
+
+                    return wp.select(inner == element_index, -1.0, 1.0)
+
+            return 1.0
+
+        return element_node_sign
+
 
 def make_tetmesh_space_topology(mesh: Tetmesh, shape: ShapeFunction):
-    if isinstance(shape, TetrahedronPolynomialShapeFunctions):
-        return forward_base_topology(TetmeshPolynomialSpaceTopology, mesh, shape)
+    if isinstance(shape, TetrahedronShapeFunction):
+        return forward_base_topology(TetmeshSpaceTopology, mesh, shape)
 
     raise ValueError(f"Unsupported shape function {shape.name}")

warp/fem/space/topology.py

@@ -37,6 +37,7 @@ class SpaceTopology:
         self.ElementArg = geometry.CellArg
 
         self._make_constant_element_node_count()
+        self._make_constant_element_node_sign()
 
     @property
     def geometry(self) -> Geometry:
@@ -176,6 +177,18 @@ class SpaceTopology:
         self.element_node_count = constant_element_node_count
         self.side_neighbor_node_counts = constant_side_neighbor_node_counts
 
+    def _make_constant_element_node_sign(self):
+        @cache.dynamic_func(suffix=self.name)
+        def constant_element_node_sign(
+            geo_arg: self.geometry.CellArg,
+            topo_arg: self.TopologyArg,
+            element_index: ElementIndex,
+            node_index_in_element: int,
+        ):
+            return 1.0
+
+        self.element_node_sign = constant_element_node_sign
+
 
 class TraceSpaceTopology(SpaceTopology):
     """Auto-generated trace topology defining the node indices associated to the geometry sides"""
@@ -267,6 +280,21 @@ class TraceSpaceTopology(SpaceTopology):
 
         return trace_element_node_index
 
+    def _make_element_node_sign(self):
+        @cache.dynamic_func(suffix=self.name)
+        def trace_element_node_sign(
+            geo_side_arg: self.geometry.SideArg,
+            topo_arg: self._topo.TopologyArg,
+            element_index: ElementIndex,
+            node_index_in_elt: int,
+        ):
+            cell_index, index_in_cell = self.neighbor_cell_index(geo_side_arg, element_index, node_index_in_elt)
+
+            geo_cell_arg = self.geometry.side_to_cell_arg(geo_side_arg)
+            return self._topo.element_node_sign(geo_cell_arg, topo_arg, cell_index, index_in_cell)
+
+        return trace_element_node_sign
+
     def full_space_topology(self) -> SpaceTopology:
         """Returns the full space topology from which this topology is derived"""
         return self._topo
@@ -351,8 +379,18 @@ class DeformedGeometrySpaceTopology(SpaceTopology):
             inner_count, outer_count = self.base.side_neighbor_node_counts(side_arg.base_arg, element_index)
             return inner_count, outer_count
 
+        @cache.dynamic_func(suffix=self.name)
+        def element_node_sign(
+            elt_arg: self.geometry.CellArg,
+            topo_arg: self.TopologyArg,
+            element_index: ElementIndex,
+            node_index_in_elt: int,
+        ):
+            return self.base.element_node_sign(elt_arg.elt_arg, topo_arg, element_index, node_index_in_elt)
+
         self.element_node_index = element_node_index
         self.element_node_count = element_node_count
+        self.element_node_sign = element_node_sign
         self.side_neighbor_node_counts = side_neighbor_node_counts