Ce tutoriel guide l'utilisateur étape par étape à travers le flux de travail complet d'une simulation TELEMAC-2D, via le cas de test « Gouttedo » (goutte), de la création de la géométrie du domaine à la visualisation des résultats.
1. Géométrie du domaine
Le domaine de calcul est un carré de 20,1 m × 20,1 m avec un fond plat. Les coordonnées des quatre coins sont définies dans un fichier .txt qui est importé dans QGIS pour construire le contour géométrique.
1.1 Préparation des dossiers
Créez les dossiers nécessaires, dans le terminal :
bashmkdir -p gouttedo/shape
mkdir -p gouttedo/user_fortranCréez le fichier texte suivant dans gouttedo/shape/geo.txt
txtx(m),y(m)
0,0
20.1,0
20.1,20.1
0,20.1
1.2 Ouverture de QGIS et création du projet
1. Ouvrez QGIS.
2. Allez dans Projet > Nouveau.
3. Enregistrez immédiatement le projet : Projet > Enregistrer sous, naviguez vers gouttedo/shape, nom du fichier : q4ts_gouttedo
1.3 Importation des points du domaine
Les coordonnées de geo.txt sont importées en tant que couche de points vectoriels.
4. Allez dans Couche > Ajouter une couche > Ajouter une couche de texte délimité.
5. Cliquez sur ... pour sélectionner gouttedo/shape/geo.txt
6. Sous Format de fichier, cochez Virgule comme délimiteur.
7. Vérifiez que les champs X et Y sont correctement remplis. Le CRS doit être EPSG:4326. Cliquez sur Ajouter puis sur Fermer.
1.4 Construction du contour : Points → Ligne → Polygone
8. Ouvrez la Boîte à outils de traitements (icône d'engrenage ou Traitement > Boîte à outils).
9. Recherchez « Points vers lignes », sélectionnez la couche de points importée, puis cliquez sur Exécuter. Une couche de polyligne est créée.
10. Recherchez « Lignes vers polygones » et appliquez-le à la couche de polyligne. La limite fermée du domaine est créée.
2. Génération du maillage avec Q4TS
Q4TS (QGIS for TELEMAC Suite) est un plugin QGIS qui génère des maillages compatibles avec TELEMAC, applique les conditions aux limites et interpole les données de champ (bathymétrie, vitesses). Ici, il est utilisé pour créer un maillage triangulaire avec une taille caractéristique de 0.3 m.
2.1 Paramètres du maillage dans Q4TS
11. Ouvrez le panneau Q4TS.
12. Remplissez les paramètres dans l'interface Q4TS comme suit :
- Contour layer: Polygones
- Mesh engine: netgen_1d_2d
- Mesh min./max. size: 0.3 m
- Result .slf: geo_gouttedo.slf
13. Cliquez sur le bouton vert ▶ (Play) en bas à droite pour lancer la génération du maillage.
14. Si le message « My work is done » apparaît, le maillage a été créé avec succès.
La couche de maillage apparaît désormais dans le panneau des couches de QGIS.
3. Définition des conditions aux limites
Les conditions aux limites de TELEMAC-2D sont encodées dans un fichier .cli. Q4TS génère automatiquement ce fichier à partir du maillage. Seules les conditions aux limites de type parois solides sont considérées dans cet exemple.
3.1 Génération du contour et des conditions aux limites dans Q4TS
Dans Q4TS, allez dans l'onglet Create Boundary.
15. Dans le champ Input mesh, sélectionnez la couche de maillage geo_gouttedo.slf créée à l'étape précédente.
16. Dans la section Contour, cliquez sur le bouton vert + pour extraire automatiquement les nœuds de la limite.La couche ContourMesh est créée.
17. Laissez le champ Initial Boundaries vide (pas de condition initiale particulière dans ce cas simple).
18. Cliquez sur le bouton vert + dans la section Boundaries pour générer les conditions aux limites.
La couche boundaries est créée automatiquement.
Par défaut, toutes les conditions aux limites générées par Q4TS sont des parois solides (code 2 2 2). Aucune modification n'est nécessaire pour cet exemple. Pour imposer des conditions aux limites liquides, modifiez la couche « boundaries » (voir la documentation Q4TS).
19. Si QGIS demande d'enregistrer un fichier .gpkg, enregistrez-le dans gouttedo/shape/
20. Cliquez sur le bouton vert ▶ (Play) pour générer geo_gouttedo.cli.
Ce fichier est placé à côté de geo_gouttedo.slf dans le dossier gouttedo/.
4. Conditions initiales
Le fluide est initialement au repos (U = V = 0 m/s). La surface libre présente une perturbation gaussienne 2D centrée au milieu du domaine, à (10,05 m, 10,05 m).
Routine utilisateur Fortran USER_CONDIN_H
TELEMAC-2D propose plusieurs méthodes pour imposer des conditions initiales. Ici, une routine utilisateur Fortran est utilisée, offrant une flexibilité totale pour des profils arbitraires. Créez le fichier gouttedo/user_fortran/user_condin_h.f avec le contenu suivant :
Fortranuser_condin_h.f — Fortran user routine
!> @brief USER INITIALISES THE PHYSICAL PARAMETERS H
SUBROUTINE USER_CONDIN_H
!
USE BIEF
USE DECLARATIONS_TELEMAC
USE DECLARATIONS_TELEMAC2D
!
USE DECLARATIONS_SPECIAL
IMPLICIT NONE
!
!+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
!
INTEGER IPOIN
DOUBLE PRECISION EIKON
INTRINSIC EXP
!
!---------------------------------------------------------------
!
DO IPOIN=1,NPOIN
EIKON = ((X(IPOIN)-10.05D0)**2 &
+ (Y(IPOIN)-10.05D0)**2) / 4.D0
H%R(IPOIN) = 2.4D0 * (1.D0 + EXP(-EIKON))
ENDDO
!
!---------------------------------------------------------------
!
RETURN
END
5. Fichier .cas
Le fichier .cas centralise tous les paramètres physiques, numériques et d'entrée/sortie. Tous les mots-clés autorisés se trouvent dans le module de guide de référence correspondant (voir la dernière version de la documentation. Dans gouttedo/, créez le fichier t2d_gouttedo.cas suivant :
EQUATIONS : 'SAINT-VENANT FE'
/
FORTRAN FILE : 'user_fortran'
BOUNDARY CONDITIONS FILE : geo_gouttedo.cli
GEOMETRY FILE : geo_gouttedo.slf
RESULTS FILE : r2d_gouttedo.slf
/
/----------------------------------------------------------------------
/ OPTIONS GENERALES
/----------------------------------------------------------------------
TITLE = 'TELEMAC 2D: DROPLET IN A BASIN'
VARIABLES FOR GRAPHIC PRINTOUTS : 'U,V,H,T*'
TIME STEP = 0.04
NUMBER OF TIME STEPS = 100
GRAPHIC PRINTOUT PERIOD : 5
LISTING FOR PRINTOUT PERIOD = 10
LAW OF BOTTOM FRICTION : 3
FRICTION COEFFICIENT = 40.
/----------------------------------------------------------------------
/ PROPAGATION
/----------------------------------------------------------------------
TURBULENCE MODEL : 1
VELOCITY DIFFUSIVITY = 0.D0
SOLVER : 7
SOLVER OPTION : 3
MAXIMUM NUMBER OF ITERATIONS FOR SOLVER : 100
SOLVER ACCURACY = 1.E-4
IMPLICITATION FOR DEPTH = 0.6
IMPLICITATION FOR VELOCITY = 0.6
/---------------------------------------------------------------
MASS-BALANCE : YES
INITIAL CONDITIONS : 'PARTICULAR'
TYPE OF ADVECTION : 2;5
SUPG OPTION : 2;2
DISCRETIZATIONS IN SPACE: 11;11
/
/ DEFAULT VALUE UNTIL V8P1 MANDATORY WITH SUPG
TREATMENT OF THE LINEAR SYSTEM = 1
/
/ DEFAULT VALUE UNTIL V8P5 KEPT FOR NON REGRESSION
TREATMENT OF NEGATIVE DEPTHS = 16. Lancement de la simulation
La simulation TELEMAC-2D est lancée depuis le terminal via le script Python telemac2d.py :
bash# 1. charger l'environnement TELEMAC
source /chemin/vers/votre/telemac/setenv_telemac.sh
# 2. Se déplacer dans le répertoire du cas
cd /chemin/vers/votre/cas/gouttedo/
# 3. Exécution séquentielle
telemac2d.py t2d_gouttedo.cas
# 4. ou exécution en parallèle (4 cœurs MPI)
telemac2d.py t2d_gouttedo.cas --ncsize=48. Post-traitement et visualisation des résultats
Une fois la simulation terminée, les résultats sont stockés dans le fichier binaire SERAFIN r2d_gouttedo.slf. Le fichier de résultats openTELEMAC peut être post-traité avec divers outils, tels que Python et ParaView.
8.1 Jupyter Notebooks
openTELEMAC fournit une collection de notebooks Jupyter couvrant le pré-traitement, le lancement de la simulation et le post-traitement pour de nombreux cas d'application (voir cet article). Ces notebooks constituent un excellent point de départ pour comprendre les API Python de TELEMAC et construire des scripts d'analyse personnalisés.
8.2 Script d'animation Python
Le script ci-dessous génère un GIF animé de la profondeur d'eau H(x,y,t), combinant une vue en plan et une vue 3D. Créez le fichier plot.py suivant dans le dossier gouttedo :
pythonimport numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import matplotlib.colors as mcolors
import matplotlib.cm as cm
from data_manip.extraction.telemac_file import TelemacFile
from postel.plot2d import plot2d_triangle_mesh, plot2d_scalar_map
plt.rcParams.update({'font.size': 18})
# load .slf file
filename = 'r2d_gouttedo.slf'
res = TelemacFile(filename)
# extract water depth
n = len(res.times)
h = np.array([res.get_data_value('WATER DEPTH', t) for t in range(n)])
# figure
fig = plt.figure(figsize=(16, 8))
gs = fig.add_gridspec(1, 3, width_ratios=[5, 6, 0.5])
ax1 = fig.add_subplot(gs[0]) #top view
ax2 = fig.add_subplot(gs[1], projection='3d') #3d view
cax = fig.add_subplot(gs[2])
ax1.set_aspect('equal')
vmin, vmax = h.min(), h.max()
norm = mcolors.Normalize(vmin=vmin, vmax=vmax)
ax2.xaxis.labelpad = 10; ax2.yaxis.labelpad = 10; ax2.zaxis.labelpad = 10
# color
cmap = cm.get_cmap('jet')
sm = cm.ScalarMappable(cmap=cmap, norm=norm)
sm.set_array([])
fig.colorbar(sm, cax=cax, label="water depth (m)")
# initialisation
plot2d_scalar_map(fig, ax1, res.tri, h[0],
data_name="water_depth (m)", vmin=vmin, vmax=vmax, colorbar=False)
ax1.set_xlabel('x (m)'); ax1.set_ylabel('y (m)')
surf = [ax2.plot_trisurf(res.tri.x, res.tri.y, h[0],
triangles=res.tri.triangles, cmap=cmap, norm=norm,
antialiased=True)]
ax2.set_xlabel('x (m)'); ax2.set_ylabel('y (m)'); ax2.set_zlabel('z (m)')
ax2.set_zlim(vmin, vmax)
fig.suptitle(f't = {res.times[0]:.1f} s')
# animation loop
def update(frame):
plot2d_scalar_map(fig, ax1, res.tri, h[frame],
data_name="water depth (m)", vmin=vmin, vmax=vmax, colorbar=False)
ax1.set_xlabel('x (m)'); ax1.set_ylabel('y (m)')
surf[0].remove()
surf[0] = ax2.plot_trisurf(res.tri.x, res.tri.y, h[frame],
triangles=res.tri.triangles, cmap=cmap, norm=norm,
antialiased=True)
fig.suptitle(f't = {res.times[frame]:.1f} s')
fps = 5
ani = animation.FuncAnimation(fig, update, frames=n, interval=1000 // fps)
# save gif
ani.save('water_depth.gif', writer=animation.PillowWriter(fps=fps))8.3 Exécuter le script de tracé et visualiser les résultats
Dans le terminal,
bash# Se déplacer dans le répertoire gouttedo
cd chemin/vers/votre/cas/gouttedo/
# Exécuter le script python
python plot.py