suggestions from review

Author: pbrubeck

firedrake/assemble.py

@@ -835,14 +835,10 @@ def restructure_base_form(expr, visited=None):
     def preprocess_base_form(expr, mat_type=None, form_compiler_parameters=None):
         """Preprocess ufl.BaseForm objects"""
         original_expr = expr
-        if mat_type != "matfree":
+        if len(expr.arguments()) == 2 and mat_type != "matfree":
             # Don't expand derivatives if `mat_type` is 'matfree'
             # For "matfree", Form evaluation is delayed
-            try:
-                expr = BaseFormAssembler.expand_derivatives_form(expr, form_compiler_parameters)
-            except ValueError:
-                # BaseForms with SLATE tensors are not fully supported in UFL.
-                pass
+            expr = BaseFormAssembler.expand_derivatives_form(expr, form_compiler_parameters)
         if not isinstance(expr, (ufl.form.Form, slate.TensorBase)):
             # => No restructuring needed for Form and slate.TensorBase
             expr = BaseFormAssembler.restructure_base_form_preorder(expr)

firedrake/variational_solver.py

@@ -133,7 +133,22 @@ def dm(self):
 
     @staticmethod
     def compute_bc_lifting(J, u, L=0):
-        """Return the action of the bilinear form J (without bcs) on a Function u."""
+        """Compute the residual after lifting DirichletBCs.
+
+        Parameters
+        ----------
+        J : ufl.BaseForm or slate.TensorBase
+            The Jacobian bilinear form.
+        u : firedrake.Function
+            The Function on which DirichletBCs are applied.
+        L : ufl.BaseForm or slate.TensorBase
+            The unlifted residual linear form.
+
+        Return
+        ------
+        F : ufl.BaseForm or slate.TensorBase
+            The residual J*u-L after lifting DirichletBCs.
+        """
         if isinstance(J, MatrixBase) and J.has_bcs:
             # Extract the full form without bcs
             if not isinstance(J.a, (ufl.BaseForm, slate.slate.TensorBase)):
@@ -399,14 +414,12 @@ def __init__(self, a, L, u, bcs=None, aP=None,
         """
         # In the linear case, the Jacobian is the equation LHS (J=a).
         # Jacobian is checked in superclass, but let's check L here.
-        if not isinstance(L, (ufl.BaseForm, slate.slate.TensorBase)) and L == 0:
-            F = self.compute_bc_lifting(a, u)
-        else:
-            if not isinstance(L, (ufl.BaseForm, slate.slate.TensorBase)):
-                raise TypeError("Provided RHS is a '%s', not a Form or Slate Tensor" % type(L).__name__)
+        if isinstance(L, (ufl.BaseForm, slate.slate.TensorBase)):
             if len(L.arguments()) != 1 and not L.empty():
                 raise ValueError("Provided RHS is not a linear form")
-            F = self.compute_bc_lifting(a, u, L=L)
+        elif L != 0:
+            raise TypeError(f"Provided RHS is a '{type(L).__name__}', not a Form or Slate Tensor")
+        F = self.compute_bc_lifting(a, u, L=L)
 
         super(LinearVariationalProblem, self).__init__(F, u, bcs=bcs, J=a, Jp=aP,
                                                        form_compiler_parameters=form_compiler_parameters,