k

Author: ksagiyam

test/test_mixed_function_space_with_mesh_sequence.py

@@ -47,7 +47,7 @@ def test_mixed_function_space_with_mesh_sequence_cell():
     dx2 = Measure(
         "dx",
         mesh2,
-        extra_measures=(
+        intersect_measures=(
             Measure("dx", mesh0),
             Measure("dx", mesh1),
         ),
@@ -106,12 +106,12 @@ def test_mixed_function_space_with_mesh_sequence_facet():
     dS1 = Measure(
         "dS",
         mesh1,
-        extra_measures=(Measure("ds", mesh2),),
+        intersect_measures=(Measure("ds", mesh2),),
     )
     ds2 = Measure(
         "ds",
         mesh2,
-        extra_measures=(
+        intersect_measures=(
             Measure("dS", mesh0),
             Measure("ds", mesh1),
         ),

ufl/measure.py

@@ -104,8 +104,8 @@ class Measure:
 
     __slots__ = (
         "_domain",
-        "_extra_measures",
         "_integral_type",
+        "_intersect_measures",
         "_metadata",
         "_subdomain_data",
         "_subdomain_id",
@@ -118,7 +118,7 @@ def __init__(
         subdomain_id="everywhere",
         metadata=None,
         subdomain_data=None,
-        extra_measures=None,
+        intersect_measures=None,
     ):
         """Initialise.
 
@@ -130,10 +130,10 @@ def __init__(
                 affecting how code is generated, including parameters
                 for optimization or debugging of generated code
             subdomain_data: object representing data to interpret subdomain_id with
-            extra_measures: a `tuple` of extra measures that defines
+            intersect_measures: a `tuple` of extra measures that defines
                 domain-integral_type map for each domain in a multi-domain problem. For instance,
                 if integral_type="dS" on ``domain``, while integral_type="ds" on domainZ, say,
-                one must pass extra_measures=(Measure("ds", domainZ),). Currently,
+                one must pass intersect_measures=(Measure("ds", domainZ),). Currently,
                 the extra measures must have "everywhere" subdomain_id.
         """
         # Map short name to long name and require a valid one
@@ -169,25 +169,25 @@ def __init__(
             raise ValueError("Invalid metadata.")
         self._metadata = metadata or {}
 
-        if extra_measures is None:
-            self._extra_measures = ()
+        if intersect_measures is None:
+            self._intersect_measures = ()
         else:
-            if not all(m.subdomain_id() == "everywhere" for m in extra_measures):
+            if not all(m.subdomain_id() == "everywhere" for m in intersect_measures):
                 raise NotImplementedError(
                     f"Currently, all extra measures must have 'everywhere' subdomain_id: "
-                    f"got {extra_measures}"
+                    f"got {intersect_measures}"
                 )
-            if not all(m.extra_measures() == () for m in extra_measures):
+            if not all(m.intersect_measures() == () for m in intersect_measures):
                 raise ValueError(
-                    f"All extra measures must have empty extra_measures: got {extra_measures}"
+                    f"All extra measures must have empty intersect_measures: got {intersect_measures}"
                 )
-            if not all(m.metadata() == {} for m in extra_measures):
+            if not all(m.metadata() == {} for m in intersect_measures):
                 raise ValueError(
-                    f"All extra measures must have empty metadata: got {extra_measures}"
+                    f"All extra measures must have empty metadata: got {intersect_measures}"
                 )
-            _extra_measures = {}
-            self._extra_measures = tuple(
-                sorted(extra_measures, key=lambda m: m.ufl_domain()._ufl_sort_key_())
+            _intersect_measures = {}
+            self._intersect_measures = tuple(
+                sorted(intersect_measures, key=lambda m: m.ufl_domain()._ufl_sort_key_())
             )
 
     def integral_type(self):
@@ -208,9 +208,9 @@ def subdomain_id(self):
         """Return the domain id of this measure (integer)."""
         return self._subdomain_id
 
-    def extra_measures(self):
+    def intersect_measures(self):
         """Return the extra measures."""
-        return self._extra_measures
+        return self._intersect_measures
 
     def metadata(self):
         """Return the integral metadata.
@@ -228,7 +228,7 @@ def reconstruct(
         domain=None,
         metadata=None,
         subdomain_data=None,
-        extra_measures=None,
+        intersect_measures=None,
     ):
         """Construct a new Measure object with some properties replaced with new values.
 
@@ -245,8 +245,8 @@ def reconstruct(
             subdomain_id = self.subdomain_id()
         if domain is None:
             domain = self.ufl_domain()
-        if extra_measures is None:
-            extra_measures = self.extra_measures()
+        if intersect_measures is None:
+            intersect_measures = self.intersect_measures()
         if metadata is None:
             metadata = self.metadata()
         if subdomain_data is None:
@@ -257,7 +257,7 @@ def reconstruct(
             subdomain_id=subdomain_id,
             metadata=metadata,
             subdomain_data=subdomain_data,
-            extra_measures=extra_measures,
+            intersect_measures=intersect_measures,
         )
 
     def subdomain_data(self):
@@ -328,8 +328,8 @@ def __str__(self):
             args.append(f"subdomain_id={self._subdomain_id}")
         if self._domain is not None:
             args.append(f"domain={self._domain}")
-        if self._extra_measures:
-            args.append(f"extra_measures={self._extra_measures}")
+        if self._intersect_measures:
+            args.append(f"intersect_measures={self._intersect_measures}")
         if self._metadata:  # Stored as {} if None
             args.append(f"metadata={self._metadata}")
         if self._subdomain_data is not None:
@@ -346,8 +346,8 @@ def __repr__(self):
             args.append(f"subdomain_id={self._subdomain_id!r}")
         if self._domain is not None:
             args.append(f"domain={self._domain!r}")
-        if self._extra_measures:
-            args.append(f"extra_measures={self._extra_measures!r}")
+        if self._intersect_measures:
+            args.append(f"intersect_measures={self._intersect_measures!r}")
         if self._metadata:  # Stored as {} if None
             args.append(f"metadata={self._metadata!r}")
         if self._subdomain_data is not None:
@@ -365,7 +365,7 @@ def __hash__(self):
             hash(self._domain),
             metadata_hashdata,
             id_or_none(self._subdomain_data),
-            self._extra_measures,
+            self._intersect_measures,
         )
         return hash(hashdata)
 
@@ -383,7 +383,7 @@ def __eq__(self, other):
             and self._domain == other._domain
             and id_or_none(self._subdomain_data) == id_or_none(other._subdomain_data)
             and sorted_metadata == sorted_other_metadata
-            and self._extra_measures == other._extra_measures
+            and self._intersect_measures == other._intersect_measures
         )
 
     def __add__(self, other):
@@ -492,7 +492,7 @@ def __rmul__(self, integrand):
             metadata=self.metadata(),
             subdomain_data=self.subdomain_data(),
             extra_domain_integral_type_map={
-                m.ufl_domain(): m.integral_type() for m in self.extra_measures()
+                m.ufl_domain(): m.integral_type() for m in self.intersect_measures()
             },
         )
         return Form([integral])