Samstag, 30. März 2013

Heal the World, make it a better place...

Da macht DWüdW eine kleine Pause in ihrem Osterüberraschungsprojekt, um zu sehen, was es in der Welt so neues gibt, und dann liest sie in der Welt: Gregor Gysi meint, der Papst solle die Sexualethik der Kirche reformieren! Da konnte sich DWüdW sofort vorstellen, wie der Papst in seinem vatikanischen Jugendherbergszimmer sitzt und noch darüber nachgrübelt, ob er sich mit dem Waschen von Frauenfüßen an Gründonnerstag aus rein fundamentaltheologischer Sicht nicht doch ein bisschen zu weit aus dem Fenster gelehnt hat. Um sich abzulenken, schlägt der Die Welt auf, schließlich will er sich über das Weltgeschehen auf dem Laufenden halten, und sofort muß er sich fragen: Vielleicht hat dieser Herr Gysi ja recht? Sollte ich, was das Pimpern angeht, nicht doch lieber ein wenig relaxter sein?
Glücklich mit dieser Vorstellung blätterte DWüdW etwas weiter in ihrem Reader und was las sie da? Guido Westerwelle fordert in der Bild: "Das unverantwortliche Spiel Nordkoreas mit dem Feuer muss aufhören!" Da wird die Führung Nordkoreas heute in Aufruhe sein! Als Land, daß ein paar nukleare Knallfrösche zum Verpuffen gebracht hat, den USA - und damit einem Land, daß 5113 Atomstrengköpfe einsatzbereit hält - mit einem atomaren Erstschlag zu drohen, mag ja eine Sache sein. Sich's mit Guido Westerwelle verscherzen aber eine ganz andere! Daher wird es wohl noch erhebliche Diskussionen um die eigene Strategie in Nordkoreas Führerbunkern geben - spätestens, wenn das nordkoreanische Auslandsabo der Bild in Pjöngjang eingetroffen ist...

Bei soviel Einsatz für die Verbesserung der Welt will DWüdW natürlich nicht nachstehen. Und was Gregor Gysi, Guido Westerwelle und der Papst können, das kann DWüdW ja schon lange! Also wird sie diese Ostern durch knallharte Rhetorik und entschlossene Symbolpolitik ihren ganz eigenen Beitrag für eine bessere und gerechtere Zukunft leisten! Als Zeichen ihrer neuen Sorge um die Armen der Welt und den Willen, überkommene Geschlechterrollen zu reformieren, hat sich DWüdW diese Ostern entschlossen, seiner naturgeilen moldawischen Zwangsprostituierten Trinkgeld geben! Von Kim Jong Un fordert DWüdW, sich endlich einen anständigen Haarschnitt zuzulegen! Außerdem hält DWüdW diese ständigen Provokationen nicht länger für hinnehmbar. DWüdW erwartet von Justin Bieber die sofortige Einstellung sämtlicher musikalischer Aktivitäten!

Freitag, 22. März 2013

Schwule, Frauen, Schulden

In menschlichen Gesellschaften gibt es ein Phänomen namens "Naturalisierung". Der Begriff meint, daß soziale, menschengemachte Normen oder Konventionen von Mitgliedern der Gesellschaft so sehr verinnerlicht werden, daß sie nicht mehr länger als sozialen Ursprungs wahrgenommen werden, sondern vielmehr als "natürlich", aus der Natur der Welt heraus entspringend. Die Konvention, bei Rot an der Ampel zu halten etwa wird man allgemein als rein soziale Konvention betrachten. Verstößt jemand gegen sie, so wird man das Verhalten des Betreffenden wohl als unsozial und unangebracht empfinden, nicht aber als "widernatürlich". Als Gegenbeispiel wird man vielleicht an homosexuelle Beziehungen denken, die von ihren Gegnern immer wieder gerne als "widernatürlich" bekämpft werden. Das ist natürlich vollkommener Unsinn. Man kann nicht nur kein Naturgesetz denken, das gleichgeschlechtliche Sexualkontakte ausschließt, man findet sie vielmehr durch alle Zeiten hindurch beim Menschen wie auch bei anderen Spezies. Homosexualität wäre nur dann "widernatürlich", würde man der Natur selbst vorwerfen wollen, widernatürlich zu sein. Offenbar aber haben manche Menschen die gesellschaftliche Ablehnung homosexueller Lebensweisen so sehr verinnerlicht, daß sie diese geradezu als Verstoß gegen Naturgesetze empfinden. Der Verstoß gegen eine naturalisierte Norm scheint so ungeheuerlich und gefährlich, wie sich gegen den Lauf der Sonne aufzulehnen.
Nun ist der Prozess der Naturalisation nicht zwangsläufig etwas Negatives. Sie ist ein ausgesprochen starkes Instrument sozialer Ordnung und eignet sich damit gut, Grundsätze, ohne die weder ein gesellschaftliches noch ein persönliches Leben zu funktionieren in der Lage wäre, gleichsam als feste Pfeiler einzurammen. Und geeignete Grundsätze können durchaus positive Wirkungen entfalten. Doch aufgrund seiner Stärke führt dieser Prozess immer wieder zu gewaltigen negativen Folgen. Von solchen betroffen sind längst nicht nur (echte oder vermeintliche) Minderheiten, sie können mühelos auch große Gesellschaftsgruppen, gar die Mehrheit erfassen und sie gegen ihre eigenen Interessen in Stellung bringen. So läßt sich vielleicht verstehen, weshalb es im frühen 20. Jahrhundert Frauenorganisationen gab, die sich energisch gegen ein Frauenwahlrecht engagierten [1][2]. Offenbar haben genug Frauen die damals durchaus noch gängige Ansicht, Frauen seien für die Politik ungeeignet und würden dort nur zu Problemen führen, so sehr verinnerlicht, daß sie dies für quasi natürlich gegeben betrachteten und so für ihre eigene Benachteiligung kämpften.
Es liegt im Wesen der Sache, daß ein solches Verhalten den Zeitgenossen nicht leicht auffällt. Und so ist es womöglich häufiger anzutreffen, als man meinen möchte. Angesichts der heutigen Wirtschaftspolitik etwa drängt sich der Eindruck auf, die Mehrheit der Bevölkerung in Deutschland und Europa sei bereit, Entwicklungen und Vorgehensweisen hinzunehmen, die gegen ihre eigenen Interessen gerichtet sind und nur einer Minderheit zum Vorteil reicht. Denn diese Entwicklungen scheinen ebenfalls quasi naturgegeben. Vermeintlich unausweichlichen Gesetzten der Ökonomie folgend werden sie kaum infrage gestellt, sie sind "alternativlos". Doch tatsächlich folgt die Ökonomie auch nichts weiter als menschengemachten Konventionen. Und daß all diese Konventionen jederzeit nach Belieben geändert werden könnten, sofern nur genug Mut und Organisationstalent aufgebracht würde, wird dabei geflissentlich übersehen, ignoriert, als Ungeheuerlichkeit gemieden. Wer will es schon wagen, sich gegen den Lauf der Sonne aufzulehnen? Nun, irgendwann werden die dringend nötigen Veränderungen nicht mehr aufgeschoben werden können. Und wie im Falle des Frauenwahlrechts wird es im Rückblick nur noch kurios und ein bisschen traurig anmuten, daß sich auch die Geschädigten selbst so lange den notwendigen Verbesserungen widersetzt hatten.

Sonntag, 17. März 2013

Der Komet aus Guttenbergs Universum

Ach ja, die beiden Kometen dieses Jahr werden hier noch eine Menge Freude machen, das hab ich so im Gefühl. Gestern etwa schrieb der Focus-Redakteur und Zentralgestirn in "Odenwalds Universum", Michael Odenwald einen vierteiligen Artikel auf Focus Online über die beiden interessanten Kometen des Jahres, PanStarrs und Ison. Neugierig machen folgende Zeilen:
„Wie eigentlich immer in solchen Fällen wird es sich in Wirklichkeit um eine unglaublich langgestreckte Ellipse handeln, die sich durchaus ein Lichtjahr weit in den Raum hinaus erstrecken kann“, konstatiert die Internet-Seite „komet-ison“. „Seine Umlaufszeit bemisst sich also vermutlich auf Hunderttausende oder gar Millionen Jahre.“.
Die Adresse der erwähnten Quelle "komet-ison" ist unvollständig, deren Autor ist nicht erwähnt und verlinkt ist sie auch nicht. Aber dafür gibt es vielleicht einen Grund. Und wenn man die "Internet-Seite komet-ison" des Amateurastronomen Stefan Krause sucht und sich durchliest, dann kommt einem einiges bekannt vor - aus dem Focus Online-Text von Michael Odenwald. Denn der hat sich längst nicht nur der beiden oben angegebenen Zitate bedient. Kleine Kostproben? Bitte. Textausschnitte aus dem Focus-Artikel sind in blau, Textstücke aus komet-ison.de in rot:

Die meisten Kometenkerne haben Durchmesser von wenigen 100 Metern bis einigen Kilometern. Größere Brocken können einige Dutzend Kilometer groß sein. Hale-Bopp etwa erreicht rund 50 Kilometer. Entsprechend wurde dieser Komet sehr hell, obwohl er weder der Sonne noch der Erde besonders nah kam.
Die allermeisten Kometenkerne messen jedoch nur wenige hundert Meter bis einige Kilometer im Durchmesser. Dagegen bringt es der Kern von Hale-Bopp (C/1995 O1) auf etwa 50 Kilometer. Entsprechend wurde dieser Komet extrem hell, obwohl er weder der Sonne noch der Erde besonders nah kam.

Der Komet wurde bereits in großer Sonnenentfernung entdeckt und besaß dabei bereits eine gut entwickelte Koma. Sie entsteht durch Gas und Staub, die sich aus dem Himmelskörper bei Annäherung an die Sonne verflüchtigen. Dies weist auf einen überdurchschnittlich großen und aktiven Kometenkern hin.
Die Tatsache, dass ISON bereits in sehr großer Sonnenentfernung entdeckt wurde und dort bereits eine gut entwickelte Koma besaß, deutet jedenfalls auf einen überdurchschnittlich großen und aktiven Kometenkern hin.

Jedes Jahr entdecken Sterngucker Dutzende neuer Schweifsterne
Hinzu kommen die bekannten kurzperiodischen Kometen (ein Umlauf dauert weniger als 200 Jahre), von denen sich fast immer einer oder mehrere in Sonnen- und/oder Erdnähe aufhalten. In aller Regel lassen sie sich nur mit Teleskopen oder lichtstarken Feldstechern beobachten, nur gelegentlich taucht einer als verwaschener Nebelfleck auf, der mit bloßem Auge sichtbar ist. Ein heller Komet mit deutlich ausgeprägtem Schweif ist nur alle fünf bis zehn Jahre zu erwarten.
Jedes Jahr werden inzwischen dutzende, wenn nicht über 100 neue Schweifsterne entdeckt. Hinzu kommen die bekannten kurzperiodischen Kometen, von denen sich fast immer einer oder mehrere gerade in Sonnen- und/oder Erdnähe aufhalten. Doch in aller Regel sind sind sie nur in Teleskopen oder allenfalls in lichtstarken Feldstechern zu beobachten; nur gelegentlich wird einer als verwaschenes Nebelfleckchen so gerade eben für das bloße Auge sichtbar. Ein wirklich heller Komet mit prächtigem Schweif ist im Durchschnitt nur alle 5 - 10 Jahre zu erwarten.

Seit der Urzeit des Sonnensystems schwirren wahrscheinlich Milliarden, vielleicht auch Billionen solcher Körper in der „Oort´schen Wolke“ umher, die sich ein halbes Lichtjahr weit ins All erstreckt
Entstanden sind diese Gebilde zusammen mit dem übrigen Sonnensystem. Seitdem, so nimmt man an, umkreisen wahrscheinlich Milliarden, vielleicht auch Billionen von Ihnen die Sonne in mehr als einem halben Lichtjahr Entfernung in der Oortschen Wolke.

Ein weiteres Reservoir ist der Kuiper-Gürtel, in dem ein Schwarm eisiger Körper jenseits der Neptunbahn kreist. Gravitative Störungen nahe vorbeiziehender Sterne, die Gezeiten der Milchstraße oder die Schwerkraft der großen Planeten reißen gelegentlich einen dieser großen Eisbrocken aus seiner Bahn, so dass er Kurs auf das innere Planetensystem nimmt.
Bewiesen ist inzwischen die Existenz des Kuiper-Gürtels, eines Schwarms eisiger Körper, die außerhalb der Neptunbahn kreisen. Durch gravitative Störungen nahe vorbeiziehender Sterne, die Gezeiten der Milchstraße (Oortsche Wolke) oder durch die großen Planeten (Kuiper Gürtel) wird ab und an ein solcher Eisbrocken aus seiner Bahn gerissen und nimmt Kurs auf das innere Planetensystem.  

Bei seinem Anflug auf die Sonne erwärmt sich der Kometenkern, und das Eis und die gefrorenen Gase sublimieren (das heißt, sie gehen ohne Umweg über die flüssige Phase direkt in die Gasphase über)
Wenn er sich der Sonne nähert, erwärmt er sich und die gefrorenen Gase sublimieren.

Dadurch werden die mit Ihnen verbackenen Partikel freigesetzt und strömen durch düsenartige Poren aus dem Kern. Um diesen bildet sich die Koma als eine bis zu 100 000 Kilometer und mehr durchmessende Wolke. Der Sonnenwind entreißt ihr Gasmoleküle und Staub. Aus ihnen bildet sich der stets von der Sonne weg gerichtete Kometenschweif, der sich bis zu 100 Millionen Kilometer durch den Weltraum erstrecken kann.
Dadurch werden auch die mit Ihnen verbackenen festen Partikel freigesetzt. Um den meist nur wenige Kilometer grossen Eisbrocken, den Kometenkern bildet sich eine bis zu 100000 km und mehr durchmessende Wolke aus Gas und Partikeln, die Koma. Durch den Sonnenwind werden Gasmoleküle und Staub aus der Koma herausgerissen - der Kometenschweif bildet sich. Er kann eine Länge von bis zu 100 Millionen Kilometern erreichen.

So wird aus einem lichtschwachen „schmutzigen Schneeball“ eine imposante Himmelserscheinung.
Aus dem unscheinbaren "schmutzigen Schneeball" ist eine imposante Himmelserscheinung geworden.

Nach ihren Besuchen im inneren Sonnensystem entschwinden Kometen wieder in die Fernen des Kuiper-Gürtels oder der Oort´schen Wolke – sofern sie nicht in die Sonne stürzen, was nicht selten geschieht. Fliegen sie aber unbeschadet davon, kehren sie erst nach Jahrhunderten, Jahrtausenden oder gar Jahrmillionen zurück.
Wenn er nicht in die Sonne stürzt, was durchaus vorkommt, entschwindet der Komet nach seiner Galavorstellung wieder in die Fernen des Kuiper-Gürtels oder der Oortschen Wolke, um erst nach Jahrhunderten, Jahrtausenden oder Jahrmillionen zurückzukehren.

An dieser Stelle habe ich mal mit der Suche nach den Vorlagen des Herrn Odenwald aufgehört. Begeistert bin ich von der journalistischen Leistung beim Focus allemal schon - die Technik des dezenten Umformulierens beherrscht man dort perfekt! Wenn das mal keine Leistung ist, die nach einem besonderen juristischen Schutz verlangt, in diesen harten Zeiten...!

Freitag, 15. März 2013

Am Anfang war was auch immer

Was berichtet die Onlineausgabe der Süddeutschen da heute:


Also, wenn man schon auf abgefahrene Kausalketten mit spektakulären Endpunkten abfährt und in einem Elementarteilchen den Ursprung des Lebens ausmacht, dann könnte man doch im Higgs-Boson mit gleichem Recht den Ursprung des Sonnenlichts sehen, den Ursprung des Pantoffeltierchens oder den Ursprung des schlechten Sex?

Neue Hinweise auf Higgs-Teilchen: Physiker nähern sich dem Ursprung des schlechten Sex

-  das wäre doch mal ein knackiger Titel für die Süddeutsche gewesen!

Mittwoch, 13. März 2013

Denkwürdige Momente des Zusammenlebens (IV)

Heute Abend in der Küche:

Er: "Wir haben einen Papst!"

Sie: "Guck' mal, ob wir auch Nudeln haben!"

Dienstag, 12. März 2013

Von Kometen geblendet

Es gibt in den Medien ein beeindruckendes Phänomen. Sprechen Politiker, staatliche Institutionen, Wirtschaftsverbände, so demonstrieren Journalisten gerne ihre Fähigkeit zur gnadenlosen Kritik. Fast schon stolz erscheinen sie, gelingt es ihnen, einer Ministerin eine Frage zu stellen, die sie "überfordert". Ganz anders ist es aber, wenn eine Institution wie die NASA etwas verkündet. Sofort fallen Journalisten allesamt in eine ehrfürchtige Schockstarre und tragen ohne eines Moments des Nachdenkens weiter, was die NASA so alles meint. Denn hey - Hallooo? - , es ist die NASA! Heute z.B. schreibt Spiegel Online anläßlich des erwarteten hellen Kometen C/2011 L4 PanStarrs:
"Laut der US-Weltraumbehörde Nasa gibt es im Schnitt alle fünf bis zehn Jahre die Möglichkeit, einen Kometen mit bloßem Auge am Himmel zu sehen."
Und stimmt, das hat sie tatsächlich so gesagt. Und es ist trotzdem völliger Quatsch. Man muß nur einmal die hellen Kometen der letzten Jahre durchgehen. Nehmen wir, durchaus realistisch, an, ein Komet ist mit bloßem Auge sichtbar, wenn er heller als 6. Magnitude (6m) wird. Dann finden sich im Zeitraum von 2000 bis 2012 (einschließlich) insgesamt 21 Kometen, die mit bloßem Auge sichtbar waren - d.h. etwa 1,6 pro Jahr:

Helle (< 6m.0) Kometen (Katalognummer und Name) nach Jahren:

2012
keiner

2011
keiner

2010
C/2009 R1 McNaught
103P/Hartley 2

2009
C/2007 N3 Lulin

2008
C/2007 W1 Boattini

2007
C/2006 P1 McNaught (*)
C/2007 F1 LONEOS
17P/Holmes (*)
8P/Tuttle

2006
C/2006 A1 Pojmanski
C/2006 M4 SWAN
73P/Schwassman-Wachmann 3

2005
C/2004 Q2 Machholz (*)

2004
C/2001 Q4 NEAT (*)
C/2002 T7 LINEAR (*)
C/2004 F4 Bradfield

2003
C/2002 V1 NEAT (*)
C/2002 X5 Kudo-Fujikawa

2002
C/2000 WM1 LINEAR (*)
C/2002 C1 Ikeya-Zhang (*)
C/2002 F1 Utsunomiya

2001
C/2001 A2 LINEAR (*)

2000
keiner

Gut, zugegeben, ziemlich viele dieser Kometen konnte man nur an sehr dunklen Orten als kleines Pünktchen mit bloßem Auge erkennen. Aber selbst wenn wir uns auf die leicht zu sehenden, mitunter gar spektakulären Kometen dieser Zeit beschränken, bleiben immerhin noch 9 (die mit den Sternchen in der Liste) innerhalb von 13 Jahren. Oder im Schnitt alle 1,4 Jahre einer.
Vielleicht setzt sich irgendwann ja einmal unter Journalisten die Erkenntnis durch, daß auch ehrwürdige wissenschaftliche Institutionen im 21. Jahrhundert PR betreiben (müssen) und die Dinge gerne mal ein bisschen eindrucksvoller, spektakulärer darstellen, als sie tatsächlich sind. Aber dann müsste man sich auch trauen, selber mal über Behauptungen sogar der NASA nachzudenken. In diesem speziellen Fall hätte das SpOn sogar leicht fallen können: Für mindestens sieben dieser Kometen in den letzten 13 Jahren hatte Spiegel Online seinerzeit selbst verkündet, daß man sie mit bloßem Auge sehen könne [1][2][3][4][5]!

Nachtrag 14.3.:
SpOn legt heute noch ein bisschen nach:
"Zuletzt war der Komet Hale-Bopp 1997 am nächtlichen Sternenhimmel mit bloßem Auge zu bewundern."

Donnerstag, 7. März 2013

Extrem-Wikipediing

Seit langem bin ich ja schon ein großer Freund der Wikipedia. Und immer noch muß die Wikipedia gegen die immer wieder gleiche Kritik verteidigt werden: Jeder könne ja einfach reinschreiben, was er wolle, und so sei diese Enzyklopädie grundsätzlich anfällig gegen Manipulation, Dilettantismus und schlichte Fehler. Und so sehr das im Prinzip natürlich stimmt, so wenig ist all dies in der Praxis ein Problem. Im der überwältigenden Mehrheit aller Fälle ist die Wikipedia völlig korrekt. Und dabei von einer Tiefe, die ihresgleichen sucht. Natürlich wäre es schön, das mal an einem netten Beispiel zu veranschaulichen. Also dachte ich, man könne doch mal nach einem schönen Problem suchen und es dann nur mit Hilfe der Wikipedia lösen. Irgendwas nicht zu Simples, man will ja nicht allzu dünne Bretter bohren, aber doch etwas Machbares. Etwas Spannendes und ein bisschen Exotisches. Also machen wir heute mal ein kleines Experiment. Als Problem nehmen wir die Aufgabe, die Positionen und Abstände der Planeten im Sonnensystem zu einem beliebigen Zeitpunkt auszurechnen. Und dazu wollen wir ausschließlich auf Informationen zurückgreifen, die wir in der Wikipedia finden. Keine Fitzelchen einer Methode, kein Zahlenwert soll eingehen, den wir nicht irgendwo in einem Wikipedia-Artikel finden. Gut, wir sind etwas großzügig und wollen auch wo nötig die englischsprachige Wikipedia benutzten, denn die ist doch noch etwas umfangreicher als die deutschsprachige. Aber das ist dann auch schon alles an Zugeständnissen.
Keine Sorge, allzu schlimm wird das gar nicht. Physikkenntnisse benötigen wir quasi gar keine. Was es braucht, sind solide Kenntnisse der Schulmathematik, aber wer hat die schon? Aber wir haben ja die Wikipedia im Rücken, um sie notfalls ein bisschen aufzufrischen. Und wir brauchen ein paar grundlegende Programmierkenntnisse, aber das sollte ja im 21. Jahrhundert zur guten Allgemeinbildung gehören? Wir wollen es auch nicht unnötig kompliziert machen und nehmen eine weit verbreitete Feld-, Wald- und Wiesenprogrammiersprache, Java etwa. Und wir halten den Code auch so schlicht wie möglich. Das sollte mir leicht fallen, denn ich bin auch nicht gerade ein Experte in Java. Aber da zeige ich einfach mal Mut zur Häßlichkeit. Ich meine, Hauptsache, am Ende funktioniert's! Und wer mit Java Probleme hat, der kann sich ja mal bei der Wikipedia in den Artikeln Java (Programmiersprache) und  Java-Syntax ein bisschen einlesen...
So, dann wollen wir mal. Und daß jetzt niemand auch nur daran denke, wegzuklicken oder gleich zum Ende zu springen! Heute geben wir dem kleinen Nerd in uns mal ordentlich Zucker, und keiner verlässt den Raum!

Das Problem an sich

Wenn wir die Positionen der Planeten im Sonnensystem angeben wollen, dann haben wir eigentlich drei Teilprobleme zu lösen: Erstens müssen wir wissen, die die Umlaufbahnen der Planeten aussehen. Also, wirklich genau aussehen, nicht nur so ein allgemeines Blahblah. Dann müssen wir irgendwie ausrechnen können, wo ein Planet zu einer vorgegebenen Zeit gerade auf seiner Umlaufbahn ist. Und dann müssen wir als drittes den Ort auf seiner Umlaufbahn irgendwie in ein allgemeines, von seiner Bahn unabhängiges Koordinatensystem umrechnen. Denn nur in so einem allgemeinen Koordinatensystem für alle Planeten können wir ja die Positionen der Planeten zueinander, und damit ihre Abstände bestimmen.
Zur Lösung der ersten beiden Teilprobleme brauchen wir nichts weiter als die drei Keplerschen Gesetze, an die man sich vielleicht noch dunkel aus der Schule erinnert. Die müssen wir allerdings ordentlich mathematisch ausschlachten. Das dritte Teilproblem ist eigentlich nur ein bisschen Vektorrechnung. Fangen wir also erst einmal bei den Keplerschen Gesetzen an!

Die Keplerschen Gesetze

Die Wikipedia sagt uns, daß die Bewegung der Planeten im Sonnensystem einigermaßen gut durch die Keplerschen Gesetze beschrieben wird: "sie [sind] eine gute Näherung für die tatsächlich in einem Sonnensystem durchlaufenen Planetenbahnen." Nehmen wir also einfach mal an, daß sich die Planeten gemäß den drei Keplerschen Gesetzen bewegen. Das erste der drei Gesetze lautet laut Wikipedia:
"Die Planeten bewegen sich auf elliptischen Bahnen, in deren einem Brennpunkt die Sonne steht."
Nehmen wir das mal beim Wort. Um die Umlaufbahn eines Planeten um die Sonne anzugeben, müssen wir also eine Ellipse angeben. Was brauchen wir, um eine Ellipse im Raum anzugeben? Der von den Keplerschen Gesetzten aus verlinkte Artikel Bahnelemente hilft weiter. Wir brauchen zwei Größen, die die Form der Ellipse bestimmen: eine dieser Größen legt die Ausmaße der Ellipse fest, die andere, wie langgestreckt sie ist. Wir lesen, daß wir hier die große Halbachse für die Größe der Ellipse und die Exzentrizität für ihre Form nehmen können.
Jetzt brauchen wir noch drei Winkel, die angeben, wie die Ellipse im Raum orientiert ist. Der erste dieser Winkel ist die Inklination. Dieser Winkel gibt an, um wieviel die Ebene, in der die Ellipse liegt, gegenüber einer Referenzebene geneigt ist. Als Referenzebene wollen wir hier die Ebene der Erdbahn, die Ebene der Ekliptik, nehmen. Wikipedia meint, das sei durchaus üblich. Die beiden anderen notwenigen Winkel müssen jetzt noch angeben, wie die Ebene, in der die Ellipse liegt, bezüglich einer festgelegten Richtung gedreht ist, und wie die Ellipse innerhalb dieser Ebene gedreht ist. Als festgelegte Richtung in der Bezugsebene, also in der Ebene der Erdbahn, nehmen wir die Richtung des Frühlingspunkts. Das ist die Richtung, in der die Sonne von der Erde aus gesehen am Frühlingsanfang steht. Für die beiden uns noch fehlenden Winkel nehmen wir hier die Winkel mit den schönen Namen Argument des Knotens und Argument der Periapsis. Haben wir diese insgesamt fünf Größen, dann ist die Umlaufbahn eines Planeten im Raum eindeutig festgelegt.
Nur eines fehlt uns, nämlich ein "Startpunkt". Wir müssen noch für einen Zeitpunkt wissen, wo der Planet gerade auf seiner Umlaufbahn ist, dann können wir ausrechnen, wo er zu jedem beliebigen anderen Zeitpunkt ist. Dabei hilft uns dann das zweite Keplersche Gesetz. Als Angabe für den Ort des Planeten auf seiner Ellipse zu einem bestimmten Zeitpunkt nehmen wir die sogenannte Mittlere Anomalie. "Anomalie" ist hier einfach nur ein schönes Wort für Winkel in der Ebene der Bahnellipse. Jetzt haben wir sechs Größen, die wir für einen Planeten kennen müssen, um seine Bewegung komplett beschreiben und seine Position für einen beliebigen Zeitpunkt bestimmen zu können. Das ist alles recht abstrakt, aber der Wikipedia-Artikel Keplerbahn bietet immerhin eine Graphik zur Illustration.
Woher sollen wir diese sechs Größen, die Bahnelemente, bekommen? Aus der Wikipedia natürlich. Die englischsprachige Wikipedia gibt die sechs Größen in den Artikeln zu den einzelnen Planeten in der Tabelle rechts oben unter dem Stichpunkt "Orbital characteristics" an.
Dann wollen wir auch schon mal ans Programmieren gehen. Wir machen uns ein Java-Projekt namens "WikiEphem" und darin ein erstes Paket "solarSystemObject". Als erstes können wir uns eine Aufzählungsklasse erstellen, die die acht Planeten mit ihren Bahnelementen aus der Wikipedia vordefiniert. Das könnte dann etwa so aussehen:

package solarSystemObject;

public enum Planet {
 // Die Zahlenwerte für die Bahnelemente der einzelnen Planeten aus der Wikipedia:
MERCURY(0.387098, 0.205630, 7.005, 48.331, 29.124, 174.796),
VENUS(0.723327, 0.006756, 3.39458, 76.678, 55.186, 50.115),
EARTH(1.00000261, 0.01671123, 0.0, 348.73936, 114.20783, 357.51716),
MARS(1.523679, 0.093315, 1.850, 49.562, 286.537, 19.3564),
JUPITER(5.204267, 0.048775, 1.305, 100.492, 275.066, 18.818),
SATURN(9.58201720, 0.055723219, 2.485240, 113.642811, 336.013862, 320.346750),
URANUS(19.22941195, 0.044405586, 0.772556, 73.989821, 96.541318, 142.955717),
NEPTUNE(30.10366151, 0.011214269, 1.767975, 131.794310, 265.646853, 267.767281);
// Die Bahnelemente der Planeten (für den 1.1.2000, 12:00h, d.h.J2000):
private double a; // Große Halbachse (in AE)
private double e; // Exzentrizität (einheitenlos)
private double i; // Inklination (in Grad)
private double OMEGA; // Argument des aufsteigenden Knotens (in Grad)
private double omega; // Argument des Perihels (in Grad)
private double M; // Mittlere Anomalie (in Grad)
/*
* Konstruktor, der die Planeten "erzeugt":
*/
private Planet(double a,double e,double i,double OMEGA,double omega,double M){
this.a = a;
this.e = e;
this.i = i;
this.OMEGA = OMEGA;
this.omega = omega;
this.M = M;
}
// Die "getters", mit  die Bahnelemente abgefragt werden können.
// (Winkel lassen wir uns gleich ins Bogenmaß umrechnen)
public double getA(){
return this.a;
}
public double getE(){
return this.e;
}
public double getI(){
return Math.toRadians(this.i);
}
public double getOMEGA(){
return Math.toRadians(this.OMEGA);
}
public double getOmega(){
return Math.toRadians(this.omega);
}
public double getM(){
return Math.toRadians(this.M);
}
}

Fertig. Jetzt der nächste Schritt. Wie können wir die Position des Planeten auf seiner Umlaufzeit aussrechnen, wenn wir seine Bahnelemente haben? Nehmen wir das zweite Keplersche Gesetz her:
"Ein von der Sonne zum Planeten gezogener „Fahrstrahl“ überstreicht in gleichen Zeiten gleich große Flächen."
Die Idee ist einfach: Dieses Gesetz sagt irgendwie etwas über die Geschwindigkeit des Planeten entlang seiner Umlaufbahn aus. Wenn wir einen Ort auf der Umlaufbahn zu einer bestimmten Zeit kennen, und wir etwas über die Geschwindigkeit wissen, dann sollten wir doch irgendwie die Orte zu anderen Zeiten ausrechnen können. Um eine solche Rechnung in der Praxis durchzuführen, benötigt man einige Hilfskonstruktionen, die noch auf Kepler persönlich zurück gehen. Die Wikipedia verrät sie uns im Artikel Kepler-Gleichung. Um die beachtliche Länge dieses Posts nicht noch weiter zu steigern, verweisen wir hier einfach nur auf den Artikel und benutzen seine Aussagen direkt ohne weitere Erläuterungen. Im Zweifel sollte man einfach den Artikel lesen. Das Fazit ist dieses:
Wir können also die mittlere Anomalie M eines Planeten leicht berechnen, wenn wir seine Umlaufzeit U und  den Zeitpunkt t0 kennen, an dem er den sonnennächsten Punkt durchläuft.
M = 2 π  (t-t0) / U      (1)
Wenn wir die exzentrische Anomalie E kennen, können wir mit der Exzentrizität e (einer der sechs Bahnelemente) die wahre Anomalie T leicht ausrechnen:
cos T = [cos E - e] / [1 - e cos E]     (2)
Den Zeitpunkt, an dem der Planet seinen sonnennächsten Punkt durchläuft, bekommen wir aus der sechsten von uns ausgesuchten Bahnelemente, der mittleren Anomalie zu einem festen Zeitpunkt. Die Umlaufzeit U bekommen wir einfach aus dem dritten Keplerschen Gesetz:
"Die Quadrate der Umlaufzeiten zweier Planeten verhalten sich wie die dritten Potenzen (Kuben) der großen Bahnhalbachsen."
Dieses Gesetz ist enorm praktisch! Denn es erlaubt es uns, die großen Halbachsen, einer der von uns gewählten sechs Bahngrößen, und die Umlaufzeiten mit den Werten für die Erde zu verknüpfen. Die Umlaufzeit der Erde kennen wir leicht, das ist (in etwa) ein Jahr. Und die große Halbachse der Erdbahn soll einfach den Wert 1 haben. Die Einheit nennen wir dann Astronomische Einheit, und es muß uns zur Berechnung der Planetenpositionen gar nicht interessieren, wie groß dieser Wert in absoluten Einheiten, etwa in Kilometern, ist. Natürlich kennt man den Wert der Astronomischen Einheit heute in Kilometern. Aber lange Zeit war er nicht bekannt, und man konnte dennoch alle Positionen im Sonnensystem maßstäblich richtig berechnen!

So. Alles, was uns jetzt also noch fehlt, ist der Zusammenhang zwischen der mittleren Anomalie M und der exzentrischen Anomalie E, dann könnten wir uns zu jedem Zeitpunkt die wahre Anomalie eines Planeten, und damit seine Position auf seiner Umlaufbahn ausrechnen. Dieser Zusammenhang steht natürlich auch im Wikipedia-Artikel zur Kepler-Gleichung, denn er ist ja gerade die Kepler-Gleichung:
E - e sin E = M     (3)
Diese Gleichung, die E und M verknüpft, ist für unser Schulwissen ein bisschen eklig. Es ist eine implizite Gleichung. In ihr tritt die Größe E direkt und als Argument einer Funktion, in diesem Fall der Sinusfunktion, auf und wir können sie nicht einfach so durch Umstellen nach E auflösen. Aber praktischerweise verrät uns die Wikipedia auch, wie wir diese Gleichung für ein gegebenes M näherungsweise für E lösen können: Wir ziehen auf beiden Seiten der letzten Gleichung M ab. Dann suchen wir dasjenige E, das eine Nullstelle einer Funktion f (E) ist. Und für das Suchen von Nullstellen einer Funktion gibt es sehr einfache und gute numerische Verfahren. Wikipedia legt uns hier gleich eines der einfachsten Verfahren nahe, das Newton-Verfahren. In unserem Fall lautet das dann:
En+1 = En + f (En) / f ' (En)       (4)
Die Ableitung f ' (E) ist leicht berechnet: f ' (E) = 1 - e cos(E). Wir müssen also mit einem Startwert E0 anfangen und solange den neuen Werte En+1 nach der obigen Gleichung aus dem alten Wert En ausrechnen, bis der zugehörige Wert f (En+1) so nahe an der Null ist, daß wir meinen, gut damit Leben zu können. Dann haben wir mit dem letzten Wert En einen guten Näherungswert für die exzentrische Anomalie E bestimmt. Und welchen Startwert E0 nehmen wir? Die englischsprachige Wikipedia empfiehlt uns an dieser Stelle den Startwert E0 = M für Umlaufbahnen mit nicht zu großer Exzentrizität e und den Startwert E0 = π für Umlaufbahnen mit großer Exzentrizität, z.B. Kometen. Die Planeten haben alle eine recht kleine Exzentrizität, also folgen wir der Wikipedia-Empfehlung und nehmen den Startwert E0 = M. Schreiben wir uns also einen kleinen Java-Code, der die Kepler-Gleichung für uns löst mit diesem Näherungsverfahren löst, und schon wir haben den Kern des Problems geknackt!

Aber halt, ein kleines technisches Problem bleibt erst noch zu beseitigen! Wir werden ja gleich Zeitdifferenzen (t - t0) für unsere Rechnungen benötigen. Im Alltag gibt man Zeiten aber üblicher- und bequemerweise als Kalenderdaten und Uhrzeiten an. Kalenderdaten und Uhrzeiten sind aber sehr unbequem, um Zeitdifferenzen auszurechnen. Ich meine, wieviel Zeit (in Sekunden, in Stunden, Tagen, was auch immer) liegt denn z.B. zwischen dem 2. September 1999, 21:21, und dem 19. Februar 2017, 06:19? Eben. Wir brauchen eine Methode, um Zeitdifferenzen bequem ausrechnen zu können. Dafür gibt es auch ein Hilfsmittel, auch in der Wikipedia, das Julianische Datum. Dabei handelt es sich einfach um eine fortlaufende Zählung von Tagen, angefangen am 1. Januar 4713 v. Chr. um 12 Uhr mittags. Kennt man die Julianische Daten, also einfach zwei Zahlen (mit Nachkommastellen), zu zwei Kalenderdaten, dann ist der Zeitunterschied zwischen den beiden Kalenderdaten einfach die Differenz der Julianischen Daten, gerechnet in Tagen. Sowas ist bequem, sowas wollen wir. Und wir müssen auch gar nicht lange rumüberlegen, denn die Wikipedia gibt im Artikel gleich eine ausgiebig kommentierte Anleitung, wie Kalenderdaten in Julianische Daten umzurechnen sind. Folgen wir einfach den dort angegebenen Schritten! Wir machen uns also noch ein Java-Paket mit Hilfmitteln, "Tools", und erzeugen uns darin eine Klasse mit Julianischen Daten. Das sieht dann z.B. so aus:


public class JulianDate {

private double jd;
private double year;
private double month;
private double day;
private double hour;
private double minute;
/*
 * Dieser Konstruktor erzeugt ein Julianisches Datum aus einem Kalendertag.
 * Die kleinste verwendete Zeiteinheit ist die Minute, kleinere Zeiteinheiten
 * müssen als Bruchteile einer Minute angegeben werden.
 */
public JulianDate(int day, int month, int year, int hour, double minute){
this.year = (double) year;
this.month = (double) month;
this.day = (double) day;
this.hour = (double) hour;
this.minute = minute;
this.jd = getJulianDate();
}

/*
 * Dieser Konstruktor erzeugt ein Julianisches Datum nur aus dem
 * Julianischen Tag. Das ist praktisch, wenn man ab einem Stichtag
 * nachher Zeitserien durchrechnen will.
 */
public JulianDate(double jdn){
this.jd = jdn;
}
/*
 * Die Methode, die zu einem bestimmten Kalenderdatum das Julianische Datum ausrechnet
 */
private double getJulianDate(){
  double Y = this.year;
  double M = this.month;
  if (this.month < 2){
    Y--;
    M += 12.0;
  }
  double D = this.day;
  double H = this.hour/24.0 + Math.floor(this.minute)/1440.0 + 
            (this.minute - Math.floor(this.minute))/86400.0;
  double A;
  double B=0;
  // Wenn "true", benutze Gregorianischen Kalender (default),
  // ansonsten benutze Julianischen:
  boolean Gregorian = true
      // Verwende sicher Julianischen Kalender:
      if (this.year < 1582 || this.year == 1582 && this.month < 10){
 Gregorian = false;
      }
      // Der kompliziertere Fall, daß die Kalenderreform im Monat liegt:
      if (this.year == 1582 && this.month == 10){
if (this.day <= 4){
  Gregorian = false;
else {
  if (this.day > 4 && this.day < 15){
      System.out.println(
                  "Fehler: Dieses Datum existiert nicht
                  (Gregorianische Kalenderreform)!");
      }
    }
 }
  if (Gregorian){
    A = Math.floor(Y/100.0);
    B = 2.0 - A + Math.floor(A/4.0);
  } else {
    B = 0.0;
  }
return Math.floor(365.25*(Y+4716.0)) + Math.floor(30.6001*(M+1.0)) + 
       D + H + B - 1524.5;
}
// Gibt das Julianische Datum aus
public double getJD()
  return this.jd;
}

}


So, haben wir das auch. Dann schreiben wir uns doch auch gleich mal eine Klasse, die die Keplersche Umlaufbahn eines Planeten enthält. Also etwa sowas:

public class KeplerianOrbit {
// Die Bezugsgrößen:
private double AEARTH = 1.00000261;  // Die große Halbachse der Erdbahn (in AE)
private double YEAR = 365.2563604167;// Umlaufzeit der Erde in Tagen (ein Jahr)
private JulianDate EPOCHnew JulianDate(1,1,2000,12,0.0); // Der Referenzzeitpunkt

// Eine Umlaufbahn hat sechs Bahnelemente:
private double a; // Große Halbachse (in AE)
private double e; // Exzentrizität (einheitenlos)
private double i; // Inklination (im Bogenmaß, d.h. rad)
private double OMEGA; // Argument des aufsteigenden Knotens (in rad)
private double omega; // Argument des Perihels (in rad)
private double M; // Mittlere Anomalie (in rad)

/*
 * Ein Konstruktor, der einfach die Bahnelemente eines Planeten übernimmt:
 */
public KeplerianOrbit(Planet planet){
this.a = planet.getA();
this.e = planet.getE();
this.i = planet.getI();
this.OMEGA = planet.getOMEGA();
this.omega = planet.getOmega();
 this.M = planet.getM();
}
}

In diese Klasse packen wir uns jetzt alles rein, was wir nach den oben gesagten Schritten zur Berechnung der Position eines Planeten brauchen. Also als erstes mal die Umlaufperiode nach dem dritten Keplerschen Gesetz:

// Berechnet die Umlaufzeit (in Tagen) aus dem 3. Keplerschen Gesetz
private double getPeriod(){
return Math.sqrt(YEAR*YEAR  * Math.pow(this.a / AEARTH), 3);
}

Kennen wir die Umlaufperiode U, dann rechnen wir mit Gleichung (1) die mittlere Anomalie am gewünschten Julianischen Datum aus:

// Rechnet die mittere Anomalie zu einem Zeitpunkt t aus
private double getMeanAnomaly(JulianDate t){
   return (2.0*Math.PI * (t.getJD() - EPOCH.getJD()) / getPeriod() + this.M
          % (2.0*Math.PI);
}

So, jetzt kommt die Berechnung der exzentrischen Anomalie mit dem Näherungsverfahren aus Gleichung (4) dran:

// Berechnet die exzentriche Anomalie  zu einer Zeit t mittels Newton-Raphson-Naeherung
private double getEccentricAnomaly(JulianDate t){
  // Berechne die augenblickliche mittere Anomalie:
  double meanAnomaly = getMeanAnomaly(t); 
  // Setze den Startwert von E auf M
  double Eold =  meanAnomaly;
  // Initialisieren
  double Enew = 0.0;
  // Die gewünschte Genauigkeitbricht abwenn die Änderung unter diesen Wert fällt:
  double acc = 1.0E-8; 
   // Initialisieren
  double change = 1.0;

  // Starte die Iteration. (Schleche Konvergenz ist nicht vorgesehen...)
  while (change > acc){ 
      // Berechne den Funktionswert am alten Wert von E:
      double f = Eold - this.e * Math.sin(Eold) - meanAnomaly;
      // Berechne die Ableitung am alten Wert von E:
      double fd = 1.0 - this.e * Math.cos(Eold);
      // Berechne den neuen Wert von E:
      Enew = Eold - f/fd;
      // Gucke mal, um wieviel sich der neue Wert noch vom alten unterscheidet:
      change = Math.abs(Enew/Eold - 1.0);
      // Setze den alten Wert von E auf den neuen Wert
      // und wiederhole die Iteration wenn nötig:
      Eold = Enew; 
  }
  return Enew;
}

Schon durch! Kennen wir jetzt die exzentrische Anomalie, können wir die wahre Anomalie T ausrechnen. Der Wikipedia-Artikel Kepler-Gleichung gibt den Zusammenhang mit der exzentrischen Anomalie an:
tan( T/2 ) =[ (1 + e) / (1 - e) ]  * tan( E/2 )      (5)
Wir werden aber auch gleich gewarnt, daß die Umkehrung der Tangensfunktion beim Auflösen dieser Gleichung nach T eine Fallunterscheidung erforderlich macht. Der Artikel True anomaly in der englischen Wikipedia erklärt diese Fallunterscheidung noch ein bisschen genauer. Der Java-Code sieht trotzdem einfach aus:

// Berechnet die wahre Anomalie zu einer gegeben exzentrischen Anomalie
private double getTrueAnomaly(double E){
  return 2.0 * Math.atan2(Math.sqrt(1.0+this.e)*Math.sin(E/2.0),
         Math.sqrt(1.0-this.e)*Math.cos(E/2.0));
}

Was uns nun fehlt, ist der Abstand des Planeten zur Sonne bei gegebener exzentrischer Anomalie. Der Zusammenhang ist laut Kepler-Gleichungs-Artikel:
r = a [ 1 - e cos( E ) ]     (6)
Das ist einfach:

// Berechnet den Abstand von der Sonne zu einer gegebenen exzentrischen Anomalie
private double getRadialPosition(double E){
  return this.a * (1.0 - this.e * Math.cos(E));
}

Transformationen

So, jetzt haben wir alles, um den Ort eines Planeten in seiner Umlaufbahn auszurechnen, die wahre Anomalie T, also den Winkel zwischen seiner Position und dem sonnennächsten Punkt seiner Bahn und seinen Abstand von der Sonne, r. Dies sind Koordinaten in Polarkoordinaten, die wir nur noch in Koordinaten in einem kartesischen Koordinatensystem im Raum umrechnen müssen. Am besten, wir verwenden gleich dreidimensionale Vektoren um die Position des Planeten anzugeben, auch schon bei den Polarkoordinaten in der Bahnebene. Berechnen wir uns also erst einmal die Position in Polarkoordinaten an einem Julianischen Datum t:

/*
 * Berechnet den Ort des Planeten zu einer gegebenen Zeit t in Kugelkoordinaten.
 * Die Koordinaten sind r - der Abstand von der Sonne, der Winkel T (die wahre
 * Anomalie) gemessen vom sonnennächsten Punkt der Bahn) und pi/2 (die Bewegung
 * des Planeten erfolgt in einer Ebene, d.h. in zwei Dimensionen, und zweite,
 * konstante Winkel wird konventionell "von oben in die Ebene" gemessen.) 
 */
public Vector getPositionInOrbit(JulianDate t){
   double E = getEccentricAnomaly(t); // Berechne die exzentrische Anomalie
   return new Vector(getRadialPosition(E),getTrueAnomaly(E),Math.PI/2.0);
}

Diese knappen Zeilen rufen einfach nur all das auf, was wir bisher geschrieben haben. Aber die Klasse "Vector" müssen wir natürlich noch schreiben. Machen wir uns ein neues Paket, das wir in einem Anfall von Größenwahn "lineare Algebra" nennen, und darein packen wir die Vektoren. Wir brauchen von der Vektorrechnung nicht viel:

public class Vector {

// Die drei Komponenten x, y, z eines Vektors in drei Dimensionen
private double x;
private double y;
private double z;
// Erzeugt einen Vektor aus drei Zahlen für die drei Komponenten
public Vector(double theX, double theY, double theZ){
  this.x = theX;
  this.y = theY;
  this.z = theZ;
}
// "Getters":
public double getX(){
  return this.x;
}
public double getY(){
  return this.y;
}
public double getZ(){
  return this.z;
}

// Berechnet den Differenzvektor zwischen den Vektoren a und b
public static Vector subtract(Vector a, Vector b){
  return new Vector(a.getX() - b.getX(), a.getY() - b.getY(), a.getZ() - b.getZ());
}
// Berechnet die Länge eines Vektors a
public static double norm(Vector a){
  return Math.sqrt(a.getX()*a.getX() + a.getY()*a.getY() + a.getZ()*a.getZ());
}
}

Das ist schon alles in Sachen Vektoren. Aber wir werden in unserem lineare Algebra-Paket auch noch Matrizen brauchen. Denn jetzt müssen wir ja von unseren Polarkoordinaten in der Bahnebene zu kartesischen Koordinaten umrechnen. Und wie geht das? Na, erst mal machen wir uns kartesische Koordinaten in einem Koordinatensystem in der Bahnebene. Die Umrechung ist einfach, die finden wir in der Wikipedia z.B. beim Artikel Kugelkoordinaten, der dreidimensionalen Variante unserer Polarkoordinaten. Machen wir uns schnell noch eine Java-Klasse "Koordinatentransformationen", z.B. im Paket "Tools", und rechnen um:


public class CoordinateTransformations {

// Transformiert einen Vektor von Kugelkoordinaten zu Kartesischen Koordinaten
public static Vector sphericalToCartesian(Vector vector){
  double X = vector.getX() * Math.sin(vector.getZ()) * Math.cos(vector.getY());
  double Y = vector.getX() * Math.sin(vector.getZ()) * Math.sin(vector.getY());
  double Z = vector.getX() * Math.cos(vector.getZ());
  return new Vector(X,Y,Z);
}
}
Und wie kommen wir von dreidimensionalen kartesischen Koordinaten in einem an der Bahnebene ausgerichteten Koordinatensystem zu einem von der Bahn unabhängigen kartesischen Koordinatensystem für das Sonnensystem? Sagen wir mal, ein kartesisches Koordinatensystem mit dem Ursprung in der Sonne, der x-Achse in Richtung des Frühlingspunkts und der y-Achse innerhalb der Ekliptik? Worin unterscheiden sich die beiden Koordinatensysteme denn? Die Längeneinheit kann ruhig die selbe sein, die Astronomische Einheit, und spiegeln wollen wir auch nichts. Also bleibt nur die Drehung. Wir bekommen den Vektor im bahnorientierten Koordinatensystem in ein unabhängiges, festes Koordinatensystem durch Drehung. Und die Drehwinkel sind praktischerweise gleich der Bahnelemente, die die Orientierung der Bahn im Raum angeben: Inklination, Argument des aufsteigenden Knotens und Argument des Perihels. In welcher Folge um welche Achsen gedreht werden muß, verlangt jetzt einiges an räumlichen Vorstellungsvermögen. Zur Hilfe sehen wir vielleicht am besten auf das Diagramm bei der Wikipedia. Als erstes korrigieren wir für die Drehung des Perihels, d.h. wir drehen um das Argument des Perihels, ω, und zwar um die z-Achse. Jetzt können wir die Kippung der Bahnebene gegenüber der Bezugsebene korrigieren. Dazu drehen wir um den Winkel der Inklination i um die x-Achse. Dann können wir als letztes um die Drehung des aufsteigenden Knotens, Ω  im Diagram, zurück drehen. Dabei ist die Drehachse wieder die z-Achse.
Und wie führen wir die Drehungen praktisch aus? Wie gesagt, wie brauchen Matrizen. Denn die Wikipedia verrät, daß Drehungen durch Drehmatrizen beschrieben werden. Der gedrehte Vektor ergibt sich durch die Multiplikation des ungedrehten Vektors mit einer Drehmatrix. Die Drehmatrix hat eine recht einfache Form, sie hängt von der Drehachse und dem Drehwinkel ab.
Jetzt haben wir zwei Optionen. Entweder, wir nehmen und Papier und Bleistift und rechnen einmal allgemein aus, wie wir den Ortsvektor unseres Planeten durch Drehung umrechnen müssen. Dazu müssen wir drei Matrizenmultiplikationen durchführen. Das ist mühsam und stupide, gibt aber eine effizientere Berechnung mit dem Computer. Oder aber, wie schreiben uns einen stupiden allgemeinen Code, der den Computer immer wieder die Matrizenmultiplikation durchführen lässt. Das ist unnötig viel Herumgerechne für den Computer, spart uns aber langweilige Rechnerei. Und vor die Wahl gestellt, selber einmal öde Rechnungen zu machen oder sie die den Computer wieder und wieder durchführen zu lassen, fällt die Antwort natürlich leicht: Der Computer soll lieber immer und immer wieder unnötig rechnen! Gucken wir also schnell noch mal in den Wikipedia-Artikel Matrix (Mathematik) um nachzugucken, wie man zwei Matrizen miteinander multipliziert und schreiben wir uns die Matrizenklasse in unserem lineare Algebra-Paket:


public class Matrix {
// Die Elemente einer 3x3-Matrix
private double[][] elements;
   
// Erzeugt eine leere Matrix
public Matrix(){
  this.elements = new double[3][3];
}
    
// Erzeugt eine 3x3-Matrix durch explizite Angabe aller 9 Elemente
public Matrix(double A11,double A12,double A13,double A21,
       double A22,double A23,double A31,double A32,double A33){
     this.elements = new double[3][3];
     this.elements[0][0] = A11;
     this.elements[0][1] = A12;
     this.elements[0][2] = A13;
     this.elements[1][0] = A21;
     this.elements[1][1] = A22;
     this.elements[1][2] = A23;
     this.elements[2][0] = A31;
     this.elements[2][1] = A32;
     this.elements[2][2] = A33;
   }
    
// Gibt das i,j-te Element der Matrix aus
public double getElement(int i, int j){
  return this.elements[i-1][j-1];
}
        
// Multipliziert zwei 3x3-Matrizen (einfach mal stupide ausgeschrieben)
public static Matrix multiply(Matrix A, Matrix B){
        double c11 = A.getElement(1,1) * B.getElement(1,1) + 
                     A.getElement(1,2) * B.getElement(2,1) + 
                     A.getElement(1,3) * B.getElement(3,1);
        double c21 = A.getElement(2,1) * B.getElement(1,1) + 
                     A.getElement(2,2) * B.getElement(2,1) + 
                     A.getElement(2,3) * B.getElement(3,1);
        double c31 = A.getElement(3,1) * B.getElement(1,1) + 
                     A.getElement(3,2) * B.getElement(2,1) + 
                     A.getElement(3,3) * B.getElement(3,1);
        double c12 = A.getElement(1,1) * B.getElement(1,2) + 
                     A.getElement(1,2) * B.getElement(2,2) + 
                     A.getElement(1,3) * B.getElement(3,2);
        double c22 = A.getElement(2,1) * B.getElement(1,2) + 
                     A.getElement(2,2) * B.getElement(2,2) + 
                     A.getElement(2,3) * B.getElement(3,2);
        double c32 = A.getElement(3,1) * B.getElement(1,2) + 
                     A.getElement(3,2) * B.getElement(2,2) + 
                     A.getElement(3,3) * B.getElement(3,2);
        double c13 = A.getElement(1,1) * B.getElement(1,3) + 
                     A.getElement(1,2) * B.getElement(2,3) + 
                     A.getElement(1,3) * B.getElement(3,3);
        double c23 = A.getElement(2,1) * B.getElement(1,3) + 
                     A.getElement(2,2) * B.getElement(2,3) + 
                     A.getElement(2,3) * B.getElement(3,3);
        double c33 = A.getElement(3,1) * B.getElement(1,3) + 
                     A.getElement(3,2) * B.getElement(2,3) + 
                     A.getElement(3,3) * B.getElement(3,3);
        Matrix C = new Matrix(c11,c12,c13,c21,c22,c23,c31,c32,c33);   
        return C;
    }
    
// Multipliziert einen Vektor mit einer Matrix
public static Vector multiply(Matrix A, Vector X){
  double x1 = A.getElement(1,1) * X.getX() + 
              A.getElement(1,2) * X.getY() + 
              A.getElement(1,3) * X.getZ();
  double x2 = A.getElement(2,1) * X.getX() + 
              A.getElement(2,2) * X.getY() + 
              A.getElement(2,3) * X.getZ();
  double x3 = A.getElement(3,1) * X.getX() + 
              A.getElement(3,2) * X.getY() + 
              A.getElement(3,3) * X.getZ();
  return new Vector(x1,x2,x3);
}
}

So. Die Drehmatrizen um die verschiedenen Koordinatenachsen können wir uns, vielleicht im Paket "Koordinatentransformationen", auch schon mal vorbereiten:

/*
 * Gibt eine Drehmatrix aus, die um einen Winkel "angle" (im Bogenmaß) dreht,
 * und zwar wahlweise um die x-Achse (dimension = 1), y-Achse (dimension = 2)
 * oder z-Achse (dimension = 3)
 */
public static Matrix getRotationMatrix(int dimension, double angle){
  Matrix rot = new Matrix();

  switch(dimension){
  // Drehung um die x-Achse
    case 1: rot.setElement(1, 1, 1.0);
    rot.setElement(2, 2, Math.cos(angle));
    rot.setElement(3, 3, Math.cos(angle));
    rot.setElement(3, 2, Math.sin(angle));
    rot.setElement(2, 3, -1.0 * Math.sin(angle));
    break;
  // Drehung um die y-Achse
    case 2: rot.setElement(2, 2, 1.0);
    rot.setElement(1, 1, Math.cos(angle));
    rot.setElement(3, 3, Math.cos(angle));
    rot.setElement(1, 3, Math.sin(angle));
    rot.setElement(3, 1, -1.0 * Math.sin(angle));
    break;
  // Drehung um die z-Achse
    case 3: rot.setElement(3, 3, 1.0);
    rot.setElement(1, 1, Math.cos(angle));
    rot.setElement(2, 2, Math.cos(angle));
    rot.setElement(2, 1, Math.sin(angle));
    rot.setElement(1, 2, -1.0 * Math.sin(angle));
    break;
  }
  return rot;
}
}

Wir sind schon so gut wie am Ziel! Alles zusammen verwenden wir in einer letzten Methode, die in der Klasse "Keplersche Umlaufbahn" den Ortsvektor des Planeten ausrechnet:


/*
 * Berechnet die Position des Planeten zu einer Zeit t in kartesischen,
 * von der Bahn des Planeten unabhängigen Koordinaten
 */
public Vector getPositionInSpace(JulianDate t){
  // Im ersten Schritt gerechnen wir die Position in der Bahnebene des Planeten in
  // Kugelkoordinaten:
  Vector polar = getPositionInOrbit(t);
  // Jetzt wandeln wir von Kugelkoordinaten in kartesische Koordinaten um:
  Vector cart = CoordinateTransformations.sphericalToCartesian(polar);
  /* Jetzt müssen wir von einem kartesischen Koordinatensystem in der Bahnebene
   so drehen, dass wir den Vektor in einem für alle Planeten gemeinsamen
   Koordinatensystem haben.
   Erst machen wir uns die benötigten Drehmatrizen: */

  // Kippt die Bahnebene relativ zur Bezugsebene, d.h. der Ekliptik:
  Matrix rotateI = CoordinateTransformations.getRotationMatrix(1,this.i); 
  // Dreht die Knotenlinie:
  Matrix rotateOMEGA  = CoordinateTransformations.getRotationMatrix(3,this.OMEGA); 
  // Dreht zum sonnennächsten Punkt der Bahn:
  Matrix rotateOmega  = CoordinateTransformations.getRotationMatrix(3,this.omega);
  // Die Gesamtdrehmatrix ist dann das Produkt der einzelnen Drehmatrizen:
  Matrix rotation = Matrix.multiply(Matrix.multiply(rotateOmega,rotateI),rotateOMEGA);
  // Führe die Drehung aus:
  return Matrix.multiply(rotation, cart);
}

Am Ziel!
Mit ein paar einfachen Zeilen können wir uns jetzt die uns interessierenden Größen berechnen. Z.B. so:


public static void main(String[] args) {
// Erzeuge die Erdumlaufbahn:
KeplerianOrbit ErdOrbit = new KeplerianOrbit(Planet.EARTH);
// Erzeuge die Venusumlaufbahn:
KeplerianOrbit VenusOrbit = new KeplerianOrbit(Planet.VENUS);

// Wähle ein beliebiges Datum, z.B. den 27.1.2012, um 23:30 und 30 Sekunden:
JulianDate T = new JulianDate(27, 1, 2012, 23, 30.5);

// Berechne die Position der Erde im Raum zu diesem Zeitpunkt:
Vector positionErde = ErdOrbit.getPositionInSpace(T);
// Berechne die Position der Venus im Raum zu diesem Zeitpunkt:
Vector positionVenus = VenusOrbit.getPositionInSpace(T);

// Schreibe den Abstand der Erde zur Sonne aus:
System.out.println("Abstand  Erde - Sonne: "
             Vector.norm(positionErde) + " AE");
// Schreibe den Abstand der Venus zur Sonne aus:
System.out.println("Abstand Venus - Sonne: "
             Vector.norm(positionVenus) + " AE");
// Schreibe den Abstand zwischen Erde und Venus aus:
System.out.println("Abstand  Erde - Venus: "
             Vector.norm(Vector.subtract(positionErde, positionVenus)) + " AE");
}


Dann lesen wir auf dem Bildschirm:

   Abstand  Erde - Sonne: 0.98472761878588 AE
   Abstand Venus - Sonne: 0.7229524281728524 AE
   Abstand  Erde - Venus: 1.1308756929560395 AE

Problem gelöst. Fertig. Jetzt haben wir ein kleines Spielzeug in der Hand, mit dem man lauter lustige Sachen machen könnte. Aber wir wollen nur einen kurzen Blick darauf werfen, wie unsere Berechnungen so aussehen.

Wie es aussieht

Die berechneten räumlichen Positionen der Planeten könnten wir zum Beispiel benutzen, um das Aussehen des Sonnensystems zu bestimmten Zeiten graphisch darzustellen . So könnten wir uns etwa die Umlaufbahnen der Planeten ausrechnen lassen und die Positionen der Planeten, z.B. einfach mal für den kommenden Sonntag, mittags um 13:31 MEZ. Blickt man von Norden auf die Ebene der Erdbahn, dann sieht das innere Sonnensystem mit den Planeten Merkur, Venus, Erde und Mars dann so aus:
Das innere Sonnensystem am 10. März 2013, um
13:31 MEZ, gesehen von nördlich der Ekliptik.
(Zur Orientierung: Der Frühlingspunkt ist rechts,
die Planeten laufen gegen den Uhrzeigersinn).

Beliebige andere Blickwinkel gehen natürlich auch. Gehen wir einfach mal in die Bahnebene der Erde und gucken uns das Sonnensystem "von der Seite" an:
Derselbe Zeitpunkt, aber gesehen aus Richtung des Früh-
lingspunkts, von innerhalb der Ekliptik (Man beachte, daß
die Z-Achse gegenüber der Y-Achse stark überhöht ist!).
Um 90 Grad in der Ebene gedreht sieht das so aus:
Nochmal dasselbe, aber diesmal wenn der Beobachter sich gegen-
über der vorherigen Abbildung um 90 Grad gegen den Uhrzeigersinn
in der Ekliptik weiterbewegt.
Aber genug gespielt. Die spannende Frage ist jetzt doch:

Wie gut sind wir?

Wie genau sind denn jetzt unsere Berechnungen mit dem "Wikipedia-Sonnensystem", verglichen mit der Realität? Sind unsere Ergebnisse glaubwürdig, oder was? Als Referenz nehmen wir mal das HORIZONS-System des JPL. Hey, das ist die NASA! Wenn die nicht weiß wie's wirklich ist, wer denn dann?? Mit diesem System (es hat natürlich auch einen Wikipedia-Artikel!) können wir uns Größen, die wir mit unserem kleinen Code berechnen, ebenfalls berechnen (zu den gleichen Zeitpunkten, versteht sich) und die Genauigkeit unserer Ergebnisse so überprüfen. Als Vergleichsgrößen nehmen wir uns mal den innersten Planeten, Merkur, und den äußersten, Neptun, sowie die Erde. Wir rechnen jeweils in 30-Tage-Schritten die Abstände dieser Planeten zur Sonne sowie die Abstände von Merkur und Neptun zur Erde aus und bestimmen die Abweichung zum Referenzwert aus HORIZONS. Dabei gehen wir mal so grob 100 Jahre in die Vergangenheit und die Zukunft und berechnen die Fehler vom 1.1.1900 bis ins Jahr 2105. Für die Abstände zur Sonne sehen die Fehler dann so aus:
Der relative Fehler im Abstand Planet - Sonne. Die Punkte haben einen
Abstand von 30 Tagen im Zeitraum 1900 - 2105. Schwarz: Merkur
Blau: Erde, Rot: Neptun.
Und das ist wohl doch so erstaunlich, daß man ein paar Worte darüber verlieren sollte. Nehmen wir uns erst die Erde, d.h. die blauen Punkte in diesem Diagramm. Offenbar Können wir den Abstand der Erde zur Sonne mit unsrem kleinen Java-Projekt ganz hervorragend bestimmen! Die Fehler liegen über einen Zeitraum von 200 Jahren deutlich unter einem Promille! Ist vielleicht aber auch nicht so schwer, schließlich ist die Erdbahn auch relativ Nahe an einem Kreis? Auf jeden Fall aber haben wir da kein Problem.
Gehen wir zu Neptun, d.h. zu den roten Punkten. Das sieht schon schlimmer aus. Und es sieht falsch aus. Und es ist falsch. Da ist einmal ein kleines Gewobbel. Aber da ist auch eine große, nach einer "Schwingung" aussehende Abweichung. Wobei, "groß" ist immer noch unter einem Prozent. Aber es sieht nach einem systematischen Fehler aus. Vielleicht sind die Bahnelemente in der Wikipedia nicht so gut? Und tatsächlich stimmen die aus der Wikipedia entnommenen Bahnelemente für alle Planeten einigermaßen mit denen überein, die man sonst wo auch in der Literatur finden kann, ausgenommen eben Neptun. Für den finden wir in anderen Quellen, z.B. hier, merklich andere Werte, insbesondere für die mittlere Anomalie. Wenn wir statt der Wikipedia-Bahnelemente diese anderen benutzen, verschwindet die große Abweichung:
Dasselbe wie vorher, aber mit korrigierten Bahnelementen für Neptun.
Offenbar sind die Bahnelemente des Neptun in der englischsprachigen Wikipedia nicht gut. Aber ok, es hat ja auch niemand behauptet, die Wikipedia sei perfekt. Und der Fehler ist eben unter einem Prozent, also was soll's? Woher das verbleibende Gewobbel im Fehler kommt? Keine Ahnung. Aber die Periode dieser Schwankung im Fehler scheint so grob mit der Umlaufzeit des Jupiter übereinzustimmen, also würde ich aus der hohlen Hand mal auf eine Bahnstörung des Neptun durch den Jupiter tippen.
Dann bleibt da noch der Merkur. Für den werden die Fehler tendentiell immer größer, je weiter man sich vom Referenzzeitpunkt, dem 1. Januar 2000, entfernt. Hier scheinen tatsächlich deutliche Störungen der Umlaufbahn siechtbar zu sein. Und Störungen, die zu Abweichungen von einer idealen Keplerbahn führen, werden in unserem Vorgehen überhaupt nicht berücksichtigt. Aber auch hier ist der Fehler unter einem Prozent über einem Zeitraum von +/- 100 Jahren.

Für die Abstände sieht es natürlich ganz ähnlich aus. Da die Erdbahn ziemlich genau gerechnet wird, steigen die Fehler nur wenig an. Korrigiert man die Bahnelemente des Neptun, so ist der Abstand zwischen ihm und der Erde sehr gut bestimmt und für Merkur liegt der Fehler bei ca. 1% über einen Zeitraum von 200 Jahren.
Der relative Fehler im Abstand Planet - Erde. Schwarz: Merkur
Rot: Neptun. 

Und das sind ja Genauigkeiten, mit denen man so für den Hausgebrauch, etwa wenn man sich mal sein Horoskop selber ausrechnen will, ganz gut leben kann.
Dasselbe nochmal, aber mit korrigierten Bahnelementen für Neptun.

Fazit

Unter dem Strich bleibt also: Die Wikipedia bietet alles, was man zur Berechnung der Positionen der Planeten braucht. Und das nicht nur irgendwie im Prinzip, sondern auch für die ganz praktische Durchführung. Dabei liegt der Fehler unter einem Prozent über den Zeitraum von 1900 bis 2100, oft sogar deutlich unter einem Prozent.
Die größte Begrenzung der Genauigkeit ist bei unserem Versuch hier, daß Bahnstörungen, etwa durch die Gravitationswirkung der Planeten untereinander, nicht berücksichtigt wurden. Dabei wäre es gar nicht besonders schwierig, sie in das Java-Projekt einzubauen! Am einfachsten lassen sie sich näherungsweise integrieren, indem man die Bahnelemente nicht, wie hier, als für alle Zeiten konstant annimmt, sondern sie selber als Funktionen der Zeit auffasst. Die Einflüsse der Planeten untereinander lassen dann die Bahnelemente mit der Zeit langsam driften. Oft reicht es schon, einen kleinen, in der Zeit linearen Term zu den Bahnelementen zu addieren, und schon steigt die Genauigkeit deutlich. Man muß nur zu jedem Julianischen Datum nicht die Standardbahnelemente zum Zeitpunkt 1.1.2000 benutzen, sondern die jeweils aktuellen Bahnelemente in einem Zwischenschritt ausrechnen. Viel komplizierter würden unsere Rechnungen nicht, und daß es so geht, deutet sie Wikipedia auch hier und da an. Allerdings fehlen konkrete Angaben, wie schnell die einzelnen Bahnelemente der Planeten driften. Und wir wollten ja nur Informationen aus der Wikipedia benutzen. Aber daß ja auch das tolle an der Wikipedia: Irgendwann wird irgendwer diese Zahlen nachtragen, und dann kann man noch eine Stufe besser werden mit seinem Wikipedia-Sonnensystem!

So, und jetzt kommen wohl noch diejenigen, die behaupten, im Internet gäbe es doch eh nur Schmutz und Schund und Pöbeleien und Gemobbe! Da gucka, hä? Komm her und isch fick deinen Brockhaus, Alta!