Wir haben uns heute als Gruppe zusammen gefunden und erste vorbereitungen getroffen. Zuerst haben wir uns darauf geeinigt das wir die Begriffe und Variablen in Deutsch benennen. Als nächstes haben wir mit ersten Konzeptzeichnungen und der Programierung der ersten Klassen angefangen. Nun haben wir uns auf die Einheiten der physikalischen Größen geeinigt (z.b. wir rechnen in Metern und nicht Kilometern). Dann haben wir die ersten Aufgaben eingeteielt und haben angefangen diese zu bearbeiten.

Erste Klasse:

	class Welt(object):
		gravitationskonstante = 6.673 * 10**(-11)			#Gravitationskonstante
		Liste_der_Objekte = []
 
 
		def berechne_Gravitationskraft(self,objekt1,objekt2):
			"""
			Gibt die Gravitationskraft aus, die zwischen den Objekten "objekt1" und "objekt2" herrscht
			"""
			abstand = ((objekt1.Koordinaten[0]-objekt2.Koordinaten[0])**2+(objekt1.Koordinaten[1]-objekt2.Koordinaten[1])**2+(objekt1.Koordinaten[2]-objekt2.Koordinaten[2])**2)**0.5
			F = self.gravitationskonstante * objekt1.Masse * objekt2.Masse / abstand**2
			return F
 
		def objekt_hinzufuegen(self,objekt):
			"""
			Fuegt der Welt ein Objekt hinzu
			"""
			self.Liste_der_Objekte.append(objekt)
 
		def objekt_als_Satellit_hinzufuegen(self,objekt,satellit,abstand):
			"""
			Fuegt ein Objekt ("satellit" genannt) in die Welt ein, welches sich
			um ein anderes Objekt ("objekt" genannt) dreht. Es ist dabei in einem stabilen Orbit.
			der Abstand ("abstand" genannt) ist dabei der Abstand zwischen den Mittelpunkten.
			Ansatz: F_g = F_r
			Nach aufloesung erhaelt man: v = sqrt(gravitationskonstante*masse_objekt/abstand)
			"""
			satellit.Geschwindigkeit = (self.gravitationskonstante*objekt.Masse/abstand)**0.5
			satellit.Koordinaten = [objekt.Koordinaten[0]+abstand,0,0]
			satellit.Geschwindigkeitsvektor = [0,satellit.Geschwindigkeit,0]
			self.objekt_hinzufuegen(satellit)
 
 

Da wir die Simulation im Raum (2 oder 3 Dimensional) haben wollen mussten wir den bisherigen Code auf Vektoren umstellen, dafür haben wir beschlossen das Numpy Modul zu verwenden. Zum Schluss haben wir einen groben Plan zur Ortsberechnung erstellt.
Als Ziel für nächste Woche haben wir uns gesetzt, dass sich jeder an der Umsetzung der Ortsberechnung versucht. Unser Plan ist es dies am nächsten Donnerstag zusammenzutragen.

Wir haben unsere Ergebnisse zusammengetragen und einen ersten Test im Erde-Mond System durchgeführt. Dies war noch ohne grafische Umsetzung, allerdings haben wir dabei schon ein großes Problem erkannt: Die Umsetzung der Zeitschritte. Dadurch hatten wir einen leichte Abweichung und der Mond hat sich immer weiter von der Erde entfernt. Trotzdem haben wir viel erreicht, zum Beispiel konnten wir ein Vektorproblem lösen und damit haben wir nun eine Funktion zum Ausrechnen des Ortes auf Basis der wirkenden Kräfte.

• Unser bisheriges Projekt

Heute haben wir uns mit dem Runge-Kutta-Verfahren beschäftigt. Das war so kompliziert, dass wir es nach 2 Stunden intensivem überlegen aufgegeben haben und uns für das Leapfrog-Verfahren entschieden haben, welches nicht so genau wie das Runge-Kutta-Verfahren ist, aber für unser Projekt genaugenug ist. Allerdings war der Code noch etwas fehlerhaft, so dass wir diesen erstmal berichtigen mussten. Das hat uns den Rest der Zeit gekostet.

Heute war das erste mal in diesem Jahr, weshalb wir uns erstmal wieder einarbeiten mussten. Nach einer Weile haben wir festgestellt, dass die Berechnung der Kräfte fehlerhaft war. Dies haben wir behoben. Der Minuend und der Subtrahend waren vertauscht. Desweiteren haben wir eine erste graphische Darstellung erstellt. Dadurch konnten wir sehen, dass die Werte einigermaßen passend sind und unsere Überlegungen richtig waren.

• Unser Projekt mit dem ersten graphischen Ansetzen

Heute war unser Ziel das Leapfrog Verfahren zu implementieren. Das haben wir nicht sofort geschafft. Nach zwei Stunden hat Stefan drauf geschaut und sofort den Fehler gesehen. Diesen haben wir behoben und jetzt funktioniert es schon fast zu gut, der Abstand des Mondes ändert sich nach etwa einer Umdrehung um nichtmal einen Meter. Das ist uns genau genug, weshalb wir dieses Verfahren benutzen werden.

Unsere Umsetzung des Leapfrog-Verfahrens:

	def leapfrog(self,zeitschritt,welt):
		ort_zwischen = self.ort + self.v * (zeitschritt/2.0)
		self.ort = ort_zwischen
		a_zwischen = self.berechne_beschleunigung(welt)
		self.v = self.v + a_zwischen * zeitschritt
		self.ort = ort_zwischen + self.v * (zeitschritt/2.0)
		return self.ort

Heute war ein erfolgreicher Tag! Wir haben eine grafische Darstellung erarbeitet. Es wird erst die vorgegebene Simulation durchgerechnet, die Koordinaten werden in eine Liste getan und aus dieser wird dann mit Matplotlib eine Simulation erstellt. Um zu prüfen ob unsere programmierte Physik auch Einwirkung auf das System hat haben wir spaßeshalber einen zweiten Mond um die Erde kreisen lassen. Dieser zweite Mond und der erste haben sich gegenseitig sehr schnell aus der Bahn gebracht, wodurch wir erkannten das die Physik zumindest etwas bewirkt.

• Die graphische Umsetzung

Nachdem wir letzte Woche grafisch die Erde und den Mond simuliert haben, sind wir heute einen Schritt weiter gegangen und wollten alle Planeten und die Sonne (allerdings noch keinen Mond) grafisch darstellen. Wir haben also einfach die Zeilen von letzter Woche angepasst. Die hat auch recht schnell funktioniert, allerdings mussten wir feststellen dass die Darstellung zumindest für unsere Laptops etwas zu aufwendig ist. Immerhin war sichtbar dass alle Planetenbahnen sehr gut aussehen und die Planeten sich schön um die Sonne bewegen. Da aber die Simulatinsberechnung zu lange dauert haben wir entschieden nur die vier inneren Planeten zu betrachten und die Außeren zu ignorieren, danach war unsere Simulation deutlichst schneller. Leider gab es beim Einfügen des Mondes ein Problem: er hat sich unabhängig von der Erde um die Sonne bewegt. Dies konnten wir noch nicht lösen, deshalb haben wir uns gedacht nächste Woche eine Simulation von 3 Körpern mit ganz einfachen Werten zu schreiben, so dass ein Objekt um ein anderes Objekt rotiert welches wiederum um ein drittes Objekt rotiert.

Da am kommenden Montag die Vorstellung im Wissenschaftsfenster ansteht, haben wir heute die Präsentation erstellt. Wesentliche Änderungen oder Neuerungen am Programm gab es daher nicht.

Am heutigen Tag wurde das Problem mit der Mondbahn noch einmal versucht zu beheben. Der Mond und die Erde haben jetzt zwar die selbe Umlaufbahn um die Sonne, aber der Mond ist immer noch ein wenig zu langsam, beziehungsweise kreist nicht um die Erde, und wird deshalb von der Erde abgehängt. Da das Problem immernoch nicht behoben werden konnte, haben wir beschlossen den Mond aus unserer Simulation raus zu lassen.

Desweiteren wurde versucht die original Positionen der Planeten zu finden und einzufügen, was aus Zeitmangel nicht geschaft wurde.

Heute wurde einen Zeitüberschrift in das Projekt eingefügt, leider läuft die Simulation nicht schnellgenug, wodurch die Zeitüberschrift (noch) etwas schneller als die dazugehörige Simulation läuft. Außerdem wurde ein Anfang für die Einfügung einer Rakete gearbeitet.

Seit Heute fliegt eine Rakete durch unser All. Sie flog anfänglich in die falsche Richtung mit einer viel zu hohen Geschwindigkeit. Woran das lag haben wir noch herausfinden und beheben können.

Wir haben die Rakete zuerst in einem System, in welchem nur die Erde vorhanden ist, implementiert. In diesem System ist heute die Erde von einem Punkt zu einer Kugel mit entschprechendem Erdradius geworden. Nun können wir also sehen ob unsere Rakete in der Simulation eigentlich durch die Erde fliegt. Wir haben voller Begeisterung einige Raketenstarts beobachtet und uns zum Teil über die merkwürdige Flugbahn lustig gemacht. Die Raketenflugbahn wurde optiemiert. Die Originalpositionen der Planeten konnten wir leider aus Zeitgründen nicht mehr einprogrammieren.

Unsere Ergebnisse:

• Das Sonnensystem
• Das Erde-Raketen-System