Home

Context Navigation

source: palm/trunk/SOURCE/poismg.f90 @ 345

Last change on this file since 345 was 257, checked in by heinze, 16 years ago
Output of messages replaced by message handling routine
Property svn:keywords set to `Id`
File size: 54.2 KB

Line
1	SUBROUTINE poismg( r )
2
3	!------------------------------------------------------------------------------!
4	! Attention: Loop unrolling and cache optimization in SOR-Red/Black method
5	! still does not bring the expected speedup on ibm! Further work
6	! is required.
7	!
8	! Current revisions:
9	! -----------------
10	! Output of messages replaced by message handling routine.
11	!
12	!
13	! Former revisions:
14	! -----------------
15	! $Id: poismg.f90 257 2009-03-11 15:17:42Z heinze $
16	!
17	! 181 2008-07-30 07:07:47Z raasch
18	! Bugfix: grid_level+1 has to be used in restrict for flags-array
19	!
20	! 114 2007-10-10 00:03:15Z raasch
21	! Boundary conditions at walls are implicitly set using flag arrays. Only
22	! Neumann BC is allowed. Upper walls are still not realized.
23	! Bottom and top BCs for array f_mg in restrict removed because boundary
24	! values are not needed (right hand side of SOR iteration).
25	!
26	! 75 2007-03-22 09:54:05Z raasch
27	! 2nd+3rd argument removed from exchange horiz
28	!
29	! RCS Log replace by Id keyword, revision history cleaned up
30	!
31	! Revision 1.6 2005/03/26 20:55:54 raasch
32	! Implementation of non-cyclic (Neumann) horizontal boundary conditions,
33	! routine prolong simplified (one call of exchange_horiz spared)
34	!
35	! Revision 1.1 2001/07/20 13:10:51 raasch
36	! Initial revision
37	!
38	!
39	! Description:
40	! ------------
41	! Solves the Poisson equation for the perturbation pressure with a multigrid
42	! V- or W-Cycle scheme.
43	!
44	! This multigrid method was originally developed for PALM by Joerg Uhlenbrock,
45	! September 2000 - July 2001.
46	!------------------------------------------------------------------------------!
47
48	USE arrays_3d
49	USE control_parameters
50	USE cpulog
51	USE grid_variables
52	USE indices
53	USE interfaces
54	USE pegrid
55
56	IMPLICIT NONE
57
58	REAL :: maxerror, maximum_mgcycles, residual_norm
59
60	REAL, DIMENSION(nzb:nzt+1,nys-1:nyn+1,nxl-1:nxr+1) :: r
61
62	REAL, DIMENSION(:,:,:), ALLOCATABLE :: p3
63
64
65	CALL cpu_log( log_point_s(29), 'poismg', 'start' )
66
67
68	!
69	!-- Initialize arrays and variables used in this subroutine
70	ALLOCATE ( p3(nzb:nzt+1,nys-1:nyn+1,nxl-1:nxr+1) )
71
72
73	!
74	!-- Some boundaries have to be added to divergence array
75	CALL exchange_horiz( d )
76	d(nzb,:,:) = d(nzb+1,:,:)
77
78	!
79	!-- Initiation of the multigrid scheme. Does n cycles until the
80	!-- residual is smaller than the given limit. The accuracy of the solution
81	!-- of the poisson equation will increase with the number of cycles.
82	!-- If the number of cycles is preset by the user, this number will be
83	!-- carried out regardless of the accuracy.
84	grid_level_count = 0
85	mgcycles = 0
86	IF ( mg_cycles == -1 ) THEN
87	maximum_mgcycles = 0
88	residual_norm = 1.0
89	ELSE
90	maximum_mgcycles = mg_cycles
91	residual_norm = 0.0
92	ENDIF
93
94	DO WHILE ( residual_norm > residual_limit .OR. &
95	mgcycles < maximum_mgcycles )
96
97	CALL next_mg_level( d, p, p3, r)
98
99	!
100	!-- Calculate the residual if the user has not preset the number of
101	!-- cycles to be performed
102	IF ( maximum_mgcycles == 0 ) THEN
103	CALL resid( d, p, r )
104	maxerror = SUM( r(nzb+1:nzt,nys:nyn,nxl:nxr)**2 )
105	#if defined( __parallel )
106	CALL MPI_ALLREDUCE( maxerror, residual_norm, 1, MPI_REAL, MPI_SUM, &
107	comm2d, ierr)
108	#else
109	residual_norm = maxerror
110	#endif
111	residual_norm = SQRT( residual_norm )
112	ENDIF
113
114	mgcycles = mgcycles + 1
115
116	!
117	!-- If the user has not limited the number of cycles, stop the run in case
118	!-- of insufficient convergence
119	IF ( mgcycles > 1000 .AND. mg_cycles == -1 ) THEN
120	message_string = 'no sufficient convergence within 1000 cycles'
121	CALL message( 'poismg', 'PA0283', 1, 2, 0, 6, 0 )
122	ENDIF
123
124	ENDDO
125
126	DEALLOCATE( p3 )
127
128	CALL cpu_log( log_point_s(29), 'poismg', 'stop' )
129
130	END SUBROUTINE poismg
131
132
133
134	SUBROUTINE resid( f_mg, p_mg, r )
135
136	!------------------------------------------------------------------------------!
137	! Description:
138	! ------------
139	! Computes the residual of the perturbation pressure.
140	!------------------------------------------------------------------------------!
141
142	USE arrays_3d
143	USE control_parameters
144	USE grid_variables
145	USE indices
146	USE pegrid
147
148	IMPLICIT NONE
149
150	INTEGER :: i, j, k, l
151
152	REAL, DIMENSION(nzb:nzt_mg(grid_level)+1, &
153	nys_mg(grid_level)-1:nyn_mg(grid_level)+1, &
154	nxl_mg(grid_level)-1:nxr_mg(grid_level)+1) :: f_mg, p_mg, r
155
156	!
157	!-- Calculate the residual
158	l = grid_level
159
160	!
161	!-- Choose flag array of this level
162	SELECT CASE ( l )
163	CASE ( 1 )
164	flags => wall_flags_1
165	CASE ( 2 )
166	flags => wall_flags_2
167	CASE ( 3 )
168	flags => wall_flags_3
169	CASE ( 4 )
170	flags => wall_flags_4
171	CASE ( 5 )
172	flags => wall_flags_5
173	CASE ( 6 )
174	flags => wall_flags_6
175	CASE ( 7 )
176	flags => wall_flags_7
177	CASE ( 8 )
178	flags => wall_flags_8
179	CASE ( 9 )
180	flags => wall_flags_9
181	CASE ( 10 )
182	flags => wall_flags_10
183	END SELECT
184
185	!$OMP PARALLEL PRIVATE (i,j,k)
186	!$OMP DO
187	DO i = nxl_mg(l), nxr_mg(l)
188	DO j = nys_mg(l), nyn_mg(l)
189	DO k = nzb+1, nzt_mg(l)
190	r(k,j,i) = f_mg(k,j,i) &
191	- ddx2_mg(l) * &
192	( p_mg(k,j,i+1) + IBITS( flags(k,j,i), 5, 1 ) * &
193	( p_mg(k,j,i) - p_mg(k,j,i+1) ) + &
194	p_mg(k,j,i-1) + IBITS( flags(k,j,i), 4, 1 ) * &
195	( p_mg(k,j,i) - p_mg(k,j,i-1) ) ) &
196	- ddy2_mg(l) * &
197	( p_mg(k,j+1,i) + IBITS( flags(k,j,i), 3, 1 ) * &
198	( p_mg(k,j,i) - p_mg(k,j+1,i) ) + &
199	p_mg(k,j-1,i) + IBITS( flags(k,j,i), 2, 1 ) * &
200	( p_mg(k,j,i) - p_mg(k,j-1,i) ) ) &
201	- f2_mg(k,l) * p_mg(k+1,j,i) &
202	- f3_mg(k,l) * &
203	( p_mg(k-1,j,i) + IBITS( flags(k,j,i), 0, 1 ) * &
204	( p_mg(k,j,i) - p_mg(k-1,j,i) ) ) &
205	+ f1_mg(k,l) * p_mg(k,j,i)
206	!
207	!-- Residual within topography should be zero
208	r(k,j,i) = r(k,j,i) * ( 1.0 - IBITS( flags(k,j,i), 6, 1 ) )
209	ENDDO
210	ENDDO
211	ENDDO
212	!$OMP END PARALLEL
213
214	!
215	!-- Horizontal boundary conditions
216	CALL exchange_horiz( r )
217
218	IF ( bc_lr /= 'cyclic' ) THEN
219	IF ( inflow_l .OR. outflow_l ) r(:,:,nxl_mg(l)-1) = r(:,:,nxl_mg(l))
220	IF ( inflow_r .OR. outflow_r ) r(:,:,nxr_mg(l)+1) = r(:,:,nxr_mg(l))
221	ENDIF
222
223	IF ( bc_ns /= 'cyclic' ) THEN
224	IF ( inflow_n .OR. outflow_n ) r(:,nyn_mg(l)+1,:) = r(:,nyn_mg(l),:)
225	IF ( inflow_s .OR. outflow_s ) r(:,nys_mg(l)-1,:) = r(:,nys_mg(l),:)
226	ENDIF
227
228	!
229	!-- Top boundary condition
230	!-- A Neumann boundary condition for r is implicitly set in routine restrict
231	IF ( ibc_p_t == 1 ) THEN
232	r(nzt_mg(l)+1,:,: ) = r(nzt_mg(l),:,:)
233	ELSE
234	r(nzt_mg(l)+1,:,: ) = 0.0
235	ENDIF
236
237
238	END SUBROUTINE resid
239
240
241
242	SUBROUTINE restrict( f_mg, r )
243
244	!------------------------------------------------------------------------------!
245	! Description:
246	! ------------
247	! Interpolates the residual on the next coarser grid with "full weighting"
248	! scheme
249	!------------------------------------------------------------------------------!
250
251	USE control_parameters
252	USE grid_variables
253	USE indices
254	USE pegrid
255
256	IMPLICIT NONE
257
258	INTEGER :: i, ic, j, jc, k, kc, l
259
260	REAL :: rkjim, rkjip, rkjmi, rkjmim, rkjmip, rkjpi, rkjpim, rkjpip, &
261	rkmji, rkmjim, rkmjip, rkmjmi, rkmjmim, rkmjmip, rkmjpi, rkmjpim, &
262	rkmjpip
263
264	REAL, DIMENSION(nzb:nzt_mg(grid_level)+1, &
265	nys_mg(grid_level)-1:nyn_mg(grid_level)+1, &
266	nxl_mg(grid_level)-1:nxr_mg(grid_level)+1) :: f_mg
267
268	REAL, DIMENSION(nzb:nzt_mg(grid_level+1)+1, &
269	nys_mg(grid_level+1)-1:nyn_mg(grid_level+1)+1, &
270	nxl_mg(grid_level+1)-1:nxr_mg(grid_level+1)+1) :: r
271
272	!
273	!-- Interpolate the residual
274	l = grid_level
275
276	!
277	!-- Choose flag array of the upper level
278	SELECT CASE ( l+1 )
279	CASE ( 1 )
280	flags => wall_flags_1
281	CASE ( 2 )
282	flags => wall_flags_2
283	CASE ( 3 )
284	flags => wall_flags_3
285	CASE ( 4 )
286	flags => wall_flags_4
287	CASE ( 5 )
288	flags => wall_flags_5
289	CASE ( 6 )
290	flags => wall_flags_6
291	CASE ( 7 )
292	flags => wall_flags_7
293	CASE ( 8 )
294	flags => wall_flags_8
295	CASE ( 9 )
296	flags => wall_flags_9
297	CASE ( 10 )
298	flags => wall_flags_10
299	END SELECT
300
301	!$OMP PARALLEL PRIVATE (i,j,k,ic,jc,kc)
302	!$OMP DO
303	DO ic = nxl_mg(l), nxr_mg(l)
304	i = 2*ic
305	DO jc = nys_mg(l), nyn_mg(l)
306	j = 2*jc
307	DO kc = nzb+1, nzt_mg(l)
308	k = 2*kc-1
309	!
310	!-- Use implicit Neumann BCs if the respective gridpoint is inside
311	!-- the building
312	rkjim = r(k,j,i-1) + IBITS( flags(k,j,i-1), 6, 1 ) * &
313	( r(k,j,i) - r(k,j,i-1) )
314	rkjip = r(k,j,i+1) + IBITS( flags(k,j,i+1), 6, 1 ) * &
315	( r(k,j,i) - r(k,j,i+1) )
316	rkjpi = r(k,j+1,i) + IBITS( flags(k,j+1,i), 6, 1 ) * &
317	( r(k,j,i) - r(k,j+1,i) )
318	rkjmi = r(k,j-1,i) + IBITS( flags(k,j-1,i), 6, 1 ) * &
319	( r(k,j,i) - r(k,j-1,i) )
320	rkjmim = r(k,j-1,i-1) + IBITS( flags(k,j-1,i-1), 6, 1 ) * &
321	( r(k,j,i) - r(k,j-1,i-1) )
322	rkjpim = r(k,j+1,i-1) + IBITS( flags(k,j+1,i-1), 6, 1 ) * &
323	( r(k,j,i) - r(k,j+1,i-1) )
324	rkjmip = r(k,j-1,i+1) + IBITS( flags(k,j-1,i+1), 6, 1 ) * &
325	( r(k,j,i) - r(k,j-1,i+1) )
326	rkjpip = r(k,j+1,i+1) + IBITS( flags(k,j+1,i+1), 6, 1 ) * &
327	( r(k,j,i) - r(k,j+1,i+1) )
328	rkmji = r(k-1,j,i) + IBITS( flags(k-1,j,i), 6, 1 ) * &
329	( r(k,j,i) - r(k-1,j,i) )
330	rkmjim = r(k-1,j,i-1) + IBITS( flags(k-1,j,i-1), 6, 1 ) * &
331	( r(k,j,i) - r(k-1,j,i-1) )
332	rkmjip = r(k-1,j,i+1) + IBITS( flags(k-1,j,i+1), 6, 1 ) * &
333	( r(k,j,i) - r(k-1,j,i+1) )
334	rkmjpi = r(k-1,j+1,i) + IBITS( flags(k-1,j+1,i), 6, 1 ) * &
335	( r(k,j,i) - r(k-1,j+1,i) )
336	rkmjmi = r(k-1,j-1,i) + IBITS( flags(k-1,j-1,i), 6, 1 ) * &
337	( r(k,j,i) - r(k-1,j-1,i) )
338	rkmjmim = r(k-1,j-1,i-1) + IBITS( flags(k-1,j-1,i-1), 6, 1 ) * &
339	( r(k,j,i) - r(k-1,j-1,i-1) )
340	rkmjpim = r(k-1,j+1,i-1) + IBITS( flags(k-1,j+1,i-1), 6, 1 ) * &
341	( r(k,j,i) - r(k-1,j+1,i-1) )
342	rkmjmip = r(k-1,j-1,i+1) + IBITS( flags(k-1,j-1,i+1), 6, 1 ) * &
343	( r(k,j,i) - r(k-1,j-1,i+1) )
344	rkmjpip = r(k-1,j+1,i+1) + IBITS( flags(k-1,j+1,i+1), 6, 1 ) * &
345	( r(k,j,i) - r(k-1,j+1,i+1) )
346
347	f_mg(kc,jc,ic) = 1.0 / 64.0 * ( &
348	8.0 * r(k,j,i) &
349	+ 4.0 * ( rkjim + rkjip + &
350	rkjpi + rkjmi ) &
351	+ 2.0 * ( rkjmim + rkjpim + &
352	rkjmip + rkjpip ) &
353	+ 4.0 * rkmji &
354	+ 2.0 * ( rkmjim + rkmjim + &
355	rkmjpi + rkmjmi ) &
356	+ ( rkmjmim + rkmjpim + &
357	rkmjmip + rkmjpip ) &
358	+ 4.0 * r(k+1,j,i) &
359	+ 2.0 * ( r(k+1,j,i-1) + r(k+1,j,i+1) + &
360	r(k+1,j+1,i) + r(k+1,j-1,i) ) &
361	+ ( r(k+1,j-1,i-1) + r(k+1,j+1,i-1) + &
362	r(k+1,j-1,i+1) + r(k+1,j+1,i+1) ) &
363	)
364
365	! f_mg(kc,jc,ic) = 1.0 / 64.0 * ( &
366	! 8.0 * r(k,j,i) &
367	! + 4.0 * ( r(k,j,i-1) + r(k,j,i+1) + &
368	! r(k,j+1,i) + r(k,j-1,i) ) &
369	! + 2.0 * ( r(k,j-1,i-1) + r(k,j+1,i-1) + &
370	! r(k,j-1,i+1) + r(k,j+1,i+1) ) &
371	! + 4.0 * r(k-1,j,i) &
372	! + 2.0 * ( r(k-1,j,i-1) + r(k-1,j,i+1) + &
373	! r(k-1,j+1,i) + r(k-1,j-1,i) ) &
374	! + ( r(k-1,j-1,i-1) + r(k-1,j+1,i-1) + &
375	! r(k-1,j-1,i+1) + r(k-1,j+1,i+1) ) &
376	! + 4.0 * r(k+1,j,i) &
377	! + 2.0 * ( r(k+1,j,i-1) + r(k+1,j,i+1) + &
378	! r(k+1,j+1,i) + r(k+1,j-1,i) ) &
379	! + ( r(k+1,j-1,i-1) + r(k+1,j+1,i-1) + &
380	! r(k+1,j-1,i+1) + r(k+1,j+1,i+1) ) &
381	! )
382	ENDDO
383	ENDDO
384	ENDDO
385	!$OMP END PARALLEL
386
387	!
388	!-- Horizontal boundary conditions
389	CALL exchange_horiz( f_mg )
390
391	IF ( bc_lr /= 'cyclic' ) THEN
392	IF (inflow_l .OR. outflow_l) f_mg(:,:,nxl_mg(l)-1) = f_mg(:,:,nxl_mg(l))
393	IF (inflow_r .OR. outflow_r) f_mg(:,:,nxr_mg(l)+1) = f_mg(:,:,nxr_mg(l))
394	ENDIF
395
396	IF ( bc_ns /= 'cyclic' ) THEN
397	IF (inflow_n .OR. outflow_n) f_mg(:,nyn_mg(l)+1,:) = f_mg(:,nyn_mg(l),:)
398	IF (inflow_s .OR. outflow_s) f_mg(:,nys_mg(l)-1,:) = f_mg(:,nys_mg(l),:)
399	ENDIF
400
401	!
402	!-- Bottom and top boundary conditions
403	! IF ( ibc_p_b == 1 ) THEN
404	! f_mg(nzb,:,: ) = f_mg(nzb+1,:,:)
405	! ELSE
406	! f_mg(nzb,:,: ) = 0.0
407	! ENDIF
408	!
409	! IF ( ibc_p_t == 1 ) THEN
410	! f_mg(nzt_mg(l)+1,:,: ) = f_mg(nzt_mg(l),:,:)
411	! ELSE
412	! f_mg(nzt_mg(l)+1,:,: ) = 0.0
413	! ENDIF
414
415
416	END SUBROUTINE restrict
417
418
419
420	SUBROUTINE prolong( p, temp )
421
422	!------------------------------------------------------------------------------!
423	! Description:
424	! ------------
425	! Interpolates the correction of the perturbation pressure
426	! to the next finer grid.
427	!------------------------------------------------------------------------------!
428
429	USE control_parameters
430	USE pegrid
431	USE indices
432
433	IMPLICIT NONE
434
435	INTEGER :: i, j, k, l
436
437	REAL, DIMENSION(nzb:nzt_mg(grid_level-1)+1, &
438	nys_mg(grid_level-1)-1:nyn_mg(grid_level-1)+1, &
439	nxl_mg(grid_level-1)-1:nxr_mg(grid_level-1)+1 ) :: p
440
441	REAL, DIMENSION(nzb:nzt_mg(grid_level)+1, &
442	nys_mg(grid_level)-1:nyn_mg(grid_level)+1, &
443	nxl_mg(grid_level)-1:nxr_mg(grid_level)+1) :: temp
444
445
446	!
447	!-- First, store elements of the coarser grid on the next finer grid
448	l = grid_level
449
450	!$OMP PARALLEL PRIVATE (i,j,k)
451	!$OMP DO
452	DO i = nxl_mg(l-1), nxr_mg(l-1)
453	DO j = nys_mg(l-1), nyn_mg(l-1)
454	!CDIR NODEP
455	DO k = nzb+1, nzt_mg(l-1)
456	!
457	!-- Points of the coarse grid are directly stored on the next finer
458	!-- grid
459	temp(2k-1,2j,2*i) = p(k,j,i)
460	!
461	!-- Points between two coarse-grid points
462	temp(2k-1,2j,2i+1) = 0.5 ( p(k,j,i) + p(k,j,i+1) )
463	temp(2k-1,2j+1,2i) = 0.5 ( p(k,j,i) + p(k,j+1,i) )
464	temp(2k,2j,2i) = 0.5 ( p(k,j,i) + p(k+1,j,i) )
465	!
466	!-- Points in the center of the planes stretched by four points
467	!-- of the coarse grid cube
468	temp(2k-1,2j+1,2i+1) = 0.25 ( p(k,j,i) + p(k,j,i+1) + &
469	p(k,j+1,i) + p(k,j+1,i+1) )
470	temp(2k,2j,2i+1) = 0.25 ( p(k,j,i) + p(k,j,i+1) + &
471	p(k+1,j,i) + p(k+1,j,i+1) )
472	temp(2k,2j+1,2i) = 0.25 ( p(k,j,i) + p(k,j+1,i) + &
473	p(k+1,j,i) + p(k+1,j+1,i) )
474	!
475	!-- Points in the middle of coarse grid cube
476	temp(2k,2j+1,2i+1) = 0.125 ( p(k,j,i) + p(k,j,i+1) + &
477	p(k,j+1,i) + p(k,j+1,i+1) + &
478	p(k+1,j,i) + p(k+1,j,i+1) + &
479	p(k+1,j+1,i) + p(k+1,j+1,i+1) )
480	ENDDO
481	ENDDO
482	ENDDO
483	!$OMP END PARALLEL
484
485	!
486	!-- Horizontal boundary conditions
487	CALL exchange_horiz( temp )
488
489	IF ( bc_lr /= 'cyclic' ) THEN
490	IF (inflow_l .OR. outflow_l) temp(:,:,nxl_mg(l)-1) = temp(:,:,nxl_mg(l))
491	IF (inflow_r .OR. outflow_r) temp(:,:,nxr_mg(l)+1) = temp(:,:,nxr_mg(l))
492	ENDIF
493
494	IF ( bc_ns /= 'cyclic' ) THEN
495	IF (inflow_n .OR. outflow_n) temp(:,nyn_mg(l)+1,:) = temp(:,nyn_mg(l),:)
496	IF (inflow_s .OR. outflow_s) temp(:,nys_mg(l)-1,:) = temp(:,nys_mg(l),:)
497	ENDIF
498
499	!
500	!-- Bottom and top boundary conditions
501	IF ( ibc_p_b == 1 ) THEN
502	temp(nzb,:,: ) = temp(nzb+1,:,:)
503	ELSE
504	temp(nzb,:,: ) = 0.0
505	ENDIF
506
507	IF ( ibc_p_t == 1 ) THEN
508	temp(nzt_mg(l)+1,:,: ) = temp(nzt_mg(l),:,:)
509	ELSE
510	temp(nzt_mg(l)+1,:,: ) = 0.0
511	ENDIF
512
513
514	END SUBROUTINE prolong
515
516
517	SUBROUTINE redblack( f_mg, p_mg )
518
519	!------------------------------------------------------------------------------!
520	! Description:
521	! ------------
522	! Relaxation method for the multigrid scheme. A Gauss-Seidel iteration with
523	! 3D-Red-Black decomposition (GS-RB) is used.
524	!------------------------------------------------------------------------------!
525
526	USE arrays_3d
527	USE control_parameters
528	USE cpulog
529	USE grid_variables
530	USE indices
531	USE interfaces
532	USE pegrid
533
534	IMPLICIT NONE
535
536	INTEGER :: colour, i, ic, j, jc, jj, k, l, n
537
538	LOGICAL :: unroll
539
540	REAL :: wall_left, wall_north, wall_right, wall_south, wall_total, wall_top
541
542	REAL, DIMENSION(nzb:nzt_mg(grid_level)+1, &
543	nys_mg(grid_level)-1:nyn_mg(grid_level)+1, &
544	nxl_mg(grid_level)-1:nxr_mg(grid_level)+1) :: f_mg, p_mg
545
546
547	l = grid_level
548
549	!
550	!-- Choose flag array of this level
551	SELECT CASE ( l )
552	CASE ( 1 )
553	flags => wall_flags_1
554	CASE ( 2 )
555	flags => wall_flags_2
556	CASE ( 3 )
557	flags => wall_flags_3
558	CASE ( 4 )
559	flags => wall_flags_4
560	CASE ( 5 )
561	flags => wall_flags_5
562	CASE ( 6 )
563	flags => wall_flags_6
564	CASE ( 7 )
565	flags => wall_flags_7
566	CASE ( 8 )
567	flags => wall_flags_8
568	CASE ( 9 )
569	flags => wall_flags_9
570	CASE ( 10 )
571	flags => wall_flags_10
572	END SELECT
573
574	unroll = ( MOD( nyn_mg(l)-nys_mg(l)+1, 4 ) == 0 .AND. &
575	MOD( nxr_mg(l)-nxl_mg(l)+1, 2 ) == 0 )
576
577	DO n = 1, ngsrb
578
579	DO colour = 1, 2
580
581	IF ( .NOT. unroll ) THEN
582	CALL cpu_log( log_point_s(36), 'redblack_no_unroll', 'start' )
583
584	!
585	!-- Without unrolling of loops, no cache optimization
586	DO i = nxl_mg(l), nxr_mg(l), 2
587	DO j = nys_mg(l) + 2 - colour, nyn_mg(l), 2
588	DO k = nzb+1, nzt_mg(l), 2
589	! p_mg(k,j,i) = 1.0 / f1_mg(k,l) * ( &
590	! ddx2_mg(l) * ( p_mg(k,j,i+1) + p_mg(k,j,i-1) ) &
591	! + ddy2_mg(l) * ( p_mg(k,j+1,i) + p_mg(k,j-1,i) ) &
592	! + f2_mg(k,l) * p_mg(k+1,j,i) &
593	! + f3_mg(k,l) * p_mg(k-1,j,i) - f_mg(k,j,i) &
594	! )
595
596	p_mg(k,j,i) = 1.0 / f1_mg(k,l) * ( &
597	ddx2_mg(l) * &
598	( p_mg(k,j,i+1) + IBITS( flags(k,j,i), 5, 1 ) * &
599	( p_mg(k,j,i) - p_mg(k,j,i+1) ) + &
600	p_mg(k,j,i-1) + IBITS( flags(k,j,i), 4, 1 ) * &
601	( p_mg(k,j,i) - p_mg(k,j,i-1) ) ) &
602	+ ddy2_mg(l) * &
603	( p_mg(k,j+1,i) + IBITS( flags(k,j,i), 3, 1 ) * &
604	( p_mg(k,j,i) - p_mg(k,j+1,i) ) + &
605	p_mg(k,j-1,i) + IBITS( flags(k,j,i), 2, 1 ) * &
606	( p_mg(k,j,i) - p_mg(k,j-1,i) ) ) &
607	+ f2_mg(k,l) * p_mg(k+1,j,i) &
608	+ f3_mg(k,l) * &
609	( p_mg(k-1,j,i) + IBITS( flags(k,j,i), 0, 1 ) * &
610	( p_mg(k,j,i) - p_mg(k-1,j,i) ) ) &
611	- f_mg(k,j,i) )
612	ENDDO
613	ENDDO
614	ENDDO
615
616	DO i = nxl_mg(l)+1, nxr_mg(l), 2
617	DO j = nys_mg(l) + (colour-1), nyn_mg(l), 2
618	DO k = nzb+1, nzt_mg(l), 2
619	p_mg(k,j,i) = 1.0 / f1_mg(k,l) * ( &
620	ddx2_mg(l) * &
621	( p_mg(k,j,i+1) + IBITS( flags(k,j,i), 5, 1 ) * &
622	( p_mg(k,j,i) - p_mg(k,j,i+1) ) + &
623	p_mg(k,j,i-1) + IBITS( flags(k,j,i), 4, 1 ) * &
624	( p_mg(k,j,i) - p_mg(k,j,i-1) ) ) &
625	+ ddy2_mg(l) * &
626	( p_mg(k,j+1,i) + IBITS( flags(k,j,i), 3, 1 ) * &
627	( p_mg(k,j,i) - p_mg(k,j+1,i) ) + &
628	p_mg(k,j-1,i) + IBITS( flags(k,j,i), 2, 1 ) * &
629	( p_mg(k,j,i) - p_mg(k,j-1,i) ) ) &
630	+ f2_mg(k,l) * p_mg(k+1,j,i) &
631	+ f3_mg(k,l) * &
632	( p_mg(k-1,j,i) + IBITS( flags(k,j,i), 0, 1 ) * &
633	( p_mg(k,j,i) - p_mg(k-1,j,i) ) ) &
634	- f_mg(k,j,i) )
635	ENDDO
636	ENDDO
637	ENDDO
638
639	DO i = nxl_mg(l), nxr_mg(l), 2
640	DO j = nys_mg(l) + (colour-1), nyn_mg(l), 2
641	DO k = nzb+2, nzt_mg(l), 2
642	p_mg(k,j,i) = 1.0 / f1_mg(k,l) * ( &
643	ddx2_mg(l) * &
644	( p_mg(k,j,i+1) + IBITS( flags(k,j,i), 5, 1 ) * &
645	( p_mg(k,j,i) - p_mg(k,j,i+1) ) + &
646	p_mg(k,j,i-1) + IBITS( flags(k,j,i), 4, 1 ) * &
647	( p_mg(k,j,i) - p_mg(k,j,i-1) ) ) &
648	+ ddy2_mg(l) * &
649	( p_mg(k,j+1,i) + IBITS( flags(k,j,i), 3, 1 ) * &
650	( p_mg(k,j,i) - p_mg(k,j+1,i) ) + &
651	p_mg(k,j-1,i) + IBITS( flags(k,j,i), 2, 1 ) * &
652	( p_mg(k,j,i) - p_mg(k,j-1,i) ) ) &
653	+ f2_mg(k,l) * p_mg(k+1,j,i) &
654	+ f3_mg(k,l) * &
655	( p_mg(k-1,j,i) + IBITS( flags(k,j,i), 0, 1 ) * &
656	( p_mg(k,j,i) - p_mg(k-1,j,i) ) ) &
657	- f_mg(k,j,i) )
658	ENDDO
659	ENDDO
660	ENDDO
661
662	DO i = nxl_mg(l)+1, nxr_mg(l), 2
663	DO j = nys_mg(l) + 2 - colour, nyn_mg(l), 2
664	DO k = nzb+2, nzt_mg(l), 2
665	p_mg(k,j,i) = 1.0 / f1_mg(k,l) * ( &
666	ddx2_mg(l) * &
667	( p_mg(k,j,i+1) + IBITS( flags(k,j,i), 5, 1 ) * &
668	( p_mg(k,j,i) - p_mg(k,j,i+1) ) + &
669	p_mg(k,j,i-1) + IBITS( flags(k,j,i), 4, 1 ) * &
670	( p_mg(k,j,i) - p_mg(k,j,i-1) ) ) &
671	+ ddy2_mg(l) * &
672	( p_mg(k,j+1,i) + IBITS( flags(k,j,i), 3, 1 ) * &
673	( p_mg(k,j,i) - p_mg(k,j+1,i) ) + &
674	p_mg(k,j-1,i) + IBITS( flags(k,j,i), 2, 1 ) * &
675	( p_mg(k,j,i) - p_mg(k,j-1,i) ) ) &
676	+ f2_mg(k,l) * p_mg(k+1,j,i) &
677	+ f3_mg(k,l) * &
678	( p_mg(k-1,j,i) + IBITS( flags(k,j,i), 0, 1 ) * &
679	( p_mg(k,j,i) - p_mg(k-1,j,i) ) ) &
680	- f_mg(k,j,i) )
681	ENDDO
682	ENDDO
683	ENDDO
684	CALL cpu_log( log_point_s(36), 'redblack_no_unroll', 'stop' )
685
686	ELSE
687
688	!
689	!-- Loop unrolling along y, only one i loop for better cache use
690	CALL cpu_log( log_point_s(38), 'redblack_unroll', 'start' )
691	DO ic = nxl_mg(l), nxr_mg(l), 2
692	DO jc = nys_mg(l), nyn_mg(l), 4
693	i = ic
694	jj = jc+2-colour
695	DO k = nzb+1, nzt_mg(l), 2
696	j = jj
697	p_mg(k,j,i) = 1.0 / f1_mg(k,l) * ( &
698	ddx2_mg(l) * &
699	( p_mg(k,j,i+1) + IBITS( flags(k,j,i), 5, 1 ) * &
700	( p_mg(k,j,i) - p_mg(k,j,i+1) ) + &
701	p_mg(k,j,i-1) + IBITS( flags(k,j,i), 4, 1 ) * &
702	( p_mg(k,j,i) - p_mg(k,j,i-1) ) ) &
703	+ ddy2_mg(l) * &
704	( p_mg(k,j+1,i) + IBITS( flags(k,j,i), 3, 1 ) * &
705	( p_mg(k,j,i) - p_mg(k,j+1,i) ) + &
706	p_mg(k,j-1,i) + IBITS( flags(k,j,i), 2, 1 ) * &
707	( p_mg(k,j,i) - p_mg(k,j-1,i) ) ) &
708	+ f2_mg(k,l) * p_mg(k+1,j,i) &
709	+ f3_mg(k,l) * &
710	( p_mg(k-1,j,i) + IBITS( flags(k,j,i), 0, 1 ) * &
711	( p_mg(k,j,i) - p_mg(k-1,j,i) ) ) &
712	- f_mg(k,j,i) )
713	j = jj+2
714	p_mg(k,j,i) = 1.0 / f1_mg(k,l) * ( &
715	ddx2_mg(l) * &
716	( p_mg(k,j,i+1) + IBITS( flags(k,j,i), 5, 1 ) * &
717	( p_mg(k,j,i) - p_mg(k,j,i+1) ) + &
718	p_mg(k,j,i-1) + IBITS( flags(k,j,i), 4, 1 ) * &
719	( p_mg(k,j,i) - p_mg(k,j,i-1) ) ) &
720	+ ddy2_mg(l) * &
721	( p_mg(k,j+1,i) + IBITS( flags(k,j,i), 3, 1 ) * &
722	( p_mg(k,j,i) - p_mg(k,j+1,i) ) + &
723	p_mg(k,j-1,i) + IBITS( flags(k,j,i), 2, 1 ) * &
724	( p_mg(k,j,i) - p_mg(k,j-1,i) ) ) &
725	+ f2_mg(k,l) * p_mg(k+1,j,i) &
726	+ f3_mg(k,l) * &
727	( p_mg(k-1,j,i) + IBITS( flags(k,j,i), 0, 1 ) * &
728	( p_mg(k,j,i) - p_mg(k-1,j,i) ) ) &
729	- f_mg(k,j,i) )
730	ENDDO
731
732	i = ic+1
733	jj = jc+colour-1
734	DO k = nzb+1, nzt_mg(l), 2
735	j =jj
736	p_mg(k,j,i) = 1.0 / f1_mg(k,l) * ( &
737	ddx2_mg(l) * &
738	( p_mg(k,j,i+1) + IBITS( flags(k,j,i), 5, 1 ) * &
739	( p_mg(k,j,i) - p_mg(k,j,i+1) ) + &
740	p_mg(k,j,i-1) + IBITS( flags(k,j,i), 4, 1 ) * &
741	( p_mg(k,j,i) - p_mg(k,j,i-1) ) ) &
742	+ ddy2_mg(l) * &
743	( p_mg(k,j+1,i) + IBITS( flags(k,j,i), 3, 1 ) * &
744	( p_mg(k,j,i) - p_mg(k,j+1,i) ) + &
745	p_mg(k,j-1,i) + IBITS( flags(k,j,i), 2, 1 ) * &
746	( p_mg(k,j,i) - p_mg(k,j-1,i) ) ) &
747	+ f2_mg(k,l) * p_mg(k+1,j,i) &
748	+ f3_mg(k,l) * &
749	( p_mg(k-1,j,i) + IBITS( flags(k,j,i), 0, 1 ) * &
750	( p_mg(k,j,i) - p_mg(k-1,j,i) ) ) &
751	- f_mg(k,j,i) )
752	j = jj+2
753	p_mg(k,j,i) = 1.0 / f1_mg(k,l) * ( &
754	ddx2_mg(l) * &
755	( p_mg(k,j,i+1) + IBITS( flags(k,j,i), 5, 1 ) * &
756	( p_mg(k,j,i) - p_mg(k,j,i+1) ) + &
757	p_mg(k,j,i-1) + IBITS( flags(k,j,i), 4, 1 ) * &
758	( p_mg(k,j,i) - p_mg(k,j,i-1) ) ) &
759	+ ddy2_mg(l) * &
760	( p_mg(k,j+1,i) + IBITS( flags(k,j,i), 3, 1 ) * &
761	( p_mg(k,j,i) - p_mg(k,j+1,i) ) + &
762	p_mg(k,j-1,i) + IBITS( flags(k,j,i), 2, 1 ) * &
763	( p_mg(k,j,i) - p_mg(k,j-1,i) ) ) &
764	+ f2_mg(k,l) * p_mg(k+1,j,i) &
765	+ f3_mg(k,l) * &
766	( p_mg(k-1,j,i) + IBITS( flags(k,j,i), 0, 1 ) * &
767	( p_mg(k,j,i) - p_mg(k-1,j,i) ) ) &
768	- f_mg(k,j,i) )
769	ENDDO
770
771	i = ic
772	jj = jc+colour-1
773	DO k = nzb+2, nzt_mg(l), 2
774	j =jj
775	p_mg(k,j,i) = 1.0 / f1_mg(k,l) * ( &
776	ddx2_mg(l) * &
777	( p_mg(k,j,i+1) + IBITS( flags(k,j,i), 5, 1 ) * &
778	( p_mg(k,j,i) - p_mg(k,j,i+1) ) + &
779	p_mg(k,j,i-1) + IBITS( flags(k,j,i), 4, 1 ) * &
780	( p_mg(k,j,i) - p_mg(k,j,i-1) ) ) &
781	+ ddy2_mg(l) * &
782	( p_mg(k,j+1,i) + IBITS( flags(k,j,i), 3, 1 ) * &
783	( p_mg(k,j,i) - p_mg(k,j+1,i) ) + &
784	p_mg(k,j-1,i) + IBITS( flags(k,j,i), 2, 1 ) * &
785	( p_mg(k,j,i) - p_mg(k,j-1,i) ) ) &
786	+ f2_mg(k,l) * p_mg(k+1,j,i) &
787	+ f3_mg(k,l) * &
788	( p_mg(k-1,j,i) + IBITS( flags(k,j,i), 0, 1 ) * &
789	( p_mg(k,j,i) - p_mg(k-1,j,i) ) ) &
790	- f_mg(k,j,i) )
791	j = jj+2
792	p_mg(k,j,i) = 1.0 / f1_mg(k,l) * ( &
793	ddx2_mg(l) * &
794	( p_mg(k,j,i+1) + IBITS( flags(k,j,i), 5, 1 ) * &
795	( p_mg(k,j,i) - p_mg(k,j,i+1) ) + &
796	p_mg(k,j,i-1) + IBITS( flags(k,j,i), 4, 1 ) * &
797	( p_mg(k,j,i) - p_mg(k,j,i-1) ) ) &
798	+ ddy2_mg(l) * &
799	( p_mg(k,j+1,i) + IBITS( flags(k,j,i), 3, 1 ) * &
800	( p_mg(k,j,i) - p_mg(k,j+1,i) ) + &
801	p_mg(k,j-1,i) + IBITS( flags(k,j,i), 2, 1 ) * &
802	( p_mg(k,j,i) - p_mg(k,j-1,i) ) ) &
803	+ f2_mg(k,l) * p_mg(k+1,j,i) &
804	+ f3_mg(k,l) * &
805	( p_mg(k-1,j,i) + IBITS( flags(k,j,i), 0, 1 ) * &
806	( p_mg(k,j,i) - p_mg(k-1,j,i) ) ) &
807	- f_mg(k,j,i) )
808	ENDDO
809
810	i = ic+1
811	jj = jc+2-colour
812	DO k = nzb+2, nzt_mg(l), 2
813	j =jj
814	p_mg(k,j,i) = 1.0 / f1_mg(k,l) * ( &
815	ddx2_mg(l) * &
816	( p_mg(k,j,i+1) + IBITS( flags(k,j,i), 5, 1 ) * &
817	( p_mg(k,j,i) - p_mg(k,j,i+1) ) + &
818	p_mg(k,j,i-1) + IBITS( flags(k,j,i), 4, 1 ) * &
819	( p_mg(k,j,i) - p_mg(k,j,i-1) ) ) &
820	+ ddy2_mg(l) * &
821	( p_mg(k,j+1,i) + IBITS( flags(k,j,i), 3, 1 ) * &
822	( p_mg(k,j,i) - p_mg(k,j+1,i) ) + &
823	p_mg(k,j-1,i) + IBITS( flags(k,j,i), 2, 1 ) * &
824	( p_mg(k,j,i) - p_mg(k,j-1,i) ) ) &
825	+ f2_mg(k,l) * p_mg(k+1,j,i) &
826	+ f3_mg(k,l) * &
827	( p_mg(k-1,j,i) + IBITS( flags(k,j,i), 0, 1 ) * &
828	( p_mg(k,j,i) - p_mg(k-1,j,i) ) ) &
829	- f_mg(k,j,i) )
830	j = jj+2
831	p_mg(k,j,i) = 1.0 / f1_mg(k,l) * ( &
832	ddx2_mg(l) * &
833	( p_mg(k,j,i+1) + IBITS( flags(k,j,i), 5, 1 ) * &
834	( p_mg(k,j,i) - p_mg(k,j,i+1) ) + &
835	p_mg(k,j,i-1) + IBITS( flags(k,j,i), 4, 1 ) * &
836	( p_mg(k,j,i) - p_mg(k,j,i-1) ) ) &
837	+ ddy2_mg(l) * &
838	( p_mg(k,j+1,i) + IBITS( flags(k,j,i), 3, 1 ) * &
839	( p_mg(k,j,i) - p_mg(k,j+1,i) ) + &
840	p_mg(k,j-1,i) + IBITS( flags(k,j,i), 2, 1 ) * &
841	( p_mg(k,j,i) - p_mg(k,j-1,i) ) ) &
842	+ f2_mg(k,l) * p_mg(k+1,j,i) &
843	+ f3_mg(k,l) * &
844	( p_mg(k-1,j,i) + IBITS( flags(k,j,i), 0, 1 ) * &
845	( p_mg(k,j,i) - p_mg(k-1,j,i) ) ) &
846	- f_mg(k,j,i) )
847	ENDDO
848
849	ENDDO
850	ENDDO
851	CALL cpu_log( log_point_s(38), 'redblack_unroll', 'stop' )
852
853	ENDIF
854
855	!
856	!-- Horizontal boundary conditions
857	CALL exchange_horiz( p_mg )
858
859	IF ( bc_lr /= 'cyclic' ) THEN
860	IF ( inflow_l .OR. outflow_l ) THEN
861	p_mg(:,:,nxl_mg(l)-1) = p_mg(:,:,nxl_mg(l))
862	ENDIF
863	IF ( inflow_r .OR. outflow_r ) THEN
864	p_mg(:,:,nxr_mg(l)+1) = p_mg(:,:,nxr_mg(l))
865	ENDIF
866	ENDIF
867
868	IF ( bc_ns /= 'cyclic' ) THEN
869	IF ( inflow_n .OR. outflow_n ) THEN
870	p_mg(:,nyn_mg(l)+1,:) = p_mg(:,nyn_mg(l),:)
871	ENDIF
872	IF ( inflow_s .OR. outflow_s ) THEN
873	p_mg(:,nys_mg(l)-1,:) = p_mg(:,nys_mg(l),:)
874	ENDIF
875	ENDIF
876
877	!
878	!-- Bottom and top boundary conditions
879	IF ( ibc_p_b == 1 ) THEN
880	p_mg(nzb,:,: ) = p_mg(nzb+1,:,:)
881	ELSE
882	p_mg(nzb,:,: ) = 0.0
883	ENDIF
884
885	IF ( ibc_p_t == 1 ) THEN
886	p_mg(nzt_mg(l)+1,:,: ) = p_mg(nzt_mg(l),:,:)
887	ELSE
888	p_mg(nzt_mg(l)+1,:,: ) = 0.0
889	ENDIF
890
891	ENDDO
892
893	ENDDO
894
895	!
896	!-- Set pressure within topography and at the topography surfaces
897	!$OMP PARALLEL PRIVATE (i,j,k,wall_left,wall_north,wall_right,wall_south,wall_top,wall_total)
898	!$OMP DO
899	DO i = nxl_mg(l), nxr_mg(l)
900	DO j = nys_mg(l), nyn_mg(l)
901	DO k = nzb, nzt_mg(l)
902	!
903	!-- First, set pressure inside topography to zero
904	p_mg(k,j,i) = p_mg(k,j,i) * ( 1.0 - IBITS( flags(k,j,i), 6, 1 ) )
905	!
906	!-- Second, determine if the gridpoint inside topography is adjacent
907	!-- to a wall and set its value to a value given by the average of
908	!-- those values obtained from Neumann boundary condition
909	wall_left = IBITS( flags(k,j,i-1), 5, 1 )
910	wall_right = IBITS( flags(k,j,i+1), 4, 1 )
911	wall_south = IBITS( flags(k,j-1,i), 3, 1 )
912	wall_north = IBITS( flags(k,j+1,i), 2, 1 )
913	wall_top = IBITS( flags(k+1,j,i), 0, 1 )
914	wall_total = wall_left + wall_right + wall_south + wall_north + &
915	wall_top
916
917	IF ( wall_total > 0.0 ) THEN
918	p_mg(k,j,i) = 1.0 / wall_total * &
919	( wall_left * p_mg(k,j,i-1) + &
920	wall_right * p_mg(k,j,i+1) + &
921	wall_south * p_mg(k,j-1,i) + &
922	wall_north * p_mg(k,j+1,i) + &
923	wall_top * p_mg(k+1,j,i) )
924	ENDIF
925	ENDDO
926	ENDDO
927	ENDDO
928	!$OMP END PARALLEL
929
930	!
931	!-- One more time horizontal boundary conditions
932	CALL exchange_horiz( p_mg )
933
934	END SUBROUTINE redblack
935
936
937
938	SUBROUTINE mg_gather( f2, f2_sub )
939
940	USE control_parameters
941	USE cpulog
942	USE indices
943	USE interfaces
944	USE pegrid
945
946	IMPLICIT NONE
947
948	INTEGER :: n, nwords, sender
949
950	REAL, DIMENSION(nzb:nzt_mg(grid_level)+1, &
951	nys_mg(grid_level)-1:nyn_mg(grid_level)+1, &
952	nxl_mg(grid_level)-1:nxr_mg(grid_level)+1) :: f2
953
954	REAL, DIMENSION(nzb:mg_loc_ind(5,myid)+1, &
955	mg_loc_ind(3,myid)-1:mg_loc_ind(4,myid)+1, &
956	mg_loc_ind(1,myid)-1:mg_loc_ind(2,myid)+1) :: f2_sub
957
958	!
959	!-- Find out the number of array elements of the subdomain array
960	nwords = SIZE( f2_sub )
961
962	#if defined( __parallel )
963	CALL cpu_log( log_point_s(34), 'mg_gather', 'start' )
964
965	IF ( myid == 0 ) THEN
966	!
967	!-- Store the local subdomain array on the total array
968	f2(:,mg_loc_ind(3,0)-1:mg_loc_ind(4,0)+1, &
969	mg_loc_ind(1,0)-1:mg_loc_ind(2,0)+1) = f2_sub
970
971	!
972	!-- Receive the subdomain arrays from all other PEs and store them on the
973	!-- total array
974	DO n = 1, numprocs-1
975	!
976	!-- Receive the arrays in arbitrary order from the PEs.
977	CALL MPI_RECV( f2_sub(nzb,mg_loc_ind(3,0)-1,mg_loc_ind(1,0)-1), &
978	nwords, MPI_REAL, MPI_ANY_SOURCE, 1, comm2d, status, &
979	ierr )
980	sender = status(MPI_SOURCE)
981	f2(:,mg_loc_ind(3,sender)-1:mg_loc_ind(4,sender)+1, &
982	mg_loc_ind(1,sender)-1:mg_loc_ind(2,sender)+1) = f2_sub
983	ENDDO
984
985	ELSE
986	!
987	!-- Send subdomain array to PE0
988	CALL MPI_SEND( f2_sub(nzb,mg_loc_ind(3,myid)-1,mg_loc_ind(1,myid)-1), &
989	nwords, MPI_REAL, 0, 1, comm2d, ierr )
990	ENDIF
991
992	CALL cpu_log( log_point_s(34), 'mg_gather', 'stop' )
993	#endif
994
995	END SUBROUTINE mg_gather
996
997
998
999	SUBROUTINE mg_scatter( p2, p2_sub )
1000	!
1001	!-- TODO: It may be possible to improve the speed of this routine by using
1002	!-- non-blocking communication
1003
1004	USE control_parameters
1005	USE cpulog
1006	USE indices
1007	USE interfaces
1008	USE pegrid
1009
1010	IMPLICIT NONE
1011
1012	INTEGER :: n, nwords, sender
1013
1014	REAL, DIMENSION(nzb:nzt_mg(grid_level-1)+1, &
1015	nys_mg(grid_level-1)-1:nyn_mg(grid_level-1)+1, &
1016	nxl_mg(grid_level-1)-1:nxr_mg(grid_level-1)+1) :: p2
1017
1018	REAL, DIMENSION(nzb:mg_loc_ind(5,myid)+1, &
1019	mg_loc_ind(3,myid)-1:mg_loc_ind(4,myid)+1, &
1020	mg_loc_ind(1,myid)-1:mg_loc_ind(2,myid)+1) :: p2_sub
1021
1022	!
1023	!-- Find out the number of array elements of the subdomain array
1024	nwords = SIZE( p2_sub )
1025
1026	#if defined( __parallel )
1027	CALL cpu_log( log_point_s(35), 'mg_scatter', 'start' )
1028
1029	IF ( myid == 0 ) THEN
1030	!
1031	!-- Scatter the subdomain arrays to the other PEs by blocking
1032	!-- communication
1033	DO n = 1, numprocs-1
1034
1035	p2_sub = p2(:,mg_loc_ind(3,n)-1:mg_loc_ind(4,n)+1, &
1036	mg_loc_ind(1,n)-1:mg_loc_ind(2,n)+1)
1037
1038	CALL MPI_SEND( p2_sub(nzb,mg_loc_ind(3,0)-1,mg_loc_ind(1,0)-1), &
1039	nwords, MPI_REAL, n, 1, comm2d, ierr )
1040
1041	ENDDO
1042
1043	!
1044	!-- Store data from the total array to the local subdomain array
1045	p2_sub = p2(:,mg_loc_ind(3,0)-1:mg_loc_ind(4,0)+1, &
1046	mg_loc_ind(1,0)-1:mg_loc_ind(2,0)+1)
1047
1048	ELSE
1049	!
1050	!-- Receive subdomain array from PE0
1051	CALL MPI_RECV( p2_sub(nzb,mg_loc_ind(3,myid)-1,mg_loc_ind(1,myid)-1), &
1052	nwords, MPI_REAL, 0, 1, comm2d, status, ierr )
1053
1054	ENDIF
1055
1056	CALL cpu_log( log_point_s(35), 'mg_scatter', 'stop' )
1057	#endif
1058
1059	END SUBROUTINE mg_scatter
1060
1061
1062
1063	RECURSIVE SUBROUTINE next_mg_level( f_mg, p_mg, p3, r )
1064
1065	!------------------------------------------------------------------------------!
1066	! Description:
1067	! ------------
1068	! This is where the multigrid technique takes place. V- and W- Cycle are
1069	! implemented and steered by the parameter "gamma". Parameter "nue" determines
1070	! the convergence of the multigrid iterative solution. There are nue times
1071	! RB-GS iterations. It should be set to "1" or "2", considering the time effort
1072	! one would like to invest. Last choice shows a very good converging factor,
1073	! but leads to an increase in computing time.
1074	!------------------------------------------------------------------------------!
1075
1076	USE arrays_3d
1077	USE control_parameters
1078	USE grid_variables
1079	USE indices
1080	USE pegrid
1081
1082	IMPLICIT NONE
1083
1084	INTEGER :: i, j, k, nxl_mg_save, nxr_mg_save, nyn_mg_save, nys_mg_save, &
1085	nzt_mg_save
1086
1087	LOGICAL :: restore_boundary_lr_on_pe0, restore_boundary_ns_on_pe0
1088
1089	REAL, DIMENSION(nzb:nzt_mg(grid_level)+1, &
1090	nys_mg(grid_level)-1:nyn_mg(grid_level)+1, &
1091	nxl_mg(grid_level)-1:nxr_mg(grid_level)+1) :: f_mg, p_mg, p3, r
1092
1093	REAL, DIMENSION(:,:,:), ALLOCATABLE :: f2, f2_sub, p2, p2_sub
1094
1095	!
1096	!-- Restriction to the coarsest grid
1097	10 IF ( grid_level == 1 ) THEN
1098
1099	!
1100	!-- Solution on the coarsest grid. Double the number of Gauss-Seidel
1101	!-- iterations in order to get a more accurate solution.
1102	ngsrb = 2 * ngsrb
1103	CALL redblack( f_mg, p_mg )
1104	ngsrb = ngsrb / 2
1105
1106	ELSEIF ( grid_level /= 1 ) THEN
1107
1108	grid_level_count(grid_level) = grid_level_count(grid_level) + 1
1109
1110	!
1111	!-- Solution on the actual grid level
1112	CALL redblack( f_mg, p_mg )
1113
1114	!
1115	!-- Determination of the actual residual
1116	CALL resid( f_mg, p_mg, r )
1117
1118	!
1119	!-- Restriction of the residual (finer grid values!) to the next coarser
1120	!-- grid. Therefore, the grid level has to be decremented now. nxl..nzt have
1121	!-- to be set to the coarse grid values, because these variables are needed
1122	!-- for the exchange of ghost points in routine exchange_horiz
1123	grid_level = grid_level - 1
1124	nxl = nxl_mg(grid_level)
1125	nxr = nxr_mg(grid_level)
1126	nys = nys_mg(grid_level)
1127	nyn = nyn_mg(grid_level)
1128	nzt = nzt_mg(grid_level)
1129
1130	ALLOCATE( f2(nzb:nzt_mg(grid_level)+1, &
1131	nys_mg(grid_level)-1:nyn_mg(grid_level)+1, &
1132	nxl_mg(grid_level)-1:nxr_mg(grid_level)+1), &
1133	p2(nzb:nzt_mg(grid_level)+1, &
1134	nys_mg(grid_level)-1:nyn_mg(grid_level)+1, &
1135	nxl_mg(grid_level)-1:nxr_mg(grid_level)+1) )
1136
1137	IF ( grid_level == mg_switch_to_pe0_level ) THEN
1138	! print*, 'myid=',myid, ' restrict and switch to PE0. level=', grid_level
1139	!
1140	!-- From this level on, calculations are done on PE0 only.
1141	!-- First, carry out restriction on the subdomain.
1142	!-- Therefore, indices of the level have to be changed to subdomain values
1143	!-- in between (otherwise, the restrict routine would expect
1144	!-- the gathered array)
1145	nxl_mg_save = nxl_mg(grid_level)
1146	nxr_mg_save = nxr_mg(grid_level)
1147	nys_mg_save = nys_mg(grid_level)
1148	nyn_mg_save = nyn_mg(grid_level)
1149	nzt_mg_save = nzt_mg(grid_level)
1150	nxl_mg(grid_level) = mg_loc_ind(1,myid)
1151	nxr_mg(grid_level) = mg_loc_ind(2,myid)
1152	nys_mg(grid_level) = mg_loc_ind(3,myid)
1153	nyn_mg(grid_level) = mg_loc_ind(4,myid)
1154	nzt_mg(grid_level) = mg_loc_ind(5,myid)
1155	nxl = mg_loc_ind(1,myid)
1156	nxr = mg_loc_ind(2,myid)
1157	nys = mg_loc_ind(3,myid)
1158	nyn = mg_loc_ind(4,myid)
1159	nzt = mg_loc_ind(5,myid)
1160
1161	ALLOCATE( f2_sub(nzb:nzt_mg(grid_level)+1, &
1162	nys_mg(grid_level)-1:nyn_mg(grid_level)+1, &
1163	nxl_mg(grid_level)-1:nxr_mg(grid_level)+1) )
1164
1165	CALL restrict( f2_sub, r )
1166
1167	!
1168	!-- Restore the correct indices of this level
1169	nxl_mg(grid_level) = nxl_mg_save
1170	nxr_mg(grid_level) = nxr_mg_save
1171	nys_mg(grid_level) = nys_mg_save
1172	nyn_mg(grid_level) = nyn_mg_save
1173	nzt_mg(grid_level) = nzt_mg_save
1174	nxl = nxl_mg(grid_level)
1175	nxr = nxr_mg(grid_level)
1176	nys = nys_mg(grid_level)
1177	nyn = nyn_mg(grid_level)
1178	nzt = nzt_mg(grid_level)
1179
1180	!
1181	!-- Gather all arrays from the subdomains on PE0
1182	CALL mg_gather( f2, f2_sub )
1183
1184	!
1185	!-- Set switch for routine exchange_horiz, that no ghostpoint exchange
1186	!-- has to be carried out from now on
1187	mg_switch_to_pe0 = .TRUE.
1188
1189	!
1190	!-- In case of non-cyclic lateral boundary conditions, both in- and
1191	!-- outflow conditions have to be used on PE0 after the switch, because
1192	!-- it then contains the total domain. Due to the virtual processor
1193	!-- grid, before the switch, PE0 can have in-/outflow at the left
1194	!-- and south wall only (or on opposite walls in case of a 1d
1195	!-- decomposition).
1196	restore_boundary_lr_on_pe0 = .FALSE.
1197	restore_boundary_ns_on_pe0 = .FALSE.
1198	IF ( myid == 0 ) THEN
1199	IF ( inflow_l .AND. .NOT. outflow_r ) THEN
1200	outflow_r = .TRUE.
1201	restore_boundary_lr_on_pe0 = .TRUE.
1202	ENDIF
1203	IF ( outflow_l .AND. .NOT. inflow_r ) THEN
1204	inflow_r = .TRUE.
1205	restore_boundary_lr_on_pe0 = .TRUE.
1206	ENDIF
1207	IF ( inflow_s .AND. .NOT. outflow_n ) THEN
1208	outflow_n = .TRUE.
1209	restore_boundary_ns_on_pe0 = .TRUE.
1210	ENDIF
1211	IF ( outflow_s .AND. .NOT. inflow_n ) THEN
1212	inflow_n = .TRUE.
1213	restore_boundary_ns_on_pe0 = .TRUE.
1214	ENDIF
1215	ENDIF
1216
1217	DEALLOCATE( f2_sub )
1218
1219	ELSE
1220
1221	CALL restrict( f2, r )
1222
1223	ENDIF
1224	p2 = 0.0
1225
1226	!
1227	!-- Repeat the same procedure till the coarsest grid is reached
1228	IF ( myid == 0 .OR. grid_level > mg_switch_to_pe0_level ) THEN
1229	CALL next_mg_level( f2, p2, p3, r )
1230	ENDIF
1231
1232	ENDIF
1233
1234	!
1235	!-- Now follows the prolongation
1236	IF ( grid_level >= 2 ) THEN
1237
1238	!
1239	!-- Grid level has to be incremented on the PEs where next_mg_level
1240	!-- has not been called before (normally it is incremented at the end
1241	!-- of next_mg_level)
1242	IF ( myid /= 0 .AND. grid_level == mg_switch_to_pe0_level ) THEN
1243	grid_level = grid_level + 1
1244	nxl = nxl_mg(grid_level)
1245	nxr = nxr_mg(grid_level)
1246	nys = nys_mg(grid_level)
1247	nyn = nyn_mg(grid_level)
1248	nzt = nzt_mg(grid_level)
1249	ENDIF
1250
1251	!
1252	!-- Prolongation of the new residual. The values are transferred
1253	!-- from the coarse to the next finer grid.
1254	IF ( grid_level == mg_switch_to_pe0_level+1 ) THEN
1255	!
1256	!-- At this level, the new residual first has to be scattered from
1257	!-- PE0 to the other PEs
1258	ALLOCATE( p2_sub(nzb:mg_loc_ind(5,myid)+1, &
1259	mg_loc_ind(3,myid)-1:mg_loc_ind(4,myid)+1, &
1260	mg_loc_ind(1,myid)-1:mg_loc_ind(2,myid)+1) )
1261
1262	CALL mg_scatter( p2, p2_sub )
1263
1264	!
1265	!-- Therefore, indices of the previous level have to be changed to
1266	!-- subdomain values in between (otherwise, the prolong routine would
1267	!-- expect the gathered array)
1268	nxl_mg_save = nxl_mg(grid_level-1)
1269	nxr_mg_save = nxr_mg(grid_level-1)
1270	nys_mg_save = nys_mg(grid_level-1)
1271	nyn_mg_save = nyn_mg(grid_level-1)
1272	nzt_mg_save = nzt_mg(grid_level-1)
1273	nxl_mg(grid_level-1) = mg_loc_ind(1,myid)
1274	nxr_mg(grid_level-1) = mg_loc_ind(2,myid)
1275	nys_mg(grid_level-1) = mg_loc_ind(3,myid)
1276	nyn_mg(grid_level-1) = mg_loc_ind(4,myid)
1277	nzt_mg(grid_level-1) = mg_loc_ind(5,myid)
1278
1279	!
1280	!-- Set switch for routine exchange_horiz, that ghostpoint exchange
1281	!-- has to be carried again out from now on
1282	mg_switch_to_pe0 = .FALSE.
1283
1284	!
1285	!-- In case of non-cyclic lateral boundary conditions, restore the
1286	!-- in-/outflow conditions on PE0
1287	IF ( myid == 0 ) THEN
1288	IF ( restore_boundary_lr_on_pe0 ) THEN
1289	IF ( inflow_l ) outflow_r = .FALSE.
1290	IF ( outflow_l ) inflow_r = .FALSE.
1291	ENDIF
1292	IF ( restore_boundary_ns_on_pe0 ) THEN
1293	IF ( inflow_s ) outflow_n = .FALSE.
1294	IF ( outflow_s ) inflow_n = .FALSE.
1295	ENDIF
1296	ENDIF
1297
1298	CALL prolong( p2_sub, p3 )
1299
1300	!
1301	!-- Restore the correct indices of the previous level
1302	nxl_mg(grid_level-1) = nxl_mg_save
1303	nxr_mg(grid_level-1) = nxr_mg_save
1304	nys_mg(grid_level-1) = nys_mg_save
1305	nyn_mg(grid_level-1) = nyn_mg_save
1306	nzt_mg(grid_level-1) = nzt_mg_save
1307
1308	DEALLOCATE( p2_sub )
1309
1310	ELSE
1311
1312	CALL prolong( p2, p3 )
1313
1314	ENDIF
1315
1316	!
1317	!-- Temporary arrays for the actual grid are not needed any more
1318	DEALLOCATE( p2, f2 )
1319
1320	!
1321	!-- Computation of the new pressure correction. Therefore,
1322	!-- values from prior grids are added up automatically stage by stage.
1323	DO i = nxl_mg(grid_level)-1, nxr_mg(grid_level)+1
1324	DO j = nys_mg(grid_level)-1, nyn_mg(grid_level)+1
1325	DO k = nzb, nzt_mg(grid_level)+1
1326	p_mg(k,j,i) = p_mg(k,j,i) + p3(k,j,i)
1327	ENDDO
1328	ENDDO
1329	ENDDO
1330
1331	!
1332	!-- Relaxation of the new solution
1333	CALL redblack( f_mg, p_mg )
1334
1335	ENDIF
1336
1337	!
1338	!-- The following few lines serve the steering of the multigrid scheme
1339	IF ( grid_level == maximum_grid_level ) THEN
1340
1341	GOTO 20
1342
1343	ELSEIF ( grid_level /= maximum_grid_level .AND. grid_level /= 1 .AND. &
1344	grid_level_count(grid_level) /= gamma_mg ) THEN
1345
1346	GOTO 10
1347
1348	ENDIF
1349
1350	!
1351	!-- Reset counter for the next call of poismg
1352	grid_level_count(grid_level) = 0
1353
1354	!
1355	!-- Continue with the next finer level. nxl..nzt have to be
1356	!-- set to the finer grid values, because these variables are needed for the
1357	!-- exchange of ghost points in routine exchange_horiz
1358	grid_level = grid_level + 1
1359	nxl = nxl_mg(grid_level)
1360	nxr = nxr_mg(grid_level)
1361	nys = nys_mg(grid_level)
1362	nyn = nyn_mg(grid_level)
1363	nzt = nzt_mg(grid_level)
1364
1365	20 CONTINUE
1366
1367	END SUBROUTINE next_mg_level

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

Download in other formats:

| Impressum | ©Leibniz Universität Hannover |