so ich habe ein etwas gröberes Problem. Ich habe schon eine ganze Menge möglichkeiten ausprobiert aber dennoch vielleicht weiss hier jemand Rat:
Es ist so das ich ein "Programm" geschrieben habe, bzw angefangen, mit welchem Kepler Ellipsen ausgerechnet werden sollten.
Das Problem ist jetzt bei der Rechnung. Es werden merkwürdige Zahlenwerte ausgegeben, die eigentlich überhaupt nicht angehen können.
Ich stelle mal das ganze skript rein.
Nebenbei, der Button wird einfach ausgeführt obwohl ich ihn nie angeklickt habe o.ä.
Aber die Rechnung ist wichtiger;
Code: Alles auswählen
# -*- coding: cp1252 -*-
from Tkinter import *
from Formeln import *
from cmath import *
from re import *
from array import *
def rechnung():
M2 = entryMDHO.get() #'ab Hier werden sich neue Werte gekrallt
Xpos = entryXposition.get()
Ypos = entryYposition.get()
Xvel = entryXgeschwindigkeit.get()
Yvel = entryYgeschwindigkeit1.get()
f = entryGravitationskonstante.get()
WerteSpeicher = {} #Dient zum abspeichern der Zwischenergebnisse um direkt auf diese Variablen zugreifen zu können,
#PosRech1 = (float(Ypos) ** 2) + (float(Xpos) ** 2) #Hier soll der Wert ausgerechnet werden um den Radius von dem GRavitationsobjekt zu sehen
for i in xrange(100): # Durchgänge in Sekunden
if i == 0: # Diese Bedingung muss sein, damit einmal alle Variablen einen Wert bekommen haben und diese Werte auch im DIctionary "WerteSpeicher" abgespeihchert sind damit die
#zweite Schleife mit den Werten richtig umgehen kann.
PosRech = (float(Ypos) ** 2) + (float(Xpos) ** 2) #Hier soll der Wert ausgerechnet werden um den Radius von dem GRavitationsobjekt zu sehen
rabsta = sqrt(PosRech)
abesch = beschleunigunga (float(f), rabsta, float(M2))
ybesch = beschleunigungy (abesch, float(Ypos), rabsta) #AUsrechnung aller Variablen die man braucht
xbesch = beschleunigungx (abesch, float(Xpos), rabsta)
xveloc = geschwindigkeitsaenderungx (xbesch, i)
yveloc = geschwindigkeitsaenderungy (ybesch, i)
vrelat = relativgeschwindigkeit (xveloc, yveloc)
neuesvx = xveloc
neuesvy = yveloc #Geschwindigkeitsberechnungsänderung
WerteSpeicher['RadiusR'] = rabsta
WerteSpeicher['BeschleunigungA'] = abesch
WerteSpeicher['BeschleunigungY'] = ybesch #An dieser Stelle wird das erste mal der Dicionairy gefüllt!
WerteSpeicher['BeschleunigungX'] = xbesch
WerteSpeicher['GeschwindigkeitX'] = xveloc
WerteSpeicher['GeschwindigkeitY'] = yveloc
WerteSpeicher['RelativeGeschwindigkeit'] = vrelat
WerteSpeicher['YPosition'] = float(Ypos) # Um das erste mal eine YPosition zu speichern die dann in der anderen schleife weiter fortgeführt wird.
WerteSpeicher['XPosition'] = float(Xpos) # Um das erste mal eine XPosition zu speichern die dann in der anderen schleife weiter fortgeführt wird.
anzeigetafel.insert(END, 'ABSTAND R=>'+ str(rabsta) + " \n")
anzeigetafel.insert(END, 'BESCHLEUNIGUNG A=>'+ str(abesch) + "\n")
anzeigetafel.insert(END, 'BESCHLEUNIGUNGY=>'+ str(ybesch) + "\n")
anzeigetafel.insert(END, 'BESCHLEUNIGUNGX=>'+ str(xbesch) + "\n") #Ausgabe der Werte
anzeigetafel.insert(END, 'GESCHWINDIGKEITX=>'+ str(neuesvx) + "\n")
anzeigetafel.insert(END, 'GESCHWINDIGKEITY=>'+ str(neuesvy) + "\n")
anzeigetafel.insert(END, 'GESCHWINDIGKEITRELA=>'+ str(vrelat) + "\n")
if i > 0:
anzeigetafel.insert(END, 'XPOSITION=>'+ str(XposNeu) + "\n")
anzeigetafel.insert(END, "---------------\n")
else:
PosRech2 = ((WerteSpeicher.get('YPosition', 'FEHLER NICHT GEFUNDEN')) ** 2) + ((WerteSpeicher.get('XPosition', 'FEHLER NICHT GEFUNDEN')) ** 2) #Berechnung der Position um den Radius r zu berechnen
rabsta = sqrt(PosRech2)
WerteSpeicher['RadiusR'] = rabsta # Hier wird der neue Radius in die SpeicherDictionary eingetragen. Folgender Vorteil, alle folgenden Elemente haben gleich einen aktuellen Radius r.
abesch2 = beschleunigunga (float(f), WerteSpeicher.get('RadiusR', 'FEHLER NICHT GEFUNDEN'), float(M2)) # Die neue Beschleunigung a
WerteSpeicher['BeschleunigungA'] = abesch2 # Aktualisierung der Beschleunigung
ybesch2 = beschleunigungy (WerteSpeicher.get('BeschleunigungA', 'FEHLER NICHT GEFUNDEN'), WerteSpeicher.get('YPosition', 'FEHLER NICHT GEFUNDEN'), WerteSpeicher.get('RadiusR', 'FEHLER NICHT GEFUNDEN'))
#Berechnung der Y Beschleunigung mithilfe der in der "WerteSpeicher" abgespeicherten Daten
WerteSpeicher['BeschleunigungY'] = ybesch2 #Aktualisierung der Werte
xbesch2 = beschleunigungy (WerteSpeicher.get('BeschleunigungA', 'FEHLER NICHT GEFUNDEN'), WerteSpeicher.get('XPosition', 'FEHLER NICHT GEFUNDEN'), WerteSpeicher.get('RadiusR', 'FEHLER NICHT GEFUNDEN'))
#Das gleiche wie bei der YBeschleunigung
WerteSpeicher['BeschleunigungX'] = xbesch2 #Aktualisierung des Wertes
xveloc2 = geschwindigkeitsaenderungx (WerteSpeicher.get('BeschleunigungX', 'FEHLER NICHT GEFUNDEN'), i)
#GEschwindigkeit in X Richtung. Wichtig für die Positionsänderung
WerteSpeicher['GeschwindigkeitX'] = xveloc2
yveloc2 = geschwindigkeitsaenderungy (WerteSpeicher.get('BeschleunigungY', 'FEHLER NICHT GEFUNDEN'), i)
#Geschwindigkeit in Y Richtung. Wichtig für die Positionsänderung
WerteSpeicher['GeschwindigkeitY'] = yveloc2
vrelat2 = relativgeschwindigkeit (WerteSpeicher.get('GeschwindigkeitX', 'FEHLER NICHT GEFUNDEN'), WerteSpeicher.get('GeschwindigkeitY', 'FEHLER NICHT GEFUNDEN'))
#Die Relativgeschwindigkeit
WerteSpeicher['RealativeGeschwindigkeit'] = vrelat2 # AKtualisierung der Werte
xposi = xyposgeschwin (WerteSpeicher.get('XPosition', 'FEHLER NICHT GEFUNDEN'), WerteSpeicher.get('GeschwindigkeitX', 'FEHLER NICHT GEFUNDEN'), i)
#Hier wird die neue XPosition errechnet
WerteSpeicher['XPosition'] = xposi
yposi = xyposgeschwin (WerteSpeicher.get('YPosition', 'FEHLER NICHT GEFUNDEN'), WerteSpeicher.get('GeschwindigkeitY', 'FEHLER NICHT GEFUNDEN'), i)
#Hier wird die neue XPosition errechnet
WerteSpeicher['YPosition'] = yposi
anzeigetafel.insert(END, 'ABSTAND R=>'+ str(rabsta) + " \n")
anzeigetafel.insert(END, 'BESCHLEUNIGUNG A=>'+ str(abesch2) + "\n")
anzeigetafel.insert(END, 'BESCHLEUNIGUNGY=>'+ str(ybesch2) + "\n")
anzeigetafel.insert(END, 'BESCHLEUNIGUNGX=>'+ str(xbesch2) + "\n") #Ausgabe der Werte
anzeigetafel.insert(END, 'GESCHWINDIGKEITX=>'+ str(xveloc2) + "\n")
anzeigetafel.insert(END, 'GESCHWINDIGKEITY=>'+ str(yveloc2) + "\n")
anzeigetafel.insert(END, 'GESCHWINDIGKEITRELA=>'+ str(vrelat2) + "\n")
if i > 0:
anzeigetafel.insert(END, 'XPOSITION=>'+ str(xposi) + "\n")
anzeigetafel.insert(END, 'YPOSITION=>'+ str(yposi) + "\n")
anzeigetafel.insert(END, "---------------\n")
#AUFRUF DES KONSTRUKTORS FÜR EIN FENSTER
hauptfenster = Tk()
hauptfenster.title("Kepler Ellipsen, SimulationsSoftware")
# DER GESAMTE TEXT FÜR DIE EINTRÄGE
Label(hauptfenster, text="MDHO : ", pady=10).grid(row=0,column=0)
Label(hauptfenster, text="XPosition : ", pady=10).grid(row=1,column=0)
Label(hauptfenster, text="YPosition : ", pady=10).grid(row=2,column=0)
Label(hauptfenster, text="XGeschwindigkeit : ", pady=10).grid(row=0,column=5)
Label(hauptfenster, text="YGEschwindigkeit : ", pady=10).grid(row=1,column=5)
Label(hauptfenster, text="Gravitationskonstante : ", pady=10).grid(row=2,column=5)
#DAS TEXTWIDGET, UM SPÄTER ERGEBNISSE ANZUZEIGEN UND ABZUSPEICHERN
scroll_y = Scrollbar(hauptfenster, orient=VERTICAL)
anzeigetafel = Text(hauptfenster, width=50, height=30, yscrollcommand=scroll_y.set)
anzeigetafel.grid(row=4, column=5)
#DIE ENTRY FELDER UM EINGABEN ZU TÄTIGEN
PlaniMasse=DoubleVar()
PlaniMasse.set(1989000000000000000000000000000.0)
XPosition=DoubleVar()
XPosition.set(147100000.0)
YPosition=DoubleVar()
YPosition.set(14234100000.0)
XGeschwindigkeit=DoubleVar()
XGeschwindigkeit.set(0.0)
YGeschwindigkeit=DoubleVar() #Hier werden den Entrys Varaiblen übergeben. Funktioniert noch nicht 100%
YGeschwindigkeit.set(30.290)
GravitationsKonstante=DoubleVar()
GravitationsKonstante.set(0.0000000000000000667)
entryMDHO=Entry(hauptfenster, textvariable=PlaniMasse)
entryMDHO.grid(row=0,column=1)
entryXposition=Entry(hauptfenster, textvariable=XPosition)
entryXposition.grid(row=1,column=1)
entryYposition=Entry(hauptfenster, textvariable=YPosition)
entryYposition.grid(row=2,column=1)
entryXgeschwindigkeit=Entry(hauptfenster, textvariable=XGeschwindigkeit)
entryXgeschwindigkeit.grid(row=0,column=6)
entryYgeschwindigkeit1=Entry(hauptfenster, textvariable=YGeschwindigkeit)
entryYgeschwindigkeit1.grid(row=1,column=6)
entryGravitationskonstante=Entry(hauptfenster, textvariable=GravitationsKonstante)
entryGravitationskonstante.grid(row=2,column=6)
# DEr STARTBUTTON DER ALLES ZUM ANFANG BRINGT
anfangbutt = Button(hauptfenster, text="REchnungstarten", command=rechnung()) #Der semioptimale Button um eine Rechnung zu starten
anfangbutt.grid(row=6, column=1)
# DAMIT DAS HAUPTFENSTER AM LEBEN BLEIBT
hauptfenster.mainloop()
Code: Alles auswählen
# -*- coding: cp1252 -*-
# KEPLER BERECHNUNGSFORMELN UND FUNKTIONEN
from cmath import *
# Beschleunigung des Himmelskörpers:
def beschleunigunga (f, r, M):
radius=r**2
##abs(radius)
faktor=M/radius
a = f*faktor
return a
# Momentaner Abstand zum GravitationsZentrum:
#def abstandr (xs, ys):
# r = sqrt((xs ** 2) + (ys ** 2))
# return r
# Y Beschleunigung
def beschleunigungy (a, ys, r):
ay = a*(ys/r)
return ay
# X BEschleunigung
def beschleunigungx (a, xs, r):
ax = a*(xs/r)
return ax
def geschwindigkeitsaenderungx (ax, t):
neuesvx = ax * t
return neuesvx
def geschwindigkeitsaenderungy (ay, t):
neuesvy = ay * t
return neuesvy
def relativgeschwindigkeit (vx, vy):
zwischenrech = (vx ** 2) + (vy ** 2)
vrel = sqrt(zwischenrech)
return vrel
def xyposgeschwin (xypos1, vx, t):
xypos = xypos1 + vx * t
return xypos
EDIT:::>
Hier ist eine Stichprobe von den Werten, welche ausgegeben werden.
Es ist die erste ausgabe. Daran sieht man mit was für merkwürdigen werten gerechnet wird.
Code: Alles auswählen
ABSTAND R=>(14234860070.3+0j)
BESCHLEUNIGUNG A=>(6.54717896417e-007+0j)
BESCHLEUNIGUNGY=>(6.54682937759e-007+0j)
BESCHLEUNIGUNGX=>(6.76571473746e-009+0j)
GESCHWINDIGKEITX=>(6.76571473746e-009+0j)
GESCHWINDIGKEITY=>(6.54682937759e-007+0j)
GESCHWINDIGKEITRELA=>(6.54717896417e-007+0j)
XPOSITION=>(147100000+0j)
YPOSITION=>(14234100000+0j)