Exemple d’utilisation des classes Qdf_IRM et MontanaIRM
Ce notebook illustre comment :
Récupérer les données QDF (Quantité-Durée-Fréquence) depuis le site web de l’IRM pour une commune belge
Exploiter les coefficients de Montana pour générer des pluies de projet
Mettre en évidence les différents comportements de décentrement (hyétogrammes de Chicago)
[ ]:
from wolfhece import check_version
check_version("2.2.74")
from wolfhece.irm_qdf import Qdf_IRM
import numpy as np
import matplotlib.pyplot as plt
INFO:root:Version de wolfhece : 2.2.73 ou supérieure est installée.
Récupération des données IRM pour une commune
On utilise la méthode make() qui télécharge automatiquement les données depuis le site de l’IRM et crée une instance Qdf_IRM prête à l’emploi.
On peut spécifier la commune soit par son nom, soit par son code INS.
[5]:
# Récupération des données pour la commune de Jalhay (code INS 63038)
qdf = Qdf_IRM.make(ins_code='Jalhay')
print(f"Commune : {qdf.name}")
print(f"Code INS : {qdf.code}")
Commune : Jalhay
Code INS : 63038
Exploration des données QDF
Les données sont stockées sous forme de DataFrames pandas :
qdf.qdf: relations Quantité-Durée-Fréquenceqdf.standarddev: écart-type de l’erreurqdf.confintlow/qdf.confintup: bornes de l’intervalle de confianceqdf.montanacoeff: coefficients de Montana
[6]:
# Affichage des relations QDF (intensité en mm/h)
display(qdf.qdf)
| 2 | 5 | 10 | 15 | 20 | 25 | 30 | 40 | 50 | 75 | 100 | 200 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Duur / Durée | ||||||||||||
| 10 min | 8.3 | 11.9 | 14.6 | 16.2 | 17.5 | 18.4 | 19.2 | 20.5 | 21.6 | 23.6 | 25.0 | 28.8 |
| 20 min | 12.6 | 18.3 | 22.5 | 25.1 | 27.1 | 28.6 | 29.8 | 31.9 | 33.6 | 36.7 | 39.0 | 44.9 |
| 30 min | 14.7 | 21.3 | 26.3 | 29.3 | 31.5 | 33.3 | 34.8 | 37.2 | 39.1 | 42.7 | 45.3 | 52.2 |
| 1 h | 18.3 | 26.3 | 32.2 | 35.8 | 38.4 | 40.5 | 42.3 | 45.1 | 47.4 | 51.7 | 54.8 | 63.0 |
| 2 h | 22.3 | 31.3 | 38.0 | 42.1 | 45.1 | 47.4 | 49.4 | 52.6 | 55.2 | 60.0 | 63.5 | 72.6 |
| 3 h | 24.8 | 34.1 | 41.1 | 45.3 | 48.3 | 50.8 | 52.8 | 56.1 | 58.7 | 63.7 | 67.3 | 76.6 |
| 6 h | 30.1 | 38.8 | 45.3 | 49.2 | 52.0 | 54.3 | 56.2 | 59.2 | 61.6 | 66.2 | 69.6 | 78.1 |
| 12 h | 37.6 | 47.8 | 55.3 | 59.8 | 63.2 | 65.8 | 68.0 | 71.5 | 74.3 | 79.6 | 83.5 | 93.4 |
| 1 d | 47.0 | 58.9 | 67.5 | 72.6 | 76.3 | 79.2 | 81.6 | 85.4 | 88.5 | 94.2 | 98.3 | 108.8 |
| 2 d | 62.4 | 77.9 | 88.8 | 95.2 | 99.7 | 103.3 | 106.2 | 110.9 | 114.6 | 121.5 | 126.4 | 138.6 |
| 3 d | 68.5 | 85.7 | 97.6 | 104.5 | 109.4 | 113.3 | 116.4 | 121.5 | 125.4 | 132.6 | 137.8 | 150.6 |
| 4 d | 75.5 | 94.2 | 106.9 | 114.3 | 119.6 | 123.6 | 127.0 | 132.3 | 136.4 | 144.0 | 149.4 | 162.7 |
| 5 d | 85.9 | 106.8 | 121.1 | 129.2 | 135.0 | 139.5 | 143.2 | 149.0 | 153.5 | 161.8 | 167.7 | 182.1 |
| 7 d | 100.6 | 123.3 | 138.6 | 147.3 | 153.4 | 158.2 | 162.0 | 168.1 | 172.9 | 181.5 | 187.6 | 202.5 |
| 10 d | 121.5 | 149.4 | 167.9 | 178.4 | 185.7 | 191.3 | 195.9 | 203.2 | 208.8 | 218.9 | 226.1 | 243.4 |
| 15 d | 147.9 | 180.0 | 201.1 | 212.9 | 221.1 | 227.4 | 232.5 | 240.5 | 246.7 | 257.9 | 265.8 | 284.6 |
| 20 d | 172.4 | 210.4 | 235.1 | 248.8 | 258.4 | 265.6 | 271.6 | 280.8 | 287.9 | 300.7 | 309.6 | 330.9 |
| 25 d | 186.6 | 226.9 | 252.7 | 267.1 | 277.0 | 284.6 | 290.7 | 300.3 | 307.6 | 320.8 | 330.0 | 351.8 |
| 30 d | 214.7 | 256.7 | 283.5 | 298.3 | 308.5 | 316.3 | 322.5 | 332.3 | 339.8 | 353.3 | 362.6 | 384.8 |
[7]:
# Coefficients de Montana
# a1, b1 : pour durées < 25 min
# a2, b2 : pour 25 min <= durées <= 6000 min
# a3, b3 : pour durées > 6000 min
display(qdf.montanacoeff)
| a1 | b1 | a2 | b2 | a3 | b3 | |
|---|---|---|---|---|---|---|
| Return period (years) | ||||||
| 2 | 148.3 | 0.4690 | 299.0 | 0.6869 | 49.6 | 0.4803 |
| 5 | 204.9 | 0.4533 | 480.0 | 0.7178 | 64.2 | 0.4866 |
| 10 | 245.8 | 0.4440 | 626.4 | 0.7345 | 77.8 | 0.4948 |
| 15 | 270.3 | 0.4389 | 719.7 | 0.7431 | 87.1 | 0.5004 |
| 20 | 288.0 | 0.4353 | 790.0 | 0.7488 | 94.3 | 0.5046 |
| 25 | 302.0 | 0.4327 | 847.2 | 0.7531 | 100.4 | 0.5079 |
| 30 | 313.6 | 0.4305 | 895.7 | 0.7565 | 105.6 | 0.5108 |
| 40 | 332.3 | 0.4271 | 975.8 | 0.7618 | 114.5 | 0.5154 |
| 50 | 347.1 | 0.4245 | 1041.0 | 0.7657 | 121.8 | 0.5191 |
| 75 | 374.7 | 0.4198 | 1167.0 | 0.7727 | 136.5 | 0.5261 |
| 100 | 394.9 | 0.4164 | 1262.7 | 0.7775 | 148.1 | 0.5312 |
| 200 | 445.8 | 0.4084 | 1516.7 | 0.7888 | 180.0 | 0.5439 |
Courbes IDF et QDF
Tracé des courbes Intensité-Durée-Fréquence (IDF) et Quantité-Durée-Fréquence (QDF) pour toutes les périodes de retour.
[8]:
# Courbes IDF (Montana + table QDF)
qdf.plot_idf()
[8]:
(<Figure size 1500x1000 with 1 Axes>,
<Axes: title={'center': 'Jalhay - code : 63038'}, xlabel='Duration [min]', ylabel='Intensity [mm/h]'>)
[9]:
# Courbes QDF
qdf.plot_qdf()
[9]:
(<Figure size 1200x800 with 1 Axes>,
<Axes: title={'center': 'Jalhay - code : 63038'}, xlabel='Duration [min]', ylabel='Quantity [mm]'>)
Accès direct aux coefficients de Montana
L’objet MontanaIRM est accessible via qdf.montana. La formule de Montana donne l’intensité moyenne : \(i = a \cdot d^{-b}\) où \(i\) est en mm/h et \(d\) en minutes.
[10]:
montana = qdf.montana
# Coefficients a, b pour une durée de 60 min et un temps de retour de 25 ans
a, b = montana.get_ab(dur=60, T=25)
print(f"Coefficients Montana (60 min, T=25 ans) : a={a:.4f}, b={b:.4f}")
# Intensité moyenne pour 60 min, T=25 ans
i_moy = montana.get_meanrain(dur=60, T=25)
print(f"Intensité moyenne (60 min, T=25 ans) : {i_moy:.2f} mm/h")
# Quantité de pluie pour 60 min, T=25 ans
q = montana.get_quantityrain(dur=60, T=25)
print(f"Quantité de pluie (60 min, T=25 ans) : {q:.2f} mm")
Coefficients Montana (60 min, T=25 ans) : a=847.2000, b=0.7531
Intensité moyenne (60 min, T=25 ans) : 38.80 mm/h
Quantité de pluie (60 min, T=25 ans) : 38.80 mm
La pluie de projet de Chicago
Principe
La méthode du hyétogramme de Chicago a été proposée par Keifer & Chu (1957) pour construire une pluie de projet synthétique dont l’intensité maximale, pour toute sous-durée, est cohérente avec les courbes IDF (Intensité-Durée-Fréquence).
Le principe repose sur les courbes de Montana qui décrivent l’intensité moyenne de la pluie en fonction de la durée \(d\) :
où \(a\) et \(b\) sont des coefficients calés pour chaque période de retour \(T\).
L’intensité instantanée correspondante est :
Construction du hyétogramme
Le hyétogramme de Chicago est construit de manière à ce que :
Pour toute sous-durée centrée sur le pic, l’intensité moyenne corresponde exactement à la valeur donnée par la courbe IDF.
La position du pic dans l’événement est contrôlée par un coefficient de décentrement \(r \in [0, 1]\) :
\(r = 1\) → pic en début de pluie (pluie « avant-lourde »)
\(r = 0.5\) → pic au centre (distribution symétrique)
\(r = 0\) → pic en fin de pluie (pluie « arrière-lourde »)
Avant le pic (\(t < t_{\text{pic}}\)), la branche descendante est construite vers la gauche ; après le pic (\(t > t_{\text{pic}}\)), la branche descendante est construite vers la droite. Chaque branche respecte individuellement la relation IDF.
Intérêt pratique
Ce type de pluie est très utilisé en hydrologie urbaine et rurale pour le dimensionnement d’ouvrages hydrauliques (bassins de rétention, réseaux d’assainissement, etc.), car il permet d’explorer l’effet du décentrement sur les hydrogrammes de crue.
Références
Keifer, C. J. & Chu, H. H. (1957). Synthetic Storm Pattern for Drainage Design. Journal of the Hydraulics Division, ASCE, 83(HY4), 1–25.
Willems, P. (2000). Compound intensity/duration/frequency-relationships of extreme precipitation for two seasons and two storm types. Journal of Hydrology, 233(1–4), 189–205.
Chow, V. T., Maidment, D. R. & Mays, L. W. (1988). Applied Hydrology. McGraw-Hill. (Section 14.3 – Design storms)
Animation de la construction
L’animation ci-dessous illustre la construction progressive du hyétogramme de Chicago.
Panneau gauche : la courbe IDF de Montana. Le point rouge indique la durée cumulée représentée à chaque étape.
Panneau droit : le hyétogramme en cours de construction. Les barres apparaissent dans l’ordre de construction (pic d’abord, puis alternance droite/gauche).
[11]:
from matplotlib import rc
from IPython.display import HTML
# Paramètres de l'animation
T_anim = 25 # Période de retour
dur_anim = 120 # Durée totale [min]
r_anim = 0.5 # Coefficient de décentrement (0.5 = centré)
timestep_anim = 5 # Pas de temps [min]
peak_dur_anim = 10 # Durée du pic [min]
anim = montana.animate_hyetogram_Chicago(
total_duration=dur_anim, T=T_anim, r=r_anim,
timestep=timestep_anim, peak_duration=peak_dur_anim,
interval=500
)
HTML(anim.to_jshtml())
INFO:matplotlib.animation:Animation.save using <class 'matplotlib.animation.HTMLWriter'>
[11]:
Hyétogramme de Chicago – Décentrement gauche / centré / droit
Le hyétogramme de Chicago permet de distribuer la pluie de projet dans le temps. Le paramètre r contrôle la position du pic :
'left': pic au début → écoulement rapide'centered': pic au centre → distribution symétrique'right': pic à la fin → montée progressive
[12]:
T = 25 # Période de retour : 25 ans
total_duration = 120 # Durée totale : 120 minutes
fig, axes = plt.subplots(1, 3, figsize=(18, 5), sharey=True, tight_layout=True)
for ax, mode in zip(axes, ['left', 'centered', 'right']):
x, y = montana.get_hyetogram_Chicago(total_duration, T, r=mode)
widths = np.concatenate((x[1:] - x[:-1], [total_duration - x[-1]]))
ax.bar(x, y, width=widths, align='edge', alpha=0.7, color='steelblue')
ax.set_title(f"Décentrement : {mode}")
ax.set_xlabel('Temps [min]')
if ax == axes[0]:
ax.set_ylabel('Intensité [mm/h]')
fig.suptitle(f'Hyétogramme de Chicago – T={T} ans, durée={total_duration} min', fontsize=14, y=1.02)
plt.show()
Hyétogramme de Chicago – Coefficient de décentrement variable r
La méthode get_hyetogram_Chicago_rvar permet un contrôle plus fin du décentrement via un coefficient r continu entre 0 et 1 :
\(r = 0\) : pic en fin de pluie
\(r = 0.5\) : pic au centre
\(r = 1\) : pic en début de pluie
On peut aussi ajuster le pas de temps et la durée du pic.
[13]:
T = 25
total_duration = 120 # minutes
timestep = 5 # minutes
peak_duration = 10 # minutes
r_values = [0, 0.25, 0.5, 0.75, 1.0]
fig, axes = plt.subplots(1, len(r_values), figsize=(20, 5), sharey=True, tight_layout=True)
for ax, r in zip(axes, r_values):
x, y = montana.get_hyetogram_Chicago_rvar(total_duration, T, r=r,
timestep=timestep,
peak_duration=peak_duration)
widths = np.concatenate((x[1:] - x[:-1], [total_duration - x[-1]]))
ax.bar(x, y, width=widths, align='edge', alpha=0.7, color='teal')
ax.set_title(f"r = {r}")
ax.set_xlabel('Temps [min]')
if ax == axes[0]:
ax.set_ylabel('Intensité [mm/h]')
fig.suptitle(f'Hyétogramme de Chicago (r variable) – T={T} ans, durée={total_duration} min',
fontsize=14, y=1.02)
plt.show()
Hyétogramme instantané
Le hyétogramme instantané utilise l’intensité instantanée de Montana (\((1-b) \cdot i_{moy}\)) et un pas de temps variable qui dépend du coefficient de décentrement r :
Pas de \((1-r)\) min avant le pic
Pas de \(r\) min après le pic
Cela assure une bonne résolution autour du pic de pluie.
[14]:
T = 25
durmax = 120 # minutes
r_values = [0.3, 0.5, 0.7]
fig, axes = plt.subplots(1, len(r_values), figsize=(18, 5), sharey=True, tight_layout=True)
for ax, r in zip(axes, r_values):
x, y = montana.get_hyetogram_instant(durmax, T, r=r)
widths = np.concatenate((x[1:] - x[:-1], [durmax - x[-1]]))
ax.bar(x, y, width=widths, align='edge', alpha=0.7, color='coral')
ax.set_title(f"r = {r}")
ax.set_xlabel('Temps [min]')
if ax == axes[0]:
ax.set_ylabel('Intensité [mm/h]')
fig.suptitle(f'Hyétogramme instantané – T={T} ans, durée max={durmax} min',
fontsize=14, y=1.02)
plt.show()
Comparaison des hyétogrammes pour différentes périodes de retour
Superposition des hyétogrammes de Chicago centrés pour plusieurs périodes de retour.
[15]:
total_duration = 120
return_periods = ['5', '10', '25', '50', '100']
fig, ax = plt.subplots(1, 1, figsize=(12, 6), tight_layout=True)
for T in return_periods:
x, y = montana.get_hyetogram_Chicago(total_duration, T, r='centered')
widths = np.concatenate((x[1:] - x[:-1], [total_duration - x[-1]]))
ax.bar(x, y, width=widths, align='edge', alpha=0.4, label=f'T = {T} ans')
ax.set_xlabel('Temps [min]')
ax.set_ylabel('Intensité [mm/h]')
ax.set_title(f'Hyétogrammes de Chicago centrés – {qdf.name} – durée={total_duration} min')
ax.legend()
plt.show()
Vérification de la quantité totale de pluie
On vérifie que le volume total de la pluie de projet (en mm) est cohérent avec la valeur donnée par la formule de Montana pour la durée totale.
[16]:
T = 25
total_duration = 120
for mode in ['left', 'centered', 'right']:
x, y = montana.get_hyetogram_Chicago(total_duration, T, r=mode)
# Calcul du volume : somme(intensité * pas_de_temps_en_heures)
widths = np.concatenate((x[1:] - x[:-1], [total_duration - x[-1]]))
volume = np.sum(y * widths / 60) # mm
print(f"Mode '{mode}' : volume = {volume:.2f} mm")
# Valeur Montana de référence
q_ref = montana.get_quantityrain(total_duration, T)
print(f"\nQuantité Montana (référence) : {q_ref:.2f} mm")
Mode 'left' : volume = 46.05 mm
Mode 'centered' : volume = 46.05 mm
Mode 'right' : volume = 46.05 mm
Quantité Montana (référence) : 46.05 mm
Utilisation des méthodes de tracé intégrées
Les classes fournissent aussi des méthodes plot_* prêtes à l’emploi.
[17]:
# Tracé via la méthode intégrée
montana.plot_hyetogram_Chicago(total_duration=120, T=25, r='centered')
[17]:
(<Figure size 1500x1000 with 1 Axes>,
<Axes: xlabel='Time [min]', ylabel='Intensity [mm/h]'>)
[18]:
# Hyétogrammes instantanés pour toutes les périodes de retour
montana.plot_hyetograms_instant(durmax=120, r=0.5)
[18]:
(<Figure size 1500x1000 with 1 Axes>,
<Axes: xlabel='Time [min]', ylabel='Intensity [mm/h]'>)
