mv d_it_map

Author: ksagiyam

firedrake/mg/kernels.py

@@ -144,7 +144,6 @@ def compile_element(expression, dual_space=None, parameters=None,
 
     config = dict(interface=builder,
                   ufl_cell=cell,
-                  domain_integral_type_map={domain: "cell"},
                   point_indices=(),
                   point_expr=point,
                   argument_multiindices=argument_multiindices,
@@ -542,8 +541,7 @@ def dg_injection_kernel(Vf, Vc, ncell):
                      entity_ids=entity_ids,
                      index_cache=index_cache,
                      quadrature_rule=macro_quadrature_rule,
-                     scalar_type=parameters["scalar_type"],
-                     domain_integral_type_map={Vf.mesh(): "cell"})
+                     scalar_type=parameters["scalar_type"])
 
     macro_context = fem.PointSetContext(**macro_cfg)
     fexpr, = fem.compile_ufl(f, macro_context)
@@ -581,8 +579,7 @@ def dg_injection_kernel(Vf, Vc, ncell):
                       entity_ids=entity_ids,
                       index_cache=index_cache,
                       quadrature_rule=quadrature_rule,
-                      scalar_type=parameters["scalar_type"],
-                      domain_integral_type_map={Vc.mesh(): "cell"})
+                      scalar_type=parameters["scalar_type"])
 
     X = ufl.SpatialCoordinate(Vc.mesh())
     K = ufl_utils.preprocess_expression(ufl.JacobianInverse(Vc.mesh()),

firedrake/pointeval_utils.py

@@ -72,7 +72,6 @@ def compile_element(expression, coordinates, parameters=None):
 
     config = dict(interface=builder,
                   ufl_cell=extract_unique_domain(coordinates).ufl_cell(),
-                  domain_integral_type_map={domain: "cell"},
                   point_indices=(),
                   point_expr=point,
                   scalar_type=utils.ScalarType)

firedrake/pointquery_utils.py

@@ -162,7 +162,6 @@ def to_reference_coords_newton_step(ufl_coordinate_element, parameters, x0_dtype
     context = tsfc.fem.GemPointContext(
         interface=builder,
         ufl_cell=cell,
-        domain_integral_type_map={domain: "cell"},
         point_indices=(),
         point_expr=point,
         scalar_type=parameters["scalar_type"]

tsfc/driver.py

@@ -282,7 +282,6 @@ def compile_expression_dual_evaluation(expression, to_element, ufl_element, *,
                       ufl_cell=domain.ufl_cell(),
                       # FIXME: change if we ever implement
                       # interpolation on facets.
-                      domain_integral_type_map={domain: "cell"},
                       argument_multiindices=argument_multiindices,
                       index_cache={},
                       scalar_type=parameters["scalar_type"])

tsfc/fem.py

@@ -51,7 +51,6 @@ class ContextBase(ProxyKernelInterface):
     keywords = (
         'ufl_cell',
         'fiat_cell',
-        'domain_integral_type_map',
         'integration_dim',
         'entity_ids',
         'argument_multiindices',
@@ -165,7 +164,7 @@ def preprocess(self, expr, context):
     @property
     def config(self):
         config = {name: getattr(self.interface, name)
-                  for name in ["ufl_cell", "index_cache", "scalar_type", "domain_integral_type_map"]}
+                  for name in ["ufl_cell", "index_cache", "scalar_type"]}
         config["interface"] = self.interface
         return config
 
@@ -379,7 +378,7 @@ def cell_avg(self, o):
         integrand, degree, argument_multiindices = entity_avg(integrand / CellVolume(domain), measure, self.context.argument_multiindices)
 
         config = {name: getattr(self.context, name)
-                  for name in ["ufl_cell", "index_cache", "scalar_type", "domain_integral_type_map"]}
+                  for name in ["ufl_cell", "index_cache", "scalar_type"]}
         config.update(quadrature_degree=degree, interface=self.context,
                       argument_multiindices=argument_multiindices)
         expr, = compile_ufl(integrand, PointSetContext(**config), point_sum=True)
@@ -396,8 +395,7 @@ def facet_avg(self, o):
 
         config = {name: getattr(self.context, name)
                   for name in ["ufl_cell", "index_cache", "scalar_type",
-                               "integration_dim", "entity_ids",
-                               "domain_integral_type_map"]}
+                               "integration_dim", "entity_ids"]}
         config.update(quadrature_degree=degree, interface=self.context,
                       argument_multiindices=argument_multiindices)
         expr, = compile_ufl(integrand, PointSetContext(**config), point_sum=True)
@@ -559,7 +557,7 @@ def translate_cellvolume(terminal, mt, ctx):
     interface = CellVolumeKernelInterface(ctx, mt.restriction)
 
     config = {name: getattr(ctx, name)
-              for name in ["ufl_cell", "index_cache", "scalar_type", "domain_integral_type_map"]}
+              for name in ["ufl_cell", "index_cache", "scalar_type"]}
     config.update(interface=interface, quadrature_degree=degree, use_canonical_quadrature_point_ordering=False)
     expr, = compile_ufl(integrand, PointSetContext(**config), point_sum=True)
     return expr
@@ -574,7 +572,7 @@ def translate_facetarea(terminal, mt, ctx):
 
     config = {name: getattr(ctx, name)
               for name in ["ufl_cell", "integration_dim", "scalar_type",
-                           "entity_ids", "index_cache", "domain_integral_type_map"]}
+                           "entity_ids", "index_cache"]}
     config.update(interface=ctx, quadrature_degree=degree, use_canonical_quadrature_point_ordering=False)
     expr, = compile_ufl(integrand, PointSetContext(**config), point_sum=True)
     return expr
@@ -588,7 +586,7 @@ def translate_cellorigin(terminal, mt, ctx):
     point_set = PointSingleton((0.0,) * domain.topological_dimension())
 
     config = {name: getattr(ctx, name)
-              for name in ["ufl_cell", "index_cache", "scalar_type", "domain_integral_type_map"]}
+              for name in ["ufl_cell", "index_cache", "scalar_type"]}
     config.update(interface=ctx, point_set=point_set, use_canonical_quadrature_point_ordering=False)
     context = PointSetContext(**config)
     return context.translator(expression)
@@ -601,7 +599,7 @@ def translate_cell_vertices(terminal, mt, ctx):
     ps = PointSet(numpy.array(ctx.fiat_cell.get_vertices()))
 
     config = {name: getattr(ctx, name)
-              for name in ["ufl_cell", "index_cache", "scalar_type", "domain_integral_type_map"]}
+              for name in ["ufl_cell", "index_cache", "scalar_type"]}
     config.update(interface=ctx, point_set=ps, use_canonical_quadrature_point_ordering=False)
     context = PointSetContext(**config)
     expr = context.translator(ufl_expr)

tsfc/kernel_interface/__init__.py

@@ -47,5 +47,9 @@ def unsummed_coefficient_indices(self):
         """A set of indices that coefficient evaluation should not sum over.
         Used for macro-cell integration."""
 
+    @abstractproperty
+    def domain_integral_type_map(self):
+        """domain integral_type map."""
+
 
 ProxyKernelInterface = make_proxy_class('ProxyKernelInterface', KernelInterface)

tsfc/kernel_interface/common.py

@@ -122,6 +122,11 @@ def register_requirements(self, ir):
         # Nothing is required by default
         pass
 
+    @property
+    def domain_integral_type_map(self):
+        """domain integral_type map."""
+        return self._domain_integral_type_map
+
 
 class KernelBuilderMixin(object):
     """Mixin for KernelBuilder classes."""
@@ -141,7 +146,6 @@ def compile_integrand(self, integrand, params, ctx):
         set_quad_rule(params, info.domain.ufl_cell(), info.integral_type, functions)
         quad_rule = params["quadrature_rule"]
         config = self.fem_config()
-        config['domain_integral_type_map'] = self._domain_integral_type_map
         config['argument_multiindices'] = self.argument_multiindices
         config['quadrature_rule'] = quad_rule
         config['index_cache'] = ctx['index_cache']