Home

Context Navigation

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

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

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

Download in other formats:

| Impressum | ©Leibniz Universität Hannover |