Finish Übungstest 6

Signed-off-by: Lorenz Stechauner <lorenz.stechauner@necronda.net>

angabe/Aufgabenblatt2.md

@@ -61,5 +61,3 @@ Himmelskörpern:
 - Implementierung von `BodyForceMap`: 2 Punkte
 - Anpassung von `Simulation`: 1 Punkt
 - Gesamt: 5 Punkte 
-
-

angabe/Aufgabenblatt3.md

@@ -47,4 +47,3 @@ Allgemeiner Hinweis: bei einigen Methoden sind Vorbedingungen (_pre-conditions_)
 - Implementierung von `BodyForceTreeMap`: 2 Punkte
 - Implementierung von `Simulation3`: 1 Punkt
 - Gesamt: 5 Punkte
-

angabe/Aufgabenblatt4.md

@@ -0,0 +1,122 @@
+# Aufgabenblatt 4
+
+## Allgemeine Anmerkungen
+Ihre Lösung für dieses Aufgabenblatt ist bis Montag, 2.5. 11h durch `git commit` und `push`
+abzugeben. Mit der Angabe werden die Dateien `CosmicSystem.java`, `Drawable.java`, 
+`NamedBodyForcePair.java`, `HierarchicalSystem.java`, `Simulation4.java` und `Aufgabe4Test.java` 
+mitgeliefert.
+
+Wenn Sie zusätzlich zu den gefragten Klassen weitere Klassen definieren, achten Sie darauf, dass
+die Klassennamen mit `My` beginnen, um Konflikte mit späteren Aufgabenblättern zu vermeiden.
+
+## Ziel
+Ziel der Aufgabe ist die Anwendung der Konzepte: Interfaces, dynamisches Binden, toString() 
+(siehe Skriptum Seite 75-84).
+
+## Beschreibung der gegebenen Dateien
+
+- [CosmicSystem](../src/CosmicSystem.java) ist ein gegebenes Interface, das von den Klassen
+`NamedBodyForcePair` und `HierarchicalSystem` implementiert wird. Mithilfe dieses lässt sich somit eine
+Hierarchie von Systemen und Subsystemen beschreiben. Unser Sonnensystem ist ein Beispiel eines Systems,
+das mehrere Teilsysteme beinhaltet. Ein solches Teilsystem ist beispielsweise das System Erde und Erdmond.
+Ein anderes Teilsystem wäre Jupiter mit seinen Monden. Verändern Sie dieses Interface nicht.
+- [Drawable](../src/Drawable.java) wird von `CosmicSystem` verwendet. Verändern Sie dieses Interface 
+nicht.
+- [NamedBodyForcePair](../src/NamedBodyForcePair.java) ist das Gerüst für eine Klassendefinition.
+Die Klasse implementiert `CosmicSystem` und repräsentiert einen einzelnen benannten Himmelskörper
+ (z.B. "Mars") zusammen mit der auf ihn wirkenden Kraft.
+- [HierarchicalSystem](../src/HierarchicalSystem.java) ist das Gerüst für eine Klassendefinition.
+Die Klasse implementiert `CosmicSystem`und repräsentiert ein System von Himmelskörpern (z.B.
+Sonnensystem) bestehend aus einem zentralen Himmelskörper und beliebig vielen Untersystemen in
+dessen Orbit. Für alle Himmelskörper werden die Kräfte, die auf diese jeweils wirken, mitverwaltet.
+- [Simulation4](../src/Simulation4.java) ist ein Gerüst für eine ausführbare Klasse. Hier soll
+die Simulation analog zur Klasse `Simulation` implementiert werden (damit Sie Ihre [ursprüngliche
+ Datei](../src/Simulation.java) nicht überschreiben müssen).
+- [Aufgabe4Test](../src/Aufgabe4Test.java) ist eine vorgegebene Klasse, die Sie zum Testen Ihrer
+Implementierung verwenden sollten. Bei einer fehlerfreien Implementierung sollten bei der
+Ausführung dieser Klasse keine Exceptions geworfen werden und alle Tests als erfolgreich ("successful") 
+ausgegeben werden. Entfernen Sie die Kommentarzeichen, um diese Klasse verwenden zu können. Sie 
+müssen diese Klasse nicht weiter verändern, können aber eigene Testfälle hinzufügen.
+
+## Aufgaben
+
+Ihre Aufgaben sind folgende:
+
+**1. Implementierung von `CosmicSystem` in `NamedBodyForcePair`:**
+ Fügen Sie in der Klasse `Body` eine öffentliche Methode `massCenter()` hinzu, die die
+ Position des Himmelskörpers liefert.
+ Definieren Sie die Klasse `NamedBodyForcePair` so, dass sie das Interface `CosmicSystem` 
+ implementiert. Die Methoden `getMass()` und `getMassCenter()` geben lediglich die Masse bzw.
+ Position des Himmelskörpers zurück.
+
+**2. Implementierung von `CosmicSystem` in `HierarchicalSystem`:**
+
+ Definieren Sie die Klasse `HierarchicalSystem` so, dass sie das Interface `CosmicSystem` implementiert.
+ Die Klasse repräsentiert ein hierarchisch aufgebautes kosmisches System von Himmelskörpern.
+ Ein solches System besteht aus einem zentralen Himmelskörper und beliebig vielen weiteren
+ kosmischen Systemen, die sich im Orbit um diesen zentralen Himmelskörper befinden. Neben der
+ Spezifikationen in `CosmicSystem` beachten Sie bitte folgende spezielle Anforderungen und Hinweise
+ für die Implementierung:
+
+- `toString()`: diese Methode soll eine textuelle Beschreibung der Hierarchie von Himmelskörpern
+und Subsystemen liefern. Dafür wird der Namen des zentralen Himmelskörpers eines Systems
+gefolgt von den Objekten im Orbit jeweils in {}-Klammern repräsentiert. Beispiel:
+
+    `"Sun {Mercury, Venus, Earth {Moon} , Mars {Deimos, Phobos} , Vesta, Pallas, Hygiea, Ceres}"`
+
+- `numberOfBodies()`: diese Methode liefert die Gesamtanzahl aller Himmelskörper (nicht Systeme)
+im System bzw. Himmelskörper, das heißt alle Objekte vom Typ `NamedBodyForcePair`. Das oben genannte
+Beispiel-System besteht z.B. aus 12 Himmelskörpern, das Mars-System im Orbit der Sonne jedoch nur
+aus 3.
+
+- `getMass()`: diese Methode liefert die Summe der Massen aller Himmelskörper im System.
+
+- `getMassCenter()`: diese Methode liefert den Schwerpunkt aller Himmelskörper im System. Dieser
+entspricht dem mit den Massen gewichteten Mittelwert aller Positionen, es müssen daher alle Positionen
+mit der jeweiligen Masse multipliziert und aufsummiert werden und das Resultat durch die Summe aller
+Massen dividiert werden. Nutzen Sie dafür die bereits implementierten Rechenoperationen in `Vector3`.
+
+- `addForceFrom(Body b)` aktualisiert für jedes `NamedBodyForcePair`-Objekt in `this` die Kraft,
+indem die von `b` auf das `NamedBodyForcePair`-Objekt ausgeübte Kraft zur Kraft hinzuaddiert wird.
+
+- `addForceTo(CosmicSystem cs)` aktualisiert für jedes `NamedBodyForcePair`-Objekt in `cs` die
+Kraft, indem alle Kräfte die von Körpern aus `this` auf das `NamedBodyForcePair`-Objekt
+ausgeübt werden, zur Kraft im Objekt hinzuaddiert werden. Beispiel: Die
+Anweisung `cs.addForce(cs)` aktualisiert alle wechselseitigen im System `cs` wirkenden Kräfte.
+
+- `update()` führt auf Basis der gespeicherten Kräfte alle Bewegungen im System `this` durch und 
+setzt danach alle Kräfte wieder auf den null-Vektor zurück.
+
+- `getBodies()` liefert eine Liste (Typ: `BodyLinkedList`) mit allen Himmelskörpern aus `this`.
+
+**3. Implementierung von `Simulation4`:**
+
+Implementieren Sie die Simulationsschleife unter Verwendung eines Objekts vom Typ 
+`HierachicalSystem`. Alle Berechnungen sollen mittels Methoden von `CosmicSystem` durchgeführt
+werden.
+
+### Hinweise: ###
+
+- Nutzen Sie für die Implementierung dieser Methoden Rekursion sowie das Konzept des _dynamischen Bindens_.
+Da `NamedBodyForcePair` und `HierarchicalSystem` Untertypen von `CosmicSystem` sind, haben sie
+jeweils eine eigene Implementierung der in `CosmicSystem` definierten Methoden und es wird zur
+Laufzeit entschieden, von welchem dynamischen Typ ein Objekt ist und welche Methode somit ausgeführt
+wird. Sie dürfen hier keine Typumwandlungen (Casts) und auch nicht die Methoden `getClass()` und
+`instanceOf()` verwenden.
+
+- Es ist möglich, aber nicht verlangt, `addForceTo(CosmicSystem cs)` ohne Verwendung von
+`getBodies()` zu implementieren. Dazu kann in `addForceTo(CosmicSystem cs)` der Zugriff auf
+die einzelnen Körper in `cs` dadurch erreicht werden, dass `this` für alle seine Himmelskörper
+und Untersysteme `addForceTo(cs)` aufruft. Wird beim rekursiven Abstieg ein einzelner Himmelskörper
+erreicht (Blattknoten) ruft dieser `cs.addForceFrom(this)` auf.
+
+- Achten Sie bei der Berechnung der Kräfte in `addForceFrom(Body b)` darauf, dass die Kraft nicht 
+verändert wird, wenn `this` und `b` derselbe Himmelskörper sind.
+
+#### _Punkteaufteilung_
+
+- Implementierung von `CosmicSystem` in `NamedBodyForcePair`: 1.5 Punkte
+- Implementierung von `CosmicSystem` in `HierarchicalSystem`: 2.5 Punkte
+- Implementierung von `Simulation4`: 1 Punkte
+
+- Gesamt: 5 Punkte

angabe/Aufgabenblatt5.md

@@ -0,0 +1,102 @@
+# Aufgabenblatt 5
+
+## Allgemeine Anmerkungen
+
+Ihre Lösung für dieses Aufgabenblatt ist bis Montag, 9.5. 11h durch `git commit` und `git push`
+abzugeben. Mit der Angabe werden die Dateien `Massive.java`, `NamedBody.java`, `MassiveLinkedList.java`,
+`MassiveForceHashMap.java`, `Simulation5.java` und `Aufgabe5Test.java` mitgeliefert.
+
+Wenn Sie zusätzlich zu den gefragten Klassen weitere Klassen definieren, achten Sie darauf, dass
+die Klassennamen mit `My` beginnen, um Konflikte mit späteren Aufgabenblättern zu vermeiden.
+
+## Ziel
+
+Ziel der Aufgabe ist die Anwendung der Konzepte: Gleichheit und Hash-Werte, Hash-Tabelle
+(siehe Skriptum Seite 85-91).
+
+## Beschreibung der gegebenen Dateien
+
+- [Massive](../src/Massive.java) ist ein Interface, das Himmelskörper (als kohärente Massen)
+beschreibt. `Massive` ist der gemeinsame Obertyp für verschiedene Klassen von Himmelkörpern. Die
+meisten spezifizierten Methoden sind mit einer `default`-Implementierung definiert. Dieser
+Programmcode wird ausgeführt, falls die entsprechende Klasse (`Body` oder `NamedBody`) über keine
+eigene Definition der Methode verfügt. Verändern Sie diese Datei bitte nicht.
+- [NamedBody](../src/NamedBody.java) ist das Gerüst einer Klassendefinition. Die Klasse
+repräsentiert Himmelskörper, die einen Namen haben.
+- [MassiveLinkedList](../src/MassiveLinkedList.java) ist das Gerüst für eine Implementierung einer
+verketteten Liste von `Massive`-Objekten. Die Liste unterscheidet sich von `BodyLinkedList`
+dadurch, dass der Elementtyp statt `Body` der Obertyp `Massive` ist.
+- [MassiveForceHashMap](../src/MassiveForceHashMap.java) ist das Gerüst für eine Implementierung
+einer assoziativen Datenstruktur, die ein `Massive`-Objekt mit der auf das Objekt wirkenden Kraft
+assoziiert.
+- [Simulation5](../src/Simulation5.java) ist ein Gerüst für eine ausführbare Klasse. Hier soll
+die Simulation analog zur Klasse `Simulation` implementiert werden (damit Sie Ihre [ursprüngliche
+ Datei](../src/Simulation.java) nicht überschreiben müssen).
+- [Aufgabe5Test](../src/Aufgabe5Test.java) ist eine vorgegebene Klasse, die Sie zum Testen Ihrer
+Implementierung verwenden sollten. Bei einer fehlerfreien Implementierung sollten bei der
+Ausführung dieser Klasse keine Exceptions geworfen werden und alle Tests als erfolgreich ("successful")
+ausgegeben werden. Entfernen Sie die Kommentarzeichen, um diese Klasse verwenden zu können. Sie
+müssen diese Klasse nicht weiter verändern, können aber eigene Testfälle hinzufügen.
+
+## Aufgaben
+
+Ihre Aufgaben sind folgende:
+
+**1. Implementieren Sie `Massive` in den Klassen `Body` und `NamedBody`.**
+
+ Passen Sie die bestehende Definition von `Body` so an, dass die Klasse `Massive` implementiert wird.
+ Vervollständigen Sie auch `NamedBody` so, dass sie `Massive` implementiert und die vorgegebene
+ Spezifikationen der Methoden erfüllt.
+
+**2. Überschreiben von `equals` und `hashCode` in `NamedBody`:**
+
+ Überschreiben Sie in `NamedBody` die Methoden `equals` und `hashCode` gemäß der dort angeführten
+ Spezifikation. Achten Sie bei der Implementierung darauf, dass die in der Klasse `Object`
+ beschriebenen Bedingungen für `equals` und `hashCode` eingehalten werden. `equals` und `hashCode`
+ müssen zusammen passen.
+
+**3. Vervollständigen von `MassiveLinkedList`:**
+
+ Definieren Sie `MassiveLinkedList`. Die Klasse ist wie `BodyLinkedList` aufgebaut, mit dem
+ Unterschied, dass der Elementtyp statt `Body` nun der Typ `Massive` ist. Die Methode `indexOf` 
+ vergleicht Objekte mittels `equals`.
+
+**4. Implementierung von `MassiveForceHashMap`:**
+
+ Vervollständigen Sie die Definition der Klasse `MassiveForceHashMap`, die eine Hash-Tabelle
+ mit Schlüssel vom Typ `Massive` und Wert vom Typ `Vector3` implementiert. Die Klasse ist ähnlich
+ zur Klasse `BodyForceTreeMap`. Die Unterschiede sind:
+ - Der Typ des Schlüssels ist der gemeinsame Obertyp von `Body` und `NamedBody` (`Massive`).
+   Dadurch lassen sich Objekte beider Klassen gemeinsam in der Hash-Tabelle speichern.
+ - Die Schlüssel-Werte-Paare sind nicht nach Masse sortiert. Stattdessen wird der Hash-Wert zur
+   Suche benutzt.
+ - Es gibt eine zusätzliche Methode `keyList()`. Die Methoden `equals` und `hashCode` werden
+   redefiniert.
+
+**5. Implementierung von `Simulation5`:**
+
+ Implementieren Sie die Simulationsschleife unter Verwendung eines Objekts vom Typ
+ `MassiveForceHashMap`. Die Methode `keyList()` hilft beim Iterieren der Hash-Tabelle.
+ Kollisionen von Himmelskörpern müssen in dieser Simulation nicht berücksichtigt werden.
+
+### Hinweise:
+
+- Verwenden Sie bei der Implementierung von `MassiveForceHashMap` eine geeignete Kollisionsbehandlung
+  für gleiche Hash-Werte. Als Vorlage können Sie den Beispielcode aus dem Skriptum nutzen.
+
+### Denkanstöße (ohne Bewertung)
+
+1. Wie könnte man vorgehen, wenn man - wie in früheren Simulationen - Himmelskörper im Fall von
+   Kollisionen verschmelzen will?
+2. Was ändert sich am Verhalten von `MassiveForceHashMap`, wenn man in `Body` die Methoden
+   `equals` und `hashCode` überschreiben würde?
+
+#### _Punkteaufteilung_
+
+- Implementierung von `Massive` in `NamedBody`: 1 Punkt
+- Implementierung von `Massive` in `Body`: 0.5 Punkt
+- Implementierung von `MassiveForceHashMap`: 2 Punkte
+- Implementierung von `MassiveLinkedList`: 0.5 Punkte
+- Implementierung von `Simulation5`: 1 Punkte
+ 
+- Gesamt: 5 Punkte

angabe/Aufgabenblatt6.md

@@ -0,0 +1,75 @@
+# Aufgabenblatt 6
+
+## Allgemeine Anmerkungen
+
+Ihre Lösung für dieses Aufgabenblatt ist bis Montag, 23.5. 11h durch `git commit` und `git push`
+abzugeben. Mit der Angabe werden die Dateien `MassiveIterable.java`, `MassiveIterator.java`, 
+`MassiveSet.java`, `MassiveForceTreeMap.java`, `Simulation6.java` und `Aufgabe6Test.java` 
+mitgeliefert.
+
+Wenn Sie zusätzlich zu den gefragten Klassen weitere Klassen definieren, achten Sie darauf, dass
+die Klassennamen mit `My` beginnen, um Konflikte mit späteren Aufgabenblättern zu vermeiden.
+
+## Ziel
+
+Ziel der Aufgabe ist die Anwendung der Konzepte: Iterator, Kopie vs. Sichtweise, Sortieren
+(siehe Skriptum Seite 91-109).
+
+## Beschreibung der gegebenen Dateien
+
+- [MassiveIterable](../src/MassiveIterable.java) ist ein Interface, das iterierbare Objekte mit
+Elementen vom Typ `Massive` spezifiziert. Verändern Sie diese Datei bitte nicht.
+- [MassiveIterator](../src/MassiveIterator.java) ist ein Interface, das einen Iterator über
+Elemente vom Typ `Massive` spezifiziert. Verändern Sie diese Datei bitte nicht.
+- [MassiveSet](../src/MassiveSet.java) ist ein Interface, das iterierbare Mengen mit 
+`Massive`-Elementen spezifiziert. Verändern Sie diese Datei bitte nicht.
+- [MassiveForceTreeMap](../src/MassiveForceTreeMap.java) ist das Gerüst für eine Implementierung
+einer assoziativen Datenstruktur, die ein `Massive`-Objekt mit der auf das Objekt wirkenden Kraft
+assoziiert.
+- [Simulation6](../src/Simulation6.java) ist ein Gerüst für eine ausführbare Klasse. Hier soll
+die Simulation analog zur Klasse `Simulation` implementiert werden (damit Sie Ihre [ursprüngliche
+ Datei](../src/Simulation.java) nicht überschreiben müssen).
+- [Aufgabe6Test](../src/Aufgabe6Test.java) ist eine vorgegebene Klasse, die Sie zum Testen Ihrer
+Implementierung verwenden sollten. Bei einer fehlerfreien Implementierung sollten bei der
+Ausführung dieser Klasse keine Exceptions geworfen werden und alle Tests als erfolgreich ("successful")
+ausgegeben werden. Entfernen Sie die Kommentarzeichen, um diese Klasse verwenden zu können. Sie
+müssen diese Klasse nicht weiter verändern, können aber eigene Testfälle hinzufügen.
+
+## Aufgaben
+
+Ihre Aufgaben sind folgende:
+
+**1. Implementieren Sie die Klasse `MassiveForceTreeMap`.**
+
+ Implementieren Sie die Klasse `MassiveForceTreeMap`. `MassiveForceTreeMap` ist wie 
+ `BodyForceTreeMap` aufgebaut, mit dem Unterschied, dass der Typ des Schlüssels statt `Body` nun 
+ der Typ `Massive` ist. Weiters soll die Klasse Methode `getKeys()` zur Verfügung stellen, 
+ die eine `MassiveSet`-Sichtweise auf die Menge der Schlüssel liefert. Änderungen an dem 
+ zurückgelieferten `MassiveSet`-Objekt wirken sich auf das zugrunde 
+ liegende `MassiveForceTreeMap`-Objekt aus. Die Methode `toList()` liefert dagegen eine 
+ unabhängige Liste (Kopie) mit allen Schlüsseln der Map. Für die Implementierung von 
+ `MassiveSet` können Sie einen eigenen Klassennamen beginnend mit `My` wählen. Die Definition kann 
+ in einer eigenen Datei oder in der Datei `MassiveForceTreeMap.java` erfolgen.
+ 
+**2. Adaptieren Sie die Klasse `HierarchicalSystem`:**
+
+ Die Klasse `HierarchicalSystem` soll so geändert werden, dass sie das gegebene 
+ Interface `MassiveIterable` implementiert. Die Reihenfolge der vom Iterator gelieferten 
+ Elemente ist nicht festgelegt. Sie dürfen für die Implementierung bei Bedarf Ihren Klassen 
+ `NamedBodyForcePair` und `HierarchicalSystem` neue, nicht angegebene Methoden hinzufügen.
+ Die Verwendung von Klassen des Java-Collection-Frameworks (z.B. java.util.Stack) ist erlaubt
+ (aber nicht notwendig).
+ 
+**3. Implementierung von `Simulation6`:**
+
+ Implementieren Sie die Simulationsschleife unter Verwendung eines Objekts vom Typ
+ `MassiveForceTreeMap`. Die Methode `getKeys()` hilft beim Iterieren der gespeicherten Schlüssel.
+ Kollisionen von Himmelskörpern müssen in dieser Simulation nicht berücksichtigt werden.
+
+#### _Punkteaufteilung_
+
+- Implementierung von `MassiveForceTreeMap`: 3 Punkte
+- Implementierung von `MassiveIterable` in `HierarchicalSystem`: 1.5 Punkte
+- Implementierung von `Simulation6`: 0.5 Punkte
+ 
+- Gesamt: 5 Punkte

angabe/Aufgabenblatt8.md

@@ -0,0 +1,152 @@
+# Aufgabenblatt 8
+
+## Allgemeine Anmerkungen
+Ihre Lösung für dieses Aufgabenblatt ist bis Dienstag, 13.6., 11h durch `git commit` und `git push` 
+abzugeben.
+Wenn Sie zusätzlich zu den gefragten Klassen und Interfaces weitere Klassen oder 
+Interfaces definieren, achten Sie darauf, dass die Klassennamen mit `My` beginnen, um Konflikte 
+mit späteren Aufgabenblättern zu vermeiden.
+
+Weiters werden die Dateien `StateFileNotFoundException.java`, 
+`StateFileFormatException.java`, `ReadDataUtil.java`, `Simulation8.java`, `Simulation9.java`,
+ `Aufgabe8Test.java` und das Verzeichnis `states` mit `txt`-Dateien mitgeliefert. 
+
+## Ziel
+Ziel der Aufgabe ist das Verständnis und die Anwendung der Konzepte: Java-Collections, Eingabe mit 
+Validierung, Exceptions (S. 110-123).
+
+## Beschreibung der gegebenen Dateien
+
+- [states](../states) ist ein Verzeichnis, in dem mehrere Dateien mit der Endung `.txt` 
+ mitgeliefert werden. Diese enthalten Daten von je einem Himmelskörper sowie dessen Positionen und
+ Geschwindigkeitsvektoren für alle Tage der Jahre 2019-2021. Die Angaben sind wie gewohnt in 
+ kartesischen Koordinaten, wobei die Sonne den Urspung des Koordinatensystems bildet und die 
+ Ekliptik die x-y-Ebene darstellt. Die Daten stammen von [https://ssd.jpl.nasa.gov/horizons.cgi#top](https://ssd.jpl.nasa.gov/horizons.cgi#top). 
+   
+    **ACHTUNG**: Die Werte sind in km bzw. km/sec angegeben! 
+                      
+- [StateFileNotFoundException](../src/StateFileNotFoundException.java) enthält die Definition
+der Klasse `StateFileNotFoundException`. Diese sollen Sie vervollständigen.
+- [StateFileFormatException](../src/StateFileFormatException.java) enthält die Definition
+der Klasse `StateFileFormatException`. Diese sollen Sie vervollständigen.
+- [ReadDataUtil](../src/ReadDataUtil.java) ist eine Klasse mit einer statischen Methode zum
+Einlesen von Position- und Bewegungsvektoren von Himmelskörpern aus Dateien. 
+Diese sollen Sie vervollständigen.
+- [Simulation8](../src/Simulation8.java) ist ein Gerüst für eine ausführbare Klasse. Hier soll
+die Simulation analog zur Klasse `Simulation` implementiert werden (damit Sie Ihre [ursprüngliche
+ Datei](../src/Simulation.java) nicht überschreiben müssen).
+- [Simulation9](../src/Simulation9.java) ist eine leere Datei. Hier soll eine weitere Simulation
+implementiert werden, die so wie `Simulation8` funktioniert, mit dem Unterschied, dass anstelle 
+der selbst implementierten Datenstrukturen nur vorgefertigte Klassen aus dem 
+Java-Collection-Framework benutzt werden sollen.
+- [Aufgabe8Test](../src/Aufgabe8Test.java) ist eine vorgegebene Klasse, die Sie zum Testen Ihrer
+Implementierung verwenden sollten. Bei einer fehlerfreien Implementierung sollten bei der
+Ausführung dieser Klasse keine Exceptions geworfen werden und alle Tests als erfolgreich ("successful")
+ausgegeben werden. Entfernen Sie die Kommentarzeichen, um diese Klasse verwenden zu können. Sie
+müssen diese Klasse nicht weiter verändern, können aber eigene Testfälle hinzufügen.
+
+
+## Aufgaben
+
+1. Ändern Sie Ihre Implementierung, sodass ein `MassiveIterator` eine Exception 
+    vom Typ `java.util.NoSuchElementException` wirft, falls `next()` aufgerufen wird,
+    jedoch der Iterator keine weitere Iteration hat (`hasNext()` liefert `false`).
+    
+2. Ändern Sie den Iterator von der von `getKeys()` zurückgelieferten 
+    Sichtweise auf `MassiveForceTreeMap` so, dass `remove()` überschrieben wird 
+    ([siehe API Dokumentation](https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html#remove--)), 
+    sodass der Iterator Einträge in Objekten von `MassiveForceTreeMap` löschen kann. Achten Sie 
+    darauf, dass hier in bestimmten Fällen eine `java.lang.IllegalStateException` geworfen werden
+    soll. Der Iterator von `HierarchicalSystem` muss nicht geändert werden.
+
+3. Validierung von Eingabedaten:
+    - Implementieren Sie in der Klasse `ReadDataUtil.java` die Methode `readConfiguration`.
+    Es soll ein gepufferter Stream zum Einlesen genutzt werden (siehe Skriptum Seite 128). 
+    Erstellen Sie zum Testen auch Varianten der txt-Dateien mit Formatfehlern.
+    - Fügen Sie der Klasse `NamedBody` bei Bedarf 
+    eine Methode `setState(Vector3 position, Vector3 velocity)` zum Setzen der Position 
+    und des Geschwindigkeitsvektors des Himmelskörpers hinzu. 
+    - Definieren Sie die beiden angegebenen Exceptionklassen in den entsprechenden 
+    mitgelieferten Dateien.
+  
+4. Ausnahmebehandlung:
+    In der Klasse `Simulation8` sollen nun die Himmelskörper mit Daten aus den gegebenen 
+    txt-Dateien initialisiert werden. Dabei sollen zumindest die Sonne sowie die 
+    inneren Planeten
+    Merkur, Venus, Erde und Mars vorkommen. Sie können weitere Himmelskörper (siehe txt-Dateien) 
+    hinzufügen. Nutzen Sie die Klasse `MassiveForceTreeMap` und ihre Iteratoren, um die 
+    Himmelskörper der Simulation zu verwalten. (Kollisionen von Himmelskörpern müssen nicht 
+    berücksichtigt werden.)
+    Ändern Sie die Klasse `Simulation8` so, dass sie zwei Kommandozeilenargumente verarbeitet. 
+    Das erste Argument ist ein String mit der Angabe des Pfades zum Verzeichnis, wo die 
+    entsprechenden txt-Dateien (z.B. `Venus.txt`,`Mercury.txt`,`Earth.txt`) mit den Konfigurationen 
+    der Himmelskörper zu finden sind. Die Dateien haben die Namen der Himmelskörper mit Endung `
+    .txt`. Für die Sonne gibt es keine txt-Datei (es wird die Position (0,0,0) angenommen).
+    Das zweite Argument ist ein String mit einer Datumsangabe der Form YYYY-MMM-DD, also z.B. 
+    2020-Dec-04, die den Tag der auszulesenden Position und Bewegungsvektor bestimmt. Die Klasse 
+    soll beim Auftreten von Problemen bei der Ausführung entsprechende Fehlermeldungen ausgeben und
+    die Ausführung in bestimmten Fällen beenden. Beispiele für Aufrufe im Kommandozeileninterpreter 
+    mit entsprechenden Fehlermeldungen (Sie können zum Ausführen das Terminal in IntelliJ nutzen
+    oder die Programmargumente unter `Edit Configurations` angeben):
+    ```
+         $ javac Simulation8.java
+         $ java Simulation8 ../states 2021-May-28
+         Running simulation ...
+         $ java Simulation8 ../states
+         Error: wrong number of arguments.
+         $ java Simulation8 ../states 2025-Dec-12
+         Warning: State not available for Earth.
+         Running simulation without Earth.
+         Warning: State not available for Venus.
+         Running simulation without Venus.
+         ...
+         $ java Simulation8 ../states-altered 2021-May-28
+         Warning: File ../states-altered/Venus.txt does not have required format. 
+         Running simulation without Venus.
+         Warning: File ../states-altered/Mars.txt not found. 
+         Running simulation without Mars.
+         Running simulation ...
+         $ java Simulation8 ../states -17
+         Error: State has wrong format (requires YYYY-MM-DD), aborting. 
+         $ java Simulation8 blah 2021-May-28
+         Warning: File blah/Earth.txt not found. 
+         Running simulation without Earth.
+         Warning: File blah/Venus.txt not found. 
+         Running simulation without Venus.
+         ...
+    ```
+
+5. Kopieren Sie den Inhalt der Datei `Simulation8.java` in die Datei `Simulation9.java` und bauen
+    Sie `Simulation9` so um, dass anstelle der selbst implementierten Datenstrukturen nur 
+    vorgefertigte Klassen aus dem Java-Collection-Framework benutzt werden.
+    
+6. Freiwillige Zusatzaufgabe (ohne Bewertung):
+    Ändern Sie die Klasse `Simulation8` so um, dass ein drittes optionales Kommandozeilenargument
+    verarbeitet werden kann. Dieses gibt an, wieviele Tage simuliert werden sollen. Beispielsweise
+    kann eine zweite Datumsangabe möglich sein, oder die Anzahl an Tagen. 
+    Sobald dieser Zeitpunkt in der Simulation erreicht wurde, können die aktuellen Positionen der
+    Himmelskörper mit den in den txt-Dateien angegebenen Positionen verglichen werden (z.B. 
+    durch erneutem Aufruf von `readConfiguration` und `draw`). Wie groß sind die Abweichungen 
+    der von NASA errechneten Positionen zu den Positionen, die Ihre Simulation liefert?
+
+### Denkanstöße (ohne Bewertung)
+
+1. Haben Sie die remove-Methode des Iterators so implementiert, dass der Aufruf keine 
+zusätzliche Suche nach dem zu löschenden Eintrag benötigt?
+2. Wie verhalten sich die von der Methode `toList()` der Klasse `MassiveForceTreeMap` 
+zurückgelieferten Listen, wenn deren enthaltene Himmelskörper durch `setState` verändert werden? 
+Werden dadurch die Himmelskörper der ursprünglichen `MassiveForceTreeMap`-Objekte auch geändert? 
+(Anmerkung: diesbezüglich gibt es im Aufgabenblatt 6 keine Vorgaben).
+3. Wie verhalten sich Ihre Iteratoren, wenn Objekte geändert werden?
+4. Wie kann man durch Einfügen von Zeichen `,` und newlines (`\n`) aus den `txt`-Dateien eine 
+"fehlerhafte" Datei machen, die trotzdem von der Methode akzeptiert wird? Kann man solche Probleme 
+verhindern?
+
+#### _Punkteaufteilung_
+
+- Änderung von `next()` von `MassiveIterator`: 0.5 Punkte
+- Implementierung der Methode `remove()` im Iterator der `MassiveSet`-Sichtweise  
+  von `MassiveForceTreeMap`: 2 Punkte
+- Implementierung der Exceptionklassen und Implementierung von `readConfiguration` 
+  in `ReadDataUtil`: 1.5 Punkte
+- Implementierung von `Simulation8` und `Simulation9`: 1 Punkt

src/Aufgabe1Test.java

@@ -1,17 +1,19 @@
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 public class Aufgabe1Test {
 
-    public static void main(String[] args) {
-        //test classes Body and Vector3
-
+    @Test
+    public void testEP2() {
         // create two bodies
-        Body sun = new Body(1.989e30,new Vector3(0,0,0),new Vector3(0,0,0));
-        Body earth = new Body(5.972e24,new Vector3(-1.394555e11,5.103346e10,0),new Vector3(-10308.53,-28169.38,0));
+        Body sun = new Body(SolSystem.SUN);
+        Body earth = new Body(SolSystem.EARTH);
 
-        testValue(earth.distanceTo(sun), 1.4850000175024106E11);
-        testValue(sun.distanceTo(earth), 1.4850000175024106E11);
+        assertEquals(1.4850000175024106E11, earth.distanceTo(sun));
+        assertEquals(1.4850000175024106E11, sun.distanceTo(earth));
 
-        for(int i = 0; i < 3600*24; i++) {
+        for (int i = 0; i < 3600 * 24; i++) {
             Vector3 f1 = earth.gravitationalForce(sun);
             Vector3 f2 = sun.gravitationalForce(earth);
 
@@ -20,36 +22,9 @@ public class Aufgabe1Test {
         }
 
         // a dummy body to check the correct position after 24h of movement
-        Body targetPositionEarth = new Body(1, new Vector3(-1.403250141841815E11,
-                4.859202658875631E10, 0.0), new Vector3(0,0,0));
+        Body targetPositionEarth = new Body(1, new Vector3(-1.403250141841815E11, 4.859202658875631E10, 0.0), new Vector3(0, 0, 0));
 
         // check distance to target position (should be zero)
-        testValue(earth.distanceTo(targetPositionEarth), 0);
-    }
-
-    public static void testComparison(Object first, Object second, boolean expected) {
-        boolean real = first == second;
-
-        if (real == expected) {
-            System.out.println("Successful comparison");
-        } else {
-            System.out.println("Comparison NOT successful! Expected value: " + expected + " / Given value: " + real);
-        }
-    }
-
-    public static void testValue(Object given, Object expected) {
-        if (given == expected) {
-            System.out.println("Successful test");
-        } else {
-            System.out.println("Test NOT successful! Expected value: " + expected + " / Given value: " + given);
-        }
-    }
-
-    public static void testValue(double given, double expected) {
-        if (given < expected + (expected+1)/1e12 && given > expected - (expected+1)/1e12) {
-            System.out.println("Successful test");
-        } else {
-            System.out.println("Test NOT successful! Expected value: " + expected + " / Given value: " + given);
-        }
+        assertEquals(0, earth.distanceTo(targetPositionEarth));
     }
 }

src/Aufgabe2Test.java

@@ -1,80 +1,51 @@
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
 public class Aufgabe2Test {
 
-    public static void main(String[] args) {
-
-        //test classes BodyQueue and BodyForceMap
-
+    @Test
+    public void testEP2() {
         // create three bodies
-        Body sun = new Body(1.989e30,new Vector3(0,0,0),new Vector3(0,0,0));
-        Body earth = new Body(5.972e24,new Vector3(-1.394555e11,5.103346e10,0),new Vector3(-10308.53,-28169.38,0));
-        Body mercury = new Body(3.301e23,new Vector3(-5.439054e10,9.394878e9,0),new Vector3(-17117.83,-46297.48,-1925.57));
-
+        Body sun = new Body(SolSystem.SUN);
+        Body earth = new Body(SolSystem.EARTH);
+        Body mercury = new Body(SolSystem.MERCURY);
 
         // check basic functions of 'BodyQueue'
-        System.out.println("Test1:");
-
         BodyQueue bq = new BodyQueue(2);
         bq.add(mercury);
         bq.add(sun);
         bq.add(earth);
-        testValue(bq.size(), 3);
+        assertEquals(3, bq.size());
 
-        testValue(bq.poll(), mercury);
-        testValue(bq.poll(), sun);
-        testValue(bq.poll(), earth);
+        assertEquals(mercury, bq.poll());
+        assertEquals(sun, bq.poll());
+        assertEquals(earth, bq.poll());
 
-        testValue(bq.size(), 0);
+        assertEquals(0, bq.size());
 
         bq.add(mercury);
         bq.add(sun);
-        testValue(bq.size(), 2);
+        assertEquals(2, bq.size());
 
         // check constructor of 'BodyQueue'
         BodyQueue bqCopy = new BodyQueue(bq);
-        testComparison(bq, bqCopy, false);
-        testComparison(bq.poll(), bqCopy.poll(), true);
+        assertNotEquals(bq, bqCopy);
+        assertEquals(bqCopy.poll(), bq.poll());
         bq.add(earth);
-        testValue(bq.size(), 2);
-        testValue(bqCopy.size(), 1);
+        assertEquals(2, bq.size());
+        assertEquals(1, bqCopy.size());
 
         // check basic functions of 'BodyForceMap'
-        System.out.println("Test2:");
         BodyForceMap bfm = new BodyForceMap(5);
         bfm.put(earth, earth.gravitationalForce(sun));
         bfm.put(sun, sun.gravitationalForce(earth));
 
-        testValue(bfm.get(earth).distanceTo(earth.gravitationalForce(sun)),0);
-        testValue(bfm.get(sun).distanceTo(sun.gravitationalForce(earth)),0);
+        assertEquals(0, bfm.get(earth).distanceTo(earth.gravitationalForce(sun)));
+        assertEquals(0, bfm.get(sun).distanceTo(sun.gravitationalForce(earth)));
 
-        bfm.put(earth, new Vector3(0,0,0));
-        testValue(bfm.get(earth).distanceTo(new Vector3(0,0,0)), 0);
-        testValue(bfm.get(mercury),null);
-
-    }
-
-    public static void testComparison(Object first, Object second, boolean expected) {
-        boolean real = first == second;
-
-        if (real == expected) {
-            System.out.println("Successful comparison");
-        } else {
-            System.out.println("Comparison NOT successful! Expected value: " + expected + " / Given value: " + real);
-        }
-    }
-
-    public static void testValue(Object given, Object expected) {
-        if (given == expected) {
-            System.out.println("Successful test");
-        } else {
-            System.out.println("Test NOT successful! Expected value: " + expected + " / Given value: " + given);
-        }
-    }
-
-    public static void testValue(double given, double expected) {
-        if (given < expected + (expected+1)/1e12 && given > expected - (expected+1)/1e12) {
-            System.out.println("Successful test");
-        } else {
-            System.out.println("Test NOT successful! Expected value: " + expected + " / Given value: " + given);
-        }
+        bfm.put(earth, new Vector3(0, 0, 0));
+        assertEquals(0, bfm.get(earth).distanceTo(new Vector3(0, 0, 0)));
+        assertNull(bfm.get(mercury));
     }
 }

src/Aufgabe3Test.java

@@ -1,73 +1,67 @@
-import java.util.Objects;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 public class Aufgabe3Test {
 
-    public static void main(String[] args) {
-
-        //test classes BodyLinkedList and BodyForceTreeMap
-
+    @Test
+    public void testEP2() {
         // create five bodies
-        Body sun = new Body(1.989e30, new Vector3(0, 0, 0), new Vector3(0, 0, 0));
-        Body earth = new Body(5.972e24, new Vector3(-1.394555e11, 5.103346e10, 0), new Vector3(-10308.53, -28169.38, 0));
-        Body mercury = new Body(3.301e23, new Vector3(-5.439054e10, 9.394878e9, 0), new Vector3(-17117.83, -46297.48, -1925.57));
-        Body venus = new Body(4.86747e24, new Vector3(-1.707667e10, 1.066132e11, 2.450232e9), new Vector3(-34446.02, -5567.47, 2181.10));
-        Body mars = new Body(6.41712e23, new Vector3(-1.010178e11, -2.043939e11, -1.591727E9), new Vector3(20651.98, -10186.67, -2302.79));
+        Body sun = new Body(SolSystem.SUN);
+        Body earth = new Body(SolSystem.EARTH);
+        Body mercury = new Body(SolSystem.MERCURY);
+        Body venus = new Body(SolSystem.VENUS);
+        Body mars = new Body(SolSystem.MARS);
 
         // check basic functions of 'BodyLinkedList'
-        System.out.println("Test1:");
-
         BodyLinkedList bl = new BodyLinkedList();
 
         bl.addLast(mercury);
         bl.addLast(sun);
         bl.addLast(earth);
-        testValue(bl.size(), 3);
+        assertEquals(3, bl.size());
 
-        testValue(bl.getFirst(), mercury);
-        testValue(bl.getLast(), earth);
+        assertEquals(mercury, bl.getFirst());
+        assertEquals(earth, bl.getLast());
 
-        testValue(bl.get(0), mercury);
-        testValue(bl.get(1), sun);
-        testValue(bl.get(2), earth);
+        assertEquals(mercury, bl.get(0));
+        assertEquals(sun, bl.get(1));
+        assertEquals(earth, bl.get(2));
 
-        System.out.println("Test2:");
-        testValue(bl.indexOf(earth), 2);
-        testValue(bl.indexOf(sun), 1);
-        testValue(bl.indexOf(mercury), 0);
+        assertEquals(2, bl.indexOf(earth));
+        assertEquals(1, bl.indexOf(sun));
+        assertEquals(0, bl.indexOf(mercury));
 
-        System.out.println("Test3:");
-        testValue(bl.pollFirst(), mercury);
-        testValue(bl.pollLast(), earth);
-        testValue(bl.pollFirst(), sun);
+        assertEquals(mercury, bl.pollFirst());
+        assertEquals(earth, bl.pollLast());
+        assertEquals(sun, bl.pollFirst());
 
-        testValue(bl.size(), 0);
-        testValue(bl.getFirst(), null);
+        assertEquals(0, bl.size());
+        assertNull(bl.getFirst());
 
-        System.out.println("Test4:");
         bl.addFirst(earth);
         bl.addFirst(venus);
         bl.addFirst(sun);
         bl.add(1, mercury);
         bl.add(4, mars);
 
-        testValue(bl.size(), 5);
+        assertEquals(5, bl.size());
 
-        testValue(bl.get(0), sun);
-        testValue(bl.get(1), mercury);
-        testValue(bl.get(2), venus);
-        testValue(bl.get(3), earth);
-        testValue(bl.get(4), mars);
+        assertEquals(sun, bl.get(0));
+        assertEquals(mercury, bl.get(1));
+        assertEquals(venus, bl.get(2));
+        assertEquals(earth, bl.get(3));
+        assertEquals(mars, bl.get(4));
 
         // check constructor of 'BodyLinkedList'
         BodyLinkedList blCopy = new BodyLinkedList(bl);
-        testComparison(bl, blCopy, false);
-        testComparison(bl.pollFirst(), blCopy.pollFirst(), true);
+        assertNotEquals(bl, blCopy);
+        assertEquals(blCopy.pollFirst(), bl.pollFirst());
         bl.addFirst(sun);
-        testValue(bl.size(), 5);
-        testValue(blCopy.size(), 4);
+        assertEquals(5, bl.size());
+        assertEquals(4, blCopy.size());
 
         // check basic functions of 'BodyForceTreeMap'
-        System.out.println("Test5:");
         BodyForceTreeMap bfm = new BodyForceTreeMap();
         bfm.put(earth, earth.gravitationalForce(sun));
         bfm.put(sun, sun.gravitationalForce(earth).plus(sun.gravitationalForce(venus)));
@@ -75,38 +69,11 @@ public class Aufgabe3Test {
         bfm.put(mars, mars.gravitationalForce(sun));
         bfm.put(mercury, mercury.gravitationalForce(sun));
 
-        testValue(bfm.get(earth).distanceTo(earth.gravitationalForce(sun)), 0);
-        testValue(bfm.get(sun).distanceTo(sun.gravitationalForce(earth).plus(sun.gravitationalForce(venus))), 0);
+        assertEquals(0, bfm.get(earth).distanceTo(earth.gravitationalForce(sun)));
+        assertEquals(0, bfm.get(sun).distanceTo(sun.gravitationalForce(earth).plus(sun.gravitationalForce(venus))));
 
-        testValue(bfm.put(earth, new Vector3(0, 0, 0)).distanceTo(earth.gravitationalForce(sun)), 0);
-        testValue(bfm.get(earth).distanceTo(new Vector3(0, 0, 0)), 0);
-        testValue(bfm.get(mercury), mercury.gravitationalForce(sun));
-
-    }
-
-    public static void testComparison(Object first, Object second, boolean expected) {
-        boolean real = first == second;
-
-        if (real == expected) {
-            System.out.println("Successful comparison");
-        } else {
-            System.out.println("Comparison NOT successful! Expected value: " + expected + " / Given value: " + real);
-        }
-    }
-
-    public static void testValue(Object given, Object expected) {
-        if (given == expected) {
-            System.out.println("Successful test");
-        } else {
-            System.out.println("Test NOT successful! Expected value: " + expected + " / Given value: " + given);
-        }
-    }
-
-    public static void testValue(double given, double expected) {
-        if (given < expected + (expected + 1) / 1e12 && given > expected - (expected + 1) / 1e12) {
-            System.out.println("Successful test");
-        } else {
-            System.out.println("Test NOT successful! Expected value: " + expected + " / Given value: " + given);
-        }
+        assertEquals(0, bfm.put(earth, new Vector3(0, 0, 0)).distanceTo(earth.gravitationalForce(sun)));
+        assertEquals(0, bfm.get(mercury).distanceTo(mercury.gravitationalForce(sun)));
+        assertEquals(mercury.gravitationalForce(sun), bfm.get(mercury));
     }
 }

src/Aufgabe4Test.java

@@ -0,0 +1,110 @@
+import java.util.HashSet;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class Aufgabe4Test {
+
+    private NamedBodyForcePair sun2, mercury2, venus2, earth2, moon2, mars2, deimos2, phobos2, vesta2, pallas2, hygiea2, ceres2;
+
+    public void resetBodies() {
+        sun2 = new NamedBodyForcePair(SolSystem4.SUN_NAMED);
+        earth2 = new NamedBodyForcePair(SolSystem4.EARTH_NAMED);
+        moon2 = new NamedBodyForcePair(SolSystem4.MOON_NAMED);
+        mars2 = new NamedBodyForcePair(SolSystem4.MARS_NAMED);
+        deimos2 = new NamedBodyForcePair(SolSystem4.DEIMOS_NAMED);
+        phobos2 = new NamedBodyForcePair(SolSystem4.PHOBOS_NAMED);
+        mercury2 = new NamedBodyForcePair(SolSystem4.MERCURY_NAMED);
+        venus2 = new NamedBodyForcePair(SolSystem4.VENUS_NAMED);
+        vesta2 = new NamedBodyForcePair(SolSystem4.VESTA_NAMED);
+        pallas2 = new NamedBodyForcePair(SolSystem4.PALLAS_NAMED);
+        hygiea2 = new NamedBodyForcePair(SolSystem4.HYGIEA_NAMED);
+        ceres2 = new NamedBodyForcePair(SolSystem4.CERES_NAMED);
+    }
+
+    @Test
+    public void testEP2() {
+        //test classes HierarchicalSystem and NamedBodyForcePair
+
+        Body sun1 = new Body(SolSystem4.SUN);
+        Body earth1 = new Body(SolSystem4.EARTH);
+        Body moon1 = new Body(SolSystem4.MOON);
+        Body mars1 = new Body(SolSystem4.MARS);
+        Body deimos1 = new Body(SolSystem4.DEIMOS);
+        Body phobos1 = new Body(SolSystem4.PHOBOS);
+        Body mercury1 = new Body(SolSystem4.MERCURY);
+        Body venus1 = new Body(SolSystem4.VENUS);
+        Body vesta1 = new Body(SolSystem4.VESTA);
+        Body pallas1 = new Body(SolSystem4.PALLAS);
+        Body hygiea1 = new Body(SolSystem4.HYGIEA);
+        Body ceres1 = new Body(SolSystem4.CERES);
+
+        Body[] bodies = new Body[]{sun1, mercury1, venus1, earth1, moon1, mars1, deimos1, phobos1, vesta1, pallas1, hygiea1, ceres1};
+        Vector3[] forceOnBody = new Vector3[bodies.length];
+        resetBodies();
+        NamedBodyForcePair[] pairs = new NamedBodyForcePair[]{sun2, mercury2, venus2, earth2, moon2, mars2, deimos2, phobos2, vesta2, pallas2, hygiea2, ceres2};
+
+        // check basic functions of 'HierarchicalSystem'
+        CosmicSystem earthSystem = new HierarchicalSystem(earth2, moon2);
+        CosmicSystem marsSystem = new HierarchicalSystem(mars2, deimos2, phobos2);
+        CosmicSystem solarSystem = new HierarchicalSystem(sun2, mercury2, venus2, earthSystem, marsSystem, vesta2, pallas2, hygiea2, ceres2);
+
+        assertEquals(2, earthSystem.numberOfBodies());
+        assertEquals(12, solarSystem.numberOfBodies());
+
+        System.out.println(solarSystem);
+        assertTrue(solarSystem.toString().contains("Mars"));
+        assertTrue(solarSystem.toString().contains("Deimos"));
+        assertTrue(solarSystem.toString().contains("Moon"));
+        assertTrue(earthSystem.toString().contains("Moon"));
+        assertTrue(earthSystem.toString().contains("Earth"));
+
+        assertEquals(1.9890118865556799E30, solarSystem.getMass());
+
+        BodyLinkedList bl = solarSystem.getBodies();
+        assertEquals(12, bl.size());
+        HashSet<Body> set = new HashSet<>();
+        while (bl.size() > 0) {
+            set.add(bl.pollFirst());
+        }
+        assertEquals(12, set.size());
+
+        for (int seconds = 0; seconds < 50000; seconds++) {
+            // for each body (with index i): compute the total force exerted on it.
+            for (int i = 0; i < bodies.length; i++) {
+                forceOnBody[i] = new Vector3(0, 0, 0); // begin with zero
+                for (int j = 0; j < bodies.length; j++) {
+                    if (i != j) {
+                        pairs[i].addForceTo(pairs[j]);
+                        Vector3 forceToAdd = bodies[i].gravitationalForce(bodies[j]);
+                        forceOnBody[i] = forceOnBody[i].plus(forceToAdd);
+                    }
+                }
+            }
+            // now forceOnBody[i] holds the force vector exerted on body with index i.
+
+            // for each body (with index i): move it according to the total force exerted on it.
+            for (int i = 0; i < bodies.length; i++) {
+                bodies[i].move(forceOnBody[i]);
+                pairs[i].update();
+            }
+        }
+
+        for (int i = 0; i < bodies.length; i++) {
+            assertEquals(0, bodies[i].massCenter().distanceTo(pairs[i].getMassCenter()));
+        }
+
+        resetBodies();
+        pairs = new NamedBodyForcePair[]{sun2, mercury2, venus2, earth2, moon2, mars2, deimos2, phobos2, vesta2, pallas2, hygiea2, ceres2};
+        HierarchicalSystem hs = new HierarchicalSystem(sun2, mercury2, venus2, new HierarchicalSystem(earth2, moon2), new HierarchicalSystem(mars2, deimos2, phobos2), vesta2, pallas2, hygiea2, ceres2);
+
+        for (int seconds = 0; seconds < 50000; seconds++) {
+            hs.addForceTo(hs);
+            hs.update();
+        }
+
+        for (int i = 0; i < bodies.length; i++) {
+            assertEquals(0, bodies[i].massCenter().distanceTo(pairs[i].getMassCenter()));
+        }
+    }
+}

src/Aufgabe5Test.java

@@ -0,0 +1,96 @@
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class Aufgabe5Test {
+
+    @Test
+    public void testEP2() {
+        //test classes NamedBody and MassiveForceHashMap
+
+        // create 12 named bodies
+        NamedBody sun1, mercury1, venus1, earth1, moon1, mars1, deimos1, phobos1, vesta1, pallas1, hygiea1, ceres1;
+
+        // create a nameless body
+        Body earth2 = new Body(SolSystem4.EARTH);
+
+        // create the same 12 named body-force pairs
+        sun1 = new NamedBody(SolSystem4.SUN_NAMED);
+        earth1 = new NamedBody(SolSystem4.EARTH_NAMED);
+        moon1 = new NamedBody(SolSystem4.MOON_NAMED);
+        mars1 = new NamedBody(SolSystem4.MARS_NAMED);
+        deimos1 = new NamedBody(SolSystem4.DEIMOS_NAMED);
+        phobos1 = new NamedBody(SolSystem4.PHOBOS_NAMED);
+        mercury1 = new NamedBody(SolSystem4.MERCURY_NAMED);
+        venus1 = new NamedBody(SolSystem4.VENUS_NAMED);
+        vesta1 = new NamedBody(SolSystem4.VESTA_NAMED);
+        pallas1 = new NamedBody(SolSystem4.PALLAS_NAMED);
+        hygiea1 = new NamedBody(SolSystem4.HYGIEA_NAMED);
+        ceres1 = new NamedBody(SolSystem4.CERES_NAMED);
+
+        NamedBody sun2 = new NamedBody("Sun", 1.9895E30, new Vector3(0.1, 0.0, 0.0), new Vector3(0.0, 0.0, 0.0));
+        NamedBody earth3 = new NamedBody("Earth", 1, new Vector3(0, 0, 0), new Vector3(0, 0, 0));
+        assertEquals(sun1, sun2);
+        assertEquals(sun2.hashCode(), sun1.hashCode());
+        assertEquals(earth1, earth3);
+        assertEquals(earth3.hashCode(), earth1.hashCode());
+
+        // check basic functions of 'MassiveForceHashMap'
+        MassiveForceHashMap map = new MassiveForceHashMap();
+        map.put(sun1, new Vector3(0, 0, 0));
+        map.put(mercury1, new Vector3(0, 0, 0));
+        map.put(venus1, new Vector3(0, 0, 0));
+        map.put(earth1, new Vector3(0, 0, 0));
+        map.put(moon1, new Vector3(0, 0, 0));
+        map.put(mars1, new Vector3(0, 0, 0));
+        map.put(deimos1, new Vector3(0, 0, 0));
+        map.put(phobos1, new Vector3(0, 0, 0));
+        map.put(vesta1, new Vector3(0, 0, 0));
+        map.put(pallas1, new Vector3(0, 0, 0));
+        map.put(hygiea1, new Vector3(0, 0, 0));
+        map.put(ceres1, new Vector3(0, 0, 0));
+        map.put(mars1, new Vector3(0, 0, 0)); // inserted twice
+        assertEquals(12, map.keyList().size());
+
+        assertTrue(map.toString().contains("Mars"));
+        assertTrue(map.toString().contains("Deimos"));
+        assertTrue(map.toString().contains("Moon"));
+        assertTrue(map.toString().contains("Earth"));
+
+        MassiveLinkedList bl = map.keyList();
+        boolean allThere = true;
+        while (bl.size() > 0) {
+            allThere &= map.containsKey(bl.pollFirst());
+        }
+        assertTrue(allThere);
+        assertFalse(map.containsKey(new Body(0, new Vector3(0, 0, 0), new Vector3(0, 0, 0))));
+        assertFalse(map.containsKey(new NamedBody("Omuamua", 0, new Vector3(0, 0, 0), new Vector3(0, 0, 0))));
+
+        int hashCode1 = map.hashCode();
+
+        Vector3 f = new Vector3(5, 5, 5);
+        map.put(earth3, f);
+        assertEquals(f, map.get(earth1));
+        assertNull(map.get(earth2));
+
+        int hashCode2 = map.hashCode();
+        assertEquals(map, map);
+        assertEquals(hashCode2, map.hashCode());
+        assertNotEquals(hashCode1, hashCode2);
+    }
+
+    @Test
+    public void testDelKey() {
+        MassiveForceHashMap map = new MassiveForceHashMap();
+        NamedBody sun1 = new NamedBody(SolSystem4.SUN_NAMED);
+        NamedBody earth1 = new NamedBody(SolSystem4.EARTH_NAMED);
+        NamedBody moon1 = new NamedBody(SolSystem4.MOON_NAMED);
+        map.put(sun1, new Vector3());
+        map.put(earth1, new Vector3());
+        map.put(moon1, new Vector3());
+        assertNotNull(map.get(sun1));
+        assertNotNull(map.delete(sun1));
+        assertNull(map.get(sun1));
+        assertNull(map.delete(sun1));
+    }
+}

src/Aufgabe6Test.java

@@ -0,0 +1,133 @@
+import org.junit.jupiter.api.Test;
+
+import java.util.HashSet;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class Aufgabe6Test {
+
+    @Test
+    public void testEP2() {
+        NamedBody sun1, mercury1, venus1, earth1, moon1, mars1, deimos1, phobos1, vesta1, pallas1, hygiea1, ceres1;
+
+        // create the same 12 named body-force pairs
+        sun1 = new NamedBody(SolSystem4.SUN_NAMED);
+        earth1 = new NamedBody(SolSystem4.EARTH_NAMED);
+        moon1 = new NamedBody(SolSystem4.MOON_NAMED);
+        mars1 = new NamedBody(SolSystem4.MARS_NAMED);
+        deimos1 = new NamedBody(SolSystem4.DEIMOS_NAMED);
+        phobos1 = new NamedBody(SolSystem4.PHOBOS_NAMED);
+        mercury1 = new NamedBody(SolSystem4.MERCURY_NAMED);
+        venus1 = new NamedBody(SolSystem4.VENUS_NAMED);
+        vesta1 = new NamedBody(SolSystem4.VESTA_NAMED);
+        pallas1 = new NamedBody(SolSystem4.PALLAS_NAMED);
+        hygiea1 = new NamedBody(SolSystem4.HYGIEA_NAMED);
+        ceres1 = new NamedBody(SolSystem4.CERES_NAMED);
+
+        // check basic functions of 'MassiveForceHashMap'
+        MassiveForceTreeMap map = new MassiveForceTreeMap();
+        map.put(sun1, new Vector3(0, 0, 0));
+        map.put(mercury1, new Vector3(0, 0, 0));
+        map.put(venus1, new Vector3(0, 0, 0));
+        map.put(earth1, new Vector3(0, 0, 0));
+        map.put(moon1, new Vector3(0, 0, 0));
+        map.put(mars1, new Vector3(0, 0, 0));
+        map.put(deimos1, new Vector3(0, 0, 0));
+        map.put(phobos1, new Vector3(0, 0, 0));
+        map.put(vesta1, new Vector3(0, 0, 0));
+        map.put(pallas1, new Vector3(0, 0, 0));
+        map.put(hygiea1, new Vector3(0, 0, 0));
+        map.put(ceres1, new Vector3(0, 0, 0));
+        map.put(mars1, new Vector3(0, 0, 0)); // inserted twice
+
+        HashSet<Massive> set1 = new HashSet<>();
+        set1.add(sun1);
+        set1.add(mercury1);
+        set1.add(venus1);
+        set1.add(earth1);
+        set1.add(moon1);
+        set1.add(mars1);
+        set1.add(deimos1);
+        set1.add(phobos1);
+        set1.add(vesta1);
+        set1.add(pallas1);
+        set1.add(hygiea1);
+        set1.add(ceres1);
+
+        assertTrue(map.toString().contains("Mars"));
+        assertTrue(map.toString().contains("Deimos"));
+        assertTrue(map.toString().contains("Moon"));
+        assertTrue(map.toString().contains("Earth"));
+
+        assertEquals(12, map.getKeys().size());
+
+        assertTrue(map.getKeys().contains(mars1));
+        assertTrue(map.getKeys().contains(new NamedBody("Mars", 6.41712E23, new Vector3(0, 0, 0), new Vector3(0, 0, 0))));
+        assertFalse(map.getKeys().contains(new Body(6.41712E23, new Vector3(0, 0, 0), new Vector3(0, 0, 0))));
+
+        HashSet<Massive> set2 = new HashSet<>();
+        for (Massive m : map.getKeys()) {
+            set2.add(m);
+        }
+
+        assertEquals(set1, set2);
+
+        MassiveLinkedList list = map.getKeys().toList();
+        while (list.size() > 0) {
+            set1.remove(list.pollLast());
+        }
+        assertTrue(set1.isEmpty());
+
+        map.getKeys().remove(mars1);
+        assertFalse(map.containsKey(mars1));
+        assertEquals(11, map.getKeys().size());
+        map.getKeys().clear();
+        assertEquals(0, map.getKeys().size());
+
+        NamedBodyForcePair sun2, mercury2, venus2, earth2, moon2, mars2, deimos2, phobos2, vesta2, pallas2, hygiea2, ceres2;
+
+        //test classes NamedBody and MassiveForceHashMap
+
+        // create 12 named bodies
+        // create the same 12 named body-force pairs
+        sun2 = new NamedBodyForcePair(SolSystem4.SUN_NAMED);
+        earth2 = new NamedBodyForcePair(SolSystem4.EARTH_NAMED);
+        moon2 = new NamedBodyForcePair(SolSystem4.MOON_NAMED);
+        mars2 = new NamedBodyForcePair(SolSystem4.MARS_NAMED);
+        deimos2 = new NamedBodyForcePair(SolSystem4.DEIMOS_NAMED);
+        phobos2 = new NamedBodyForcePair(SolSystem4.PHOBOS_NAMED);
+        mercury2 = new NamedBodyForcePair(SolSystem4.MERCURY_NAMED);
+        venus2 = new NamedBodyForcePair(SolSystem4.VENUS_NAMED);
+        vesta2 = new NamedBodyForcePair(SolSystem4.VESTA_NAMED);
+        pallas2 = new NamedBodyForcePair(SolSystem4.PALLAS_NAMED);
+        hygiea2 = new NamedBodyForcePair(SolSystem4.HYGIEA_NAMED);
+        ceres2 = new NamedBodyForcePair(SolSystem4.CERES_NAMED);
+
+        CosmicSystem earthSystem = new HierarchicalSystem(earth2, moon2);
+        CosmicSystem marsSystem = new HierarchicalSystem(mars2, deimos2, phobos2);
+        HierarchicalSystem solarSystem = new HierarchicalSystem(sun2, mercury2, venus2, earthSystem, marsSystem, vesta2, pallas2, hygiea2, ceres2);
+
+        int count = 0;
+        for (Massive b : solarSystem) {
+            count++;
+        }
+        assertEquals(12, count);
+    }
+
+    @Test
+    public void testIterator() {
+        NamedBody sun1, mercury1, venus1;
+        sun1 = new NamedBody(SolSystem4.SUN_NAMED);
+        mercury1 = new NamedBody(SolSystem4.MERCURY_NAMED);
+        venus1 = new NamedBody(SolSystem4.VENUS_NAMED);
+
+        MassiveForceTreeMap map = new MassiveForceTreeMap();
+
+        map.put(sun1, new Vector3());
+        map.put(mercury1, new Vector3());
+        map.put(venus1, new Vector3());
+        for (Massive m : map.getKeys().toList()) {
+            System.out.println(m);
+        }
+    }
+}

src/Aufgabe8Test.java

@@ -0,0 +1,100 @@
+
+import java.util.HashSet;
+import java.util.NoSuchElementException;
+
+public class Aufgabe8Test {
+
+    public static void main(String[] args) {
+
+        /* //TODO: uncomment for testing
+
+        MassiveForceTreeMap map = new MassiveForceTreeMap();
+        NamedBody mars;
+
+        map.put(new NamedBody("Oumuamua", 8e6, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Earth", 5.972E24, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Moon", 7.349E22, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(mars = new NamedBody("Mars", 6.41712E23, new Vector3(0, 0, 0),
+                        new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Deimos", 1.8E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Phobos", 1.08E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Mercury", 3.301E23, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Venus", 4.86747E24, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Vesta", 2.5908E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Pallas", 2.14E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Hygiea", 8.32E19, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Ceres", 9.394E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+
+
+        System.out.println("Test1:");
+        MassiveIterator iterator = map.getKeys().iterator();
+        int count = 0;
+        while(iterator.hasNext()) {
+            if (iterator.next().equals(mars)) {
+                iterator.remove();
+            }
+            count++;
+        }
+        testValue(count, 12);
+        testValue(map.getKeys().size(), 11);
+        testValue(map.getKeys().contains(mars), false);
+
+        System.out.println("Test2:");
+        try {
+            iterator.next();
+            // this statement must not be reached
+            testValue(true, false);
+        } catch (NoSuchElementException e) {
+            testValue(true, true);
+        }
+
+        System.out.println("Test3:");
+        iterator = map.getKeys().iterator();
+        while(iterator.hasNext()) {
+            iterator.next();
+            iterator.remove();
+        }
+        testValue(map.getKeys().size(),0);
+
+        */ //TODO: uncomment
+    }
+
+    public static void testComparison(Object first, Object second, boolean expected) {
+        boolean real = first == second;
+
+        if (real == expected) {
+            System.out.println("Successful comparison");
+        } else {
+            System.out.println("Comparison NOT successful! Expected value: " + expected + " / Given value: " + real);
+        }
+    }
+
+    public static void testValue(Object given, Object expected) {
+        if (given == expected) {
+            System.out.println("Successful test");
+        } else {
+            System.out.println("Test NOT successful! Expected value: " + expected + " / Given value: " + given);
+        }
+    }
+
+    public static void testValue(double given, double expected) {
+        if (given < expected + (expected + 1) / 1e12 && given > expected - (expected + 1) / 1e12) {
+            System.out.println("Successful test");
+        } else {
+            System.out.println("Test NOT successful! Expected value: " + expected + " / Given value: " + given);
+        }
+    }
+
+}

src/Body.java

@@ -3,8 +3,8 @@ import codedraw.CodeDraw;
 /**
  * This class represents celestial bodies like stars, planets, asteroids, etc...
  */
-public class Body {
-    private double mass;
+public class Body implements Massive {
+    private final double mass;
     private Vector3 massCenter; // position of the mass center.
     private Vector3 currentMovement;
 
@@ -14,6 +14,12 @@ public class Body {
         this.currentMovement = currentMovement;
     }
 
+    public Body(Body other) {
+        this.mass = other.mass;
+        this.massCenter = new Vector3(other.massCenter);
+        this.currentMovement = new Vector3(other.currentMovement);
+    }
+
     /**
      * Returns the distance between the mass centers of this body and the specified body 'b'.
      */
@@ -29,8 +35,10 @@ public class Body {
      * Hint: see simulation loop in Simulation.java to find out how this is done.
      */
     public Vector3 gravitationalForce(Body b) {
+        if (b == this) return new Vector3();
         Vector3 direction = b.massCenter.minus(massCenter);
         double distance = direction.length();
+        if (distance == 0) return new Vector3();
         direction.normalize();
         double force = Simulation.G * mass * b.mass / (distance * distance);
         return direction.times(force);
@@ -70,16 +78,24 @@ public class Body {
         return mass;
     }
 
+    public Vector3 massCenter() {
+        return massCenter;
+    }
+
+    public boolean collidesWith(Body body) {
+        return this.distanceTo(body) < this.radius() + body.radius();
+    }
+
     /**
      * Returns a new body that is formed by the collision of this body and 'b'. The impulse
      * of the returned body is the sum of the impulses of 'this' and 'b'.
      */
-    public Body merge(Body b) {
-        double mass = this.mass + b.mass;
+    public Body merge(Body body) {
+        double totalMass = this.mass + body.mass;
         return new Body(
-                mass,
-                massCenter.times(this.mass).plus(b.massCenter.times(b.mass)).times(1.0 / mass),
-                currentMovement.times(this.mass).plus(b.currentMovement.times(b.mass)).times(1.0 / mass)
+                totalMass,
+                this.massCenter.times(this.mass).plus(body.massCenter.times(body.mass)).times(1.0 / totalMass),
+                this.currentMovement.times(this.mass).plus(body.currentMovement.times(body.mass)).times(1.0 / totalMass)
         );
     }
 
@@ -100,9 +116,10 @@ public class Body {
      * mass, position (mass center) and current movement. Example:
      * "5.972E24 kg, position: [1.48E11,0.0,0.0] m, movement: [0.0,29290.0,0.0] m/s."
      */
+    @Override
     public String toString() {
         return String.format(
-                "%f kg, position: %s m, movement: %s m/s.",
+                "%g kg, position: %s m, movement: %s m/s.",
                 mass, massCenter.toString(), currentMovement.toString()
         );
     }

src/BodyForceTreeMap.java

@@ -1,40 +1,131 @@
-// A map that associates a Body with a Vector3 (typically this is the force exerted on the body).
-// The number of key-value pairs is not limited.
+/**
+ * A map that associates a Body with a Vector3 (typically this is the force exerted on the body).
+ * The number of key-value pairs is not limited.
+ */
 public class BodyForceTreeMap {
+    private int size = 0;
+    private Item root = null;
 
-    //TODO: declare variables.
-
-    // Adds a new key-value association to this map. If the key already exists in this map,
-    // the value is replaced and the old value is returned. Otherwise 'null' is returned.
-    // Precondition: key != null.
+    /**
+     * Adds a new key-value association to this map. If the key already exists in this map,
+     * the value is replaced and the old value is returned. Otherwise 'null' is returned.
+     * Precondition: key != null.
+     */
     public Vector3 put(Body key, Vector3 value) {
+        if (root == null) {
+            root = new Item(key, value);
+            size++;
+            return null;
+        }
+
+        Item item = root;
+        while (item != null) {
+            if (item.key == key) {
+                Vector3 old = item.value;
+                item.value = value;
+                return old;
+            } else if (item.key.mass() > key.mass()) {
+                if (item.left != null) {
+                    item = item.left;
+                } else {
+                    item.setLeft(new Item(key, value));
+                    size++;
+                    break;
+                }
+            } else {
+                if (item.right != null) {
+                    item = item.right;
+                } else{
+                    item.setRight(new Item(key, value));
+                    size++;
+                    break;
+                }
+            }
+        }
 
-        //TODO: implement method.
         return null;
     }
 
-    // Returns the value associated with the specified key, i.e. the method returns the force vector
-    // associated with the specified key. Returns 'null' if the key is not contained in this map.
-    // Precondition: key != null.
+    /**
+     * Returns the value associated with the specified key, i.e. the method returns the force vector
+     * associated with the specified key. Returns 'null' if the key is not contained in this map.
+     * Precondition: key != null.
+     */
     public Vector3 get(Body key) {
-
-        //TODO: implement method.
+        Item item = root;
+        while (item != null) {
+            if (item.key == key) {
+                return item.value;
+            } else if (item.key.mass() > key.mass()) {
+                item = item.left;
+            } else {
+                item = item.right;
+            }
+        }
         return null;
     }
 
-    // Returns 'true' if this map contains a mapping for the specified key.
+    /**
+     * Returns 'true' if this map contains a mapping for the specified key.
+     */
     public boolean containsKey(Body key) {
-
-        //TODO: implement method.
+        Item item = root;
+        while (item != null) {
+            if (item.key == key) {
+                return true;
+            } else if (item.key.mass() > key.mass()) {
+                item = item.left;
+            } else {
+                item = item.right;
+            }
+        }
         return false;
     }
 
-    // Returns a readable representation of this map, in which key-value pairs are ordered
-    // descending according to the mass of the bodies.
+    public int size() {
+        return this.size;
+    }
+
+    private String toString(Item item) {
+        String s = "";
+        if (item == null) {
+            return s;
+        }
+        s += this.toString(item.right);
+        s += String.format("{%s: %s}\n", item.key, item.value);
+        s += this.toString(item.left);
+        return s;
+    }
+
+    /**
+     * Returns a readable representation of this map, in which key-value pairs are ordered
+     * descending according to the mass of the bodies.
+     */
+    @Override
     public String toString() {
+        return (root != null) ? toString(root) : "";
+    }
 
-        //TODO: implement method.
-        return null;
+    private static class Item {
+        private final Body key;
+        private Vector3 value;
+        private Item parent;
+        private Item left;
+        private Item right;
 
+        public Item(Body key, Vector3 value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        public void setLeft(Item left) {
+            this.left = left;
+            if (left != null) left.parent = this;
+        }
+
+        public void setRight(Item right) {
+            this.right = right;
+            if (right != null) right.parent = this;
+        }
     }
 }

src/BodyLinkedList.java

@@ -1,103 +1,246 @@
-// A list of bodies implemented as a linked list.
-// The number of elements of the list is not limited.
-public class BodyLinkedList {
+import java.util.Iterator;
 
-    //TODO: declare variables.
+/**
+ * A list of bodies implemented as a linked list.
+ * The number of elements of the list is not limited.
+ */
+public class BodyLinkedList implements Iterable<Body> {
+    private int size = 0;
+    private Item first;
+    private Item last;
 
-    // Initializes 'this' as an empty list.
+    /**
+     * Initializes 'this' as an empty list.
+     */
     public BodyLinkedList() {
-
-        //TODO: define constructor.
+        first = null;
+        last = null;
     }
 
-    // Initializes 'this' as an independent copy of the specified list 'list'.
-    // Calling methods of this list will not affect the specified list 'list'
-    // and vice versa.
-    // Precondition: list != null.
+    /**
+     * Initializes 'this' as an independent copy of the specified list 'list'.
+     * Calling methods of this list will not affect the specified list 'list'
+     * and vice versa.
+     * Precondition: list != null.
+     */
     public BodyLinkedList(BodyLinkedList list) {
-
-        //TODO: define constructor.
+        this.size = 0;
+        for (Body b : list) {
+            this.addLast(b);
+        }
     }
 
-    // Inserts the specified element 'body' at the beginning of this list.
+    /**
+     * Inserts the specified element 'body' at the beginning of this list.
+     */
     public void addFirst(Body body) {
-
-        //TODO: implement method.
+        if (first == null) {
+            first = new Item(body);
+            last = first;
+        } else {
+            first.setPrev(new Item(body));
+            first = first.prev;
+        }
+        size++;
     }
 
-    // Appends the specified element 'body' to the end of this list.
+    /**
+     * Appends the specified element 'body' to the end of this list.
+     */
     public void addLast(Body body) {
-
-        //TODO: implement method.
+        if (last == null) {
+            last = new Item(body);
+            first = last;
+        } else {
+            last.setNext(new Item(body));
+            last = last.next;
+        }
+        size++;
     }
 
-    // Returns the last element in this list.
-    // Returns 'null' if the list is empty.
+    /**
+     * Returns the last element in this list.
+     * Returns 'null' if the list is empty.
+     */
     public Body getLast() {
-
-        //TODO: implement method.
-        return null;
+        return (last != null) ? last.body : null;
     }
 
-    // Returns the first element in this list.
-    // Returns 'null' if the list is empty.
+    /**
+     * Returns the first element in this list.
+     * Returns 'null' if the list is empty.
+     */
     public Body getFirst() {
-
-        //TODO: implement method.
-        return null;
+        return (first != null) ? first.body : null;
     }
 
-    // Retrieves and removes the first element in this list.
-    // Returns 'null' if the list is empty.
+    /**
+     * Retrieves and removes the first element in this list.
+     * Returns 'null' if the list is empty.
+     */
     public Body pollFirst() {
-
-        //TODO: implement method.
-        return null;
+        if (first == null) {
+            return null;
+        }
+        Body b = first.body;
+        first = first.next;
+        if (first != null) first.setPrev(null);
+        size--;
+        return b;
     }
 
-    // Retrieves and removes the last element in this list.
-    // Returns 'null' if the list is empty.
+    /**
+     * Retrieves and removes the last element in this list.
+     * Returns 'null' if the list is empty.
+     */
     public Body pollLast() {
-
-        //TODO: implement method.
-        return null;
+        if (last == null) {
+            return null;
+        }
+        Body b = last.body;
+        last = last.prev;
+        if (last != null) last.setNext(null);
+        size--;
+        return b;
     }
 
-    // Inserts the specified element 'body' at the specified position in this list.
-    // Precondition: i >= 0 && i <= size().
+    /**
+     * Inserts the specified element 'body' at the specified position in this list.
+     * Precondition: i >= 0 && i <= size().
+     */
     public void add(int i, Body body) {
+        if (first == null || i == 0) {
+            addFirst(body);
+            return;
+        } else if (i == size) {
+            addLast(body);
+            return;
+        }
 
-        //TODO: implement method.
+        Item item = first;
+        for (int j = 0; j < i; j++) {
+            item = item.next;
+        }
+
+        item.prev.setNext(new Item(body));
+        item.setPrev(item.prev.next);
+        size++;
     }
 
-    // Returns the element at the specified position in this list.
-    // Precondition: i >= 0 && i < size().
+    private Body removeItem(Item item) {
+        if (item == first) {
+            first = item.next;
+            if (first != null) first.setPrev(null);
+        } else if (item == last) {
+            last = item.prev;
+            if (last != null) last.setNext(null);
+        } else {
+            item.next.setPrev(item.prev);
+        }
+        size--;
+        return item.body;
+    }
+
+    /**
+     * Returns the element at the specified position in this list.
+     * Precondition: i >= 0 && i < size().
+     */
     public Body get(int i) {
-
-        //TODO: implement method.
-        return null;
+        Item item;
+        if (i < size / 2) {
+            item = first;
+            for (int j = 0; j < i; j++) {
+                item = item.next;
+            }
+        } else {
+            item = last;
+            for (int j = size - 1; j > i; j--) {
+                item = item.prev;
+            }
+        }
+        return item.body;
     }
 
-    // Returns the index of the first occurrence of the specified element in this list, or -1 if
-    // this list does not contain the element.
+    /**
+     * Returns the index of the first occurrence of the specified element in this list, or -1 if
+     * this list does not contain the element.
+     */
     public int indexOf(Body body) {
+        if (first == null) {
+            return -1;
+        }
 
-        //TODO: implement method.
-        return -2;
-    }
+        Item item = first;
+        for (int i = 0; i < size; i++, item = item.next) {
+            if (item.body == body) return i;
+        }
 
-    // Removes all bodies of this list, which are colliding with the specified
-    // body. Returns a list with all the removed bodies.
-    public BodyLinkedList removeCollidingWith(Body body) {
-
-        //TODO: implement method.
-        return null;
-    }
-
-    // Returns the number of bodies in this list.
-    public int size() {
-
-        //TODO: implement method.
         return -1;
     }
+
+    /**
+     * Removes all bodies of this list, which are colliding with the specified
+     * body. Returns a list with all the removed bodies.
+     */
+    public BodyLinkedList removeCollidingWith(Body body) {
+        BodyLinkedList removed = new BodyLinkedList();
+        for (Item item = first; item != null; item = item.next) {
+            if (body != item.body && body.collidesWith(item.body)) {
+                removed.addLast(this.removeItem(item));
+            }
+        }
+        return removed;
+    }
+
+    /**
+     * Returns the number of bodies in this list.
+     */
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public Iterator<Body> iterator() {
+        return new Iterator<>() {
+            Item ptr = first;
+            boolean yieldedFirst = false;
+
+            @Override
+            public boolean hasNext() {
+                return ptr != null && (!yieldedFirst || ptr.next != null);
+            }
+
+            @Override
+            public Body next() {
+                if (!yieldedFirst) {
+                    yieldedFirst = true;
+                } else {
+                    ptr = ptr.next;
+                }
+                return ptr.body;
+            }
+        };
+    }
+
+    private static class Item {
+        private final Body body;
+        private Item prev;
+        private Item next;
+
+        public Item(Body body) {
+            this.body = body;
+            this.prev = null;
+            this.next = null;
+        }
+
+        public void setPrev(Item prev) {
+            this.prev = prev;
+            if (prev != null) prev.next = this;
+        }
+
+        public void setNext(Item next) {
+            this.next = next;
+            if (next != null) next.prev = this;
+        }
+    }
 }

src/BodyQueue.java

@@ -27,15 +27,15 @@ public class BodyQueue {
      * Initializes this queue as an independent copy of the specified queue.
      * Calling methods of this queue will not affect the specified queue
      * and vice versa.
-     * Precondition: q != null.
+     * Precondition: other != null.
      */
-    public BodyQueue(BodyQueue q) {
-        this.capacity = q.capacity;
-        this.head = q.size();
+    public BodyQueue(BodyQueue other) {
+        this.capacity = other.capacity;
+        this.head = other.size();
         this.tail = 0;
         this.queue = new Body[this.capacity];
-        for (int i = 0; i < q.size(); i++) {
-            this.queue[i] = q.queue[i];
+        for (int i = 0, j = other.tail; i < this.head; i++, j++) {
+            this.queue[i] = other.queue[j % other.capacity];
         }
     }
 
@@ -43,12 +43,11 @@ public class BodyQueue {
      * Adds the specified body 'b' to this queue.
      */
     public void add(Body b) {
+        if ((head + 1) % capacity == tail) {
+            doubleCapacity();
+        }
         queue[head] = b;
         head = (head + 1) % capacity;
-        if (head == tail) {
-            doubleCapacity();
-            head = capacity / 2;
-        }
     }
 
     /**
@@ -57,6 +56,8 @@ public class BodyQueue {
      */
     public Body poll() {
         if (tail == head) {
+            tail = 0;
+            head = 0;
             return null;
         }
         Body b = queue[tail];
@@ -77,10 +78,10 @@ public class BodyQueue {
      */
     private void doubleCapacity() {
         Body[] tmp = new Body[capacity * 2];
-        for (int i = head, j = 0; i < tail + capacity; i++, j++) {
-            tmp[j] = queue[i % capacity];
+        head = size();
+        for (int i = 0, j = tail; i < head; i++, j++) {
+            tmp[i] = queue[j % capacity];
         }
-        head = capacity;
         tail = 0;
         capacity *= 2;
         queue = tmp;

src/CosmicSystem.java

@@ -0,0 +1,59 @@
+/**
+ * A representation of a system of bodies with associated forces. Provides methods
+ * for computing current mutual forces, updating the positions of bodies and drawing
+ * the bodies in a CodeDraw object.
+ */
+public interface CosmicSystem extends Drawable {
+
+    /**
+     * Returns a readable representation of this system.
+     */
+    String toString();
+
+    /**
+     * Returns the mass center of this system.
+     */
+    Vector3 getMassCenter();
+
+    /**
+     * Returns the overall mass of this system.
+     */
+    double getMass();
+
+    /**
+     * Returns the overall number of bodies contained in this system.
+     */
+    int numberOfBodies();
+
+    /**
+     * Returns the distance between the mass centers of 'this' and the specified system.
+     * Precondition: cs != null
+     */
+    double distanceTo(CosmicSystem cs);
+
+    /**
+     * Adds the force that the specified body exerts on each of this systems bodies to each of this
+     * systems bodies.
+     * Precondition: b != null
+     */
+    void addForceFrom(Body b);
+
+    /**
+     * Adds the force that this system exerts on each of the bodies of 'cs' to the bodies in 'cs'.
+     * For exact computations this means that for each body of 'this' its force on each body of
+     * 'cs' is added to this body of 'cs'.
+     * Precondition: cs != null
+     */
+    void addForceTo(CosmicSystem cs);
+
+    /**
+     * Returns a list with all the bodies of 'this'. The order is not defined.
+     */
+    BodyLinkedList getBodies();
+
+    /**
+     * Moves each of the bodies of 'this' according to the previously accumulated forces and
+     * resets all forces to zero.
+     */
+    void update();
+}

src/Drawable.java

@@ -0,0 +1,13 @@
+import codedraw.CodeDraw;
+
+/**
+ * An object that can be drawn in a CodeDraw canvas.
+ */
+public interface Drawable {
+
+    /**
+     * draws the object into the canvas 'cd'
+     * Precondition: cd != null
+     */
+    void draw(CodeDraw cd);
+}

src/HierarchicalSystem.java

@@ -0,0 +1,177 @@
+import codedraw.CodeDraw;
+
+/**
+ * A cosmic system that is composed of a central named body (of type 'NamedBodyForcePair')
+ * and an arbitrary number of subsystems (of type 'CosmicSystem') in its orbit.
+ * This class implements 'CosmicSystem'.
+ */
+public class HierarchicalSystem implements CosmicSystem, MassiveIterable {
+
+    private final NamedBodyForcePair central;
+    private CosmicSystem[] orbit;
+    private CosmicSystem[] all;
+
+    /**
+     * Initializes this system with a name and a central body.
+     */
+    public HierarchicalSystem(NamedBodyForcePair central, CosmicSystem... inOrbit) {
+        this.central = central;
+        this.orbit = inOrbit;
+        this.all = new CosmicSystem[this.orbit.length + 1];
+        this.all[0] = central;
+        System.arraycopy(this.orbit, 0, this.all, 1, this.orbit.length);
+    }
+
+    @Override
+    public Vector3 getMassCenter() {
+        double mass = this.getMass();
+        Vector3 massCenter = new Vector3();
+        for (CosmicSystem sys : all) {
+            massCenter.add(sys.getMassCenter().times(sys.getMass() / mass));
+        }
+        return massCenter;
+    }
+
+    @Override
+    public double getMass() {
+        double mass = 0;
+        for (CosmicSystem sys : all) {
+            mass += sys.getMass();
+        }
+        return mass;
+    }
+
+    @Override
+    public int numberOfBodies() {
+        int num = 0;
+        for (CosmicSystem sys : all) {
+            num += sys.numberOfBodies();
+        }
+        return num;
+    }
+
+    @Override
+    public double distanceTo(CosmicSystem cs) {
+        return this.getMassCenter().distanceTo(cs.getMassCenter());
+    }
+
+    @Override
+    public void addForceFrom(Body b) {
+        for (CosmicSystem sys : all) {
+            sys.addForceFrom(b);
+        }
+    }
+
+    @Override
+    public void addForceTo(CosmicSystem cs) {
+        for (CosmicSystem sys : all) {
+            sys.addForceTo(cs);
+        }
+    }
+
+    @Override
+    public BodyLinkedList getBodies() {
+        BodyLinkedList list = new BodyLinkedList();
+        for (CosmicSystem sys : all) {
+            for (Body b : sys.getBodies()) {
+                list.addFirst(b);
+            }
+        }
+        return list;
+    }
+
+    @Override
+    public void update() {
+        for (CosmicSystem sys : all) {
+            sys.update();
+        }
+    }
+
+    @Override
+    public void draw(CodeDraw cd) {
+        for (CosmicSystem sys : all) {
+            sys.draw(cd);
+        }
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(central.getName());
+
+        sb.append(" {");
+        boolean first = true;
+        for (CosmicSystem sys : orbit) {
+            if (!first) sb.append(", ");
+            sb.append(sys.toString());
+            first = false;
+        }
+        sb.append("}");
+
+        return sb.toString();
+    }
+
+    /**
+     * Puts the system 'cs' at the first place in the orbit of this system.
+     * Precondition: cs != null
+     */
+    public boolean putFirst(CosmicSystem cs) {
+        CosmicSystem[] old = orbit;
+        orbit = new CosmicSystem[old.length + 1];
+        all = new CosmicSystem[old.length + 2];
+
+        orbit[0] = cs;
+        System.arraycopy(old, 0, orbit, 1, old.length);
+        all[0] = central;
+        System.arraycopy(orbit, 0, all, 1, orbit.length);
+
+        return true;
+    }
+
+    @Override
+    public MassiveIterator iterator() {
+        return new MassiveIterator() {
+            private int i = 0;
+            private MassiveIterator cur = null;
+
+            @Override
+            public Massive next() {
+                if (cur != null && cur.hasNext()) return cur.next();
+
+                while (i < all.length) {
+                    CosmicSystem sys = all[i++];
+                    if (sys instanceof NamedBodyForcePair m) {
+                        return m.getBody();
+                    } else if (sys instanceof HierarchicalSystem hs) {
+                        cur = hs.iterator();
+                        if (cur.hasNext()) {
+                            return cur.next();
+                        }
+                    }
+                }
+
+                return null;
+            }
+
+            @Override
+            public boolean hasNext() {
+                if (cur != null && cur.hasNext()) return true;
+
+                while (i < all.length) {
+                    CosmicSystem sys = all[i];
+                    if (sys instanceof NamedBodyForcePair) return true;
+                    i++;
+
+                    if (sys instanceof HierarchicalSystem hs) {
+                        cur = hs.iterator();
+                        if (cur.hasNext()) {
+                            return true;
+                        }
+                    }
+                }
+
+                return false;
+            }
+        };
+    }
+}

src/Massive.java

@@ -0,0 +1,73 @@
+/**
+ * Represents a coherent mass with a mass center in 3D space. Has two naming schemes for its
+ * methods. Please, do not change this interface definition!
+ */
+public interface Massive extends Drawable {
+
+    /**
+     * Returns the mass.
+     */
+    default double mass() {
+        return getMass();
+    }
+
+    /**
+     * Returns the mass center.
+     */
+    default Vector3 massCenter() {
+        return getMassCenter();
+    }
+
+    /**
+     * Returns the mass.
+     */
+    default double getMass() {
+        return mass();
+    }
+
+    /**
+     * Returns the mass center.
+     */
+    default Vector3 getMassCenter() {
+        return massCenter();
+    }
+
+    /**
+     * Returns the approximate radius of 'this', assuming it is a coherent round mass.
+     * (It is assumed that the radius r is related to the mass m by r = m ^ 0.5,
+     * where m and r measured in solar units.)
+     */
+    default double getRadius() {
+        return radius();
+    }
+
+    /**
+     * Returns the approximate radius of 'this', assuming it is a coherent round mass.
+     * (It is assumed that the radius r is related to the mass m by r = m ^ 0.5,
+     * where m and r measured in solar units.)
+     */
+    default double radius() {
+        return SpaceDraw.massToRadius(mass());
+    }
+
+    /**
+     * Returns a vector representing the gravitational force exerted by 'b' on this mass.
+     * The gravitational Force F is calculated by F = G*(m1*m2)/(r*r), with m1 and m2 being the
+     * masses of the objects interacting, r being the distance between the centers of the masses
+     * and G being the gravitational constant.
+     */
+    default Vector3 gravitationalForce(Massive b) {
+        Vector3 direction = b.massCenter().minus(this.massCenter());
+        double distance = direction.length();
+        direction.normalize();
+        double force = Simulation.G * this.mass() * b.mass() / (distance * distance);
+        return direction.times(force);
+    }
+
+    /**
+     * Centers this mass at a new position, according to the specified force vector 'force' exerted
+     * on it, and updates the current velocity vector accordingly.
+     * (Velocity depends on the mass of 'this', its current velocity and the exerted force.)
+     */
+    void move(Vector3 force);
+}

src/MassiveForceHashMap.java

@@ -0,0 +1,181 @@
+/**
+ * A hash map that associates a 'Massive'-object with a Vector3 (typically this is the force
+ * exerted on the object). The number of key-value pairs is not limited.
+ */
+public class MassiveForceHashMap {
+    private int size;
+    private Massive[] keys;
+    private Vector3[] values;
+
+    /**
+     * Initializes 'this' as an empty map.
+     */
+    public MassiveForceHashMap() {
+        this(16);
+    }
+
+    public MassiveForceHashMap(int capacity) {
+        this.size = 0;
+        this.keys = new Massive[capacity];
+        this.values = new Vector3[capacity];
+    }
+
+    /**
+     * Adds a new key-value association to this map. If the key already exists in this map,
+     * the value is replaced and the old value is returned. Otherwise 'null' is returned.
+     * Precondition: key != null.
+     */
+    public Vector3 put(Massive key, Vector3 value) {
+        if (size > keys.length / 2) doubleCapacity();
+
+        int idx = ((key.hashCode() % keys.length) + keys.length) % keys.length;
+        for (int i = 0; i < keys.length; i++) {
+            int pos = (idx + i) % keys.length;
+            if (values[pos] == null) {
+                keys[pos] = key;
+                values[pos] = value;
+                size++;
+                return null;
+            } else if (keys[pos].equals(key)) {
+                Vector3 old = values[pos];
+                values[pos] = value;
+                return old;
+            }
+        }
+        throw new RuntimeException();
+    }
+
+    private void doubleCapacity() {
+        Massive[] oldKeys = keys;
+        Vector3[] oldValues = values;
+        keys = new Massive[keys.length * 2];
+        values = new Vector3[values.length * 2];
+        size = 0;
+
+        for (int i = 0; i < oldKeys.length; i++) {
+            Massive k = oldKeys[i];
+            Vector3 v = oldValues[i];
+            if (v != null) put(k, v);
+        }
+    }
+
+    /**
+     * Returns the value associated with the specified key, i.e. the method returns the force vector
+     * associated with the specified key. Returns 'null' if the key is not contained in this map.
+     * Precondition: key != null.
+     */
+    public Vector3 get(Massive key) {
+        int pos = find(key);
+        return (pos == -1) ? null : values[pos];
+    }
+
+    private int find(Massive key) {
+        int idx = ((key.hashCode() % keys.length) + keys.length) % keys.length;
+        for (int i = 0; i < keys.length; i++) {
+            int pos = (idx + i) % keys.length;
+            if (keys[pos] == null) {
+                break;
+            } else if (keys[pos].equals(key)) {
+                return pos;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * Deletes the mapping for the specified key from this map if present.
+     * Returns the previous value associated with key, or null if there was
+     * no mapping for key.
+     * Precondition: key != null
+     */
+    public Vector3 delete(Massive key) {
+        int pos = find(key);
+        if (pos == -1) return null;
+
+        Vector3 val = values[pos];
+        values[pos] = null;
+        return val;
+    }
+
+    /**
+     * Returns 'true' if this map contains a mapping for the specified key.
+     */
+    public boolean containsKey(Massive key) {
+        return this.get(key) != null;
+    }
+
+    /**
+     * Returns a readable representation of this map, with all key-value pairs. Their order is not
+     * defined.
+     */
+    @Override
+    public String toString() {
+        if (size == 0) return "{}";
+
+        StringBuilder sb = new StringBuilder("{");
+        for (int i = 0; i < keys.length; i++) {
+            Massive k = keys[i];
+            Vector3 v = values[i];
+            if (k != null && v != null) {
+                sb.append("\n  ");
+                sb.append(k);
+                sb.append(": ");
+                sb.append(v);
+                sb.append(",");
+            }
+        }
+        sb.deleteCharAt(sb.length() - 1);
+        sb.append("\n}");
+        return sb.toString();
+    }
+
+    /**
+     * Compares `this` with the specified object for equality. Returns `true` if the specified
+     * `o` is not `null` and is of type `MassiveForceHashMap` and both `this` and `o` have equal
+     * key-value pairs, i.e. the number of key-value pairs is the same in both maps and every
+     * key-value pair in `this` equals one key-value pair in `o`. Two key-value pairs are
+     * equal if the two keys are equal and the two values are equal. Otherwise, `false` is returned.
+     */
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof MassiveForceHashMap map) || map.size != size)
+            return false;
+
+        for (int i = 0; i < keys.length; i++) {
+            Massive k1 = keys[i];
+            Vector3 v1 = values[i];
+            if (k1 == null || v1 == null) continue;
+            Vector3 v2 = map.get(k1);
+            if (!v1.equals(v2)) return false;
+        }
+        return true;
+    }
+
+    /**
+     * Returns the hashCode of `this`.
+     */
+    @Override
+    public int hashCode() {
+        int hash = 0;
+        for (int i = 0; i < keys.length; i++) {
+            Massive k = keys[i];
+            Vector3 v = values[i];
+            if (k == null || v == null) continue;
+            hash ^= k.hashCode();
+            hash ^= v.hashCode();
+        }
+        return hash;
+    }
+
+    /**
+     * Returns a list of all the keys in no specified order.
+     */
+    public MassiveLinkedList keyList() {
+        MassiveLinkedList list = new MassiveLinkedList();
+        for (int i = 0; i < keys.length; i++) {
+            if (keys[i] != null && values[i] != null)
+                list.addLast(keys[i]);
+        }
+        return list;
+    }
+}

src/MassiveForceTreeMap.java

@@ -0,0 +1,234 @@
+import codedraw.CodeDraw;
+
+/**
+ * A map that associates an object of 'Massive' with a Vector3. The number of key-value pairs
+ * is not limited.
+ */
+public class MassiveForceTreeMap implements MassiveSet {
+    private int size = 0;
+    private Item root;
+
+    /**
+     * Adds a new key-value association to this map. If the key already exists in this map,
+     * the value is replaced and the old value is returned. Otherwise 'null' is returned.
+     * Precondition: key != null.
+     */
+    public Vector3 put(Massive key, Vector3 value) {
+        if (root == null) {
+            root = new Item(key, value);
+            size++;
+            return null;
+        }
+
+        Item item = root;
+        while (item != null) {
+            if (item.key.equals(key)) {
+                Vector3 old = item.value;
+                item.value = value;
+                return old;
+            } else if (item.key.mass() > key.mass()) {
+                if (item.left != null) {
+                    item = item.left;
+                } else {
+                    item.setLeft(new Item(key, value));
+                    size++;
+                    break;
+                }
+            } else {
+                if (item.right != null) {
+                    item = item.right;
+                } else{
+                    item.setRight(new Item(key, value));
+                    size++;
+                    break;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Returns the value associated with the specified key, i.e. the method returns the force vector
+     * associated with the specified key. Returns 'null' if the key is not contained in this map.
+     * Precondition: key != null.
+     */
+    public Vector3 get(Massive key) {
+        Item item = root;
+        while (item != null) {
+            if (item.key.equals(key)) {
+                return item.value;
+            } else if (item.key.mass() > key.mass()) {
+                item = item.left;
+            } else {
+                item = item.right;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Returns 'true' if this map contains a mapping for the specified key.
+     * Precondition: key != null
+     */
+    public boolean containsKey(Massive key) {
+        Item item = root;
+        while (item != null) {
+            if (item.key.equals(key)) {
+                return true;
+            } else if (item.key.mass() > key.mass()) {
+                item = item.left;
+            } else {
+                item = item.right;
+            }
+        }
+        return false;
+    }
+
+    private String toString(Item item) {
+        String s = "";
+        if (item == null) {
+            return s;
+        }
+        s += this.toString(item.right);
+        s += String.format("{%s: %s}\n", item.key, item.value);
+        s += this.toString(item.left);
+        return s;
+    }
+
+    /**
+     * Returns a readable representation of this map, in which key-value pairs are ordered
+     * descending according to 'key.getMass()'.
+     */
+    public String toString() {
+        return (root != null) ? toString(root) : "";
+    }
+
+    /**
+     * Returns a `MassiveSet` view of the keys contained in this tree map. Changing the
+     * elements of the returned `MassiveSet` object also affects the keys in this tree map.
+     */
+    public MassiveSet getKeys() {
+        return this;
+    }
+
+    @Override
+    public void draw(CodeDraw cd) {
+
+    }
+
+    @Override
+    public MassiveIterator iterator() {
+        return new MassiveIterator() {
+            private Item next = root.getLeftLeaf();
+
+            @Override
+            public Massive next() {
+                if (next == null) return null;
+                Massive m = next.key;
+                Item newNext = (next.right != null) ? next.right.getLeftLeaf() : next.parent;
+                while (newNext != null && newNext.right == next) {
+                    next = newNext;
+                    newNext = newNext.parent;
+                }
+                next = newNext;
+                return m;
+            }
+
+            @Override
+            public boolean hasNext() {
+                return next != null;
+            }
+        };
+    }
+
+    @Override
+    public boolean contains(Massive element) {
+        return containsKey(element);
+    }
+
+    @Override
+    public void remove(Massive element) {
+        Item item = root;
+        while (item != null) {
+            if (item.key.equals(element)) {
+                Item newP = null;
+                if (item.left != null) {
+                    newP = item.left.getRightLeaf();
+                } else if (item.right != null) {
+                    newP = item.right.getLeftLeaf();
+                }
+                if (item.parent.left == item) {
+                    item.parent.setLeft(newP);
+                } else {
+                    item.parent.setRight(newP);
+                }
+                size--;
+                return;
+            } else if (item.key.mass() > element.mass()) {
+                item = item.left;
+            } else {
+                item = item.right;
+            }
+        }
+    }
+
+    @Override
+    public void clear() {
+        size = 0;
+        root = null;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public MassiveLinkedList toList() {
+        MassiveLinkedList list = new MassiveLinkedList();
+        for (Massive m : this) {
+            list.addLast(m);
+        }
+        return list;
+    }
+
+    private static class Item {
+        private final Massive key;
+        private Vector3 value;
+        private Item parent;
+        private Item left;
+        private Item right;
+
+        public Item(Massive key, Vector3 value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        public void setLeft(Item left) {
+            this.left = left;
+            if (left != null) left.parent = this;
+        }
+
+        public void setRight(Item right) {
+            this.right = right;
+            if (right != null) right.parent = this;
+        }
+
+        public Item getLeftLeaf() {
+            Item cur = this;
+            while (cur.left != null) {
+                cur = cur.left;
+            }
+            return cur;
+        }
+
+        public Item getRightLeaf() {
+            Item cur = this;
+            while (cur.right != null) {
+                cur = cur.right;
+            }
+            return cur;
+        }
+    }
+}

src/MassiveIterable.java

@@ -0,0 +1,11 @@
+/**
+ * Iterable objects with 'Massive' elements.
+ */
+public interface MassiveIterable extends Iterable<Massive> {
+
+    /**
+     * Returns an iterator over elements of 'Massive'.
+     */
+    @Override
+    MassiveIterator iterator();
+}

src/MassiveIterator.java

@@ -0,0 +1,20 @@
+import java.util.Iterator;
+
+/**
+ * An iterator over elements of 'Massive'.
+ */
+public interface MassiveIterator extends Iterator<Massive> {
+
+    /**
+     * Returns the next element in the iteration.
+     * (Returns 'null' if the iteration has no more elements.)
+     */
+    @Override
+    Massive next();
+
+    /**
+     * Returns 'true' if the iteration has more elements.
+     */
+    @Override
+    boolean hasNext();
+}

src/MassiveLinkedList.java

@@ -0,0 +1,218 @@
+import java.util.Iterator;
+
+/**
+ * A list of massive objects implemented as a linked list.
+ * The number of elements of the list is not limited.
+ */
+public class MassiveLinkedList implements MassiveIterable {
+    private int size = 0;
+    private Item first;
+    private Item last;
+
+    /**
+     * Initializes 'this' as an empty list.
+     */
+    public MassiveLinkedList() {
+        first = null;
+        last = null;
+    }
+
+    /**
+     * Initializes 'this' as an independent copy of the specified list 'list'.
+     * Calling methods of this list will not affect the specified list 'list'
+     * and vice versa.
+     * Precondition: list != null.
+     */
+    public MassiveLinkedList(BodyLinkedList list) {
+        this.size = 0;
+        for (Body b : list) {
+            this.addLast(b);
+        }
+    }
+
+    /**
+     * Inserts the specified element 'body' at the beginning of this list.
+     */
+    public void addFirst(Massive body) {
+        if (first == null) {
+            first = new Item(body);
+            last = first;
+        } else {
+            first.setPrev(new Item(body));
+            first = first.prev;
+        }
+        size++;
+    }
+
+    /**
+     * Appends the specified element 'body' to the end of this list.
+     */
+    public void addLast(Massive body) {
+        if (last == null) {
+            last = new Item(body);
+            first = last;
+        } else {
+            last.setNext(new Item(body));
+            last = last.next;
+        }
+        size++;
+    }
+
+    /**
+     * Returns the last element in this list.
+     * Returns 'null' if the list is empty.
+     */
+    public Massive getLast() {
+        return (last != null) ? last.body : null;
+    }
+
+    /**
+     * Returns the first element in this list.
+     * Returns 'null' if the list is empty.
+     */
+    public Massive getFirst() {
+        return (first != null) ? first.body : null;
+    }
+
+    /**
+     * Retrieves and removes the first element in this list.
+     * Returns 'null' if the list is empty.
+     */
+    public Massive pollFirst() {
+        if (first == null) {
+            return null;
+        }
+        Massive m = first.body;
+        first = first.next;
+        if (first != null) first.setPrev(null);
+        size--;
+        return m;
+    }
+
+    /**
+     * Retrieves and removes the last element in this list.
+     * Returns 'null' if the list is empty.
+     */
+    public Massive pollLast() {
+        if (last == null) {
+            return null;
+        }
+        Massive m = last.body;
+        last = last.prev;
+        if (last != null) last.setNext(null);
+        size--;
+        return m;
+    }
+
+    /**
+     * Inserts the specified element at the specified position in this list.
+     * Precondition: i >= 0 && i <= size().
+     */
+    public void add(int i, Massive m) {
+        if (first == null || i == 0) {
+            addFirst(m);
+            return;
+        } else if (i == size) {
+            addLast(m);
+            return;
+        }
+
+        Item item = first;
+        for (int j = 0; j < i; j++) {
+            item = item.next;
+        }
+
+        item.prev.setNext(new Item(m));
+        item.setPrev(item.prev.next);
+        size++;
+    }
+
+    /**
+     * Returns the element at the specified position in this list.
+     * Precondition: i >= 0 && i < size().
+     */
+    public Massive get(int i) {
+        Item item;
+        if (i < size / 2) {
+            item = first;
+            for (int j = 0; j < i; j++) {
+                item = item.next;
+            }
+        } else {
+            item = last;
+            for (int j = size - 1; j > i; j--) {
+                item = item.prev;
+            }
+        }
+        return item.body;
+    }
+
+    /**
+     * Returns the index of the first occurrence of the specified element in this list, or -1 if
+     * this list does not contain the element.
+     */
+    public int indexOf(Massive m) {
+        if (first == null) {
+            return -1;
+        }
+
+        Item item = first;
+        for (int i = 0; i < size; i++, item = item.next) {
+            if (item.body.equals(m)) return i;
+        }
+
+        return -1;
+    }
+
+    /**
+     * Returns the number of elements in this list.
+     */
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public MassiveIterator iterator() {
+        return new MassiveIterator() {
+            Item ptr = first;
+            boolean yieldedFirst = false;
+
+            @Override
+            public boolean hasNext() {
+                return ptr != null && (!yieldedFirst || ptr.next != null);
+            }
+
+            @Override
+            public Massive next() {
+                if (!yieldedFirst) {
+                    yieldedFirst = true;
+                } else {
+                    ptr = ptr.next;
+                }
+                return ptr.body;
+            }
+        };
+    }
+
+    private static class Item {
+        private final Massive body;
+        private Item prev;
+        private Item next;
+
+        public Item(Massive body) {
+            this.body = body;
+            this.prev = null;
+            this.next = null;
+        }
+
+        public void setPrev(Item prev) {
+            this.prev = prev;
+            if (prev != null) prev.next = this;
+        }
+
+        public void setNext(Item next) {
+            this.next = next;
+            if (next != null) next.prev = this;
+        }
+    }
+}

src/MassiveSet.java

@@ -0,0 +1,31 @@
+/**
+ * A collection of 'Massive' objects in which there are no duplicates.
+ */
+public interface MassiveSet extends MassiveIterable, Drawable {
+
+    /**
+     * Returns 'true' if the set has the specified element (i.e., has an element equal to the
+     * specified element).
+     */
+    boolean contains(Massive element);
+
+    /**
+     * Removes the specified element from the set.
+     */
+    void remove(Massive element);
+
+    /**
+     * Removes all elements from the set.
+     */
+    void clear();
+
+    /**
+     * Returns the number of elements in the set.
+     */
+    int size();
+
+    /**
+     * Returns an object of 'MassiveLinkedList' with all elements of 'this'.
+     */
+    MassiveLinkedList toList();
+}

src/NamedBody.java

@@ -0,0 +1,79 @@
+import codedraw.CodeDraw;
+
+public class NamedBody implements Massive {
+
+    private final String name;
+    private final Body body;
+
+    /**
+     * Initializes this with name, mass, current position and movement.
+     */
+    public NamedBody(String name, double mass, Vector3 massCenter, Vector3 currentMovement) {
+        this(name, new Body(mass, massCenter, currentMovement));
+    }
+
+    public NamedBody(String name, Body body) {
+        this.name = name;
+        this.body = body;
+    }
+
+    public NamedBody(NamedBody other) {
+        this(other.name, new Body(other.body));
+    }
+
+    /**
+     * Returns the name of the body.
+     */
+    public String getName() {
+        return name;
+    }
+
+    public Body getBody() {
+        return body;
+    }
+
+    public Vector3 getMassCenter() {
+        return body.getMassCenter();
+    }
+
+    public double getMass() {
+        return body.getMass();
+    }
+
+    /**
+     * Compares `this` with the specified object. Returns `true` if the specified `o` is not
+     * `null` and is of type `NamedBody` and both `this` and `o` have equal names.
+     * Otherwise, `false` is returned.
+     */
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof NamedBody b)) return false;
+        return this.name.equals(b.name);
+    }
+
+    /**
+     * Returns the hashCode of `this`.
+     */
+    @Override
+    public int hashCode() {
+        return this.name.hashCode();
+    }
+
+    /**
+     * Returns a readable representation including the name of this body.
+     */
+    @Override
+    public String toString() {
+        return this.getName();
+    }
+
+    @Override
+    public void move(Vector3 force) {
+        body.move(force);
+    }
+
+    @Override
+    public void draw(CodeDraw cd) {
+        body.draw(cd);
+    }
+}

src/NamedBodyForcePair.java

@@ -0,0 +1,95 @@
+import codedraw.CodeDraw;
+
+/**
+ * A body with a name and an associated force. The leaf node of
+ * a hierarchical cosmic system. This class implements 'CosmicSystem'.
+ */
+public class NamedBodyForcePair implements CosmicSystem {
+
+    private final NamedBody body;
+    private final Vector3 force = new Vector3();
+
+    /**
+     * Initializes this with name, mass, current position and movement. The associated force
+     * is initialized with a zero vector.
+     */
+    public NamedBodyForcePair(String name, double mass, Vector3 massCenter, Vector3 currentMovement) {
+        this(new NamedBody(name, mass, massCenter, currentMovement));
+    }
+
+    public NamedBodyForcePair(String name, Body body) {
+        this(new NamedBody(name, body));
+    }
+
+    public NamedBodyForcePair(NamedBody body) {
+        this.body = body;
+    }
+
+    public NamedBodyForcePair(NamedBodyForcePair other) {
+        this(new NamedBody(other.body));
+    }
+
+    public Body getBody() {
+        return body.getBody();
+    }
+
+    /**
+     * Returns the name of the body.
+     */
+    public String getName() {
+        return body.getName();
+    }
+
+    @Override
+    public String toString() {
+        return this.getName();
+    }
+
+    @Override
+    public Vector3 getMassCenter() {
+        return body.massCenter();
+    }
+
+    @Override
+    public double getMass() {
+        return body.mass();
+    }
+
+    @Override
+    public int numberOfBodies() {
+        return 1;
+    }
+
+    @Override
+    public double distanceTo(CosmicSystem cs) {
+        return getMassCenter().distanceTo(cs.getMassCenter());
+    }
+
+    @Override
+    public void addForceFrom(Body b) {
+        force.add(body.gravitationalForce(b));
+    }
+
+    @Override
+    public void addForceTo(CosmicSystem cs) {
+        cs.addForceFrom(body.getBody());
+    }
+
+    @Override
+    public BodyLinkedList getBodies() {
+        BodyLinkedList list = new BodyLinkedList();
+        list.addFirst(body.getBody());
+        return list;
+    }
+
+    @Override
+    public void update() {
+        body.move(force);
+        force.set(0);
+    }
+
+    @Override
+    public void draw(CodeDraw cd) {
+        body.draw(cd);
+    }
+}

src/ReadDataUtil.java

@@ -0,0 +1,27 @@
+import java.io.*;
+
+public class ReadDataUtil {
+
+    // Reads the position and velocity vector on the specified 'day' from the file with the
+    // specified 'path', and sets position and current velocity of 'b' accordingly. If
+    // successful the method returns 'true'. If the specified 'day' was not found in the file,
+    // 'b' is unchanged and the method returns 'false'.
+    // The file format is validated before reading the state.
+    // Lines before the line "$$SOE" and after the line "$$EOE" the are ignored. Each line of the
+    // file between the line "$$SOE" and the line "$$EOE" is required to have the following format:
+    // JDTDB, TIME, X, Y, Z, VX, VY, VZ
+    // where JDTDB is interpretable as a 'double' value, TIME is a string and X, Y, Z, VX, VY and
+    // VZ are interpretable as 'double' values. JDTDB can be ignored. The character ',' must only
+    // be used as field separator. If the file is not found, an exception of the class
+    // 'StateFileNotFoundException' is thrown. If it does not comply with the format described
+    // above, the method throws an exception of the class 'StateFileFormatException'. Both
+    // exceptions are subtypes of 'IOException'.
+    // Precondition: b != null, path != null, day != null and has the format YYYY-MM-DD.
+    public static boolean readConfiguration(NamedBody b, String path, String day)
+            throws IOException {
+
+            // TODO: implement this method.
+            return false;
+        }
+    }
+

src/Simulation.java

@@ -81,7 +81,7 @@ public class Simulation {
             // merge bodies that have collided
             for (int i = 0; i < bodies.length; i++) {
                 for (int j = i + 1; j < bodies.length; j++) {
-                    if (bodies[j].distanceTo(bodies[i]) < bodies[j].radius() + bodies[i].radius()) {
+                    if (bodies[j].collidesWith(bodies[i])) {
                         bodies[i] = bodies[i].merge(bodies[j]);
                         Body[] bodiesOneRemoved = new Body[bodies.length - 1];
                         for (int k = 0; k < bodiesOneRemoved.length; k++) {

src/Simulation3.java

@@ -1,11 +1,74 @@
-// Simulates the formation of a massive solar system.
-//
+import codedraw.CodeDraw;
+
+import java.awt.*;
+import java.util.Random;
+
+/**
+ * Simulates the formation of a massive solar system.
+ */
 public class Simulation3 {
 
-    // The main simulation method using instances of other classes.
+    /**
+     * The main simulation method using instances of other classes.
+     */
     public static void main(String[] args) {
+        CodeDraw cd = new CodeDraw();
+        BodyLinkedList bodies = new BodyLinkedList();
+        BodyForceTreeMap forceOnBody = new BodyForceTreeMap();
 
-        //TODO: change implementation of this method according to 'Aufgabenblatt3.md'.
+        Random random = new Random(2022);
 
+        for (int i = 0; i < Simulation.NUMBER_OF_BODIES; i++) {
+            bodies.addLast(new Body(
+                    Math.abs(random.nextGaussian()) * Simulation.OVERALL_SYSTEM_MASS / Simulation.NUMBER_OF_BODIES,
+                    new Vector3(
+                            0.2 * random.nextGaussian() * Simulation.AU,
+                            0.2 * random.nextGaussian() * Simulation.AU,
+                            0.2 * random.nextGaussian() * Simulation.AU
+                    ),
+                    new Vector3(
+                            0 + random.nextGaussian() * 5e3,
+                            0 + random.nextGaussian() * 5e3,
+                            0 + random.nextGaussian() * 5e3
+                    )
+            ));
+        }
+
+        long seconds = 0;
+        while (true) {
+            seconds++;
+
+            BodyLinkedList mergedBodies = new BodyLinkedList();
+            for (Body b1 : bodies) {
+                BodyLinkedList colliding = bodies.removeCollidingWith(b1);
+                for (Body b2 : colliding) {
+                    b1 = b1.merge(b2);
+                }
+                mergedBodies.addLast(b1);
+            }
+            bodies = mergedBodies;
+
+            for (Body b1 : bodies) {
+                Vector3 force = new Vector3();
+                for (Body b2 : bodies) {
+                    if (b1 != b2) {
+                        force = force.plus(b1.gravitationalForce(b2));
+                    }
+                }
+                forceOnBody.put(b1, force);
+            }
+
+            for (Body body : bodies) {
+                body.move(forceOnBody.get(body));
+            }
+
+            if ((seconds % 3600) == 0) {
+                cd.clear(Color.BLACK);
+                for (Body body : bodies) {
+                    body.draw(cd);
+                }
+                cd.show();
+            }
+        }
     }
 }

src/Simulation4.java

@@ -0,0 +1,49 @@
+import codedraw.CodeDraw;
+
+import java.awt.*;
+
+/**
+ * Simulates the formation of a massive solar system.
+ */
+public class Simulation4 {
+
+    public static final double SECTION_SIZE = 10 * Simulation.AU;
+
+    /**
+     * The main simulation method using instances of other classes.
+     */
+    public static void main(String[] args) {
+        CodeDraw cd = new CodeDraw();
+
+        NamedBodyForcePair sun = new NamedBodyForcePair(SolSystem4.SUN_NAMED);
+        NamedBodyForcePair earth = new NamedBodyForcePair(SolSystem4.EARTH_NAMED);
+        NamedBodyForcePair moon = new NamedBodyForcePair(SolSystem4.MOON_NAMED);
+        NamedBodyForcePair mars = new NamedBodyForcePair(SolSystem4.MARS_NAMED);
+        NamedBodyForcePair deimos = new NamedBodyForcePair(SolSystem4.DEIMOS_NAMED);
+        NamedBodyForcePair phobos = new NamedBodyForcePair(SolSystem4.PHOBOS_NAMED);
+        NamedBodyForcePair mercury = new NamedBodyForcePair(SolSystem4.MERCURY_NAMED);
+        NamedBodyForcePair venus = new NamedBodyForcePair(SolSystem4.VENUS_NAMED);
+        NamedBodyForcePair vesta = new NamedBodyForcePair(SolSystem4.VESTA_NAMED);
+        NamedBodyForcePair pallas = new NamedBodyForcePair(SolSystem4.PALLAS_NAMED);
+        NamedBodyForcePair hygiea = new NamedBodyForcePair(SolSystem4.HYGIEA_NAMED);
+        NamedBodyForcePair ceres = new NamedBodyForcePair(SolSystem4.CERES_NAMED);
+
+        CosmicSystem earthSystem = new HierarchicalSystem(earth, moon);
+        CosmicSystem marsSystem = new HierarchicalSystem(mars, deimos, phobos);
+        CosmicSystem sol = new HierarchicalSystem(sun, mercury, venus, earthSystem, marsSystem, vesta, pallas, hygiea, ceres);
+
+        long seconds = 0;
+        while (true) {
+            seconds++;
+
+            sol.addForceTo(sol);
+            sol.update();
+
+            if ((seconds % 3600) == 0) {
+                cd.clear(Color.BLACK);
+                sol.draw(cd);
+                cd.show();
+            }
+        }
+    }
+}

src/Simulation5.java

@@ -0,0 +1,113 @@
+import codedraw.CodeDraw;
+
+import java.awt.*;
+import java.util.Random;
+
+/**
+ * Simulates the formation of a massive solar system.
+ */
+public class Simulation5 {
+
+    // gravitational constant
+    public static final double G = 6.6743e-11;
+
+    // one astronomical unit (AU) is the average distance of earth to the sun.
+    public static final double AU = 150e9; // meters
+
+    // one light year
+    public static final double LY = 9.461e15; // meters
+
+    // some further constants needed in the simulation
+    public static final double SUN_MASS = 1.989e30; // kilograms
+    public static final double SUN_RADIUS = 696340e3; // meters
+    public static final double EARTH_MASS = 5.972e24; // kilograms
+    public static final double EARTH_RADIUS = 6371e3; // meters
+
+    // set some system parameters
+    public static final double SECTION_SIZE = 10 * AU; // the size of the square region in space
+
+    public static final int NUMBER_OF_BODIES = 22;
+    public static final double OVERALL_SYSTEM_MASS = 20 * SUN_MASS; // kilograms
+
+    // all quantities are based on units of kilogram respectively second and meter.
+
+    /**
+     * The main simulation method using instances of other classes.
+     */
+    public static void main(String[] args) {
+        // simulation
+        CodeDraw cd = new CodeDraw();
+
+        // create solar system with 12 bodies
+        NamedBody sun = new NamedBody(SolSystem4.SUN_NAMED);
+        NamedBody earth = new NamedBody(SolSystem4.EARTH_NAMED);
+        NamedBody moon = new NamedBody(SolSystem4.MOON_NAMED);
+        NamedBody mars = new NamedBody(SolSystem4.MARS_NAMED);
+        NamedBody deimos = new NamedBody(SolSystem4.DEIMOS_NAMED);
+        NamedBody phobos = new NamedBody(SolSystem4.PHOBOS_NAMED);
+        NamedBody mercury = new NamedBody(SolSystem4.MERCURY_NAMED);
+        NamedBody venus = new NamedBody(SolSystem4.VENUS_NAMED);
+        NamedBody vesta = new NamedBody(SolSystem4.VESTA_NAMED);
+        NamedBody pallas = new NamedBody(SolSystem4.PALLAS_NAMED);
+        NamedBody hygiea = new NamedBody(SolSystem4.HYGIEA_NAMED);
+        NamedBody ceres = new NamedBody(SolSystem4.CERES_NAMED);
+
+        // create some additional bodies
+        Body[] bodies = new Body[NUMBER_OF_BODIES];
+
+        Random random = new Random(2022);
+
+        for (int i = 0; i < bodies.length; i++) {
+            bodies[i] = new Body(
+                    Math.abs(random.nextGaussian()) * OVERALL_SYSTEM_MASS / bodies.length,
+                    new Vector3(0.2 * random.nextGaussian() * AU, 0.2 * random.nextGaussian() * AU, 0.2 * random.nextGaussian() * AU),
+                    new Vector3(0 + random.nextGaussian() * 5e3, 0 + random.nextGaussian() * 5e3, 0 + random.nextGaussian() * 5e3)
+            );
+        }
+
+        MassiveForceHashMap forceOnBody = new MassiveForceHashMap();
+        forceOnBody.put(sun, new Vector3());
+        forceOnBody.put(earth, new Vector3());
+        forceOnBody.put(moon, new Vector3());
+        forceOnBody.put(mars, new Vector3());
+        forceOnBody.put(deimos, new Vector3());
+        forceOnBody.put(phobos, new Vector3());
+        forceOnBody.put(mercury, new Vector3());
+        forceOnBody.put(venus, new Vector3());
+        forceOnBody.put(vesta, new Vector3());
+        forceOnBody.put(pallas, new Vector3());
+        forceOnBody.put(hygiea, new Vector3());
+        forceOnBody.put(ceres, new Vector3());
+
+        for (Body b : bodies) {
+            forceOnBody.put(b, new Vector3());
+        }
+
+        long seconds = 0;
+        while (true) {
+            seconds++;
+
+            for (Massive b1 : forceOnBody.keyList()) {
+                Vector3 force = new Vector3();
+                for (Massive b2 : forceOnBody.keyList()) {
+                    if (b1 != b2) {
+                        force = force.plus(b1.gravitationalForce(b2));
+                    }
+                }
+                forceOnBody.put(b1, force);
+            }
+
+            for (Massive body : forceOnBody.keyList()) {
+                body.move(forceOnBody.get(body));
+            }
+
+            if ((seconds % 3600) == 0) {
+                cd.clear(Color.BLACK);
+                for (Massive body : forceOnBody.keyList()) {
+                    body.draw(cd);
+                }
+                cd.show();
+            }
+        }
+    }
+}

src/Simulation6.java

@@ -0,0 +1,113 @@
+import codedraw.CodeDraw;
+
+import java.awt.*;
+import java.util.Random;
+
+/**
+ * Simulates the formation of a massive solar system.
+ */
+public class Simulation6 {
+
+    // gravitational constant
+    public static final double G = 6.6743e-11;
+
+    // one astronomical unit (AU) is the average distance of earth to the sun.
+    public static final double AU = 150e9; // meters
+
+    // one light year
+    public static final double LY = 9.461e15; // meters
+
+    // some further constants needed in the simulation
+    public static final double SUN_MASS = 1.989e30; // kilograms
+    public static final double SUN_RADIUS = 696340e3; // meters
+    public static final double EARTH_MASS = 5.972e24; // kilograms
+    public static final double EARTH_RADIUS = 6371e3; // meters
+
+    // set some system parameters
+    public static final double SECTION_SIZE = 10 * AU; // the size of the square region in space
+
+    public static final int NUMBER_OF_BODIES = 22;
+    public static final double OVERALL_SYSTEM_MASS = 20 * SUN_MASS; // kilograms
+
+    // all quantities are based on units of kilogram respectively second and meter.
+
+    /**
+     * The main simulation method using instances of other classes.
+     */
+    public static void main(String[] args) {
+        // simulation
+        CodeDraw cd = new CodeDraw();
+
+        // create solar system with 12 bodies
+        NamedBody sun = new NamedBody(SolSystem4.SUN_NAMED);
+        NamedBody earth = new NamedBody(SolSystem4.EARTH_NAMED);
+        NamedBody moon = new NamedBody(SolSystem4.MOON_NAMED);
+        NamedBody mars = new NamedBody(SolSystem4.MARS_NAMED);
+        NamedBody deimos = new NamedBody(SolSystem4.DEIMOS_NAMED);
+        NamedBody phobos = new NamedBody(SolSystem4.PHOBOS_NAMED);
+        NamedBody mercury = new NamedBody(SolSystem4.MERCURY_NAMED);
+        NamedBody venus = new NamedBody(SolSystem4.VENUS_NAMED);
+        NamedBody vesta = new NamedBody(SolSystem4.VESTA_NAMED);
+        NamedBody pallas = new NamedBody(SolSystem4.PALLAS_NAMED);
+        NamedBody hygiea = new NamedBody(SolSystem4.HYGIEA_NAMED);
+        NamedBody ceres = new NamedBody(SolSystem4.CERES_NAMED);
+
+        // create some additional bodies
+        Body[] bodies = new Body[NUMBER_OF_BODIES];
+
+        Random random = new Random(2022);
+
+        for (int i = 0; i < bodies.length; i++) {
+            bodies[i] = new Body(
+                    Math.abs(random.nextGaussian()) * OVERALL_SYSTEM_MASS / bodies.length,
+                    new Vector3(0.2 * random.nextGaussian() * AU, 0.2 * random.nextGaussian() * AU, 0.2 * random.nextGaussian() * AU),
+                    new Vector3(0 + random.nextGaussian() * 5e3, 0 + random.nextGaussian() * 5e3, 0 + random.nextGaussian() * 5e3)
+            );
+        }
+
+        MassiveForceTreeMap forceOnBody = new MassiveForceTreeMap();
+        forceOnBody.put(sun, new Vector3());
+        forceOnBody.put(earth, new Vector3());
+        forceOnBody.put(moon, new Vector3());
+        forceOnBody.put(mars, new Vector3());
+        forceOnBody.put(deimos, new Vector3());
+        forceOnBody.put(phobos, new Vector3());
+        forceOnBody.put(mercury, new Vector3());
+        forceOnBody.put(venus, new Vector3());
+        forceOnBody.put(vesta, new Vector3());
+        forceOnBody.put(pallas, new Vector3());
+        forceOnBody.put(hygiea, new Vector3());
+        forceOnBody.put(ceres, new Vector3());
+
+        for (Body b : bodies) {
+            forceOnBody.put(b, new Vector3());
+        }
+
+        long seconds = 0;
+        while (true) {
+            seconds++;
+
+            for (Massive b1 : forceOnBody.getKeys()) {
+                Vector3 force = new Vector3();
+                for (Massive b2 : forceOnBody.getKeys()) {
+                    if (b1 != b2) {
+                        force = force.plus(b1.gravitationalForce(b2));
+                    }
+                }
+                forceOnBody.put(b1, force);
+            }
+
+            for (Massive body : forceOnBody.getKeys()) {
+                body.move(forceOnBody.get(body));
+            }
+
+            if ((seconds % 3600) == 0) {
+                cd.clear(Color.BLACK);
+                for (Massive body : forceOnBody.getKeys()) {
+                    body.draw(cd);
+                }
+                cd.show();
+            }
+        }
+    }
+}

src/Simulation8.java

@@ -0,0 +1,60 @@
+import codedraw.CodeDraw;
+
+// Simulates the solar system.
+//
+public class Simulation8 {
+
+    // gravitational constant
+    public static final double G = 6.6743e-11;
+
+    // one astronomical unit (AU) is the average distance of earth to the sun.
+    public static final double AU = 150e9; // meters
+
+    // set some system parameters
+    public static final double SECTION_SIZE = 10 * AU; // the size of the square region in space
+
+    // all quantities are based on units of kilogram respectively second and meter.
+
+    // The main simulation method using instances of other classes.
+    public static void main(String[] args) {
+
+        // simulation
+        CodeDraw cd = new CodeDraw();
+
+        // create solar system with 13 bodies
+        MassiveForceTreeMap map = new MassiveForceTreeMap();
+
+        map.put(new NamedBody("Oumuamua", 8e6, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Earth", 5.972E24, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Moon", 7.349E22, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Mars1", 6.41712E23, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Deimos", 1.8E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Phobos", 1.08E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Mercury", 3.301E23, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Venus", 4.86747E24, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Vesta", 2.5908E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Pallas", 2.14E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Hygiea", 8.32E19, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Ceres1", 9.394E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+
+
+        //TODO: implementation of this method according to 'Aufgabenblatt8.md'.
+
+        // add sun after states have been read from files.
+        map.put(new NamedBody("Sun", 1.989E30, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+
+    }
+}

src/Simulation9.java

@@ -0,0 +1,7 @@
+// Simulates the solar system.
+//
+public class Simulation9 {
+
+    // TODO: Implement the simulation using the Java-Collections framework.
+
+}

src/SolSystem.java

@@ -0,0 +1,7 @@
+public class SolSystem {
+    public static final Body SUN = new Body(1.989e30, new Vector3(0, 0, 0), new Vector3(0, 0, 0));
+    public static final Body EARTH = new Body(5.972e24, new Vector3(-1.394555e11, 5.103346e10, 0), new Vector3(-10308.53, -28169.38, 0));
+    public static final Body MERCURY = new Body(3.301e23, new Vector3(-5.439054e10, 9.394878e9, 0), new Vector3(-17117.83, -46297.48, -1925.57));
+    public static final Body VENUS = new Body(4.86747e24, new Vector3(-1.707667e10, 1.066132e11, 2.450232e9), new Vector3(-34446.02, -5567.47, 2181.10));
+    public static final Body MARS = new Body(6.41712e23, new Vector3(-1.010178e11, -2.043939e11, -1.591727E9), new Vector3(20651.98, -10186.67, -2302.79));
+}

src/SolSystem4.java

@@ -0,0 +1,27 @@
+public class SolSystem4 {
+    public static final Body SUN = new Body(1.989E30, new Vector3(0.0, 0.0, 0.0), new Vector3(0.0, 0.0, 0.0));
+    public static final Body EARTH = new Body(5.972E24, new Vector3(-6.13135922534815E10, -1.383789852227691E11, 2.719682263474911E7), new Vector3(26832.720535473603, -11948.23168764519, 1.9948243075997851));
+    public static final Body MOON = new Body(7.349E22, new Vector3(-6.132484773775896E10, -1.387394951280871E11, 1.701046736294776E7), new Vector3(27916.62329282941, -12020.39526008238, -94.89703264508708));
+    public static final Body MARS = new Body(6.41712E23, new Vector3(-1.7923193702925848E11, 1.726665823982123E11, 7.991673845249474E9), new Vector3(-15925.78496403673, -15381.16179928219, 68.67560910598857));
+    public static final Body DEIMOS = new Body(1.8E20, new Vector3(-1.792255010450533E11, 1.726891122683271E11, 7.990659337380297E9), new Vector3(-17100.476719804457, -15020.348656808, 631.2927851249581));
+    public static final Body PHOBOS = new Body(1.08E20, new Vector3(-1.792253482539647E11, 1.72661109673625E11, 7.987848354800322E9), new Vector3(-14738.203714241401, -13671.17675223948, -411.0012490555253));
+    public static final Body MERCURY = new Body(3.301E23, new Vector3(-5.167375560011926E10, -4.217574885682655E10, 1.14808913958168E9), new Vector3(21580.25398577148, -34951.03632847389, -4835.225596525241));
+    public static final Body VENUS = new Body(4.86747E24, new Vector3(-3.123150865740532E10, 1.0395568504115701E11, 3.173401325838074E9), new Vector3(-33748.180519629335, -10014.25141045021, 1809.94488874165));
+    public static final Body VESTA = new Body(2.5908E20, new Vector3(-3.337493557929893E11, -4.7147908276077385E10, 4.1923010146878105E10), new Vector3(4440.54247538484, -19718.49074006637, 48.06573124543601));
+    public static final Body PALLAS = new Body(2.14E20, new Vector3(4.3452066613895575E11, -2.057319365171432E11, 1.0549957423213101E11), new Vector3(5058.947582097117, 11184.45711782372, -8183.524138259704));
+    public static final Body HYGIEA = new Body(8.32E19, new Vector3(-3.983943433707043E11, 2.325833000024021E11, -2.233667695713672E10), new Vector3(-6931.864585548552, -15686.8108598699, -690.5791992347208));
+    public static final Body CERES = new Body(9.394E20, new Vector3(3.781372641419032E11, 1.96718960466285E11, -6.366459168068592E10), new Vector3(-8555.324226752316, 14718.33755980907, 2040.230135060142));
+
+    public static final NamedBody SUN_NAMED = new NamedBody("Sun", SUN);
+    public static final NamedBody EARTH_NAMED = new NamedBody("Earth", EARTH);
+    public static final NamedBody MOON_NAMED = new NamedBody("Moon", MOON);
+    public static final NamedBody MARS_NAMED = new NamedBody("Mars", MARS);
+    public static final NamedBody DEIMOS_NAMED = new NamedBody("Deimos", DEIMOS);
+    public static final NamedBody PHOBOS_NAMED = new NamedBody("Phobos", PHOBOS);
+    public static final NamedBody MERCURY_NAMED = new NamedBody("Mercury", MERCURY);
+    public static final NamedBody VENUS_NAMED = new NamedBody("Venus", VENUS);
+    public static final NamedBody VESTA_NAMED = new NamedBody("Vesta", VESTA);
+    public static final NamedBody PALLAS_NAMED = new NamedBody("Pallas", PALLAS);
+    public static final NamedBody HYGIEA_NAMED = new NamedBody("Hygiea", HYGIEA);
+    public static final NamedBody CERES_NAMED = new NamedBody("Ceres", CERES);
+}

src/SpaceDraw.java

@@ -8,7 +8,6 @@ public class SpaceDraw {
      * where m and r measured in solar units.)
      */
     public static double massToRadius(double mass) {
-
         return Simulation.SUN_RADIUS * (Math.pow(mass / Simulation.SUN_MASS, 0.5));
     }
 
@@ -34,7 +33,6 @@ public class SpaceDraw {
      * Returns the approximate color of temperature 'kelvin'.
      */
     private static Color kelvinToColor(int kelvin) {
-
         double k = kelvin / 100D;
         double red = k <= 66 ? 255 : 329.698727446 * Math.pow(k - 60, -0.1332047592);
         double green = k <= 66 ? 99.4708025861 * Math.log(k) - 161.1195681661 : 288.1221695283 * Math.pow(k - 60, -0.0755148492);
@@ -51,12 +49,15 @@ public class SpaceDraw {
      * A transformation used in the method 'kelvinToColor'.
      */
     private static int limitAndDarken(double color, int kelvin) {
-
         int kelvinNorm = kelvin - 373;
-
-        if (color < 0 || kelvinNorm < 0) return 0;
-        else if (color > 255) return 255;
-        else if (kelvinNorm < 500) return (int) ((color / 256D) * (kelvinNorm / 500D) * 256);
-        else return (int) color;
+        if (color < 0 || kelvinNorm < 0) {
+            return 0;
+        } else if (color > 255) {
+            return 255;
+        } else if (kelvinNorm < 500) {
+            return (int) ((color / 256D) * (kelvinNorm / 500D) * 256);
+        } else {
+            return (int) color;
+        }
     }
 }

src/StateFileFormatException.java

@@ -0,0 +1,7 @@
+import java.io.IOException;
+
+public class StateFileFormatException extends IOException {
+
+    // TODO: implement class
+
+}

src/StateFileNotFoundException.java

@@ -0,0 +1,7 @@
+import java.io.IOException;
+
+public class StateFileNotFoundException extends IOException {
+
+    // TODO: implement class
+
+}

src/Vector3.java

@@ -4,7 +4,6 @@ import codedraw.CodeDraw;
  * This class represents vectors in a 3D vector space.
  */
 public class Vector3 {
-
     private double x;
     private double y;
     private double z;
@@ -23,37 +22,51 @@ public class Vector3 {
         this.z = z;
     }
 
+    public Vector3(Vector3 other) {
+        this(other.x, other.y, other.z);
+    }
+
+    public void set(double v) {
+        set(v, v, v);
+    }
+
+    public void set(double x, double y, double z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
     /**
      * Returns the sum of this vector and vector 'v'.
      */
     public Vector3 plus(Vector3 v) {
-        Vector3 result = new Vector3();
-        result.x = x + v.x;
-        result.y = y + v.y;
-        result.z = z + v.z;
-        return result;
+        return new Vector3(x + v.x, y + v.y, z + v.z);
+    }
+
+    public void add(Vector3 v) {
+        this.x += v.x;
+        this.y += v.y;
+        this.z += v.z;
     }
 
     /**
      * Returns the product of this vector and 'd'.
      */
     public Vector3 times(double d) {
-        Vector3 result = new Vector3();
-        result.x = x * d;
-        result.y = y * d;
-        result.z = z * d;
-        return result;
+        return new Vector3(x * d, y * d, z * d);
     }
 
     /**
      * Returns the sum of this vector and -1*v.
      */
     public Vector3 minus(Vector3 v) {
-        Vector3 result = new Vector3();
-        result.x = x - v.x;
-        result.y = y - v.y;
-        result.z = z - v.z;
-        return result;
+        return new Vector3(x - v.x, y - v.y, z - v.z);
+    }
+
+    public void sub(Vector3 v) {
+        this.x -= v.x;
+        this.y -= v.y;
+        this.z -= v.z;
     }
 
     /**
@@ -85,22 +98,38 @@ public class Vector3 {
         z /= length;
     }
 
+    public double getScreenX(CodeDraw cd) {
+        return cd.getWidth() * (this.x + Simulation4.SECTION_SIZE / 2) / Simulation4.SECTION_SIZE;
+    }
+
+    public double getScreenY(CodeDraw cd) {
+        return cd.getWidth() * (this.y + Simulation4.SECTION_SIZE / 2) / Simulation4.SECTION_SIZE;
+    }
+
     /**
      * Draws a filled circle with a specified radius centered at the (x,y) coordinates of this vector
      * in the canvas associated with 'cd'. The z-coordinate is not used.
      */
     public void drawAsFilledCircle(CodeDraw cd, double radius) {
-        double x = cd.getWidth() * (this.x + Simulation.SECTION_SIZE / 2) / Simulation.SECTION_SIZE;
-        double y = cd.getWidth() * (this.y + Simulation.SECTION_SIZE / 2) / Simulation.SECTION_SIZE;
-        radius = cd.getWidth() * radius / Simulation.SECTION_SIZE;
-        cd.fillCircle(x, y, Math.max(radius, 1.5));
+        radius = cd.getWidth() * radius / Simulation4.SECTION_SIZE;
+        cd.fillCircle(getScreenX(cd), getScreenY(cd), Math.max(radius, 1.5));
     }
 
     /**
      * Returns the coordinates of this vector in brackets as a string
      * in the form "[x,y,z]", e.g., "[1.48E11,0.0,0.0]".
      */
+    @Override
     public String toString() {
-        return String.format("[%f,%f,%f]", x, y, z);
+        return String.format("[%g,%g,%g]", x, y, z);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (other.getClass() != Vector3.class) {
+            return false;
+        }
+        Vector3 v = (Vector3) other;
+        return this.x == v.x && this.y == v.y && this.z == v.z;
     }
 }

states/Ceres.txt

@@ -0,0 +1 @@
+*******************************************************************************
JPL/HORIZONS                  1 Ceres (A801 AA)            2021-May-29 11:14:24
Rec #:       1 (+COV) Soln.date: 2021-Apr-13_11:04:44   # obs: 1075 (1995-2021)
 
IAU76/J2000 helio. ecliptic osc. elements (au, days, deg., period=Julian yrs):
 
  EPOCH=  2458849.5 ! 2020-Jan-01.00 (TDB)         Residual RMS= .24563
   EC= .07687465013145245  QR= 2.556401146697176   TP= 2458240.1791309435
   OM= 80.3011901917491    W=  73.80896808746482   IN= 10.59127767086216
   A= 2.769289292143484    MA= 130.3159688200986   ADIST= 2.982177437589792
   PER= 4.60851            N= .213870839           ANGMOM= .028541613
   DAN= 2.69515            DDN= 2.81323            L= 153.8445988
   B= 10.1666388           MOID= 1.59231997        TP= 2018-May-01.6791309435
 
Asteroid physical parameters (km, seconds, rotational period in hours):
   GM= 62.6284             RAD= 469.7              ROTPER= 9.07417
   H= 3.53                 G= .120                 B-V= .713
                           ALBEDO= .090            STYP= C
 
ASTEROID comments: 
1: soln ref.= JPL#48, OCC=0           radar(60 delay, 0 Dop.)
2: source=ORB
*******************************************************************************
 

 

*******************************************************************************
Ephemeris / WWW_USER Sat May 29 11:14:24 2021 Pasadena, USA      / Horizons
*******************************************************************************
Target body name: 1 Ceres (A801 AA)               {source: JPL#48}
Center body name: Solar System Barycenter (0)     {source: DE441}
Center-site name: BODY CENTER
*******************************************************************************
Start time      : A.D. 2019-Jan-01 00:00:00.0000 TDB
Stop  time      : A.D. 2021-Dec-31 00:00:00.0000 TDB
Step-size       : 1440 minutes
*******************************************************************************
Center geodetic : 0.00000000,0.00000000,0.0000000 {E-lon(deg),Lat(deg),Alt(km)}
Center cylindric: 0.00000000,0.00000000,0.0000000 {E-lon(deg),Dxy(km),Dz(km)}
Center radii    : (undefined)                                                  
Small perturbers: Yes                             {source: SB441-N16}
Output units    : KM-S
Output type     : GEOMETRIC cartesian states
Output format   : 2 (position and velocity)
Reference frame : Ecliptic of J2000.0
*******************************************************************************
Initial IAU76/J2000 heliocentric ecliptic osculating elements (au, days, deg.):
  EPOCH=  2458849.5 ! 2020-Jan-01.00 (TDB)         Residual RMS= .24563        
   EC= .07687465013145245  QR= 2.556401146697176   TP= 2458240.1791309435      
   OM= 80.3011901917491    W=  73.80896808746482   IN= 10.59127767086216       
  Equivalent ICRF heliocentric cartesian coordinates (au, au/d):
   X= 1.007608869613381E+00  Y=-2.390064275223502E+00  Z=-1.332124522752402E+00
  VX= 9.201724467227128E-03 VY= 3.370381135398406E-03 VZ=-2.850337057661093E-04
Asteroid physical parameters (km, seconds, rotational period in hours):        
   GM= 62.6284             RAD= 469.7              ROTPER= 9.07417             
   H= 3.53                 G= .120                 B-V= .713                   
                           ALBEDO= .090            STYP= C                     
*******************************************************************************
            JDTDB,            Calendar Date (TDB),                      X,                      Y,                      Z,                     VX,                     VY,                     VZ,
**************************************************************************************************************************************************************************************************
$$SOE
2458484.500000000, A.D. 2019-Jan-01 00:00:00.0000, -3.250173761375654E+08, -2.203419016964185E+08,  5.291759744142130E+07,  9.165639992762751E+00, -1.610304458359491E+01, -2.199191038589312E+00,
2458485.500000000, A.D. 2019-Jan-02 00:00:00.0000, -3.242228904176531E+08, -2.217314468071813E+08,  5.272716798630814E+07,  9.225201159592405E+00, -1.606231425347662E+01, -2.208891128305465E+00,
2458486.500000000, A.D. 2019-Jan-03 00:00:00.0000, -3.234232669168970E+08, -2.231174631789901E+08,  5.253590227803711E+07,  9.284569975630303E+00, -1.602136099186057E+01, -2.218548732405131E+00,
2458487.500000000, A.D. 2019-Jan-04 00:00:00.0000, -3.226185222878132E+08, -2.244999315973394E+08,  5.234380399205689E+07,  9.343745668666449E+00, -1.598018588186176E+01, -2.228163742508103E+00,
2458488.500000000, A.D. 2019-Jan-05 00:00:00.0000, -3.218086732493464E+08, -2.258788329413921E+08,  5.215087681312392E+07,  9.402727473215403E+00, -1.593879000860668E+01, -2.237736051536023E+00,
2458489.500000000, A.D. 2019-Jan-06 00:00:00.0000, -3.209937365862889E+08, -2.272541481841512E+08,  5.195712443519008E+07,  9.461514630511177E+00, -1.589717445918542E+01, -Line truncated

states/Deimos.txt

@@ -0,0 +1 @@
+*******************************************************************************
 Revised: Sep 28, 2012             Deimos / (Mars)                          402

 SATELLITE PHYSICAL PROPERTIES:
  Radius (km)             = 7.8 x 6.0 x 5.1 Density (g cm^-3)   =  1.76 +- 0.30
  Mass (10^20 kg )        = 1.80 (10^-5)    Geometric Albedo    =  0.06 
                               (+- 0.15)    V(1,0)              = +12.89

 SATELLITE ORBITAL DATA:
  Semi-major axis, a (km) = 23.4632(10^3)   Orbital period      = 1.263 d
  Eccentricity, e         =  0.00033        Rotational period   = Synchronous
  Inclination, i  (deg)   =  1.791
*******************************************************************************
 

 

*******************************************************************************
Ephemeris / WWW_USER Sat May 29 10:45:06 2021 Pasadena, USA      / Horizons
*******************************************************************************
Target body name: Deimos (402)                    {source: mar097}
Center body name: Solar System Barycenter (0)     {source: DE441}
Center-site name: BODY CENTER
*******************************************************************************
Start time      : A.D. 2019-Jan-01 00:00:00.0000 TDB
Stop  time      : A.D. 2021-Dec-31 00:00:00.0000 TDB
Step-size       : 1440 minutes
*******************************************************************************
Center geodetic : 0.00000000,0.00000000,0.0000000 {E-lon(deg),Lat(deg),Alt(km)}
Center cylindric: 0.00000000,0.00000000,0.0000000 {E-lon(deg),Dxy(km),Dz(km)}
Center radii    : (undefined)                                                  
Output units    : KM-S
Output type     : GEOMETRIC cartesian states
Output format   : 2 (position and velocity)
Reference frame : Ecliptic of J2000.0
*******************************************************************************
            JDTDB,            Calendar Date (TDB),                      X,                      Y,                      Z,                     VX,                     VY,                     VZ,
**************************************************************************************************************************************************************************************************
$$SOE
2458484.500000000, A.D. 2019-Jan-01 00:00:00.0000,  1.629770068419321E+08,  1.448938565178654E+08, -9.976786424947232E+05, -1.390775070821403E+01,  2.006702271722930E+01,  2.206267009848659E-01,
2458485.500000000, A.D. 2019-Jan-02 00:00:00.0000,  1.616454083339736E+08,  1.466561241183909E+08, -9.189826430664584E+05, -1.518254290575987E+01,  1.874885297378025E+01,  6.211439556607115E-01,
2458486.500000000, A.D. 2019-Jan-03 00:00:00.0000,  1.603295987661050E+08,  1.484089715526735E+08, -8.542450205237195E+05, -1.662730791933799E+01,  1.940010929352612E+01,  1.280299042692367E+00,
2458487.500000000, A.D. 2019-Jan-04 00:00:00.0000,  1.590094571248652E+08,  1.501158464981909E+08, -7.974257696473002E+05, -1.637194171931468E+01,  2.081930278826077E+01,  1.225740388531875E+00,
2458488.500000000, A.D. 2019-Jan-05 00:00:00.0000,  1.576485442130992E+08,  1.517872503711629E+08, -7.306718326271325E+05, -1.505526712863220E+01,  2.066705403270559E+01,  5.393610853589710E-01,
2458489.500000000, A.D. 2019-Jan-06 00:00:00.0000,  1.562481509963061E+08,  1.534650346788671E+08, -6.506882054592073E+05, -1.488131085212162E+01,  1.892415224960050E+01,  2.364929723547409E-01,
2458490.500000000, A.D. 2019-Jan-07 00:00:00.0000,  1.548456532213624E+08,  1.551603609939339E+08, -5.736244909284711E+05, -1.636149865752989E+01,  1.791745726465136E+01,  7.648830913660243E-01,
2458491.500000000, A.D. 2019-Jan-08 00:00:00.0000,  1.534595493466119E+08,  1.568371088582374E+08, -5.112212451166362E+05, -1.756417196682084E+01,  1.888482010057535E+01,  1.345794862689913E+00,
2458492.500000000, A.D. 2019-Jan-09 00:00:00.0000,  1.520623962542237E+08,  1.584649504312741E+08, -4.534915764811859E+05, -1.696179849424676E+01,  2.014711729542566E+01,  1.121564085760665E+00,
2458493.500000000, A.D. 2019-Jan-10 00:00:00.0000,  1.506215858316507E+08,  1.600640521714851E+08, -3.834709960333332E+05, -1.569221856072902E+01,  1.958616404749911E+01,  4.245318881830809E-01,
2458494.500000000, A.D. 2019-Jan-11 00:00:00.0000,  1.491477540622245E+08,  1.616750507489093E+08, -3.022875910980776E+05, -1.587454907026639E+01,  1.777621024315604E+01,  2.848018926377289E-01,
2458495.500000000, A.D. 2019-Jan-12 00:00:00.0000,  1.476793352244079E+08,  1.632988907726929E+08, -2.275076390290037E+05, -1.748033234696750E+01,  1.713263148594174E+01,  9.089681033409676E-01,
2458496.500000000, A.D. 2019-Jan-13 00:00:00.0000,  1.462260353296198E+08,  1.648952801077152E+08, -1.671918434069678E+05, -1.837744691188085E+01,  1.834715983828853E+01,  1.376113760911172E+00,
2458497.500000000, A.D. 2019-Jan-14 00:00:00.0000,  1.447547757778870E+08,  1.664419752374789E+08, -1.080164558948129E+05, -1.747478325889392E+01,  1.936553174620019E+01,  9.959151162581Line truncated

states/Earth.txt

@@ -0,0 +1 @@
+*******************************************************************************
 Revised: April 12, 2021                 Earth                              399
 
 GEOPHYSICAL PROPERTIES (revised Aug 15, 2018):
  Vol. Mean Radius (km)    = 6371.01+-0.02   Mass x10^24 (kg)= 5.97219+-0.0006
  Equ. radius, km          = 6378.137        Mass layers:
  Polar axis, km           = 6356.752          Atmos         = 5.1   x 10^18 kg
  Flattening               = 1/298.257223563   oceans        = 1.4   x 10^21 kg
  Density, g/cm^3          = 5.51              crust         = 2.6   x 10^22 kg
  J2 (IERS 2010)           = 0.00108262545     mantle        = 4.043 x 10^24 kg
  g_p, m/s^2  (polar)      = 9.8321863685      outer core    = 1.835 x 10^24 kg
  g_e, m/s^2  (equatorial) = 9.7803267715      inner core    = 9.675 x 10^22 kg
  g_o, m/s^2               = 9.82022         Fluid core rad  = 3480 km
  GM, km^3/s^2             = 398600.435436   Inner core rad  = 1215 km
  GM 1-sigma, km^3/s^2     =      0.0014     Escape velocity = 11.186 km/s
  Rot. Rate (rad/s)        = 0.00007292115   Surface area:
  Mean sidereal day, hr    = 23.9344695944     land          = 1.48 x 10^8 km
  Mean solar day 2000.0, s = 86400.002         sea           = 3.62 x 10^8 km
  Mean solar day 1820.0, s = 86400.0         Love no., k2    = 0.299
  Moment of inertia        = 0.3308          Atm. pressure   = 1.0 bar
  Mean temperature, K      = 270             Volume, km^3    = 1.08321 x 10^12
  Mean effect. IR temp, K  = 255             Magnetic moment = 0.61 gauss Rp^3
  Geometric albedo         = 0.367           Vis. mag. V(1,0)= -3.86
  Solar Constant (W/m^2)   = 1367.6 (mean), 1414 (perihelion), 1322 (aphelion)
 HELIOCENTRIC ORBIT CHARACTERISTICS:
  Obliquity to orbit, deg  = 23.4392911  Sidereal orb period  = 1.0000174 y
  Orbital speed, km/s      = 29.79       Sidereal orb period  = 365.25636 d
  Mean daily motion, deg/d = 0.9856474   Hill's sphere radius = 234.9       
*******************************************************************************
 

 

*******************************************************************************
Ephemeris / WWW_USER Sat May 29 10:40:56 2021 Pasadena, USA      / Horizons
*******************************************************************************
Target body name: Earth (399)                     {source: DE441}
Center body name: Solar System Barycenter (0)     {source: DE441}
Center-site name: BODY CENTER
*******************************************************************************
Start time      : A.D. 2019-Jan-01 00:00:00.0000 TDB
Stop  time      : A.D. 2021-Dec-31 00:00:00.0000 TDB
Step-size       : 1440 minutes
*******************************************************************************
Center geodetic : 0.00000000,0.00000000,0.0000000 {E-lon(deg),Lat(deg),Alt(km)}
Center cylindric: 0.00000000,0.00000000,0.0000000 {E-lon(deg),Dxy(km),Dz(km)}
Center radii    : (undefined)                                                  
Output units    : KM-S
Output type     : GEOMETRIC cartesian states
Output format   : 2 (position and velocity)
Reference frame : Ecliptic of J2000.0
*******************************************************************************
            JDTDB,            Calendar Date (TDB),                      X,                      Y,                      Z,                     VX,                     VY,                     VZ,
**************************************************************************************************************************************************************************************************
$$SOE
2458484.500000000, A.D. 2019-Jan-01 00:00:00.0000, -2.565786669256473E+07,  1.459776345868732E+08, -1.548952074754238E+04, -2.984330713107311E+01, -5.272844521387671E+00,  9.256858421500258E-04,
2458485.500000000, A.D. 2019-Jan-02 00:00:00.0000, -2.823230306715931E+07,  1.454994529806256E+08, -1.539797420976311E+04, -2.974849808661338E+01, -5.795951202541079E+00,  1.189057422698703E-03,
2458486.500000000, A.D. 2019-Jan-03 00:00:00.0000, -3.079812529513879E+07,  1.449761369768790E+08, -1.528494889068604E+04, -2.964390303251469E+01, -6.317573192078425E+00,  1.421347092815495E-03,
2458487.500000000, A.D. 2019-Jan-04 00:00:00.0000, -3.335448763868447E+07,  1.444078275668288E+08, -1.515349592279643E+04, -2.952952169701604E+01, -6.837416330766245E+00,  1.614456923548779E-03,
2458488.500000000, A.D. 2019-Jan-05 00:00:00.0000, -3.590054559349991E+07,  1.437946910589049E+08, -1.500727118092030E+04, -2.940538252957142E+01, -7.355189425480081E+00,  1.762484838532252E-03,
2458489.500000000, A.D. 2019-Jan-06 00:00:00.0000, -3.843545826881640E+07,  1.431369186478721E+08, -1.485034648505598E+04, -2.927154029096869E+01, -7.870608226542243E+00,  1.861695334308244E-03,
2458490.500000000, A.D. 2019-Jan-07 00:00:00.0000, -4.095839053895415E+07,  1.424347256597345E+08, -1.468702586828172E+04, -2.912807313230036E+01, -8.383398913379908E+00,  1.910426228024509E-03,
2458491.500000000,Line truncated

states/Hygiea.txt

@@ -0,0 +1 @@
+*******************************************************************************
JPL/HORIZONS                 10 Hygiea (A849 GA)           2021-May-29 11:16:49
Rec #:      10 (+COV) Soln.date: 2021-May-03_17:43:21   # obs: 3663 (1849-2021)
 
IAU76/J2000 helio. ecliptic osc. elements (au, days, deg., period=Julian yrs):
 
  EPOCH=  2451659.5 ! 2000-Apr-25.00 (TDB)         Residual RMS= .21441
   EC= .1194380603574853   QR= 2.76353045482564    TP= 2451662.1100178338
   OM= 283.6579501838269   W=  314.3412537644239   IN= 3.842864474453038
   A= 3.138371453968998    MA= 359.5373090218986   ADIST= 3.513212453112356
   PER= 5.55987            N= .177275021           ANGMOM= .030256146
   DAN= 2.85525            DDN= 3.37537            L= 238.0636827
   B= -2.7473692           MOID= 1.75311995        TP= 2000-Apr-27.6100178338
 
Asteroid physical parameters (km, seconds, rotational period in hours):
   GM= 7.                  RAD= 203.56             ROTPER= 13.828
   H= 5.55                 G= .150                 B-V= .696
                           ALBEDO= .0717           STYP= C
 
ASTEROID comments: 
1: soln ref.= JPL#102, OCC=0
2: source=ORB
*******************************************************************************
 

 

*******************************************************************************
Ephemeris / WWW_USER Sat May 29 11:16:49 2021 Pasadena, USA      / Horizons
*******************************************************************************
Target body name: 10 Hygiea (A849 GA)             {source: JPL#102}
Center body name: Solar System Barycenter (0)     {source: DE441}
Center-site name: BODY CENTER
*******************************************************************************
Start time      : A.D. 2019-Jan-01 00:00:00.0000 TDB
Stop  time      : A.D. 2021-Dec-31 00:00:00.0000 TDB
Step-size       : 1440 minutes
*******************************************************************************
Center geodetic : 0.00000000,0.00000000,0.0000000 {E-lon(deg),Lat(deg),Alt(km)}
Center cylindric: 0.00000000,0.00000000,0.0000000 {E-lon(deg),Dxy(km),Dz(km)}
Center radii    : (undefined)                                                  
Small perturbers: Yes                             {source: SB441-N16}
Output units    : KM-S
Output type     : GEOMETRIC cartesian states
Output format   : 2 (position and velocity)
Reference frame : Ecliptic of J2000.0
*******************************************************************************
Initial IAU76/J2000 heliocentric ecliptic osculating elements (au, days, deg.):
  EPOCH=  2451659.5 ! 2000-Apr-25.00 (TDB)         Residual RMS= .21441        
   EC= .1194380603574853   QR= 2.76353045482564    TP= 2451662.1100178338      
   OM= 283.6579501838269   W=  314.3412537644239   IN= 3.842864474453038       
  Equivalent ICRF heliocentric cartesian coordinates (au, au/d):
   X=-1.484281795031938E+00  Y=-2.082009786619123E+00  Z=-1.048489626801920E+00
  VX= 9.214067619681732E-03 VY=-5.607303490974008E-03 VZ=-1.877398380211751E-03
Asteroid physical parameters (km, seconds, rotational period in hours):        
   GM= 7.                  RAD= 203.56             ROTPER= 13.828              
   H= 5.55                 G= .150                 B-V= .696                   
                           ALBEDO= .0717           STYP= C                     
*******************************************************************************
            JDTDB,            Calendar Date (TDB),                      X,                      Y,                      Z,                     VX,                     VY,                     VZ,
**************************************************************************************************************************************************************************************************
$$SOE
2458484.500000000, A.D. 2019-Jan-01 00:00:00.0000,  4.873124883219800E+08,  1.403841894154261E+08,  3.390302039027818E+07, -3.091538853677393E+00,  1.518656207823583E+01,  3.198275266803741E-02,
2458485.500000000, A.D. 2019-Jan-02 00:00:00.0000,  4.870435388221376E+08,  1.416957805017916E+08,  3.390565563008341E+07, -3.134135730347184E+00,  1.517432485329112E+01,  2.901843559971784E-02,
2458486.500000000, A.D. 2019-Jan-03 00:00:00.0000,  4.867709111017210E+08,  1.430063096693100E+08,  3.390803482228220E+07, -3.176682817287593E+00,  1.516198065733805E+01,  2.605572729273575E-02,
2458487.500000000, A.D. 2019-Jan-04 00:00:00.0000,  4.864946094706300E+08,  1.443157676844693E+08,  3.391015810653216E+07, -3.219179927873935E+00,  1.514952969366037E+01,  2.309464303133790E-02,
2458488.500000000, A.D. 2019-Jan-05 00:00:00.0000,  4.862146382548585E+08,  1.456241453313133E+08,  3.391202562380935E+07, -3.261626876187203E+00,  1.513697216535112E+01,  2.013519805090080E-02,
2458489.500000000, A.D. 2019-Jan-06 00:00:00.0000,  4.859310017964332E+08,  1.469314334114242E+08,  3.391363751640403E+07, -3.304023477009827E+00,  1.512430827531151E+01,  1.717740753818653E-02,
2458490.50Line truncated

states/Mars.txt

@@ -0,0 +1 @@
+*******************************************************************************
 Revised: June 21, 2016                 Mars                            499 / 4
 
 PHYSICAL DATA (updated 2019-Oct-29):
  Vol. mean radius (km) = 3389.92+-0.04   Density (g/cm^3)      =  3.933(5+-4)
  Mass x10^23 (kg)      =    6.4171       Flattening, f         =  1/169.779
  Volume (x10^10 km^3)  =   16.318        Equatorial radius (km)=  3396.19
  Sidereal rot. period  =   24.622962 hr  Sid. rot. rate, rad/s =  0.0000708822 
  Mean solar day (sol)  =   88775.24415 s Polar gravity m/s^2   =  3.758
  Core radius (km)      = ~1700           Equ. gravity  m/s^2   =  3.71
  Geometric Albedo      =    0.150                                              

  GM (km^3/s^2)         = 42828.375214    Mass ratio (Sun/Mars) = 3098703.59
  GM 1-sigma (km^3/s^2) = +- 0.00028      Mass of atmosphere, kg= ~ 2.5 x 10^16
  Mean temperature (K)  =  210            Atmos. pressure (bar) =    0.0056 
  Obliquity to orbit    =   25.19 deg     Max. angular diam.    =  17.9"
  Mean sidereal orb per =    1.88081578 y Visual mag. V(1,0)    =  -1.52
  Mean sidereal orb per =  686.98 d       Orbital speed,  km/s  =  24.13
  Hill's sphere rad. Rp =  319.8          Escape speed, km/s    =   5.027
                                 Perihelion  Aphelion    Mean
  Solar Constant (W/m^2)         717         493         589
  Maximum Planetary IR (W/m^2)   470         315         390
  Minimum Planetary IR (W/m^2)    30          30          30
*******************************************************************************
 

 

*******************************************************************************
Ephemeris / WWW_USER Sat May 29 10:42:12 2021 Pasadena, USA      / Horizons
*******************************************************************************
Target body name: Mars (499)                      {source: mar097}
Center body name: Solar System Barycenter (0)     {source: DE441}
Center-site name: BODY CENTER
*******************************************************************************
Start time      : A.D. 2019-Jan-01 00:00:00.0000 TDB
Stop  time      : A.D. 2021-Dec-31 00:00:00.0000 TDB
Step-size       : 1440 minutes
*******************************************************************************
Center geodetic : 0.00000000,0.00000000,0.0000000 {E-lon(deg),Lat(deg),Alt(km)}
Center cylindric: 0.00000000,0.00000000,0.0000000 {E-lon(deg),Dxy(km),Dz(km)}
Center radii    : (undefined)                                                  
Output units    : KM-S
Output type     : GEOMETRIC cartesian states
Output format   : 2 (position and velocity)
Reference frame : Ecliptic of J2000.0
*******************************************************************************
            JDTDB,            Calendar Date (TDB),                      X,                      Y,                      Z,                     VX,                     VY,                     VZ,
**************************************************************************************************************************************************************************************************
$$SOE
2458484.500000000, A.D. 2019-Jan-01 00:00:00.0000,  1.629806212726895E+08,  1.449170333840721E+08, -9.972368219362050E+05, -1.511758798465740E+01,  2.024466077262084E+01,  7.950950455491554E-01,
2458485.500000000, A.D. 2019-Jan-02 00:00:00.0000,  1.616666306318552E+08,  1.466592204222224E+08, -9.284941105299219E+05, -1.529854435317747E+01,  2.008348535512331E+01,  7.961582545504307E-01,
2458486.500000000, A.D. 2019-Jan-03 00:00:00.0000,  1.603370878697700E+08,  1.483874155285474E+08, -8.596629525371343E+05, -1.547758897796352E+01,  1.992077769195369E+01,  7.971424419158213E-01,
2458487.500000000, A.D. 2019-Jan-04 00:00:00.0000,  1.589921586133672E+08,  1.501014874191028E+08, -7.907501629922390E+05, -1.565471145149662E+01,  1.975656332519256E+01,  7.980478977679955E-01,
2458488.500000000, A.D. 2019-Jan-05 00:00:00.0000,  1.576320093740007E+08,  1.518013070158002E+08, -7.217625324030295E+05, -1.582990173978651E+01,  1.959086777497644E+01,  7.988749163606697E-01,
2458489.500000000, A.D. 2019-Jan-06 00:00:00.0000,  1.562568075144522E+08,  1.534867474451801E+08, -6.527068259266689E+05, -1.600315017388914E+01,  1.942371653144429E+01,  7.996237927294008E-01,
2458490.500000000, A.D. 2019-Jan-07 00:00:00.0000,  1.548667212163704E+08,  1.551576840368080E+08, -5.835897826206610E+05, -1.617444745028182E+01,  1.925513506002808E+01,  8.002948247990496E-01,
2458491.500000000, A.D. 2019-Jan-08 00:00:00.0000,  1.534619194481221E+08,  1.568139943211130E+08, -5.144181147708669E+05, -1.634378463559922E+01,  1.908514881632767E+01,  8.008883189872105E-01,
2458492.500000000, A.D. 2019-Jan-09 00:00:00.0000,  1.520425719328370E+08,  1.584555580266072E+08, -4.451985071971491E+05, -1.651115317232192E+01,  1.891378324494117E+01,  8.014045955915563E-01,
2458493.500000000, A.D. 2019-Jan-10 00:00:00.0000,  1.506088491165577E+08,  1.600822570Line truncated

states/Mercury.txt

@@ -0,0 +1 @@
+*******************************************************************************
 Revised: April 12, 2021             Mercury                            199 / 1

 PHYSICAL DATA (updated 2021-Apr-12):
  Vol. Mean Radius (km) =  2440+-1        Density (g cm^-3)     = 5.427
  Mass x10^23 (kg)      =     3.302       Volume (x10^10 km^3)  = 6.085  
  Sidereal rot. period  =    58.6463 d    Sid. rot. rate (rad/s)= 0.00000124001
  Mean solar day        =   175.9421 d    Core radius (km)      = ~1600 
  Geometric Albedo      =     0.106       Surface emissivity    = 0.77+-0.06
  GM (km^3/s^2)         = 22031.86855     Equatorial radius, Re = 2440 km
  GM 1-sigma (km^3/s^2) =                 Mass ratio (Sun/plnt) = 6023682
  Mom. of Inertia       =     0.33        Equ. gravity  m/s^2   = 3.701     
  Atmos. pressure (bar) = < 5x10^-15      Max. angular diam.    = 11.0"   
  Mean Temperature (K)  = 440             Visual mag. V(1,0)    = -0.42 
  Obliquity to orbit[1] =  2.11' +/- 0.1' Hill's sphere rad. Rp = 94.4 
  Sidereal orb. per.    =  0.2408467 y    Mean Orbit vel.  km/s = 47.362 
  Sidereal orb. per.    = 87.969257  d    Escape vel. km/s      =  4.435
                                 Perihelion  Aphelion    Mean
  Solar Constant (W/m^2)         14462       6278        9126
  Maximum Planetary IR (W/m^2)   12700       5500        8000
  Minimum Planetary IR (W/m^2)   6           6           6
*******************************************************************************
 

 

*******************************************************************************
Ephemeris / WWW_USER Sat May 29 10:44:15 2021 Pasadena, USA      / Horizons
*******************************************************************************
Target body name: Mercury Barycenter (199)        {source: DE441}
Center body name: Solar System Barycenter (0)     {source: DE441}
Center-site name: BODY CENTER
*******************************************************************************
Start time      : A.D. 2019-Jan-01 00:00:00.0000 TDB
Stop  time      : A.D. 2021-Dec-31 00:00:00.0000 TDB
Step-size       : 1440 minutes
*******************************************************************************
Center geodetic : 0.00000000,0.00000000,0.0000000 {E-lon(deg),Lat(deg),Alt(km)}
Center cylindric: 0.00000000,0.00000000,0.0000000 {E-lon(deg),Dxy(km),Dz(km)}
Center radii    : (undefined)                                                  
Output units    : KM-S
Output type     : GEOMETRIC cartesian states
Output format   : 2 (position and velocity)
Reference frame : Ecliptic of J2000.0
*******************************************************************************
            JDTDB,            Calendar Date (TDB),                      X,                      Y,                      Z,                     VX,                     VY,                     VZ,
**************************************************************************************************************************************************************************************************
$$SOE
2458484.500000000, A.D. 2019-Jan-01 00:00:00.0000, -4.726172010176350E+07, -4.671443491995941E+07,  4.087355549094304E+05,  2.476489737911525E+01, -3.197373466563876E+01, -4.885743869363329E+00,
2458485.500000000, A.D. 2019-Jan-02 00:00:00.0000, -4.504662628045791E+07, -4.939781389662974E+07, -1.384256303950027E+04,  2.649090922567385E+01, -3.013080867029864E+01, -4.893491681532311E+00,
2458486.500000000, A.D. 2019-Jan-03 00:00:00.0000, -4.268744093530888E+07, -5.191926900769829E+07, -4.364078858033977E+05,  2.810060075715364E+01, -2.822641779858932E+01, -4.885545989948044E+00,
2458487.500000000, A.D. 2019-Jan-04 00:00:00.0000, -4.019415029511578E+07, -5.427372055955493E+07, -8.576292172248587E+05,  2.959543332284336E+01, -2.626581826341684E+01, -4.862470361474793E+00,
2458488.500000000, A.D. 2019-Jan-05 00:00:00.0000, -3.757661912555066E+07, -5.645652107258561E+07, -1.276221821827557E+06,  3.097675164780530E+01, -2.425376903877616E+01, -4.824777032999984E+00,
2458489.500000000, A.D. 2019-Jan-06 00:00:00.0000, -3.484460215971279E+07, -5.846341490909117E+07, -1.690943077258494E+06,  3.224575348305964E+01, -2.219459107995216E+01, -4.772928966296266E+00,
2458490.500000000, A.D. 2019-Jan-07 00:00:00.0000, -3.200775791049036E+07, -6.029050283693682E+07, -2.100588311544280E+06,  3.340346461749693E+01, -2.009222242113644E+01, -4.707342057886178E+00,
2458491.500000000, A.D. 2019-Jan-08 00:00:00.0000, -2.907566445107453E+07, -6.193421119043718E+07, -2.503986835449349E+06,  3.445071813865603E+01, -1.795026956967477E+01, -4.628387436073188E+00,
2458492.500000000, A.D. 2019-Jan-09 00:00:00.0000, -2.605783683745320E+07, -6.339126532835345E+07, -2.899998175334480E+06,  3.538813702492201E+01, -1.577205566239713E+01, -4.536393799008507E+00,
2458493.500000000, A.D. 2019-Jan-10 00:00:00.0000, -2.296374591860145E+07, -6.465866713043597E+07, -3.287508508714639E+06,  3.621611931804928E+01, -1.356066587824763E+01, -4.4316497652739Line truncated

states/Moon.txt

@@ -0,0 +1 @@
+*******************************************************************************
 Revised: July 31, 2013             Moon / (Earth)                          301
 
 GEOPHYSICAL DATA (updated 2018-Aug-15):
  Vol. mean radius, km  = 1737.53+-0.03    Mass, x10^22 kg       =    7.349
  Radius (gravity), km  = 1738.0           Surface emissivity    =    0.92
  Radius (IAU), km      = 1737.4           GM, km^3/s^2          = 4902.800066
  Density, g/cm^3       =    3.3437        GM 1-sigma, km^3/s^2  =  +-0.0001  
  V(1,0)                =   +0.21          Surface accel., m/s^2 =    1.62
  Earth/Moon mass ratio = 81.3005690769    Farside crust. thick. = ~80 - 90 km
  Mean crustal density  = 2.97+-.07 g/cm^3 Nearside crust. thick.= 58+-8 km 
  Heat flow, Apollo 15  = 3.1+-.6 mW/m^2   Mean angular diameter = 31'05.2"
  Heat flow, Apollo 17  = 2.2+-.5 mW/m^2   Sid. rot. rate, rad/s = 0.0000026617
  Geometric Albedo      = 0.12             Mean solar day        = 29.5306 d
  Obliquity to orbit    = 6.67 deg         Orbit period          = 27.321582 d
  Semi-major axis, a    = 384400 km        Eccentricity          = 0.05490
  Mean motion, rad/s    = 2.6616995x10^-6  Inclination           = 5.145 deg
  Apsidal period        = 3231.50 d        Nodal period          = 6798.38 d
                                 Perihelion  Aphelion    Mean
  Solar Constant (W/m^2)         1414+-7     1323+-7     1368+-7
  Maximum Planetary IR (W/m^2)   1314        1226        1268
  Minimum Planetary IR (W/m^2)      5.2         5.2         5.2
********************************************************************************
 

 

*******************************************************************************
Ephemeris / WWW_USER Sat May 29 10:37:33 2021 Pasadena, USA      / Horizons
*******************************************************************************
Target body name: Moon (301)                      {source: DE441}
Center body name: Solar System Barycenter (0)     {source: DE441}
Center-site name: BODY CENTER
*******************************************************************************
Start time      : A.D. 2019-Jan-01 00:00:00.0000 TDB
Stop  time      : A.D. 2021-Dec-31 00:00:00.0000 TDB
Step-size       : 1440 minutes
*******************************************************************************
Center geodetic : 0.00000000,0.00000000,0.0000000 {E-lon(deg),Lat(deg),Alt(km)}
Center cylindric: 0.00000000,0.00000000,0.0000000 {E-lon(deg),Dxy(km),Dz(km)}
Center radii    : (undefined)                                                  
Output units    : KM-S
Output type     : GEOMETRIC cartesian states
Output format   : 2 (position and velocity)
Reference frame : Ecliptic of J2000.0
*******************************************************************************
            JDTDB,            Calendar Date (TDB),                      X,                      Y,                      Z,                     VX,                     VY,                     VZ,
**************************************************************************************************************************************************************************************************
$$SOE
2458484.500000000, A.D. 2019-Jan-01 00:00:00.0000, -2.594394676171621E+07,  1.457191537925642E+08,  1.879243548780680E+04, -2.920041610016305E+01, -6.056705035428428E+00, -1.966945528910324E-02,
2458485.500000000, A.D. 2019-Jan-02 00:00:00.0000, -2.845592611394830E+07,  1.451803785812578E+08,  1.623692531195283E+04, -2.895255066097593E+01, -6.409660276312301E+00, -3.913050853114974E-02,
2458486.500000000, A.D. 2019-Jan-03 00:00:00.0000, -3.094792578110056E+07,  1.446123349695342E+08,  1.210336327194422E+04, -2.873857798558501E+01, -6.735868388841888E+00, -5.607390920661848E-02,
2458487.500000000, A.D. 2019-Jan-04 00:00:00.0000, -3.342301224542837E+07,  1.440169043922708E+08,  6.638979418374598E+03, -2.856133703400771E+01, -7.045269234648544E+00, -6.984182488488688E-02,
2458488.500000000, A.D. 2019-Jan-05 00:00:00.0000, -3.588440683780140E+07,  1.433951150574999E+08,  1.401237256228924E+02, -2.842160365794606E+01, -7.347618075593773E+00, -7.995494653159207E-02,
2458489.500000000, A.D. 2019-Jan-06 00:00:00.0000, -3.833531567854504E+07,  1.427471718373300E+08, -7.063083834618330E+03, -2.831828513313826E+01, -7.652168141780209E+00, -8.611012284631547E-02,
2458490.500000000, A.D. 2019-Jan-07 00:00:00.0000, -4.077877806521063E+07,  1.420725120030732E+08, -1.462169253620505E+04, -2.824865612457545E+01, -7.967393190450194E+00, -8.817278973292941E-02,
2458491.500000000, A.D. 2019-Jan-08 00:00:00.0000, -4.321753736156642E+07,  1.413698821931921E+08, -2.218191225136817E+04, -2.820864186216586E+01, -8.300779167236234E+00, -8.616250353755506E-02,
2458492.500000000, A.D. 2019-Jan-09 00:00:00.0000, -4.565393756762660E+07,  1.406374292618203E+08, -2.939757816486806E+04, -2.819312280044993E+01, -8.658715043800495E+00, -8.023246092884984E-02,
2458493.500000000, A.D. 2019-Jan-10 00:00:00.0000, -4.8089845Line truncated

states/Oumuamua.txt

@@ -0,0 +1 @@
+*******************************************************************************
JPL/HORIZONS              1I/'Oumuamua (A/2017 U1)         2021-Jun-01 05:20:33
Rec #:50452719 (+COV) Soln.date: 2018-Jun-26_12:17:57    # obs: 207 (2017-2018)

NOTE:
This orbit solution includes non-gravitational perturbations as described in 
Micheli et al. (2018): http://dx.doi.org/10.1038/s41586-018-0254-4

The behavior of these accelerations outside the observed data arc from
2017 October 14 to 2018 January 2 can only be assumed.  Predictions outside
this time interval, especially prior to October 2017, could be much more
uncertain than reported here.
 
IAU76/J2000 helio. ecliptic osc. elements (au, days, deg., period=Julian yrs):
 
  EPOCH=  2458080.5 ! 2017-Nov-23.00 (TDB)         Residual RMS= .063527
   EC= 1.201133796102373   QR= .2559115812959116   TP= 2458006.0073213754
   OM= 24.59690955523242   W=  241.8105360304898   IN= 122.7417062847286
   A= -1.27234500742808    MA= 51.15761979369358   ADIST= 9.999999E99
   PER= 9.999999E99        N= .68674693            ANGMOM= .012910695
   DAN= 1.30212            DDN= .35938             L= 159.3364847
   B= -47.8467702          MOID= .0958212          TP= 2017-Sep-09.5073213754
 
Asteroid physical parameters (km, seconds, rotational period in hours):
   GM= n.a.                RAD= n.a.               ROTPER= 7.937
   H= 22.08                G= .150                 B-V= n.a.
                           ALBEDO= n.a.            STYP= n.a.
 
Asteroid non-gravitational force model (AMRAT= m^2/kg;A1,A2,A3=au/d^2;R0=au):
   AMRAT=  0.
   A1= 2.790193367004E-7   A2= 1.441264152527E-8   A3= 1.573922634125E-8
 Non-standard or simulated/proxy model:
   ALN=  .04083733261  NK=  2.6      NM=  2.       NN=  3.       R0=  5.
 
ASTEROID comments: 
1: soln ref.= JPL#16
2: source=ORB; Sol. 7c, Micheli et al. 2018
*******************************************************************************
 

 

*******************************************************************************
Ephemeris / WWW_USER Tue Jun  1 05:20:34 2021 Pasadena, USA      / Horizons
*******************************************************************************
Target body name: 1I/'Oumuamua (A/2017 U1)        {source: JPL#16}
Center body name: Solar System Barycenter (0)     {source: DE441}
Center-site name: BODY CENTER
*******************************************************************************
Start time      : A.D. 2019-Jan-01 00:00:00.0000 TDB
Stop  time      : A.D. 2021-Dec-31 00:00:00.0000 TDB
Step-size       : 1440 minutes
*******************************************************************************
Center geodetic : 0.00000000,0.00000000,0.0000000 {E-lon(deg),Lat(deg),Alt(km)}
Center cylindric: 0.00000000,0.00000000,0.0000000 {E-lon(deg),Dxy(km),Dz(km)}
Center radii    : (undefined)                                                  
Small perturbers: Yes                             {source: SB441-N16}
Output units    : KM-S
Output type     : GEOMETRIC cartesian states
Output format   : 2 (position and velocity)
Reference frame : Ecliptic of J2000.0
*******************************************************************************
Initial IAU76/J2000 heliocentric ecliptic osculating elements (au, days, deg.):
  EPOCH=  2458080.5 ! 2017-Nov-23.00 (TDB)         Residual RMS= .063527       
   EC= 1.201133796102373   QR= .2559115812959116   TP= 2458006.0073213754      
   OM= 24.59690955523242   W=  241.8105360304898   IN= 122.7417062847286       
  Equivalent ICRF heliocentric cartesian coordinates (au, au/d):
   X= 1.889136186533479E+00  Y= 5.222899434623107E-01  Z= 5.088057830311858E-01
  VX= 2.106502285864550E-02 VY= 3.535022471254454E-04 VZ= 8.998631872968255E-03
Asteroid physical parameters (km, seconds, rotational period in hours):        
   GM= n.a.                RAD= n.a.               ROTPER= 7.937               
   H= 22.08                G= .150                 B-V= n.a.                   
                           ALBEDO= n.a.            STYP= n.a.                  
Asteroid non-gravitational force model (AMRAT= m^2/kg;A1,A2,A3=au/d^2;R0=au):  
   AMRAT=  0.                                                                  
   A1= 2.790193367004E-7   A2= 1.441264152527E-8   A3= 1.573922634125E-8       
 Non-standard or simulated/proxy model:                                        
   ALN=  .04083733261  NK=  2.6      NM=  2.       NN=  3.       R0=  5.       
*******************************************************************************
            JDTDB,            Calendar Date (TDB),                      X,                      Y,                      Z,                     VX,                     VY,                     VZ,
**************************************************************************************************************************************************************************************************
$$SOE
2458484.500000000, A.D. 2019-Jan-01 00:00:00.0000,  1.312288663591239E+09,  2.6Line truncated

states/Pallas.txt

@@ -0,0 +1 @@
+*******************************************************************************
JPL/HORIZONS                 2 Pallas (A802 FA)            2021-May-29 11:15:53
Rec #:       2 (+COV) Soln.date: 2021-May-03_17:43:21   # obs: 8933 (1804-2020)
 
IAU76/J2000 helio. ecliptic osc. elements (au, days, deg., period=Julian yrs):
 
  EPOCH=  2449820.5 ! 1995-Apr-13.00 (TDB)         Residual RMS= .37013
   EC= .2338923901398553   QR= 2.123199358589515   TP= 2449888.2401978029
   OM= 173.3007005773634   W=  309.6979504659889   IN= 34.80656077842534
   A= 2.771411393468747    MA= 345.5289835475172   ADIST= 3.41962342834798
   PER= 4.61381            N= .213625241           ANGMOM= .027842964
   DAN= 2.27928            DDN= 3.07993            L= 128.6154841
   B= -26.0523449          MOID= 1.22409999        TP= 1995-Jun-19.7401978029
 
Asteroid physical parameters (km, seconds, rotational period in hours):
   GM= 14.3                RAD= 272.5              ROTPER= 7.8132
   H= 4.21                 G= .110                 B-V= .635
                           ALBEDO= .101            STYP= B
 
ASTEROID comments: 
1: soln ref.= JPL#42, OCC=0
2: source=ORB
*******************************************************************************
 

 

*******************************************************************************
Ephemeris / WWW_USER Sat May 29 11:15:53 2021 Pasadena, USA      / Horizons
*******************************************************************************
Target body name: 2 Pallas (A802 FA)              {source: JPL#42}
Center body name: Solar System Barycenter (0)     {source: DE441}
Center-site name: BODY CENTER
*******************************************************************************
Start time      : A.D. 2019-Jan-01 00:00:00.0000 TDB
Stop  time      : A.D. 2021-Dec-31 00:00:00.0000 TDB
Step-size       : 1440 minutes
*******************************************************************************
Center geodetic : 0.00000000,0.00000000,0.0000000 {E-lon(deg),Lat(deg),Alt(km)}
Center cylindric: 0.00000000,0.00000000,0.0000000 {E-lon(deg),Dxy(km),Dz(km)}
Center radii    : (undefined)                                                  
Small perturbers: Yes                             {source: SB441-N16}
Output units    : KM-S
Output type     : GEOMETRIC cartesian states
Output format   : 2 (position and velocity)
Reference frame : Ecliptic of J2000.0
*******************************************************************************
Initial IAU76/J2000 heliocentric ecliptic osculating elements (au, days, deg.):
  EPOCH=  2449820.5 ! 1995-Apr-13.00 (TDB)         Residual RMS= .37013        
   EC= .2338923901398553   QR= 2.123199358589515   TP= 2449888.2401978029      
   OM= 173.3007005773634   W=  309.6979504659889   IN= 34.80656077842534       
  Equivalent ICRF heliocentric cartesian coordinates (au, au/d):
   X=-3.914331834006519E-01  Y= 2.086547556539849E+00  Z=-3.858944255506239E-01
  VX=-1.247921525244788E-02 VY=-3.104370043226314E-03 VZ= 1.462708693235823E-03
Asteroid physical parameters (km, seconds, rotational period in hours):        
   GM= 14.3                RAD= 272.5              ROTPER= 7.8132              
   H= 4.21                 G= .110                 B-V= .635                   
                           ALBEDO= .101            STYP= B                     
*******************************************************************************
            JDTDB,            Calendar Date (TDB),                      X,                      Y,                      Z,                     VX,                     VY,                     VZ,
**************************************************************************************************************************************************************************************************
$$SOE
2458484.500000000, A.D. 2019-Jan-01 00:00:00.0000, -3.453585004297552E+08,  2.151464493938778E+07,  1.484082838948810E+07, -3.944259837966826E+00, -1.692743937506040E+01,  1.202778577972903E+01,
2458485.500000000, A.D. 2019-Jan-02 00:00:00.0000, -3.456951638863605E+08,  2.005187568649421E+07,  1.587984777317063E+07, -3.848901261556055E+00, -1.693289035516663E+01,  1.202354285563258E+01,
2458486.500000000, A.D. 2019-Jan-03 00:00:00.0000, -3.460235950197951E+08,  1.858865349208418E+07,  1.691848867122066E+07, -3.753697268809341E+00, -1.693792445828556E+01,  1.201902480253225E+01,
2458487.500000000, A.D. 2019-Jan-04 00:00:00.0000, -3.463438073066825E+08,  1.712501428967858E+07,  1.795672738107823E+07, -3.658650645445643E+00, -1.694254364596886E+01,  1.201423320898760E+01,
2458488.500000000, A.D. 2019-Jan-05 00:00:00.0000, -3.466558144628218E+08,  1.566099384279655E+07,  1.899454033766988E+07, -3.563764142227468E+00, -1.694674989182626E+01,  1.200916966895306E+01,
2458489.500000000, A.D. 2019-Jan-06 00:00:00.0000, -3.469596304401702E+08,  1.419662774393039E+07,  2.003190411386344E+07, -3.469040475028256E+00, -1.695054518113680E+01,  1.200383578151577E+01,
2458490.50000Line truncated

states/Phobos.txt

@@ -0,0 +1 @@
+*******************************************************************************
 Revised: Sep 28, 2012             Phobos / (Mars)                          401

 SATELLITE PHYSICAL PROPERTIES:
  Radius (km)             = 13.1 x11.1 x9.3 Density (g cm^-3)   =  1.90 +- 0.08
  Mass (10^20 kg )        =  1.08 (10^-4)   Geometric Albedo    =  0.06 
                                 (+- 0.1)   V(1,0)              = +11.8

 SATELLITE ORBITAL DATA:
  Semi-major axis, a (km) = 9.3772(10^3)    Orbital period      = 0.319 d
  Eccentricity, e         = 0.0151          Rotational period   = Synchronous
  Inclination, i  (deg)   = 1.082
*******************************************************************************
 

 

*******************************************************************************
Ephemeris / WWW_USER Sat May 29 10:42:43 2021 Pasadena, USA      / Horizons
*******************************************************************************
Target body name: Phobos (401)                    {source: mar097}
Center body name: Solar System Barycenter (0)     {source: DE441}
Center-site name: BODY CENTER
*******************************************************************************
Start time      : A.D. 2019-Jan-01 00:00:00.0000 TDB
Stop  time      : A.D. 2021-Dec-31 00:00:00.0000 TDB
Step-size       : 1440 minutes
*******************************************************************************
Center geodetic : 0.00000000,0.00000000,0.0000000 {E-lon(deg),Lat(deg),Alt(km)}
Center cylindric: 0.00000000,0.00000000,0.0000000 {E-lon(deg),Dxy(km),Dz(km)}
Center radii    : (undefined)                                                  
Output units    : KM-S
Output type     : GEOMETRIC cartesian states
Output format   : 2 (position and velocity)
Reference frame : Ecliptic of J2000.0
*******************************************************************************
            JDTDB,            Calendar Date (TDB),                      X,                      Y,                      Z,                     VX,                     VY,                     VZ,
**************************************************************************************************************************************************************************************************
$$SOE
2458484.500000000, A.D. 2019-Jan-01 00:00:00.0000,  1.629815469459798E+08,  1.449078262404279E+08, -9.983748377748802E+05, -1.321954683184625E+01,  2.052462587429605E+01, -1.744932928934002E-01,
2458485.500000000, A.D. 2019-Jan-02 00:00:00.0000,  1.616735070963576E+08,  1.466541000389653E+08, -9.324437475351617E+05, -1.420250003553856E+01,  2.184633030243700E+01,  3.505949021617258E-01,
2458486.500000000, A.D. 2019-Jan-03 00:00:00.0000,  1.603453133760684E+08,  1.483898444933466E+08, -8.637763171340525E+05, -1.588886150652570E+01,  2.195539407823319E+01,  1.156924375162896E+00,
2458487.500000000, A.D. 2019-Jan-04 00:00:00.0000,  1.589963203868488E+08,  1.501098760173905E+08, -7.923181186252534E+05, -1.729058793712412E+01,  2.072091398352851E+01,  1.719619509083024E+00,
2458488.500000000, A.D. 2019-Jan-05 00:00:00.0000,  1.576293690746227E+08,  1.518101004375398E+08, -7.197556495422348E+05, -1.761559164024376E+01,  1.882089747799705E+01,  1.674065535210163E+00,
2458489.500000000, A.D. 2019-Jan-06 00:00:00.0000,  1.562491866939842E+08,  1.534899834000229E+08, -6.485038052894101E+05, -1.671025527427437E+01,  1.739668835039943E+01,  1.022211683575713E+00,
2458490.500000000, A.D. 2019-Jan-07 00:00:00.0000,  1.548594736165679E+08,  1.551531185370942E+08, -5.801435848044157E+05, -1.527542732636680E+01,  1.737416290432804E+01,  1.964283104845430E-01,
2458491.500000000, A.D. 2019-Jan-08 00:00:00.0000,  1.534602039265565E+08,  1.568048786592960E+08, -5.141828407533616E+05, -1.447374325382064E+01,  1.868284796861607E+01, -2.021117742077783E-01,
2458492.500000000, A.D. 2019-Jan-09 00:00:00.0000,  1.520476168717376E+08,  1.584482933658796E+08, -4.483511435208395E+05, -1.498652197492919E+01,  2.023409466264165E+01,  1.029737217303914E-01,
2458493.500000000, A.D. 2019-Jan-10 00:00:00.0000,  1.506172439040140E+08,  1.600818118911068E+08, -3.803407664359212E+05, -1.650935825658196E+01,  2.084523889823814E+01,  8.673361088921618E-01,
2458494.500000000, A.D. 2019-Jan-11 00:00:00.0000,  1.491671109136406E+08,  1.617006636088864E+08, -3.093780068372786E+05, -1.811585327651534E+01,  2.005435037339918E+01,  1.574488841944787E+00,
2458495.500000000, A.D. 2019-Jan-12 00:00:00.0000,  1.476988804873439E+08,  1.633000182378080E+08, -2.365900902837664E+05, -1.888367793193226E+01,  1.827233163967256E+01,  1.773559447645338E+00,
2458496.500000000, A.D. 2019-Jan-13 00:00:00.0000,  1.462168698589457E+08,  1.648778573100380E+08, -1.642827164929807E+05, -1.838437827752159E+01,  1.652621299537533E+01,  1.316329386611214E+00,
2458497.500000000, A.D. 2019-Jan-14 00:00:00.0000,  1.447255342797189E+08,  1.664363644925710E+08, -9.452541922541708E+04, -1.700405054310853E+01,  1.591601042035790E+01,  4.84418544335017Line truncated

states/Venus.txt

@@ -0,0 +1 @@
+*******************************************************************************
 Revised: April 12, 2021                Venus                           299 / 2
 
 PHYSICAL DATA (updated 2020-Oct-19):
  Vol. Mean Radius (km) =  6051.84+-0.01 Density (g/cm^3)      =  5.204
  Mass x10^23 (kg)      =    48.685      Volume (x10^10 km^3)  = 92.843
  Sidereal rot. period  =   243.018484 d Sid. Rot. Rate (rad/s)= -0.00000029924
  Mean solar day        =   116.7490 d   Equ. gravity  m/s^2   =  8.870
  Mom. of Inertia       =     0.33       Core radius (km)      = ~3200
  Geometric Albedo      =     0.65       Potential Love # k2   = ~0.25
  GM (km^3/s^2)         = 324858.592     Equatorial Radius, Re = 6051.893 km
  GM 1-sigma (km^3/s^2) =    +-0.006     Mass ratio (Sun/Venus)= 408523.72
  Atmos. pressure (bar) =  90            Max. angular diam.    =   60.2"
  Mean Temperature (K)  = 735            Visual mag. V(1,0)    =   -4.40
  Obliquity to orbit    = 177.3 deg      Hill's sphere rad.,Rp =  167.1
  Sidereal orb. per., y =   0.61519726   Orbit speed, km/s     =   35.021
  Sidereal orb. per., d = 224.70079922   Escape speed, km/s    =   10.361
                                 Perihelion  Aphelion    Mean
  Solar Constant (W/m^2)         2759         2614       2650
  Maximum Planetary IR (W/m^2)    153         153         153
  Minimum Planetary IR (W/m^2)    153         153         153
*******************************************************************************
 

 

*******************************************************************************
Ephemeris / WWW_USER Sat May 29 10:41:39 2021 Pasadena, USA      / Horizons
*******************************************************************************
Target body name: Venus Barycenter (299)          {source: DE441}
Center body name: Solar System Barycenter (0)     {source: DE441}
Center-site name: BODY CENTER
*******************************************************************************
Start time      : A.D. 2019-Jan-01 00:00:00.0000 TDB
Stop  time      : A.D. 2021-Dec-31 00:00:00.0000 TDB
Step-size       : 1440 minutes
*******************************************************************************
Center geodetic : 0.00000000,0.00000000,0.0000000 {E-lon(deg),Lat(deg),Alt(km)}
Center cylindric: 0.00000000,0.00000000,0.0000000 {E-lon(deg),Dxy(km),Dz(km)}
Center radii    : (undefined)                                                  
Output units    : KM-S
Output type     : GEOMETRIC cartesian states
Output format   : 2 (position and velocity)
Reference frame : Ecliptic of J2000.0
*******************************************************************************
            JDTDB,            Calendar Date (TDB),                      X,                      Y,                      Z,                     VX,                     VY,                     VZ,
**************************************************************************************************************************************************************************************************
$$SOE
2458484.500000000, A.D. 2019-Jan-01 00:00:00.0000, -8.238126961879626E+07,  7.005400357447663E+07,  5.684910758346014E+06, -2.263904820538244E+01, -2.701728799104976E+01,  9.352522537487609E-01,
2458485.500000000, A.D. 2019-Jan-02 00:00:00.0000, -8.430421210851002E+07,  6.769252287428245E+07,  5.763435044511393E+06, -2.187056411397726E+01, -2.764297308639734E+01,  8.823195889301818E-01,
2458486.500000000, A.D. 2019-Jan-03 00:00:00.0000, -8.616000326168314E+07,  6.527793470247705E+07,  5.837355477688540E+06, -2.108472508611304E+01, -2.824654501526468E+01,  8.286888312335829E-01,
2458487.500000000, A.D. 2019-Jan-04 00:00:00.0000, -8.794717128355025E+07,  6.281217077175058E+07,  5.906613629538920E+06, -2.028217402444955E+01, -2.882751772321507E+01,  7.744037506720485E-01,
2458488.500000000, A.D. 2019-Jan-05 00:00:00.0000, -8.966430052740383E+07,  6.029720395853411E+07,  5.971154876742747E+06, -1.946356764952629E+01, -2.938542446947505E+01,  7.195086496297805E-01,
2458489.500000000, A.D. 2019-Jan-06 00:00:00.0000, -9.131003266225842E+07,  5.773504661667021E+07,  6.030928445242047E+06, -1.862957589113161E+01, -2.991981823154502E+01,  6.640483221889149E-01,
2458490.500000000, A.D. 2019-Jan-07 00:00:00.0000, -9.288306778738710E+07,  5.512774885702962E+07,  6.085887450950667E+06, -1.778088126726145E+01, -3.043027208880648E+01,  6.080680130282587E-01,
2458491.500000000, A.D. 2019-Jan-08 00:00:00.0000, -9.438216549269339E+07,  5.247739679490615E+07,  6.135988936896548E+06, -1.691817825148213E+01, -3.091637958471852E+01,  5.516133759465482E-01,
2458492.500000000, A.D. 2019-Jan-09 00:00:00.0000, -9.580614586395182E+07,  4.978611076705655E+07,  6.181193906766072E+06, -1.604217262952625E+01, -3.137775506723322E+01,  4.947304320630508E-01,
2458493.500000000, A.D. 2019-Jan-10 00:00:00.0000, -9.715389043202378E+07,  4.705604352028117E+07,  6.221467354824975E+06, -1.515358084596507E+01, -3.181403400709587E+01,  4.374655277489836E-01,
Line truncated

states/Vesta.txt

@@ -0,0 +1 @@
+*******************************************************************************
JPL/HORIZONS                  4 Vesta (A807 FA)            2021-May-29 11:46:53
Rec #:       4 (+COV) Soln.date: 2021-Apr-13_11:15:57   # obs: 9451 (1950-2021)
 
IAU76/J2000 helio. ecliptic osc. elements (au, days, deg., period=Julian yrs):
 
  EPOCH=  2458849.5 ! 2020-Jan-01.00 (TDB)         Residual RMS= .47385
   EC= .08857261385730482  QR= 2.15270823108896    TP= 2458247.8038331456
   OM= 103.8092892453337   W=  150.8357762126256   IN= 7.14181494423702
   A= 2.361908654291772    MA= 163.3754032354997   ADIST= 2.571109077494583
   PER= 3.62997            N= .271524746           ANGMOM= .026333145
   DAN= 2.53982            DDN= 2.17514            L= 254.8345779
   B= 3.4734313            MOID= 1.13987994        TP= 2018-May-09.3038331456
 
Asteroid physical parameters (km, seconds, rotational period in hours):
   GM= 17.8                RAD= 262.7              ROTPER= 5.342128
   H= 3.31                 G= .320                 B-V= .782
                           ALBEDO= .4228           STYP= V
 
ASTEROID comments: 
1: soln ref.= JPL#36, OCC=0           radar(2977 delay, 0 Dop
2: source=ORB
*******************************************************************************
 

 

*******************************************************************************
Ephemeris / WWW_USER Sat May 29 11:46:53 2021 Pasadena, USA      / Horizons
*******************************************************************************
Target body name: 4 Vesta (A807 FA)               {source: JPL#36}
Center body name: Solar System Barycenter (0)     {source: DE441}
Center-site name: BODY CENTER
*******************************************************************************
Start time      : A.D. 2019-Jan-01 00:00:00.0000 TDB
Stop  time      : A.D. 2021-Dec-31 00:00:00.0000 TDB
Step-size       : 1440 minutes
*******************************************************************************
Center geodetic : 0.00000000,0.00000000,0.0000000 {E-lon(deg),Lat(deg),Alt(km)}
Center cylindric: 0.00000000,0.00000000,0.0000000 {E-lon(deg),Dxy(km),Dz(km)}
Center radii    : (undefined)                                                  
Small perturbers: Yes                             {source: SB441-N16}
Output units    : KM-S
Output type     : GEOMETRIC cartesian states
Output format   : 2 (position and velocity)
Reference frame : Ecliptic of J2000.0
*******************************************************************************
Initial IAU76/J2000 heliocentric ecliptic osculating elements (au, days, deg.):
  EPOCH=  2458849.5 ! 2020-Jan-01.00 (TDB)         Residual RMS= .47385        
   EC= .08857261385730482  QR= 2.15270823108896    TP= 2458247.8038331456      
   OM= 103.8092892453337   W=  150.8357762126256   IN= 7.14181494423702        
  Equivalent ICRF heliocentric cartesian coordinates (au, au/d):
   X= 1.243605461680222E+00  Y= 2.133870405923554E+00  Z= 6.874866847781977E-01
  VX=-8.779290950353064E-03 VY= 4.462599423343603E-03 VZ= 2.927653651039283E-03
Asteroid physical parameters (km, seconds, rotational period in hours):        
   GM= 17.8                RAD= 262.7              ROTPER= 5.342128            
   H= 3.31                 G= .320                 B-V= .782                   
                           ALBEDO= .4228           STYP= V                     
*******************************************************************************
            JDTDB,            Calendar Date (TDB),                      X,                      Y,                      Z,                     VX,                     VY,                     VZ,
**************************************************************************************************************************************************************************************************
$$SOE
2458484.500000000, A.D. 2019-Jan-01 00:00:00.0000,  2.896729116971705E+08, -1.781911555651397E+08, -2.990483159764896E+07,  1.170943386515238E+01,  1.610135702679393E+01, -1.907600473100395E+00,
2458485.500000000, A.D. 2019-Jan-02 00:00:00.0000,  2.906810176722590E+08, -1.767977867679520E+08, -3.006927776908569E+07,  1.162632187843875E+01,  1.615247313008015E+01, -1.899017818371286E+00,
2458486.500000000, A.D. 2019-Jan-03 00:00:00.0000,  2.916819348495660E+08, -1.754000215493568E+08, -3.023298083640625E+07,  1.154302696793227E+01,  1.620312600149254E+01, -1.890399043588770E+00,
2458487.500000000, A.D. 2019-Jan-04 00:00:00.0000,  2.926756475433087E+08, -1.739978999425360E+08, -3.039593769300150E+07,  1.145955188327699E+01,  1.625331541370235E+01, -1.881744476562807E+00,
2458488.500000000, A.D. 2019-Jan-05 00:00:00.0000,  2.936621403049815E+08, -1.725914619995510E+08, -3.055814526057230E+07,  1.137589936732655E+01,  1.630304115698279E+01, -1.873054444803577E+00,
2458489.500000000, A.D. 2019-Jan-06 00:00:00.0000,  2.946413979227638E+08, -1.711807477898281E+08, -3.071960048910274E+07,  1.129207215603937E+01,  1.635230303907983E+01, -Line truncated