Orbitalmechanik: Orbit als Funktion der Zeit. Universelle Variablenformulierung?

7

Ich versuche, eine zweidimensionale Umlaufbahn für ein Kepler-Problem mit zwei Körpern zu modellieren, bin aber bei der Einführung der Zeitvariablen hängen geblieben.

Für einen Satelliten mit bekannter Semi-Major-Achse (a), Exzentrizität (e) und wahrer Anomalie (Theta) habe ich:

r = a*(1-e**2)/(1+e*cos(theta))

Wie kann ich Theta als Funktion der Zeit mithilfe der im Wiki vorgeschlagenen universellen Variablenformulierungsmethode berechnen? Ich habe keine Ahnung, wie ich es implementieren soll (verwende Python, aber jeder Algorithmus-Rat wird sehr geschätzt!)

Wie berechne ich alternativ r als Funktion der Zeit?

Hinweis: Alle anderen Orbitalelemente und Massen sind verfügbar. Ich versuche auch, eine allgemeine Lösung für elliptische, hyperbolische und parabolische Bahnen zu finden.

Prost!

imnegan
quelle
Ich sehe, dass Sie die Tags game-designund verwendet haben game-mechanics. Ist diese geschlossene Form für eine Simulation auf Spielebene wirklich notwendig und wie interagiert sie mit dem Gameplay?
Lars Viklund
Was Ihr Problem
betrifft
Lars: Ich entscheide mich für eine geschlossene Form (wenn ich verstanden habe, was das richtig bedeutet), um Planeten über einen langen Zeitraum feste, stabile Umlaufbahnen zu geben. Kleinere Objekte (Raumschiffe usw.) haben eine variable Bewegung, die durch die Gravitationsgesetze von Newton definiert wird und leicht zu berechnen sein sollte.
Imnegan
Planetmaker - danke für die Empfehlung, ich werde es überprüfen.
Imnegan

Antworten:

7

Ich habe die wahre Anomalie als Funktion der Zeit für die Planetenbewegung in c # folgendermaßen berechnet:

  1. Berechnen Sie die mittlere Anomalie (Zeit: aktuelle Zeit, G: Newton grav.connstant, M: Planetenmasse oder die Summe der beiden umlaufenden Objekte, a: Semi-Major-Achse)

            //M = nt
                double n = Math.Sqrt((G * (M)) / (a * a * a));
                double Mt = n * time;
    
  2. Berechnen Sie die exzentrische Anomalie E durch Lösen der Kepler-Gleichung:

         //For orbits with ε > 0.8, an initial value of E0 = π should be used.
            if (eccentr>0.8)
                E = NumApprox(150, Math.PI,Mt, 10E-15);
            else
                E = NumApprox(150, Mt, Mt, 10E-15);
    
  3. wahre Anomalie (Winkel)

    true_anom = 2.0 * Math.Atan2 (Math.Sqrt (1.0 + exzentrisch) * Math.Sin (E / 2.0), Math.Sqrt (1.0 - exzentrisch) * Math.Cos (E / 2.0));

  4. Entfernung vom Planeten

    d = a * ((1,0 - Exzentr * Exzentr) / (1,0 + Exzentr * Math.Cos (true_anom)));

Endlich Numerische Approximation des inversen Problems :

private double NumApprox(int intr, double prev,double Mt, double  err)
    {
        double ret = prev;
        double retprev = prev;
        for (int i=0 ; i<intr; i++){
            retprev = ret;
            ret = ret - (ret - eccentr * Math.Sin(ret) - Mt) / (1.0 - eccentr * Math.Cos(ret));
            if ( Math.Abs(ret - retprev) < err)
                break;
        }
        return ret; 
    }

Geben Sie hier die Bildbeschreibung ein

BEARBEITEN: Position und Geschwindigkeit berechnen

Was wir getan haben, ist die Hälfte der Arbeit, um Cartesain Orbit Elements von Kepler Orbit Elements zu erhalten, wobei:

    //some kepler Orbit Elements: 
    public double d;
    public double true_anom;
    public double eccentr;
    public double a;
    public double E;
    public double w=0; //small omega ω :  Argument of periapsis (in rad)

    //Cartesain Orbit Elements: 
    //Position Vector
    private double x;
    private double y;
    private double z; //2d :not used
    //Velocity Vector
    private double vx;
    private double vy;
    private double vz; //2d :not used

Als letzten Schritt können wir Positions- und Geschwindigkeitsvektoren berechnen als:

//Position
x = d * Math.Cos(true_anom);
y = d * Math.Sin(true_anom);
//apply ω
double xx = x * Math.Cos(w) - y * Math.Sin(w);
double yy = x * Math.Sin(w) + y * Math.Cos(w);
x = xx;
y = yy;


//Velocity
double v = Math.Sqrt(G * M * a) / d;
vx = -v * Math.Sin(E);
vy = -v * Math.Sqrt(1.0-eccentr*eccentr) * Math.Cos(E);

EDIT: Referenzen Geben Sie hier die Bildbeschreibung ein

Orbitalelemente

Keplers Gleichung

Wahre Anomalie

Exzentrizitätsvektor

Argument der Periapsis

Newtons Methode zur numerischen Approximation

Die Physikdokumentation des Kerbal Space Program (KSP) (pdf)

dnk drone.vs.drones
quelle
Das ist großartig, danke! Auch die Tatsache, dass es in 2D ist, stimmt einfach mit dem überein, mit dem ich spiele. Ist es aus Neugier ohne Neigung und Z-Achse möglich, Objekte darzustellen, die im Uhrzeigersinn umkreisen?
Imnegan