Cas d'utilisation : traçage de profils verticaux sur demande pour n'importe quel lieu¶

# Tracer un diagramme Skew-T Log-P à l'aide de la librairie Metpy.

# Cette commande empêche matplotlib de montrer le graphique où il veut,
# nous utiliserons une autre commande plus tard pour le montrer tel qu'on le souhaite.
plt.ioff()

# On commence par créer le graphique et on y ajoute les tracés.
fig = plt.figure(figsize=(10, 8), tight_layout=True)
skew = SkewT(fig, rotation=45)
skew.plot(p[:len(t)], t, 'r', label='Température')
skew.plot(p[:len(td)], td, 'g', label='Point de rosée')
skew.plot_barbs(p[:len(ws)], u, v)
skew.ax.set_ylim(1050, 100)
skew.ax.set_xlim(-40, 60)
skew.ax.xaxis.set_label_text('Température (°C)')
skew.ax.yaxis.set_label_text('Pression (hPa|mbar)')

# Ajouter un axe secondaire qui convertit automatiquement entre la pression et la 
# hauteur en supposant une atmosphère standard. La valeur de -0,12 place l'axe
# secondaire 0,12 coordonnées normalisées (0 à 1) à gauche de l'axe original.
secax = skew.ax.secondary_yaxis(
    -0.12,
    functions=(
        lambda p: mpcalc.pressure_to_height_std(units.Quantity(p, 'hPa')).m_as('km'),
        lambda h: mpcalc.height_to_pressure_std(units.Quantity(h, 'km')).m
    )
)
# Afficher les marques 0, 1, 3, 6, 9, 12, 15 km.
secax.yaxis.set_major_locator(plt.FixedLocator([0, 1, 3, 6, 9, 12, 15]))
secax.yaxis.set_minor_locator(plt.NullLocator())
secax.yaxis.set_major_formatter(plt.ScalarFormatter())
secax.set_ylabel('Hauteur (km)')

# Calculer le profil de la parcelle complet et l'ajouter au tracé sous forme de ligne noire.
prof = mpcalc.parcel_profile(p, t[0], td[0]).to('degC')
skew.plot(p, prof, 'k', linewidth=2, label='Profil de la parcelle*')

# Remplir les zones de CAPE et CIN.
skew.shade_cin(p, t, prof, td, label='CIN*')
skew.shade_cape(p, t, prof, label='CAPE*')

# Ligne oblique à l'isotherme 0.
skew.ax.axvline(0, color='c', linestyle='--', linewidth=2)

# Ajouter les lignes spéciales appropriées.
wet_bulb = mpcalc.wet_bulb_temperature(p, t, td)
skew.plot(p, wet_bulb, 'b', linewidth=1, label='Thermomètre mouillé*')
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()

# Ajouter un titre avec toutes les données utilisées pour le tracé.
skew.ax.title.set_text(f'Radiosondage {model} pour (' +
                       f'{str(lat) + DEG_SYMBOL + "N" if lat >= 0 else str(lat*-1) + DEG_SYMBOL + "S"}, ' +
                       f'{str(lon) + DEG_SYMBOL + "E" if lon >= 0 else str(lon*-1) + DEG_SYMBOL + "O"}) ' + '\n' +
                       f'Passe du modèle: {model_run} ' + '\n' +
                       f'Heure de prévision: {forecast_hour[0:5]}{datetime.datetime.strptime(forecast_hour[5:], "%Y-%m-%dT%H:%M:%SZ")}'
                       )
skew.ax.legend()

# Utiliser plt.show() ou plt.savefig('nom.png') en dehors d'un Jupyter Notebook.
display(fig)

# Tracer un Hodographe à l'aide de la librairie Metpy.

fig = plt.figure(figsize=(7, 7), tight_layout=True)
ax = fig.add_subplot(1, 1, 1)

# Valeurs du niveau de pression à afficher sur l'hodographe si elles
# sont présentes. Vous pouvez en ajouter ou en supprimer à votre guise.
boundaries_default = [950, 850, 700, 500, 300, 250]

# Toujours afficher le premier niveau de pression.
boundaries_p = [p[0].magnitude]

# Afficher également tous ceux de la liste ci-dessus, mais seulement s'ils sont plus hauts que
# le premier niveau de pression et sont au moins 50mbar au-dessus du premier niveau de pression.
# Par exemple, si le premier niveau de pression est à 855mbar, ne pas afficher 950 ni 850.
boundaries_p.extend([bd for bd in boundaries_default if ((boundaries_p[0]-bd)>=50 and bd>=p[-1].magnitude)])
boundaries_p *= units.hPa
u_pts, v_pts = mpinterpolate.interpolate_1d(boundaries_p, p, u, v)
boundaries_p[0] = round(boundaries_p[0])

# Ajouter les points sur l'hodographe pour les niveaux de pression choisis.
ax.scatter(u_pts, v_pts, c="black", zorder=10)
texts = []
for up, vp, z in zip(u_pts, v_pts, boundaries_p):
    z_str = int(z.magnitude)
    texts.append(ax.text(up, vp, z_str, ha='center', fontsize=10,
                    path_effects=[mpatheffects.withStroke(foreground='white', linewidth=2)],
                    zorder=12)
                )

# Échelle de l'hodographe en fonction de la valeur du vent la plus élevée.
max_range = math.ceil(max(ws).magnitude) + 1
h = Hodograph(ax, component_range=max_range)

if max_range < 50:
    inc = math.ceil(max_range / 10)
else:
    inc = 5 * math.ceil(max_range / 100)

# Ajouter des axes au centre du graphique.
ax.spines['left'].set_position('zero')
ax.spines['bottom'].set_position('zero')
ax.patch.set_edgecolor('black')
ax.patch.set_linewidth(0.5)

# Ajouter une couleur qui change en fonction des niveaux de pression.
h.plot_colormapped(u, v, p)

# Redimensionner l'hodographe pour zoomer là où se trouvent les valeurs.
# Commentez h.ax.autoscale() si vous voulez l'hodographe entier à la place.
h.ax.autoscale()
bottom, top = h.ax.get_ylim()
left, right = h.ax.get_xlim()

# Ajouter les lignes de la grille pour les vitesses de vent.
h.add_grid(increment=inc)

# S'assurer que les axes restent à l'intérieur du graphique si les vents sont tous très éloignés dans une direction.
if left > 0:
    left = -1
if bottom > 0:
    bottom = -1
if right < 0:
    right = 1
if top < 0:
    top = 1

# Redimensionner l'hodographe pour zoomer sur le graphique,
# mais n'afficher que les valeurs d'axe sur l'axe le plus long
# et ajouter un petit tampon pour s'assurer que l'ensemble du
# tracé reste toujours visible.
norm_bottom = abs(bottom)
norm_left = abs(left)
whole, remainder = divmod(max_range, inc)
highest = max(norm_bottom, top, norm_left, right)
if highest in (norm_bottom, top):
    if highest == norm_bottom:
        norm_bottom = (whole + math.ceil(remainder/inc)) * inc
    else:
        top = (whole + math.ceil(remainder/inc)) * inc
    ax.set_ylim(bottom=-norm_bottom, top=top)
    ax.set_xlim(left=-norm_left, right=right)
    
    ax.yaxis.set_major_locator(mticker.MultipleLocator(inc))
    ticks_loc_y = ax.get_yticks().tolist()
    ax.yaxis.set_major_locator(mticker.FixedLocator(ticks_loc_y))
    ax.set_yticklabels([f'{abs(int(y))}' for y in ticks_loc_y])
    ax.set_xticks([])
else:
    if highest == norm_left:
        norm_left = (whole + math.ceil(remainder/inc)) * inc
    else:
        right = (whole + math.ceil(remainder/inc)) * inc
    ax.set_ylim(bottom=-norm_bottom, top=top)
    ax.set_xlim(left=-norm_left, right=right)
    
    ax.xaxis.set_major_locator(mticker.MultipleLocator(inc))
    ticks_loc_x = ax.get_xticks().tolist()
    ax.xaxis.set_major_locator(mticker.FixedLocator(ticks_loc_x))
    ax.set_xticklabels([f'{abs(int(x))}' for x in ticks_loc_x])
    ax.set_yticks([])

# Supprimer les étiquettes car les axes sont au milieu du graphique.
ax.set_xlabel('')
ax.set_ylabel('')

h.ax.title.set_text('Hodographe, Vitesse du vent en noeuds, Hauteur en hPa')

# Veiller à ce que le texte des points dans l'hodographe ne se chevauchent pas.
adjust_text(texts, arrowprops=dict(arrowstyle='->', color='r', lw=0.5), expand_text=(1.8, 1.8))

# Utiliser plt.show() ou plt.savefig('nom.png') en dehors d'un Jupyter Notebook.
display(fig)

# Traçage du tableau des indices de convection.

fig = plt.figure(figsize=(12, 2), tight_layout=True)
table_ax = fig.add_subplot(1, 1, 1)
table_ax.axis('tight')
table_ax.axis('off')

# Nom des colonnes et des lignes du tableau.
col_names = ['CAPE', 'CIN', 'LCL', 'LI', 'LFC', 'EL']
row_names = ['SFC', 'ML', 'MU', 'Unités']
tab = table_ax.table(cellText=conv_indices, colLabels=col_names, rowLabels=row_names, loc='center', cellLoc='center')

# Modifier la taille et l'échelle de la police du tableau pour améliorer la lisibilité.
tab.auto_set_font_size(False)
tab.set_fontsize(12)
tab.scale(1.5, 1.5)

# Remplir le tableau.
for (row, col), cell in tab.get_celld().items():
    # Mettre les titres des lignes et des colonnes en gras.
    if (row == 0) or (col == -1):
        cell.set_text_props(fontproperties=FontProperties(size=12, weight='bold'))

# Utiliser plt.show() ou plt.savefig('nom.png') en dehors d'un Jupyter Notebook.
display(fig)