Simulation des Écoulements d'Eau de Pluie

Introduction

En 2024, nous avons décidé de nous lancer dans un projet qui répond aux défis actuels de notre société. Les changements climatiques et leurs impacts croissants sur les zones urbaines sont devenus des préoccupations majeures. Les inondations fréquentes et les défis liés à la gestion des eaux pluviales ont mis en lumière la nécessité de solutions innovantes. C'est dans ce contexte que l'idée de travailler sur la simulation des écoulements d'eau de pluie est née, avec pour objectif de contribuer à une meilleure prévention des risques d'inondation. Les inondations urbaines, en particulier, représentent un risque croissant pour les infrastructures et les populations. La simulation hydrologique est un outil essentiel pour comprendre et prévoir ces phénomènes, permettant ainsi une meilleure gestion des risques. En simulant différents scénarios, les chercheurs et les décideurs peuvent prendre des décisions éclairées pour protéger les communautés et les infrastructures.

Développement des Algorithmes de Simulation

La première étape a consisté à imaginer un algorithme simulant les écoulements d'eau de pluie. Pour cela, après une revue de la littérature, des premières versions ont été implémentées en utilisant le langage de programmation Python, ainsi que des bibliothèques telles que NumPy et Pandas pour la manipulation des données et les calculs numériques. Ces implémentations se basent sur la loi de Darcy, essentielle pour comprendre comment l'eau se déplace à travers un milieu poreux. Ces algorithmes utilisent une approche basée sur une grille régulière pour discrétiser l'espace et le temps, ce qui permet de modéliser la propagation de l'eau avec une précision paramétrable.

Pour le calcul du gradient en surface, on s'est basé sur la différence entre les niveaux d'eau, c'est-à-dire la somme de l'altitude et de la hauteur d'eau. En sous-sol, le calcul du gradient prend en compte un paramètre de porosité du sol couplé à la saturation en eau. La saturation est calculée sur la base d'un paramètre de capacité qui représente la limite d'eau pouvant être contenue dans un point du sol.

Assez tôt, l'idée de rendre configurables les fonctions d'évolution de la simulation et la structure de données a été imaginée. L'objectif serait de permettre à des chercheurs de se connecter à une plateforme et de choisir, voire de fournir, la fonction d'évolution.

Dans cette optique, le simulateur prend en paramètre un json décrivant les grandeurs utilisées par l'algorithme. Noter qu'elles peuvent aussi bien être constantes (comme la hauteur du terrain, même si un phénomène d'érosion n'est pas interdit) que variables (quantité d'eau typiquement).

{
  "features": [
    "height_m",
    // le gradient peut se décliner sur les axes (x,y et z)
    "gradient_x",
    "water_gradient_x",
    // épaisseur de chaque couche de terrain
    "thickness_m",
    "permeability",
    // quantité d'eau à un instant T
    "water_mm",
    // limite d'eau (saturation)
    "water_capacity_mm",
    // potentiel hydraulique (utilisé pour la loi de Darty)
    "pression_atm"
  ],
  // résolution temporelle
  "time": {
    "step_number": 100,
    "duration_sec": 120
  },
  "topology": {
    // resolution de la grille spatiale
    "resolution": {
      "x_axis": 512,
      "y_axis": 512,
      "z_axis": 1
    },
    // normalisation du terrain
    "dimension": {
      "x_axis_meter": 1000,
      "y_axis_meter": 1000,
      "z_axis_meter": 10
    }
  }
}

Le simulateur se charge de gérer efficacement la mémoire et l'accès aux données. En apparence, l'accès aux données se fait de manière naturelle à partir du nom de la "feature", sous le capôt c'est un numpy array qui permet de faire des calculs efficaces. La classe Model représente la donnée et il suffit d'implémenter l'interface Simulator pour décrire un comportement de façon modulaire.

class SurfaceFlow(Simulator):
    # https://planet-terre.ens-lyon.fr/ressource/permeabilite-des-roches.xml

    def single_step(self, model: Model, dt_sec):
        surface = model.surface
        grad = np.array([surface.water_gradient_y, surface.water_gradient_x])
        surface.water_mm = displace(surface.water_mm, grad)


def displace(a: np.ndarray, gradient, flow_ratio: float = 1.):
    fns = {
        -1: lambda x: -x,
        0: lambda x: 1 - np.abs(x),
        1: lambda x: x,
    }

    # result = np.zeros_like(a)
    result = a.copy() * (1 - flow_ratio)

    for dx in range(-1, 2):
        wx = np.maximum(fns[dx](gradient[1]), 0.0)
        for dy in range(-1, 2):
            wy = np.maximum(fns[dy](gradient[0]), 0.0)
            result += np.roll(flow_ratio * wx * wy * a, (dy, dx), axis=(0, 1))

    error = result.sum() - a.sum()

    if abs(error) > 1e-3:
        print(f'error: {error} (before={a.sum()}, after={result.sum()})')
    return result

Ce design s'est révélé très pratique, en particulier pour itérer sur l'algorithme et surtout activer et désactiver des composantes.

Pour valider ces algorithmes, ils ont été testés sur des jeux de données synthétiques. Auparavant, des travaux avaient été réalisés sur des algorithmes de génération procédurale, en particulier avec l'application de phénomènes d'érosion. Ces algorithmes ont été réutilisés pour produire des données de terrain réalistes, notamment des modèles d'élévation générés à l'aide de techniques basées sur les fonctions de bruit de Perlin et simplex noise.

Les tests se sont déroulés à la fois sur ces données complexes et assez réalistes, mais aussi sur des cas triviaux comme un simple plan incliné. Cette approche a permis d'évaluer la crédibilité des algorithmes dans des conditions variées et d'identifier les éventuelles améliorations à apporter. Les cas simples, comme le plan incliné, ont aidé à observer des comportements particuliers sur des topologies de terrain précises et contrôlées, facilitant ainsi le diagnostic et l'ajustement des modèles. De plus, les algorithmes ont également été testés sur des données réelles, bien que peu précises, d'élévation de terrain disponible publiquement, afin de valider leur applicabilité dans des contextes réels.

Création de l'Application

Notre application se compose d'un back-end et d'un front-end. Le back-end est un serveur REST développé en Python qui exécute l'algorithme de simulation et permet de récupérer les données pour la visualisation. Le serveur permet également de récupérer des données géolocalisées de serveurs publics, ce qui enrichit nos simulations avec des informations contextuelles précieuses.

Le front-end est une interface utilisateur qui affiche une carte géographique avec une heatmap transparente représentant la quantité d'eau en surface au cours du temps. Cette interface permet aux utilisateurs de visualiser facilement les écoulements et d'identifier les zones à risque. Nous avons utilisé OpenMap Box pour créer une carte interactive où les utilisateurs peuvent zoomer, dézoomer et se déplacer pour visualiser les zones d'intérêt.

La visualisation des résultats est un aspect clé de notre application. La heatmap transparente représente la quantité d'eau en surface au cours du temps, permettant aux utilisateurs d'identifier facilement les zones à risque et de comprendre les dynamiques des écoulements d'eau. Les utilisateurs peuvent également superposer différentes couches de données géospatiales, telles que les données d'élévation, de couverture du sol, et de cadastre, pour une analyse plus détaillée.

Défis et Apprentissages

L'un des principaux défis de ce projet a été d'apprendre un nouveau domaine : l'hydrologie. Comprendre les concepts hydrologiques et les techniques de simulation avancées a été une tâche ardue, mais enrichissante. Nous avons dû nous familiariser avec des concepts tels que la loi de Darcy, l'équation de Richards et les équations de Saint-Venant, qui décrivent les écoulements d'eau dans différents contextes.

Ce projet nous a permis d'acquérir une compréhension approfondie des processus hydrologiques et des techniques de simulation avancées. Nous avons appris l'importance de la précision des données et de l'intégration des données géospatiales pour des simulations hydrologiques précises.

Conclusion

Le projet "Simulation de l'Écoulement de l'Eau de Pluie" a été une aventure enrichissante qui nous a permis d'en apprendre beaucoup sur le domaine de l'hydrologie.

Nous regrettons de ne pas avoir collaboré avec des hydrologues lors de ce projet, car leur expertise aurait été précieuse pour challenger et améliorer nos algorithmes sur le plan scientifique. À l'avenir, nous espérons pouvoir travailler avec des experts en hydrologie pour affiner et valider nos modèles.

Nous aimerions également faire tester notre application par des utilisateurs et passer de l'état de prototype à celui d' application en production, avec un déploiement dans le cloud. La capacité de travailler en temps réel sur une plateforme hébergée dans le cloud pourrait, nous l'espérons, accélérer les recherches de nombreux chercheurs en hydrologie.