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:

import numpy as np
import matplotlib.pyplot as plt
 
class Himmelskoerper(object):
 
	Liste_der_Kraefte = []		#die Liste der Kraefte
	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 = 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):
		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)
		self.v = v
		s = v*zeitschritt								#zurueckgelegte Strecke im Zeitintervall
		ort = self.ort + s
		return ort
 
	def leapfrog(self,zeitschritt,welt):
		r = self.berechne_resultierende_Kraft(welt)		#Kraft an aktueller Position
		zwischenposition = berechne_ort(zeitschritt/2)
		originalposition = self.ort
		self.ort = zwischenposition
		a_zwischen = self.berechne_beschleunigung(welt)
		v_neu = self.v + a_zwi
 
 
 
 
#------------------------------------------------------------------------------------------------------------------------------------
 
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 = 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)
 
#------------------------------------------------------------------------------------------------------------------------------------
 
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
bla = mond.ort-erde.ort
print "Erde: "+ str(erde.ort)
print "Mond: "+ str(mond.ort)
erde1_ausgangspunkt_x= erde.ort[0]
erde1_ausgangspunkt_y= erde.ort[1]
mond1_ausgangspunkt_x= mond.ort[0]
mond1_ausgangspunkt_y= mond.ort[1]
print np.linalg.norm(mond.ort-erde.ort)
for i in xrange(660000):
	#erde.ort = erde.berechne_ort(30.0,welt)
	mond.ort = mond.berechne_ort(30.0,welt)
	#print erde.m
	#print np.linalg.norm(mond.v)
blabla = mond.ort-erde.ort
w = np.arccos(np.dot(bla,blabla)/(np.linalg.norm(bla)*np.linalg.norm(blabla)))
print w*360/(2*np.pi)
print "Erde: "+ str(erde.ort)
print "Mond: "+ str(mond.ort)
print np.linalg.norm(mond.ort-erde.ort)
#print a*b
erde2_ausgangspunkt_x= erde.ort[0]
erde2_ausgangspunkt_y= erde.ort[1]
mond2_ausgangspunkt_x= mond.ort[0]
mond2_ausgangspunkt_y= mond.ort[1]
 
x = [erde1_ausgangspunkt_x, mond1_ausgangspunkt_x, erde2_ausgangspunkt_x, mond2_ausgangspunkt_x]
y = [erde1_ausgangspunkt_y,mond1_ausgangspunkt_y,erde2_ausgangspunkt_y,mond2_ausgangspunkt_y]
 
plt.scatter(x,y)
plt.show()