int main(int argc, char **argv)
{
int np[2];
ptrdiff_t n[3];
ptrdiff_t alloc_local;
ptrdiff_t local_ni[3], local_i_start[3];
ptrdiff_t local_no[3], local_o_start[3];
double err;
double *planned_in, *executed_in;
pfft_complex *planned_out, *executed_out;
pfft_plan plan_forw=NULL, plan_back=NULL;
MPI_Comm comm_cart_2d;
/* Set size of FFT and process mesh */
n[0] = 29; n[1] = 27; n[2] = 31;
np[0] = 2; np[1] = 2;
/* Initialize MPI and PFFT */
MPI_Init(&argc, &argv);
pfft_init();
/* Create two-dimensional process grid of size np[0] x np[1], if possible */
if( pfft_create_procmesh_2d(MPI_COMM_WORLD, np[0], np[1], &comm_cart_2d) ){
pfft_fprintf(MPI_COMM_WORLD, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]);
MPI_Finalize();
return 1;
}
/* Get parameters of data distribution */
alloc_local = pfft_local_size_dft_r2c_3d(n, comm_cart_2d, PFFT_TRANSPOSED_OUT| PFFT_PADDED_R2C,
local_ni, local_i_start, local_no, local_o_start);
/* Allocate memory for planning */
planned_in = pfft_alloc_real (2 * alloc_local);
planned_out = pfft_alloc_complex(alloc_local);
/* Plan parallel forward FFT */
plan_forw = pfft_plan_dft_r2c_3d(
n, planned_in, planned_out, comm_cart_2d, PFFT_FORWARD, PFFT_TRANSPOSED_OUT| PFFT_MEASURE| PFFT_DESTROY_INPUT| PFFT_PADDED_R2C);
/* Plan parallel backward FFT */
plan_back = pfft_plan_dft_c2r_3d(
n, planned_out, planned_in, comm_cart_2d, PFFT_BACKWARD, PFFT_TRANSPOSED_IN| PFFT_MEASURE| PFFT_DESTROY_INPUT| PFFT_PADDED_C2R);
/* Free planning arrays since we use other arrays for execution */
pfft_free(planned_in); pfft_free(planned_out);
/* Allocate memory for execution */
executed_in = pfft_alloc_real(2 * alloc_local);
executed_out = pfft_alloc_complex(alloc_local);
/* Initialize input with random numbers */
pfft_init_input_real(3, n, local_ni, local_i_start,
executed_in);
/* execute parallel forward FFT */
pfft_execute_dft_r2c(plan_forw, executed_in, executed_out);
/* clear the old input */
pfft_clear_input_real(3, n, local_ni, local_i_start,
executed_in);
/* execute parallel backward FFT */
pfft_execute_dft_c2r(plan_back, executed_out, executed_in);
/* Scale data */
for(ptrdiff_t l=0; l < local_ni[0] * local_ni[1] * local_ni[2]; l++)
executed_in[l] /= (n[0]*n[1]*n[2]);
/* Print error of back transformed data */
err = pfft_check_output_real(3, n, local_ni, local_i_start, executed_in, comm_cart_2d);
pfft_printf(comm_cart_2d, "Error after one forward and backward trafo of size n=(%td, %td, %td):\n", n[0], n[1], n[2]);
pfft_printf(comm_cart_2d, "maxerror = %6.2e;\n", err);
/* free mem and finalize */
pfft_destroy_plan(plan_forw);
pfft_destroy_plan(plan_back);
MPI_Comm_free(&comm_cart_2d);
pfft_free(executed_in); pfft_free(executed_out);
MPI_Finalize();
return 0;
}
int main(int argc, char **argv)
{
int np[2];
ptrdiff_t n[3];
ptrdiff_t alloc_local;
ptrdiff_t local_ni[3], local_i_start[3];
ptrdiff_t local_no[3], local_o_start[3];
double err, *in;
pfft_complex *out;
pfft_plan plan_forw=NULL, plan_back=NULL;
MPI_Comm comm_cart_2d;
/* Set size of FFT and process mesh */
n[0] = 29; n[1] = 27; n[2] = 31;
np[0] = 2; np[1] = 2;
/* Initialize MPI and PFFT */
MPI_Init(&argc, &argv);
pfft_init();
/* Create two-dimensional process grid of size np[0] x np[1], if possible */
if( pfft_create_procmesh_2d(MPI_COMM_WORLD, np[0], np[1], &comm_cart_2d) ){
pfft_fprintf(MPI_COMM_WORLD, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]);
MPI_Finalize();
return 1;
}
/* Get parameters of data distribution */
alloc_local = pfft_local_size_dft_r2c_3d(n, comm_cart_2d, PFFT_TRANSPOSED_NONE,
local_ni, local_i_start, local_no, local_o_start);
/* Allocate memory */
in = pfft_alloc_real(2 * alloc_local);
out = pfft_alloc_complex(alloc_local);
/* Plan parallel forward FFT */
plan_forw = pfft_plan_dft_r2c_3d(
n, in, out, comm_cart_2d, PFFT_FORWARD, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT);
/* Plan parallel backward FFT */
plan_back = pfft_plan_dft_c2r_3d(
n, out, in, comm_cart_2d, PFFT_BACKWARD, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT);
/* Initialize input with random numbers */
// m = 0;
// for(int k0=0; k0<n[0]; k0++){
// for(int k1=0; k1<n[1]; k1++){
// for(int k2=0; k2<n[2]; k2++, m++)
// in[m] = 1000/(m+1);
// for(int k2=n[2]; k2<n[2]/2+1; k2++, m++)
// in[m] = 0;
// }
// }
pfft_init_input_r2c(3, n, local_ni, local_i_start,
in);
/* execute parallel forward FFT */
pfft_execute(plan_forw);
/* execute parallel backward FFT */
pfft_execute(plan_back);
/* Scale data */
for(ptrdiff_t l=0; l < local_ni[0] * local_ni[1] * local_ni[2]; l++)
in[l] /= (n[0]*n[1]*n[2]);
/* Print error of back transformed data */
MPI_Barrier(MPI_COMM_WORLD);
err = pfft_check_output_c2r(3, n, local_ni, local_i_start, in, comm_cart_2d);
pfft_printf(comm_cart_2d, "Error after one forward and backward trafo of size n=(%td, %td, %td):\n", n[0], n[1], n[2]);
pfft_printf(comm_cart_2d, "maxerror = %6.2e;\n", err);
/* free mem and finalize */
pfft_destroy_plan(plan_forw);
pfft_destroy_plan(plan_back);
MPI_Comm_free(&comm_cart_2d);
pfft_free(in); pfft_free(out);
MPI_Finalize();
return 0;
}
int main(int argc, char **argv){
ptrdiff_t n[3], gc_below[3], gc_above[3];
ptrdiff_t local_ni[3], local_i_start[3];
ptrdiff_t local_no[3], local_o_start[3];
ptrdiff_t local_ngc[3], local_gc_start[3];
ptrdiff_t alloc_local, alloc_local_gc;
int np[3], rnk_self, size, verbose;
double err;
MPI_Comm comm_cart_2d;
pfft_complex *cdata;
pfft_gcplan ths;
MPI_Init(&argc, &argv);
pfft_init();
MPI_Comm_rank(MPI_COMM_WORLD, &rnk_self);
MPI_Comm_size(MPI_COMM_WORLD, &size);
/* default values */
n[0] = n[1] = n[2] = 8; /* n[0] = 3; n[1] = 5; n[2] = 7;*/
np[0]=2; np[1]=2; np[2] = 1;
verbose = 0;
for(int t=0; t<3; t++){
gc_below[t] = 0;
gc_above[t] = 0;
}
gc_below[0] = 0;
gc_above[0] = 4;
/* set values by commandline */
init_parameters(argc, argv, n, np, gc_below, gc_above, &verbose);
/* Create two-dimensional process grid of size np[0] x np[1], if possible */
if( pfft_create_procmesh_2d(MPI_COMM_WORLD, np[0], np[1], &comm_cart_2d) ){
pfft_fprintf(MPI_COMM_WORLD, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]);
MPI_Finalize();
return 1;
}
/* Get parameters of data distribution */
/* alloc_local, local_no, local_o_start are given in complex units */
/* local_ni, local_i_start are given in real units */
alloc_local = pfft_local_size_dft_r2c_3d(n, comm_cart_2d, PFFT_TRANSPOSED_NONE,
local_ni, local_i_start, local_no, local_o_start);
/* alloc_local_gc, local_ngc, local_gc_start are given in complex units */
alloc_local_gc = pfft_local_size_gc_3d(
local_no, local_o_start, gc_below, gc_above,
local_ngc, local_gc_start);
/* Allocate enough memory for FFT and ghost cells */
cdata = pfft_alloc_complex(alloc_local_gc > alloc_local ? alloc_local_gc : alloc_local);
/* Plan parallel ghost cell send */
ths = pfft_plan_cgc_3d(n, gc_below, gc_above,
cdata, comm_cart_2d, PFFT_GC_TRANSPOSED_NONE | PFFT_GC_R2C);
/* Initialize input with random numbers */
pfft_init_input_complex_3d(n, local_no, local_o_start,
cdata);
/* check gcell input */
if(verbose)
pfft_apr_complex_3d(cdata, local_no, local_o_start, "gcell input", comm_cart_2d);
/* Execute parallel ghost cell send */
pfft_exchange(ths);
/* Check gcell output */
if(verbose)
pfft_apr_complex_3d(cdata, local_ngc, local_gc_start, "exchanged gcells", comm_cart_2d);
/* Execute adjoint parallel ghost cell send */
pfft_reduce(ths);
/* check input */
if(verbose)
pfft_apr_complex_3d(cdata, local_no, local_o_start, "reduced gcells", comm_cart_2d);
/* Scale data */
for(ptrdiff_t l=0; l < local_no[0] * local_no[1] * local_no[2]; l++)
cdata[l] /= 2;
/* Print error of back transformed data */
MPI_Barrier(comm_cart_2d);
err = pfft_check_output_complex_3d(n, local_no, local_o_start, cdata, comm_cart_2d);
pfft_printf(comm_cart_2d, "Error after one gcell exchange and reduce of logical size n=(%td, %td, %td),\n", n[0], n[1], n[2]);
pfft_printf(comm_cart_2d, "physical size pn=(%td, %td, %td),\n", n[0], n[1], n[2]/2+1);
pfft_printf(comm_cart_2d, "gc_below = (%td, %td, %td), gc_above = (%td, %td, %td):\n", gc_below[0], gc_below[1], gc_below[2], gc_above[0], gc_above[1], gc_above[2]);
pfft_printf(comm_cart_2d, "maxerror = %6.2e;\n", err);
/* free mem and finalize */
pfft_destroy_gcplan(ths);
MPI_Comm_free(&comm_cart_2d);
pfft_free(cdata);
MPI_Finalize();
return 0;
}
int main(int argc, char **argv)
{
int np[2];
ptrdiff_t n[3];
double err;
ptrdiff_t alloc_local_c;
ptrdiff_t local_ni_c[3], local_i_start_c[3];
ptrdiff_t local_no_c[3], local_o_start_c[3];
pfft_complex *in_c, *out_c;
pfft_plan plan_forw_c=NULL, plan_back_c=NULL;
ptrdiff_t alloc_local_r, alloc_local_forw, alloc_local_back;
ptrdiff_t local_ni_r[3], local_i_start_r[3];
ptrdiff_t local_no_r[3], local_o_start_r[3];
pfft_complex *in_r;
double *out_r;
pfft_plan plan_forw_r=NULL, plan_back_r=NULL;
MPI_Comm comm_cart_2d;
/* Set size of FFT and process mesh */
n[0] = 4; n[1] = 4; n[2] = 6;
np[0] = 2; np[1] = 2;
/* Initialize MPI and PFFT */
MPI_Init(&argc, &argv);
pfft_init();
/* Create two-dimensional process grid of size np[0] x np[1], if possible */
if( pfft_create_procmesh_2d(MPI_COMM_WORLD, np[0], np[1], &comm_cart_2d) ){
pfft_fprintf(MPI_COMM_WORLD, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]);
MPI_Finalize();
return 1;
}
/* Get parameters of data distribution */
alloc_local_c = pfft_local_size_dft_3d(n, comm_cart_2d, PFFT_TRANSPOSED_NONE,
local_ni_c, local_i_start_c, local_no_c, local_o_start_c);
alloc_local_forw = pfft_local_size_dft_c2r_3d(n, comm_cart_2d, PFFT_TRANSPOSED_NONE,
local_ni_r, local_i_start_r, local_no_r, local_o_start_r);
alloc_local_back = pfft_local_size_dft_r2c_3d(n, comm_cart_2d, PFFT_TRANSPOSED_NONE,
local_no_r, local_o_start_r, local_ni_r, local_i_start_r);
alloc_local_r = (alloc_local_forw > alloc_local_back) ? alloc_local_forw : alloc_local_back;
/* Allocate memory */
in_c = pfft_alloc_complex(alloc_local_c);
out_c = pfft_alloc_complex(alloc_local_c);
in_r = pfft_alloc_complex(alloc_local_r);
out_r = pfft_alloc_real(2*alloc_local_r);
/* Plan parallel forward FFT */
plan_forw_c = pfft_plan_dft_3d(
n, in_c, out_c, comm_cart_2d, PFFT_FORWARD, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT);
plan_forw_r = pfft_plan_dft_c2r_3d(
n, in_r, out_r, comm_cart_2d, PFFT_FORWARD, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT);
/* Plan parallel backward FFT */
plan_back_c = pfft_plan_dft_3d(
n, out_c, in_c, comm_cart_2d, PFFT_BACKWARD, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT);
plan_back_r = pfft_plan_dft_r2c_3d(
n, out_r, in_r, comm_cart_2d, PFFT_BACKWARD, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT);
/* Initialize input with random numbers */
init_input(n, local_ni_c, local_i_start_c, in_c);
init_input(n, local_ni_r, local_i_start_r, in_r);
/* execute parallel forward FFT */
pfft_execute(plan_forw_c);
pfft_execute(plan_forw_r);
/* execute parallel backward FFT */
pfft_execute(plan_back_c);
pfft_execute(plan_back_r);
/* Scale data */
for(ptrdiff_t l=0; l < local_ni_c[0] * local_ni_c[1] * local_ni_c[2]; l++)
in_c[l] /= (n[0]*n[1]*n[2]);
for(ptrdiff_t l=0; l < local_ni_r[0] * local_ni_r[1] * local_ni_r[2]; l++)
in_r[l] /= (n[0]*n[1]*n[2]);
/* Print error of back transformed data */
err = compare_c2c_c2r(local_ni_c, local_ni_r, in_c, in_r, comm_cart_2d);
pfft_printf(comm_cart_2d, "Error after one forward and backward trafo of size n=(%td, %td, %td):\n", n[0], n[1], n[2]);
pfft_printf(comm_cart_2d, "maxerror = %6.2e;\n", err);
/* free mem and finalize */
pfft_destroy_plan(plan_forw_c);
pfft_destroy_plan(plan_back_c);
pfft_destroy_plan(plan_forw_r);
pfft_destroy_plan(plan_back_r);
MPI_Comm_free(&comm_cart_2d);
pfft_free(in_c); pfft_free(out_c);
pfft_free(in_r); pfft_free(out_r);
MPI_Finalize();
return 0;
}
