name

Author: ksagiyam

test/test_mixed_function_space_with_mesh_sequence.py

@@ -47,10 +47,10 @@ def test_mixed_function_space_with_mesh_sequence_cell():
     dx2 = Measure(
         "dx",
         mesh2,
-        extra_measures={
-            mesh0: "dx",
-            mesh1: "dx",
-        },
+        extra_measures=(
+            Measure("dx", mesh0),
+            Measure("dx", mesh1),
+        ),
     )
     x1 = SpatialCoordinate(mesh1)
     # Assemble (0, 1)-block.
@@ -106,17 +106,17 @@ def test_mixed_function_space_with_mesh_sequence_facet():
     dS1 = Measure(
         "dS",
         mesh1,
-        extra_measures={
-            mesh2: "ds",
-        },
+        extra_measures=(
+            Measure("ds", mesh2),
+        ),
     )
     ds2 = Measure(
         "ds",
         mesh2,
-        extra_measures={
-            mesh0: "dS",
-            mesh1: "ds",
-        },
+        extra_measures=(
+            Measure("dS", mesh0),
+            Measure("ds", mesh1),
+        ),
     )
     x2 = SpatialCoordinate(mesh2)
     # Assemble (2, 1)-block.

ufl/algorithms/domain_analysis.py

@@ -152,16 +152,16 @@ def group_integrals_by_domain_and_type(integrals, domains):
 
     Returns:
         Dictionary mapping (domain, integral_type) to a
-        dictionary mapping (extra_measures, list(Integral)).
+        dictionary mapping (extra_domain_integral_type_map, list(Integral)).
     """
     integrals_by_domain_and_type = defaultdict(lambda: defaultdict(list))
     for itg in integrals:
         if itg.ufl_domain() is None:
             raise ValueError("Integral has no domain.")
-        key = (itg.ufl_domain(), itg.integral_type())
-        key2 = tuple(itg.extra_measures().items())
+        key0 = (itg.ufl_domain(), itg.integral_type())
+        key1 = tuple(itg.extra_domain_integral_type_map().items())
         # Append integral to list of integrals with shared key
-        integrals_by_domain_and_type[key][key2].append(itg)
+        integrals_by_domain_and_type[key0][key1].append(itg)
 
     return integrals_by_domain_and_type
 
@@ -293,7 +293,7 @@ def build_integral_data(integrals):
         integral_type = integral.integral_type()
         ufl_domain = integral.ufl_domain()
         subdomain_ids = integral.subdomain_id()
-        extra_measures_tuple = tuple(integral.extra_measures().items())
+        extra_domain_integral_type_tuple = tuple(integral.extra_domain_integral_type_map().items())
         if "everywhere" in subdomain_ids:
             raise ValueError(
                 "'everywhere' not a valid subdomain id. "
@@ -302,32 +302,34 @@ def build_integral_data(integrals):
 
         # Group for integral data (One integral data object for all
         # integrals with same domain, itype, (but possibly different metadata).
-        itgs[(ufl_domain, integral_type, subdomain_ids, extra_measures_tuple)].append(integral)
+        itgs[(ufl_domain, integral_type, subdomain_ids, extra_domain_integral_type_tuple)].append(
+            integral
+        )
 
     # Build list with canonical ordering, iteration over dicts
     # is not deterministic across python versions
     def keyfunc(item):
-        (d, itype, sid, extra_meas_tuple), integrals = item
+        (d, itype, sid, extra_d_itype_tuple), integrals = item
         sid_int = tuple(-1 if i == "otherwise" else i for i in sid)
         return (
             d._ufl_sort_key_(),
             itype,
             (type(sid).__name__,),
             sid_int,
-            tuple((d_._ufl_sort_key_(), itype_) for d_, itype_ in extra_meas_tuple),
+            tuple((d_._ufl_sort_key_(), itype_) for d_, itype_ in extra_d_itype_tuple),
         )
 
     integral_datas = []
-    for (d, itype, sid, extra_meas_tuple), integrals in sorted(itgs.items(), key=keyfunc):
-        domain_integral_type_tuple = ((d, itype),) + extra_meas_tuple
+    for (d, itype, sid, extra_d_itype_tuple), integrals in sorted(itgs.items(), key=keyfunc):
+        d_itype_tuple = ((d, itype),) + extra_d_itype_tuple
         integral_datas.append(
             IntegralData(
                 d,
                 itype,
                 sid,
                 integrals,
                 {},
-                domain_integral_type_map=dict(domain_integral_type_tuple),
+                domain_integral_type_map=dict(d_itype_tuple),
             )
         )
     return integral_datas
@@ -357,7 +359,7 @@ def group_form_integrals(form, domains, do_append_everywhere_integrals=True):
             if ddt_integrals_map is None:
                 continue
 
-            for extra_measures_tuple, ddt_integrals in ddt_integrals_map.items():
+            for extra_domain_integral_type_tuple, ddt_integrals in ddt_integrals_map.items():
                 # Group integrals by subdomain id, after splitting e.g.
                 #   f*dx((1,2)) + g*dx((2,3)) -> f*dx(1) + (f+g)*dx(2) + g*dx(3)
                 # (note: before this call, 'everywhere' is a valid subdomain_id,
@@ -406,7 +408,9 @@ def calc_hash(cd):
                                 subdomain_id,
                                 metadata,
                                 None,
-                                extra_measures=dict(extra_measures_tuple),
+                                extra_domain_integral_type_map=dict(
+                                    extra_domain_integral_type_tuple
+                                ),
                             )
                             integral = attach_coordinate_derivatives(integral, samecd_integrals[0])
                             integrals.append(integral)
@@ -423,15 +427,15 @@ def calc_hash(cd):
         meta_hash = hash(canonicalize_metadata(metadata))
         subdomain_id = integral.subdomain_id()
         subdomain_data = id_or_none(integral.subdomain_data())
-        extra_measures_tuple = tuple(integral.extra_measures().items())
+        extra_domain_integral_type_tuple = tuple(integral.extra_domain_integral_type_map().items())
         integrand = renumber_indices(integral.integrand())
         key = (
             integral_type,
             ufl_domain,
             meta_hash,
             integrand,
             subdomain_data,
-            extra_measures_tuple,
+            extra_domain_integral_type_tuple,
         )
         unique_integrals[key] += (subdomain_id,)
         metadata_table[key] = metadata
@@ -444,7 +448,7 @@ def calc_hash(cd):
             metadata,
             integrand,
             subdomain_data,
-            extra_measures_tuple,
+            extra_domain_integral_type_tuple,
         ) = integral_data
         integral = Integral(
             integrand,
@@ -453,7 +457,7 @@ def calc_hash(cd):
             subdomain_ids,
             metadata_table[integral_data],
             subdomain_data,
-            extra_measures=dict(extra_measures_tuple),
+            extra_domain_integral_type_map=dict(extra_domain_integral_type_tuple),
         )
         grouped_integrals.append(integral)
 

ufl/algorithms/signature.py

@@ -144,8 +144,10 @@ def compute_form_signature(form, renumbering):  # FIXME: Fix callers
         integrand_hashdata = compute_expression_hashdata(integral.integrand(), terminal_hashdata)
 
         domain_hashdata = integral.ufl_domain()._ufl_signature_data_(renumbering)
-        extra_measures_hash_data = tuple(
-            (d._ufl_signature_data_(renumbering), it) for d, it in integral.extra_measures().items()
+        # Note that integlra.extra_domain_integral_type_map() has been sorted by domain.
+        extra_domain_integral_type_map_hashdata = tuple(
+            (d._ufl_signature_data_(renumbering), it)
+            for d, it in integral.extra_domain_integral_type_map().items()
         )
 
         # Collect all data about integral that should be reflected in
@@ -157,7 +159,7 @@ def compute_form_signature(form, renumbering):  # FIXME: Fix callers
             integrand_hashdata,
             domain_hashdata,
             integral.integral_type(),
-            extra_measures_hash_data,
+            extra_domain_integral_type_map_hashdata,
             integral.subdomain_id(),
             canonicalize_metadata(integral.metadata()),
         )

ufl/form.py

@@ -53,10 +53,11 @@ def _sorted_integrals(integrals):
         it = integral.integral_type()
         si = integral.subdomain_id()
         # Make a sortable key.
-        extra_measures_sortable = tuple(
-            (d_._ufl_sort_key_(), it_) for d_, it_ in integral.extra_measures().items()
+        extra_sortable = tuple(
+            (d_._ufl_sort_key_(), it_)
+            for d_, it_ in integral.extra_domain_integral_type_map().items()
         )
-        integrals_dict[d][it][extra_measures_sortable][si].append(integral)
+        integrals_dict[d][it][extra_sortable][si].append(integral)
 
     all_integrals = []
 
@@ -604,11 +605,11 @@ def _analyze_domains(self):
         self._integration_domains = sort_domains(
             join_domains([itg.ufl_domain() for itg in self._integrals])
         )
-        # Collect domains in extra_measures.
-        domains_in_extra_measures = join_domains(
-            [d for itg in self._integrals for d in itg.extra_measures()]
+        # Collect domains in extra_domain_integral_type_map.
+        domains_in_extra_domain_integral_type_map = join_domains(
+            [d for itg in self._integrals for d in itg.extra_domain_integral_type_map()]
         )
-        domains_in_extra_measures -= set(self._integration_domains)
+        domains_in_extra_domain_integral_type_map -= set(self._integration_domains)
         # Collect domains in integrands.
         domains_in_integrands = set()
         for o in chain(
@@ -618,7 +619,7 @@ def _analyze_domains(self):
             domains_in_integrands.update(domain.meshes)
         domains_in_integrands -= set(self._integration_domains)
         all_domains = self._integration_domains + sort_domains(
-            join_domains(domains_in_extra_measures | domains_in_integrands)
+            join_domains(domains_in_extra_domain_integral_type_map | domains_in_integrands)
         )
         # Let problem solving environments access all domains via
         # self._domain_numbering.keys() (wrapped in extract_domains()).

ufl/integral.py

@@ -23,7 +23,7 @@ class Integral:
     """An integral over a single domain."""
 
     __slots__ = (
-        "_extra_measures",
+        "_extra_domain_integral_type_map",
         "_integral_type",
         "_integrand",
         "_metadata",
@@ -40,7 +40,7 @@ def __init__(
         subdomain_id,
         metadata,
         subdomain_data,
-        extra_measures=None,
+        extra_domain_integral_type_map=None,
     ):
         """Initialise."""
         if not isinstance(integrand, Expr):
@@ -51,11 +51,12 @@ def __init__(
         self._subdomain_id = subdomain_id
         self._metadata = metadata
         self._subdomain_data = subdomain_data
-        if extra_measures is None:
-            self._extra_measures = {}
+        if extra_domain_integral_type_map is None:
+            self._extra_domain_integral_type_map = {}
         else:
-            self._extra_measures = {
-                d: extra_measures[d] for d in sort_domains(extra_measures.keys())
+            self._extra_domain_integral_type_map = {
+                d: extra_domain_integral_type_map[d]
+                for d in sort_domains(extra_domain_integral_type_map.keys())
             }
 
     def reconstruct(
@@ -66,7 +67,7 @@ def reconstruct(
         subdomain_id=None,
         metadata=None,
         subdomain_data=None,
-        extra_measures=None,
+        extra_domain_integral_type_map=None,
     ):
         """Construct a new Integral object with some properties replaced with new values.
 
@@ -87,16 +88,16 @@ def reconstruct(
             metadata = self.metadata()
         if subdomain_data is None:
             subdomain_data = self._subdomain_data
-        if extra_measures is None:
-            extra_measures = self._extra_measures
+        if extra_domain_integral_type_map is None:
+            extra_domain_integral_type_map = self._extra_domain_integral_type_map
         return Integral(
             integrand,
             integral_type,
             domain,
             subdomain_id,
             metadata,
             subdomain_data,
-            extra_measures=extra_measures,
+            extra_domain_integral_type_map=extra_domain_integral_type_map,
         )
 
     def integrand(self):
@@ -115,9 +116,9 @@ def subdomain_id(self):
         """Return the subdomain id of this integral."""
         return self._subdomain_id
 
-    def extra_measures(self):
-        """Return the additional domain-integral_type map."""
-        return self._extra_measures
+    def extra_domain_integral_type_map(self):
+        """Return the extra domain-integral_type map."""
+        return self._extra_domain_integral_type_map
 
     def metadata(self):
         """Return the compiler metadata this integral has been annotated with."""
@@ -150,7 +151,7 @@ def __str__(self):
         mname = ufl.measure.integral_type_to_measure_name[self._integral_type]
         temp = {
             d: ufl.measure.integral_type_to_measure_name[it]
-            for d, it in self._extra_measures.items()
+            for d, it in self._extra_domain_integral_type_map.items()
         }
         return (
             f"{{self._integrand}} * "
@@ -162,7 +163,7 @@ def __repr__(self):
         return (
             f"Integral({self._integrand!r}, {self._integral_type!r}, {self._ufl_domain!r}, "
             f"{self._subdomain_id!r}, {self._metadata!r}, {self._subdomain_data!r}, "
-            f"extra_measures={self._extra_measures!r})"
+            f"extra_domain_integral_type_map={self._extra_domain_integral_type_map!r})"
         )
 
     def __eq__(self, other):
@@ -175,7 +176,7 @@ def __eq__(self, other):
             and self._integrand == other._integrand
             and self._metadata == other._metadata
             and id_or_none(self._subdomain_data) == id_or_none(other._subdomain_data)
-            and self._extra_measures == other._extra_measures
+            and self._extra_domain_integral_type_map == other._extra_domain_integral_type_map
         )
 
     def __hash__(self):
@@ -189,6 +190,6 @@ def __hash__(self):
             hash(self._ufl_domain),
             self._subdomain_id,
             id_or_none(self._subdomain_data),
-            tuple((hash(d), it) for d, it in self._extra_measures.items()),
+            tuple((hash(d), it) for d, it in self._extra_domain_integral_type_map.items()),
         )
         return hash(hashdata)