FEniCS · schnellerhase · Oct 23, 2025 · Jun 25, 2025 · Jun 25, 2025 · Jun 25, 2025
diff --git a/doc/source/manual/form_language.rst b/doc/source/manual/form_language.rst
@@ -477,7 +477,7 @@ represents an :math:`n\times n` unit matrix of given size :math:`n`,
 as in this example::
 
   # Geometric dimension
-  d = cell.geometric_dimension()
+  d = cell.geometric_dimension
 
   # d x d identiy matrix
   I = Identity(d)
@@ -671,7 +671,7 @@ single expression with free indices that should map to tensor axes,
 like mapping :math:`v_k` to :math:`\mathbf{v}` or :math:`A_{ij}` to
 :math:`\mathbf{A}`, the following examples show how this is done::
 
-  vk = Identity(cell.geometric_dimension())[0,k]
+  vk = Identity(cell.geometric_dimension)[0,k]
   v = as_tensor(vk, (k,))
 
   Aij = v[i]*u[j]

diff --git a/test/test_automatic_differentiation.py b/test/test_automatic_differentiation.py
@@ -628,7 +628,7 @@ def xtest_derivative_grad_coeff_with_variation_components(self, d_expr):
 @pytest.mark.parametrize("lower_geo", [True, False])
 @pytest.mark.parametrize("apply_deriv", [True, False])
 def test_diff_grad_jacobian(cell, gdim, order, lower_alg, lower_geo, apply_deriv):
-    tdim = cell.topological_dimension()
+    tdim = cell.topological_dimension
 
     domain = Mesh(LagrangeElement(cell, order, (gdim,)))
 
@@ -678,7 +678,7 @@ def test_diff_grad_jacobian(cell, gdim, order, lower_alg, lower_geo, apply_deriv
 @pytest.mark.parametrize("lower_geo", [True, False])
 @pytest.mark.parametrize("apply_deriv", [True, False])
 def test_diff_grad_grad_jacobian(cell, gdim, order, lower_alg, lower_geo, apply_deriv):
-    tdim = cell.topological_dimension()
+    tdim = cell.topological_dimension
 
     domain = Mesh(LagrangeElement(cell, order, (gdim,)))
 

diff --git a/test/test_cell.py b/test/test_cell.py
@@ -5,83 +5,83 @@
 
 def test_interval():
     cell = ufl.interval
-    assert cell.num_vertices() == 2
-    assert cell.num_edges() == 1
-    assert cell.num_faces() == 0
+    assert cell.num_vertices == 2
+    assert cell.num_edges == 1
+    assert cell.num_faces == 0
 
 
 def test_triangle():
     cell = ufl.triangle
-    assert cell.num_vertices() == 3
-    assert cell.num_edges() == 3
-    assert cell.num_faces() == 1
+    assert cell.num_vertices == 3
+    assert cell.num_edges == 3
+    assert cell.num_faces == 1
 
 
 def test_quadrilateral():
     cell = ufl.quadrilateral
-    assert cell.num_vertices() == 4
-    assert cell.num_edges() == 4
-    assert cell.num_faces() == 1
+    assert cell.num_vertices == 4
+    assert cell.num_edges == 4
+    assert cell.num_faces == 1
 
 
 def test_tetrahedron():
     cell = ufl.tetrahedron
-    assert cell.num_vertices() == 4
-    assert cell.num_edges() == 6
-    assert cell.num_faces() == 4
+    assert cell.num_vertices == 4
+    assert cell.num_edges == 6
+    assert cell.num_faces == 4
 
 
 def test_hexahedron():
     cell = ufl.hexahedron
-    assert cell.num_vertices() == 8
-    assert cell.num_edges() == 12
-    assert cell.num_faces() == 6
+    assert cell.num_vertices == 8
+    assert cell.num_edges == 12
+    assert cell.num_faces == 6
 
 
 def test_pentatope():
     cell = ufl.pentatope
-    assert cell.num_vertices() == 5
-    assert cell.num_edges() == 10
-    assert cell.num_faces() == 10
+    assert cell.num_vertices == 5
+    assert cell.num_edges == 10
+    assert cell.num_faces == 10
 
 
 def test_tesseract():
     cell = ufl.tesseract
-    assert cell.num_vertices() == 16
-    assert cell.num_edges() == 32
-    assert cell.num_faces() == 24
+    assert cell.num_vertices == 16
+    assert cell.num_edges == 32
+    assert cell.num_faces == 24
 
 
 @pytest.mark.parametrize("cell", [ufl.interval])
 def test_cells_1d(cell):
-    assert cell.num_facets() == cell.num_vertices()
-    assert cell.num_ridges() == 0
-    assert cell.num_peaks() == 0
+    assert cell.num_facets == cell.num_vertices
+    assert cell.num_ridges == 0
+    assert cell.num_peaks == 0
 
 
 @pytest.mark.parametrize("cell", [ufl.triangle, ufl.quadrilateral])
 def test_cells_2d(cell):
-    assert cell.num_facets() == cell.num_edges()
-    assert cell.num_ridges() == cell.num_vertices()
-    assert cell.num_peaks() == 0
+    assert cell.num_facets == cell.num_edges
+    assert cell.num_ridges == cell.num_vertices
+    assert cell.num_peaks == 0
 
 
 @pytest.mark.parametrize("cell", [ufl.tetrahedron, ufl.hexahedron, ufl.prism, ufl.pyramid])
 def test_cells_3d(cell):
-    assert cell.num_facets() == cell.num_faces()
-    assert cell.num_ridges() == cell.num_edges()
-    assert cell.num_peaks() == cell.num_vertices()
+    assert cell.num_facets == cell.num_faces
+    assert cell.num_ridges == cell.num_edges
+    assert cell.num_peaks == cell.num_vertices
 
 
 @pytest.mark.parametrize("cell", [ufl.tesseract, ufl.pentatope])
 def test_cells_4d(cell):
-    assert cell.num_facets() == cell.num_sub_entities(3)
-    assert cell.num_ridges() == cell.num_faces()
-    assert cell.num_peaks() == cell.num_edges()
+    assert cell.num_facets == cell.num_sub_entities(3)
+    assert cell.num_ridges == cell.num_faces
+    assert cell.num_peaks == cell.num_edges
 
 
 def test_tensorproductcell():
     orig = ufl.TensorProductCell(ufl.interval, ufl.interval)
     cell = orig.reconstruct()
-    assert cell.sub_cells() == orig.sub_cells()
-    assert cell.topological_dimension() == orig.topological_dimension()
+    assert cell.sub_cells == orig.sub_cells
+    assert cell.topological_dimension == orig.topological_dimension
diff --git a/test/test_derivative.py b/test/test_derivative.py
@@ -109,11 +109,11 @@ def make_value(c):
     acell = adomain.ufl_cell()
     bcell = bdomain.ufl_cell()
     assert acell == bcell
-    if adomain.geometric_dimension() == 1:
+    if adomain.geometric_dimension == 1:
         x = (0.3,)
-    elif adomain.geometric_dimension() == 2:
+    elif adomain.geometric_dimension == 2:
         x = (0.3, 0.4)
-    elif adomain.geometric_dimension() == 3:
+    elif adomain.geometric_dimension == 3:
         x = (0.3, 0.4, 0.5)
     av = a(x, amapping)
     bv = b(x, bmapping)

diff --git a/test/test_domains.py b/test/test_domains.py
@@ -36,13 +36,13 @@
 
 def test_construct_domains_from_cells():
     for cell in all_cells:
-        d = cell.topological_dimension()
+        d = cell.topological_dimension
         Mesh(LagrangeElement(cell, 1, (d,)))
 
 
 def test_construct_domains_with_names():
     for cell in all_cells:
-        d = cell.topological_dimension()
+        d = cell.topological_dimension
         e = LagrangeElement(cell, 1, (d,))
         D2 = Mesh(e, ufl_id=2)
         D3 = Mesh(e, ufl_id=3)
@@ -56,30 +56,30 @@ def test_domains_sort_by_name():
     # working
     domains1 = [
         Mesh(
-            LagrangeElement(cell, 1, (cell.topological_dimension(),)),
-            ufl_id=hash(cell.cellname()),
+            LagrangeElement(cell, 1, (cell.topological_dimension,)),
+            ufl_id=hash(cell.cellname),
         )
         for cell in all_cells
     ]
     domains2 = [
         Mesh(
-            LagrangeElement(cell, 1, (cell.topological_dimension(),)),
-            ufl_id=hash(cell.cellname()),
+            LagrangeElement(cell, 1, (cell.topological_dimension,)),
+            ufl_id=hash(cell.cellname),
         )
         for cell in sorted(all_cells)
     ]
-    sdomains = sorted(domains1, key=lambda D: (D.topological_dimension(), D.ufl_cell(), D.ufl_id()))
+    sdomains = sorted(domains1, key=lambda D: (D.topological_dimension, D.ufl_cell(), D.ufl_id()))
     assert sdomains != domains1
     assert sdomains == domains2
 
 
 def test_topdomain_creation():
     D = Mesh(LagrangeElement(interval, 1, (1,)))
-    assert D.geometric_dimension() == 1
+    assert D.geometric_dimension == 1
     D = Mesh(LagrangeElement(triangle, 1, (2,)))
-    assert D.geometric_dimension() == 2
+    assert D.geometric_dimension == 2
     D = Mesh(LagrangeElement(tetrahedron, 1, (3,)))
-    assert D.geometric_dimension() == 3
+    assert D.geometric_dimension == 3
 
 
 def test_cell_legacy_case():

diff --git a/test/test_evaluate.py b/test/test_evaluate.py
@@ -71,7 +71,7 @@ def testZero():
 
 def testIdentity():
     cell = triangle
-    ident = Identity(cell.topological_dimension())
+    ident = Identity(cell.topological_dimension)
 
     s = 123 * ident[0, 0]
     e = s((5, 7))
@@ -178,7 +178,7 @@ def testIndexSum2():
     cell = triangle
     domain = Mesh(LagrangeElement(cell, 1, (2,)))
     x = SpatialCoordinate(domain)
-    ident = Identity(cell.topological_dimension())
+    ident = Identity(cell.topological_dimension)
     i, j = indices(2)
     s = (x[i] * x[j]) * ident[i, j]
     e = s((5, 7))

diff --git a/test/test_extract_blocks.py b/test/test_extract_blocks.py
@@ -90,7 +90,7 @@ def lhs(u, p, v, q):
 
 def test_postive_restricted_extract_none():
     cell = ufl.triangle
-    d = cell.topological_dimension()
+    d = cell.topological_dimension
     domain = ufl.Mesh(LagrangeElement(cell, 1, (d,)))
     el_u = LagrangeElement(cell, 2, (d,))
     el_p = LagrangeElement(cell, 1)
@@ -112,7 +112,7 @@ def test_postive_restricted_extract_none():
 def test_part_extract():
     """Test extraction of a single block from a mixed function space form."""
     cell = ufl.quadrilateral
-    d = cell.topological_dimension()
+    d = cell.topological_dimension
     domain = ufl.Mesh(LagrangeElement(cell, 1, (d,)))
     el_u = LagrangeElement(cell, 2, (d,))
     el_p = LagrangeElement(cell, 1, (d,))

diff --git a/test/test_measures.py b/test/test_measures.py
@@ -73,10 +73,10 @@ def test_foo():
     mymesh = MockMesh(9)
     mydomain = Mesh(LagrangeElement(cell, 1, (gdim,)), ufl_id=9, cargo=mymesh)
 
-    assert cell.topological_dimension() == tdim
-    assert cell.cellname() == "triangle"
-    assert mydomain.topological_dimension() == tdim
-    assert mydomain.geometric_dimension() == gdim
+    assert cell.topological_dimension == tdim
+    assert cell.cellname == "triangle"
+    assert mydomain.topological_dimension == tdim
+    assert mydomain.geometric_dimension == gdim
     assert mydomain.ufl_cell() == cell
     assert mydomain.ufl_id() == 9
     assert mydomain.ufl_cargo() == mymesh