Simulation gravitationnelle | Python | Astronomie | Physique | Modélisation informatique

Introduction

Dans ce projet, nous allons développer une simulation gravitationnelle en utilisant Python, mettant en évidence l'interaction entre la Terre et un "Super Jupiter" hypothétique, une planète ayant 500 fois la masse de Jupiter. Cette simulation vise à démontrer l'impact d'un tel corps massif sur le mouvement de la Terre, en considérant les immenses forces gravitationnelles en jeu. Ce projet convient aux étudiants et aux amateurs passionnés par la physique, l'astronomie et les simulations informatiques. Pour y parvenir, nous utiliserons des bibliothèques Python telles que NumPy pour les calculs numériques et Matplotlib pour visualiser les mouvements dynamiques des planètes.

👀 Aperçu

🎯 Tâches

Dans ce projet, vous allez apprendre :

Comment comprendre et appliquer la Loi de la Gravitation Universelle de Newton pour modéliser l'interaction entre les corps célestes.
Comment utiliser la programmation Python pour créer un modèle informatique d'un système gravitationnel.
Comment employer la bibliothèque NumPy pour effectuer des calculs numériques efficaces en Python.
Comment simuler la mécanique orbitale de la Terre en présence d'un "Super Jupiter" ayant 500 fois la masse de Jupiter.
Comment analyser et interpréter les résultats de la simulation pour comprendre l'impact des corps célestes massifs sur la dynamique orbitale.
Comment implémenter Matplotlib pour créer des représentations visuelles de la simulation, mettant en évidence les trajectoires orbitales et les positions relatives des planètes.
Comment explorer les concepts de force, de masse et d'accélération dans un contexte cosmique.
Comment ajuster les paramètres de simulation tels que la masse, la distance et les pas de temps pour différents scénarios.
Comment développer des compétences en débogage et en optimisation du code Python pour les calculs scientifiques.

🏆 Réalisations

Après avoir terminé ce projet, vous serez capable de :

Appliquer les principes fondamentaux de la physique, en particulier la Loi de la Gravitation Universelle de Newton, dans un contexte pratique et informatique.
Créer et exécuter une simulation basée sur la physique à l'aide de Python.
Montrer une maîtrise dans l'utilisation de NumPy pour gérer efficacement les calculs numériques à grande échelle.
Visualiser des données et des simulations complexes à l'aide de Matplotlib, améliorant l'interprétabilité des résultats scientifiques.
Comprendre la dynamique du mouvement planétaire et les effets des forces gravitationnelles des corps massifs.
Analyser et interpréter les résultats de la simulation pour tirer des conclusions significatives sur la mécanique céleste.
Ajuster et expérimenter avec les paramètres de simulation, conduisant à une compréhension plus approfondie de la mécanique orbitale.
Mettre en évidence des compétences accrues en résolution de problèmes et en débogage dans un environnement de programmation, en particulier dans le contexte du calcul scientifique.
Montrer une connaissance de base de la manière dont les forces gravitationnelles influencent le mouvement des corps célestes, ouvrant la voie à des explorations ultérieures en astrophysique et en modélisation informatique.

Configuration de l'environnement

Tout d'abord, nous devons configurer nos fichiers de projet et importer les bibliothèques nécessaires.

Créez un fichier Python nommé simulation.py :

touch ~/project/simulation.py

Ensuite, importez les bibliothèques suivantes :

## Importation des bibliothèques requises
from typing import Tuple
import numpy as np
import pylab as py
import matplotlib.pyplot as plt
from matplotlib import animation
from matplotlib.lines import Line2D
from tqdm import trange

Dans cette étape initiale du projet de simulation gravitationnelle, plusieurs bibliothèques Python importantes sont importées pour configurer l'environnement de notre simulation :

typing : Plus précisément, Tuple du module typing est importé. Cela est utilisé pour les indications de type en Python, ce qui aide à la lisibilité et au débogage du code. Il permet de spécifier les types de valeurs qui peuvent être regroupées dans un tuple, assurant la cohérence et la clarté dans les définitions de fonctions.
numpy : La bibliothèque numpy, importée sous le nom np, est un package fondamental pour le calcul scientifique en Python. Elle offre un support pour des tableaux et des matrices multi-dimensionnels de grande taille, ainsi qu'une vaste collection de fonctions mathématiques de haut niveau pour opérer sur ces tableaux. Elle est cruciale pour gérer les calculs numériques dans la simulation.
pylab : Importé sous le nom py, pylab est un module de Matplotlib qui s'installe en même temps que Matplotlib. Il fournit une interface similaire à MATLAB, particulièrement utile pour les calculs et les tracés interactifs. Cependant, son utilisation est généralement déconseillée au profit de l'importation explicite de matplotlib.pyplot et numpy.
matplotlib.pyplot : Ce module, importé sous le nom plt, est utilisé pour créer des visualisations statiques, animées et interactives en Python. C'est un aspect central de ce projet pour tracer les trajectoires des corps célestes.
matplotlib.animation : Ce sous-module de Matplotlib fournit la fonctionnalité pour créer des animations. Il est essentiel pour visualiser le mouvement dynamique des planètes dans la simulation gravitationnelle.
matplotlib.lines.Line2D : Cette classe de la bibliothèque Matplotlib est utilisée pour créer des objets de ligne qui peuvent être tracés sur les graphiques. Elle est utile pour des tracés plus détaillés ou personnalisés dans la simulation.
tqdm.trange : trange du module tqdm est une variante de la fonction range de Python avec un compteur de progression intégré. Il est utile pour afficher la progression des boucles dans la simulation, surtout lorsqu'il s'agit de calculs extensifs.

En important ces bibliothèques et modules, nous posons les bases pour les calculs numériques complexes et les visualisations requises dans le projet de simulation gravitationnelle. Cette configuration est cruciale pour les étapes suivantes où la logique physique et d'animation réelle sera implémentée.

Définition des constantes

Définissez les constantes qui seront utilisées dans notre simulation. Cela inclut la constante gravitationnelle, les unités astronomiques et les masses normalisées de la Terre, de Jupiter et du Soleil.

## Constantes
G = 6.673e-11                 ## Constante gravitationnelle
AU = 1.496e11                 ## Unité astronomique en km
YEAR = 365*24*60*60.0         ## Secondes dans une année
MM = 6e24                     ## Masse de normalisation
ME = 6e24/MM                  ## Masse normalisée de la Terre
MS = 2e30/MM                  ## Masse normalisée du Soleil
MJ = 500*1.9e27/MM            ## Masse normalisée de Jupiter
GG = (MM*G*YEAR**2)/(AU**3)   ## Constante gravitationnelle pour la simulation

Dans cette étape, nous définissons plusieurs constantes essentielles pour la simulation gravitationnelle. Ces constantes sont fondamentales pour modéliser avec précision la mécanique céleste et les interactions gravitationnelles dans la simulation :

Constante gravitationnelle (G) : Fixée à 6.673e-11 (en unités SI), cette constante est cruciale dans la loi de la gravitation universelle de Newton. Elle représente la force de gravité et est utilisée pour calculer la force gravitationnelle entre deux masses.
Unité astronomique (AU) : Définie comme 1.496e11 kilomètres, elle représente la distance moyenne de la Terre au Soleil. Cette unité est utilisée pour exprimer les distances dans le système solaire de manière plus pratique.
Année (YEAR) : Calculée comme 365*24*60*60.0, elle représente le nombre de secondes dans une année. Elle est utilisée pour convertir les calculs liés au temps en années, une unité de temps plus intuitive pour les simulations astronomiques.
Masse de normalisation (MM) : Fixée à 6e24, cette valeur est utilisée comme masse de référence pour normaliser les autres masses dans la simulation. Elle est approximativement équivalente à la masse de la Terre.
Masse normalisée de la Terre (ME) : Calculée comme 6e24/MM, elle représente la masse de la Terre en unités normalisées. Elle est essentiellement fixée à 1, car la masse de normalisation (MM) est basée sur la masse de la Terre.
Masse normalisée du Soleil (MS) : Fixée à 2e30/MM, elle représente la masse du Soleil en unités normalisées. La masse du Soleil est un facteur critique dans la simulation de la traction gravitationnelle sur les planètes.
Masse normalisée de Jupiter (MJ) : De manière unique, dans cette simulation, la masse de Jupiter est amplifiée à 500*1.9e27/MM pour représenter un scénario de "Super Jupiter". Cette masse considérablement plus importante démontrera l'impact d'une planète beaucoup plus massive sur l'orbite de la Terre.
Constante gravitationnelle pour la simulation (GG) : C'est la constante gravitationnelle ajustée pour l'échelle et les unités de la simulation, calculée comme (MM*G*YEAR**2)/(AU**3). Elle adapte la constante gravitationnelle du monde réel aux unités normalisées utilisées dans la simulation.

En définissant ces constantes, nous disposons des paramètres nécessaires pour simuler avec précision les forces gravitationnelles et les mouvements des corps célestes tels que la Terre et ce "Super Jupiter" hypothétique. Cette étape est cruciale pour s'assurer que les calculs de la simulation reflètent les dynamiques astronomiques réalistes. En même temps, vous pouvez modifier ces constantes autant que vous le souhaitez pour observer différents résultats à la fin.

Création de la fonction de force gravitationnelle

Maintenant, nous allons définir une fonction pour calculer la force gravitationnelle entre deux corps. Cette fonction sera cruciale pour déterminer le mouvement des planètes.

## Fonction pour calculer la force gravitationnelle
def gravitational_force(m1: float, m2: float, r: np.ndarray) -> np.ndarray:
    """
    Calcule la force gravitationnelle entre deux corps.
    """
    F_mag = GG * m1 * m2 / (np.linalg.norm(r) + 1e-20)**2
    theta = np.arctan2(np.abs(r[1]), np.abs(r[0]) + 1e-20)
    F = F_mag * np.array([np.cos(theta), np.sin(theta)])
    F *= -np.sign(r)
    return F

Dans cette étape, nous définissons une fonction gravitational_force pour calculer la force gravitationnelle entre deux corps célestes. Cette fonction est un composant critique de la simulation, car elle applique la loi de la gravitation universelle de Newton pour déterminer la force exercée entre deux masses quelconques dans l'espace. Voici un détail de la fonction :

Définition de la fonction : La fonction gravitational_force prend trois arguments :
- m1 et m2 : Les masses des deux corps (valeurs de type float).
- r : Un tableau NumPy représentant le vecteur de déplacement entre les deux corps.
Calcul de la magnitude de la force (F_mag) :
- La fonction calcule d'abord la magnitude de la force gravitationnelle en utilisant la formule F_mag = GG * m1 * m2 / (np.linalg.norm(r) + 1e-20)**2.
- GG est la constante gravitationnelle pour la simulation.
- np.linalg.norm(r) calcule la distance euclidienne entre les deux corps. Un nombre petit (1e-20) est ajouté pour éviter la division par zéro.
Détermination de la direction (theta et F) :
- L'angle theta est calculé en utilisant np.arctan2 pour trouver l'angle du vecteur de force dans les coordonnées polaires. Encore une fois, un nombre petit (1e-20) est ajouté au dénominateur pour éviter la division par zéro lorsque le déplacement dans la direction x (r[0]) est nul.
- Le vecteur de force F est ensuite calculé en utilisant F_mag et l'angle theta, avec des composantes le long des axes x et y ([np.cos(theta), np.sin(theta)]).
Ajustement de la direction de la force :
- Le vecteur de force F est multiplié par -np.sign(r) pour s'assurer que la force est toujours attractive (pointant vers l'autre corps) conformément aux lois de la gravitation.
Retour du vecteur de force :
- Enfin, la fonction retourne le vecteur de force gravitationnelle F.

En mettant en œuvre cette fonction, nous apprenons à appliquer les lois physiques dans un environnement informatique. La fonction est essentielle pour calculer les interactions gravitationnelles entre la Terre et le "Super Jupiter" dans la simulation, qui influencera leurs trajectoires respectives.

Implémentation du solveur RK4

Implémentez le solveur d'ordre 4 de Runge-Kutta pour résoudre les équations différentielles du mouvement. Cette méthode est largement utilisée pour résoudre numériquement les équations différentielles ordinaires.

## Solveur RK4
def RK4Solver(t: float, r: np.ndarray, v: np.ndarray, h: float, planet: str, r_other: np.ndarray, v_other: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
    """
    Solveur d'ordre 4 de Runge-Kutta pour le mouvement planétaire.
    """
    def dr_dt(v: np.ndarray) -> np.ndarray:
        return v

    def dv_dt(r: np.ndarray, planet: str) -> np.ndarray:
        if planet == 'earth':
            return (gravitational_force(ME, MS, r) + gravitational_force(ME, MJ, r - r_other)) / ME
        elif planet == 'jupiter':
            return (gravitational_force(MJ, MS, r) - gravitational_force(MJ, ME, r - r_other)) / MJ

    k11 = dr_dt(v)
    k21 = dv_dt(r, planet)

    k12 = dr_dt(v + 0.5 * h * k21)
    k22 = dv_dt(r + 0.5 * h * k11, planet)

    k13 = dr_dt(v + 0.5 * h * k22)
    k23 = dv_dt(r + 0.5 * h * k12, planet)

    k14 = dr_dt(v + h * k23)
    k24 = dv_dt(r + h * k13, planet)

    y0 = r + h * (k11 + 2 * k12 + 2 * k13 + k14) / 6
    y1 = v + h * (k21 + 2 * k22 + 2 * k23 + k24) / 6

    return y0, y1

Dans cette étape, nous implémentons une fonction appelée RK4Solver, qui utilise la méthode de Runge-Kutta d'ordre 4 (RK4) pour résoudre les équations différentielles. Cette méthode est cruciale pour simuler avec précision le mouvement des planètes dans notre modèle gravitationnel. Voici un aperçu de ce que fait la fonction RK4Solver :

Définition de la fonction :
- RK4Solver prend plusieurs paramètres :
  - t : Le temps actuel.
  - r : Le vecteur de position actuel de la planète.
  - v : Le vecteur de vitesse actuel de la planète.
  - h : Le pas de temps pour la simulation.
  - planet : Une chaîne de caractères indiquant laquelle des planètes (Terre ou Jupiter) est simulée.
  - r_other et v_other : Les vecteurs de position et de vitesse de l'autre planète.
Fonctions auxiliaires dans RK4Solver :
- dr_dt(v: np.ndarray) -> np.ndarray : Cette fonction renvoie la vitesse de variation de la position, qui est simplement la vitesse v.
- dv_dt(r: np.ndarray, planet: str) -> np.ndarray : Cette fonction calcule l'accélération de la planète due aux forces gravitationnelles. Elle utilise la fonction gravitational_force définie précédemment pour calculer les forces exercées par le Soleil et l'autre planète (Terre ou Jupiter) et renvoie l'accélération.
Calculs de Runge-Kutta :
- La méthode RK4 implique le calcul de quatre "pentes" (k11, k21, k12, k22, k13, k23, k14, k24) à différents points au sein du pas de temps puis les combine pour obtenir une estimation précise de la position et de la vitesse au prochain pas de temps.
- Ces pentes sont calculées en utilisant la position et la vitesse actuelles, ainsi que les dérivées de la position (dr_dt) et de la vitesse (dv_dt).
Mise à jour de la position et de la vitesse :
- La fonction calcule la position (y0) et la vitesse (y1) suivantes de la planète en utilisant la moyenne pondérée de ces pentes, selon la formule RK4.
Retour des résultats :
- Enfin, la fonction renvoie les vecteurs de position et de vitesse mis à jour (y0, y1) pour la planète.

En implémentant la fonction RK4Solver, nous apprenons une méthode efficace et précise pour résoudre numériquement les équations différentielles ordinaires. Cela est particulièrement important dans les simulations impliquant des systèmes complexes comme le mouvement planétaire, où la précision est essentielle pour obtenir des résultats réalistes. La méthode RK4 trouve un bon équilibre entre l'efficacité de calcul et la précision, ce qui en fait un choix populaire dans de nombreuses applications scientifiques et techniques.

Configuration de l'animation

Avant d'exécuter la simulation, nous devons préparer l'animation. Cette étape consiste à créer un tracé et à initialiser les lignes et les marqueurs représentant les planètes.

## Préparation de l'animation
def setup_animation() -> Tuple[py.Figure, py.Axes, Line2D, Line2D, py.Text]:
    """
    Prépare le tracé pour l'animation de la simulation gravitationnelle.
    """
    ## Création d'une figure et d'un axe de tracé
    fig, ax = py.subplots()

    ## Définition des limites et des graduations de l'axe
    ax.axis('square')
    ax.set_xlim((-7.2, 7.2))
    ax.set_ylim((-7.2, 7.2))
    ax.get_xaxis().set_ticks([])
    ax.get_yaxis().set_ticks([])

    ## Traçage du Soleil
    ax.plot(0, 0, 'o', markersize=9, markerfacecolor="#FDB813",
            markeredgecolor="#FD7813")

    ## Initialisation des lignes pour la Terre et Jupiter
    line_earth, = ax.plot([], [], 'o-', color='#d2eeff',
                          markevery=10000, markerfacecolor='#0077BE', lw=2)
    line_jupiter, = ax.plot([], [], 'o-', color='#e3dccb', markersize=8,
                            markerfacecolor='#f66338', lw=2, markevery=10000)
    ## Ajout d'un objet de texte
    ttl = ax.text(0.24, 1.05, '', transform=ax.transAxes, va='center')

    ## Retour des composants
    return fig, ax, line_earth, line_jupiter, ttl

Dans cette étape, nous définissons une fonction appelée setup_animation qui prépare le tracé pour l'animation de la simulation gravitationnelle. Cette fonction configure les composants visuels de la simulation, tels que la zone de tracé, les marqueurs planétaires et le positionnement initial.

Cette fonction est essentielle pour visualiser les orbites simulées de la Terre et de Jupiter. Elle pose la scène pour la partie dynamique de la simulation où les positions de ces planètes seront mises à jour frame par frame pour créer une animation.

Création de la fonction d'animation

Créez une fonction qui mettra à jour les positions des planètes pour chaque trame de l'animation.

## Fonction d'animation
def animate(i: int) -> Tuple[Line2D, Line2D, py.Text]:
    """
    Fonction d'animation pour le mouvement planétaire.
    """
    earth_trail, jupiter_trail = 40, 200
    tm_yr = 'Temps écoulé ='+ str(round(t[i], 1)) +'ans'
    ttl.set_text(tm_yr)
    line_earth.set_data(r[i:max(1, i - earth_trail):-1, 0],
                        r[i:max(1, i - earth_trail):-1, 1])
    line_jupiter.set_data(r_jupiter[i:max(
        1, i - jupiter_trail):-1, 0], r_jupiter[i:max(1, i - jupiter_trail):-1, 1])
    return line_earth, line_jupiter, ttl

Dans cette étape, nous définissons la fonction animate, qui est au cœur de la création de l'animation pour la simulation du mouvement planétaire. Cette fonction est appelée plusieurs fois pour mettre à jour les positions de la Terre et de Jupiter sur le tracé, créant ainsi l'effet de mouvement au fil du temps. Voici ce qui se passe dans la fonction animate :

Longueur de la trace pour la Terre et Jupiter :
- Les variables earth_trail et jupiter_trail sont définies, déterminant combien de positions précédentes (trace) de chaque planète sont affichées. Cela crée un effet de trace visuelle, montrant la trajectoire suivie par chaque planète.
Mise à jour de l'affichage du temps :
- Le temps écoulé (tm_yr) est calculé et défini comme le texte de l'objet de texte ttl. Cela affiche le temps de simulation en années sur l'animation.
Mise à jour de la position de la Terre :
- line_earth.set_data met à jour la position de la Terre dans l'animation. Elle utilise une tranche du tableau de positions r pour créer un effet de trace, montrant où la Terre s'est trouvée récemment dans son orbite.
Mise à jour de la position de Jupiter :
- De manière similaire, line_jupiter.set_data met à jour la position de Jupiter en utilisant une tranche du tableau r_jupiter. La longueur plus grande de la trace pour Jupiter reflète son orbite plus large.
Retour des objets mis à jour :
- La fonction renvoie les objets Line2D mis à jour (line_earth, line_jupiter) et l'objet de texte (ttl). Ce sont les éléments qui changent dans chaque trame de l'animation.

Cette fonction animate est cruciale pour visualiser la simulation, montrant comment la Terre et Jupiter se déplacent au fil du temps sous l'influence mutuelle de leur gravité. Elle donne vie à la simulation en mettant dynamiquement à jour le tracé avec chaque trame.

Initialisation des paramètres de simulation

Avant de commencer la simulation, initialisez les paramètres de temps, la position et la vitesse de la Terre et de Jupiter.

## Initialisation
ti, tf = 0, 120  ## Temps initial et final en années
N = 100 * tf     ## 100 points par an
t = np.linspace(ti, tf, N)  ## Tableau de temps
h = t[1] - t[0]  ## Pas de temps

## Initialisation de la position et de la vitesse
r = np.zeros([N, 2])         ## Position de la Terre
v = np.zeros([N, 2])         ## Vitesse de la Terre
r_jupiter = np.zeros([N, 2])  ## Position de Jupiter
v_jupiter = np.zeros([N, 2])  ## Vitesse de Jupiter

## Conditions initiales
r[0] = [1496e8 / AU, 0]
r_jupiter[0] = [5.2, 0]
v[0] = [0, np.sqrt(MS * GG / r[0, 0])]
v_jupiter[0] = [0, 13.06e3 * YEAR / AU]

Dans cette étape, nous configurons les conditions initiales et les paramètres de la simulation, ce qui est crucial pour démarrer l'animation du mouvement de la Terre et de Jupiter. Voici un résumé de ce qui est fait :

Initialisation du temps :
- ti et tf sont définis comme le temps initial et final de la simulation, mesuré en années (0 à 120 ans).
- N est défini comme le nombre total de points dans la simulation, calculé comme 100 points par an.
- t est un tableau créé en utilisant np.linspace pour représenter les pas de temps depuis le temps initial jusqu'au temps final.
- h est le pas de temps, calculé comme la différence entre les deux premiers éléments du tableau t.
Initialisation de la position et de la vitesse :
- Les tableaux r et v sont initialisés pour stocker la position et la vitesse de la Terre à chaque pas de temps. Ils sont initialisés à zéro et ont une forme pour accueillir deux coordonnées (x et y) pour chaque pas de temps.
- De manière similaire, r_jupiter et v_jupiter sont initialisés pour stocker la position et la vitesse de Jupiter.
Définition des conditions initiales :
- La position initiale de la Terre (r[0]) est définie comme sa distance du Soleil, normalisée par l'Unité astronomique (AU).
- La position initiale de Jupiter (r_jupiter[0]) est définie à 5,2 AU du Soleil, reflétant sa position réelle dans le système solaire.
- La vitesse initiale de la Terre (v[0]) est calculée en fonction de la force gravitationnelle exercée par le Soleil.
- La vitesse initiale de Jupiter (v_jupiter[0]) est définie à une valeur spécifique qui reflète sa vitesse orbitale réelle.

Cette étape est fondamentale car elle établit le point de départ de la simulation. Les positions et vitesses initiales sont cruciales pour calculer le mouvement subséquent des deux planètes sous l'effet des forces gravitationnelles.

Exécution de la simulation

Exécutez la simulation sur la plage de temps définie en utilisant le solveur RK4 et mettez à jour les positions des planètes.

## Exécution de la simulation
for i in trange(N - 1, desc="Génération de l'animation"):
    r[i + 1], v[i + 1] = RK4Solver(t[i], r[i],
                                   v[i], h, 'earth', r_jupiter[i], v_jupiter[i])
    r_jupiter[i + 1], v_jupiter[i +
                                1] = RK4Solver(t[i], r_jupiter[i], v_jupiter[i], h, 'jupiter', r[i], v[i])

Dans cette étape, nous exécutons la boucle principale pour exécuter la simulation gravitationnelle. C'est ici que le mouvement de la Terre et de Jupiter est calculé sur la période de temps spécifiée en utilisant la fonction RK4Solver. Voici une explication simple de ce processus :

Exécution de la boucle de simulation :
- Une boucle est configurée pour s'exécuter pour N - 1 itérations, où N est le nombre total de pas de temps dans la simulation. Cette boucle est cruciale pour avancer la simulation à chaque pas de temps.
- La fonction trange du module tqdm est utilisée pour itérer sur les pas de temps. Cela fournit une barre de progression (décrite comme "Génération de l'animation") pour montrer l'avancement de la simulation.
Mise à jour des positions et des vitesses de la Terre et de Jupiter :
- Dans chaque itération de la boucle, la fonction RK4Solver est appelée deux fois :
  - Une fois pour mettre à jour la position (r[i + 1]) et la vitesse (v[i + 1]) de la Terre au prochain pas de temps.
  - Une fois pour mettre à jour la position (r_jupiter[i + 1]) et la vitesse (v_jupiter[i + 1]) de Jupiter au prochain pas de temps.
- La fonction RK4Solver prend la position et la vitesse actuelle de la planète, ainsi que la position et la vitesse de l'autre planète, pour calculer le nouvel état.
Simulation des interactions :
- Cette boucle simule essentiellement l'interaction gravitationnelle entre la Terre et Jupiter (en considérant leur influence mutuelle et l'influence du Soleil) à chaque petit pas de temps, conduisant à une représentation réaliste de leurs orbites au fil du temps.

À la fin de cette boucle, nous avons les tableaux r, v, r_jupiter et v_jupiter remplis avec les positions et les vitesses de la Terre et de Jupiter à chaque pas de temps, prêts à être animés dans la prochaine phase du projet. Cette étape est où les lois de physique fondamentales et les méthodes numériques sont appliquées pour simuler la dynamique céleste.

Affichage de l'animation

Enfin, exécutez l'animation et affichez les résultats.

## Préparation de l'animation
fig, ax, line_earth, line_jupiter, ttl = setup_animation()
## Ajout d'une échelle et d'étiquettes
ax.plot([-6,-5],[6.5,6.5],'r-')
ax.text(-4.5,6.3,r'1 UA = $1,496 \times 10^8$ km')

ax.plot(-6,-6.2,'o', color = '#d2eeff', markerfacecolor = '#0077BE')
ax.text(-5.5,-6.4,'Terre')

ax.plot(-3.3,-6.2,'o', color = '#e3dccb',markersize = 8, markerfacecolor = '#f66338')
ax.text(-2.9,-6.4,'Super Jupiter (500 fois plus massive)')

ax.plot(5,-6.2,'o', markersize = 9, markerfacecolor = "#FDB813",markeredgecolor ="#FD7813")
ax.text(5.5,-6.4,'Soleil')

## Création de l'animation
anim = animation.FuncAnimation(
    fig, animate, frames=4000, interval=1, blit=False)

## Affichage de l'animation
plt.show()

Dans la dernière étape du projet, nous affichons l'animation de la simulation gravitationnelle qui montre le mouvement de la Terre et du "Super Jupiter" hypothétique. Cette étape consiste à visualiser les positions calculées des planètes au cours de la période de simulation.

Maintenant que nous avons terminé toutes les étapes, nous pouvons exécuter le code dans l'environnement de bureau en utilisant la commande suivante :

cd ~/projet
python simulation.py

Dans cette étape, nous pouvons apprécier visuellement les résultats de leur simulation, en observant comment le massive "Super Jupiter" influence l'orbite de la Terre.

Résumé

Dans ce projet, nous avons effectivement développé une simulation gravitationnelle mettant en scène la Terre et Jupiter à l'aide de Python. Nous avons utilisé la méthode Runge-Kutta d'ordre 4 (RK4) pour une intégration numérique précise, et Matplotlib pour une visualisation claire et attrayante. Ce projet offre non seulement une application pratique des principes de physique et de codage, mais encourage également les étudiants à expérimenter en modifiant le code pour simuler des corps célestes de masses variées, explorant ainsi une gamme d'interactions et de dynamiques gravitationnelles.

Simulation gravitationnelle de la Terre et du Super Jupiter