Pass kwargs to Cofunction.interpolate

Author: pbrubeck

firedrake/cofunction.py

@@ -308,14 +308,45 @@ def __imul__(self, expr):
             return self
         return NotImplemented
 
-    def interpolate(self, expression):
-        r"""Interpolate an expression onto this :class:`Cofunction`.
-
-        :param expression: a UFL expression to interpolate
+    @PETSc.Log.EventDecorator()
+    def interpolate(
+        self,
+        expression,
+        subset=None,
+        allow_missing_dofs=False,
+        default_missing_val=None,
+        ad_block_tag=None
+    ):
+        r"""Interpolate a dual expression onto this :class:`Cofunction`.
+
+        :param expression: a dual UFL expression to interpolate
+        :kwarg subset: An optional :class:`pyop2.types.set.Subset` to apply the
+            interpolation over. Cannot, at present, be used when interpolating
+            across meshes unless the target mesh is a :func:`.VertexOnlyMesh`.
+        :kwarg allow_missing_dofs: For interpolation across meshes: allow
+            degrees of freedom (aka DoFs/nodes) in the target mesh that cannot be
+            defined on the source mesh. For example, where nodes are point
+            evaluations, points in the target mesh that are not in the source mesh.
+            When ``False`` this raises a ``ValueError`` should this occur. When
+            ``True`` the corresponding values are set to zero or to the value
+            ``default_missing_val`` if given. Ignored if interpolating within the
+            same mesh or onto a :func:`.VertexOnlyMesh` (the behaviour of a
+            :func:`.VertexOnlyMesh` in this scenario is, at present, set when
+            it is created).
+        :kwarg default_missing_val: For interpolation across meshes: the optional
+            value to assign to DoFs in the target mesh that are outside the source
+            mesh. If this is not set then zero is used. Ignored if interpolating
+            within the same mesh or onto a :func:`.VertexOnlyMesh`.
+        :kwarg ad_block_tag: An optional string for tagging the resulting assemble block on
+            the Pyadjoint tape.
         :returns: this :class:`firedrake.cofunction.Cofunction` object"""
-        from firedrake import interpolation
-        interp = interpolation.Interpolate(ufl_expr.Argument(self.function_space().dual(), 0), expression)
-        return firedrake.assemble(interp, tensor=self)
+        from firedrake import interpolate, assemble
+        v, = self.arguments()
+        interp = interpolate(v, expression,
+                             subset=subset,
+                             allow_missing_dofs=allow_missing_dofs,
+                             default_missing_val=default_missing_val)
+        return assemble(interp, tensor=self, ad_block_tag=ad_block_tag)
 
     @property
     def cell_set(self):