Merge branch 'main' into mscroggs/prism-ds

Author: mscroggs

demo/MixedGradient.py

@@ -21,18 +21,6 @@ def test_demo(file, scalar_type):
         # Skip complex demos on win32
         pytest.skip(reason="_Complex not supported on Windows")
 
-    if file == "Symmetry":
-        pytest.xfail("Demo currently failing. See https://github.com/FEniCS/ufl/issues/343.")
-    if file in [
-        "MixedGradient",
-        "TraceElement",  # HDiv Trace
-        "MixedElasticity",  # VectorElement of BDM
-        "RestrictedElement",
-        "_TensorProductElement",
-    ]:
-        # Skip demos that use elements not yet implemented in Basix
-        pytest.skip(reason="Element not yet implemented in Basix")
-
     if "complex" in scalar_type and file in [
         "BiharmonicHHJ",
         "BiharmonicRegge",

demo/TraceElement.py

@@ -103,6 +103,8 @@ def generator(ir: ExpressionIR, options):
         d["constant_names_init"] = ""
         d["constant_names"] = "NULL"
 
+    d["coordinate_element_hash"] = f"UINT64_C({ir.expression.coordinate_element_hash})"
+
     # Check that no keys are redundant or have been missed
     from string import Formatter
 

demo/test_demos.py

@@ -49,6 +49,7 @@
   .value_shape = {value_shape},
   .num_components = {num_components},
   .rank = {rank},
+  .coordinate_element_hash = {coordinate_element_hash},
 }};
 
 // Alias name

ffcx/codegeneration/C/expressions.py

@@ -74,8 +74,7 @@ def generator(ir: IntegralIR, domain: basix.CellType, options):
         f".tabulate_tensor_{np_scalar_type} = tabulate_tensor_{factory_name},"
     )
 
-    element_hash = 0 if ir.coordinate_element_hash is None else ir.coordinate_element_hash
-
+    assert ir.expression.coordinate_element_hash is not None
     implementation = ufcx_integrals.factory.format(
         factory_name=factory_name,
         enabled_coefficients=code["enabled_coefficients"],
@@ -84,7 +83,7 @@ def generator(ir: IntegralIR, domain: basix.CellType, options):
         needs_facet_permutations="true" if ir.expression.needs_facet_permutations else "false",
         scalar_type=dtype_to_c_type(options["scalar_type"]),
         geom_type=dtype_to_c_type(dtype_to_scalar_dtype(options["scalar_type"])),
-        coordinate_element_hash=f"UINT64_C({element_hash})",
+        coordinate_element_hash=f"UINT64_C({ir.expression.coordinate_element_hash})",
         tabulate_tensor_float32=code["tabulate_tensor_float32"],
         tabulate_tensor_float64=code["tabulate_tensor_float64"],
         tabulate_tensor_complex64=code["tabulate_tensor_complex64"],

ffcx/codegeneration/C/expressions_template.py

@@ -133,7 +133,7 @@ def coefficient(
         end = begin + bs * (num_dofs - 1) + 1
 
         if ttype == "zeros":
-            logging.debug("Not expecting zero coefficients to get this far.")
+            logger.debug("Not expecting zero coefficients to get this far.")
             return []
 
         # For a constant coefficient we reference the dofs directly, so no definition needed
@@ -239,7 +239,7 @@ def spatial_coordinate(
         if self.integral_type in ufl.custom_integral_types:
             # FIXME: Jacobian may need adjustment for custom_integral_types
             if mt.local_derivatives:
-                logging.exception("FIXME: Jacobian in custom integrals is not implemented.")
+                logger.exception("FIXME: Jacobian in custom integrals is not implemented.")
             return []
         else:
             return self._define_coordinate_dofs_lincomb(mt, tabledata, quadrature_rule, access)

ffcx/codegeneration/C/integrals.py

@@ -109,7 +109,7 @@ def entity(self, entity_type, restriction):
         elif entity_type == "vertex":
             return self.entity_local_index[0]
         else:
-            logging.exception(f"Unknown entity_type {entity_type}")
+            logger.exception(f"Unknown entity_type {entity_type}")
 
     def argument_loop_index(self, iarg):
         """Loop index for argument iarg."""
@@ -135,8 +135,9 @@ def x_component(self, mt):
 
     def J_component(self, mt):
         """Jacobian component."""
-        # FIXME: Add domain number!
-        return L.Symbol(format_mt_name("J", mt), dtype=L.DataType.REAL)
+        return L.Symbol(
+            format_mt_name(f"J{mt.expr.ufl_domain().ufl_id()}", mt), dtype=L.DataType.REAL
+        )
 
     def domain_dof_access(self, dof, component, gdim, num_scalar_dofs, restriction):
         """Domain DOF access."""

ffcx/codegeneration/definitions.py

@@ -16,11 +16,12 @@
 #define UFCX_VERSION_RELEASE 0
 
 #if UFCX_VERSION_RELEASE
-#define UFCX_VERSION                                                            \
+#define UFCX_VERSION                                                           \
   UFCX_VERSION_MAJOR "." UFCX_VERSION_MINOR "." UFCX_VERSION_MAINTENANCE
 #else
-#define UFCX_VERSION                                                            \
-  UFCX_VERSION_MAJOR "." UFCX_VERSION_MINOR "." UFCX_VERSION_MAINTENANCE ".dev0"
+#define UFCX_VERSION                                                           \
+  UFCX_VERSION_MAJOR "." UFCX_VERSION_MINOR "." UFCX_VERSION_MAINTENANCE ".de" \
+                                                                         "v0"
 #endif
 
 #include <stdbool.h>
@@ -86,8 +87,8 @@ extern "C"
   /// null pointer can be passed. For interior facets the array will have size 2
   /// (one permutation for each cell adjacent to the facet).
   typedef void(ufcx_tabulate_tensor_float32)(
-      float* restrict A, const float* restrict w,
-      const float* restrict c, const float* restrict coordinate_dofs,
+      float* restrict A, const float* restrict w, const float* restrict c,
+      const float* restrict coordinate_dofs,
       const int* restrict entity_local_index,
       const uint8_t* restrict quadrature_permutation);
 
@@ -96,8 +97,8 @@ extern "C"
   ///
   /// @see ufcx_tabulate_tensor_single
   typedef void(ufcx_tabulate_tensor_float64)(
-      double* restrict A, const double* restrict w,
-      const double* restrict c, const double* restrict coordinate_dofs,
+      double* restrict A, const double* restrict w, const double* restrict c,
+      const double* restrict coordinate_dofs,
       const int* restrict entity_local_index,
       const uint8_t* restrict quadrature_permutation);
 
@@ -136,21 +137,21 @@ extern "C"
 #endif // __STDC_NO_COMPLEX__
     bool needs_facet_permutations;
 
-    /// Get the hash of the coordinate element associated with the geometry of the mesh.
+    /// Hash of the coordinate element associated with the geometry of the mesh.
     uint64_t coordinate_element_hash;
 
     uint8_t domain;
   } ufcx_integral;
 
   typedef struct ufcx_expression
   {
-    /// Evaluate expression into tensor A with compiled evaluation points
+    /// Evaluate expression into tensor A with compiled evaluation
+    /// points.
     ///
-    /// @param[out] A
-    ///         Dimensions: A[num_points][num_components][num_argument_dofs]
+    /// @param[out] A Dimensions:
+    /// `A[num_points][num_components][num_argument_dofs]`
     ///
     /// @see ufcx_tabulate_tensor
-    ///
     ufcx_tabulate_tensor_float32* tabulate_tensor_float32;
     ufcx_tabulate_tensor_float64* tabulate_tensor_float64;
 #ifndef __STDC_NO_COMPLEX__
@@ -180,7 +181,7 @@ extern "C"
     int entity_dimension;
 
     /// Coordinates of evaluations points. Dimensions:
-    /// points[num_points][entity_dimension]
+    /// `points[num_points][entity_dimension]`
     const double* points;
 
     /// Shape of expression. Dimension: value_shape[num_components]
@@ -192,6 +193,9 @@ extern "C"
     /// Rank, i.e. number of arguments
     int rank;
 
+    /// Hash of the coordinate element associated with the geometry of
+    /// the mesh.
+    uint64_t coordinate_element_hash;
   } ufcx_expression;
 
   /// This class defines the interface for the assembly of the global
@@ -205,9 +209,9 @@ extern "C"
   ///
   ///     A = a(V1, V2, ..., Vr, w1, w2, ..., wn),
   ///
-  /// where each argument Vj represents the application to the
-  /// sequence of basis functions of Vj and w1, w2, ..., wn are given
-  /// fixed functions (coefficients).
+  /// where each argument Vj represents the application to the sequence
+  /// of basis functions of Vj and w1, w2, ..., wn are given fixed
+  /// functions (coefficients).
   typedef struct ufcx_form
   {
     /// String identifying the form
@@ -231,8 +235,8 @@ extern "C"
     /// List of names of constants
     const char** constant_name_map;
 
-    /// Get the hash of the finite element for the i-th argument function, where 0 <=
-    /// i < r + n.
+    /// Get the hash of the finite element for the i-th argument
+    /// function, where 0 <= i < r + n.
     ///
     /// @param i Argument number if 0 <= i < r Coefficient number j = i
     /// - r if r + j <= i < r + n
@@ -244,7 +248,8 @@ extern "C"
     /// IDs for each integral in form_integrals list
     int* form_integral_ids;
 
-    /// Offsets for cell, interior facet and exterior facet integrals in form_integrals list
+    /// Offsets for cell, interior facet and exterior facet integrals in
+    /// form_integrals list
     int* form_integral_offsets;
 
   } ufcx_form;