Als Himmelsmechaniker der besonders an der Bewegung von Planeten und Asteroiden interessiert ist, bin ich auf Simulationen angewiesen. Wir können (zumindest in unserem Sonnensystem) die Himmelskörper zwar beobachten – wenn auch nicht alle – aber ihre Bewegung ist zu langsam, um ihre Bewegung direkt und rein aus Beobachtungsdaten vernünftig analysieren zu können.
Der äußerste Planet unseres Sonnensystems, Neptun, braucht für einen Umlauf beispielsweise 165 Jahre. Er wurde aber erst 1846 entdeckt. Und obwohl das schon 164 Jahre her ist, ist es doch noch nicht lang genug um einen kompletten Neptunumlauf beobachten zu können. Glücklicherweise müssen wir das aber auch nicht. Wir kennen ja die Kräfte, die für die Bewegung der Himmelskörper verantwortlich sind. Diese Kräfte können wir mathematisch beschreiben und damit auch Modelle eines Planetensystems basteln das wir dann am Computer betrachten. Hier können wir die Zeit schneller laufen lassen und zusehen, wie sich die Planeten und Asteroiden bewegen würden, wenn wir lange genug beobachten könnten.
Kleine Programme, die solche Simulationen durchführen gibt es haufenweise (hier habe ich mal eines vorgestellt). Die sind aber eher nette wissenschaftliche Spielereien und für die echte Forschung nicht wirklich brauchbar. Dabei gibt es auch professionelle Programme frei verfügbar – und die sind oft nichtmal kompliziert.
Das Programm, das ich hier vorstellen möchte heisst “Mercury“. Entwickelt wurde es von John Chambers auf dessen Homepage man das Paket auch runterladen kann.
Was macht Mercury?
Mit Mercury lässt sich die Bewegung eines beliebigen Planetensystems simulieren. Man hat einen Zentralkörper (den Stern) und dazu große und kleine Himmelskörper wie Planeten oder Asteroiden. Man kann sich mit Mercury nun ansehen, wie deren Bewegung unter ihrem gegenseitigen gravitativen Einfluss aussieht.
Ich habe den ganzen Prozess einer himmelsmechanischen Simulation früher schonmal in einer kleinen Serie (Teil 1, Teil 2, Teil 3, Teil 4) beschrieben und möchte mich hier nicht wiederholen.
Ich möchte auch nicht auf die genaue mathematische Methode eingehen, mit der Mercury die der Planetenbewegung zugrunde liegenden Differentialgleichungen löst (es handelt sich dabei nicht um die Methode der Lie-Reihen, die ich hier schonmal vorgestellt habe). Wer die Details wissen möchte, der kann das in Chambers’ Artikel nachlesen (“A hybrid symplectic integrator that permits close encounters between massive bodies”, MNRAS 304, 793 (1999))
Ich möchte hier erklären, wie jeder dieses Programm benutzen kann, um selbst die Bewegung der Himmelskörper auf professionellen Niveau zu untersuchen
Installation
Bevor man Mercury verwenden kann, muss man es erstmal installieren. Das ist nicht so einfach wie bei “normalen” Programmen. Es gibt keine schicken grafischen Installationsassistenten oder ähnliches – hier ist Handarbeit gefragt 😉
Zuerst einmal lädt man sich das Archiv mit den Dateien runter und entpackt es. Linux-Usern muss ich wohl nicht erklären, wie man ein tar-file entpackt und die gängigen Windowsprogramme sollten das von alleine schaffen.
Ihr habt nun einige Dateien vor euch. Diejenigen, deren Endung “.for” lautet, stellen die Komponenten des eigentlichen Programs dar. Es ist der Fortran-Quellcode von Mercury6 und wer nicht wirklich weiß was er tut, sollte diese Dateien lieber nicht bearbeiten. Was man aber tun muss, ist die Dateien zu kompilieren. Man muss aus dem Quellcode ein ausführbares Programm machen. Unter Linux sollte sich leicht ein passender Kompiler finden lassen Ich verwende meistens “g77”, der mittlerweile aber gfortran heisst soweit ich das mitbekommen habe. Mit dem Befehl
g77 -O -o mercury6 mercury6_2.for
wird aus dem Quellcode (“mercury6_2.for”) eine ausführbare Datei (“mercury6”) erzeugt. Auf diese Weise kompiliert man am besten gleich auch noch “element6.for” und “close6.for”. Natürlich kann man die Fortran-Dateien auch unter Windows kompilieren. Ich weiß gerade nicht, welche Programme hier momentan empfehlenswert sind – ich glaube, ich habe Mercury mal mit dem Watcom Fortran Compiler kompiliert.
Ok – gehen wir davon aus, dass wir nun ein lauffähige Versionen von Mercury haben. Nun müssen wir dem Program natürlich noch sagen, was wir genau simulieren wollen. Dafür gibt es eine Reihe von Inputdateien, die wir editieren müssen.
Was soll Mercury machen
Wichtig sind hier vor allem die Dateien mit den Namen “big.in” und “small.in”. So wie die meisten numerischen Simulationsprogramme unterscheidet auch Mercury zwischen “großen” und “kleinen” Himmelskörper. Große Objekte sind massiv genug, um alle anderen Himmelskörper durch ihre Gravitationskraft zu beeinflussen. Kleine Objekte spüren nur die Gravitationskraft aller anderen Körper; sind selbst aber zu winzig um einen merkbaren Gravitationseinfluss auszuüben; dieser wird vernachlässigt.
Typischerweise trägt man bei “big.in” die Planeten ein, die man simulieren will; bei “small.in” finden sich dann Asteroiden, Kometen oder anderer “Kleinkram”. Man sollte sich hier gut überlegen, was man alles inkludieren will. Während man von den “kleinen” Objekten durchaus sehr viele gleichzeitig simulieren kann (sie beeinflussen einander ja nicht) steigt der Rechenaufwand enorm mit der Zahl der “großen” Körper – denn hier muss ja immer ausgerechnet werden wie jedes einzelne Objekt jedes andere beeinflusst.
Mercury kommt gleich mit voll funktionsfähigen Inputdateien. In der mitgelieferten “big.in”-Datei sind die passenden Werte für alle Planeten (plus Pluto) angegeben. Das sieht so aus:
Die ersten beiden wichtigen Angaben, die man hier machen muss, sind die für “style” und “epoch”. Unter “style” spezifiziert man, wie genau man die Parameter der Himmelskörper angegeben hat. Im Beispiel ist “Cartesian” eingestellt – das bedeutet die Planeten werden durch die Angabe ihrer heliozentrischen x,y und z-Koordinaten und durch die Angabe ihre x, y und z-Geschwindigkeitskomponenten beschrieben (zu den anderen Optionen sage ich später etwas). Der Punkt “epoch” ist der Zeitpunkt – aufgeschrieben im julianischen Datum, für den die Angaben gültig sind. Diese Information wird dann später noch nützlich sein…
Dann kommen die Daten der Planeten selbst. In der ersten Zeile steht jeweils der Name des Objekts, seine Masse (in Einheiten der Sonnenmasse), ein Wert für “r” der uns vorerst nicht weiter zu interessieren braucht und die Dichte des Planeten (die eigentlich auch nicht relevant für die allermeisten Berechnungen ist). Danach folgen die schon oben genannten Werte für Position und Geschwindigkeit und schließlich drei weitere Zahlen die im Beispiel alle den Wert “0” haben (die haben mit dem Drehmoment des Körpers zu tun und sind fürs erste auch uninteressant).
Die Datei “small.in” sieht ähnlich aus:
Auch hier wird am Anfang spezifiziert, in welchen Format die Daten angegeben sind. In diesem Fall ist es “asteroidal” – das bedeutet, dass man nicht x,y und z-Koordinaten angibt sondern dessen Bahnelemente.
Der Zeitpunkt für den diese Elemente gültig sind (“epoch”) wird diesmal für jeden kleinen Körper einzeln angegeben. Das ist der Wert der bei “ep” gleich neben dem Namen des Objekts steht. Diese Zeitpunkte können identisch sein – müssen aber nicht. Sind die Zeiten verschiedenen, dann rechnet der Integrator erstmal alle Parameter auf den gleichen Zeitpunkt um bevor die eigentliche Simulation startet.
Jetzt hat man eigentlich schon das wichtigste geschafft – es fehlen allerdings noch einige allgemeine Angaben zur Simulation. Die gibt man in der Datei “param.in” an:
Wichtig sind hier vor allem die ersten 6 Zeilen. Mit “algorithm” wählt man die numerische Methode aus, die für die Simulation verwendet werden soll. Hier ist für die meisten Anwendungen “HYB” die beste Wahl. Dieser “Hybrid-Integrator” wählt je nach den aktuellen Bedingungen automatisch die beste Methode aus. Natürlich muss das Programm auch wissen, wie lange es simulieren soll. Dafür gibt man Start- und Stopzeitpunkt (wieder im Julianischen Datum) an. Das “Output-Interval” ist der Zeitraum, für den man seine Datenpunkte bekommen möchte. Wenn ich beispielsweise die Bewegung der Himmelskörper eine Million Jahre lang berechne, dann möchte ich vielleicht nicht für jeden einzelnen Tag alle Positionen aller Objekte erfahren (die Datenmenge wäre enorm groß) sondern z.B. nur alle 10000 Jahre. Dieser Zeitraum kann hier spezifiziert werden. Sehr wichtig ist der Wert bei “timestep”. Das ist der Zeitschritt der Integration und diesen Wert auszuwählen ist knifflig. Ich habe das hier schonmal genauer beschrieben. Als Richtwert (der aber wirklich nur als solcher zu betrachten ist) kann man hier etwa 10% der kürzesten Umlaufzeit eines in der Simulation auftretenden Himmelskörpers nehmen.
Den “accuracy parameter” kann man fürs erste ignorieren – genauso wie die Einstellungen, die man in den nächsten Zeilen machen kann. Wichtig sind nur zwei Parameter aus dem letzten Absatz. Bei “radius of central body” und “central mass” muss man die entsprechenden Werte für den Zentralstern des Planetensystems eingeben.
Rechnen und Auswerten
Hat man das alles eingestellt (bzw. nur angesehen – denn die Beispieldateien sind ja schon korrekt ausgefüllt), dann kann es eigentlich losgehen. Will man die Namen der ganzen Inputdateien ändern, dann muss man das noch in “files.in” angeben und danach kann man “mercury6” laufen lassen. Macht man das mit den Beispieldateien, sollte das Ergebnis so aussehen:
Die ganzen Zahlen die hier stehen, braucht man auch erstmal nicht genau zu verstehen – interessant ist vielleicht das, was bei “dE/E” und “dL/L” steht. Hier wird angegeben wie sich Gesamtenergie und -drehimpuls des Systems im Laufe der Zeit geändert haben. Da die Energie- bzw. Drehimpulserhaltung gilt, sollten diese Werte natürlich sehr klein sein!
Aber was hat das Programm denn nun simuliert? Die Ergebnisse finden sich in einer neuen Datei namens “xv.out” die man erst bearbeiten muss, um sie betrachten zu können. Dazu braucht man das Programm “element6”, das aus dieser Datei die richtigen Ergebnisse extrahiert. Man editiert dazu die Datei “element.in” – hier muss man angeben, welche Datei bearbeite werden soll (“xv.out”), in welchen Format die Daten ausgegeben werden sollen, welcher Zeitraum zwischen den Ausgabeschritten liegen soll und natürlich welche Daten ausgegeben werden sollen! Hier kann man aus einer langen Liste von Möglichkeiten wählen (die einzelnen Parameter sind alle in der Bedinungsanleitung “mercury6.man” aufgeführt). Im Beispiel findet man hier folgende Zeile:
a8.5 e8.6 i8.4 g8.4 n8.4 l8.4 m13e
Sieht kryptisch aus, ist aber simpel. “a” steht für die große Halbachse des Objekts – “a8.5” heisst, dass der Wert auf 8 Stellen genau, 5 davon hinter dem Komma ausgegeben werden soll. “e” steht für die Exzentrizität der Bahn; “i” für die Inklination, etc.
Lässt man nun das Programm “element6” laufen erhält man einen Haufen neue Dateien mit der Endung “.aei”. Das sind nun die eigentlichen Resultate der Simulation. So sehen sie beispielsweise für den Asteroiden APOLLO (einer aus der Datei “small.in”) aus:
Man sieht hier genau, was sich im Simulationszeitraum von 30 Jahren getan hat. Die große Halbachse der Bahn des Asteroiden ist beispielsweise von 1.47105 astronomischen Einheiten auf 1.47075 gewachsen während die Bahnexzentrizität von 0.560011 auf 0.559899 gesunken ist.
Gut – das alles ist noch nicht wirklich schön bunt und spektakulär. Man kann diesen Output mit den Rohdaten vergleichen, die ein beobachtender Astronom von seinem Teleskop bekommt. Da muss man nun noch analysieren, reduzieren und ein paar nette grafische Programme benutzen um schließlich schöne Plots zu bekommen. Aber dann sieht man zum Beispiel so wie im nächsten Bild sehr schön wie sich die Exzentrizitäten der Erd- und Venusbahn gekoppelt und gegengleich im Laufe der Jahrtausende ändern:
Soweit zum Einsteigercrashkurs “Sonnensystemsimulation” 😉 Mit mercury6 kann man noch viel mehr machen – ich habe z.B. noch nicht erklärt, wozu das Program “close6” gut ist und wie das mit den nahen Begegnungen und den Kollisionen ist. Aber das muss man auch nicht wissen um das Program erstmal kennenzulernen – und bei Interesse erkläre ich das gern in einem späteren Beitrag. In der Bedienungsanleitung (“mercury6.man”) werden alle Aspekte und Details nochmal genau erklärt – und wenn noch Fragen offen sind, dann antworte ich natürlich auch gerne! Wer also bisher durchgehalten und immer noch Lust hat, solche Simulationen zu rechnen, dem wünsche ich viel Erfolg!
Und wer dabei auf den Geschmack gekommen ist, der soll mir Bescheid sagen! Ich kann immer Leute (und vor allem Computer 😉 ) brauchen die mir bei meinen Simulationen helfen (die dann doch etwas umfangreicher sind als die paar Asteroiden und 30 Jahre im Beispiel 😉 ).
Kommentare (31)