การใช้วิธี Runge-Kutta กับลำดับที่สองของ ODE

ฉันจะเปลี่ยนวิธีการของออยเลอร์โดยลำดับที่ 4 ของ Runge-Kutta เพื่อตัดสินว่าการเคลื่อนที่ของฤดูใบไม้ร่วงฟรีนั้นมีขนาดไม่คงที่ (เช่นการลดลงอิสระจาก 10,000 กม. เหนือพื้นดิน) อย่างไร

จนถึงตอนนี้ฉันเขียนการรวมอย่างง่ายโดยวิธีออยเลอร์:

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

ตัวแปร x หมายถึงตำแหน่งปัจจุบัน, v หมายถึงความเร็ว, getMagnitude (x) จะส่งกลับค่าความเร่งบนตำแหน่ง x

ฉันพยายามใช้ RK4:

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

โดยที่ 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;
}

แต่มีบางอย่างผิดปกติเพราะฉันรวมเพียงครั้งเดียวโดยใช้ RK4 (ความเร่ง) การบูรณาการความเร็วโดยใช้ RK4 ไม่เหมาะสมเพราะมันเหมือนกับ v * dt

คุณช่วยบอกฉันได้ไหมว่าจะแก้สมการอนุพันธ์อันดับสองโดยใช้การรวมเข้าด้วยกันของ Runge-Kutta ได้อย่างไร ฉันควรใช้ RK4 โดยการคำนวณ k1, l1, k2, l2 ... สัมประสิทธิ์ l4 หรือไม่? ฉันจะทำสิ่งนั้นได้อย่างไร

ดูเหมือนจะมีความสับสนเล็กน้อยเกี่ยวกับวิธีการใช้วิธีการหลายขั้นตอน (เช่น Runge-Kutta) กับลำดับที่ 2 หรือสูงกว่าเพื่อ ODEs หรือระบบของ ODE กระบวนการนี้ง่ายมากเมื่อคุณเข้าใจ แต่อาจไม่ชัดเจนหากไม่มีคำอธิบายที่ดี วิธีการต่อไปนี้เป็นวิธีที่ฉันพบง่ายที่สุด

ในกรณีของคุณสมการเชิงอนุพันธ์ที่คุณต้องการที่จะแก้ปัญหาคือ{x} ขั้นตอนแรกคือการเขียน ODE ลำดับที่สองนี้เป็นระบบของ ODE ลำดับที่หนึ่ง สิ่งนี้จะทำตาม$F = m\ddot{x}$

สมการทั้งหมดในระบบนี้จะต้องแก้ไขพร้อมกันซึ่งก็คือบอกว่าคุณไม่ควรเลื่อนแล้วเลื่อนพวกเขาทั้งคู่ควรจะก้าวหน้าในเวลาเดียวกัน ในภาษาที่รองรับการทำงานของเวกเตอร์โดยไม่มีการวนซ้ำทำได้ง่าย ๆ โดยทำข้อกำหนดที่จำเป็นทั้งหมดในเวกเตอร์โค้ดที่มีความยาว 2 ฟังก์ชันที่คำนวณด้านขวามือ (อัตราการเปลี่ยนแปลง) ของ ODE ของคุณควรคืนค่าเวกเตอร์ที่มีความยาว 2 , การควรจะเป็นพาหะของความยาว 2 และตัวแปรของรัฐควรจะเป็นเวกเตอร์ของความยาว 2. ใน MATLAB รหัสที่จำเป็นสำหรับเวลาก้าวสามารถเขียนเป็น:$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

ที่และผลตอบแทนที่มีเวกเตอร์(t)) อย่างที่คุณเห็นโดยการทำให้เวกเตอร์เป็นสิ่งที่คุณไม่จำเป็นต้องเปลี่ยนไวยากรณ์ของรหัส RK4 ไม่ว่าจะมีสมการกี่อันในระบบ ODE ของคุณX$=(x,v)$RHS( t, X )$(\dot{x}(t),\dot{v}(t))$

น่าเสียดายที่ C ++ ไม่สนับสนุนการทำงานของเวกเตอร์ในลักษณะนี้ดังนั้นคุณต้องใช้ไลบรารีเวกเตอร์ใช้ลูปหรือเขียนส่วนต่าง ๆ ด้วยตนเอง ใน C ++ คุณสามารถใช้std::valarrayเพื่อให้ได้ผลเหมือนกัน นี่คือตัวอย่างการทำงานที่เรียบง่ายพร้อมการเร่งความเร็วคงที่

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

}