source: palm/trunk/SOURCE/poisfft_mod.f90 @ 1851

Last change on this file since 1851 was 1851, checked in by maronga, 5 years ago

last commit documented

  • Property svn:keywords set to Id
File size: 45.6 KB
Line 
1!> @file poisfft_mod.f90
2!--------------------------------------------------------------------------------!
3! This file is part of PALM.
4!
5! PALM is free software: you can redistribute it and/or modify it under the terms
6! of the GNU General Public License as published by the Free Software Foundation,
7! either version 3 of the License, or (at your option) any later version.
8!
9! PALM is distributed in the hope that it will be useful, but WITHOUT ANY
10! WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
11! A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
12!
13! You should have received a copy of the GNU General Public License along with
14! PALM. If not, see <http://www.gnu.org/licenses/>.
15!
16! Copyright 1997-2014  Leibniz Universitaet Hannover
17!--------------------------------------------------------------------------------!
18!
19! Current revisions:
20! -----------------
21!
22!
23! Former revisions:
24! -----------------
25! $Id: poisfft_mod.f90 1851 2016-04-08 13:32:50Z maronga $
26!
27! 1850 2016-04-08 13:29:27Z maronga
28! Module renamed
29!
30!
31! 1804 2016-04-05 16:30:18Z maronga
32! Removed code for parameter file check (__check)
33!
34! 1682 2015-10-07 23:56:08Z knoop
35! Code annotations made doxygen readable
36!
37! 1482 2014-10-18 12:34:45Z raasch
38! use 2d-decomposition, if accelerator boards are used
39!
40! 1406 2014-05-16 13:47:01Z raasch
41! bugfix for pgi 14.4: declare create moved after array declaration
42!
43! 1320 2014-03-20 08:40:49Z raasch
44! ONLY-attribute added to USE-statements,
45! kind-parameters added to all INTEGER and REAL declaration statements,
46! kinds are defined in new module kinds,
47! old module precision_kind is removed,
48! revision history before 2012 removed,
49! comment fields (!:) to be used for variable explanations added to
50! all variable declaration statements
51!
52! 1318 2014-03-17 13:35:16Z raasch
53! module interfaces removed
54!
55! 1306 2014-03-13 14:30:59Z raasch
56! openmp sections removed from the overlap branch,
57! second argument removed from parameter list
58!
59! 1216 2013-08-26 09:31:42Z raasch
60! resorting of arrays moved to separate routines resort_for_...,
61! one argument, used as temporary work array, removed from all transpose
62! routines
63! overlapping fft / transposition implemented
64!
65! 1212 2013-08-15 08:46:27Z raasch
66! tridia routines moved to seperate module tridia_solver
67!
68! 1208 2013-08-13 06:41:49Z raasch
69! acc-update clauses added for "ar" so that ffts other than cufft can also be
70! used (although they are not ported and will give a poor performance)
71!
72! 1111 2013-03-08 23:54:10Z raasch
73! further openACC porting of non-parallel (MPI) branch:
74! tridiagonal routines split into extermal subroutines (instead using CONTAINS),
75! no distinction between parallel/non-parallel in poisfft and tridia any more,
76! tridia routines moved to end of file because of probable bug in PGI compiler 12.5
77! (otherwise "invalid device function" is indicated during runtime),
78! optimization of tridia routines: constant elements and coefficients of tri are
79! stored in seperate arrays ddzuw and tric, last dimension of tri reduced from 5
80! to 2,
81! poisfft_init is now called internally from poisfft, maketri is called from
82! poisfft_init,
83! ibc_p_b = 2 removed
84!
85! 1106 2013-03-04 05:31:38Z raasch
86! routines fftx, ffty, fftxp, fftyp removed, calls replaced by fft_x, fft_y,
87! in the 1D-decomposition routines fft_x, ffty are replaced by fft_x_1d,
88! fft_y_1d
89!
90! 1103 2013-02-20 02:15:53Z raasch
91! tri, ar, and ar1 arguments in tridia-routines (2d) are removed because they
92! sometimes cause segmentation faults with intel 12.1 compiler
93!
94! 1092 2013-02-02 11:24:22Z raasch
95! unused variables removed
96!
97! 1036 2012-10-22 13:43:42Z raasch
98! code put under GPL (PALM 3.9)
99!
100! 2012-09-21 07:03:55Z raasch
101! FLOAT type conversion replaced by REAL
102!
103! 1003 2012-09-14 14:35:53Z raasch
104! indices nxa, nya, etc. replaced by nx, ny, etc.
105!
106! 940 2012-07-09 14:31:00Z raasch
107! special handling of tri-array as an argument in tridia_1dd routines switched
108! off because it caused segmentation faults with intel 12.1 compiler
109!
110! 877 2012-04-03 11:21:44Z suehring
111! Bugfix: Avoid divisions by zero in case of using a 'neumann' bc for the
112! pressure at the top of the model domain.
113!
114! 809 2012-01-30 13:32:58Z maronga
115! Bugfix: replaced .AND. and .NOT. with && and ! in the preprocessor directives
116!
117! 807 2012-01-25 11:53:51Z maronga
118! New cpp directive "__check" implemented which is used by check_namelist_files
119! (most of the code is unneeded by check_namelist_files).
120!
121! Revision 1.1  1997/07/24 11:24:14  raasch
122! Initial revision
123!
124!
125! Description:
126! ------------
127!> Solves the Poisson equation with a 2D spectral method
128!>        d^2 p / dx^2 + d^2 p / dy^2 + d^2 p / dz^2 = s
129!>
130!> Input:
131!> real    ar   contains (nnz,nny,nnx) elements of the velocity divergence,
132!>              starting from (1,nys,nxl)
133!>
134!> Output:
135!> real    ar   contains the solution for perturbation pressure p
136!------------------------------------------------------------------------------!
137 MODULE poisfft_mod
138 
139
140    USE fft_xy,                                                                &
141        ONLY:  fft_init, fft_y, fft_y_1d, fft_y_m, fft_x, fft_x_1d, fft_x_m
142
143    USE indices,                                                               &
144        ONLY:  nnx, nny, nx, nxl, nxr, ny, nys, nyn, nz
145
146    USE transpose_indices,                                                     &
147        ONLY:  nxl_y, nxl_z, nxr_y, nxr_z, nys_x, nys_z, nyn_x, nyn_z, nzb_x,  &
148               nzb_y, nzt_x, nzt_y
149
150    USE tridia_solver,                                                         &
151        ONLY:  tridia_1dd, tridia_init, tridia_substi, tridia_substi_overlap
152
153    IMPLICIT NONE
154
155    LOGICAL, SAVE ::  poisfft_initialized = .FALSE.
156
157    PRIVATE
158
159    PUBLIC  poisfft, poisfft_init
160
161    INTERFACE poisfft
162       MODULE PROCEDURE poisfft
163    END INTERFACE poisfft
164
165    INTERFACE poisfft_init
166       MODULE PROCEDURE poisfft_init
167    END INTERFACE poisfft_init
168
169
170 CONTAINS
171
172!------------------------------------------------------------------------------!
173! Description:
174! ------------
175!> @todo Missing subroutine description.
176!------------------------------------------------------------------------------!
177    SUBROUTINE poisfft_init
178
179       USE arrays_3d,                                                          &
180           ONLY:  ddzu_pres, ddzw
181
182       USE kinds
183
184       IMPLICIT NONE
185
186       INTEGER(iwp) ::  k  !<
187
188
189       CALL fft_init
190
191       CALL tridia_init
192
193       poisfft_initialized = .TRUE.
194
195    END SUBROUTINE poisfft_init
196
197
198
199!------------------------------------------------------------------------------!
200! Description:
201! ------------
202!> Two-dimensional Fourier Transformation in x- and y-direction.
203!------------------------------------------------------------------------------!
204    SUBROUTINE poisfft( ar )
205
206       USE control_parameters,                                                 &
207           ONLY:  fft_method, transpose_compute_overlap
208
209       USE cpulog,                                                             &
210           ONLY:  cpu_log, cpu_log_nowait, log_point_s
211
212       USE kinds
213
214       USE pegrid
215
216       IMPLICIT NONE
217
218       INTEGER(iwp) ::  ii           !<
219       INTEGER(iwp) ::  iind         !<
220       INTEGER(iwp) ::  inew         !<
221       INTEGER(iwp) ::  jj           !<
222       INTEGER(iwp) ::  jind         !<
223       INTEGER(iwp) ::  jnew         !<
224       INTEGER(iwp) ::  ki           !<
225       INTEGER(iwp) ::  kk           !<
226       INTEGER(iwp) ::  knew         !<
227       INTEGER(iwp) ::  n            !<
228       INTEGER(iwp) ::  nblk         !<
229       INTEGER(iwp) ::  nnx_y        !<
230       INTEGER(iwp) ::  nny_z        !<
231       INTEGER(iwp) ::  nnz_t        !<
232       INTEGER(iwp) ::  nnz_x        !<
233       INTEGER(iwp) ::  nxl_y_bound  !<
234       INTEGER(iwp) ::  nxr_y_bound  !<
235
236       INTEGER(iwp), DIMENSION(4) ::  isave  !<
237
238       REAL(wp), DIMENSION(1:nz,nys:nyn,nxl:nxr) ::  ar      !<
239       REAL(wp), DIMENSION(nys:nyn,nxl:nxr,1:nz) ::  ar_inv  !<
240       !$acc declare create( ar_inv )
241
242       REAL(wp), DIMENSION(:,:,:),   ALLOCATABLE ::  ar1      !<
243       REAL(wp), DIMENSION(:,:,:),   ALLOCATABLE ::  f_in     !<
244       REAL(wp), DIMENSION(:,:,:),   ALLOCATABLE ::  f_inv    !<
245       REAL(wp), DIMENSION(:,:,:),   ALLOCATABLE ::  f_out_y  !<
246       REAL(wp), DIMENSION(:,:,:),   ALLOCATABLE ::  f_out_z  !<
247
248
249       CALL cpu_log( log_point_s(3), 'poisfft', 'start' )
250
251       IF ( .NOT. poisfft_initialized )  CALL poisfft_init
252
253!
254!--    Two-dimensional Fourier Transformation in x- and y-direction.
255       IF ( pdims(2) == 1  .AND.  pdims(1) > 1  .AND.  num_acc_per_node == 0 ) &
256       THEN
257
258!
259!--       1d-domain-decomposition along x:
260!--       FFT along y and transposition y --> x
261          CALL ffty_tr_yx( ar, ar )
262
263!
264!--       FFT along x, solving the tridiagonal system and backward FFT
265          CALL fftx_tri_fftx( ar )
266
267!
268!--       Transposition x --> y and backward FFT along y
269          CALL tr_xy_ffty( ar, ar )
270
271       ELSEIF ( pdims(1) == 1 .AND. pdims(2) > 1 .AND. num_acc_per_node == 0 ) &
272       THEN
273
274!
275!--       1d-domain-decomposition along y:
276!--       FFT along x and transposition x --> y
277          CALL fftx_tr_xy( ar, ar )
278
279!
280!--       FFT along y, solving the tridiagonal system and backward FFT
281          CALL ffty_tri_ffty( ar )
282
283!
284!--       Transposition y --> x and backward FFT along x
285          CALL tr_yx_fftx( ar, ar )
286
287       ELSEIF ( .NOT. transpose_compute_overlap )  THEN
288
289!
290!--       2d-domain-decomposition or no decomposition (1 PE run)
291!--       Transposition z --> x
292          CALL cpu_log( log_point_s(5), 'transpo forward', 'start' )
293          CALL resort_for_zx( ar, ar_inv )
294          CALL transpose_zx( ar_inv, ar )
295          CALL cpu_log( log_point_s(5), 'transpo forward', 'pause' )
296
297          CALL cpu_log( log_point_s(4), 'fft_x', 'start' )
298          IF ( fft_method /= 'system-specific' )  THEN
299             !$acc update host( ar )
300          ENDIF
301          CALL fft_x( ar, 'forward' )
302          IF ( fft_method /= 'system-specific' )  THEN
303             !$acc update device( ar )
304          ENDIF
305          CALL cpu_log( log_point_s(4), 'fft_x', 'pause' )
306
307!
308!--       Transposition x --> y
309          CALL cpu_log( log_point_s(5), 'transpo forward', 'continue' )
310          CALL resort_for_xy( ar, ar_inv )
311          CALL transpose_xy( ar_inv, ar )
312          CALL cpu_log( log_point_s(5), 'transpo forward', 'pause' )
313
314          CALL cpu_log( log_point_s(7), 'fft_y', 'start' )
315          IF ( fft_method /= 'system-specific' )  THEN
316             !$acc update host( ar )
317          ENDIF
318          CALL fft_y( ar, 'forward', ar_tr = ar,                &
319                      nxl_y_bound = nxl_y, nxr_y_bound = nxr_y, &
320                      nxl_y_l = nxl_y, nxr_y_l = nxr_y )
321          IF ( fft_method /= 'system-specific' )  THEN
322             !$acc update device( ar )
323          ENDIF
324          CALL cpu_log( log_point_s(7), 'fft_y', 'pause' )
325
326!
327!--       Transposition y --> z
328          CALL cpu_log( log_point_s(5), 'transpo forward', 'continue' )
329          CALL resort_for_yz( ar, ar_inv )
330          CALL transpose_yz( ar_inv, ar )
331          CALL cpu_log( log_point_s(5), 'transpo forward', 'stop' )
332
333!
334!--       Solve the tridiagonal equation system along z
335          CALL cpu_log( log_point_s(6), 'tridia', 'start' )
336          CALL tridia_substi( ar )
337          CALL cpu_log( log_point_s(6), 'tridia', 'stop' )
338
339!
340!--       Inverse Fourier Transformation
341!--       Transposition z --> y
342          CALL cpu_log( log_point_s(8), 'transpo invers', 'start' )
343          CALL transpose_zy( ar, ar_inv )
344          CALL resort_for_zy( ar_inv, ar )
345          CALL cpu_log( log_point_s(8), 'transpo invers', 'pause' )
346
347          CALL cpu_log( log_point_s(7), 'fft_y', 'continue' )
348          IF ( fft_method /= 'system-specific' )  THEN
349             !$acc update host( ar )
350          ENDIF
351          CALL fft_y( ar, 'backward', ar_tr = ar,               &
352                      nxl_y_bound = nxl_y, nxr_y_bound = nxr_y, &
353                      nxl_y_l = nxl_y, nxr_y_l = nxr_y )
354          IF ( fft_method /= 'system-specific' )  THEN
355             !$acc update device( ar )
356          ENDIF
357          CALL cpu_log( log_point_s(7), 'fft_y', 'stop' )
358
359!
360!--       Transposition y --> x
361          CALL cpu_log( log_point_s(8), 'transpo invers', 'continue' )
362          CALL transpose_yx( ar, ar_inv )
363          CALL resort_for_yx( ar_inv, ar )
364          CALL cpu_log( log_point_s(8), 'transpo invers', 'pause' )
365
366          CALL cpu_log( log_point_s(4), 'fft_x', 'continue' )
367          IF ( fft_method /= 'system-specific' )  THEN
368             !$acc update host( ar )
369          ENDIF
370          CALL fft_x( ar, 'backward' )
371          IF ( fft_method /= 'system-specific' )  THEN
372             !$acc update device( ar )
373          ENDIF
374          CALL cpu_log( log_point_s(4), 'fft_x', 'stop' )
375
376!
377!--       Transposition x --> z
378          CALL cpu_log( log_point_s(8), 'transpo invers', 'continue' )
379          CALL transpose_xz( ar, ar_inv )
380          CALL resort_for_xz( ar_inv, ar )
381          CALL cpu_log( log_point_s(8), 'transpo invers', 'stop' )
382
383       ELSE
384
385!
386!--       2d-domain-decomposition or no decomposition (1 PE run) with
387!--       overlapping transposition / fft
388!--       cputime logging must not use barriers, which would prevent overlapping
389          ALLOCATE( f_out_y(0:ny,nxl_y:nxr_y,nzb_y:nzt_y), &
390                    f_out_z(0:nx,nys_x:nyn_x,nzb_x:nzt_x) )
391!
392!--       Transposition z --> x + subsequent fft along x
393          ALLOCATE( f_inv(nys:nyn,nxl:nxr,1:nz) )
394          CALL resort_for_zx( ar, f_inv )
395!
396!--       Save original indices and gridpoint counter
397          isave(1) = nz
398          isave(2) = nzb_x
399          isave(3) = nzt_x
400          isave(4) = sendrecvcount_zx
401!
402!--       Set new indices for transformation
403          nblk  = nz / pdims(1)
404          nz    = pdims(1)
405          nnz_x = 1
406          nzb_x = 1 + myidx * nnz_x
407          nzt_x = ( myidx + 1 ) * nnz_x
408          sendrecvcount_zx = nnx * nny * nnz_x
409
410          ALLOCATE( ar1(0:nx,nys_x:nyn_x,nzb_x:nzt_x) )
411          ALLOCATE( f_in(nys:nyn,nxl:nxr,1:nz) )
412
413          DO  kk = 1, nblk
414
415             IF ( kk == 1 )  THEN
416                CALL cpu_log( log_point_s(5), 'transpo forward', 'start', cpu_log_nowait )
417             ELSE
418                CALL cpu_log( log_point_s(5), 'transpo forward', 'continue', cpu_log_nowait )
419             ENDIF
420
421             DO  knew = 1, nz
422                ki = kk + nblk * ( knew - 1 )
423                f_in(:,:,knew) = f_inv(:,:,ki)
424             ENDDO
425
426             CALL transpose_zx( f_in, ar1(:,:,:))
427             CALL cpu_log( log_point_s(5), 'transpo forward', 'pause' )
428
429             IF ( kk == 1 )  THEN
430                CALL cpu_log( log_point_s(4), 'fft_x', 'start', cpu_log_nowait )
431             ELSE
432                CALL cpu_log( log_point_s(4), 'fft_x', 'continue', cpu_log_nowait )
433             ENDIF
434
435             n = isave(2) + kk - 1
436             CALL fft_x( ar1(:,:,:), 'forward',  ar_2d = f_out_z(:,:,n))
437             CALL cpu_log( log_point_s(4), 'fft_x', 'pause' )
438
439          ENDDO
440!
441!--       Restore original indices/counters
442          nz               = isave(1)
443          nzb_x            = isave(2)
444          nzt_x            = isave(3)
445          sendrecvcount_zx = isave(4)
446
447          DEALLOCATE( ar1, f_in, f_inv )
448
449!
450!--       Transposition x --> y + subsequent fft along y
451          ALLOCATE( f_inv(nys_x:nyn_x,nzb_x:nzt_x,0:nx) )
452          CALL resort_for_xy( f_out_z, f_inv )
453!
454!--       Save original indices and gridpoint counter
455          isave(1) = nx
456          isave(2) = nxl_y
457          isave(3) = nxr_y
458          isave(4) = sendrecvcount_xy
459!
460!--       Set new indices for transformation
461          nblk  = ( ( nx+1 ) / pdims(2) ) - 1
462          nx    = pdims(2)
463          nnx_y = 1
464          nxl_y = myidy * nnx_y
465          nxr_y = ( myidy + 1 ) * nnx_y - 1
466          sendrecvcount_xy = nnx_y * ( nyn_x-nys_x+1 ) * ( nzt_x-nzb_x+1 )
467
468          ALLOCATE( ar1(0:ny,nxl_y:nxr_y,nzb_y:nzt_y) )
469          ALLOCATE( f_in(nys_x:nyn_x,nzb_x:nzt_x,0:nx) )
470
471          DO  ii = 0, nblk
472
473             CALL cpu_log( log_point_s(5), 'transpo forward', 'continue', cpu_log_nowait )
474
475             DO  inew = 0, nx-1
476                iind = ii + ( nblk + 1 ) * inew
477                f_in(:,:,inew) = f_inv(:,:,iind)
478             ENDDO
479
480             CALL transpose_xy( f_in, ar1(:,:,:) )
481
482             CALL cpu_log( log_point_s(5), 'transpo forward', 'pause' )
483
484             IF ( ii == 1 )  THEN
485                CALL cpu_log( log_point_s(7), 'fft_y', 'start', cpu_log_nowait )
486             ELSE
487                CALL cpu_log( log_point_s(7), 'fft_y', 'continue', cpu_log_nowait )
488             ENDIF
489
490             nxl_y_bound = isave(2)
491             nxr_y_bound = isave(3)
492             n           = isave(2) + ii
493             CALL fft_y( ar1(:,:,:), 'forward', ar_tr = f_out_y,               &
494                         nxl_y_bound = nxl_y_bound, nxr_y_bound = nxr_y_bound, &
495                         nxl_y_l = n, nxr_y_l = n )
496
497             CALL cpu_log( log_point_s(7), 'fft_y', 'pause' )
498
499          ENDDO
500!
501!--       Restore original indices/counters
502          nx               = isave(1)
503          nxl_y            = isave(2)
504          nxr_y            = isave(3)
505          sendrecvcount_xy = isave(4)
506
507          DEALLOCATE( ar1, f_in, f_inv )
508
509!
510!--       Transposition y --> z + subsequent tridia + resort for z --> y
511          ALLOCATE( f_inv(nxl_y:nxr_y,nzb_y:nzt_y,0:ny) )
512          CALL resort_for_yz( f_out_y, f_inv )
513!
514!--       Save original indices and gridpoint counter
515          isave(1) = ny
516          isave(2) = nys_z
517          isave(3) = nyn_z
518          isave(4) = sendrecvcount_yz
519!
520!--       Set new indices for transformation
521          nblk             = ( ( ny+1 ) / pdims(1) ) - 1
522          ny               = pdims(1)
523          nny_z            = 1
524          nys_z            = myidx * nny_z
525          nyn_z            = ( myidx + 1 ) * nny_z - 1
526          sendrecvcount_yz = ( nxr_y-nxl_y+1 ) * nny_z * ( nzt_y-nzb_y+1 )
527
528          ALLOCATE( ar1(nxl_z:nxr_z,nys_z:nyn_z,1:nz) )
529          ALLOCATE( f_in(nxl_y:nxr_y,nzb_y:nzt_y,0:ny) )
530
531          DO  jj = 0, nblk
532!
533!--          Forward Fourier Transformation
534!--          Transposition y --> z
535             CALL cpu_log( log_point_s(5), 'transpo forward', 'continue', cpu_log_nowait )
536
537             DO  jnew = 0, ny-1
538                jind = jj + ( nblk + 1 ) * jnew
539                f_in(:,:,jnew) = f_inv(:,:,jind)
540             ENDDO
541
542             CALL transpose_yz( f_in, ar1(:,:,:) )
543
544             IF ( jj == nblk )  THEN
545                CALL cpu_log( log_point_s(5), 'transpo forward', 'stop' )
546             ELSE
547                CALL cpu_log( log_point_s(5), 'transpo forward', 'pause' )
548             ENDIF
549
550!
551!--          Solve the tridiagonal equation system along z
552             CALL cpu_log( log_point_s(6), 'tridia', 'start', cpu_log_nowait )
553
554             n = isave(2) + jj
555             CALL tridia_substi_overlap( ar1(:,:,:), n )
556
557             CALL cpu_log( log_point_s(6), 'tridia', 'stop' )
558
559!
560!--          Inverse Fourier Transformation
561!--          Transposition z --> y
562!--          Only one thread should call MPI routines, therefore forward and
563!--          backward tranpose are in the same section
564             IF ( jj == 0 )  THEN
565                CALL cpu_log( log_point_s(8), 'transpo invers', 'start', cpu_log_nowait )
566             ELSE
567                CALL cpu_log( log_point_s(8), 'transpo invers', 'continue', cpu_log_nowait )
568             ENDIF
569
570             CALL transpose_zy( ar1(:,:,:), f_in )
571
572             DO  jnew = 0, ny-1
573                jind = jj + ( nblk + 1 ) * jnew
574                f_inv(:,:,jind) = f_in(:,:,jnew)
575             ENDDO
576
577             CALL cpu_log( log_point_s(8), 'transpo invers', 'pause' )
578
579          ENDDO
580!
581!--       Restore original indices/counters
582          ny               = isave(1)
583          nys_z            = isave(2)
584          nyn_z            = isave(3)
585          sendrecvcount_yz = isave(4)
586
587          CALL resort_for_zy( f_inv, f_out_y )
588
589          DEALLOCATE( ar1, f_in, f_inv )
590
591!
592!--       fft along y backward + subsequent transposition y --> x
593          ALLOCATE( f_inv(nys_x:nyn_x,nzb_x:nzt_x,0:nx) )
594!
595!--       Save original indices and gridpoint counter
596          isave(1) = nx
597          isave(2) = nxl_y
598          isave(3) = nxr_y
599          isave(4) = sendrecvcount_xy
600!
601!--       Set new indices for transformation
602          nblk             = (( nx+1 ) / pdims(2) ) - 1
603          nx               = pdims(2)
604          nnx_y            = 1
605          nxl_y            = myidy * nnx_y
606          nxr_y            = ( myidy + 1 ) * nnx_y - 1
607          sendrecvcount_xy = nnx_y * ( nyn_x-nys_x+1 ) * ( nzt_x-nzb_x+1 )
608
609          ALLOCATE( ar1(0:ny,nxl_y:nxr_y,nzb_y:nzt_y) )
610          ALLOCATE( f_in(nys_x:nyn_x,nzb_x:nzt_x,0:nx) )
611
612          DO  ii = 0, nblk
613
614             CALL cpu_log( log_point_s(7), 'fft_y', 'continue', cpu_log_nowait )
615
616             n = isave(2) + ii
617             nxl_y_bound = isave(2)
618             nxr_y_bound = isave(3)
619
620             CALL fft_y( ar1(:,:,:), 'backward', ar_tr = f_out_y,              &
621                         nxl_y_bound = nxl_y_bound, nxr_y_bound = nxr_y_bound, &
622                         nxl_y_l = n, nxr_y_l = n )
623
624             IF ( ii == nblk )  THEN
625                CALL cpu_log( log_point_s(7), 'fft_y', 'stop' )
626             ELSE
627                CALL cpu_log( log_point_s(7), 'fft_y', 'pause' )
628             ENDIF
629
630             CALL cpu_log( log_point_s(8), 'transpo invers', 'continue', cpu_log_nowait )
631
632             CALL transpose_yx( ar1(:,:,:), f_in )
633
634             DO  inew = 0, nx-1
635                iind = ii + (nblk+1) * inew
636                f_inv(:,:,iind) = f_in(:,:,inew)
637             ENDDO
638
639             CALL cpu_log( log_point_s(8), 'transpo invers', 'pause' )
640
641          ENDDO
642!
643!--       Restore original indices/counters
644          nx               = isave(1)
645          nxl_y            = isave(2)
646          nxr_y            = isave(3)
647          sendrecvcount_xy = isave(4)
648
649          CALL resort_for_yx( f_inv, f_out_z )
650
651          DEALLOCATE( ar1, f_in, f_inv )
652
653!
654!--       fft along x backward + subsequent final transposition x --> z
655          ALLOCATE( f_inv(nys:nyn,nxl:nxr,1:nz) )
656!
657!--       Save original indices and gridpoint counter
658          isave(1) = nz
659          isave(2) = nzb_x
660          isave(3) = nzt_x
661          isave(4) = sendrecvcount_zx
662!
663!--       Set new indices for transformation
664          nblk             = nz / pdims(1)
665          nz               = pdims(1)
666          nnz_x            = 1
667          nzb_x            = 1 + myidx * nnz_x
668          nzt_x            = ( myidx + 1 ) * nnz_x
669          sendrecvcount_zx = nnx * nny * nnz_x
670
671          ALLOCATE( ar1(0:nx,nys_x:nyn_x,nzb_x:nzt_x) )
672          ALLOCATE( f_in(nys:nyn,nxl:nxr,1:nz) )
673
674          DO  kk = 1, nblk
675
676             CALL cpu_log( log_point_s(4), 'fft_x', 'continue', cpu_log_nowait )
677
678             n = isave(2) + kk - 1
679             CALL fft_x( ar1(:,:,:), 'backward', f_out_z(:,:,n))
680
681             IF ( kk == nblk )  THEN
682                CALL cpu_log( log_point_s(4), 'fft_x', 'stop' )
683             ELSE
684                CALL cpu_log( log_point_s(4), 'fft_x', 'pause' )
685             ENDIF
686
687             CALL cpu_log( log_point_s(8), 'transpo invers', 'continue', cpu_log_nowait )
688
689             CALL transpose_xz( ar1(:,:,:), f_in )
690
691             DO  knew = 1, nz
692                ki = kk + nblk * (knew-1)
693                f_inv(:,:,ki) = f_in(:,:,knew)
694             ENDDO
695
696             IF ( kk == nblk )  THEN
697                CALL cpu_log( log_point_s(8), 'transpo invers', 'stop' )
698             ELSE
699                CALL cpu_log( log_point_s(8), 'transpo invers', 'pause' )
700             ENDIF
701
702          ENDDO
703!
704!--       Restore original indices/counters
705          nz               = isave(1)
706          nzb_x            = isave(2)
707          nzt_x            = isave(3)
708          sendrecvcount_zx = isave(4)
709
710          CALL resort_for_xz( f_inv, ar )
711
712          DEALLOCATE( ar1, f_in, f_inv )
713
714       ENDIF
715
716       CALL cpu_log( log_point_s(3), 'poisfft', 'stop' )
717
718    END SUBROUTINE poisfft
719
720
721!------------------------------------------------------------------------------!
722! Description:
723! ------------
724!> Fourier-transformation along y with subsequent transposition y --> x for
725!> a 1d-decomposition along x.
726!>
727!> @attention The performance of this routine is much faster on the NEC-SX6,
728!>            if the first index of work_ffty_vec is odd. Otherwise
729!>            memory bank conflicts may occur (especially if the index is a
730!>            multiple of 128). That's why work_ffty_vec is dimensioned as
731!>            0:ny+1.
732!>            Of course, this will not work if users are using an odd number
733!>            of gridpoints along y.
734!------------------------------------------------------------------------------!
735    SUBROUTINE ffty_tr_yx( f_in, f_out )
736
737
738       USE control_parameters,                                                 &
739           ONLY:  host
740
741       USE cpulog,                                                             &
742           ONLY:  cpu_log, log_point_s
743
744       USE kinds
745
746       USE pegrid
747
748       IMPLICIT NONE
749
750       INTEGER(iwp)            ::  i            !<
751       INTEGER(iwp)            ::  iend         !<
752       INTEGER(iwp)            ::  iouter       !<
753       INTEGER(iwp)            ::  ir           !<
754       INTEGER(iwp)            ::  j            !<
755       INTEGER(iwp)            ::  k            !<
756
757       INTEGER(iwp), PARAMETER ::  stridex = 4  !<
758
759       REAL(wp), DIMENSION(0:ny,stridex)        ::  work_ffty      !<
760#if defined( __nec )
761       REAL(wp), DIMENSION(0:ny+1,1:nz,nxl:nxr) ::  work_ffty_vec  !<
762#endif
763       REAL(wp), DIMENSION(1:nz,0:ny,nxl:nxr)             ::  f_in   !<
764       REAL(wp), DIMENSION(nnx,1:nz,nys_x:nyn_x,pdims(1)) ::  f_out  !<
765       REAL(wp), DIMENSION(nxl:nxr,1:nz,0:ny)             ::  work   !<
766
767!
768!--    Carry out the FFT along y, where all data are present due to the
769!--    1d-decomposition along x. Resort the data in a way that x becomes
770!--    the first index.
771       CALL cpu_log( log_point_s(7), 'fft_y_1d', 'start' )
772
773       IF ( host(1:3) == 'nec' )  THEN
774#if defined( __nec )
775!
776!--       Code optimized for vector processors
777!$OMP     PARALLEL PRIVATE ( i, j, k )
778!$OMP     DO
779          DO  i = nxl, nxr
780
781             DO  j = 0, ny
782                DO  k = 1, nz
783                   work_ffty_vec(j,k,i) = f_in(k,j,i)
784                ENDDO
785             ENDDO
786
787             CALL fft_y_m( work_ffty_vec(:,:,i), ny+1, 'forward' )
788
789          ENDDO
790
791!$OMP     DO
792          DO  k = 1, nz
793             DO  j = 0, ny
794                DO  i = nxl, nxr
795                   work(i,k,j) = work_ffty_vec(j,k,i)
796                ENDDO
797             ENDDO
798          ENDDO
799!$OMP     END PARALLEL
800#endif
801
802       ELSE
803
804!
805!--       Cache optimized code.
806!--       The i-(x-)direction is split into a strided outer loop and an inner
807!--       loop for better cache performance
808!$OMP     PARALLEL PRIVATE (i,iend,iouter,ir,j,k,work_ffty)
809!$OMP     DO
810          DO  iouter = nxl, nxr, stridex
811
812             iend = MIN( iouter+stridex-1, nxr )  ! Upper bound for inner i loop
813
814             DO  k = 1, nz
815
816                DO  i = iouter, iend
817
818                   ir = i-iouter+1  ! counter within a stride
819                   DO  j = 0, ny
820                      work_ffty(j,ir) = f_in(k,j,i)
821                   ENDDO
822!
823!--                FFT along y
824                   CALL fft_y_1d( work_ffty(:,ir), 'forward' )
825
826                ENDDO
827
828!
829!--             Resort
830                DO  j = 0, ny
831                   DO  i = iouter, iend
832                      work(i,k,j) = work_ffty(j,i-iouter+1)
833                   ENDDO
834                ENDDO
835
836             ENDDO
837
838          ENDDO
839!$OMP     END PARALLEL
840
841       ENDIF
842       CALL cpu_log( log_point_s(7), 'fft_y_1d', 'pause' )
843
844!
845!--    Transpose array
846#if defined( __parallel )
847       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'start' )
848       IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
849       CALL MPI_ALLTOALL( work(nxl,1,0),      sendrecvcount_xy, MPI_REAL, &
850                          f_out(1,1,nys_x,1), sendrecvcount_xy, MPI_REAL, &
851                          comm1dx, ierr )
852       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'stop' )
853#endif
854
855    END SUBROUTINE ffty_tr_yx
856
857
858!------------------------------------------------------------------------------!
859! Description:
860! ------------
861!>  Transposition x --> y with a subsequent backward Fourier transformation for
862!>  a 1d-decomposition along x
863!------------------------------------------------------------------------------!
864    SUBROUTINE tr_xy_ffty( f_in, f_out )
865
866
867       USE control_parameters,                                                 &
868           ONLY:  host
869
870       USE cpulog,                                                             &
871           ONLY:  cpu_log, log_point_s
872
873       USE kinds
874
875       USE pegrid
876
877       IMPLICIT NONE
878
879       INTEGER(iwp)            ::  i            !<
880       INTEGER(iwp)            ::  iend         !<
881       INTEGER(iwp)            ::  iouter       !<
882       INTEGER(iwp)            ::  ir           !<
883       INTEGER(iwp)            ::  j            !<
884       INTEGER(iwp)            ::  k            !<
885
886       INTEGER(iwp), PARAMETER ::  stridex = 4  !<
887
888       REAL(wp), DIMENSION(0:ny,stridex)        ::  work_ffty      !<
889#if defined( __nec )
890       REAL(wp), DIMENSION(0:ny+1,1:nz,nxl:nxr) ::  work_ffty_vec  !<
891#endif
892       REAL(wp), DIMENSION(nnx,1:nz,nys_x:nyn_x,pdims(1)) ::  f_in   !<
893       REAL(wp), DIMENSION(1:nz,0:ny,nxl:nxr)             ::  f_out  !<
894       REAL(wp), DIMENSION(nxl:nxr,1:nz,0:ny)             ::  work   !<
895
896!
897!--    Transpose array
898#if defined( __parallel )
899       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'start' )
900       IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
901       CALL MPI_ALLTOALL( f_in(1,1,nys_x,1), sendrecvcount_xy, MPI_REAL, &
902                          work(nxl,1,0),     sendrecvcount_xy, MPI_REAL, &
903                          comm1dx, ierr )
904       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'stop' )
905#endif
906
907!
908!--    Resort the data in a way that y becomes the first index and carry out the
909!--    backward fft along y.
910       CALL cpu_log( log_point_s(7), 'fft_y_1d', 'continue' )
911
912       IF ( host(1:3) == 'nec' )  THEN
913#if defined( __nec )
914!
915!--       Code optimized for vector processors
916!$OMP     PARALLEL PRIVATE ( i, j, k )
917!$OMP     DO
918          DO  k = 1, nz
919             DO  j = 0, ny
920                DO  i = nxl, nxr
921                   work_ffty_vec(j,k,i) = work(i,k,j)
922                ENDDO
923             ENDDO
924          ENDDO
925
926!$OMP     DO
927          DO  i = nxl, nxr
928
929             CALL fft_y_m( work_ffty_vec(:,:,i), ny+1, 'backward' )
930
931             DO  j = 0, ny
932                DO  k = 1, nz
933                   f_out(k,j,i) = work_ffty_vec(j,k,i)
934                ENDDO
935             ENDDO
936
937          ENDDO
938!$OMP     END PARALLEL
939#endif
940
941       ELSE
942
943!
944!--       Cache optimized code.
945!--       The i-(x-)direction is split into a strided outer loop and an inner
946!--       loop for better cache performance
947!$OMP     PARALLEL PRIVATE ( i, iend, iouter, ir, j, k, work_ffty )
948!$OMP     DO
949          DO  iouter = nxl, nxr, stridex
950
951             iend = MIN( iouter+stridex-1, nxr )  ! Upper bound for inner i loop
952
953             DO  k = 1, nz
954!
955!--             Resort
956                DO  j = 0, ny
957                   DO  i = iouter, iend
958                      work_ffty(j,i-iouter+1) = work(i,k,j)
959                   ENDDO
960                ENDDO
961
962                DO  i = iouter, iend
963
964!
965!--                FFT along y
966                   ir = i-iouter+1  ! counter within a stride
967                   CALL fft_y_1d( work_ffty(:,ir), 'backward' )
968
969                   DO  j = 0, ny
970                      f_out(k,j,i) = work_ffty(j,ir)
971                   ENDDO
972                ENDDO
973
974             ENDDO
975
976          ENDDO
977!$OMP     END PARALLEL
978
979       ENDIF
980
981       CALL cpu_log( log_point_s(7), 'fft_y_1d', 'stop' )
982
983    END SUBROUTINE tr_xy_ffty
984
985
986!------------------------------------------------------------------------------!
987! Description:
988! ------------
989!> FFT along x, solution of the tridiagonal system and backward FFT for
990!> a 1d-decomposition along x
991!>
992!> @warning this subroutine may still not work for hybrid parallelization
993!>          with OpenMP (for possible necessary changes see the original
994!>          routine poisfft_hybrid, developed by Klaus Ketelsen, May 2002)
995!------------------------------------------------------------------------------!
996    SUBROUTINE fftx_tri_fftx( ar )
997
998
999       USE control_parameters,                                                 &
1000           ONLY:  host
1001
1002       USE cpulog,                                                             &
1003           ONLY:  cpu_log, log_point_s
1004
1005       USE grid_variables,                                                     &
1006           ONLY:  ddx2, ddy2
1007
1008       USE kinds
1009
1010       USE pegrid
1011
1012       IMPLICIT NONE
1013
1014       INTEGER(iwp) ::  i                   !<
1015       INTEGER(iwp) ::  j                   !<
1016       INTEGER(iwp) ::  k                   !<
1017       INTEGER(iwp) ::  m                   !<
1018       INTEGER(iwp) ::  n                   !<
1019       INTEGER(iwp) ::  omp_get_thread_num  !<
1020       INTEGER(iwp) ::  tn                  !<
1021
1022       REAL(wp), DIMENSION(0:nx)                          ::  work_fftx  !<
1023       REAL(wp), DIMENSION(0:nx,1:nz)                     ::  work_trix  !<
1024       REAL(wp), DIMENSION(nnx,1:nz,nys_x:nyn_x,pdims(1)) ::  ar         !<
1025       REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE          ::  tri        !<
1026
1027
1028       CALL cpu_log( log_point_s(33), 'fft_x_1d + tridia', 'start' )
1029
1030       ALLOCATE( tri(5,0:nx,0:nz-1,0:threads_per_task-1) )
1031
1032       tn = 0              ! Default thread number in case of one thread
1033!$OMP  PARALLEL DO PRIVATE ( i, j, k, m, n, tn, work_fftx, work_trix )
1034       DO  j = nys_x, nyn_x
1035
1036!$        tn = omp_get_thread_num()
1037
1038          IF ( host(1:3) == 'nec' )  THEN
1039!
1040!--          Code optimized for vector processors
1041             DO  k = 1, nz
1042
1043                m = 0
1044                DO  n = 1, pdims(1)
1045                   DO  i = 1, nnx
1046                      work_trix(m,k) = ar(i,k,j,n)
1047                      m = m + 1
1048                   ENDDO
1049                ENDDO
1050
1051             ENDDO
1052
1053             CALL fft_x_m( work_trix, 'forward' )
1054
1055          ELSE
1056!
1057!--          Cache optimized code
1058             DO  k = 1, nz
1059
1060                m = 0
1061                DO  n = 1, pdims(1)
1062                   DO  i = 1, nnx
1063                      work_fftx(m) = ar(i,k,j,n)
1064                      m = m + 1
1065                   ENDDO
1066                ENDDO
1067
1068                CALL fft_x_1d( work_fftx, 'forward' )
1069
1070                DO  i = 0, nx
1071                   work_trix(i,k) = work_fftx(i)
1072                ENDDO
1073
1074             ENDDO
1075
1076          ENDIF
1077
1078!
1079!--       Solve the linear equation system
1080          CALL tridia_1dd( ddx2, ddy2, nx, ny, j, work_trix, tri(:,:,:,tn) )
1081
1082          IF ( host(1:3) == 'nec' )  THEN
1083!
1084!--          Code optimized for vector processors
1085             CALL fft_x_m( work_trix, 'backward' )
1086
1087             DO  k = 1, nz
1088
1089                m = 0
1090                DO  n = 1, pdims(1)
1091                   DO  i = 1, nnx
1092                      ar(i,k,j,n) = work_trix(m,k)
1093                      m = m + 1
1094                   ENDDO
1095                ENDDO
1096
1097             ENDDO
1098
1099          ELSE
1100!
1101!--          Cache optimized code
1102             DO  k = 1, nz
1103
1104                DO  i = 0, nx
1105                   work_fftx(i) = work_trix(i,k)
1106                ENDDO
1107
1108                CALL fft_x_1d( work_fftx, 'backward' )
1109
1110                m = 0
1111                DO  n = 1, pdims(1)
1112                   DO  i = 1, nnx
1113                      ar(i,k,j,n) = work_fftx(m)
1114                      m = m + 1
1115                   ENDDO
1116                ENDDO
1117
1118             ENDDO
1119
1120          ENDIF
1121
1122       ENDDO
1123
1124       DEALLOCATE( tri )
1125
1126       CALL cpu_log( log_point_s(33), 'fft_x_1d + tridia', 'stop' )
1127
1128    END SUBROUTINE fftx_tri_fftx
1129
1130
1131!------------------------------------------------------------------------------!
1132! Description:
1133! ------------
1134!> Fourier-transformation along x with subsequent transposition x --> y for
1135!> a 1d-decomposition along y.
1136!>
1137!> @attention NEC-branch of this routine may significantly profit from
1138!>            further optimizations. So far, performance is much worse than
1139!>            for routine ffty_tr_yx (more than three times slower).
1140!------------------------------------------------------------------------------!
1141    SUBROUTINE fftx_tr_xy( f_in, f_out )
1142
1143
1144       USE control_parameters,                                                 &
1145           ONLY:  host
1146
1147       USE cpulog,                                                             &
1148           ONLY:  cpu_log, log_point_s
1149
1150       USE kinds
1151
1152       USE pegrid
1153
1154       IMPLICIT NONE
1155
1156       INTEGER(iwp) ::  i  !<
1157       INTEGER(iwp) ::  j  !<
1158       INTEGER(iwp) ::  k  !<
1159
1160       REAL(wp), DIMENSION(0:nx,1:nz,nys:nyn)             ::  work_fftx  !<
1161       REAL(wp), DIMENSION(1:nz,nys:nyn,0:nx)             ::  f_in       !<
1162       REAL(wp), DIMENSION(nny,1:nz,nxl_y:nxr_y,pdims(2)) ::  f_out      !<
1163       REAL(wp), DIMENSION(nys:nyn,1:nz,0:nx)             ::  work       !<
1164
1165!
1166!--    Carry out the FFT along x, where all data are present due to the
1167!--    1d-decomposition along y. Resort the data in a way that y becomes
1168!--    the first index.
1169       CALL cpu_log( log_point_s(4), 'fft_x_1d', 'start' )
1170
1171       IF ( host(1:3) == 'nec' )  THEN
1172!
1173!--       Code for vector processors
1174!$OMP     PARALLEL PRIVATE ( i, j, k )
1175!$OMP     DO
1176          DO  i = 0, nx
1177
1178             DO  j = nys, nyn
1179                DO  k = 1, nz
1180                   work_fftx(i,k,j) = f_in(k,j,i)
1181                ENDDO
1182             ENDDO
1183
1184          ENDDO
1185
1186!$OMP     DO
1187          DO  j = nys, nyn
1188
1189             CALL fft_x_m( work_fftx(:,:,j), 'forward' )
1190
1191             DO  k = 1, nz
1192                DO  i = 0, nx
1193                   work(j,k,i) = work_fftx(i,k,j)
1194                ENDDO
1195             ENDDO
1196
1197          ENDDO
1198!$OMP     END PARALLEL
1199
1200       ELSE
1201
1202!
1203!--       Cache optimized code (there might be still a potential for better
1204!--       optimization).
1205!$OMP     PARALLEL PRIVATE (i,j,k)
1206!$OMP     DO
1207          DO  i = 0, nx
1208
1209             DO  j = nys, nyn
1210                DO  k = 1, nz
1211                   work_fftx(i,k,j) = f_in(k,j,i)
1212                ENDDO
1213             ENDDO
1214
1215          ENDDO
1216
1217!$OMP     DO
1218          DO  j = nys, nyn
1219             DO  k = 1, nz
1220
1221                CALL fft_x_1d( work_fftx(0:nx,k,j), 'forward' )
1222
1223                DO  i = 0, nx
1224                   work(j,k,i) = work_fftx(i,k,j)
1225                ENDDO
1226             ENDDO
1227
1228          ENDDO
1229!$OMP     END PARALLEL
1230
1231       ENDIF
1232       CALL cpu_log( log_point_s(4), 'fft_x_1d', 'pause' )
1233
1234!
1235!--    Transpose array
1236#if defined( __parallel )
1237       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'start' )
1238       IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
1239       CALL MPI_ALLTOALL( work(nys,1,0),      sendrecvcount_xy, MPI_REAL, &
1240                          f_out(1,1,nxl_y,1), sendrecvcount_xy, MPI_REAL, &
1241                          comm1dy, ierr )
1242       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'stop' )
1243#endif
1244
1245    END SUBROUTINE fftx_tr_xy
1246
1247
1248!------------------------------------------------------------------------------!
1249! Description:
1250! ------------
1251!> Transposition y --> x with a subsequent backward Fourier transformation for
1252!> a 1d-decomposition along x.
1253!------------------------------------------------------------------------------!
1254    SUBROUTINE tr_yx_fftx( f_in, f_out )
1255
1256
1257       USE control_parameters,                                                 &
1258           ONLY:  host
1259
1260       USE cpulog,                                                             &
1261           ONLY:  cpu_log, log_point_s
1262
1263       USE kinds
1264
1265       USE pegrid
1266
1267       IMPLICIT NONE
1268
1269       INTEGER(iwp) ::  i  !<
1270       INTEGER(iwp) ::  j  !<
1271       INTEGER(iwp) ::  k  !<
1272
1273       REAL(wp), DIMENSION(0:nx,1:nz,nys:nyn)             ::  work_fftx  !<
1274       REAL(wp), DIMENSION(nny,1:nz,nxl_y:nxr_y,pdims(2)) ::  f_in       !<
1275       REAL(wp), DIMENSION(1:nz,nys:nyn,0:nx)             ::  f_out      !<
1276       REAL(wp), DIMENSION(nys:nyn,1:nz,0:nx)             ::  work       !<
1277
1278!
1279!--    Transpose array
1280#if defined( __parallel )
1281       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'start' )
1282       IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
1283       CALL MPI_ALLTOALL( f_in(1,1,nxl_y,1), sendrecvcount_xy, MPI_REAL, &
1284                          work(nys,1,0),     sendrecvcount_xy, MPI_REAL, &
1285                          comm1dy, ierr )
1286       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'stop' )
1287#endif
1288
1289!
1290!--    Carry out the FFT along x, where all data are present due to the
1291!--    1d-decomposition along y. Resort the data in a way that y becomes
1292!--    the first index.
1293       CALL cpu_log( log_point_s(4), 'fft_x_1d', 'continue' )
1294
1295       IF ( host(1:3) == 'nec' )  THEN
1296!
1297!--       Code optimized for vector processors
1298!$OMP     PARALLEL PRIVATE ( i, j, k )
1299!$OMP     DO
1300          DO  j = nys, nyn
1301
1302             DO  k = 1, nz
1303                DO  i = 0, nx
1304                   work_fftx(i,k,j) = work(j,k,i)
1305                ENDDO
1306             ENDDO
1307
1308             CALL fft_x_m( work_fftx(:,:,j), 'backward' )
1309
1310          ENDDO
1311
1312!$OMP     DO
1313          DO  i = 0, nx
1314             DO  j = nys, nyn
1315                DO  k = 1, nz
1316                   f_out(k,j,i) = work_fftx(i,k,j)
1317                ENDDO
1318             ENDDO
1319          ENDDO
1320!$OMP     END PARALLEL
1321
1322       ELSE
1323
1324!
1325!--       Cache optimized code (there might be still a potential for better
1326!--       optimization).
1327!$OMP     PARALLEL PRIVATE (i,j,k)
1328!$OMP     DO
1329          DO  j = nys, nyn
1330             DO  k = 1, nz
1331
1332                DO  i = 0, nx
1333                   work_fftx(i,k,j) = work(j,k,i)
1334                ENDDO
1335
1336                CALL fft_x_1d( work_fftx(0:nx,k,j), 'backward' )
1337
1338             ENDDO
1339          ENDDO
1340
1341!$OMP     DO
1342          DO  i = 0, nx
1343             DO  j = nys, nyn
1344                DO  k = 1, nz
1345                   f_out(k,j,i) = work_fftx(i,k,j)
1346                ENDDO
1347             ENDDO
1348          ENDDO
1349!$OMP     END PARALLEL
1350
1351       ENDIF
1352       CALL cpu_log( log_point_s(4), 'fft_x_1d', 'stop' )
1353
1354    END SUBROUTINE tr_yx_fftx
1355
1356
1357!------------------------------------------------------------------------------!
1358! Description:
1359! ------------
1360!> FFT along y, solution of the tridiagonal system and backward FFT for
1361!> a 1d-decomposition along y.
1362!>
1363!> @warning this subroutine may still not work for hybrid parallelization
1364!>          with OpenMP (for possible necessary changes see the original
1365!>          routine poisfft_hybrid, developed by Klaus Ketelsen, May 2002)
1366!------------------------------------------------------------------------------!
1367    SUBROUTINE ffty_tri_ffty( ar )
1368
1369
1370       USE control_parameters,                                                 &
1371           ONLY:  host
1372
1373       USE cpulog,                                                             &
1374           ONLY:  cpu_log, log_point_s
1375
1376       USE grid_variables,                                                     &
1377           ONLY:  ddx2, ddy2
1378
1379       USE kinds
1380
1381       USE pegrid
1382
1383       IMPLICIT NONE
1384
1385       INTEGER(iwp) ::  i                   !<
1386       INTEGER(iwp) ::  j                   !<
1387       INTEGER(iwp) ::  k                   !<
1388       INTEGER(iwp) ::  m                   !<
1389       INTEGER(iwp) ::  n                   !<
1390       INTEGER(iwp) ::  omp_get_thread_num  !<
1391       INTEGER(iwp) ::  tn                  !<
1392
1393       REAL(wp), DIMENSION(0:ny)                          ::  work_ffty  !<
1394       REAL(wp), DIMENSION(0:ny,1:nz)                     ::  work_triy  !<
1395       REAL(wp), DIMENSION(nny,1:nz,nxl_y:nxr_y,pdims(2)) ::  ar         !<
1396       REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE          ::  tri        !<
1397
1398
1399       CALL cpu_log( log_point_s(39), 'fft_y_1d + tridia', 'start' )
1400
1401       ALLOCATE( tri(5,0:ny,0:nz-1,0:threads_per_task-1) )
1402
1403       tn = 0           ! Default thread number in case of one thread
1404!$OMP  PARALLEL DO PRIVATE ( i, j, k, m, n, tn, work_ffty, work_triy )
1405       DO  i = nxl_y, nxr_y
1406
1407!$        tn = omp_get_thread_num()
1408
1409          IF ( host(1:3) == 'nec' )  THEN
1410!
1411!--          Code optimized for vector processors
1412             DO  k = 1, nz
1413
1414                m = 0
1415                DO  n = 1, pdims(2)
1416                   DO  j = 1, nny
1417                      work_triy(m,k) = ar(j,k,i,n)
1418                      m = m + 1
1419                   ENDDO
1420                ENDDO
1421
1422             ENDDO
1423
1424             CALL fft_y_m( work_triy, ny, 'forward' )
1425
1426          ELSE
1427!
1428!--          Cache optimized code
1429             DO  k = 1, nz
1430
1431                m = 0
1432                DO  n = 1, pdims(2)
1433                   DO  j = 1, nny
1434                      work_ffty(m) = ar(j,k,i,n)
1435                      m = m + 1
1436                   ENDDO
1437                ENDDO
1438
1439                CALL fft_y_1d( work_ffty, 'forward' )
1440
1441                DO  j = 0, ny
1442                   work_triy(j,k) = work_ffty(j)
1443                ENDDO
1444
1445             ENDDO
1446
1447          ENDIF
1448
1449!
1450!--       Solve the linear equation system
1451          CALL tridia_1dd( ddy2, ddx2, ny, nx, i, work_triy, tri(:,:,:,tn) )
1452
1453          IF ( host(1:3) == 'nec' )  THEN
1454!
1455!--          Code optimized for vector processors
1456             CALL fft_y_m( work_triy, ny, 'backward' )
1457
1458             DO  k = 1, nz
1459
1460                m = 0
1461                DO  n = 1, pdims(2)
1462                   DO  j = 1, nny
1463                      ar(j,k,i,n) = work_triy(m,k)
1464                      m = m + 1
1465                   ENDDO
1466                ENDDO
1467
1468             ENDDO
1469
1470          ELSE
1471!
1472!--          Cache optimized code
1473             DO  k = 1, nz
1474
1475                DO  j = 0, ny
1476                   work_ffty(j) = work_triy(j,k)
1477                ENDDO
1478
1479                CALL fft_y_1d( work_ffty, 'backward' )
1480
1481                m = 0
1482                DO  n = 1, pdims(2)
1483                   DO  j = 1, nny
1484                      ar(j,k,i,n) = work_ffty(m)
1485                      m = m + 1
1486                   ENDDO
1487                ENDDO
1488
1489             ENDDO
1490
1491          ENDIF
1492
1493       ENDDO
1494
1495       DEALLOCATE( tri )
1496
1497       CALL cpu_log( log_point_s(39), 'fft_y_1d + tridia', 'stop' )
1498
1499    END SUBROUTINE ffty_tri_ffty
1500
1501 END MODULE poisfft_mod
Note: See TracBrowser for help on using the repository browser.