Objectif de la fiche : utiliser un langage de programmation pour étudier la relation approchée entre la variation du vecteur vitesse 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, en l'appliquant ici à la « constante des aires » de Mercure.
Cette fiche est autonome : tu n'as besoin d'aucun autre document, elle reprend le script déjà construit en première (fiche « masse du Soleil »). 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).
Contexte : la loi des aires
- Le mouvement de Mercure autour du Soleil a déjà été étudié deux fois dans cette série : pour vérifier la loi de Kepler et peser le Soleil, puis pour retrouver sa masse à partir de la variation du vecteur vitesse. Cette fiche revient une troisième fois sur les mêmes données, pour illustrer une propriété différente : la constante des aires.
- D'après la deuxième loi de Kepler, le segment reliant une planète au Soleil balaie des aires égales en des durées égales, quelle que soit la position de la planète sur son orbite. Mercure va donc plus vite près du Soleil, et plus lentement loin de lui — de façon à toujours balayer la même aire par unité de temps.
- En coordonnées cartésiennes, cette aire balayée par unité de temps s'exprime par la grandeur
C = x·vy − y·vx(à un facteur 2 près) : si la loi des aires est vérifiée, cette expression doit rester constante tout au long de l'orbite, quelle que soit la position considérée.
Reprise : positions et vecteurs vitesse
- Ce script reprend exactement celui déjà construit en première : le modèle d'orbite circulaire pour Mercure, puis la construction de
vxletvylpar différences centrées. - Le script ci-dessous est déjà complet : copie-le tel quel dans Thonny (ou dans Basthon) pour commencer.
import numpy as np
import matplotlib.pyplot as plt
# Modèle d'orbite circulaire pour Mercure
r = 0.387
Torb = 87.969
t = 8 * np.arange(11)
theta = 2 * np.pi * t / Torb
x = r * np.cos(theta)
y = r * np.sin(theta)
# Vecteurs vitesse par différences centrées
vxl = []
m = np.arange(len(t) - 2)
for i in m :
vxl.append((x[i+2] - x[i]) / (t[i+2] - t[i]))
vyl = []
for i in m :
vyl.append((y[i+2] - y[i]) / (t[i+2] - t[i]))Passer aux unités SI
- Convertis les positions
xetyen mètres. Commevxletvylont 2 valeurs de moins quexety, retire d'abord le dernier élément avecx[:-1], puis le premier avec[1:]: les deux ensemble reviennent à ne garder que les positions intermédiaires, celles qui correspondent réellement aux vitesses calculées. - Convertis aussi
vxletvylen m/s (multiplie par1,5×10¹¹m/UA, divise par24×3600s/jour).
# TODO : positions en mètres, en retirant le dernier terme
dx = x[:__] * 1.5*10**11
dy = y[:__] * 1.5*10**11
# TODO : vitesses en m/s
vyln = 1.5*10**11 * np.array(___) / (24*3600)
vxln = 1.5*10**11 * np.array(___) / (24*3600)
# TODO : retire aussi le premier terme des distances, pour correspondre aux vitesses
dxn = dx[_:]
dyn = dy[_:]Indice
Après les deux découpages successifs ([:-1] puis [1:]), dxn et dyn ne contiennent plus ni le tout premier ni le tout dernier point de l'orbite : exactement la même plage que vxl et vyl.
Calculer la constante des aires
- Calcule
Cs = dxn·vyln − dyn·vxlnpour tous les points de mesure, puis traceCsen fonction du numéro de pointn = np.arange(len(t)-2), en points bleus avec la légende'constante des aires'.
# TODO : la constante des aires, pour chaque point de mesure
Cs = (___*_____ - ___*_____)
n = np.arange(len(t) - _)
plt.plot(_, __, '__', label='__________________')
plt.grid()
plt.xlabel('______________')
plt.ylabel('___________')Un nuage de 9 points, tous à peu près à la même hauteur (autour de 2,5×10¹⁵), quel que soit le point de l'orbite considéré : c'est exactement ce que prédit la loi des aires.
Modéliser par une constante
- Comme dans les fiches précédentes, modélise
Cspar une constante avecnp.polyfit(n, Cs, 0), affiche la valeur trouvée avec"%.1e"%..., puis superpose cette droite horizontale au nuage de points. - Utilise
plt.ylim(0, 3*10**15)pour bien situer le nuage de points sur le graphe.
# TODO : modélise Cs par une constante
mod = np.polyfit(_, __, _)
Cmods = float(mod[_])
print('la constante des aires est de l ordre de', "%.1e"%Cmods)
# TODO : droite horizontale du modèle
Cmodgs = 0*n + mod[_]
plt.plot(n, Cmodgs, '__', label="_______")
plt.ylim(0, 3*10**15)
plt.legend()
plt.show()La console affiche une constante des aires de l'ordre de 2,5×10¹⁵ m²/s. Sur le graphe, la droite rouge du modèle passe quasiment au milieu de tous les points bleus, à l'exception de deux ou trois qui s'en écartent légèrement — un écart attribuable aux approximations de la méthode des différences centrées, pas à une remise en cause de la loi elle-même.
Conclusion
- La quasi-constance de
Cillustre numériquement la loi des aires de Kepler, conséquence directe du caractère central de la force gravitationnelle exercée par le Soleil sur Mercure : une force toujours dirigée vers un même point ne peut pas faire varier l'aire balayée par unité de temps. - Cette propriété n'est pas propre à Mercure ni même à la gravitation : elle se généralise à tout mouvement soumis à une force centrale, et correspond à la conservation d'une grandeur physique fondamentale, le moment cinétique.
Pense-bête — la constante des aires
| x[:-1] | retire le dernier élément |
| x[1:] | retire le premier élément |
| C = x·vy − y·vx | double de l'aire balayée par unité de temps |
| C constante | signature d'une force centrale |
| loi des aires | 2e loi de Kepler |
| np.polyfit(x,y,0) | modélise par une constante (une moyenne) |
Pas de Thonny sous la main ? Utilise Basthon
Ouvrir dans un nouvel onglet ↗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.