xref: /petsc/src/mat/impls/fft/fftw/fftw.c (revision 09dd8a536f51df49d6d012a7978b38d6b659076a) 
1 
2 /*
3     Provides an interface to the FFTW package.
4     Testing examples can be found in ~src/mat/examples/tests
5 */
6 
7 #include <../src/mat/impls/fft/fft.h>   /*I "petscmat.h" I*/
8 EXTERN_C_BEGIN
9 #include <fftw3-mpi.h>
10 EXTERN_C_END
11 
12 typedef struct {
13   ptrdiff_t   ndim_fftw,*dim_fftw;
14   fftw_plan   p_forward,p_backward;
15   unsigned    p_flag; /* planner flags, FFTW_ESTIMATE,FFTW_MEASURE, FFTW_PATIENT, FFTW_EXHAUSTIVE */
16   PetscScalar *finarray,*foutarray,*binarray,*boutarray; /* keep track of arrays becaue fftw plan should be
17                                                             executed for the arrays with which the plan was created */
18 } Mat_FFTW;
19 
20 extern PetscErrorCode MatMult_SeqFFTW(Mat,Vec,Vec);
21 extern PetscErrorCode MatMultTranspose_SeqFFTW(Mat,Vec,Vec);
22 extern PetscErrorCode MatMult_MPIFFTW(Mat,Vec,Vec);
23 extern PetscErrorCode MatMultTranspose_MPIFFTW(Mat,Vec,Vec);
24 extern PetscErrorCode MatDestroy_FFTW(Mat);
25 extern PetscErrorCode VecDestroy_MPIFFTW(Vec);
26 extern PetscErrorCode MatGetVecs_FFTW(Mat,Vec*,Vec*);
27 
28 #undef __FUNCT__
29 #define __FUNCT__ "MatMult_SeqFFTW"
30 PetscErrorCode MatMult_SeqFFTW(Mat A,Vec x,Vec y)
31 {
32   PetscErrorCode ierr;
33   Mat_FFT        *fft  = (Mat_FFT*)A->data;
34   Mat_FFTW       *fftw = (Mat_FFTW*)fft->data;
35   PetscScalar    *x_array,*y_array;
36   PetscInt       ndim=fft->ndim,*dim=fft->dim;
37 
38   PetscFunctionBegin;
39 #if !defined(PETSC_USE_COMPLEX)
40 
41   SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"not support for real numbers");
42 #endif
43   ierr = VecGetArray(x,&x_array);CHKERRQ(ierr);
44   ierr = VecGetArray(y,&y_array);CHKERRQ(ierr);
45   if (!fftw->p_forward){ /* create a plan, then excute it */
46     switch (ndim){
47     case 1:
48       fftw->p_forward = fftw_plan_dft_1d(dim[0],(fftw_complex*)x_array,(fftw_complex*)y_array,FFTW_FORWARD,fftw->p_flag);
49       break;
50     case 2:
51       fftw->p_forward = fftw_plan_dft_2d(dim[0],dim[1],(fftw_complex*)x_array,(fftw_complex*)y_array,FFTW_FORWARD,fftw->p_flag);
52       break;
53     case 3:
54       fftw->p_forward = fftw_plan_dft_3d(dim[0],dim[1],dim[2],(fftw_complex*)x_array,(fftw_complex*)y_array,FFTW_FORWARD,fftw->p_flag);
55       break;
56     default:
57       fftw->p_forward = fftw_plan_dft(ndim,dim,(fftw_complex*)x_array,(fftw_complex*)y_array,FFTW_FORWARD,fftw->p_flag);
58       break;
59     }
60     fftw->finarray  = x_array;
61     fftw->foutarray = y_array;
62     /* Warning: if (fftw->p_flag!==FFTW_ESTIMATE) The data in the in/out arrays is overwritten!
63                 planning should be done before x is initialized! See FFTW manual sec2.1 or sec4 */
64     fftw_execute(fftw->p_forward);
65   } else { /* use existing plan */
66     if (fftw->finarray != x_array || fftw->foutarray != y_array){ /* use existing plan on new arrays */
67       fftw_execute_dft(fftw->p_forward,(fftw_complex*)x_array,(fftw_complex*)y_array);
68     } else {
69       fftw_execute(fftw->p_forward);
70     }
71   }
72   ierr = VecRestoreArray(y,&y_array);CHKERRQ(ierr);
73   ierr = VecRestoreArray(x,&x_array);CHKERRQ(ierr);
74   PetscFunctionReturn(0);
75 }
76 
77 #undef __FUNCT__
78 #define __FUNCT__ "MatMultTranspose_SeqFFTW"
79 PetscErrorCode MatMultTranspose_SeqFFTW(Mat A,Vec x,Vec y)
80 {
81   PetscErrorCode ierr;
82   Mat_FFT        *fft = (Mat_FFT*)A->data;
83   Mat_FFTW       *fftw = (Mat_FFTW*)fft->data;
84   PetscScalar    *x_array,*y_array;
85   PetscInt       ndim=fft->ndim,*dim=fft->dim;
86 
87   PetscFunctionBegin;
88 #if !defined(PETSC_USE_COMPLEX)
89   SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"not support for real numbers");
90 #endif
91   ierr = VecGetArray(x,&x_array);CHKERRQ(ierr);
92   ierr = VecGetArray(y,&y_array);CHKERRQ(ierr);
93   if (!fftw->p_backward){ /* create a plan, then excute it */
94     switch (ndim){
95     case 1:
96       fftw->p_backward = fftw_plan_dft_1d(dim[0],(fftw_complex*)x_array,(fftw_complex*)y_array,FFTW_BACKWARD,fftw->p_flag);
97       break;
98     case 2:
99       fftw->p_backward = fftw_plan_dft_2d(dim[0],dim[1],(fftw_complex*)x_array,(fftw_complex*)y_array,FFTW_BACKWARD,fftw->p_flag);
100       break;
101     case 3:
102       fftw->p_backward = fftw_plan_dft_3d(dim[0],dim[1],dim[2],(fftw_complex*)x_array,(fftw_complex*)y_array,FFTW_BACKWARD,fftw->p_flag);
103       break;
104     default:
105       fftw->p_backward = fftw_plan_dft(ndim,dim,(fftw_complex*)x_array,(fftw_complex*)y_array,FFTW_BACKWARD,fftw->p_flag);
106       break;
107     }
108     fftw->binarray  = x_array;
109     fftw->boutarray = y_array;
110     fftw_execute(fftw->p_backward);CHKERRQ(ierr);
111   } else { /* use existing plan */
112     if (fftw->binarray != x_array || fftw->boutarray != y_array){ /* use existing plan on new arrays */
113       fftw_execute_dft(fftw->p_backward,(fftw_complex*)x_array,(fftw_complex*)y_array);
114     } else {
115       fftw_execute(fftw->p_backward);CHKERRQ(ierr);
116     }
117   }
118   ierr = VecRestoreArray(y,&y_array);CHKERRQ(ierr);
119   ierr = VecRestoreArray(x,&x_array);CHKERRQ(ierr);
120   PetscFunctionReturn(0);
121 }
122 
123 #undef __FUNCT__
124 #define __FUNCT__ "MatMult_MPIFFTW"
125 PetscErrorCode MatMult_MPIFFTW(Mat A,Vec x,Vec y)
126 {
127   PetscErrorCode ierr;
128   Mat_FFT        *fft  = (Mat_FFT*)A->data;
129   Mat_FFTW       *fftw = (Mat_FFTW*)fft->data;
130   PetscScalar    *x_array,*y_array;
131   PetscInt       ndim=fft->ndim,*dim=fft->dim;
132   MPI_Comm       comm=((PetscObject)A)->comm;
133 // PetscInt ctr;
134 //  ptrdiff_t      ndim1=(ptrdiff_t) ndim,*pdim;
135 //  ndim1=(ptrdiff_t) ndim;
136 //  pdim = (ptrdiff_t *)calloc(ndim,sizeof(ptrdiff_t));
137 
138 //  for(ctr=0;ctr<ndim;ctr++)
139 //     {
140 //      pdim[ctr] = dim[ctr];
141 //     }
142 
143   PetscFunctionBegin;
144 #if !defined(PETSC_USE_COMPLEX)
145   SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"not support for real numbers");
146 #endif
147 //  pdim = (ptrdiff_t *)calloc(ndim,sizeof(ptrdiff_t));
148 //  for (ctr=0; ctr<ndim; ctr++) pdim[ctr] = dim[ctr];
149 
150   ierr = VecGetArray(x,&x_array);CHKERRQ(ierr);
151   ierr = VecGetArray(y,&y_array);CHKERRQ(ierr);
152   if (!fftw->p_forward){ /* create a plan, then excute it */
153     switch (ndim){
154     case 1:
155 #if defined(PETSC_USE_COMPLEX)
156       fftw->p_forward = fftw_mpi_plan_dft_1d(dim[0],(fftw_complex*)x_array,(fftw_complex*)y_array,comm,FFTW_FORWARD,fftw->p_flag);
157 #endif
158       break;
159     case 2:
160 #if defined(PETSC_USE_COMPLEX)
161       fftw->p_forward = fftw_mpi_plan_dft_2d(dim[0],dim[1],(fftw_complex*)x_array,(fftw_complex*)y_array,comm,FFTW_FORWARD,fftw->p_flag);
162 #else
163       fftw->p_forward = fftw_mpi_plan_dft_r2c_2d(dim[0],dim[1],(double *)x_array,(fftw_complex*)y_array,comm,FFTW_ESTIMATE);
164 #endif
165       break;
166     case 3:
167 #if defined(PETSC_USE_COMPLEX)
168       fftw->p_forward = fftw_mpi_plan_dft_3d(dim[0],dim[1],dim[2],(fftw_complex*)x_array,(fftw_complex*)y_array,comm,FFTW_FORWARD,fftw->p_flag);
169 #else
170       fftw->p_forward = fftw_mpi_plan_dft_r2c_3d(dim[0],dim[1],dim[3],(double *)x_array,(fftw_complex*)y_array,comm,FFTW_ESTIMATE);
171 #endif
172       break;
173     default:
174 #if defined(PETSC_USE_COMPLEX)
175       fftw->p_forward = fftw_mpi_plan_dft(fftw->ndim_fftw,fftw->dim_fftw,(fftw_complex*)x_array,(fftw_complex*)y_array,comm,FFTW_FORWARD,fftw->p_flag);
176 #else
177       fftw->p_forward = fftw_mpi_plan_dft_r2c(fftw->ndim_fftw,fftw->dim_fftw,(double *)x_array,(fftw_complex*)y_array,comm,FFTW_ESTIMATE);
178 #endif
179  //     fftw->p_forward = fftw_mpi_plan_dft(ndim,dim,(fftw_complex*)x_array,(fftw_complex*)y_array,comm,FFTW_FORWARD,fftw->p_flag);
180       break;
181     }
182     fftw->finarray  = x_array;
183     fftw->foutarray = y_array;
184     /* Warning: if (fftw->p_flag!==FFTW_ESTIMATE) The data in the in/out arrays is overwritten!
185                 planning should be done before x is initialized! See FFTW manual sec2.1 or sec4 */
186     fftw_execute(fftw->p_forward);
187   } else { /* use existing plan */
188     if (fftw->finarray != x_array || fftw->foutarray != y_array){ /* use existing plan on new arrays */
189       fftw_execute_dft(fftw->p_forward,(fftw_complex*)x_array,(fftw_complex*)y_array);
190     } else {
191       fftw_execute(fftw->p_forward);
192     }
193   }
194   ierr = VecRestoreArray(y,&y_array);CHKERRQ(ierr);
195   ierr = VecRestoreArray(x,&x_array);CHKERRQ(ierr);
196   PetscFunctionReturn(0);
197 }
198 
199 #undef __FUNCT__
200 #define __FUNCT__ "MatMultTranspose_MPIFFTW"
201 PetscErrorCode MatMultTranspose_MPIFFTW(Mat A,Vec x,Vec y)
202 {
203   PetscErrorCode ierr;
204   Mat_FFT        *fft  = (Mat_FFT*)A->data;
205   Mat_FFTW       *fftw = (Mat_FFTW*)fft->data;
206   PetscScalar    *x_array,*y_array;
207   PetscInt       ndim=fft->ndim,*dim=fft->dim;
208   MPI_Comm       comm=((PetscObject)A)->comm;
209 //  PetscInt       ctr;
210 //  ptrdiff_t      ndim1=(ptrdiff_t)ndim,*pdim;
211 //  ndim1=(ptrdiff_t) ndim;
212 //  pdim = (ptrdiff_t *)calloc(ndim,sizeof(ptrdiff_t));
213 
214 //  for(ctr=0;ctr<ndim;ctr++)
215 //     {
216 //      pdim[ctr] = dim[ctr];
217 //     }
218 
219   PetscFunctionBegin;
220 //#if !defined(PETSC_USE_COMPLEX)
221 //  SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"not support for real numbers");
222 //#endif
223 //  ierr = PetscMalloc(ndim*sizeof(ptrdiff_t), (ptrdiff_t *)&pdim);CHKERRQ(ierr);
224 // should pdim be a member of Mat_FFTW?
225 //  for (ctr=0; ctr<ndim; ctr++) pdim[ctr] = dim[ctr];
226 
227   ierr = VecGetArray(x,&x_array);CHKERRQ(ierr);
228   ierr = VecGetArray(y,&y_array);CHKERRQ(ierr);
229   if (!fftw->p_backward){ /* create a plan, then excute it */
230     switch (ndim){
231     case 1:
232 #if defined(PETSC_USE_COMPLEX)
233       fftw->p_backward = fftw_mpi_plan_dft_1d(dim[0],(fftw_complex*)x_array,(fftw_complex*)y_array,comm,FFTW_BACKWARD,fftw->p_flag);
234 #endif
235       break;
236     case 2:
237 #if defined(PETSC_USE_COMPLEX)
238       fftw->p_backward = fftw_mpi_plan_dft_2d(dim[0],dim[1],(fftw_complex*)x_array,(fftw_complex*)y_array,comm,FFTW_BACKWARD,fftw->p_flag);
239 #else
240       fftw->p_backward = fftw_mpi_plan_dft_c2r_2d(dim[0],dim[1],(fftw_complex*)x_array,(double *)y_array,comm,FFTW_ESTIMATE);
241 #endif
242       break;
243     case 3:
244 #if defined(PETSC_USE_COMPLEX)
245       fftw->p_backward = fftw_mpi_plan_dft_3d(dim[0],dim[1],dim[2],(fftw_complex*)x_array,(fftw_complex*)y_array,comm,FFTW_BACKWARD,fftw->p_flag);
246 #else
247       fftw->p_backward = fftw_mpi_plan_dft_c2r_3d(dim[0],dim[1],dim[2],(fftw_complex*)x_array,(double *)y_array,comm,FFTW_ESTIMATE);
248 #endif
249       break;
250     default:
251 #if defined(PETSC_USE_COMPLEX)
252       fftw->p_backward = fftw_mpi_plan_dft(fftw->ndim_fftw,fftw->dim_fftw,(fftw_complex*)x_array,(fftw_complex*)y_array,comm,FFTW_BACKWARD,fftw->p_flag);
253 #else
254       fftw->p_backward = fftw_mpi_plan_dft_c2r(fftw->ndim_fftw,fftw->dim_fftw,(fftw_complex*)x_array,(double *)y_array,comm,FFTW_ESTIMATE);
255 #endif
256 //      fftw->p_backward = fftw_mpi_plan_dft(ndim,dim,(fftw_complex*)x_array,(fftw_complex*)y_array,comm,FFTW_BACKWARD,fftw->p_flag);
257       break;
258     }
259     fftw->binarray  = x_array;
260     fftw->boutarray = y_array;
261     fftw_execute(fftw->p_backward);CHKERRQ(ierr);
262   } else { /* use existing plan */
263     if (fftw->binarray != x_array || fftw->boutarray != y_array){ /* use existing plan on new arrays */
264       fftw_execute_dft(fftw->p_backward,(fftw_complex*)x_array,(fftw_complex*)y_array);
265     } else {
266       fftw_execute(fftw->p_backward);CHKERRQ(ierr);
267     }
268   }
269   ierr = VecRestoreArray(y,&y_array);CHKERRQ(ierr);
270   ierr = VecRestoreArray(x,&x_array);CHKERRQ(ierr);
271   PetscFunctionReturn(0);
272 }
273 
274 #undef __FUNCT__
275 #define __FUNCT__ "MatDestroy_FFTW"
276 PetscErrorCode MatDestroy_FFTW(Mat A)
277 {
278   Mat_FFT        *fft = (Mat_FFT*)A->data;
279   Mat_FFTW       *fftw = (Mat_FFTW*)fft->data;
280   PetscErrorCode ierr;
281 
282   PetscFunctionBegin;
283 #if !defined(PETSC_USE_COMPLEX)
284   SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"not support for real numbers");
285 #endif
286   fftw_destroy_plan(fftw->p_forward);
287   fftw_destroy_plan(fftw->p_backward);
288   ierr = PetscFree(fftw->dim_fftw);CHKERRQ(ierr);
289   ierr = PetscFree(fft->data);CHKERRQ(ierr);
290   PetscFunctionReturn(0);
291 }
292 
293 #include <../src/vec/vec/impls/mpi/pvecimpl.h>   /*I  "petscvec.h"   I*/
294 #undef __FUNCT__
295 #define __FUNCT__ "VecDestroy_MPIFFTW"
296 PetscErrorCode VecDestroy_MPIFFTW(Vec v)
297 {
298   PetscErrorCode  ierr;
299   PetscScalar     *array;
300 
301   PetscFunctionBegin;
302 #if !defined(PETSC_USE_COMPLEX)
303   SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"not support for real numbers");
304 #endif
305   ierr = VecGetArray(v,&array);CHKERRQ(ierr);
306   fftw_free((fftw_complex*)array);CHKERRQ(ierr);
307   ierr = VecRestoreArray(v,&array);CHKERRQ(ierr);
308   ierr = VecDestroy_MPI(v);CHKERRQ(ierr);
309   PetscFunctionReturn(0);
310 }
311 
312 #undef __FUNCT__
313 #define __FUNCT__ "MatGetVecs1DC_FFTW"
314 /*
315    MatGetVecs_FFTW1D - Get Vectors(s) compatible with matrix, i.e. with the
316      parallel layout determined by FFTW-1D
317 
318 */
319 PetscErrorCode  MatGetVecs_FFTW1D(Mat A,Vec *fin,Vec *fout,Vec *bin,Vec *bout)
320 {
321   PetscErrorCode ierr;
322   PetscMPIInt    size,rank;
323   MPI_Comm       comm=((PetscObject)A)->comm;
324   Mat_FFT        *fft = (Mat_FFT*)A->data;
325 //  Mat_FFTW       *fftw = (Mat_FFTW*)fft->data;
326   PetscInt       N=fft->N;
327   PetscInt       ndim=fft->ndim,*dim=fft->dim;
328   ptrdiff_t      f_alloc_local,f_local_n0,f_local_0_start;
329   ptrdiff_t      f_local_n1,f_local_1_end;
330   ptrdiff_t      b_alloc_local,b_local_n0,b_local_0_start;
331   ptrdiff_t      b_local_n1,b_local_1_end;
332   fftw_complex   *data_fin,*data_fout,*data_bin,*data_bout;
333 
334   PetscFunctionBegin;
335 #if !defined(PETSC_USE_COMPLEX)
336   SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"not support for real numbers");
337 #endif
338   ierr = MPI_Comm_size(comm, &size);CHKERRQ(ierr);
339   ierr = MPI_Comm_rank(comm, &rank);CHKERRQ(ierr);
340   if (size == 1){
341     SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"Works only for parallel 1D");
342   }
343   else {
344       if (ndim>1){
345         SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"Works only for parallel 1D");}
346       else {
347           f_alloc_local = fftw_mpi_local_size_1d(dim[0],comm,FFTW_FORWARD,FFTW_ESTIMATE,&f_local_n0,&f_local_0_start,&f_local_n1,&f_local_1_end);
348           b_alloc_local = fftw_mpi_local_size_1d(dim[0],comm,FFTW_BACKWARD,FFTW_ESTIMATE,&b_local_n0,&b_local_0_start,&b_local_n1,&b_local_1_end);
349           if (fin) {
350             data_fin  = (fftw_complex*)fftw_malloc(sizeof(fftw_complex)*f_alloc_local);
351             ierr = VecCreateMPIWithArray(comm,f_local_n0,N,(const PetscScalar*)data_fin,fin);CHKERRQ(ierr);
352             (*fin)->ops->destroy   = VecDestroy_MPIFFTW;
353           }
354           if (fout) {
355             data_fout = (fftw_complex*)fftw_malloc(sizeof(fftw_complex)*f_alloc_local);
356             ierr = VecCreateMPIWithArray(comm,f_local_n1,N,(const PetscScalar*)data_fout,fout);CHKERRQ(ierr);
357             (*fout)->ops->destroy   = VecDestroy_MPIFFTW;
358           }
359           if (bin) {
360             data_bin  = (fftw_complex*)fftw_malloc(sizeof(fftw_complex)*b_alloc_local);
361             ierr = VecCreateMPIWithArray(comm,b_local_n0,N,(const PetscScalar*)data_bin,bin);CHKERRQ(ierr);
362             (*bin)->ops->destroy   = VecDestroy_MPIFFTW;
363           }
364           if (bout) {
365             data_bout = (fftw_complex*)fftw_malloc(sizeof(fftw_complex)*b_alloc_local);
366             ierr = VecCreateMPIWithArray(comm,b_local_n1,N,(const PetscScalar*)data_bout,bout);CHKERRQ(ierr);
367             (*bout)->ops->destroy   = VecDestroy_MPIFFTW;
368           }
369   }
370   if (fin){
371     ierr = PetscLayoutReference(A->cmap,&(*fin)->map);CHKERRQ(ierr);
372   }
373   if (fout){
374     ierr = PetscLayoutReference(A->rmap,&(*fout)->map);CHKERRQ(ierr);
375   }
376   if (bin){
377     ierr = PetscLayoutReference(A->rmap,&(*bin)->map);CHKERRQ(ierr);
378   }
379   if (bout){
380     ierr = PetscLayoutReference(A->rmap,&(*bout)->map);CHKERRQ(ierr);
381   }
382   PetscFunctionReturn(0);
383 }
384 
385 
386 }
387 
388 #undef __FUNCT__
389 #define __FUNCT__ "MatGetVecs_FFTW"
390 /*
391    MatGetVecs_FFTW - Get vector(s) compatible with the matrix, i.e. with the
392      parallel layout determined by FFTW
393 
394    Collective on Mat
395 
396    Input Parameter:
397 .  mat - the matrix
398 
399    Output Parameter:
400 +   fin - (optional) input vector of forward FFTW
401 -   fout - (optional) output vector of forward FFTW
402 
403   Level: advanced
404 
405 .seealso: MatCreateFFTW()
406 */
407 PetscErrorCode  MatGetVecs_FFTW(Mat A,Vec *fin,Vec *fout)
408 {
409   PetscErrorCode ierr;
410   PetscMPIInt    size,rank;
411   MPI_Comm       comm=((PetscObject)A)->comm;
412   Mat_FFT        *fft = (Mat_FFT*)A->data;
413   Mat_FFTW       *fftw = (Mat_FFTW*)fft->data;
414   PetscInt       N=fft->N, N1, n1,vsize;
415 
416   PetscFunctionBegin;
417 //#if !defined(PETSC_USE_COMPLEX)
418 //  SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"not support for real numbers");
419 //#endif
420   PetscValidHeaderSpecific(A,MAT_CLASSID,1);
421   PetscValidType(A,1);
422 
423   ierr = MPI_Comm_size(comm, &size);CHKERRQ(ierr);
424   ierr = MPI_Comm_rank(comm, &rank);CHKERRQ(ierr);
425   if (size == 1){ /* sequential case */
426     if (fin) {ierr = VecCreateSeq(PETSC_COMM_SELF,N,fin);CHKERRQ(ierr);}
427     if (fout){ierr = VecCreateSeq(PETSC_COMM_SELF,N,fout);CHKERRQ(ierr);}
428     printf("The code successfully comes at the end of the routine with one processor\n");
429   } else {        /* mpi case */
430     ptrdiff_t      alloc_local,local_n0,local_0_start;
431     ptrdiff_t      local_n1,local_1_end;
432     PetscInt       ndim=fft->ndim,*dim=fft->dim,n=fft->n;
433     fftw_complex   *data_fin,*data_fout;
434     double         *data_finr, *data_foutr;
435     ptrdiff_t local_1_start;
436     PetscInt N1;
437 //    PetscInt ctr;
438 //    ptrdiff_t      ndim1,*pdim;
439 //    ndim1=(ptrdiff_t) ndim;
440 //    pdim = (ptrdiff_t *)calloc(ndim,sizeof(ptrdiff_t));
441 
442 //    for(ctr=0;ctr<ndim;ctr++)
443 //        {
444 //           pdim[ctr] = dim[ctr];
445 //       }
446 
447     switch (ndim){
448     case 1:
449       /* Get local size */
450       /* We need to write an error message here saying that one cannot call this routine when doing paralllel 1D complex FFTW */
451 //      SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"Works only for parallel Multi-dimensional FFTW, Dimension>1. Check Documentation for MatGetVecs_FFTW1D routine");
452       alloc_local = fftw_mpi_local_size_1d(dim[0],comm,FFTW_FORWARD,FFTW_ESTIMATE,&local_n0,&local_0_start,&local_n1,&local_1_end);
453       if (fin) {
454         data_fin  = (fftw_complex*)fftw_malloc(sizeof(fftw_complex)*alloc_local);
455         ierr = VecCreateMPIWithArray(comm,local_n0,N,(const PetscScalar*)data_fin,fin);CHKERRQ(ierr);
456         (*fin)->ops->destroy   = VecDestroy_MPIFFTW;
457       }
458       if (fout) {
459         data_fout = (fftw_complex*)fftw_malloc(sizeof(fftw_complex)*alloc_local);
460         ierr = VecCreateMPIWithArray(comm,local_n1,N,(const PetscScalar*)data_fout,fout);CHKERRQ(ierr);
461         (*fout)->ops->destroy   = VecDestroy_MPIFFTW;
462       }
463       break;
464     case 2:
465 #if !defined(PETSC_USE_COMPLEX)
466       alloc_local =  fftw_mpi_local_size_2d_transposed(dim[0],dim[1]/2+1,comm,&local_n0,&local_0_start,&local_n1,&local_1_start);
467       N1 = 2*dim[0]*(dim[1]/2+1); n1 = 2*local_n0*(dim[1]/2+1);
468       if (fin) {
469         data_finr=(double *)fftw_malloc(sizeof(double)*alloc_local*2);
470         ierr = VecCreateMPIWithArray(PETSC_COMM_WORLD,n1,N1,(PetscScalar*)data_finr,fin);CHKERRQ(ierr);
471         ierr = VecGetSize(*fin,&vsize);CHKERRQ(ierr);
472         //printf("The code comes here with vector size %d\n",vsize);
473         (*fin)->ops->destroy   = VecDestroy_MPIFFTW;
474       }
475       if (fout) {
476         data_fout=(fftw_complex *)fftw_malloc(sizeof(fftw_complex)*alloc_local);
477         ierr = VecCreateMPIWithArray(PETSC_COMM_WORLD,n1,N1,(PetscScalar*)data_fout,fout);CHKERRQ(ierr);
478         (*fout)->ops->destroy   = VecDestroy_MPIFFTW;
479       }
480       printf("Vector size from fftw.c is  %d\n",N1);
481 
482 #else
483       /* Get local size */
484      printf("Hope this does not come here");
485       alloc_local = fftw_mpi_local_size_2d(dim[0],dim[1],comm,&local_n0,&local_0_start);
486       if (fin) {
487         data_fin  = (fftw_complex*)fftw_malloc(sizeof(fftw_complex)*alloc_local);
488         ierr = VecCreateMPIWithArray(comm,n,N,(const PetscScalar*)data_fin,fin);CHKERRQ(ierr);
489         (*fin)->ops->destroy   = VecDestroy_MPIFFTW;
490       }
491       if (fout) {
492         data_fout = (fftw_complex*)fftw_malloc(sizeof(fftw_complex)*alloc_local);
493         ierr = VecCreateMPIWithArray(comm,n,N,(const PetscScalar*)data_fout,fout);CHKERRQ(ierr);
494         (*fout)->ops->destroy   = VecDestroy_MPIFFTW;
495       }
496      printf("Hope this does not come here");
497 #endif
498       break;
499     case 3:
500       /* Get local size */
501 #if !defined(PETSC_USE_COMPLEX)
502   SETERRQ(comm,PETSC_ERR_SUP,"Not done yet");
503 #else
504       alloc_local = fftw_mpi_local_size_3d(dim[0],dim[1],dim[2],comm,&local_n0,&local_0_start);
505 //      printf("The quantity n is %d",n);
506       if (fin) {
507         data_fin  = (fftw_complex*)fftw_malloc(sizeof(fftw_complex)*alloc_local);
508         ierr = VecCreateMPIWithArray(comm,n,N,(const PetscScalar*)data_fin,fin);CHKERRQ(ierr);
509         (*fin)->ops->destroy   = VecDestroy_MPIFFTW;
510       }
511       if (fout) {
512         data_fout = (fftw_complex*)fftw_malloc(sizeof(fftw_complex)*alloc_local);
513         ierr = VecCreateMPIWithArray(comm,n,N,(const PetscScalar*)data_fout,fout);CHKERRQ(ierr);
514         (*fout)->ops->destroy   = VecDestroy_MPIFFTW;
515       }
516 #endif
517       break;
518     default:
519       /* Get local size */
520 #if !defined(PETSC_USE_COMPLEX)
521   SETERRQ(comm,PETSC_ERR_SUP,"Not done yet");
522 #else
523       alloc_local = fftw_mpi_local_size(fftw->ndim_fftw,fftw->dim_fftw,comm,&local_n0,&local_0_start);
524 //      printf("The value of alloc local is %d from process %d\n",alloc_local,rank);
525 //      printf("The value of alloc local is %d",alloc_local);
526 //      pdim=(ptrdiff_t *)calloc(ndim,sizeof(ptrdiff_t));
527 //      for(i=0;i<ndim;i++)
528 //         {
529 //          pdim[i]=dim[i];printf("%d",pdim[i]);
530 //         }
531 //      alloc_local = fftw_mpi_local_size(ndim,pdim,comm,&local_n0,&local_0_start);
532 //      printf("The quantity n is %d",n);
533       if (fin) {
534         data_fin  = (fftw_complex*)fftw_malloc(sizeof(fftw_complex)*alloc_local);
535         ierr = VecCreateMPIWithArray(comm,n,N,(const PetscScalar*)data_fin,fin);CHKERRQ(ierr);
536         (*fin)->ops->destroy   = VecDestroy_MPIFFTW;
537       }
538       if (fout) {
539         data_fout = (fftw_complex*)fftw_malloc(sizeof(fftw_complex)*alloc_local);
540         ierr = VecCreateMPIWithArray(comm,n,N,(const PetscScalar*)data_fout,fout);CHKERRQ(ierr);
541         (*fout)->ops->destroy   = VecDestroy_MPIFFTW;
542       }
543 #endif
544       break;
545     }
546   }
547   if (fin){
548     ierr = PetscLayoutReference(A->cmap,&(*fin)->map);CHKERRQ(ierr);
549   }
550   if (fout){
551     ierr = PetscLayoutReference(A->rmap,&(*fout)->map);CHKERRQ(ierr);
552   }
553   PetscFunctionReturn(0);
554 }
555 
556 //EXTERN_C_BEGIN - Do we need this?
557 #undef __FUNCT__
558 #define __FUNCT__ "InputTransformFFT"
559 PetscErrorCode InputTransformFFT(Mat A,Vec x,Vec y)
560 {
561   PetscErrorCode ierr;
562   PetscFunctionBegin;
563   ierr = PetscTryMethod(A,"InputTransformFFT_C",(Mat,Vec,Vec),(A,x,y));CHKERRQ(ierr);
564   PetscFunctionReturn(0);
565 }
566 //EXTERN_C_END - Do we need this?
567 /*
568       InputTransformFFT_FFTW - Copies the user data to the vector that goes into FFTW block
569   Input A, x, y
570   A - FFTW matrix
571   x - user d
572   Options Database Keys:
573 + -mat_fftw_plannerflags - set FFTW planner flags
574 
575    Level: intermediate
576 
577 */
578 
579 EXTERN_C_BEGIN
580 #undef __FUNCT__
581 #define __FUNCT__ "InputTransformFFT_FTTW"
582 PetscErrorCode InputTransformFFT_FFTW(Mat A,Vec x,Vec y)
583 {
584   PetscErrorCode ierr;
585   MPI_Comm       comm=((PetscObject)A)->comm;
586   Mat_FFT        *fft = (Mat_FFT*)A->data;
587   Mat_FFTW       *fftw = (Mat_FFTW*)fft->data;
588   PetscInt       N=fft->N, N1, n1 ,NM;
589   PetscInt       ndim=fft->ndim,*dim=fft->dim,n=fft->n;
590   PetscInt       low, *indx1, *indx2, tempindx, tempindx1;
591   PetscInt       i,j;
592   ptrdiff_t      alloc_local,local_n0,local_0_start;
593   ptrdiff_t      local_n1,local_1_start;
594   VecScatter     vecscat;
595   IS             list1,list2;
596 
597   ierr = VecGetOwnershipRange(y,&low,PETSC_NULL);
598 
599  switch (ndim){
600  case 1:
601   SETERRQ(comm,PETSC_ERR_SUP,"Not Supported by FFTW");
602   break;
603  case 2:
604       alloc_local =  fftw_mpi_local_size_2d_transposed(dim[0],dim[1]/2+1,comm,&local_n0,&local_0_start,&local_n1,&local_1_start);
605       N1 = 2*dim[0]*(dim[1]/2+1); n1 = 2*local_n0*(dim[1]/2+1);
606 
607      ierr = PetscMalloc(sizeof(PetscInt)*local_n0*N1,&indx1);CHKERRQ(ierr);
608      ierr = PetscMalloc(sizeof(PetscInt)*local_n0*N1,&indx2);CHKERRQ(ierr);
609 
610      if (dim[1]%2==0)
611       NM = dim[1]+2;
612     else
613       NM = dim[1]+1;
614 
615      for (i=0;i<local_n0;i++){
616         for (j=0;j<dim[1];j++){
617             tempindx = i*dim[1] + j;
618             tempindx1 = i*NM + j;
619             indx1[tempindx]=local_0_start*N1+tempindx;
620             indx2[tempindx]=low+tempindx1;
621   //          printf("index3 %d from proc %d is \n",indx3[tempindx],rank);
622   //          printf("index4 %d from proc %d is \n",indx4[tempindx],rank);
623         }
624      }
625 
626      ierr = ISCreateGeneral(comm,local_n0*dim[1],indx1,PETSC_COPY_VALUES,&list1);CHKERRQ(ierr);
627      ierr = ISCreateGeneral(comm,local_n0*dim[1],indx2,PETSC_COPY_VALUES,&list2);CHKERRQ(ierr);
628 
629      ierr = VecScatterCreate(x,list1,y,list2,&vecscat);
630      ierr = VecScatterBegin(vecscat,x,y,INSERT_VALUES,SCATTER_FORWARD);
631      ierr = VecScatterEnd(vecscat,x,y,INSERT_VALUES,SCATTER_FORWARD);
632      ierr = VecScatterDestroy(&vecscat);
633      break;
634 
635  case 3:
636   SETERRQ(comm,PETSC_ERR_SUP,"Not Done Yet");
637   break;
638 
639  default:
640   SETERRQ(comm,PETSC_ERR_SUP,"Not Done Yet");
641   break;
642  }
643 
644  return 0;
645 }
646 EXTERN_C_END
647 
648 /*
649 //EXTERN_C_BEGIN - Do we need this?
650 #undef __FUNCT__
651 #define __FUNCT__ "OutputTransformFFT"
652 PetscErrorCode OutputTransformFFT(Mat A,Vec x,Vec y)
653 {
654   PetscErrorCode ierr;
655   PetscFunctionBegin;
656   ierr = PetscTryMethod(A,"OutputTransformFFT_C",(Mat,Vec,Vec),(A,x,y));CHKERRQ(ierr);
657   PetscFunctionReturn(0);
658 }
659 //EXTERN_C_END - Do we need this?
660 */
661 
662 EXTERN_C_BEGIN
663 #undef __FUNCT__
664 #define __FUNCT__ "MatCreate_FFTW"
665 /*
666       MatCreate_FFTW - Creates a matrix object that provides FFT
667   via the external package FFTW
668   Options Database Keys:
669 + -mat_fftw_plannerflags - set FFTW planner flags
670 
671    Level: intermediate
672 
673 */
674 
675 PetscErrorCode MatCreate_FFTW(Mat A)
676 {
677   PetscErrorCode ierr;
678   MPI_Comm       comm=((PetscObject)A)->comm;
679   Mat_FFT        *fft=(Mat_FFT*)A->data;
680   Mat_FFTW       *fftw;
681   PetscInt       n=fft->n,N=fft->N,ndim=fft->ndim,*dim = fft->dim;
682   const char     *p_flags[]={"FFTW_ESTIMATE","FFTW_MEASURE","FFTW_PATIENT","FFTW_EXHAUSTIVE"};
683   PetscBool      flg;
684   PetscInt       p_flag,partial_dim=1,ctr;
685   PetscMPIInt    size,rank;
686   ptrdiff_t      *pdim;
687 
688   PetscFunctionBegin;
689 //#if !defined(PETSC_USE_COMPLEX)
690 //  SETERRQ(comm,PETSC_ERR_SUP,"not support for real numbers");
691 //#endif
692 
693   ierr = MPI_Comm_size(comm, &size);CHKERRQ(ierr);
694   ierr = MPI_Comm_rank(comm, &rank);CHKERRQ(ierr);
695 
696   pdim = (ptrdiff_t *)calloc(ndim,sizeof(ptrdiff_t));
697   pdim[0] = dim[0];
698   for(ctr=1;ctr<ndim;ctr++)
699       {
700           partial_dim *= dim[ctr];
701           pdim[ctr] = dim[ctr];
702       }
703 //#if !defined(PETSC_USE_COMPLEX)
704 //  SETERRQ(comm,PETSC_ERR_SUP,"not support for real numbers");
705 //#endif
706 
707 //  printf("partial dimension is %d",partial_dim);
708   if (size == 1) {
709     ierr = MatSetSizes(A,N,N,N,N);CHKERRQ(ierr);
710     n = N;
711   } else {
712     ptrdiff_t alloc_local,local_n0,local_0_start,local_n1,local_1_end;
713     switch (ndim){
714     case 1:
715 #if !defined(PETSC_USE_COMPLEX)
716   SETERRQ(comm,PETSC_ERR_SUP,"FFTW does not support parallel 1D real transform");
717 #endif
718       alloc_local = fftw_mpi_local_size_1d(dim[0],comm,FFTW_FORWARD,FFTW_ESTIMATE,&local_n0,&local_0_start,&local_n1,&local_1_end);
719       n = (PetscInt)local_n0;
720       ierr = MatSetSizes(A,n,n,N,N);CHKERRQ(ierr);
721 //      PetscObjectComposeFunctionDynamic((PetscObject)A,"MatGetVecs1DC_C","MatGetVecs1DC_FFTW",MatGetVecs1DC_FFTW);
722       break;
723     case 2:
724       alloc_local = fftw_mpi_local_size_2d(dim[0],dim[1],comm,&local_n0,&local_0_start);
725       /*
726        PetscMPIInt    rank;
727        PetscSynchronizedPrintf(comm,"[%d] MatCreateSeqFFTW: local_n0, local_0_start %d %d, N %d,dim %d, %d\n",rank,(PetscInt)local_n0*dim[1],(PetscInt)local_0_start,m,dim[0],dim[1]);
728        PetscSynchronizedFlush(comm);
729        */
730       n = (PetscInt)local_n0*dim[1];
731       ierr = MatSetSizes(A,n,n,N,N);CHKERRQ(ierr);
732       break;
733     case 3:
734 //      printf("The value of alloc local is %d",alloc_local);
735       n = (PetscInt)local_n0*dim[1]*dim[2];
736       ierr = MatSetSizes(A,n,n,N,N);CHKERRQ(ierr);
737       break;
738     default:
739       alloc_local = fftw_mpi_local_size(ndim,pdim,comm,&local_n0,&local_0_start);
740 //      printf("The value of alloc local is %ld from process %d\n",alloc_local,rank);
741 //      alloc_local = fftw_mpi_local_size(ndim,dim,comm,&local_n0,&local_0_start);
742       n = (PetscInt)local_n0*partial_dim;
743 //      printf("New partial dimension is %d %d %d",n,N,ndim);
744       ierr = MatSetSizes(A,n,n,N,N);CHKERRQ(ierr);
745       break;
746     }
747   }
748   ierr = PetscObjectChangeTypeName((PetscObject)A,MATFFTW);CHKERRQ(ierr);
749 
750   ierr = PetscNewLog(A,Mat_FFTW,&fftw);CHKERRQ(ierr);
751   fft->data = (void*)fftw;
752 
753   fft->n           = n;
754   fftw->ndim_fftw  = (ptrdiff_t)ndim; // This is dimension of fft
755   ierr = PetscMalloc(ndim*sizeof(ptrdiff_t), (ptrdiff_t *)&(fftw->dim_fftw));CHKERRQ(ierr);
756   for(ctr=0;ctr<ndim;ctr++) (fftw->dim_fftw)[ctr]=dim[ctr];
757 
758   fftw->p_forward  = 0;
759   fftw->p_backward = 0;
760   fftw->p_flag     = FFTW_ESTIMATE;
761 
762   if (size == 1){
763     A->ops->mult          = MatMult_SeqFFTW;
764     A->ops->multtranspose = MatMultTranspose_SeqFFTW;
765   } else {
766     A->ops->mult          = MatMult_MPIFFTW;
767     A->ops->multtranspose = MatMultTranspose_MPIFFTW;
768   }
769   fft->matdestroy          = MatDestroy_FFTW;
770   A->ops->getvecs       = MatGetVecs_FFTW;
771   A->assembled          = PETSC_TRUE;
772 #if !defined(PETSC_USE_COMPLEX)
773   PetscObjectComposeFunctionDynamic((PetscObject)A,"InputTransformFFT_C","InputTransformFFT_FFTW",InputTransformFFT_FFTW);
774 //  PetscObjectComposeFunctionDynamic((PetscObject)A,"OutputTransformFFT_C","OutputTransformFFT_FFTW",OutputTransformFFT_FFTW);
775 #endif
776 
777   /* get runtime options */
778   ierr = PetscOptionsBegin(((PetscObject)A)->comm,((PetscObject)A)->prefix,"FFTW Options","Mat");CHKERRQ(ierr);
779     ierr = PetscOptionsEList("-mat_fftw_plannerflags","Planner Flags","None",p_flags,4,p_flags[0],&p_flag,&flg);CHKERRQ(ierr);
780     if (flg) {fftw->p_flag = (unsigned)p_flag;}
781   PetscOptionsEnd();
782   PetscFunctionReturn(0);
783 }
784 EXTERN_C_END
785 
786 
787 
788 
789