Trajectoire parabolique et PFD en Python

Objectif de la fiche : utiliser un langage de programmation pour étudier la relation approchée entre l'accélération d'un système modélisé par un point matériel entre deux instants voisins et la somme des forces appliquées sur celui-ci — le principe fondamental de la dynamique.

Cette fiche reprend l'essentiel de la fiche n°3 de première, avec les mêmes données de pointage vidéo. Elle est autonome : tu n'as besoin d'aucun autre document. 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).

Les données du pointage

À savoir

Un logiciel de pointage vidéo a permis de relever les coordonnées (x, y) d'une balle de golf en vol, image par image, sur une chronophotographie.
L'intervalle de temps entre deux images est constant : 0,10 s. Le tableau des instants n'a donc pas besoin d'être saisi à la main : il se déduit directement du nombre de points pointés, avec 0.1*np.arange(len(x)).
Le script ci-dessous est déjà complet : copie-le tel quel dans Thonny (ou dans Basthon) pour commencer.

etape0_donnees.py

import numpy as np
import matplotlib.pyplot as plt

# Coordonnées pointées de la balle de golf (m)
x = np.array([0.01, 0.41, 0.91, 1.39, 1.86, 2.33, 2.81, 3.33, 3.79, 4.31, 4.83, 5.36, 5.86, 6.34, 6.77])
y = np.array([0.01, 0.52, 1.01, 1.42, 1.77, 2.02, 2.16, 2.19, 2.13, 1.96, 1.71, 1.38, 0.97, 0.50, 0])

# Instants associés, générés automatiquement (0,10 s entre deux images)
t = 0.1 * np.arange(len(x))

Visualiser la trajectoire

Consigne

Trace y en fonction de x, avec des points bleus reliés par une ligne ('bo-').
Ajoute les étiquettes "xreelle" / "yreelle" et une grille.

etape1_trajectoire.py

# TODO : trace y en fonction de x, points bleus reliés
plt.plot(__, __, '____')
plt.xlabel("________")
plt.ylabel("________")
plt.grid()
plt.show()

Résultat attendu

Une arche régulière : la balle monte, atteint un sommet vers x ≈ 3,3 m, y ≈ 2,19 m, puis redescend jusqu'à toucher le sol vers x ≈ 6,8 m — la silhouette caractéristique d'une trajectoire parabolique.

Construire les vecteurs vitesse

Consigne

La vitesse horizontale au point i s'estime par différence centrée : vx = (x[i+2] - x[i]) / (t[i+2] - t[i]). Cette formule utilise le point avant et le point après le point i+1, ce qui donne une estimation plus précise qu'une différence simple.
Comme le calcul utilise x[i+2], il est impossible de l'appliquer aux deux derniers points de la liste : la boucle doit donc parcourir m = np.arange(len(t)-2), et non len(t) directement.
Crée deux listes vides vxl et vyl, puis remplis-les avec une boucle for, comme dans les fiches précédentes.

etape2_vitesse.py

vxl = []
m = np.arange(len(t) - _)
for i in m :
    vx = (x[i+_] - x[_]) / (t[i+_] - t[_])
    vxl.append(__)

vyl = []
m = np.arange(len(t) - _)
for i in m :
    vy = (y[i+_] - y[_]) / (t[i+_] - t[_])
    vyl.append(__)

Indice

Ici, l'intervalle de temps entre t[i] et t[i+2] vaut toujours 0,2 s (deux pas de 0,1 s) : la division par (t[i+2]-t[i]) reste donc valable même si, dans d'autres contextes, les instants ne sont pas régulièrement espacés.

Résultat attendu

vxl et vyl contiennent chacune 13 valeurs (15 points de départ, moins 2). vxl[i] correspond en réalité à la vitesse horizontale au point i+1 — un décalage d'indice dont il faudra se souvenir pour la suite.

Construire les vecteurs accélération

Consigne

Exactement la même démarche permet de calculer la variation de vitesse par unité de temps (l'accélération), mais cette fois à partir des listes vxl et vyl plutôt que x et y.
Comme vxl et vyl ont déjà 2 valeurs de moins que x et y, et que le calcul utilise encore un décalage de 2, la boucle doit cette fois parcourir m = np.arange(len(t)-4).

etape3_acceleration.py

axl = []
m = np.arange(len(t) - _)
for i in m :
    ax = (vxl[i+_] - vxl[_]) / (t[i+_] - t[_])
    axl.append(__)

ayl = []
m = np.arange(len(t) - _)
for i in m :
    ay = (vyl[i+_] - vyl[_]) / (t[i+_] - t[_])
    ayl.append(__)

Indice

Le décalage s'accumule : axl[i] correspond à l'accélération horizontale au point i+2 de la trajectoire d'origine (un décalage de 1 par rapport à vxl, qui était lui-même décalé de 1 par rapport à x).

Résultat attendu

axl et ayl contiennent chacune 11 valeurs. C'est ayl, l'accélération verticale, qui va nous intéresser pour la suite : c'est elle qui devrait se rapprocher de -9,8 m·s⁻², la valeur du champ de pesanteur.

Représenter les vecteurs accélération

Consigne

Pour chaque point où l'accélération a pu être calculée, trace deux flèches avec plt.arrow, toutes deux partant de (x[i+2], y[i+2]) — le décalage d'indice repéré à l'étape précédente : la boucle doit donc démarrer à 1 avec m = np.arange(1, len(t)-4), pour rester valide.
La première flèche représente l'accélération réellement mesurée : plt.arrow(x[i+2], y[i+2], 0.1*axl[i], 0.1*ayl[i], head_width=0.1). Le facteur 0.1 est purement esthétique, pour que les flèches restent lisibles sur le graphe.
La seconde flèche, en rouge (fc='r', ec='r'), sert de référence : elle est purement verticale, de norme 0.1*9.8 — le champ de pesanteur tabulé, à la même échelle.
Superpose ces flèches à la trajectoire (reprends le tracé de l'étape 1), avec plt.xlim(0,7), plt.ylim(0,3) et le titre "Comparaison entre accélération et champ de pesanteur".

etape4_vecteurs.py

m = np.arange(1, len(t) - _)
for i in m :
    plt.arrow(x[i+_], y[i+_], 0.1*axl[_], 0.1*ayl[_], head_width=0.1)
    plt.arrow(x[i+_], y[i+_], 0*axl[i], 0.1*(0*axl[i]-___), fc='_', ec='_', head_width=0.1)

plt.xlim(_, _)
plt.ylim(_, _)
plt.grid()
plt.plot(x, y, '____')
plt.xlabel("________")
plt.ylabel("________")
plt.title("_______________________________________________")
plt.show()

Résultat attendu

Le long de la parabole, deux jeux de flèches quasiment superposés : les flèches noires (accélération mesurée) pointent presque toutes verticalement vers le bas, avec une longueur très proche de celle des flèches rouges (référence à 9,8 m·s⁻²). Conclusion visuelle : les variations du vecteur vitesse sont, pour l'essentiel, verticales et dirigées vers le bas.

Comparaison quantitative à g

Consigne

Pour aller au-delà de la comparaison visuelle, trace ayl (l'accélération verticale réelle) en fonction du numéro de point, sur un graphe dédié.
Superpose deux droites horizontales : l'une d'ordonnée constante -9,8 (le champ de pesanteur théorique), l'autre d'ordonnée égale à la moyenne des valeurs de ayl.
Cette moyenne s'obtient élégamment avec np.polyfit(m, ayl, 0) : un polynôme de degré 0 (une constante) qui « modélise au mieux » un nuage de points n'est autre que leur moyenne.

etape5_comparaison.py

m = np.arange(0, len(t) - _)
ath = 0*m - ___

# TODO : modélise ayl par une constante (polynôme de degré 0)
mod = np.polyfit(_, ___, _)
moda = 0*m + mod[_]

plt.plot(m, ayl, '____', label="______")
plt.grid()
plt.ylim(-20, 0)
plt.plot(m, ath, '__', label="_")
plt.plot(m, moda, '__', label="______")
plt.xlabel("__________________")
plt.ylabel("________________________")
plt.title("_______________________________________________")
plt.show()

print(round(mod[_], 1))

Indice

np.polyfit(m, ayl, 0) renvoie un tableau avec une seule valeur, mod[0] : c'est cette valeur — la moyenne — qu'il faut réutiliser pour construire la droite moda et pour l'afficher à la fin.

Résultat attendu

La console affiche -8.5 : la moyenne des accélérations verticales mesurées vaut environ -8,5 m·s⁻², proche de la valeur théorique -9,8 m·s⁻² sans lui être rigoureusement égale.

Analyse critique

Regarde bien le graphe obtenu : les points ne sont-ils pas plutôt en dessous de la moyenne au centre de la trajectoire, et au-dessus vers les extrémités ? Si les écarts entre les points mesurés et la moyenne suivaient une tendance plutôt qu'une répartition aléatoire, ce serait le signe que le modèle (une accélération verticale constante, seule action du poids) ne capture pas tout ce qui se passe réellement — par exemple une résistance de l'air, qui dépendrait de la vitesse de la balle et varierait donc le long de la trajectoire.
Une analyse plus poussée (test statistique sur les résidus, comme dans la fiche sur la cinétique chimique) permettrait de trancher plus rigoureusement. Ce n'est pas l'objectif premier de cette fiche, mais garde ce réflexe critique : un modèle qui « colle à peu près » aux mesures ne veut pas toujours dire qu'il est le bon.

Pense-bête — différences centrées et décalages d'indices

(x[i+2]-x[i])/(t[i+2]-t[i])	différence centrée : plus précise qu'une différence simple
vxl[i]	correspond en réalité au point i+1
axl[i]	correspond en réalité au point i+2

np.polyfit(x,y,0)	modélise par une constante = la moyenne
0.1 *	facteur d'échelle pour la lisibilité des vecteurs
g ≈ 9,8 m·s⁻²	champ de pesanteur terrestre

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.