Question

我将尽力解释发生了什么以及我的问题。

这有点数学，因此不支持乳胶，因此遗憾的是我不得不求助于图像。我希望可以。

我不知道为什么要倒转，对此感到抱歉。无论如何，这是一个线性系统Ax = b，我们知道A和b，因此我们可以找到x，这是我们在下一个时间步长上的近似值。我们将继续执行直到时间t_final。

这是代码

import numpy as np

tau = 2 * np.pi
tau2 = tau * tau
i = complex(0,1)

def solution_f(t, x):
    return 0.5 * (np.exp(-tau * i * x) * np.exp((2 - tau2) * i * t) + np.exp(tau * i * x) * np.exp((tau2 + 4) * i * t))

def solution_g(t, x):
    return 0.5 * (np.exp(-tau * i * x) * np.exp((2 - tau2) * i * t) - np.exp(tau * i * x) * np.exp((tau2 + 4) * i * t))

for l in range(2, 12):
    N = 2 ** l #number of grid points
    dx = 1.0 / N #space between grid points
    dx2 = dx * dx
    dt = dx #time step
    t_final = 1
    approximate_f = np.zeros((N, 1), dtype = np.complex)
    approximate_g = np.zeros((N, 1), dtype = np.complex)

    #Insert initial conditions
    for k in range(N):
        approximate_f[k, 0] = np.cos(tau * k * dx)
        approximate_g[k, 0] = -i * np.sin(tau * k * dx)

    #Create coefficient matrix
    A = np.zeros((2 * N, 2 * N), dtype = np.complex)

    #First row is special
    A[0, 0] = 1 -3*i*dt
    A[0, N] = ((2 * dt / dx2) + dt) * i
    A[0, N + 1] = (-dt / dx2) * i
    A[0, -1] = (-dt / dx2) * i

    #Last row is special
    A[N - 1, N - 1] = 1 - (3 * dt) * i
    A[N - 1, N] = (-dt / dx2) * i
    A[N - 1, -2] = (-dt / dx2) * i
    A[N - 1, -1] = ((2 * dt / dx2) + dt) * i

    #middle
    for k in range(1, N - 1):
        A[k, k] = 1 - (3 * dt) * i
        A[k, k + N - 1] = (-dt / dx2) * i
        A[k, k + N] = ((2 * dt / dx2) + dt) * i
        A[k, k + N + 1] = (-dt / dx2) * i

    #Bottom half
    A[N :, :N] = A[:N, N:]
    A[N:, N:] = A[:N, :N]

    Ainv = np.linalg.inv(A)

    #Advance through time
    time = 0
    while time < t_final:
        b = np.concatenate((approximate_f, approximate_g), axis = 0)
        x = np.dot(Ainv, b) #Solve Ax = b
        approximate_f = x[:N]
        approximate_g = x[N:]
        time += dt
    approximate_solution = np.concatenate((approximate_f, approximate_g), axis=0)

    #Calculate the actual solution
    actual_f = np.zeros((N, 1), dtype = np.complex)
    actual_g = np.zeros((N, 1), dtype = np.complex)
    for k in range(N):
        actual_f[k, 0] = solution_f(t_final, k * dx)
        actual_g[k, 0] = solution_g(t_final, k * dx)
    actual_solution = np.concatenate((actual_f, actual_g), axis = 0)

    print(np.sqrt(dx) * np.linalg.norm(actual_solution - approximate_solution))

它不起作用。至少不是在一开始，它就不会这么慢地开始。我应该无条件地稳定下来，并收敛于正确的答案。

这是怎么了？

Answer 1

L2-norm可能是测试收敛性的有用指标，但在调试时并不理想，因为它不能解释问题所在。尽管您的解决方案应该是无条件稳定的，但后向Euler不一定会收敛到正确的答案。就像前向欧拉非常不稳定（抗耗散）一样，后向欧拉也非常耗散。绘制解决方案可以确认这一点。数值解收敛到零。对于下一阶近似，Crank-Nicolson是一个合理的候选者。下面的代码包含更通用的theta方法，以便您可以调整解决方案的隐含性。 theta = 0.5表示CN，theta = 1表示BE，theta = 0表示FE。我调整了其他几件事：

这是一个小注释，但是由于不能保证t_final是dt的倍数，因此您不必在同一时间比较解决方案。
关于您对此的评论很慢：随着空间分辨率的提高，时间分辨率也需要提高。即使在dt = dx的情况下，也必须执行（1024 x 1024）* 1024矩阵乘法1024次。我发现这在我的计算机上花费的时间并不长。我删除了一些不必要的级联以加快速度，但是不幸的是，将时间步长更改为dt =（dx ** 2）/ 2确实会使事情陷入困境。如果您担心速度，可以尝试使用Numba进行编译。

所有这些，我发现CN的一致性并没有取得巨大的成功。我必须设置N = 2 ^ 6才能在t_final = 1处获得任何结果。增加t_final会使情况变得更糟，减少t_final会使情况变得更好。根据您的需求，您可以考虑实现TR-BDF2或其他线性多步方法来改善这一点。

具有绘图的代码如下：

import numpy as np
import matplotlib.pyplot as plt

tau = 2 * np.pi
tau2 = tau * tau
i = complex(0,1)

def solution_f(t, x):
    return 0.5 * (np.exp(-tau * i * x) * np.exp((2 - tau2) * i * t) + np.exp(tau * i * x) * np.exp((tau2 + 4) * i * t))

def solution_g(t, x):
    return 0.5 * (np.exp(-tau * i * x) * np.exp((2 - tau2) * i * t) - np.exp(tau * i * x) * 
np.exp((tau2 + 4) * i * t))

l=6
N = 2 ** l 
dx = 1.0 / N 
dx2 = dx * dx
dt = dx2/2
t_final = 1.
x_arr = np.arange(0,1,dx)

approximate_f = np.cos(tau*x_arr)
approximate_g = -i*np.sin(tau*x_arr)

H = np.zeros([2*N,2*N], dtype=np.complex)
for k in range(N):
    H[k,k] = -3*i*dt
    H[k,k+N] = (2/dx2+1)*i*dt    
    if k==0:
        H[k,N+1] = -i/dx2*dt
        H[k,-1] = -i/dx2*dt     
    elif k==N-1:
        H[N-1,N] = -i/dx2*dt
        H[N-1,-2] = -i/dx2*dt    
    else:
        H[k,k+N-1] = -i/dx2*dt
        H[k,k+N+1] = -i/dx2*dt
### Bottom half
H[N :, :N] = H[:N, N:]
H[N:, N:] = H[:N, :N]

### Theta method. 0.5 -> Crank Nicolson
theta=0.5
A = np.eye(2*N)+H*theta
B = np.eye(2*N)-H*(1-theta)

### Precompute for faster computations
mat = np.linalg.inv(A)@B

t = 0
b = np.concatenate((approximate_f, approximate_g))
while t < t_final:
    t += dt
    b = mat@b

approximate_f = b[:N]
approximate_g = b[N:]
approximate_solution = np.concatenate((approximate_f, approximate_g))

#Calculate the actual solution
actual_f = solution_f(t,np.arange(0,1,dx))
actual_g = solution_g(t,np.arange(0,1,dx))
actual_solution = np.concatenate((actual_f, actual_g))

plt.figure(figsize=(7,5))
plt.plot(x_arr,actual_f.real,c="C0",label=r"$Re(f_\mathrm{true})$")
plt.plot(x_arr,actual_f.imag,c="C1",label=r"$Im(f_\mathrm{true})$")
plt.plot(x_arr,approximate_f.real,c="C0",ls="--",label=r"$Re(f_\mathrm{num})$")
plt.plot(x_arr,approximate_f.imag,c="C1",ls="--",label=r"$Im(f_\mathrm{num})$")
plt.legend(loc=3,fontsize=12)
plt.xlabel("x")

plt.savefig("num_approx.png",dpi=150)

Answer 2

我不会讲所有的数学知识，但是我会提供一个建议。

对f_xx和g_xx使用直接计算似乎是数值不稳定的不错选择。直观上，应该期望一阶方法会在术语上造成二阶错误。在通过该公式后，各个术语中的二阶错误会逐渐成为二阶导数中的恒定阶错误。另外，当步长变小时，您会发现一个二次公式会使即使很小的舍入误差也变成令人惊讶的大误差。

相反，我建议您首先将其转换为包含4个功能的一阶系统：f，f_x，g和g_x。然后在该系统上进行向后的Euler。直观地，使用这种方法，一阶方法会创建二阶错误，该二阶错误会通过公式生成二阶错误。现在，您从一开始就应该收敛，并且对舍入误差的传播也不再那么敏感。

在Python中使用隐式Euler解决PDE-错误的输出

2 个答案: