Skip to main content
 首页 » 编程设计

python之使用 FFT 和 Python 高效计算 3D 拉普拉斯算子

2024年11月01日9shihaiming

为了求解 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 相比,我获得了大约两倍的性能。出于某种原因,一个线程或四个以上的线程速度较慢。

所以,我现在的主要问题基本上是:

  1. FFT(W) 是否可以并行化,其性能随可用内核/线程数的增加而扩展?如果是,我需要考虑什么?目前,两到四个线程似乎是我的最佳选择。更多(或更少)速度较慢,尽管我的 CPU 上有八个线程可用。

  2. 我应该尝试并行化我的 Python 代码吗?例如。将三个一维 FFT 放在三个不同的内核上。当然,我必须确保我不会同时在不同线程中读取和写入同一个变量,所以我需要在上面的代码中添加一些额外的“临时”变量,例如:

    • 线程 1:TempA = FFT(psi..., axis=0)
    • 线程 2:TempB = FFT(psi..., axis=1)
    • 线程 3:TempC = FFT(psi..., axis=1)
    • 最后一步:psi = TempA + TempB + TempC
  3. axis=0 的 FFT需要两倍(!)其他轴的时间。是否有可能消除这种差异并使所有 FFT 都同样快?

  4. (新)到底是 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), 
) 

抱歉格式问题,我是个菜鸟,不擅长在堆栈溢出时发帖。另请注意,拉普拉斯有限差分给出了反射边界条件。您并通过将循环设置为包括相对边界上的第一行点来使它们周期性。