Include changes from #237 by @MattFerraro

Author: jorgensd

chapter1/fundamentals_code.ipynb

@@ -290,7 +290,8 @@
     "The inner product $\\int_\\Omega \\nabla u \\cdot \\nabla v ~\\mathrm{d} x$ can be expressed in various ways in UFL. We have used the notation `ufl.dot(ufl.grad(u), ufl.grad(v))*ufl.dx`.\n",
     "The dot product in UFL computes the sum (contraction) over the last index of the first factor and first index of the second factor.\n",
     "In this case, both factors are tensors of rank one (vectors) and so the sum is just over the single index of both $\\nabla u$ and $\\nabla v$.\n",
-    "To compute an inner product of matrices (with two indices), one must instead of `ufl.dot` use the function `ufl.inner`. For vectors, `ufl.dot` and `ufl.inner` are equivalent.\n",
+    "To compute an inner product of matrices (with two indices), on must use use the function `ufl.inner` instead of `ufl.dot`.\n",
+    "For vectors, `ufl.dot` and `ufl.inner` are equivalent.\n",
     "\n",
     "```{admonition} Complex numbers\n",
     "In DOLFINx, one can solve complex number problems by using an installation of PETSc using complex numbers.\n",

chapter1/fundamentals_code.py

@@ -173,7 +173,8 @@
 # The inner product $\int_\Omega \nabla u \cdot \nabla v ~\mathrm{d} x$ can be expressed in various ways in UFL. We have used the notation `ufl.dot(ufl.grad(u), ufl.grad(v))*ufl.dx`.
 # The dot product in UFL computes the sum (contraction) over the last index of the first factor and first index of the second factor.
 # In this case, both factors are tensors of rank one (vectors) and so the sum is just over the single index of both $\nabla u$ and $\nabla v$.
-# To compute an inner product of matrices (with two indices), one must instead of `ufl.dot` use the function `ufl.inner`. For vectors, `ufl.dot` and `ufl.inner` are equivalent.
+# To compute an inner product of matrices (with two indices), on must use use the function `ufl.inner` instead of `ufl.dot`.
+# For vectors, `ufl.dot` and `ufl.inner` are equivalent.
 #
 # ```{admonition} Complex numbers
 # In DOLFINx, one can solve complex number problems by using an installation of PETSc using complex numbers.

chapter2/linearelasticity_code.ipynb

@@ -14,7 +14,10 @@
     "- Compute Von Mises stresses\n",
     "\n",
     "## Test problem\n",
-    "As a test example, we will model a clamped beam deformed under its own weight in 3D. This can be modeled, by setting the right-hand side body force per unit volume to $f=(0,0,-\\rho g)$ with $\\rho$ the density of the beam and $g$ the acceleration of gravity. The beam is box-shaped with length $L$ and has a square cross section of width $W$. We set $u=u_D=(0,0,0)$ at the clamped end, x=0. The rest of the boundary is traction free, that is, we set $T=0$. We start by defining the physical variables used in the program."
+    "As a test example, we will model a clamped beam deformed under its own weight in 3D.\n",
+    "This can be modeled, by setting the right-hand side body force per unit volume to $f=(0,0,-\\rho g)$ with $\\rho$ the density of the beam and $g$ the acceleration of gravity.\n",
+    "The beam is box-shaped with length $L$ and has a square cross section of width $W$. We set $u=u_D=(0,0,0)$ at the clamped end, x=0. The rest of the boundary is traction free, that is, we set $T=0$.\n",
+    "We start by defining the physical variables used in the program."
    ]
   },
   {
@@ -24,7 +27,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Scaled variable\n",
     "import pyvista\n",
     "from dolfinx import mesh, fem, plot, io, default_scalar_type\n",
     "from dolfinx.fem.petsc import LinearProblem\n",
@@ -41,7 +43,7 @@
    },
    "outputs": [],
    "source": [
-    "L = 1\n",
+    "L = 1.0\n",
     "W = 0.2\n",
     "mu = 1\n",
     "rho = 1\n",

chapter4/compiler_parameters.ipynb

@@ -26,11 +26,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import matplotlib.pyplot as plt\n",
     "import pandas as pd\n",
     "import seaborn\n",
     "import time\n",
-    "import ufl\n",
     "\n",
     "from ufl import TestFunction, TrialFunction, dx, inner\n",
     "from dolfinx.mesh import create_unit_cube\n",
@@ -50,7 +48,8 @@
    "id": "2",
    "metadata": {},
    "source": [
-    "Next we generate a general function to assemble the mass matrix for a unit cube. Note that we use `dolfinx.fem.form` to compile the variational form. For codes using `dolfinx.fem.petsc.LinearProblem`, you can supply `jit_options` as a keyword argument."
+    "Next we generate a general function to assemble the mass matrix for a unit cube. Note that we use `dolfinx.fem.form` to compile the variational form.\n",
+    "For codes using `dolfinx.fem.petsc.LinearProblem`, you can supply `jit_options` as a keyword argument."
    ]
   },
   {
@@ -136,8 +135,11 @@
     "                    cffi_options = [option, \"-march=native\"]\n",
     "                else:\n",
     "                    cffi_options = [option]\n",
-    "                jit_options = {\"cffi_extra_compile_args\": cffi_options,\n",
-    "                               \"cache_dir\": cache_dir, \"cffi_libraries\": [\"m\"]}\n",
+    "                jit_options = {\n",
+    "                    \"cffi_extra_compile_args\": cffi_options,\n",
+    "                    \"cache_dir\": cache_dir,\n",
+    "                    \"cffi_libraries\": [\"m\"],\n",
+    "                }\n",
     "                runtime = compile_form(space, degree, jit_options=jit_options)\n",
     "                results[\"Space\"].append(space)\n",
     "                results[\"Degree\"].append(str(degree))\n",
@@ -150,7 +152,9 @@
    "id": "10",
    "metadata": {},
    "source": [
-    "We have now stored all the results to a dictionary. To visualize it, we use pandas and its Dataframe class. We can inspect the data in a jupyter notebook as follows"
+    "We have now stored all the results to a dictionary. To visualize it, we use pandas and its Dataframe class.\n",
+    "To instpect the data in a Jupyter notebook, call the code below.\n",
+    "If you are running this code in a script, you can use `print(results_df)` instead."
    ]
   },
   {
@@ -169,7 +173,8 @@
    "id": "12",
    "metadata": {},
    "source": [
-    "We can now make a plot for each element type to see the variation given the different compile options. We create a new colum for each element type and degree."
+    "Next, we inspect the impact of the compiler option on each type of finite element family.\n",
+    "To achieve this, we add an extra column to the dataframe, which combines the space and degree of the finite element."
    ]
   },
   {
@@ -195,7 +200,8 @@
    "id": "14",
    "metadata": {},
    "source": [
-    "We observe that the compile time increases when increasing the degree of the function space, and that we get most speedup by using \"-O3\" or \"-Ofast\" combined with \"-march=native\"."
+    "We observe that the compile time increases when increasing the degree of the function space,\n",
+    "and that we get most speedup by using \"-O3\" or \"-Ofast\" combined with \"-march=native\"."
    ]
   }
  ],

chapter4/compiler_parameters.py

@@ -6,7 +6,7 @@
 #       extension: .py
 #       format_name: light
 #       format_version: '1.5'
-#       jupytext_version: 1.16.5
+#       jupytext_version: 1.17.2
 #   kernelspec:
 #     display_name: Python 3 (ipykernel)
 #     language: python
@@ -27,11 +27,9 @@
 # We start by specifying the current directory as the location to place the generated C files, we obtain the current directory using pathlib
 
 # +
-import matplotlib.pyplot as plt
 import pandas as pd
 import seaborn
 import time
-import ufl
 
 from ufl import TestFunction, TrialFunction, dx, inner
 from dolfinx.mesh import create_unit_cube
@@ -46,7 +44,8 @@
 print(f"Directory to put C files in: {cache_dir}")
 # -
 
-# Next we generate a general function to assemble the mass matrix for a unit cube. Note that we use `dolfinx.fem.form` to compile the variational form. For codes using `dolfinx.fem.petsc.LinearProblem`, you can supply `jit_options` as a keyword argument.
+# Next we generate a general function to assemble the mass matrix for a unit cube. Note that we use `dolfinx.fem.form` to compile the variational form.
+# For codes using `dolfinx.fem.petsc.LinearProblem`, you can supply `jit_options` as a keyword argument.
 
 # +
 
@@ -86,20 +85,26 @@ def compile_form(space: str, degree: int, jit_options: Dict):
                     cffi_options = [option, "-march=native"]
                 else:
                     cffi_options = [option]
-                jit_options = {"cffi_extra_compile_args": cffi_options,
-                               "cache_dir": cache_dir, "cffi_libraries": ["m"]}
+                jit_options = {
+                    "cffi_extra_compile_args": cffi_options,
+                    "cache_dir": cache_dir,
+                    "cffi_libraries": ["m"],
+                }
                 runtime = compile_form(space, degree, jit_options=jit_options)
                 results["Space"].append(space)
                 results["Degree"].append(str(degree))
                 results["Options"].append("\n".join(cffi_options))
                 results["Time"].append(runtime)
 
-# We have now stored all the results to a dictionary. To visualize it, we use pandas and its Dataframe class. We can inspect the data in a jupyter notebook as follows
+# We have now stored all the results to a dictionary. To visualize it, we use pandas and its Dataframe class.
+# To instpect the data in a Jupyter notebook, call the code below.
+# If you are running this code in a script, you can use `print(results_df)` instead.
 
 results_df = pd.DataFrame.from_dict(results)
 results_df
 
-# We can now make a plot for each element type to see the variation given the different compile options. We create a new colum for each element type and degree.
+# Next, we inspect the impact of the compiler option on each type of finite element family.
+# To achieve this, we add an extra column to the dataframe, which combines the space and degree of the finite element.
 
 seaborn.set(style="ticks")
 seaborn.set(font_scale=1.2)
@@ -111,4 +116,5 @@ def compile_form(space: str, degree: int, jit_options: Dict):
     g = seaborn.catplot(x="Options", y="Time", kind="bar", data=df_e, col="Element")
     g.fig.set_size_inches(16, 4)
 
-# We observe that the compile time increases when increasing the degree of the function space, and that we get most speedup by using "-O3" or "-Ofast" combined with "-march=native".
+# We observe that the compile time increases when increasing the degree of the function space,
+# and that we get most speedup by using "-O3" or "-Ofast" combined with "-march=native".