{ "cells": [ { "cell_type": "markdown", "id": "f92cef7e", "metadata": {}, "source": [ "# Accès aux résultats GPU et manipulation des données\n", "\n", "Ce script permet d'accéder aux résultats des simulations 2D effectuées sur GPU et de manipuler les données pour une analyse ultérieure. Il est conçu pour être utilisé avec les fichiers de résultats générés par les simulations." ] }, { "cell_type": "markdown", "id": "3eab0fcd", "metadata": {}, "source": [ "## Import des modules nécessaires" ] }, { "cell_type": "code", "execution_count": 1, "id": "16790f90", "metadata": {}, "outputs": [], "source": [ "import _add_path # for debugging purposes only - must be removed in production\n", "\n", "from wolfhece import is_enough\n", "try:\n", " if not is_enough('2.2.33'):\n", " raise ImportError(\"HECE version 2.2.33 or higher is required.\")\n", "except ImportError as e:\n", " print(f\"Error: {e}\")\n", " raise\n", "\n", "from wolfhece.Results2DGPU import wolfres2DGPU, OneWolfResult, views_2D, WolfArray\n", "from wolfgpu.results_store import ResultsStore, ResultType\n", "\n", "from wolfhece.pydownloader import toys_gpu_dataset, GITLAB_EXAMPLE_GPU\n", "\n", "import numpy as np" ] }, { "cell_type": "markdown", "id": "9d705009", "metadata": {}, "source": [ "## Accès direct depuis le ResultStore\n", "\n", "Le ResultStore est la classe qui gère les opérations de lecture et d'écriture des résultats des simulations GPU.\n", "\n", "Même si d'autres routines sont disponibles, nous demandons à l'utilisateur de ne pas les utiliser directement, mais de passer par le ResultStore.\n", "Il offre en effet une interface fixe pour accéder aux résultats, ce qui permet de garantir la compatibilité avec les futures versions du code, notamment le passage de fichiers \"npz\" au format \"npy\".\n", "\n", "En interne, le code GPU utilise un tuilage pour convertir les données de modélisation en un format rectangulaire dense, mieux adapté au stockage et aux calculs sur GPU.\n", "En outre, pour le \"npz\", seules les valeurs non nulles sont stockées (via le format [CSR - Compressed Sparse Row](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csr_matrix.html)), ce qui permet de réduire la taille des fichiers.\n", "\n", "L'utilisateur final voudra habituellement quant à lui disposer des résultats sous forme géoréférencée, ce qui nécessite une conversion des données.\n", "\n", "Cette conversion de données n'est pas \"gratuite\" en termes de temps de calcul. Si on souhaite accéder rapidement aux résultats, le format \"npy\" est plus adapté, car il stocke les matrices tuilées sans cette étape de conversion CSR." ] }, { "cell_type": "code", "execution_count": 2, "id": "b604dc7a", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "ERROR:root:HTTP error occurred while downloading https://gitlab.uliege.be/HECE/wolfgpu_examples/-/raw/main/channel_w_archbridge_fully_man004/bridge_deck.npy: 404 Client Error: Not Found for url: https://gitlab.uliege.be/HECE/wolfgpu_examples/-/raw/main/channel_w_archbridge_fully_man004/bridge_deck.npy\n" ] } ], "source": [ "rs = toys_gpu_dataset('channel_w_archbridge_fully_man004') # Load a GPU dataset from the web and obtain a ResultsStore object\n", "\n", "assert isinstance(rs, ResultsStore), \"The object should be an instance of ResultsStore\"\n", "\n", "# An error message will be raised as the bridge_deck is not available in the dataset -- It is normal !" ] }, { "cell_type": "markdown", "id": "f5999cfe", "metadata": {}, "source": [ "### Obtenir le nombre de résultats disponibles" ] }, { "cell_type": "code", "execution_count": 3, "id": "1b7cbac1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rs.nb_results # Get the number of results available in the dataset" ] }, { "cell_type": "markdown", "id": "f327800c", "metadata": {}, "source": [ "### Récupérer les valeurs associées aux sauvegardes\n", "\n", "Il est possible de récupérer les séries temporelles des valeurs associées aux résultats.\n", "Les valeurs possibles sont dans la classe `ResultType` et sont les suivantes :\n", "\n", "- T : The simulation time (the time inside the simulation)\n", "- LAST_DELTA_T : The last Δt computed at the moment the record is taken.\n", "- NB_ACTIVE_TILES : The number of active tiles in the simulation. An active tile is a tile where there is some water.\n", "- STEP_NUM : The number of the simulation step.\n", "- CLOCK_T : The time spent into the simulation (wall clock time)\n", "- NB_MOSTLY_DRY_MESHES : Number of mostly dry mesh. A mostly dry mesh is a mesh where water depth is not zero but very small (< 1e-5 m).\n", "- NB_WET_MESHES : Number of wet meshes. A wet mesh is a mesh where water depth is above zero." ] }, { "cell_type": "code", "execution_count": 5, "id": "9a8ba65b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0.0, 40.60536419227719, 81.21073305234313, 121.81609793752432, 162.4214591383934, 203.02682216465473]\n", "[8466.0, 8466.0, 8466.0, 8466.0, 8466.0, 8466.0]\n" ] } ], "source": [ "print(rs.get_named_series(ResultType.T))\n", "print(rs.get_named_series(ResultType.NB_WET_MESHES))" ] }, { "cell_type": "markdown", "id": "2cffc0e4", "metadata": {}, "source": [ "### Récupérer les résultats\n", "\n", "- soit le dernier pas disponible\n", "- soit un pas spécifique" ] }, { "cell_type": "code", "execution_count": 7, "id": "8030fa0f", "metadata": {}, "outputs": [], "source": [ "res = rs.get_last_result()\n", "\n", "# returns [t, dt, n_iter_dry_up_euler, n_iter_dry_up_rk, h, qx, qy]" ] }, { "cell_type": "code", "execution_count": null, "id": "c1b1fb2c", "metadata": {}, "outputs": [], "source": [ "h = rs.get_last_named_result(ResultType.H) # Get the last result for the water depth\n", "qx, qy = rs.get_last_named_result([ResultType.QX, ResultType.QY]) # Get the last result for the x-component and y-component of the unit discharge - we can mix ResultType values in a list" ] }, { "cell_type": "markdown", "id": "fe13c134", "metadata": {}, "source": [ "Les résultats sont retournés sous la forme de matrices numpy NON géoréférencées (Numpy ne permet pas ce type d'opération).\n", "\n", "**ATTENTION que les formes sont transposées par rapport à ce que Wolf a l'habitude de faire.**\n", "\n", "En réalité, la simulation a été définie avec 500 mailles selon X et 21 mailles selon Y.\n", "\n", "Dans ces résultats \"bruts\", les mailles sont stockées en lignes, ce qui signifie que la première dimension correspond à Y et la seconde à X." ] }, { "cell_type": "code", "execution_count": null, "id": "8420f451", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " (21, 500)\n" ] } ], "source": [ "print(type(h), h.shape)\n", "print(type(qx), qx.shape)\n", "print(type(qy), qy.shape)" ] }, { "cell_type": "markdown", "id": "7e9f21f3", "metadata": {}, "source": [ "### Graphiques\n", "\n", "Il est tout à fait possible de visualiser les résultats obtenus avec des bibliothèques comme Matplotlib ou Seaborn." ] }, { "cell_type": "code", "execution_count": null, "id": "21a233f5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "plt.imshow(qx, cmap='viridis', origin='lower') # Le stockage sous la forme (21,500) permet d'utiliser imshow directement, tandis que Wolf devrait les transposer (ce qui est la plupart du temps transparent pour l'utilisateur, et sans surcoût)." ] }, { "cell_type": "markdown", "id": "d936a00f", "metadata": {}, "source": [ "### Récupérer un résultat spécifique" ] }, { "cell_type": "code", "execution_count": 14, "id": "7b659c47", "metadata": {}, "outputs": [], "source": [ "h = rs.get_named_result(ResultType.H, 1) # Get the first result for the water depth - index is 1-based (like Fortran code)" ] }, { "cell_type": "markdown", "id": "fbeb05cc", "metadata": {}, "source": [ "## Travailler avec l'objet \"wolfres2DGPU\"\n", "\n", "\"wolfres2DGPU\" est un objet qui permet de manipuler les résultats des simulations 2D sur GPU de manière plus complète. Il est basé sur l'objet \"Wolfresults_2D\" qui permet entre autre de gérer les résultats CPU-Fortran.\n", "\n", "En interne, \"wolfres2DGPU\" utilise le \"ResultStore\" pour accéder aux résultats, mais il offre des fonctionnalités supplémentaires pour manipuler les données." ] }, { "cell_type": "code", "execution_count": 2, "id": "d542ed0d", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "ERROR:root:HTTP error occurred while downloading https://gitlab.uliege.be/HECE/wolfgpu_examples/-/raw/main/channel_w_archbridge_fully_man004/bridge_deck.npy: 404 Client Error: Not Found for url: https://gitlab.uliege.be/HECE/wolfgpu_examples/-/raw/main/channel_w_archbridge_fully_man004/bridge_deck.npy\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "https://gitlab.uliege.be/HECE/wolfgpu_examples/-/raw/main/channel_w_archbridge_fully_man004\n" ] } ], "source": [ "url = GITLAB_EXAMPLE_GPU + '/' + 'channel_w_archbridge_fully_man004'\n", "print(url)\n", "res = wolfres2DGPU(url) # Initialisation sur base d'un url - pas possible d'utiliser toys_gpu_dataset ici car il renvoit directement un ResultsStore" ] }, { "cell_type": "markdown", "id": "8d25d864", "metadata": {}, "source": [ "### Récupérer les temps et les pas de sauvegarde" ] }, { "cell_type": "code", "execution_count": 3, "id": "04da2dee", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "([0.0, 40.60536419227719, 81.21073305234313, 121.81609793752432, 162.4214591383934, 203.02682216465473], [0, 1000, 2000, 3000, 4000, 5000])\n" ] } ], "source": [ "print(res.get_times_steps())" ] }, { "cell_type": "markdown", "id": "3358e597", "metadata": {}, "source": [ "### Récupérer un pas spécifique" ] }, { "cell_type": "code", "execution_count": 4, "id": "aeec7ab3", "metadata": {}, "outputs": [], "source": [ "res.read_oneresult(0) # Here we are 0-based, so we read the first result - more Pythonic\n", "res.read_oneresult(-1) # Here we are 0-based, so we read the last result" ] }, { "cell_type": "markdown", "id": "d8a839af", "metadata": {}, "source": [ "### Accès aux résultats stockés dans l'objet\n", "\n", "Pour diverses raisons difficiles à résumer ici, les différentes matrices de résultats sont stockées dans un dictionnaire Python \"myblocks\". En GPU, il n'y a qu'une seule entrée au dictionnaire, mais en CPU, il y peut y en avoir plusieurs (aspects multiblocs obligent).\n", "\n", "L'objet interne est \"OneWolfResult\". Il contient les matrices de base (hauteur d'eau, débit selon X et débit selon Y) mais également des combinaisons (voir \"views_2D\").\n", "\n", "Le type de résultat fourni par défaut est la hauteur d'eau." ] }, { "cell_type": "code", "execution_count": 5, "id": "a441045c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(500, 21)" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "res.myblocks['block1'].waterdepth # Access the water depth for the first block (GPU only has one block, but CPU can have several blocks)\n", "res.myblocks['block1'].waterdepth.shape # Shape of the water depth matrix for the first block" ] }, { "cell_type": "code", "execution_count": 6, "id": "a70c11ea", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# res.myblocks['block1'].qx # Access the x-component of the unit discharge for the first block\n", "# res.myblocks['block1'].qy # Access the y-component of the unit discharge for the first block\n", "res.myblocks['block1'].current # Access the current view for the first block" ] }, { "cell_type": "code", "execution_count": 7, "id": "9318b500", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "res.myblocks['block1'].current is res.myblocks['block1'].waterdepth # By default, the current view is the water depth, but it can be changed to other views (qx, qy, etc.)" ] }, { "cell_type": "markdown", "id": "49d09350", "metadata": {}, "source": [ "Il est toutefois possible d'accéder au résultat courant sous le forme d'un WolfArray." ] }, { "cell_type": "code", "execution_count": 8, "id": "94dc00ce", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n", "True\n" ] } ], "source": [ "curres_by_index = res[0] # Access the first block result (0-based index)\n", "curres_by_name = res['block1'] # Access the first block result (1-based index)\n", "type(curres_by_index), type(curres_by_name) # Both should be of type OneWolfResult\n", "\n", "print(curres_by_name is curres_by_index) # Both should be the same object\n", "print(np.all(curres_by_index.array == curres_by_name.array)) # But the data should be the same\n" ] }, { "cell_type": "markdown", "id": "3b59878b", "metadata": {}, "source": [ "### Changement de vue\n", "\n", "A choisir dans \"views_2D\", les vues disponibles sont :\n", "- WATERDEPTH = _('Water depth [m]')\n", "- WATERLEVEL = _('Water level [m]')\n", "- TOPOGRAPHY = _('Bottom level [m]')\n", "- QX = _('Discharge X [m2s-1]')\n", "- QY = _('Discharge Y [m2s-1]')\n", "- QNORM = _('Discharge norm [m2s-1]')\n", "- UX =_('Velocity X [ms-1]')\n", "- UY = _('Velocity Y [ms-1]')\n", "- UNORM = _('Velocity norm [ms-1]')\n", "- HEAD = _('Head [m]')\n", "- FROUDE = _('Froude [-]')\n", "- U_SHEAR = _('Shear velocity [ms-1]')\n", "- SHIELDS_NUMBER = _('Shields number - Manning-Strickler')\n", "- CRITICAL_DIAMETER_SHIELDS = _('Critical grain diameter - Shields')\n", "- CRITICAL_DIAMETER_IZBACH = _('Critical grain diameter - Izbach')\n", "- CRITICAL_DIAMETER_SUSPENSION_50 = _('Critical grain diameter - Suspension 50%')\n", "- CRITICAL_DIAMETER_SUSPENSION_100 = _('Critical grain diameter - Suspension 100%')\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "38399f2c", "metadata": {}, "outputs": [], "source": [ "res.set_currentview(views_2D.FROUDE) # Change the current view to the x-component of the unit discharge" ] }, { "cell_type": "code", "execution_count": 10, "id": "c3e7677d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "res[0].plot_matplotlib()" ] }, { "cell_type": "markdown", "id": "baf6d2f6", "metadata": {}, "source": [ "### Récupérer tous les résultats dans une liste Python\n", "\n", "Pour des simulations pas trop lourdes, on peut envisager de récupérer tous les résultats dans une liste Python. Cela permet de manipuler les données plus facilement, mais attention à la mémoire disponible." ] }, { "cell_type": "code", "execution_count": 27, "id": "be37bb46", "metadata": {}, "outputs": [], "source": [ "res.set_currentview(views_2D.WATERDEPTH) # Reset the current view to the water depth\n", "all = []\n", "for i in range(res.get_nbresults()):\n", " res.read_oneresult(i)\n", " all.append(res.as_WolfArray()) # here using the as_WolfArray method to create a new WolfArray from the current result" ] }, { "cell_type": "code", "execution_count": 28, "id": "a75cfde0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of results in the list: 6\n", "max : 8.042151 min : 7.981053 median : 8.007215 mean : 8.017717930545713\n", "max : 8.042157 min : 7.981057 median : 8.007235 mean : 8.017718853354594\n", "max : 8.04216 min : 7.9810605 median : 8.007196 mean : 8.017717930545713\n", "max : 8.042163 min : 7.9810634 median : 8.0072155 mean : 8.017717930545713\n", "max : 8.042169 min : 7.9810696 median : 8.0071945 mean : 8.017717930545713\n", "max : 8.042171 min : 7.981072 median : 8.007233 mean : 8.017717930545713\n" ] } ], "source": [ "print(f\"Number of results in the list: {len(all)}\")\n", "for i in range(len(all)):\n", " print('max : ', all[i].array.max(), 'min :', all[i].array.min(), 'median :', np.ma.median(all[i].array), 'mean :', np.ma.mean(all[i].array))" ] }, { "cell_type": "markdown", "id": "e3277d63", "metadata": {}, "source": [ "### Création de cartes de danger\n", "\n", "Les cartes accessibles sont:\n", "- Danger map - Water depth\n", "- Danger map - Velocity norm\n", "- Danger map - Discharge norm\n", "- Danger map - Water surface elevation\n", "- Danger map - Head\n", "- Danger map - Time of arrival\n", "- Danger map - Time of maximum" ] }, { "cell_type": "code", "execution_count": 29, "id": "604c5348", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 6/6 [00:00<00:00, 103.73it/s]\n" ] } ], "source": [ "dm_h, dm_unorm, dm_qnorm, dm_z, dm_head, dm_toa, dm_tm = res.danger_map() # tuple of WolfArray - H, U_norm, Q_norm, Z, Head, Time_of_arrival, Time_of_maximum" ] }, { "cell_type": "code", "execution_count": 30, "id": "f8a49d16", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "dm_h.plot_matplotlib()" ] }, { "cell_type": "markdown", "id": "3e44c93a", "metadata": {}, "source": [ "## Et ensuite ?\n", "\n", "La manipulation de résultats et la conversion en WolfArray géoréférencée permet d'effectuer des analyses plus poussées et de visualiser les données de manière plus intuitive. \n", "\n", "La combinaison avec des données vectorielles (polygones d'analyse, bâtiments, etc.) permet de croiser les résultats de la simulation avec des données géographiques pour une analyse plus complète." ] } ], "metadata": { "kernelspec": { "display_name": "python3.11", "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.11.9" } }, "nbformat": 4, "nbformat_minor": 5 }