From 67f020a813ac3e0531ff171d575aebf9fc02375c Mon Sep 17 00:00:00 2001 From: RemDelaporteMathurin Date: Tue, 1 Oct 2024 08:20:30 +0200 Subject: [PATCH] Fixed PRF calculation and refactoring --- challenges/solutions/solution_A.ipynb | 241 +++++++++++++++++--------- 1 file changed, 158 insertions(+), 83 deletions(-) diff --git a/challenges/solutions/solution_A.ipynb b/challenges/solutions/solution_A.ipynb index c02b739..b943ecd 100644 --- a/challenges/solutions/solution_A.ipynb +++ b/challenges/solutions/solution_A.ipynb @@ -8,44 +8,22 @@ "\n", "Here you will find the solution for the challenge A.\n", "\n", - "Two simulations are needed, one with the barrier and one without.\n", - "\n", - "The flux values from each case can be used to evaluate the PRF = 1557" + "Two simulations are needed, one with the barrier and one without." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Defining initial values\n", - "Defining variational problem\n", - "Defining source terms\n", - "Defining boundary conditions\n", - "Solving steady state problem...\n", - "Solved problem in 1.10 s\n", - "Defining initial values\n", - "Defining variational problem\n", - "Defining source terms\n", - "Defining boundary conditions\n", - "Solving steady state problem...\n", - "Solved problem in 1.20 s\n", - "Surface flux with barrier = 2.12e+14 H/m2/s\n", - "Surface flux without barrier = 3.29e+17 H/m2/s\n", - "PRF = 1557\n" - ] - } - ], + "outputs": [], "source": [ "import festim as F\n", "import h_transport_materials as htm\n", "import numpy as np\n", "\n", "upstream_pressure = 1e6 # Pa (=10 bar)\n", + "barrier_thick = 2.5e-6\n", + "substrate_thick = 0.02\n", "\n", "# eurofer properties\n", "diffusivity_eurofer = htm.diffusivities.filter(material=\"eurofer_97\").filter(\n", @@ -70,26 +48,51 @@ " .filter(isotope=\"h\")\n", " .filter(author=\"serra\")\n", ")\n", - "S_al2o3 = solubility_al2o3[0]\n", + "S_al2o3 = solubility_al2o3[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model with barrier" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Defining initial values\n", + "Defining variational problem\n", + "Defining source terms\n", + "Defining boundary conditions\n", + "Time stepping...\n", + "100.0 % 1.0e+05 s Elapsed time so far: 1.1 s\n" + ] + } + ], + "source": [ + "model_with_barrier = F.Simulation(log_level=40)\n", "\n", - "L_eurofer = 0.02\n", - "L_barrier = 2e-6\n", + "# define mesh\n", + "vertices_left = np.linspace(0, substrate_thick, num=500)\n", "\n", - "results_folder = \"challenge_A/\"\n", + "vertices_right = np.linspace(substrate_thick, substrate_thick + barrier_thick, num=500)\n", "\n", - "model_with_barrier = F.Simulation(log_level=40)\n", "\n", - "# define mesh\n", - "size = L_eurofer + L_barrier\n", - "cells_required = int(size / 1e-07)\n", - "vertices = np.linspace(0, size, num=cells_required)\n", + "vertices = np.concatenate([vertices_left, vertices_right])\n", "\n", - "model_with_barrier.mesh = F.MeshFromVertices(vertices=vertices)\n", + "model_with_barrier.mesh = F.MeshFromVertices(vertices)\n", "\n", "# define materials\n", "eurofer = F.Material(\n", " id=2,\n", - " borders=[0, L_eurofer],\n", + " borders=[0, substrate_thick],\n", " D_0=D_eurofer.pre_exp.magnitude,\n", " E_D=D_eurofer.act_energy.magnitude,\n", " S_0=S_eurofer.pre_exp.magnitude,\n", @@ -97,16 +100,16 @@ ")\n", "al2o3 = F.Material(\n", " id=1,\n", - " borders=[L_eurofer, size],\n", + " borders=[substrate_thick, substrate_thick + barrier_thick],\n", " D_0=D_al2o3.pre_exp.magnitude,\n", " E_D=D_al2o3.act_energy.magnitude,\n", " S_0=S_al2o3.pre_exp.magnitude,\n", " E_S=S_al2o3.act_energy.magnitude,\n", ")\n", - "model_with_barrier.materials = F.Materials([eurofer, al2o3])\n", + "model_with_barrier.materials = [eurofer, al2o3]\n", "\n", "# define temperature\n", - "model_with_barrier.T = F.Temperature(value=600)\n", + "model_with_barrier.T = 600\n", "\n", "# define boundary conditions\n", "model_with_barrier.boundary_conditions = [\n", @@ -118,44 +121,71 @@ "\n", "# define settings\n", "model_with_barrier.settings = F.Settings(\n", - " absolute_tolerance=1e-10,\n", + " absolute_tolerance=1e10,\n", " relative_tolerance=1e-10,\n", - " maximum_iterations=30,\n", - " transient=False,\n", + " transient=True,\n", " chemical_pot=True,\n", + " final_time=1e5,\n", ")\n", "\n", "# define exports\n", - "my_derived_quantities = F.DerivedQuantities(\n", - " [F.SurfaceFlux(\"solute\", surface=2)],\n", - " filename=results_folder + \"with_barrier.csv\",\n", - " show_units=True,\n", - ")\n", - "model_with_barrier.exports = F.Exports([my_derived_quantities])\n", + "# define exports\n", + "permeation_flux_with_barrier = F.SurfaceFlux(\"solute\", surface=2)\n", + "model_with_barrier.exports = [\n", + " F.DerivedQuantities([permeation_flux_with_barrier], show_units=True)\n", + "]\n", + "\n", + "model_with_barrier.dt = F.Stepsize(initial_value=0.5, stepsize_change_ratio=1.1)\n", + "\n", "\n", "# run simulation\n", "model_with_barrier.initialise()\n", - "model_with_barrier.run()\n", - "\n", + "model_with_barrier.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model without barrier" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Defining initial values\n", + "Defining variational problem\n", + "Defining source terms\n", + "Defining boundary conditions\n", + "Time stepping...\n", + "100.0 % 1.0e+05 s Elapsed time so far: 0.5 s\n" + ] + } + ], + "source": [ "model_without_barrier = F.Simulation(log_level=40)\n", "\n", "# define mesh\n", - "size = L_eurofer\n", - "cells_required = int(size / 1e-07)\n", - "vertices = np.linspace(0, size, num=cells_required)\n", + "vertices = np.linspace(0, substrate_thick, num=500)\n", "\n", - "model_without_barrier.mesh = F.MeshFromVertices(vertices=vertices)\n", + "model_without_barrier.mesh = F.MeshFromVertices(vertices)\n", "\n", "# define materials\n", "eurofer = F.Material(\n", " id=2,\n", - " borders=[0, L_eurofer],\n", + " borders=[0, substrate_thick],\n", " D_0=D_eurofer.pre_exp.magnitude,\n", " E_D=D_eurofer.act_energy.magnitude,\n", " S_0=S_eurofer.pre_exp.magnitude,\n", " E_S=S_eurofer.act_energy.magnitude,\n", ")\n", - "model_without_barrier.materials = F.Materials([eurofer])\n", + "model_without_barrier.materials = eurofer\n", "\n", "# define temperature\n", "model_without_barrier.T = F.Temperature(value=600)\n", @@ -170,44 +200,89 @@ "\n", "# define settings\n", "model_without_barrier.settings = F.Settings(\n", - " absolute_tolerance=1e-10,\n", + " absolute_tolerance=1e10,\n", " relative_tolerance=1e-10,\n", - " maximum_iterations=30,\n", - " transient=False,\n", - " chemical_pot=True,\n", + " transient=True,\n", + " chemical_pot=False,\n", + " final_time=1e5,\n", ")\n", "\n", + "model_without_barrier.dt = F.Stepsize(initial_value=0.5, stepsize_change_ratio=1.1)\n", + "\n", "# define exports\n", - "my_derived_quantities = F.DerivedQuantities(\n", - " [F.SurfaceFlux(\"solute\", surface=2)],\n", - " filename=results_folder + \"without_barrier.csv\",\n", - " show_units=True,\n", - ")\n", - "model_without_barrier.exports = F.Exports([my_derived_quantities])\n", + "permeation_flux_without_barrier = F.SurfaceFlux(\"solute\", surface=2)\n", + "model_without_barrier.exports = [\n", + " F.DerivedQuantities([permeation_flux_without_barrier], show_units=True)\n", + "]\n", "\n", "# run simulation\n", "model_without_barrier.initialise()\n", - "model_without_barrier.run()\n", + "model_without_barrier.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Results" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "t_without_barrier = permeation_flux_without_barrier.t\n", + "t_with_barrier = permeation_flux_with_barrier.t\n", "\n", + "permeation_flux_with_barrier_vals = -np.array(permeation_flux_with_barrier.data)\n", + "permeation_flux_without_barrier_vals = -np.array(permeation_flux_without_barrier.data)\n", "\n", - "data_with_barrier = np.genfromtxt(\n", - " results_folder + \"/with_barrier.csv\", delimiter=\",\", names=True\n", - ")\n", - "data_without_barrier = np.genfromtxt(\n", - " results_folder + \"/without_barrier.csv\", delimiter=\",\", names=True\n", - ")\n", + "import matplotlib.pyplot as plt\n", "\n", - "surface_flux_with_barrier = data_with_barrier[\"solute_flux_surface_2_H_m2_s1\"] * -1\n", - "surface_flux_without_barrier = (\n", - " data_without_barrier[\"solute_flux_surface_2_H_m2_s1\"] * -1\n", - ")\n", + "plt.figure()\n", "\n", - "PRF = surface_flux_without_barrier / surface_flux_with_barrier\n", + "plt.plot(t_without_barrier, permeation_flux_without_barrier_vals, label=\"without barrier\")\n", + "plt.plot(t_with_barrier, permeation_flux_with_barrier_vals, label=\"with barrier\")\n", "\n", - "print(f\"Surface flux with barrier = {surface_flux_with_barrier:.2e} H/m2/s\")\n", - "print(f\"Surface flux without barrier = {surface_flux_without_barrier:.2e} H/m2/s\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.ylim(bottom=1e5)\n", + "plt.legend()\n", + "plt.xlabel(\"Time (s)\")\n", + "plt.ylabel(\"Permeation flux (H/m2/s)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PRF: 1.96e+03\n" + ] + } + ], + "source": [ + "PRF = permeation_flux_without_barrier_vals[-1] / permeation_flux_with_barrier_vals[-1]\n", "\n", - "print(f\"PRF = {PRF:.0f}\")" + "print(f\"PRF: {PRF:.2e}\")" ] } ], @@ -227,7 +302,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.10" } }, "nbformat": 4,