{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Notebook: Creation of a 2D Modeling via Script - Short Version\n", "\n", "To create a 2D simulation, it is necessary to:\n", "\n", " - create a \"prev_sim2D\" instance by providing the full path and the generic name of the simulation as an argument\n", " - define a vectorial contour/polygon delimiting the working area\n", " - (optional) define a \"magnetic grid\" used to snap the vertices of the polygons --> allows alignment between different models, for example\n", " - define the spatial resolution of the mesh on which the data (topography, friction, unknowns...) will initially be provided\n", " - define the contours/polygons of the blocks and their respective spatial resolution\n", " - call the mesher (call to the Fortran code)\n", " - create the mandatory matrices and fill them with the desired values (via script(s) or GUI)\n", " - create potential boundaries for boundary conditions (.sux, .suy)\n", " - impose the necessary boundary conditions (note: no conditions == impermeable)\n", " - configure the problem\n", " - execute the computation\n", " - process the results\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Importing Modules" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from tempfile import TemporaryDirectory\n", "from pathlib import Path\n", "\n", "from datetime import datetime as dt\n", "from datetime import timezone as tz\n", "from datetime import timedelta as td\n", "from typing import Literal, Union\n", "\n", "from wolfhece.mesh2d.wolf2dprev import prev_sim2D\n", "from wolfhece.PyVertexvectors import zone, Zones, vector, wolfvertex\n", "from wolfhece.wolf_array import WolfArray, WolfArrayMB\n", "from wolfhece.wolfresults_2D import Wolfresults_2D, views_2D\n", "from wolfhece.mesh2d.cst_2D_boundary_conditions import BCType_2D, Direction, revert_bc_type" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Definition of the Working Directory" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "test\n" ] } ], "source": [ "outdir = Path(r'test')\n", "outdir.mkdir(exist_ok=True) # Création du dossier de sortie\n", "print(outdir.name)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Verification of the presence of the \"wolfcli\" code\n", "\n", "Returns the full path to the code" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Code found : C:\\Users\\pierre\\Documents\\Gitlab\\Python310new\\Lib\\site-packages\\wolfhece\\libs\\wolfcli.exe\n" ] } ], "source": [ "wolfcli = prev_sim2D.check_wolfcli() # méthode de classe, il n'est donc pas nécessaire d'instancier la classe pour l'appeler\n", "\n", "if wolfcli:\n", " print('Code found : ', wolfcli)\n", "else:\n", " print('Code not found !')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Creation of a 2D simulation object" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "WARNING:root:No infiltration file found\n" ] } ], "source": [ "# Passage en attribut du répertoire de travail auquel on a ajouté le nom générique de la simulation.\n", "# \"clear\" permet de supprimer les fichiers de la simulation précédente.\n", "newsim = prev_sim2D(fname=str(outdir / 'test'), clear=True)\n", "\n", "# Un message de type \"logging.info\" est émis car aucun fichier n'a été trouvé. Ceci est normal !\n", "# Si un fichier est trouvé, il est chargé." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Geometry of the Problem" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Definition of the external polygon -- using a \"vector\" class -- see [wolfhece.PyVertexvectors](https://wolf.hece.uliege.be/autoapi/wolfhece/PyVertexvectors/index.html)\n", "\n", "Square domain of size 1.0 m x 1.0 m" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Nombre de vertices : 5\n", "5 vertices car la polygone est fermé et le dernier point est aux mêmes coordonnées que le premier.\n" ] } ], "source": [ "# Define the extrenal contour\n", "extern = vector()\n", "extern.add_vertex(wolfvertex(0., 0.))\n", "extern.add_vertex(wolfvertex(1., 0.))\n", "extern.add_vertex(wolfvertex(1., 1.))\n", "extern.add_vertex(wolfvertex(0., 1.))\n", "extern.close_force()\n", "\n", "print('Nombre de vertices : ', extern.nbvertices)\n", "print('5 vertices car la polygone est fermé et le dernier point est aux mêmes coordonnées que le premier.')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Setup Steps" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# \"Very Fast\" - One block\n", "# -----------------------\n", "\n", "# # with tuple\n", "# newsim.setup_oneblock((0.,0.,1,1,1.,1.), block_spatial_stepsize = 0.1, friction_coefficient =0.04)\n", "\n", "# # with dictionary\n", "# newsim.setup_oneblock({'ox': 0., 'oy': 0., 'nbx':1, 'nby':1, 'dx': 1., 'dy': 1.}, block_spatial_stepsize = 0.1, friction_coefficient = 0.04)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Meshing done !\n" ] } ], "source": [ "# More verbose - One block\n", "# ------------------------\n", "\n", "# Magnetic grid - dx and dy are the grid steps [m], origx and origy are the coordinates of the first point of the grid.\n", "# The magnetic grid has nothing to do with the spatial resolution of the calculation. It is used to move the contour points of the blocks to place them on the magnetic grid.\n", "# This ensures that the edges of the blocks will be perfectly aligned on the fine grid.\n", "newsim.set_magnetic_grid(dx=1., dy=1., origx=0., origy=0.)\n", "\n", "# Transfer the polygon as the external simulation boundary.\n", "newsim.set_external_border_vector(extern)\n", "\n", "# By default, the coordinates of the polygon will be translated so that the point (xmin, ymin) is at (0, 0).\n", "newsim.translate_origin2zero = True\n", "\n", "# Choice of the fine mesh spatial step size [m].\n", "newsim.set_mesh_fine_size(dx=0.1, dy=0.1)\n", "\n", "# Adding a block with its specific spatial step size [m].\n", "newsim.add_block(extern, dx=0.2, dy=0.2)\n", "\n", "# Meshing the problem\n", "if newsim.mesh():\n", " print('Meshing done!')\n", "else:\n", " print('Meshing failed!')\n", "\n", "# If \"with_turbulence\" is True, the \".kbin\" and \".epsbin\" files will also be created and will contain the turbulent kinetic energy.\n", "newsim.create_fine_arrays(default_frot=0.04, with_tubulence=False)\n", "\n", "# Search for potential boundary conditions based on the \".napbin\" matrix and write the \".sux\" and \".suy\" files.\n", "newsim.create_sux_suy()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "At this stage, files should be present in your modeling directory.\n", "\n", "We might wonder about the size of the \"fine\" matrices, i.e., the matrices with a resolution of 0.1m x 0.1m.\n", "\n", "Given that the desired computational domain is 1.0m x 1.0m, the size is:\n", "\n", " - nbx = int(length_x / dx_fin) + 2 + 2 * 3 * (dx_block / dx_fin) = 10 + 2 + 6 = 18\n", " - nby = int(length_y / dy_fin) + 2 + 2 * 3 * (dy_block / dy_fin) = 10 + 2 + 6 = 18\n", "\n", "Around the computational domain, there is 1 fringe cell all around (dx_fin, dy_fin) + 3 times the largest block cell size.\n", "\n", "In this example, since there is only one block but its cell size is twice that of the fine matrix, there are 8 additional cells all around.\n", "\n", "Thus:\n", "\n", " - The first computational cell is at position (5,5) with a 1-based convention, Fortran-style, or (4,4) with a 0-based convention, Python-style.\n", " - The last computational cell is at position (14,14) with a 1-based convention, Fortran-style, or (13,13) with a 0-based convention, Python-style.\n", " - The first X-oriented boundary is at index (5,5) with a 1-based convention, Fortran-style, or (4,4) with a 0-based convention, Python-style.\n", " - The first Y-oriented boundary is at index (5,5) with a 1-based convention, Fortran-style, or (4,4) with a 0-based convention, Python-style.\n", " - The last X-oriented boundary is at index (15,15) with a 1-based convention, Fortran-style, or (14,14) with a 0-based convention, Python-style.\n", " - The last Y-oriented boundary is at index (15,15) with a 1-based convention, Fortran-style, or (14,14) with a 0-based convention, Python-style." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Shape of the mesh : 18 18\n" ] } ], "source": [ "print('Shape of the mesh : ', newsim.nbx, newsim.nby) # must be 18,18" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "assert newsim.napbin.array.data[4,4] == 1, 'napbin[4,4] should be 1'\n", "assert newsim.napbin.array.data[3,3] == 0, 'napbin[3,3] should be 0'\n", "assert newsim.napbin.array.data[newsim.nbx-4,newsim.nby-4] == 0, 'napbin[nbx-4,nby-4] should be 0'\n", "assert newsim.napbin.array.data[newsim.nbx-5,newsim.nby-5] == 1, 'napbin[nbx-5,nby-5] should be 1'\n", "\n", "assert newsim.napbin.array[3,3] is np.ma.masked, 'napbin[3,3] should be masked'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Parameters" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "newsim.parameters.set_params_time_iterations(nb_timesteps= 1000, optimize_timestep=True, writing_frequency=1, writing_mode='Iterations', initial_cond_reading_mode='Binary', writing_type='Binary compressed')\n", "newsim.parameters.set_params_temporal_scheme(RungeKutta='RK21', CourantNumber=0.35)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Checks" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n" ] } ], "source": [ "# Plusieurs niveaux de vebrosité sont disponibles:\n", "# - 0 : Erreurs uniquement\n", "# - 1 : Erreurs et Warnings\n", "# - 2 : Erreurs, Warnings et Informations\n", "# - 3 : 2 + en-têtes de sections\n", "print(newsim.check_all(verbosity= 0))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Boundary conditions" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "newsim.reset_all_boundary_conditions()\n", "\n", "# ou via des boucles, tout est possible !\n", "for j in range(5,15): # -> bouclage de 5 à 14 inclus\n", " newsim.add_boundary_condition(i = 15, j = j, bc_type = BCType_2D.H, bc_value = 1.0, border=Direction.X)\n", "\n", "for j in range(5,15): # -> bouclage de 5 à 14 inclus\n", " newsim.add_boundary_condition(i = 5, j = j, bc_type = BCType_2D.QX, bc_value = 1.0, border=Direction.X)\n", " newsim.add_boundary_condition(i = 5, j = j, bc_type = BCType_2D.QY, bc_value = 0.0, border=Direction.X)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Listing of BCs along each axis:\n", "\n", "- Number of BCs\n", "- List the indices\n", "- Obtain a list of \"boundary_condition_2D\" objects - https://wolf.hece.uliege.be/autoapi/wolfgpu/simple_simulation/index.html#wolfgpu.simple_simulation.boundary_condition_2D\n", "- Check existence or not\n", "- Change the value and/or type\n", "- Remove a previously imposed condition" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Nb CL selon X : 30\n", "Nb CL selon Y : 0\n" ] } ], "source": [ "print('Nb CL selon X : ', newsim.nb_weak_bc_x)\n", "print('Nb CL selon Y : ', newsim.nb_weak_bc_y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Saving to Disk\n", "\n", "Parameters and boundary conditions can be saved to disk in the \".par\" file using the \"save\" method.\n", "\n", "Writing to disk can therefore only be validly performed **after** defining both the necessary parameters and the problem's boundary conditions." ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "WARNING:root:No infiltration data to write\n" ] } ], "source": [ "newsim.save()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Initial Conditions / Data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Topography" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "# mise à zéro de la topographie\n", "newsim.top.array[:,:] = 0.0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Initial water depth" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "# Comme la topo est plate, on peut facilement éditer la matrice de hauteur d'eau\n", "newsim.hbin.array[:,:] = 1.0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Unit discharges along X and Y" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [], "source": [ "newsim.qxbin.array[:,:] = 0.\n", "newsim.qybin.array[:,:] = 0." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Friction coefficient\n", "\n", "We keep the default value of 0.04" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Saving\n", "\n", "The matrices are referenced in the object.\n", "\n", "We force the update of the files." ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [], "source": [ "newsim.save_arrays_modifications()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Calculation\n", "\n", "Once all the files are written to disk, it is time to start the calculation.\n", "\n", "To do this, either use \"run_wolfcli\" or execute the command \"wolfcli run_wolf2d_prev genfile=pathtosim\" in a command window, provided that wolfcli is accessible there (e.g., via the PATH)." ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [], "source": [ "newsim.run_wolfcli()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Be Patient!!\n", "\n", "The calculation is in progress... at least if a command window appears and calculation information is displayed.\n", "\n", "The total calculation time is impossible to predict.\n", "\n", "**WARNING** If a file access error is mentioned, it is likely related to another window still open or an unclosed file link. Start by closing all previous command windows and restart the script." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Results Analysis" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "# Instanciation d'un objet résultat\n", "res = Wolfresults_2D(newsim.filename)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1001" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Récupération du nombre de résultats\n", "res.get_nbresults()\n", "\n", "# 1001 car 1000 itérations + 1 état initial" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "# Récupération des résultats d'un pas spécifique (0-based) -- \"-1\" pour le dernier pas\n", "res.read_oneresult(-1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simple Matplotlib Display of the Last Step" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "res.read_oneresult(-1)\n", "res.set_current(views_2D.WATERDEPTH) # Calcul de la hauteur d'eau\n" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Minimum 1.0003558\n", "Maximum 1.0017345\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "print('Minimum ', res[0].array.min())\n", "print('Maximum ', res[0].array.max())\n", "\n", "fig,ax = res[0].plot_matplotlib()\n", "fig.suptitle('Hauteur d\\'eau')\n", "fig.colorbar(ax.images[0], ax=ax)\n", "fig.tight_layout()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**It might also be time to open the WOLF interface for more interactivity...**" ] } ], "metadata": { "kernelspec": { "display_name": "Python310new", "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.10.11" } }, "nbformat": 4, "nbformat_minor": 2 }