我正在解决一个非线性薛定谔（NLS）方程：
(1): i*u_t + 0.5*u_xx + abs(u)^2 * u = 0
应用傅立叶变换后，变为：
(2): uhat_t = -0.5*i*k^2 * uhat + i * fft(abs(u)^2 * u)
其中uhat是u的傅里叶变换。上面的等式（2）是一个相当陈述的IVP，可以通过第四个Runge-Kutta方法求解。以下是我求解方程（2）的代码：
import numpy as np
import math
from matplotlib import pyplot as plt
from matplotlib import animation
#----- Numerical integration of ODE via fixed-step classical Runge-Kutta -----
def RK4(TimeSpan,uhat0,nt):
h = float(TimeSpan[1]-TimeSpan[0])/nt
print h
t = np.empty(nt+1)
print np.size(t) # nt+1 vector
w = np.empty(t.shape+uhat0.shape,dtype=uhat0.dtype)
print np.shape(w) # nt+1 by nx matrix
t[0] = TimeSpan[0]
w[0,:] = uhat0 # enter initial conditions in w
for i in range(nt):
t[i+1] = t[i]+h
w[i+1,:] = RK4Step(t[i], w[i,:],h)
return w
def RK4Step(t,w,h):
k1 = h * uhatprime(t,w)
k2 = h * uhatprime(t+0.5*h, w+0.5*k1*h)
k3 = h * uhatprime(t+0.5*h, w+0.5*k2*h)
k4 = h * uhatprime(t+h, w+k3*h)
return w + (k1+2*k2+2*k3+k4)/6.
#----- Constructing the grid and kernel functions -----
L = 40
nx = 512
x = np.linspace(-L/2,L/2, nx+1)
x = x[:nx]
kx1 = np.linspace(0,nx/2-1,nx/2)
kx2 = np.linspace(1,nx/2, nx/2)
kx2 = -1*kx2[::-1]
kx = (2.* np.pi/L)*np.concatenate((kx1,kx2))
#----- Define RHS -----
def uhatprime(t, uhat):
u = np.fft.ifft(uhat)
z = -(1j/2.) * (kx**2) * uhat + 1j * np.fft.fft((abs(u)**2) * u)
return z
#------ Initial Conditions -----
u0 = 1./np.cosh(x)#+1./np.cosh(x-0.4*L)
uhat0 = np.fft.fft(u0)
#------ Solving for ODE -----
TimeSpan = [0,10.]
nt = 100
uhatsol = RK4(TimeSpan,uhat0,nt)
print np.shape(uhatsol)
print uhatsol[:6,:]
我打印出了第6步的迭代，错误发生在第6步，我不明白为什么会这样。这6个步骤的结果是：
nls.py:44: RuntimeWarning: overflow encountered in square
z = -(1j/2.) * (kx**2) * uhat + 1j * np.fft.fft((abs(u)**2) * u)
(101, 512)
[[ 4.02123859e+01 +0.00000000e+00j -3.90186082e+01 +3.16101312e-14j
3.57681095e+01 -1.43322854e-14j ..., -3.12522653e+01 +1.18074871e-13j
3.57681095e+01 -1.20028987e-13j -3.90186082e+01 +1.62245217e-13j]
[ 4.02073593e+01 +2.01061092e+00j -3.90137309e+01 -1.95092228e+00j
3.57636385e+01 +1.78839803e+00j ..., -3.12483587e+01 -1.56260675e+00j
3.57636385e+01 +1.78839803e+00j -3.90137309e+01 -1.95092228e+00j]
[ 4.01015488e+01 +4.02524105e+00j -3.89110557e+01 -3.90585271e+00j
3.56695007e+01 +3.58076808e+00j ..., -3.11660830e+01 -3.12911766e+00j
3.56695007e+01 +3.58076808e+00j -3.89110557e+01 -3.90585271e+00j]
[ 3.98941946e+01 +6.03886019e+00j -3.87098310e+01 -5.85991079e+00j
3.54849686e+01 +5.37263725e+00j ..., -3.10047495e+01 -4.69562640e+00j
3.54849686e+01 +5.37263725e+00j -3.87098310e+01 -5.85991079e+00j]
[ 3.95847537e+01 +8.04663227e+00j -3.84095149e+01 -7.80840256e+00j
3.52095058e+01 +7.15970026e+00j ..., -3.07638375e+01 -6.25837011e+00j
3.52095070e+01 +7.15970040e+00j -3.84095155e+01 -7.80840264e+00j]
[ 1.47696187e+22 -7.55759947e+22j 1.47709575e+22 -7.55843420e+22j
1.47749677e+22 -7.56093844e+22j ..., 1.47816312e+22 -7.56511230e+22j
1.47749559e+22 -7.56093867e+22j 1.47709516e+22 -7.55843432e+22j]]
在第6步，迭代的值是疯狂的。 Aslo，这里发生了溢出错误。
任何帮助？谢谢!!!!
答案 0 :(得分：2)
第一次解析时有两个不同的错误。
（发现对python numpy无效）正如多次说的那样，fft的标准实现不包含维度的缩放，这是责任用户。因此，对于u组件的向量n，
fft(ifft(uhat)) == n*uhat and ifft(fft(u))==n*u
如果您想使用uhat = fft(u)，则重建必须为u=ifft(uhat)/n。
在RK4步骤中，您必须决定因素h的一个位置。要么（例如，其他类似的）
k2 = f(t+0.5*h, y+0.5*h*k1)
或
k2 = h*f(t+0.5*h, y+0.5*k1)
然而，纠正这些点只会延迟爆发。动力爆炸的可能性难怪，这是从立方术语中预期的。一般来说，如果所有项都是线性或亚线性的，那么只能期望“慢”指数增长。
为了避免“非物理”奇点，必须将步长与Lipschitz常数成反比。由于这里的Lipschitz常数大小为u^2，因此必须动态调整。我发现在区间[0,1]中使用1000步，即h=0.001，没有奇点。对于区间[0,10]上的10 000步，这仍然适用。
更新原始方程中没有时间导数的部分是自伴的，这意味着函数的范数平方（绝对值的平方上的积分）保留在精确值中解。因此，一般情况是轮换。现在的问题是功能的某些部分可能以如此小的半径或如此高的速度“旋转”，使得时间步长代表旋转的大部分或甚至多次旋转。这很难用数值方法捕获，因此需要减少时间步长。这种现象的一般名称是“刚性微分方程”：显式Runge-Kutta方法不适用于僵硬的问题。
更新2：使用methods used before，可以使用
解决解耦频域中的线性部分vhat = exp( 0.5j * kx**2 * t) * uhat
允许具有更大步长的稳定解决方案。与KdV方程的处理一样，线性部分i*u_t+0.5*u_xx=0在DFT下解耦到
i*uhat_t-0.5*kx**2*uhat=0
因此可以很容易地解决到相应的指数
exp( -0.5j * kx**2 * t).
然后通过设置
使用常数的变化来处理完整的等式uhat = exp（-0.5j * kx ** 2 * t）* vhat。
这为kx的较大部件增加了一些刚度的负担，但仍然保留了第三种力量。因此，如果步长变大，数值解就会在很少的步骤中爆炸。
下面的工作代码
import numpy as np
import math
from matplotlib import pyplot as plt
from matplotlib import animation
#----- Numerical integration of ODE via fixed-step classical Runge-Kutta -----
def RK4Stream(odefunc,TimeSpan,uhat0,nt):
h = float(TimeSpan[1]-TimeSpan[0])/nt
print h
w = uhat0
t = TimeSpan[0]
while True:
w = RK4Step(odefunc, t, w, h)
t = t+h
yield t,w
def RK4Step(odefunc, t,w,h):
k1 = odefunc(t,w)
k2 = odefunc(t+0.5*h, w+0.5*k1*h)
k3 = odefunc(t+0.5*h, w+0.5*k2*h)
k4 = odefunc(t+h, w+k3*h)
return w + (k1+2*k2+2*k3+k4)*(h/6.)
#----- Constructing the grid and kernel functions -----
L = 40
nx = 512
x = np.linspace(-L/2,L/2, nx+1)
x = x[:nx]
kx1 = np.linspace(0,nx/2-1,nx/2)
kx2 = np.linspace(1,nx/2, nx/2)
kx2 = -1*kx2[::-1]
kx = (2.* np.pi/L)*np.concatenate((kx1,kx2))
def uhat2vhat(t,uhat):
return np.exp( 0.5j * (kx**2) *t) * uhat
def vhat2uhat(t,vhat):
return np.exp(- 0.5j * (kx**2) *t) * vhat
#----- Define RHS -----
def uhatprime(t, uhat):
u = np.fft.ifft(uhat)
return - 0.5j * (kx**2) * uhat + 1j * np.fft.fft((abs(u)**2) * u)
def vhatprime(t, vhat):
u = np.fft.ifft(vhat2uhat(t,vhat))
return 1j * uhat2vhat(t, np.fft.fft((abs(u)**2) * u) )
#------ Initial Conditions -----
u0 = 1./np.cosh(x) #+ 1./np.cosh(x+0.4*L)+1./np.cosh(x-0.4*L) #symmetric or remove jump at wrap-around
uhat0 = np.fft.fft(u0)
#------ Solving for ODE -----
t0 = 0; tf = 10.0;
TimeSpan = [t0, tf]
# nt = 500 # limit case, barely stable, visible spurious bumps in phase
nt = 1000 # boring but stable. smaller step sizes give same picture
vhat0 = uhat2vhat(t0,uhat0)
fig = plt.figure()
ax1 = plt.subplot(211,ylim=(-0.1,2))
ax2 = plt.subplot(212,ylim=(-3.2,3.2))
line1, = ax1.plot(x,u0)
line2, = ax2.plot(x,u0*0)
vhatstream = RK4Stream(vhatprime,[t0,tf],vhat0,nt)
def animate(i):
t,vhat = vhatstream.next()
print t
u = np.fft.ifft(vhat2uhat(t,vhat))
line1.set_ydata(np.real(np.abs(u)))
line2.set_ydata(np.real(np.angle(u)))
return line1,line2
anim = animation.FuncAnimation(fig, animate, interval=15000/nt+10, blit=False)
plt.show()