GRAVITATION

1.Prinzip

Das hier beschriebene Programm simuliert die Bewegungen von Planeten mithilfe
der Newton'schen Formel zur Berechnung der Gravitation 
      m1*m2
 F = ------ * G  . 
       r 
Wobei m1 und m2 die Massen der momentan berechneten Planeten und r der Abstand 
zwischen diesen ist. G ist die Gravitationskonstante und betrgt 
6.67*E-11 [m^3/(kg*s)]. Mittels der Massen kann dann die Kraft in eine 
Beschleunigung umgerechnet werden. 

2.Das Universum im Programm 

Von jedem Planeten kann eine x, y und z-Position im Universum, ein 
Geschwindigkeitsanteil in jede dieser drei Richtungen eine Masse, ein Radius
(der im Moment aber keinen Einflu auf die Berechnungen hat) und eine Farbe 
(mit der der Planet am Bildschirm dargestellt wird) angegeben werden. Weiters
kann die Genauigkeit der Berechnungen ber die Zeit geregelt werden, hier erfolgt 
die Angabe in Vielfachen von Sekunden. 

In den "#defines" die sich ganz am Anfang des Programmes befinden ist es mglich 
die Genauigkeit der Daten der Planeten zu variieren indem man die Zeile 
#define TYP long double  
verndert. statt long double knnen Datentypen wie float eingesetzt werden um 
die Genauigkeit der Berechnung zu verringern, was wiederum die Rechenge=
schwindigkeit erhht. 

3.Der Aufbau des Programmes

	3.1 Allgemeines
Das Programm ist objektorientiert Programmiert und knnte theoretisch circa 
65000 Planeten (oder Sonnen) verwalten, was allerdings bei der heutigen 
Rechnergeschwindigkeit nicht sinnvoll ist (gnstig ist eine Anzahl bis 10 
Planeten). Auerdem wird die Anzahl der Planeten durch den zur Verfgung 
stehenden Speicherplatz eingeschrnkt. 

	3.2  Die Liste der Planeten
Um mit mehreren Planeten arbeiten zu knnen bentigt man eine Liste in der die
Planeten verzeichnet sind und mit der man die Planeten verwalten kann. Es
werden von Firmen wie BORLAND oder MICROSOFT fr die C++ - Compiler verschiedene
Listenklassen angeboten. Da ich nur ungengende Beschreibungen dieser Klassen
finden konnte, habe ich mir kurzerhand  einn eigen programmiert. 
Die Klasse ist in der Datei liste-x.h zu finden. Sie ist eine template-Klasse, 
was den Vorteil hat, da die Klasse TPlanet (in der die Daten fr den Planten)
verzeichnet sind nachtrglich abgendert werden kann, ohne da dies auf die 
Funktion der Listenklasse Einflu htte. 

Die Liste besteht im Prinzip aus aneinandergereihten Elementen. Die Liste hat 
einen Kopf und einen Schwanz, dazwischen befinden sich die restlichen Elemente
in denen die Planeten verzeichnet sind. Fr jeden Planeten gibt es ein eigenes
Element. In jedem Element sind die Adressen des nchsten und des vorigen 
Elementes gespeichert und somit verkettet.
	[Kopf-Element1-Element2-Element3-...-ElementX-Schwanz]
Die verschiedenen Elemente werden durch die Klasse TListe erzeugt und verwaltet.
Mit den in TListe enthaltenen Funktionen knnen neue Elemente erzeugt, 
bestehende Elemente gelscht, das Aktuelle Element gelesen, das Aktuelle Element
verndert und hnliche Ttigkeiten ausgefhrt werden.

Weiters ist in der Datei liste_x.h eine Iterator-Klasse enthalten mit der auf
die verschiedenen Elemente einer Klasse zugegriffen werden knnen. Wobei 
beliebig viele Iteratoren initialisiert werden knnen. Um einen Iterator zu 
erstellen mu man ihn zuerst erstellen [ TIterator *I1; ] wobei der Name des
Iterators (hier I1) natrlich beliebig ist. Danach hat man ihn zu 
initialisieren, was mithilfe einer Funktion der Klasse TListe zu geschehen hat
( Iterator_initialisieren (TIterator *Iterator) ). 

		3.2.1 Erstellen und verwalten einer neuen Liste

Will man neue Liste erstellen, mu man zuerst eine Klasse erstellen die dann in 
die Liste eingebettet werden soll. In unserem Beispiel heit die neue Klasse
[ TPlanet ]. 
Eine neue Liste kann man jetzt mit der Zeile 
[ TListe<TPlanet> Planeten; ]
erstellen. Um Planeten hinzuzufgen sind in der Listenklasse Operatoren 
definiert, die diese Aktion erleichtern. so kann man einen neuen Planeten 
hinzufgen indem man die Zeile 
[ ++Planeten; ]
hinzufgt. Mit dem Operator & kann man auf den neu erstellten Planeten direkt
zugreifen. Hat man in der Klasse TPlanet beispielsweise eine Variable "Masse"
definiert kann man folgendermaen auf diese zugreifen:
[ &Planeten->Masse = 330000000000; ]
Hat man bereits mehrere Planeten erstellt so kann man mit diesem Operator jedoch 
nur auf den zuletzt erstellten zugreifen, jetzt kommt die Iterator-Klasse 
(TIterator) ins Spiel. Zuerst hat man einen Iterator zu erzeugen, was man mit
folgender Zeile zustandebringt:
[ TIterator I1; ]
Natrlich mu der Iterator nicht unbedingt I1 heien, er kann ohne weiteres auch 
Franzi genannt werden. Es knnen, wie schon frher erwhnt beliebig viele 
Iteratoren definiert werden. Um den Iterator jetzt auch verwenden zu knnen 
mu man ihn initialisieren. Das geschieht folgendermaen:
[ Planeten.Iterator_initialisieren (&I1); ]
Wird ein neuer Planet erstellt oder ein alter weggelscht, so mu der Iterator 
neu initialisiert werden. In der Iterator-Klasse (TIterator) habe ich einige 
Funktionen programmiert mit denen der Iterator vernnftig verwendet werden kann.
So kann er mit der Funktion [ I1=I1.Anfang(); ] auf das erste Element gesetzt 
werden. Wobei alle Iteratoren einer Liste untereinander kompatibel sind, das
heit man kann auch folgende Zeile schreiben: [ I2=I1.Pos(); ] wobei der 
Iterator I2 auf dieselbe Position gesetzt wird an der der Iterator I1 momentan 
steht. Eine weitere Funktion ist I1.Ende(); mit der das letzte Element angezeigt 
wird. Die Funktionen .Anfang(), .Pos(), .Ende() liefern immer eine int-Zahl. 
Der Iterator kann auch mit = auf eine beleibige Position gesetzt werden 
[ I1=...; ]. man kann den Iterato inkrementieren und dekrementieren mit den 
gewohnten Operatoren ++ und -- [++I2;] oder [--I1;]. Um jetzt auf ein Element
der Liste mithilfe des Iterator zuzugreifen mu man folgendermaen vorgehen.
man erhlt die Adresse des gewnschten Planeten mithilfe des Operators >>
[ Adresse=(Planeten>>I1); ] (Wobei Adresse: TPlaneten *Adresse; ist)
Um jetzt auf die Variablen und die Funktionen des einzelnen Planeten zuzugreifen
mu man diese nur noch anreihen, beispielsweise:
[ Wert = (Planeten>>I1)->Masse; ]
genauso kann man die Werte ndern: [ (Planeten>>I1)->Masse=Wert; ]. Selbst=
verstndlicherweise kann nur auf die im public-Teil der Klasse definierten 
Daten und Funktionen zugegriffen werden.

Die Listenklasse hat noch einige Funktionen die eher unwichtig sind, auf sie 
will ich hier nicht nher eingehen, da sie auch im Programm Gravitation nicht
verwendet werden.

	3.3 Das Gravitationsprogramm

		3.3.1 Allgemeines

Wie schon ganz zu Beginn erwhnt wird die Kraft zwischen jeweils zwei Planeten
berechnet und mithilfe der Massen in eine Beschleunigung umgewandelt. Die 
aktuelle Geschwindigkeit des Planeten wird um die Beschleunigung verndert. 
indem man jetzt die Geschwindigkeit mit der eingestellten Zeit multipliziert
kommt man auf die Entfernung die der Planet whrend dieser Zeit zurcklegt.

		3.3.2 Beliebig viele Planeten

Fr die Programmierung des Programmes bestanden mehrere Probleme. Eines der 
Probleme war, da nicht nur zwei Planeten vorhanden waren, sondern, da das 
Programm auch fr beliebig viele andere Planeten klaglos funktionieren sollte.

Dazu wird im Programm fr jeden Planeten berechnet, welchen Einflu die anderen
Planeten haben. Nachdem diese Berechnungen fr jeden Planeten ausgefhrt 
worden sind, werden die daraus resultierenden Beschleunigungen einberechnet.
Danach wird die Planetenbewegung aller Planeten fr die eingestellte Zeit
berechnet. 

Damit die nderungen eines Planenten sich schon auf die anderen Planeten aus=
wirken bevor auch die anderen Planeten verndert worden sind, habe ich eine 
zweite Liste eingefhrt in der die nderungen vermerkt werden. Sind dann die 
nderungen fr alle Planeten durchgerechnet, dann werden die notierten 
nderungen in die Daten des Planeten eingerechnet. 

		3.3.3 Drei Koordinatenachsen

Die ganz zu Beginn des Artikels erwhnte Formel von Newton mu fr die 
Aufgabenstellung wie sie sich hier gestellt hat adaptiert werden, da die 
Kraft F die man als Ergebnis der Gleichung bekommt in die Richtung des anderen
Planeten zeigt. Damit kann man natrlich nicht viel anfangen. Mein Programm
spaltet die Kraft F in drei Teilkrfte entlang jeder der Koordinatenachsen auf. 
Mithilfe der Masse wird dann eine Beschleunigung in jede einzelne der Ko=
ordinatenachsen ermittelt. Daraus lt sich dann die nderung der Geschwindig=
keit in jede Richtung errechnen. Mit der Zeit verknpft kann man dann die 
Positionsnderung fr jede der drei Koordinaten berechnen.

		3.3.4 Die Zeit

Die Genauigkeit mit der Planetenbahnen hngt sehr stark von der Zeit ab die 
zwischen den Berechnungen liegt. In meinem Programm kann man die Zeit in 
vielfachen von Sekunden angeben (zB. 0.0001 oder 3600). Auerdem kann eine
statische oder eine dynamische Zeitbasis gewhlt werden.

Fr jedes spezielle Problem mu man sich berlegen welche Zeitbasis am 
gnstigsten ist. Die Bewegung der Erde um die Sonne knnte bespielsweise 
mit einer Zeitbasis von 86400 berechnet werden (86400 s sind ein Tag). Fr
die Bewegung des Mondes um die Erde wird dieser Wert schon fast zu gering, da 
der Mond ja doch nur eine Umlaufzeit von ca. 28 Tagen um die Erde hat, hier 
wre eine Zeitbasis von 1 h (=3600s) vielleicht gnstiger. 
[ Uni.ZeitQuantDauer_setzen (STATISCH, 3600, 3600); ]
Auerdem kann man die Zeit noch dynamisch regeln lassen, das funktioniert aber 
noch nicht so ganz wie ich es gerne htte, der Ansatz ist aber schon vorhanden.
Bei der dynamischen Zeitregelung kann man eine ober und eine Untergrenze 
festlegen zwischen denen sich die Zeitdauer verndern kann. 
[ Uni.ZeitQuantDauer_setzen (DYNAMISCH, 0.05, 8600); ]

		3.3.5 Neue Planeten, andere Daten

Will man einen neuen Planeten erzeugen sind in der Prozedur folgende Zeilen 
hinzuzufgen:
[ Uni.Planet_erzeugen(); ]
[ (&Uni.Planeten)->benennen ("Venus"); ]  Planetenname
[ (&Uni.Planeten)->Masse = 500E15; ]      Planetenmasse in kg
[ (&Uni.Planeten)->Koordinaten->x = 190E8; ]     
[ (&Uni.Planeten)->Koordinaten->y = 780E9; ]     
[ (&Uni.Planeten)->Koordinaten->z = 9E11; ]      
[ (&Uni.Planeten)->Geschwindigkeit->x = 996; ]      
[ (&Uni.Planeten)->Geschwindigkeit->y = 921.558E2; ]      
[ (&Uni.Planeten)->Geschwindigkeit->z = 11E2; ]      
[ (&Uni.Planeten)->Radius = 6E6; ]	Radius in m (hat keinen Einflu)
[ (&Uni.Planeten)->Farbe = 5; ]	 	Farbe in der der Planet dargestellt 
					wird

Momentan sind im Programm folgende Himmelskrper programmiert:
Die Sonne an der Position 0 im Universum und mit der Geschwindigkeit 0. 
Die Erde und der Mond mit jeweils Position, Geschwindigkeit und Masse, die 
so genau sind wie ich sie aus diversen Bchern herauslesen habe knnen, wobei
sich die Daten in den verschiedenen Bchern ein bischen unterscheiden. 
Ein Komet der in der Sonne verglhen oder die Erde zerstren wrde, wenn
diese mglichkeit im Programm vorgesehen wre. Kollisionen habe ich nicht
programmiert (um die Erde vorerst vom Untergang zu bewahren).

		3.3.6 Ergnzungen

Ich habe es komischerweise nicht geschafft eine funktionierende Graphikausgabe 
fr dieses Programm mit den Borland-C++-Befehlen der Header-Datei graphics.h
zu programmieren. Aus diesem Grund habe ich mir schnell ein paar einfache 
routinen selbst programmiert (bsp: Darstellung eines Pixels am Bildschirm, 
Fllen des Bildschirmes). Aus diesem Grund wird das Programm in einem DOS-Fenster
unter WINDOWS wahrscheinlich nicht funktionieren. 

