Physique-chimie · 2de · Pour aller plus loin n°1

Le décollage
d'Ariane 5.

Change d'échelle : après la chute d'une bille, place à un vrai décollage de fusée, avec des données issues d'un sujet de baccalauréat. Tu vas retrouver les mêmes outils Python que dans les fiches précédentes — tableaux, tracés, boucles — mais appliqués à un phénomène qui dure plusieurs secondes et parcourt des dizaines de mètres.

decollage.py — aperçut = 0.00 s

Objectif de la fiche : exploiter un tableau de positions successives d'une fusée (Ariane 5) pour en tracer la position puis la vitesse en fonction du temps, à l'aide du langage Python.

Cette fiche est autonome : tu n'as besoin d'aucun autre document, les données sont recopiées directement dans le script (pas besoin de fichier tableur). Chaque étape contient un script incomplet à compléter, puis à copier-coller dans Thonny (ou dans la console Basthon tout en bas de la page si tu n'as pas Thonny sous la main).

00

Les données du décollage

À savoir
  • Le tableau ci-dessous est extrait d'un sujet de baccalauréat 2012 : il donne la position corrigée d'un point situé au bas de la fusée Ariane 5, toutes les 0,2 seconde après le décollage.
  • Dans un contexte professionnel, ces données viendraient souvent d'un fichier tableur (.xlsx), chargé en Python avec le module openpyxl. Ici, pour rester autonome sans avoir besoin d'un fichier séparé, on les recopie directement dans un np.array — une méthode tout aussi valable, mentionnée explicitement dans le document source.
  • Le script ci-dessous est déjà complet : copie-le tel quel dans Thonny (ou dans Basthon) pour commencer.

Tableau des positions

Le temps est exprimé en secondes, la position en mètres.

t (s) 00,20,40,60,811,21,41,61,822,22,42,6
z (m) 00,06−0,040,06−0,040,121,011,963,354,626,398,4710,6912,97
t (s) 2,833,23,43,63,844,24,44,64,855,25,4
z (m) 16,1319,4223,0926,7630,9335,2439,9244,8549,8555,4261,367,574,3381,48

Remarque : les toutes premières valeurs de z oscillent autour de 0 (bruit de mesure au moment du décollage), avant que la fusée ne prenne franchement de l'altitude.

etape0_donnees.py
import numpy as np
import matplotlib.pyplot as plt

# Temps écoulé depuis le décollage (s)
t = np.array([0, 0.2, 0.4, 0.6, 0.8, 1, 1.2, 1.4, 1.6, 1.8, 2, 2.2, 2.4, 2.6, 2.8, 3,
        3.2, 3.4, 3.6, 3.8, 4, 4.2, 4.4, 4.6, 4.8, 5, 5.2, 5.4])

# Position du bas de la fusée (m)
z = np.array([0, 0.06, -0.04, 0.06, -0.04, 0.12, 1.01, 1.96, 3.35, 4.62, 6.39, 8.47,
        10.69, 12.97, 16.13, 19.42, 23.09, 26.76, 30.93, 35.24, 39.92, 44.85, 49.85,
        55.42, 61.3, 67.5, 74.33, 81.48])

print('nombre de valeurs :', len(t), len(z))
Résultat attendu

La console affiche nombre de valeurs : 28 28 — les deux tableaux t et z ont bien la même longueur, condition indispensable pour tout tracé avec plt.plot.

01

Tracer la position en fonction du temps

Consigne
  • Trace z en fonction de t, avec des points bleus (indice 'bo').
  • Ajoute les étiquettes des axes ("temps (s)" / "position (m)") et une grille.
etape1_position.py
# TODO : trace z en fonction de t, en points bleus
plt.plot(____, ____, '__')
plt.xlabel("____")
plt.ylabel("____")
plt.grid()
plt.show()
Résultat attendu

Une courbe quasiment plate et bruitée pendant la première seconde (la fusée est encore proche du sol), puis une montée de plus en plus rapide : la signature d'une accélération croissante, typique d'un décollage.

02

En déduire la vitesse avec np.diff

Consigne
  • La fonction np.diff(z) calcule directement la différence entre chaque valeur et la précédente : z[1]-z[0], z[2]-z[1], etc. C'est une autre façon d'obtenir les déplacements successifs, sans écrire de boucle for toi-même.
  • Comme l'intervalle de temps est constant (0,2 s entre deux mesures), divise ce résultat par 0.2 pour obtenir une véritable vitesse en m/s.
  • np.diff renvoie un tableau avec un élément de moins que le tableau de départ (27 valeurs à partir de 28) : il faut donc aussi redimensionner t en lui retirant son dernier élément, avec t[:27], avant de tracer.
  • Trace la vitesse obtenue en fonction de t0, en croix rouges ('rx').
etape2_vitesse.py
# TODO : différences successives de z, converties en vitesse (Δt = 0,2 s)
vz = np.diff(__) / ___

# TODO : réduis t d'une valeur pour qu'il ait la même longueur que vz
t0 = t[:__]

# TODO : trace la vitesse en fonction de t0, en croix rouges
plt.plot(____, ____, '__')
plt.xlabel("____")
plt.ylabel("____")
plt.grid()
plt.show()
Indice

t contient 28 valeurs, vz en contient 27 : t[:27] garde les 27 premières valeurs de t, associées aux 27 vitesses calculées entre chaque paire de points consécutifs.

Résultat attendu

Un nuage de croix rouges globalement croissant : la vitesse de la fusée augmente au cours du temps, de plus en plus vite vers la fin — cohérent avec une accélération qui s'intensifie à mesure que le carburant est consommé.

＋

Pour aller encore plus loin

Piste de réflexion
  • À partir des deux graphes obtenus (position et vitesse), il est possible d'estimer l'accélération de la fusée (en réappliquant la même méthode de différences successives, cette fois à vz).
  • Connaissant la masse d'Ariane 5 au décollage, la seconde loi de Newton permet ensuite d'estimer la somme des forces qui s'exercent sur la fusée, et donc la force de réaction des moteurs au moment du décollage.
  • Ce travail peut se comparer à des estimations obtenues directement à partir de photographies du décollage : une belle occasion de mener un petit projet personnel, à la maison ou en classe.

Pas de Thonny sous la main ? Utilise Basthon

Ouvrir dans un nouvel onglet ↗
Basthon est une console Python qui tourne directement dans le navigateur, sans rien installer. Colle ici (avec Ctrl+V ou Cmd+V) le code copié avec les boutons « Copier le code » ci-dessus, puis appuie sur Entrée pour l'exécuter.