Orbitalmechanik: Orbit als Funktion der Zeit. Universelle Variablenformulierung?

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!

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; 
    }

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

Orbitalelemente

Keplers Gleichung

Wahre Anomalie

Exzentrizitätsvektor

Argument der Periapsis

Newtons Methode zur numerischen Approximation

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