source: palm/trunk/SOURCE/fft_xy_mod.f90 @ 2274

Last change on this file since 2274 was 2274, checked in by Giersch, 4 years ago

Changed error messages

  • Property svn:keywords set to Id
File size: 53.0 KB
Line 
1!> @file fft_xy_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
6! terms of the GNU General Public License as published by the Free Software
7! Foundation, either version 3 of the License, or (at your option) any later
8! version.
9!
10! PALM is distributed in the hope that it will be useful, but WITHOUT ANY
11! WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
12! A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
13!
14! You should have received a copy of the GNU General Public License along with
15! PALM. If not, see <http://www.gnu.org/licenses/>.
16!
17! Copyright 1997-2017 Leibniz Universitaet Hannover
18!------------------------------------------------------------------------------!
19!
20! Current revisions:
21! -----------------
22!
23!
24! Former revisions:
25! -----------------
26! $Id: fft_xy_mod.f90 2274 2017-06-09 13:27:48Z Giersch $
27! Changed error messages
28!
29! 2119 2017-01-17 16:51:50Z raasch
30!
31! 2118 2017-01-17 16:38:49Z raasch
32! OpenACC directives and CUDA-fft related code removed
33!
34! 2000 2016-08-20 18:09:15Z knoop
35! Forced header and separation lines into 80 columns
36!
37! 1850 2016-04-08 13:29:27Z maronga
38! Module renamed
39!
40! 1815 2016-04-06 13:49:59Z raasch
41! cpp-directives for ibmy removed
42!
43! 1749 2016-02-09 12:19:56Z raasch
44! small OpenACC bugfix
45!
46! 1682 2015-10-07 23:56:08Z knoop
47! Code annotations made doxygen readable
48!
49! 1600 2015-06-11 15:50:12Z raasch
50! bugfix: openMP threadprivate statement moved after variable declaration
51!
52! 1482 2014-10-18 12:34:45Z raasch
53! cudafft workaround for data declaration of ar_tmp because of PGI 14.1 bug
54!
55! 1402 2014-05-09 14:25:13Z raasch
56! fortran bugfix for r1392
57!
58! 1398 2014-05-07 11:15:00Z heinze
59! bugfix: typo removed for KIND in CMPLX function
60!
61! 1392 2014-05-06 09:10:05Z raasch
62! bugfix: KIND attribute added to CMPLX functions
63!
64! 1374 2014-04-25 12:55:07Z raasch
65! bugfixes: missing variables added to ONLY list, dpk renamed dp
66!
67! 1372 2014-04-24 06:29:32Z raasch
68! openMP-bugfix for fftw: some arrays defined as threadprivate
69!
70! 1353 2014-04-08 15:21:23Z heinze
71! REAL constants provided with KIND-attribute
72!
73! 1342 2014-03-26 17:04:47Z kanani
74! REAL constants defined as wp-kind
75!
76! 1322 2014-03-20 16:38:49Z raasch
77! REAL functions provided with KIND-attribute
78!
79! 1320 2014-03-20 08:40:49Z raasch
80! ONLY-attribute added to USE-statements,
81! kind-parameters added to all INTEGER and REAL declaration statements,
82! kinds are defined in new module kinds,
83! old module precision_kind is removed,
84! revision history before 2012 removed,
85! comment fields (!:) to be used for variable explanations added to
86! all variable declaration statements
87!
88! 1304 2014-03-12 10:29:42Z raasch
89! openmp bugfix: work1 used in Temperton algorithm must be private
90!
91! 1257 2013-11-08 15:18:40Z raasch
92! openacc loop and loop vector clauses removed, declare create moved after
93! the FORTRAN declaration statement
94!
95! 1219 2013-08-30 09:33:18Z heinze
96! bugfix: use own branch for fftw
97!
98! 1216 2013-08-26 09:31:42Z raasch
99! fft_x and fft_y modified for parallel / ovverlapping execution of fft and
100! transpositions,
101! fftw implemented for 1d-decomposition (fft_x_1d, fft_y_1d)
102!
103! 1210 2013-08-14 10:58:20Z raasch
104! fftw added
105!
106! 1166 2013-05-24 13:55:44Z raasch
107! C_DOUBLE/COMPLEX reset to dpk
108!
109! 1153 2013-05-10 14:33:08Z raasch
110! code adjustment of data types for CUDA fft required by PGI 12.3 / CUDA 5.0
111!
112! 1111 2013-03-08 23:54:10Z raasch
113! further openACC statements added, CUDA branch completely runs on GPU
114! bugfix: CUDA fft plans adjusted for domain decomposition (before they always
115! used total domain)
116!
117! 1106 2013-03-04 05:31:38Z raasch
118! CUDA fft added
119! array_kind renamed precision_kind, 3D- instead of 1D-loops in fft_x and fft_y
120! old fft_x, fft_y become fft_x_1d, fft_y_1d and are used for 1D-decomposition
121!
122! 1092 2013-02-02 11:24:22Z raasch
123! variable sizw declared for NEC case only
124!
125! 1036 2012-10-22 13:43:42Z raasch
126! code put under GPL (PALM 3.9)
127!
128! Revision 1.1  2002/06/11 13:00:49  raasch
129! Initial revision
130!
131!
132! Description:
133! ------------
134!> Fast Fourier transformation along x and y for 1d domain decomposition along x.
135!> Original version: Klaus Ketelsen (May 2002)
136!------------------------------------------------------------------------------!
137 MODULE fft_xy
138 
139
140    USE control_parameters,                                                    &
141        ONLY:  fft_method, message_string
142       
143    USE indices,                                                               &
144        ONLY:  nx, ny, nz
145       
146#if defined( __fftw )
147    USE, INTRINSIC ::  ISO_C_BINDING
148#endif
149
150    USE kinds
151   
152    USE singleton,                                                             &
153        ONLY: fftn
154   
155    USE temperton_fft
156   
157    USE transpose_indices,                                                     &
158        ONLY:  nxl_y, nxr_y, nyn_x, nys_x, nzb_x, nzb_y, nzt_x, nzt_y
159
160    IMPLICIT NONE
161
162    PRIVATE
163    PUBLIC fft_x, fft_x_1d, fft_y, fft_y_1d, fft_init, fft_x_m, fft_y_m
164
165    INTEGER(iwp), DIMENSION(:), ALLOCATABLE, SAVE ::  ifax_x  !<
166    INTEGER(iwp), DIMENSION(:), ALLOCATABLE, SAVE ::  ifax_y  !<
167
168    LOGICAL, SAVE ::  init_fft = .FALSE.  !<
169
170    REAL(wp), SAVE ::  dnx      !<
171    REAL(wp), SAVE ::  dny      !<
172    REAL(wp), SAVE ::  sqr_dnx  !<
173    REAL(wp), SAVE ::  sqr_dny  !<
174   
175    REAL(wp), DIMENSION(:), ALLOCATABLE, SAVE ::  trigs_x  !<
176    REAL(wp), DIMENSION(:), ALLOCATABLE, SAVE ::  trigs_y  !<
177
178#if defined( __ibm )
179    INTEGER(iwp), PARAMETER ::  nau1 = 20000  !<
180    INTEGER(iwp), PARAMETER ::  nau2 = 22000  !<
181!
182!-- The following working arrays contain tables and have to be "save" and
183!-- shared in OpenMP sense
184    REAL(wp), DIMENSION(nau1), SAVE ::  aux1  !<
185    REAL(wp), DIMENSION(nau1), SAVE ::  auy1  !<
186    REAL(wp), DIMENSION(nau1), SAVE ::  aux3  !<
187    REAL(wp), DIMENSION(nau1), SAVE ::  auy3  !<
188   
189#elif defined( __nec )
190    INTEGER(iwp), SAVE ::  nz1  !<
191   
192    REAL(wp), DIMENSION(:), ALLOCATABLE, SAVE ::  trig_xb  !<
193    REAL(wp), DIMENSION(:), ALLOCATABLE, SAVE ::  trig_xf  !<
194    REAL(wp), DIMENSION(:), ALLOCATABLE, SAVE ::  trig_yb  !<
195    REAL(wp), DIMENSION(:), ALLOCATABLE, SAVE ::  trig_yf  !<
196   
197#endif
198
199#if defined( __fftw )
200    INCLUDE  'fftw3.f03'
201    INTEGER(KIND=C_INT) ::  nx_c  !<
202    INTEGER(KIND=C_INT) ::  ny_c  !<
203   
204    COMPLEX(KIND=C_DOUBLE_COMPLEX), DIMENSION(:), ALLOCATABLE, SAVE ::  x_out  !<
205    COMPLEX(KIND=C_DOUBLE_COMPLEX), DIMENSION(:), ALLOCATABLE, SAVE ::         &
206       y_out  !<
207   
208    REAL(KIND=C_DOUBLE), DIMENSION(:), ALLOCATABLE, SAVE ::                    &
209       x_in   !<
210    REAL(KIND=C_DOUBLE), DIMENSION(:), ALLOCATABLE, SAVE ::                    &
211       y_in   !<
212    !$OMP THREADPRIVATE( x_out, y_out, x_in, y_in )
213   
214   
215    TYPE(C_PTR), SAVE ::  plan_xf, plan_xi, plan_yf, plan_yi
216#endif
217
218!
219!-- Public interfaces
220    INTERFACE fft_init
221       MODULE PROCEDURE fft_init
222    END INTERFACE fft_init
223
224    INTERFACE fft_x
225       MODULE PROCEDURE fft_x
226    END INTERFACE fft_x
227
228    INTERFACE fft_x_1d
229       MODULE PROCEDURE fft_x_1d
230    END INTERFACE fft_x_1d
231
232    INTERFACE fft_y
233       MODULE PROCEDURE fft_y
234    END INTERFACE fft_y
235
236    INTERFACE fft_y_1d
237       MODULE PROCEDURE fft_y_1d
238    END INTERFACE fft_y_1d
239
240    INTERFACE fft_x_m
241       MODULE PROCEDURE fft_x_m
242    END INTERFACE fft_x_m
243
244    INTERFACE fft_y_m
245       MODULE PROCEDURE fft_y_m
246    END INTERFACE fft_y_m
247
248 CONTAINS
249
250
251!------------------------------------------------------------------------------!
252! Description:
253! ------------
254!> @todo Missing subroutine description.
255!------------------------------------------------------------------------------!
256    SUBROUTINE fft_init
257
258       IMPLICIT NONE
259
260!
261!--    The following temporary working arrays have to be on stack or private
262!--    in OpenMP sense
263#if defined( __ibm )
264       REAL(wp), DIMENSION(0:nx+2) ::  workx  !<
265       REAL(wp), DIMENSION(0:ny+2) ::  worky  !<
266       REAL(wp), DIMENSION(nau2)   ::  aux2   !<
267       REAL(wp), DIMENSION(nau2)   ::  auy2   !<
268       REAL(wp), DIMENSION(nau2)   ::  aux4   !<
269       REAL(wp), DIMENSION(nau2)   ::  auy4   !<
270#elif defined( __nec )
271       REAL(wp), DIMENSION(0:nx+3,nz+1)   ::  work_x  !<
272       REAL(wp), DIMENSION(0:ny+3,nz+1)   ::  work_y  !<
273       REAL(wp), DIMENSION(6*(nx+3),nz+1) ::  workx   !<
274       REAL(wp), DIMENSION(6*(ny+3),nz+1) ::  worky   !<
275#endif
276
277!
278!--    Return, if already called
279       IF ( init_fft )  THEN
280          RETURN
281       ELSE
282          init_fft = .TRUE.
283       ENDIF
284
285       IF ( fft_method == 'system-specific' )  THEN
286
287          dnx = 1.0_wp / ( nx + 1.0_wp )
288          dny = 1.0_wp / ( ny + 1.0_wp )
289          sqr_dnx = SQRT( dnx )
290          sqr_dny = SQRT( dny )
291#if defined( __ibm )
292!
293!--       Initialize tables for fft along x
294          CALL DRCFT( 1, workx, 1, workx, 1, nx+1, 1,  1, sqr_dnx, aux1, nau1, &
295                      aux2, nau2 )
296          CALL DCRFT( 1, workx, 1, workx, 1, nx+1, 1, -1, sqr_dnx, aux3, nau1, &
297                      aux4, nau2 )
298!
299!--       Initialize tables for fft along y
300          CALL DRCFT( 1, worky, 1, worky, 1, ny+1, 1,  1, sqr_dny, auy1, nau1, &
301                      auy2, nau2 )
302          CALL DCRFT( 1, worky, 1, worky, 1, ny+1, 1, -1, sqr_dny, auy3, nau1, &
303                      auy4, nau2 )
304#elif defined( __nec )
305          message_string = 'fft method "' // TRIM( fft_method) // &
306                           '" currently does not work on NEC'
307          CALL message( 'fft_init', 'PA0187', 1, 2, 0, 6, 0 )
308
309          ALLOCATE( trig_xb(2*(nx+1)), trig_xf(2*(nx+1)),                      &
310                    trig_yb(2*(ny+1)), trig_yf(2*(ny+1)) )
311
312          work_x = 0.0_wp
313          work_y = 0.0_wp
314          nz1  = nz + MOD( nz+1, 2 )  ! odd nz slows down fft significantly
315                                      ! when using the NEC ffts
316
317!
318!--       Initialize tables for fft along x (non-vector and vector case (M))
319          CALL DZFFT( 0, nx+1, sqr_dnx, work_x, work_x, trig_xf, workx, 0 )
320          CALL ZDFFT( 0, nx+1, sqr_dnx, work_x, work_x, trig_xb, workx, 0 )
321          CALL DZFFTM( 0, nx+1, nz1, sqr_dnx, work_x, nx+4, work_x, nx+4,      &
322                       trig_xf, workx, 0 )
323          CALL ZDFFTM( 0, nx+1, nz1, sqr_dnx, work_x, nx+4, work_x, nx+4,      &
324                       trig_xb, workx, 0 )
325!
326!--       Initialize tables for fft along y (non-vector and vector case (M))
327          CALL DZFFT( 0, ny+1, sqr_dny, work_y, work_y, trig_yf, worky, 0 )
328          CALL ZDFFT( 0, ny+1, sqr_dny, work_y, work_y, trig_yb, worky, 0 )
329          CALL DZFFTM( 0, ny+1, nz1, sqr_dny, work_y, ny+4, work_y, ny+4,      &
330                       trig_yf, worky, 0 )
331          CALL ZDFFTM( 0, ny+1, nz1, sqr_dny, work_y, ny+4, work_y, ny+4,      &
332                       trig_yb, worky, 0 )
333#else
334          message_string = 'no system-specific fft-call available'
335          CALL message( 'fft_init', 'PA0188', 1, 2, 0, 6, 0 )
336#endif
337       ELSEIF ( fft_method == 'temperton-algorithm' )  THEN
338!
339!--       Temperton-algorithm
340!--       Initialize tables for fft along x and y
341          ALLOCATE( ifax_x(nx+1), ifax_y(ny+1), trigs_x(nx+1), trigs_y(ny+1) )
342
343          CALL set99( trigs_x, ifax_x, nx+1 )
344          CALL set99( trigs_y, ifax_y, ny+1 )
345
346       ELSEIF ( fft_method == 'fftw' )  THEN
347!
348!--       FFTW
349#if defined( __fftw )
350          nx_c = nx+1
351          ny_c = ny+1
352          !$OMP PARALLEL
353          ALLOCATE( x_in(0:nx+2), y_in(0:ny+2), x_out(0:(nx+1)/2),             &
354                    y_out(0:(ny+1)/2) )
355          !$OMP END PARALLEL
356          plan_xf = FFTW_PLAN_DFT_R2C_1D( nx_c, x_in, x_out, FFTW_ESTIMATE )
357          plan_xi = FFTW_PLAN_DFT_C2R_1D( nx_c, x_out, x_in, FFTW_ESTIMATE )
358          plan_yf = FFTW_PLAN_DFT_R2C_1D( ny_c, y_in, y_out, FFTW_ESTIMATE )
359          plan_yi = FFTW_PLAN_DFT_C2R_1D( ny_c, y_out, y_in, FFTW_ESTIMATE )
360#else
361          message_string = 'preprocessor switch for fftw is missing'
362          CALL message( 'fft_init', 'PA0080', 1, 2, 0, 6, 0 )
363#endif
364
365       ELSEIF ( fft_method == 'singleton-algorithm' )  THEN
366
367          CONTINUE
368
369       ELSE
370
371          message_string = 'fft method "' // TRIM( fft_method) // &
372                           '" not available'
373          CALL message( 'fft_init', 'PA0189', 1, 2, 0, 6, 0 )
374       ENDIF
375
376    END SUBROUTINE fft_init
377
378
379!------------------------------------------------------------------------------!
380! Description:
381! ------------
382!> Fourier-transformation along x-direction.                 
383!> Version for 2D-decomposition.
384!> It uses internal algorithms (Singleton or Temperton) or     
385!> system-specific routines, if they are available           
386!------------------------------------------------------------------------------!
387 
388    SUBROUTINE fft_x( ar, direction, ar_2d )
389
390
391       IMPLICIT NONE
392
393       CHARACTER (LEN=*) ::  direction  !<
394       
395       COMPLEX(wp), DIMENSION(:), ALLOCATABLE ::  cwork  !<
396
397       INTEGER(iwp) ::  i          !<
398       INTEGER(iwp) ::  ishape(1)  !<
399       INTEGER(iwp) ::  j          !<
400       INTEGER(iwp) ::  k          !<
401
402       LOGICAL ::  forward_fft !<
403       
404       REAL(wp), DIMENSION(0:nx+2) ::  work   !<
405       REAL(wp), DIMENSION(nx+2)   ::  work1  !<
406       
407#if defined( __ibm )
408       REAL(wp), DIMENSION(nau2) ::  aux2  !<
409       REAL(wp), DIMENSION(nau2) ::  aux4  !<
410#elif defined( __nec )
411       REAL(wp), DIMENSION(6*(nx+1)) ::  work2  !<
412#endif
413
414       REAL(wp), DIMENSION(0:nx,nys_x:nyn_x), OPTIONAL   ::                    &
415          ar_2d   !<
416       REAL(wp), DIMENSION(0:nx,nys_x:nyn_x,nzb_x:nzt_x) ::                    &
417          ar      !<
418
419       IF ( direction == 'forward' )  THEN
420          forward_fft = .TRUE.
421       ELSE
422          forward_fft = .FALSE.
423       ENDIF
424
425       IF ( fft_method == 'singleton-algorithm' )  THEN
426
427!
428!--       Performing the fft with singleton's software works on every system,
429!--       since it is part of the model
430          ALLOCATE( cwork(0:nx) )
431     
432          IF ( forward_fft )   then
433
434             !$OMP PARALLEL PRIVATE ( cwork, i, ishape, j, k )
435             !$OMP DO
436             DO  k = nzb_x, nzt_x
437                DO  j = nys_x, nyn_x
438
439                   DO  i = 0, nx
440                      cwork(i) = CMPLX( ar(i,j,k), KIND=wp )
441                   ENDDO
442
443                   ishape = SHAPE( cwork )
444                   CALL FFTN( cwork, ishape )
445
446                   DO  i = 0, (nx+1)/2
447                      ar(i,j,k) = REAL( cwork(i), KIND=wp )
448                   ENDDO
449                   DO  i = 1, (nx+1)/2 - 1
450                      ar(nx+1-i,j,k) = -AIMAG( cwork(i) )
451                   ENDDO
452
453                ENDDO
454             ENDDO
455             !$OMP END PARALLEL
456
457          ELSE
458
459             !$OMP PARALLEL PRIVATE ( cwork, i, ishape, j, k )
460             !$OMP DO
461             DO  k = nzb_x, nzt_x
462                DO  j = nys_x, nyn_x
463
464                   cwork(0) = CMPLX( ar(0,j,k), 0.0_wp, KIND=wp )
465                   DO  i = 1, (nx+1)/2 - 1
466                      cwork(i)      = CMPLX( ar(i,j,k), -ar(nx+1-i,j,k),       &
467                                             KIND=wp )
468                      cwork(nx+1-i) = CMPLX( ar(i,j,k),  ar(nx+1-i,j,k),       &
469                                             KIND=wp )
470                   ENDDO
471                   cwork((nx+1)/2) = CMPLX( ar((nx+1)/2,j,k), 0.0_wp, KIND=wp )
472
473                   ishape = SHAPE( cwork )
474                   CALL FFTN( cwork, ishape, inv = .TRUE. )
475
476                   DO  i = 0, nx
477                      ar(i,j,k) = REAL( cwork(i), KIND=wp )
478                   ENDDO
479
480                ENDDO
481             ENDDO
482             !$OMP END PARALLEL
483
484          ENDIF
485
486          DEALLOCATE( cwork )
487
488       ELSEIF ( fft_method == 'temperton-algorithm' )  THEN
489
490!
491!--       Performing the fft with Temperton's software works on every system,
492!--       since it is part of the model
493          IF ( forward_fft )  THEN
494
495             !$OMP PARALLEL PRIVATE ( work, work1, i, j, k )
496             !$OMP DO
497             DO  k = nzb_x, nzt_x
498                DO  j = nys_x, nyn_x
499
500                   work(0:nx) = ar(0:nx,j,k)
501                   CALL fft991cy( work, work1, trigs_x, ifax_x, 1, nx+1, nx+1, 1, -1 )
502
503                   DO  i = 0, (nx+1)/2
504                      ar(i,j,k) = work(2*i)
505                   ENDDO
506                   DO  i = 1, (nx+1)/2 - 1
507                      ar(nx+1-i,j,k) = work(2*i+1)
508                   ENDDO
509
510                ENDDO
511             ENDDO
512             !$OMP END PARALLEL
513
514          ELSE
515
516             !$OMP PARALLEL PRIVATE ( work, work1, i, j, k )
517             !$OMP DO
518             DO  k = nzb_x, nzt_x
519                DO  j = nys_x, nyn_x
520
521                   DO  i = 0, (nx+1)/2
522                      work(2*i) = ar(i,j,k)
523                   ENDDO
524                   DO  i = 1, (nx+1)/2 - 1
525                      work(2*i+1) = ar(nx+1-i,j,k)
526                   ENDDO
527                   work(1)    = 0.0_wp
528                   work(nx+2) = 0.0_wp
529
530                   CALL fft991cy( work, work1, trigs_x, ifax_x, 1, nx+1, nx+1, 1, 1 )
531                   ar(0:nx,j,k) = work(0:nx)
532
533                ENDDO
534             ENDDO
535             !$OMP END PARALLEL
536
537          ENDIF
538
539       ELSEIF ( fft_method == 'fftw' )  THEN
540
541#if defined( __fftw )
542          IF ( forward_fft )  THEN
543
544             !$OMP PARALLEL PRIVATE ( work, i, j, k )
545             !$OMP DO
546             DO  k = nzb_x, nzt_x
547                DO  j = nys_x, nyn_x
548
549                   x_in(0:nx) = ar(0:nx,j,k)
550                   CALL FFTW_EXECUTE_DFT_R2C( plan_xf, x_in, x_out )
551
552                   IF ( PRESENT( ar_2d ) )  THEN
553
554                      DO  i = 0, (nx+1)/2
555                         ar_2d(i,j) = REAL( x_out(i), KIND=wp ) / ( nx+1 )
556                      ENDDO
557                      DO  i = 1, (nx+1)/2 - 1
558                         ar_2d(nx+1-i,j) = AIMAG( x_out(i) ) / ( nx+1 )
559                      ENDDO
560
561                   ELSE
562
563                      DO  i = 0, (nx+1)/2
564                         ar(i,j,k) = REAL( x_out(i), KIND=wp ) / ( nx+1 )
565                      ENDDO
566                      DO  i = 1, (nx+1)/2 - 1
567                         ar(nx+1-i,j,k) = AIMAG( x_out(i) ) / ( nx+1 )
568                      ENDDO
569
570                   ENDIF
571
572                ENDDO
573             ENDDO
574             !$OMP END PARALLEL
575
576          ELSE
577             !$OMP PARALLEL PRIVATE ( work, i, j, k )
578             !$OMP DO
579             DO  k = nzb_x, nzt_x
580                DO  j = nys_x, nyn_x
581
582                   IF ( PRESENT( ar_2d ) )  THEN
583
584                      x_out(0) = CMPLX( ar_2d(0,j), 0.0_wp, KIND=wp )
585                      DO  i = 1, (nx+1)/2 - 1
586                         x_out(i) = CMPLX( ar_2d(i,j), ar_2d(nx+1-i,j),        &
587                                           KIND=wp )
588                      ENDDO
589                      x_out((nx+1)/2) = CMPLX( ar_2d((nx+1)/2,j), 0.0_wp,      &
590                                               KIND=wp )
591
592                   ELSE
593
594                      x_out(0) = CMPLX( ar(0,j,k), 0.0_wp, KIND=wp )
595                      DO  i = 1, (nx+1)/2 - 1
596                         x_out(i) = CMPLX( ar(i,j,k), ar(nx+1-i,j,k), KIND=wp )
597                      ENDDO
598                      x_out((nx+1)/2) = CMPLX( ar((nx+1)/2,j,k), 0.0_wp,       &
599                                               KIND=wp )
600
601                   ENDIF
602
603                   CALL FFTW_EXECUTE_DFT_C2R( plan_xi, x_out, x_in)
604                   ar(0:nx,j,k) = x_in(0:nx)
605
606                ENDDO
607             ENDDO
608             !$OMP END PARALLEL
609
610          ENDIF
611#endif
612
613       ELSEIF ( fft_method == 'system-specific' )  THEN
614
615#if defined( __ibm )
616          IF ( forward_fft )  THEN
617
618             !$OMP PARALLEL PRIVATE ( work, i, j, k )
619             !$OMP DO
620             DO  k = nzb_x, nzt_x
621                DO  j = nys_x, nyn_x
622
623                   CALL DRCFT( 0, ar, 1, work, 1, nx+1, 1, 1, sqr_dnx, aux1,   &
624                               nau1, aux2, nau2 )
625
626                   DO  i = 0, (nx+1)/2
627                      ar(i,j,k) = work(2*i)
628                   ENDDO
629                   DO  i = 1, (nx+1)/2 - 1
630                      ar(nx+1-i,j,k) = work(2*i+1)
631                   ENDDO
632
633                ENDDO
634             ENDDO
635             !$OMP END PARALLEL
636
637          ELSE
638
639             !$OMP PARALLEL PRIVATE ( work, i, j, k )
640             !$OMP DO
641             DO  k = nzb_x, nzt_x
642                DO  j = nys_x, nyn_x
643
644                   DO  i = 0, (nx+1)/2
645                      work(2*i) = ar(i,j,k)
646                   ENDDO
647                   DO  i = 1, (nx+1)/2 - 1
648                      work(2*i+1) = ar(nx+1-i,j,k)
649                   ENDDO
650                   work(1) = 0.0_wp
651                   work(nx+2) = 0.0_wp
652
653                   CALL DCRFT( 0, work, 1, work, 1, nx+1, 1, -1, sqr_dnx,      & 
654                               aux3, nau1, aux4, nau2 )
655
656                   DO  i = 0, nx
657                      ar(i,j,k) = work(i)
658                   ENDDO
659
660                ENDDO
661             ENDDO
662             !$OMP END PARALLEL
663
664          ENDIF
665
666#elif defined( __nec )
667
668          IF ( forward_fft )  THEN
669
670             !$OMP PARALLEL PRIVATE ( work, i, j, k )
671             !$OMP DO
672             DO  k = nzb_x, nzt_x
673                DO  j = nys_x, nyn_x
674
675                   work(0:nx) = ar(0:nx,j,k)
676
677                   CALL DZFFT( 1, nx+1, sqr_dnx, work, work, trig_xf, work2, 0 )
678     
679                   DO  i = 0, (nx+1)/2
680                      ar(i,j,k) = work(2*i)
681                   ENDDO
682                   DO  i = 1, (nx+1)/2 - 1
683                      ar(nx+1-i,j,k) = work(2*i+1)
684                   ENDDO
685
686                ENDDO
687             ENDDO
688             !$END OMP PARALLEL
689
690          ELSE
691
692             !$OMP PARALLEL PRIVATE ( work, i, j, k )
693             !$OMP DO
694             DO  k = nzb_x, nzt_x
695                DO  j = nys_x, nyn_x
696
697                   DO  i = 0, (nx+1)/2
698                      work(2*i) = ar(i,j,k)
699                   ENDDO
700                   DO  i = 1, (nx+1)/2 - 1
701                      work(2*i+1) = ar(nx+1-i,j,k)
702                   ENDDO
703                   work(1) = 0.0_wp
704                   work(nx+2) = 0.0_wp
705
706                   CALL ZDFFT( -1, nx+1, sqr_dnx, work, work, trig_xb, work2, 0 )
707
708                   ar(0:nx,j,k) = work(0:nx)
709
710                ENDDO
711             ENDDO
712             !$OMP END PARALLEL
713
714          ENDIF
715
716#else
717          message_string = 'no system-specific fft-call available'
718          CALL message( 'fft_x', 'PA0188', 1, 2, 0, 6, 0 )
719#endif
720
721       ELSE
722
723          message_string = 'fft method "' // TRIM( fft_method) // &
724                           '" not available'
725          CALL message( 'fft_x', 'PA0189', 1, 2, 0, 6, 0 )
726
727       ENDIF
728
729    END SUBROUTINE fft_x
730
731!------------------------------------------------------------------------------!
732! Description:
733! ------------
734!> Fourier-transformation along x-direction.
735!> Version for 1D-decomposition.
736!> It uses internal algorithms (Singleton or Temperton) or
737!> system-specific routines, if they are available
738!------------------------------------------------------------------------------!
739 
740    SUBROUTINE fft_x_1d( ar, direction )
741
742
743       IMPLICIT NONE
744
745       CHARACTER (LEN=*) ::  direction  !<
746       
747       INTEGER(iwp) ::  i               !<
748       INTEGER(iwp) ::  ishape(1)       !<
749
750       LOGICAL ::  forward_fft          !<
751
752       REAL(wp), DIMENSION(0:nx)   ::  ar     !<
753       REAL(wp), DIMENSION(0:nx+2) ::  work   !<
754       REAL(wp), DIMENSION(nx+2)   ::  work1  !<
755       
756       COMPLEX(wp), DIMENSION(:), ALLOCATABLE ::  cwork  !<
757       
758#if defined( __ibm )
759       REAL(wp), DIMENSION(nau2) ::  aux2       !<
760       REAL(wp), DIMENSION(nau2) ::  aux4       !<
761#elif defined( __nec )
762       REAL(wp), DIMENSION(6*(nx+1)) ::  work2  !<
763#endif
764
765       IF ( direction == 'forward' )  THEN
766          forward_fft = .TRUE.
767       ELSE
768          forward_fft = .FALSE.
769       ENDIF
770
771       IF ( fft_method == 'singleton-algorithm' )  THEN
772
773!
774!--       Performing the fft with singleton's software works on every system,
775!--       since it is part of the model
776          ALLOCATE( cwork(0:nx) )
777     
778          IF ( forward_fft )   then
779
780             DO  i = 0, nx
781                cwork(i) = CMPLX( ar(i), KIND=wp )
782             ENDDO
783             ishape = SHAPE( cwork )
784             CALL FFTN( cwork, ishape )
785             DO  i = 0, (nx+1)/2
786                ar(i) = REAL( cwork(i), KIND=wp )
787             ENDDO
788             DO  i = 1, (nx+1)/2 - 1
789                ar(nx+1-i) = -AIMAG( cwork(i) )
790             ENDDO
791
792          ELSE
793
794             cwork(0) = CMPLX( ar(0), 0.0_wp, KIND=wp )
795             DO  i = 1, (nx+1)/2 - 1
796                cwork(i)      = CMPLX( ar(i), -ar(nx+1-i), KIND=wp )
797                cwork(nx+1-i) = CMPLX( ar(i),  ar(nx+1-i), KIND=wp )
798             ENDDO
799             cwork((nx+1)/2) = CMPLX( ar((nx+1)/2), 0.0_wp, KIND=wp )
800
801             ishape = SHAPE( cwork )
802             CALL FFTN( cwork, ishape, inv = .TRUE. )
803
804             DO  i = 0, nx
805                ar(i) = REAL( cwork(i), KIND=wp )
806             ENDDO
807
808          ENDIF
809
810          DEALLOCATE( cwork )
811
812       ELSEIF ( fft_method == 'temperton-algorithm' )  THEN
813
814!
815!--       Performing the fft with Temperton's software works on every system,
816!--       since it is part of the model
817          IF ( forward_fft )  THEN
818
819             work(0:nx) = ar
820             CALL fft991cy( work, work1, trigs_x, ifax_x, 1, nx+1, nx+1, 1, -1 )
821
822             DO  i = 0, (nx+1)/2
823                ar(i) = work(2*i)
824             ENDDO
825             DO  i = 1, (nx+1)/2 - 1
826                ar(nx+1-i) = work(2*i+1)
827             ENDDO
828
829          ELSE
830
831             DO  i = 0, (nx+1)/2
832                work(2*i) = ar(i)
833             ENDDO
834             DO  i = 1, (nx+1)/2 - 1
835                work(2*i+1) = ar(nx+1-i)
836             ENDDO
837             work(1)    = 0.0_wp
838             work(nx+2) = 0.0_wp
839
840             CALL fft991cy( work, work1, trigs_x, ifax_x, 1, nx+1, nx+1, 1, 1 )
841             ar = work(0:nx)
842
843          ENDIF
844
845       ELSEIF ( fft_method == 'fftw' )  THEN
846
847#if defined( __fftw )
848          IF ( forward_fft )  THEN
849
850             x_in(0:nx) = ar(0:nx)
851             CALL FFTW_EXECUTE_DFT_R2C( plan_xf, x_in, x_out )
852
853             DO  i = 0, (nx+1)/2
854                ar(i) = REAL( x_out(i), KIND=wp ) / ( nx+1 )
855             ENDDO
856             DO  i = 1, (nx+1)/2 - 1
857                ar(nx+1-i) = AIMAG( x_out(i) ) / ( nx+1 )
858             ENDDO
859
860         ELSE
861
862             x_out(0) = CMPLX( ar(0), 0.0_wp, KIND=wp )
863             DO  i = 1, (nx+1)/2 - 1
864                x_out(i) = CMPLX( ar(i), ar(nx+1-i), KIND=wp )
865             ENDDO
866             x_out((nx+1)/2) = CMPLX( ar((nx+1)/2), 0.0_wp, KIND=wp )
867
868             CALL FFTW_EXECUTE_DFT_C2R( plan_xi, x_out, x_in)
869             ar(0:nx) = x_in(0:nx)
870
871         ENDIF
872#endif
873
874       ELSEIF ( fft_method == 'system-specific' )  THEN
875
876#if defined( __ibm )
877          IF ( forward_fft )  THEN
878
879             CALL DRCFT( 0, ar, 1, work, 1, nx+1, 1, 1, sqr_dnx, aux1, nau1,   &
880                         aux2, nau2 )
881
882             DO  i = 0, (nx+1)/2
883                ar(i) = work(2*i)
884             ENDDO
885             DO  i = 1, (nx+1)/2 - 1
886                ar(nx+1-i) = work(2*i+1)
887             ENDDO
888
889          ELSE
890
891             DO  i = 0, (nx+1)/2
892                work(2*i) = ar(i)
893             ENDDO
894             DO  i = 1, (nx+1)/2 - 1
895                work(2*i+1) = ar(nx+1-i)
896             ENDDO
897             work(1) = 0.0_wp
898             work(nx+2) = 0.0_wp
899
900             CALL DCRFT( 0, work, 1, work, 1, nx+1, 1, -1, sqr_dnx, aux3, nau1, &
901                         aux4, nau2 )
902
903             DO  i = 0, nx
904                ar(i) = work(i)
905             ENDDO
906
907          ENDIF
908#elif defined( __nec )
909          IF ( forward_fft )  THEN
910
911             work(0:nx) = ar(0:nx)
912
913             CALL DZFFT( 1, nx+1, sqr_dnx, work, work, trig_xf, work2, 0 )
914     
915             DO  i = 0, (nx+1)/2
916                ar(i) = work(2*i)
917             ENDDO
918             DO  i = 1, (nx+1)/2 - 1
919                ar(nx+1-i) = work(2*i+1)
920             ENDDO
921
922          ELSE
923
924             DO  i = 0, (nx+1)/2
925                work(2*i) = ar(i)
926             ENDDO
927             DO  i = 1, (nx+1)/2 - 1
928                work(2*i+1) = ar(nx+1-i)
929             ENDDO
930             work(1) = 0.0_wp
931             work(nx+2) = 0.0_wp
932
933             CALL ZDFFT( -1, nx+1, sqr_dnx, work, work, trig_xb, work2, 0 )
934
935             ar(0:nx) = work(0:nx)
936
937          ENDIF
938#else
939          message_string = 'no system-specific fft-call available'
940          CALL message( 'fft_x_1d', 'PA0188', 1, 2, 0, 6, 0 )
941#endif
942       ELSE
943          message_string = 'fft method "' // TRIM( fft_method) // &
944                           '" not available'
945          CALL message( 'fft_x_1d', 'PA0189', 1, 2, 0, 6, 0 )
946
947       ENDIF
948
949    END SUBROUTINE fft_x_1d
950
951!------------------------------------------------------------------------------!
952! Description:
953! ------------
954!> Fourier-transformation along y-direction.
955!> Version for 2D-decomposition.
956!> It uses internal algorithms (Singleton or Temperton) or
957!> system-specific routines, if they are available.
958!>
959!> direction:  'forward' or 'backward'
960!> ar, ar_tr:  3D data arrays
961!>             forward:   ar: before  ar_tr: after transformation
962!>             backward:  ar_tr: before  ar: after transfosition
963!>
964!> In case of non-overlapping transposition/transformation:
965!> nxl_y_bound = nxl_y_l = nxl_y
966!> nxr_y_bound = nxr_y_l = nxr_y
967!>
968!> In case of overlapping transposition/transformation
969!> - nxl_y_bound  and  nxr_y_bound have the original values of
970!>   nxl_y, nxr_y.  ar_tr is dimensioned using these values.
971!> - nxl_y_l = nxr_y_r.  ar is dimensioned with these values, so that
972!>   transformation is carried out for a 2D-plane only.
973!------------------------------------------------------------------------------!
974 
975    SUBROUTINE fft_y( ar, direction, ar_tr, nxl_y_bound, nxr_y_bound, nxl_y_l, &
976                      nxr_y_l )
977
978
979       IMPLICIT NONE
980
981       CHARACTER (LEN=*) ::  direction  !<
982       
983       INTEGER(iwp) ::  i            !<
984       INTEGER(iwp) ::  j            !<
985       INTEGER(iwp) ::  jshape(1)    !<
986       INTEGER(iwp) ::  k            !<
987       INTEGER(iwp) ::  nxl_y_bound  !<
988       INTEGER(iwp) ::  nxl_y_l      !<
989       INTEGER(iwp) ::  nxr_y_bound  !<
990       INTEGER(iwp) ::  nxr_y_l      !<
991
992       LOGICAL ::  forward_fft  !<
993
994       REAL(wp), DIMENSION(0:ny+2) ::  work   !<
995       REAL(wp), DIMENSION(ny+2)   ::  work1  !<
996       
997       COMPLEX(wp), DIMENSION(:), ALLOCATABLE ::  cwork  !<
998       
999#if defined( __ibm )
1000       REAL(wp), DIMENSION(nau2) ::  auy2  !<
1001       REAL(wp), DIMENSION(nau2) ::  auy4  !<
1002#elif defined( __nec )
1003       REAL(wp), DIMENSION(6*(ny+1)) ::  work2  !<
1004#endif
1005
1006       REAL(wp), DIMENSION(0:ny,nxl_y_l:nxr_y_l,nzb_y:nzt_y)         ::        &
1007          ar     !<
1008       REAL(wp), DIMENSION(0:ny,nxl_y_bound:nxr_y_bound,nzb_y:nzt_y) ::        &
1009          ar_tr  !<
1010
1011       IF ( direction == 'forward' )  THEN
1012          forward_fft = .TRUE.
1013       ELSE
1014          forward_fft = .FALSE.
1015       ENDIF
1016
1017       IF ( fft_method == 'singleton-algorithm' )  THEN
1018
1019!
1020!--       Performing the fft with singleton's software works on every system,
1021!--       since it is part of the model
1022          ALLOCATE( cwork(0:ny) )
1023
1024          IF ( forward_fft )   then
1025
1026             !$OMP PARALLEL PRIVATE ( cwork, i, jshape, j, k )
1027             !$OMP DO
1028             DO  k = nzb_y, nzt_y
1029                DO  i = nxl_y_l, nxr_y_l
1030
1031                   DO  j = 0, ny
1032                      cwork(j) = CMPLX( ar(j,i,k), KIND=wp )
1033                   ENDDO
1034
1035                   jshape = SHAPE( cwork )
1036                   CALL FFTN( cwork, jshape )
1037
1038                   DO  j = 0, (ny+1)/2
1039                      ar_tr(j,i,k) = REAL( cwork(j), KIND=wp )
1040                   ENDDO
1041                   DO  j = 1, (ny+1)/2 - 1
1042                      ar_tr(ny+1-j,i,k) = -AIMAG( cwork(j) )
1043                   ENDDO
1044
1045                ENDDO
1046             ENDDO
1047             !$OMP END PARALLEL
1048
1049          ELSE
1050
1051             !$OMP PARALLEL PRIVATE ( cwork, i, jshape, j, k )
1052             !$OMP DO
1053             DO  k = nzb_y, nzt_y
1054                DO  i = nxl_y_l, nxr_y_l
1055
1056                   cwork(0) = CMPLX( ar_tr(0,i,k), 0.0_wp, KIND=wp )
1057                   DO  j = 1, (ny+1)/2 - 1
1058                      cwork(j)      = CMPLX( ar_tr(j,i,k), -ar_tr(ny+1-j,i,k), &
1059                                             KIND=wp )
1060                      cwork(ny+1-j) = CMPLX( ar_tr(j,i,k),  ar_tr(ny+1-j,i,k), &
1061                                             KIND=wp )
1062                   ENDDO
1063                   cwork((ny+1)/2) = CMPLX( ar_tr((ny+1)/2,i,k), 0.0_wp,       &
1064                                            KIND=wp )
1065
1066                   jshape = SHAPE( cwork )
1067                   CALL FFTN( cwork, jshape, inv = .TRUE. )
1068
1069                   DO  j = 0, ny
1070                      ar(j,i,k) = REAL( cwork(j), KIND=wp )
1071                   ENDDO
1072
1073                ENDDO
1074             ENDDO
1075             !$OMP END PARALLEL
1076
1077          ENDIF
1078
1079          DEALLOCATE( cwork )
1080
1081       ELSEIF ( fft_method == 'temperton-algorithm' )  THEN
1082
1083!
1084!--       Performing the fft with Temperton's software works on every system,
1085!--       since it is part of the model
1086          IF ( forward_fft )  THEN
1087
1088             !$OMP PARALLEL PRIVATE ( work, work1, i, j, k )
1089             !$OMP DO
1090             DO  k = nzb_y, nzt_y
1091                DO  i = nxl_y_l, nxr_y_l
1092
1093                   work(0:ny) = ar(0:ny,i,k)
1094                   CALL fft991cy( work, work1, trigs_y, ifax_y, 1, ny+1, ny+1, 1, -1 )
1095
1096                   DO  j = 0, (ny+1)/2
1097                      ar_tr(j,i,k) = work(2*j)
1098                   ENDDO
1099                   DO  j = 1, (ny+1)/2 - 1
1100                      ar_tr(ny+1-j,i,k) = work(2*j+1)
1101                   ENDDO
1102
1103                ENDDO
1104             ENDDO
1105             !$OMP END PARALLEL
1106
1107          ELSE
1108
1109             !$OMP PARALLEL PRIVATE ( work, work1, i, j, k )
1110             !$OMP DO
1111             DO  k = nzb_y, nzt_y
1112                DO  i = nxl_y_l, nxr_y_l
1113
1114                   DO  j = 0, (ny+1)/2
1115                      work(2*j) = ar_tr(j,i,k)
1116                   ENDDO
1117                   DO  j = 1, (ny+1)/2 - 1
1118                      work(2*j+1) = ar_tr(ny+1-j,i,k)
1119                   ENDDO
1120                   work(1)    = 0.0_wp
1121                   work(ny+2) = 0.0_wp
1122
1123                   CALL fft991cy( work, work1, trigs_y, ifax_y, 1, ny+1, ny+1, 1, 1 )
1124                   ar(0:ny,i,k) = work(0:ny)
1125
1126                ENDDO
1127             ENDDO
1128             !$OMP END PARALLEL
1129
1130          ENDIF
1131
1132       ELSEIF ( fft_method == 'fftw' )  THEN
1133
1134#if defined( __fftw )
1135          IF ( forward_fft )  THEN
1136
1137             !$OMP PARALLEL PRIVATE ( work, i, j, k )
1138             !$OMP DO
1139             DO  k = nzb_y, nzt_y
1140                DO  i = nxl_y_l, nxr_y_l
1141
1142                   y_in(0:ny) = ar(0:ny,i,k)
1143                   CALL FFTW_EXECUTE_DFT_R2C( plan_yf, y_in, y_out )
1144
1145                   DO  j = 0, (ny+1)/2
1146                      ar_tr(j,i,k) = REAL( y_out(j), KIND=wp ) / (ny+1)
1147                   ENDDO
1148                   DO  j = 1, (ny+1)/2 - 1
1149                      ar_tr(ny+1-j,i,k) = AIMAG( y_out(j) ) / (ny+1)
1150                   ENDDO
1151
1152                ENDDO
1153             ENDDO
1154             !$OMP END PARALLEL
1155
1156          ELSE
1157
1158             !$OMP PARALLEL PRIVATE ( work, i, j, k )
1159             !$OMP DO
1160             DO  k = nzb_y, nzt_y
1161                DO  i = nxl_y_l, nxr_y_l
1162
1163                   y_out(0) = CMPLX( ar_tr(0,i,k), 0.0_wp, KIND=wp )
1164                   DO  j = 1, (ny+1)/2 - 1
1165                      y_out(j) = CMPLX( ar_tr(j,i,k), ar_tr(ny+1-j,i,k),       &
1166                                        KIND=wp )
1167                   ENDDO
1168                   y_out((ny+1)/2) = CMPLX( ar_tr((ny+1)/2,i,k), 0.0_wp,       &
1169                                            KIND=wp )
1170
1171                   CALL FFTW_EXECUTE_DFT_C2R( plan_yi, y_out, y_in )
1172                   ar(0:ny,i,k) = y_in(0:ny)
1173
1174                ENDDO
1175             ENDDO
1176             !$OMP END PARALLEL
1177
1178          ENDIF
1179#endif
1180
1181       ELSEIF ( fft_method == 'system-specific' )  THEN
1182
1183#if defined( __ibm )
1184          IF ( forward_fft)  THEN
1185
1186             !$OMP PARALLEL PRIVATE ( work, i, j, k )
1187             !$OMP DO
1188             DO  k = nzb_y, nzt_y
1189                DO  i = nxl_y_l, nxr_y_l
1190
1191                   CALL DRCFT( 0, ar, 1, work, 1, ny+1, 1, 1, sqr_dny, auy1,   & 
1192                               nau1, auy2, nau2 )
1193
1194                   DO  j = 0, (ny+1)/2
1195                      ar_tr(j,i,k) = work(2*j)
1196                   ENDDO
1197                   DO  j = 1, (ny+1)/2 - 1
1198                      ar_tr(ny+1-j,i,k) = work(2*j+1)
1199                   ENDDO
1200
1201                ENDDO
1202             ENDDO
1203             !$OMP END PARALLEL
1204
1205          ELSE
1206
1207             !$OMP PARALLEL PRIVATE ( work, i, j, k )
1208             !$OMP DO
1209             DO  k = nzb_y, nzt_y
1210                DO  i = nxl_y_l, nxr_y_l
1211
1212                   DO  j = 0, (ny+1)/2
1213                      work(2*j) = ar_tr(j,i,k)
1214                   ENDDO
1215                   DO  j = 1, (ny+1)/2 - 1
1216                      work(2*j+1) = ar_tr(ny+1-j,i,k)
1217                   ENDDO
1218                   work(1)    = 0.0_wp
1219                   work(ny+2) = 0.0_wp
1220
1221                   CALL DCRFT( 0, work, 1, work, 1, ny+1, 1, -1, sqr_dny,      &
1222                               auy3, nau1, auy4, nau2 )
1223
1224                   DO  j = 0, ny
1225                      ar(j,i,k) = work(j)
1226                   ENDDO
1227
1228                ENDDO
1229             ENDDO
1230             !$OMP END PARALLEL
1231
1232          ENDIF
1233#elif defined( __nec )
1234          IF ( forward_fft )  THEN
1235
1236             !$OMP PARALLEL PRIVATE ( work, i, j, k )
1237             !$OMP DO
1238             DO  k = nzb_y, nzt_y
1239                DO  i = nxl_y_l, nxr_y_l
1240
1241                   work(0:ny) = ar(0:ny,i,k)
1242
1243                   CALL DZFFT( 1, ny+1, sqr_dny, work, work, trig_yf, work2, 0 )
1244
1245                   DO  j = 0, (ny+1)/2
1246                      ar_tr(j,i,k) = work(2*j)
1247                   ENDDO
1248                   DO  j = 1, (ny+1)/2 - 1
1249                      ar_tr(ny+1-j,i,k) = work(2*j+1)
1250                   ENDDO
1251
1252                ENDDO
1253             ENDDO
1254             !$END OMP PARALLEL
1255
1256          ELSE
1257
1258             !$OMP PARALLEL PRIVATE ( work, i, j, k )
1259             !$OMP DO
1260             DO  k = nzb_y, nzt_y
1261                DO  i = nxl_y_l, nxr_y_l
1262
1263                   DO  j = 0, (ny+1)/2
1264                      work(2*j) = ar_tr(j,i,k)
1265                   ENDDO
1266                   DO  j = 1, (ny+1)/2 - 1
1267                      work(2*j+1) = ar_tr(ny+1-j,i,k)
1268                   ENDDO
1269                   work(1) = 0.0_wp
1270                   work(ny+2) = 0.0_wp
1271
1272                   CALL ZDFFT( -1, ny+1, sqr_dny, work, work, trig_yb, work2, 0 )
1273
1274                   ar(0:ny,i,k) = work(0:ny)
1275
1276                ENDDO
1277             ENDDO
1278             !$OMP END PARALLEL
1279
1280          ENDIF
1281#else
1282          message_string = 'no system-specific fft-call available'
1283          CALL message( 'fft_y', 'PA0188', 1, 2, 0, 6, 0 ) 
1284#endif
1285
1286       ELSE
1287
1288          message_string = 'fft method "' // TRIM( fft_method) // &
1289                           '" not available'
1290          CALL message( 'fft_y', 'PA0189', 1, 2, 0, 6, 0 )
1291
1292       ENDIF
1293
1294    END SUBROUTINE fft_y
1295
1296!------------------------------------------------------------------------------!
1297! Description:
1298! ------------
1299!> Fourier-transformation along y-direction.
1300!> Version for 1D-decomposition.
1301!> It uses internal algorithms (Singleton or Temperton) or
1302!> system-specific routines, if they are available.
1303!------------------------------------------------------------------------------!
1304 
1305    SUBROUTINE fft_y_1d( ar, direction )
1306
1307
1308       IMPLICIT NONE
1309
1310       CHARACTER (LEN=*) ::  direction
1311       
1312       INTEGER(iwp) ::  j          !<
1313       INTEGER(iwp) ::  jshape(1)  !<
1314
1315       LOGICAL ::  forward_fft  !<
1316
1317       REAL(wp), DIMENSION(0:ny)    ::  ar     !<
1318       REAL(wp), DIMENSION(0:ny+2)  ::  work   !<
1319       REAL(wp), DIMENSION(ny+2)    ::  work1  !<
1320       
1321       COMPLEX(wp), DIMENSION(:), ALLOCATABLE ::  cwork  !<
1322       
1323#if defined( __ibm )
1324       REAL(wp), DIMENSION(nau2) ::  auy2  !<
1325       REAL(wp), DIMENSION(nau2) ::  auy4  !<
1326#elif defined( __nec )
1327       REAL(wp), DIMENSION(6*(ny+1)) ::  work2  !<
1328#endif
1329
1330       IF ( direction == 'forward' )  THEN
1331          forward_fft = .TRUE.
1332       ELSE
1333          forward_fft = .FALSE.
1334       ENDIF
1335
1336       IF ( fft_method == 'singleton-algorithm' )  THEN
1337
1338!
1339!--       Performing the fft with singleton's software works on every system,
1340!--       since it is part of the model
1341          ALLOCATE( cwork(0:ny) )
1342
1343          IF ( forward_fft )  THEN
1344
1345             DO  j = 0, ny
1346                cwork(j) = CMPLX( ar(j), KIND=wp )
1347             ENDDO
1348
1349             jshape = SHAPE( cwork )
1350             CALL FFTN( cwork, jshape )
1351
1352             DO  j = 0, (ny+1)/2
1353                ar(j) = REAL( cwork(j), KIND=wp )
1354             ENDDO
1355             DO  j = 1, (ny+1)/2 - 1
1356                ar(ny+1-j) = -AIMAG( cwork(j) )
1357             ENDDO
1358
1359          ELSE
1360
1361             cwork(0) = CMPLX( ar(0), 0.0_wp, KIND=wp )
1362             DO  j = 1, (ny+1)/2 - 1
1363                cwork(j)      = CMPLX( ar(j), -ar(ny+1-j), KIND=wp )
1364                cwork(ny+1-j) = CMPLX( ar(j),  ar(ny+1-j), KIND=wp )
1365             ENDDO
1366             cwork((ny+1)/2) = CMPLX( ar((ny+1)/2), 0.0_wp, KIND=wp )
1367
1368             jshape = SHAPE( cwork )
1369             CALL FFTN( cwork, jshape, inv = .TRUE. )
1370
1371             DO  j = 0, ny
1372                ar(j) = REAL( cwork(j), KIND=wp )
1373             ENDDO
1374
1375          ENDIF
1376
1377          DEALLOCATE( cwork )
1378
1379       ELSEIF ( fft_method == 'temperton-algorithm' )  THEN
1380
1381!
1382!--       Performing the fft with Temperton's software works on every system,
1383!--       since it is part of the model
1384          IF ( forward_fft )  THEN
1385
1386             work(0:ny) = ar
1387             CALL fft991cy( work, work1, trigs_y, ifax_y, 1, ny+1, ny+1, 1, -1 )
1388
1389             DO  j = 0, (ny+1)/2
1390                ar(j) = work(2*j)
1391             ENDDO
1392             DO  j = 1, (ny+1)/2 - 1
1393                ar(ny+1-j) = work(2*j+1)
1394             ENDDO
1395
1396          ELSE
1397
1398             DO  j = 0, (ny+1)/2
1399                work(2*j) = ar(j)
1400             ENDDO
1401             DO  j = 1, (ny+1)/2 - 1
1402                work(2*j+1) = ar(ny+1-j)
1403             ENDDO
1404             work(1)    = 0.0_wp
1405             work(ny+2) = 0.0_wp
1406
1407             CALL fft991cy( work, work1, trigs_y, ifax_y, 1, ny+1, ny+1, 1, 1 )
1408             ar = work(0:ny)
1409
1410          ENDIF
1411
1412       ELSEIF ( fft_method == 'fftw' )  THEN
1413
1414#if defined( __fftw )
1415          IF ( forward_fft )  THEN
1416
1417             y_in(0:ny) = ar(0:ny)
1418             CALL FFTW_EXECUTE_DFT_R2C( plan_yf, y_in, y_out )
1419
1420             DO  j = 0, (ny+1)/2
1421                ar(j) = REAL( y_out(j), KIND=wp ) / (ny+1)
1422             ENDDO
1423             DO  j = 1, (ny+1)/2 - 1
1424                ar(ny+1-j) = AIMAG( y_out(j) ) / (ny+1)
1425             ENDDO
1426
1427          ELSE
1428
1429             y_out(0) = CMPLX( ar(0), 0.0_wp, KIND=wp )
1430             DO  j = 1, (ny+1)/2 - 1
1431                y_out(j) = CMPLX( ar(j), ar(ny+1-j), KIND=wp )
1432             ENDDO
1433             y_out((ny+1)/2) = CMPLX( ar((ny+1)/2), 0.0_wp, KIND=wp )
1434
1435             CALL FFTW_EXECUTE_DFT_C2R( plan_yi, y_out, y_in )
1436             ar(0:ny) = y_in(0:ny)
1437
1438          ENDIF
1439#endif
1440
1441       ELSEIF ( fft_method == 'system-specific' )  THEN
1442
1443#if defined( __ibm )
1444          IF ( forward_fft )  THEN
1445
1446             CALL DRCFT( 0, ar, 1, work, 1, ny+1, 1, 1, sqr_dny, auy1, nau1,   &
1447                         auy2, nau2 )
1448
1449             DO  j = 0, (ny+1)/2
1450                ar(j) = work(2*j)
1451             ENDDO
1452             DO  j = 1, (ny+1)/2 - 1
1453                ar(ny+1-j) = work(2*j+1)
1454             ENDDO
1455
1456          ELSE
1457
1458             DO  j = 0, (ny+1)/2
1459                work(2*j) = ar(j)
1460             ENDDO
1461             DO  j = 1, (ny+1)/2 - 1
1462                work(2*j+1) = ar(ny+1-j)
1463             ENDDO
1464             work(1)    = 0.0_wp
1465             work(ny+2) = 0.0_wp
1466
1467             CALL DCRFT( 0, work, 1, work, 1, ny+1, 1, -1, sqr_dny, auy3,      &
1468                         nau1, auy4, nau2 )
1469
1470             DO  j = 0, ny
1471                ar(j) = work(j)
1472             ENDDO
1473
1474          ENDIF
1475#elif defined( __nec )
1476          IF ( forward_fft )  THEN
1477
1478             work(0:ny) = ar(0:ny)
1479
1480             CALL DZFFT( 1, ny+1, sqr_dny, work, work, trig_yf, work2, 0 )
1481
1482             DO  j = 0, (ny+1)/2
1483                ar(j) = work(2*j)
1484             ENDDO
1485             DO  j = 1, (ny+1)/2 - 1
1486                ar(ny+1-j) = work(2*j+1)
1487             ENDDO
1488
1489          ELSE
1490
1491             DO  j = 0, (ny+1)/2
1492                work(2*j) = ar(j)
1493             ENDDO
1494             DO  j = 1, (ny+1)/2 - 1
1495                work(2*j+1) = ar(ny+1-j)
1496             ENDDO
1497             work(1) = 0.0_wp
1498             work(ny+2) = 0.0_wp
1499
1500             CALL ZDFFT( -1, ny+1, sqr_dny, work, work, trig_yb, work2, 0 )
1501
1502             ar(0:ny) = work(0:ny)
1503
1504          ENDIF
1505#else
1506          message_string = 'no system-specific fft-call available'
1507          CALL message( 'fft_y_1d', 'PA0188', 1, 2, 0, 6, 0 ) 
1508
1509#endif
1510
1511       ELSE
1512
1513          message_string = 'fft method "' // TRIM( fft_method) // &
1514                           '" not available'
1515          CALL message( 'fft_y_1d', 'PA0189', 1, 2, 0, 6, 0 )
1516
1517       ENDIF
1518
1519    END SUBROUTINE fft_y_1d
1520
1521!------------------------------------------------------------------------------!
1522! Description:
1523! ------------
1524!> Fourier-transformation along x-direction.
1525!> Version for 1d domain decomposition
1526!> using multiple 1D FFT from Math Keisan on NEC or Temperton-algorithm
1527!> (no singleton-algorithm on NEC because it does not vectorize)
1528!------------------------------------------------------------------------------!
1529 
1530    SUBROUTINE fft_x_m( ar, direction )
1531
1532
1533       IMPLICIT NONE
1534
1535       CHARACTER (LEN=*) ::  direction  !<
1536       
1537       INTEGER(iwp) ::  i     !<
1538       INTEGER(iwp) ::  k     !<
1539       INTEGER(iwp) ::  siza  !<
1540
1541       REAL(wp), DIMENSION(0:nx,nz)       ::  ar     !<
1542       REAL(wp), DIMENSION(0:nx+3,nz+1)   ::  ai     !<
1543       REAL(wp), DIMENSION(6*(nx+4),nz+1) ::  work1  !<
1544       
1545#if defined( __nec )
1546       INTEGER(iwp) ::  sizw  !<
1547       
1548       COMPLEX(wp), DIMENSION((nx+4)/2+1,nz+1) ::  work  !<
1549#endif
1550
1551       IF ( fft_method == 'temperton-algorithm' )  THEN
1552
1553          siza = SIZE( ai, 1 )
1554
1555          IF ( direction == 'forward')  THEN
1556
1557             ai(0:nx,1:nz) = ar(0:nx,1:nz)
1558             ai(nx+1:,:)   = 0.0_wp
1559
1560             CALL fft991cy( ai, work1, trigs_x, ifax_x, 1, siza, nx+1, nz, -1 )
1561
1562             DO  k = 1, nz
1563                DO  i = 0, (nx+1)/2
1564                   ar(i,k) = ai(2*i,k)
1565                ENDDO
1566                DO  i = 1, (nx+1)/2 - 1
1567                   ar(nx+1-i,k) = ai(2*i+1,k)
1568                ENDDO
1569             ENDDO
1570
1571          ELSE
1572
1573             DO  k = 1, nz
1574                DO  i = 0, (nx+1)/2
1575                   ai(2*i,k) = ar(i,k)
1576                ENDDO
1577                DO  i = 1, (nx+1)/2 - 1
1578                   ai(2*i+1,k) = ar(nx+1-i,k)
1579                ENDDO
1580                ai(1,k) = 0.0_wp
1581                ai(nx+2,k) = 0.0_wp
1582             ENDDO
1583
1584             CALL fft991cy( ai, work1, trigs_x, ifax_x, 1, siza, nx+1, nz, 1 )
1585
1586             ar(0:nx,1:nz) = ai(0:nx,1:nz)
1587
1588          ENDIF
1589
1590       ELSEIF ( fft_method == 'system-specific' )  THEN
1591
1592#if defined( __nec )
1593          siza = SIZE( ai, 1 )
1594          sizw = SIZE( work, 1 )
1595
1596          IF ( direction == 'forward')  THEN
1597
1598!
1599!--          Tables are initialized once more. This call should not be
1600!--          necessary, but otherwise program aborts in asymmetric case
1601             CALL DZFFTM( 0, nx+1, nz1, sqr_dnx, work, nx+4, work, nx+4,       &
1602                          trig_xf, work1, 0 )
1603
1604             ai(0:nx,1:nz) = ar(0:nx,1:nz)
1605             IF ( nz1 > nz )  THEN
1606                ai(:,nz1) = 0.0_wp
1607             ENDIF
1608
1609             CALL DZFFTM( 1, nx+1, nz1, sqr_dnx, ai, siza, work, sizw,         &
1610                          trig_xf, work1, 0 )
1611
1612             DO  k = 1, nz
1613                DO  i = 0, (nx+1)/2
1614                   ar(i,k) = REAL( work(i+1,k), KIND=wp )
1615                ENDDO
1616                DO  i = 1, (nx+1)/2 - 1
1617                   ar(nx+1-i,k) = AIMAG( work(i+1,k) )
1618                ENDDO
1619             ENDDO
1620
1621          ELSE
1622
1623!
1624!--          Tables are initialized once more. This call should not be
1625!--          necessary, but otherwise program aborts in asymmetric case
1626             CALL ZDFFTM( 0, nx+1, nz1, sqr_dnx, work, nx+4, work, nx+4,       &
1627                          trig_xb, work1, 0 )
1628
1629             IF ( nz1 > nz )  THEN
1630                work(:,nz1) = 0.0_wp
1631             ENDIF
1632             DO  k = 1, nz
1633                work(1,k) = CMPLX( ar(0,k), 0.0_wp, KIND=wp )
1634                DO  i = 1, (nx+1)/2 - 1
1635                   work(i+1,k) = CMPLX( ar(i,k), ar(nx+1-i,k), KIND=wp )
1636                ENDDO
1637                work(((nx+1)/2)+1,k) = CMPLX( ar((nx+1)/2,k), 0.0_wp, KIND=wp )
1638             ENDDO
1639
1640             CALL ZDFFTM( -1, nx+1, nz1, sqr_dnx, work, sizw, ai, siza, &
1641                          trig_xb, work1, 0 )
1642
1643             ar(0:nx,1:nz) = ai(0:nx,1:nz)
1644
1645          ENDIF
1646
1647#else
1648          message_string = 'no system-specific fft-call available'
1649          CALL message( 'fft_x_m', 'PA0188', 1, 2, 0, 6, 0 ) 
1650#endif
1651
1652       ELSE
1653
1654          message_string = 'fft method "' // TRIM( fft_method) // &
1655                           '" not available'
1656          CALL message( 'fft_x_m', 'PA0189', 1, 2, 0, 6, 0 )
1657
1658       ENDIF
1659
1660    END SUBROUTINE fft_x_m
1661
1662!------------------------------------------------------------------------------!
1663! Description:
1664! ------------
1665!> Fourier-transformation along y-direction.
1666!> Version for 1d domain decomposition
1667!> using multiple 1D FFT from Math Keisan on NEC or Temperton-algorithm
1668!> (no singleton-algorithm on NEC because it does not vectorize)
1669!------------------------------------------------------------------------------!
1670 
1671    SUBROUTINE fft_y_m( ar, ny1, direction )
1672
1673
1674       IMPLICIT NONE
1675
1676       CHARACTER (LEN=*) ::  direction  !<
1677       
1678       INTEGER(iwp) ::  j     !<
1679       INTEGER(iwp) ::  k     !<
1680       INTEGER(iwp) ::  ny1   !<
1681       INTEGER(iwp) ::  siza  !<
1682
1683       REAL(wp), DIMENSION(0:ny1,nz)      ::  ar     !<
1684       REAL(wp), DIMENSION(0:ny+3,nz+1)   ::  ai     !<
1685       REAL(wp), DIMENSION(6*(ny+4),nz+1) ::  work1  !<
1686       
1687#if defined( __nec )
1688       INTEGER(iwp) ::  sizw  !<
1689       
1690       COMPLEX(wp), DIMENSION((ny+4)/2+1,nz+1) ::  work !<
1691#endif
1692
1693       IF ( fft_method == 'temperton-algorithm' )  THEN
1694
1695          siza = SIZE( ai, 1 )
1696
1697          IF ( direction == 'forward')  THEN
1698
1699             ai(0:ny,1:nz) = ar(0:ny,1:nz)
1700             ai(ny+1:,:)   = 0.0_wp
1701
1702             CALL fft991cy( ai, work1, trigs_y, ifax_y, 1, siza, ny+1, nz, -1 )
1703
1704             DO  k = 1, nz
1705                DO  j = 0, (ny+1)/2
1706                   ar(j,k) = ai(2*j,k)
1707                ENDDO
1708                DO  j = 1, (ny+1)/2 - 1
1709                   ar(ny+1-j,k) = ai(2*j+1,k)
1710                ENDDO
1711             ENDDO
1712
1713          ELSE
1714
1715             DO  k = 1, nz
1716                DO  j = 0, (ny+1)/2
1717                   ai(2*j,k) = ar(j,k)
1718                ENDDO
1719                DO  j = 1, (ny+1)/2 - 1
1720                   ai(2*j+1,k) = ar(ny+1-j,k)
1721                ENDDO
1722                ai(1,k) = 0.0_wp
1723                ai(ny+2,k) = 0.0_wp
1724             ENDDO
1725
1726             CALL fft991cy( ai, work1, trigs_y, ifax_y, 1, siza, ny+1, nz, 1 )
1727
1728             ar(0:ny,1:nz) = ai(0:ny,1:nz)
1729
1730          ENDIF
1731
1732       ELSEIF ( fft_method == 'system-specific' )  THEN
1733
1734#if defined( __nec )
1735          siza = SIZE( ai, 1 )
1736          sizw = SIZE( work, 1 )
1737
1738          IF ( direction == 'forward')  THEN
1739
1740!
1741!--          Tables are initialized once more. This call should not be
1742!--          necessary, but otherwise program aborts in asymmetric case
1743             CALL DZFFTM( 0, ny+1, nz1, sqr_dny, work, ny+4, work, ny+4, &
1744                          trig_yf, work1, 0 )
1745
1746             ai(0:ny,1:nz) = ar(0:ny,1:nz)
1747             IF ( nz1 > nz )  THEN
1748                ai(:,nz1) = 0.0_wp
1749             ENDIF
1750
1751             CALL DZFFTM( 1, ny+1, nz1, sqr_dny, ai, siza, work, sizw, &
1752                          trig_yf, work1, 0 )
1753
1754             DO  k = 1, nz
1755                DO  j = 0, (ny+1)/2
1756                   ar(j,k) = REAL( work(j+1,k), KIND=wp )
1757                ENDDO
1758                DO  j = 1, (ny+1)/2 - 1
1759                   ar(ny+1-j,k) = AIMAG( work(j+1,k) )
1760                ENDDO
1761             ENDDO
1762
1763          ELSE
1764
1765!
1766!--          Tables are initialized once more. This call should not be
1767!--          necessary, but otherwise program aborts in asymmetric case
1768             CALL ZDFFTM( 0, ny+1, nz1, sqr_dny, work, ny+4, work, ny+4, &
1769                          trig_yb, work1, 0 )
1770
1771             IF ( nz1 > nz )  THEN
1772                work(:,nz1) = 0.0_wp
1773             ENDIF
1774             DO  k = 1, nz
1775                work(1,k) = CMPLX( ar(0,k), 0.0_wp, KIND=wp )
1776                DO  j = 1, (ny+1)/2 - 1
1777                   work(j+1,k) = CMPLX( ar(j,k), ar(ny+1-j,k), KIND=wp )
1778                ENDDO
1779                work(((ny+1)/2)+1,k) = CMPLX( ar((ny+1)/2,k), 0.0_wp, KIND=wp )
1780             ENDDO
1781
1782             CALL ZDFFTM( -1, ny+1, nz1, sqr_dny, work, sizw, ai, siza, &
1783                          trig_yb, work1, 0 )
1784
1785             ar(0:ny,1:nz) = ai(0:ny,1:nz)
1786
1787          ENDIF
1788
1789#else
1790          message_string = 'no system-specific fft-call available'
1791          CALL message( 'fft_y_m', 'PA0188', 1, 2, 0, 6, 0 ) 
1792#endif
1793
1794       ELSE
1795         
1796          message_string = 'fft method "' // TRIM( fft_method) // &
1797                           '" not available'
1798          CALL message( 'fft_y_m', 'PA0189', 1, 2, 0, 6, 0 )
1799
1800       ENDIF
1801
1802    END SUBROUTINE fft_y_m
1803
1804
1805 END MODULE fft_xy
Note: See TracBrowser for help on using the repository browser.