fftwpp crea una matriz llena de cero después de una convolución

Question

Utilizo FFTWPP para transformar mis datos y mi núcleo de convolución en el espacio de Fourier, multiplicarlos como en un producto escalar y convertirlos en el espacio real. Cuando ejecuto el programa por primera vez, crea una matriz que está completamente llena de ceros. Cuando lo vuelvo a ejecutar, me da los resultados deseados.

Mientras lo ejecuta, un wisdom3.txt es creado. Si lo elimino, el programa lleva mucho tiempo crear una matriz llena de cero nuevamente.

¿Qué le pasa a mi código?

// sx, sy and sz are the dimensions of my data

int szp = sz / 2 + 1;
size_t align = sizeof(Complex);

// creates arrays to store the data in, the double one is for the real data
// the Complex one for the fourier data
array3<double> f(sx, sy, sz, align);
array3<Complex> g(sx, sy, szp, align);

// copying data into double array
for(int k = 0; k < sz; k++)
    for(int j = 0; j < sy; j++)
        for(int i = 0; i < sx; i++)
            f(i, j, k) = data[i + sx * j + sx * sy * k];

// transforming data into fourier space
rcfft3d Forward3(sz, f, g);
Forward3.fft(f, g);


// generate the kernel
array3<double> kernel(sx, sy, sz);
array3<Complex> kernel2(sx, sy, szp, align);
// more code to create the kernel left out ...


// transform the kernel into the fourier space
rcfft3d ForwardKernel3(sz, kernel, kernel2);
ForwardKernel3.fft(kernel, kernel2);


// multiplying data and kernel in fourier space together
for(int k = 0; k < szp; k++)
    for(int j = 0; j < sy; j++)
        for(int i = 0; i < sx; i++)
            g(i, j, k) = g(i, j, k) * kernel2(i, j, k);


// transform back to normal space
crfft3d Backward3(sz, g, f);
Backward3.fftNormalized(g, f);


// putting everything in the results array and normalize
for(int k = 0; k < sz; k++)
    for(int j = 0; j < sy; j++)
        for(int i = 0; i < sx; i++)
            result[i + sx * j + sx * sy * k] =
                (f(i, j, k) >= thresholdValue ? f(i, j, k) : 0);

Answer 1

FFTW ++ es un envoltorio sobre FFTW. FFTW requiere generar un plan de ejecución para procesar sus datos de manera eficiente. Una vez que se genera el plan, se puede reutilizar para procesar varios conjuntos de datos. El archivo que está viendo wisdom3.txt es información sobre el plan que genera su programa en su primera ejecución. Una vez que existe, se carga en ejecuciones sucesivas y permite que su programa se ejecute rápidamente. Si lo elimina, FFTW tiene que regenerarlo, haciendo que su programa funcione de nuevo nuevamente.

En cuanto a por qué su salida es cero en la primera ejecución, se debe a este paso de generación del plan. Se explica en el FFTW Preguntas frecuentes.

Para concluir, dado que no he usado FFTW ++, no sé el método exacto que se supone que debe llamar para asegurarse de que se genere el plan antes de realizar el FT. Pero debe llamarlo inmediatamente después de definir sus matrices de entrada/salida y antes de inicializarlas con sus datos. Y si necesita ejecutar su código varias veces, debe mantener el archivo de sabiduría.