Planetenumlaufbahn

Neue Frage »

sackstand Auf diesen Beitrag antworten »
Planetenumlaufbahn
hi, ich habe eine Riesiges Problem.
Ich habe als Aufgabe im AS (Anwendungssysteme) Erstelle mittels OpenGL das Sonnenystem. soweit so gut wo es klemmt ist das Berechnen der Umlaufbahnen und das Darstellen. ich habe im netz rum gegoogled aber nichts gefunden woraus ICH schlau werde.

soweit bin ich bis Jetzt:

die sonne Steht im Brennpunt der Ellipse.

was fehlt mir:

Wie berechne ich bei gegebener Umlaufzeit die Position?

es soll nur 2d (Draufsicht) sein wie berechne ich nun die Position (vektor) der einzelnen planeten ausgegangen von der zeit (in Tagen)

und bitte die Formeln auch mit erklärungen weil ich mit den formlen allein meist nichts anfangen kann wenn ich sie NICHT verstehe!

danke schonmal für die hilfe smile
juergen Auf diesen Beitrag antworten »

Erstes Keplersches Gesetz:
http://www.physicsnet.org/html/content-54-2.html

Zweites Keplersches Gesetz:
http://www.physicsnet.org/html/content-55-2.html
Poff Auf diesen Beitrag antworten »
RE: Planetenumlaufbahn
Zitat:
Original von sackstand
...
Wie berechne ich bei gegebener Umlaufzeit die Position?
...


z.B. Mit den Kepplerschen Gesetzen, besser dem 'Zweiten'

Der von der Sonne ausgehende OrtsVektor überstreicht in gleichen
Zeiten gleiche Flächen und innerhalb eines Umlaufes die komplette
Fläche der Bahnellipse.

Damit sollte es zu machen sein, aber die Ausführung überlass ich dir


Augenzwinkern


... da war juergen schneller geschockt
sackstand Auf diesen Beitrag antworten »

super danke für die schnelle antwort. ich werde mcih nachher regestrien da man ja hier scheinbar shcnell und gute hilfe bekommt danke smile


ps: wenn mein Prog. fertig ist werde ich es mal hier reinstellen ^^
PSM Auf diesen Beitrag antworten »
RE: Planetenumlaufbahn
Wie meinst du das mit "bei gegebener Umlaufzeit die Position"?
Ich beschäftige mich in meiner Freizeit mit Astrophysik. Hast du schonmal was von "wahrer Anomalie" gehört/gelesen? Dieser Winkel gibt an, wann der Planet das Perihel das letzte Mal durchlaufen hat.
Willst du das wissen?
Wenn ja, werde ich die Formeln dafür posten. Erklären kann ich sie dir nicht so gut, weil sie z.T. sehr kompliziert sind. Vielleicht würde auch "Google" helfen.

MfG
Patrick
sackstand Auf diesen Beitrag antworten »

hmmm naja ich glaube das ist im mom noch eine nummer zu hert für mich unglücklich ich sitz immernoch daran zu verstehen wie ich das was kepler so schön formuliert hat für mich in vektoren zu erfassen und rauszufinden wie ich das alles berechnen kann unglücklich irgendwie steig ich da noch nicht hinter wie ich das alles berechnen kann. und wie ich das dann in C++ umsetzen kann /formlen usw)

abre trzodem danke erstmal fürs angebot
 
 
Poff Auf diesen Beitrag antworten »
RE: Planetenumlaufbahn
PSM,

er will quasi die (Polar)Koordinaten des Planeten zu jedem beliebigen
vorgegebenen fixen Zeitpunkt berechnen (können).

Dass es mit Keppler2 geht sollte klar sein.
Nachdem die Halbachsen der Bahnellipse bekannt sind, ist deren
Fläche bestimmbar und damit die Flächenkonstante ...
und damit die Position.


Augenzwinkern
sackstand Auf diesen Beitrag antworten »

also ich habe lange drüber nachgedacht welcher mein entscheidener wert für das animiern der planeten ist und wie ich das am besten umsetze.

also: ich möchte über die zeit T (in tagen) die bewegung (position) der planeten steuern (wobei bei tag 0 alle planeten in einer linie stehen können / sollen) so das ich nur die tage hochzählen muss. nun finde ich aber nirgends eine formel wo ich als angabe die Zeit Grosse, Kleine Bahnachse und umlaufzeit angebe und als ergebnis jeh X und Y (Koordinaten in AE o.ä.) herrausbekomme. ich habe es auch nicht geschafft aus mir vorliegenden Formeln eine solche zu entwickeltn.

ich bin leider kein mathe ass und hab nach der 10 klasse aufhören müssen. da ich mir alles weitere selber beibringe habe ich leider auch nicht das Fundierte wissen wie ein studi, oder abituri. drum tu ich mich da scheinbar auch sehr schwer die formeln richtig umzustellen oder für mich zu nutzen unglücklich bitte um hilfe wenn mir einer die formel nennen koennte oder besser noch mir den weg erklären kann wie ich drauf komme damit ich es verstehe! das wäre mir sehr lieb.

ich hofffe jemand kann sich meinem Problem annehmen und mich "unterrichten" da ich noch viel darüber lernen möchte was physik usw angeht. danke
Poff Auf diesen Beitrag antworten »

'sackstand'

... ich sagte nicht ohne Grund, "das überlass ich dir"

ich hab mich noch nie genauer damit befasst und weiß deswegen
auch nicht wie das 'am Einfachsten' anzugehen sein könnte,
(und zum wild rumrechnen hab ich keine Lust)

... ganz simpel scheint mir die Lösung nicht zu werden Augenzwinkern

mit einfach etwas Formeln umstellen ist da nichts wenn es auf
genauere Resultate ankommt. Falls nicht könntest ja gleich mit nem
Kreis rechnen ...


wart mal ab vielleicht postet dir wer ne fertige Bahngleichung


smile
sackstand Auf diesen Beitrag antworten »

hmm wäre schön smile aber ich glaube nicht das der zufall mir gnädig ist :/
aber trozdem danke smile für den anstoss
Bruce Auf diesen Beitrag antworten »

Ein Fall für Physiker Wink

Benutze die Polarkoordinatendarstellung für Kegelschnitte und verwende zur Berechnung der Bahn ein simples Eulerverfahren.

Gehe also zum Beispiel wie folgt vor:

Wähle durch geschicktes Raten ein hinreichend kleines dt und berechne dann




Das wiederholst Du, solange Du die Planetenbahn simulierst.

Zu jedem Zeitpunkt gilt für die cartesischen Koordinaten x,y der Bahnpunkte:


Hier gilt für die Flächengeschwindigkeit C des Planeten:

wobei T die Umlaufzeit des Planeten ist und a,b sind die große bzw. kleine Halbachse der Planetenbahn.

Für die Parameter der verwendeten Polarkoordinatendarstellung gilt:


Hast Du noch weitere Fragen, etwa zu C++ ? Nur keine Hemmungen!

Gruß von Bruce.
Poff Auf diesen Beitrag antworten »

So, hab doch mal etwas rumgebastelt.

Die große Ellipsenhalbachse sei r und die kleine b

f: = r - e = r - sqrt(r^2 - b^2)

Die Sonne F1 im Ursprung, die Abszisse zusammenfallend mit der
großen Halbachse, die Ellipsenschnittpunkte mit der Abszisse seien
E1 und E2 und die Strecke f = E1F1 (E2F1 die größere von beiden)
auf der negativen Seite der Abszisse liegend.
Die Gesamtumlaufzeit in Tagen sei Ud und es gelte im Bahnpunkte
E1 der Zeitpunkt to = 0.




dann sollten folgende Zusammenhänge gelten:

'Äquivalente Kreisfläche' zur Abszisse x




Fläche Flächenstrahl zur Koordinate (x|y) y>0 beginnend bei to = 0






zugleich ist (Ud = 365 für Erde) :





und damit zum Zeitpunkt 't' in Tagen :









... nun noch die Konstanten (r, f, b, Ud) einsetzen, 't' FREI zw.
0 und Ud/2 wählen und die Gl. numerisch nach x auflösen . Augenzwinkern

die zugehörige y Koordinate ergibt sich dann zu :




modulo Denk- und sonstigen Fehlerchen ....



Augenzwinkern Augenzwinkern
PSM Auf diesen Beitrag antworten »

Hallo Bruce,
ich habe eine Frage: ginge das auch mit der Berechnung der wahren Anomalie?
Zuerst hätte die mittlere Anomalie berechnet. Wenn man die num. Exzentriztät der Planetenbahn kennt, so kann man mit einem Näherungsverfahren die exzentrische Anomalie bestimmen. Schließlich lässt sich damit die wahre Anomalie zu jedem Zeitpunkt ausrechnen, genauso wie die Entfernung zur Sonne.
Soweit ich weiß, geht man in der Ephemeridenrechnung so vor.

MfG
Patrick
Bruce Auf diesen Beitrag antworten »

@Poff

Wie kommst Du auf die Formel für FE ?


Wieso kann FE für negative x gößer als die halbe Ellipsenfläche werden ?
Ich befürchte, daß da etwas nicht stimmt!

@PSM
Da kann ich dir auf Anhieb nicht weiterhelfen, die diversen Näherungsverfahren der Himmelsmechaniker kenne ich nicht.
Mein Vorschlag oben hat für mich den Vorteil, das die Formeln auch für Nicht-Spezialisten durchschaubar sind und das Verfahren sich
einfach als Algorithmus in C++ implementieren lassen dürfte. Aber Du kannst ja mal nähere Details hier angeben, vielleicht kann ich das dann besser beurteilen.

Gruß von Bruce
sackstand Auf diesen Beitrag antworten »

eieieei geschockt das ist viel stoff. ich tu mich leider immer schwer solche formeln zu "verstehen" wäre schön wenn man(bruce smile ) erklären koennte so schritt für schritt wie ich darauf komme und wie ich das ganze einsetze

ich weiss nicht wenn du dich mit c++ auskennen solltest dann sag einfach mal bescheid dann kann ich es evt. "deutlicher" in c++ ausdrücken. im moment verstehe ich viele sachen in der/den formeln nicht. unteranderem auch einige zeichen und abläufe

PS: im moment siehts bei mir so aus verwirrt traurig Hilfe
PSM Auf diesen Beitrag antworten »

Hallo Bruce,
ich habe mir die Lösung wie hier vorgestellt:
http://de.wikipedia.org/wiki/Kepler-Gleichung
Im Buch Astrowissen von Hans-Ulrich Keller wird die Berechnung (fast) genauso beschrieben.

MfG
Patrick
Poff Auf diesen Beitrag antworten »

@Bruce

Fehler hätten können drin sein, hab das nicht rückverifiziert,
aber gerade das was du bemängelst ist mit ziemlicher Sicherheit
richtig. Weiß nicht wie du auf deinen Einwand kommst,
vielleicht nur ein Verständigungsproblem ??

FE ist die Fläche des Ellipsenauschnittes eingegrenzt durch
folgende Punkte bzw Strecken F1E1, Ellipsenbogen E1P(x|y)
und P(x|y)F1. (eben die vom Bahnstrahl überstrichene Fläche
beginnend vom Zeitpunkt to=0, Bahnpunkt E1)
F1E1 liegt dabei auf den negativen Ast der Abszisse.


Davon ab liefert die (Bahn)Gleichung beste passende Werte,
sodass ein Fehler von dieser Seite her eigentlich fast ganz
auszuschließen ist.


z.B. Erde

r = 149.595*10^6 km
f = 147.09 *10^6 km
e = r - f = 2.505*10^6 km
b = sqrt(149.595^2-2.505^2) = 149.5740*10^6 km


Für jeden Zeitpunkt 't', 0 < t < 365/2 und Bahnpunkt P(x|y) y>=0
gilt für die Bahn der Erde:





y ermittelt sich dann zu :




das liefert zB. für den Zeitpunkt t = 90.27724459 den Bahnpunkt
mit der maximalen positiven Ordinate
(2504999.962 | 149574000 )

und das passt bestens, denn
1. ist 149574000 = b und
2. ist 2504999 + 147090000 = 149594999 = r


besser kanns doch garnicht passen !!

damit scheint ein Fehlerchen NICHT mehr sein zu können.


smile
sackstand Auf diesen Beitrag antworten »

ehm verwirrt ist ja alles gut und schön aber kann mir das bitte auch einer erklären jedenfals so im ansatz das ich wenigstens verstehe worum es in meim thread geht? weil versteh ich GARNICHTS MEHR traurig ich fühl mich voll :rolleyes: bitte helft mir. ich habe ncihtmehr viel zeit weil ich in einer woche zur reha muss und bisdahin msus das wengistens noch drin sein unglücklich
Bruce Auf diesen Beitrag antworten »

@sackstand

Ja ja, man hat es nicht leicht, aber leicht hat es einen. Nur keine Panik!

Zur Erklärung versuche ich es mal in C++ auszudrücken, vielleicht verstehen wir uns dann besser.
Also schau dir mal das nachfolgende Programm-Listing an. Ich habe das Program mit dem GNU C++ Compiler
von Suse Linux 9.0 compiliert und getestet. Die Ergebnisse erscheinen mir plausibel.

#include <cmath>
#include <iostream>
using namespace std;

class point2D
{
private:
double r; double phi; double x; double y;

point2D();
point2D& operator=(const point2D &p);

public:
point2D(double r,double phi): r(r), phi(phi), x(r*cos(phi)), y(r*sin(phi)) {};
point2D(const point2D &p): r(p.r), phi(p.phi), x(p.x), y(p.y) {};
~point2D(){};

double getR() const{return r;}
double getPhi() const {return phi;}
double getX() const {return x;}
double getY() const {return y;}
};

class planetOrbit
{
private:
const double a; const double b; const double T; const double dt;
const double phi0; double phi; const double C;
const double eps; const double p; double r;

planetOrbit();
planetOrbit(const planetOrbit&);
planetOrbit& operator=(const planetOrbit&);

double calcC(){double const pi=acos(-1.0); return pi*a*b/T;}
double calcEps(){return pow(1-(b*b)/(a*a),0.5);}
double calcP(){return b*b/a;}
double calcR(double phi){return p/(1-eps*cos(phi));}

public:
planetOrbit(double a, double b, double T, int n, double phi0):
a(a), b(b), T(T), dt(T/n), phi0(phi0), phi(phi0), C(calcC()),
eps(calcEps()), p(calcP()), r(calcR(phi)) {};
~planetOrbit(){};

point2D getNextPoint(){
phi += (2*C*dt)/(r*r);
r = calcR(phi);
return point2D(r,phi-phi0);
}
};

void plotPoint(const point2D &p){
cout << p.getX() << " " << p.getY() << endl;
}


int main(int argc, char** argv){
const double aPlanet = atof(argv[1]); /*große Halbachse der Planetenbahn z.B 1.0*/
const double bPlanet = atof(argv[2]); /*kleine Halbachse der Planetenbahn z.B 0.9*/
const double tPlanet = atof(argv[3]); /*Umlaufdauer des Planeten z.B. 1*/
const double phi0 = atof(argv[4]); /*Polarwinkel des Anfangspunktes der Bahn z.B 0*/
const int tSteps = atoi(argv[5]); /*Anzahl der Zeitschritte z.B. 365*/
const int tStart = atoi(argv[6]); /*Startzeit 0<tStart<tSteps*/
const int tEnd = atoi(argv[7]); /*Endzeit tStart<tEnd<=tSteps*/

planetOrbit orbit(aPlanet,bPlanet,tPlanet,tSteps,phi0);
for (int t=0; t<tEnd; t++){
if (tStart<t) plotPoint(orbit.getNextPoint());
else orbit.getNextPoint();
}

return 0;
}


@Poff
O.K. Poff, ich habe nun begriffen wie Du an die Formel für FK gekommen bist. Ich habe übersehen,
daß FK ja auch noch von x abhängt. Die vielen Formeln haben mich wohl etwas verwirrt.
Allerdings hätte ich keine Lust x(t) numerisch zu bestimmen, das ist zusätzlicher Programmieraufwand.
Der von mir beschriebene Ansatz erscheint mir einfacher zu programmieren.

@PMS
Ich habe mir die Seite vonn Wikipeda angeschaut. Das dort beschriebene Verfahren sieht recht
übersichtlich aus! Es hat allerdings den Nachteil, das zusätzlicher Programmieraufwand für
die Lösung der transzendeten Gleichung E*sin(E)=M(t)/e anfällt. Das von dir vorgeschlagene Verfahren
kann man benutzen, wenn man diesen Aufwand nicht scheut.

Gruß von Bruce.
sackstand Auf diesen Beitrag antworten »

so gefällt mir das :] nun verstehe ich das schon viel besser aber noch zur übersicht was sind die einzelnen variabeln weil mit dem dt zb kann ich nicht wirklich viel anfangen und wieso in point2d nen r (radius???) was sind phi und phi0 ?? das wäre noch nett wenn du mir das noch bissle erklären kannst aber sonst ist das schon echt, für MICH, viel verständlicher! super arbeit nu bin ich schonmal bissle mehr Tanzen
Bruce Auf diesen Beitrag antworten »

O.K. O.K sackstand, ich gebe dir noch weitere Detailinformationen.

Eine Kurve kann durch einen Parameter t und die Koordinatenfunktionen x(t), y(t) beschrieben werden.
Man läßt t einfach durch ein Intervall laufen und die zugehörigen Punkte P(t)=(x(t),y(t)) bilden dann
im Koordinatensystem ein Kurvenstück. Neben den kartesischen Koordinaten kann man einem Punkt P(x,y)
sogenannte Polarkoordinaten r,phi zuordnen. r ist der Abstand von P zum Ursprung, also r = sqrt(x^2+y^2).
Der Polarwinkel phi ist der Winkel, den die Strecke vom Ursprung nach P mit der positiven x-Achse
einschließt. Es gilt:


Für die Ellipse kennt man r als Funktion von phi, es gilt nämlich:


Daraus können die Punkte P(x,y) gemäß

berechnet werden.

Von der elliptischen Planetenbahn kennt man die Umlaufzeit T sowie die große und kleine Halbachse a bzw. b.
Die Bewegung des Planeten auf dieser Bahn willst Du nun insofern
realitätsnah auf dem Bildschirm darstellen, daß der Fahrstrahl in gleichen Zeiten gleiche Flächen
überstreicht, wie es das 2. Kepler'sche Gesetz der Planetenbewegung festlegt.
Startpunkt P0 deiner Zeichnung sei der Punkt mit dem Polarwinkel phi_0. Die nachfolgenden Punkte
P_1, P_2, ..., P_n sollen so konstruiert werden, das die Fläche zwischen den Fahrstrahlen
aufeinanderfolgender Punkte konstant ist. Wenn phi_k der Polarwinkel des k-ten Punktes ist, dann
ist diese Bedingung näherungsweise erfüllt, wenn

gilt, wobei t_k der Zeitpunkt ist, zu dem der Planet sich im Punkt P_k befindet.
Diese Näherung ist um so besser, je kleiner dt ist.

Im Programm wid phi_(k+1) gemäß

mit konstantem dt berechnet, d.h. t_k taucht nicht mehr explizit auf.

Die Ellipsenbahn kann in einem 2 dimensionalen Koordinatensystem durch die Punkte P(t)=(x(t),y(t))
beschrieben werden, wobei t für die Zeit steht. Das Programm berechnet diese Bahnpunkte für die Zeiten
t0=tStart, t=t0+dt, t=t0+2dt, t=t0+3dt, .... ,t=tEnd. Zu Demonstrationszwecken kann ich T=365, dt=1,
tStart=100 und tEnd=255 setzen. Die Zeiteinheit sei hier mal Tage, d.h. dt=1 entspricht 1.Tag.

Durch Variation von phi0 kann die Ellipse um den Brennpunkt im Ursprung gedreht werden.

Kennst Du eigentlich Differentialrechnung und weist Du was ein Drehimpuls ist ?
Es ist ziemlich mühsam das ganze Zeug hier zu eklären ohne Kenntnisse über diese Dinge
voraussetzen zu dürfen.

Wofür brauchst Du das Programm ? Du hast geschrieben für "Anwendungssysteme", das sagt mir nichts!
Machst Du irgend eine IT-Ausbildung ?

Gruß von Bruce.
Poff Auf diesen Beitrag antworten »

Hallo Bruce,

du scheinst dich ja etwas auszukennen auf dem astronomischen
Gebiet. *gg*

Vielleicht kannst du mal einen guten Literatur-Tipp dazu,
nicht zu hochtrabend, nicht zu armseelig,

-- am besten einen echten Klassiker eben --

posten, würde mich echt interessieren.


... 'dabei' soll es nun nicht primär um Bahngleichungen
und insbesondere NICHT um Gleichungen in kompliziertesten
Differentialfeldgleichungsformen gehen, sondern um das
'astronomische Gebiet' in etwas weitreichenderer Form an sich ...



smile
sackstand Auf diesen Beitrag antworten »

jo hatte erst Informatiker systemintegration (admin) und nun anwendungsentwicklung (also Programmierer) naja und mein hobby ist es ausserdem. wie gesagt opengl c++ und sowas alles smile naja drehimpuls nicht wirklich unglücklich aber wenn du gute links oder Literatur hast dann immer her damit ... mir ist es leider nicht möglich gewesen abi oder so zu amchen das das in der schule behandelt wurde (ausführlich) und daher bin ich mit meinem wissen doch stark zurück, aber ich will es lernen wenns geht alles smile , naja hatte mich vorm sommer mit Quaternions Bezierkurven und solch rumgeschlagen.

also das was ich von dir gelesen habe leuchtet mir total ein!
kann es sein das du ein lehrer bist ?? wenn nein solltest du einer werden ! ich werde mich nun auch mit polarsystem um so beschäftigen... um zum drehimpuls werde ich mcih morgen früh gleich belesen (hast du ein gutes buch wo das alles erklärt ist oder von mir aus auch mehrere).

wenn du noch sachen hast die ich lernen "sollte" um auf diesen gebieten firm zu werden bitte sage sie mir! ich werde mich morgen dann ransetzen und mal mein ersten versuch starten das in grafich ansehnliches umzusetzen und wenns klappt poste ich das hier mal smile


ich danke dir!!!

PS: ich komme sicher wieder !
Poff Auf diesen Beitrag antworten »

@sackstand,

das von mir gepostete läuft im Prinzip auf Ähnliches raus.
Ich berechne dabei die Fläche die vom Bahnvektor, beginnend
im Punkt E1(-f,0) bis hin zum Punkt P(x,y) y>=0 überstrichen
wird. Das liefert mir dann die Bestimmungsgleichung für die
Bahnabszisse x (und der Ordinate y) zum beliebigen Zeitpunkt
't', 0 <= t <= Ud/2.

Die Lösung kann NUR auf numerischem Wege ermittelt werden,
stellt dann aber eine EXAKTE Lösung dar, deren Ungenauigkeit
nur von der Ungenauigkeit der BahnGrundkonstanten abhängt.
(Theoretisch gesehen ist diese vereinfachte Bahngleichung exakt,
also keine Näherungslösung ...)



Die Formel hätte sich noch um einige Elemente 'einfacher'
schreiben lassen, aber das war NICHT mein Anliegen.
Ich wollte dabei für MICH überprüfen ob ich mit diesem Ansatz richtig
liege und ob ich damit zum Ziel gelangen würde, nicht mehr nicht
weniger und das hat sich bestätigt.

Besonders überrascht war ich darüber, dass nichtmal ein Fehlerchen
drin verborgen lag ...


smile



Edit
Bruce Auf diesen Beitrag antworten »

@poff
Also, in der Literatur zur Astronomie bzw. Himmelmechanik kenne ich mich nicht aus!
Deswegen kann ich dir keinen Klassiker bennen.

Das was in diesem Thread behandelt wurde, wird gerne im Rahmen von Übungsaufgaben zu
Vorlesungen über Theoretische Mechanik diskutiert, und zwar im Rahmen der Kinematik,
die zu Beginn einer solchen Vorlesung abgehandelt wird.

Wenn Du dich ein bischen mit theoretischer Mechanik beschäftigen willst, so findest Du
in einer Uni-Bibliothek unter den Physiklehrbüchern sicher ein reichhaltiges Angebot für
den Einstieg in die Kinematik.

Beispiele:

Nolting: Grundkurs Theoretische Physik 1
Volz: Einführung in die Theoretische Mechanik 1
Berkley Physik Kurs: Band 1 Mechanik

Das sind Bücher in die ich gerne hineinschaue, aber es gibt auch zahlreiche andere Gute.
Das Buch von Volz habe ich für diesen Thread zu Rate gezogen.


@sackstand
Ich bin kein Lehrer und das ist auch gut so! Allerdings habe ich schon Studenten an der
Uni im Rahmen von Übungen als "Vorturner" beglückt.

Es fällt mir schwer, eine Einführung in die Thematik für jemanden ohne solides Schulwissen
über Analysis zu finden. Vielleicht fängst Du am besten mit Schulbüchern für die Klassen
10-11 an, damit Du ein Gefühl dafür bekommst, worum es in der Mechanik geht.
Eventuell hast du unter www.physikerboard.de die Chance, von Schülern oder anderen Physikern
wertvolle Literaturhinweise zu bekommen.

Bei meinen Vorbereitungen für die erwähnten Physikübungen an der Uni erschien mir das
Buch von Tipler recht nützlich für den Einstieg. Vielleicht kannst Du das Buch in einer
Stadt- oder Uni-Bibliothek mal ausleihen und testen ob es dir zusagt.

Gruß von Bruce.
sackstand Auf diesen Beitrag antworten »

cool! ich werde mich gleich mal nach den themen umsehen und mir die bücher mal antun smile danke für alles smile ich setzt mcih glecih ran und versuch mal was in OpenGL zusammen zuschreiben smile ich werde mich sicher wieder melden ^^ bis denne

PS: ich versuch es dann auchmal die lösung von poff zu integriern! smile
mal sehen was besser geht und schneller ist smile

byby Wink
sackstand Auf diesen Beitrag antworten »

he super es geht soweit alles nur ein kleines Problem noch (erstmal)
der Planet (der blaue ding siehe anhang) wird beim errechen der Sonne Langsamer? sollte er nicht in der nähe schneller werden??? ich habe das gelbe im ursprung gezeichnet also r = 0?? oder hab ich da was falsch gemacht das er vom falschen brennpunkt ausgeht ?

wäre schön wenn man prüfen koennte smile

PS: ist das mit der geschwindigkeit so "korrekt" also das verhältnis

code:
1:
2:
3:
4:
5:
6:
aPlanet = 1; /*große Halbachse der Planetenbahn z.B 1.0*/
bPlanet = 0.8; /*kleine Halbachse der Planetenbahn z.B 0.9*/  
tPlanet = 1; /*Umlaufdauer des Planeten z.B. 1*/ 
phi0 = 0; /*Polarwinkel des Anfangspunktes der Bahn z.B 0*/  
tSteps = 365; /*Anzahl der Zeitschritte z.B. 365*/
tStart = 0; /*Startzeit 0<tStart<tSteps*/  tEnd = 365; /*Endzeit tStart<tEnd<=tSteps*/


so das als daten zur umlaufbahn


hier der link da es um 2kb zu gross is zum uppen :/

--- >> Hier <<---
Bruce Auf diesen Beitrag antworten »

Hi sackstand,

ich hab dein Programm mal runtergladen und ausprobiert.

Wo befindet sich der Ursprung des logischen Koordinatensystems in dem Programfenster? Ich vermute,
das sich der Ursprung genau in der Mitte des Programfensters befindet. Dann müßte die Sonne sich
auch dort befinden und nicht da, wo sie zur Zeit gemalt wird. Dann sind auch die Geschwindigkeiten
plausibel.

Verläuft die x-Achse von links nach rechts oder von rechts nach links ?

Also ich schlage vor, Du schaust dir noch mal genau deine Transformation der logischen
Koordinaten in die Bildschirmkoordinaten an, da vermute ich den Fehler.

Gruß von Bruce.
sackstand Auf diesen Beitrag antworten »

oh sorry das hatte ich vergessen zu schreiben :/

aber kein problem hier die infos

der Ursprung liegt da wo das gelbe viereck ist (die sonne) ich habe die ganze bahn nach "links" verschoben weil ich sie sonst hätte kleiner machen müssen oder sie würde aus dem bildschirm rausragen

und xachse links rechts:


^ y
|
|
|
|
--------------------------> x
/
/
/ z

so ich hoffe man kanns erkennen :) ich zeichne es auf der x-y Achse

(ich habe dei Kamera auf der Z achse richtung ursprung ausgerichtet

von -3 z nach 0 z
die ellipse noch -1x verrückt damit sie wie oben geschrieben "raufpasst"
ich kann sie ja in den ursprung setzen und mal ein gitter alle "1" einheiten hinzufügen. ich werde es in paar min uppen :)

edit: da so viel zu tun ist heute auf arbeit werde ich es erst zu heute abend schaffen :/
kurellajunior Auf diesen Beitrag antworten »

Hi,

also nur vom optischen Gefühl sieht es gut aus. Wenn ich jedoch von Planetenbewegung auf den Brennpunkt schließe, muss er im rechten Brennpunkt der Ellipse liegen...
sackstand Auf diesen Beitrag antworten »

So! ich habs geschafft ! ich hatte einfach ne klammer falsch gesetzt unglücklich und dadurch hatte er eine berechnung vergessen durchzuführen das hat sich dann so ausgewirkt smile . naja nun ist alles Top! ich danke euch ganz besonders Bruce und Poff smile ihr habt mich gerettet! ich werde nun mein testzeugs in richtige OOP Form bringen und dann alles ansehnlicher machen. wenns soweit ist werde ich mal eine kleine beta hier reinstellen smile ich hoffe das ich das übers WE schaffe bis dahin Wink



PS: Bruce Gott
Poff Auf diesen Beitrag antworten »

Zitat:
Original von sackstand
...
mal sehen was besser geht und schneller ist smile
...


ob schneller oder langsamer ist nicht die Frage.
Das eine arbeitet als Näherung, das andere exakt.


Um dir den 2. Weg etwas zu erleichtern versuch ich's nochmal
zusammenzufassen.



Es sei wie oben

Die große Ellipsenhalbachse r und die kleine b

f: = r - e = r - sqrt(r^2 - b^2)

Die Sonne F1 im Ursprung, die Abszisse zusammenfallend mit der
großen Halbachse, die Ellipsenschnittpunkte mit der Abszisse seien
E1 und E2 und die Strecke f = E1F1 auf der negativen Seite der
Abszisse liegend (E2F1 ist die größere von beiden).
Die Gesamtumlaufzeit in Tagen sei Ud und es gelte im Bahnpunkte
E1 der Zeitpunkt to = 0.

FK sei per Definition folgender Ausdruck



dann gilt für einen beliebigen Bahnpunkt P(x_t | y_t) einer Planeten-
bahn und die zugehörigeZeit t ( 0 <= t <= Ud/2,, y >= 0) folgende
BahnbedingungsGleichung:




Diese Bahngl. lässt sich algebraisch nach t auflösen, oder aber auf
numerischem Wege für ein gegebenes t das zugehörige x_t bestimmen
(numerisch nach x-auflösen).

y_t ist dabei durch folgenden Ausdruck zu substituieren :





Willst du entsprechende Berechnungen durchführen, so hast du
mindestens folgende Möglichkeiten.

Entweder die mathematische Bibliothek deiner Programmiersprache
bietet dir eine solche LösungsFunktion an, dann brauchst nur noch
noch die Bahngleichung in der dazu nötigen Form (z.B. als eine
Funktion in x) zu programmieren und überlässt die numerische Lösung
dieser speziellen Bibliotheksfunktion,

oder aber falls das nicht vorhanden ist,
programmierst die Lösungbestimmung selbst mittels Iterationen über
das 'Newton-Verfahren' . Das konvergiert im allgemeinen recht schnell,
sodass meist nicht mehr als drei bis sechs Iterationen nötig sind.
Einzig im engen Bereich um die BahnPunkte E1 und E2 gibts Probleme,
weil hier die Werte der Ableitung enorm hoch ansteigen ....


Als dritte Möglichkeit bietet sich noch ein anderer Weg an.
Da sich die Bahn-Gl. problemlos nach t auflösen lässt, kannst du so
zu jeder frei wählbaren gültigen Bahnabszisse problemlos den
zugehörigen Zeitpunkt 't' genau errechnen und so die Bahn leicht
tabellisieren.
Wählst du z.B. 10^6 Km als Schrittweite, so erhälst auf diese Weise
gänzlich OHNE Iteration ca 2*300 Bahnortszeittrippel (x_t, y_t, t)
die sich so ganz einfach in ein entsprechendes Array einrechnen lassen.
Bei einer späteren Ortsabfrage zu vorgewählter Zeit sortierst einfach
den passendsten Wert raus.
Der einzige Wermutstropfen dabei, die enstehenden Zeitpunkte 't'
fallen nicht genau auf glatte Tages-Zahlen.

Mittels binärer Intervallschachtelung ca. 7-10 Schritte ist aber AUCH
auf diesem Wege zu jedem gewünschten Zeitpunkt 't' das zu-
gehörige Ortspaar(x_t | y_t) beliebig genau zu errechnen.




Zurück zum Newton.
Wie sehen diese Iterationen aus ?
Nun dazu bestimmst 'einfach' zu einen fest vorgewählten 't' einen
einigermaßen dazu passenden Startwert x_0 und ermittelst die
iterative Folge x_(n+1) = x_n - B(x_n) / B'(x_n).
Dazu brauchst natürlich die Ableitung B '. Die ist nicht sonderlich
umfangreich, aber doch recht komplex bei ihrer Ermittlung *gg*.
Macht nicht allzuviel zusätliche Programmierarbeit und für die schnellen
Computer von heute ist es fast egal ob sie etwas mehr oder etwas
weniger zu addieren oder zu multiplizieren haben.


hier nochmal das explizite B(..) und B'(..)






FK ist dabei noch durch den Therm von ganz oben zu ersetzen






um Programmierung und sonstige Umsetzung musst dich selbst
kümmern ...

... aber das musst du dir nicht wirklich antun *gg*


smile
sackstand Auf diesen Beitrag antworten »

hehe Big Laugh also ich mach es erstmal nach bruce "nährungsverfahren" das reicht und bringt das ergebnis, weil man eh keinen untershcied sieht. und als schulprojekt allemal, aber wenn es fertig ist werde ich auf jeden fall mal deine methode noch mit einbauen und dann mal gucken wie es sich auf speed usw auswirkt und dann mal vergleich ziehen die werte und alles smile aber erstmal muss ich alles strukturiern und zusammencoden ^^ (interface planeten monde paar daten zum anzeigen usw) smile

PS: trozdem danke für die "näherbringung" deiner Variante smile sie ist zwar für mich sehr kompliziert aber interessant mehere wege zu sehen


So: ich habs geschafft bei dem ganzen hick hack hier inna Firma. es lauft nun auf SDL deswegen noch die SDL.DLL. ich habe noch keinen timer eingebaut deswegen läuft es bei machnen schneller und bei manchen langsamer ^^ aber jedenfals sollte es so richtig sein Klick Hier smile
Neue Frage »
Antworten »



Verwandte Themen