From ddad2245e8db3fbe4dd959d16ad4d9f6024a2551 Mon Sep 17 00:00:00 2001 From: ckhurana Date: Thu, 23 Oct 2025 12:38:48 -0400 Subject: [PATCH 01/11] rebasing applications section --- book/content/applications/fission/index.md | 15 + .../fusion/fuel_cycle/fuel_cycle_map.md | 31 ++ .../applications/fusion/fuel_cycle/test.svg | 84 ++++ book/content/applications/fusion/index.md | 15 + .../content/applications/general/advection.md | 228 ++++++++++ .../applications/general/heat_transfer.md | 157 +++++++ book/content/applications/general/index.md | 15 + .../content/applications/general/monoblock.md | 303 +++++++++++++ .../general/permeation_barrier.md | 304 +++++++++++++ book/content/applications/general/simple.md | 265 +++++++++++ .../applications/general/simple_permeation.md | 154 +++++++ .../material_science/fitting_tds.md | 416 +++++++++++++++++ .../applications/material_science/index.md | 15 + .../material_science/microstructure.md | 426 ++++++++++++++++++ .../applications/material_science/tds.md | 325 +++++++++++++ 15 files changed, 2753 insertions(+) create mode 100644 book/content/applications/fission/index.md create mode 100644 book/content/applications/fusion/fuel_cycle/fuel_cycle_map.md create mode 100644 book/content/applications/fusion/fuel_cycle/test.svg create mode 100644 book/content/applications/fusion/index.md create mode 100644 book/content/applications/general/advection.md create mode 100644 book/content/applications/general/heat_transfer.md create mode 100644 book/content/applications/general/index.md create mode 100644 book/content/applications/general/monoblock.md create mode 100644 book/content/applications/general/permeation_barrier.md create mode 100644 book/content/applications/general/simple.md create mode 100644 book/content/applications/general/simple_permeation.md create mode 100644 book/content/applications/material_science/fitting_tds.md create mode 100644 book/content/applications/material_science/index.md create mode 100644 book/content/applications/material_science/microstructure.md create mode 100644 book/content/applications/material_science/tds.md diff --git a/book/content/applications/fission/index.md b/book/content/applications/fission/index.md new file mode 100644 index 0000000..bd25c8b --- /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 0000000..78bbd84 --- /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 0000000..44f3295 --- /dev/null +++ b/book/content/applications/fusion/fuel_cycle/test.svg @@ -0,0 +1,84 @@ + + + + + + + + + + + + Reactor + + + + + + + + + TES + + + + + + + + Blanket + + + + + + + + \ 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 0000000..5efbf5a --- /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 0000000..0c49fa9 --- /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 0000000..ba6b0dc --- /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 0000000..a88e956 --- /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 0000000..fb1b0d9 --- /dev/null +++ b/book/content/applications/general/monoblock.md @@ -0,0 +1,303 @@ +--- +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)= +# 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( + "task08/mesh.med", + cell_file="task08/mesh_domains.xdmf", + facet_file="task08/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="task08/mesh_domains.xdmf", facet_file="task08/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/general/permeation_barrier.md b/book/content/applications/general/permeation_barrier.md new file mode 100644 index 0000000..3fa702f --- /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 0000000..4ad35f7 --- /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 [Task 2](task02.ipynb) +``` + +```{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 0000000..e166694 --- /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 0000000..5f8504d --- /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 0000000..ed725bf --- /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/material_science/microstructure.md b/book/content/applications/material_science/microstructure.md new file mode 100644 index 0000000..9ddb2f6 --- /dev/null +++ b/book/content/applications/material_science/microstructure.md @@ -0,0 +1,426 @@ +--- +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 +--- + +# Hydrogen diffusion along grain boundaries + +This tutorial shows how to use FESTIM to simulate hydrogen diffusion in metal microstructures. + +We'll show how to generate a microstructure using Voronoi cells, mesh it with GMSH, and solve a transport problem with FESTIM. + ++++ + +## Geometry + +### Generating the microstructure + +First, we use `scipy` to make a [Voronoi diagram](https://en.wikipedia.org/wiki/Voronoi_diagram) mimicking a microstructure. + +```{code-cell} ipython3 +import numpy as np +from scipy.spatial import Voronoi, voronoi_plot_2d +import matplotlib.pyplot as plt +import gmsh + + +np.random.seed(1) + +# N random seeds in [0,size]x[0,size] +size = 1.5 +N_seeds = 150 +points = np.random.rand(N_seeds, 2) * size + +# centre everything on 0.5, 0.5 +points -= size / 2 +points += 0.5 + +vor = Voronoi(points) + +voronoi_plot_2d(vor, show_vertices=False, show_points=True) +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. + +```{code-cell} ipython3 +from shapely.geometry import Polygon +from shapely import difference, union_all +from shapely.plotting import plot_polygon, plot_points + +gap = 0.01 # thickness of grain boundary + +grains = [] +for region_idx in vor.point_region: + region = vor.regions[region_idx] + if -1 in region or len(region) == 0: + continue # skip infinite regions + poly = Polygon([vor.vertices[i] for i in region]) + poly = poly.intersection( + Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]) + ) # clip to domain + if not poly.is_empty: + grains.append(poly.buffer(-gap / 2)) # shrink each grain inward + +print("Number of grains:", len(grains)) + +plt.figure(figsize=(8, 8)) +# plot grains +for polygon in grains: + plot_polygon(polygon=polygon, add_points=False) + plot_points(polygon, markersize=2, color="tab:blue") +plt.show() +``` + +We can make a new `Polygon` for our grain boundaries by subtracting all the grains from a square polygon. + +```{code-cell} ipython3 +# Grain boundary = everything not covered by grains +eps = gap / 2 +domain = Polygon( + [(0 + eps, 0 + eps), (1 - eps, 0 + eps), (1 - eps, 1 - eps), (0 + eps, 1 - eps)] +) +grain_union = union_all(grains) +grain_boundaries = difference(domain, grain_union) + +plt.figure(figsize=(8, 8)) +for polygon in grains: + plot_polygon(polygon=polygon, add_points=False) +plot_polygon(polygon=grain_boundaries, facecolor="tab:orange", add_points=False) +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. + +```{code-cell} ipython3 +:tags: [hide-output] + +gmsh.initialize() +gmsh.model.add("voronoi") + +lc = 0.01 # mesh size + + +def add_polygon_occ(poly): + """Add polygon using OpenCASCADE kernel for better Boolean operations""" + if poly.is_empty: + return [] + + # Handle MultiPolygon recursively + if poly.geom_type == "MultiPolygon": + surfaces = [] + for p in poly.geoms: + surfaces.extend(add_polygon_occ(p)) + return surfaces + + # Ensure polygon is valid + poly = poly.buffer(0) + if not poly.is_valid: + return [] + + # exterior coords + coords = list(poly.exterior.coords)[:-1] # remove duplicate last point + if len(coords) < 3: + return [] + + # Create wire from points using OCC + points = [] + for x, y in coords: + points.append(gmsh.model.occ.addPoint(x, y, 0)) + + # Create lines connecting the points + lines = [] + for i in range(len(points)): + next_i = (i + 1) % len(points) + lines.append(gmsh.model.occ.addLine(points[i], points[next_i])) + + # Create curve loop and surface + wire = gmsh.model.occ.addWire(lines) + + # Handle holes if any + holes = [] + if len(poly.interiors) > 0: + for interior in poly.interiors: + int_coords = list(interior.coords)[:-1] + if len(int_coords) < 3: + continue + + # Create hole wire + hole_points = [] + for x, y in int_coords: + hole_points.append(gmsh.model.occ.addPoint(x, y, 0)) + + hole_lines = [] + for i in range(len(hole_points)): + next_i = (i + 1) % len(hole_points) + hole_lines.append( + gmsh.model.occ.addLine(hole_points[i], hole_points[next_i]) + ) + + hole_wire = gmsh.model.occ.addWire(hole_lines) + holes.append(hole_wire) + + # Create surface + if holes: + surface = gmsh.model.occ.addPlaneSurface([wire] + holes) + else: + surface = gmsh.model.occ.addPlaneSurface([wire]) + + return [surface] + + +# Add grains using OCC kernel +grain_surfaces = [] +for i, poly in enumerate(grains): + grain_surfaces.extend(add_polygon_occ(poly)) + +gb_surfaces = [] +if not grain_boundaries.is_empty: + gb_surfaces.extend(add_polygon_occ(grain_boundaries)) + +# Synchronize OCC before fragmentation +gmsh.model.occ.synchronize() + +# Fragment all surfaces together +gmsh.model.occ.fragment([(2, tag) for tag in grain_surfaces], [(2, gb_surfaces[0])]) +gmsh.model.occ.synchronize() + +# Create physical groups with all fragmented surfaces + +gmsh.model.addPhysicalGroup(2, grain_surfaces, 1, name="grains") +gmsh.model.addPhysicalGroup(2, gb_surfaces, 2, name="grain_boundaries") + +# Set mesh size for all points +gmsh.option.setNumber("Mesh.MeshSizeMax", lc) +gmsh.option.setNumber("Mesh.MeshSizeMin", lc) + +# find lines on the boundaries +# Get all line entities (dimension = 1) +lines = gmsh.model.getEntities(1) + +# List to store the tags of the lines on the boundaries +lines_on_left = [] +lines_on_right = [] + +for line_tag_pair in lines: + dim = line_tag_pair[0] # Dimension of the entity (1 for lines) + tag = line_tag_pair[1] # Tag of the entity + + # Get the bounding points (dimension = 0) for the current line + bounding_points = gmsh.model.getBoundary([line_tag_pair]) + + # Get the coordinates for each bounding point + point_coords = [] + for point_tag_pair in bounding_points: + coords = gmsh.model.getValue(point_tag_pair[0], point_tag_pair[1], []) + point_coords.append(coords) + + # Check if both bounding points are on the left boundary (x ≈ eps) + is_on_left = True + for coords in point_coords: + x_coord = coords[0] + if abs(x_coord - eps) > 1e-9: + is_on_left = False + break + + # Check if both bounding points are on the right boundary (x ≈ 1-eps) + is_on_right = True + for coords in point_coords: + x_coord = coords[0] + if abs(x_coord - (1 - eps)) > 1e-9: + is_on_right = False + break + + if is_on_left: + lines_on_left.append(tag) + if is_on_right: + lines_on_right.append(tag) + +print("Lines on left boundary:", lines_on_left) +print("Lines on right boundary:", lines_on_right) + +if lines_on_left: + gmsh.model.addPhysicalGroup(1, lines_on_left, name="left_boundary") +if lines_on_right: + gmsh.model.addPhysicalGroup(1, lines_on_right, name="right_boundary") + +gmsh.model.mesh.generate(2) +# gmsh.fltk.run() +gmsh.write("voronoi_grains.msh") + +gmsh.finalize() +``` + +## FESTIM model + +We can now define our hydrogen transport problem. + +$$ +\frac{\partial c}{\partial t} = \nabla \cdot (D \nabla c) +$$ + +where $D=D_\mathrm{GB}$ and $D=D_\mathrm{grain}$ in the grain boundary and grain, respectively. + +Boundary conditions: + +- $ c = 0 $ on the left surface +- $ c = 1 $ on the right surface + +Interface condition: +- We assume continuity of concentration at the GB/grain interfaces. + +Simulation time: $t_f = 1.5$ + +### Convert mesh to dolfinx + +```{code-cell} ipython3 +from dolfinx.io import gmshio +from mpi4py import MPI + + +model_rank = 0 +mesh, cell_tags, facet_tags = gmshio.read_from_msh( + "voronoi_grains.msh", MPI.COMM_WORLD, 0, gdim=2 +) +``` + +```{code-cell} ipython3 +:tags: [hide-input] + +from dolfinx import plot +import pyvista + +pyvista.start_xvfb() +pyvista.set_jupyter_backend("html") + +tdim = mesh.topology.dim + +mesh.topology.create_connectivity(tdim, tdim) +fdim = mesh.topology.dim - 1 +tdim = mesh.topology.dim +mesh.topology.create_connectivity(fdim, tdim) + +topology, cell_types, x = plot.vtk_mesh(mesh, tdim, cell_tags.indices) +p = pyvista.Plotter() +grid = pyvista.UnstructuredGrid(topology, cell_types, x) +grid.cell_data["Cell Marker"] = cell_tags.values +grid.set_active_scalars("Cell Marker") +p.add_mesh(grid, show_edges=False) +if pyvista.OFF_SCREEN: + figure = p.screenshot("cell_marker.png") +p.show() +``` + +### Case 1: GBs are more diffusive + +In this first case, $D_\mathrm{GB}= 1000 \ D_\mathrm{grain}$ + +```{code-cell} ipython3 +import festim as F + +grain_mat = F.Material(D_0=0.001, E_D=0) +gb_mat = F.Material(D_0=1, E_D=0) + + +grain_vol = F.VolumeSubdomain(id=1, material=grain_mat) +gb_vol = F.VolumeSubdomain(id=2, material=gb_mat) + +left_surf = F.SurfaceSubdomain(id=3) +right_surf = F.SurfaceSubdomain(id=4) + +my_model = F.HydrogenTransportProblem() + +my_model.mesh = F.Mesh(mesh) + +# we need to pass the meshtags to the model directly +my_model.facet_meshtags = facet_tags +my_model.volume_meshtags = cell_tags + +my_model.subdomains = [left_surf, right_surf, grain_vol, gb_vol] + +H = F.Species("H") +my_model.species = [H] + +my_model.temperature = 400 + +my_model.boundary_conditions = [ + F.FixedConcentrationBC(subdomain=left_surf, value=0, species=H), + F.FixedConcentrationBC(subdomain=right_surf, value=1, species=H), +] + +my_model.settings = F.Settings(atol=1e-10, rtol=1e-20, final_time=1.5) +my_model.settings.stepsize = 0.01 + +my_model.exports = [F.VTXSpeciesExport(filename="out.bp", field=H)] + +my_model.initialise() +my_model.run() +``` + +At the end of the simulation, we can see on the concentration field the preferential diffusion along the grain boundaries! + +```{code-cell} ipython3 +:tags: [hide-input] + +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_title(f"D_GB/D_grain = {gb_mat.D_0/grain_mat.D_0: .4f}") + + +if not pyvista.OFF_SCREEN: + u_plotter.show() +else: + figure = u_plotter.screenshot("concentration.png") +``` + +### Case 2: GBs are less diffusive + +We can also look at the opposite case with grain boundaries less diffusive the the grain themselves. + +```{code-cell} ipython3 +gb_mat.D_0 = 0.1 +grain_mat.D_0 = 1 + +my_model.initialise() +my_model.run() +``` + +```{code-cell} ipython3 +:tags: [hide-input] + +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_title(f"D_GB/D_grain = {gb_mat.D_0/grain_mat.D_0: .1f}") + +if not pyvista.OFF_SCREEN: + u_plotter.show() +else: + figure = u_plotter.screenshot("concentration.png") +``` diff --git a/book/content/applications/material_science/tds.md b/book/content/applications/material_science/tds.md new file mode 100644 index 0000000..ff11594 --- /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() +``` From 54b77f5ee75b7e78c708377ba49350ce13d83481 Mon Sep 17 00:00:00 2001 From: ckhurana Date: Thu, 23 Oct 2025 12:41:55 -0400 Subject: [PATCH 02/11] added updated toc --- book/_toc.yml | 60 +++++++++++++++++++++++++++++---------------------- 1 file changed, 34 insertions(+), 26 deletions(-) diff --git a/book/_toc.yml b/book/_toc.yml index 0ae07d8..d3e9c71 100644 --- a/book/_toc.yml +++ b/book/_toc.yml @@ -1,44 +1,52 @@ -# 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: - - file: content/meshes/mesh_festim - - file: content/meshes/mesh_fenics - - file: content/meshes/mesh_gmsh - - file: content/meshes/mesh_salome + - file: content/meshes/mesh_festim + - file: content/meshes/mesh_fenics + - file: content/meshes/mesh_gmsh + - file: content/meshes/mesh_salome - caption: Materials - chapters: - - file: content/material/material_basics - - file: content/material/material_htm - - file: content/material/material_advanced + chapters: + - file: content/material/material_basics + - file: content/material/material_htm + - file: content/material/material_advanced - caption: Species & Reactions chapters: - - file: content/species_reactions/species - - file: content/species_reactions/reactions - - file: content/species_reactions/surface_reactions + - file: content/species_reactions/species + - file: content/species_reactions/reactions + - file: content/species_reactions/surface_reactions - caption: Temperature chapters: - - file: content/temperatures/temperatures_basic - - file: content/temperatures/temperatures_advanced - + - 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 + # Material science group + - 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 + # Fusion group with nested sections + sections: + - file: content/applications/fusion/plasma + - file: content/applications/fusion/fuel_cycle/fuel_cycle_map From 78261540b4e47b6d5dd3151cef4b54fc555ba9bc Mon Sep 17 00:00:00 2001 From: Chirag Date: Thu, 23 Oct 2025 15:44:17 -0400 Subject: [PATCH 03/11] fixed toc --- book/_toc.yml | 62 +++++++++++++++++++++++++-------------------------- 1 file changed, 31 insertions(+), 31 deletions(-) diff --git a/book/_toc.yml b/book/_toc.yml index d3e9c71..8036cd7 100644 --- a/book/_toc.yml +++ b/book/_toc.yml @@ -4,49 +4,49 @@ root: intro parts: - caption: Getting started chapters: - - file: content/applications/general/simple + - file: content/applications/general/simple - caption: Meshing chapters: - - file: content/meshes/mesh_festim - - file: content/meshes/mesh_fenics - - file: content/meshes/mesh_gmsh - - file: content/meshes/mesh_salome + - file: content/meshes/mesh_festim + - file: content/meshes/mesh_fenics + - file: content/meshes/mesh_gmsh + - file: content/meshes/mesh_salome - caption: Materials chapters: - - file: content/material/material_basics - - file: content/material/material_htm - - file: content/material/material_advanced + - file: content/material/material_basics + - file: content/material/material_htm + - file: content/material/material_advanced - caption: Species & Reactions chapters: - - file: content/species_reactions/species - - file: content/species_reactions/reactions - - file: content/species_reactions/surface_reactions + - file: content/species_reactions/species + - file: content/species_reactions/reactions + - file: content/species_reactions/surface_reactions - caption: Temperature chapters: - - file: content/temperatures/temperatures_basic - - file: content/temperatures/temperatures_advanced + - file: content/temperatures/temperatures_basic + - file: content/temperatures/temperatures_advanced - caption: Applications chapters: - - 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 - # Material science group - - 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 - # Fusion group with nested sections - sections: - - file: content/applications/fusion/plasma - - file: content/applications/fusion/fuel_cycle/fuel_cycle_map + - 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 + # Material science group + - 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 + # Fusion group with nested sections + sections: + - file: content/applications/fusion/plasma + - file: content/applications/fusion/fuel_cycle/fuel_cycle_map From ed97cfaa48b0c6d2519c2dbea955b182bf1b75cd Mon Sep 17 00:00:00 2001 From: Chirag Date: Thu, 23 Oct 2025 16:07:40 -0400 Subject: [PATCH 04/11] got rid of old files --- book/content/applications/microstructure.md | 426 - book/content/applications/task01.ipynb | 479 - book/content/applications/task02.ipynb | 555 - book/content/applications/task03.ipynb | 325 - book/content/applications/task04.ipynb | 525 - book/content/applications/task06.ipynb | 438 - book/content/applications/task07.ipynb | 249 - book/content/applications/task08.ipynb | 595 - book/content/applications/task08/mesh.med | Bin 6235398 -> 0 bytes book/content/applications/task10.ipynb | 58846 ------------------ 10 files changed, 62438 deletions(-) delete mode 100644 book/content/applications/microstructure.md delete mode 100644 book/content/applications/task01.ipynb delete mode 100644 book/content/applications/task02.ipynb delete mode 100644 book/content/applications/task03.ipynb delete mode 100644 book/content/applications/task04.ipynb delete mode 100644 book/content/applications/task06.ipynb delete mode 100644 book/content/applications/task07.ipynb delete mode 100644 book/content/applications/task08.ipynb delete mode 100644 book/content/applications/task08/mesh.med delete mode 100644 book/content/applications/task10.ipynb diff --git a/book/content/applications/microstructure.md b/book/content/applications/microstructure.md deleted file mode 100644 index 1de0370..0000000 --- a/book/content/applications/microstructure.md +++ /dev/null @@ -1,426 +0,0 @@ ---- -jupytext: - formats: ipynb,md:myst - text_representation: - extension: .md - format_name: myst - format_version: 0.13 - jupytext_version: 1.17.3 -kernelspec: - display_name: festim-workshop - language: python - name: python3 ---- - -# Hydrogen diffusion along grain boundaries - -This tutorial shows how to use FESTIM to simulate hydrogen diffusion in metal microstructures. - -We'll show how to generate a microstructure using Voronoi cells, mesh it with GMSH, and solve a transport problem with FESTIM. - -+++ - -## Geometry - -### Generating the microstructure - -First, we use `scipy` to make a [Voronoi diagram](https://en.wikipedia.org/wiki/Voronoi_diagram) mimicking a microstructure. - -```{code-cell} ipython3 -import numpy as np -from scipy.spatial import Voronoi, voronoi_plot_2d -import matplotlib.pyplot as plt -import gmsh - - -np.random.seed(1) - -# N random seeds in [0,size]x[0,size] -size = 1.5 -N_seeds = 150 -points = np.random.rand(N_seeds, 2) * size - -# centre everything on 0.5, 0.5 -points -= size / 2 -points += 0.5 - -vor = Voronoi(points) - -voronoi_plot_2d(vor, show_vertices=False, show_points=True) -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. - -```{code-cell} ipython3 -from shapely.geometry import Polygon -from shapely import difference, union_all -from shapely.plotting import plot_polygon, plot_points - -gap = 0.01 # thickness of grain boundary - -grains = [] -for region_idx in vor.point_region: - region = vor.regions[region_idx] - if -1 in region or len(region) == 0: - continue # skip infinite regions - poly = Polygon([vor.vertices[i] for i in region]) - poly = poly.intersection( - Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]) - ) # clip to domain - if not poly.is_empty: - grains.append(poly.buffer(-gap / 2)) # shrink each grain inward - -print("Number of grains:", len(grains)) - -plt.figure(figsize=(8, 8)) -# plot grains -for polygon in grains: - plot_polygon(polygon=polygon, add_points=False) - plot_points(polygon, markersize=2, color="tab:blue") -plt.show() -``` - -We can make a new `Polygon` for our grain boundaries by subtracting all the grains from a square polygon. - -```{code-cell} ipython3 -# Grain boundary = everything not covered by grains -eps = gap / 2 -domain = Polygon( - [(0 + eps, 0 + eps), (1 - eps, 0 + eps), (1 - eps, 1 - eps), (0 + eps, 1 - eps)] -) -grain_union = union_all(grains) -grain_boundaries = difference(domain, grain_union) - -plt.figure(figsize=(8, 8)) -for polygon in grains: - plot_polygon(polygon=polygon, add_points=False) -plot_polygon(polygon=grain_boundaries, facecolor="tab:orange", add_points=False) -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. - -```{code-cell} ipython3 -:tags: [hide-output] - -gmsh.initialize() -gmsh.model.add("voronoi") - -lc = 0.01 # mesh size - - -def add_polygon_occ(poly): - """Add polygon using OpenCASCADE kernel for better Boolean operations""" - if poly.is_empty: - return [] - - # Handle MultiPolygon recursively - if poly.geom_type == "MultiPolygon": - surfaces = [] - for p in poly.geoms: - surfaces.extend(add_polygon_occ(p)) - return surfaces - - # Ensure polygon is valid - poly = poly.buffer(0) - if not poly.is_valid: - return [] - - # exterior coords - coords = list(poly.exterior.coords)[:-1] # remove duplicate last point - if len(coords) < 3: - return [] - - # Create wire from points using OCC - points = [] - for x, y in coords: - points.append(gmsh.model.occ.addPoint(x, y, 0)) - - # Create lines connecting the points - lines = [] - for i in range(len(points)): - next_i = (i + 1) % len(points) - lines.append(gmsh.model.occ.addLine(points[i], points[next_i])) - - # Create curve loop and surface - wire = gmsh.model.occ.addWire(lines) - - # Handle holes if any - holes = [] - if len(poly.interiors) > 0: - for interior in poly.interiors: - int_coords = list(interior.coords)[:-1] - if len(int_coords) < 3: - continue - - # Create hole wire - hole_points = [] - for x, y in int_coords: - hole_points.append(gmsh.model.occ.addPoint(x, y, 0)) - - hole_lines = [] - for i in range(len(hole_points)): - next_i = (i + 1) % len(hole_points) - hole_lines.append( - gmsh.model.occ.addLine(hole_points[i], hole_points[next_i]) - ) - - hole_wire = gmsh.model.occ.addWire(hole_lines) - holes.append(hole_wire) - - # Create surface - if holes: - surface = gmsh.model.occ.addPlaneSurface([wire] + holes) - else: - surface = gmsh.model.occ.addPlaneSurface([wire]) - - return [surface] - - -# Add grains using OCC kernel -grain_surfaces = [] -for i, poly in enumerate(grains): - grain_surfaces.extend(add_polygon_occ(poly)) - -gb_surfaces = [] -if not grain_boundaries.is_empty: - gb_surfaces.extend(add_polygon_occ(grain_boundaries)) - -# Synchronize OCC before fragmentation -gmsh.model.occ.synchronize() - -# Fragment all surfaces together -gmsh.model.occ.fragment([(2, tag) for tag in grain_surfaces], [(2, gb_surfaces[0])]) -gmsh.model.occ.synchronize() - -# Create physical groups with all fragmented surfaces - -gmsh.model.addPhysicalGroup(2, grain_surfaces, 1, name="grains") -gmsh.model.addPhysicalGroup(2, gb_surfaces, 2, name="grain_boundaries") - -# Set mesh size for all points -gmsh.option.setNumber("Mesh.MeshSizeMax", lc) -gmsh.option.setNumber("Mesh.MeshSizeMin", lc) - -# find lines on the boundaries -# Get all line entities (dimension = 1) -lines = gmsh.model.getEntities(1) - -# List to store the tags of the lines on the boundaries -lines_on_left = [] -lines_on_right = [] - -for line_tag_pair in lines: - dim = line_tag_pair[0] # Dimension of the entity (1 for lines) - tag = line_tag_pair[1] # Tag of the entity - - # Get the bounding points (dimension = 0) for the current line - bounding_points = gmsh.model.getBoundary([line_tag_pair]) - - # Get the coordinates for each bounding point - point_coords = [] - for point_tag_pair in bounding_points: - coords = gmsh.model.getValue(point_tag_pair[0], point_tag_pair[1], []) - point_coords.append(coords) - - # Check if both bounding points are on the left boundary (x ≈ eps) - is_on_left = True - for coords in point_coords: - x_coord = coords[0] - if abs(x_coord - eps) > 1e-9: - is_on_left = False - break - - # Check if both bounding points are on the right boundary (x ≈ 1-eps) - is_on_right = True - for coords in point_coords: - x_coord = coords[0] - if abs(x_coord - (1 - eps)) > 1e-9: - is_on_right = False - break - - if is_on_left: - lines_on_left.append(tag) - if is_on_right: - lines_on_right.append(tag) - -print("Lines on left boundary:", lines_on_left) -print("Lines on right boundary:", lines_on_right) - -if lines_on_left: - gmsh.model.addPhysicalGroup(1, lines_on_left, name="left_boundary") -if lines_on_right: - gmsh.model.addPhysicalGroup(1, lines_on_right, name="right_boundary") - -gmsh.model.mesh.generate(2) -# gmsh.fltk.run() -gmsh.write("voronoi_grains.msh") - -gmsh.finalize() -``` - -## FESTIM model - -We can now define our hydrogen transport problem. - -$$ -\frac{\partial c}{\partial t} = \nabla \cdot (D \nabla c) -$$ - -where $D=D_\mathrm{GB}$ and $D=D_\mathrm{grain}$ in the grain boundary and grain, respectively. - -Boundary conditions: - -- $ c = 0 $ on the left surface -- $ c = 1 $ on the right surface - -Interface condition: -- We assume continuity of concentration at the GB/grain interfaces. - -Simulation time: $t_f = 1.5$ - -### Convert mesh to dolfinx - -```{code-cell} ipython3 -from dolfinx.io import gmshio -from mpi4py import MPI - - -model_rank = 0 -mesh, cell_tags, facet_tags = gmshio.read_from_msh( - "voronoi_grains.msh", MPI.COMM_WORLD, 0, gdim=2 -) -``` - -```{code-cell} ipython3 -:tags: [hide-input] - -from dolfinx import plot -import pyvista - -pyvista.start_xvfb() -pyvista.set_jupyter_backend("html") - -tdim = mesh.topology.dim - -mesh.topology.create_connectivity(tdim, tdim) -fdim = mesh.topology.dim - 1 -tdim = mesh.topology.dim -mesh.topology.create_connectivity(fdim, tdim) - -topology, cell_types, x = plot.vtk_mesh(mesh, tdim, cell_tags.indices) -p = pyvista.Plotter() -grid = pyvista.UnstructuredGrid(topology, cell_types, x) -grid.cell_data["Cell Marker"] = cell_tags.values -grid.set_active_scalars("Cell Marker") -p.add_mesh(grid, show_edges=False) -if pyvista.OFF_SCREEN: - figure = p.screenshot("cell_marker.png") -p.show() -``` - -### Case 1: GBs are more diffusive - -In this first case, $D_\mathrm{GB}= 1000 \ D_\mathrm{grain}$ - -```{code-cell} ipython3 -import festim as F - -grain_mat = F.Material(D_0=0.001, E_D=0) -gb_mat = F.Material(D_0=1, E_D=0) - - -grain_vol = F.VolumeSubdomain(id=1, material=grain_mat) -gb_vol = F.VolumeSubdomain(id=2, material=gb_mat) - -left_surf = F.SurfaceSubdomain(id=3) -right_surf = F.SurfaceSubdomain(id=4) - -my_model = F.HydrogenTransportProblem() - -my_model.mesh = F.Mesh(mesh) - -# we need to pass the meshtags to the model directly -my_model.facet_meshtags = facet_tags -my_model.volume_meshtags = cell_tags - -my_model.subdomains = [left_surf, right_surf, grain_vol, gb_vol] - -H = F.Species("H") -my_model.species = [H] - -my_model.temperature = 400 - -my_model.boundary_conditions = [ - F.FixedConcentrationBC(subdomain=left_surf, value=0, species=H), - F.FixedConcentrationBC(subdomain=right_surf, value=1, species=H), -] - -my_model.settings = F.Settings(atol=1e-10, rtol=1e-20, final_time=1.5) -my_model.settings.stepsize = 0.01 - -my_model.exports = [F.VTXSpeciesExport(filename="out.bp", field=H)] - -my_model.initialise() -my_model.run() -``` - -At the end of the simulation, we can see on the concentration field the preferential diffusion along the grain boundaries! - -```{code-cell} ipython3 -:tags: [hide-input] - -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_title(f"D_GB/D_grain = {gb_mat.D_0/grain_mat.D_0: .4f}") - - -if not pyvista.OFF_SCREEN: - u_plotter.show() -else: - figure = u_plotter.screenshot("concentration.png") -``` - -### Case 2: GBs are less diffusive - -We can also look at the opposite case with grain boundaries less diffusive the the grain themselves. - -```{code-cell} ipython3 -gb_mat.D_0 = 0.1 -grain_mat.D_0 = 1 - -my_model.initialise() -my_model.run() -``` - -```{code-cell} ipython3 -:tags: [hide-input] - -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_title(f"D_GB/D_grain = {gb_mat.D_0/grain_mat.D_0: .1f}") - -if not pyvista.OFF_SCREEN: - u_plotter.show() -else: - figure = u_plotter.screenshot("concentration.png") -``` diff --git a/book/content/applications/task01.ipynb b/book/content/applications/task01.ipynb deleted file mode 100644 index 4ab34e1..0000000 --- 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": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHACAYAAABeV0mSAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAaitJREFUeJzt3XdcVfX/B/DXHXDZIFMQRHAjCAgO3Cs3akMtLXNVlqVGw6x+leVXstKWaWlqWabm1qKU3FtBcOFmiiB773vP7w+UvnxxwOVyzx2v5+NxHw85nHPu66Jy3/czJYIgCCAiIiIyEFKxAxARERFpEosbIiIiMigsboiIiMigsLghIiIig8LihoiIiAwKixsiIiIyKCxuiIiIyKCwuCEiIiKDwuKGiIiIDAqLGyIiIjIoRl3cHD58GKGhoXBzc4NEIsGOHTsadH1ZWRmmTJkCPz8/yOVyjB079r7nfffdd+jYsSPMzc3Rvn17rFu3rvHhiYiI6L6MurgpLi6Gv78/li1bptb1SqUS5ubmmD17NgYPHnzfc1asWIH58+fjo48+wqVLl7BgwQLMmjULu3fvbkx0IiIiegAJN86sJpFIsH379lqtLxUVFXj//fexfv165OXlwdfXF4sXL0b//v3rXD9lyhTk5eXVaf3p2bMnevXqhc8//7zm2Ny5cxEVFYWjR4820ashIiIyXnKxA+iyqVOnIjExERs3boSbmxu2b9+OYcOG4cKFC2jbtm297lFeXg4zM7Nax8zNzXH69GlUVlbCxMSkKaITEREZLaPulnqYmzdvYsOGDdi8eTP69OmD1q1b480330Tv3r2xdu3aet9n6NCh+PHHHxEdHQ1BEBAVFYU1a9agsrISWVlZTfgKiIiIjBNbbh7g7NmzEAQB7dq1q3W8vLwcDg4O9b7P//3f/yE9PR09evSAIAhwcXHBlClT8Nlnn0Emk2k6NhERkdFjcfMAKpUKMpkM0dHRdYoQKyuret/H3Nwca9aswQ8//IA7d+7A1dUVK1euhLW1NRwdHTUdm4iIyOixuHmAwMBAKJVKZGRkoE+fPo2+n4mJCdzd3QEAGzduxKhRoyCVsleQiIhI04y6uCkqKsKNGzdqvk5ISEBsbCzs7e3Rrl07TJo0CZMnT8aSJUsQGBiIrKws7N+/H35+fhgxYgQAIC4uDhUVFcjJyUFhYSFiY2MBAAEBAQCAa9eu4fTp0+jevTtyc3OxdOlSXLx4ET///LO2Xy4REZFRMOqp4AcPHsSAAQPqHH/++efx008/obKyEgsXLsS6deuQmpoKBwcHhISEYMGCBfDz8wMAtGrVCklJSXXuce/HevnyZUycOBFXr16FiYkJBgwYgMWLF6N9+/ZN++KIiIiMlFEXN0RERGR4OOiDiIiIDAqLGyIiIjIoRjegWKVS4fbt27C2toZEIhE7DhEREdWDIAgoLCyEm5vbI2cbG11xc/v2bXh4eIgdg4iIiNSQkpJSs7TKgxhdcWNtbQ2g+odjY2MjchoiIiKqj4KCAnh4eNS8jz+M0RU397qibGxsWNwQERHpmfoMKeGAYiIiIjIoLG6IiIjIoLC4ISIiIoPC4oaIiIgMCosbIiIiMigsboiIiMigsLghIiIig8LihoiIiAwKixsiIiIyKCxuiIiIyKCIWtwcPnwYoaGhcHNzg0QiwY4dO+p97bFjxyCXyxEQENBk+YiIiEj/iFrcFBcXw9/fH8uWLWvQdfn5+Zg8eTIGDRrURMmIiIhIX4m6cebw4cMxfPjwBl/30ksvYeLEiZDJZA1q7SEiw1OlVKG8SoWKKhUqlCpUqQSYyCRQyGQwlUthKpdCJn30RntEZDj0blfwtWvX4ubNm/j111+xcOFCseMQURMqrVAiPqsIKTklSMouQXJOCW7nlSKnuAI5JRXIKapAcYXykfexMZPDwUqBZhYmcLBSoIWdOTwdLNDS3gKeDhbwdLCEiYxDEIkMhV4VN9evX8c777yDI0eOQC6vX/Ty8nKUl5fXfF1QUNBU8YioEcoqlYhJzsO5W3mIu12AuLQCxGcWQSXU/x5SCSCXSlGhVNU6XlBWhYKyKiQ84DpTuRTtXazh42oDHzcbBLa0g4+rDeQseIj0kt4UN0qlEhMnTsSCBQvQrl27el8XHh6OBQsWNGEyIlJHRZUKpxNycPxmFk4n5ODcrTxUKutWMs0sTODpYFnTytLCzhwOVgrYW5rC3tIUduYmMDORwUQmqSlGBEFAlUpARZUKZZVK5JZUIKe4EjnF5cgsLMet3FIk51S3BCVmFaO4QokLqfm4kJpf87yWpjIEtbJHdy979G7jCL8WtpCye4tIL0gEQWjA56KmI5FIsH37dowdO/a+38/Ly0OzZs0gk8lqjqlUKgiCAJlMhr1792LgwIF1rrtfy42Hhwfy8/NhY2Oj8ddBRA+WVVSO/ZczsP9KBo5cz6zTpeRsrUBwq2bo5GYLHzcbdHK1gbONWZNmUqkE3MotRVxaPuJuF+BCaj6iknJRWFZV6zxHKwUGtHfCwA7O6NvOCZYKvflsSGQQCgoKYGtrW6/3b73532ljY4MLFy7UOrZ8+XLs378fW7ZsgZeX132vUygUUCgU2ohIRPdRUFaJPRfTsevcbRy7kVWrm8nJWoG+bZ3Q3bu6haSlvQUkEu22jkilErR0sEBLBwsM83UFAChVAq6mF+J0QjZOxufg6I0sZBWVY3P0LWyOvgUzEykGd3TBmIAW6NvOEQq57BHPQkTaJGpxU1RUhBs3btR8nZCQgNjYWNjb26Nly5aYP38+UlNTsW7dOkilUvj6+ta63tnZGWZmZnWOE5G4VCoBJ+Kz8dupZERevoOKqn/HwPi1sMWgjs4Y2MEZvm662dUjk0rg41Y9/mZKLy9UVKlwJjEH+69k4J/Ld5CUXYI/zqfhj/NpsDGTI9TfDc90awnfFrZiRyciiFzcREVFYcCAATVfh4WFAQCef/55/PTTT0hLS0NycrJY8YiogXKKK7AlOgW/nUpGYnZJzfE2zlYY4++GUH83tHK0FDGhekzlUvRq44hebRzx/siOuJCaj12xt7H7/G3cKSjH+lPJWH8qGf4edpjUrSVG+bvCwlRvGsaJDI7OjLnRlob02RFR/dzMLMLKQ/HYHpNaM1PJSiHHE11aYEJXD/i42mi9u0kblCoBp+Kz8dvpZOy5lF4zINrOwgSTe3hics9WcLRitziRJjTk/ZvFDRGpLSY5F98fuom9cXdw7zdJZ3dbTOzWEqH+bkY16DarqBxbom/ht1PJSM6pbrVSyKV4KsgdL/Tx1ssWKyJdwuLmIVjcEDVedFIOvthzDSfis2uODe7ogpf7eyPI017EZOJTqgTsvZSO7w/H41xKHgBAIgHGBrTA3MFt4enAIodIHSxuHoLFDZH6LqcV4Is9V7HvSgYAwEQmwdiAFnipnzfaOFuLnE63CIKA0wk5+OFwPPbf/XnJpRKMC/bA7EFt4GprLnJCIv3C4uYhWNwQNVxKTgk+33MVu8/fhiBUzyYaH+yO1wa2hZsd36Qf5cKtfHyx9yoOXcsEUD1AeXIPT7w2qC1szU1ETkekH1jcPASLG6L6K6mowoqDN/HD4fia6dyh/m54fXBbeDtZiZxO/5xJzMHne67idEIOAMDB0hRvDm2P8cEe3NyT6BFY3DwEixuiRxMEAbvPpyE84jLS8ssAAL3aOODdER3RyY1ruTSGIAg4dC0TC/+8jBsZRQAAH1cbfBjqg+7eDiKnI9JdLG4egsUN0cPdzCzC/G0XaloX3JuZ4/2RPhjaycUgp3OLpVKpwi8nkvDlP9dqtnp4oksL/N9IHzSzNBU5HZHuYXHzECxuiO6vUqnCD4du4pt9N1ChVMHMRIpZ/dvghb7eMDPh9gJNJbuoHEsir2HD6WQIAmBvaYoPQ30w2t+NxSTRf2Fx8xAsbojqOn8rD29vOY8r6YUAgH7tnPCfx33h3sxC5GTG42xyLt7Zeh7X7lR3VfVr54SFY33hYc+/AyKAxc1Dsbgh+ldFlQpf/nMNPxy6CZUANLMwwQehPhgb0IKtBiKoqKpuPft2f3XrmaWpDB+O7oRxQe78+yCjx+LmIVjcEFW7kVGIORtjcel2AQBgtL8bPgz1gQO3CxDdzcwizNtyHlFJuQCAoZ1csOhxP/7dkFFjcfMQLG7I2AmCgF9OJuE/f15GeZUKdhYmCH/cD8P9XMWORv9FqRLww+Gb+DLyGiqVAhytFPj8qc4Y0MFZ7GhEomBx8xAsbsiY5RRX4I3fY3HgavVicn3aOuKLcf5wsTETORk9yMXUfLy+KRbX704bn9qrFeYP7whTuVTkZETaxeLmIVjckLE6m5yLWevPIi2/DKZyKd4Z1gFTeraClIvH6byySiUW/30Fa48lAgD8Pezw3cRADvgmo8Li5iFY3JCxEQQBa48lYlHEZVSpBHg5WmL5pC7o6Mp///pm76V0vLn5HArKqmBrboKl4/0xqKOL2LGItKIh799s1yQyYIVllXhl/Vl8/EccqlQCRvq5YtervVjY6KkhnZrjz9l90NndFvmllZj+cxQW/30FSpVRfUYleiQWN0QGKjGrGI8vP46/LqbDRCbBR6E+WDYxENZm3KhRn3nYW2DzzBBM6dkKALDi4E1M//kM8ksrxQ1GpENY3BAZoGM3sjDmu2O4kVGE5jZm+P2lEEzp5cW1UgyEQi7DR6M74eunA6CQS3HwaiYeX34M8ZlFYkcj0gksbogMiCAI+OlYAiavOY380koEeNhh16u9ENiymdjRqAmMCWiBLTN7wtXWDPGZxRjz3TEcvJohdiwi0bG4ITIQlUoV3t1+ER/tjoNSJeCJwBbY+GIPOHOat0Hzc7fFrld7I8izGQrLqjDtpzNYeyxB7FhEomJxQ2QAisurMOPnKGw4nQyJBHh3RAcsGe/PDS+NhJO1Ar+90B0Tgj2gEoAFu+Ow8I84qDjQmIwUixsiPZdRWIYJK0/g0LVMmJlIseq5YLzYtzXH1xgZhVyGT5/0w9vD2gMAfjyagFc3nEVZpVLkZETax+KGSI/dzCzCE8uP42JqAewtTbHxxRAM9uG6J8ZKIpHglf5t8PXTATCRSRBxIR3P/ngKucUVYkcj0ioWN0R6KjopB0+uOI5buaXwdLDAtpd7IsDDTuxYpAPGBLTAumndYWMmR1RSLp78/jhu55WKHYtIa1jcEOmhg1czMHHVKeSVVMLfww7bXu6JVo6WYsciHRLS2gFbX+6JFnbmiM8sxrjvTyAhq1jsWERaweKGSM/8fTENL6yLQnmVCgPaO2HDC93hYKUQOxbpoLYu1tg8MwTejpZIzSvFuO9P4HJagdixiJocixsiPbI95hZm/RaDSmX1Vgo/PBcMC1O52LFIh7nZmeP3mSHwcbVBVlE5JvxwAtFJuWLHImpSLG6I9MT6U0kI+/0clCoB44Lc8c0zgTCV878wPZqjlQIbXuyBYM9mKCirwrM/nsLR61lixyJqMvzNSKQHVh2Ox3vbL0IQgCk9W2Hxk50hk3KqN9WfrbkJ1k3vhj5tHVFaqcS0n8/g8LVMsWMRNQkWN0Q6btXhePwn4jIA4JX+rfFhqA+kLGxIDRamcvz4fDAe83FBRZUKL6yLwpHrLHDI8LC4IdJha44m1BQ2cwe3xdvDOnBxPmoUhVyG7yZ2wWM+LiivUmHGz1HsoiKDw+KGSEetO5GIj/+IAwDMHtgGcwe3EzkRGQpTuRTfTeyCwR2dUV6lwvSfz7DAIYPC4oZIB/16Mgkf7LwEoLor6vXHWNiQZpnKpfhuUhcM6vBvgXPsBgscMgwsboh0zMbTyXh/x0UAwEt9vfHW0PbsiqImoZDLsPzZLhh4t8CZ8XMUopNyxI5F1Ggsboh0yO5ztzF/+wUAwPTeXnhnOMfYUNNSyGVY8WwX9G3nhNJKJaauPYO421zoj/QbixsiHXHoWibCfo+FIACTurfE+yM7srAhrVDIZfj+2S416+BMXnOKWzWQXmNxQ6QDopNyMfOXaFQqBYzq7IqPx/iysCGtsjCVY/WUrndXMq7Asz+e4mabpLdELW4OHz6M0NBQuLm5QSKRYMeOHQ89f9u2bXjsscfg5OQEGxsbhISEYM+ePdoJS9RErqYXYtpPZ1BaqUTfdk5YOj6AC/SRKGzNTfDztG7wursX1bOrTyG7qFzsWEQNJmpxU1xcDH9/fyxbtqxe5x8+fBiPPfYYIiIiEB0djQEDBiA0NBQxMTFNnJSoaaTklOC51aeQX1qJLi3t8P2zXbilAonKyVqBX2d0h5utGeIzizFl7RkUl1eJHYuoQSSCIAhihwAAiUSC7du3Y+zYsQ26rlOnTpgwYQI++OCDep1fUFAAW1tb5Ofnw8bGRo2kRJqRU1yBJ5YfQ2J2Cdq7WGPTSz1gZ2EqdiwiAMDNzCKM+/4EcoorMKC9E1ZNDoZcxsKbxNOQ92+9/peqUqlQWFgIe3v7B55TXl6OgoKCWg8isZVVKjHj5zNIzC6BezNzrJvejYUN6ZTWTlb48flgmJlIceBqJv5v50XoyGdhokfS6+JmyZIlKC4uxvjx4x94Tnh4OGxtbWseHh4eWkxIVJdKJeD1TbE4m5wHGzM5fpraFS42ZmLHIqqjS8tm+ObpQEglwIbTKfjuwA2xIxHVi94WNxs2bMBHH32ETZs2wdnZ+YHnzZ8/H/n5+TWPlJQULaYkqmtRxGX8dTEdpjIpVk4ORhtna7EjET3QkE7N8dHoTgCAL/Zew9boWyInIno0udgB1LFp0yZMnz4dmzdvxuDBgx96rkKhgEKh0FIyoof7+XgifjyaAAD4fFxn9PB2EDkR0aNNDmmF1NxS/HA4HvO2noeLjRl6t3UUOxbRA+ldy82GDRswZcoU/Pbbbxg5cqTYcYjqLTLuDhbsrt4v6q2h7TEmoIXIiYjqb96wDgj1d0OVSsDL66NxI6NI7EhEDyRqcVNUVITY2FjExsYCABISEhAbG4vk5GQA1V1KkydPrjl/w4YNmDx5MpYsWYIePXogPT0d6enpyM/PFyM+Ub1dup2P2RtioBKAZ7p54JX+rcWORNQgUqkEX4zrjK6tmqGwrAozfj6DvJIKsWMR3ZeoxU1UVBQCAwMRGBgIAAgLC0NgYGDNtO60tLSaQgcAfvjhB1RVVWHWrFlwdXWtecyZM0eU/ET1kVVUjhfXRaO0Uok+bR3xCVcfJj1VvQ9VEFrYmSMxuwSvrD+LSqVK7FhEdejMOjfawnVuSJvKq5SYtOoUopJy4eVoiR2v9IKthYnYsYga5Up6AZ5cfhzFFUpM6t4SC8eyYKemZzTr3BDpMkEQ8H87LiIqKRfWZnKsmhzMwoYMQofmNvj66UBIJMD6U8lYdyJJ7EhEtbC4IWoia48l4veoW5BKgG+fCUQbZyuxIxFpzGAfF8wb1gEA8PEfcTh8LVPkRET/YnFD1AQOX8vEwj/jAADvjuiI/u0fvBYTkb56qa83nuziDqVKwGsbYpCcXSJ2JCIALG6INC45uwSv/nYWKgF4Ksgd03t7iR2JqElIJBIsesIXAR52yC+txEu/RqO0Qil2LCIWN0SaVFapxMxfo1FQVoUADzv853EOtCTDVj2DqgscrUxxOa0A87ed5x5UJDoWN0QaIggC3tt+EXFpBXCwNMWKZ7tAIZeJHYuoybnammPZxC6QSSXYEXsbPx9PFDsSGTkWN0Qa8tvpZGw9++8AYldbc7EjEWlND28HvDuiIwBg4Z+XcTohR+REZMxY3BBpQGxKHhbsqh5A/NbQDujZhvvukPGZ1qsVRt/douGV9Wdxp6BM7EhkpFjcEDVSdlE5Xvk1GhVKFYZ2csHMft5iRyIShUQiwadP+qFDc2tkFZVjFlcwJpGwuCFqBKVKwJyNsbidXwZvR0t8Ps6fA4jJqFmYyvH9s0GwVsgRlZSLpZHXxI5ERojFDVEjfLPvOo7eyIK5iQzfPxcEGzOuQEzUytESi5/qDABYcfAmDlzNEDkRGRsWN0RqOnEzG9/uvw4AWPSEL9q5WIuciEh3jPBzxeQQTwBA2KZYpOWXipyIjAmLGyI1ZBeVY87GGKgEYFyQOx4PdBc7EpHOeXdER/i2sEFuSSVmb4hBFcffkJawuCFqIJVKwBubzyGjsBxtnK2wYEwnsSMR6SQzExm+m9gF1go5ziRy/A1pD4sbogZadSQeB69mQiGXYtnEQFiYysWORKSzPB0s8emT1eNvlh+8iYMcf0Na0ODfyoIg4NChQzhy5AgSExNRUlICJycnBAYGYvDgwfDw8GiKnEQ64WxyLj7fcxUA8EGoDzo0txE5EZHuG9nZFSfjPfHLySSE/X4Of83pAxcbM7FjkQGrd8tNaWkpFi1aBA8PDwwfPhx//vkn8vLyIJPJcOPGDXz44Yfw8vLCiBEjcPLkyabMTCSK/NK74wZUAkZ2dsXEbi3FjkSkN94b2RE+rjbIKa7Am5vPQaXi/lPUdOpd3LRr1w5nz57F999/j4KCApw8eRJbt27Fr7/+ioiICCQnJ+PmzZvo06cPJkyYgFWrVjVlbiKtEgQB726/gFu5pWhpb4HwJ/y4ng1RA5iZyPDNMwEwM5HiyPUsrDmWIHYkMmASoZ7bt168eBG+vr71umlFRQWSkpLQtm3bRoVrCgUFBbC1tUV+fj5sbNilQPWz7ewthP1+DnKpBFte7okADzuxIxHppV9PJuH9HRdhKpNix6xe8HHj72Gqn4a8f9e75aa+hQ0AmJqa6mRhQ6SOlJwSfLDzEgBg7uC2LGyIGmFS95YY3NEZFUoV5m6KQVmlUuxIZIDUmi2lVNb+x3jq1CkcPnwYlZWVGglFpCuUKgFhv8eiqLwKwZ7N8HL/NmJHItJrEokEi5/sDEcrBa7dKcKnf10ROxIZoAYVN2lpaejduzcUCgX69euH3NxcjBo1CiEhIejfvz98fX2RlpbWVFmJtO6HwzdxJjEXlqYyfDkhADIpx9kQNZaDlQJfjKueHv7T8UQcuMLp4aRZDSpu5s2bB0EQsH37dri6umLUqFEoKChASkoKkpKS4OLigv/85z9NlZVIqy6m5mPp3upFxz4a3Qke9hYiJyIyHP3bO2Nqr1YAgLe2nENWUbm4gcigNGidm3/++Qfbtm1Djx490KtXLzg6OiIyMhItWrQAACxYsAAzZsxokqBE2lRaocScjdXTvof7NsdTQdxegUjT5g3rgOM3snH1TiHe2XoBqyYHcRYiaUSDWm5yc3NrChl7e3tYWFjA09Oz5vutW7dmtxQZhE//uoybmcVwtlZg0eOc9k3UFMxMZPj6mQCYyCT45/IdbDubKnYkMhANKm6cnZ1rFS+vvvoq7O3ta77Ozc2FpaWl5tIRieDo9Sz8fCIJAPDFOH80szQVORGR4erQ3AZzB7cDAHy0+xJ3DyeNaFBxExAQgBMnTtR8/emnn9Yqbo4ePYrOnTtrLh2RlhWWVWLe1vMAgMkhnujbzknkRESG76W+3vD3sENhWRXmbb2Aei6/RvRADRpzs3Pnzod+v1u3bujXr1+jAhGJaVHEFaTmlcLD3hzzhnUQOw6RUZDLpFgyzh8jvzmCw9cyseF0CiZ25/YmpD6N7gretWvXBi32R6RLjlzPxIbTyQCAz570h6WCu30TaUsbZyu8NbQ9AOA/f8YhJadE5ESkz9T+7Z2amopjx44hIyMDKpWq1vdmz57d6GBE2lRYVol5W6q7o54P8URIaweRExEZn6m9vLDnUjrOJObirS3n8NuMHpBybSlSg1rFzdq1azFz5kyYmprCwcGh1kwSiUTC4ob0zn/+vIzb+WVoaW+BecPZHUUkBplUgi/G+WPYV0dwMj4H604kYkovL7FjkR5Sq1vqgw8+wAcffID8/HwkJiYiISGh5hEfH6/pjERN6tC1TGw8kwIA+PypzrAwZXcUkVg8HSzx7ojqDxif/n0FydnsnqKGU6u4KSkpwdNPPw2pVKNDdoi0rqCsEu/cnR01pWcrdPdmdxSR2CZ190QPb3uUVarw7nbOnqKGU6s6mT59OjZv3qzpLERaFx5xBWn5ZfB0sMDbw9qLHYeIAEilEnz6RGco5FIcvZGFzdG3xI5EekYiqFESK5VKjBo1CqWlpfDz84OJiUmt7y9dulRjATWtoKAAtra2yM/Ph42NjdhxSESn4rMxYeVJAMDGF3ugB1ttiHTKD4duIvyvK7Axk+OfN/rB2dpM7Egkooa8f6s1uGDRokXYs2cP2rev/qT7vwOKiXRdWaUS87dfAAA8082DhQ2RDpre2wt/nE/DhdR8fLjzElY8GyR2JNITahU3S5cuxZo1azBlyhQNxyHSjuUHbiA+sxhO1gq8M7yj2HGI6D7kMik+fdIPo5cdw18X0/H3xXQM820udizSA2qNuVEoFOjVq1ejn/zw4cMIDQ2Fm5sbJBIJduzY8chrDh06hKCgIJiZmcHb2xvff/99o3OQcbl2pxArDt0EACwY3Qm25iaPuIKIxNLJzRYv9fUGAHyw8yLySytFTkT6QK3iZs6cOfj2228b/eTFxcXw9/fHsmXL6nV+QkICRowYgT59+iAmJgbvvvsuZs+eja1btzY6CxkHlUrA/G0XUKkUMLijC4bzUyCRzps9qC28HS2RUViO8IjLYschPaDWgOLHH38c+/fvh4ODAzp16lRnQPG2bdsaHkQiwfbt2zF27NgHnjNv3jzs2rULly//+4975syZOHfuXK0NPR+GA4qN2y8nEvF/Oy/B0lSGf97oB1dbc7EjEVE9nE7Iwfgfqn/P//ZCd/Rs7ShyItK2hrx/q9VyY2dnhyeeeAL9+vWDo6MjbG1taz2ayokTJzBkyJBax4YOHYqoqChUVt6/qbK8vBwFBQW1HmSc0vJLsfjvqwCAt4d1YGFDpEe6edlj0t3NNN/fcRHlVUqRE5Eua9CA4qKiIlhZWWHt2rVNleeh0tPT4eLiUuuYi4sLqqqqkJWVBVdX1zrXhIeHY8GCBdqKSDpKEAR8sPMSisqrENjSDs/28BQ7EhE10NvDOmDPpTuIzyzGqsPxeHVgW7EjkY5qUMuNo6Mjhg8fjhUrVuD27dtNlemh/neq+b1etQdNQZ8/fz7y8/NrHikpKU2ekXTPnkt3EBl3Byay6sXBZNyMj0jv2Jqb4P9GVc9u/Hb/DSRlF4uciHRVg4qbq1evYsSIEdi6dSu8vLzQtWtXfPLJJzh//nxT5aulefPmSE9Pr3UsIyMDcrkcDg73X6dEoVDAxsam1oOMS3F5FT7efQkA8FLf1mjf3FrkRESkrtH+bujVxgHlVSp8sPMSt2ag+2pQcePp6YnXXnsN//zzDzIyMhAWFoZLly6hb9++8PLywpw5c7B//34olU3TFxoSEoLIyMhax/bu3Yvg4OA6g5qJ7vlm/3Xczi+DezNzzBrQRuw4RNQIEokEn4zxhalMikPXMhFxIf3RF5HRUXvnS1tbWzzzzDPYuHEjsrKy8MMPP0ClUmHq1KlwcnLC+vXrH3mPoqIixMbGIjY2FkD1VO/Y2FgkJycDqO5Smjx5cs35M2fORFJSEsLCwnD58mWsWbMGq1evxptvvqnuyyADd/1OIVYfSQBQvaaNualM5ERE1FjeTlZ4uX9rAMCC3ZdQWMa1b6g2jWzrLZfLMWTIEHz77bdISkrCvn370K5du0deFxUVhcDAQAQGBgIAwsLCEBgYiA8++AAAkJaWVlPoAICXlxciIiJw8OBBBAQE4JNPPsE333yDJ598UhMvgwyMIAj4v50XUaWqXtNmUEeXR19ERHrh5f6t0crBAhmF5Viy95rYcUjHNGidm/qMrZFIJPDz82tUqKbEdW6Mx46YVMzdFAszEykiX+8HD3sLsSMRkQYduZ6J51afhlQC7Hq1N3xbNN1SJCS+Jts4MyAgABKJpM4Mpf+ujyQSSZONuSGqr4KySiz8s3qxx9cGtmVhQ2SA+rR1wmh/N+w6dxvvbb+A7a/0gpQzIQkNLG4SEhJq/iwIAnx9fREREQFPT64ZQrpl6d5ryCoqh7ejJWb08RI7DhE1kfdHdsT+Kxk4dysfW6JvYXxXD7EjkQ5oUHHzv0WMRCKBu7s7ixvSKRdT87HuRCIA4OMxvlDIOYiYyFA525hhzqC2+E/EZSz++wqG+jbnZrikmQHFRLpCpaoeRKwSgFGdXdG7LfefITJ0z/dshdZOlsgursBX/3BwMbG4IQOz9ewtxCTnwdJUhvdH+ogdh4i0wFQuxUejOwEA1p1IwtX0QpETkdgaXdw8aNsDIm0rLKus2Rhz9qC2aG5rJnIiItKWPm2dMLSTC5QqAR/t4srFxq5BY24CAwNrFTOlpaUIDQ2FqalprfPOnj2rmXREDbDswA1kFZXDy9ESU3txEDGRsXl/pA8OXs3Eifhs/HUxHSP86m6mTMahQcXN2LFja309ZswYTWYhUltCVjHWHK2ezff+yI4wlbPHlcjYeNhbYGa/1vh633X858/LGNDemauSG6kGFTcffvhhU+UgapT//BmHSqWAfu2cMLCDs9hxiEgkM/u1xpboW0jNK8WKgzcQNqS92JFIBPx4S3rv0LVM/HM5A3KpBP83qiPHgREZMXNTGd4f2REA8P3heCRnl4iciMRQ7+Jm2LBhOH78+CPPKywsxOLFi/Hdd981KhhRfVQqVfjkjzgAwOSQVmjjbC1yIiIS2zDf5ujVxgEVVSr8JyJO7Dgkgnp3S40bNw7jx4+HtbU1Ro8ejeDgYLi5ucHMzAy5ubmIi4vD0aNHERERgVGjRuHzzz9vytxEAIBfTiThRkYR7C1NMWdwW7HjEJEOkEgk+DC0E4Z/fQR7Lt3Byfhs9PB2EDsWaVGDNs6sqKjAli1bsGnTJhw5cgR5eXnVN5FI4OPjg6FDh+KFF15A+/a628fJjTMNR3ZROfp/cRCFZVVY9LgfJnZvKXYkItIh7++4gF9PJsO3hQ12zerNfaf0XEPevxtU3Pyv/Px8lJaWwsHBASYm+rHcNYsbw/He9gtYfyoZPq422P1ab8j4i4uI/kt2UTn6f34QheVV+GKcP54Kchc7EjVCQ96/GzWg2NbWFs2bN9ebwoYMx5X0Amw4nQwA+DDUh4UNEdXhYKXAqwPbAAA+33MFJRVVIicibeFsKdJL4RFXoBKA4b7N0Z196UT0AFN6tYKHvTnuFJTjh0PxYschLWFxQ3rn8LVMHLqWCROZBPOGdRA7DhHpMIVchvnDq6eG/3D4JtLzy0RORNrA4ob0ilIlYFHEZQDAcz1aoZWjpciJiEjXDfdtjmDPZiirVOGzPVfEjkNawOKG9MrWs7dwJb0QNmZyvHa3L52I6GEkEgn+b5QPAGDb2VScv5UnbiBqco0qbioqKnDr1i0kJyfXehA1hZKKKizZW73r92sD26KZpekjriAiqubvYYfHA1sAABb+eZm7hhs4tYqb69evo0+fPjA3N4enpye8vLzg5eWFVq1awcuLuzFT0/jxSALuFJTDvZk5Jvf0FDsOEemZt4a2h0IuxemEHOy5lC52HGpCDdo4854pU6ZALpfjjz/+gKurK/fyoSaXUViG7w/dBADMG9YBCjl3+iWihnGzM8eLfb3x7f4b+OzvqxjU0QUmMo7OMERqFTexsbGIjo5Ghw6cqULa8WXkdZRUKBHgYYdRnV3FjkNEeurFvt5YfyoZ8VnF+D0qBZO6sxXYEKlVsvr4+CArK0vTWYju69qdQmw6Uz2W672R3PWbiNRnbWaC2XcnI3z1z3Uu7Geg1CpuFi9ejLfffhsHDx5EdnY2CgoKaj2INCk84jJUAjCsU3N0bWUvdhwi0nMTu3vCw94cmYXlWH0kQew41ATU2ltKKq2uif73E7QgCJBIJFAqlZpJ1wS4t5R+OXEzG8+sOgm5VILIsH7w4ro2RKQBO2NTMWdjLKwUchx6qz8crBRiR6JHaMj7t1pjbg4cOKBWMKKGEAShZsGtp7t5sLAhIo0J7eyGVUficTG1AMsO3MCHoZ3EjkQapFZx069fP03nIKojMu4OYpLzYGYixeyBbcWOQ0QGRCqV4J1hHfHs6lP49WQSpvb0QksHC7FjkYaoVdwAQF5eHlavXo3Lly9DIpHAx8cH06ZNg62trSbzkZFSqgR8vqd6wb5pvbzgbGMmciIiMjS92zqiT1tHHLmehSWRV/H104FiRyINUWtAcVRUFFq3bo0vv/wSOTk5yMrKwtKlS9G6dWucPXtW0xnJCG2PScX1jCLYmpvgpX6txY5DRAbq3ua7O2Nv42JqvshpSFPUKm5ef/11jB49GomJidi2bRu2b9+OhIQEjBo1CnPnztVwRDI25VVKfBl5DQDwSv/WsDU3ETkRERkq3xa2GBPgBgBY/Dc31TQUarfczJs3D3L5v71acrkcb7/9NqKiojQWjozT+pPJSM0rhYuNAs/3bCV2HCIycG8OaQ8TmQRHrmfh6HWu4WYI1CpubGxs7rtBZkpKCqytrRsdioxXUXkVlh24AQCYO7gdzEy4zQIRNS0Pe4ualYo/33uVm2oaALWKmwkTJmD69OnYtGkTUlJScOvWLWzcuBEzZszAM888o+mMZER+PBKPnOIKeDtaYlyQu9hxiMhIzBrQBuYmMpxLycO+yxlix6FGUmu21BdffAGJRILJkyejqqp66WoTExO8/PLL+PTTTzUakIxHVlE5Vh2OBwC8MaQ95NzQjoi0xMlagSm9WmHFwZv4Yu9VDOzgDKmUW73oK7XePUxNTfH1118jNzcXsbGxiImJQU5ODr788ksoFFzlkdTz3YEbKK5Qwq+FLUb4NRc7DhEZmZf6esNaIceV9EL8eSFN7DjUCI36aGxhYQE/Pz907twZFhZc/IjUl5ZfivUnq8dxvT2sPTfHJCKts7MwxQt9vQEAX0ZeQ5VSJXIiUle9i5snnniiZlPMJ5544qGPhli+fDm8vLxgZmaGoKAgHDly5KHnr1+/Hv7+/rCwsICrqyumTp2K7OzsBj0n6Z5l+2+gQqlCdy979G7jKHYcIjJSU3u1QjMLE8RnFWNbTKrYcUhN9S5ubG1taz5N29jYwNbW9oGP+tq0aRPmzp2L9957DzExMejTpw+GDx9+35lYAHD06FFMnjwZ06dPx6VLl7B582acOXMGM2bMqPdzku5JySnB71EpAICwx9qx1YaIRGNtZoKX+1cvHPr1P9dRUcXWG32k1q7gmtK9e3d06dIFK1asqDnWsWNHjB07FuHh4XXO/+KLL7BixQrcvHmz5ti3336Lzz77DCkpKfV6Tu4KrnvmbTmPTVEp6N3GEb/O6C52HCIycqUVSvT7/AAyCsvxyZhOeC6kldiRCA17/1ZrzM3AgQORl5d33yceOHBgve5RUVGB6OhoDBkypNbxIUOG4Pjx4/e9pmfPnrh16xYiIiIgCALu3LmDLVu2YOTIkQ98nvLychQUFNR6kO5Iyi7GlrO3AACvP9ZO5DRERIC5qQyvDmwDAPh2/w2UVihFTkQNpVZxc/DgQVRUVNQ5XlZW9sgxM/dkZWVBqVTCxcWl1nEXFxekp6ff95qePXti/fr1mDBhAkxNTdG8eXPY2dnh22+/feDzhIeH1+oy8/DwqFc+0o6v912HUiWgf3snBHk2EzsOEREA4OmuLdHCzhwZheX45WSi2HGogRpU3Jw/fx7nz58HAMTFxdV8ff78ecTExGD16tVo0aJFgwL87/gKQRAeOOYiLi4Os2fPxgcffIDo6Gj8/fffSEhIwMyZMx94//nz5yM/P7/mUd/uK2p6NzOLsOPugL3XB7PVhoh0h6lcijmD2wIAVhy8iaLyKpETUUM0aBG/gIAASCQSSCSS+3Y/mZubP7QV5b85OjpCJpPVaaXJyMio05pzT3h4OHr16oW33noLANC5c2dYWlqiT58+WLhwIVxdXetco1AouPaOjvr6n+tQCcDgji7w97ATOw4RUS1PBLbA9wdvIj6rGD8fT8SsAW3EjkT11KCWm4SEBNy8eROCIOD06dNISEioeaSmpqKgoADTpk2r171MTU0RFBSEyMjIWscjIyPRs2fP+15TUlICqbR2ZJmseu8h7gWiX67dKcTu87cBAK8/1lbkNEREdcllUrw2qLqgWXUknq03eqRBLTeentUbi6lUmpkaFxYWhueeew7BwcEICQnBypUrkZycXNPNNH/+fKSmpmLdunUAgNDQULzwwgtYsWIFhg4dirS0NMydOxfdunWDm5ubRjKRdnz1zzUIAjDctzk6udV/+QAiIm0K7eyGb/fdQHxWMdadSMQr/dl6ow/U2lvqnri4OCQnJ9cZXDx69Oh6XT9hwgRkZ2fj448/RlpaGnx9fREREVFTRKWlpdVa82bKlCkoLCzEsmXL8MYbb8DOzg4DBw7E4sWLG/MySMvibhcg4kI6JJLqnb+JiHSVXCbFqwPbIOz3c1h1OB7Ph7SCpaJRb52kBWqtcxMfH4/HH38cFy5cgEQiqekSujcQWKnU3WlzXOdGfC+si0Jk3B2E+rvh22cCxY5DRPRQVUoVBi89hMTsEswb1qFmkT/SriZf52bOnDnw8vLCnTt3YGFhgUuXLuHw4cMIDg7GwYMH1bklGYmLqfmIjLsDqQSYM4hjbYhI98llUrw2sPr31crDN1HMsTc6T63i5sSJE/j444/h5OQEqVQKqVSK3r17Izw8HLNnz9Z0RjIg3+6/DgAI9XdDG2crkdMQEdXPmAA3tHKwQG5JJX45mSR2HHoEtYobpVIJK6vqNyZHR0fcvl0968XT0xNXr17VXDoyKFfSC7Dn0h1IJMBrAzkoj4j0R/XYm3utN/FsvdFxahU3vr6+NYv5de/eHZ999hmOHTuGjz/+GN7e3hoNSIbj2/03AAAjfF3Rxtla5DRERA0zNsANng4WyCmuwK9svdFpahU377//fs108IULFyIpKQl9+vRBREQEvvnmG40GJMNwI6MQERfSAKBmzxYiIn0il0nx6t2F/FYejkdJBVtvdJVa89mGDh1a82dvb2/ExcUhJycHzZo1e+DWCWTcvjtwE4IAPObjgo6unKVGRPrp8cAW+Hb/DSTnlODXk0l4sS9nTumiBrfcVFVVQS6X4+LFi7WO29vbs7Ch+0rMKsbO2Oo9pGYP5AwpItJfbL3RDw0ubuRyOTw9PXV6LRvSLcsP3oBKAAa0d4KfO1cjJiL99niXFvCwN0dWUQXWn0x+9AWkdWqPuZk/fz5ycnI0nYcMTEpOCbadrW61eY3r2hCRATCRSTGr/797TpVV8sO+rlFrzM0333yDGzduwM3NDZ6enrC0tKz1/bNnz2okHOm/FYduokoloHcbR3Rp2UzsOEREGvFEF3d8ve860vLLsPXsLUzq7il2JPovahU3Y8aM4fgaeqS0/FJsiboFgOvaEJFhMZVL8WJfbyzYHYfvD93EhGAPyGVqdYZQE1CruPnoo480HIMM0Q+H4lGhVKG7lz26ezuIHYeISKOe7toS3+6/gZScUuw+fxuPB7qLHYnuUqvM9Pb2RnZ2dp3jeXl5XMSPAAAZhWXYcLp6oN1sjrUhIgNkbirD9N5eAIDlB25CpWrwPtTURNQqbhITE+87W6q8vBy3bt1qdCjSf6uPJKC8SoUuLe3QszVbbYjIMD0X4glrhRzXM4oQefmO2HHorgZ1S+3atavmz3v27IGt7b/TepVKJfbt2wcvLy/NpSO9lF9SWbM0+awBbTg+i4gMlo2ZCSb39MR3B25i+YEbGOLjwt95OqBBxc3YsWMBABKJBM8//3yt75mYmKBVq1ZYsmSJxsKRfvrlZCKKK5To0NwaAzs4ix2HiKhJTevlhdVHE3DuVj6O3shCn7ZOYkcyeg3qllKpVFCpVGjZsiUyMjJqvlapVCgvL8fVq1cxatSopspKeqC0Qom1xxIBAC/3b81PMERk8BysFHimW0sAwHcHboichgA1x9wkJCTA0dFR01nIAGyOTkF2cQXcm5ljpJ+r2HGIiLTixb7eMJFJcDI+B9FJXOBWbGpNBQeAffv2Yd++fTUtOP9tzZo1jQ5G+qdSqcIPh+IBAC/19eaaD0RkNFxtzfFkF3dsPJOC5QduYvUUe7EjGTW13n0WLFiAIUOGYN++fcjKykJubm6tBxmnP87fRmpeKRytTDEu2EPsOEREWjWzX2tIJcC+KxmIu10gdhyjplbLzffff4+ffvoJzz33nKbzkJ5SqQSsOHgTADC1lxfMTGQiJyIi0q5WjpYY1dkNu87dxncHb+C7iV3EjmS01Gq5qaioQM+ePTWdhfTY/isZuHanCFYKOZ7twT1WiMg4vTKgNQDgrwtpSM4uETmN8VKruJkxYwZ+++03TWchPSUIApYfrJ4hMKlHS9iam4iciIhIHB2a26B/eyeoBODHo/FixzFaanVLlZWVYeXKlfjnn3/QuXNnmJjUfjNbunSpRsKRfjiTmIuzyXkwlUsxvRcXcSQi4/ZS39Y4eDUTv0elYM6gtnCwUogdyeioVdycP38eAQEBAICLFy/W+h7XNTE+91ptngpyh7ONmchpiIjE1cPbHp3dbXH+Vj7WnUjC64+1EzuS0VGruDlw4ICmc5CeirtdgINXMyGVAC/24aapREQSiQQv9W2NWb+dxboTiZjZrzXMTTnJQpsatRDJjRs3sGfPHpSWlgKoHntBxuX7Q9UzpEb4uaKVo6XIaYiIdMMw3+ZoaW+B3JJKbI5OETuO0VGruMnOzsagQYPQrl07jBgxAmlpaQCqBxq/8cYbGg1IuutWbgn+vFD9dz+zX2uR0xAR6Q6ZVIIX+lSPQVx1JB5VStUjriBNUqu4ef3112FiYoLk5GRYWFjUHJ8wYQL+/vtvjYUj3bb2WCKUKgG92jjAt4Xtoy8gIjIiTwV5wN7SFCk5pfjrYrrYcYyKWsXN3r17sXjxYri7u9c63rZtWyQlJWkkGOm2/NJKbDydDAB4gWNtiIjqMDeVYXJI9bpfKw/Hc+iGFqlV3BQXF9dqsbknKysLCgWnvBmDjaeTUVyhRDsXK/Rr5yR2HCIinTQ5pBXMTKS4kJqPEzezxY5jNNQqbvr27Yt169bVfC2RSKBSqfD5559jwIABGgtHuqmiSoW1xxIBADP6eHP6PxHRA9hbmmLC3b32vj/MRf20Ra2p4J9//jn69++PqKgoVFRU4O2338alS5eQk5ODY8eOaToj6Zg/zt9GekEZnKwVGBPgJnYcIiKdNqOPN345mYTD1zIRd7sAPm42YkcyeGq13Pj4+OD8+fPo1q0bHnvsMRQXF+OJJ55ATEwMWrfmrBlDJggCVh1JAABM6dkKCjnXbiAiehgPewuM8HMFUD1zipqeWi03ANC8eXMsWLBAk1lIDxy7kY3LaQWwMJVhUveWYschItILL/VtjT/Op2HXudt4c2h7tLAzFzuSQVOr5Wbt2rXYvHlzneObN2/Gzz//3OhQpLtW3v3UMT7YA3YWpiKnISLSD37utgjxdoBSJWDd8USx4xg8tYqbTz/9FI6OjnWOOzs7Y9GiRY0ORbrpSnoBDl+r3mphGjfIJCJqkBl3F/X77XQyisurRE5j2NQqbpKSkuDlVffNzdPTE8nJyQ261/Lly+Hl5QUzMzMEBQXhyJEjDz2/vLwc7733Hjw9PaFQKNC6dWusWbOmQc9J6vnx7lib4b6uaOlQdykAIiJ6sAHtneHtaInCsipsjuKWDE1JreLG2dkZ58+fr3P83LlzcHBwqPd9Nm3ahLlz5+K9995DTEwM+vTpg+HDhz+0QBo/fjz27duH1atX4+rVq9iwYQM6dOigzsugBrhTUIadsakA/v30QURE9SeVSjC1VysAwNrj1Su8U9NQq7h5+umnMXv2bBw4cABKpRJKpRL79+/HnDlz8PTTT9f7PkuXLsX06dMxY8YMdOzYEV999RU8PDywYsWK+57/999/49ChQ4iIiMDgwYPRqlUrdOvWDT179lTnZVAD/HQ8EZVKAV1bNUNgy2ZixyEi0ktPBrnD1twESdkl+OfyHbHjGCy1ipuFCxeie/fuGDRoEMzNzWFubo4hQ4Zg4MCB9R5zU1FRgejoaAwZMqTW8SFDhuD48eP3vWbXrl0IDg7GZ599hhYtWqBdu3Z48803a3Ylv5/y8nIUFBTUelDDFJdXYf3J6m01uNUCEZH6LEzlmHh3punqowkipzFcak0FNzU1xaZNm/DJJ5/g3LlzMDc3h5+fHzw9Pet9j6ysLCiVSri4uNQ67uLigvT0+28wFh8fj6NHj8LMzAzbt29HVlYWXnnlFeTk5Dxw3E14eDinrDfStrO3UFBWhVYOFhjc0eXRFxAR0QM9H9IKqw7H43RCDi7cyoefOzce1jS1Wm7uadeuHcaNG4dRo0Y1qLD5b/+7dL8gCA9czl+lUkEikWD9+vXo1q0bRowYgaVLl+Knn356YOvN/PnzkZ+fX/NISeEgroZQqYSarRam9vKCVMqtFoiIGqO5rRlGda5e1G/1US7q1xTUarlRKpX46aefsG/fPmRkZEClUtX6/v79+x95D0dHR8hksjqtNBkZGXVac+5xdXVFixYtYGv7b5XbsWNHCIKAW7duoW3btnWuUSgU3MyzEQ5dy0R8VjGsFXI8GeT+6AuIiOiRpvf2xo7Y2/jjfBreGd4RzW3NxI5kUNRquZkzZw7mzJkDpVIJX19f+Pv713rUh6mpKYKCghAZGVnreGRk5AMHCPfq1Qu3b99GUVFRzbFr165BKpXC3Z1vvE1hzbHqPuEJXT1gpVB7QWsiIvovfu626NbKHlUqAetOJIodx+Co9W61ceNG/P777xgxYkSjnjwsLAzPPfccgoODERISgpUrVyI5ORkzZ84EUN2llJqaWrMD+cSJE/HJJ59g6tSpWLBgAbKysvDWW29h2rRpMDfnUtaadv1OIY5cz4JUAjzfs5XYcYiIDMr0Pl44nZiD9aeS8erANrAw5QdITVF7QHGbNm0a/eQTJkxAdnY2Pv74Y6SlpcHX1xcRERE143fS0tJqrXljZWWFyMhIvPbaawgODoaDgwPGjx+PhQsXNjoL1bX27hLhj/m4wMOei/YREWnS4I4uaGlvgeScEmw9m4rneqg3dpXqkgiC0OBVhJYsWYL4+HgsW7bsgYN/dVVBQQFsbW2Rn58PGxtuO/8geSUV6BG+D2WVKmx8sQd6eNd/cUYiIqqftccSsGB3HLwdLfFPWD9O2niIhrx/q9Vyc/ToURw4cAB//fUXOnXqBBMTk1rf37Ztmzq3JR2y4XQKyipV8HG1QXcve7HjEBEZpHHBHlgaeQ3xWcU4cDUDg7jchkaoVdzY2dnh8ccf13QW0hGVSlXNALepvVrpXescEZG+sFLI8Uy3llh5OB4/HU9kcaMhahU3a9eu1XQO0iF/X0xHWn4ZHK1MEervJnYcIiKD9lwPT/x4JB5HrmfhRkYR2jhbiR1J7zVqEb/MzEwcPXoUx44dQ2ZmpqYykcjW3p3+Pam7J8xMZCKnISIybB72FjUtNpwWrhlqFTfFxcWYNm0aXF1d0bdvX/Tp0wdubm6YPn06SkpKNJ2RtCg2JQ9nk/NgIpNgUo+WYschIjIKU+4ut7El+hYKyirFDWMA1CpuwsLCcOjQIezevRt5eXnIy8vDzp07cejQIbzxxhuazkhadK/VJtTfDc7WXDGTiEgberZ2QFtnK5RUKLEl6pbYcfSeWsXN1q1bsXr1agwfPhw2NjawsbHBiBEjsGrVKmzZskXTGUlL0vPL8Of5NADAtF5eIqchIjIeEomkZrHUdScSoVI1eJUW+i9qFTclJSX33f/J2dmZ3VJ6bP2pJFSpBHRt1Qy+LbhLLRGRNj0e2ALWZnIkZpfg0HWOY20MtYqbkJAQfPjhhygrK6s5VlpaigULFiAkJERj4Uh7yquU2HC6ejXoKT3ZakNEpG2WCjnGB3sAAH46lihuGD2n1lTwr7/+GsOGDYO7uzv8/f0hkUgQGxsLMzMz7NmzR9MZSQv+vpiOrKIKuNgoMKQT11kgIhLD5BBPrDmWgEPXMhGfWQRvJ04LV4daLTe+vr64fv06wsPDERAQgM6dO+PTTz/F9evX0alTJ01nJC1YdyIJAPBMt5YwkTVqhQAiIlKTp4MlBrZ3BvDv72VqOLW3IDU3N8cLL7ygySwkkoup+YhOyoVcKsHEbpz+TUQkpud7tsK+KxnYEn0Lbw5tDysFdwtvKLU+ooeHh2PNmjV1jq9ZswaLFy9udCjSrl/ufjoY5tsczjac/k1EJKbebRzh7WSJovIqbI3mtHB1qFXc/PDDD+jQoUOd4506dcL333/f6FCkPXklFdgRmwoANdMQiYhIPFKpBM+HtAIA/Mxp4WpRq7hJT0+Hq6trneNOTk5IS0trdCjSns1Rt1BepUKH5tYI9mwmdhwiIgLwZJA7rBRyxGcW4+iNLLHj6B21ihsPDw8cO3aszvFjx47BzY0bLeoLlUrALyeru6Se78ndv4mIdIWVQo6ngtwBAD8fTxQ3jB5Sa5TSjBkzMHfuXFRWVmLgwIEAgH379uHtt9/m9gt65NC1TCTnlMDaTI4xASxKiYh0yeQQT/x0PBH7r2YgJacEHvYWYkfSG2oVN2+//TZycnLwyiuvoKKiAgBgZmaGefPmYf78+RoNSE3n57u7z44P9oCFKUfjExHpEm8nK/Ru44ijN7Kw4XQy3h5Wd6wr3Z9a3VISiQSLFy9GZmYmTp48iXPnziEnJwcffPCBpvNRE0nMKsaha9XLez/bw1PkNEREdD/P9qhenmPTmRSUVylFTqM/GrVam5WVFbp27QpfX18oFApNZSIt+PVkEgQB6NfOCV6OlmLHISKi+xjc0QUuNgpkF1fg74vpYsfRG1yK1giVVijxe1QKgOo+XSIi0k1ymRTP3F1c9deTXLG4vljcGKGdsakoKKuCh705+t9d5puIiHTT011bQiaV4ExiLq6kF4gdRy+wuDEygiDU7FfybHdPyKSc/k1EpMua25phiE/1hsbrTyaLnEY/sLgxMmeT8xCXVgCFXIrxwR5ixyEionq4N/Fj29lbKCqvEjmN7lO7uPnll1/Qq1cvuLm5ISmpuiXgq6++ws6dOzUWjjRv/anqv6tRnd3QzNJU5DRERFQfPVs7wNvJEsUVSuyISRU7js5Tq7hZsWIFwsLCMGLECOTl5UGprJ6eZmdnh6+++kqT+UiD8koq8Of56u0xJvXg7t9ERPpCIpFgUvfq1pvq2a7cb+ph1Cpuvv32W6xatQrvvfceZDJZzfHg4GBcuHBBY+FIs7aeTa3ZRyrQw07sOERE1ABPdXGHmYkUV9ILEZ2UK3YcnaZWcZOQkIDAwMA6xxUKBYqLixsdijRPEISaLqlJPTy5jxQRkZ6xtTDBaP/qrXI4Lfzh1CpuvLy8EBsbW+f4X3/9BR8fn8ZmoiZwKiEH8ZnFsDCVYSz3kSIi0kv3BhZHXEhHdlG5yGl0l1obCr311luYNWsWysrKIAgCTp8+jQ0bNiA8PBw//vijpjOSBqw/VT19cEyAG6zNTEROQ0RE6ujsbofO7rY4fysfv0fdwsv9W4sdSSepVdxMnToVVVVVePvtt1FSUoKJEyeiRYsW+Prrr/H0009rOiM1UlZROf6+WD2QeGI3rkhMRKTPnu3hibe3nMdvp5PwYl9vrld2H2pPBX/hhReQlJSEjIwMpKenIyUlBdOnT9dkNtKQLdG3UKkU4O9uCz93W7HjEBFRI4R2doONmRwpOaU4fHcDZKqt0Yv4OTo6wtmZS/jrKpVKwIbT1V1SE7tz+jcRkb4zN5XhqaDqRVjvTRSh2urdLRUYGFjvGTZnz55VOxBp1rGbWUjKLoG1Qo5Qfw4kJiIyBBO7e2DNsQTsv5KB9PwyNLc1EzuSTql3cTN27NgmjEFN5be7A4mf6NICFqZqDbEiIiId08bZGt1a2eN0Yg42R6XgtUFtxY6kU+r9bvfhhx82ZQ5qAhkFZdgbdwcAMLE7BxITERmSZ7p74HRiDjaeScErA9pwYPF/4caZBuz3qBQoVQKCPZuhfXNrseMQEZEGDfd1hY2ZHKl5pThynQOL/1u9ixt7e3tkZWUBAJo1awZ7e/sHPhpi+fLl8PLygpmZGYKCgnDkyJF6XXfs2DHI5XIEBAQ06PmMhVIlYMPpFADcR4qIyBCZmcjwRBd3AMDGu7/vqVq9u6W+/PJLWFtXf/rX1OaYmzZtwty5c7F8+XL06tULP/zwA4YPH464uDi0bPngN+T8/HxMnjwZgwYNwp07dzSSxdAcupaB1LxS2FmYYLivq9hxiIioCTzTrSV+Op6Ify7fQUZBGZxtOLAYACSCiFuLdu/eHV26dMGKFStqjnXs2BFjx45FeHj4A697+umn0bZtW8hkMuzYseO+W0E8SEFBAWxtbZGfnw8bG5vGxNdpM34+g38uZ2BGby+8P4pbYhARGaonVxxHdFIu3hraHrMGtBE7TpNpyPu32mNulEoltmzZgk8++QQLFy7E1q1bUVVVVe/rKyoqEB0djSFDhtQ6PmTIEBw/fvyB161duxY3b96s9wDn8vJyFBQU1HoYuvT8Muy/kgEAeIZr2xARGbSnu1avebPpTApUKtHaK3SKWnODL168iDFjxiA9PR3t27cHAFy7dg1OTk7YtWsX/Pz8HnmPrKwsKJVKuLi41Dru4uKC9PT0+15z/fp1vPPOOzhy5Ajk8vpFDw8Px4IFC+p1rqHYEp0ClQB087JHaycrseMQEVETGtXZDR//EYfknBIcv5mN3m0dxY4kOrVabmbMmIFOnTrh1q1bOHv2LM6ePYuUlBR07twZL774YoPu9b8LAwqCcN/FApVKJSZOnIgFCxagXbt29b7//PnzkZ+fX/NISTHsQVcqlYBNUdWv8V41T0REhsvcVIbHA1sAQM2K9MZOrZabc+fOISoqCs2aNas51qxZM/znP/9B165d63UPR0dHyGSyOq00GRkZdVpzAKCwsBBRUVGIiYnBq6++CgBQqVQQBAFyuRx79+7FwIED61ynUCigUCga8vL02on4bKTklMLaTM6BxERERuLpri2x7kQS9salI6uoHI5WxvO+dz9qtdy0b9/+vrOUMjIy0KZN/QYzmZqaIigoCJGRkbWOR0ZGomfPnnXOt7GxwYULFxAbG1vzmDlzJtq3b4/Y2Fh0795dnZdicDaeqW61GRvQAuamMpHTEBGRNvi42cDfww6VSgFbo2+JHUd09W65+e+BuIsWLcLs2bPx0UcfoUePHgCAkydP4uOPP8bixYvr/eRhYWF47rnnEBwcjJCQEKxcuRLJycmYOXMmgOoupdTUVKxbtw5SqRS+vr61rnd2doaZmVmd48Yqt7gCey5Wt4RNYJcUEZFRmdjNA+dS8rDxTApe7Otd7/0gDVG9ixs7O7taPyhBEDB+/PiaY/dmlIeGhkKpVNbrnhMmTEB2djY+/vhjpKWlwdfXFxEREfD0rN4qIC0tDcnJ7D+sr+0xqahQquDbwga+LWzFjkNERFo0qrMbPt4dh4SsYpyMz0FIawexI4mm3uvcHDp0qN437devn9qBmpqhrnMjCAKGfXUEV+8U4pOxvniuB/eSIiIyNu9uv4DfTiVjtL8bvnkmUOw4GtWQ9+96t9zocsFCQGxKHq7eKYSZiRSj/d3EjkNERCKY2K0lfjuVjL8vpiOnuAL2lqZiRxKFWrOlACAvLw+rV6/G5cuXIZFI4OPjg2nTpsHWlt0hYth0dyDxCD9X2JqbiJyGiIjE4NvCFr4tbHAxtQDbY1IxvbeX2JFEodZsqaioKLRu3RpffvklcnJykJWVhaVLl6J169Y4e/aspjPSIxSVV2HXudsAqqcDEhGR8Zpw931gc1QKRNxhSVRqFTevv/46Ro8ejcTERGzbtg3bt29HQkICRo0ahblz52o4Ij3Kn+dvo6RCCW9HS3Rt1ezRFxARkcEa7e8GhVyKK+mFuJCaL3YcUajdcjNv3rxaWyDI5XK8/fbbiIqK0lg4qp97a9tM6Oph1FP/iIgIsDU3wTDf5gCA36MMe1X+B1GruLGxsbnvFO2UlBRYW1s3OhTV39X0QsQk50EuleCJLu5ixyEiIh0wPrh6rbOdsbdRVlm/5VkMiVrFzYQJEzB9+nRs2rQJKSkpuHXrFjZu3IgZM2bgmWee0XRGeoh7A4kHd3SBk7VxL7dNRETVQrwd0MLOHIVlVdhz6f6bURsytWZLffHFF5BIJJg8eTKqqqoAACYmJnj55Zfx6aefajQgPVh5lRLbYqqX2Z7QjSsSExFRNalUgnHB7vjqn+v4PSoFYwJaiB1Jq9RquTE1NcXXX3+N3NxcxMbGIiYmBjk5Ofjyyy+NapNKse29dAd5JZVwtTVD37ZOYschIiId8lSQOyQS4NiNbKTklIgdR6vUKm7usbCwgJ+fHzp37gwLCwtNZaJ6utclNS7IHTIpBxITEdG/3JtZoHcbRwDAZiPbTLNB3VLTpk2r13lr1qxRKwzVX2peKY7dzAIAjAtmlxQREdU1LtgDR65nYUtUCuYMams0H4QbVNz89NNP8PT0RGBgoNEuDKQrtkXfgiAAPbzt4WHPVjMiIqpriI8LbMzkuJ1fhuM3s9DHSIYwNKi4mTlzJjZu3Ij4+HhMmzYNzz77LOzt7ZsqGz2AIAjYcra6iXFcEFttiIjo/sxMZBgb2ALrTiTh96hbRlPcNGjMzfLly5GWloZ58+Zh9+7d8PDwwPjx47Fnzx625GjRmcRcJGWXwNJUhuF+zcWOQ0REOuzemjd7LqUjr6RC5DTa0eABxQqFAs888wwiIyMRFxeHTp064ZVXXoGnpyeKioqaIiP9j813V5wc2dkVFqZq731KRERGoJObDTq62qCiSlWzD6Gha9RsKYlEAolEAkEQoFKpNJWJHqK4vAp/XkgDwIHERET0aBKJBOODq1ewvzfL1tA1uLgpLy/Hhg0b8Nhjj6F9+/a4cOECli1bhuTkZFhZWTVFRvovf11MR0mFEq0cLBDsyU0yiYjo0cYGtICpTIpLtwtw0Qg202xQn8Yrr7yCjRs3omXLlpg6dSo2btwIBweHpspG97Elurrqrl6cyTim9BERUeM0szTFY51c8Of5NGyJvgXfFrZiR2pSEqEBI4GlUilatmyJwMDAh76xbtu2TSPhmkJBQQFsbW2Rn58PGxsbseM0SHJ2Cfp+fqB6xcl5A+FmZy52JCIi0hOHrmXi+TWnYWtugtPvDYJCLhM7UoM05P27QS03kydPZmuBiLbenf7du40jCxsiImqQ3m0c4WprhrT8Muy7nIERfq5iR2oyDV7Ej8ShUgnYcnf57KeC3EVOQ0RE+kYmlWBsYAusOHgTW6NvGXRx06jZUqQ9J+OzkZpXCmszOYZ24to2RETUcE92qf5wfPBaJjILy0VO03RY3OiJe602of5uMDPRr35SIiLSDW2creDvYQelSsDO2FSx4zQZFjd6oLCsEhEXq9e2YZcUERE1xlNdWgAAtp5lcUMiiriQhrJKFVo7WSLQw07sOEREpMdC/d1gKpPicloB4m4XiB2nSbC40QObo+4NJPbgbDUiImoUOwtTDOroDADYdncWrqFhcaPj4jOLEJWUC6kEeOJuUyIREVFj3BtYvCP2NqqUhrd9EosbHbftbp9o33ZOcLExEzkNEREZgn7tneBgaYqsonIcvp4pdhyNY3Gjw1QqAdtjqoube1U2ERFRY5nIpBgTcHdgcbThDSxmcaPDTifmVK9to5DjMR8XseMQEZEBeTKouriJjLuD/JJKkdNoFosbHbb9bpfUCD9Xrm1DREQa1cnNFh2aW6NCqcLu87fFjqNRLG50VFmlEhEXqte2eZwDiYmIqAncWzttq4HNmmJxo6Mi4+6gsLwKLezM0a2VvdhxiIjIAI0OcINMKkFMch5uZhaJHUdjWNzoqHsDiR8PbAGplGvbEBGR5jlbm6FvW0cAhrXmDYsbHZRZWI5D16qn5rFLioiImtKTd7umtp9NhUoliJxGM1jc6KDd525DqRLg72GH1k5WYschIiIDNrijC2zM5LidX4YT8dlix9EIFjc66F6X1BOBbLUhIqKmZWYiwyh/NwDA1mjD6JoSvbhZvnw5vLy8YGZmhqCgIBw5cuSB527btg2PPfYYnJycYGNjg5CQEOzZs0eLaZve9TuFuJCaD7lUgtC7/9iIiIia0r2FYv++lI6SiiqR0zSeqMXNpk2bMHfuXLz33nuIiYlBnz59MHz4cCQnJ9/3/MOHD+Oxxx5DREQEoqOjMWDAAISGhiImJkbLyZvOtrutNv3bO8Pe0lTkNEREZAy6tLSDp4MFSiqUiIy7I3acRpMIgiDa6KHu3bujS5cuWLFiRc2xjh07YuzYsQgPD6/XPTp16oQJEybggw8+qNf5BQUFsLW1RX5+PmxsbNTK3VRUKgG9Fu9HWn4Zlk/qghF+rmJHIiIiI7E08hq+2Xcd/ds74aep3cSOU0dD3r9Fa7mpqKhAdHQ0hgwZUuv4kCFDcPz48XrdQ6VSobCwEPb2D14Hpry8HAUFBbUeuupkfDbS8stgbSbHwA7OYschIiIjMjageijEketZyCwsFzlN44hW3GRlZUGpVMLFpfaeSS4uLkhPT6/XPZYsWYLi4mKMHz/+geeEh4fD1ta25uHh4dGo3E3pXpfUqM5u3G6BiIi0ytvJCv4edlCqBPyh59sxiD6gWCKpvUCdIAh1jt3Phg0b8NFHH2HTpk1wdn5wK8f8+fORn59f80hJSWl05qZQWqHEX3e3W3iCa9sQEZEIHr/berMjlsWNWhwdHSGTyeq00mRkZNRpzflfmzZtwvTp0/H7779j8ODBDz1XoVDAxsam1kMX7Y1LR3GFEh725gj2bCZ2HCIiMkKj/Ku3YziXkod4Pd6OQbTixtTUFEFBQYiMjKx1PDIyEj179nzgdRs2bMCUKVPw22+/YeTIkU0dU2u2nb233YJ7vVquiIiINM3RSoE+d7dj0OfWG1G7pcLCwvDjjz9izZo1uHz5Ml5//XUkJydj5syZAKq7lCZPnlxz/oYNGzB58mQsWbIEPXr0QHp6OtLT05Gfny/WS9CIjIIyHLl+d7sFLtxHREQiuvc+tCMmFSJOqG4UUYubCRMm4KuvvsLHH3+MgIAAHD58GBEREfD09AQApKWl1Vrz5ocffkBVVRVmzZoFV1fXmsecOXPEegkasevcbaiE6nUGvBwtxY5DRERG7DEfF1iYypCcU4KYlDyx46hF1HVuxKCL69yM+vYILqYW4JOxvniuh6fYcYiIyMiFbYrFtphUTA7xxMdjfMWOA0BP1rmhajcyinAxtQByqQQjuWgfERHpgDF3u6Z2n7uNSqVK5DQNx+JGZLtiqwcS923nxO0WiIhIJ/Rq7QBHKwVySypx+Fqm2HEajMWNiARBwM5z1aPRxwRwk0wiItINcpkUo/31d80bFjciOncrH0nZJTA3keExn4ev7UNERKRN92ZN7b2UjsKySpHTNAyLGxHtvNslNaSTCyxM5SKnISIi+pdvCxt4O1mivEqFPZf0a6dwFjciqVKqsPtc9XYL7JIiIiJdI5FI8HjAv2ve6BMWNyI5EZ+NrKJyNLMwQZ+2TmLHISIiqmPM3eLm2M0s3CkoEzlN/bG4EcnOuwO0Rvi5wkTGvwYiItI9LR0sEOzZDIJQPS1cX/BdVQRllUr8fbF6w9Cx3G6BiIh02L01b7brUdcUixsR7L+SgaLyKrSwM0dQS+4ATkREumuUnytMZBJcul2AGxmFYsepFxY3Irg3SyrU3w1SKXcAJyIi3dXM0hR9744N3aUna96wuNGy/NJKHLhSvdojZ0kREZE+CL27oN/u82l6sVM4ixst23MxHRVKFdq7WKOjq25s3ElERPQwj/m4wMxEioSsYlxMLRA7ziOxuNGyneequ6RGs9WGiIj0hKVCjkEdq1fS33VO9wcWs7jRojsFZTh+MxsAavbsICIi0gehnavft/44nwaVSre7pljcaNHuc7chCECQZzN42FuIHYeIiKje+rd3grVCjrT8MkQl5Yod56FY3GjRLu4ATkREesrMRIahvs0B6H7XFIsbLYnPLML5W/mQSSUY6ecqdhwiIqIGuzekIuJCOqqUKpHTPBiLGy2512rTp60jHKwUIqchIiJquJ6tHeBgaYqc4gocuzuGVBexuNECQRBqFj5ilxQREekruUyKEXd7H3R5QT8WN1pw6XYB4rOKoZBL8ZhPc7HjEBERqe3eUiZ7L6WjrFIpcpr7Y3GjBX+cTwMADOzgDCuFXOQ0RERE6gtq2QyutmYoLK/CwauZYse5LxY3TUwQBPxxvrrpLpRr2xARkZ6TSiX/bsdwTje7pljcNLHYlDzcyi2FhakMA9o7ix2HiIio0e7Nmvrn8h0UlVeJnKYuFjdN7F6X1OCOLjA3lYmchoiIqPE6udnA29ES5VUq/BN3R+w4dbC4aUIqlYA/7xY3ozpzbRsiIjIMEokEo+623uzSwa4pFjdNKCopF+kFZbA2k6Nfeyex4xAREWnMva6pw9cykVtcIXKa2ljcNKF7A4mH+DSHQs4uKSIiMhxtnK3g42qDKpWAvy+lix2nFhY3TaRKqULEhbtdUv7skiIiIsNzb9aUri3ox+KmiZxKyEFWUQXsLEzQu42j2HGIiIg0LvTuh/eTCdm4U1Amcpp/sbhpIve6pIb7NoeJjD9mIiIyPO7NLBDk2QyCgJreCl3Ad90mUKlU4a+L1f2Pozpz4T4iIjJc92YD31v6RBewuGkCR29kIa+kEo5WpujuZS92HCIioiYzws8VEgkQnZSL23mlYscBwOKmSfxxrrp6HeHnCjm7pIiIyIC52Jiha6vqD/K60jXFd14NK69SYu8ldkkREZHxuNc1tVtHuqZY3GjYoauZKCyvQnMbMwR7NhM7DhERUZMb5tscUglwLiUPKTklYscRv7hZvnw5vLy8YGZmhqCgIBw5cuSh5x86dAhBQUEwMzODt7c3vv/+ey0lrZ97A6pGdnaFVCoROQ0REVHTc7Y2Q3cvBwDAnzrQNSVqcbNp0ybMnTsX7733HmJiYtCnTx8MHz4cycnJ9z0/ISEBI0aMQJ8+fRATE4N3330Xs2fPxtatW7Wc/P5KK5T453L1BmLcS4qIiIzJvQVr7y2FIiZRi5ulS5di+vTpmDFjBjp27IivvvoKHh4eWLFixX3P//7779GyZUt89dVX6NixI2bMmIFp06bhiy++0HLy+9t/JQMlFUq4NzNHgIed2HGIiIi0Zlin5pBJJbiYWoDErGJRs4hW3FRUVCA6OhpDhgypdXzIkCE4fvz4fa85ceJEnfOHDh2KqKgoVFZWNlnW+rpXrY7s7AqJhF1SRERkPBysFOjZWje6pkQrbrKysqBUKuHi4lLruIuLC9LT778BV3p6+n3Pr6qqQlZW1n2vKS8vR0FBQa1HUygqr8L+KxkAgFDOkiIiIiM00u/urKlz4nZNiT6g+H9bOARBeGirx/3Ov9/xe8LDw2Fra1vz8PDwaGTi+0vOLoGzjQJejpbo5GbTJM9BRESky4b5NodcKoFcJkFhmXg9KnKxntjR0REymaxOK01GRkad1pl7mjdvft/z5XI5HBwc7nvN/PnzERYWVvN1QUFBkxQ4Pm42OPzWAGQWlrNLioiIjJKdhSmOvzMQzjZmouYQreXG1NQUQUFBiIyMrHU8MjISPXv2vO81ISEhdc7fu3cvgoODYWJict9rFAoFbGxsaj2aikQiEf0vlIiISEy68D4oardUWFgYfvzxR6xZswaXL1/G66+/juTkZMycORNAdavL5MmTa86fOXMmkpKSEBYWhsuXL2PNmjVYvXo13nzzTbFeAhEREekY0bqlAGDChAnIzs7Gxx9/jLS0NPj6+iIiIgKenp4AgLS0tFpr3nh5eSEiIgKvv/46vvvuO7i5ueGbb77Bk08+KdZLICIiIh0jEe6NyDUSBQUFsLW1RX5+fpN2UREREZHmNOT9W/TZUkRERESaxOKGiIiIDAqLGyIiIjIoLG6IiIjIoLC4ISIiIoPC4oaIiIgMCosbIiIiMigsboiIiMigsLghIiIig8LihoiIiAyKqHtLieHebhMFBQUiJyEiIqL6uve+XZ9do4yuuCksLAQAeHh4iJyEiIiIGqqwsBC2trYPPcfoNs5UqVS4ffs2rK2tIZFINHrvgoICeHh4ICUlxSg35TT21w/wZ2Dsrx/gz4Cv37hfP9B0PwNBEFBYWAg3NzdIpQ8fVWN0LTdSqRTu7u5N+hw2NjZG+48a4OsH+DMw9tcP8GfA12/crx9omp/Bo1ps7uGAYiIiIjIoLG6IiIjIoLC40SCFQoEPP/wQCoVC7CiiMPbXD/BnYOyvH+DPgK/fuF8/oBs/A6MbUExERESGjS03REREZFBY3BAREZFBYXFDREREBoXFjYYsX74cXl5eMDMzQ1BQEI4cOSJ2JK05fPgwQkND4ebmBolEgh07dogdSavCw8PRtWtXWFtbw9nZGWPHjsXVq1fFjqVVK1asQOfOnWvWtQgJCcFff/0ldizRhIeHQyKRYO7cuWJH0ZqPPvoIEomk1qN58+Zix9Kq1NRUPPvss3BwcICFhQUCAgIQHR0tdiytadWqVZ1/AxKJBLNmzdJ6FhY3GrBp0ybMnTsX7733HmJiYtCnTx8MHz4cycnJYkfTiuLiYvj7+2PZsmViRxHFoUOHMGvWLJw8eRKRkZGoqqrCkCFDUFxcLHY0rXF3d8enn36KqKgoREVFYeDAgRgzZgwuXbokdjStO3PmDFauXInOnTuLHUXrOnXqhLS0tJrHhQsXxI6kNbm5uejVqxdMTEzw119/IS4uDkuWLIGdnZ3Y0bTmzJkztf7+IyMjAQDjxo3TfhiBGq1bt27CzJkzax3r0KGD8M4774iUSDwAhO3bt4sdQ1QZGRkCAOHQoUNiRxFVs2bNhB9//FHsGFpVWFgotG3bVoiMjBT69esnzJkzR+xIWvPhhx8K/v7+YscQzbx584TevXuLHUOnzJkzR2jdurWgUqm0/txsuWmkiooKREdHY8iQIbWODxkyBMePHxcpFYkpPz8fAGBvby9yEnEolUps3LgRxcXFCAkJETuOVs2aNQsjR47E4MGDxY4iiuvXr8PNzQ1eXl54+umnER8fL3Ykrdm1axeCg4Mxbtw4ODs7IzAwEKtWrRI7lmgqKirw66+/Ytq0aRrfx7E+WNw0UlZWFpRKJVxcXGodd3FxQXp6ukipSCyCICAsLAy9e/eGr6+v2HG06sKFC7CysoJCocDMmTOxfft2+Pj4iB1LazZu3IizZ88iPDxc7Cii6N69O9atW4c9e/Zg1apVSE9PR8+ePZGdnS12NK2Ij4/HihUr0LZtW+zZswczZ87E7NmzsW7dOrGjiWLHjh3Iy8vDlClTRHl+o9s4s6n8b2UqCIIo1SqJ69VXX8X58+dx9OhRsaNoXfv27REbG4u8vDxs3boVzz//PA4dOmQUBU5KSgrmzJmDvXv3wszMTOw4ohg+fHjNn/38/BASEoLWrVvj559/RlhYmIjJtEOlUiE4OBiLFi0CAAQGBuLSpUtYsWIFJk+eLHI67Vu9ejWGDx8ONzc3UZ6fLTeN5OjoCJlMVqeVJiMjo05rDhm21157Dbt27cKBAweafOd5XWRqaoo2bdogODgY4eHh8Pf3x9dffy12LK2Ijo5GRkYGgoKCIJfLIZfLcejQIXzzzTeQy+VQKpViR9Q6S0tL+Pn54fr162JH0QpXV9c6hXzHjh2NZmLJf0tKSsI///yDGTNmiJaBxU0jmZqaIigoqGZU+D2RkZHo2bOnSKlImwRBwKuvvopt27Zh//798PLyEjuSThAEAeXl5WLH0IpBgwbhwoULiI2NrXkEBwdj0qRJiI2NhUwmEzui1pWXl+Py5ctwdXUVO4pW9OrVq84SENeuXYOnp6dIicSzdu1aODs7Y+TIkaJlYLeUBoSFheG5555DcHAwQkJCsHLlSiQnJ2PmzJliR9OKoqIi3Lhxo+brhIQExMbGwt7eHi1bthQxmXbMmjULv/32G3bu3Alra+uaVjxbW1uYm5uLnE473n33XQwfPhweHh4oLCzExo0bcfDgQfz9999iR9MKa2vrOmOsLC0t4eDgYDRjr958802EhoaiZcuWyMjIwMKFC1FQUIDnn39e7Gha8frrr6Nnz55YtGgRxo8fj9OnT2PlypVYuXKl2NG0SqVSYe3atXj++echl4tYYmh9fpaB+u677wRPT0/B1NRU6NKli1FNAz5w4IAAoM7j+eefFzuaVtzvtQMQ1q5dK3Y0rZk2bVrNv38nJydh0KBBwt69e8WOJSpjmwo+YcIEwdXVVTAxMRHc3NyEJ554Qrh06ZLYsbRq9+7dgq+vr6BQKIQOHToIK1euFDuS1u3Zs0cAIFy9elXUHNwVnIiIiAwKx9wQERGRQWFxQ0RERAaFxQ0REREZFBY3REREZFBY3BAREZFBYXFDREREBoXFDRERERkUFjdERERkUFjcEBER0X0dPnwYoaGhcHNzg0QiwY4dO5r8OVNTU/Hss8/CwcEBFhYWCAgIQHR0dIPuweKGiPTe6tWrMWTIkEbdIyMjA05OTkhNTdVQKiL9V1xcDH9/fyxbtkwrz5ebm4tevXrBxMQEf/31F+Li4rBkyRLY2dk16D7cfoGI9Fp5eTm8vb2xceNG9OnTp1H3CgsLQ0FBAX788UcNpSMyHBKJBNu3b8fYsWNrjlVUVOD999/H+vXrkZeXB19fXyxevBj9+/dX6zneeecdHDt2DEeOHGlUVrbcEJFe27p1K6ysrBpd2ADA1KlTsX79euTm5mogGZHhmzp1Ko4dO4aNGzfi/PnzGDduHIYNG4br16+rdb9du3YhODgY48aNg7OzMwIDA7Fq1aoG34fFDRHphMzMTDRv3hyLFi2qOXbq1CmYmppi7969D7xu48aNGD16dK1jU6ZMwdixY7Fo0SK4uLjAzs4OCxYsQFVVFd566y3Y29vD3d0da9asqXWdn58fmjdvju3bt2v2xREZoJs3b2LDhg3YvHkz+vTpg9atW+PNN99E7969sXbtWrXuGR8fjxUrVqBt27bYs2cPZs6cidmzZ2PdunUNug+LGyLSCU5OTlizZg0++ugjREVFoaioCM8++yxeeeWVh46nOXLkCIKDg+sc379/P27fvo3Dhw9j6dKl+OijjzBq1Cg0a9YMp06dwsyZMzFz5kykpKTUuq5bt26NbhInMgZnz56FIAho164drKysah6HDh3CzZs3AQCJiYmQSCQPfbz66qs191SpVOjSpQsWLVqEwMBAvPTSS3jhhRewYsWKBmWTa/SVEhE1wogRI/DCCy9g0qRJ6Nq1K8zMzPDpp58+8Py8vDzk5eXBzc2tzvfs7e3xzTffQCqVon379vjss89QUlKCd999FwAwf/58fPrppzh27BiefvrpmutatGiBmJgYzb84IgOjUqkgk8kQHR0NmUxW63tWVlYAqv8/Xb58+aH3adasWc2fXV1d4ePjU+v7HTt2xNatWxuUjcUNEemUL774Ar6+vvj9998RFRUFMzOzB55bWloKAPc9p1OnTpBK/22cdnFxga+vb83XMpkMDg4OyMjIqHWdubk5SkpKGvsyiAxeYGAglEolMjIyHjjmzcTEBB06dKj3PXv16oWrV6/WOnbt2jV4eno2KBuLGyLSKfHx8bh9+zZUKhWSkpLQuXPnB57r4OAAiURy3wHAJiYmtb6WSCT3PaZSqWody8nJgZOTUyNeAZHhKCoqwo0bN2q+TkhIQGxsLOzt7dGuXTtMmjQJkydPxpIlSxAYGIisrCzs378ffn5+GDFiRIOf7/XXX0fPnj2xaNEijB8/HqdPn8bKlSuxcuXKBt2HY26ISGdUVFRg0qRJmDBhAhYuXIjp06fjzp07Dzzf1NQUPj4+iIuL01iGixcvIjAwUGP3I9JnUVFRCAwMrPk/ERYWhsDAQHzwwQcAgLVr12Ly5Ml444030L59e4wePRqnTp2Ch4eHWs/XtWtXbN++HRs2bICvry8++eQTfPXVV5g0aVKD7sOWGyLSGe+99x7y8/PxzTffwMrKCn/99RemT5+OP/7444HXDB06FEePHsXcuXMb/fwlJSWIjo6uNWOLyJj1798fD1sOz8TEBAsWLMCCBQs09pyjRo3CqFGjGnUPttwQkU44ePAgvvrqK/zyyy+wsbGBVCrFL7/8gqNHjz50psQLL7yAiIgI5OfnNzrDzp070bJlS42smUNE4uEKxUSk98aPH4/AwEDMnz+/Uffp1q0b5s6di4kTJ2ooGRGJgS03RKT3Pv/885qpp+rKyMjAU089hWeeeUZDqYhILGy5ISIiIoPClhsiIiIyKCxuiIiIyKCwuCEiIiKDwuKGiIiIDAqLGyIiIjIoLG6IiIjIoLC4ISIiIoPC4oaIiIgMCosbIiIiMij/D/F6JQfdZiNaAAAAAElFTkSuQmCC", - "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 4226357..0000000 --- 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": "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", - "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 41242b1..0000000 --- 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 5ad477a..0000000 --- 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 77b2469..0000000 --- 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='