Home

Context Navigation

source: palm/trunk/SOURCE/fft_xy.f90 @ 1497

Last change on this file since 1497 was 1483, checked in by raasch, 10 years ago
last commit documented
Property svn:keywords set to `Id`
File size: 58.8 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

| Impressum | ©Leibniz Universität Hannover |