如何在C语言中方形障碍物的数值模拟中使高斯包运动

Question

I am trying to use Gaussian packages to study the transmission probability via Trotter-Suzuki formula and fast Fourier transform (FFT) when confronted with a square barrier, just as done in this Quantum Python article . But I need to realize it using C. In principle, the wave function will remain its shape before the collision with the square barrier. But I found that the wave function becomes flat dramatically with time before colliding with the square barrier. Anybody finds problems in the following codes?

Here, two files - result and psi.txt - are created to store the initial and evolved wave-function. The first two data for each are x coordinates, the probability of the wave function at that x . The third data for each line in file result is the square barrier distribution. The FFT I use is shown in this C program .

#include <stdio.h>
#include <math.h>

#define h_bar 1.0
#define pi 3.1415926535897932385E0
#define m0 1.0

typedef double real;
typedef struct { real Re; real Im; }  complex;

extern void fft(complex x[], int N, int flag);

complex complex_product(complex x, real y_power, real y_scale)
{//x*exp(i*y_power)*y_scale
    real Re, Im;

    Re = (x.Re*cos(y_power)-x.Im*sin(y_power))*y_scale;
    Im = (x.Re*sin(y_power)+x.Im*cos(y_power))*y_scale;

    x.Re = Re; x.Im = Im;
    return x;
}

real potential(real x, real a)
{
    return (x<0 || x>=a) ? 0 : 1;
}


void main()
{
    int t_steps=20, i, N=pow(2,10), m, n;
    complex psi[N];
    real x0=-2, p0=1, k0=p0/h_bar, x[N], k[N], V[N];
    real sigma=0.5, a=0.1, x_lower=-5, x_upper=5;
    real dt=1, dx=(x_upper-x_lower)/N, dk=2*pi/(dx*N);
    FILE  *file;

    file = fopen("result", "w");
    //initialize
    for (n=0; n<N; n++)
    {
        x[n] = x_lower+n*dx;
        k[n] = k0+(n-N*0.5)*dk;
        V[n] = potential(x[n], a);
        psi[n].Re = exp(-pow((x[n]-x0)/sigma, 2)/2)*cos(p0*(x[n]-x0)/h_bar);
        psi[n].Im = exp(-pow((x[n]-x0)/sigma, 2)/2)*sin(p0*(x[n]-x0)/h_bar);
    }

    for (m=0; m<N; m++)
        fprintf(file, "%g %g %g\n", x[m],     psi[m].Re*psi[m].Re+psi[m].Im*psi[m].Im, V[m]);
    fclose(file);

    for (i=0; i<t_steps; i++)
    {

        printf("t_steps=%d\n", i);
        for (n=0; n<N; n++)
        {
            psi[n]=complex_product(psi[n], -V[n]*dt/h_bar, 1);
            psi[n]=complex_product(psi[n], -k[0]*x[n], dx/sqrt(2*pi));//x--->x_mod
        }


        fft(psi, N, 1);//psi: x_mod--->k_mod

        for (m=0; m<N; m++)
        {
            psi[m]=complex_product(psi[m], -m*dk*x[0], 1);//k_mod--->k
            psi[m]=complex_product(psi[m], -h_bar*k[m]*k[m]*dt/(2*m0), 1./N);
            psi[m]=complex_product(psi[m], m*dk*x[0], 1);//k--->k_mod
        }

        fft(psi, N, -1);
        for (n=0; n<N; n++)
            psi[n] = complex_product(psi[n], k[0]*x[n], sqrt(2*pi)/dx);//x_mod--->x
    }

    file = fopen("psi.txt", "w");
    for (m=0; m<N; m++)
        fprintf(file, "%g %g 0\n", x[m], pow((psi[m]).Re, 2)+pow((psi[m]).Im, 2));
    fclose(file);   

}

I use the following Python code to plot the initial and final evolved wave functions:

call: `>>> python plot.py result psi.txt`

import matplotlib.pyplot as plt
from sys import argv

for filename in argv[1:]:
    print filename
    f = open(filename, 'r')
    lines = [line.strip(" \n").split(" ") for line in f]
    x = [float(line[0]) for line in lines]
    y = [float(line[2]) for line in lines]
    psi = [float(line[1]) for line in lines]
    print "x=%g, max=%g" % (x[psi.index(max(psi))], max(psi))

    plt.plot(x, y, x, psi)
#plt.xlim([-1.0e-10, 1.0e-10])
plt.ylim([0, 3])
plt.show()

Answer 1

变量i在这里未初始化：

 k[n] = k0+(i-N*0.5)*dk;

Answer 2

Your code is almost correct, sans the fact that you are missing the initial/final half-step in the real domain and some unnecessary operations (k _mod -> k and back), but the main problem is that your initial conditions are really chosen badly. The time evolution of a Gaussian wavepacket results in the uncertainty spreading out quadratically in time:

Given your choice of particle mass and initial wavepacket width, the term in the braces equals 1 + 4 t ² . After one timestep, the wavepacket is already significantly wider than initially and after another timestep becomes wider than the entire simulation box. The periodicity implied by the use of FFT results in spatial and frequency aliasing, which together with the overly large timestep is why your final wavefunction looks that strange.

I would advise that you try to replicate exactly the conditions of the Python program, including the fact that the entire system is in a deep potential well (V _border -> +oo).