如何用Python3模拟三体

要在Python3中模拟三体问题，你可以使用数值积分方法来解决系统的微分方程。 通过使用Runge-Kutta方法、定义初始条件和参数、编写运动方程和绘制轨迹，可以实现三体问题的模拟。下面我将详细描述这些步骤。

一、定义三体问题的基本概念和微分方程

三体问题是经典力学中的一个问题，它研究三个物体在互相吸引的情况下的运动。为了模拟三体问题，我们需要定义三个物体的质量、初始位置和速度，并使用牛顿引力公式来计算它们之间的相互作用力。根据这些力，我们可以写出物体的运动方程，这是一个由位置和速度组成的微分方程组。

1、初始条件和参数定义

在三体问题的模拟中，首先需要定义三个物体的初始条件，包括它们的质量、位置和速度。假设我们有三个物体A、B和C，它们的质量分别为m1、m2和m3，位置分别为r1、r2和r3，速度分别为v1、v2和v3。我们可以使用Python的numpy库来定义这些初始条件和参数。

import numpy as np
质量
m1, m2, m3 = 1.0, 1.0, 1.0
初始位置 (x, y, z)
r1 = np.array([1.0, 0.0, 0.0])
r2 = np.array([-1.0, 0.0, 0.0])
r3 = np.array([0.0, 1.0, 0.0])
初始速度 (vx, vy, vz)
v1 = np.array([0.0, 1.0, 0.0])
v2 = np.array([0.0, -1.0, 0.0])
v3 = np.array([1.0, 0.0, 0.0])

2、运动方程

为了模拟三体问题，我们需要写出描述物体运动的微分方程。牛顿引力公式告诉我们物体之间的相互作用力是：

[ F = G \frac{m1 \cdot m2}{r^2} ]

其中，G是引力常数，m1和m2是两个物体的质量，r是它们之间的距离。根据牛顿第二定律，我们可以写出物体的加速度：

[ a = \frac{F}{m} ]

我们需要将这个加速度代入到运动方程中，得到三个物体的加速度。

def acceleration(r1, r2, r3, m1, m2, m3, G):
    # 计算距离向量
    r12 = r2 - r1
    r13 = r3 - r1
    r23 = r3 - r2
    # 计算距离的平方
    r12_mag = np.linalg.norm(r12)
    r13_mag = np.linalg.norm(r13)
    r23_mag = np.linalg.norm(r23)
    # 计算加速度
    a1 = G * m2 * r12 / r12_mag<strong>3 + G * m3 * r13 / r13_mag</strong>3
    a2 = -G * m1 * r12 / r12_mag<strong>3 + G * m3 * r23 / r23_mag</strong>3
    a3 = -G * m1 * r13 / r13_mag<strong>3 - G * m2 * r23 / r23_mag</strong>3
    return a1, a2, a3

3、数值积分方法

为了求解运动方程，我们可以使用数值积分方法，比如Runge-Kutta方法。Runge-Kutta方法是一种常用的数值积分方法，它可以在给定的初始条件下，通过一系列的迭代步骤来近似求解微分方程。在这里，我们使用四阶Runge-Kutta方法来进行数值积分。

def runge_kutta_step(r1, r2, r3, v1, v2, v3, m1, m2, m3, G, dt):
    # 计算k1
    a1, a2, a3 = acceleration(r1, r2, r3, m1, m2, m3, G)
    k1_r1 = v1 * dt
    k1_r2 = v2 * dt
    k1_r3 = v3 * dt
    k1_v1 = a1 * dt
    k1_v2 = a2 * dt
    k1_v3 = a3 * dt
    # 计算k2
    a1, a2, a3 = acceleration(r1 + 0.5 * k1_r1, r2 + 0.5 * k1_r2, r3 + 0.5 * k1_r3, m1, m2, m3, G)
    k2_r1 = (v1 + 0.5 * k1_v1) * dt
    k2_r2 = (v2 + 0.5 * k1_v2) * dt
    k2_r3 = (v3 + 0.5 * k1_v3) * dt
    k2_v1 = a1 * dt
    k2_v2 = a2 * dt
    k2_v3 = a3 * dt
    # 计算k3
    a1, a2, a3 = acceleration(r1 + 0.5 * k2_r1, r2 + 0.5 * k2_r2, r3 + 0.5 * k2_r3, m1, m2, m3, G)
    k3_r1 = (v1 + 0.5 * k2_v1) * dt
    k3_r2 = (v2 + 0.5 * k2_v2) * dt
    k3_r3 = (v3 + 0.5 * k2_v3) * dt
    k3_v1 = a1 * dt
    k3_v2 = a2 * dt
    k3_v3 = a3 * dt
    # 计算k4
    a1, a2, a3 = acceleration(r1 + k3_r1, r2 + k3_r2, r3 + k3_r3, m1, m2, m3, G)
    k4_r1 = (v1 + k3_v1) * dt
    k4_r2 = (v2 + k3_v2) * dt
    k4_r3 = (v3 + k3_v3) * dt
    k4_v1 = a1 * dt
    k4_v2 = a2 * dt
    k4_v3 = a3 * dt
    # 更新位置和速度
    r1_next = r1 + (k1_r1 + 2 * k2_r1 + 2 * k3_r1 + k4_r1) / 6
    r2_next = r2 + (k1_r2 + 2 * k2_r2 + 2 * k3_r2 + k4_r2) / 6
    r3_next = r3 + (k1_r3 + 2 * k2_r3 + 2 * k3_r3 + k4_r3) / 6
    v1_next = v1 + (k1_v1 + 2 * k2_v1 + 2 * k3_v1 + k4_v1) / 6
    v2_next = v2 + (k1_v2 + 2 * k2_v2 + 2 * k3_v2 + k4_v2) / 6
    v3_next = v3 + (k1_v3 + 2 * k2_v3 + 2 * k3_v3 + k4_v3) / 6
    return r1_next, r2_next, r3_next, v1_next, v2_next, v3_next

4、模拟和绘图

现在我们可以使用上面的函数来模拟三体问题，并绘制物体的轨迹。我们将定义一个时间步长和总的模拟时间，使用Runge-Kutta方法迭代更新物体的状态，并使用matplotlib库来绘制它们的轨迹。

import matplotlib.pyplot as plt
引力常数
G = 1.0
时间步长
dt = 0.01
总时间
T = 10.0
初始化轨迹
trajectory1 = [r1]
trajectory2 = [r2]
trajectory3 = [r3]
迭代更新
t = 0
while t < T:
    r1, r2, r3, v1, v2, v3 = runge_kutta_step(r1, r2, r3, v1, v2, v3, m1, m2, m3, G, dt)
    trajectory1.append(r1)
    trajectory2.append(r2)
    trajectory3.append(r3)
    t += dt
转换为数组
trajectory1 = np.array(trajectory1)
trajectory2 = np.array(trajectory2)
trajectory3 = np.array(trajectory3)
绘制轨迹
plt.figure(figsize=(10, 10))
plt.plot(trajectory1[:, 0], trajectory1[:, 1], label="Body 1")
plt.plot(trajectory2[:, 0], trajectory2[:, 1], label="Body 2")
plt.plot(trajectory3[:, 0], trajectory3[:, 1], label="Body 3")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.show()