Momentane Bahngeschwindigkeit von Planeten

xindon

Hey,

in meiner Simulation berechne ich mithilfe der Bahnelemente Planetenpositionen zu einer bestimmten Zeit.

Doch ich weiß leider nicht, wie ich die momentane Bahngeschwindigkeit zu dieser Zeit berechnen kann.

Ich könnte es in der Simulation auch über den Abstand der Koordinaten annähern, aber es muss doch auch möglich sein, es mehr oder weniger exakt zu berechnen.

Kennt sich damit jemand ein bisschen aus?

Vielen Dank schonmal

Tobi3000

Weiß nicht genau welche Art von Formeln du jetzt suchst, aber allgemein würde ich nach Kepler suchen.

http://de.wikipedia.org/wiki/Keplersche_Gesetze
http://de.wikipedia.org/wiki/Keplerellipse
http://de.wikipedia.org/wiki/Kepler-Gleichung

xindon

Ja, da war ich überall schon, aber ich weiß nicht, wie ich daraus auf die Bahngeschwindigkeit kommen könnte..

Ein Einsatzpunkt wäre das zweite Keplersche Gesetz (Flächensatz), weil da ja die Geschwindigkeit drin steckt, aber mehr fällt mir dazu auch nicht ein.

proggingmania

Ho,
den Ortsvektor des Objekts einmal ableiten und ggf. den Betrag bilden.

xindon

Hey,

stimmt, das mit der Ableitung hört sich gut an, wir hatten dieses Jahr ja Differenzialrechnung in der Schule

Aber was meinst du mit Ortsvektor? Nach Wikipedia sind das ja grad die Koordianten mit der Sonne als Ursprung des Systems. Doch wie kann ich denn einen Vektor ableiten?

Vielen Dank

YASC

Wenn du ne Funktion von der Zeit hast, die dir diese Koordinaten ausspuckt, die einmal ableiten, dann hast du die Geschwindigkeit

xindon

Har, das hört sich einfacher an als es ist....

Ich habe die Vorgehensweise aus diesem PDF der Nasa implementiert.

Muss ich jetzt alles einsetzen bis ich eine große Gleichung hab und die dann ableiten?

/************************************************************************/
/* Computes the position of the planet on the given Julian day number	*/
/* See: Nasa - Approximate Positions of the Major Planets.pdf			*/
/************************************************************************/
Vector3 Planet::ComputePosition(double JDN)
{
	// 0. Number of centuries past J2000.0
	double t = (JDN - 2451545.0) / 36525;

	// 1. Compute the value of each of the planet's six elements:
	double a = this->semi_major_axis + this->delta_semi_major_axis * t;		// Semi-major axis
	double e = this->eccentricity + this->delta_eccentricity * t;			// Eccentricity
	double I = this->inclination + this->delta_inclination * t;				// Inclination
	double L = this->mean_longitude + this->delta_mean_longitude * t;		// Mean longitude
	double omegaPerihelion = this->longitude_of_perihelion + this->delta_longitude_of_perihelion * t;	// Longitude of perihelion
	double omegaAscendingNode = this->longitude_of_ascending_node + this->delta_longitude_of_ascending_node * t; // Longitude of ascending node

	// 2. Compute the argument of perihelion w and the mean anomaly M
	double w = omegaPerihelion - omegaAscendingNode;
	double M = L - omegaPerihelion + (this->extendedParameters ? (this->b*t*t + c * cos(this->f * t) + s * sin(this->f * t)) : 0);

	// 3a. Modulus the mean anomaly so that -Pi <= M <= +Pi
	M = fmod(M, 6.283185307179586476925286766559) - 3.1415926535897932384626433832795;

	// 3b. Obtain the eccentric anomaly E from the solution of Kepler's equation
	double deltaE, deltaM;
	double E = M + e * sin(M);
	do {
		deltaM = M - (E - e * sin(E));
		deltaE = deltaM / (1.0 - e * cos(E));
		E = E + deltaE;
	} while (deltaE > 0.000001);

	// 4. Compute the planet's heliocentric coordinates in its orbital plane r', with the x'-axis aligned
	//    from the focus to the perihelion
	double x_ = a * (cos(E) - e);
	double y_ = a * sqrt(1.0 - (e * e)) * sin(E);
	double z_ = 0.0;

	// 5. Compute the coordinates in the J2000 ecliptic plane with the x-axis aligned toward the equinox
	double sinOmegaPerihelion = sin(w);
	double cosOmegaPerihelion = cos(w);
	double sinOmegaAscending = sin(omegaAscendingNode);
	double cosOmegaAscending = cos(omegaAscendingNode);
	double sinInclination = sin(I);
	double cosInclination = cos(I);

	Vector3 vec;

	vec.x = (((cosOmegaPerihelion * cosOmegaAscending) - (sinOmegaPerihelion * sinOmegaAscending * cosInclination)) * x_) + (((-sinOmegaPerihelion * cosOmegaAscending) - (cosOmegaPerihelion * sinOmegaAscending * cosInclination)) * y_);
	vec.y = (((cosOmegaPerihelion * sinOmegaAscending) + (sinOmegaPerihelion * cosOmegaAscending * cosInclination)) * x_) + (((-sinOmegaPerihelion * sinOmegaAscending) + (cosOmegaPerihelion * cosOmegaAscending * cosInclination)) * y_);
	vec.z = ((sinOmegaPerihelion * sinInclination) * x_) + ((cosOmegaPerihelion * sinInclination) * y_); 

	return vec;
}

YASC

xindon schrieb:

Har, das hört sich einfacher an als es ist....

Is das nich immer so?

Muss ich jetzt alles einsetzen bis ich eine große Gleichung hab und die dann ableiten?

Das waer wohl ne Moeglichkeit. Muss aber ziemlich umstaendlich sein
Ich empfehle mal die lektuere dieses Buches:
Game physics | ISBN: 1558607404
Da is ein Beispiel zu Planetenbahnen drin; mit Formel und Herleitung und allem drum und dran.

ja und zwar komponentenweise.
d.h für vec.x hast du ja eine konkrete Formel. Die leitest du nach t ab.
--> damit erhältst du nen Ausdruck für die Geschwindigkeit in Richtung der x - Achse. analog für y und z --> fertig.

ich würde dir aber empfehlen das numerisch zu berechnen. d.h
Ort zur Zeit t berechnen und zur Zeit t+h und per Differenzenquotient die
Geschwindigkeit bestimmen. Funktioniert afaik besser als wenn du es exakt berechnest und ist wesentlich einfacher.

xindon

Numeriker schrieb:

ich würde dir aber empfehlen das numerisch zu berechnen. d.h
Ort zur Zeit t berechnen und zur Zeit t+h und per Differenzenquotient die
Geschwindigkeit bestimmen. Funktioniert afaik besser als wenn du es exakt berechnest und ist wesentlich einfacher.

Ja, das habe ich ja im Grunde oben gemeint mit der groben Annäherung über den Abstand der Punkte auf der Bahn. Ich glaub, ich werd's auch so machen; es muss ja nicht 100%ig richtig sein, sondern einfache eine Größenordnung angeben.

Vielen Dank euch allen