Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen gezeigt.

--- ws1718:raketensimulation [2018/03/23 21:28]
leogummersbach
+++ ws1718:raketensimulation [2018/04/07 20:12] (aktuell)
leogummersbach Physik näher betrachtet, Teil 2
@@ Zeile 1: / Zeile 1: @@
+Kommentar von Lysanne: \\
+Ihr habt in eurer Doku den Verlauf des Projektes sehr eng mit dem geforderten Theorieteil verbunden, was den Verlauf gut nachvollziehbar macht und auch effizient ist.
+Ihr solltet allerdings noch ein wenig genauer auf die konkreten physikalischen und mathematischen Modelle eingehen, also zum Beispiel die physikalischen Formeln für die Berechnungen mit anfügen.
+Auch für eine genauere Erläuterung des von euch verwendeten Leapfrog-Verfahrens an eurem Beispiel wären andere Studis sicher dankbar. Gut wäre in dem Zusammenhang vielleicht auch nochmal eine kurze Erläuterung, warum das Eulerverfahren nicht zufriedenstellend war.
+Auch ein paar Worte über die Graphik unter Matplotlib sollten vielleicht noch ergänzt werden.
+Es sind auch ein paar kleinere Rechtschreib- und Kommafehler drin. Wir geben euch dafür keine Abzüge, aber in anderen akademischen Zusammenhängen wurd darauf geachtet.
+Vielleicht könnt ihr die Doku noch ein wenig mit konkreter Mathematik und Physik auskleiden, sodass man das nicht alles dem Code oder Wikipedia (Leapfrog) entnehmen muss? Ansonsten ist es eine gute Doku, bei der man sieht, dass ihr euch intensiv mit dem Thema auseinander gesetzt habt.
 ======Raketensimulation======
-Das Ziel unseres Projektes war, eine Rakete, unter Berügsichtigung der Naturgesetze, von der Erde starten zu lassen, wobei die Rakete durch die Anziehungskräfte der Planeten beeinflusst werden soll.
+Das Ziel unseres Projektes war es, eine Rakete von der Erde starten zu lassen, wobei die Rakete durch die Anziehungskräfte der Planeten beeinflusst werden soll.
 **Folgende Personen haben an dem Projekt mitgearbeitet:**
@@ Zeile 15: / Zeile 29: @@
 Man hat die Erde, legt die Startposition einer Rakete sowie Werte für Beschleunigung, Masse, usw. fest und Simuliert dann graphisch
 die Flugbahn der Rakete und wie diese von anderen Himmelskörpern beeinflusst wird. Das ganze wird erst mal auf einfachster Basis
-zweidimensional oder auch dreidimensional umgesetzt, später kann man noch verschiedene Planeten hinzufügen. Als Beispielmission wäre dann möglich dass man eine
+zweidimensional oder auch dreidimensional umgesetzt, später kann man noch verschiedene Planeten hinzufügen. Als Beispielmission wäre eine Rakete möglich, die von der Erde losfliegt und dann am Mars in einen stabilen Orbit kommt.
-Rakete konstruiert die von der Erde losfliegt und dann am Mars in eine stabilen Orbit kommt.
 Über die Art der graphischen Umsetzung müsste noch entschieden werden (z.B. Turtle oder andere Programme die besser geeignet wären)
 Relativität wird erst mal nicht mit einfließen, das wäre zu schwer.
@@ Zeile 32: / Zeile 45: @@
 Literatur und Hilfsmittel:
-  * Die vom Projetleiter vorgegebenen Seiten zum erlernen der Sprache Python\\
+  * Die vom Projetleiter vorgegebenen Seiten zum Erlernen der Sprache Python\\
   * Für die Physik:\\
     * Schultafelwerk\\
@@ Zeile 62: / Zeile 75: @@
-Einführung\\
 In unserem Projekt haben wir uns mit der Idee beschäftigt, eine Rakete in unserem Sonnensystem fliegen zu lassen. Wir wollten anfänglich eine Rakete gezielt von einem Planeten, nämlich der Erde, zu einem beliebigen anderen Planeten in unserem System schicken. Dazu mussten wir uns zuerst einmal mit den Planeten in unserem Sonnensystem auseinander setzen, welche Kräfte auf diese einwirken und wie sie um die Sonne kreisen. Um das in ein Programm zu bekommen mussten wir uns auch überlegen, wie welche physikalischen Eigenschaften auf unser System wirken und vor allem wie wir diese ausrechnen lassen können. Das Problem der Berechnung war uns anfänglich gar nicht so bewusst.
-Verlauf:\\
+**Verlauf**\\
-In den ersten Wochen haben wir uns mit Python vertraut gemacht. Dann ist die Entscheidung für eine Raketensimulation gefallen. Wir haben damit angefangen, dass wir die Physik nach bestem Wissen und Gewissen einprogrammiert haben. Danach konnten wir schon einen Mond um die Erde kreisen lassen. Dies war aber noch zu ungenau, weshalb wir das bisher verwendet Euler-Verfahren gegen das bessere Leapfrog-Verfahren ersetzt haben. Nun haben wir die Erde gegen die Sonne und den Mond gegen die Erde getauscht, sodass man sich im Sonnensystem wiederfand. Danach haben wir die drei anderen inneren Planeten eingefügt. Als letztes haben wir eine Rakete im Erde-Mondsystem starten lassen.
+In den ersten Wochen haben wir uns mit Python vertraut gemacht. Dann ist die Entscheidung für eine Raketensimulation gefallen. Wir haben damit angefangen, dass wir die Physik nach bestem Wissen und Gewissen einprogrammiert haben. Danach konnten wir schon den Mond um die Erde kreisen lassen. Dies war aber noch zu ungenau, weshalb wir das bisher verwendet Euler-Verfahren gegen das bessere Leapfrog-Verfahren ersetzt haben. Nun haben wir die Erde gegen die Sonne und den Mond gegen die Erde getauscht, sodass man sich im Sonnensystem wiederfand. Danach haben wir die drei anderen inneren Planeten eingefügt. Als letztes haben wir eine Rakete im Erde-Mondsystem starten lassen.
+**Die physikalischen Eigenschaften**\\
+Zuerst haben wir uns überlegt welche Kräfte in unserem Sonnensystem wirken. Wir haben beschlossen die Relativität nicht zu berücksichtigen. Außerdem haben wir festgestellt dass wir die wirkende Gravitation zwischen den Objekten in Vektorform benötigen, woraufhin wir dies so eingefügt haben. Die Berechnung sieht folgendermaßen aus:
+  - Es wird zu jedem anderen Objekt in der Welt die Gravitationskraft berechnet
+  - Daraus wird dann eine resultierende Kraft berechnet, indem alle Gravitationskräfte in Vektorform addiert werden
+  - Mit bestehenden Werten (Masse, Ort, Geschwindigkeit, Beschleunigung) wird der nächste Ort berechnet, wobei natürlich auch die Geschwindigkeit und die Beschleunigung aktualisiert werden. Die Berechnung funktioniert folgendermaßen:
+    * **Beschleunigung:**\\ Da Kraft gleich Masse mal Beschleunigung ist, folgt aus //F = a*m// die Gleichung //a = F/m//. Im Code wird //r// anstatt //F// geschrieben, da es sich dort um die resultierende Kraft handelt. Desweiteren wird //self.m// anstatt //m// geschrieben, weil die Masse des Objekts in der Klasse gespeichert ist.
+    * **Geschwindigkeit:**\\ Es gilt //v = a*t//. Anstelle von //t// wird im Code //zeitschritt// geschrieben. Es wird //self.v + v//, also die alte und neu berechnete Geschwindigkeit addiert, ausgegeben.
+    * **Ort:**\\ Laut dem ersten Newtonschen Gesetz bleibt die Geschwindigkeit eines Körpers unverändert bis eine Kraft auf ihn einwirkt. Deshalb ist es wichtig dass die Geschwindigkeit als fester Wert in der Klasse gespeichert wird. Dies geschiet mit //self.v = v//. Mit der Formel //s = v*t// wird die in der Zeit //t// zurückgelegte Strecke berechnet. Es wird wieder //zeitschritt// im Code anstatt von //t// geschrieben. Wieder muss der alte Ort addiert mit dem neu berechneten Ort ausgegeben werden.
+  - Am Ende wird das "Leapfrog-Verfahren" angewendet, wodurch der nächste Ort deutlich genauer ist. Bei diesem Verfahren wird zunächst eine Zwischenprognose nach einem halben Zeitschritt berechnet. Ausgehend von dieser wird dann eine Geschwindigkeit berechnet, bei der allerdings die alte Geschwindigkeit und die Beschleunigung der Zwischenprognose einfließen. Mit dieser neuen Geschwindigkeit wird dann der Ort nach einem weiteren halben Zeitschritt berechnet. Somit kommt man auf einen ganzen Zeitschritt, das Ergebnis ist jedoch wesentlich genauer.
+{{:ws1718:raketensimulation:leapfrog_verfahren_prinzip.png?nolink&800|}}
+{{:ws1718:raketensimulation:leapfrog_verfahren_kreisbahn.png?nolink&800|}}
+<code python>
+	def berechne_gravitationskraft(self,objekt1):
+		"""
+		Gibt die Gravitationskraft aus, die zwischen den Objekten "objekt1" und "objekt2" herrscht
+		Das Ergebnis wird als Vektor ausgegeben, immer in Richtung von objekt1 bis objekt2
+		"""
+		verbindungsvektor = self.ort-objekt1.ort
+		betrag = np.linalg.norm(verbindungsvektor)
+		F_betrag = (welt.gravitationskonstante * objekt1.m * self.m)/betrag**2
+		F = (F_betrag/betrag)*verbindungsvektor
+		return F
+	def berechne_kraefte_neu(self,welt):
+		"""
+		Aktualisiert die Werte in der Liste der Kraefte, indem alle Werte neu berechnet werden
+		"""
+		self.Liste_der_Kraefte = []
+		for i in welt.Liste_der_Objekte:
+			if i.name != self.name:
+				k = i.berechne_gravitationskraft(self)
+				self.Liste_der_Kraefte.append(k)
+	def berechne_resultierende_Kraft(self,welt):
+		"""
+		Aus der Liste der Kraefte wird eine resultierende Kraft in Form eines Vektors berechnet
+		"""
+		self.berechne_kraefte_neu(welt)
+		r = np.array([0.0,0.0,0.0])			#resultierende Kraft
+		for i in self.Liste_der_Kraefte:
+			r = r + i
+		return r
+	def berechne_beschleunigung(self,welt):
+		"""
+		Aus der resultierende Kraft wird mit der Masse die Beschleunigung berechnet
+		"""
+		r = self.berechne_resultierende_Kraft(welt)
+		a = r/self.m
+		return a
+	def berechne_geschwindigkeitsvektor(self,zeitschritt,welt):
+		"""
+		Aus der Beschleunigung wird mit dem uebergebenen Zeitschritt der Geschwindigkeitsvektor berechnet
+		"""
+		a = self.berechne_beschleunigung(welt)
+		v = a*zeitschritt
+		return self.v + v					#alte und neue Geschwindigkeit addiert
+	def berechne_ort(self,zeitschritt,welt):
+		"""
+		Nun wird wieder mithilfe des Zeitschrittes aus der Geschwindigkeit die zurueckgelegte Strecke berechnet und daraus folgt dann der neue Ort
+		"""
+		v = self.berechne_geschwindigkeitsvektor(zeitschritt,welt)
+		self.v = v
+		s = v*zeitschritt								#zurueckgelegte Strecke im Zeitintervall
+		ort = self.ort + s
+		return ort
+	def leapfrog(self,zeitschritt,welt):
+		"""
+		Die Methode berechne_ort ist eigentlich schon ausreichend, allerdings gibt es Probleme mit der Genauigkeit.
+		Hier wird das geloest, indem das Leapfrog Verfahren angewendet wird.
+		"""
+		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
+</code>
+**Die Objekte**\\
+Als nächstes haben wir uns überlegt wie wir unsere Planeten in das System bekommen. Über die Klasse Welt und deren Methoden konnten wir zuerst nur Objekte ohne "Wirkung" hinzufügen.
+<code python>
-Die physikalischen Eigenschaften:\\
+class Welt(object):
-Zuerst haben wir uns überlegt welche Kräfte in unserem Sonnensystem wirken. Dann haben wir beschlossen die Relativität nicht zu berücksichtigen. Wir haben festgestellt dass wir die wirkende Gravitation zwischen den Objekten in Verktorform benötigen, woraufhin wir dies so eingefügt haben.
+	gravitationskonstante = 6.673 * 10**(-11)			#Gravitationskonstante
+	Liste_der_Objekte = []
-======Quelltext======
-Dann haben wir mit Hilfe der Gravitationskonstanten und den gegebenen Werten (Masse, Startentfernung und Zeitschritt) einen Richtungsvektor berechnet.
-======Quelltext======
+	def objekt_hinzufuegen(self,objekt,ort):
+		"""
+		Fuegt der Welt ein Objekt hinzu
+		"""
+		self.Liste_der_Objekte.append(objekt)
+		objekt.ort = ort
+	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.v = np.array([0.0,(self.gravitationskonstante*objekt.m/abstand)**0.5,0.0])
+		ort = objekt.ort + np.array([abstand,0,0])
+		self.objekt_hinzufuegen(satellit,ort)
-Zu guter Letzt haben wir anhand dieses Richtungsvektors eine Bewegung erwirkt.
+</code>
-======Quelltext======
+Durch eine for-Schleife haben wir die Gravitation zwischen den Objekten immer wieder neu berechnen lassen, wodurch sie sich kreisend um die Sonne bewegen.
-Die Objekte:\\
+<code python>
-Als nächstes haben wir uns überlegt wie wir nun unsere Planeten in das System bekommen. Über die Klasse Welt und deren Methoden konnten wir zuerst nur Objekte ohne "Wirkung" hinzufügen.
-======Quelltext======
+for i in xrange(100):
+	merkur.ort = merkur.leapfrog(Zeit,welt)
+	venus.ort = venus.leapfrog(Zeit,welt)
+	erde.ort = erde.leapfrog(Zeit,welt)
+	mars.ort = mars.leapfrog(Zeit,welt)
+	ort0 = ax.plot3D(np.array([merkur.ort[0]]),np.array([merkur.ort[1]]),np.array([merkur.ort[2]]),'b.')
+	merkurbahn.append(ort0)
+	ort0 = ax.plot3D(np.array([venus.ort[0]]),np.array([venus.ort[1]]),np.array([venus.ort[2]]),'r.')
+	venusbahn.append(ort0)
+	ort0 = ax.plot3D(np.array([erde.ort[0]]),np.array([erde.ort[1]]),np.array([erde.ort[2]]),'b.')
+	erdbahn.append(ort0)
+	ort0 = ax.plot3D(np.array([mars.ort[0]]),np.array([mars.ort[1]]),np.array([mars.ort[2]]),'r.')
+	marsbahn.append(ort0)
-Durch eine for-Schleife haben wir die Gravitationskraft zwischen den Objekten immer wieder neu berechnen lassen, wodurch sie sich kreisend um die Sonne bewegen.
+</code>
-Fazit:\\
+**Fazit**\\
-Abschließend ist festzustellen, dass so ein Projekt egal wie leicht es anfänglich wirkt und wie gut man glaubt mit dem Thema umgehen zu können doch sehr komplex und zeitaufwendig werden kann, und in unserem Fall auch geworden ist. Nichts desto trotz hat die Arbeit Spaß gemacht, vor allem dann wenn ein Problem behoben werden konnte oder ein großer Schritt in dem Projekt geschafft wurde. Zu unserm Projekt im Speziellem bleibt zu sagen, dass wir eine Menge im Bereich der Kreisbahnberechnung gelernt haben und dass wir sehr zufrieden mit dem Ergebnis sind, auch wenn wir nicht fertig wurden.
+Abschließend ist festzustellen, dass so ein Projekt egal wie leicht es anfänglich wirkt und wie gut man glaubt mit dem Thema umgehen zu können doch sehr komplex und zeitaufwendig werden kann, und in unserem Fall auch geworden ist. Nichts desto trotz hat die Arbeit Spaß gemacht, vor allem dann wenn ein Problem behoben werden konnte oder ein großer Schritt in dem Projekt geschafft wurde. Zu unserm Projekt im Speziellen bleibt zu sagen, dass wir eine Menge im Bereich der Kreisbahnberechnung gelernt haben und dass wir sehr zufrieden mit dem Ergebnis sind, auch wenn wir nicht fertig wurden.
-Das Ergebnis sind zwei ähnliche, wenn auch verschiedene Programme. Zum einen gibt es die eigentliche Raketensimulation, in der es aber nur die Rakete und die Erde als Objekte gibt. Zum anderen gibt es noch eine Simulation des inneren Sonnensystems. In der Zukunft könnte man Versuchen, diese beiden Teile zu einem zu verbinden. Ob dies sinnvoll ist bleibt allerdings offen, da sich die Bewegung einer Rakete und die von Planeten in ganz anderen Zeitdimensionen abspielen.
+Das Ergebnis sind zwei ähnliche, wenn auch verschiedene Programme. Zum einen gibt es die eigentliche Raketensimulation, in der es aber nur die Rakete und die Erde als Objekte gibt. Zum anderen gibt es noch eine Simulation des inneren Sonnensystems. In der Zukunft könnte man versuchen, diese beiden Teile zu einem zu verbinden. Ob dies sinnvoll ist bleibt allerdings offen, da sich die Bewegung einer Rakete und die von Planeten in ganz anderen Zeitdimensionen abspielen.
   * [[ws1718:Raketensimulation:Modulliste]]
   * {{:ws1718:raketensimulation:erde_und_rakete.zip|}}
   * {{:ws1718:raketensimulation:inneres_sonnensystem.zip|}}

Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Unterschiede

Seiten-Werkzeuge