Python 模拟一个耦合的常微分方程

我想写一个程序，把一个二阶微分方程变成两个常微分方程，但我不知道用Python怎么做

我得到了很多错误，请帮助正确编写代码

来自scipy.integrate import solve\u ivp的

将matplotlib.pyplot作为plt导入
将numpy作为np导入
N=30#耦合振荡器的数量。
α=0.25
A=1.0
#初始位置。
y[0]=0#将左侧固定为零。
y[N+1]=0#将右侧固定为零。
#range（1，N+1）命令仅打印出[1,2,3，…N]。
对于（1，N+1）范围内的p：#p是粒子数。
y[p]=A*np.sin（3*p*np.pi/（N+1.0））
####################################################
#初始速度。
####################################################
v[0]=0#左右边界为
v[N+1]=0#夹紧且不移动。
#此版本将所有粒子速度设置为零。
对于范围（1，N+1）内的p：
v[p]=0
w0=[v[p]，y[p]]
def加速（t，w）：
v[p]，y[p]=w
全球a
a[0]=0.0
a[N+1]=0.0
#此版本在所有粒子上显式循环。
对于范围（1，N+1）内的p：
a[p]=[v[p]，y（p+1）+y（p-1）-2*y（p）+alpha*（（y[p+1]-y[p]）**2-（y[p]-y[p-1]）**2]
归还
持续时间=50
t=np.linspace（0，持续时间，800）
abserr=1.0e-8
relerr=1.0e-6
解决方案=解决ivp（加速度，[0，持续时间]，w0，方法=RK45'，t\u eval=t，
矢量化=False，密集输出=True，args=（），atol=abserr，rtol=relerr）

大多数通用解算器不处理结构化状态对象。它们只是使用平面数组作为状态空间点的表示。从初始点的构造来看，您似乎倾向于状态空间排序

  [ v[0], v[1], ... v[N+1], y[0], y[1], ..., y[N+1] ]

这样就可以简单地拆分这两者，并从速度和加速度数组中组合导数向量

让我们保持简单，在小函数中分离功能

a = np.zeros(N+2)
def accel(y):
    global a ## initialized to the correct length with zero, avoids repeated allocation
    a[1:-1] = y[2:]+y[:-2]-2*y[1:-1] + alpha*((y[2:]-y[1:-1])**2-(y[1:-1]-y[:-2])**2)
    return a

def derivs(t,w):
    v,y = w[:N+2], w[N+2:]
    return np.concatenate([accel(y), v])

还是保持避免分配的主题

dwdt = np.zeros(2*N+4)
def derivs(t,w):
    global dwdt
    v,y = w[:N+2], w[N+2:]
    dwdt[:N+2] = accel(y)
    dwdt[N+2:] = v
    return dwdt

现在你只需要设置

w0=np.concatenate([v,y])

---

以快速获得更有趣的错误类别。

欢迎使用SO。真棒的问题。您可能需要考虑升级到Python 3（版本3.92是当前版本）。它甚至可以帮助您编写代码。另外，你能把你在问题中遇到的实际错误写出来吗？@VirtualScooter:我从阅读

a

中看出，在使用前没有定义，

w0

不是平面数组，从元组分配到

a[p]

中的单个浮点位置，

accel

的返回类型如果最后一个未完全校正，则不是平面数组。w0是微分方程的初始条件如何提供初始条件。简而言之，

w0=np.concatenate（[np.zero（N+2），np.sin（3*np.pi*np.linspace（0,1，N+2））

。