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

Peser le Soleil
avec la loi de Kepler.

Les huit planètes du Système solaire suivent toutes la même règle : le carré de leur période de révolution est proportionnel au cube du demi-grand axe de leur orbite. Ce projet te propose de vérifier cette règle avec Python, d'en déduire la masse du Soleil, puis de réutiliser la même méthode pour peser un astéroïde à l'aide de son satellite.

kepler.py — aperçut = 0.00 s

Objectif de la fiche : tester la validité de la troisième loi de Kepler à partir des données du Système solaire, en déduire la masse du Soleil, puis appliquer le même raisonnement pour déterminer la masse de l'astéroïde Eugénie à partir du mouvement de son satellite.

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 Système solaire

À savoir
  • Le tableau ci-dessous, issu du site de l'Observatoire de Paris, donne pour les huit planètes le demi-grand axe a de leur orbite (en unités astronomiques, UA) et leur période de révolution T (en années).
  • 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 deux np.array.
  • Le script ci-dessous est déjà complet : copie-le tel quel dans Thonny (ou dans Basthon) pour commencer.

La 3e loi de Kepler appliquée au Système solaire

planète MercureVénusTerreMarsJupiterSaturneUranusNeptune
a (UA) 0,38710,72331,00001,52375,20269,554719,21830,109
T (an) 0,24080,61521,00001,880811,86229,45784,020164,77

La troisième loi de Kepler affirme que le rapport a³/T² devrait être à peu près constant pour toutes les planètes tournant autour du même astre : c'est ce que tu vas vérifier.

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

# Demi-grand axe (UA) : Mercure, Vénus, Terre, Mars, Jupiter, Saturne, Uranus, Neptune
at = np.array([0.3871, 0.7233, 1.0000, 1.5237, 5.2026, 9.5547, 19.218, 30.109])

# Période de révolution (année)
tt = np.array([0.2408, 0.6152, 1.0000, 1.8808, 11.862, 29.457, 84.020, 164.77])
01

Vérifier la loi de Kepler

Consigne
  • Calcule a3, le cube de at (at**3), et t2, le carré de tt (tt**2).
  • Trace a3 en fonction de t2, en croix rouges ('rx'), avec une grille.
etape1_verification.py
# TODO : cube de a et carré de T
a3 = (__)**_
t2 = (__)**_
plt.grid()
plt.plot(__, __, '__')
plt.show()
Résultat attendu

Un graphe où sept des huit points sont écrasés près de l'origine, en bas à gauche : l'orbite de Neptune, bien plus grande que les autres, écrase l'échelle et empêche d'apprécier la validité de la loi pour les planètes proches du Soleil. C'est l'occasion de réfléchir aux échelles de représentation.

02

Zoomer sur les planètes proches

Consigne
  • Le slicing at[:4] garde uniquement les 4 premiers éléments d'un tableau : les 4 planètes les plus proches du Soleil (Mercure, Vénus, Terre, Mars).
  • Crée att et ttt, restreints à ces 4 planètes, puis recalcule a3 et t2 à partir de ces nouveaux tableaux et retrace le graphe.
etape2_zoom.py
# TODO : ne garde que les 4 premières planètes
att = at[:__]
ttt = tt[:__]
a3 = (att)**3
t2 = (ttt)**2
plt.grid()
plt.plot(t2, a3, '__')
plt.show()
Résultat attendu

Cette fois, les 4 points s'alignent bien sur une droite passant par l'origine : la loi de Kepler semble vérifiée. Comme les données sont exprimées en UA et en années, la pente de cette droite vaut ici environ 1 — un résultat propre à ces unités particulières, pas une propriété physique générale.

03

Passer aux unités internationales

Consigne
  • Pour que la pente de la droite ait un sens physique exploitable, il faut travailler en unités du Système International : le mètre pour les distances, la seconde pour les durées.
  • 1 UA ≈ 1.5*10**11 m. 1 année ≈ 365*24*3600 s.
  • Reprends toutes les planètes (pas seulement les 4 premières) : convertis at en mètres (ar) et tt en secondes (tr), recalcule a3 et t2, puis modélise le nuage de points par une droite grâce à np.polyfit(t2, a3, 1) — le degré 1 signifie qu'on cherche une droite, pas une courbe.
etape3_unites_si.py
# TODO : conversion en unités SI (mètres et secondes)
ar = at * (___*10**__)
tr = tt * (___*24*3600)

a3 = (ar)**3
t2 = (tr)**2
plt.grid()
plt.plot(t2, a3, '__')
plt.show()

# TODO : modélise le nuage de points par une droite (degré 1)
mod = np.polyfit(__, __, _)
print('mod :', mod)
Indice

mod contient 2 valeurs pour une droite a3 = mod[0]*t2 + mod[1] : mod[0] est le coefficient directeur (la pente), c'est lui qui va nous intéresser à l'étape suivante. mod[1] devrait être proche de 0, puisque la droite passe par l'origine.

Résultat attendu

Les 8 planètes s'alignent maintenant sur une droite, avec une pente mod[0] de l'ordre de 3,4 × 10¹⁸ (en m³/s²) : bien loin de 1, car on n'est plus en UA et en années.

04

En déduire la masse du Soleil

Consigne
  • La troisième loi de Kepler s'écrit T² = (4π² / (G·M)) × a³, où G = 6,67×10⁻¹¹ N·m²·kg⁻² est la constante de gravitation et M la masse de l'astre central (ici, le Soleil).
  • En traçant a³ en fonction de T², la pente mod[0] que tu viens d'obtenir vaut donc G×M / (4π²). On en déduit M = mod[0] × 4π² / G.
  • En Python, π s'obtient avec np.pi.
etape4_masse_soleil.py
G = 6.67e-11

# TODO : masse du Soleil déduite de la pente de la droite
Msoleil = mod[_] * 4 * np.pi**_ / _
print('Masse du Soleil (kg) :', Msoleil)
Résultat attendu

Une masse de l'ordre de 2 × 10³⁰ kg, très proche de la valeur tabulée de la masse du Soleil (1,989 × 10³⁰ kg) : la méthode fonctionne.

05

Peser l'astéroïde Eugénie

Consigne
  • L'astéroïde Eugénie possède un petit satellite naturel, observé par optique adaptative : sa période de révolution est de 4,7 jours et le demi-grand axe de son orbite vaut 1190 km.
  • Un seul couple (a, T) suffit ici : convertis-les en unités SI (mètres et secondes), puis applique directement la formule M = 4π²a³ / (G T²) — c'est la même relation qu'à l'étape précédente, réarrangée pour calculer une masse à partir d'un seul point de mesure plutôt que d'une pente.
etape5_masse_eugenie.py
# TODO : conversion en unités SI
a_sat = 1190 * ____
T_sat = 4.7 * 24 * ____

# TODO : masse de l'astéroïde, à partir de la même relation de Kepler
Meugenie = 4 * np.pi**2 * a_sat**_ / (G * T_sat**_)
print("Masse d'Eugénie (kg) :", Meugenie)
Indice

1 km = 1000 m. 1 jour = 24*3600 s. La formule est symétrique en a_sat au cube et T_sat au carré, exactement comme a3 et t2 aux étapes précédentes.

Résultat attendu

Une masse de l'ordre de 6 × 10¹⁸ kg pour l'astéroïde Eugénie — plus de 10 ordres de grandeur inférieure à celle du Soleil, ce qui donne une idée de l'immense différence de masse entre une étoile et un astéroïde.

Pense-bête — la 3e loi de Kepler

T² = 4π²a³/(GM)relation entre période, orbite et masse centrale
pente de a³=f(T²)vaut GM/4π²
np.polyfit(x,y,1)modélise un nuage de points par une droite
1 UA≈ 1,5×10¹¹ m
1 année≈ 365×24×3600 s
G6,67×10⁻¹¹ N·m²·kg⁻²

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.