--- /srv/reproducible-results/rbuild-debian/r-b-build.whxtjzF9/b1/fenics-dolfinx_0.8.0-10_arm64.changes +++ /srv/reproducible-results/rbuild-debian/r-b-build.whxtjzF9/b2/fenics-dolfinx_0.8.0-10_arm64.changes ├── Files │ @@ -1,9 +1,9 @@ │ │ - 9ae9777a10e74ff33a505c728707f805 1199856 doc optional dolfinx-doc_0.8.0-10_all.deb │ + beb8285b2abd322fe6201c35b0a175f0 1199876 doc optional dolfinx-doc_0.8.0-10_all.deb │ 1a11ac42d7e203ed8dd4c4f0855ed868 46676 libdevel optional libdolfinx-complex-dev_0.8.0-10_arm64.deb │ 6affb0adc555c130684fb522ccaf84f7 11936900 debug optional libdolfinx-complex0.8-dbgsym_0.8.0-10_arm64.deb │ 105708ffcc041dcd8e231953b8a8263b 508600 libs optional libdolfinx-complex0.8_0.8.0-10_arm64.deb │ c1822569b884e8cf1b414533e5fcea91 207796 libdevel optional libdolfinx-dev_0.8.0-10_arm64.deb │ e6eb23bdbd1993ce55f62aa4dc20ab4c 46676 libdevel optional libdolfinx-real-dev_0.8.0-10_arm64.deb │ 7f62b9574f03e5477c3a7fb996c1e603 11934276 debug optional libdolfinx-real0.8-dbgsym_0.8.0-10_arm64.deb │ 5f47eabfad8f3133d530366e321636e3 509104 libs optional libdolfinx-real0.8_0.8.0-10_arm64.deb ├── dolfinx-doc_0.8.0-10_all.deb │ ├── file list │ │ @@ -1,3 +1,3 @@ │ │ -rw-r--r-- 0 0 0 4 2024-06-22 12:59:48.000000 debian-binary │ │ --rw-r--r-- 0 0 0 21620 2024-06-22 12:59:48.000000 control.tar.xz │ │ --rw-r--r-- 0 0 0 1178044 2024-06-22 12:59:48.000000 data.tar.xz │ │ +-rw-r--r-- 0 0 0 21624 2024-06-22 12:59:48.000000 control.tar.xz │ │ +-rw-r--r-- 0 0 0 1178060 2024-06-22 12:59:48.000000 data.tar.xz │ ├── control.tar.xz │ │ ├── control.tar │ │ │ ├── ./md5sums │ │ │ │ ├── ./md5sums │ │ │ │ │┄ Files differ │ ├── data.tar.xz │ │ ├── data.tar │ │ │ ├── file list │ │ │ │ @@ -886,17 +886,17 @@ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/56ce7e71d8c71b4d8ef7c699176dd4fd/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 19145 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/56ce7e71d8c71b4d8ef7c699176dd4fd/demo_stokes.py │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/67f8546536727bd5386a27073bd16e12/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 8030 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/67f8546536727bd5386a27073bd16e12/demo_elasticity.py │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/6ad57720b461988475bd5c9286e3f111/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 7392 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/6ad57720b461988475bd5c9286e3f111/demo_types.py │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/9561cf6cd1a70079b986f4eb31580cbd/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 3870 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/9561cf6cd1a70079b986f4eb31580cbd/demo_poisson_matrix_free.ipynb.gz │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 3873 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/9561cf6cd1a70079b986f4eb31580cbd/demo_poisson_matrix_free.ipynb.gz │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/9ed4657d08dda04de30e6463e2f58d75/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 2603 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/9ed4657d08dda04de30e6463e2f58d75/demo_mixed-poisson.ipynb.gz │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 2602 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/9ed4657d08dda04de30e6463e2f58d75/demo_mixed-poisson.ipynb.gz │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/b94ac7be61dc3726ca331afd20f195d2/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 5600 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/b94ac7be61dc3726ca331afd20f195d2/demo_poisson.py │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/e8140d02a100265518e126a3cfe79d8e/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 3877 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/e8140d02a100265518e126a3cfe79d8e/demo_interpolation-io.py │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/e8b180b39a27d7b04c2f666d14475ee3/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 11162 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/e8b180b39a27d7b04c2f666d14475ee3/demo_cahn-hilliard.py │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-06-22 12:59:48.000000 ./usr/share/doc/dolfinx-doc/python/_downloads/f6f3cc4d9540871af057920d1ddb5561/ │ │ │ ├── ./usr/share/doc/dolfinx-doc/python/_downloads/9561cf6cd1a70079b986f4eb31580cbd/demo_poisson_matrix_free.ipynb.gz │ │ │ │ ├── demo_poisson_matrix_free.ipynb │ │ │ │ │ ├── Pretty-printed │ │ │ │ │ │┄ Similarity: 0.9876077586206897% │ │ │ │ │ │┄ Differences: {"'cells'": "{0: {'id': '286df229'}, 1: {'id': 'a52a7225'}, 2: {'id': '1ebbff1c'}, 3: {'id': " │ │ │ │ │ │┄ "'b35ee887'}, 4: {'id': '3b5d03ab'}, 5: {'id': '50fffeb3'}, 6: {'id': 'fdd8b43b'}, 7: " │ │ │ │ │ │┄ "{'id': '7f05754f'}, 8: {'id': '47859317'}, 9: {'id': 'ecc929f3'}, 10: {'id': " │ │ │ │ │ │┄ "'cfeb5a53'}, 11: {'id': '9cf6510d'}, 12: {'id': 'f154ac7c'}, 13: {'id': '06193cfd'}, " │ │ │ │ │ │┄ "14: {'id': '6545f6d9'}, 15: {'id': '1a891546'}, 16: {'id': '4224d76f'}, 17: {'id': " │ │ │ │ │ │┄ "'c0079a3d'}, 1 […] │ │ │ │ │ │ @@ -1,12 +1,12 @@ │ │ │ │ │ │ { │ │ │ │ │ │ "cells": [ │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "markdown", │ │ │ │ │ │ - "id": "9c5797d4", │ │ │ │ │ │ + "id": "286df229", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "# Matrix-free conjugate gradient solver for the Poisson equation\n", │ │ │ │ │ │ "\n", │ │ │ │ │ │ "This demo illustrates how to solve the Poisson equation using a\n", │ │ │ │ │ │ "matrix-free conjugate gradient (CG) solver. In particular, it\n", │ │ │ │ │ │ "illustrates how to\n", │ │ │ │ │ │ @@ -68,84 +68,84 @@ │ │ │ │ │ │ "\n", │ │ │ │ │ │ "The modules that will be used are imported:" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "7a875a24", │ │ │ │ │ │ + "id": "a52a7225", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "from mpi4py import MPI" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "7807ed77", │ │ │ │ │ │ + "id": "1ebbff1c", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "import numpy as np" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "64b22440", │ │ │ │ │ │ + "id": "b35ee887", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "import dolfinx\n", │ │ │ │ │ │ "import ufl\n", │ │ │ │ │ │ "from dolfinx import fem, la\n", │ │ │ │ │ │ "from ufl import action, dx, grad, inner" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "markdown", │ │ │ │ │ │ - "id": "bec21b4b", │ │ │ │ │ │ + "id": "3b5d03ab", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "We begin by using {py:func}`create_rectangle\n", │ │ │ │ │ │ "` to create a rectangular\n", │ │ │ │ │ │ "{py:class}`Mesh ` of the domain, and creating a\n", │ │ │ │ │ │ "finite element {py:class}`FunctionSpace `\n", │ │ │ │ │ │ "on the mesh." │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "379fe201", │ │ │ │ │ │ + "id": "50fffeb3", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "dtype = dolfinx.default_scalar_type\n", │ │ │ │ │ │ "real_type = np.real(dtype(0.0)).dtype\n", │ │ │ │ │ │ "comm = MPI.COMM_WORLD\n", │ │ │ │ │ │ "mesh = dolfinx.mesh.create_rectangle(comm, [[0.0, 0.0], [1.0, 1.0]], [10, 10], dtype=real_type)" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "a0dd152e", │ │ │ │ │ │ + "id": "fdd8b43b", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "# Create function space\n", │ │ │ │ │ │ "degree = 2\n", │ │ │ │ │ │ "V = fem.functionspace(mesh, (\"Lagrange\", degree))" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "markdown", │ │ │ │ │ │ - "id": "5fa3ff55", │ │ │ │ │ │ + "id": "7f05754f", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "The second argument to {py:class}`functionspace\n", │ │ │ │ │ │ "` is a tuple consisting of `(family,\n", │ │ │ │ │ │ "degree)`, where `family` is the finite element family, and `degree`\n", │ │ │ │ │ │ "specifies the polynomial degree. In this case `V` consists of\n", │ │ │ │ │ │ "third-order, continuous Lagrange finite element functions.\n", │ │ │ │ │ │ @@ -156,94 +156,94 @@ │ │ │ │ │ │ "and then retrieving all facets on the boundary using\n", │ │ │ │ │ │ "{py:func}`exterior_facet_indices `." │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "3097e699", │ │ │ │ │ │ + "id": "47859317", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "tdim = mesh.topology.dim\n", │ │ │ │ │ │ "mesh.topology.create_connectivity(tdim - 1, tdim)\n", │ │ │ │ │ │ "facets = dolfinx.mesh.exterior_facet_indices(mesh.topology)" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "markdown", │ │ │ │ │ │ - "id": "71409ba8", │ │ │ │ │ │ + "id": "ecc929f3", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "We now find the degrees of freedom that are associated with the boundary\n", │ │ │ │ │ │ "facets using\n", │ │ │ │ │ │ "{py:func}`locate_dofs_topological `" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "697e2e3d", │ │ │ │ │ │ + "id": "cfeb5a53", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "dofs = fem.locate_dofs_topological(V=V, entity_dim=tdim - 1, entities=facets)" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "markdown", │ │ │ │ │ │ - "id": "f979fd8d", │ │ │ │ │ │ + "id": "9cf6510d", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "and use {py:func}`dirichletbc ` to define the\n", │ │ │ │ │ │ "essential boundary condition. On the boundary we prescribe the\n", │ │ │ │ │ │ "{py:class}`Function ` `uD`, which we create by\n", │ │ │ │ │ │ "interpolating the expression $u_{\\rm D}$ in the finite element space\n", │ │ │ │ │ │ "$V$." │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "1ed8f000", │ │ │ │ │ │ + "id": "f154ac7c", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "uD = fem.Function(V, dtype=dtype)\n", │ │ │ │ │ │ "uD.interpolate(lambda x: 1 + x[0] ** 2 + 2 * x[1] ** 2)\n", │ │ │ │ │ │ "bc = fem.dirichletbc(value=uD, dofs=dofs)" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "markdown", │ │ │ │ │ │ - "id": "2952f82e", │ │ │ │ │ │ + "id": "06193cfd", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "Next, we express the variational problem using UFL." │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "e14313e3", │ │ │ │ │ │ + "id": "6545f6d9", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "x = ufl.SpatialCoordinate(mesh)\n", │ │ │ │ │ │ "u = ufl.TrialFunction(V)\n", │ │ │ │ │ │ "v = ufl.TestFunction(V)\n", │ │ │ │ │ │ "f = fem.Constant(mesh, dtype(-6.0))\n", │ │ │ │ │ │ "a = inner(grad(u), grad(v)) * dx\n", │ │ │ │ │ │ "L = inner(f, v) * dx\n", │ │ │ │ │ │ "L_fem = fem.form(L, dtype=dtype)" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "markdown", │ │ │ │ │ │ - "id": "df0a5ed6", │ │ │ │ │ │ + "id": "1a891546", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "For the matrix-free solvers we also define a second linear form `M` as\n", │ │ │ │ │ │ "the {py:class}`action ` of the bilinear form $a$ on an\n", │ │ │ │ │ │ "arbitrary {py:class}`Function ` `ui`. This linear\n", │ │ │ │ │ │ "form is defined as\n", │ │ │ │ │ │ "\n", │ │ │ │ │ │ @@ -251,78 +251,78 @@ │ │ │ │ │ │ "M(v) = a(u_i, v) \\quad \\text{for} \\; \\ u_i \\in V.\n", │ │ │ │ │ │ "$$" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "e1b39c5b", │ │ │ │ │ │ + "id": "4224d76f", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "ui = fem.Function(V, dtype=dtype)\n", │ │ │ │ │ │ "M = action(a, ui)\n", │ │ │ │ │ │ "M_fem = fem.form(M, dtype=dtype)" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "markdown", │ │ │ │ │ │ - "id": "7c87c227", │ │ │ │ │ │ + "id": "c0079a3d", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "### Matrix-free conjugate gradient solver\n", │ │ │ │ │ │ "\n", │ │ │ │ │ │ "The right hand side vector $b - A x_{\\rm bc}$ is the assembly of the linear\n", │ │ │ │ │ │ "form $L$ where the essential Dirichlet boundary conditions are implemented\n", │ │ │ │ │ │ "using lifting. Since we want to avoid assembling the matrix `A`, we compute\n", │ │ │ │ │ │ "the necessary matrix-vector product using the linear form `M` explicitly." │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "3a0e7b3d", │ │ │ │ │ │ + "id": "bd3bfb46", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "# Apply lifting: b <- b - A * x_bc\n", │ │ │ │ │ │ "b = fem.assemble_vector(L_fem)\n", │ │ │ │ │ │ "ui.x.array[:] = 0.0\n", │ │ │ │ │ │ "fem.set_bc(ui.x.array, [bc], scale=-1.0)\n", │ │ │ │ │ │ "fem.assemble_vector(b.array, M_fem)\n", │ │ │ │ │ │ "b.scatter_reverse(la.InsertMode.add)" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "e6729588", │ │ │ │ │ │ + "id": "13685d4b", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "# Set BC dofs to zero on right hand side\n", │ │ │ │ │ │ "fem.set_bc(b.array, [bc], scale=0.0)\n", │ │ │ │ │ │ "b.scatter_forward()" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "markdown", │ │ │ │ │ │ - "id": "f7fca990", │ │ │ │ │ │ + "id": "980e5a6c", │ │ │ │ │ │ "metadata": { │ │ │ │ │ │ "lines_to_next_cell": 2 │ │ │ │ │ │ }, │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "To implement the matrix-free CG solver using *DOLFINx* vectors, we define the\n", │ │ │ │ │ │ "function `action_A` to compute the matrix-vector product $y = A x$." │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "9622ee4b", │ │ │ │ │ │ + "id": "c9f7adfb", │ │ │ │ │ │ "metadata": { │ │ │ │ │ │ "lines_to_next_cell": 2 │ │ │ │ │ │ }, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "def action_A(x, y):\n", │ │ │ │ │ │ " # Set coefficient vector of the linear form M and ensure it is updated\n", │ │ │ │ │ │ @@ -337,15 +337,15 @@ │ │ │ │ │ │ "\n", │ │ │ │ │ │ " # Set BC dofs to zero\n", │ │ │ │ │ │ " fem.set_bc(y.array, [bc], scale=0.0)" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "markdown", │ │ │ │ │ │ - "id": "dfc29b48", │ │ │ │ │ │ + "id": "13eb5f07", │ │ │ │ │ │ "metadata": { │ │ │ │ │ │ "lines_to_next_cell": 2 │ │ │ │ │ │ }, │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "### Basic conjugate gradient solver\n", │ │ │ │ │ │ "\n", │ │ │ │ │ │ "Solves the problem `A x = b`, using the function `action_A` as the operator,\n", │ │ │ │ │ │ @@ -353,15 +353,15 @@ │ │ │ │ │ │ "vector. `comm` is the MPI Communicator, `max_iter` is the maximum number of\n", │ │ │ │ │ │ "iterations, `rtol` is the relative tolerance." │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "393dcc22", │ │ │ │ │ │ + "id": "b964fd76", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "def cg(comm, action_A, x: la.Vector, b: la.Vector, max_iter: int = 200, rtol: float = 1e-6):\n", │ │ │ │ │ │ " rtol2 = rtol**2\n", │ │ │ │ │ │ "\n", │ │ │ │ │ │ " nr = b.index_map.size_local\n", │ │ │ │ │ │ @@ -399,61 +399,61 @@ │ │ │ │ │ │ " p.array[:] = beta * p.array + r\n", │ │ │ │ │ │ "\n", │ │ │ │ │ │ " raise RuntimeError(f\"Solver exceeded max iterations ({max_iter}).\")" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "markdown", │ │ │ │ │ │ - "id": "4f0bed95", │ │ │ │ │ │ + "id": "031d5e53", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "This matrix-free solver is now used to compute the finite element solution.\n", │ │ │ │ │ │ "The finite element solution's approximation error as compared with the\n", │ │ │ │ │ │ "exact solution is measured in the $L_2$-norm." │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "0fb8cf9f", │ │ │ │ │ │ + "id": "e489c21d", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "rtol = 1e-6\n", │ │ │ │ │ │ "u = fem.Function(V, dtype=dtype)\n", │ │ │ │ │ │ "iter_cg1 = cg(mesh.comm, action_A, u.x, b, max_iter=200, rtol=rtol)" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "e05956ab", │ │ │ │ │ │ + "id": "9bbe4107", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "# Set BC values in the solution vector\n", │ │ │ │ │ │ "fem.set_bc(u.x.array, [bc], scale=1.0)" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "9599a84e", │ │ │ │ │ │ + "id": "c71cede5", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "def L2Norm(u):\n", │ │ │ │ │ │ " val = fem.assemble_scalar(fem.form(inner(u, u) * dx, dtype=dtype))\n", │ │ │ │ │ │ " return np.sqrt(comm.allreduce(val, op=MPI.SUM))" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "86693038", │ │ │ │ │ │ + "id": "ec679260", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "# Print CG iteration number and error\n", │ │ │ │ │ │ "error_L2_cg1 = L2Norm(u - uD)\n", │ │ │ │ │ │ "if mesh.comm.rank == 0:\n", │ │ │ │ │ │ " print(\"Matrix-free CG solver using DOLFINx vectors:\")\n", │ │ │ ├── ./usr/share/doc/dolfinx-doc/python/_downloads/9ed4657d08dda04de30e6463e2f58d75/demo_mixed-poisson.ipynb.gz │ │ │ │ ├── demo_mixed-poisson.ipynb │ │ │ │ │ ├── Pretty-printed │ │ │ │ │ │┄ Similarity: 0.9856770833333333% │ │ │ │ │ │┄ Differences: {"'cells'": "{0: {'id': '738dcb0e'}, 1: {'id': 'be24fc49'}, 2: {'id': '2daf26aa'}, 3: {'id': " │ │ │ │ │ │┄ "'1b0c2110'}}"} │ │ │ │ │ │ @@ -1,32 +1,32 @@ │ │ │ │ │ │ { │ │ │ │ │ │ "cells": [ │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "markdown", │ │ │ │ │ │ - "id": "c22f180e", │ │ │ │ │ │ + "id": "738dcb0e", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "# Mixed formulation for the Poisson equation" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "markdown", │ │ │ │ │ │ - "id": "e07ddd00", │ │ │ │ │ │ + "id": "be24fc49", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "This demo illustrates how to solve Poisson equation using a mixed\n", │ │ │ │ │ │ "(two-field) formulation. In particular, it illustrates how to\n", │ │ │ │ │ │ "\n", │ │ │ │ │ │ "* Use mixed and non-continuous finite element spaces.\n", │ │ │ │ │ │ "* Set essential boundary conditions for subspaces and $H(\\mathrm{div})$ spaces.\n" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "markdown", │ │ │ │ │ │ - "id": "29d9831d", │ │ │ │ │ │ + "id": "2daf26aa", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "```{admonition} Download sources\n", │ │ │ │ │ │ ":class: download\n", │ │ │ │ │ │ "\n", │ │ │ │ │ │ "* {download}`Python script <./demo_mixed-poisson.py>`\n", │ │ │ │ │ │ "* {download}`Jupyter notebook <./demo_mixed-poisson.ipynb>`\n", │ │ │ │ │ │ @@ -99,15 +99,15 @@ │ │ │ │ │ │ "\n", │ │ │ │ │ │ "## Implementation" │ │ │ │ │ │ ] │ │ │ │ │ │ }, │ │ │ │ │ │ { │ │ │ │ │ │ "cell_type": "code", │ │ │ │ │ │ "execution_count": null, │ │ │ │ │ │ - "id": "51b23fe7", │ │ │ │ │ │ + "id": "1b0c2110", │ │ │ │ │ │ "metadata": {}, │ │ │ │ │ │ "outputs": [], │ │ │ │ │ │ "source": [ │ │ │ │ │ │ "\n", │ │ │ │ │ │ "from mpi4py import MPI\n", │ │ │ │ │ │ "from petsc4py import PETSc\n", │ │ │ │ │ │ "\n",