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.

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.

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