Adapt to UFL changing some methods to properties (#4629)

* Adapt to UFL changing some methods to properties

See FEniCS/ufl#385.

Author: connorjward

.github/workflows/core.yml

@@ -194,7 +194,8 @@ jobs:
             : # because they rely on non-PyPI versions of petsc4py.
             pip install --no-build-isolation --no-deps \
               "$PETSC_DIR"/"$PETSC_ARCH"/externalpackages/git.slepc/src/binding/slepc4py
-            pip install --no-deps git+https://github.com/NGSolve/ngsPETSc.git netgen-mesher netgen-occt
+            # UNDO ME
+            pip install --no-deps git+https://github.com/NGSolve/ngsPETSc.git@connorjward/ufl-cell-fix netgen-mesher netgen-occt
 
             : # We have to pass '--no-build-isolation' to use a custom petsc4py
             EXTRA_BUILD_ARGS='--no-isolation'

demos/ma-demo/ma-demo.py.rst

@@ -111,7 +111,7 @@ a Function, w. ::
 
   n = FacetNormal(mesh)
 
-  I = Identity(mesh.geometric_dimension())
+  I = Identity(mesh.geometric_dimension)
 
   L = inner(sigma, tau)*dx
   L += (inner(div(tau), grad(u))*dx

docs/notebooks/03-elasticity.ipynb

@@ -118,7 +118,7 @@
     "f = as_vector([0, -rho*g])\n",
     "mu = Constant(1)\n",
     "lambda_ = Constant(0.25)\n",
-    "Id = Identity(mesh.geometric_dimension()) # 2x2 Identity tensor"
+    "Id = Identity(mesh.geometric_dimension) # 2x2 Identity tensor"
    ]
   },
   {
@@ -285,7 +285,7 @@
     "    f = as_vector([0, -rho*g])\n",
     "    mu = Constant(1)\n",
     "    lambda_ = Constant(0.25)\n",
-    "    Id = Identity(mesh.geometric_dimension()) # 2x2 Identity tensor\n",
+    "    Id = Identity(mesh.geometric_dimension) # 2x2 Identity tensor\n",
     "    \n",
     "    bc = DirichletBC(V, Constant([0, 0]), 1)\n",
     "    u = TrialFunction(V)\n",
@@ -393,7 +393,7 @@
     "    f = as_vector([0, -rho*g])\n",
     "    mu = Constant(1)\n",
     "    lambda_ = Constant(0.25)\n",
-    "    Id = Identity(mesh.geometric_dimension()) # 2x2 Identity tensor\n",
+    "    Id = Identity(mesh.geometric_dimension) # 2x2 Identity tensor\n",
     "    def epsilon(u):\n",
     "        return 0.5*(grad(u) + grad(u).T)\n",
     "\n",

docs/notebooks/08-composable-solvers.ipynb

@@ -114,7 +114,7 @@
     "bc_value = as_vector([0.25 * x**2 * (2-x)**2 *y**2, 0])\n",
     "\n",
     "bcs = [DirichletBC(W.sub(0), bc_value, 4),\n",
-    "       DirichletBC(W.sub(0), zero(mesh.geometric_dimension()), (1, 2, 3))]"
+    "       DirichletBC(W.sub(0), zero(mesh.geometric_dimension), (1, 2, 3))]"
    ]
   },
   {

docs/source/petsc-interface.rst

@@ -375,8 +375,8 @@ Accordingly, set
 
 .. code-block:: python3
 
-    dim = mesh.topological_dimension()
-    gdim = mesh.geometrical_dimension()
+    dim = mesh.topological_dimension
+    gdim = mesh.geometric_dimension
     entity_dofs = np.zeros(dim+1, dtype=np.int32)
     entity_dofs[0] = gdim
     entity_dofs[1] = gdim*(p-1)

firedrake/assemble.py

@@ -1871,9 +1871,9 @@ def _(_, self):
 @_as_global_kernel_arg.register(CellFacetKernelArg)
 def _as_global_kernel_arg_cell_facet(_, self):
     if self._mesh.extruded:
-        num_facets = self._mesh._base_mesh.ufl_cell().num_facets()
+        num_facets = self._mesh._base_mesh.ufl_cell().num_facets
     else:
-        num_facets = self._mesh.ufl_cell().num_facets()
+        num_facets = self._mesh.ufl_cell().num_facets
     return op2.DatKernelArg((num_facets, 2))
 
 

firedrake/bcs.py

@@ -130,12 +130,12 @@ def nodes(self):
         # First, we bail out on zany elements.  We don't know how to do BC's for them.
         V = self._function_space
         if isinstance(V.finat_element, (finat.Argyris, finat.Morley, finat.Bell)) or \
-           (isinstance(V.finat_element, finat.Hermite) and V.mesh().topological_dimension() > 1):
+           (isinstance(V.finat_element, finat.Hermite) and V.mesh().topological_dimension > 1):
             raise NotImplementedError("Strong BCs not implemented for element %r, use Nitsche-type methods until we figure this out" % V.finat_element)
 
         def hermite_stride(bcnodes):
             fe = self._function_space.finat_element
-            tdim = self._function_space.mesh().topological_dimension()
+            tdim = self._function_space.mesh().topological_dimension
             if isinstance(fe, finat.Hermite) and tdim == 1:
                 bcnodes = bcnodes[::2]  # every second dof is the vertex value
             elif fe.complex.is_macrocell() and self._function_space.ufl_element().sobolev_space == ufl.H1:

firedrake/checkpointing.py

@@ -593,7 +593,7 @@ def save_mesh(self, mesh, distribution_name=None, permutation_name=None):
                     # Save tmesh.layers, which contains (start layer, stop layer)-tuple for each cell
                     # Conceptually, we project these integer pairs onto DG0 vector space of dim=2.
                     cell = base_tmesh.ufl_cell()
-                    element = finat.ufl.VectorElement("DP" if cell.is_simplex() else "DQ", cell, 0, dim=2)
+                    element = finat.ufl.VectorElement("DP" if cell.is_simplex else "DQ", cell, 0, dim=2)
                     layers_tV = impl.FunctionSpace(base_tmesh, element)
                     self._save_function_space_topology(layers_tV)
                     # Note that _cell_numbering coincides with DG0 section, so we can use tmesh.layers directly.
@@ -1056,7 +1056,7 @@ def load_mesh(self, name=DEFAULT_MESH_NAME, reorder=None, distribution_parameter
             variable_layers = self.get_attr(path, PREFIX_EXTRUDED + "_variable_layers")
             if variable_layers:
                 cell = base_tmesh.ufl_cell()
-                element = finat.ufl.VectorElement("DP" if cell.is_simplex() else "DQ", cell, 0, dim=2)
+                element = finat.ufl.VectorElement("DP" if cell.is_simplex else "DQ", cell, 0, dim=2)
                 _ = self._load_function_space_topology(base_tmesh, element)
                 base_tmesh_key = self._generate_mesh_key_from_names(base_tmesh.name,
                                                                     base_tmesh._distribution_name,
@@ -1119,7 +1119,7 @@ def load_mesh(self, name=DEFAULT_MESH_NAME, reorder=None, distribution_parameter
             path = self._path_to_mesh_immersed(tmesh.name, name)
             if path in self.h5pyfile:
                 cell = tmesh.ufl_cell()
-                element = finat.ufl.FiniteElement("DP" if cell.is_simplex() else "DQ", cell, 0)
+                element = finat.ufl.FiniteElement("DP" if cell.is_simplex else "DQ", cell, 0)
                 cell_orientations_tV = self._load_function_space_topology(tmesh, element)
                 tmesh_key = self._generate_mesh_key_from_names(tmesh.name,
                                                                tmesh._distribution_name,

firedrake/cython/extrusion_numbering.pyx

@@ -564,7 +564,7 @@ def top_bottom_boundary_nodes(mesh,
     layer_extents = mesh.layer_extents
     cell_closure = mesh.cell_closure
     ncell, nclosure = mesh.cell_closure.shape
-    n_vert_facet = mesh._base_mesh.ufl_cell().num_facets()
+    n_vert_facet = mesh._base_mesh.ufl_cell().num_facets
     assert facet_points.shape[0] == n_vert_facet + 2
 
     bottom_facet = facet_points[n_vert_facet]

firedrake/cython/supermeshimpl.pyx

@@ -69,7 +69,7 @@ def assemble_mixed_mass_matrix(V_A, V_B, candidates,
     vertex_map_B = mesh_B.coordinates.cell_node_map().values_with_halo
 
     num_vertices = vertex_map_A.shape[1]
-    gdim = mesh_A.geometric_dimension()
+    gdim = mesh_A.geometric_dimension
     simplex_A = numpy.empty((num_vertices, gdim), dtype=ScalarType)
     simplex_B = numpy.empty_like(simplex_A, dtype=ScalarType)
     simplices_C = numpy.empty(MAGIC[gdim], dtype=ScalarType)
@@ -119,10 +119,10 @@ def intersection_finder(mesh_A, mesh_B):
         long nnodes_A, nnodes_B, ncells_A, ncells_B
         int dim_A, dim_B, loc_A, loc_B
 
-    dim = mesh_A.geometric_dimension()
-    assert dim == mesh_B.geometric_dimension()
-    assert dim == mesh_A.topological_dimension()
-    assert dim == mesh_B.topological_dimension()
+    dim = mesh_A.geometric_dimension
+    assert dim == mesh_B.geometric_dimension
+    assert dim == mesh_A.topological_dimension
+    assert dim == mesh_B.topological_dimension
 
     assert mesh_A.coordinates.function_space().ufl_element().degree() == 1
     assert mesh_B.coordinates.function_space().ufl_element().degree() == 1
@@ -144,8 +144,8 @@ def intersection_finder(mesh_A, mesh_B):
     vertex_map_B = mesh_B.coordinates.cell_node_map().values_with_halo.astype(int)
     nnodes_A = mesh_A.coordinates.dof_dset.total_size
     nnodes_B = mesh_B.coordinates.dof_dset.total_size
-    dim_A = mesh_A.geometric_dimension()
-    dim_B = mesh_B.geometric_dimension()
+    dim_A = mesh_A.geometric_dimension
+    dim_B = mesh_B.geometric_dimension
     ncells_A = mesh_A.num_cells()
     ncells_B = mesh_B.num_cells()
     loc_A = vertex_map_A.shape[1]