From cfab7abae259020de1bf23b457338d53cfd22cda Mon Sep 17 00:00:00 2001 From: RemDelaporteMathurin Date: Fri, 27 Feb 2026 10:08:12 -0500 Subject: [PATCH 1/9] started adding inline code refs --- book/content/applications/task01.ipynb | 21 ++++++++------------- book/content/misc/dolfinx_steady.md | 2 +- 2 files changed, 9 insertions(+), 14 deletions(-) diff --git a/book/content/applications/task01.ipynb b/book/content/applications/task01.ipynb index 67960085..cc30a7ab 100644 --- a/book/content/applications/task01.ipynb +++ b/book/content/applications/task01.ipynb @@ -45,12 +45,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Every FESTIM model is represented by a `Simulation` object. Here, we give it the name `my_model`" + "Every FESTIM model is represented by a {py:class}`HydrogenTransportProblem` object. Here, we give it the name `my_model`" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -82,7 +82,7 @@ "\n", "FESTIM simulations need a mesh. FESTIM provides support for simple 1D meshes. More complicated meshes can be imported from external software (see [](heat_transfer_sims)).\n", "\n", - "The most straightforward mesh is `MeshFromVertices`, which takes a `vertices` argument." + "The most straightforward mesh is {py:class}`Mesh1D`, which takes a `vertices` argument." ] }, { @@ -123,7 +123,7 @@ "source": [ "## 2. Materials\n", "\n", - "`Material` objects hold the materials properties like diffusivity and solubility.\n", + "{py:class}`Material` objects hold the materials properties like diffusivity and solubility.\n", "\n", "Here we only need the diffusivity defined as an Arrhenius law:\n", "\n", @@ -135,7 +135,6 @@ "\n", "```{note} Note\n", "All units in FESTIM as SI (apart for activation energies that are in eV)\n", - "To check what unit is expected by FESTIM, check the documentation. [Here](https://festim.readthedocs.io/en/latest/api/festim.materials.html#festim.materials.material.Material) is the reference for the `Material` class\n", "```" ] }, @@ -171,13 +170,9 @@ "## 3. Temperature\n", "\n", "Temperature is a very important parameter in hydrogen transport.\n", - "The value can be a simple float (like here `300`) or a `sympy` expression like `500 + 3*sympy.exp(-F.x)`.\n", + "The value can be a simple float (like here `300`) or a more complex expression.\n", "\n", - "The temperature is in K.\n", - "\n", - "```{note} Note\n", - "For heat transfer simulations, the `HeatTransferProblem` can be used instead. See [Heat transfer simulations](heat_transfer_sims)\n", - "```" + "The temperature is in K." ] }, { @@ -204,7 +199,7 @@ "\n", "- ``field`` represents the variable on which the boundary condition is imposed. Here, `0` stands for the mobile hydrogen concentration.\n", "\n", - "- ``value`` is the value of the mobile concentration. Again, it could be a function of time and space with ``1e15*F.x + F.t``\n", + "- ``value`` is the value of the mobile concentration. Again, it could be a function of time and space\n", "\n", "- ``surfaces`` is a list of surfaces ids (in 1D, `1` is left and `2` is right)\n", "\n", @@ -234,7 +229,7 @@ "source": [ "## 5. Settings\n", "\n", - "With `Settings` we set the main solver parameters.\n", + "With {py:class}`Settings` we set the main solver parameters.\n", "- `absolute_tolerance`: the absolute tolerance of the Newton solver. For concentrations in $\\mathrm{m}^{-3}$, `1e10` is usually fine.\n", "- `relative_tolerance`: the relative tolerance of the Newton solver. Values around `1e-10` are good practices.\n", "- `final_time`: since we want to solve a transient problem, we need to set the final time. Here, 100 s.\n", diff --git a/book/content/misc/dolfinx_steady.md b/book/content/misc/dolfinx_steady.md index f9ba08d6..6bc6675c 100644 --- a/book/content/misc/dolfinx_steady.md +++ b/book/content/misc/dolfinx_steady.md @@ -76,7 +76,7 @@ from dolfinx import fem import basix ``` -We then create a mesh using `create_unit_square()` +We then create a mesh using {py:func}`create_unit_square` ```{code-cell} ipython3 nx = ny = 96 From eb776060923fce30443fccb71b1ae7e29bd1e790 Mon Sep 17 00:00:00 2001 From: RemDelaporteMathurin Date: Fri, 27 Feb 2026 15:07:40 -0500 Subject: [PATCH 2/9] better title --- book/content/boundary_conditions/bc_intro.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/book/content/boundary_conditions/bc_intro.md b/book/content/boundary_conditions/bc_intro.md index b21ac271..84af116d 100644 --- a/book/content/boundary_conditions/bc_intro.md +++ b/book/content/boundary_conditions/bc_intro.md @@ -8,7 +8,7 @@ jupytext: jupytext_version: 1.19.1 --- -# Fixed value and flux boundary condition mathematics +# Backgrounc This section discusses the math behind fixed temperature/concentration and flux boundary conditions (BCs). From 8fc4fb889c1ef89ed174a40f941731f4a35a4372 Mon Sep 17 00:00:00 2001 From: RemDelaporteMathurin Date: Fri, 27 Feb 2026 15:09:35 -0500 Subject: [PATCH 3/9] correct title --- book/content/species_reactions/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/book/content/species_reactions/index.md b/book/content/species_reactions/index.md index 0d1551fa..5c84932b 100644 --- a/book/content/species_reactions/index.md +++ b/book/content/species_reactions/index.md @@ -12,4 +12,4 @@ kernelspec: name: python3 --- -# Meshes \ No newline at end of file +# Species and reactions \ No newline at end of file From 76c966e42accf61aa9a22bc4fba4f7e1ac5a78a8 Mon Sep 17 00:00:00 2001 From: RemDelaporteMathurin Date: Fri, 27 Feb 2026 15:51:01 -0500 Subject: [PATCH 4/9] fixed getting started + modified intro --- book/_toc.yml | 3 +- book/content/applications/ml.md | 17 ++ book/content/applications/task01.ipynb | 228 +++++-------------------- book/intro.md | 28 ++- 4 files changed, 92 insertions(+), 184 deletions(-) create mode 100644 book/content/applications/ml.md diff --git a/book/_toc.yml b/book/_toc.yml index 0105206e..94be3bb2 100644 --- a/book/_toc.yml +++ b/book/_toc.yml @@ -77,4 +77,5 @@ parts: - file: content/applications/task08 - file: content/applications/task06 - file: content/applications/task10 - - file: content/applications/microstructure \ No newline at end of file + - file: content/applications/microstructure + - file: content/applications/ml \ No newline at end of file diff --git a/book/content/applications/ml.md b/book/content/applications/ml.md new file mode 100644 index 00000000..0fdea651 --- /dev/null +++ b/book/content/applications/ml.md @@ -0,0 +1,17 @@ +--- +jupytext: + formats: ipynb,md:myst + text_representation: + extension: .md + format_name: myst + format_version: 0.13 + jupytext_version: 1.18.1 +kernelspec: + display_name: festim-workshop + language: python + name: python3 +--- + +# Training a FESTIM surrogate model + +Coming soon! \ No newline at end of file diff --git a/book/content/applications/task01.ipynb b/book/content/applications/task01.ipynb index cc30a7ab..e235550f 100644 --- a/book/content/applications/task01.ipynb +++ b/book/content/applications/task01.ipynb @@ -10,7 +10,7 @@ "\n", "In this task, we'll go through the basics of FESTIM and run a simple simulation on a 1D domain.\n", "\n", - "The very first step is to import the `festim` package:" + "The very first step is to import the {py:mod}`festim` package:" ] }, { @@ -45,12 +45,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Every FESTIM model is represented by a {py:class}`HydrogenTransportProblem` object. Here, we give it the name `my_model`" + "We then create a {py:class}`HydrogenTransportProblem` object." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -62,37 +62,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Several \"ingredients\" are now required to run a FESTIM simulation:\n", - "- a mesh\n", - "- a temperature\n", - "- a set of materials\n", - "- optionally: trapping properties\n", - "- boundary conditions\n", - "- optionally: sources of H\n", - "- simulation settings\n", - "- a stepsize for transient problems" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Mesh\n", - "\n", - "FESTIM simulations need a mesh. FESTIM provides support for simple 1D meshes. More complicated meshes can be imported from external software (see [](heat_transfer_sims)).\n", + "## Mesh\n", "\n", - "The most straightforward mesh is {py:class}`Mesh1D`, which takes a `vertices` argument." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Numpy can be used to generate heavier meshes. Here we create a mesh containing 1000 cells over a [0, 7e-6] domain (7 microns).\n", - "\n", - "This mesh is assigned to the simulation by setting the `.mesh` attribute of `my_model`." + "FESTIM simulations need a mesh, here we use {py:class}`Mesh1D`." ] }, { @@ -103,16 +75,15 @@ "source": [ "import numpy as np\n", "\n", - "my_model.mesh = F.Mesh1D(vertices=np.linspace(0, 7e-6, num=1001))" + "my_model.mesh = F.Mesh1D(vertices=np.linspace(0, 1, num=1001))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "```{admonition} Tip\n", - ":class: tip\n", - "For more information on meshes in FESTIM. See the Meshing section of the tutorials.\n", + "```{seealso}\n", + "For more information on meshes in FESTIM, see [](meshes).\n", "```" ] }, @@ -121,21 +92,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 2. Materials\n", - "\n", - "{py:class}`Material` objects hold the materials properties like diffusivity and solubility.\n", - "\n", - "Here we only need the diffusivity defined as an Arrhenius law:\n", + "## Materials\n", "\n", - "$$\n", - " D = D_0 \\exp{(-E_D/k_B T)}\n", - "$$\n", - "\n", - "where $k_B$ is the Boltzmann constant in eV/K and $T$ is the temperature in K. From this, the pre-exponential coefficient, $D_0$ in m2/s, and the diffusion actiavtion energy, $E_D$ in eV are needed.\n", - "\n", - "```{note} Note\n", - "All units in FESTIM as SI (apart for activation energies that are in eV)\n", - "```" + "{py:class}`Material` objects hold the materials properties like diffusivity.\n" ] }, { @@ -144,11 +103,11 @@ "metadata": {}, "outputs": [], "source": [ - "mat = F.Material(D_0=1e-7, E_D=0.2)\n", + "mat = F.Material(D_0=1, E_D=0.0)\n", "\n", - "volume_subdomain = F.VolumeSubdomain1D(id=1, borders=[0, 7e-6], material=mat)\n", + "volume_subdomain = F.VolumeSubdomain1D(id=1, borders=[0, 1], material=mat)\n", "boundary_left = F.SurfaceSubdomain1D(id=1, x=0)\n", - "boundary_right = F.SurfaceSubdomain1D(id=2, x=7e-6)\n", + "boundary_right = F.SurfaceSubdomain1D(id=2, x=1)\n", "my_model.subdomains = [volume_subdomain, boundary_left, boundary_right]" ] }, @@ -167,12 +126,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 3. Temperature\n", - "\n", - "Temperature is a very important parameter in hydrogen transport.\n", - "The value can be a simple float (like here `300`) or a more complex expression.\n", - "\n", - "The temperature is in K." + "## Temperature" ] }, { @@ -189,22 +143,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 4. Boundary conditions & source\n", - "\n", - "Our hydrogen transport problem now needs boundary conditions and a volumetric source term.\n", + "## Boundary conditions\n", "\n", - "FESTIM provides plenty of boundary conditions (see [Dirichlet BCs](https://festim.readthedocs.io/en/latest/api/festim.boundary_conditions.dirichlets.html#festim-boundary-conditions-dirichlets-package) and [Fluxes](https://festim.readthedocs.io/en/latest/api/festim.boundary_conditions.fluxes.html)).\n", - "\n", - "Here we'll simply set the mobile concentration at ``1e15`` on the left and right boundaries (resp. `1` and `2`).\n", - "\n", - "- ``field`` represents the variable on which the boundary condition is imposed. Here, `0` stands for the mobile hydrogen concentration.\n", - "\n", - "- ``value`` is the value of the mobile concentration. Again, it could be a function of time and space\n", - "\n", - "- ``surfaces`` is a list of surfaces ids (in 1D, `1` is left and `2` is right)\n", - "\n", - "A volumetric source of mobile H (`field=0`) is set in the whole volume (`volume=1`) and its value is `1e20` H/m3/s.\n", - "Additional sources can be applied." + "Our hydrogen transport problem now needs boundary conditions." ] }, { @@ -214,12 +155,9 @@ "outputs": [], "source": [ "my_model.boundary_conditions = [\n", - " F.FixedConcentrationBC(subdomain=boundary_left, value=1e15, species=H),\n", - " F.FixedConcentrationBC(subdomain=boundary_right, value=1e15, species=H),\n", - "]\n", - "\n", - "\n", - "my_model.sources = [F.ParticleSource(value=1e20, volume=volume_subdomain, species=H)]" + " F.FixedConcentrationBC(subdomain=boundary_left, value=1, species=H),\n", + " F.FixedConcentrationBC(subdomain=boundary_right, value=0, species=H),\n", + "]" ] }, { @@ -227,20 +165,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 5. Settings\n", - "\n", - "With {py:class}`Settings` we set the main solver parameters.\n", - "- `absolute_tolerance`: the absolute tolerance of the Newton solver. For concentrations in $\\mathrm{m}^{-3}$, `1e10` is usually fine.\n", - "- `relative_tolerance`: the relative tolerance of the Newton solver. Values around `1e-10` are good practices.\n", - "- `final_time`: since we want to solve a transient problem, we need to set the final time. Here, 100 s.\n", + "## Settings\n", "\n", - "\n", - "```{admonition} Tip\n", - ":class: tip\n", - "Tuning absolute and relative tolerances can be a fine art. If tolerances the solver may not converge.\n", - "If they are too high, the solver may converge to quickly (in zero iterations), resulting in no evolution of the concentration fields.\n", - "To have more information on the solving steps, set the log level of the solver to 20 with ``my_model.log_level = 20`` (default is 40)\n", - "```" + "With {py:class}`Settings` we set the main solver parameters." ] }, { @@ -249,7 +176,7 @@ "metadata": {}, "outputs": [], "source": [ - "my_model.settings = F.Settings(atol=1e10, rtol=1e-10, final_time=2) # s" + "my_model.settings = F.Settings(atol=1e-10, rtol=1e-10, final_time=2)" ] }, { @@ -257,18 +184,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 7. Stepsize\n", - "\n", - "Since we are solving a transient problem, we need to set a ``Stepsize``.\n", - "Here, the value of the stepsize is fixed at 0.05.\n", + "## Stepsize\n", "\n", - "We also add ``milestones`` to ensure the simulation passes by specific times.\n", - "\n", - "\n", - "```{admonition} Note\n", - ":class: tip\n", - "Transient simulations can be accelerated with adaptive stepsize. See [Task 2](task02.ipynb)\n", - "```" + "Since we are solving a transient problem, we need to set a {py:class}``Stepsize``.\n", + "Here, the value of the stepsize is fixed at 0.05." ] }, { @@ -277,7 +196,7 @@ "metadata": {}, "outputs": [], "source": [ - "my_model.settings.stepsize = F.Stepsize(0.05, milestones=[0.1, 0.2, 0.5, 1]) # s" + "my_model.settings.stepsize = F.Stepsize(0.05, milestones=[0.05, 0.1, 0.2, 0.5, 1]) # s" ] }, { @@ -285,15 +204,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 6. Exports\n", + "## Exports\n", "\n", - "Finally, we want to be able to visualise the concentration field.\n", - "To do so, we add an `XDMFExport` object which will export the concentration field at each timestep to an XDMF file.\n", - "This XDMF file can then be read in [Paraview](https://www.paraview.org/).\n", - "\n", - "- `field`: the field we want to export. Here, `\"solute\"` stands for the mobile concentration of hydrogen. It could be ``\"retention\"``, ``\"1\"`` (trap 1), ``\"T\"`` (temperature)\n", - "\n", - "- `filename`: the path to the exported file\n" + "Finally, we want to be able to visualise the concentration field.\n" ] }, { @@ -305,9 +218,9 @@ "profile = F.Profile1DExport(field=H, subdomain=volume_subdomain, times=my_model.settings.stepsize.milestones)\n", "\n", "my_model.exports = [\n", - " F.XDMFExport(\n", + " F.VTXSpeciesExport(\n", " field=H,\n", - " filename=\"task01/hydrogen_concentration.xdmf\",\n", + " filename=\"hydrogen_concentration.bp\",\n", " ),\n", " profile,\n", "]" @@ -318,7 +231,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 8. Run\n", + "## Run\n", "\n", "Finally, we initialise the model and run it!" ] @@ -331,7 +244,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "dd68a8650d154deb9b60ecf79a6f743c", + "model_id": "84888cfa4ac140289105a7ce2f6834bc", "version_major": 2, "version_minor": 0 }, @@ -354,21 +267,28 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Three files should have been created: hydrogen_concentration.xdmf, hydrogen_concentration.h5, and mobile_concentration.txt\n", - "\n", - "The .xdmf file is the one that can be opened in Paraview, and it points to the .h5 file.\n", + "You should now see the file `hydrogen_concentration.bp`.\n", "\n", - "The profile exported as a text file can now be plotted with matplotlib:" + "```{seealso}\n", + "Check out the [Paraview](paraview) section for visualisation!\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualise" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -379,7 +299,6 @@ ], "source": [ "import matplotlib.pyplot as plt\n", - "import numpy as np\n", "\n", "x = my_model.mesh.mesh.geometry.x[:, 0]\n", "for time, data in zip(profile.times, profile.data):\n", @@ -390,61 +309,6 @@ "plt.legend()\n", "plt.show()" ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To solve the steady-state problem, simply set:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "my_model.settings.transient = False\n", - "my_model.settings.stepsize = None\n", - "\n", - "my_model.exports = [profile]" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "my_model.initialise()\n", - "\n", - "my_model.run()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "data = profile.data[0]\n", - "plt.plot(x, data)\n", - "plt.xlabel(\"x (m)\")\n", - "plt.ylabel(\"Mobile concentration (H/m3)\")\n", - "plt.show()" - ] } ], "metadata": { @@ -463,7 +327,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.5" + "version": "3.13.12" }, "orig_nbformat": 4 }, diff --git a/book/intro.md b/book/intro.md index 119f5181..8810600d 100644 --- a/book/intro.md +++ b/book/intro.md @@ -1,3 +1,29 @@ +--- +jupytext: + formats: ipynb,md:myst + text_representation: + extension: .md + format_name: myst + format_version: 0.13 + jupytext_version: 1.18.1 +kernelspec: + display_name: festim-workshop + language: python + name: python3 +--- + + # The FESTIM tutorial -Welcome to the FESTIM tutorial! \ No newline at end of file +Welcome to the FESTIM tutorial! + + +## Interactive tutorials + +```{code-cell} ipython3 +import festim as F + +print(F.__version__) +``` + +## Clickable API links From 7d6133d02b346097196b4e67e444b612d49d85f8 Mon Sep 17 00:00:00 2001 From: RemDelaporteMathurin Date: Fri, 27 Feb 2026 15:51:09 -0500 Subject: [PATCH 5/9] link to meshes --- book/content/meshes/index.md | 1 + 1 file changed, 1 insertion(+) diff --git a/book/content/meshes/index.md b/book/content/meshes/index.md index 0d1551fa..58f315dc 100644 --- a/book/content/meshes/index.md +++ b/book/content/meshes/index.md @@ -12,4 +12,5 @@ kernelspec: name: python3 --- +(meshes)= # Meshes \ No newline at end of file From 3b9d93e965d95042a8c591854099acd074a71169 Mon Sep 17 00:00:00 2001 From: RemDelaporteMathurin Date: Fri, 27 Feb 2026 16:26:48 -0500 Subject: [PATCH 6/9] more context to intro --- book/_config.yml | 1 + book/intro.md | 17 +++++++++++++++++ 2 files changed, 18 insertions(+) diff --git a/book/_config.yml b/book/_config.yml index 80567951..ca70bd62 100644 --- a/book/_config.yml +++ b/book/_config.yml @@ -68,6 +68,7 @@ sphinx: - "sphinx.ext.autodoc" - "sphinx.ext.intersphinx" - "sphinx_codeautolink" + # - "sphinx_design" parse: myst_enable_extensions: diff --git a/book/intro.md b/book/intro.md index 8810600d..518687e7 100644 --- a/book/intro.md +++ b/book/intro.md @@ -17,9 +17,18 @@ kernelspec: Welcome to the FESTIM tutorial! +Comments and corrections to this webpage should be submitted to the issue tracker by going to the relevant page in the tutorial, then click the {fab}`github` repository symbol in the top right corner and either {fas}`lightbulb` “open issue” or {fas}`pencil` "suggest edit". ## Interactive tutorials +You don't have to install FESTIM locally to be able to run these examples yourself. + +Press the {fas}`rocket` button on the toolbar, then the {fas}`play` button to edit and run the code. + +```{note} +This might take a while to load after new releases of the book. +``` + ```{code-cell} ipython3 import festim as F @@ -27,3 +36,11 @@ print(F.__version__) ``` ## Clickable API links + +You can directly click modules, functions, and classes to have access to their API documentation. + +```{code-cell} ipython3 +from festim import Mesh1D # click Mesh1D +import matplotlib # click matplotlib +from dolfinx import fem # click fem +``` \ No newline at end of file From 5f746528d2571586d393c42d7831e47d2c4e58bb Mon Sep 17 00:00:00 2001 From: RemDelaporteMathurin Date: Fri, 27 Feb 2026 21:15:15 -0500 Subject: [PATCH 7/9] more intro --- book/intro.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/book/intro.md b/book/intro.md index 518687e7..5641e045 100644 --- a/book/intro.md +++ b/book/intro.md @@ -15,7 +15,9 @@ kernelspec: # The FESTIM tutorial -Welcome to the FESTIM tutorial! +Welcome to the FESTIM tutorial! 🎉 + +Here you can learn to run FESTIM simulations from complete application cases and from the fundamental building blocks of the code! Comments and corrections to this webpage should be submitted to the issue tracker by going to the relevant page in the tutorial, then click the {fab}`github` repository symbol in the top right corner and either {fas}`lightbulb` “open issue” or {fas}`pencil` "suggest edit". From fd133cd7e0f53dbbe56ee07f51ffed4550fb5577 Mon Sep 17 00:00:00 2001 From: RemDelaporteMathurin Date: Fri, 27 Feb 2026 21:28:59 -0500 Subject: [PATCH 8/9] autolinks --- book/content/applications/task02.ipynb | 10 +++++----- book/content/applications/task03.ipynb | 2 +- book/content/applications/task04.ipynb | 8 ++++---- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/book/content/applications/task02.ipynb b/book/content/applications/task02.ipynb index 097ce07e..6d847640 100644 --- a/book/content/applications/task02.ipynb +++ b/book/content/applications/task02.ipynb @@ -142,7 +142,7 @@ "\n", "where $\\varphi =2.5 \\times 10^{19} \\text{m}^{-2}\\text{s}^{-1}$ and $f(x)$ is a Gaussian spatial distribution with a mean value of $4.5 \\: \\text{nm}$ and a width of $2.5 \\: \\text{nm}$.\n", "\n", - "FESTIM has a special class for this case: `ImplantationFlux`.\n", + "FESTIM has a special class for this case: {py:class}`ParticleSource`.\n", "\n", "The ion flux is temporally defined using a Sympy Piecewise expression, to be active for the `implantation_time`.\n", "\n", @@ -186,7 +186,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Boundary conditions (BCs) can be of several types in FESTIM, the most simple of them being the `FixedConcentrationBC` where an analytical expression is given in the argument: `value`. The argument `subdomain` is the subdomain on which the BC is applied. If no BC is applied on a surface, it will be considered as a non flux surface (ie $\\frac{\\partial c}{\\partial\\textbf{n}} = 0$).\n", + "Boundary conditions (BCs) can be of several types in FESTIM, the most simple of them being the {py:class}`FixedConcentrationBC` where an analytical expression is given in the argument: `value`. The argument `subdomain` is the subdomain on which the BC is applied. If no BC is applied on a surface, it will be considered as a non flux surface (ie $\\frac{\\partial c}{\\partial\\textbf{n}} = 0$).\n", "\n", "In this case, the solute concentration is set to zero on the left and right surface." ] @@ -273,7 +273,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The `Stepsize` object defines the simulation stepsize.\n", + "The {py:class}`Stepsize` object defines the simulation stepsize.\n", "\n", "The argument `initial_value` is the initial stepsize is expressed in $\\text{s}$.\n", "\n", @@ -294,7 +294,7 @@ "To do so, we'll use 'derived quantities' objects.\n", "There is a wide range of derived quantities available in FESTIM.\n", "\n", - "Here, we'll use `TotalVolume` (volume integration) and `HydrogenFlux`." + "Here, we'll use {py:class}`TotalVolume` (volume integration) and {py:class}`SurfaceFlux`." ] }, { @@ -556,7 +556,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.5" + "version": "3.13.12" }, "orig_nbformat": 4 }, diff --git a/book/content/applications/task03.ipynb b/book/content/applications/task03.ipynb index 41242b17..0a8d5a77 100644 --- a/book/content/applications/task03.ipynb +++ b/book/content/applications/task03.ipynb @@ -24,7 +24,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The first step is to create a model using a `Simulation` object." + "The first step is to create a model using a {py:class}`HydrogenTransportProblem` object." ] }, { diff --git a/book/content/applications/task04.ipynb b/book/content/applications/task04.ipynb index 5ad477ab..49885a9e 100644 --- a/book/content/applications/task04.ipynb +++ b/book/content/applications/task04.ipynb @@ -17,7 +17,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 1) Model with barrier\n", + "## Model with barrier\n", "\n", "Let's first create a model where tungsten is coated with 1 micron of barrier material on both sides." ] @@ -328,7 +328,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 2) Model without barrier\n", + "## Model without barrier\n", "\n", "We can also run the equivalent model without permeation barriers with bare tungsten.\n", "Let's make a few modifications:" @@ -387,7 +387,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 3) Calculate the PRF" + "## Calculate the PRF" ] }, { @@ -516,7 +516,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.5" + "version": "3.13.12" }, "orig_nbformat": 4 }, From 00d34c8195ccbf4a5300ef631280e9505eedf32e Mon Sep 17 00:00:00 2001 From: RemDelaporteMathurin Date: Sat, 28 Feb 2026 13:57:03 -0500 Subject: [PATCH 9/9] code autolink --- book/content/meshes/mesh_festim.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/book/content/meshes/mesh_festim.ipynb b/book/content/meshes/mesh_festim.ipynb index 56949d4d..7e63c417 100644 --- a/book/content/meshes/mesh_festim.ipynb +++ b/book/content/meshes/mesh_festim.ipynb @@ -20,7 +20,7 @@ "\n", "## Uniform 1D meshes\n", "\n", - "The `Mesh1D` class in FESTIM allows you to define 1D meshes by simply specifying the coordinates of the mesh vertices. This makes it easy to construct uniform or structured meshes over a given interval.\n", + "The {py:class}`Mesh1D` class in FESTIM allows you to define 1D meshes by simply specifying the coordinates of the mesh vertices. This makes it easy to construct uniform or structured meshes over a given interval.\n", "\n", "A **uniform mesh** is one where the spacing between points is constant. This type of mesh is ideal for problems where the physical properties or expected solution gradients are evenly distributed across the domain.\n", "\n",