Mathesis Wiki

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
======Protokoll am 14.12.17======

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:

<code python>

import numpy as np

class Himmelskoerper(object):
	
	Liste_der_Kraefte = [np.array([0.0,1.0,0.0]),np.array([0.0,2.0,0.0]),np.array([1.0,0.0,3.0]),np.array([1.0,2.0,0.0])]		#die Liste der Kraefte gefuellt mit Beispielen
	m = 1.0
	v = np.array([0.0,0.0,0.0])
	ort = np.array([0.0,0.0,0.0])
	name = ""
	
	def __repr__(self):
		return self.name
		
	def __init__(self,name,m):
		self.name = name
		self.m = m

	
	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 = objekt1.ort-self.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):
		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):
		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):
		r = self.berechne_resultierende_Kraft(welt)
		a = r/self.m
		return a
		
	def berechne_geschwindigkeitsvektor(self,zeitschritt,welt):
		a = self.berechne_beschleunigung(welt)
		v = a*zeitschritt
		return self.v + v					#alte und neue Geschwindigkeit addiert
		
	def berechne_ort(self,zeitschritt,welt):
		v = self.berechne_geschwindigkeitsvektor(zeitschritt,welt)
		s = v*zeitschritt								#zurueckgelegte Strecke im Zeitintervall
		ort = self.ort + s
		return ort
		
#------------------------------------------------------------------------------------------------------------------------------------

class Planet(Himmelskoerper):
	
	Abstand_zur_Sonne = 0
	min_Temperatur = 0
	max_Temperatur = 0
	Umlaufperiode = 0
	Rotationsperiode = 0
		

		
#------------------------------------------------------------------------------------------------------------------------------------
	

class Welt(object):
	                       
	gravitationskonstante = 6.673 * 10**(-11)			#Gravitationskonstante
	Liste_der_Objekte = []

	


	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 = (self.gravitationskonstante*objekt.m/abstand)**0.5
		ort = objekt.ort + np.array([abstand,0,0])
		self.objekt_hinzufuegen(satellit,ort)

#------------------------------------------------------------------------------------------------------------------------------------

erde = Planet("Erde",5.972E24)
mond = Planet("Mond",7.35E22)
welt = Welt()
welt.objekt_hinzufuegen(erde,np.array([0.0,0.0,0.0]))
welt.objekt_als_satellit_hinzufuegen(erde,mond,384400000.0)
print erde.ort
print mond.ort
a = mond.ort-erde.ort
for i in xrange(2200000):
	erde.ort = erde.berechne_ort(1.0,welt)
	mond.ort = mond.berechne_ort(1.0,welt)
	#print "Erde: "+ str(erde.ort)
	#print np.linalg.norm(mond.ort-erde.ort)
	print i/100000.0
b = mond.ort-erde.ort
print np.arccos(np.dot(a,b)/(np.linalg.norm(a)*np.linalg.norm(b)))
#print a*b


</code>
Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
