diff --git a/book/_toc.yml b/book/_toc.yml
index 0ae07d86..fe7dc6fe 100644
--- a/book/_toc.yml
+++ b/book/_toc.yml
@@ -1,12 +1,10 @@
-# Table of contents
-# Learn more at https://jupyterbook.org/customize/toc.html
-
format: jb-book
root: intro
+
parts:
- caption: Getting started
chapters:
- - file: content/applications/task01
+ - file: content/applications/general/simple
- caption: Meshing
chapters:
@@ -16,7 +14,7 @@ parts:
- file: content/meshes/mesh_salome
- caption: Materials
- chapters:
+ chapters:
- file: content/material/material_basics
- file: content/material/material_htm
- file: content/material/material_advanced
@@ -31,14 +29,24 @@ parts:
chapters:
- file: content/temperatures/temperatures_basic
- file: content/temperatures/temperatures_advanced
-
+
- caption: Applications
chapters:
- - file: content/applications/task02
- - file: content/applications/task03
- - file: content/applications/task04
- - file: content/applications/task07
- - 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/general/index
+ # General group
+ sections:
+ - file: content/applications/general/simple_permeation
+ - file: content/applications/general/permeation_barrier
+ - file: content/applications/general/heat_transfer
+ - file: content/applications/general/advection
+ - file: content/applications/general/monoblock
+ - file: content/applications/material_science/index
+ sections:
+ - file: content/applications/material_science/fittings_tds
+ - file: content/applications/material_science/microstructure
+ - file: content/applications/fusion/index
+ sections:
+ - file: content/applications/fusion/pfc
+ - file: content/applications/fusion/fuel_cycle/fuel_cycle_map
+ - file: content/applications/fusion/fuel_cycle/pav
+ - file: content/applications/fusion/fuel_cycle/heat_exchanger
diff --git a/book/content/applications/fission/index.md b/book/content/applications/fission/index.md
new file mode 100644
index 00000000..bd25c8b5
--- /dev/null
+++ b/book/content/applications/fission/index.md
@@ -0,0 +1,15 @@
+---
+jupytext:
+ formats: ipynb,md:myst
+ text_representation:
+ extension: .md
+ format_name: myst
+ format_version: 0.13
+ jupytext_version: 1.18.1
+---
+
+# Fission #
+
+Modeling fission components with FESTIM
+
++++
diff --git a/book/content/applications/fusion/fuel_cycle/fuel_cycle_map.md b/book/content/applications/fusion/fuel_cycle/fuel_cycle_map.md
new file mode 100644
index 00000000..78bbd84a
--- /dev/null
+++ b/book/content/applications/fusion/fuel_cycle/fuel_cycle_map.md
@@ -0,0 +1,31 @@
+---
+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
+---
+
+# Fusion fuel cycle modeling #
+
+FESTIM can be used to model fusion fuel cycle components.
+
+* Fuel cycle components
+* System level modeling?
+
+```{code-cell} ipython3
+:tags: [hide-input]
+
+from IPython.display import HTML
+
+with open("test.svg") as f:
+ svg = f.read()
+
+HTML(svg)
+```
diff --git a/book/content/applications/fusion/fuel_cycle/test.svg b/book/content/applications/fusion/fuel_cycle/test.svg
new file mode 100644
index 00000000..44f32952
--- /dev/null
+++ b/book/content/applications/fusion/fuel_cycle/test.svg
@@ -0,0 +1,84 @@
+
+
\ No newline at end of file
diff --git a/book/content/applications/fusion/index.md b/book/content/applications/fusion/index.md
new file mode 100644
index 00000000..5efbf5a4
--- /dev/null
+++ b/book/content/applications/fusion/index.md
@@ -0,0 +1,15 @@
+---
+jupytext:
+ formats: ipynb,md:myst
+ text_representation:
+ extension: .md
+ format_name: myst
+ format_version: 0.13
+ jupytext_version: 1.18.1
+---
+
+# Fusion #
+
+Modeling fusion components with FESTIM
+
++++
diff --git a/book/content/applications/general/advection.md b/book/content/applications/general/advection.md
new file mode 100644
index 00000000..0c49fa9e
--- /dev/null
+++ b/book/content/applications/general/advection.md
@@ -0,0 +1,228 @@
+---
+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
+---
+
+# Advection-diffusion problem
+
+In this task, we'll simulate advection-diffusion in a fluid domain.
+
+Natively, advection is not taken into account in FESTIM. The idea is therefore to modify the governing equations by adding an advection term.
+
+```{code-cell} ipython3
+import festim as F
+
+my_model = F.HydrogenTransportProblem()
+
+H = F.Species("H")
+my_model.species = [H]
+```
+
+Create a mesh with FEniCS:
+
+```{code-cell} ipython3
+from dolfinx.mesh import create_unit_square
+from mpi4py import MPI
+
+# creating a mesh with FEniCS
+nx = ny = 20
+mesh_fenics = create_unit_square(MPI.COMM_WORLD, nx, ny)
+```
+
+```{code-cell} ipython3
+:tags: [hide-cell]
+
+import pyvista
+
+pyvista.start_xvfb()
+pyvista.set_jupyter_backend('html')
+```
+
+```{code-cell} ipython3
+from dolfinx import plot
+
+pyvista.start_xvfb()
+
+tdim = mesh_fenics.topology.dim
+
+mesh_fenics.topology.create_connectivity(tdim, tdim)
+topology, cell_types, geometry = plot.vtk_mesh(mesh_fenics, tdim)
+grid = pyvista.UnstructuredGrid(topology, cell_types, geometry)
+
+plotter = pyvista.Plotter()
+plotter.add_mesh(grid, show_edges=True)
+plotter.view_xy()
+if not pyvista.OFF_SCREEN:
+ plotter.show()
+else:
+ figure = plotter.screenshot("mesh.png")
+```
+
+The mesh can now be passed to a `festim.Mesh` instance.
+
+```{code-cell} ipython3
+my_model.mesh = F.Mesh(mesh_fenics)
+```
+
+We create subdomains for volumes and boundaries
+
+```{code-cell} ipython3
+import numpy as np
+import dolfinx
+
+topbot_boundary = F.SurfaceSubdomain(id=1, locator=lambda x: np.logical_or(np.isclose(x[1], 0.0), np.isclose(x[1], 1.0)))
+left_boundary = F.SurfaceSubdomain(id=2, locator=lambda x: np.isclose(x[0], 0.0))
+right_boundary = F.SurfaceSubdomain(id=3, locator=lambda x: np.isclose(x[0], 1.0))
+volume_subdomain = F.VolumeSubdomain(id=1, material=F.Material(D_0=1, E_D=0))
+
+my_model.subdomains = [
+ topbot_boundary,
+ left_boundary,
+ volume_subdomain,
+]
+```
+
+Let's add the rest of the parameters.
+For this case, the concentration will be set to 1 on the left surface and to zero on the top and bottom surfaces.
+
+```{code-cell} ipython3
+my_model.temperature = 500
+
+my_model.boundary_conditions = [
+ F.FixedConcentrationBC(species=H, subdomain=topbot_boundary, value=0),
+ F.FixedConcentrationBC(species=H, subdomain=left_boundary, value=1),
+]
+
+my_model.settings = F.Settings(atol=1e-10, rtol=1e-10, transient=False)
+```
+
+We can now run the pure diffusion simulation and visualise the hydrogen concentration field.
+
+```{code-cell} ipython3
+my_model.initialise()
+my_model.run()
+```
+
+```{code-cell} ipython3
+hydrogen_concentration = H.solution
+
+topology, cell_types, geometry = plot.vtk_mesh(hydrogen_concentration.function_space)
+u_grid = pyvista.UnstructuredGrid(topology, cell_types, geometry)
+u_grid.point_data["c"] = hydrogen_concentration.x.array.real
+u_grid.set_active_scalars("c")
+u_plotter = pyvista.Plotter()
+u_plotter.add_mesh(u_grid, show_edges=True)
+u_plotter.view_xy()
+
+if not pyvista.OFF_SCREEN:
+ u_plotter.show()
+else:
+ figure = u_plotter.screenshot("concentration_diff_only.png")
+```
+
+## Adding advection
+
+Let's now add an advection term. To do so, we first need to create a velocity field.
+For simplicity sake, we will create an arbitrary field `velocity`.
+
+>
+> Note: this velocity field can be obtained from solving the Navier-Stokes equations with FEniCS or with another code (OpenFOAM).
+>
+
+```{code-cell} ipython3
+from basix.ufl import element
+
+el = element("Lagrange", mesh_fenics.topology.cell_name(), 2, shape=(mesh_fenics.geometry.dim, ))
+
+
+V = dolfinx.fem.functionspace(my_model.mesh.mesh, el)
+
+velocity = dolfinx.fem.Function(V)
+
+velocity.interpolate(lambda x: (-100*x[1]*(x[1]-1), np.full_like(x[0], 0.0)))
+```
+
+Here's what `velocity` looks like:
+
+```{code-cell} ipython3
+topology, cell_types, geometry = plot.vtk_mesh(V)
+values = np.zeros((geometry.shape[0], 3), dtype=np.float64)
+values[:, :len(velocity)] = velocity.x.array.real.reshape((geometry.shape[0], len(velocity)))
+
+# Create a point cloud of glyphs
+function_grid = pyvista.UnstructuredGrid(topology, cell_types, geometry)
+function_grid["v"] = values
+glyphs = function_grid.glyph(orient="v", factor=0.005)
+
+# Create a pyvista-grid for the mesh
+mesh_fenics.topology.create_connectivity(mesh_fenics.topology.dim, mesh_fenics.topology.dim)
+grid = pyvista.UnstructuredGrid(*plot.vtk_mesh(mesh_fenics, mesh_fenics.topology.dim))
+
+# Create plotter
+plotter = pyvista.Plotter()
+plotter.add_mesh(grid, style="wireframe", color="k")
+plotter.add_mesh(glyphs)
+plotter.view_xy()
+if not pyvista.OFF_SCREEN:
+ plotter.show()
+else:
+ fig_as_array = plotter.screenshot("glyphs.png")
+```
+
+Now that we created a FEniCS function representing the velocity, let's add an advection term to the governing equation.
+
+The governing equation for steady state advection-diffusion is:
+
+$$\nabla \cdot (D \nabla c) - v \cdot \nabla c = 0$$
+
+where $D$ is the diffusion coefficient, $c$ is the hydrogen concentration and $v$ is the velocity.
+
+```{code-cell} ipython3
+advection_term = F.AdvectionTerm(
+ velocity=velocity,
+ subdomain=volume_subdomain,
+ species=H,
+)
+
+my_model.advection_terms = [advection_term]
+```
+
+```{code-cell} ipython3
+my_model.initialise()
+my_model.run()
+```
+
+Now that the governing equation has been modified, let's run the simulation again and check the new concentration field.
+
+```{code-cell} ipython3
+hydrogen_concentration = H.solution
+
+topology, cell_types, geometry = plot.vtk_mesh(hydrogen_concentration.function_space)
+u_grid = pyvista.UnstructuredGrid(topology, cell_types, geometry)
+u_grid.point_data["c"] = hydrogen_concentration.x.array.real
+u_grid.set_active_scalars("c")
+u_plotter = pyvista.Plotter()
+u_plotter.add_mesh(u_grid, show_edges=False)
+u_plotter.add_mesh(glyphs, color="black", opacity=0.2)
+u_plotter.view_xy()
+
+if not pyvista.OFF_SCREEN:
+ u_plotter.show()
+else:
+ figure = u_plotter.screenshot("concentration_with_adv.png")
+```
+
+The concentration field is greatly affected as particles are now pushed towards the right hand side of the domain.
+
+# Task:
+
+Vary the velocity field to investigate its influence on the mobile concentration
diff --git a/book/content/applications/general/heat_transfer.md b/book/content/applications/general/heat_transfer.md
new file mode 100644
index 00000000..ba6b0dcb
--- /dev/null
+++ b/book/content/applications/general/heat_transfer.md
@@ -0,0 +1,157 @@
+---
+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
+---
+
+(heat_transfer_sims)=
+# Heat transfer simulations
+
+In this task, we'll learn how to run a heat transfer simulation and couple it to H transport.
+
+The governing equation for transient heat transfer is:
+
+$$\rho \ C_p \frac{\partial T}{\partial t} = \nabla \cdot (\lambda \ \nabla T) + \dot{Q} $$
+
+where $\rho$ is the density in kg/m3, $C_p$ is the heat capacity in J/kg/K, $\lambda$ is the thermal conductivity in W/m/K, and $\dot{Q}$ is the volumetric heat source in W/m3.
+
+In steady state, this becomes:
+
+$$\nabla \cdot (\lambda \ \nabla T) + \dot{Q} = 0$$
+
++++
+
+To use the temperature from a Heat Transfer simulation instead of a prescribed temperature, we are using the `festim.HeatTransferProblem` class.
+
++++
+
+Since we want to run a heat transfer simulation, the thermal conductivity $\lambda$ in W/m/K has to be specified in the material.
+It is possible to set a temperature-dependent thermal conductivity by creating a function and passing it to the `thermal_conductivity` argument.
+
+Here, $\lambda = 3 + 0.1\ T$
+
+```{code-cell} ipython3
+import festim as F
+
+my_model = F.HeatTransferProblem()
+
+
+def thermal_cond_function(T):
+ return 3 + 0.1 * T
+
+
+mat = F.Material(D_0=4.1e-7, E_D=0.39, thermal_conductivity=thermal_cond_function)
+```
+
+We create a simple mesh with FEniCS and create subdomains (surfaces and volume).
+
+```{code-cell} ipython3
+import dolfinx
+from mpi4py import MPI
+import numpy as np
+
+# creating a mesh with FEniCS
+nx = ny = 20
+mesh_fenics = dolfinx.mesh.create_unit_square(MPI.COMM_WORLD, nx, ny)
+
+# creating mesh with festim
+my_model.mesh = F.Mesh(mesh=mesh_fenics)
+
+volume_subdomain = F.VolumeSubdomain(id=1, material=mat)
+
+
+top_bot = F.SurfaceSubdomain(id=2, locator=lambda x: np.logical_or(np.isclose(x[1], 0.0), np.isclose(x[1], 1.0)))
+left = F.SurfaceSubdomain(id=3, locator=lambda x: np.isclose(x[0], 0.0))
+right = F.SurfaceSubdomain(id=4, locator=lambda x: np.isclose(x[0], 1.0))
+
+my_model.subdomains = [volume_subdomain, top_bot, left, right]
+```
+
+For the heat source and boundary conditions, we'll use spatially dependent values.
+
+```{code-cell} ipython3
+my_model.sources = [
+ F.HeatSource(value=lambda x: 1 + 0.1 * x[0], volume=volume_subdomain)
+]
+
+import ufl
+
+fixed_temperature_left = F.FixedTemperatureBC(
+ subdomain=left, value=lambda x: 350 + 20 * ufl.cos(x[0]) * ufl.sin(x[1])
+)
+
+def h_coeff(x):
+ return 100 * x[0]
+
+def T_ext(x):
+ return 300 + 3 * x[1]
+
+convective_heat_transfer = F.HeatFluxBC(
+ subdomain=top_bot, value=lambda x, T: h_coeff(x) * (T_ext(x) - T)
+)
+
+heat_flux = F.HeatFluxBC(
+ subdomain=right, value=lambda x: 10 + 3 * ufl.cos(x[0]) + ufl.sin(x[1])
+)
+
+
+my_model.boundary_conditions = [
+ fixed_temperature_left,
+ convective_heat_transfer,
+ heat_flux,
+]
+```
+
+Final settings, and we run the simulation:
+
+```{code-cell} ipython3
+my_model.settings = F.Settings(
+ transient=False,
+ atol=1e-09,
+ rtol=1e-09,
+)
+
+my_model.initialise()
+my_model.run()
+```
+
+```{code-cell} ipython3
+:tags: [hide-cell]
+
+import pyvista
+
+pyvista.start_xvfb()
+pyvista.set_jupyter_backend("html")
+```
+
+```{code-cell} ipython3
+from dolfinx import plot
+
+T = my_model.u
+
+topology, cell_types, geometry = plot.vtk_mesh(T.function_space)
+u_grid = pyvista.UnstructuredGrid(topology, cell_types, geometry)
+u_grid.point_data["T"] = T.x.array.real
+u_grid.set_active_scalars("T")
+u_plotter = pyvista.Plotter()
+u_plotter.add_mesh(u_grid, cmap="inferno", show_edges=False)
+u_plotter.add_mesh(u_grid, style="wireframe", color="white", opacity=0.2)
+
+contours = u_grid.contour(9)
+u_plotter.add_mesh(contours, color="white")
+
+u_plotter.view_xy()
+
+if not pyvista.OFF_SCREEN:
+ u_plotter.show()
+else:
+ figure = u_plotter.screenshot("temperature.png")
+```
diff --git a/book/content/applications/general/index.md b/book/content/applications/general/index.md
new file mode 100644
index 00000000..a88e9567
--- /dev/null
+++ b/book/content/applications/general/index.md
@@ -0,0 +1,15 @@
+---
+jupytext:
+ formats: ipynb,md:myst
+ text_representation:
+ extension: .md
+ format_name: myst
+ format_version: 0.13
+ jupytext_version: 1.18.1
+---
+
+# General #
+
+Modeling fusion components with FESTIM
+
++++
diff --git a/book/content/applications/general/monoblock.md b/book/content/applications/general/monoblock.md
new file mode 100644
index 00000000..badf8b60
--- /dev/null
+++ b/book/content/applications/general/monoblock.md
@@ -0,0 +1,302 @@
+---
+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
+---
+
+# Monoblock #
+
+In this task, we will learn how to run CAD-based simulations.
+
+Our example case will be a 3D ITER-like monoblock made of three different materials (tungsten, cucrzr, and copper).
+
+```{code-cell} ipython3
+import meshio
+
+
+def convert_med_to_xdmf(
+ med_file,
+ cell_file="mesh_domains.xdmf",
+ facet_file="mesh_boundaries.xdmf",
+ cell_type="tetra",
+ facet_type="triangle",
+):
+ """Converts a MED mesh to XDMF
+ Args:
+ med_file (str): the name of the MED file
+ cell_file (str, optional): the name of the file containing the
+ volume markers. Defaults to "mesh_domains.xdmf".
+ facet_file (str, optional): the name of the file containing the
+ surface markers.. Defaults to "mesh_boundaries.xdmf".
+ cell_type (str, optional): The topology of the cells. Defaults to "tetra".
+ facet_type (str, optional): The topology of the facets. Defaults to "triangle".
+ Returns:
+ dict, dict: the correspondance dict, the cell types
+ """
+ msh = meshio.read(med_file)
+
+ correspondance_dict = {-k: v for k, v in msh.cell_tags.items()}
+
+ cell_data_types = msh.cell_data_dict["cell_tags"].keys()
+
+ for mesh_block in msh.cells:
+ if mesh_block.type == cell_type:
+ meshio.write_points_cells(
+ cell_file,
+ msh.points,
+ [mesh_block],
+ cell_data={"f": [-1 * msh.cell_data_dict["cell_tags"][cell_type]]},
+ )
+ elif mesh_block.type == facet_type:
+ meshio.write_points_cells(
+ facet_file,
+ msh.points,
+ [mesh_block],
+ cell_data={"f": [-1 * msh.cell_data_dict["cell_tags"][facet_type]]},
+ )
+
+ return correspondance_dict, cell_data_types
+```
+
+```{code-cell} ipython3
+correspondance_dict, cell_data_types = convert_med_to_xdmf(
+ "monoblock_mesh/mesh.med",
+ cell_file="monoblock_mesh/mesh_domains.xdmf",
+ facet_file="monoblock_mesh/mesh_boundaries.xdmf",
+)
+
+print(correspondance_dict)
+```
+
+```{code-cell} ipython3
+import festim as F
+
+tungsten = F.Material(
+ D_0=4.1e-7,
+ E_D=0.39,
+ K_S_0=1.87e24,
+ E_K_S=1.04,
+ thermal_conductivity=100,
+)
+
+copper = F.Material(
+ D_0=6.6e-7,
+ E_D=0.387,
+ K_S_0=3.14e24,
+ E_K_S=0.572,
+ thermal_conductivity=350,
+)
+
+cucrzr = F.Material(
+ D_0=3.92e-7, E_D=0.418, K_S_0=4.28e23, E_K_S=0.387, thermal_conductivity=350
+)
+```
+
+The converted .xdmf files can then be imported in FESTIM using the `MeshFromXDMF` class:
+
+```{code-cell} ipython3
+mesh = F.MeshFromXDMF(
+ volume_file="monoblock_mesh/mesh_domains.xdmf", facet_file="monoblock_mesh/mesh_boundaries.xdmf"
+)
+
+mesh.mesh.geometry.x[:] *= 1e-3 # mm to m
+```
+
+```{code-cell} ipython3
+tungsten_volume = F.VolumeSubdomain(id=6, material=tungsten)
+copper_volume = F.VolumeSubdomain(id=7, material=copper)
+cucrzr_volume = F.VolumeSubdomain(id=8, material=cucrzr)
+top_surface = F.SurfaceSubdomain(id=9)
+cooling_surface = F.SurfaceSubdomain(id=10)
+poloidal_gap_w = F.SurfaceSubdomain(id=11)
+poloidal_gap_cu = F.SurfaceSubdomain(id=12)
+poloidal_gap_cucrzr = F.SurfaceSubdomain(id=13)
+toroidal_gap = F.SurfaceSubdomain(id=14)
+bottom = F.SurfaceSubdomain(id=15)
+
+all_subdomains = [
+ tungsten_volume,
+ copper_volume,
+ cucrzr_volume,
+ top_surface,
+ cooling_surface,
+ poloidal_gap_cu,
+ poloidal_gap_w,
+ poloidal_gap_cucrzr,
+ toroidal_gap,
+ bottom,
+]
+```
+
+```{code-cell} ipython3
+heat_transfer_problem = F.HeatTransferProblem()
+heat_transfer_problem.subdomains = all_subdomains
+heat_transfer_problem.mesh = mesh
+
+heat_flux_top = F.HeatFluxBC(subdomain=top_surface, value=10e6)
+convective_flux_coolant = F.HeatFluxBC(
+ subdomain=cooling_surface, value=lambda T: 7e04 * (323 - T)
+)
+
+
+heat_transfer_problem.boundary_conditions = [heat_flux_top, convective_flux_coolant]
+
+heat_transfer_problem.exports = [F.VTXTemperatureExport("out.bp")]
+
+heat_transfer_problem.settings = F.Settings(
+ atol=1e-10,
+ rtol=1e-10,
+ transient=False,
+)
+heat_transfer_problem.initialise()
+heat_transfer_problem.run()
+```
+
+```{code-cell} ipython3
+my_model = F.HydrogenTransportProblemDiscontinuous()
+my_model.method_interface = "penalty"
+
+my_model.subdomains = all_subdomains
+
+H = F.Species("H", subdomains=my_model.volume_subdomains)
+my_model.species = [H]
+
+my_model.mesh = mesh
+
+my_model.surface_to_volume = {
+ top_surface: tungsten_volume,
+ cooling_surface: cucrzr_volume,
+ poloidal_gap_w: tungsten_volume,
+ poloidal_gap_cu: copper_volume,
+ poloidal_gap_cucrzr: cucrzr_volume,
+ toroidal_gap: tungsten_volume,
+ bottom: tungsten_volume,
+}
+
+penalty_term = 1e20
+my_model.interfaces = [
+ F.Interface(
+ id=16, subdomains=(tungsten_volume, copper_volume), penalty_term=penalty_term
+ ),
+ F.Interface(
+ id=17, subdomains=(copper_volume, cucrzr_volume), penalty_term=penalty_term
+ ),
+]
+```
+
+Using the tags provided by `correspondance_dict`, we can create materials and assign them to the simulation:
+
++++
+
+Similarily, the surface tags are used to create boundary conditions:
+
+```{code-cell} ipython3
+import ufl
+
+phi = 1.61e22
+R_p = 9.52e-10
+implantation_flux_top = F.FixedConcentrationBC(
+ subdomain=top_surface,
+ value=lambda T: phi * R_p / (tungsten.D_0 * ufl.exp(-tungsten.E_D / F.k_B / T)),
+ species=H,
+)
+
+recombination_fluxes = [
+ F.FixedConcentrationBC(subdomain=surf, value=0, species=H)
+ for surf in [
+ toroidal_gap,
+ bottom,
+ poloidal_gap_w,
+ poloidal_gap_cu,
+ poloidal_gap_cucrzr,
+ cooling_surface,
+ ]
+]
+
+
+my_model.boundary_conditions = [implantation_flux_top] + recombination_fluxes
+
+my_model.temperature = 1200 # heat_transfer_problem.u # FIXME https://fenicsproject.discourse.group/t/interpolate-expression-on-submesh-with-parent-mesh-function/17467
+
+my_model.settings = F.Settings(
+ atol=1e10,
+ rtol=1e-10,
+ transient=False,
+ max_iterations=10,
+)
+
+my_model.initialise()
+my_model.run()
+```
+
+```{code-cell} ipython3
+assert my_model.interfaces[0].id in tungsten_volume.ft.values
+assert my_model.interfaces[0].id in copper_volume.ft.values
+assert my_model.interfaces[1].id in copper_volume.ft.values
+assert my_model.interfaces[1].id in cucrzr_volume.ft.values
+```
+
+## Post processing
+
+```{code-cell} ipython3
+:tags: [hide-cell]
+
+import pyvista
+
+pyvista.start_xvfb()
+pyvista.set_jupyter_backend("html")
+```
+
+```{code-cell} ipython3
+from dolfinx import plot
+
+T = heat_transfer_problem.u
+
+topology, cell_types, geometry = plot.vtk_mesh(T.function_space)
+u_grid = pyvista.UnstructuredGrid(topology, cell_types, geometry)
+u_grid.point_data["T"] = T.x.array.real
+u_grid.set_active_scalars("T")
+u_plotter = pyvista.Plotter()
+u_plotter.add_mesh(u_grid, cmap="inferno", show_edges=False)
+u_plotter.add_mesh(u_grid, style="wireframe", color="white", opacity=0.2)
+
+contours = u_grid.contour(9)
+u_plotter.add_mesh(contours, color="white")
+
+u_plotter.view_xy()
+
+if not pyvista.OFF_SCREEN:
+ u_plotter.show()
+else:
+ figure = u_plotter.screenshot("temperature.png")
+```
+
+```{code-cell} ipython3
+u_plotter = pyvista.Plotter()
+
+for vol in my_model.volume_subdomains:
+ sol = H.subdomain_to_post_processing_solution[vol]
+
+ topology, cell_types, geometry = plot.vtk_mesh(sol.function_space)
+ u_grid = pyvista.UnstructuredGrid(topology, cell_types, geometry)
+ u_grid.point_data["c"] = sol.x.array.real
+ u_grid.set_active_scalars("c")
+ u_plotter.add_mesh(u_grid, cmap="viridis", show_edges=False)
+ u_plotter.add_mesh(u_grid, style="wireframe", color="white", opacity=0.2)
+
+u_plotter.view_xy(negative=True)
+
+
+if not pyvista.OFF_SCREEN:
+ u_plotter.show()
+else:
+ figure = u_plotter.screenshot("concentration.png")
+```
diff --git a/book/content/applications/task08/mesh.med b/book/content/applications/general/monoblock_mesh/mesh.med
similarity index 100%
rename from book/content/applications/task08/mesh.med
rename to book/content/applications/general/monoblock_mesh/mesh.med
diff --git a/book/content/applications/general/permeation_barrier.md b/book/content/applications/general/permeation_barrier.md
new file mode 100644
index 00000000..3fa702f3
--- /dev/null
+++ b/book/content/applications/general/permeation_barrier.md
@@ -0,0 +1,304 @@
+---
+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
+---
+
+# Permeation barrier modelling
+
+In this task, we will model permeation barriers on tungsten and compute the associated Permeation Reduction Factor (PRF).
+
+The PRF is the ratio of the steady state permeation flux without barriers by that of the case with barriers.
+
++++
+
+## 1) Model with barrier
+
+Let's first create a model where tungsten is coated with 1 micron of barrier material on both sides.
+
+```{code-cell} ipython3
+import festim as F
+
+model_barrier = F.HydrogenTransportProblemDiscontinuous()
+```
+
+Let's create three ``VolumeSubdomain1D`` instances for the three subdomains and assign them to ``model_barrier.subdomains``.
+
+```{admonition} Note
+By default, the solubility law of the materials is `"sievert"`.
+However, it can be changed by overriding the `solubility_law` argument to `"henry"`
+```
+
+```{code-cell} ipython3
+barrier_thick = 1e-6
+substrate_thick = 3e-3
+
+barrier = F.Material(
+ D_0=1e-8,
+ E_D=0.39,
+ K_S_0=1e22,
+ E_K_S=1.04,
+)
+
+tungsten = F.Material(
+ D_0=4.1e-7,
+ E_D=0.39,
+ K_S_0=1.87e24,
+ E_K_S=1.04,
+)
+
+volume_barrier_left = F.VolumeSubdomain1D(
+ id=1, borders=[0, barrier_thick], material=barrier
+)
+volume_tungsten = F.VolumeSubdomain1D(
+ id=2, borders=[barrier_thick, substrate_thick + barrier_thick], material=tungsten
+)
+volume_barrier_right = F.VolumeSubdomain1D(
+ id=3,
+ borders=[substrate_thick + barrier_thick, substrate_thick + 2 * barrier_thick],
+ material=barrier,
+)
+
+boundary_left = F.SurfaceSubdomain1D(id=1, x=0)
+boundary_right = F.SurfaceSubdomain1D(id=2, x=substrate_thick + 2 * barrier_thick)
+
+model_barrier.subdomains = [
+ volume_barrier_left,
+ volume_tungsten,
+ volume_barrier_right,
+ boundary_left,
+ boundary_right,
+]
+```
+
+```{code-cell} ipython3
+model_barrier.surface_to_volume = {
+ boundary_left: volume_barrier_left,
+ boundary_right: volume_barrier_right,
+}
+
+model_barrier.interfaces = [
+ F.Interface(id=3, subdomains=[volume_barrier_left, volume_tungsten], penalty_term=1e10),
+ F.Interface(id=4, subdomains=[volume_tungsten, volume_barrier_right], penalty_term=1e10),
+]
+```
+
+```{code-cell} ipython3
+H = F.Species("H", subdomains=model_barrier.volume_subdomains)
+model_barrier.species = [H]
+```
+
+To avoid cells overlapping the domains boundaries, we create 3 lists of vertices.
+
+```{code-cell} ipython3
+import numpy as np
+
+vertices_left = np.linspace(0, barrier_thick, num=50)
+
+vertices_mid = np.linspace(barrier_thick, substrate_thick + barrier_thick, num=50)
+
+vertices_right = np.linspace(
+ substrate_thick + barrier_thick, substrate_thick + 2 * barrier_thick, num=50
+)
+
+vertices = np.concatenate([vertices_left, vertices_mid, vertices_right])
+
+model_barrier.mesh = F.Mesh1D(vertices)
+```
+
+The temperature is homogeneous across the domain.
+
+```{code-cell} ipython3
+model_barrier.temperature = 600
+```
+
+A Sievert's boundary condition is applied on the left surface and the concentration is assumed to be zero on the right surface.
+
+```{code-cell} ipython3
+left_bc = F.SievertsBC(
+ subdomain=boundary_left, S_0=barrier.K_S_0, E_S=barrier.E_K_S, pressure=100, species=H
+)
+
+right_bc = F.FixedConcentrationBC(species=H, subdomain=boundary_right, value=0)
+
+model_barrier.boundary_conditions = [left_bc, right_bc]
+```
+
+For this task, we want to compute the permeation flux, that is the flux at the right surface.
+
+We will also export the concentration profiles at three different times
+
+```{code-cell} ipython3
+permeation_flux = F.SurfaceFlux(field=H, surface=boundary_right)
+
+vtx_exports = [
+ F.VTXSpeciesExport(filename=f"h_{i}.bp", field=H, subdomain=vol) for i, vol in enumerate(model_barrier.volume_subdomains)
+]
+
+
+profile_exports = [
+ F.Profile1DExport(field=spe, subdomain=vol, times=[100, 17000, 8e5])
+ for spe in model_barrier.species
+ for vol in model_barrier.volume_subdomains
+]
+model_barrier.exports = [permeation_flux] + vtx_exports + profile_exports
+```
+
+```{code-cell} ipython3
+model_barrier.settings = F.Settings(
+ atol=1e0,
+ rtol=1e-09,
+ final_time=8e5,
+)
+
+
+model_barrier.settings.stepsize = F.Stepsize(
+ initial_value=5, growth_factor=1.1, cutback_factor=0.9, target_nb_iterations=4, milestones=[100, 17000, 8e5]
+)
+```
+
+```{code-cell} ipython3
+model_barrier.initialise()
+model_barrier.run()
+```
+
+We can plot the concentration profiles at different times and notice the jump of concentrations at interfaces:
+
+```{code-cell} ipython3
+:tags: [hide-input]
+
+import matplotlib.pyplot as plt
+
+xlim_left = (0, barrier_thick * 2)
+xlim_mid = (None, None)
+xlim_right = (substrate_thick, substrate_thick + 2 * barrier_thick)
+
+fig, axs = plt.subplots(nrows=1, ncols=3, sharey=True, figsize=(20, 4))
+
+# three shades of blue for the three times
+colours = ["#1f77b4", "#185580", "#0C273B"]
+
+for ax, xlim in zip(axs, [xlim_left, xlim_mid, xlim_right]):
+ plt.sca(ax)
+ for profile in profile_exports:
+ for i, time in enumerate(profile.times):
+ label = f"{time:.0f} s" if ax == axs[0] and profile == profile_exports[0] else None
+ c = profile.data[i]
+ ax.plot(profile.x, c, color=colours[i], label=label)
+
+ ax.set_xlim(xlim)
+ ax.set_xlabel("Depth (m)")
+
+axs[0].legend(fontsize=12, reverse=True)
+axs[0].set_yscale("log")
+axs[0].set_ylim(bottom=1e12)
+axs[0].set_ylabel("Mobile H concentration (H/m$^3$)")
+axs[0].set_title("zoom left")
+axs[2].set_title("zoom right")
+plt.show()
+```
+
+## 2) Model without barrier
+
+We can also run the equivalent model without permeation barriers with bare tungsten.
+Let's make a few modifications:
+
+```{code-cell} ipython3
+model_no_barrier = F.HydrogenTransportProblem()
+
+boundary_left = F.SurfaceSubdomain1D(id=1, x=barrier_thick)
+boundary_right = F.SurfaceSubdomain1D(id=2, x=substrate_thick + 1 * barrier_thick)
+model_no_barrier.subdomains = [volume_tungsten, boundary_left, boundary_right]
+
+# new mesh
+model_no_barrier.mesh = F.Mesh1D(np.linspace(*volume_tungsten.borders, num=50))
+
+# change the solubility of the Sievert's condition
+left_bc.S_0 = tungsten.K_S_0
+left_bc.E_S = tungsten.E_K_S
+
+model_no_barrier.temperature = model_barrier.temperature
+model_no_barrier.boundary_conditions = model_barrier.boundary_conditions
+model_no_barrier.species = model_barrier.species
+
+model_no_barrier.settings = model_barrier.settings
+
+
+permeation_flux_no_barrier = F.SurfaceFlux(field=H, surface=boundary_right)
+model_no_barrier.exports = [permeation_flux_no_barrier]
+
+model_no_barrier.initialise()
+model_no_barrier.run()
+```
+
+## 3) Calculate the PRF
+
++++
+
+We can plot the temporal evolution of permeation flux with or without permeation barriers:
+
+```{code-cell} ipython3
+import matplotlib.pyplot as plt
+plt.figure()
+
+plt.plot(permeation_flux_no_barrier.t, permeation_flux_no_barrier.data, label="without barrier")
+plt.plot(permeation_flux.t, permeation_flux.data, label="with barrier")
+
+plt.xscale("log")
+plt.legend()
+plt.xlabel("Time (s)")
+plt.ylabel("Permeation flux (H/m2/s)")
+plt.show()
+```
+
+Clearly, having the coating on both sides reduces the permeation flux!
+
+Moreover, it can be shown that the PRF of this configuration is:
+
+$$\mathrm{PRF} = 1 + 2 \alpha \beta \gamma$$
+
+With
+
+$$\alpha = D_\mathrm{substrate} / D_\mathrm{barrier} $$
+
+$$\beta = S_\mathrm{substrate} / S_\mathrm{barrier} $$
+
+$$\gamma = e_\mathrm{barrier} / e_\mathrm{substrate} $$
+
+We can compare the computed PRF to the theory.
+
+```{code-cell} ipython3
+computed_PRF = permeation_flux_no_barrier.data[-1] / permeation_flux.data[-1]
+
+diff_ratio = tungsten.D_0 / barrier.D_0
+sol_ratio = tungsten.K_S_0 / barrier.K_S_0
+length_ratio = barrier_thick / substrate_thick
+
+theoretical_PRF = 1 + 2 * diff_ratio * sol_ratio * length_ratio
+
+print(f"Theoretical PRF = {theoretical_PRF:.4f}")
+print(f"Computed PRF = {computed_PRF:.4f}")
+print(f"Error = {(computed_PRF - theoretical_PRF)/theoretical_PRF:.2%}")
+```
+
+# Question
+Will adding traps to the simulation change the value of the PRF?
+
+
+Show solution
+
+No. The PRF is a measure of the flux of mobile particles and is computed at steady state.
+
+At steady state, the McNabb & Foster model states that the concentration of mobile particle is independent of the trapped concentration.
+
+Therefore, the steady state PRF is independent of trapping.
+
+
diff --git a/book/content/applications/general/simple.md b/book/content/applications/general/simple.md
new file mode 100644
index 00000000..48b7d420
--- /dev/null
+++ b/book/content/applications/general/simple.md
@@ -0,0 +1,265 @@
+---
+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
+---
+
+(simple-simulation)=
+# Simple simulation
+
+In this task, we'll go through the basics of FESTIM and run a simple simulation on a 1D domain.
+
+The very first step is to import the `festim` package:
+
+```{code-cell} ipython3
+import festim as F
+
+print(F.__version__)
+```
+
+Every FESTIM model is represented by a `Simulation` object. Here, we give it the name `my_model`
+
+```{code-cell} ipython3
+my_model = F.HydrogenTransportProblem()
+```
+
+Several "ingredients" are now required to run a FESTIM simulation:
+- a mesh
+- a temperature
+- a set of materials
+- optionally: trapping properties
+- boundary conditions
+- optionally: sources of H
+- simulation settings
+- a stepsize for transient problems
+
++++
+
+## 1. Mesh
+
+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)).
+
+The most straightforward mesh is `MeshFromVertices`, which takes a `vertices` argument.
+
++++
+
+Numpy can be used to generate heavier meshes. Here we create a mesh containing 1000 cells over a [0, 7e-6] domain (7 microns).
+
+This mesh is assigned to the simulation by setting the `.mesh` attribute of `my_model`.
+
+```{code-cell} ipython3
+import numpy as np
+
+my_model.mesh = F.Mesh1D(vertices=np.linspace(0, 7e-6, num=1001))
+```
+
+```{admonition} Tip
+:class: tip
+For more information on meshes in FESTIM. See the Meshing section of the tutorials.
+```
+
++++
+
+## 2. Materials
+
+`Material` objects hold the materials properties like diffusivity and solubility.
+
+Here we only need the diffusivity defined as an Arrhenius law:
+
+$$
+ D = D_0 \exp{(-E_D/k_B T)}
+$$
+
+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.
+
+```{note} Note
+All units in FESTIM as SI (apart for activation energies that are in eV)
+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
+```
+
+```{code-cell} ipython3
+mat = F.Material(D_0=1e-7, E_D=0.2)
+
+volume_subdomain = F.VolumeSubdomain1D(id=1, borders=[0, 7e-6], material=mat)
+boundary_left = F.SurfaceSubdomain1D(id=1, x=0)
+boundary_right = F.SurfaceSubdomain1D(id=2, x=7e-6)
+my_model.subdomains = [volume_subdomain, boundary_left, boundary_right]
+```
+
+```{code-cell} ipython3
+H = F.Species("H")
+my_model.species = [H]
+```
+
+## 3. Temperature
+
+Temperature is a very important parameter in hydrogen transport.
+The value can be a simple float (like here `300`) or a `sympy` expression like `500 + 3*sympy.exp(-F.x)`.
+
+The temperature is in K.
+
+```{note} Note
+For heat transfer simulations, the `HeatTransferProblem` can be used instead. See [Heat transfer simulations](heat_transfer_sims)
+```
+
+```{code-cell} ipython3
+my_model.temperature = 300
+```
+
+## 4. Boundary conditions & source
+
+Our hydrogen transport problem now needs boundary conditions and a volumetric source term.
+
+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)).
+
+Here we'll simply set the mobile concentration at ``1e15`` on the left and right boundaries (resp. `1` and `2`).
+
+- ``field`` represents the variable on which the boundary condition is imposed. Here, `0` stands for the mobile hydrogen concentration.
+
+- ``value`` is the value of the mobile concentration. Again, it could be a function of time and space with ``1e15*F.x + F.t``
+
+- ``surfaces`` is a list of surfaces ids (in 1D, `1` is left and `2` is right)
+
+A volumetric source of mobile H (`field=0`) is set in the whole volume (`volume=1`) and its value is `1e20` H/m3/s.
+Additional sources can be applied.
+
+```{code-cell} ipython3
+my_model.boundary_conditions = [
+ F.FixedConcentrationBC(subdomain=boundary_left, value=1e15, species=H),
+ F.FixedConcentrationBC(subdomain=boundary_right, value=1e15, species=H),
+]
+
+
+my_model.sources = [F.ParticleSource(value=1e20, volume=volume_subdomain, species=H)]
+```
+
+## 5. Settings
+
+With `Settings` we set the main solver parameters.
+- `absolute_tolerance`: the absolute tolerance of the Newton solver. For concentrations in $\mathrm{m}^{-3}$, `1e10` is usually fine.
+- `relative_tolerance`: the relative tolerance of the Newton solver. Values around `1e-10` are good practices.
+- `final_time`: since we want to solve a transient problem, we need to set the final time. Here, 100 s.
+
+
+```{admonition} Tip
+:class: tip
+Tuning absolute and relative tolerances can be a fine art. If tolerances the solver may not converge.
+If they are too high, the solver may converge to quickly (in zero iterations), resulting in no evolution of the concentration fields.
+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)
+```
+
+```{code-cell} ipython3
+my_model.settings = F.Settings(atol=1e10, rtol=1e-10, final_time=2) # s
+```
+
+## 7. Stepsize
+
+Since we are solving a transient problem, we need to set a ``Stepsize``.
+Here, the value of the stepsize is fixed at 0.05.
+
+We also add ``milestones`` to ensure the simulation passes by specific times.
+
+
+```{admonition} Note
+:class: tip
+Transient simulations can be accelerated with adaptive stepsize. See [TDS](../material_science/tds.md)
+```
+
+```{code-cell} ipython3
+my_model.settings.stepsize = F.Stepsize(0.05, milestones=[0.1, 0.2, 0.5, 1]) # s
+```
+
+## 6. Exports
+
+Finally, we want to be able to visualise the concentration field.
+To do so, we add an `XDMFExport` object which will export the concentration field at each timestep to an XDMF file.
+This XDMF file can then be read in [Paraview](https://www.paraview.org/).
+
+- `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)
+
+- `filename`: the path to the exported file
+
+```{code-cell} ipython3
+class ProfileExport(F.VolumeQuantity):
+
+ def compute(self):
+ profile = self.field.solution.x.array[:].copy()
+
+ self.data.append(profile)
+```
+
+```{code-cell} ipython3
+profile = ProfileExport(field=H, volume=volume_subdomain)
+
+my_model.exports = [
+ F.XDMFExport(
+ field=H,
+ filename="task01/hydrogen_concentration.xdmf",
+ ),
+ profile,
+]
+```
+
+## 8. Run
+
+Finally, we initialise the model and run it!
+
+```{code-cell} ipython3
+my_model.initialise()
+
+my_model.run()
+```
+
+Three files should have been created: hydrogen_concentration.xdmf, hydrogen_concentration.h5, and mobile_concentration.txt
+
+The .xdmf file is the one that can be opened in Paraview, and it points to the .h5 file.
+
+The profile exported as a text file can now be plotted with matplotlib:
+
+```{code-cell} ipython3
+import matplotlib.pyplot as plt
+import numpy as np
+
+x = my_model.mesh.mesh.geometry.x[:, 0]
+
+for t in [0.1, 0.2, 0.5, 1]:
+ idx = np.where(np.isclose(profile.t, t))[0][0]
+ data = profile.data[idx]
+ plt.plot(x, data, label=f"{t} s")
+
+plt.xlabel("x (m)")
+plt.ylabel("Mobile concentration (H/m3)")
+plt.legend()
+plt.show()
+```
+
+To solve the steady-state problem, simply set:
+
+```{code-cell} ipython3
+my_model.settings.transient = False
+my_model.settings.stepsize = None
+
+my_model.exports = [profile]
+```
+
+```{code-cell} ipython3
+my_model.initialise()
+
+my_model.run()
+```
+
+```{code-cell} ipython3
+data = profile.data[0]
+plt.plot(x, data, label=f"{t} s")
+plt.xlabel("x (m)")
+plt.ylabel("Mobile concentration (H/m3)")
+plt.show()
+```
diff --git a/book/content/applications/general/simple_permeation.md b/book/content/applications/general/simple_permeation.md
new file mode 100644
index 00000000..e1666947
--- /dev/null
+++ b/book/content/applications/general/simple_permeation.md
@@ -0,0 +1,154 @@
+---
+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
+---
+
+# Simple permeation simulation
+
+In this task, we'll go through the basics of FESTIM and run a simple permeation simulation on a 1D domain.
+
+```{code-cell} ipython3
+import festim as F
+```
+
+The first step is to create a model using a `Simulation` object.
+
+```{code-cell} ipython3
+my_model = F.HydrogenTransportProblem()
+
+H = F.Species("H")
+my_model.species = [H]
+```
+
+We'll consider a 3 mm-thick material and a regular mesh (1000 cells)
+
+```{code-cell} ipython3
+import numpy as np
+
+my_model.mesh = F.Mesh1D(vertices=np.linspace(0, 3e-4, num=1001))
+```
+
+`Material` objects hold the materials properties like diffusivity and solubility.
+
+Here we only need the diffusivity defined as an Arrhenius law: $D = D_0 \exp{(-E_D/k_B T)}$ 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 units m2/s, and the diffusion actiavtion energy, $E_D$ in units eV are needed.`
+
+```{code-cell} ipython3
+material = F.Material(D_0=1.9e-7, E_D=0.2)
+
+volume_subdomain = F.VolumeSubdomain1D(id=1, borders=(0, 3e-4), material=material)
+left_boundary = F.SurfaceSubdomain1D(id=1, x=0)
+right_boundary = F.SurfaceSubdomain1D(id=2, x=3e-4)
+
+my_model.subdomains = [volume_subdomain, left_boundary, right_boundary]
+```
+
+The temperature is set at 500 K
+
+```{code-cell} ipython3
+my_model.temperature = 500
+```
+
+FESTIM has a `SievertsBC` class representing Sievert's law of solubility: $c = S \ \sqrt{P}$ at metal surfaces.
+
+> Note:
+>
+> A similar class exists for non-metallic materials behaving according to Henry's law: `HenrysBC`
+
+We'll use this boundary condition on the left surface (`id=1`) and will assume a zero concentration on the right side (`id=2`).
+
+```{code-cell} ipython3
+P_up = 100 # Pa
+
+my_model.boundary_conditions = [
+ F.SievertsBC(subdomain=left_boundary, S_0=4.02e21, E_S=1.04, pressure=P_up, species=H),
+ F.FixedConcentrationBC(subdomain=right_boundary, value=0, species=H),
+]
+```
+
+With `Settings` we set the main solver parameters.
+
+```{code-cell} ipython3
+my_model.settings = F.Settings(atol=1e-2, rtol=1e-10, final_time=100) # s
+```
+
+Let's choose a stepsize small enough to have good temporal resolution:
+
+```{code-cell} ipython3
+my_model.settings.stepsize = F.Stepsize(1 / 20)
+```
+
+For this permeation experiment, we are only interested in the hydrogen flux on the right side:
+
+```{code-cell} ipython3
+permeation_flux = F.SurfaceFlux(field=H, surface=right_boundary)
+
+my_model.exports = [permeation_flux]
+```
+
+```{code-cell} ipython3
+my_model.initialise()
+
+my_model.run()
+```
+
+This problem can be solved analytically. The solution for the downstream flux is:
+
+$$\mathrm{downstream \ flux} = \frac{P_\mathrm{up} \Phi}{L} \left(1 + 2 \sum_{n=1}^{\infty} \left(-1\right)^{n} \exp{(- \frac{\pi^{2} D n^{2} t}{L^{2}})}\right) $$
+
+```{code-cell} ipython3
+def downstream_flux(t, P_up, permeability, L, D):
+ """calculates the downstream H flux at a given time t
+
+ Args:
+ t (float, np.array): the time
+ P_up (float): upstream partial pressure of H
+ permeability (float): material permeability
+ L (float): material thickness
+ D (float): diffusivity of H in the material
+
+ Returns:
+ float, np.array: the downstream flux of H
+ """
+ n_array = np.arange(1, 10000)[:, np.newaxis]
+ summation = np.sum(
+ (-1) ** n_array * np.exp(-((np.pi * n_array) ** 2) * D / L**2 * t), axis=0
+ )
+ return P_up**0.5 * permeability / L * (2 * summation + 1)
+```
+
+We can compare the computed downstream flux to the analytical solution:
+
+```{code-cell} ipython3
+times = permeation_flux.t
+
+D = 1.9e-7 * np.exp(-0.2 / F.k_B / 500)
+S = 4.02e21 * np.exp(-1.04 / F.k_B / 500)
+
+import matplotlib.pyplot as plt
+
+plt.scatter(times, np.abs(permeation_flux.data), alpha=0.2, label="computed")
+plt.plot(
+ times,
+ downstream_flux(times, P_up, permeability=D * S, L=3e-4, D=D),
+ color="tab:orange",
+ label="analytical",
+)
+plt.ylim(bottom=0)
+plt.xlabel("Time (s)")
+plt.ylabel("Downstream flux (H/m2/s)")
+plt.show()
+```
+
+Phew! We have a good agreement between our model and the analytical solution!
+
+To reproduce simple permeation experiments, the analytical solution is obviously enough.
+However, for more complex scenarios (transients, trapping regimes,..) a numerical model provides more flexibility.
diff --git a/book/content/applications/material_science/fitting_tds.md b/book/content/applications/material_science/fitting_tds.md
new file mode 100644
index 00000000..5f8504dc
--- /dev/null
+++ b/book/content/applications/material_science/fitting_tds.md
@@ -0,0 +1,416 @@
+---
+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
+---
+
+# Fitting a TDS spectrum
+
+In this task, we'll perform an automated identification of trapping site properties using a parametric optimisation algorithm.
+See [R. Delaporte-Mathurin et al. NME (2021)](https://doi.org/10.1016/j.nme.2021.100984) for more details.
+
++++
+
+## TDS model
+
++++
+
+We have to define our FESTIM model, which we'll use in both task steps. The simulation will be performed for the case of H desorption from a W domain. Using the HTM library, we can get parameters of the H diffusivity in W that are required to set up the model.
+
+```{code-cell} ipython3
+import h_transport_materials as htm
+
+D = (
+ htm.diffusivities.filter(material="tungsten")
+ .filter(isotope="h")
+ .filter(author="fernandez")[0]
+)
+print(D)
+```
+
+For this task, we'll consider a simplified simulation scenario. Firstly, we'll set only one sort of trapping site characterised by a detrapping barrier `E_p` [eV] and uniformly distributed in the W domain with concentration `n` [at. fr.]. Secondly, we'll assume that this W sample was kept in a H environment infinetly long, so all the trap sites were filled with H atoms. Thirdly, we'll suppose that all mobile H atoms leave the sample before the TDS. Finally, we'll simulate simulate the TDS phase assuming a uniform heating ramp of 5 K/s.
+
+The initial conditions are:
+$$ \left.c_{\mathrm{m}}\right\vert_{t=0}=0 $$
+$$ \left.c_{\mathrm{t}}\right\vert_{t=0}=n $$
+which we'll set using the `InitialCondition` class.
+
+For the boundary conditions, we'll use the assumption of an instantaneous recombination (using `FixedConcentrationBC`):
+$$ \left.c_{\mathrm{m}}\right\vert_{x=0}=\left.c_{\mathrm{m}}\right\vert_{x=L}=0 $$
+
+For the fitting stage, we have to treat the detrapping energy and the trap concentration as variable parameters. Therefore, we'll define a function that encapsulates our `Simulation` object and accepts two input parameters: the trap density and detrapping energy.
+
+```{code-cell} ipython3
+import festim as F
+import numpy as np
+
+
+def temperature(t):
+ ramp = 5 # K/s
+ return 300 + ramp * t
+
+
+def TDS(n, E_p):
+ """Runs the simulation with parameters p that represent:
+
+ Args:
+ n (float): concentration of trap 1, at. fr.
+ E_p (float): detrapping barrier from trap 1, eV
+
+ Returns:
+ F.DerivedQuantities: the derived quantities of the simulation
+ """
+ w_atom_density = 6.3e28 # atom/m3
+ trap_conc = n * w_atom_density
+
+ # Define Simulation object
+ synthetic_TDS = F.HydrogenTransportProblem()
+
+ H = F.Species("H")
+ trapped_species = F.Species("H_trapped", mobile=False)
+ synthetic_TDS.species = [H, trapped_species]
+
+ # Define a simple mesh
+ vertices = np.linspace(0, 20e-6, num=200)
+ synthetic_TDS.mesh = F.Mesh1D(vertices)
+
+ # Define material properties
+ tungsten = F.Material(
+ D_0=D.pre_exp.magnitude,
+ E_D=D.act_energy.magnitude,
+ )
+
+ boundary_left = F.SurfaceSubdomain1D(id=1, x=0)
+ boundary_right = F.SurfaceSubdomain1D(id=2, x=20e-6)
+ volume_subdomain = F.VolumeSubdomain1D(id=3, borders=[0, 20e-6], material=tungsten)
+ synthetic_TDS.subdomains = [boundary_left, boundary_right, volume_subdomain]
+
+ # Define traps
+
+ empty_trap = F.ImplicitSpecies(
+ n=trap_conc,
+ others=[trapped_species],
+ )
+ trap_1_reaction = F.Reaction(
+ reactant=[H, empty_trap],
+ product=[trapped_species],
+ k_0=D.pre_exp.magnitude / (1.1e-10**2 * 6 * w_atom_density),
+ E_k=D.act_energy.magnitude,
+ p_0=1e13,
+ E_p=E_p,
+ volume=volume_subdomain,
+ )
+
+ synthetic_TDS.reactions = [trap_1_reaction]
+
+ # Set initial conditions
+ synthetic_TDS.initial_conditions = [
+ F.InitialCondition(species=trapped_species, value=trap_conc),
+ ]
+
+ # Set boundary conditions
+ synthetic_TDS.boundary_conditions = [
+ F.FixedConcentrationBC(subdomain=surf, value=0, species=H)
+ for surf in [boundary_left, boundary_right]
+ ]
+
+ # Define the material temperature evolution
+ synthetic_TDS.temperature = temperature
+
+ # Define the simulation settings
+ synthetic_TDS.settings = F.Settings(
+ atol=1e10,
+ rtol=1e-10,
+ final_time=140,
+ max_iterations=50,
+ )
+
+ synthetic_TDS.settings.stepsize = F.Stepsize(
+ initial_value=0.01,
+ growth_factor=1.2,
+ cutback_factor=0.9,
+ target_nb_iterations=4,
+ max_stepsize=lambda t: None if t < 1 else 1,
+ )
+
+ fluxes = [
+ F.SurfaceFlux(field=H, surface=boundary_left),
+ F.SurfaceFlux(field=H, surface=boundary_right),
+ ]
+
+ synthetic_TDS.exports = fluxes
+ synthetic_TDS.initialise()
+ synthetic_TDS.run()
+
+ return fluxes
+```
+
+## Generate dummy data
+
+Now we can generate a reference TDS spectrum. For the reference case, we'll consider the following parameters: $n=0.01~\text{at.fr}$ and $E_p=1~\text{eV}$.
+
+```{code-cell} ipython3
+reference_prms = [1e-2, 1.0]
+data = TDS(*reference_prms)
+```
+
+Additionally, we can add some noise to the generated TDS spectra to mimic the experimental conditions. We'll also save the noisy flux dependence on temperature into a file to use it further as a reference data.
+
+```{code-cell} ipython3
+import matplotlib.pyplot as plt
+
+
+# Calculate the total desorption flux
+flux_left = data[0].data
+flux_right = data[1].data
+flux_total = np.array(flux_left) + np.array(flux_right)
+
+# Get temperature
+T = temperature(np.array(data[0].t))
+
+# Add random noise
+noise = np.random.normal(0, 0.05 * max(flux_total), len(flux_total))
+noisy_flux = flux_total + noise
+
+# Save to file
+np.savetxt("Noisy_TDS.csv", np.column_stack([T, noisy_flux]), delimiter=";", fmt="%f")
+
+# Visualise
+plt.plot(T, noisy_flux, linewidth=2)
+
+plt.ylabel(r"Desorption flux (m$^{-2}$ s$^{-1}$)")
+plt.xlabel(r"Temperature (K)")
+plt.show()
+```
+
+## Automated TDS fit
+
++++
+
+Here we'll define the algorithm to fit the generated TDS spectra using the [`minimize`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html) method from the `scipy.optimize` python library. The initial implementation of the algorithm can be found in [this repository](https://github.com/RemDelaporteMathurin/tds_optimisation/tree/main). We'll try to find the values of the detrapping barrier and the trap concetration so the average absolute error between the reference and the fitted spectras satisfies the required tolerance. To start with, we'll read our reference data and define an auxiliary method to display information on the status of fitting.
+
+```{code-cell} ipython3
+ref = np.genfromtxt("Noisy_TDS.csv", delimiter=";")
+
+
+def info(xk):
+ """
+ Print information during the fitting procedure
+ """
+ print("-" * 40)
+ print("New iteration.")
+ print(f"Point is: {xk}")
+```
+
+Then, we define an error function `error_function` that:
+- runs the TDS model with a given set of parameters
+- calculates the mean absolute error between the reference and the simulated TDS
+- collects intermediate values of parameters and the calculated errors for visualisation purposes
+
+```{code-cell} ipython3
+from scipy.interpolate import interp1d
+
+prms = []
+errors = []
+
+all_ts = []
+all_fluxes = []
+
+i = 0 # initialise counter
+
+
+def error_function(prm):
+ """
+ Compute average absolute error between simulation and reference
+ """
+ global i
+ global prms
+ global errors
+ global all_ts
+ global all_fluxes
+
+ i += 1
+ prms.append(prm)
+
+ # Filter the results if a negative value is found
+ if any([e < 0 for e in prm]):
+ return 1e30
+
+ # Get the simulation result
+ n, Ep = prm
+ res = TDS(n, Ep)
+
+ flux = np.array(res[0].data) + np.array(res[1].data)
+ all_fluxes.append(flux)
+ all_ts.append(np.array(res[0].t))
+
+ T = temperature(np.array(res[0].t))
+
+ interp_tds = interp1d(T, flux, fill_value="extrapolate")
+
+ # Compute the mean absolute error between sim and ref
+ err = np.abs(interp_tds(ref[:, 0]) - ref[:, 1]).mean()
+
+ print(f"Average absolute error is : {err:.2e}")
+ errors.append(err)
+ return err
+```
+
+Finally, we'll minimise `error_function` to find the set of trap properties reproducing the reference TDS (within some tolerance).
+
+We'll use the Nelder-Mead minimisation algorithm with the initial guess: $n=0.02~\text{at.fr.}$ and $E_p=1.1~\text{eV}$.
+
+```{code-cell} ipython3
+:tags: [hide-output]
+
+from scipy.optimize import minimize
+
+
+# Set the tolerances
+fatol = 3e18
+xatol = 1e-2
+
+initial_guess = [2e-2, 1.1]
+
+# Minimise the error function
+res = minimize(
+ error_function,
+ np.array(initial_guess),
+ method="Nelder-Mead",
+ options={"disp": True, "fatol": fatol, "xatol": xatol},
+ callback=info,
+)
+```
+
+## Visualise results
+
+```{code-cell} ipython3
+# Process the obtained results
+predicted_data = TDS(*res.x)
+
+T = temperature(np.array(predicted_data[0].t))
+
+flux_left = predicted_data[0].data
+flux_right = predicted_data[1].data
+flux_total = np.array(flux_left) + np.array(flux_right)
+
+for i, (t, flux) in enumerate(zip(all_ts, all_fluxes)):
+ T = temperature(t)
+ if i == 0:
+ plt.plot(T, flux, color="tab:red", lw=2, label="Initial guess")
+ else:
+ plt.plot(T, flux, color="tab:grey", lw=0.5)
+
+plt.plot(ref[:, 0], ref[:, 1], linewidth=2, label="Reference")
+plt.plot(T, flux_total, linewidth=2, label="Optimised")
+
+plt.ylabel(r"Desorption flux (m$^{-2}$ s$^{-1}$)")
+plt.xlabel(r"Temperature (K)")
+plt.legend()
+plt.show()
+```
+
+```{code-cell} ipython3
+:tags: [hide-input]
+
+import matplotlib.animation as animation
+from IPython.display import HTML
+
+# Turn off interactive plotting to prevent static display
+plt.ioff()
+
+# Create the figure and axis
+fig, ax = plt.subplots(figsize=(10, 6))
+
+# Set up the plot limits and labels
+ax.set_ylabel(r"Desorption flux (m$^{-2}$ s$^{-1}$)")
+ax.set_xlabel(r"Temperature (K)")
+
+# Plot experimental data in blue (always visible)
+ax.plot(ref[:, 0], ref[:, 1], linewidth=2, label="Experimental data", color="blue")
+
+# Initialize empty line objects for the animation
+line_current, = ax.plot([], [], color="red", linewidth=2, label="Current iteration", zorder=1000)
+lines_previous = []
+
+def animate(frame):
+ # Clear previous iteration lines
+ for line in lines_previous:
+ line.remove()
+ lines_previous.clear()
+
+ # Plot all previous iterations in light grey
+ for i in range(frame):
+ T_iter = temperature(all_ts[i])
+ line_prev, = ax.plot(T_iter, all_fluxes[i], color="lightgrey", linewidth=0.8, alpha=0.6)
+ lines_previous.append(line_prev)
+
+ # Plot current iteration in red
+ if frame < len(all_ts):
+ T_current = temperature(all_ts[frame])
+ line_current.set_data(T_current, all_fluxes[frame])
+
+ # Update legend and title
+ ax.set_title(f"TDS Fitting Animation - Iteration {frame + 1}/{len(all_ts)}")
+ ax.legend()
+
+ # Set consistent axis limits
+ all_temps = [temperature(ts) for ts in all_ts]
+ all_temp_vals = np.concatenate(all_temps + [ref[:, 0]])
+ all_flux_vals = np.concatenate(all_fluxes + [ref[:, 1]])
+
+ ax.set_xlim(all_temp_vals.min() * 0.95, all_temp_vals.max() * 1.05)
+ ax.set_ylim(0, all_flux_vals.max() * 1.1)
+
+ return [line_current] + lines_previous
+
+# Create animation
+anim = animation.FuncAnimation(
+ fig, animate, frames=len(all_ts), interval=100, blit=False, repeat=True
+)
+
+# Close the figure to prevent static display
+plt.close(fig)
+
+# Display only the animation
+HTML(anim.to_jshtml())
+
+# Uncomment to save as gif
+# anim.save('tds_fitting_animation.gif', writer='pillow', fps=10)
+```
+
+Additionally, we can visualise how the parameters and the computed error varied during the optimisation process.
+
+```{code-cell} ipython3
+plt.ion()
+plt.scatter(
+ np.array(prms)[:, 0], np.array(prms)[:, 1], c=np.array(errors), cmap="viridis"
+)
+plt.plot(np.array(prms)[:, 0], np.array(prms)[:, 1], color="tab:grey", lw=0.5)
+
+plt.scatter(*reference_prms, c="tab:red")
+plt.annotate(
+ "Reference",
+ xy=reference_prms,
+ xytext=(reference_prms[0] - 0.003, reference_prms[1] + 0.1),
+ arrowprops=dict(facecolor="black", arrowstyle="-|>"),
+)
+plt.annotate(
+ "Initial guess",
+ xy=initial_guess,
+ xytext=(initial_guess[0] - 0.004, initial_guess[1] + 0.05),
+ arrowprops=dict(facecolor="black", arrowstyle="-|>"),
+)
+
+plt.xlabel(r"Trap 1 concentration (at. fr.)")
+plt.ylabel(r"Detrapping barrier (eV)")
+plt.show()
+```
diff --git a/book/content/applications/material_science/index.md b/book/content/applications/material_science/index.md
new file mode 100644
index 00000000..ed725bfb
--- /dev/null
+++ b/book/content/applications/material_science/index.md
@@ -0,0 +1,15 @@
+---
+jupytext:
+ formats: ipynb,md:myst
+ text_representation:
+ extension: .md
+ format_name: myst
+ format_version: 0.13
+ jupytext_version: 1.18.1
+---
+
+# Material Science #
+
+Modeling fusion components with FESTIM
+
++++
diff --git a/book/content/applications/microstructure.md b/book/content/applications/material_science/microstructure.md
similarity index 99%
rename from book/content/applications/microstructure.md
rename to book/content/applications/material_science/microstructure.md
index 1de03704..9ddb2f68 100644
--- a/book/content/applications/microstructure.md
+++ b/book/content/applications/material_science/microstructure.md
@@ -5,7 +5,7 @@ jupytext:
extension: .md
format_name: myst
format_version: 0.13
- jupytext_version: 1.17.3
+ jupytext_version: 1.18.1
kernelspec:
display_name: festim-workshop
language: python
@@ -51,7 +51,7 @@ plt.show()
```
Now that we have vertices for each Voronoi cell, we can use `shapely` to turn them into `shapely.Polygon` objects for easy manipulation.
-We then shrink the Voronoi cells to make grain boundaries appear. Note that the grain boundary thickness is arbitrary here.
+We then shrink the Voronoi cells to make grain boundaries appear. Note that the grain boundary thickness is arbitrary here.
```{code-cell} ipython3
from shapely.geometry import Polygon
@@ -102,7 +102,7 @@ plt.show()
### Mesh with GMSH
-We can now pass this geometry to GMSH for meshing. We tag the grains, grain boundaries, and the left and right surfaces as different subdomains.
+We can now pass this geometry to GMSH for meshing. We tag the grains, grain boundaries, and the left and right surfaces as different subdomains.
```{code-cell} ipython3
:tags: [hide-output]
diff --git a/book/content/applications/material_science/tds.md b/book/content/applications/material_science/tds.md
new file mode 100644
index 00000000..ff11594a
--- /dev/null
+++ b/book/content/applications/material_science/tds.md
@@ -0,0 +1,325 @@
+---
+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
+---
+
+# TDS simulation
+
+Thermo-desorption spectra (TDS) are a valuble source of experimental data for understanding the mechanics of hydorgen transport. The nature of the spectra produced by thermo-desorption experiments can give insight to the trapping properties of a given material. There are three stages in a TDS experiment; The implantation stage, the resting stage and the desoption stage. Each stage can be modelled, and the desportion flux spectra reproduced.
+
+In this task, we'll simulate a thermo-desorption experiment for a sample of tungsten.
+
+```{code-cell} ipython3
+import festim as F
+
+my_model = F.HydrogenTransportProblem()
+```
+
+Let's create a mesh from a list of vertices with more refinement close to $x=0$.
+
+```{code-cell} ipython3
+import numpy as np
+
+vertices = np.concatenate(
+ [
+ np.linspace(0, 30e-9, num=200),
+ np.linspace(30e-9, 3e-6, num=300),
+ np.linspace(3e-6, 20e-6, num=200),
+ ]
+)
+
+my_model.mesh = F.Mesh1D(vertices)
+```
+
+The material we want to simulate is tungsten. The only property we need is the diffusion coefficient.
+
+```{code-cell} ipython3
+tungsten = F.Material(
+ D_0=4.1e-07, # m2/s
+ E_D=0.39, # eV
+)
+
+volume_subdomain = F.VolumeSubdomain1D(id=1, borders=[0, 20e-6], material=tungsten)
+left_boundary = F.SurfaceSubdomain1D(id=1, x=0)
+right_boundary = F.SurfaceSubdomain1D(id=2, x=20e-6)
+
+my_model.subdomains = [
+ volume_subdomain,
+ left_boundary,
+ right_boundary,
+]
+```
+
+```{code-cell} ipython3
+w_atom_density = 6.3e28 # atom/m3
+
+H = F.Species("H")
+trapped_H1 = F.Species("trapped_H1", mobile=False)
+trapped_H2 = F.Species("trapped_H2", mobile=False)
+empty_trap1 = F.ImplicitSpecies(n=1.3e-3 * w_atom_density, others=[trapped_H1])
+empty_trap2 = F.ImplicitSpecies(n=4e-4 * w_atom_density, others=[trapped_H2])
+my_model.species = [H, trapped_H1, trapped_H2]
+
+trapping_reaction_1 = F.Reaction(
+ reactant=[H, empty_trap1],
+ product=[trapped_H1],
+ k_0=4.1e-7 / (1.1e-10**2 * 6 * w_atom_density),
+ E_k=0.39,
+ p_0=1e13,
+ E_p=0.87,
+ volume=volume_subdomain,
+)
+trapping_reaction_2 = F.Reaction(
+ reactant=[H, empty_trap2],
+ product=[trapped_H2],
+ k_0=4.1e-7 / (1.1e-10**2 * 6 * w_atom_density),
+ E_k=0.39,
+ p_0=1e13,
+ E_p=1.0,
+ volume=volume_subdomain,
+)
+
+my_model.reactions = [
+ trapping_reaction_1,
+ trapping_reaction_2,
+]
+```
+
+The source term is defined as:
+\begin{equation}
+ S_{ext} = \varphi \cdot f(x) \quad \forall \, t<400 \text{s}
+\end{equation}
+
+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}$.
+
+FESTIM has a special class for this case: `ImplantationFlux`.
+
+The ion flux is temporally defined using a Sympy Piecewise expression, to be active for the `implantation_time`.
+
+Below, `t` is a built-in FESTIM variable that represent time in $\text{s}$.
+
+```{code-cell} ipython3
+import ufl
+
+implantation_time = 400 # s
+incident_flux = 2.5e19 # H/m2/s
+
+def ion_flux(t):
+ return ufl.conditional(t <= implantation_time, incident_flux, 0)
+
+
+def gaussian_distribution(x, center, width):
+ return (
+ 1
+ / (width * (2 * ufl.pi) ** 0.5)
+ * ufl.exp(-0.5 * ((x[0] - center) / width) ** 2)
+ )
+
+
+source_term = F.ParticleSource(
+ value=lambda x, t: ion_flux(t) * gaussian_distribution(x, 4.5e-9, 2.5e-9),
+ volume=volume_subdomain,
+ species=H,
+)
+
+my_model.sources = [source_term]
+```
+
+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$).
+
+In this case, the solute concentration is set to zero on the left and right surface.
+
+```{code-cell} ipython3
+my_model.boundary_conditions = [
+ F.FixedConcentrationBC(subdomain=left_boundary, value=0, species=H),
+ F.FixedConcentrationBC(subdomain=right_boundary, value=0, species=H),
+]
+```
+
+In this example, the temperature is constant from $t=0$ to $t=450 \text{s}$ (implantation + resting phase), then increases from $t=450 \text{s}$ to $t=500 \text{s}$ in order to perform the thermo-desorption (TDS phase).
+
+\begin{equation}
+ T(t) =
+ \begin{cases}
+ 300, & \text{if} \: t < 450 \\
+ 300 + 8(t - 450), & \text{else} \\
+ \end{cases}
+\end{equation}
+
+$T$ is expressed in $\text{K}$.
+
+```{code-cell} ipython3
+implantation_temp = 300 # K
+temperature_ramp = 8 # K/s
+
+start_tds = implantation_time + 50 # s
+
+
+def temp_fun(t):
+ if t <= start_tds:
+ return implantation_temp
+ else:
+ return implantation_temp + temperature_ramp * (t - start_tds)
+
+
+my_model.temperature = temp_fun
+```
+
+```{code-cell} ipython3
+my_model.settings = F.Settings(atol=1e10, rtol=1e-10, final_time=500)
+```
+
+```{code-cell} ipython3
+my_model.settings.stepsize = F.Stepsize(
+ initial_value=0.5,
+ growth_factor=1.1,
+ cutback_factor=0.9,
+ target_nb_iterations=4,
+ max_stepsize=lambda t: 0.5 if t > start_tds else None,
+ milestones=[implantation_time, start_tds, start_tds + 50],
+)
+```
+
+The `Stepsize` object defines the simulation stepsize.
+
+The argument `initial_value` is the initial stepsize is expressed in $\text{s}$.
+
+An adaptive stepsize algorithm has been implemented in order to save computational cost.
+`growth_factor` and `cutback_factor` define by how much the stepsize is increased or decreased after each iteration (depending on the number of Newton iterations required to converged).
+
+The optional argument `max_stepsize` sets the maximum stepsize. It takes a function of time. In this case, we cap the stepsize at 0.5 s after the start of the TDS.
+We also set `milestones` in order to make sure the simulation doesn't over step the end of the implantation and the start of the TDS.
+
++++
+
+We want to plot the evolution of the surface fluxes as a function of time.
+
+To do so, we'll use 'derived quantities' objects.
+There is a wide range of derived quantities available in FESTIM.
+
+Here, we'll use `TotalVolume` (volume integration) and `HydrogenFlux`.
+
+```{code-cell} ipython3
+left_flux = F.SurfaceFlux(surface=left_boundary, field=H)
+right_flux = F.SurfaceFlux(surface=right_boundary, field=H)
+total_mobile_H = F.TotalVolume(field=H, volume=volume_subdomain)
+total_trapped_H1 = F.TotalVolume(field=trapped_H1, volume=volume_subdomain)
+total_trapped_H2 = F.TotalVolume(field=trapped_H2, volume=volume_subdomain)
+
+profile_exports = [
+ F.Profile1DExport(
+ field=spe,
+ times=[implantation_time, start_tds, start_tds + 50],
+ )
+ for spe in [H, trapped_H1, trapped_H2]
+]
+
+my_model.exports = [
+ total_mobile_H,
+ total_trapped_H1,
+ total_trapped_H2,
+ left_flux,
+ right_flux,
+] + profile_exports
+```
+
+```{code-cell} ipython3
+my_model.initialise()
+my_model.run()
+```
+
+```{code-cell} ipython3
+:tags: [hide-input]
+
+import matplotlib.pyplot as plt
+
+time_labels = ["After implantation", "Start of TDS", "50 s after TDS start"]
+
+fig, axs = plt.subplots(3, 3, sharex=True, sharey="row", figsize=(12, 8))
+for i, profile in enumerate(profile_exports):
+ axs[i, 0].set_ylabel(profile.field.name)
+ for j, time in enumerate(profile.times):
+ axs[0, j].set_title(time_labels[j])
+ plt.sca(axs[i, j])
+ plt.plot(profile.x, profile.data[j])
+ plt.fill_between(
+ profile.x,
+ profile.data[j],
+ alpha=0.2,
+ )
+
+for ax in axs.flat:
+ ax.spines["top"].set_visible(False)
+ ax.spines["right"].set_visible(False)
+ ax.set_ylim(bottom=0)
+plt.xlim(0, 3.5e-6)
+axs[2, 0].set_xlabel("Position (m)")
+plt.show()
+```
+
+```{code-cell} ipython3
+t = left_flux.t
+flux_total = np.array(left_flux.data) + np.array(right_flux.data)
+
+plt.plot(t, flux_total, linewidth=3)
+
+plt.ylabel(r"Desorption flux (m$^{-2}$ s$^{-1}$)")
+plt.xlabel(r"Time (s)")
+plt.show()
+```
+
+Make use of numpy to compute the time derivative of the traps inventories!
+
+```{code-cell} ipython3
+contribution_trap_1 = -np.diff(total_trapped_H1.data) / np.diff(t)
+contribution_trap_2 = -np.diff(total_trapped_H2.data) / np.diff(t)
+```
+
+We can now plot the TDS spectrum with the 3 traps contributions
+
+```{code-cell} ipython3
+plt.plot(t, flux_total, linewidth=3)
+plt.plot(t[1:], contribution_trap_1, linestyle="--", color="grey")
+plt.fill_between(t[1:], 0, contribution_trap_1, facecolor="grey", alpha=0.1)
+plt.plot(t[1:], contribution_trap_2, linestyle="--", color="grey")
+plt.fill_between(t[1:], 0, contribution_trap_2, facecolor="grey", alpha=0.1)
+
+plt.xlim(450, 500)
+plt.ylim(bottom=-1.25e18, top=0.6e19)
+plt.ylabel(r"Desorption flux (m$^{-2}$ s$^{-1}$)")
+plt.xlabel(r"Time (s)")
+
+plt.ylabel(r"Desorption flux (m$^{-2}$ s$^{-1}$)")
+plt.xlabel(r"Time (s)")
+```
+
+## Task
+1) Increase the implantation temperature to 500 K and see how the TDS spectrum is affected
+2) Vary the detrapping energy of the first trap
+3) At the end of the implantation phase, what is the proportion of hydrogen trapped in trap 2?
+
+```{code-cell} ipython3
+:tags: [hide-cell]
+
+plt.stackplot(
+ t,
+ total_trapped_H1.data,
+ total_trapped_H2.data,
+ total_mobile_H.data,
+ labels=["trapped H1", "trapped H2", "mobile H"],
+ alpha=0.5,
+)
+plt.legend(reverse=True)
+plt.ylabel(r"Inventory (m$^{-2}$)")
+plt.xlabel(r"Time (s)")
+plt.show()
+```
diff --git a/book/content/applications/task01.ipynb b/book/content/applications/task01.ipynb
deleted file mode 100644
index 4ab34e11..00000000
--- a/book/content/applications/task01.ipynb
+++ /dev/null
@@ -1,479 +0,0 @@
-{
- "cells": [
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "(simple-simulation)=\n",
- "# Simple simulation\n",
- "\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:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "2.0a2\n"
- ]
- }
- ],
- "source": [
- "import festim as F\n",
- "\n",
- "print(F.__version__)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Every FESTIM model is represented by a `Simulation` object. Here, we give it the name `my_model`"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {},
- "outputs": [],
- "source": [
- "my_model = F.HydrogenTransportProblem()"
- ]
- },
- {
- "attachments": {},
- "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",
- "\n",
- "The most straightforward mesh is `MeshFromVertices`, 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`."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [],
- "source": [
- "import numpy as np\n",
- "\n",
- "my_model.mesh = F.Mesh1D(vertices=np.linspace(0, 7e-6, 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",
- "```"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 2. Materials\n",
- "\n",
- "`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",
- "$$\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",
- "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",
- "```"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {},
- "outputs": [],
- "source": [
- "mat = F.Material(D_0=1e-7, E_D=0.2)\n",
- "\n",
- "volume_subdomain = F.VolumeSubdomain1D(id=1, borders=[0, 7e-6], material=mat)\n",
- "boundary_left = F.SurfaceSubdomain1D(id=1, x=0)\n",
- "boundary_right = F.SurfaceSubdomain1D(id=2, x=7e-6)\n",
- "my_model.subdomains = [volume_subdomain, boundary_left, boundary_right]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {},
- "outputs": [],
- "source": [
- "H = F.Species(\"H\")\n",
- "my_model.species = [H]"
- ]
- },
- {
- "attachments": {},
- "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 `sympy` expression like `500 + 3*sympy.exp(-F.x)`.\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",
- "```"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {},
- "outputs": [],
- "source": [
- "my_model.temperature = 300"
- ]
- },
- {
- "attachments": {},
- "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",
- "\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 with ``1e15*F.x + F.t``\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."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "metadata": {},
- "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)]"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 5. Settings\n",
- "\n",
- "With `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",
- "\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",
- "```"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "metadata": {},
- "outputs": [],
- "source": [
- "my_model.settings = F.Settings(atol=1e10, rtol=1e-10, final_time=2) # s"
- ]
- },
- {
- "attachments": {},
- "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",
- "\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",
- "```"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "metadata": {},
- "outputs": [],
- "source": [
- "my_model.settings.stepsize = F.Stepsize(0.05, milestones=[0.1, 0.2, 0.5, 1]) # s"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 6. 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"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "metadata": {},
- "outputs": [],
- "source": [
- "class ProfileExport(F.VolumeQuantity):\n",
- "\n",
- " def compute(self):\n",
- " profile = self.field.solution.x.array[:].copy()\n",
- "\n",
- " self.data.append(profile)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "profile = ProfileExport(field=H, volume=volume_subdomain)\n",
- "\n",
- "my_model.exports = [\n",
- " F.XDMFExport(\n",
- " field=H,\n",
- " filename=\"task01/hydrogen_concentration.xdmf\",\n",
- " ),\n",
- " profile,\n",
- "]"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 8. Run\n",
- "\n",
- "Finally, we initialise the model and run it!"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 13,
- "metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "Solving HydrogenTransportProblem: 100%|██████████| 2.00/2.00 [00:00<00:00, 12.2it/s]\n"
- ]
- }
- ],
- "source": [
- "my_model.initialise()\n",
- "\n",
- "my_model.run()"
- ]
- },
- {
- "attachments": {},
- "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",
- "\n",
- "The profile exported as a text file can now be plotted with matplotlib:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 14,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "image/png": "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",
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "import matplotlib.pyplot as plt\n",
- "import numpy as np\n",
- "\n",
- "x = my_model.mesh.mesh.geometry.x[:, 0]\n",
- "\n",
- "for t in [0.1, 0.2, 0.5, 1]:\n",
- " idx = np.where(np.isclose(profile.t, t))[0][0]\n",
- " data = profile.data[idx]\n",
- " plt.plot(x, data, label=f\"{t} s\")\n",
- "\n",
- "plt.xlabel(\"x (m)\")\n",
- "plt.ylabel(\"Mobile concentration (H/m3)\")\n",
- "plt.legend()\n",
- "plt.show()"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "To solve the steady-state problem, simply set:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 15,
- "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": 16,
- "metadata": {},
- "outputs": [],
- "source": [
- "my_model.initialise()\n",
- "\n",
- "my_model.run()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 17,
- "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, label=f\"{t} s\")\n",
- "plt.xlabel(\"x (m)\")\n",
- "plt.ylabel(\"Mobile concentration (H/m3)\")\n",
- "plt.show()"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "festim-workshop",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.13.5"
- },
- "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/book/content/applications/task02.ipynb b/book/content/applications/task02.ipynb
deleted file mode 100644
index 42263575..00000000
--- a/book/content/applications/task02.ipynb
+++ /dev/null
@@ -1,555 +0,0 @@
-{
- "cells": [
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# TDS simulation\n",
- "\n",
- "Thermo-desorption spectra (TDS) are a valuble source of experimental data for understanding the mechanics of hydorgen transport. The nature of the spectra produced by thermo-desorption experiments can give insight to the trapping properties of a given material. There are three stages in a TDS experiment; The implantation stage, the resting stage and the desoption stage. Each stage can be modelled, and the desportion flux spectra reproduced.\n",
- "\n",
- "In this task, we'll simulate a thermo-desorption experiment for a sample of tungsten."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [],
- "source": [
- "import festim as F\n",
- "\n",
- "my_model = F.HydrogenTransportProblem()"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Let's create a mesh from a list of vertices with more refinement close to $x=0$."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {},
- "outputs": [],
- "source": [
- "import numpy as np\n",
- "\n",
- "vertices = np.concatenate(\n",
- " [\n",
- " np.linspace(0, 30e-9, num=200),\n",
- " np.linspace(30e-9, 3e-6, num=300),\n",
- " np.linspace(3e-6, 20e-6, num=200),\n",
- " ]\n",
- ")\n",
- "\n",
- "my_model.mesh = F.Mesh1D(vertices)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The material we want to simulate is tungsten. The only property we need is the diffusion coefficient."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [],
- "source": [
- "tungsten = F.Material(\n",
- " D_0=4.1e-07, # m2/s\n",
- " E_D=0.39, # eV\n",
- ")\n",
- "\n",
- "volume_subdomain = F.VolumeSubdomain1D(id=1, borders=[0, 20e-6], material=tungsten)\n",
- "left_boundary = F.SurfaceSubdomain1D(id=1, x=0)\n",
- "right_boundary = F.SurfaceSubdomain1D(id=2, x=20e-6)\n",
- "\n",
- "my_model.subdomains = [\n",
- " volume_subdomain,\n",
- " left_boundary,\n",
- " right_boundary,\n",
- "]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [],
- "source": [
- "w_atom_density = 6.3e28 # atom/m3\n",
- "\n",
- "H = F.Species(\"H\")\n",
- "trapped_H1 = F.Species(\"trapped_H1\", mobile=False)\n",
- "trapped_H2 = F.Species(\"trapped_H2\", mobile=False)\n",
- "empty_trap1 = F.ImplicitSpecies(n=1.3e-3 * w_atom_density, others=[trapped_H1])\n",
- "empty_trap2 = F.ImplicitSpecies(n=4e-4 * w_atom_density, others=[trapped_H2])\n",
- "my_model.species = [H, trapped_H1, trapped_H2]\n",
- "\n",
- "trapping_reaction_1 = F.Reaction(\n",
- " reactant=[H, empty_trap1],\n",
- " product=[trapped_H1],\n",
- " k_0=4.1e-7 / (1.1e-10**2 * 6 * w_atom_density),\n",
- " E_k=0.39,\n",
- " p_0=1e13,\n",
- " E_p=0.87,\n",
- " volume=volume_subdomain,\n",
- ")\n",
- "trapping_reaction_2 = F.Reaction(\n",
- " reactant=[H, empty_trap2],\n",
- " product=[trapped_H2],\n",
- " k_0=4.1e-7 / (1.1e-10**2 * 6 * w_atom_density),\n",
- " E_k=0.39,\n",
- " p_0=1e13,\n",
- " E_p=1.0,\n",
- " volume=volume_subdomain,\n",
- ")\n",
- "\n",
- "my_model.reactions = [\n",
- " trapping_reaction_1,\n",
- " trapping_reaction_2,\n",
- "]"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The source term is defined as:\n",
- "\\begin{equation}\n",
- " S_{ext} = \\varphi \\cdot f(x) \\quad \\forall \\, t<400 \\text{s}\n",
- "\\end{equation}\n",
- "\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",
- "\n",
- "The ion flux is temporally defined using a Sympy Piecewise expression, to be active for the `implantation_time`.\n",
- "\n",
- "Below, `t` is a built-in FESTIM variable that represent time in $\\text{s}$."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {},
- "outputs": [],
- "source": [
- "import ufl\n",
- "\n",
- "implantation_time = 400 # s\n",
- "incident_flux = 2.5e19 # H/m2/s\n",
- "\n",
- "def ion_flux(t):\n",
- " return ufl.conditional(t <= implantation_time, incident_flux, 0)\n",
- "\n",
- "\n",
- "def gaussian_distribution(x, center, width):\n",
- " return (\n",
- " 1\n",
- " / (width * (2 * ufl.pi) ** 0.5)\n",
- " * ufl.exp(-0.5 * ((x[0] - center) / width) ** 2)\n",
- " )\n",
- "\n",
- "\n",
- "source_term = F.ParticleSource(\n",
- " value=lambda x, t: ion_flux(t) * gaussian_distribution(x, 4.5e-9, 2.5e-9),\n",
- " volume=volume_subdomain,\n",
- " species=H,\n",
- ")\n",
- "\n",
- "my_model.sources = [source_term]"
- ]
- },
- {
- "attachments": {},
- "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",
- "\n",
- "In this case, the solute concentration is set to zero on the left and right surface."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {},
- "outputs": [],
- "source": [
- "my_model.boundary_conditions = [\n",
- " F.FixedConcentrationBC(subdomain=left_boundary, value=0, species=H),\n",
- " F.FixedConcentrationBC(subdomain=right_boundary, value=0, species=H),\n",
- "]"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "In this example, the temperature is constant from $t=0$ to $t=450 \\text{s}$ (implantation + resting phase), then increases from $t=450 \\text{s}$ to $t=500 \\text{s}$ in order to perform the thermo-desorption (TDS phase).\n",
- "\n",
- "\\begin{equation}\n",
- " T(t) =\n",
- " \\begin{cases}\n",
- " 300, & \\text{if} \\: t < 450 \\\\\n",
- " 300 + 8(t - 450), & \\text{else} \\\\\n",
- " \\end{cases}\n",
- "\\end{equation}\n",
- "\n",
- "$T$ is expressed in $\\text{K}$."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {},
- "outputs": [],
- "source": [
- "implantation_temp = 300 # K\n",
- "temperature_ramp = 8 # K/s\n",
- "\n",
- "start_tds = implantation_time + 50 # s\n",
- "\n",
- "\n",
- "def temp_fun(t):\n",
- " if t <= start_tds:\n",
- " return implantation_temp\n",
- " else:\n",
- " return implantation_temp + temperature_ramp * (t - start_tds)\n",
- "\n",
- "\n",
- "my_model.temperature = temp_fun"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "metadata": {},
- "outputs": [],
- "source": [
- "my_model.settings = F.Settings(atol=1e10, rtol=1e-10, final_time=500)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "metadata": {},
- "outputs": [],
- "source": [
- "my_model.settings.stepsize = F.Stepsize(\n",
- " initial_value=0.5,\n",
- " growth_factor=1.1,\n",
- " cutback_factor=0.9,\n",
- " target_nb_iterations=4,\n",
- " max_stepsize=lambda t: 0.5 if t > start_tds else None,\n",
- " milestones=[implantation_time, start_tds, start_tds + 50],\n",
- ")"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The `Stepsize` object defines the simulation stepsize.\n",
- "\n",
- "The argument `initial_value` is the initial stepsize is expressed in $\\text{s}$.\n",
- "\n",
- "An adaptive stepsize algorithm has been implemented in order to save computational cost.\n",
- "`growth_factor` and `cutback_factor` define by how much the stepsize is increased or decreased after each iteration (depending on the number of Newton iterations required to converged).\n",
- "\n",
- "The optional argument `max_stepsize` sets the maximum stepsize. It takes a function of time. In this case, we cap the stepsize at 0.5 s after the start of the TDS.\n",
- "We also set `milestones` in order to make sure the simulation doesn't over step the end of the implantation and the start of the TDS."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We want to plot the evolution of the surface fluxes as a function of time.\n",
- "\n",
- "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`."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "metadata": {},
- "outputs": [],
- "source": [
- "left_flux = F.SurfaceFlux(surface=left_boundary, field=H)\n",
- "right_flux = F.SurfaceFlux(surface=right_boundary, field=H)\n",
- "total_mobile_H = F.TotalVolume(field=H, volume=volume_subdomain)\n",
- "total_trapped_H1 = F.TotalVolume(field=trapped_H1, volume=volume_subdomain)\n",
- "total_trapped_H2 = F.TotalVolume(field=trapped_H2, volume=volume_subdomain)\n",
- "\n",
- "profile_exports = [\n",
- " F.Profile1DExport(\n",
- " field=spe,\n",
- " times=[implantation_time, start_tds, start_tds + 50],\n",
- " )\n",
- " for spe in [H, trapped_H1, trapped_H2]\n",
- "]\n",
- "\n",
- "my_model.exports = [\n",
- " total_mobile_H,\n",
- " total_trapped_H1,\n",
- " total_trapped_H2,\n",
- " left_flux,\n",
- " right_flux,\n",
- "] + profile_exports"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "2d350a2ef7e64d9b8ea89c131b50dbae",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Solving HydrogenTransportProblem: 0%| | 0.00/500 [00:00"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "import matplotlib.pyplot as plt\n",
- "\n",
- "time_labels = [\"After implantation\", \"Start of TDS\", \"50 s after TDS start\"]\n",
- "\n",
- "fig, axs = plt.subplots(3, 3, sharex=True, sharey=\"row\", figsize=(12, 8))\n",
- "for i, profile in enumerate(profile_exports):\n",
- " axs[i, 0].set_ylabel(profile.field.name)\n",
- " for j, time in enumerate(profile.times):\n",
- " axs[0, j].set_title(time_labels[j])\n",
- " plt.sca(axs[i, j])\n",
- " plt.plot(profile.x, profile.data[j])\n",
- " plt.fill_between(\n",
- " profile.x,\n",
- " profile.data[j],\n",
- " alpha=0.2,\n",
- " )\n",
- "\n",
- "for ax in axs.flat:\n",
- " ax.spines[\"top\"].set_visible(False)\n",
- " ax.spines[\"right\"].set_visible(False)\n",
- " ax.set_ylim(bottom=0)\n",
- "plt.xlim(0, 3.5e-6)\n",
- "axs[2, 0].set_xlabel(\"Position (m)\")\n",
- "plt.show()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 13,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "image/png": "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",
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "t = left_flux.t\n",
- "flux_total = np.array(left_flux.data) + np.array(right_flux.data)\n",
- "\n",
- "plt.plot(t, flux_total, linewidth=3)\n",
- "\n",
- "plt.ylabel(r\"Desorption flux (m$^{-2}$ s$^{-1}$)\")\n",
- "plt.xlabel(r\"Time (s)\")\n",
- "plt.show()"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Make use of numpy to compute the time derivative of the traps inventories!"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 14,
- "metadata": {},
- "outputs": [],
- "source": [
- "contribution_trap_1 = -np.diff(total_trapped_H1.data) / np.diff(t)\n",
- "contribution_trap_2 = -np.diff(total_trapped_H2.data) / np.diff(t)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We can now plot the TDS spectrum with the 3 traps contributions"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 15,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "Text(0.5, 0, 'Time (s)')"
- ]
- },
- "execution_count": 15,
- "metadata": {},
- "output_type": "execute_result"
- },
- {
- "data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkoAAAHACAYAAABd4Ee6AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAm4hJREFUeJzs3Xd8VHXWP/DPnZreeyEJCQmkQSChd6QpTaWISFPQtayFx8dd97frrvu4us3uioJIUwTp64r03gkhvZPe+0wm02fu749sBoYkpMxkWs779ZqXcufeOwcIM2e+5RyGZVkWhBBCCCGkE465AyCEEEIIsVSUKBFCCCGEdIMSJUIIIYSQblCiRAghhBDSDUqUCCGEEEK6QYkSIYQQQkg3KFEihBBCCOkGJUqEEEIIId2gRIkQQgghpBuUKBFCCCGEdIMSpS5cvHgRCxcuREBAABiGwZEjR/p0vVwux7p16xAXFwcej4clS5Z0ed7333+PkSNHwsHBAf7+/li/fj0aGxsN/w0QQgghxCgoUepCW1sbRo4ciS+++KJf12s0Gtjb2+PVV1/FI4880uU5ly9fxpo1a/Dcc88hKysL+/fvx61bt7BhwwZDQieEEEKIEVGi1IX58+fjvffewxNPPNHl80qlEm+99RYCAwPh6OiIcePG4fz587rnHR0dsXnzZmzcuBF+fn5d3uP69esIDQ3Fq6++irCwMEyePBkvvPACkpOTB+K3RAghhJB+oESpH9avX48rV65g7969SE9Px7JlyzBv3jwUFBT0+h4TJ05ERUUFjh07BpZlUVtbiwMHDuCxxx4bwMgJIYQQ0heUKPXR3bt38cMPP2D//v2YMmUKwsPD8eabb2Ly5MnYvn17r+8zceJEfP/991ixYgUEAgH8/Pzg5uaGzz//fACjJ4QQQkhfUKLURykpKWBZFpGRkXByctI9Lly4gLt37/b6PtnZ2Xj11Vfxzjvv4Pbt2zh+/DiKi4vxq1/9agCjJ4QQQkhf8MwdgLXRarXgcrm4ffs2uFyu3nNOTk69vs8HH3yASZMm4X//938BAPHx8XB0dMSUKVPw3nvvwd/f36hxE0IIIaTvKFHqo4SEBGg0GtTV1WHKlCn9vo9UKgWPp//H35F4sSxrUIyEEEIIMQ5KlLogkUhQWFio+3VxcTFSU1Ph4eGByMhIrFq1CmvWrMGHH36IhIQENDQ04OzZs4iLi8Ojjz4KoH1qTalUoqmpCa2trUhNTQUAjBo1CgCwcOFCbNy4EZs3b8bcuXNRXV2N119/HWPHjkVAQICpf8uEEEII6QLD0vBFJ+fPn8eMGTM6HV+7di127NgBlUqF9957D7t27UJlZSU8PT0xYcIEvPvuu4iLiwMAhIaGorS0tNM97v/j/vzzz/HVV1+huLgYbm5umDlzJv72t78hMDBw4H5zhBBCCOk1m0qUKisr8Zvf/Aa//PILZDIZIiMjsW3bNowZM8bcoRFCCCHECtnM1FtzczMmTZqEGTNm4JdffoGPjw/u3r0LNzc3c4dGCCGEECtlMyNKv/3tb3HlyhVcunTJ3KEQQgghxEbYTKIUHR2NuXPnoqKiAhcuXEBgYCBeeuklbNy4scvzFQoFFAqF7tdarRZNTU3w9PQEwzCmCpsQQgghBmBZFq2trQgICACHMwDlIVkbIRQKWaFQyL799ttsSkoK+9VXX7F2dnbszp07uzz/j3/8IwuAHvSgBz3oQQ962MCjvLx8QPILmxlREggESExMxNWrV3XHXn31Vdy6dQvXrl3rdP6DI0oikQhDhgxBeXk5XFxcTBIzIYQQQgwjFosRHByMlpYWuLq6Gv3+NrOY29/fH9HR0XrHRowYgYMHD3Z5vlAohFAo7HTcxcWFEiVCCCHEygzUshmb6fU2adIk5OXl6R3Lz89HSEiImSIihBBCiLWzmUTpjTfewPXr1/H++++jsLAQe/bswZYtW/Dyyy+bOzRCCCGEWCmbSZSSkpJw+PBh/PDDD4iNjcX//d//4ZNPPsGqVavMHRohhBBCrJTNLOY2lFgshqurK0QiEa1RIoQQQqzEQH9+28yIEiGEEEKIsVGiRAghhBDSDUqUCCGEEEK6QYkSIYQQQkg3KFEihBBCCOkGJUqEEEIIId2gRIkQQgghpBuUKBFCCCGEdIMSJUIIIYSQblCiRAghhBDSDUqUCCGEEEK6QYkSIYQQQkg3KFEihBBCCOkGJUqEEEIIId2gRIkQQgghpBs8cwdAyGCQkpKClpYWAADDMOByuRgxYgS8vb3NGxghhJCHokSJkAGmUqmQlpaGsrIyveMXLlzA1KlTMXnyZHC5XDNFRwgh5GEoUSLEyMrLy3H69GksWbIEQqEQGo0GERER8PT0BMuyYFkWzc3NKCsrw/nz51FWVobVq1ebO2xCCCFdoESJECNRKpU4duwY0tLSAABnzpzB3LlzAQCjRo3SO5dlWeTm5uLcuXOIjY0Fy7JgGMbUIRNCCOkBJUqEGIFWq8WBAwdQUFAAAIiNjcXkyZO7PZ9hGIwYMQJhYWEQCoVoa2uDvb09VCoVhEIhJU2EEGIhKFEixEAsy+Knn35CQUEBuFwuHn/8cQwZMqRX19rZ2enukZ+fj+PHj2PSpEkYO3bsQIZMCCGkl6g8ACEGOnfuHFJTU8EwDBYsWNDrJOlBdXV1EIvFOHnyJGpqaowcJSGEkP6gRIkQA6hUKuTl5QEAZs2ahfDw8H7fKyEhAUOHDoVGo8GBAwegVCqNFSYhhJB+okSJEAPweDwsX74c8+bNQ3x8vEH3YhgGc+fOhZOTExobG3Hs2DEjRUkIIaS/KFEipB86tvnLZDIIBAJER0cb5b729vZ49NFHwTAM0tLSdDvoCCGEmAclSoT0kVarxa5du3DhwoUBmR4LCgrChAkTAAA///wzGhoajP4ahBBCeod2vRHSR7du3UJJSQmqqqoQFRUFJycno7/G2LFjUVlZCScnJ3A49H2GEELMhRIlQvpAJBLh7NmzAIApU6YMSJIEABwOB0888QQYhhmw1yCEENIz+qpKSC+xLItjx45BqVQiMDDQ4MXbPekoOkm73wghxHwoUSKkl7Kzs5Gfnw8ul4tHHnnEZNWza2pqcOTIEdTW1prk9QghhNxDiRIhvSCTyfDLL78AaF8/5OnpabLXvnr1KtLS0nDp0iWTvSYhhJB2lCgR0gvl5eWQy+Xw8PBAUlKSSV973LhxAICsrCzaAUcIISZGiRIhvTBs2DCsXr0a8+fPB49n2j0Q3t7euorfly9fNulrE0LIYEeJEiG9oFQq4eHhAV9fX7O8fkeT3PT0dDQ3N5slBkIIGYwoUSLkIWpqalBZWWn2nWf+/v4ICQkBy7K4cuWKWWMhhJDBhBIlQrrBsiyOHz+Ob775Bunp6eYOR7dWKTU1FWKx2MzREELI4EAFJwnpRnFxMUpLS8HlchEWFmbucBAUFISIiAj4+/tDIBCYOxxCCBkUKFEipAssy+LcuXMAgPj4eDg7O5s5onaLFi0Ch8OBnZ2duUMhhJBBgabeCOlCYWEhKioqwOPxdAupLYVWq4VWqzV3GIQQMihQokTIA+4fTRo1ahQcHR3NHJE+tVqNjIwMXL9+3dyhEEKIzbOZROlPf/oTGIbRe/j5+Zk7LGKF8vLyUF1dDT6fb/Likr1RX1+PI0eO4OzZs1AoFOYOhxBCbJrNJEoAEBMTg+rqat0jIyPD3CERK6RWq+Ho6IjRo0fD3t7e3OF04ufnBzc3N6hUKuTk5Jg7HEIIsWk2tZibx+PRKBIxWHR0NAICAsCyrLlD6RLDMIiOjsbVq1eRnp6OUaNGmTskQgixWTY1olRQUICAgACEhYXhqaeeQlFRUbfnKhQKiMVivQchQHsVbj6fb9Fb8EeMGAGgvYQB/ewSQsjAsZlEady4cdi1axdOnDiBrVu3oqamBhMnTkRjY2OX53/wwQdwdXXVPYKDg00cMbE09fX1yM7Otop1P66urggMDAQAiyiGSQghtophLXV+wUBtbW0IDw/HW2+9hU2bNnV6XqFQ6H0gisViBAcHQyQSwcXFxZShEgtx+PBh3VTWzJkzzR1Oj9LT03H69Gl4e3vjxRdfBMMw5g6JEEJMTiwWw9XVdcA+v21mROlBjo6OiIuLQ0FBQZfPC4VCuLi46D3I4NXa2orMzEwA7WuUrEFkZCS4XC74fD7kcrm5wyGEEJtkU4u576dQKJCTk4MpU6aYOxRiBW7dugWtVouAgACr2RBgZ2eH5557Dp6enha9nooQQqyZzYwovfnmm7hw4QKKi4tx48YNLF26FGKxGGvXrjV3aMTCqVQqJCcnAwBGjx5t5mj6xsnJCSqVytxhEEKIzbKZEaWKigqsXLkSDQ0N8Pb2xvjx43H9+nWEhISYOzRi4dLS0iCTyeDi4oKIiAhzh9NnWq0WUqkUKpUKrq6u5g6HEEJsis0kSnv37jV3CMQKsSyLGzduAGgfTeJwrG+QNTMzE2fOnEFcXBwWL15s7nAIIcSmWN+nAiFGJJVKIRQKIRAIEBMTY+5w+sXFxQUajQb5+fkWWySTEEKslc2MKBHSH46OjnjmmWfQ1NQEoVBo7nD6JTAwEAKBAFKpFJWVlQgKCjJ3SIQQYjNoRIkMaizLQqVSwdnZ2dyh9BuXy0VoaCgAID8/37zBEEKIjaFEiQxaZWVlaG1tNXcYRjF06FAAlCgRQoixUaJEBiW1Wo29e/fi888/R319vbnDMVhYWBgYhkFtbS1EIpG5wyGEEJtBiRIZlLKzsyGTyWBvbw9PT09zh2Mwe3t7+Pv7A0C31egJIYT0HS3mJoNSSkoKACA2NtYqSwJ0JSEhASNGjMCwYcPMHQohhNgMSpTIoNPQ0IDS0lIwDIPY2Fhzh2M0UVFRYBgGTk5O5g6FEEJshm18lSakD27fvg2gfQG0Ne926wrLstBoNOYOgxBCbAaNKJFBRa1WIy0tDQAQFxdn5miMTyaTIScnBwzDICkpydzhEEKI1aMRJTKoVFZWQi6Xw8nJSVd7yJbU1NTgl19+wcWLF6lKNyGEGAGNKJFBJSQkBC+99BLq6+ttZhH3/YKDg8Hn8yGRSFBTU6PbCUcIIaR/bO+TgpCHYFkWQqHQZtt88Hg8DBkyBAAVnySEEGOgRIkMGnK5HCqVytxhDDiq0k0IIcZDiRIZFNRqNT7//HPs2bMHbW1t5g5nQHUkSlVVVTbTooUQQsyFEiUyKOTn50MqlaKhoQH29vbmDmdAOTo6wtfXFwBV6SaEEEPRYm4yKHSUBIiOjrbIRdxlTTLcKGlBvUSBpjYVmqQqNLYp0arQwMdJgEgfRwzzccQwb0cM9XKAgPfw30NYWBjq6urQ1NRkot8BIYTYJkqUiM2TSCS6kZWYmBgzR3OPWK7G8ew6/JRRh9QKcbfnFdS14UpRs+7XXAZIDHHDstH+mBnpCT63c9KUkJCAxMREm+hjRwgh5kSJErF5GRkZYFkWfn5+8PDwMHc4SKsUY9eNCpzPb4RS0/daRxoWuFHSghslLfByFODJBD8sTfCDn4ud7pyO6UWtVmuRI2iEEGItKFEiNq9j2s3co0lSpQYfny3G3ttVRrtnQ5sSX18uw9YrZZgzwhubZobB3/VewqTRaMAwDBiGMdprEkLIYEKJErFpNTU1qK2tBZfLRWRkpNniuFbcjD/9nI8qkaLbc9wd+BgV5AJPRz48HATwcOTDUcBFWbMMBXVtKKhrQ2U312tZ4Hh2PS4UNOL5yUOwdlwQ6mqqcfnyZTg7O2PFihUD9VsjhBCbRokSsWkeHh547LHH0NzcbJbdbq1yNT48U4SDqTVdPs/nMpg+zBML43wxOdy9y/VG95Mo1LhQ0IQfU6qQUt55XZNMpcWn50rw7/RavDbODZWVlRAIBDQFRwgh/cSw1BAKACAWi+Hq6gqRSAQXFxdzh0OMqK2tDVqt1uSvW94sw/N7MlDRIu/0nB2PgxemDMGyBH+42vP7df/8ujb8eLsKP2XWQarUdHqeAYs1jungaFV47rnnbLYaOSFkcBvoz2/6iklsmkajMUuSlF/XhjU707pMkhKHuOLgxjHYMHFIv5MkAIj0ccTv5w/DyVfGYvlofzy4CokFgzKVIwDgempOv1+HEEIGM0qUiM06deoUrly5AplMZtLXTa8UY/3uNDS0KfWOOwi4+P28CGx7Jh5DPIw3Dehqz8cf5g/DnvUJiPZz0nuuWtP+7erMrUx8d70UNIBMCCF9Q4kSsUlSqRTXr1/HuXPnIJFITPa6N0qaseH7dIjlar3jw30dcfj5MVgxJgCcAdqBFhvgjD3rE/D7eRFwtmtfflitdQYAeDGt+OORdLy2NxUShfphtyGEEHIfSpSITcrMzIRWq4WPjw+8vb1N8prn8hvx0t5MyFT6U30JQS7Y9sxIBNy3bX+gcDkMVowJwIENoxEf4AwRa4c2lg8ew8KHI8G/06qw6IvLKGmw7X53hBBiLJQoEZt0f8sSU0gua8Gmg9mdCkhOGuqOr5+Og4udaTeYBrjaYceakXhmbBBKNe4o1bhBzbb/cy+qb8PjX15Bcgm1NyGEkJ5QokRsTn19PaqqqsDhcDB8+PABf72KFhk2HcyBWqufJM0e7oXPl8fAns8d8Bi6wudy8JvZ4Vi5aB5uMcNRz95bv9QsVeHprTdwNLXSLLERQoi1oESJ2JyMjAwAQGhoKBwcHAb0tdoUavz6xyw0S1V6x5fE++Ifj4/osS6SKcwa7oV9zyVguJ+z3nGlRovX9qbiszMFtMibEEK6Yf53cUKMiGVZXaI00KNJGi2L3xzJRWG9VO/41AgP/OmxSHA5ltM2JMjNDl8vi8TscMdOz310Kh9v7k+HSmP6MgqEEGLpKFEiNkWhUMDf3x/29vYIDw8f0Nf69HwxLhTqr/OJ8HbA35YMt6gkCQAuXbqEHd98jccDZVgzIaTT8wdTKvDC7tuQqzoXriSEkMGMEiViU+zs7LBkyRI8//zz4PP7X8yxJ/9Or8X2axV6x9zsefhsWQychJbXGcjPzw8AUFJSjHcXxeCdBdF4sErB2dw6rNl2E2K5qos7EELI4ESJErE5KpUKXO7ALaDOr2vDu8fy9Y7xOAw+ejIawe6m7yfXG8HBwQDaF7q3tbXh2clh2LI6EXZ8/beAmyVNeOrr66hv7b55LyGEDCaUKBGb0dDQgLq6ugFtWaJUa/G7o7mdygD8fl4EkkLcBux1DWVvb6+rJ1VcXAwAmB3ti++eG9epdEF2tRjLvrqK8iZpp/sQQshgQ4kSsRkXLlzA5s2bcevWrQF7jS8vlSKvTr9Y49OJAXgywX/AXtNYOkaVSktLdccSQz2w74UJ8HIS6p1b0ijFsq+uoaC21aQxEkKIpaFEidgEhUKB3NxcAPcSAmO7Uy7C9mvlescivB2wadbQAXk9YwsKCgKgnygBwAh/Fxx8cQKCH+g/VyOWY9nX15Ba3mKqEAkhxOJQokRsQm5uLtRqNdzc3ODr62v0+0uVGvzu33m4v6Ykj8Pgr4uHQ8izjn9GgYGBANqnKNva9EfFQjwdceBXExHlq19rqUWqwtNbr+NKYYPJ4iSEEEtiHe/whPSgo3bSiBEjwAxA09l/nL6Liha53rGXp4Ugytepmyssj729PSZPnoxly5ZBIBB0et7XxQ77XhiPhCFueselSg3Wb7+F45k1JoqUEEIsByVKxOpJJBIUFRUBGJgikxcLGnHgjn6SMCrIBevHD8wU30AaO3YswsPDuy2d4OYgwPcbxmHKMC+940qNFi99fxs/3irv8jpCCLFVRkmUVCoVysvLkZeXh6Ym8zfa/OCDD8AwDF5//XVzh0JMICsrCyzLws/PD+7u7ka9t1iuxh9/LtA7Zs/n4P1FURZXVLK3NJqHF5V0EPDwzdpEPBanv0BdywJvHUzH1otFAxkeIYRYlH4nShKJBF9//TWmT58OV1dXhIaGIjo6Gt7e3ggJCcHGjRsHdPdRd27duoUtW7YgPj7e5K9NzCMvLw/AwIwmfXGhBA1tSr1j//tIuMXWS+oJy7IoLi7G+fPnoVB0XytJyOPis5UJWDl2SKfn/nIsB387nkv94Qghg0K/EqWPP/4YoaGh2Lp1K2bOnIlDhw4hNTUVeXl5uHbtGv74xz9CrVZj9uzZmDdvHgoKCnq+qRFIJBKsWrUKW7duNfrIArFcK1euxMKFC42eKOXUSLDvdpXescnh7lia4GfU1zElhmFw6tQpXLhwAeXlD59G43IYvP94LF6c3rkVzObzd/G7wxnQaClZIoTYtn71Wrh69SrOnTuHuLi4Lp8fO3Ysnn32WXz11VfYtm0bLly4gGHDhhkUaG+8/PLLeOyxx/DII4/gvffee+i5CoVC7xu1WCwe6PDIADL2z5eWZfGX44V6u9yEPA7+37yIAVksbkqBgYEQiUQoLS1FRETEQ89lGAa/mTcc7g58vH8sV++5H26WQyxT46MVIyHkDVwldEIIMad+JUr79+/v1XlCoRAvvfRSf16iz/bu3YuUlJReT/d98MEHePfddwc4KjLQWJaFSmX83mRH02uRVqmfPG+YGIwgN+uccrtfUFAQsrOzUVZW1utrnp8aDjd7AX57KF0vefw5oxpiuQpfPTMGjhbY444QQgxlE7veysvL8dprr+G7776DnZ1dr655++23IRKJdI+epiGI5amrq8O//vUvXL161aj3FclU+Phssd6xIe52WD/B+na5daWjnlJlZSXUanWvr1ueFIwvV42BgKv/tnGpoAGrvrmB5gfWchFCiC0wWqJ0+/ZtY92qX69dV1eHMWPGgMfjgcfj4cKFC/jss8/A4/G63OUjFArh4uKi9yDWJTMzE42NjaiurjbqfT8/X4Jmqf4o1dtzI6ymsGRP3Nzc4OjoCI1Gg8rKyj5dOy/WDzvWJ8FRoD/VllreguVfX0ONSN7NlYQQYp2M9s7/+OOPG+tWfTZr1ixkZGQgNTVV90hMTMSqVauQmpo6oJ3kiXmwLIusrCwAQFRUlNHum1Xdih9T9BOvWVGemBzuYbTXMDeGYXSjSg+2M+mNiRFe2LNxPNwd9GsxFdRJ8OTmqyhuaOvmSkIIsT59WlSwfPnyLo+zLGvW+knOzs6IjY3VO+bo6AhPT89Ox4ltqK6uRlNTE3g8HsLDO+/K6g8ty+L944W4fx+XHY+Dt2Yb5/6WJCgoCPn5+aiqqur55C6MDHbD/l9NwOptN1F93yhSZYsMy766ih3rxyI20NVY4RJCiNn0KVE6ffo0du/eDScn/bYNLMvi4sWLRg2MkIfJzMwEAAwdOrTLdhz9cTy7HulVrXrHnp88BAGuvVv3Zk0iIyMRGBiI0NDQft8jwscZB16ciNXf3EDRfaNIDRIlntpyHV89MwaTH6jwTQgh1qZPidL06dPh5OSEadOmdXouISHBaEEZw/nz580dAhkgAzHtplRr8dn5Er1jIR72WDsuyCj3tzQODg5wcHAw+D6BbvbY/6sJWLv9JjLv2yUoUaixbvtN/O3JeDw5xjb/DAkhg0Of1igdOnSoyyQJAI4fP26UgAjpSXl5OcRiMQQCAcLCwoxyzx9TqlH5QNPbN2aGQWAjC7i701M7k97wdBLih43jMX6o/joutZbF/+xPw+dnCqiKNyHEahn0KVBTQ93EienZ2dkhLi4O0dHR4PEMr93TKlfj68v6i5pHBblgZqSnwfe2ZPX19fj3v/+Nn3/+2eB7OdvxsWP92E794QDgw1P5ePtQBtQarcGvQwghpmZQojRnzhxjxUFIr/n4+GDu3LmYOXOmUe63/Vo5WmT69YT+Z1aY1Vfg7olarUZmZqauqbCh7PhcfL4yAc9N7jzKt/dWOTbsSkabovd1mwghxBIYlCjRcDoxB41GA63WOKMTtWIFdt/UryU0M9ITo4Jsf8eWj48PeDweZDIZ6uvrjXJPDofBHxZE450F0XgwzzyfV48VW66hrpVqLRFCrIdBiZKtf+MmlicrKwvl5eVGS9I3XyqFXH0v6eIwwGszjLPuydJxuVwEBAQA6F89pYd5dnIYvnx6dKcinZmVYjzx5VUU1kmM+nqEEDJQbHulKrEpGo0G//nPf7Bz584+V5TuSlGDFIfT9NfZPT7SD0O9DN8NZi06Ck/2pe9bb82P88eejePg9kBhyopmGZ7cfBW3SsxXe40QQnqLEiViNe7evQu5XA5HR0fdSIghPjlXrNfg1Y7HwUtTQwy+rzW5v0L3QEyljwnxwMEXJyLYQ7+ZsEimwqpvbuDndOO2nyGEEGMzKFEyVqE/Qnqjo8hkZGQkOBzDcvz0SjHO5TfqHVs9LhA+zkKD7mtt/P39weFw0NraCpFINCCvEe7thEMvTkL8A+u+lGotXt6Tgs3n79J6R0KIxTLo0yY5OdlYcRDyUCqVCnl5eQCMU2Ry8yX9NTnuDnw8OyHY4PtaGz6fD19fX3h7e0MiGbh1Q97OQux9fjxmDvfp9NzfjufitwczoKLyAYQQC2R4ERpCTKCgoABKpRIuLi7w9+9cq6cv0irFuHy3We/YsxOC4CQcnP8cli9fDnt7ewiFAzua5iDgYcvqMXjn31nYc0N/TdS+5HJUtEjx5aoxcLXnd3MHQggxPYPXKMlkMkilUt2vS0tL8cknn+DkyZOG3poQnY5pt6ioKIN3W26+qD+a5OHIx/LRhq95slZcLtcoFbp7g8fl4C9LYvH2/OGdnrtS2IgnN19FeZO0iysJIcQ8DE6UFi9ejF27dgEAWlpaMG7cOHz44YdYvHgxNm/ebHCAhGi1Wl2Xe0On3VIrxLhS9MBo0vhgOAi4Bt3X2mk0GqhUKpMkTAzD4IVp4di8qnP5gMI6CZb86wpSypq7uZoQQkzL4EQpJSUFU6ZMAQAcOHAAvr6+KC0txa5du/DZZ58ZHCAhHA4HL730EpYvXw5vb2+D7vXVA2uTPB35WD7GsKk8W3DixAn8/e9/R35+vslec36cP/a9MAFeTvpTfo1tSqzcch3HMmhHHCHE/AxOlKRSKZydnQEAJ0+exBNPPAEOh4Px48cbvYgdGby0Wi2CgoIMmnbrcjRpQjDs+YN7NAlon35Tq9UDUk/pYUYFu+HIyxMR6eukd1yh1uKl71Pw5flC2hFHCDErgxOliIgIHDlyBOXl5Thx4oSu/1tdXR1cXFwMDpAMbh3tStRqw3uEPbjTzdORj2WjaTQJGNjCkz0JcnfAgRcnYsowr07P/f14Hu2II4SYlcGJ0jvvvIM333wToaGhGDduHCZMmACgfXQpISHB4ADJ4JaamoqPP/4Yt2/fNuw+FSJcfWA06bmJNJrUoSNRqq6uhlKpNPnru9jx8e26JKwcO6TTc/uSy7Fu+02IZCqTx0UIIQYnSkuXLkVZWRmSk5Nx/Phx3fFZs2bh448/NvT2ZJDLysqCRCIxeETpywd2unk5CrAsgUaTOri4uMDZ2Rksy6KiosIsMfC5HLz/eCx+9+jwTg11aUccIcRcjNLCxM/PDwkJCXrVkseOHYvhwztvASakt1pbW1FcXAzAsN1u6ZViXCtu0Tv23MRg2NFokp7725mYC8MweH5q+444Oz7tiCOEmB/1eiMWKzs7G0B7mw1XV9cezu7eN1fL9X7t7STA0gQ/g2KzRUFBQQDMs07pQfNi/bH3+e53xFGPOEKIqVCiRCxWVlYWAMNGkwrq2jr1dFs7LohGk7oQFBSEoUOHWsxI8MN2xFGPOEKIqVCiRCxSS0sLysvbR4IiIyP7fZ9t1/RHk1zseLTTrRseHh5YsmQJkpKSzB2KzsN2xP3teC7eOZoFjZaSJULIwKFEiVikjtGk4OBgODk59XB218qbZTieVad3bFVSwKCvwt0TU7Uz6a2H7Yjbfb0Uv/ruNmRKy4qZEGI7+pwoyWQyVFZWdjre8cFGiDGEh4djzJgxiIuL6/c9dlyvgOa+wQZ7PgdPJwYaITrb1tzcjJKSEnOHoadjR1xXPeJOZdfi6W+uo6nN9GUNCCG2r0+J0oEDBxAZGYlHH30U8fHxuHHjhu651atXGz04Mnj5+vpi2rRp/V4vU9+qwJG0Gr1jy0b7w82BOtM/TE1NDTZv3owff/zR4tb/dPSI+2xlAgRc/beuO2UteHLzVZQ1UvkAQohx9SlReu+995CSkoK0tDR8++23ePbZZ7Fnzx4AsLg3VWLdDK2btPtmJZT3DSfxuQzWjA0yNCyb5+3tDR6PB5lMhvr6enOH06VFIwOw89mxcLbj6R0vbmjDE5uvIrtKbKbICCG2qE+Jkkql0jUlTUxMxMWLF/H111/jz3/+s0E9uAjpwLIszp49i8LCQmi1/WtbIZKpsC9Ff/v4ojhf+LoIu7mCdOByufD3b1/sbgllArozIdwTB1+ciABXO73jDRIFVnx9DTeKGru5khBC+qZPiZKPjw/S09N1v/b09MSpU6eQk5Ojd5yQ/qqtrcWlS5dw8OBBqFT9a1nxQ3IVpPct7uUw7c1vSe+Ys+9bX0T6OuPQS5Mw3M9Z73irQo01397EqexaM0VGCLElfUqUdu/eDR8fH71jAoEAP/zwAy5cuGDUwMjglJmZCQAICwuDUNj3ESCpUoPvb+lvNpg7whtDPOyNEt9gYAkVunvLz9UOP/5qAsaGeegdV6i1+NV3t7E/ubybKwkhpHf6lCgFBQXBz+9eReOamnuLZSdNmmS8qMigxLKsbvdkfxdxH0mrQYtMf33TcxNpNKkv/P39wTAMxGIxWlpazB1Oj1zs+Nj17Fg8MsJX77hGy+J/D6Rj68UiM0VGCLEFBtVRmjNnjrHiIASVlZVoaWkBn89HWFhYn69Xa1nsuqk/mjQ53B1Rvv2rwzRYCQQC3cixpU+/dbDjc/HVM6OxbEznBft/OZaDT07n04YTQki/8Ho+pXv0xkOMqWPaLTw8HHx+37fxn85tQGWLXO8YrU3qn7Fjx4LL5SIiIsLcofQaj8vB35fGw8NJgK8v6I8ifXK6ADKlBr+dP5w2nhBC+sSgRInecIixaLVag3q7sSyLHdf116PE+DshcUj/m+kOZsOGDQOXy4WDg4O5Q+kThmHw9vwR8HAQ4INfcvWe+/piEaRKDd5dFAMOh967CCG9Qy1MiEUQi8Xg8/kQCoUICQnp8/XJZSJkVUv0jq0bH0zJvAEsrZVJX7wwLRz/tyS20/Hd10vx1sF06g9HCOk1g0aUCDEWNzc3vPDCC2hoaACP1/cfy+3XKvR+Hehmh0eGd26kSnqvpqYGKSkpGDp0KIKDrW8Kc/X4ENjzuXjrQBruz4sO3K6AQq3Fx8tHgsel74qEkIczKFESCATGioMQqNVquLi49Pm6wvo2XLrbpHdszdhA8Gh6xSAZGRnIyMiAQqGwykQJAJaOCYI9n4vX9t6B+r5s6ae0KjAAPqJkiRDSA4PeIZKTk40VBxnE2traoFQq+12Je8d1/dEkV3seloz06+Zs0lvWUniyJ4/F++Pr1WMg4Om/3f07rQr/sz8Nak3/fu4IIYODUabe5HI50tPTUVdX1+nDbtGiRcZ4CWLDTp06hdzcXMycORMjRozo07W1YgV+zqzTO/bUmAA4CLjGDHFQ6kiUqquroVQqrXoEedYIX2xbm4gNO5OhUN97jzqaWgUA+HAZjSwRQrpmcKJ0/PhxrFmzBg0NDZ2eYxjGqheEkoGnVquRm5sLhULRr2m375Mr9aZUhDwOViYGGDPEQcvFxQVOTk6QSCSorKzsV20rSzJlmDe2rknExl1dJ0sfLR8FLk3XEkIeYPBXqFdeeQXLli1DdXU1tFqt3oOSJNKTgoICKBQKODk5ISCgbwlOm0KNA100v/V0tN6RD0vCMIxVtTPpjamR7cnSg9NwR1Or8L/706Cl3XCEkAcYnCjV1dVh06ZN8PX17flkQh5wf+2kvm7lP5xWi1bFvWScAbBmXKAxwxv0OhKl8nLb6Zk2NdIb33SRLB26U4k/HM2kQrqEED0GJ0pLly7F+fPnjRCKYTZv3oz4+Hi4uLjAxcUFEyZMwC+//GLusMhDKJVK5OXlAeh7bzeNlsV3DzS/nR7piVBP6yqQaOk6EqXa2lqbSiC6S5a+v1GG94/l2NTvlRBiGIPXKH3xxRdYtmwZLl26hLi4uE6tJ1599VVDX6JXgoKC8Ne//lXXcmHnzp1YvHgx7ty5g5iYGJPEQPomLy8ParUabm5uut5ivXUuv7FTuxIaTTI+Ly8vPP300wgNDbW54p1TI73x9eoxeH5XMlSae4nR1kvFcBDw8MbsSDNGRwixFAYnSnv27MGJEydgb2+P8+fP672ZMgxjskRp4cKFer/+y1/+gs2bN+P69euUKFkoQ6bddt/ULwkwws8JY4KpXYmxMQwDPz/bLbUwI8oHn69MwMt77uhV6/70TAEcBFy8MC3cjNERQiyBwYnS73//e/z5z3/Gb3/7W3A4lrG9VqPRYP/+/Whra8OECRO6PEehUEChUOh+LRaLTRUe+a9Zs2bB3d29z9NumVWtSCnX//taMy7Q5kY8LIlGo+lXo2JrMC/WH/9cpsGmH9Nw/4zbB7/kwlHIwzPj+95ShxBiOwzObJRKJVasWGERSVJGRgacnJwgFArxq1/9CocPH0Z0dHSX537wwQdwdXXVPay18rA1c3d3x8SJE+Hh4dGn63Y9MJrk4yTA3BHexgyN3Ecmk+HYsWPYtm2bza7deTwhCO910RvuD0czcSyjuosrCCGDhcHZzdq1a7Fv3z5jxGKwqKgopKam4vr163jxxRexdu1aZGdnd3nu22+/DZFIpHvY0q4ea6FWq/t8TY1YjpPZ9XrHViYFgE/FAgeMQCBATk4OKioquqyXZitWjQvB7x/TL3jKssDre1NxpdB2f9+EkIczeOpNo9Hg73//O06cOIH4+PhOw/MfffSRoS/RawKBQLeYOzExEbdu3cKnn36Kr7/+utO5QqEQQqHQZLGRe9ra2vDLL78gIiICQ4cO7dOU2Z7kKty37hb2fA6WJfgPQJSkA5fLhZ+fHyoqKlBaWgpvb9sdvdswZSjEcjU+O1OgO6bUaPH8rmTsfX4C4oJoHRwhg43BiVJGRgYSEhIAAJmZmXrPmXvNCMuyeuuQiGXIzs5GVlYWGhoaEB7e+8WyUqWmc4HJeF+42tvm2hlLEhwcjIqKCpSUlCAxMdHc4QyoNx4ZhqY2Bb67fq/HXZtSg3Xbb+LAixMR5uVoxugIIaZmcKJ07tw5Y8RhsN/97neYP38+goOD0drair179+L8+fM4fvy4uUMjD+hIqPu6iPtIWo1egUkAeCaJSgKYQnBwMK5du4bi4mKwLGv2L0EDiWEYvLsoFs1tKvx83/qkxjYlVm+7gYMvToSvi50ZIySEmJLNLOyora3F6tWrERUVhVmzZuHGjRs4fvw4Zs+ebe7QyH1aWlp03egjI3tfp6bLApPDPKjApIn4+/uDx+NBKpWivr6+5wusHJfD4KMVIzEpwlPveEWzDOu230KrXGWmyAghptavRKnjg663Kisrez7JQNu2bUNJSQkUCgXq6upw+vRpSpIsUMdoUlBQEJydnXt93YWCRpQ36xeYXD02yKixke5xuVxdle7i4mIzR2MaQh4XX69ORFyg/rqknGoxXvo+BSqNtpsrCSG2pF+JUlJSEjZu3IibN292e45IJMLWrVsRGxuLQ4cO9TtAYlsyMjIAACNGjOjhTH27buon28N9HZEUQgtrTSk4OBgeHh7g8QyesbcaTkIedqxP6rQu6VJBA94+lGGz5RIIIff06x0vJycH77//PubNmwc+n4/ExEQEBATAzs4Ozc3NusW6iYmJ+Mc//oH58+cbO25ihWpra1FXVwcul4thw4b1+rqs6lbcLhPpHVszLsim18lYoqSkJIwbNw5OTk7mDsWkPJ2E2LE+CU98eRWNbUrd8QO3KxDoZk+tTgixcf0aUfLw8MA///lPVFVVYfPmzYiMjERDQwMKCtq31K5atQq3b9/GlStXKEkiOnK5HL6+vggLC4OdXe8Xw+5+YDTJ20mAedG2u0XdUjEMA5ZlodUOvimnEE9HbFuXBDu+/lvmp2cK8OMtqsFGiC1jWBo7BtDewsTV1RUikQguLi7mDsdmSaVSyOXyXrfDqBUrMO9fN6G+rw/Xq9NDsXHSkIEKkfSAz+dDrVYPupElADidXYvndyfjvh9HcDkMvl2XhGmRlLwTYg4D/fltM7veiOXTarV97hn2w+0qvSTJjkcFJs2poKAAH330EY4ePWruUMzikWhfvLtYv9WJRsvile9TUFDbaqaoCCEDiRIlYhIVFRWQSCR9ukaq1GB/FwUm3RyowKS5uLm5QaVSoaysDBqNpucLbNDq8SH41TT9QqmtCjWe3XkLjRIqcEuIraFEiQw4tVqN77//Hp9//nmfeoX9O70WYrl+P7hnxlKBSXPy8vKCnZ0dlEolqqqqzB2O2bw1NwoL4vVHNsubZPjVd7ehUA/OBJIQW0WJEhlwhYWFkMvlEAqF8PDw6NU1WrZzgcmpER4IowKTZsUwDIKDgwEMnnpKXeFwGPxz2UiMDHbTO36rpBm/O5RJZQMIsSEGJ0qnT5/u9rmumtGSwaejdtLw4cPB4fTuR+5iQRNKm2R6x1bTaJJF6EiUSkpKzBuImdnxudi6egz8XfV3cB5MqcBXF4rMFBUhxNgMTpQee+wx/M///A+Uynv1Rerr67Fw4UK8/fbbht6eWDmFQoH8/HwAfevttvtmhd6vI30cMS7UzZihkX7qSJTKysqgVqt7ONu2+bjY4Zu1iXAQcPWO//1ELk5k1ZgpKkKIMRmcKF28eBE//fQTkpKSkJWVhZ9//hmxsbGQSCRIS0szRozEiuXk5ECtVsPDwwM+Pj69uia3RoKbpfoFJlePDaQCkxbCw8MDjo6O0Gg0qKio6PkCGxcT4IpPVozC/T+eLAu8vjcVmZWi7i8khFgFgxOlcePG4c6dO4iPj8eYMWPw+OOP43/+539w9uxZ3TdPMnjdP+3W20TnwdEkT0c+Ho3pXZJFBh7DMEhISMC0adPg5uZm7nAswpwYP/xmnv6IqUylwYadyagVy7u5ihBiDYyymDsvLw+3bt1CUFAQeDwecnNzIZVKjXFrYsVkMpluHUtvp93qWhU4lqXfnf6pMQEQ8GjfgSUZO3Ysxo0bR4nSfV6YOhTLxug3aq4Ry7FxVzJkStoJR4i1MvjT569//SsmTJiA2bNnIzMzE7du3dKNMF27ds0YMRIrZW9vj5deeglz587t9Qfq3mT9ApNCHgfLR1OBSUs0WOsodYdhGPzl8TiMDdPf2ZleIcKb+9Og1dJOOEKskcGJ0qeffoojR47g888/h52dHWJiYnDz5k088cQTmD59uhFCJNbMwcEBMTExvTpXptLgxzv6BSYXxPrAw1EwEKERA0kkEqSnp6O2ttbcoVgMAY+Dr54ZgyEe+mUsfs6oxien880UFSHEEAYnShkZGZ0a3/L5fPzjH//AyZMnDb09sVIsy4Jl2T7tivopvRYimf75VBLAcl25cgWHDx/GnTt3zB2KRfFwFODbdYlwtuPpHf/sbCGOplZ2cxUhxFIZnCh5eXl1+9y0adMMvT2xUhcvXsR3332HsrKyXp2vZVnsfqDA5KSh7gj3dhyI8IgRhIaGAmgvKEr0Rfg4419PjwaXo7+B4a0D6UivaDFPUISQfuH1fMrD/fnPf37o8++8846hL0GsDMuySEtLQ3NzM6Kionp1zeXCJpQ06heYXDMuqJuziSUICQkBh8NBY2Mjmpub4e7ubu6QLMrUSG/8cWE03jmapTumUGvx/K7b+Pcrk+DjYveQqwkhlsLgROnw4cN6v1apVCguLgaPx0N4eDglSoNQZWUlmpubwefzERER0atrdt3UH02K8HbAhDC3AYiOGItQKIS/vz8qKytRWFiIpKQkc4dkcdZMCEV+bSu+u35vZLVGLMcL393GDxvHw47PfcjVhBBLYHCi1NX6BLFYjHXr1uHxxx839PbECnXUTgoPDwefz+/x/LxaCW6UtOgdWzM2iApMWoGwsDBKlHrwx4UxKKyT4HpRk+7YnbIW/P5IJv6xNJ5+zgmxcANSnMbFxQV//vOf8Yc//GEgbk8smFarRVZW+1TDiBEjenXN7gdGkzwc+Xg0lgpMWoOOdUrFxcWDvp1Jd/hcDr5cNQZB7vZ6xw/crsC2y4O3sTAh1mLAqvi1tLRAJKLy/YNNUVER2traYG9vjyFDhvR4fn2rAj9n1ukde2p0AIRUYNIqeHt7w9HRESqVClVVVeYOx2J5OAq67An3/rEcXMiv7+YqQoglMHjq7bPPPtP7NcuyqK6uxu7duzFv3jxDb0+sTMe0W2RkJLjcntdf7HmgwKSAy2D5GCowaS0YhsFjjz0GHx8feHp6mjscsCwLsViMyspKVFVVQSaT6aa2GIbBuHHjdDt1WZY16bTXcD8XfLR8FH713W3dMS0LvLInBUdfnoSh3k4mi4UQ0nsGJ0off/yx3q85HA68vb2xdu1avP3224benliZoUOHorGxsVfTblKlBj+m6BeYXBjnC08qMGlVgoKCepUUm8Lly5dx9uzZbp+PiIiAi4sLuFwuMjMzcebMGfj7+yM0NBSxsbFwdnYe0Pjmxfph0+xIfHTqXvHJVrkaG3Yl48jLk+Bi1/OaPkKIaRmcKBUX0xw7uSc2NhZDhw7t1bmH02ogluuva6GSANZJo9GYfIRGLBbjxo0biI+Ph6enJ9RqNVxdXcEwDLy8vODn5wdnZ2ewbPuIJcuycHBwgEKhAACUlZWhtbUVra2tyM/Px6lTpxAWFob4+HiMGDECAsHAJOy/nhmBvJpW/Jxx70tCUX0bXv3hDratTepUe4kQYl4M2/EuMsiJxWK4urpCJBLBxcXF3OFYLblcDpVK1eN5Gi2LxzbfQmXLvc7q0yI88MWK2IEMjwyQ/Px8ZGdnIzY2FgkJCQP6WvX19bhy5QoyMjKg1WoRHR2tm+ZXq9VgWbZXuy2VSiXq6+tRU1ODgoICvTVWfD4fGzduhLe394D8HqRKNZZuvobsarHe8RemDsXbj/ZuEwQhpN1Af373a0Rp06ZNvT73o48+6s9LECsjkUiQlZWFoUOHws6u50J6Z/Ia9JIkAFg7nkaTrFVTUxOKiorA5/MHLFFiWRY3btzAqVOnoNVqAQCBgYGIjIzUncPj9f4tTSAQIDAwEIGBgRgzZgxaWlqQm5uL7OxsODg4wMXFRTdKplQqjTrC5CDgYcuaMVj8xRU0til1x7++WIQoP2c8MZr+LRBiKfqVKPW2txPVBxk8MjIycPLkSQQGBmLFihUPPZdlWey8XqF3LNrPCYlDXAcyRDKAwsLCcPXqVRQXF0Oj0Rh9zZJUKsXRo0eRn5+ve73x48fD3994C//d3Nwwfvx4jBs3DkqlEkqlEiqVChqNBlu2bMHw4cMxdepUuLoa5+c0yN0BX60eg6e3XodKc29g/7eHMjDU2wmjgt2M8jqEEMP0K1H69NNPERMTYzELOIn5paWlAQCGDx/e47mpFWKkV7XqHVs3ngpMWjMfHx84ODhAKpWirKwMYWFhRr3/rVu3kJ+fDy6Xi2nTpmHkyJED9vPCMAyEQiGA9qQ+OzsbUqkUKSkpyMjIwIwZMzBu3DhwOIaXsEgK9cD/LY7Fbw9l6I4p1Vo8vysZP/16MnypzQkhZtevf+kJCQloamqvMtuxy4kMXjU1NaitrQWXy9WbBunOjgdGk/xdhJg9YmDWghDTYBhmwJrksiyLMWPGYMSIEXj66acxatQokybVsbGxWLFiBQIDA6FSqXDy5Els3boVlZWVPV/cC0+NHYK1E0L0jtW1KvD8rmTIVRqjvAYhpP/6lSi5ubmhqKgIAFBSUqJbL0AGp9TUVADtLUvs7e0fem5pkwzn8vUT62fGBoJHO32snrETpfz8fKjVarS1tYFlWcyfP3/AFlf3JDAwEMuXL8fs2bMhFApRU1ODb775Br/88guMsR/m9wuiMTFcvw5VWoUIbx/KMMr9CSH916+ptyeffBLTpk2Dv78/GIZBYmJit9NwHQkVsU0ajUZXZDI6OrrH83ffqMD9b/vOQi6eHOU3QNERUwoJCQHDMKirq4NIJDJoLc+1a9dw8uRJjBgxAvPmzbOIaVmGYRAXF4fw8HBcuHABOTk5UCgURomNz+XgX0+PxuJ/XUFZk1R3/PCdSozwd8bzU8MNfg1CSP/0K1HasmULnnjiCRQWFuLVV1/Fxo0bB7xQG7FMhYWFkEqlcHBw0I0odKdZqsLR9Fq9Y0sT/OEoNLicF7EA9vb2CAgIgFAo1NUq6o/bt2/j5MmTAAB3d3eLSJLu5+DggPnz5yMmJgbe3t6QyWSws7ODUqkEn8/v99ol9/+2OXn8X1fQprw35fbBL7kY5uOMGcOp/yEh5tDvT6iOuiW3b9/Ga6+9RonSINXQ0AAOh4MRI0b0+AGx73YV5Op707Q8DoOnkwIHOkRiQsuWLYNAIOhxCrY7GRkZ+M9//gMASExMxLhx44wZnlF19DLsmB48evQoNBoNHn/88X6/H0b6OuOTpxLw/O5kdMy4sSzw6g93cPjlSYjwoTYnhJiawds2tm/fTknSIDZp0iS88MILSExMfOh5CrUWP9zWb5o6L9obfi7CgQyPmBiHw9FV6e6r3NxcHD58GAAwcuRITJkyxeJGk7rT0NCA0tJSFBcXY/PmzSgoKOj3vWZH++LNOVF6x1oVajy/Kxkiac/FXAkhxkUt2olB1Go17O3t4ejo+NDz/pNRi6Y2/Tf5tdSuxCaxLIvm5mbU19f3+pqGhgYcOnQILMsiOjoaM2fOtJokCQA8PT2xatUq+Pj4QCaTYc+ePbh06VK/F2K/ND0cC+L1a0QVNbTh13vvQK2hzTOEmBIlSqTfxGJxr9qVaFkWO2/olwQYH+aG4X40jWCLMjIy8Pnnn+PUqVO9vqa2thZarRbBwcGYM2eOVSVJHTw8PPDUU08hPj4eAHD27FkcPHgQSqWyhys7YxgG/1g6ErGB+u0YLubX46+/5BolXkJI71CiRPqlvr4eH3/8MX744Ycey0NcLmxCcaNM7xiNJtmugIAAAMDdu3chl8t7OLtdVFQUVq1ahXnz5hmlkKO58Hg8PPLII5g1axY4HA6ysrJw8ODBft3LXsDFltWJ8HLSb53yzeViHLhd0c1VhBBjs953JGJWHZW4e7PLZ8cDo0kR3g6YNNR9wGIj5uXp6QkPDw9otVpdy5GHYVkWcrkcXl5eNrPeceTIkVi6dClcXFwwceLEft8nwM0eX68eAz5Xf4Ttd4cykFLWbGiYhJBeMMq+7DNnzuDMmTOoq6vrNLrw7bffGuMliAXRarW6RKmn2klZ1a24VSrSO7ZmHLUrsXXDhg3DjRs3kJOTo5uKepBMJsOPP/6IyZMnw8fH9ra+BwUFYf369eByuboSAm1tbXBy6tuU85gQD/xlSRzeOpiuO6bUaPHC7tv49yuT4O/avx2GhJDeMXhE6d1338WcOXNw5swZNDQ0oLm5We9hKh988AGSkpLg7OwMHx8fLFmyBHl5eSZ7/cGksLAQEokE9vb2CA9/eCG8B9cmeTkK8FiM7X0oEn3Dhg0D0P6z0tUaHZZl8fPPP6OkpATHjh2z2er+HYV41Wo17t69i88++wxXrlzp8yLv5UnBWD8pVO9YfasCz++6TW1OCBlgBo8offXVV9ixYwdWr15tjHj67cKFC3j55ZeRlJQEtVqN//f//h/mzJmD7OzsHndkkb65c+cOAGDEiBEPbYxcLZLjZLb+zqdVSQEQ8GjG19Z5e3vD1dUVIpEIhYWFnUYe09PTkZWVBYZhMHfuXKtel9RbRUVFUKlUOH36NFpaWjB//vw+/b7/36MjUFArweXCBt2xjEoR3jqQjk+fMm3/O0IGE4PfnZRKpUFz8MZy/PhxrFu3DjExMRg5ciS2b9+OsrIy3L5929yh2RSJRKJbdxIbG/vQc7+7VQnNfV+c7fkcLBvt3/0FxGYwDIOIiAgA7fWR7ieVSnH8+HEAwMSJE+HvPzh+JiZMmIDp06cDAJKTk7Fv374+7YjjcTn44ukEhHo66B3/d1oVvrpAraIIGSgGJ0obNmzAnj17jBGLUYlE7etiPDw8unxeoVBALBbrPUjPMjIyoNVq4efnBy8vr27PE8lUOHCnRu/Y4yP94GrPH+gQiYWIjY3Fo48+ikcffVTv+MWLF3WLt5OSkswUnXmMHj0aCxYsAJfLRX5+Pnbt2gWZTNbzhf/l5tDe5sTpgbY/fz+RizM5td1cRQgxhMFTb3K5HFu2bMHp06cRHx8PPl//g/Cjjz4y9CX6jGVZbNq0CZMnT+521OODDz7Au+++a+LIrF9iYiL4fH6nv+cH7btdDel9/ao4DPDMWGpXMph4enrC09NT72elqakJt27dAgBMmzZtUEy5PSgyMhJOTk44cuQIKisrsX37dqxdu7bXSwQifJzx6VOjsGGXfpuT1/am4vBLEzHM1zZ2DhJiKQx+l0pPT8eoUaPA4XCQmZmJO3fu6B6pqalGCLHvXnnlFaSnp+OHH37o9py3334bIpFI9ygvLzdhhNaLy+UiKioKQ4cO7fYcmUqD729V6h2bG+2NYHfanTMYqdVq3f/fuXMHWq0WoaGhCAkJMWNU5hUQEIDly5fD0dERbm5ufe6NN2uEL96aO1zvmEShxoZdyWiR9r3AJSGkewzb3xr7FurXv/41jhw5gosXLyIsLKzX14nFYt3iUxcXl54vGKQUCkWP6yp+SK7C+ycK9Y4d2DAaUb5UiXuwUalUSE1NRUVFBVatWgWGYXDnzh3daNNg19raCnt7ezg4OEAo7FvfQ5Zl8fq+VBxN1e+hODnCCzvWJ4HHHXyjdWRwGujPb5v5l8SyLF555RUcOnQIZ8+e7VOSRHqmVCqxZcsWXLlyBRpN99uRVRotdlzXH52bHO5OSdIgxeVykZycjOLiYhQXF0OpVCIyMpKSpP9ydnYGj8eDUqmETCbDiRMnUFZW1qtrGYbB356MR1ygq97xy4UN+MuxnIEIl5BBySiJUktLCz788ENs2LABGzduxEcffaRbTG0qL7/8Mr777jvs2bMHzs7OqKmpQU1NTZ8WSpLuZWVlobq6GhkZGQ9dV3Iipx5VIoXesecmBg90eMRCcTgcREVFAWjf6dWb3oCD1e3bt3H9+nV89913KC4u7tU1dnwutqwZA29n/dGo7VdK8OMtWk5AiDEYnCglJycjPDwcH3/8MZqamtDQ0ICPP/4Y4eHhSElJMUaMvbJ582aIRCJMnz4d/v7+use+fftMFoMt61hvFhsb2229FpZlse2q/pvzyEAXjAl27fJ8MjgMH96+liYvLw+lpaVmjsZyRUdHIyQkBCqVCnv27EFhYWHPFwHwd21vcyJ4YKrt/x3JQHJJ00CESsigYnCi9MYbb2DRokUoKSnBoUOHcPjwYRQXF2PBggV4/fXXjRBi77As2+Vj3bp1JovBVjU0NKCsrAwMw2DEiBHdnnepsAmF9VK9Y89NDKZCeINcVdW9NTSNjY1mjMSy8fl8LF68GEOHDoVarcbevXs71aDqzugh7nj/iTi9YyoNi199dxuVLTSqToghjDKi9Jvf/AY83r1KAzweD2+99RaSk5MNvT2xAB2VuENDQx/atHTbNf3RpHAvB0wb1nUdKzI4qFQqXTkAoHPxSaKPx+Nh4cKFGDZsGDQaDfbv34+srKxeXbt0TBA2TNZfm9kgUeL5XcmQKtXdXEUI6YnBiZKLi0uXiw/Ly8ttphP4YKbRaHQNcB9WiTulXISUcv2inc9OCAaHRpMGtezsbMhkMl0j2JqaGhpV6gGXy8Vjjz2G4cOHQ6vV4vDhw70uiPvb+cMxNdJb71hWlRiv7U2FRmtTG5wJMRmDE6UVK1bgueeew759+1BeXo6Kigrs3bsXGzZswMqVK40RIzGj3NxctLW1wdHR8aG1kx5cm+TnIsT8GO9uziaDgVar1bUQio+Px9ChQ3XNcsnDcTgczJs3D3FxcZg/f36vv3TyuBx8/lQCwrz0i1eeyq7Fez9nD0SohNg8gytz//Of/wTDMFizZo2usByfz8eLL76Iv/71rwYHSMzL09MT0dHRcHNz67YBbk6NBBcL9ReNrhsfBD7VcRnUioqK0NLSAoFAgKioKMTExIDL5cLBwaHniwk4HA5mz54NoL0/nr29PdRqNQQCwUOvc3XgY+uaRDzx5RWI5fem3LZfKUGwuwOenUylUwjpC6MVnJRKpbh79y5YlkVERITVvRlSwcmusSwLiUTy0HPeOJCN03n3Opq7O/Bx/OWxcBB0nViRweHKlSu4ceMGRo0ahbFjx+qO29vbd5t0k+61tbXhxx9/RGJiYq8akV8vasTqbTeguq8zNcMAXz0zBnNj/AYyVEJMymoKTjo4OCAuLg7x8fFWlySR7vVU96awvk0vSQKANeMCKUkimDBhAlasWIG4OP3dWHV1dcjOpmmgvsrLy0NzczNOnTqFixcv9nj++KGe+MfSkXrH2nvC3UFqecsARUmI7enX1NumTZvwf//3f3B0dMSmTZseeq45muISw6nVapw7dw6RkZHw8Oh+59rWK/oL+Z3teHhqTMBAh0esgEqlgqurfg2tlpYW/Pjjj+ByuQgLC+tzj7PBbPTo0VAqlbh69SrOnTsHtVqNGTNmPLT8xpKEQJQ3SfHhqXzdMblKiw07b+HgixMR4tm7RryEDGb9SpTu3LmjG2no2DreFaqfY71yc3Nx9epVpKenY8OGDV1W4y5tkuF4dr3esWeSAuAkNHjpG7FiEokEarUafD6/03Nubm7w9PREY2Mj8vLyMGrUKNMHaMXGjx8PHo+Hixcv4tKlS1Cr1Zg9e/ZD32tfmRmB8mYpfkyu0B1rkCix9tubOPDiRHg59a3HHCGDTb8+0c6dO6f7/507dyIoKKjTBynLsigvpxL61qpjt1JsbGy3LUu+uVKG+3ccOwi4WJUUaIrwiAW7efMm0tLSkJSU1GUiFBkZiWvXriErK4sSpX5ITEwEl8vFuXPncO3aNWg0GsybN6/bZIlhGPzl8ThUtchxufDeNHlJoxTP7riFHzaOhyN9uSGkWwavUQoLC0NDQ0On401NTdSY1ko1NDSgpKQEDMN0Wl/SobJFjv9k1ukdW5kYAFf7zqMIZPCQyWTIzMwEy7Lw9u66PERERAQYhkFtbS3q6uq6PIc8XEJCAh555BEAwN27d6FQKB56Pp/LwZfPjMYIf/2FrukVIrz4fQpUGu2AxUqItTM4Uepu05xEIoGdnZ2htydm0DGaFBYW1m39lm+vlUN933CSHY+D1WNpNGmwS09Ph1qthqenJwICul6rZm9vr/sSZcp+kLYmPj4eCxYswNKlS7uc5nyQix0fO9cnIdBNf13Yxfx6/OZAerfv5YQMdv0eb+1YxM0wDN555x29nW4ajUa3LZhYF7VaravEHR8f3+U5tWIFDqfV6B1bOtofno4Pr+9CbJtWq9X72XnYupn4+HgUFRUhNzcXkydP1lXuJn0TGRkJoH0kz97eHmVlZQgJCel2utzHxQ67nhuLpZuvoll6b0froTuV8HYR4u353fdyJGSw6nei1LGIm2VZZGRk6BVBEwgEGDlyJN58803DIyQmlZOTA5lMBmdnZ4SGhnZ5zo7rFXq1WfhcBuvGBZkoQmKpSktLIZFIIBQKH1rFHQB8fHzg6+sLsViMpqYmSpQMxLIsUlJScOzYMYwYMQJPPvlkt7Wqwr2d8O26JDy99QZkKo3u+NcXiuDuIMCvpoWbKmxCrEK/E6WOBd3r16/Hp59+SkUabYRKpYK9vX23i7jrWhX4MaVK79gTI/3g60I7Zwa7juatw4YN61VByRkzZsDJyYneO4yEz+eDy+UiJycHP/74I5YtW6bXrPx+CUPc8a9VCdi467ZeD7i//pILFzs+nh43xFRhE2LxDF6jtH37dt0bHcuyNM9t5RISErBx40aMGTOmy+e3XS2H8r7RJB6HwfoJwaYKj1golUqF0tJSAPemg3ri4uICDoeja31EDBMeHo5FixaBy+UiPz8f+/bte2jB2JnDffHXJzpv1vh/RzLwU1pVF1cQMjgZpTL3tm3bEBsbCzs7O9jZ2SE2NhbffPONMW5NTEylUoHH43XZT6pGrMD+O9V6xx4f6YdAN1q0P9jx+XysX78ejzzyCLy8vPp0rVKpRGlpKX3JMoKwsDA8/vjj4PF4KCwsxA8//AClUtnt+csSg/H7x/TXJbEs8Ma+VJzLpR2JhABGSJT+8Ic/4LXXXsPChQuxf/9+7N+/HwsXLsQbb7yB3//+98aIkZiATCZDQUHBQ7cZf3O1TG9tEo/DYOMkGk0i7RiG6XFt0oNYlsXBgwdx8OBBlJSUDExgg8yQIUPwxBNPgM/no7i4GN9///1DR+02TBmKV2dG6B1Ta1n86rvbuFHUONDhEmLxDE6UNm/ejK1bt+KDDz7AokWLsGjRInzwwQfYsmULvvrqK2PESEwgJSUFe/bswb///e8un68WyXHwjv5OtycT/ODvSqNJg51arYZWq4VGo+n55AcwDAM/v/YGrVQqwHiCgoLw5JNPQigUwt/fv8c1Y2/MjsS6iaF6xxRqLZ7bmYyUsuYBjJQQy2dwoqTRaJCYmNjp+JgxY2jtgZXQarVITk4GgG5HBLZe0a+bxOcy2DCRFnwS4OLFi/juu+/6XYk/NjYWDMOgtLQU9fX1PV9AeiUgIACrV6/GxIkTe3wvZhgG7yyIxhOj9WuhSRRqrN12E+kVLQMYKSGWzeBE6ZlnnsHmzZs7Hd+yZQtWrVpl6O2JCRQUFKClpQV2dnaIiorq9Hxli7xT3aRlCf7wo51ug55arUZOTg4aGhr63dvx/lIUNKpkXC4uLmAYBnK5HDKZDL/88gva2tq6PJfDYfD3J+MxJ9pX73irQo1nvrmBzEqRKUImxOIYdTH3hg0bsGHDBsTGxmLr1q3gcDjYtGmT7kEs082bNwG0f7PvqsLv1itleqNJQh4Hz02ktUnkXvsMR0fHbitx90ZHcdPc3FxIJBJjhUfu8/PPP+PmzZvYsWMHWltbuzyHx+Xg86cTMD1Kv/2MWK7GM9tuILtKbIpQCbEoBidKmZmZGD16NLy9vXH37l3cvXsX3t7eGD16NDIzM3Hnzh3cuXMHqampRgiXGFt9fT2KiorAMAxGjhzZ6fnyZhmOPDiaNNofPs40mkTa//0DQFRUVLfVoHvD19cXfn5+0Gg0uH79urHCI/cZO3YsnJyc0NDQgO3bt6O5ueu1R0IeF189MwZThunvXmyRqvDMthvIq+k6ySLEVhncMrqj8CSxTrdu3QLQvjbJ1dW10/NfXS7DfRvdYMfj4Dmqm0QAiMXiPtdOepikpCT89NNPaGxshFarNSjxIp25u7tjxYoVOHDgAJqbm/Htt99i9erV8PHx6XSuHZ+LLasT8dzOW7h6997Ot6Y2JZ7eeh3fbRjXqcEuIbbKoHcilUqFGTNmID8/31jxEBNiWRa1tbUA0GVfvsL6Nvwno1bv2IoxAfByop5uBMjOzgYA+Pv7G6W6tr+/PxYtWoQlS5ZQkjRAXF1dsWLFCnh6ekIikWDHjh2orKzs8lx7ARffrE3E2DAPveONbUqs3HodGRW0ZokMDga9G/H5fGRmZvZ7EScxL4Zh8Mwzz+Cpp57CkCGdd7B9fr4E9y1Ngj2fg/UTqKcbaU+yc3JyAKDLDQD95efnB7VaTcUnB5CTkxOWL18OPz8/yGQy7N+/v9vSDg4CHravS0JiiLve8RapCk9vvY7bpVQ6gNg+g7+2rVmzBtu2bTNGLMQMVCoVAgICOiW7aZVinM3XLza3dlwQPB1pNIm0mzx5MiIiIrptntxfLMuitbVVN2JFjM/e3h5Lly5FeHg4FixY8NARPEchDzueHYuxofojS60KNVZvu4Frd6koJbFtBq9RUiqV+Oabb3Dq1CkkJibC0dFR7/mPPvrI0JcgA6CxsRH29vZdfpNkWRafnC3WO+Zmz8Pa8TSaRNoxDIPQ0FD4+/sb/d4qlQp79+6FTCaDm5ubQbvpSPcEAgEWL14MoL0yv729PSQSCZydnTud6yTkYcezSXh+121cLmzQHZcqNVi3/Sa2rEnEtEjvTtcRYguMtuvNxcUF+fn5ul1utNPNsh05cgSfffZZl20jrhY1I7lMf/3BxklD4CQ0OK8mNmSgCsry+XyEhIQAAC5fvkzTcCag0WhQXFyML774AufPn+/yz9xBwMM3axMxc7j+4m+FWosNO29RI11is2jX2yBUXl6OiooKcLlceHvrfwvUsiw+PVeid8zPRYgVY+hbPWnX0NCAvLw8BAcHw8PDo+cL+mH06NEoKChARUUFSktLjT69RzorLS2FUqnEhQsX0Nraiscee6zTlJwdv710wGt77+CXzHtlQ1QaFq/uvYNGiQLrJoWZOnRCBpRRtpa0tLTgww8/xIYNG7Bx40Z8/PHHEIloR4SlunbtGgBg+PDhnaZKT+bUI6dWv+DfS1NDIOTRLiTSLicnBzdu3BjQKtpOTk6Ijo4GQKNKppKYmIhZs2YBaK+Qvn//fqhUqk7nCXgcfL4yAUtG6X95YlngTz9l4+/Hc+nvi9gUgz/9kpOTER4ejo8//hhNTU1oaGjARx99hPDwcGpHYIGampp0u5XGjBmj95xKo8Xn50v0jg31csDCOP2WBmTwYlkWeXl5ALrvC2gsCQkJ4PP5qKurQ0ZGxoC+Fmk3cuRILFy4EFwuF7m5udi1a1eXLU94XA4+Wj4KayeEdHruy/N38ZuD6VBrtKYImZABZ3Ci9MYbb2DRokUoKSnBoUOHcPjwYRQXF2PBggV4/fXXjRAiMaaOqsehoaHw8tKvvHs4tQZlzXK9Y69OCwWPQ+UfSLva2lqIxWLweLwuS0oYk52dna7h9qVLl6i1iYkMGzYMTz75JIRCISoqKrBt2zaIxZ1bl3A4DP60KAb/O7dzeYgfkyuwcVcyWuWdR6QIsTZGGVH6zW9+Ax7v3nInHo+Ht956S9eRnlgGqVSqW2Df8QHUQaJQ418XS/WOxQU4Y2aUp6nCI1agYzRpyJAhev/mB0pMTAy8vb0xdOhQcLncAX890i4oKAgrV66Eq6srXF1dO03Rd2AYBi/PiMBfn4jDg9+nzuXVY+nmayhvkpogYkIGjsGJkouLC8rKyjodLy8v73KbKTGfkpISqNVqeHt7IzhYvw3JtqvlaJLqf/t7fUYYFRMlOizL6qrwh4eHm+Q1ORwOFi5ciClTpkAopP6CpuTh4YGVK1fiscceg1KpBMuy3a49emrsEHy9OrHTWsa82lYs+dcV3CppMkXIhAwIgxOlFStW4LnnnsO+fft0u6n27t2LDRs2YOXKlcaIkRhJdHQ0NmzYgNmzZ+slQFUiOXbdqNA7d/owD4wNdTNxhMSS1dTUoLW1FTwer1OiPZA6Rq4UCgVYloVWS2tfTMXBwQFCoRBqtRptbW04duwYzp0712XCNDvaF99vGAd3B77e8cY2JVZtvYEDtys6XUOINTB47Pyf//wnGIbBmjVrdHVV+Hw+XnzxRfz1r381OEBiPBqNBs7Ozp1G+j45VwzlfZ1vuQzwxsyBXahLrI9IJIJAIEBwcLBJpt0e1NLSgmvXrsHT0xPTpk0z+esPdmVlZbrlFPX19ViyZAkEAv1K/YmhHjj68mQ8t/MWCururSlTarR4c38a8mrEeGvecPC5tIuWWA+GNdI+TqlUirt374JlWURERMDBwcEYtzUZsVgMV1dXiEQiozT4tCRarRZNTU1wdHTsVCQwvVKMVTtS9Y6tTAzA7+ZGmDBCYi1aW1shk8nM8u+7rKwMx48fB8MwWLVqVZdd78nAysrKwunTp6HRaODr64unnnoKbm5unc4Ty1X49Z47uJBf3+m5MSHu+OLpBPi72psgYjIYDPTnt8FpvUwmg1QqhYODA+Li4uDq6ootW7bg5MmTxoiPGEFWVhb+9a9/4fjx43rHWZbFP04X6R1zFnLx4pTOW34J0Wq1YBjGbF+ChgwZgqFDh4JlWZw6darbRq5k4MTExGDZsmVwcHBAbW0ttm7d2uUaVRc7PratTcSzXRSfvF3ajEc/vYTzeXWmCJkQgxmcKC1evBi7du0C0D40Pm7cOHz44YdYvHgxNm/ebHCAxDAsy+LSpUsA2ov43e9UbgNSK/S3/T4/eUinNQaEtLa2dll80NQmTpwIgUCA2tpaXLlyxdzhDEoBAQG6ET2pVIqdO3fizp07nc7jcTl4Z2E0PngiDnyu/qaQZqkK67bfwj9O5FK9JWLxDE6UUlJSMGXKFADAgQMH4Ovri9LSUuzatQufffaZwQESw+Tk5KC+vh5CoRAJCQm640q1Fh890Pg20M0OTycGmjpEYuFYlsXevXuxa9cuNDc3mzUWBwcH3fqk5ORkFBUV9XAFGQjOzs5YsWIFoqKioNVqO30Ju9/KsUNw8MWJCHLvPNX2r3N3sfzrayisoxpZxHIZnChJpVLd4uCTJ0/iiSeeAIfDwfjx41FaWtrD1cZz8eJFLFy4EAEBAWAYBkeOHDHZa1uq+0eTRo0apbe9+rtblahs0S8u+cbMMAioVQl5QENDA1pbW/X+rZtTWFgYYmJiAADHjx9Ha2urmSManPh8Ph599FE89dRT8PPz061/7GpKND7IDT//egpmR3eu8p9S1oJHP7uEL88X0ugSsUgGfypGRETgyJEjKC8vx4kTJzBnzhwAQF1dnUkXRbe1tWHkyJH44osvTPaali4/Px81NTXg8/kYPXq07nitWIGvLuknsaOCXDBnuNeDtyAEd+/eBQAEBgaaZbdbV8aPHw8vLy/Y2dlBqVSaO5xBi2EYBAS093yTyWSoqanBZ599huzs7E7nujrwsWX1GPz+sRGdqv0r1Vr8/XgeHv/yKnKqO1cBJ8ScDH7Xe+edd/D000/jjTfewKxZszBhwgQA7aNL90/1DLT58+dj/vz5Jns9S3f/aNLIkSNhb39v2PvDM0WQqfS/ub31yFAqLkm61JEohYaGmjeQ+3C5XMyZMwdCodDmdqlas+vXr0MsFmP//v1ITEzEnDlzwOffW/PIMAw2TBmK0SHu2LQvFSWN+lW7MypFWPj5ZTw3OQwvzYiAqz2tlyTmZ/CI0tKlS3X1Ne7fVTVr1ix8/PHHht5+wCgUCojFYr2HLRGJRGhqagKPx9NrV3KrtAW/ZOtv2X18pC/iAunDhnQmkUhQW1sLAAPe262vnJycwOfzIZfLwbKsRSw2H+xmzJihe79JTk7G1q1bdT8/9xs9xB2/vDYVGyaH4cHvZ2oti68vFmHaP87hm0tFUKhpdyMxL6PVUbIkDMPg8OHDWLJkSbfn/OlPf8K7777b6bgt1VESi8UoLy/XfcCpNFos35aCwvp73+Kc7Xj4z68S4eEo6O42ZBBLT0/H6dOn4ePj89B/T+bEsiwyMzORlpaGZcuWwdOT+hOaW2lpKY4fP462tjZwuVzMnj0bY8eO7XLUOqWsGW8dSO92QXeQuz3+d24UFsYHgEMNukkXLL6OEtDe2fuZZ57BhAkTUFlZCQDYvXs3Ll++bIzbD4i3334bIpFI9ygvLzd3SEbVUfPm/lGAH5Kr9JIkAPj1tFBKkki3OqbdLG006X5arRZ3796FVCrFoUOHIJHQDipzCwkJwerVqzF06FBoNBocP368yxICQPvo0n9+PRkvTQ/vtHYJACqaZXhtbyqm//M8vrlUBJGMRg6JaRmcKB08eBBz586Fvb097ty5A4VCAaC97sr7779vcIADpWNtw/0PW8CyLAoLC3V/Dx3qWxX48qL+Au7hvo5YPtrflOERKzN69GjExMQgLKxz4UBLweVyMW/ePLi6uqK1tRWHDx/u9PNPTM/BwQGLFy/GzJkzERgYiBEjRnR7rh2fi7fmDcepTdPwaJxfl+eUNUnx3s85GP/+GfzucAZya2xruQSxXAYnSu+99x6++uorbN26VW/R3sSJE5GSkmLo7Ukf5efn4/vvv8f333+v17jy43PFaFPqz/X/v3kR4NJQNnmIwMBATJo0Ce7u7uYO5aHs7Owwf/582Nvbo76+Hj/99BNV7rYADMNg1KhRWL58OdRqNaRSKVQqFf7zn/90WZMrzMsRX64ag0MvTURSaNc/czKVBntulGHeJ5cw88PzeP9YDm4WN1FpATJgDN71lpeXh6lTp3Y67uLigpaWFkNv32sSiQSFhYW6XxcXFyM1NRUeHh4WPW1gTFqtFmfOnAEAXT0pALhdJsJPGfrtAhbF+2JUkKvJYyTWxZqSDRcXF8yfPx8//fQTysrKcOLECcyfP592c1qAjr8DjUaDK1eu4Pbt20hPT8eMGTMwduxYcLlcvfNHD3HHjy9MwKnsWnxyugDZ3ZQMKKpvw5b6Imy5WAQ3Bz6mDPNGfKArYgJcEBPgClfqMkCMwOBEyd/fH4WFhZ22Dl++fBlDh5quA31ycjJmzJih+/WmTZsAAGvXrsWOHTtMFoc5paen66pwJyUlAWivT/LusXy985yEXLwxw3KnUoj5sSyLq1evwsfHB76+vuBwrKMQqZeXF2bPno1ffvkFubm5iIqKQnh4uLnDIvcZPnw4ysvLUV5ejpMnTyIlJQVz585FRIR+I26GYTAnxg+zo32RXNqMHVdLcDyzBhpt1/uPWqQq/JRWhZ/SqnTHAt3sEenrBD9XO/i62MHPxQ6+rnbwdBTA2Y4PZzsenO14EPK4Xd6TEMAIidILL7yA1157Dd9++y0YhkFVVRWuXbuGN998E++8844xYuyV6dOnwwY38PWaWq3GuXPnAABjx46FnZ0dAGDrlTIUN8r0zn15aii8nGgBN+ledXU1bty4AT6fjzVr1pg7nD4JCgrCtGnTIJfLLXpt1WDl5uaGpUuXIjMzE5cvX0ZDQwO+//57DBs2DHPmzIGXl37hW4ZhkBTqgaRQD9SI5NhzoxR7b5WjrrXndWiVLTJUtsh6PE/A48DFjqeXPDkJ7/81/7/P8+DrYodQT0cEutuDz7WOLxDEMAYnSm+99RZEIhFmzJgBuVyOqVOnQigU4s0338Qrr7xijBhJL9y6dQtisRhOTk4YNWoUAKCgrg3fXNXfzRfj74SnEgPMECGxJh091IKDgztNi1iDyMhIAO3Vou3s7KDRaMDj8axmZMzWMQyDuLg4DBs2DDdu3MCdO3dQUFAAhmGwcuXKbq/zc7XDpjlReP2RSGRUinAmpxancuoMruatVGvRIFGiQdL7Ku9cDoMgd3uEeDpiuJ8zEkPcMSbEHZ5Owp4vJlbFaHWUpFIpsrOzodVqER0d/dAmiZZooOswDCS5XI7PPvsMMpkMc+bMQWxsLDRaFmt2pSK98l4fLC4D7HtuNKJ8revvhpjezp070djYiJkzZ3aaErE2arUav/zyC5ydnTF//nyrTPxsXXNzMy5evIgpU6YgICAAPB4Pra2t0Gq1cHNz6/H6imYpLuTXI7NShKwqMXJrWqFUm2dx91AvR4wJccfkYV6YOdwHzna0TmqgDfTnt0EjSlqtFjt27MChQ4dQUlIChmEQFhaGpUuXYvXq1bSI0kQkEglcXV1hb2+P6OhoAMC+21V6SRIArJ8QTEkS6VFLSwsaGxvBMAyCg4PNHY7B6urqUFtbi+rqaqhUKixYsEBvhy4xP3d3dyxevBhA+xc/hmFw9uxZZGRkID4+HpMmTeo0JXe/IHcHrBoXovu1SqNFYZ0EOdViVDbLUCOWo1Ys/+9/FRBJVVAO0C65ooY2FDW0Yf/tCgh4HEyP9MZj8f6YNcIXTkLL6JVI+qbfI0osy2LhwoU4duwYRo4cieHDh4NlWeTk5CAjIwOLFi3CkSNHjBzuwLHmESWgPVlqbW2Fk5MTqkVyLNlyG9L7ygGEeNjjwIbRsOPTt2nycCkpKTh//jwCAgKwYMECc4djFB0LhzUaDQIDA7Fw4UI4ODiYOyzSDZZlceTIERQXF+uOhYSEICEhAdHR0UZJdOUqDVrlarTKVf/9773/F993TKK49/8tMiUqmmVokfa96KWQx8HsaF88OzkMo4dYdrkNazPQn9/9TpS2b9+O1157DUePHtXbbQYAZ8+exZIlS/DFF19YzUJQa06UlEqlrsAey7J4eV8WLt1t0jvn22fikRTiZoboiLXZv38/ysvLMX78eMTHx5s7HKOprq7G8ePHoVKp4OzsjEWLFsHX19fcYZGHqK6uxs2bN1FUVKTbrCMUCjFhwgRMmzbNbHG1SJUoaZSitLENBbUSpJQ1405ZC2Sq3pXTGD3EDc9NHoq5Mb7g0YJwg1lsojRnzhzMnDkTv/3tb7t8/v3338eFCxdw4sQJgwI0FWtMlMrLy5Gfn4/Ro0eDx2sf0v1PZi3ePpqnd96To/zwp8cizREisTIajQbffvstWltb8dRTT1nNv4Xeam5uxsmTJyESicDlcrFgwQIqH2AFWltbkZ2djczMTIhEIkyZMgXTp08Hh8OBXC5HQUEBIiIiYG9vb7YY1RotcqpbkVzahIv59bhc2ACV5uEfr4Fu9nhuchhWjR9CJQoMYLGJkp+fH44fP67bYfWgO3fuYP78+aipqTEkPpOxtkRJq9Viy5YtqK2tRWJiIqZOnYpqkRxPbr2NVsW9bzVejgIceWEMXO1pTQbpHaVSiaqqqoeuCbFmSqUSZ8+eRV1dHZ5++uleLRYmloFlWZSXl8PDwwNOTk7gcDgoKCjA0aNHwTAM/P39ERAQoHt4e3ubbaejSKrCyewa/JxRjcsFDVB3U/8JaE+Y3pwbicUjA6nxbz9YbKIkEAhQWloKf/+ue4VVVVUhLCzManouWVuidOPGDRw/fhxCoRDPPvsshHZ22Ph9Om6WivTO+/jJaDwy3DY/8MjAkMvlUKvV5g5jQLEsC7FYDDc3N9jZ2YHL5UImk5l1RIL0T35+Pq5du4bGxsZOz/H5fKxevVq3KaG5uRkSiQRubm5wdHQ0WRLV3KbE/tvl2HGlBFUiebfnxQS44Lfzh2PKMG+TxGUrLHbXW0ddku5wuVybf7M1F4lEoisuOWXKFNjb22PXjYpOSdLCOB9KkkivdXxnsqa2Jf3FMAxcXV3BsixkMhnKy8tx5swZTJ8+HTExMbRj14pERkYiMjISra2tqKqqQk1NDWpra1FXVwelUgkulwu5XA4Oh4OUlBRcvnwZQPvPgLOzs64purOzMyZOnKj7oO241hjlJNwdBXh+ajjWTwrD8cwafHO5GGnlLZ3Oy6oSY/W2m5ga6Y0/L4pBqJejwa9NDNfvRIllWaxbtw5CYdfFtaxlJMkanT59GgqFAr6+voiNjUVBXRs+PVesd46/ixBvz7Hu+jfEtMrLy/Hzzz9j2LBhGD9+vLnDMamcnBwolUqcPHkShYWFmD17Nhwd6UPKmjg7OyMqKgpRUVEA2j+jmpub4ejoCJVKpTvm7OwMiUSiG1UUi+8Vq0xISIC9vT04HA4uXbqEy5cvw9HRUS+Z8vT0hI+PD4KDg/u8+47P5WDhyAAsiPdHcmkz/nEiDzeLmzqddzG/HnM/uYhXZw3DxilDIeDRgm9z6vfU2/r163t13vbt2/tze5Ozlqm30tJSXe+6lStXwtPbF09vv4O8ujbdOQyAbbTLjfTRuXPncOfOHURGRmL69OnmDsektFot0tPTkZycDK1WC3t7e8ycORORkZE0umSDtFotpFIpWltbdaVVJBIJJk6cqJspOXHiBLKysrq9x0svvQRv7/YpssrKSkilUgQHB+vaR/UGy7I4k1OHvx3PRUGdpMtzonyd8f4TsRgT4tGH3+HgYrFrlGyNtSRK27ZtQ0VFBeLi4jB79mx8fLYY317Tb1OydlwQ3nzEdA2JifVjWRbffvstRCIR5syZ06nJ9WDR2NiIc+fOoamp/Vt+cHAwZs6cCU9PTzNHRkyNZVnI5XK9ZKq1tRVNTU1obm7G6tWrdW1xjh07hszMTADtG52GDBmCiIgIhIWFPXSJSge1RouDKRX46FQ+asWdZ2MYBlg1bgjenj8CjlS0shNKlEzEWhKlxsZGnD17FtOmTUNGrQIbvk/H/X+Bw3wc8cP6BAhpqJb0QUNDA3bt2gUul4s1a9YM6srVGo0GqampSE1NhUajwRNPPDFoE0fSO5cvX0Z+fj5aWlr0jgsEAkRGRmLJkiW9WuskUajx4ck87Lxagq42yQ3xcMBHy0ciMZRGl+5HiZKJWEOixLIspFIptFotasUKLP82BU1t9yrE8rkMflifQG1KSJ/dvHkTly9fxpAhQzBv3jxzh2MRWltbUVxcjJEjR0IgEIDP56O6uho+Pj7UL450SSKRoLKyEuXl5bh79y7a2trg6+uLjRs36n5m6uvr4eXl9dAp3fSKFvz2YAayu2j2y2GAF6aF441HImnt0n9RomQilpwoqdVqlJWVISAgACqVCiqNFs9+l47UCv1/RJtmhmH9BOvvzUVM74cffkB1dTUmT56s6xdI9CkUCnz//fdwdHTE+PHjMWLECLPV6CGWj2VZXX/BkJAQMAwDrVaLL774Ao6OjkhISMCoUaO6/bxRa7TYfqUEH53K77Li9wh/F3y8YiSG+1nW55U5DPTnN/0rtwJnz57F7t27cfbsWQDAR2eKOyVJUyM8sHZ8kDnCI1aura0N1dXVANr7aZGuNTY2gs/nQyQS4cSJE9i5cydycnKg1ZqnSz2xbAzDICAgQPdvimVZVFVVgcPhoKWlBefOncMnn3yCAwcOoKqqqtP1PC4HG6cOxfHXpyAxpHNvuJxqMRZ9cQXbrxSDxjsGFo0o/ZeljigVFxdj165dAIAlS5YgX+6E/z2cq3dOoKsQ+54bTdW3Sb+0tbUhOTkZLS0tmDVrlrnDsWhqtRpZWVlIS0uDXN5eONDNzQ2jR49GTEzMoF7bRXpHpVKhoKAAGRkZqKys1B0PCwvDvHnz4OPj0+kajZbFlotF+OhUXpdtUWZEeeMfy0bCy6nrcj22jqbeTMQSEyW5XI7NmzdDLBYjLi4O4QmT8NS3KZCp7n2DFXAZ7F47CtH+zmaMlFi7wVCN25iUSiWysrKQnp4OhUIBLpeLjRs3wsHBwdyhEStSX1+P5ORk5Oa2f/l95ZVX4OHR/ULt7CoxNv2Yitya1k7PeTkJ8eHykZgWOfiqelOiZCKWmCgdPnwY6enpcHV1xRPLV2Lt91kobpTpnfPuY8PwxKiu28gQ0lttbW00fN8PKpUKeXl5UCgUSEpKAp/PB4/Hw9WrVxEcHIzg4GCqw0R6JBaLUVFRgejoaPB4PAiFQly4cAFBQUGIiIjQ+xlSqDX48GQ+tlws6vJeGyaH4X/nRQ2qJruUKJmIpSVKaWlpOHLkCBiGwZPLluHPF5pwo6RF75zHR/rizwuizBMgsQn19fUQiUTw8vLqVb0X0rOmpiYcOHAAAODq6oq4uDhER0fDyYl2o5Leqa+vx+7duwG01/KaMWMGwsLC9M65VFCPTT+mob61c92laH8XfLYyARE+g+NnjhIlE7GkREkikeDTTz+FWq3G+PHj8VO9B/6TWad3znBfR+xeOwp2/MHzrYEY36lTp5CRkYGYmBhMmjTJ3OHYBLFYjLS0NBQWFupaZzAMg9DQUERFRSEiIgICgcDMURJLJpPJcPPmTV0tLwCIiIjA7Nmz9dYwNUoUeOtAOs7k1nW6hz2fiz8ujMaKJNsf1aREyUQsKVECgPT0dOTk5CDPbji+vVah95yHAx/frRuFYHfqdE76j2VZbNmyBW1tbXj00UcRFES7Jo1JpVKhqKgIubm5qK2t1R1fsmQJhg6lyvmkZxKJBDdv3kR6ejq0Wi0YhkFCQgIeeeQR2Nu3v/+zLItd10rxl2M5UKo778CcH+uHD56Ig5uD7SbnVB5gEFIoFAgLC4PYZ1SnJMmez8G/VsRSkkQMVlNTg7a2NvD5fPj70zo3Y+Pz+YiKisLixYuxfPlyjB49Gj4+PvDy8oJCoYBGo8GVK1fw008/ITs7GzKZrOebkkHFyckJM2fOxNq1azFs2DCwLIvc3Fy9+l0Mw2DtxFD8+5VJiOyi2PAvmTWY/+klXC9qNGXoNoVGlP7L3CNKLMvi9OnTSEhIgFAoxJncBrxxMFuvPQmXAT5bHoupEVS+nhjuypUruHHjBoYOHYpHHnnE3OEMOizLYt++fbru9QzDICgoCEOHDkVoaCg8PDxsfsqE9E1lZSVkMhkiIyMhFArB5XKRl5eHyMhIcDgcyFUavH8sB7uulXa6lmGAV2ZE4NVZw8Dn2tYYCU29mYi5E6UzZ87g8uXLcHZ2xrCpi/HmkXwoHhhGpR1uxJh27dqFhoYGzJgxA8OGDTN3OIMOy7JoaGhASUkJSkpK0NzcrPd8QEAAnnrqKTNFR6xBQUEBfvrpJ/j6+mLOnDm6Kd1T2bV460AamqWqTtckDHHDpysSMMTTdkpZDPTnN21zsQAdfbYAwCUsHm8cyoP6gY6IL00JoSSJGI1IJEJDQwMYhkFwMLW9MQeGYeDt7Q1vb28kJSVBLBajpKQEFRUVqK6uhqurKxQKhW434t69e+Hr64ugoCAEBgbC2Zlqpw12SqUSQqEQtbW12L17t27B9+xoXxx/fSo2/ZiKK4X6U253ylrw6GeX8OfFMXg8IZBGLXuBRpT+y1wjSlevXsWpU6cAAK4hMfgsz75T1+gnR/nhj48Oox9oYjSZmZk4efIk/P39sXDhQnOHQx6gVquhUql0C3br6upw5MgRvXNcXV11SVNISAglToOUTCbD9evXkZaWprfge8aMGXBwcMSWS0X454nOX74B4JERPvjL43HwdbEzQ+TGQ1NvJmKOROnixYs4d+4cAMAxOBpf5NsD0E+GFsX54N0FUeBxKEkixtPRsFMul3fZMoFYFqVSiaqqKlRXV6O6uhqNjY16BUInTpyI8ePHA2j/4KypqYGvry9VCh9EmpubcenSJRQWFgIAhgwZgvXr1wMA0spb8NreOyhplHa6ztmOhz8siMayMUFW+2WcEiUTMXWilJycjJ9//hkAwAuMxtbCzm9oT40JwNtzw8Gx0h9eYtmoGrf1UiqVqK2t1SVO48aNQ0BAADgcDu7evYsTJ04AAFxcXODr66v3sLOz7tED8nCVlZW4cOECpk6disjISHC5XGg0GkhVWrz7UzYO3K7o8rqpkd744Ik4BLpZ345qSpRMxNSJkkQiwfYdO3FX7YEjNZ1f77mJwXhteqjVZvjEsqnVal1TV2JbCgsLcfv2bYhEoi6fv7+OU2trKxQKBdzd3cHlUvFaW8GyrO6zg8fj4ebNm8jNzcWcOXOQ12aH3x/JRINE2ek6ez4Xr8yMwHOTw6yqmDElSiZiikRJoVBAIBBAq9XidlEd3jyQiTJR5x/W16aHYsOkIQMSAyFnzpxBW1sb4uPj4eXlZe5wyABRKpVoaGhAfX096uvr0dDQALFYjKeffhpubm7gcDhITk7G9evXweFw4O7uDi8vL93D09MTLi4uejV7iPXRaDTYtm0bJBIJACAyMhJjJ03DF9fqcPhOZZfXhHg64J0F0Zg1wteUofYbJUomMtB/0JWVldi/fz8SExORp/HG307ehVKj/0fPAPjtnHA8nRRo9NcnBAC0Wi02b94MhUKBRYsWwc/Pz9whEROSy+UQCoW60YZbt24hMzNT12rlQevWrdN1sy8rK4NIJIK7uzvc3d3h4OBAI95WQiaT4dq1a3oVvuPj48ELGIH/O12OWnHnfnEAMCPKG79fEI1wb8vuGUeJkokM1B80y7K4ceMGTp06Ba1WCxXPEXtao6B9oCi6mz0PHywejsnhVEySDJzy8nLs378fQqEQq1evptECApZlIZFI0NzcjKamJjQ1NaG5uRkikQjr1q0Dn88HwzA4e/YscnNzddcJBAK4ubnB3d0dLi4uGDdunK6H3f1TP8RyNDc34+LFi7h79y6A9hIVs+bMx7FqO+y5WYausgEOAzyeEIRXZ0UgxNPRxBH3DtVRsmISiQQ///yz7s2lXOuOC60hnZKkkYEu+OcTw+Fn5Vs0ieUrKioCAISEhFCSRAC0f1g6OzvD2dkZQ4bcm/LvSHY6mrK6u7sjODgYLS0tkEgkUCqVqKurQ11de0PWpKQkaDQacDgcnDx5EiUlJXBxcdF7ODo6wtHREb6+vvTzZwbu7u5YvHgxampqcP36dZSUlCAibAjeG+eDlWOH4E9H05FcJta7RssCB1MqcDS1EkvHBOGVmREIch9cuykpURoAGo0Gt27dwvnz56FQKKAFg5vKIORofPDg9v/VYwPxxswwmyspTywPy7K6rcMhISFmjoZYugdHhOLi4hAXFweg/T1OLBZDJBJBLBZDLpdDrVZDrVYDAJqamtDW1oa2tjZUV1d3uverr76qS5QuXbqE2tpaXRLl4OAAOzs7CIVC2NnZISjo3rb1jmkjY49WaTQaqNVqaDQaaDQaaLVa3X9ZloWnp6cu3ubmZrS2toJlWd3zDMOAw+GAYRj4+/uDz+cDaJ/yUqvV4PF44PP5uuKh5ubn54clS5agtbUVDg4OaGtrwzAvOyz1qMQ4dTMuityR2eYE9r7PK7WWxd5b5TiYUoHFowKxbmIoYgNdzfi7MB3L+FuzMS0iMU6eOg1Wq0G91gHXlCFoZPWHLJ3tePjzY5F4ZDgtpiWm0dTUBJFIBA6Hg6CgIHOHQ6wYl8vVrVXqyuzZs9Ha2orW1lZIJBLdf6VSKbRaLeRyuS7hqaysRFVVVbev9dprr+mSlP/85z+4e/cu+Hw+uFyuLjnpSFTWr1+vO/fixYsoLS3VJTQPJkEvvPCCLnE5efIkcnJyuo3h+eef1xX/TE5ORkZGRrfnrlu3Dq6urmAYBrdu3UJycrLen9v9SeDcuXN1f4b19fVobm6Gg4MDXFxc4OTkNOCjbh1FSlmWhUgkQmFhITQaDRJRhyRXB9yReyJH4QE5+LprVBoWB25X4MDtCowJccfaiaGYF+MHAc92v+xTomQEKpUKRUVFCBgShgMpldh+uRjOCn8oWS4KNF64fxSJAfDEKD+8Oj0UHo4Cs8VMBp+OdQmBgYG6b7yEDAQ7OzvY2dnB29u723NYlgXLskhKSoJIJIJMJoNUKoVMJoNSqWwfjddqIZPJdNfI5XKwLAulsvNu4Y7nO0abmpqaUF9f3+3rt7a26tZUabX3+moyDKNLwjoSsftjEAqFcHd310vQOn4vWq0WarVad75SqQSHw9HdX6PR6EbagPad0HK5HBwOBzk5OXpJVceUqIuLC1xdXTF+/Hi4uraP4KhUKl2MxmJvb4/nnnsOaWlpSE9Ph0wmxSiOFKPsK1CpdUW6ygc1Wv31P7dLm3G7tBnezkIsGRWABfEBiA9ytbn1abSY+7/6uhhMIpEgIzsXKelZaKguB7QanNeOQLGi+8Vu8QHO+N3cCMQEUKsBYnodb8RRUVGIjo42dziE9JlKpYJSqYRKpYJWq9VNfXU8fH3vbWdvbGyEVCrVJTNcLlcvAbq/9IFardabPjM2rVari12hUOgeQ4YM0Y1qZWdno7CwEFKpFBKJRC95A4DVq1fryjpcv34dN2/ehIuLC9zd3XWL6u9fXG9IEqVWq5Gbm4uMjAzd1CkbnIA9RXwo1VpwoQELptN6WwAY4uGAx+L98VicP2ICXEySNNGuNxPp6Q9aq2WRWVKDyzdTUFteBEbapLfaqFUrwE1VMMq0nYeivZ0EeHV6KBbF+1KVbWI2LMvqqnHb2jc+QmwJy7KQSqW66cvW1laMGjVKl/ycO3cOBQUF3V6/fv163ZRecXExWlpadIlUX5OopqYmZGVlISkpCVItD4fSanD9xi1EaMpQoXFBudYNFRpXKLuYoPJyEmJiuCcmRXhiYrgXgj0GZhE4JUom8uAfdKNEgTulTUgtbUBqlRRp5S0QKEVYZHdvHrtB64AyjRvKNG5oZjv3aRvu64hnxgZifrSPTc/fEuugUqmgUHRdL4UQYj06vvR0LKjvWFQvEokgkUiwdu1aXVmH06dPIz8/X3cth8OBq6urLnGaMGEChEJhn17/yNGjKPrvVD7QvjOuiXVArdYJNRpnVGhduxxtCnSzR3yQK2IDXREd4IKYABf4OBu+25sSpT768ssv8Y9//APV1dWIiYnBJ598gilTpvR4Xccf9Atbz6K+vhF20loEc1tQoXHFZVXYf89iMZVfjDqtE8o0bpCi8xojBsD0SE+sHhuIxCG2N1dLrFNJSQk8PDxoSzYhNu7BEePMzExUVlZCLBZDLBbryj0A7eugXnrpJb2kqrKyUjeF5+rqCmdnZzg6OsLJyQmOjo5gGAYsy6KmpgZ3795Fdl4BJKJm3T3VLIPv5Qm6RGkIpxlaMGjSOkAKPh4cUPByEiDE0xEhHg4Y4umAIR4OCHJ3gI+zEN7OQjgKe15KTXWU+mDfvn14/fXX8eWXX2LSpEn4+uuvMX/+fGRnZ+vVB3kYl7un4W8n0P3J+HAkAFi0/+UyuKgaqnc+j8Mg0scR8YEuiA90RlKIK9VDIhalra0Nhw4dApfLxapVq6gpKiE27MEv57GxsYiNjQVwr7hox+iTXC6HSqXSVWavq6vTFR3t6r6vvfaabhF7VVUVlEolRsXFgMvlQiKRoLy2AXWtSoTIeCgWaQAwGMOvhBunva+kguWilRWiVStEKytEM2uPIoknGiRK3C5txr3P2nvs+Vx4Owvh7iiAs5AHRyEXTkI+nO3u/T9XI+sUrzHZVKL00Ucf4bnnnsOGDRsAAJ988glOnDiBzZs344MPPujVPbjQQqIVoEzbPqVWo3XC/X9xfi5CxAc6tydGAc4Y4edkVc0DyeDTsdvNw8ODkiRCBrH7i4sGBnZulTVr1iy0tLTopvLEYjGkUina2trA4XAgk8l0iVJ+fn6XNbIAYBa3Do+/uBHXi1uQn1wFRVsdBKwaQkYDISOFF0cKAJCxPLgwcqSqAwAweFyYBTtGDRXLgRocqFguVOBA2cqFVCxAntYD9VpHAAyGcJphBxXAADJF17sgjcVmEiWlUonbt2/jt7/9rd7xOXPm4OrVq53O79h10EEsbq9GWqt1glrrBA5YhPDFSHBSw3dYHEYGuiIu0BmQiaBUKiEQCMDna6FRyqGCADwej6bZiEXqWPQZFhbWw5mEkMHMyckJTk5OXdZZu393IQAMHz4cvr6+aGtrg0wm09vNx+Vy4Slk8dhwVywYsQhHjx7tMqmyZ9SI49UgVd2etDkySvAZLey6+SiNQR22y8YAAMbxy+HEaU+Q5Fo5LhvjD6AbNpMoNTQ0QKPR6G0PBQBfX1/U1NR0Ov+DDz7Au+++2+m4L0cCO55a92u+io9N85bpfjj2nz6G4uLiTtcxDAOBQIDnn39eV6MmPz8fra2tui2crq6uVL+GmJRMJkN5eTkAYOzYsfD09DRzRIQQW+Dv79/tcw+uk5o/fz5EIhEUCgVUKhXUajUUSiUaxVK0yFT4Q3A0yhrbUFHnDEFtFuzUYjAsCy60YMCCy7BgWQYqcNExw1OndQSX0UIIdTdRGI/NJEodHhzV6W4r9Ntvv41Nmzbpfi0WixEcHIx58+ZBIBBAoVDoiprdP13h5uYGT09P3fMd53QkUq6urrqsOzs7W9dbq4OTkxPc3d3h5eWFyZMnU+JEBlRRURG0Wi18fHwoSSKEmMSDn7nBwcEIDg7u5dVTAQBtCjUaJArUt7Y/RDIVJAo1Xleo0aZQQ6IIRqtcjVqFGs0tIgB/Ne5v4j42kyh5eXmBy+V2Gj2qq6vrNMoEtFdX7WpLZEJCwkNXzS9atEjv1x1VYpVKJdRqNbjce+uVIiIiYG9vr+vKLZfLIZFIIJFIUFdXh0ceeURXMO3SpUtQqVQIDg5GUFCQrlw+IYbomHYbMWKEmSMhhJDecxTy4CjkIcSz+yLOHcRiMVw39Xhav9lMoiQQCDBmzBicOnUKjz/+uO74qVOnsHjx4gF7XYZhuk26JkyYoPt/lmUhk8nQ2NiIxsZGKJVKODg46J4rKChAS0sLUlNTAbQnfsHBwQgNDcWQIUP0EjBCekOlUqG0tBQAqBI3IYT0k03VUdq3bx9Wr16Nr776ChMmTMCWLVuwdetWZGVl9dgtfaDrMDxMxzRdaWkpSkpKOvUn8vHxwTPPPGPSmIht6OjePmrUKNpsQAixSVRHqQ9WrFiBxsZG/PnPf0Z1dTViY2Nx7NixHpMkc2MYBjExMYiJiQHQ/uFWWlqKoqIi5OXlITw8HEKhEGq1GkqlEqdPn0ZkZCRCQkKogCB5KA8PD/j5+Zk7DEIIsVo2NaJkCHOOKD0My7JQqVS6Lte5ubnYt28fgPaF4dHR0YiJidH19SHkfo6OjpRME0Js2kB/ftM7qIXrKDvQwdvbG+PGjYO9vT0kEglu3ryJ7du34+DBgygtLQXlvQRoLzJ56NAh5ObmmjsUQgixapQoWRlPT0/MmzcPmzZtwrJlyxAREQGGYVBaWoqDBw+irq7O3CESC5Cbm4uSkhJdDSVCCCH9Y1NrlAYTHo+H6OhoREdHo7m5GdevX0dDQwNCQkKgUqmg0WhQVVUFHx8f8Hj01zyYKBQKFBYWAgDi4uLMHA0hhFg3+gS1Ae7u7pg/f76uuCafz0draysOHjwIoVCI8ePHIyYmhkoMDBIFBQXQaDTw8vJ6aPVcQgghPaOpNxty//ZvkUikW8d0+vRpbN++HZmZmdBqtWaMkJhCdnY2ACA+Pp5KAhBCiIEoUbJRQUFB+PWvf4158+bB0dERYrEYJ0+exO7du3VFCIntEYvFqKioANCeKBFCCDEMJUo2jMfjYdy4cXjttdfwyCOPwM7ODo2NjTh8+DBaW1vNHR4ZADk5OQCA0NBQuLq6mjkaQgixfrRGaRDg8/mYNGkSRo8ejQsXLoDD4cDT01PX0Fej0dD6JRvh6emJkJAQjBw50tyhEEKITaCCk/9lqQUnB5JWq0V5eTn279+PyZMnIzo6mta0WDmGYeDk5GTuMAghxGSo4CQZMBwOB3fu3EFbWxtOnDiBH3/8EY2NjeYOixiAz+ebOwRCCLEplCgNcgsXLsSsWbPA4/FQWVmJ3bt349KlS1CpVOYOjfSBRqPBnTt3IJfLzR0KIYTYFEqUBjkul4vJkyfj5ZdfRlRUFLRaLW7duoWdO3eiqKjI3OGRXiotLcW5c+ewbds2amNDCCFGRIkSAQC4ubnhqaeewooVK+Dq6gqxWAyxWGzusEgvddROonVmhBBiXLTrjegZPnw4hg4ditu3b2Ps2LFQq9VQKpVoaWmBs7Mz7Y6zQAqFAnfv3gVAtZMIIcTYKFEinQgEAkyYMAEAdInRoUOHwOfzMXv2bPj5+ZkzPPKA/Px8allCCCEDhKbeSI+ampqgUChQX1+PH374ARcuXKDF3haCZVmkpaUBAEaOHEnTboQQYmSUKJEe+fv74+WXX0ZsbCxYlsXt27exa9cuaoViAaqrq1FXVwcej4fRo0ebOxxCCLE5lCiRXnF0dMSTTz6JlStXwsXFBSKRCAcPHsSJEyegVqvNHd6g1dDQAC6Xi9jYWDg4OJg7HEIIsTm0Ron0SWRkJEJCQnDmzBncunULcrmcFnibUXx8PEaOHAmtVmvuUAghxCZRokT6TCgU4tFHH0VcXBxcXFzg4OAAuVwOqVQKtVoNZ2dnc4c4aPD5fNjZ2Zk7DEIIsVk09Ub6LTg4GK6uruDxeHB0dMTly5exc+dOZGZmUtHDAaZWq1FfX08tSwghZIBRokSMQqPRoLm5GUqlEidPnsS///1vSKVSc4dls/Ly8rB7924cPXrU3KEQQohNo0SJGAWPx8P69esxa9YscDgc3L17F7t27dIVQiTGw7Is7ty5AwDw8fExczSEEGLbKFEiRsPhcDB58mRs3LgRPj4+kEqlOHr0KE6cOAGFQmHu8GxGVVUVlQQghBAToUSJGJ2fnx82btyoq+5dUlJCa5aMKDU1FQAQFxdHJQEIIWSA0a43MiB4PB7mzJmDqKgoqFQquLu7Qy6XQ6vVQi6Xw97e3twhWqXW1lbk5+cDAMaOHWvmaAghxPbRiBIZUCEhIYiIiNDtjCssLMS3336L7OxsGmXqh5SUFLAsi5CQEOq5RwghJkCJEjEZhmGQlZUFhUKB48eP49ChQxCJROYOy2potVqUlJQAACZNmmTeYAghZJBgWPpaDwAQi8VwdXWFSCSCi4uLucOxWRqNBteuXcP58+eh0WjA5/MxadIkjBo1ChwO5e094XA4KCkpQXR0NDXAJYQQDPznNyVK/0WJkmk1NDTgp59+QllZGYD2xrtz5syBp6enmSOzbE5OTpQgEULIfQb685u+whOz8PLywrp16/DYY49BIBCgurqaClQ+RHFxMbhcLiVJhBBiYrTrjZgNwzBITExEZGQk8vPzMXz4cMjlcmg0GigUCgiFQnOHaBFqampw+PBheHp64oUXXqC2JYQQYkI0okTMzsXFBYmJieBwOHBwcIBUKsU333yDa9euQaPRmDs8s7t8+TIAICgoiJIkQggxMUqUiMXJzc2FQqHAtWvXsGfPHtTV1Zk7JLMpLS1FWVkZuFwupk+fbu5wCCFk0KFEiVicqVOn4sknn4S9vT3q6+uxZ88eXLlyZdCNLrEsqxtNSkxMhJubm3kDIoSQQYgSJWJxGIZBbGwsXnrpJURHR0Or1eLGjRv4/vvvUVtba+7wTCY3Nxe1tbUQCASYMmWKucMhhJBBiRIlYrGcnJywbNkyLF26FA4ODmhoaEBhYaG5wzKJ1tZWnD17FgAwceJEODo6mjkiQggZnGjXG7F4MTExCA0NxdWrVzFt2jSo1WpoNBpoNBpwuVxzhzcgGIZBQEAA5HI5Jk+ebO5wCCFk0KKCk/9FBSeti0wmw86dOxEUFISJEyfa3G4wDocDe3t7yOVyODg4mDscQgixWAP9+U0jSsQqlZaWora2FrW1tSgqKsKcOXMQGBho7rAMplKpwOfzYWdnpyuXQAghxHxsZo3SX/7yF0ycOBEODg60O2gQGD58OFauXAlnZ2c0Nzdj3759OHPmDBQKhblD6zeNRoMff/wRZ86cgVqtNnc4hBBCYEOJklKpxLJly/Diiy+aOxRiIpGRkXjxxRcxatQoAEBaWhp27NiB/Px8WOOM8vXr11FbW4u8vDyrTvgIIcSW2MzU27vvvgsA2LFjh3kDISZlb2+PxYsXIz4+Hv/5z3/Q1NSElJQUDBs2zNyh9UlpaSlu3rwJAFiwYAGtkyOEEAthM4lSXykUCr1v7WKx2IzREEOFhYXhxRdfxKVLlxATEwOhUAilUgmlUgkOhwMez3J/1CsqKnD06FGwLIv4+HjExMSYOyRCCCH/ZTNTb331wQcf/P/27jQmqqsPA/gzwLDDyLAjOlI2EREVW3FpcaEqFcFgLRqbSLQYY7VqrB+0WrEx1i6SVE1d6lIbG2lTcUloqLayFrVuVKAUERBQWSqKICDbnPeD9b6OMiB1hvX5JZM4955z75n7eGf+3GUGCoVCegwaNKi7h0QvycjICJMnT4aDgwNMTExgYWGBc+fO4fDhwygoKOiRp+Pu3LmD48ePo6WlBR4eHpg1a1Z3D4mIiJ7SowulmJgYyGSydh+XLl36T8tet24dHjx4ID1KS0t1PHrqbq2trbhx4wYePHiAkydPIj4+HlVVVd09LElzczNOnTqF5uZmvPLKK3jnnXd69JEvIqL+qEd/j9Ldu3dx9+7ddtsMGTIEpqam0vNvv/0Wq1atQnV1dafWxe9R6puampqQlpaGc+fOobW1FTKZDMOGDUNgYCAUCkV3Dw/l5eW4ePEi5s6d2+e+C4qIqCv06+9RsrOzg52dXXcPg3oxY2NjTJ06FaNGjcLp06eRl5eHnJwc5ObmYubMmd1y0XdNTQ2sra1hamoKT0/PXnfhORFRf9KjC6XOKCkpwb1791BSUoLW1lZkZmYCADw8PGBpadm9g6Nup1QqMW/ePNy6dQtnz57FrVu3oFKppPld8XMoDQ0NSElJwfXr1xEdHQ0rKyu9ro+IiF5ejz711hlRUVE4fPjwc9OTkpIwadKkDvvz1Fv/Ul1djQEDBkCtVqOpqQlHjhyBsbExRo0aBZVKBZlMptP15efn47fffkN9fT0AYObMmRgzZoxO10FE1B/p+/O7zxRKL4uFUv9179497Ny5U3puY2MDX19fuLu7Q6lU/ueiSQiB27dv4+rVq8jPzwfw+HRyWFgY77IkItIRFkpdhIVS/1ZVVYU//vgDmZmZaGpqkqZbW1tjwoQJ8PHx6fQyjx07huLiYgCATCbDhAkTEBQUxDvbiIh0qF9fzE3UVWxtbRESEoIpU6YgOzsbf//9N4qKilBTUyP9QK1arUZBQQHOnz8Pa2trKBQKCCFQX1+PhoYGNDQ0YPr06bC3t4dcLseQIUNQXl6OoUOHYuzYsXB2du7ul0lERJ3EQonoKSYmJggICEBAQACamppQVFQENzc3GBsbAwBqa2tRUVGBioqKNvu3tLRINw+MGzcOEydO5BEkIqJejO/gRFoYGxvD29tbY9qIESNgb2+P6upqVFdXw8DAABYWFjA3N4eFhQVcXFyktiYmJl09ZCIi0jEWSkSd8OQnb4iIqH9gofSvJ9e088dxiYiIeo8nn9v6ujeNhdK/nvwGGG/bJiIi6n2qqqr0csSfhdK/lEolgMff8M1TK92vpqYGgwYNQmlpKb+uoZsxi56DWfQczKLnePDgAQYPHix9jusaC6V/GRgYAHh8DQr/0/cc1tbWzKOHYBY9B7PoOZhFz/Hkc1zny9XLUomIiIj6ABZKRERERFqwUPqXiYkJNm3axO++6SGYR8/BLHoOZtFzMIueQ99Z8LfeiIiIiLTgESUiIiIiLVgoEREREWnBQomIiIhIi35VKH366aeQyWRYtWqVNC0qKgoymUzjERgYqNGvsbERK1asgJ2dHSwsLBAWFoZbt2518ej7lrayAIDc3FyEhYVBoVDAysoKgYGBKCkpkeYzC91rK4tn94knjy+++EJqwyx0r60sHj58iOXLl8PV1RVmZmbw8fHB7t27NfoxC/1oK4+KigpERUXBxcUF5ubmmDFjBvLz8zX6MY+XFxMT89z7j5OTkzRfCIGYmBi4uLjAzMwMkyZNQk5OjsYydJVDvymULl68iH379mHEiBHPzZsxYwbKysqkx88//6wxf9WqVTh+/Dji4uKQnp6Ohw8fIjQ0FK2trV01/D5FWxYFBQWYOHEihg4diuTkZPz555/YuHEjTE1NpTbMQre0ZfH0/lBWVoaDBw9CJpNhzpw5UhtmoVvasli9ejUSExNx5MgR5ObmYvXq1VixYgVOnjwptWEWutdWHkIIzJ49G4WFhTh58iSuXr0KlUqF4OBg1NXVSe2Yh274+vpqvA9lZWVJ8z7//HPExsZi165duHjxIpycnPDmm2+itrZWaqOzHEQ/UFtbKzw9PcWZM2dEUFCQWLlypTRv4cKFIjw8XGvf6upqIZfLRVxcnDTt9u3bwsDAQCQmJupx1H1Te1lERkaKd999V2tfZqFb7WXxrPDwcDFlyhTpObPQrfay8PX1FZ988olG+9GjR4sNGzYIIZiFPmjLIy8vTwAQ2dnZUtuWlhahVCrFN998I4RgHrqyadMm4e/v3+Y8tVotnJycxLZt26Rpjx49EgqFQuzZs0cIodsc+sURpffffx8zZ85EcHBwm/OTk5Ph4OAALy8vREdHo7KyUpp3+fJlNDc3Y9q0adI0FxcXDB8+HBkZGXofe1+jLQu1Wo2EhAR4eXlh+vTpcHBwwNixY3HixAmpDbPQrY72iycqKiqQkJCAxYsXS9OYhW61l8XEiRNx6tQp3L59G0IIJCUl4fr165g+fToAZqEP2vJobGwEAI2j3IaGhjA2NkZ6ejoA5qFL+fn5cHFxgZubG+bNm4fCwkIAQFFREcrLyzW2sYmJCYKCgqRtrMsc+vxvvcXFxeHKlSu4ePFim/NDQkIwd+5cqFQqFBUVYePGjZgyZQouX74MExMTlJeXw9jYGDY2Nhr9HB0dUV5e3hUvoc9oL4vKyko8fPgQ27Ztw5YtW/DZZ58hMTERERERSEpKQlBQELPQoY72i6cdPnwYVlZWiIiIkKYxC93pKIsdO3YgOjoarq6uMDIygoGBAfbv34+JEycCYBa61l4eQ4cOhUqlwrp167B3715YWFggNjYW5eXlKCsrA8A8dGXs2LH47rvv4OXlhYqKCmzZsgXjx49HTk6OtB0dHR01+jg6OqK4uBiAbnPo04VSaWkpVq5cidOnT2v8BfC0yMhI6d/Dhw/HmDFjoFKpkJCQoPHB8CwhBGQymc7H3Fd1lIVarQYAhIeHY/Xq1QCAkSNHIiMjA3v27EFQUJDWZTOLznmR/eJpBw8exIIFC16oLbPonBfJYseOHTh//jxOnToFlUqF1NRULFu2DM7Ozu0eDWQWnddRHnK5HMeOHcPixYuhVCphaGiI4OBghISEdLhs5tE5T29TPz8/jBs3Du7u7jh8+LB0w9Wz2/NFtvF/yaFPn3q7fPkyKisrERAQACMjIxgZGSElJQU7duyAkZFRmxd0OTs7Q6VSSXcxODk5oampCffv39doV1lZ+Vw1S9p1lIWtrS2MjIwwbNgwjX4+Pj7SXW/MQjc6s1+kpaUhLy8P7733nsYymIVudJRFXV0d1q9fj9jYWMyaNQsjRozA8uXLERkZiS+//BIAs9ClF9k3AgICkJmZierqapSVlSExMRFVVVVwc3MDwDz0xcLCAn5+fsjPz5fufnv2yNDT21iXOfTpQmnq1KnIyspCZmam9BgzZgwWLFiAzMxMGBoaPtenqqoKpaWlcHZ2BgAEBARALpfjzJkzUpuysjJkZ2dj/PjxXfZaeruOsjAxMcGrr76KvLw8jX7Xr1+HSqUCwCx0pTP7xYEDBxAQEAB/f3+NZTAL3egoi9bWVjQ3N8PAQPOt2tDQUDoKyyx0pzP7hkKhgL29PfLz83Hp0iWEh4cDYB760tjYiNzcXDg7O8PNzQ1OTk4a27ipqQkpKSnSNtZpDp269LsPePoOhtraWrFmzRqRkZEhioqKRFJSkhg3bpwYOHCgqKmpkfosXbpUuLq6il9//VVcuXJFTJkyRfj7+4uWlpZuehV9w7N398THxwu5XC727dsn8vPzxc6dO4WhoaFIS0uT2jAL/WjrrrcHDx4Ic3NzsXv37jb7MAv9eDaLoKAg4evrK5KSkkRhYaE4dOiQMDU1FV9//bXUhlnoz7N5/PjjjyIpKUkUFBSIEydOCJVKJSIiIjT6MI+Xt2bNGpGcnCwKCwvF+fPnRWhoqLCyshI3b94UQgixbds2oVAoRHx8vMjKyhLz588Xzs7Oevns7teFUn19vZg2bZqwt7cXcrlcDB48WCxcuFCUlJRo9GloaBDLly8XSqVSmJmZidDQ0OfaUOe19eF84MAB4eHhIUxNTYW/v784ceKExnxmoR9tZbF3715hZmYmqqur2+zDLPTj2SzKyspEVFSUcHFxEaampsLb21ts375dqNVqqQ2z0J9n8/jqq6+Eq6ur9JmxYcMG0djYqNGHeby8yMhI4ezsLORyuXBxcREREREiJydHmq9Wq8WmTZuEk5OTMDExEW+88YbIysrSWIaucpAJIYROjosRERER9TF9+holIiIiopfBQomIiIhICxZKRERERFqwUCIiIiLSgoUSERERkRYslIiIiIi0YKFEREREpAULJSIiIiItWCgRERERacFCiYh6rJiYGIwcObLb1r9x40YsWbLkhdp++OGH+OCDD/Q8IiLqavwJEyLqFjKZrN35CxcuxK5du9DY2AhbW9suGtX/VVRUwNPTE9euXcOQIUM6bF9ZWQl3d3dcu3YNbm5u+h8gEXUJFkpE1C3Ky8ulf//www/4+OOPkZeXJ00zMzODQqHojqEBALZu3YqUlBT88ssvL9xnzpw58PDwwGeffabHkRFRV+KpNyLqFk5OTtJDoVBAJpM9N+3ZU29RUVGYPXs2tm7dCkdHRwwYMACbN29GS0sL1q5dC6VSCVdXVxw8eFBjXbdv30ZkZCRsbGxga2uL8PBw3Lx5s93xxcXFISwsTGPaTz/9BD8/P5iZmcHW1hbBwcGoq6uT5oeFheHo0aMvvW2IqOdgoUREvcrZs2dx584dpKamIjY2FjExMQgNDYWNjQ0uXLiApUuXYunSpSgtLQUA1NfXY/LkybC0tERqairS09NhaWmJGTNmoKmpqc113L9/H9nZ2RgzZow0raysDPPnz8eiRYuQm5uL5ORkRERE4OmD8q+99hpKS0tRXFys341ARF2GhRIR9SpKpRI7duyAt7c3Fi1aBG9vb9TX12P9+vXw9PTEunXrYGxsjN9//x3A4yNDBgYG2L9/P/z8/ODj44NDhw6hpKQEycnJba6juLgYQgi4uLhI08rKytDS0oKIiAgMGTIEfn5+WLZsGSwtLaU2AwcOBIAOj1YRUe9h1N0DICLqDF9fXxgY/P9vPEdHRwwfPlx6bmhoCFtbW1RWVgIALl++jBs3bsDKykpjOY8ePUJBQUGb62hoaAAAmJqaStP8/f0xdepU+Pn5Yfr06Zg2bRrefvtt2NjYSG3MzMwAPD6KRUR9AwslIupV5HK5xnOZTNbmNLVaDQBQq9UICAjA999//9yy7O3t21yHnZ0dgMen4J60MTQ0xJkzZ5CRkYHTp09j586d+Oijj3DhwgXpLrd79+61u1wi6n146o2I+rTRo0cjPz8fDg4O8PDw0Hhou6vO3d0d1tbW+OuvvzSmy2QyTJgwAZs3b8bVq1dhbGyM48ePS/Ozs7Mhl8vh6+ur19dERF2HhRIR9WkLFiyAnZ0dwsPDkZaWhqKiIqSkpGDlypW4detWm30MDAwQHByM9PR0adqFCxewdetWXLp0CSUlJYiPj8c///wDHx8fqU1aWhpef/116RQcEfV+LJSIqE8zNzdHamoqBg8ejIiICPj4+GDRokVoaGiAtbW11n5LlixBXFycdArP2toaqampeOutt+Dl5YUNGzZg+/btCAkJkfocPXoU0dHRen9NRNR1+IWTRERtEEIgMDAQq1atwvz58ztsn5CQgLVr1+LatWswMuLln0R9BY8oERG1QSaTYd++fWhpaXmh9nV1dTh06BCLJKI+hkeUiIiIiLTgESUiIiIiLVgoEREREWnBQomIiIhICxZKRERERFqwUCIiIiLSgoUSERERkRYslIiIiIi0YKFEREREpAULJSIiIiIt/gdX/WMCYzbEjAAAAABJRU5ErkJggg==",
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "plt.plot(t, flux_total, linewidth=3)\n",
- "plt.plot(t[1:], contribution_trap_1, linestyle=\"--\", color=\"grey\")\n",
- "plt.fill_between(t[1:], 0, contribution_trap_1, facecolor=\"grey\", alpha=0.1)\n",
- "plt.plot(t[1:], contribution_trap_2, linestyle=\"--\", color=\"grey\")\n",
- "plt.fill_between(t[1:], 0, contribution_trap_2, facecolor=\"grey\", alpha=0.1)\n",
- "\n",
- "plt.xlim(450, 500)\n",
- "plt.ylim(bottom=-1.25e18, top=0.6e19)\n",
- "plt.ylabel(r\"Desorption flux (m$^{-2}$ s$^{-1}$)\")\n",
- "plt.xlabel(r\"Time (s)\")\n",
- "\n",
- "plt.ylabel(r\"Desorption flux (m$^{-2}$ s$^{-1}$)\")\n",
- "plt.xlabel(r\"Time (s)\")"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Task\n",
- "1) Increase the implantation temperature to 500 K and see how the TDS spectrum is affected\n",
- "2) Vary the detrapping energy of the first trap\n",
- "3) At the end of the implantation phase, what is the proportion of hydrogen trapped in trap 2?"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 17,
- "metadata": {
- "tags": [
- "hide-cell"
- ]
- },
- "outputs": [
- {
- "data": {
- "image/png": "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",
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "plt.stackplot(\n",
- " t,\n",
- " total_trapped_H1.data,\n",
- " total_trapped_H2.data,\n",
- " total_mobile_H.data,\n",
- " labels=[\"trapped H1\", \"trapped H2\", \"mobile H\"],\n",
- " alpha=0.5,\n",
- ")\n",
- "plt.legend(reverse=True)\n",
- "plt.ylabel(r\"Inventory (m$^{-2}$)\")\n",
- "plt.xlabel(r\"Time (s)\")\n",
- "plt.show()"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "festim-workshop",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.13.5"
- },
- "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/book/content/applications/task03.ipynb b/book/content/applications/task03.ipynb
deleted file mode 100644
index 41242b17..00000000
--- a/book/content/applications/task03.ipynb
+++ /dev/null
@@ -1,325 +0,0 @@
-{
- "cells": [
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Simple permeation simulation\n",
- "\n",
- "In this task, we'll go through the basics of FESTIM and run a simple permeation simulation on a 1D domain."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [],
- "source": [
- "import festim as F"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The first step is to create a model using a `Simulation` object."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {},
- "outputs": [],
- "source": [
- "my_model = F.HydrogenTransportProblem()\n",
- "\n",
- "H = F.Species(\"H\")\n",
- "my_model.species = [H]"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We'll consider a 3 mm-thick material and a regular mesh (1000 cells)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [],
- "source": [
- "import numpy as np\n",
- "\n",
- "my_model.mesh = F.Mesh1D(vertices=np.linspace(0, 3e-4, num=1001))"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "`Material` objects hold the materials properties like diffusivity and solubility.\n",
- "\n",
- "Here we only need the diffusivity defined as an Arrhenius law: $D = D_0 \\exp{(-E_D/k_B T)}$ 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 units m2/s, and the diffusion actiavtion energy, $E_D$ in units eV are needed.`"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [],
- "source": [
- "material = F.Material(D_0=1.9e-7, E_D=0.2)\n",
- "\n",
- "volume_subdomain = F.VolumeSubdomain1D(id=1, borders=(0, 3e-4), material=material)\n",
- "left_boundary = F.SurfaceSubdomain1D(id=1, x=0)\n",
- "right_boundary = F.SurfaceSubdomain1D(id=2, x=3e-4)\n",
- "\n",
- "my_model.subdomains = [volume_subdomain, left_boundary, right_boundary]"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The temperature is set at 500 K"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {},
- "outputs": [],
- "source": [
- "my_model.temperature = 500"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "FESTIM has a `SievertsBC` class representing Sievert's law of solubility: $c = S \\ \\sqrt{P}$ at metal surfaces.\n",
- "\n",
- "> Note:\n",
- "> \n",
- "> A similar class exists for non-metallic materials behaving according to Henry's law: `HenrysBC`\n",
- "\n",
- "We'll use this boundary condition on the left surface (`id=1`) and will assume a zero concentration on the right side (`id=2`)."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {},
- "outputs": [],
- "source": [
- "P_up = 100 # Pa\n",
- "\n",
- "my_model.boundary_conditions = [\n",
- " F.SievertsBC(subdomain=left_boundary, S_0=4.02e21, E_S=1.04, pressure=P_up, species=H),\n",
- " F.FixedConcentrationBC(subdomain=right_boundary, value=0, species=H),\n",
- "]"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "With `Settings` we set the main solver parameters."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {},
- "outputs": [],
- "source": [
- "my_model.settings = F.Settings(atol=1e-2, rtol=1e-10, final_time=100) # s"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Let's choose a stepsize small enough to have good temporal resolution:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "metadata": {},
- "outputs": [],
- "source": [
- "my_model.settings.stepsize = F.Stepsize(1 / 20)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "For this permeation experiment, we are only interested in the hydrogen flux on the right side:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "metadata": {},
- "outputs": [],
- "source": [
- "permeation_flux = F.SurfaceFlux(field=H, surface=right_boundary)\n",
- "\n",
- "my_model.exports = [permeation_flux]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "Solving HydrogenTransportProblem: 0%| | 0.00/100 [00:00"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "times = permeation_flux.t\n",
- "\n",
- "D = 1.9e-7 * np.exp(-0.2 / F.k_B / 500)\n",
- "S = 4.02e21 * np.exp(-1.04 / F.k_B / 500)\n",
- "\n",
- "import matplotlib.pyplot as plt\n",
- "\n",
- "plt.scatter(times, np.abs(permeation_flux.data), alpha=0.2, label=\"computed\")\n",
- "plt.plot(\n",
- " times,\n",
- " downstream_flux(times, P_up, permeability=D * S, L=3e-4, D=D),\n",
- " color=\"tab:orange\",\n",
- " label=\"analytical\",\n",
- ")\n",
- "plt.ylim(bottom=0)\n",
- "plt.xlabel(\"Time (s)\")\n",
- "plt.ylabel(\"Downstream flux (H/m2/s)\")\n",
- "plt.show()"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Phew! We have a good agreement between our model and the analytical solution!\n",
- "\n",
- "To reproduce simple permeation experiments, the analytical solution is obviously enough.\n",
- "However, for more complex scenarios (transients, trapping regimes,..) a numerical model provides more flexibility."
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "festim-workshop",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.13.3"
- },
- "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/book/content/applications/task04.ipynb b/book/content/applications/task04.ipynb
deleted file mode 100644
index 5ad477ab..00000000
--- a/book/content/applications/task04.ipynb
+++ /dev/null
@@ -1,525 +0,0 @@
-{
- "cells": [
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Permeation barrier modelling\n",
- "\n",
- "In this task, we will model permeation barriers on tungsten and compute the associated Permeation Reduction Factor (PRF).\n",
- "\n",
- "The PRF is the ratio of the steady state permeation flux without barriers by that of the case with barriers."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 1) Model with barrier\n",
- "\n",
- "Let's first create a model where tungsten is coated with 1 micron of barrier material on both sides."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [],
- "source": [
- "import festim as F\n",
- "\n",
- "model_barrier = F.HydrogenTransportProblemDiscontinuous()"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Let's create three ``VolumeSubdomain1D`` instances for the three subdomains and assign them to ``model_barrier.subdomains``.\n",
- "\n",
- "```{admonition} Note\n",
- "By default, the solubility law of the materials is `\"sievert\"`.\n",
- "However, it can be changed by overriding the `solubility_law` argument to `\"henry\"`\n",
- "```"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {},
- "outputs": [],
- "source": [
- "barrier_thick = 1e-6\n",
- "substrate_thick = 3e-3\n",
- "\n",
- "barrier = F.Material(\n",
- " D_0=1e-8,\n",
- " E_D=0.39,\n",
- " K_S_0=1e22,\n",
- " E_K_S=1.04,\n",
- ")\n",
- "\n",
- "tungsten = F.Material(\n",
- " D_0=4.1e-7,\n",
- " E_D=0.39,\n",
- " K_S_0=1.87e24,\n",
- " E_K_S=1.04,\n",
- ")\n",
- "\n",
- "volume_barrier_left = F.VolumeSubdomain1D(\n",
- " id=1, borders=[0, barrier_thick], material=barrier\n",
- ")\n",
- "volume_tungsten = F.VolumeSubdomain1D(\n",
- " id=2, borders=[barrier_thick, substrate_thick + barrier_thick], material=tungsten\n",
- ")\n",
- "volume_barrier_right = F.VolumeSubdomain1D(\n",
- " id=3,\n",
- " borders=[substrate_thick + barrier_thick, substrate_thick + 2 * barrier_thick],\n",
- " material=barrier,\n",
- ")\n",
- "\n",
- "boundary_left = F.SurfaceSubdomain1D(id=1, x=0)\n",
- "boundary_right = F.SurfaceSubdomain1D(id=2, x=substrate_thick + 2 * barrier_thick)\n",
- "\n",
- "model_barrier.subdomains = [\n",
- " volume_barrier_left,\n",
- " volume_tungsten,\n",
- " volume_barrier_right,\n",
- " boundary_left,\n",
- " boundary_right,\n",
- "]\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [],
- "source": [
- "model_barrier.surface_to_volume = {\n",
- " boundary_left: volume_barrier_left,\n",
- " boundary_right: volume_barrier_right,\n",
- "}\n",
- "\n",
- "model_barrier.interfaces = [\n",
- " F.Interface(id=3, subdomains=[volume_barrier_left, volume_tungsten], penalty_term=1e10),\n",
- " F.Interface(id=4, subdomains=[volume_tungsten, volume_barrier_right], penalty_term=1e10),\n",
- "]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [],
- "source": [
- "H = F.Species(\"H\", subdomains=model_barrier.volume_subdomains)\n",
- "model_barrier.species = [H]"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "To avoid cells overlapping the domains boundaries, we create 3 lists of vertices."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {},
- "outputs": [],
- "source": [
- "import numpy as np\n",
- "\n",
- "vertices_left = np.linspace(0, barrier_thick, num=50)\n",
- "\n",
- "vertices_mid = np.linspace(barrier_thick, substrate_thick + barrier_thick, num=50)\n",
- "\n",
- "vertices_right = np.linspace(\n",
- " substrate_thick + barrier_thick, substrate_thick + 2 * barrier_thick, num=50\n",
- ")\n",
- "\n",
- "vertices = np.concatenate([vertices_left, vertices_mid, vertices_right])\n",
- "\n",
- "model_barrier.mesh = F.Mesh1D(vertices)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The temperature is homogeneous across the domain."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {},
- "outputs": [],
- "source": [
- "model_barrier.temperature = 600"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "A Sievert's boundary condition is applied on the left surface and the concentration is assumed to be zero on the right surface."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {},
- "outputs": [],
- "source": [
- "left_bc = F.SievertsBC(\n",
- " subdomain=boundary_left, S_0=barrier.K_S_0, E_S=barrier.E_K_S, pressure=100, species=H\n",
- ")\n",
- "\n",
- "right_bc = F.FixedConcentrationBC(species=H, subdomain=boundary_right, value=0)\n",
- "\n",
- "model_barrier.boundary_conditions = [left_bc, right_bc]"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "For this task, we want to compute the permeation flux, that is the flux at the right surface.\n",
- "\n",
- "We will also export the concentration profiles at three different times"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "metadata": {},
- "outputs": [],
- "source": [
- "permeation_flux = F.SurfaceFlux(field=H, surface=boundary_right)\n",
- "\n",
- "vtx_exports = [\n",
- " F.VTXSpeciesExport(filename=f\"h_{i}.bp\", field=H, subdomain=vol) for i, vol in enumerate(model_barrier.volume_subdomains)\n",
- "]\n",
- "\n",
- "\n",
- "profile_exports = [\n",
- " F.Profile1DExport(field=spe, subdomain=vol, times=[100, 17000, 8e5])\n",
- " for spe in model_barrier.species\n",
- " for vol in model_barrier.volume_subdomains\n",
- "]\n",
- "model_barrier.exports = [permeation_flux] + vtx_exports + profile_exports"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "metadata": {},
- "outputs": [],
- "source": [
- "model_barrier.settings = F.Settings(\n",
- " atol=1e0,\n",
- " rtol=1e-09,\n",
- " final_time=8e5,\n",
- ")\n",
- "\n",
- "\n",
- "model_barrier.settings.stepsize = F.Stepsize(\n",
- " initial_value=5, growth_factor=1.1, cutback_factor=0.9, target_nb_iterations=4, milestones=[100, 17000, 8e5]\n",
- ")"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "99a7e32250034788baab765e005fa956",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Solving HydrogenTransportProblemDiscontinuous: 0%| | 0.00/800k [00:00"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "import matplotlib.pyplot as plt\n",
- "\n",
- "xlim_left = (0, barrier_thick * 2)\n",
- "xlim_mid = (None, None)\n",
- "xlim_right = (substrate_thick, substrate_thick + 2 * barrier_thick)\n",
- "\n",
- "fig, axs = plt.subplots(nrows=1, ncols=3, sharey=True, figsize=(20, 4))\n",
- "\n",
- "# three shades of blue for the three times\n",
- "colours = [\"#1f77b4\", \"#185580\", \"#0C273B\"]\n",
- "\n",
- "for ax, xlim in zip(axs, [xlim_left, xlim_mid, xlim_right]):\n",
- " plt.sca(ax)\n",
- " for profile in profile_exports:\n",
- " for i, time in enumerate(profile.times):\n",
- " label = f\"{time:.0f} s\" if ax == axs[0] and profile == profile_exports[0] else None\n",
- " c = profile.data[i]\n",
- " ax.plot(profile.x, c, color=colours[i], label=label)\n",
- "\n",
- " ax.set_xlim(xlim)\n",
- " ax.set_xlabel(\"Depth (m)\")\n",
- "\n",
- "axs[0].legend(fontsize=12, reverse=True)\n",
- "axs[0].set_yscale(\"log\")\n",
- "axs[0].set_ylim(bottom=1e12)\n",
- "axs[0].set_ylabel(\"Mobile H concentration (H/m$^3$)\")\n",
- "axs[0].set_title(\"zoom left\")\n",
- "axs[2].set_title(\"zoom right\")\n",
- "plt.show()"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 2) 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:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 12,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "6bdfa35141f1441aa12f5ca1a147ac1a",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Solving HydrogenTransportProblem: 0%| | 0.00/800k [00:00"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "import matplotlib.pyplot as plt\n",
- "plt.figure()\n",
- "\n",
- "plt.plot(permeation_flux_no_barrier.t, permeation_flux_no_barrier.data, label=\"without barrier\")\n",
- "plt.plot(permeation_flux.t, permeation_flux.data, label=\"with barrier\")\n",
- "\n",
- "plt.xscale(\"log\")\n",
- "plt.legend()\n",
- "plt.xlabel(\"Time (s)\")\n",
- "plt.ylabel(\"Permeation flux (H/m2/s)\")\n",
- "plt.show()"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Clearly, having the coating on both sides reduces the permeation flux!\n",
- "\n",
- "Moreover, it can be shown that the PRF of this configuration is:\n",
- "\n",
- "$$\\mathrm{PRF} = 1 + 2 \\alpha \\beta \\gamma$$\n",
- "\n",
- "With \n",
- "\n",
- "$$\\alpha = D_\\mathrm{substrate} / D_\\mathrm{barrier} $$\n",
- "\n",
- "$$\\beta = S_\\mathrm{substrate} / S_\\mathrm{barrier} $$\n",
- "\n",
- "$$\\gamma = e_\\mathrm{barrier} / e_\\mathrm{substrate} $$\n",
- "\n",
- "We can compare the computed PRF to the theory."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 14,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Theoretical PRF = 6.1113\n",
- "Computed PRF = 6.0617\n",
- "Error = -0.81%\n"
- ]
- }
- ],
- "source": [
- "computed_PRF = permeation_flux_no_barrier.data[-1] / permeation_flux.data[-1]\n",
- "\n",
- "diff_ratio = tungsten.D_0 / barrier.D_0\n",
- "sol_ratio = tungsten.K_S_0 / barrier.K_S_0\n",
- "length_ratio = barrier_thick / substrate_thick\n",
- "\n",
- "theoretical_PRF = 1 + 2 * diff_ratio * sol_ratio * length_ratio\n",
- "\n",
- "print(f\"Theoretical PRF = {theoretical_PRF:.4f}\")\n",
- "print(f\"Computed PRF = {computed_PRF:.4f}\")\n",
- "print(f\"Error = {(computed_PRF - theoretical_PRF)/theoretical_PRF:.2%}\")"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Question\n",
- "Will adding traps to the simulation change the value of the PRF?\n",
- "\n",
- "\n",
- "Show solution
\n",
- "
\n",
- "No. The PRF is a measure of the flux of mobile particles and is computed at steady state.\n",
- "\n",
- "At steady state, the McNabb & Foster model states that the concentration of mobile particle is independent of the trapped concentration.\n",
- "\n",
- "Therefore, the steady state PRF is independent of trapping.\n",
- "\n",
- " "
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "festim-workshop",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.13.5"
- },
- "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/book/content/applications/task06.ipynb b/book/content/applications/task06.ipynb
deleted file mode 100644
index 77b24695..00000000
--- a/book/content/applications/task06.ipynb
+++ /dev/null
@@ -1,438 +0,0 @@
-{
- "cells": [
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Advection-diffusion problem\n",
- "\n",
- "In this task, we'll simulate advection-diffusion in a fluid domain.\n",
- "\n",
- "Natively, advection is not taken into account in FESTIM. The idea is therefore to modify the governing equations by adding an advection term."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [],
- "source": [
- "import festim as F\n",
- "\n",
- "my_model = F.HydrogenTransportProblem()\n",
- "\n",
- "H = F.Species(\"H\")\n",
- "my_model.species = [H]"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Create a mesh with FEniCS:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {},
- "outputs": [],
- "source": [
- "from dolfinx.mesh import create_unit_square\n",
- "from mpi4py import MPI\n",
- "\n",
- "# creating a mesh with FEniCS\n",
- "nx = ny = 20\n",
- "mesh_fenics = create_unit_square(MPI.COMM_WORLD, nx, ny)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {
- "tags": [
- "hide-cell"
- ]
- },
- "outputs": [],
- "source": [
- "import pyvista\n",
- "\n",
- "pyvista.start_xvfb()\n",
- "pyvista.set_jupyter_backend('html')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "0cae32a2a8d5456ea092a74ae0201c4f",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "EmbeddableWidget(value='