为了求解 PDE(薛定谔方程),我需要在三个维度上计算拉普拉斯算子。我目前的解决方案是这样的(到目前为止需要最多时间的部分代码):
for n in range(Ntstep): # loop
for i in range(self.Nixyz[0]): # internal levels of wavefunction
wf.psi[i,:,:,:]=self.expu * wf.psi[i,:,:,:] # potential
if n < Ntstep - 1: # compute laplacian in 3d
wf.psi[i,:,:,:]=\
sf.ifft(self.expkx*sf.fft(wf.psi[i,:,:,:],
axis=0,**fft_args),axis=0,**fft_args)
wf.psi[i,:,:,:]=\
sf.ifft(self.expky*sf.fft(wf.psi[i,:,:,:],
axis=1,**fft_args),axis=1,**fft_args)
wf.psi[i,:,:,:]=\
sf.ifft(self.expkz*sf.fft(wf.psi[i,:,:,:],
axis=2,**fft_args),axis=2,**fft_args)
为了获得更好的性能,我尝试/做过/考虑过以下内容:
不要直接进行 3D FFT。拉普拉斯算子是可分离的,因此可以分成三个一维 FFT,这应该会降低
n^3的复杂性。至3n. (在上面的代码中完成。)我针对MKL编译了numpy和scipy,希望能获得一些性能,尤其是希望能够实现多线程计算。对于某些操作,使用了多线程(矩阵向量乘法),但 numpy.fft 和 scipy.fftpack 都没有使用多核。
我编译了 libfftw 和 pyfftw,并将其用作 np/sp 的直接替代品。我有一个 Intel Core i7-3770K,即四核八线程。在 fftw 中使用两个或四个线程时,与 np/sp 相比,我获得了大约两倍的性能。出于某种原因,一个线程或四个以上的线程速度较慢。
所以,我现在的主要问题基本上是:
FFT(W) 是否可以并行化,其性能随可用内核/线程数的增加而扩展?如果是,我需要考虑什么?目前,两到四个线程似乎是我的最佳选择。更多(或更少)速度较慢,尽管我的 CPU 上有八个线程可用。
我应该尝试并行化我的 Python 代码吗?例如。将三个一维 FFT 放在三个不同的内核上。当然,我必须确保我不会同时在不同线程中读取和写入同一个变量,所以我需要在上面的代码中添加一些额外的“临时”变量,例如:
- 线程 1:TempA = FFT(psi..., axis=0)
- 线程 2:TempB = FFT(psi..., axis=1)
- 线程 3:TempC = FFT(psi..., axis=1)
- 最后一步:psi = TempA + TempB + TempC
axis=0的 FFT需要两倍(!)其他轴的时间。是否有可能消除这种差异并使所有 FFT 都同样快?(新)到底是 FFT 方法是最佳选择,还是用户 Rory 的有限差分方法总是更好,至少在性能方面如此?
我认为有效地计算拉普拉斯算子是一个已被广泛研究的主题,因此即使是论文、书籍等的一些链接或提示也可能会有所帮助。
请您参考如下方法:
我真的没有答案,但我的 fft 拉普拉斯算子看起来比你的简单:
def laplacian3d(field, KX, KY, KZ):
return ifft(-KX**2*fft(field, axis = 0), axis = 0) +
ifft(-KY**2*fft(field, axis = 1), axis = 1) +
ifft(-KZ**2*fft(field, axis = 2), axis = 2)
其中 KX、KY 和 KZ 是 3D 阵列,由: KX, KY, KZ = meshgrid(kx, ky, kz, indexing='ij'),feild 是 3D 实空间场(波函数),kx = 2*pi* fftfreq(len(x), (x[1]-x[0])), (x 是包含均匀间隔位置的实空间一维数组)
在实践中,我发现用 cython 实现的有限差分拉普拉斯算子的速度要快大约 10 倍:
cimport numpy as np
cimport cython
import numpy as np
#3D laplacian of a complex function
@cython.boundscheck(False) # turn of bounds-checking for entire function
def laplacianFD3dcomplex(np.ndarray[double complex, ndim=3] f, double complex dx, double complex dy, double complex dz):
cdef unsigned int i, j, k, ni, nj, nk
cdef double complex ifactor, jfactor, kfactor, ijkfactor
ni = f.shape[0]
nj = f.shape[1]
nk = f.shape[2]
cdef np.ndarray[double complex, ndim=3] lapf = np.zeros((ni,nj,nk)) +0.0J
ifactor = 1/dx**2
jfactor = 1/dy**2
kfactor = 1/dz**2
ijkfactor = 2.0*(ifactor + jfactor + kfactor)
for i in xrange(1,ni-1):
for j in xrange(1, nj-1):
for k in xrange(1, nk-1):
lapf[i, j, k] = (f[i, j, k-1] + f[i, j, k+1])*kfactor + (f[i, j-1, k] + f[i, j+1, k])*jfactor + (f[i-1, j, k] + f[i+1, j, k])*ifactor - f[i,j,k]*ijkfactor
return lapf
#3D laplacian of a real function
@cython.boundscheck(False) # turn of bounds-checking for entire function
def laplacianFD3dreal(np.ndarray[double, ndim=3] f, double dx, double dy, double dz):
cdef unsigned int i, j, k, ni, nj, nk
cdef double ifactor, jfactor, kfactor, ijkfactor
ni = f.shape[0]
nj = f.shape[1]
nk = f.shape[2]
cdef np.ndarray[double, ndim=3] lapf = np.zeros((ni,nj,nk))
ifactor = 1/dx**2
jfactor = 1/dy**2
kfactor = 1/dz**2
ijkfactor = 2.0*(ifactor + jfactor + kfactor)
for i in xrange(1,ni-1):
for j in xrange(1, nj-1):
for k in xrange(1, nk-1):
lapf[i, j, k] = (f[i, j, k-1] + f[i, j, k+1])*kfactor + (f[i, j-1, k] + f[i, j+1, k])*jfactor + (f[i-1, j, k] + f[i+1, j, k])*ifactor - f[i,j,k]*ijkfactor
return lapf
可以将以上代码复制到名为“cython_finite_diff.pyx”的文件中,并使用如下所示的 setup.py 文件进行编译:
#To build the cython code in the .pyx file, type in the terminal:
#"python setup.py build_ext --inplace"
from distutils.core import setup
from distutils.extension import Extension
from Cython.Build import cythonize
import numpy
extensions = [
Extension("cython_finite_diff", ["cython_finite_diff.pyx"],
include_dirs = [numpy.get_include()]),
]
setup(
name = "my_cython_fd",
ext_modules = cythonize(extensions, annotate=True),
)
抱歉格式问题,我是个菜鸟,不擅长在堆栈溢出时发帖。另请注意,拉普拉斯有限差分给出了反射边界条件。您并通过将循环设置为包括相对边界上的第一行点来使它们周期性。
