Merge branch 'main' into pbrubeck/test/gem

Author: pbrubeck

.github/workflows/core.yml

@@ -121,7 +121,7 @@ jobs:
       - name: Install system dependencies (1)
         run: apt-get -y install git python3
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           path: firedrake-repo
           ref: ${{ inputs.source_ref }}
@@ -207,10 +207,7 @@ jobs:
           pip install --verbose $EXTRA_PIP_FLAGS \
             --no-binary h5py \
             --extra-index-url https://download.pytorch.org/whl/cpu \
-            "$(echo ./firedrake-repo/dist/firedrake-*.tar.gz)"
-
-          pip install -U pip
-          pip install --group ./firedrake-repo/pyproject.toml:ci
+            "$(echo ./firedrake-repo/dist/firedrake-*.tar.gz)[ci,docs]"
 
           pip install -I "firedrake-fiat @ git+https://github.com/firedrakeproject/fiat.git@pbrubeck/simplify-indexed"
           firedrake-clean
@@ -455,7 +452,7 @@ jobs:
         # Make sure the current directory is empty
         run: find . -delete
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           path: firedrake-repo
           ref: ${{ inputs.source_ref }}
@@ -534,7 +531,7 @@ jobs:
     name: Lint codebase
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           ref: ${{ inputs.source_ref }}
       - uses: actions/setup-python@v5

.github/workflows/docker_build.yml

@@ -58,7 +58,7 @@ jobs:
           echo "/opt/homebrew/bin" >> "$GITHUB_PATH"
 
       - name: Check out the repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Log in to Docker Hub
         uses: docker/login-action@v3

.github/workflows/pr.yml

@@ -8,7 +8,7 @@ jobs:
   test:
     uses: ./.github/workflows/core.yml
     with:
-      source_ref: ${{ github.head_ref }}
+      source_ref: ${{ github.ref }}
       target_branch: ${{ github.base_ref }}
       # Only run macOS tests if the PR is labelled 'macOS'
       test_macos: ${{ contains(github.event.pull_request.labels.*.name, 'macOS') }}

demos/full_waveform_inversion/full_waveform_inversion.py.rst

@@ -109,10 +109,12 @@ built over the ``my_ensemble.comm`` (spatial) communicator.
         dt = 0.03  # time step in seconds
         final_time = 0.6  # final time in seconds
         nx, ny = 15, 15
+        ftol = 0.9  # optimisation tolerance
     else:
         dt = 0.002  # time step in seconds
         final_time = 1.0  # final time in seconds
         nx, ny = 80, 80
+        ftol = 1e-2  # optimisation tolerance
 
     mesh = UnitSquareMesh(nx, ny, comm=my_ensemble.comm)
 
@@ -278,21 +280,28 @@ To have the step 4, we need first to tape the forward problem. That is done by c
 
 We now instantiate :class:`~.EnsembleReducedFunctional`::
 
-    J_hat = EnsembleReducedFunctional(J_val, Control(c_guess), my_ensemble)
+    J_hat = EnsembleReducedFunctional(J_val,
+                                      Control(c_guess, riesz_map="l2"),
+                                      my_ensemble)
 
 which enables us to recompute :math:`J` and its gradient :math:`\nabla_{\mathtt{c\_guess}} J`,
 where the :math:`J_s` and its gradients :math:`\nabla_{\mathtt{c\_guess}} J_s` are computed in parallel
 based on the ``my_ensemble`` configuration.
 
 
 **Steps 4-6**: The instance of the :class:`~.EnsembleReducedFunctional`, named ``J_hat``,
-is then passed as an argument to the ``minimize`` function::
+is then passed as an argument to the ``minimize`` function. The default ``minimize`` function
+uses ``scipy.minimize``, and wraps the ``ReducedFunctional`` in a ``ReducedFunctionalNumPy``
+that handles transferring data between Firedrake and numpy data structures. However, because
+we have a custom ``ReducedFunctional``, we need to do this ourselves::
 
-    c_optimised = minimize(J_hat, method="L-BFGS-B", options={"disp": True, "maxiter": 1},
-                            bounds=(1.5, 2.0), derivative_options={"riesz_representation": 'l2'}
-                            )
+    from pyadjoint.reduced_functional_numpy import ReducedFunctionalNumPy
+    Jnumpy = ReducedFunctionalNumPy(J_hat)
 
-The ``minimize`` function executes the optimisation algorithm until the stopping criterion (``maxiter``) is met.
+    c_optimised = minimize(Jnumpy, method="L-BFGS-B", options={"disp": True, "ftol": ftol},
+                           bounds=(1.5, 2.0))
+
+The ``minimize`` function executes the optimisation algorithm until the stopping criterion (``ftol``) is met.
 For 20 iterations, the predicted velocity model is shown in the following figure.
 
 .. image:: c_predicted.png
@@ -303,9 +312,7 @@ For 20 iterations, the predicted velocity model is shown in the following figure
 .. warning::
 
     The ``minimize`` function uses the SciPy library for optimisation. However, for scenarios that require higher
-    levels of spatial parallelism, you should assess whether SciPy is the most suitable option for your problem.
-    SciPy's optimisation algorithm is not inner-product-aware. Therefore, we configure the options with
-    ``derivative_options={"riesz_representation": 'l2'}`` to account for this requirement.
+    levels of spatial parallelism, you should assess whether SciPy is the most suitable option for your problem such as the pyadjoint's TAOSolver.
 
 .. note::
 

demos/linear_fluid_structure_interaction/linear_fluid_structure_interaction.py.rst

@@ -287,11 +287,11 @@ To save data for visualization, we change the position of the nodes in the mesh,
         output_data.counter += 1
         if output_data.counter % output_data_every_x_time_steps != 0:
             return
-        mesh_static = mesh.coordinates.vector().get_local()
-        mesh.coordinates.vector().set_local(mesh_static + X.vector().get_local())
-        mesh.coordinates.dat.data[:, 1] += eta.dat.data_ro
+        mesh_static = mesh.coordinates.copy(deepcopy=True)
+        mesh.coordinates += X
+        mesh.coordinates.dat.data_rw[:, 1] += eta.dat.data_ro
         outfile_phi.write(phi)
-        mesh.coordinates.vector().set_local(mesh_static)
+        mesh.coordinates.assign(mesh_static)
 
 
     output_data.counter = -1  # -1 to exclude counting print of initial state

demos/ma-demo/ma-demo.py.rst

@@ -97,9 +97,9 @@ one, we must explicitly specify the domain we wish to integrate over. ::
   x, y = SpatialCoordinate(mesh)
   fexpr = exp(-(cos(x)**2 + cos(y)**2))
   f = Function(V).interpolate(fexpr)
-  scaling = assemble(Constant(1, domain=mesh)*dx)/assemble(f*dx)
+  scaling = assemble(Constant(1)*dx(domain=mesh))/assemble(f*dx)
   f *= scaling
-  assert abs(assemble(f*dx)-assemble(Constant(1, domain=mesh)*dx)) < 1.0e-8
+  assert abs(assemble(f*dx)-assemble(Constant(1)*dx(domain=mesh))) < 1.0e-8
 
 Now we build the UFL expression for the variational form. We will use
 the nonlinear solve, so the form needs to be a 1-form that depends on

demos/saddle_point_pc/saddle_point_systems.py.rst

@@ -87,19 +87,12 @@ problem.  We will need some trial and test functions for the spaces::
         sigma, u = TrialFunctions(W)
         tau, v = TestFunctions(W)
 
-along with a function to hold the forcing term, living in the
+along with a random function to hold the forcing term, living in the
 discontinuous space. ::
 
     #
-        f = Function(V)
-
-To initialise this function to a random value we access its :class:`~.Vector`
-form and use numpy_ to set the values::
-
-    #
-        import numpy as np
-        fvector = f.vector()
-        fvector.set_local(np.random.uniform(size=fvector.local_size()))
+        rg = RandomGenerator()
+        f = rg.uniform(V)
 
 Note that the homogeneous Dirichlet conditions in the primal
 formulation turn into homogeneous Neumann conditions on the dual

demos/shape_optimization/shape_optimization.py.rst

@@ -70,9 +70,10 @@ and evaluate the objective function::
 
 We now turn the objective function into a reduced function so that pyadjoint
 (and UFL shape differentiation capability) can automatically compute shape
-gradients, that is, directions of steepest ascent::
+gradients, that is, directions of steepest ascent. We also set the relevant
+Riesz map for this problem::
 
-  Jred = ReducedFunctional(J, Control(dT))
+  Jred = ReducedFunctional(J, Control(dT, riesz_map="H1"))
   stop_annotating()
 
 We now have all the ingredients to implement a basic steepest descent shape
@@ -84,8 +85,7 @@ optimization algorithm with fixed step size.::
     File.write(mesh.coordinates)
 
     # compute the gradient (steepest ascent)
-    opts = {"riesz_representation": "H1"}
-    gradJ = Jred.derivative(options=opts)
+    gradJ = Jred.derivative(apply_riesz=True)
 
     # update domain
     dT -= 0.2*gradJ

docker/Dockerfile.vanilla

@@ -61,6 +61,5 @@ ENV CFLAGS="-mtune=generic" CPPFLAGS="-mtune=generic"
 ENV MPICC=$CC
 
 # Install Firedrake
-RUN pip install -U pip \
-    && git clone https://github.com/firedrakeproject/firedrake.git /opt/firedrake --branch release \
-    && pip install --verbose --no-binary h5py --editable /opt/firedrake --group /opt/firedrake/pyproject.toml:docker
+RUN pip install --verbose --no-binary h5py --src /opt \
+        --editable git+https://github.com/firedrakeproject/firedrake.git@release#egg=firedrake[docker]

docs/source/conf.py

@@ -257,6 +257,7 @@
 
     .. warning::
         You are reading a version of the website built against the unstable ``main`` branch. This content is liable to change without notice and may be inappropriate for your use case.
+        You can find the documentation for the current stable release `here <https://firedrakeproject.org/>`__.
 """
 
 # -- Options for LaTeX output --------------------------------------------