Anwendung der Runge-Kutta-Methode auf ODEs zweiter Ordnung

Wie kann ich die Euler-Methode durch Runge-Kutta 4. Ordnung ersetzen, um die Bewegung des freien Falls in nicht konstanter Gravitationsgröße (z. B. freier Fall aus 10 000 km Höhe) zu bestimmen?

Bisher habe ich eine einfache Integration nach der Euler-Methode geschrieben:

while()
{
    v += getMagnitude(x) * dt;
    x += v * dt;
    time += dt;
}

x Variable bedeutet aktuelle Position, v bedeutet Geschwindigkeit, getMagnitude (x) gibt die Beschleunigung auf x Position zurück.

Ich habe versucht, RK4 zu implementieren:

while()
{
    v += rk4(x, dt) * dt; // rk4() instead of getMagintude()
    x += v * dt;
    time += dt;
}

Dabei ist der Funktionskörper von rk4 ():

inline double rk4(double tx, double tdt)
{
   double k1 = getMagnitude(tx);
   double k2 = getMagnitude(tx + 0.5 * tdt * k1);
   double k3 = getMagnitude(tx + 0.5 * tdt * k2);
   double k4 = getMagnitude(tx + tdt * k3);

   return (k1 + 2*k2 + 2*k3 + k4)/6.0;
}

Aber etwas stimmt nicht, weil ich nur einmal mit RK4 (Beschleunigung) integriere. Die Integration der Geschwindigkeit mit RK4 ist nicht sinnvoll, da sie mit v * dt identisch ist.

Können Sie mir sagen, wie man Differentialgleichungen zweiter Ordnung mithilfe der Runge-Kutta-Integration löst? Sollte ich RK4 implementieren, indem ich die Koeffizienten k1, l1, k2, l2 ... l4 berechne? Wie kann ich das machen?

Es scheint ziemlich verwirrend zu sein, wie mehrstufige (z. B. Runge-Kutta) Methoden auf ODEs 2. oder höherer Ordnung oder ODE-Systeme angewendet werden sollen. Der Prozess ist sehr einfach, wenn Sie ihn erst einmal verstanden haben, aber ohne eine gute Erklärung vielleicht nicht offensichtlich. Die folgende Methode finde ich am einfachsten.

$F = m\ddot{x}$

$v$$x$k1k4$(x,v)$

while (t<TMAX)
    k1 = RHS( t, X );
    k2 = RHS( t + dt / 2, X + dt / 2 * k1 );
    k3 = RHS( t + dt / 2, X + dt / 2 * k2 );
    k4 = RHS( t + dt, X + dt * k3 );
    X = X + dt / 6 * ( k1 + 2 * k2 + 2 * k3 + k4 );
    t = t + dt;
end

X$=(x,v)$RHS( t, X )$(\dot{x}(t),\dot{v}(t))$

Leider unterstützt C ++ solche Vektoroperationen nicht nativ, sodass Sie entweder eine Vektorbibliothek verwenden, Schleifen verwenden oder die einzelnen Teile manuell ausschreiben müssen. In C ++ können Sie std::valarrayden gleichen Effekt erzielen. Hier ist ein einfaches Arbeitsbeispiel mit konstanter Beschleunigung.

#include <valarray>
#include <iostream>

const size_t NDIM = 2;

typedef std::valarray<double> Vector;

Vector RHS( const double t, const Vector X )
{
  // Right hand side of the ODE to solve, in this case:
  // d/dt(x) = v;
  // d/dt(v) = 1;
  Vector output(NDIM);
  output[0] = X[1];
  output[1] = 1;
  return output;
}

int main()
{

  //initialize values

  // State variable X is [position, velocity]
  double init[] = { 0., 0. };
  Vector X( init, NDIM );

  double t = 0.;
  double tMax=5.;
  double dt = 0.1;

  //time loop
  int nSteps = round( ( tMax - t ) / dt );
  for (int stepNumber = 1; stepNumber<=nSteps; ++stepNumber)
  {

    Vector k1 = RHS( t, X );
    Vector k2 = RHS( t + dt / 2.0,  X + dt / 2.0 * k1 );
    Vector k3 = RHS( t + dt / 2.0, X + dt / 2.0 * k2 );
    Vector k4 = RHS( t + dt, X + dt * k3 );

    X += dt / 6.0 * ( k1 + 2.0 * k2 + 2.0 * k3 + k4 );
    t += dt;
  }
  std::cout<<"Final time: "<<t<<std::endl;
  std::cout<<"Final position: "<<X[0]<<std::endl;
  std::cout<<"Final velocity: "<<X[1]<<std::endl;

}