Satellitenbahnen [Greenfoot]

Moin Leute,

z.Z. arbeite ich in der Schule an einem Projekt in "Greenfoot" (basierend auf Java). In dem Projekt geht es darum Satellitenbahnen zu simulieren, ein Projekt für den Informatik- und Physikunterricht. Soweit kein Problem!

Hier (http://www.fileuploadx.de/368637) findet sich mein Projekt, welches ihr mit Greenfoot abspielen könnt. Wenn ihr auf "Start" drückt, könnt ihr zunächst den Satelliten positionieren und müsst anschließend [Enter] drücken, dann beginnt der Satellit sich auf seiner Bahn zu bewegen. Das ganze basiert auf der Vorlage NewtonsLab (von Michael Kölling, falls es euch was sagt...).

Jetzt habe ich noch ein paar Fragen, bei den ihr mir vielleicht behilflich sein könntet.

1. Die "Evaluation"-Klasse schreibt alle Daten auf die Leinwand. Alle Daten stimmen, bis auf eine Information: Die Geschwindigkeit. Es fällt mir leider schwer, dass hier ausführlich zu Kommentieren, wie diese Information zustande kommt, doch will ich es kurz anreißen. Das Programm arbeitet mit Vektoren, folglich habe ich versucht aus der Vektorlänge die Geschwindigkeit zu bestimmen, indem ich sie mit der Methode setting.pixelToKilometer() (Klasse Setting) versucht habe um zurechnen. Die Größenordnung kann einfach nicht stimmen, ich hätte einen Wert in einer leicht anderen Größenordnung erwartet.

2. Nach kurzer Beobachtung fällt auf, dass sich die Bahn auf der sich der Satellit um den Planeten bewegt, sich "ändert", d.H. es entstehen Abweichungen, wodurch der Satellit irgendwann in den Planeten fliegt, dürfte Physikalisch gesehen eigentlich nicht so sein oder? Ich vermutete zunächst, dass es sich hierbei um einen Umwandlungsfehler/Rundungsfehler handeln müsste (z.B. Koordinaten mit double-Wert zu einem integer-Wert). War leider nicht der Fall, nun weiß ich nicht wo der Fehler sein müsste.

Falls euch sonst noch was auffallen sollte, gebt mir bitte Bescheid.

Ich würde mich über jede Hilfe freuen :)

Grüße,
Darkmiller

Hi,
so wie ich das sehe verlierst du tatsächlich Exaktheit mit deinen Vektoren. Namentlich geht es dabei um "direction", was du als int speicherst. Zwischen 30° und 30,1° liegt dann wohl aber doch ein Unterschied.

Ich habe mir mal erlaubt deine Vector-Klasse mit komplexen Zahlen neu zu entwerfen. Das macht alles wesentlich kürzer (wenn auch sicher nicht schneller, da ich Größen wie Länge und Winkel [bei komplexen Zahlen auch Argument genannt] nicht speichere, sondern berechne).

Den Satellit habe ich mal ein wenig kreisen lassen (auch mit vollem Tempo um viele Umläufe zu erreichen) und er stürzt uns nun nicht mehr auf die Köpfe ;)

Hier der Code:
http://pastie.org/private/aolbbe6ermf4vwq3t4ra

P.S.: schönes Programm (:

Hallo Blackberry,

vielen Dank erst einmal! An die "direction" hatte ich nicht gedacht.

Hast du vielleicht auch eine Idee, was das andere Problem angeht? Schätzungsweise würde ich auf eine Geschwindigkeit von +- 10.000 km/h denken, aber um die 1.000 km/h sind eindeutig zu wenig, denn ein Geostationärer Satellit umkreist die Erde auf ca. 35.000 km "Höhe", und umkreist die Erde Beispielsweise an einem Tag.

Daraus folgt:
v = U/t
U = 2*pi*35.000 km
t = 24 h

v = (2*pi*35.000)/24 km/h
v = 9162.97 km/h

Im Programm sind es nicht ganz 30.000, da es eine Ellipsenbahn ist, variiert es auch leicht, aber das dürfte nur ein leichter Faktor sein.

Wo liegt mein Denkfehler?

Grüße,
Darkmiller

//EDIT: achja, eine Sache fällt mir noch ein, wie bekomme ich Greenfootprojekte in Eclipse eingebunden? Ich habe versucht ein Projekt zu erstellen, in dem ich die *.java Dateien und Bilder geladen habe, hab bei den Projekteinstellungen auf die Dateien "bluejcore.jar" und "greenfoot.jar" gelinkt. Im Reiter "Run configurations" habe ich Greenfoot augewählt. Zuletzt habe ich noch eine "standalone.properties" erstellt, welche die Struktur des Projektes schlüssig für Eclipse enthielt. Hat wer Ideen, was ich falsch gemacht haben könnte?

Zu Eclipse:
http://www.greenfoot.org/topics/317

Zur Flugphysik:
Muss ich mich erst wieder einlesen; habe in meinem Mathe Studium zum Glück nichts mit Physik zu tun :P

Was mir bei deiner Rechnung aber auffällt ist, dass du bei der Höhe des geostationären Satelliten die Entfernung zur Erdoberfläche genommen hast. Die Entfernung zum Erdmittelpunkt beträgt noch etwa 6.000km mehr.

Mit der Rechnung erhälst du: (2*pi*(35786+6378))/24, was ungefähr 11038 betragen würde, also in der von dir erwarteten Größenordnung liegt.

EDIT:
Zum Programm:
Die Geschwindigkeit erscheint mir auch relativ unrealistisch. Berechnen tust du das ja mit deinem rätselhaften "distanceFactor" in Setting, der bei dir 0,00784929356 beträgt. Das multiplizierst du an die Länge des Richtungsvektors und behauptest das sei die Geschwindigkeit in km/h.

Da der Fehler also zwangsweise an diesem Faktor liegt wäre ich mal interessiert zu wissen, wie du zu der gekommen bist ;)

der rätselhafte "distanceFactor" entsteht wie folgt:

man denke sich einen Planeten, mit 100 Pixel Durchmesser. Wir wissen der Erdradius beträgt ca. 6370 km. Nun brauchen wir einen Faktor um das ganze um zurechnen. So habe ich die Methode auch pixelToKilometer genannt.

100 / (2*6370) = distanceFactor

da hab ich mir gedacht, die Geschwindigkeit ist nichts anderes als die Vektorlänge und hab mir gedacht: Die Vektorlänge ist eine "Strecke", sodass ich diesen Faktor auch ganz einfach darauf anwenden kann.

//EDIT: kurze, leicht unsichere Frage: der Faktor wird wahrscheinlich das Problem sein. Kann es zufällig sein, dass die Länge genau das ist was ich haben will, aber dass ich anstatt km/s mich für km/h entschieden habe?

Eine Verwechslung von km/s und km/h halte ich hier für unwahrscheinlich. Du rechnest überall mit Kilometern und Stunden, also werden da auch nicht plötzlich Sekunden draus werden. Von km/s auf km/h wird ja durch Multiplikation mit 60*60=3600 umgerechnet. Es ist 60*60*1800 = 6480000, also auch außerhalb deiner gewünschten Größenordnung.

Bei der Umrechnung von den Pixeln sehe ich auch kein Problem. Wie wäre es, wenn du dein Programm mal so umschreibst, dass die Rechnungen mit den eigentlichen Koordinaten ausgeführt werden und für die Darstellung das ganze erst auf Pixel runtergerechnet wird. Dann gibt dir die Länge des Geschwindigkeitsvektors auch tatsächlich die Geschwindigkeit an.

du meinst, ich soll in der Vektorklasse alles mit pixelToKilometer() umrechnen und in der Klasse Body, wo die Koordinaten berechnet und gesetzt werden, mit kilometerToPixel() arbeiten?

werde ich mal testen, aber ist es nicht das selbe als würde ich es später bei der Ausgabe umwandeln?

mir ist folgendes Eingefallen:
jedes mal wenn die act()-Methode aufgerufen wurde, bewegt sich der Satellit um die Vektorlänge des "movement"-Vektors. Folglich habe ich einfach diese Einheit gewählt:

[v] = km/act()

act() könnte man auch in Stunden definieren, fällt mir aber spontan keine simple Lösung ein...

Okay das erklärt dann natürlich das Problem (:
In Java kannst du ja aber sehr einfach mit dieser Methode:
http://docs.oracle.com/javase/1.5.0/...ntTimeMillis()
die verstrichene Zeit messen und dann entsprechend umrechnen.

Sag bescheid, wenn es funktioniert ;)

ja, könnte ich machen, doch wäre das ja nicht Synchron oder?

---------- Post added at 19:47 ---------- Previous post was at 18:48 ----------

aktuelles Version: http://www.fileuploadx.de/318435

Eine Frage hätte ich noch. In der "Evaluation"-Klasse gebe ich mit der Methode writeText(...) Texte aus. Nun habe ich mir gedacht, dass ich weitere "Zeichnungen" auch über diese Methode mache. Das ist natürlich auch nicht schwer. Nur wenn ich etwas zeichnen will, dass konstant angezeigt werden soll, ist es ziemlich schwierig, da sich die Methode immer wieder neu zeichnet.

Es geht im speziellen darum, dass ich die Bahn des Satelliten einzeichnen möchte. Ich könnte zwar jeden Punkt speichern, wäre ziemlich umständlich. Ich könnte auch jedes mal die Bahn berechnen, auch umständlich. Ich habe mir gedacht, dass der Satellit immer an seinem aktuellen Punkt, einen kleinen Punkt malt, sodass sich nach einer Zeit das Gesamtbild ergibt. Wie schaffe ich das ohne eine der beiden erstgenannten Möglichkeiten?

Du könntest doch einfach einen weiteren Actor ähnlich wie "Evaluation" erstellen, dem den Satelliten übergeben und den dann jedes mal bei act() entsprechend Punkte setzen lassen.

das Problem ist ja, dass die act()-Methode, durch einen Neuaufruf einer Methode die Zeichnen soll, dass gezeichnete durch eine neue Zeichnung ersetzt. Wenn ich also nun eine neue Klasse anlegen würde, die die Aufgabe hat alle Punkte zu zeichnen, wäre immer nur der aktuelle Punkt zu sehen.

Dann würde ich mit Queues arbeiten. Die werden ja von Java schon als Templateklasse zur Verfügung gestellt und du könntest die zu zeichnenden Punkte dort eintragen.

Sollte die Schlange zu voll werden, so kannst du ja beim Einfügen gleich wieder ein Element entfernen. Das läuft ja so, dass zuerst entfernt wird, was zuerst rein kam. Also würde dein Satellit einen langen "Schweif" wie ein Komet hinter sich herziehen, der ab einer gewissen Länge abbricht. Ist die Länge lang genug, so wirst du bei elliptischen Bahnen auch stets eine völlig gezeichnete Ellipse haben.

Wirklich aufwändig zu implementieren ist das nicht.

hab eine Coordinatenklasse angelegt, die jeweils ein x und ein y Wert hat. Evaluation erzeugt eine ArrayList<Coordinate>, womit sich die Punkte die gezeichnet werden sollen gespeichert werden können.

Er zeichnet solange bis die geflogene Distanz größer als 2*pi*Entfernung ist, oder er diesen Punkt schon registriert hat. Kostet zwar viel Speicher, aber funktioniert größtenteils.

so alle Probleme gelöst, kann geclosed werden!

Vielen dank nochmal an Blackberry!