Gravitationssimulation von Erde und Super Jupiter

Einführung

In diesem Projekt werden wir eine Gravitationssimulation mit Python entwickeln, um die Wechselwirkung zwischen der Erde und einem hypothetischen "Super Jupiter", einem Planeten mit 500-mal der Masse von Jupiter, zu zeigen. Ziel dieser Simulation ist es, die Auswirkungen eines so massiven Körpers auf die Bewegung der Erde zu demonstrieren, unter Berücksichtigung der enormen Gravitationskräfte. Dieses Projekt eignet sich für Schüler und Hobbyisten, die sich für Physik, Astronomie und computergestützte Simulationen interessieren. Dazu werden wir Python-Bibliotheken wie NumPy für numerische Berechnungen und Matplotlib für die Visualisierung der dynamischen Bewegungen der Planeten einsetzen.

👀 Vorschau

🎯 Aufgaben

In diesem Projekt lernen Sie:

• Wie man Newtons Gesetz der universellen Gravitation versteht und anwendet, um die Wechselwirkung zwischen Himmelskörpern zu modellieren.
• Wie man mit Python-Programmierung ein computergestütztes Modell eines Gravitationssystems erstellt.
• Wie man die NumPy-Bibliothek für effiziente numerische Berechnungen in Python einsetzt.
• Wie man die Bahndrehmechanik der Erde in Gegenwart eines "Super Jupiter" mit 500-mal der Masse von Jupiter simuliert.
• Wie man die Ergebnisse der Simulation analysiert und interpretiert, um die Auswirkungen massiver Himmelskörper auf die Bahndrehmechanik zu verstehen.
• Wie man Matplotlib implementiert, um visuelle Darstellungen der Simulation zu erstellen, die die Bahnen und relativen Positionen der Planeten zeigen.
• Wie man die Konzepte von Kraft, Masse und Beschleunigung in einem kosmischen Kontext erforscht.
• Wie man die Simulationsparameter wie Masse, Entfernung und Zeitschritte für verschiedene Szenarien anpasst.
• Wie man Fähigkeiten im Debuggen und Optimieren von Python-Code für wissenschaftliche Berechnungen entwickelt.

🏆 Errungenschaften

Nach Abschluss dieses Projekts werden Sie in der Lage sein:

• Grundprinzipien der Physik, insbesondere Newtons Gesetz der universellen Gravitation, in einem praktischen, computergestützten Kontext anzuwenden.
• Eine physikbasierte Simulation mit Python zu erstellen und auszuführen.
• Beweis führen, dass Sie die NumPy-Bibliothek zur effizienten Handhabung von großen numerischen Berechnungen beherrschen.
• Komplexe Daten und Simulationen mit Matplotlib zu visualisieren, um die Interpretierbarkeit wissenschaftlicher Ergebnisse zu verbessern.
• Die Dynamik der Planetenbewegung und die Auswirkungen von Gravitationskräften von massiven Körpern zu verstehen.
• Die Ergebnisse der Simulation zu analysieren und zu interpretieren, um sinnvolle Schlüsse über die Himmelsmechanik zu ziehen.
• Die Simulationsparameter anzupassen und zu experimentieren, um ein tieferes Verständnis der Bahndrehmechanik zu erlangen.
• Verbesserte Problemlöse- und Debugging-Fähigkeiten in einer Programmierumgebung, insbesondere im Kontext der wissenschaftlichen Rechnung, zu demonstrieren.
• Ein grundlegendes Wissen darüber zu vermitteln, wie Gravitationskräfte die Bewegung von Himmelskörpern formen, um den Weg für weitere Forschungen in der Astrophysik und der computergestützten Modellierung zu ebnen.

Die Umgebung einrichten

Zunächst müssen wir unsere Projekt-Dateien einrichten und die erforderlichen Bibliotheken importieren.

Erstellen Sie eine Python-Datei namens simulation.py:

touch ~/project/simulation.py

Importieren Sie dann die folgenden Bibliotheken:

## Importing required libraries
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

In diesem ersten Schritt des Gravitationssimulationsprojekts werden mehrere wichtige Python-Bibliotheken importiert, um die Umgebung für unsere Simulation aufzusetzen:

1. typing: Insbesondere wird Tuple aus dem typing-Modul importiert. Dies wird für die Typhinweise in Python verwendet, was die Lesbarkeit und das Debugging des Codes unterstützt. Es ermöglicht die Angabe, welche Typen von Werten in einem Tupel gruppiert werden können, um Konsistenz und Klarheit in den Funktionsdefinitionen sicherzustellen.
2. numpy: Die numpy-Bibliothek, importiert als np, ist ein grundlegendes Paket für die wissenschaftliche Rechnung in Python. Sie bietet Unterstützung für große, mehrdimensionale Arrays und Matrizen sowie eine umfangreiche Sammlung von hochwertigen mathematischen Funktionen, um auf diesen Arrays zu operieren. Sie ist für die Behandlung von numerischen Berechnungen in der Simulation von entscheidender Bedeutung.
3. pylab: Importiert als py, ist pylab ein Modul in Matplotlib, das zusammen mit Matplotlib installiert wird. Es bietet eine MATLAB-ähnliche Schnittstelle, die besonders nützlich für interaktive Berechnungen und Plotting ist. Allerdings wird seine Verwendung im Allgemeinen nicht empfohlen, sondern es wird empfohlen, matplotlib.pyplot und numpy explizit zu importieren.
4. matplotlib.pyplot: Dieses Modul, importiert als plt, wird verwendet, um statische, animierte und interaktive Visualisierungen in Python zu erstellen. Es ist ein zentraler Aspekt dieses Projekts für das Plotten der Bahnen von Himmelskörpern.
5. matplotlib.animation: Dieses Untermodul von Matplotlib bietet die Funktionalität zum Erstellen von Animationen. Es ist essentiell für die Visualisierung der dynamischen Bewegung von Planeten in der Gravitationssimulation.
6. matplotlib.lines.Line2D: Diese Klasse aus der Matplotlib-Bibliothek wird verwendet, um Linienobjekte zu erstellen, die auf Plots gezeichnet werden können. Sie ist nützlich für detaillierteres oder benutzerdefiniertes Plotting in der Simulation.
7. tqdm.trange: trange aus dem tqdm-Modul ist eine Variante der Python-Eingabefunktion mit einem eingebauten Fortschrittsbalken. Es ist nützlich für die Anzeige des Fortschritts von Schleifen in der Simulation, insbesondere wenn es um umfangreiche Berechnungen geht.

Indem wir diese Bibliotheken und Module importieren, legen wir die Grundlage für die komplexen numerischen Berechnungen und Visualisierungen, die im Gravitationssimulationsprojekt erforderlich sind. Diese Einrichtung ist entscheidend für die nachfolgenden Schritte, in denen die tatsächliche Physik und die Animationslogik implementiert werden.

Konstanten definieren

Definieren Sie die Konstanten, die in unserer Simulation verwendet werden. Dies umfasst die Gravitationskonstante, astronomische Einheiten und die normalisierten Massen der Erde, Jupiters und der Sonne.

## Constants
G = 6.673e-11                 ## Gravitationskonstante
AU = 1.496e11                 ## Astronomische Einheit in km
YEAR = 365*24*60*60.0         ## Sekunden in einem Jahr
MM = 6e24                     ## Massen-Normalisierung
ME = 6e24/MM                  ## Normalisierte Masse der Erde
MS = 2e30/MM                  ## Normalisierte Masse der Sonne
MJ = 500*1.9e27/MM            ## Normalisierte Masse von Jupiter
GG = (MM*G*YEAR**2)/(AU**3)   ## Gravitationskonstante für die Simulation

In diesem Schritt definieren wir mehrere essentielle Konstanten für die Gravitationssimulation. Diese Konstanten sind grundlegend für die genaue Modellierung der Himmelsmechanik und der Gravitationswechselwirkungen in der Simulation:

1. Gravitationskonstante (G): Mit dem Wert 6.673e-11 (in SI-Einheiten) ist diese Konstante in Newtons Gesetz der universellen Gravitation von entscheidender Bedeutung. Sie repräsentiert die Stärke der Schwerkraft und wird verwendet, um die Gravitationskraft zwischen zwei Massen zu berechnen.
2. Astronomische Einheit (AU): Definiert als 1.496e11 Kilometer, repräsentiert sie die durchschnittliche Entfernung von der Erde zur Sonne. Diese Einheit wird verwendet, um Entfernungen innerhalb des Sonnensystems auf eine handhabbare Weise auszudrücken.
3. Jahr (YEAR): Berechnet als 365*24*60*60.0, repräsentiert es die Anzahl der Sekunden in einem Jahr. Dies wird verwendet, um zeitspezifische Berechnungen in Jahre umzurechnen, eine intuitivere Zeiteinheit für astronomische Simulationen.
4. Massen-Normalisierung (MM): Mit dem Wert 6e24 wird diese Größe als Referenzmasse verwendet, um andere Massen in der Simulation zu normalisieren. Sie entspricht ungefähr der Masse der Erde.
5. Normalisierte Masse der Erde (ME): Berechnet als 6e24/MM, repräsentiert sie die Masse der Erde in normalisierten Einheiten. Sie ist im Wesentlichen auf 1 gesetzt, da die Normalisierungsmasse (MM) auf der Masse der Erde basiert.
6. Normalisierte Masse der Sonne (MS): Mit dem Wert 2e30/MM repräsentiert sie die Masse der Sonne in normalisierten Einheiten. Die Masse der Sonne ist ein kritischer Faktor bei der Simulation der Gravitationskraft auf die Planeten.
7. Normalisierte Masse von Jupiter (MJ): Im Gegensatz dazu wird in dieser Simulation die Masse von Jupiter auf 500*1.9e27/MM vergrößert, um ein Szenario mit einem "Super Jupiter" zu repräsentieren. Diese erheblich größere Masse wird die Auswirkungen eines massiveren Planeten auf die Erde-Umlaufbahn demonstrieren.
8. Gravitationskonstante für die Simulation (GG): Dies ist die Gravitationskonstante, die für die Skala und die Einheiten der Simulation angepasst wurde, berechnet als (MM*G*YEAR**2)/(AU**3). Sie passt die reale Welt-Gravitationskonstante an die in der Simulation verwendeten normalisierten Einheiten an.

Indem wir diese Konstanten definieren, verfügen wir über die erforderlichen Parameter, um die Gravitationskräfte und Bewegungen von Himmelskörpern wie der Erde und diesem hypothetischen "Super Jupiter" genauer zu simulieren. Dieser Schritt ist von entscheidender Bedeutung, um sicherzustellen, dass die Berechnungen der Simulation realistische astronomische Dynamiken widerspiegeln. Gleichzeitig können Sie diese Konstanten beliebig ändern, um am Ende verschiedene Ergebnisse zu beobachten.

Die Gravitationskraftfunktion erstellen

Nun definieren wir eine Funktion, um die Gravitationskraft zwischen zwei Körpern zu berechnen. Diese Funktion wird von entscheidender Bedeutung sein, um die Bewegung der Planeten zu bestimmen.

## Function to calculate gravitational force
def gravitational_force(m1: float, m2: float, r: np.ndarray) -> np.ndarray:
    """
    Calculate gravitational force between two bodies.
    """
    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

In diesem Schritt definieren wir eine Funktion gravitational_force, um die Gravitationskraft zwischen zwei Himmelskörpern zu berechnen. Diese Funktion ist ein entscheidender Bestandteil der Simulation, da sie Newtons Gesetz der universellen Gravitation anwendet, um die Kraft zu bestimmen, die zwischen zwei beliebigen Massen im Weltraum ausgeübt wird. Hier ist eine detaillierte Erklärung der Funktion:

1. Funktionsdefinition: Die Funktion gravitational_force nimmt drei Argumente entgegen:
   • m1 und m2: Die Massen der beiden Körper (float-Werte).
   • r: Ein NumPy-Array, das den Verschiebungsvektor zwischen den beiden Körpern repräsentiert.
2. Berechnung der Kraftgröße (F_mag):
   • Die Funktion berechnet zunächst die Größe der Gravitationskraft mit der Formel F_mag = GG * m1 * m2 / (np.linalg.norm(r) + 1e-20)**2.
   • GG ist die Gravitationskonstante für die Simulation.
   • np.linalg.norm(r) berechnet die euklidische Entfernung zwischen den beiden Körpern. Eine kleine Zahl (1e-20) wird hinzugefügt, um eine Division durch Null zu vermeiden.
3. Bestimmung der Richtung (theta und F):
   • Der Winkel theta wird mit np.arctan2 berechnet, um den Winkel des Kraftvektors in Polarkoordinaten zu bestimmen. Auch hier wird eine kleine Zahl (1e-20) zum Nenner hinzugefügt, um eine Division durch Null zu vermeiden, wenn die Verschiebung in x-Richtung (r[0]) Null ist.
   • Der Kraftvektor F wird dann mit F_mag und dem Winkel theta berechnet, mit Komponenten entlang der x- und y-Achsen ([np.cos(theta), np.sin(theta)]).
4. Anpassung der Kraftrichtung:
   • Der Kraftvektor F wird mit -np.sign(r) multipliziert, um sicherzustellen, dass die Kraft immer anziehend (auf den anderen Körper gerichtet) ist, wie es die Gravitationsgesetze vorsehen.
5. Rückgabe des Kraftvektors:
   • Schließlich gibt die Funktion den Gravitationskraftvektor F zurück.

Durch die Implementierung dieser Funktion lernen wir, wie physikalische Gesetze in einem computergestützten Umfeld angewendet werden. Die Funktion ist essentiell für die Berechnung der Gravitationswechselwirkungen zwischen der Erde und dem "Super Jupiter" in der Simulation, die ihre jeweiligen Bahnen beeinflussen werden.

Die RK4-Lösungsmethode implementieren

Implementieren Sie die Runge-Kutta-4. Ordnung-Lösungsmethode, um die Differentialgleichungen der Bewegung zu lösen. Diese Methode wird weit verbreitet zur numerischen Lösung von gewöhnlichen Differentialgleichungen verwendet.

## RK4 Solver
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]:
    """
    Fourth order Runge-Kutta solver for planetary motion.
    """
    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

In diesem Schritt implementieren wir eine Funktion namens RK4Solver, die die Runge-Kutta-4. Ordnung (RK4)-Methode zur Lösung von Differentialgleichungen verwendet. Diese Methode ist von entscheidender Bedeutung für die genaue Simulation der Bewegung von Planeten in unserem Gravitationsmodell. Hier ist ein Überblick über das, was die RK4Solver-Funktion macht:

1. Funktionsdefinition:
   • RK4Solver nimmt mehrere Parameter entgegen:
     • t: Die aktuelle Zeit.
     • r: Der aktuelle Positionvektor des Planeten.
     • v: Der aktuelle Geschwindigkeitsvektor des Planeten.
     • h: Der Zeitschritt für die Simulation.
     • planet: Ein String, der angibt, welcher Planet (Erde oder Jupiter) simuliert wird.
     • r_other und v_other: Die Position- und Geschwindigkeitsvektoren des anderen Planeten.
2. Hilfsfunktionen innerhalb von RK4Solver:
   • dr_dt(v: np.ndarray) -> np.ndarray: Diese Funktion gibt die Änderungsrate der Position zurück, was einfach die Geschwindigkeit v ist.
   • dv_dt(r: np.ndarray, planet: str) -> np.ndarray: Diese Funktion berechnet die Beschleunigung des Planeten aufgrund von Gravitationskräften. Sie verwendet die zuvor definierte gravitational_force-Funktion, um die Kräfte zu berechnen, die von der Sonne und dem anderen Planeten (Erde oder Jupiter) ausgeübt werden, und gibt die Beschleunigung zurück.
3. Runge-Kutta-Berechnungen:
   • Die RK4-Methode umfasst die Berechnung von vier "Steigungen" (k11, k21, k12, k22, k13, k23, k14, k24) an verschiedenen Punkten innerhalb des Zeitschritts und die anschließende Kombination dieser Steigungen, um eine genaue Schätzung der Position und Geschwindigkeit zum nächsten Zeitschritt zu erhalten.
   • Diese Steigungen werden mithilfe der aktuellen Position und Geschwindigkeit sowie der Ableitungen der Position (dr_dt) und Geschwindigkeit (dv_dt) berechnet.
4. Aktualisierung der Position und Geschwindigkeit:
   • Die Funktion berechnet die nächste Position (y0) und Geschwindigkeit (y1) des Planeten mithilfe der gewichteten Durchschnittswerte dieser Steigungen gemäß der RK4-Formel.
5. Rückgabe der Ergebnisse:
   • Schließlich gibt die Funktion die aktualisierten Position- und Geschwindigkeitsvektoren (y0, y1) für den Planeten zurück.

Indem wir die RK4Solver-Funktion implementieren, lernen wir eine effiziente und genaue Methode zur numerischen Lösung von gewöhnlichen Differentialgleichungen. Dies ist besonders wichtig in Simulationen von komplexen Systemen wie der Planetenbewegung, wo Genauigkeit der Schlüssel zur Erzielung realistischer Ergebnisse ist. Die RK4-Methode findet einen guten Kompromiss zwischen Rechenleistung und Genauigkeit und ist daher eine beliebte Wahl in vielen wissenschaftlichen und technischen Anwendungen.

Die Animation einrichten

Bevor wir die Simulation ausführen, müssen wir die Animation einrichten. Dieser Schritt beinhaltet das Erstellen eines Plots und die Initialisierung der Linien und Marker, die die Planeten repräsentieren.

## Setup animation
def setup_animation() -> Tuple[py.Figure, py.Axes, Line2D, Line2D, py.Text]:
    """
    Set up the animation plot.
    """
    ## Creating a Plot Figure and Axes
    fig, ax = py.subplots()

    ## Setting Axes Limits and Ticks
    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([])

    ## Plotting the Sun
    ax.plot(0, 0, 'o', markersize=9, markerfacecolor="#FDB813",
            markeredgecolor="#FD7813")

    ## Initializing Lines for Earth and 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)
    ## Adding a Text Object
    ttl = ax.text(0.24, 1.05, '', transform=ax.transAxes, va='center')

    ## Returning Components
    return fig, ax, line_earth, line_jupiter, ttl

In diesem Schritt definieren wir eine Funktion namens setup_animation, die den Plot für die Animation der Gravitationssimulation vorbereitet. Diese Funktion setzt die visuellen Komponenten der Simulation auf, wie die Plotfläche, die Planetenmarker und die Anfangspositionierung.

Diese Funktion ist von entscheidender Bedeutung für die Visualisierung der simulierten Umlaufbahnen von Erde und Jupiter. Sie bereitet die Bühne für den dynamischen Teil der Simulation, in dem die Positionen dieser Planeten frame für frame aktualisiert werden, um eine Animation zu erstellen.

Die Animationsfunktion erstellen

Erstellen Sie eine Funktion, die die Positionen der Planeten für jeden Frame der Animation aktualisiert.

## Animation function
def animate(i: int) -> Tuple[Line2D, Line2D, py.Text]:
    """
    Animation function for the planetary motion.
    """
    earth_trail, jupiter_trail = 40, 200
    tm_yr = 'Elapsed time = ' + str(round(t[i], 1)) + ' years'
    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

In diesem Schritt definieren wir die animate-Funktion, die der Kern der Erstellung der Animation für die Planetenbewegungssimulation ist. Diese Funktion wird wiederholt aufgerufen, um die Positionen von Erde und Jupiter im Plot zu aktualisieren und den Effekt der Bewegung über die Zeit zu erzeugen. Hier ist, was in der animate-Funktion passiert:

1. Spurlängen für Erde und Jupiter:
   • Die Variablen earth_trail und jupiter_trail werden festgelegt, um zu bestimmen, wie viele vorherige Positionen (Spur) jedes Planeten angezeigt werden. Dies erzeugt einen visuellen Spureffekt, der den Weg zeigt, den jeder Planet zurückgelegt hat.
2. Aktualisierung der Zeitanzeige:
   • Die vergangene Zeit (tm_yr) wird berechnet und als Text des ttl-Textobjekts festgelegt. Dies zeigt die Simulationszeit in Jahren auf der Animation an.
3. Aktualisierung der Erde-Position:
   • line_earth.set_data aktualisiert die Position von Erde in der Animation. Es verwendet einen Schnitt der Positionierungsarray r, um einen Spureffekt zu erzeugen und zu zeigen, wo Erde sich kürzlich in ihrer Umlaufbahn befand.
4. Aktualisierung der Jupiter-Position:
   • Ähnlich aktualisiert line_jupiter.set_data die Position von Jupiter mithilfe eines Schnittes des r_jupiter-Arrays. Die längere Spur für Jupiter spiegelt seine größere Umlaufbahn wider.
5. Rückgabe aktualisierter Objekte:
   • Die Funktion gibt die aktualisierten Line2D-Objekte (line_earth, line_jupiter) und das Textobjekt (ttl) zurück. Dies sind die Elemente, die sich in jedem Frame der Animation ändern.

Diese animate-Funktion ist von entscheidender Bedeutung für die Visualisierung der Simulation, um zu zeigen, wie Erde und Jupiter sich über die Zeit unter ihrem gegenseitigen Gravitationsfluss bewegen. Sie bringt die Simulation zum Leben, indem sie den Plot mit jedem Frame dynamisch aktualisiert.

Die Simulationsparameter initialisieren

Bevor Sie die Simulation starten, initialisieren Sie die Zeitparameter, die Position und die Geschwindigkeit von Erde und Jupiter.

## Initialization
ti, tf = 0, 120  ## Initial and final time in years
N = 100 * tf     ## 100 points per year
t = np.linspace(ti, tf, N)  ## Time array
h = t[1] - t[0]  ## Time step

## Position and Velocity Initialization
r = np.zeros([N, 2])         ## Position of Earth
v = np.zeros([N, 2])         ## Velocity of Earth
r_jupiter = np.zeros([N, 2])  ## Position of Jupiter
v_jupiter = np.zeros([N, 2])  ## Velocity of Jupiter

## Initial Conditions
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]

In diesem Schritt legen wir die Anfangsbedingungen und Parameter für die Simulation fest, was für das Starten der Animation der Bewegung von Erde und Jupiter von entscheidender Bedeutung ist. Hier ist eine Zusammenfassung dessen, was gemacht wird:

1. Zeitinitialisierung:
   • ti und tf werden als Anfangs- und Endzeit der Simulation festgelegt, gemessen in Jahren (0 bis 120 Jahre).
   • N wird als die Gesamtzahl der Punkte in der Simulation definiert, berechnet als 100 Punkte pro Jahr.
   • t ist ein Array, das mit np.linspace erstellt wird, um die Zeitschritte von der Anfangs- bis zur Endzeit darzustellen.
   • h ist der Zeitschritt, berechnet als die Differenz zwischen den ersten beiden Elementen des t-Arrays.
2. Position- und Geschwindigkeitsinitialisierung:
   • Die Arrays r und v werden initialisiert, um die Position und Geschwindigkeit von Erde in jedem Zeitschritt zu speichern. Sie werden mit Null initialisiert und haben eine Form, um zwei Koordinaten (x und y) für jeden Zeitschritt aufzunehmen.
   • Ähnlich werden r_jupiter und v_jupiter initialisiert, um Jupiter's Position und Geschwindigkeit zu speichern.
3. Setzen der Anfangsbedingungen:
   • Die Anfangsposition von Erde (r[0]) wird auf ihren Abstand zur Sonne, normalisiert durch die astronomische Einheit (AU), festgelegt.
   • Die Anfangsposition von Jupiter (r_jupiter[0]) wird auf 5,2 AU von der Sonne festgelegt, was seine tatsächliche Position im Sonnensystem widerspiegelt.
   • Die Anfangsgeschwindigkeit von Erde (v[0]) wird basierend auf der Gravitationskraft, die von der Sonne ausgeübt wird, berechnet.
   • Die Anfangsgeschwindigkeit von Jupiter (v_jupiter[0]) wird auf einen bestimmten Wert festgelegt, der seine tatsächliche Bahngeschwindigkeit widerspiegelt.

Dieser Schritt ist grundlegend, da er den Ausgangspunkt für die Simulation festlegt. Die Anfangspositionen und -geschwindigkeiten sind von entscheidender Bedeutung für die Berechnung der nachfolgenden Bewegung beider Planeten unter Gravitationskräften.

Die Simulation ausführen

Führen Sie die Simulation über den definierten Zeitraum mit dem RK4-Lösungsmethode aus und aktualisieren Sie die Positionen der Planeten.

## Running the simulation
for i in trange(N - 1, desc="Generating 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])

In diesem Schritt führen wir die Hauptschleife aus, um die Gravitationssimulation auszuführen. Hier wird die Bewegung von Erde und Jupiter über den angegebenen Zeitraum mithilfe der RK4Solver-Funktion berechnet. Hier ist eine einfache Erklärung dieses Prozesses:

1. Ausführen der Simulationsschleife:
   • Eine Schleife wird für N - 1 Iterationen ausgeführt, wobei N die Gesamtzahl der Zeitschritte in der Simulation ist. Diese Schleife ist von entscheidender Bedeutung für die Fortführung der Simulation durch jeden Zeitschritt.
   • Die trange-Funktion aus dem tqdm-Modul wird verwendet, um über die Zeitschritte zu iterieren. Dies liefert eine Fortschrittsanzeige (beschrieben als "Generating Animation"), um den Fortschritt der Simulation anzuzeigen.
2. Aktualisierung der Positionen und Geschwindigkeiten von Erde und Jupiter:
   • Innerhalb jeder Iteration der Schleife wird die RK4Solver-Funktion zweimal aufgerufen:
     • Einmal, um die Position von Erde (r[i + 1]) und die Geschwindigkeit (v[i + 1]) zum nächsten Zeitschritt zu aktualisieren.
     • Einmal, um die Position von Jupiter (r_jupiter[i + 1]) und die Geschwindigkeit (v_jupiter[i + 1]) zum nächsten Zeitschritt zu aktualisieren.
   • Die RK4Solver-Funktion nimmt die aktuelle Position und Geschwindigkeit des Planeten sowie die Position und Geschwindigkeit des anderen Planeten entgegen, um den neuen Zustand zu berechnen.
3. Simulieren von Wechselwirkungen:
   • Diese Schleife simuliert im Wesentlichen die Gravitationswechselwirkung zwischen Erde und Jupiter (unter Berücksichtigung ihrer gegenseitigen Beeinflussung und der Beeinflussung der Sonne) in jedem kleinen Zeitschritt, was zu einer realistischen Darstellung ihrer Umlaufbahnen über die Zeit führt.

Am Ende dieser Schleife haben wir die Arrays r, v, r_jupiter und v_jupiter mit den Positionen und Geschwindigkeiten von Erde und Jupiter in jedem Zeitschritt gefüllt, die im nächsten Projektabschnitt animiert werden können. In diesem Schritt werden die Kernphysik und numerischen Methoden angewendet, um die Himmelsdynamik zu simulieren.

Die Animation anzeigen

Schließlich führen Sie die Animation aus und zeigen Sie die Ergebnisse an.

## Setting Up the Animation
fig, ax, line_earth, line_jupiter, ttl = setup_animation()
## Adding Scale and Labels
ax.plot([-6,-5],[6.5,6.5],'r-')
ax.text(-4.5,6.3,r'1 AU = $1.496 \times 10^8$ km')

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

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

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

## Creating the Animation
anim = animation.FuncAnimation(
    fig, animate, frames=4000, interval=1, blit=False)

## Displaying the Animation
plt.show()

Im letzten Schritt des Projekts zeigen wir die Animation der Gravitationssimulation, die die Bewegung der Erde und des hypothetischen "Super Jupiter" zeigt. Dieser Schritt beinhaltet die Visualisierung der berechneten Positionen der Planeten über die Simulationsperiode.

Jetzt haben wir alle Schritte abgeschlossen und können den Code in der Desktopumgebung mit dem folgenden Befehl ausführen:

cd ~/project
python simulation.py

In diesem Schritt können wir die Ergebnisse ihrer Simulation visuell würdigen und beobachten, wie der massive "Super Jupiter" die Umlaufbahn der Erde beeinflusst.

Zusammenfassung

In diesem Projekt haben wir effektiv eine Gravitationssimulation mit Erde und Jupiter in Python entwickelt. Wir haben die Runge-Kutta-4. Ordnungsmethode (RK4) für eine präzise numerische Integration und Matplotlib für eine klare und ansprechende Visualisierung eingesetzt. Dieses Projekt bietet nicht nur eine praktische Anwendung von Physik- und Codierungsprinzipien, sondern ermutigt auch die Studierenden, durch Änderung des Codes zu experimentieren, um Himmelskörper unterschiedlicher Massen zu simulieren und somit eine Reihe von Gravitationswechselwirkungen und -dynamiken zu erkunden.