Revert ridgevectors to edgevectors

ffcx/codegeneration/access.py

@@ -40,14 +40,14 @@ def __init__(self, entity_type: str, integral_type: str, symbols, options):
             ufl.geometry.CellCoordinate: self.cell_coordinate,
             ufl.geometry.FacetCoordinate: self.facet_coordinate,
             ufl.geometry.CellVertices: self.cell_vertices,
-            ufl.geometry.FacetEdgeVectors: self.facet_ridge_vectors,
-            ufl.geometry.CellEdgeVectors: self.cell_ridge_vectors,
+            ufl.geometry.FacetEdgeVectors: self.facet_edge_vectors,
+            ufl.geometry.CellEdgeVectors: self.cell_edge_vectors,
             ufl.geometry.CellFacetJacobian: self.cell_facet_jacobian,
             ufl.geometry.CellRidgeJacobian: self.cell_ridge_jacobian,
             ufl.geometry.ReferenceCellVolume: self.reference_cell_volume,
             ufl.geometry.ReferenceFacetVolume: self.reference_facet_volume,
-            ufl.geometry.ReferenceCellEdgeVectors: self.reference_cell_ridge_vectors,
-            ufl.geometry.ReferenceFacetEdgeVectors: self.reference_facet_ridge_vectors,
+            ufl.geometry.ReferenceCellEdgeVectors: self.reference_cell_edge_vectors,
+            ufl.geometry.ReferenceFacetEdgeVectors: self.reference_facet_edge_vectors,
             ufl.geometry.ReferenceNormal: self.reference_normal,
             ufl.geometry.CellOrientation: self._pass,
             ufl.geometry.FacetOrientation: self.facet_orientation,
@@ -258,11 +258,11 @@ def cell_ridge_jacobian(self, mt, tabledata, num_points):
         else:
             raise RuntimeError(f"Unhandled cell types {cellname}.")
 
-    def reference_cell_ridge_vectors(self, mt, tabledata, num_points):
+    def reference_cell_edge_vectors(self, mt, tabledata, num_points):
         """Access a reference cell ridge vector."""
         cellname = ufl.domain.extract_unique_domain(mt.terminal).ufl_cell().cellname()
         if cellname in ("triangle", "tetrahedron", "quadrilateral", "hexahedron"):
-            table = L.Symbol(f"{cellname}_reference_cell_ridge_vectors", dtype=L.DataType.REAL)
+            table = L.Symbol(f"{cellname}_reference_cell_edge_vectors", dtype=L.DataType.REAL)
             return table[mt.component[0]][mt.component[1]]
         elif cellname == "interval":
             raise RuntimeError(
@@ -271,11 +271,11 @@ def reference_cell_ridge_vectors(self, mt, tabledata, num_points):
         else:
             raise RuntimeError(f"Unhandled cell types {cellname}.")
 
-    def reference_facet_ridge_vectors(self, mt, tabledata, num_points):
+    def reference_facet_edge_vectors(self, mt, tabledata, num_points):
         """Access a reference facet ridge vector."""
         cellname = ufl.domain.extract_unique_domain(mt.terminal).ufl_cell().cellname()
         if cellname in ("tetrahedron", "hexahedron"):
-            table = L.Symbol(f"{cellname}_reference_facet_ridge_vectors", dtype=L.DataType.REAL)
+            table = L.Symbol(f"{cellname}_reference_facet_edge_vectors", dtype=L.DataType.REAL)
             return table[mt.component[0]][mt.component[1]]
         elif cellname in ("interval", "triangle", "quadrilateral"):
             raise RuntimeError(
@@ -319,7 +319,7 @@ def cell_vertices(self, mt, tabledata, num_points):
         expr = self.symbols.domain_dof_access(dof, component, gdim, num_scalar_dofs, mt.restriction)
         return expr
 
-    def cell_ridge_vectors(self, mt, tabledata, num_points):
+    def cell_edge_vectors(self, mt, tabledata, num_points):
         """Access a cell ridge vector."""
         # Get properties of domain
         domain = ufl.domain.extract_unique_domain(mt.terminal)
@@ -359,7 +359,7 @@ def cell_ridge_vectors(self, mt, tabledata, num_points):
             dof0, component, gdim, num_scalar_dofs, mt.restriction
         ) - self.symbols.domain_dof_access(dof1, component, gdim, num_scalar_dofs, mt.restriction)
 
-    def facet_ridge_vectors(self, mt, tabledata, num_points):
+    def facet_edge_vectors(self, mt, tabledata, num_points):
         """Access a facet ridge vector."""
         # Get properties of domain
         domain = ufl.domain.extract_unique_domain(mt.terminal)

ffcx/codegeneration/expression_generator.py

@@ -62,12 +62,12 @@ def generate(self):
     def generate_geometry_tables(self):
         """Generate static tables of geometry data."""
         ufl_geometry = {
-            ufl.geometry.FacetEdgeVectors: "facet_ridge_vectors",
+            ufl.geometry.FacetEdgeVectors: "facet_edge_vectors",
             ufl.geometry.CellFacetJacobian: "cell_facet_jacobian",
             ufl.geometry.ReferenceCellVolume: "reference_cell_volume",
             ufl.geometry.ReferenceFacetVolume: "reference_facet_volume",
-            ufl.geometry.ReferenceCellEdgeVectors: "reference_cell_ridge_vectors",
-            ufl.geometry.ReferenceFacetEdgeVectors: "reference_facet_ridge_vectors",
+            ufl.geometry.ReferenceCellEdgeVectors: "reference_cell_edge_vectors",
+            ufl.geometry.ReferenceFacetEdgeVectors: "reference_facet_edge_vectors",
             ufl.geometry.ReferenceNormal: "reference_normals",
         }
 

ffcx/codegeneration/geometry.py

@@ -23,10 +23,10 @@ def write_table(tablename, cellname):
         return reference_cell_volume(tablename, cellname)
     if tablename == "reference_facet_volume":
         return reference_facet_volume(tablename, cellname)
-    if tablename == "reference_cell_ridge_vectors":
-        return reference_cell_ridge_vectors(tablename, cellname)
-    if tablename == "reference_facet_ridge_vectors":
-        return reference_facet_ridge_vectors(tablename, cellname)
+    if tablename == "reference_cell_edge_vectors":
+        return reference_cell_edge_vectors(tablename, cellname)
+    if tablename == "reference_facet_edge_vectors":
+        return reference_facet_edge_vectors(tablename, cellname)
     if tablename == "reference_normals":
         return reference_normals(tablename, cellname)
     if tablename == "facet_orientation":
@@ -93,18 +93,18 @@ def reference_facet_volume(tablename, cellname):
     return L.VariableDecl(symbol, volumes[0])
 
 
-def reference_cell_ridge_vectors(tablename, cellname):
+def reference_cell_edge_vectors(tablename, cellname):
     """Write reference ridge vectors."""
     celltype = getattr(basix.CellType, cellname)
     topology = basix.topology(celltype)
     geometry = basix.geometry(celltype)
-    ridge_vectors = [geometry[j] - geometry[i] for i, j in topology[1]]
-    out = np.array(ridge_vectors)
+    edge_vectors = [geometry[j] - geometry[i] for i, j in topology[1]]
+    out = np.array(edge_vectors)
     symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)
     return L.ArrayDecl(symbol, values=out, const=True)
 
 
-def reference_facet_ridge_vectors(tablename, cellname):
+def reference_facet_edge_vectors(tablename, cellname):
     """Write facet reference ridge vectors."""
     celltype = getattr(basix.CellType, cellname)
     topology = basix.topology(celltype)
@@ -115,18 +115,18 @@ def reference_facet_ridge_vectors(tablename, cellname):
     if len(topology) != 4:
         raise ValueError("Can only get facet ridges for 3D cells.")
 
-    ridge_vectors = []
+    edge_vectors = []
     for facet in topology[-2]:
         if len(facet) == 3:
-            ridge_vectors += [geometry[facet[j]] - geometry[facet[i]] for i, j in triangle_ridges]
+            edge_vectors += [geometry[facet[j]] - geometry[facet[i]] for i, j in triangle_ridges]
         elif len(facet) == 4:
-            ridge_vectors += [
+            edge_vectors += [
                 geometry[facet[j]] - geometry[facet[i]] for i, j in quadrilateral_ridges
             ]
         else:
             raise ValueError("Only triangular and quadrilateral faces supported.")
 
-    out = np.array(ridge_vectors)
+    out = np.array(edge_vectors)
     symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)
     return L.ArrayDecl(symbol, values=out, const=True)