Relativistische n-Körper-Simulation. Gravitationswellenforschung am Laptop durch hocheffiziente Java-Programmierung


Projektarbeit, 2016
20 Seiten

Leseprobe

Inhaltsverzeichnis

Überblick

1 Einleitung

2 Wie alles begann

3 Aufbau des Programms

4 Der Programmkern

5 Der Einbau der Relativitätstheorie
5.1 Relativistische Massenzunahme
5.2 Ausbreitungsgeschwindigkeit der Gravitation als Wirkung
5.3 Zeitdilatation / Längenkontraktion

6 Zusatzmodule zur Berechnung
6.1 Kollisionen
6.2 Gezeitenreibung
6.3 Raumbegrenzung

7 Zusatzmodule zur graphischen Ausgabe
7.1 Flugbahn
7.2 Geschwindigkeit
7.3 Gruppierungen
7.4 Keplerbahnen / Osculating Orbits

8 Module zur Visualisierung der Gravitation
8.1 grid()-Methode
8.2 cube()-Methode

9 Die graphische Ausgabe
9.1 Koordinatenumrechnung
9.2 Sichtbarkeit

10 Multithreading für noch mehr Rechenleistung

11 Zusammenfassung und Anwendungsbeispiele

12 Quellenverzeichnis
12.1 Informationsquellen
12.2 Bildquellen

Überblick

Das Projekt ist ein Programm in Java, das sowohl relativistisch als auch klassisch n-Körper-Probleme berechnen kann. Die gesamte bekannte Physik der Himmelsmechanik soll darin erfasst werden, unter Anderem auch die begrenzte Ausbreitungsgeschwindigkeit der Gravitation als Wirkung.

Es enthält verschiedene zuschaltbare Module, mit denen man beispielsweise die Raumkrümmung visualisieren kann oder zusätzliche Informationen zu den Körpern wie Flugbahn, Geschwindigkeit oder Gruppierungen von Körpern anzeigen kann.

Zur graphischen Ausgabe verwende ich selbst entwickelte Algorithmen, beispielsweise zur Koordinatenumrechnung, da diese wesentlich effizienter sind als jede andere Grafikausgabe.

Das Programm kann sowohl Sonnensysteme mit wenigen Körpern als auch Kollisionen von Sternhaufen und Galaxien mit vielen Körpern berechnen. Je nach Rechenleistung sind bei Desktopcomputern bis zu 15 Millionen Rechenschritte pro Sekunde möglich.

1 Einleitung

n-Körper-Simulationen gibt es viele, doch die wenigsten berücksichtigen die auf den ersten Blick unscheinbare Konstante c – die Lichtgeschwindigkeit. Diese kleine Konstante macht aus dem trivialen Algorithmus, auf dem mein Programm aufbaut, eine komplexe und interessante Sache. Dass bewegte Massen schwerer sind, ist eine der einfachen Folgen, die sich mit etwa zehn Zeilen Quellcode bewältigen lässt. Aber c verursacht noch ein weiteres Problem, ein sehr viel schwierigeres, das man erst bei genauerem Hinsehen bemerkt: Nichts kann sich schneller als c ausbreiten, eben auch nicht die Gravitation selbst.

Ein kleines Beispiel kann das gut veranschaulichen: Das Licht benötigt von der Sonne zur Erde circa acht Minuten, die Wirkung der Gravitation auch. Würde man die Sonne von einem Moment auf den anderen verschwinden lassen, dann würde die Erde sich also noch acht Minuten lang in einem stabilen Orbit um die verschwundene Sonne befinden, bevor sie sich in geradliniger Bahn weiter bewegen würde.

Während sich durch die bewegte Masse die Periheldrehung erklären lässt, ist die auf c begrenzte Ausbreitungsgeschwindigkeit der Gravitation in Kombination mit der Zeitdilatation Ursache für Gravitationswellen, die mit meinem Programm untersucht werden können. Wie genau die Umsetzung dieses Problems in Quellcode erfolgt ist, wird Kern dieser Arbeit sein. In dem mittlerweile rund 2800 Programmzeilen umfassenden, hocheffizienten Code steckt nach mehr als zwei Jahren Forschung jedoch Informationsgehalt von der Größenordnung der Bibel, sodass ich im Rahmen dieser kurzen Arbeit nicht auf alle Details näher eingehen darf.

2 Wie alles begann

Ich habe das Programm im Frühling 2014 quasi aus dem Nichts begonnen. Alles, was ich zur Verfügung hatte, waren mein Informatikwissen in der Mitte der elften Klasse und eine Formelsammlung. Zunächst entwickelte ich den Programmkern für zwei räumliche Dimensionen. Eine Graphikausgabe existierte noch nicht. Die Methodik, alle berechneten Objekte zunächst als Kopie abzuspeichern und am Ende jedes Rechenschrittes für den nächsten zu übernehmen (siehe Kapitel 4), sowie eine primitive textbasierte Ausgabemethode über die BlueJ-Konsole konnte ich aus meinem vorherigen Projekt, Conway’s Game of Life, mit geringen Änderungen übernehmen. Ich war überwältigt, als ich zum ersten Mal zwei „Textpixel“ umeinander kreisen sah – und das bei etwa 200 Zeilen Code.

Abbildung in dieser Leseprobe nicht enthalten

Abbildung 1: Die primitive textbasierte Ausgabe; dennoch: die Simulation des Doppelsternsystems gelingt, eigener Screenshot

Nach und nach verbesserte ich das Programm, aus 2D wurde 3D, aus Textkonsole das schnellere und schönere JFrame mit Maus- und Tastaturinteraktion. Ich fügte zahlreiche Zusatzmodule und sogar die Relativitätstheorie hinzu. Heute sind es über zweieinhalb Tausend Programmzeilen mehr.

3 Aufbau des Programms

Das Programm ist mithilfe von BlueJ in der Objektorientierten Sprache Java geschrieben. Die Programmeffizienz hängt allein vom Programmierstil ab. Es gibt fünf grundlegende Klassen:

Abbildung in dieser Leseprobe nicht enthalten

Abbildung 2: Klassen in BlueJ, eigener Screenshot

1) Object

Die Object-Klasse beinhaltet eine Art Bauplan für Körper. Ein Körper besitzt alle darin festgehaltenen Attribute, beispielsweise Masse, Position und Geschwindigkeit.

2) PhysX

Diese Klasse verwaltet Objekte der Object-Klasse und enthält das Hauptprogramm und damit die gesamte Physik. Darin befinden sich die Hauptrechenschleife (calculate()-Methode) sowie in einem gesonderten Thread die Ausgabeschleife (output()-Methode), die einem Objekt der Window-Klasse sagt, was wo gezeichnet werden soll.

3) Window

Die Window-Klasse erzeugt im Konstruktor ein Fenster, auf das sie zugreifen kann. Sie beinhaltet den Algorithmus für die Koordinatenumrechnung (convert()-Methode), welcher mithilfe von Variablen aus MouseInputAdapter und KeyAdapter die dreidimensionalen Koordinaten von der PhysX-Klasse rotiert, skaliert und mit einem einstellbaren Sichtwinkel versieht. Die nun zweidimensionalen Koordinaten werden in Objekten der OutData-Klasse zwischengespeichert und später auf dem Display gezeichnet.

4) OutData

In Objekten dieser Klasse werden zu zeichnende Körper, Linien oder Bezeichnungen von Körpern zwischengespeichert (siehe Kapitel 9.2).

5) <<abstract>> Programs

In dieser abstrakten Klasse kann man Programme anfertigen, die die PhysX-Klasse ausführen soll. Einem Objekt der PhysX-Klasse werden Körper im Ausgangszustand übergeben und anschließend wird die Simulation gestartet.

4 Der Programmkern

Den Kern des Programms bildet die Methode der kleinen Schritte. Für sehr kleine Zeitabschnitte wird iterativ für jeden Körper die aus den einzelnen Teilkräften zu jedem anderen Körper summierte Gesamtbeschleunigung berechnet. Damit das Programm weniger Rechnungen durchführen muss, wird anstatt der Kraft über die Grundgleichung der Mechanik1 direkt die Beschleunigung berechnet. Die folgende Formel ergibt sich so als Weiterentwicklung des Gravitationsgesetzes2:

An dieser Stelle noch ein Hinweis: Die Methode der kleinen Schritte führt bei sehr vielen Körpern und einer zu hoch gewählten Simulationsgeschwindigkeit (zu großen kleinen Schritten) dazu, dass sich „enge“ Umlaufbahnen „aufblähen“. Bei sehr geringen Abständen wird die Beschleunigung so groß, dass die im nächsten Rechenschritt daraus berechnete Position zu weit vom Zentralkörper entfernt ist, sodass der Körper nach Periheldurchgang nicht mehr ausreichend abgebremst wird und oft sogar Fluchtgeschwindigkeit erreicht.

Aus der Gesamtbeschleunigung werden dann die neue Geschwindigkeit und schließlich die neue Position des Objekts berechnet3:

Diese Rechnungen werden für alle drei Raumrichtungen ausgeführt. Die Werte für Geschwindigkeit und Position werden als Kopie gespeichert. Sobald alle Objekte berechnet wurden, werden die Originalwerte mit der Kopie überschrieben, sodass alle Objekte scheinbar zum gleichen Zeitpunkt aktualisiert werden.

Die Variable t (im Programm ts) ist die Dauer eines Zeitabschnitts und wird nach jeder Berechnung aktualisiert. Die Zeit T, die ein Rechenschritt benötigt, wird gemessen und mit dem vorherigen Wert von t im an den Wert von t angepassten Verhältnis verrechnet. Dadurch kann sich der Wert von t zu Gunsten einer konstanten Simulaionsgeschwindigkeit dynamisch an die Rechengeschwindigkeit des Computers anpassen und zugleich werden zu große Schwankungen von t verhindert, die zu Rechenungenauigkeit und sogar zum Absturz des Programms führen würden. Die Variable tspd ermöglicht das Einstellen der Simulationsgeschwindigkeit. Das ist der (sehr stark gekürzte) Quellcode der Hauptschleife:

5 Der Einbau der Relativitätstheorie

5.1 Relativistische Massenzunahme

Ich habe die Periheldrehung durch mein Programm entdeckt. Erst danach las ich zufällig, dass sie in der Realität existiert und Folgeeffekt der relativistischen Massenzunahme ist.

Zur Implementierung dieser ist es zunächst notwendig, die Körper mit der Variable m0, der Ruhemasse, auszustatten. Im Programmkern muss dann noch die Funktion ergänzt werden, die die bewegte Masse4 m bei jedem Körper in jedem Rechenschritt in Abhängigkeit von Ruhemasse und aktueller Geschwindigkeit aktualisiert:

5.2 Ausbreitungsgeschwindigkeit der Gravitation als Wirkung

Die Wirkung Gravitation kann sich genauso wie Licht nur mit Lichtgeschwindigkeit ausbreiten. Ein Körper B wird von der Gravitation eines Körpers A erst nach einer gewissen Zeit erfasst, welche von der Entfernung der Körper abhängig. Es gilt die Formel für die konstante Geschwindigkeit5:

Ganz so einfach ist es leider nicht. Denn sieht man in der Zeit um zurück, dann hat Körper B bereits eine ganz andere Position und auch eine andere (bewegte) Masse, die von Körper A nun entweder mehr oder weniger weit entfernt ist.

Sie fragen sich an dieser Stelle sicherlich, wie man denn in die Vergangenheit sieht. Dazu muss diese aufgezeichnet werden, oder besser die Positionen und Massen aller vorhandenen Objekte.

Mein Programm besitzt die sphere()-Methode, durch die Körper nicht aus einem kugelförmigen Raum um den Koordinatenursprung „ausbüchsen“ können. Diese Methode hat den Nebeneffekt, dass zwei Körper nie weiter als den Durchmesser d der Kugel entfernt sind:

Das bedeutet, dass ich die Vergangenheit nur bis nach aufzeichnen muss, was dazu führt, dass ich nicht unendliche Speicherkapazitäten benötige. Leider gibt es noch ein Problem: Ich kann den Zeitfluss nur in einer gewissen Auflösung (beispielsweise 1000 „Zeitabbilder“ pro Sekunde) aufzeichnen, da der Speicher und auch die Geschwindigkeit pro Rechenschritt der Hauptschleife begrenzt sind. Dies lässt sich jedoch programmtechnisch bewältigen.

Nun verfüge ich also über eine zeitliche Aufzeichnung der Positionen und Massen aller vorhandenen Körper, kann also in die Vergangenheit des Raumes einsehen.

Mein Programm berechnet nun zunächst die ungefähre Entfernung von Körper A nach Körper B zum Zeitpunkt :

Anschließend wird der Abstand von Körper A zu dem um in der Vergangenheit liegenden Körper B neu berechnet und ausgehend von um den zeitlichen Abstand vom vorherigen berechneten Abstand angepasst:

Dem folgen nach obigem Schema weitere Rechenschritte:

Die neu berechnete zeitliche Abweichung muss logischerweise immer kleiner werden, da sich kein Körper schneller als c bewegen kann. Es läuft also auf einen Grenzwert hinaus.

[...]


1 Dr. Tilman Pehle, Dr. Lutz Engelmann: Formelsammlung Naturwissenschaften. 1. Auflage, H. Heenemann, Berlin, 2013, S. 5

2 Dr. Tilman Pehle, Dr. Lutz Engelmann: Formelsammlung Naturwissenschaften. 1. Auflage, H. Heenemann, Berlin, 2013, S. 15

3 Dr. Tilman Pehle, Dr. Lutz Engelmann: Formelsammlung Naturwissenschaften. 1. Auflage, H. Heenemann, Berlin, 2013, S. 10

4 Dr. Tilman Pehle, Dr. Lutz Engelmann: Formelsammlung Naturwissenschaften. 1. Auflage, H. Heenemann, Berlin, 2013, S. 12

5 Dr. Tilman Pehle, Dr. Lutz Engelmann: Formelsammlung Naturwissenschaften. 1. Auflage, H. Heenemann, Berlin, 2013, S. 10

Ende der Leseprobe aus 20 Seiten

Details

Titel
Relativistische n-Körper-Simulation. Gravitationswellenforschung am Laptop durch hocheffiziente Java-Programmierung
Veranstaltung
Jugend Forscht Landeswettbewerb Bayern
Autor
Jahr
2016
Seiten
20
Katalognummer
V320721
ISBN (eBook)
9783668202160
ISBN (Buch)
9783668202177
Dateigröße
889 KB
Sprache
Deutsch
Anmerkungen
Jugend forscht Sonderpreis
Schlagworte
Physik, Astronomie, Gravitation, Gravitationswellen, n-Körper, n-body, Java, Simulation, Sonnensystem, Galaxie, Sternhaufen, Cluster, CPU, Planeten, Planet 9, Monde, Asteroiden, Kometen, Programm, Code, Quellcode, Jugend Forscht, NASA, JPL, Jet Propulsion Laboratory, Kepler, Orbit, Bahn, Sonne, Merkur, Venus, Erde, Mars, Jupiter, Saturn, Uranus, Neptun, Ceres, Pluto, New Horizons, Laptop, PC, Computer, Standardbibliotheken, JFrame, Grafik, Grafikausgabe, 3D, Raum, Zeit, Spacetime, Umlaufbahn, osculating orbit
Arbeit zitieren
Moritz Lehmann (Autor), 2016, Relativistische n-Körper-Simulation. Gravitationswellenforschung am Laptop durch hocheffiziente Java-Programmierung, München, GRIN Verlag, https://www.grin.com/document/320721

Kommentare

  • Noch keine Kommentare.
Im eBook lesen
Titel: Relativistische n-Körper-Simulation. Gravitationswellenforschung am Laptop durch hocheffiziente Java-Programmierung


Ihre Arbeit hochladen

Ihre Hausarbeit / Abschlussarbeit:

- Publikation als eBook und Buch
- Hohes Honorar auf die Verkäufe
- Für Sie komplett kostenlos – mit ISBN
- Es dauert nur 5 Minuten
- Jede Arbeit findet Leser

Kostenlos Autor werden