Contact
Un de nos experts vous contactera dans les plus brefs délais pour discuter de vos besoins et organiser une démo sur-mesure de la plateforme.
Depuis la première prévision numérique dans les années 1950, la prévision numérique du temps (PNT) n'a cessé de s'améliorer. Grâce au développement d'ordinateurs plus puissants, les modèles de PNT peuvent désormais prédire la météo des 5 prochains jours avec une fiabilité reconnue. Voyons comment la PNT a évolué de la physique au calcul numérique et comment vous pouvez réaliser vos propres simulations météorologiques sur Qarnot.
La plupart des activités – qu'elles soient liées à l'agriculture, au transport ou à l'énergie – sont affectées par la météo. Par conséquent, connaître son état dans un avenir proche, voire à plus long terme, peut être très utile. Alors, comment réussir à prédire avec précision les phénomènes atmosphériques qui se produisent constamment autour de nous ?
Les équations de Navier-Stokes existent depuis le milieu du XIXe siècle pour exprimer les principes physiques de conservation de la masse, de la quantité de mouvement et de l'énergie dans le contexte des fluides visqueux. Elles peuvent être utilisées pour modéliser les courants océaniques, l'écoulement de l'air autour d'une aile et, dans notre cas, la météo.
Le seul inconvénient est que, même si ces équations aux dérivées partielles sont valables en tout point de l'espace et du temps, elles ne sont pas solubles en tant que telles.
La production de prévisions réalistes telle que nous la connaissons n'a commencé qu'au XXe siècle, lorsque des scientifiques ont montré que ces équations pouvaient être approximées à un nombre fini de points dans l'espace. Avec le développement des premiers ordinateurs dans les années 1950, la prévision numérique est devenue possible, moyennant des approximations considérables.
Aujourd'hui, avec les progrès de la puissance de calcul et le développement des supercalculateurs, des modèles plus précis sont constamment créés.
Même avec un besoin moindre d'approximations, certaines restent nécessaires pour réduire le temps de calcul des prévisions météorologiques.
À titre d'exemple, une prévision à 16 jours réalisée par les modèles du Global Forecast System nécessite environ 5 heures d'exécution sur le supercalculateur de la National Oceanic and Atmospheric Administration (NOAA).
L'approximation hydrostatique, par exemple, est toujours utilisée dans la plupart des modèles modernes (à l'exception de ceux spécialisés dans les phénomènes extrêmes, comme les modèles d'ouragans). Cette approximation suppose que le mouvement vertical est beaucoup plus petit que le mouvement horizontal, ce qui permet de calculer la force de pression comme si elle était en équilibre avec la force gravitationnelle.
Sous cette hypothèse, le système d'équations utilisé dans les modèles de PNT est composé des équations primitives, qui consistent en une équation de l'énergie thermique et une version simplifiée des équations de Navier-Stokes, couplées à la loi des gaz parfaits. Ce système peut ensuite être résolu dans des modèles à points de grille avec la méthode des différences finies, dans les trois dimensions spatiales.
Les solutions des équations mentionnées ci-dessus peuvent être calculées pour un nombre fini de points, ce qui soulève la question de la détermination des points où les solutions seront calculées. Ceci est généralement fait en discrétisant la région d'intérêt en petites cellules, dont la totalité forme ce que l'on appelle un maillage.
Différents maillages sont adaptés à différents scénarios, et le choix du type et de la taille du maillage est essentiel, car il affectera la précision, les erreurs et les exigences en matière de puissance de calcul.
Alors que la plupart des modèles à points de grille utilisent un maillage latitude-longitude, avec une résolution déterminée par la taille d'une cellule, certains utilisent des maillages plus sophistiqués, pour inclure une résolution variable, par exemple. C'est le cas des maillages de Voronoï : ils partitionnent l'espace en régions proches de chaque point d'intérêt (POI), créant un maillage irrégulier ou régulier selon le POI choisi. Ce principe est pratique pour les grands domaines qui couvrent plusieurs topographies terrestres, telles que les montagnes, impliquant des phénomènes physiques plus petits. Il peut également être utile pour les prévisions régionales localisées, comme un pays qui souhaite exécuter une simulation météorologique sur l'ensemble du globe avec une précision plus fine sur son territoire.
Bien que nous ayons choisi de nous concentrer ici sur les modèles de PNT, l'ensemble du processus de prévision météorologique qui se déroule avant que nous puissions voir les prévisions de demain sur votre écran de télévision est bien plus sophistiqué.
Premièrement, les observations de l'état de l'atmosphère sont récupérées par des satellites, des stations météorologiques et d'autres dispositifs de mesure, avant d'être traitées pour s'adapter aux modèles de prévision.
Un modèle est ensuite exécuté sur de puissants ordinateurs avec ces données et produit des sorties qui sont post-traitées pour corriger les biais du modèle et créer des variables d'intérêt, telles que les précipitations quotidiennes et la vitesse du vent.
Des ressources informatiques peuvent également être nécessaires pour d'autres étapes telles que l'assimilation de données, mais puisque les modèles de PNT utilisent la méthode des différences finies, ils sont certainement le composant le plus gourmand en ressources de tous.
Afin d'illustrer ce que nous avons appris jusqu'à présent, nous allons maintenant vérifier la précision atteinte par une prévision réalisée avec WRF (Weather Research and Forecasting Model), un modèle open source populaire développé à l'origine par le National Center for Atmospheric Research (NCAR), et l'exécuter sur Qarnot.
Avant de lancer le cas de test, veuillez vous assurer que les prérequis suivants sont remplis :
Pour notre cas de test, nous allons utiliser le modèle WRF, un modèle à méso-échelle capable d'effectuer des simulations à haute résolution. Son exécution comprend deux composants : le Système de pré-traitement WRF (WPS) et le modèle WRF.
Le paquet WPS traite les données terrestres et météorologiques afin de créer des conditions initiales et des conditions aux limites horizontales. Il prend en charge les trois programmes suivants :
Le modèle WRF peut ensuite être exécuté via :
met_em* générés par metgrid et crée les fichiers de conditions aux limites et initiales ;Créez un dossier WRF, et à l'intérieur, un dossier input. Dans le dossier input, vous inclurez tous les fichiers nécessaires au calcul :
wrf.exe. Enregistrez le script suivant dans votre dossier input – il pourrait également être adapté à votre simulation si vous le jugez approprié.## running_script.sh
<details><summary>Click to see the code</summary>
<p>
```
#!/bin/bash
# move files uploaded in the bucket to their respective folders for execution
echo "Moving input files..."
mv /job/DATA/ /opt/Build_WRF/
mv /job/namelist.wps /opt/WPS
mv /job/namelist.input /opt/WRF/test/em_real
### WPS ###
cd /opt/WPS/
# WPS output folder
mkdir /job/WPS
# GEOGRID
echo "Running geogrid.exe..."
./geogrid.exe 2>&1 | tee /job/WPS/geogrid.out
# UNGRIB with files in DATA
echo "Running ungrib.exe..."
./link_grib.csh /opt/Build_WRF/DATA/GFS_
ln -sf ungrib/Variable_Tables/Vtable.GFS Vtable
./ungrib.exe 2>&1 | tee /job/WPS/ungrib.out
# METGRID
echo "Running metgrid.exe..."
./metgrid.exe 2>&1 | tee /job/WPS/metgrid.out
# get metgrid levels
MET_FILE=$(ls met_em* | head -n 1)
TMP_LEVELS=$(ncdump -h $MET_FILE | grep -i "num_metgrid_levels =" | cut -d' ' -f3)
TMP_SOIL_LEVELS=$(ncdump -h $MET_FILE | grep -i num_metgrid_soil_levels | cut -d' ' -f3)
# copy files automatically generated in the executables folder to the job folder
cp --update /opt/WPS/FILE* /job/WPS/
cp --update /opt/WPS/geo_* /job/WPS/
cp --update /opt/WPS/met_em* /job/WPS/
cp --update /opt/WPS/*.log /job/WPS/
### WRF ###
cd /opt/WRF/test/em_real/
# WRF output folders
mkdir -p /job/WRF/real
# set metgrid levels
LINE_LEVELS=$(grep "num_metgrid_levels" namelist.input)
sed -i "s|$LINE_LEVELS| num_metgrid_levels = $TMP_LEVELS,|g" namelist.input
LINE_SOIL_LEVELS=$(grep "num_metgrid_soil_levels" namelist.input)
sed -i "s|$LINE_SOIL_LEVELS| num_metgrid_soil_levels = $TMP_SOIL_LEVELS,|g" namelist.input
# REAL
echo "Running real.exe..."
ln -sf /job/WPS/met_em* .
mpirun --allow-run-as-root ./real.exe 2>&1 | tee /job/WRF/real.out
cp --update /opt/WRF/test/em_real/rsl* /job/WRF/real/
# WRF
echo "Running wrf.exe..."
mpirun --allow-run-as-root ./wrf.exe 2>&1 | tee /job/WRF/wrf.out
echo "Done running!"
# copy files automatically generated in the executables folder to the job folder
cp --update /opt/WRF/test/em_real/wrfbdy* /job/WRF/
cp --update /opt/WRF/test/em_real/wrfinput* /job/WRF/
cp --update /opt/WRF/test/em_real/rsl* /job/WRF/
cp --update /opt/WRF/test/em_real/wrfout* /job/WRF/
# if restart interval not null
cp --update /opt/WRF/test/em_real/wrfrst* /job/WRF/
```
</p>
</details>Maintenant que vous avez tous les éléments nécessaires à la simulation, utilisons le SDK Python de Qarnot pour lancer le calcul. Vous pouvez enregistrer le script Python suivant sous run.py dans le dossier WRF.
Assurez-vous d'avoir copié votre jeton d'authentification dans le script (à la place de <<<put your secret token here>>>) pour pouvoir lancer la tâche sur Qarnot.
## wrf_sdk_qarnot.py
<details><summary>Click to see the code</summary>
<p>
```
#!/usr/bin/env python
import sys
import qarnot
import os
# Edit 'samples.conf' to provide your own credentials
# Create a connection, from which all other objects will be derived
conn = qarnot.Connection(client_token="<<<put your secret token here>>>")
# Create a task
task = conn.create_task('wrf_demo', 'docker-batch', 1)
# Store if an error happened during the process
error_happened = False
try:
# Create a resource bucket and add input files
input_bucket = conn.create_bucket('wrf-files')
input_bucket.sync_directory('input')
# Attach the bucket to the task
task.resources.append(input_bucket)
# Create a result bucket and attach it to the task
output_bucket = conn.create_bucket('wrf-files-output')
task.results = output_bucket
# Set the command to run when launching the container, by overriding a
# constant.
# Task constants are the main way of controlling a task's behaviour
task.constants['DOCKER_REPO'] = "qarnotlab/wrf"
task.constants['DOCKER_TAG'] = "v1"
task.constants['DOCKER_CMD'] = './running_script.sh'
# Update results every 5 seconds
task.snapshot(5)
# Submit the task to the Api, that will launch it on the cluster
task.submit()
# Wait for the task to be finished, and monitor the progress of its
# deployment
last_state = ''
done = False
while not done:
# Update task state changes
if task.state != last_state:
last_state = task.state
print("** {}".format(last_state))
# Wait for the task to complete, with a timeout of 2 seconds.
# This will return True as soon as the task is complete, or False
# after the timeout.
done = task.wait(2)
# Display fresh stdout / stderr
sys.stdout.write(task.fresh_stdout())
sys.stderr.write(task.fresh_stderr())
# Display errors on failure
if task.state == 'Failure':
print("** Errors: %s" % task.errors[0])
error_happened = True
else:
# Download results from output_bucket into given folder
task.download_results('output')
finally:
# Delete the task
# task.delete(purge_resources=True, purge_results=True)
# Exit code in case of error
if error_happened:
sys.exit(1)
```
</p>
</details>L'arborescence finale que vous obtenez après avoir téléchargé ou créé tous les fichiers ci-dessus devrait ressembler à ceci :
WRFinputDATAGFS_......GFS_...namelist.inputnamelist.wpsrunning_script.shwrf_sdk_qarnot.pyLa seule chose qui reste à faire est de suivre ces étapes pour configurer un environnement virtuel Python dans le dossier WRF, puis d'exécuter le script Python en tapant python run.py dans un terminal.
Vous pouvez ensuite consulter les détails des tâches sur votre propre console ou sur la console Qarnot en cliquant sur votre tâche. Une fois la tâche terminée, les résultats (c'est-à-dire les fichiers créés, y compris la sortie finale, les fichiers de redémarrage et les journaux) seront téléchargés sur votre ordinateur.
Si vous avez exécuté la simulation ci-dessus avec les données et les scripts fournis, vous devriez obtenir un fichier de sortie wrfout_d01_2020-09-10_00:00:00 contenant des prévisions de 36 heures pour de nombreuses variables. Vous pouvez utiliser n'importe quel logiciel de visualisation – ici, nous avons utilisé un logiciel de visualisation, adapté pour un simple premier aperçu des données – pour afficher les résultats de la simulation.
En comparant cette prévision avec les données observées (à partir des archives Meteociel) au moment de la simulation, nous obtenons deux animations de température montrant les mêmes variations, validant ainsi la prévision.
Comme la plupart des modèles atmosphériques, WRF est un système modulaire et peut donc être couplé à d'autres modèles, tels que ceux de l'océan ou de la surface terrestre. Les modèles couplés permettent des simulations plus fines pour des applications spécifiques, notamment la modélisation du climat, des feux de forêt, des cyclones tropicaux, de la qualité de l'air, de l'énergie solaire ou des cultures.
WRF intègre d'ailleurs depuis la version 4 une extension, WRF-Chem, qui couple le modèle WRF à la chimie pour simuler l'émission, le transport, le mélange et les transformations chimiques des gaz traces et des aérosols simultanément avec la météorologie à l'échelle régionale. Nous avons testé sur Qarnot une simulation d'émission de poussières dans la région méditerranéenne en 2014, ainsi que d'autres tutoriels qui permettent aux utilisateurs de démarrer avec ce module.
Bien que de nombreux autres modèles existent que celui présenté ici, avec différentes équations, approximations, paramètres ou même applications, par exemple pour les prévisions climatiques, ils ont tous des limites communes.
Leur résolution de simulation sera toujours contrainte par la puissance de calcul disponible, même si des progrès sont toujours réalisés dans ce domaine. De plus, la vaste gamme d'influences de processus complexes et le nombre croissant d'observations et de données disponibles rendent la tâche de prévision météorologique de plus en plus difficile.
L'une des dernières tendances dans ce domaine est l'application possible des algorithmes d'apprentissage automatique à la prévision numérique du temps et aux prévisions climatiques. Bien qu'elle soit déjà intégrée dans certaines méthodes de prédiction et de post-traitement et que de nombreuses recherches soient en cours, elle fait également face à ses propres défis, tels que l'instabilité, la reproductibilité et l'interprétabilité.
Il reste à voir où la recherche mènera.
Nous espérons que ce tutoriel vous a plu ! Si vous avez des questions, veuillez contacter qlab@qarnot.com et nous vous aiderons avec plaisir !
