Home

Context Navigation

source: palm/trunk/SOURCE/netcdf.f90 @ 803

Last change on this file since 803 was 772, checked in by heinze, 13 years ago
last commit documented
Property svn:keywords set to `Id`
File size: 178.2 KB

Line
1	#if defined( __ibmy_special )
2	@PROCESS NOOPTimize
3	#endif
4	SUBROUTINE define_netcdf_header( callmode, extend, av )
5
6	!------------------------------------------------------------------------------!
7	! Current revisions:
8	! ------------------
9	!
10	! Former revisions:
11	! -----------------
12	! $Id: netcdf.f90 772 2011-10-27 11:08:46Z franke $
13	!
14	! 771 2011-10-27 10:56:21Z heinze
15	! +lpt
16	!
17	! 600 2010-11-24 16:10:51Z raasch
18	! bugfix concerning check of cross-section levels on netcdf-files to be
19	! extended (xz,yz)
20	!
21	! 564 2010-09-30 13:18:59Z helmke
22	! nc_precision changed from 40 masks to 1 mask, start number of mask output
23	! files changed to 201, netcdf message identifiers of masked output changed
24	!
25	! 519 2010-03-19 05:30:02Z raasch
26	! particle number defined as unlimited dimension in case of NetCDF4 output,
27	! special characters like * and " are now allowed for NetCDF variable names,
28	! replacement of these characters removed, routine clean_netcdf_varname
29	! removed
30	!
31	! 493 2010-03-01 08:30:24Z raasch
32	! Extensions for NetCDF4 output
33	!
34	! 410 2009-12-04 17:05:40Z letzel
35	! masked data output
36	!
37	! 359 2009-08-19 16:56:44Z letzel
38	! for extended NetCDF files, the updated title attribute includes an update of
39	! time_average_text where appropriate.
40	! Bugfix for extended NetCDF files: In order to avoid 'data mode' errors if
41	! updated attributes are larger than their original size, NF90_PUT_ATT is called
42	! in 'define mode' enclosed by NF90_REDEF and NF90_ENDDEF calls. This implies a
43	! possible performance loss; an alternative strategy would be to ensure equal
44	! attribute size in a job chain.
45	! NetCDF unit attribute in timeseries output in case of statistic
46	! regions added.
47	! Output of NetCDF messages with aid of message handling routine.
48	! Output of messages replaced by message handling routine.
49	! Typographical errors fixed.
50	!
51	! 216 2008-11-25 07:12:43Z raasch
52	! Origin of the xy-coordinate system shifted from the center of the first
53	! grid cell (indices i=0, j=0) to the south-left corner of this cell.
54	!
55	! 189 2008-08-13 17:09:26Z letzel
56	! consistently allow 100 spectra levels instead of 10
57	! bug fix in the determination of the number of output heights for spectra,
58	! +user-defined spectra
59	!
60	! 97 2007-06-21 08:23:15Z raasch
61	! Grids defined for rho and sa
62	!
63	! 48 2007-03-06 12:28:36Z raasch
64	! Output topography height information (zu_s_inner, zw_s_inner) to 2d-xy and 3d
65	! datasets
66	!
67	! RCS Log replace by Id keyword, revision history cleaned up
68	!
69	! Revision 1.12 2006/09/26 19:35:16 raasch
70	! Bugfix yv coordinates for yz cross sections
71	!
72	! Revision 1.1 2005/05/18 15:37:16 raasch
73	! Initial revision
74	!
75	!
76	! Description:
77	! ------------
78	! In case of extend = .FALSE.:
79	! Define all necessary dimensions, axes and variables for the different
80	! NetCDF datasets. This subroutine is called from check_open after a new
81	! dataset is created. It leaves the open NetCDF files ready to write.
82	!
83	! In case of extend = .TRUE.:
84	! Find out if dimensions and variables of an existing file match the values
85	! of the actual run. If so, get all necessary informations (ids, etc.) from
86	! this file.
87	!
88	! Parameter av can assume values 0 (non-averaged data) and 1 (time averaged
89	! data)
90	!------------------------------------------------------------------------------!
91	#if defined( __netcdf )
92
93	USE arrays_3d
94	USE constants
95	USE control_parameters
96	USE grid_variables
97	USE indices
98	USE netcdf_control
99	USE pegrid
100	USE particle_attributes
101	USE profil_parameter
102	USE spectrum
103	USE statistics
104
105
106	IMPLICIT NONE
107
108	CHARACTER (LEN=2) :: suffix
109	CHARACTER (LEN=2), INTENT (IN) :: callmode
110	CHARACTER (LEN=3) :: suffix1
111	CHARACTER (LEN=4) :: grid_x, grid_y, grid_z
112	CHARACTER (LEN=6) :: mode
113	CHARACTER (LEN=10) :: netcdf_var_name, precision, var
114	CHARACTER (LEN=80) :: time_average_text
115	CHARACTER (LEN=2000) :: var_list, var_list_old
116
117	INTEGER :: av, file_id, i, id_x, id_y, id_z, j, ns, ns_old, nz_old
118
119	INTEGER, DIMENSION(1) :: id_dim_time_old, id_dim_x_yz_old, &
120	id_dim_y_xz_old, id_dim_zu_sp_old, &
121	id_dim_zu_xy_old, id_dim_zu_3d_old, &
122	id_dim_zu_mask_old
123
124	LOGICAL :: found
125
126	LOGICAL, INTENT (INOUT) :: extend
127
128	LOGICAL, SAVE :: init_netcdf = .FALSE.
129
130	REAL, DIMENSION(1) :: last_time_coordinate
131
132	REAL, DIMENSION(:), ALLOCATABLE :: netcdf_data
133	REAL, DIMENSION(:,:), ALLOCATABLE :: netcdf_data_2d
134
135
136
137	!
138	!-- Initializing actions (return to calling routine check_parameters afterwards)
139	IF ( .NOT. init_netcdf ) THEN
140	!
141	!-- Check and set accuracy for NetCDF output. First set default value
142	nc_precision = NF90_REAL4
143
144	i = 1
145	DO WHILE ( netcdf_precision(i) /= ' ' )
146	j = INDEX( netcdf_precision(i), '_' )
147	IF ( j == 0 ) THEN
148	WRITE ( message_string, * ) 'netcdf_precision must contain a ', &
149	'"_"netcdf_precision(', i, ')="', &
150	TRIM( netcdf_precision(i) ),'"'
151	CALL message( 'define_netcdf_header', 'PA0241', 1, 2, 0, 6, 0 )
152	ENDIF
153
154	var = netcdf_precision(i)(1:j-1)
155	precision = netcdf_precision(i)(j+1:)
156
157	IF ( precision == 'NF90_REAL4' ) THEN
158	j = NF90_REAL4
159	ELSEIF ( precision == 'NF90_REAL8' ) THEN
160	j = NF90_REAL8
161	ELSE
162	WRITE ( message_string, * ) 'illegal netcdf precision: ', &
163	'netcdf_precision(', i, ')="', &
164	TRIM( netcdf_precision(i) ),'"'
165	CALL message( 'define_netcdf_header', 'PA0242', 1, 2, 0, 6, 0 )
166	ENDIF
167
168	SELECT CASE ( var )
169	CASE ( 'xy' )
170	nc_precision(1) = j
171	CASE ( 'xz' )
172	nc_precision(2) = j
173	CASE ( 'yz' )
174	nc_precision(3) = j
175	CASE ( '2d' )
176	nc_precision(1:3) = j
177	CASE ( '3d' )
178	nc_precision(4) = j
179	CASE ( 'pr' )
180	nc_precision(5) = j
181	CASE ( 'ts' )
182	nc_precision(6) = j
183	CASE ( 'sp' )
184	nc_precision(7) = j
185	CASE ( 'prt' )
186	nc_precision(8) = j
187	CASE ( 'masks' )
188	nc_precision(11) = j
189	CASE ( 'all' )
190	nc_precision = j
191
192	CASE DEFAULT
193	WRITE ( message_string, * ) 'unknown variable in inipar ', &
194	'assignment: netcdf_precision(', i, ')="', &
195	TRIM( netcdf_precision(i) ),'"'
196	CALL message( 'define_netcdf_header', 'PA0243', 1, 2, 0, 6, 0 )
197
198	END SELECT
199
200	i = i + 1
201	IF ( i > 50 ) EXIT
202	ENDDO
203
204	init_netcdf = .TRUE.
205
206	RETURN
207
208	ENDIF
209
210	!
211	!-- Determine the mode to be processed
212	IF ( extend ) THEN
213	mode = callmode // '_ext'
214	ELSE
215	mode = callmode // '_new'
216	ENDIF
217
218	!
219	!-- Select the mode to be processed. Possibilities are 3d, mask, xy, xz, yz,
220	!-- pr and ts.
221	SELECT CASE ( mode )
222
223	CASE ( 'ma_new' )
224
225	!
226	!-- decompose actual parameter file_id (=formal parameter av) into
227	!-- mid and av
228	file_id = av
229	IF ( file_id <= 200+max_masks ) THEN
230	mid = file_id - 200
231	av = 0
232	ELSE
233	mid = file_id - (200+max_masks)
234	av = 1
235	ENDIF
236
237	!
238	!-- Define some global attributes of the dataset
239	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), NF90_GLOBAL, &
240	'Conventions', 'COARDS' )
241	CALL handle_netcdf_error( 'netcdf', 464 )
242
243	IF ( av == 0 ) THEN
244	time_average_text = ' '
245	ELSE
246	WRITE (time_average_text, '('', '',F7.1,'' s average'')') &
247	averaging_interval
248	ENDIF
249	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), NF90_GLOBAL, 'title', &
250	TRIM( run_description_header ) // &
251	TRIM( time_average_text ) )
252	CALL handle_netcdf_error( 'netcdf', 465 )
253	IF ( av == 1 ) THEN
254	WRITE ( time_average_text,'(F7.1,'' s avg'')' ) averaging_interval
255	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), NF90_GLOBAL, &
256	'time_avg', TRIM( time_average_text ) )
257	CALL handle_netcdf_error( 'netcdf', 466 )
258	ENDIF
259
260	!
261	!-- Define time coordinate for volume data (unlimited dimension)
262	nc_stat = NF90_DEF_DIM( id_set_mask(mid,av), 'time', NF90_UNLIMITED, &
263	id_dim_time_mask(mid,av) )
264	CALL handle_netcdf_error( 'netcdf', 467 )
265
266	nc_stat = NF90_DEF_VAR( id_set_mask(mid,av), 'time', NF90_DOUBLE, &
267	id_dim_time_mask(mid,av), &
268	id_var_time_mask(mid,av) )
269	CALL handle_netcdf_error( 'netcdf', 468 )
270
271	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), &
272	id_var_time_mask(mid,av), 'units', &
273	'seconds')
274	CALL handle_netcdf_error( 'netcdf', 469 )
275
276	!
277	!-- Define spatial dimensions and coordinates:
278	!-- Define vertical coordinate grid (zu grid)
279	nc_stat = NF90_DEF_DIM( id_set_mask(mid,av), 'zu_3d', &
280	mask_size(mid,3), id_dim_zu_mask(mid,av) )
281	CALL handle_netcdf_error( 'netcdf', 470 )
282
283	nc_stat = NF90_DEF_VAR( id_set_mask(mid,av), 'zu_3d', NF90_DOUBLE, &
284	id_dim_zu_mask(mid,av), &
285	id_var_zu_mask(mid,av) )
286	CALL handle_netcdf_error( 'netcdf', 471 )
287
288	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), id_var_zu_mask(mid,av), &
289	'units', 'meters' )
290	CALL handle_netcdf_error( 'netcdf', 472 )
291
292	!
293	!-- Define vertical coordinate grid (zw grid)
294	nc_stat = NF90_DEF_DIM( id_set_mask(mid,av), 'zw_3d', &
295	mask_size(mid,3), id_dim_zw_mask(mid,av) )
296	CALL handle_netcdf_error( 'netcdf', 473 )
297
298	nc_stat = NF90_DEF_VAR( id_set_mask(mid,av), 'zw_3d', NF90_DOUBLE, &
299	id_dim_zw_mask(mid,av), &
300	id_var_zw_mask(mid,av) )
301	CALL handle_netcdf_error( 'netcdf', 474 )
302
303	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), id_var_zw_mask(mid,av), &
304	'units', 'meters' )
305	CALL handle_netcdf_error( 'netcdf', 475 )
306
307	!
308	!-- Define x-axis (for scalar position)
309	nc_stat = NF90_DEF_DIM( id_set_mask(mid,av), 'x', &
310	mask_size(mid,1), id_dim_x_mask(mid,av) )
311	CALL handle_netcdf_error( 'netcdf', 476 )
312
313	nc_stat = NF90_DEF_VAR( id_set_mask(mid,av), 'x', NF90_DOUBLE, &
314	id_dim_x_mask(mid,av), id_var_x_mask(mid,av) )
315	CALL handle_netcdf_error( 'netcdf', 477 )
316
317	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), id_var_x_mask(mid,av), &
318	'units', 'meters' )
319	CALL handle_netcdf_error( 'netcdf', 478 )
320
321	!
322	!-- Define x-axis (for u position)
323	nc_stat = NF90_DEF_DIM( id_set_mask(mid,av), 'xu', &
324	mask_size(mid,1), id_dim_xu_mask(mid,av) )
325	CALL handle_netcdf_error( 'netcdf', 479 )
326
327	nc_stat = NF90_DEF_VAR( id_set_mask(mid,av), 'xu', NF90_DOUBLE, &
328	id_dim_xu_mask(mid,av), &
329	id_var_xu_mask(mid,av) )
330	CALL handle_netcdf_error( 'netcdf', 480 )
331
332	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), id_var_xu_mask(mid,av), &
333	'units', 'meters' )
334	CALL handle_netcdf_error( 'netcdf', 481 )
335
336	!
337	!-- Define y-axis (for scalar position)
338	nc_stat = NF90_DEF_DIM( id_set_mask(mid,av), 'y', &
339	mask_size(mid,2), id_dim_y_mask(mid,av) )
340	CALL handle_netcdf_error( 'netcdf', 482 )
341
342	nc_stat = NF90_DEF_VAR( id_set_mask(mid,av), 'y', NF90_DOUBLE, &
343	id_dim_y_mask(mid,av), id_var_y_mask(mid,av) )
344	CALL handle_netcdf_error( 'netcdf', 483 )
345
346	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), id_var_y_mask(mid,av), &
347	'units', 'meters' )
348	CALL handle_netcdf_error( 'netcdf', 484 )
349
350	!
351	!-- Define y-axis (for v position)
352	nc_stat = NF90_DEF_DIM( id_set_mask(mid,av), 'yv', &
353	mask_size(mid,2), id_dim_yv_mask(mid,av) )
354	CALL handle_netcdf_error( 'netcdf', 485 )
355
356	nc_stat = NF90_DEF_VAR( id_set_mask(mid,av), 'yv', NF90_DOUBLE, &
357	id_dim_yv_mask(mid,av), &
358	id_var_yv_mask(mid,av) )
359	CALL handle_netcdf_error( 'netcdf', 486 )
360
361	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), id_var_yv_mask(mid,av), &
362	'units', 'meters' )
363	CALL handle_netcdf_error( 'netcdf', 487 )
364
365	!
366	!-- In case of non-flat topography define 2d-arrays containing the height
367	!-- informations
368	IF ( TRIM( topography ) /= 'flat' ) THEN
369	!
370	!-- Define zusi = zu(nzb_s_inner)
371	nc_stat = NF90_DEF_VAR( id_set_mask(mid,av), 'zusi', NF90_DOUBLE, &
372	(/ id_dim_x_mask(mid,av), &
373	id_dim_y_mask(mid,av) /), &
374	id_var_zusi_mask(mid,av) )
375	CALL handle_netcdf_error( 'netcdf', 488 )
376
377	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), &
378	id_var_zusi_mask(mid,av), &
379	'units', 'meters' )
380	CALL handle_netcdf_error( 'netcdf', 489 )
381
382	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), &
383	id_var_zusi_mask(mid,av), &
384	'long_name', 'zu(nzb_s_inner)' )
385	CALL handle_netcdf_error( 'netcdf', 490 )
386
387	!
388	!-- Define zwwi = zw(nzb_w_inner)
389	nc_stat = NF90_DEF_VAR( id_set_mask(mid,av), 'zwwi', NF90_DOUBLE, &
390	(/ id_dim_x_mask(mid,av), &
391	id_dim_y_mask(mid,av) /), &
392	id_var_zwwi_mask(mid,av) )
393	CALL handle_netcdf_error( 'netcdf', 491 )
394
395	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), &
396	id_var_zwwi_mask(mid,av), &
397	'units', 'meters' )
398	CALL handle_netcdf_error( 'netcdf', 492 )
399
400	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), &
401	id_var_zwwi_mask(mid,av), &
402	'long_name', 'zw(nzb_w_inner)' )
403	CALL handle_netcdf_error( 'netcdf', 493 )
404
405	ENDIF
406
407
408	!
409	!-- Define the variables
410	var_list = ';'
411	i = 1
412
413	DO WHILE ( domask(mid,av,i)(1:1) /= ' ' )
414
415	!
416	!-- Check for the grid
417	found = .TRUE.
418	SELECT CASE ( domask(mid,av,i) )
419	!
420	!-- Most variables are defined on the scalar grid
421	CASE ( 'e', 'lpt', 'p', 'pc', 'pr', 'pt', 'q', 'ql', 'ql_c', &
422	'ql_v', 'ql_vp', 'qv', 'rho', 's', 'sa', 'vpt' )
423
424	grid_x = 'x'
425	grid_y = 'y'
426	grid_z = 'zu'
427	!
428	!-- u grid
429	CASE ( 'u' )
430
431	grid_x = 'xu'
432	grid_y = 'y'
433	grid_z = 'zu'
434	!
435	!-- v grid
436	CASE ( 'v' )
437
438	grid_x = 'x'
439	grid_y = 'yv'
440	grid_z = 'zu'
441	!
442	!-- w grid
443	CASE ( 'w' )
444
445	grid_x = 'x'
446	grid_y = 'y'
447	grid_z = 'zw'
448
449	CASE DEFAULT
450	!
451	!-- Check for user-defined quantities
452	CALL user_define_netcdf_grid( domask(mid,av,i), found, &
453	grid_x, grid_y, grid_z )
454
455	END SELECT
456
457	!
458	!-- Select the respective dimension ids
459	IF ( grid_x == 'x' ) THEN
460	id_x = id_dim_x_mask(mid,av)
461	ELSEIF ( grid_x == 'xu' ) THEN
462	id_x = id_dim_xu_mask(mid,av)
463	ENDIF
464
465	IF ( grid_y == 'y' ) THEN
466	id_y = id_dim_y_mask(mid,av)
467	ELSEIF ( grid_y == 'yv' ) THEN
468	id_y = id_dim_yv_mask(mid,av)
469	ENDIF
470
471	IF ( grid_z == 'zu' ) THEN
472	id_z = id_dim_zu_mask(mid,av)
473	ELSEIF ( grid_z == 'zw' ) THEN
474	id_z = id_dim_zw_mask(mid,av)
475	ENDIF
476
477	!
478	!-- Define the grid
479	nc_stat = NF90_DEF_VAR( id_set_mask(mid,av), domask(mid,av,i), &
480	nc_precision(11), &
481	(/ id_x, id_y, id_z, &
482	id_dim_time_mask(mid,av) /), &
483	id_var_domask(mid,av,i) )
484
485	IF ( .NOT. found ) THEN
486	WRITE ( message_string, * ) 'no grid defined for', &
487	' variable ', TRIM( domask(mid,av,i) )
488	CALL message( 'define_netcdf_header', 'PA0244', 0, 1, 0, 6, 0 )
489	ENDIF
490
491	var_list = TRIM( var_list ) // TRIM( domask(mid,av,i) ) // ';'
492
493	CALL handle_netcdf_error( 'netcdf', 494 )
494	!
495	!-- Store the 'real' name of the variable (with *, for example)
496	!-- in the long_name attribute. This is evaluated by Ferret,
497	!-- for example.
498	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), &
499	id_var_domask(mid,av,i), &
500	'long_name', domask(mid,av,i) )
501	CALL handle_netcdf_error( 'netcdf', 495 )
502	!
503	!-- Define the variable's unit
504	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), &
505	id_var_domask(mid,av,i), &
506	'units', TRIM( domask_unit(mid,av,i) ) )
507	CALL handle_netcdf_error( 'netcdf', 496 )
508
509	i = i + 1
510
511	ENDDO
512
513	!
514	!-- No arrays to output
515	IF ( i == 1 ) RETURN
516
517	!
518	!-- Write the list of variables as global attribute (this is used by
519	!-- restart runs and by combine_plot_fields)
520	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), NF90_GLOBAL, &
521	'VAR_LIST', var_list )
522	CALL handle_netcdf_error( 'netcdf', 497 )
523
524	!
525	!-- Leave NetCDF define mode
526	nc_stat = NF90_ENDDEF( id_set_mask(mid,av) )
527	CALL handle_netcdf_error( 'netcdf', 498 )
528
529	!
530	!-- Write data for x (shifted by +dx/2) and xu axis
531	ALLOCATE( netcdf_data(mask_size(mid,1)) )
532
533	netcdf_data = ( mask_i_global(mid,:mask_size(mid,1)) + 0.5 ) * dx
534
535	nc_stat = NF90_PUT_VAR( id_set_mask(mid,av), id_var_x_mask(mid,av), &
536	netcdf_data, start = (/ 1 /), &
537	count = (/ mask_size(mid,1) /) )
538	CALL handle_netcdf_error( 'netcdf', 499 )
539
540	netcdf_data = mask_i_global(mid,:mask_size(mid,1)) * dx
541
542	nc_stat = NF90_PUT_VAR( id_set_mask(mid,av), id_var_xu_mask(mid,av),&
543	netcdf_data, start = (/ 1 /), &
544	count = (/ mask_size(mid,1) /) )
545	CALL handle_netcdf_error( 'netcdf', 500 )
546
547	DEALLOCATE( netcdf_data )
548
549	!
550	!-- Write data for y (shifted by +dy/2) and yv axis
551	ALLOCATE( netcdf_data(mask_size(mid,2)) )
552
553	netcdf_data = ( mask_j_global(mid,:mask_size(mid,2)) + 0.5 ) * dy
554
555	nc_stat = NF90_PUT_VAR( id_set_mask(mid,av), id_var_y_mask(mid,av), &
556	netcdf_data, start = (/ 1 /), &
557	count = (/ mask_size(mid,2) /))
558	CALL handle_netcdf_error( 'netcdf', 501 )
559
560	netcdf_data = mask_j_global(mid,:mask_size(mid,2)) * dy
561
562	nc_stat = NF90_PUT_VAR( id_set_mask(mid,av), id_var_yv_mask(mid,av), &
563	netcdf_data, start = (/ 1 /), &
564	count = (/ mask_size(mid,2) /))
565	CALL handle_netcdf_error( 'netcdf', 502 )
566
567	DEALLOCATE( netcdf_data )
568
569	!
570	!-- Write zu and zw data (vertical axes)
571	ALLOCATE( netcdf_data(mask_size(mid,3)) )
572
573	netcdf_data = zu( mask_k_global(mid,:mask_size(mid,3)) )
574
575	nc_stat = NF90_PUT_VAR( id_set_mask(mid,av), id_var_zu_mask(mid,av), &
576	netcdf_data, start = (/ 1 /), &
577	count = (/ mask_size(mid,3) /) )
578	CALL handle_netcdf_error( 'netcdf', 503 )
579
580	netcdf_data = zw( mask_k_global(mid,:mask_size(mid,3)) )
581
582	nc_stat = NF90_PUT_VAR( id_set_mask(mid,av), id_var_zw_mask(mid,av), &
583	netcdf_data, start = (/ 1 /), &
584	count = (/ mask_size(mid,3) /) )
585	CALL handle_netcdf_error( 'netcdf', 504 )
586
587	DEALLOCATE( netcdf_data )
588
589	!
590	!-- In case of non-flat topography write height information
591	IF ( TRIM( topography ) /= 'flat' ) THEN
592
593	ALLOCATE( netcdf_data_2d(mask_size(mid,1),mask_size(mid,2)) )
594	netcdf_data_2d = zu_s_inner( mask_i_global(mid,:mask_size(mid,1)),&
595	mask_j_global(mid,:mask_size(mid,2)) )
596
597	nc_stat = NF90_PUT_VAR( id_set_mask(mid,av), &
598	id_var_zusi_mask(mid,av), &
599	netcdf_data_2d, &
600	start = (/ 1, 1 /), &
601	count = (/ mask_size(mid,1), &
602	mask_size(mid,2) /) )
603	CALL handle_netcdf_error( 'netcdf', 505 )
604
605	netcdf_data_2d = zw_w_inner( mask_i_global(mid,:mask_size(mid,1)),&
606	mask_j_global(mid,:mask_size(mid,2)) )
607
608	nc_stat = NF90_PUT_VAR( id_set_mask(mid,av), &
609	id_var_zwwi_mask(mid,av), &
610	netcdf_data_2d, &
611	start = (/ 1, 1 /), &
612	count = (/ mask_size(mid,1), &
613	mask_size(mid,2) /) )
614	CALL handle_netcdf_error( 'netcdf', 506 )
615
616	DEALLOCATE( netcdf_data_2d )
617
618	ENDIF
619	!
620	!-- restore original parameter file_id (=formal parameter av) into av
621	av = file_id
622
623
624	CASE ( 'ma_ext' )
625
626	!
627	!-- decompose actual parameter file_id (=formal parameter av) into
628	!-- mid and av
629	file_id = av
630	IF ( file_id <= 200+max_masks ) THEN
631	mid = file_id - 200
632	av = 0
633	ELSE
634	mid = file_id - (200+max_masks)
635	av = 1
636	ENDIF
637
638	!
639	!-- Get the list of variables and compare with the actual run.
640	!-- First var_list_old has to be reset, since GET_ATT does not assign
641	!-- trailing blanks.
642	var_list_old = ' '
643	nc_stat = NF90_GET_ATT( id_set_mask(mid,av), NF90_GLOBAL, 'VAR_LIST',&
644	var_list_old )
645	CALL handle_netcdf_error( 'netcdf', 507 )
646
647	var_list = ';'
648	i = 1
649	DO WHILE ( domask(mid,av,i)(1:1) /= ' ' )
650	var_list = TRIM(var_list) // TRIM( domask(mid,av,i) ) // ';'
651	i = i + 1
652	ENDDO
653
654	IF ( av == 0 ) THEN
655	var = '(mask)'
656	ELSE
657	var = '(mask_av)'
658	ENDIF
659
660	IF ( TRIM( var_list ) /= TRIM( var_list_old ) ) THEN
661	WRITE ( message_string, * ) 'NetCDF file for ', TRIM( var ), &
662	' data for mask', mid, ' from previous run found,', &
663	'&but this file cannot be extended due to variable ', &
664	'mismatch.&New file is created instead.'
665	CALL message( 'define_netcdf_header', 'PA0335', 0, 1, 0, 6, 0 )
666	extend = .FALSE.
667	RETURN
668	ENDIF
669
670	!
671	!-- Get and compare the number of vertical gridpoints
672	nc_stat = NF90_INQ_VARID( id_set_mask(mid,av), 'zu', &
673	id_var_zu_mask(mid,av) )
674	CALL handle_netcdf_error( 'netcdf', 508 )
675
676	nc_stat = NF90_INQUIRE_VARIABLE( id_set_mask(mid,av), &
677	id_var_zu_mask(mid,av), &
678	dimids = id_dim_zu_mask_old )
679	CALL handle_netcdf_error( 'netcdf', 509 )
680	id_dim_zu_mask(mid,av) = id_dim_zu_mask_old(1)
681
682	nc_stat = NF90_INQUIRE_DIMENSION( id_set_mask(mid,av), &
683	id_dim_zu_mask(mid,av), &
684	len = nz_old )
685	CALL handle_netcdf_error( 'netcdf', 510 )
686
687	IF ( mask_size(mid,3) /= nz_old ) THEN
688	WRITE ( message_string, * ) 'NetCDF file for ', TRIM( var ), &
689	' data for mask', mid, ' from previous run found,', &
690	'&but this file cannot be extended due to mismatch in ', &
691	' number of&vertical grid points.', &
692	'&New file is created instead.'
693	CALL message( 'define_netcdf_header', 'PA0336', 0, 1, 0, 6, 0 )
694	extend = .FALSE.
695	RETURN
696	ENDIF
697
698	!
699	!-- Get the id of the time coordinate (unlimited coordinate) and its
700	!-- last index on the file. The next time level is plmask..count+1.
701	!-- The current time must be larger than the last output time
702	!-- on the file.
703	nc_stat = NF90_INQ_VARID( id_set_mask(mid,av), 'time', &
704	id_var_time_mask(mid,av) )
705	CALL handle_netcdf_error( 'netcdf', 511 )
706
707	nc_stat = NF90_INQUIRE_VARIABLE( id_set_mask(mid,av), &
708	id_var_time_mask(mid,av), &
709	dimids = id_dim_time_old )
710	CALL handle_netcdf_error( 'netcdf', 512 )
711	id_dim_time_mask(mid,av) = id_dim_time_old(1)
712
713	nc_stat = NF90_INQUIRE_DIMENSION( id_set_mask(mid,av), &
714	id_dim_time_mask(mid,av), &
715	len = domask_time_count(mid,av) )
716	CALL handle_netcdf_error( 'netcdf', 513 )
717
718	nc_stat = NF90_GET_VAR( id_set_mask(mid,av), &
719	id_var_time_mask(mid,av), &
720	last_time_coordinate, &
721	start = (/ domask_time_count(mid,av) /), &
722	count = (/ 1 /) )
723	CALL handle_netcdf_error( 'netcdf', 514 )
724
725	IF ( last_time_coordinate(1) >= simulated_time ) THEN
726	WRITE ( message_string, * ) 'NetCDF file for ', TRIM( var ), &
727	' data for mask', mid, ' from previous run found,', &
728	'&but this file cannot be extended because the current ', &
729	'output time&is less or equal than the last output time ', &
730	'on this file.&New file is created instead.'
731	CALL message( 'define_netcdf_header', 'PA0337', 0, 1, 0, 6, 0 )
732	domask_time_count(mid,av) = 0
733	extend = .FALSE.
734	RETURN
735	ENDIF
736
737	!
738	!-- Dataset seems to be extendable.
739	!-- Now get the variable ids.
740	i = 1
741	DO WHILE ( domask(mid,av,i)(1:1) /= ' ' )
742	nc_stat = NF90_INQ_VARID( id_set_mask(mid,av), &
743	TRIM( domask(mid,av,i) ), &
744	id_var_domask(mid,av,i) )
745	CALL handle_netcdf_error( 'netcdf', 515 )
746	i = i + 1
747	ENDDO
748
749	!
750	!-- Update the title attribute on file
751	!-- In order to avoid 'data mode' errors if updated attributes are larger
752	!-- than their original size, NF90_PUT_ATT is called in 'define mode'
753	!-- enclosed by NF90_REDEF and NF90_ENDDEF calls. This implies a possible
754	!-- performance loss due to data copying; an alternative strategy would be
755	!-- to ensure equal attribute size in a job chain. Maybe revise later.
756	IF ( av == 0 ) THEN
757	time_average_text = ' '
758	ELSE
759	WRITE (time_average_text, '('', '',F7.1,'' s average'')') &
760	averaging_interval
761	ENDIF
762	nc_stat = NF90_REDEF( id_set_mask(mid,av) )
763	CALL handle_netcdf_error( 'netcdf', 516 )
764	nc_stat = NF90_PUT_ATT( id_set_mask(mid,av), NF90_GLOBAL, 'title', &
765	TRIM( run_description_header ) // &
766	TRIM( time_average_text ) )
767	CALL handle_netcdf_error( 'netcdf', 517 )
768	nc_stat = NF90_ENDDEF( id_set_mask(mid,av) )
769	CALL handle_netcdf_error( 'netcdf', 518 )
770	WRITE ( message_string, * ) 'NetCDF file for ', TRIM( var ), &
771	' data for mask', mid, ' from previous run found.', &
772	'&This file will be extended.'
773	CALL message( 'define_netcdf_header', 'PA0338', 0, 0, 0, 6, 0 )
774	!
775	!-- restore original parameter file_id (=formal parameter av) into av
776	av = file_id
777
778
779	CASE ( '3d_new' )
780
781	!
782	!-- Define some global attributes of the dataset
783	nc_stat = NF90_PUT_ATT( id_set_3d(av), NF90_GLOBAL, 'Conventions', &
784	'COARDS' )
785	CALL handle_netcdf_error( 'netcdf', 62 )
786
787	IF ( av == 0 ) THEN
788	time_average_text = ' '
789	ELSE
790	WRITE (time_average_text, '('', '',F7.1,'' s average'')') &
791	averaging_interval
792	ENDIF
793	nc_stat = NF90_PUT_ATT( id_set_3d(av), NF90_GLOBAL, 'title', &
794	TRIM( run_description_header ) // &
795	TRIM( time_average_text ) )
796	CALL handle_netcdf_error( 'netcdf', 63 )
797	IF ( av == 1 ) THEN
798	WRITE ( time_average_text,'(F7.1,'' s avg'')' ) averaging_interval
799	nc_stat = NF90_PUT_ATT( id_set_3d(av), NF90_GLOBAL, 'time_avg', &
800	TRIM( time_average_text ) )
801	CALL handle_netcdf_error( 'netcdf', 63 )
802	ENDIF
803
804	!
805	!-- Define time coordinate for volume data (unlimited dimension)
806	nc_stat = NF90_DEF_DIM( id_set_3d(av), 'time', NF90_UNLIMITED, &
807	id_dim_time_3d(av) )
808	CALL handle_netcdf_error( 'netcdf', 64 )
809
810	nc_stat = NF90_DEF_VAR( id_set_3d(av), 'time', NF90_DOUBLE, &
811	id_dim_time_3d(av), id_var_time_3d(av) )
812	CALL handle_netcdf_error( 'netcdf', 65 )
813
814	nc_stat = NF90_PUT_ATT( id_set_3d(av), id_var_time_3d(av), 'units', &
815	'seconds')
816	CALL handle_netcdf_error( 'netcdf', 66 )
817
818	!
819	!-- Define spatial dimensions and coordinates:
820	!-- Define vertical coordinate grid (zu grid)
821	nc_stat = NF90_DEF_DIM( id_set_3d(av), 'zu_3d', nz_do3d-nzb+1, &
822	id_dim_zu_3d(av) )
823	CALL handle_netcdf_error( 'netcdf', 67 )
824
825	nc_stat = NF90_DEF_VAR( id_set_3d(av), 'zu_3d', NF90_DOUBLE, &
826	id_dim_zu_3d(av), id_var_zu_3d(av) )
827	CALL handle_netcdf_error( 'netcdf', 68 )
828
829	nc_stat = NF90_PUT_ATT( id_set_3d(av), id_var_zu_3d(av), 'units', &
830	'meters' )
831	CALL handle_netcdf_error( 'netcdf', 69 )
832
833	!
834	!-- Define vertical coordinate grid (zw grid)
835	nc_stat = NF90_DEF_DIM( id_set_3d(av), 'zw_3d', nz_do3d-nzb+1, &
836	id_dim_zw_3d(av) )
837	CALL handle_netcdf_error( 'netcdf', 70 )
838
839	nc_stat = NF90_DEF_VAR( id_set_3d(av), 'zw_3d', NF90_DOUBLE, &
840	id_dim_zw_3d(av), id_var_zw_3d(av) )
841	CALL handle_netcdf_error( 'netcdf', 71 )
842
843	nc_stat = NF90_PUT_ATT( id_set_3d(av), id_var_zw_3d(av), 'units', &
844	'meters' )
845	CALL handle_netcdf_error( 'netcdf', 72 )
846
847	!
848	!-- Define x-axis (for scalar position)
849	nc_stat = NF90_DEF_DIM( id_set_3d(av), 'x', nx+2, id_dim_x_3d(av) )
850	CALL handle_netcdf_error( 'netcdf', 73 )
851
852	nc_stat = NF90_DEF_VAR( id_set_3d(av), 'x', NF90_DOUBLE, &
853	id_dim_x_3d(av), id_var_x_3d(av) )
854	CALL handle_netcdf_error( 'netcdf', 74 )
855
856	nc_stat = NF90_PUT_ATT( id_set_3d(av), id_var_x_3d(av), 'units', &
857	'meters' )
858	CALL handle_netcdf_error( 'netcdf', 75 )
859
860	!
861	!-- Define x-axis (for u position)
862	nc_stat = NF90_DEF_DIM( id_set_3d(av), 'xu', nx+2, id_dim_xu_3d(av) )
863	CALL handle_netcdf_error( 'netcdf', 358 )
864
865	nc_stat = NF90_DEF_VAR( id_set_3d(av), 'xu', NF90_DOUBLE, &
866	id_dim_xu_3d(av), id_var_xu_3d(av) )
867	CALL handle_netcdf_error( 'netcdf', 359 )
868
869	nc_stat = NF90_PUT_ATT( id_set_3d(av), id_var_xu_3d(av), 'units', &
870	'meters' )
871	CALL handle_netcdf_error( 'netcdf', 360 )
872
873	!
874	!-- Define y-axis (for scalar position)
875	nc_stat = NF90_DEF_DIM( id_set_3d(av), 'y', ny+2, id_dim_y_3d(av) )
876	CALL handle_netcdf_error( 'netcdf', 76 )
877
878	nc_stat = NF90_DEF_VAR( id_set_3d(av), 'y', NF90_DOUBLE, &
879	id_dim_y_3d(av), id_var_y_3d(av) )
880	CALL handle_netcdf_error( 'netcdf', 77 )
881
882	nc_stat = NF90_PUT_ATT( id_set_3d(av), id_var_y_3d(av), 'units', &
883	'meters' )
884	CALL handle_netcdf_error( 'netcdf', 78 )
885
886	!
887	!-- Define y-axis (for v position)
888	nc_stat = NF90_DEF_DIM( id_set_3d(av), 'yv', ny+2, id_dim_yv_3d(av) )
889	CALL handle_netcdf_error( 'netcdf', 361 )
890
891	nc_stat = NF90_DEF_VAR( id_set_3d(av), 'yv', NF90_DOUBLE, &
892	id_dim_yv_3d(av), id_var_yv_3d(av) )
893	CALL handle_netcdf_error( 'netcdf', 362 )
894
895	nc_stat = NF90_PUT_ATT( id_set_3d(av), id_var_yv_3d(av), 'units', &
896	'meters' )
897	CALL handle_netcdf_error( 'netcdf', 363 )
898
899	!
900	!-- In case of non-flat topography define 2d-arrays containing the height
901	!-- informations
902	IF ( TRIM( topography ) /= 'flat' ) THEN
903	!
904	!-- Define zusi = zu(nzb_s_inner)
905	nc_stat = NF90_DEF_VAR( id_set_3d(av), 'zusi', NF90_DOUBLE, &
906	(/ id_dim_x_3d(av), id_dim_y_3d(av) /), &
907	id_var_zusi_3d(av) )
908	CALL handle_netcdf_error( 'netcdf', 413 )
909
910	nc_stat = NF90_PUT_ATT( id_set_3d(av), id_var_zusi_3d(av), &
911	'units', 'meters' )
912	CALL handle_netcdf_error( 'netcdf', 414 )
913
914	nc_stat = NF90_PUT_ATT( id_set_3d(av), id_var_zusi_3d(av), &
915	'long_name', 'zu(nzb_s_inner)' )
916	CALL handle_netcdf_error( 'netcdf', 415 )
917
918	!
919	!-- Define zwwi = zw(nzb_w_inner)
920	nc_stat = NF90_DEF_VAR( id_set_3d(av), 'zwwi', NF90_DOUBLE, &
921	(/ id_dim_x_3d(av), id_dim_y_3d(av) /), &
922	id_var_zwwi_3d(av) )
923	CALL handle_netcdf_error( 'netcdf', 416 )
924
925	nc_stat = NF90_PUT_ATT( id_set_3d(av), id_var_zwwi_3d(av), &
926	'units', 'meters' )
927	CALL handle_netcdf_error( 'netcdf', 417 )
928
929	nc_stat = NF90_PUT_ATT( id_set_3d(av), id_var_zwwi_3d(av), &
930	'long_name', 'zw(nzb_w_inner)' )
931	CALL handle_netcdf_error( 'netcdf', 418 )
932
933	ENDIF
934
935
936	!
937	!-- Define the variables
938	var_list = ';'
939	i = 1
940
941	DO WHILE ( do3d(av,i)(1:1) /= ' ' )
942
943	!
944	!-- Check for the grid
945	found = .TRUE.
946	SELECT CASE ( do3d(av,i) )
947	!
948	!-- Most variables are defined on the scalar grid
949	CASE ( 'e', 'lpt', 'p', 'pc', 'pr', 'pt', 'q', 'ql', 'ql_c', &
950	'ql_v', 'ql_vp', 'qv', 'rho', 's', 'sa', 'vpt' )
951
952	grid_x = 'x'
953	grid_y = 'y'
954	grid_z = 'zu'
955	!
956	!-- u grid
957	CASE ( 'u' )
958
959	grid_x = 'xu'
960	grid_y = 'y'
961	grid_z = 'zu'
962	!
963	!-- v grid
964	CASE ( 'v' )
965
966	grid_x = 'x'
967	grid_y = 'yv'
968	grid_z = 'zu'
969	!
970	!-- w grid
971	CASE ( 'w' )
972
973	grid_x = 'x'
974	grid_y = 'y'
975	grid_z = 'zw'
976
977	CASE DEFAULT
978	!
979	!-- Check for user-defined quantities
980	CALL user_define_netcdf_grid( do3d(av,i), found, grid_x, &
981	grid_y, grid_z )
982
983	END SELECT
984
985	!
986	!-- Select the respective dimension ids
987	IF ( grid_x == 'x' ) THEN
988	id_x = id_dim_x_3d(av)
989	ELSEIF ( grid_x == 'xu' ) THEN
990	id_x = id_dim_xu_3d(av)
991	ENDIF
992
993	IF ( grid_y == 'y' ) THEN
994	id_y = id_dim_y_3d(av)
995	ELSEIF ( grid_y == 'yv' ) THEN
996	id_y = id_dim_yv_3d(av)
997	ENDIF
998
999	IF ( grid_z == 'zu' ) THEN
1000	id_z = id_dim_zu_3d(av)
1001	ELSEIF ( grid_z == 'zw' ) THEN
1002	id_z = id_dim_zw_3d(av)
1003	ENDIF
1004
1005	!
1006	!-- Define the grid
1007	nc_stat = NF90_DEF_VAR( id_set_3d(av), do3d(av,i), &
1008	nc_precision(4), &
1009	(/ id_x, id_y, id_z, id_dim_time_3d(av) /), &
1010	id_var_do3d(av,i) )
1011
1012	IF ( .NOT. found ) THEN
1013	WRITE ( message_string, * ) 'no grid defined for', &
1014	' variable ', TRIM( do3d(av,i) )
1015	CALL message( 'define_netcdf_header', 'PA0244', 0, 1, 0, 6, 0 )
1016	ENDIF
1017
1018	var_list = TRIM( var_list ) // TRIM( do3d(av,i) ) // ';'
1019
1020	CALL handle_netcdf_error( 'netcdf', 79 )
1021	!
1022	!-- Store the 'real' name of the variable (with *, for example)
1023	!-- in the long_name attribute. This is evaluated by Ferret,
1024	!-- for example.
1025	nc_stat = NF90_PUT_ATT( id_set_3d(av), id_var_do3d(av,i), &
1026	'long_name', do3d(av,i) )
1027	CALL handle_netcdf_error( 'netcdf', 80 )
1028	!
1029	!-- Define the variable's unit
1030	nc_stat = NF90_PUT_ATT( id_set_3d(av), id_var_do3d(av,i), &
1031	'units', TRIM( do3d_unit(av,i) ) )
1032	CALL handle_netcdf_error( 'netcdf', 357 )
1033	#if defined( __netcdf4 )
1034	!
1035	!-- Set collective io operations for parallel io
1036	IF ( netcdf_data_format > 2 ) THEN
1037	nc_stat = NF90_VAR_PAR_ACCESS( id_set_3d(av), &
1038	id_var_do3d(av,i), &
1039	NF90_COLLECTIVE )
1040	CALL handle_netcdf_error( 'netcdf', 445 )
1041	ENDIF
1042	#endif
1043	i = i + 1
1044
1045	ENDDO
1046
1047	!
1048	!-- No arrays to output
1049	IF ( i == 1 ) RETURN
1050
1051	!
1052	!-- Write the list of variables as global attribute (this is used by
1053	!-- restart runs and by combine_plot_fields)
1054	nc_stat = NF90_PUT_ATT( id_set_3d(av), NF90_GLOBAL, 'VAR_LIST', &
1055	var_list )
1056	CALL handle_netcdf_error( 'netcdf', 81 )
1057
1058	!
1059	!-- Leave NetCDF define mode
1060	nc_stat = NF90_ENDDEF( id_set_3d(av) )
1061	CALL handle_netcdf_error( 'netcdf', 82 )
1062
1063	!
1064	!-- Write data for x (shifted by +dx/2) and xu axis
1065	ALLOCATE( netcdf_data(0:nx+1) )
1066
1067	DO i = 0, nx+1
1068	netcdf_data(i) = ( i + 0.5 ) * dx
1069	ENDDO
1070
1071	nc_stat = NF90_PUT_VAR( id_set_3d(av), id_var_x_3d(av), netcdf_data, &
1072	start = (/ 1 /), count = (/ nx+2 /) )
1073	CALL handle_netcdf_error( 'netcdf', 83 )
1074
1075	DO i = 0, nx+1
1076	netcdf_data(i) = i * dx
1077	ENDDO
1078
1079	nc_stat = NF90_PUT_VAR( id_set_3d(av), id_var_xu_3d(av), &
1080	netcdf_data, start = (/ 1 /), &
1081	count = (/ nx+2 /) )
1082	CALL handle_netcdf_error( 'netcdf', 385 )
1083
1084	DEALLOCATE( netcdf_data )
1085
1086	!
1087	!-- Write data for y (shifted by +dy/2) and yv axis
1088	ALLOCATE( netcdf_data(0:ny+1) )
1089
1090	DO i = 0, ny+1
1091	netcdf_data(i) = ( i + 0.5 ) * dy
1092	ENDDO
1093
1094	nc_stat = NF90_PUT_VAR( id_set_3d(av), id_var_y_3d(av), netcdf_data, &
1095	start = (/ 1 /), count = (/ ny+2 /))
1096	CALL handle_netcdf_error( 'netcdf', 84 )
1097
1098	DO i = 0, ny+1
1099	netcdf_data(i) = i * dy
1100	ENDDO
1101
1102	nc_stat = NF90_PUT_VAR( id_set_3d(av), id_var_yv_3d(av), &
1103	netcdf_data, start = (/ 1 /), &
1104	count = (/ ny+2 /))
1105	CALL handle_netcdf_error( 'netcdf', 387 )
1106
1107	DEALLOCATE( netcdf_data )
1108
1109	!
1110	!-- Write zu and zw data (vertical axes)
1111	nc_stat = NF90_PUT_VAR( id_set_3d(av), id_var_zu_3d(av), &
1112	zu(nzb:nz_do3d), start = (/ 1 /), &
1113	count = (/ nz_do3d-nzb+1 /) )
1114	CALL handle_netcdf_error( 'netcdf', 85 )
1115
1116
1117	nc_stat = NF90_PUT_VAR( id_set_3d(av), id_var_zw_3d(av), &
1118	zw(nzb:nz_do3d), start = (/ 1 /), &
1119	count = (/ nz_do3d-nzb+1 /) )
1120	CALL handle_netcdf_error( 'netcdf', 86 )
1121
1122
1123	!
1124	!-- In case of non-flat topography write height information
1125	IF ( TRIM( topography ) /= 'flat' ) THEN
1126
1127	nc_stat = NF90_PUT_VAR( id_set_3d(av), id_var_zusi_3d(av), &
1128	zu_s_inner(0:nx+1,0:ny+1), &
1129	start = (/ 1, 1 /), &
1130	count = (/ nx+2, ny+2 /) )
1131	CALL handle_netcdf_error( 'netcdf', 419 )
1132
1133	nc_stat = NF90_PUT_VAR( id_set_3d(av), id_var_zwwi_3d(av), &
1134	zw_w_inner(0:nx+1,0:ny+1), &
1135	start = (/ 1, 1 /), &
1136	count = (/ nx+2, ny+2 /) )
1137	CALL handle_netcdf_error( 'netcdf', 420 )
1138
1139	ENDIF
1140
1141	CASE ( '3d_ext' )
1142
1143	!
1144	!-- Get the list of variables and compare with the actual run.
1145	!-- First var_list_old has to be reset, since GET_ATT does not assign
1146	!-- trailing blanks.
1147	var_list_old = ' '
1148	nc_stat = NF90_GET_ATT( id_set_3d(av), NF90_GLOBAL, 'VAR_LIST', &
1149	var_list_old )
1150	CALL handle_netcdf_error( 'netcdf', 87 )
1151
1152	var_list = ';'
1153	i = 1
1154	DO WHILE ( do3d(av,i)(1:1) /= ' ' )
1155	var_list = TRIM(var_list) // TRIM( do3d(av,i) ) // ';'
1156	i = i + 1
1157	ENDDO
1158
1159	IF ( av == 0 ) THEN
1160	var = '(3d)'
1161	ELSE
1162	var = '(3d_av)'
1163	ENDIF
1164
1165	IF ( TRIM( var_list ) /= TRIM( var_list_old ) ) THEN
1166	message_string = 'NetCDF file for volume data ' // &
1167	TRIM( var ) // ' from previous run found,' // &
1168	'&but this file cannot be extended due to' // &
1169	' variable mismatch.' // &
1170	'&New file is created instead.'
1171	CALL message( 'define_netcdf_header', 'PA0245', 0, 1, 0, 6, 0 )
1172	extend = .FALSE.
1173	RETURN
1174	ENDIF
1175
1176	!
1177	!-- Get and compare the number of vertical gridpoints
1178	nc_stat = NF90_INQ_VARID( id_set_3d(av), 'zu_3d', id_var_zu_3d(av) )
1179	CALL handle_netcdf_error( 'netcdf', 88 )
1180
1181	nc_stat = NF90_INQUIRE_VARIABLE( id_set_3d(av), id_var_zu_3d(av), &
1182	dimids = id_dim_zu_3d_old )
1183	CALL handle_netcdf_error( 'netcdf', 89 )
1184	id_dim_zu_3d(av) = id_dim_zu_3d_old(1)
1185
1186	nc_stat = NF90_INQUIRE_DIMENSION( id_set_3d(av), id_dim_zu_3d(av), &
1187	len = nz_old )
1188	CALL handle_netcdf_error( 'netcdf', 90 )
1189
1190	IF ( nz_do3d-nzb+1 /= nz_old ) THEN
1191	message_string = 'NetCDF file for volume data ' // &
1192	TRIM( var ) // ' from previous run found,' // &
1193	'&but this file cannot be extended due to' // &
1194	' mismatch in number of' // &
1195	'&vertical grid points (nz_do3d).' // &
1196	'&New file is created instead.'
1197	CALL message( 'define_netcdf_header', 'PA0246', 0, 1, 0, 6, 0 )
1198	extend = .FALSE.
1199	RETURN
1200	ENDIF
1201
1202	!
1203	!-- Get the id of the time coordinate (unlimited coordinate) and its
1204	!-- last index on the file. The next time level is pl3d..count+1.
1205	!-- The current time must be larger than the last output time
1206	!-- on the file.
1207	nc_stat = NF90_INQ_VARID( id_set_3d(av), 'time', id_var_time_3d(av) )
1208	CALL handle_netcdf_error( 'netcdf', 91 )
1209
1210	nc_stat = NF90_INQUIRE_VARIABLE( id_set_3d(av), id_var_time_3d(av), &
1211	dimids = id_dim_time_old )
1212	CALL handle_netcdf_error( 'netcdf', 92 )
1213
1214	id_dim_time_3d(av) = id_dim_time_old(1)
1215
1216	nc_stat = NF90_INQUIRE_DIMENSION( id_set_3d(av), id_dim_time_3d(av), &
1217	len = do3d_time_count(av) )
1218	CALL handle_netcdf_error( 'netcdf', 93 )
1219
1220	nc_stat = NF90_GET_VAR( id_set_3d(av), id_var_time_3d(av), &
1221	last_time_coordinate, &
1222	start = (/ do3d_time_count(av) /), &
1223	count = (/ 1 /) )
1224	CALL handle_netcdf_error( 'netcdf', 94 )
1225
1226	IF ( last_time_coordinate(1) >= simulated_time ) THEN
1227	message_string = 'NetCDF file for volume data ' // &
1228	TRIM( var ) // ' from previous run found,' // &
1229	'&but this file cannot be extended becaus' // &
1230	'e the current output time' // &
1231	'&is less or equal than the last output t' // &
1232	'ime on this file.' // &
1233	'&New file is created instead.'
1234	CALL message( 'define_netcdf_header', 'PA0247', 0, 1, 0, 6, 0 )
1235	do3d_time_count(av) = 0
1236	extend = .FALSE.
1237	RETURN
1238	ENDIF
1239
1240	!
1241	!-- Dataset seems to be extendable.
1242	!-- Now get the variable ids.
1243	i = 1
1244	DO WHILE ( do3d(av,i)(1:1) /= ' ' )
1245	nc_stat = NF90_INQ_VARID( id_set_3d(av), TRIM( do3d(av,i) ), &
1246	id_var_do3d(av,i) )
1247	CALL handle_netcdf_error( 'netcdf', 95 )
1248	#if defined( __netcdf4 )
1249	!
1250	!-- Set collective io operations for parallel io
1251	IF ( netcdf_data_format > 2 ) THEN
1252	nc_stat = NF90_VAR_PAR_ACCESS( id_set_3d(av), &
1253	id_var_do3d(av,i), &
1254	NF90_COLLECTIVE )
1255	CALL handle_netcdf_error( 'netcdf', 453 )
1256	ENDIF
1257	#endif
1258	i = i + 1
1259	ENDDO
1260
1261	!
1262	!-- Update the title attribute on file
1263	!-- In order to avoid 'data mode' errors if updated attributes are larger
1264	!-- than their original size, NF90_PUT_ATT is called in 'define mode'
1265	!-- enclosed by NF90_REDEF and NF90_ENDDEF calls. This implies a possible
1266	!-- performance loss due to data copying; an alternative strategy would be
1267	!-- to ensure equal attribute size. Maybe revise later.
1268	IF ( av == 0 ) THEN
1269	time_average_text = ' '
1270	ELSE
1271	WRITE (time_average_text, '('', '',F7.1,'' s average'')') &
1272	averaging_interval
1273	ENDIF
1274	nc_stat = NF90_REDEF( id_set_3d(av) )
1275	CALL handle_netcdf_error( 'netcdf', 429 )
1276	nc_stat = NF90_PUT_ATT( id_set_3d(av), NF90_GLOBAL, 'title', &
1277	TRIM( run_description_header ) // &
1278	TRIM( time_average_text ) )
1279	CALL handle_netcdf_error( 'netcdf', 96 )
1280	nc_stat = NF90_ENDDEF( id_set_3d(av) )
1281	CALL handle_netcdf_error( 'netcdf', 430 )
1282	message_string = 'NetCDF file for volume data ' // &
1283	TRIM( var ) // ' from previous run found.' // &
1284	'&This file will be extended.'
1285	CALL message( 'define_netcdf_header', 'PA0248', 0, 0, 0, 6, 0 )
1286
1287	CASE ( 'xy_new' )
1288
1289	!
1290	!-- Define some global attributes of the dataset
1291	nc_stat = NF90_PUT_ATT( id_set_xy(av), NF90_GLOBAL, 'Conventions', &
1292	'COARDS' )
1293	CALL handle_netcdf_error( 'netcdf', 97 )
1294
1295	IF ( av == 0 ) THEN
1296	time_average_text = ' '
1297	ELSE
1298	WRITE (time_average_text, '('', '',F7.1,'' s average'')') &
1299	averaging_interval
1300	ENDIF
1301	nc_stat = NF90_PUT_ATT( id_set_xy(av), NF90_GLOBAL, 'title', &
1302	TRIM( run_description_header ) // &
1303	TRIM( time_average_text ) )
1304	CALL handle_netcdf_error( 'netcdf', 98 )
1305	IF ( av == 1 ) THEN
1306	WRITE ( time_average_text,'(F7.1,'' s avg'')' ) averaging_interval
1307	nc_stat = NF90_PUT_ATT( id_set_xy(av), NF90_GLOBAL, 'time_avg', &
1308	TRIM( time_average_text ) )
1309	CALL handle_netcdf_error( 'netcdf', 98 )
1310	ENDIF
1311
1312	!
1313	!-- Define time coordinate for xy sections (unlimited dimension)
1314	nc_stat = NF90_DEF_DIM( id_set_xy(av), 'time', NF90_UNLIMITED, &
1315	id_dim_time_xy(av) )
1316	CALL handle_netcdf_error( 'netcdf', 99 )
1317
1318	nc_stat = NF90_DEF_VAR( id_set_xy(av), 'time', NF90_DOUBLE, &
1319	id_dim_time_xy(av), id_var_time_xy(av) )
1320	CALL handle_netcdf_error( 'netcdf', 100 )
1321
1322	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_time_xy(av), 'units', &
1323	'seconds')
1324	CALL handle_netcdf_error( 'netcdf', 101 )
1325
1326	!
1327	!-- Define the spatial dimensions and coordinates for xy-sections.
1328	!-- First, determine the number of horizontal sections to be written.
1329	IF ( section(1,1) == -9999 ) THEN
1330	RETURN
1331	ELSE
1332	ns = 1
1333	DO WHILE ( section(ns,1) /= -9999 .AND. ns <= 100 )
1334	ns = ns + 1
1335	ENDDO
1336	ns = ns - 1
1337	ENDIF
1338
1339	!
1340	!-- Define vertical coordinate grid (zu grid)
1341	nc_stat = NF90_DEF_DIM( id_set_xy(av), 'zu_xy', ns, id_dim_zu_xy(av) )
1342	CALL handle_netcdf_error( 'netcdf', 102 )
1343
1344	nc_stat = NF90_DEF_VAR( id_set_xy(av), 'zu_xy', NF90_DOUBLE, &
1345	id_dim_zu_xy(av), id_var_zu_xy(av) )
1346	CALL handle_netcdf_error( 'netcdf', 103 )
1347
1348	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_zu_xy(av), 'units', &
1349	'meters' )
1350	CALL handle_netcdf_error( 'netcdf', 104 )
1351
1352	!
1353	!-- Define vertical coordinate grid (zw grid)
1354	nc_stat = NF90_DEF_DIM( id_set_xy(av), 'zw_xy', ns, id_dim_zw_xy(av) )
1355	CALL handle_netcdf_error( 'netcdf', 105 )
1356
1357	nc_stat = NF90_DEF_VAR( id_set_xy(av), 'zw_xy', NF90_DOUBLE, &
1358	id_dim_zw_xy(av), id_var_zw_xy(av) )
1359	CALL handle_netcdf_error( 'netcdf', 106 )
1360
1361	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_zw_xy(av), 'units', &
1362	'meters' )
1363	CALL handle_netcdf_error( 'netcdf', 107 )
1364
1365	!
1366	!-- Define a pseudo vertical coordinate grid for the surface variables
1367	!-- u* and t* to store their height level
1368	nc_stat = NF90_DEF_DIM( id_set_xy(av), 'zu1_xy', 1, &
1369	id_dim_zu1_xy(av) )
1370	CALL handle_netcdf_error( 'netcdf', 108 )
1371
1372	nc_stat = NF90_DEF_VAR( id_set_xy(av), 'zu1_xy', NF90_DOUBLE, &
1373	id_dim_zu1_xy(av), id_var_zu1_xy(av) )
1374	CALL handle_netcdf_error( 'netcdf', 109 )
1375
1376	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_zu1_xy(av), 'units', &
1377	'meters' )
1378	CALL handle_netcdf_error( 'netcdf', 110 )
1379
1380	!
1381	!-- Define a variable to store the layer indices of the horizontal cross
1382	!-- sections, too
1383	nc_stat = NF90_DEF_VAR( id_set_xy(av), 'ind_z_xy', NF90_DOUBLE, &
1384	id_dim_zu_xy(av), id_var_ind_z_xy(av) )
1385	CALL handle_netcdf_error( 'netcdf', 111 )
1386
1387	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_ind_z_xy(av), 'units', &
1388	'gridpoints')
1389	CALL handle_netcdf_error( 'netcdf', 112 )
1390
1391	!
1392	!-- Define x-axis (for scalar position)
1393	nc_stat = NF90_DEF_DIM( id_set_xy(av), 'x', nx+2, id_dim_x_xy(av) )
1394	CALL handle_netcdf_error( 'netcdf', 113 )
1395
1396	nc_stat = NF90_DEF_VAR( id_set_xy(av), 'x', NF90_DOUBLE, &
1397	id_dim_x_xy(av), id_var_x_xy(av) )
1398	CALL handle_netcdf_error( 'netcdf', 114 )
1399
1400
1401	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_x_xy(av), 'units', &
1402	'meters' )
1403	CALL handle_netcdf_error( 'netcdf', 115 )
1404
1405	!
1406	!-- Define x-axis (for u position)
1407	nc_stat = NF90_DEF_DIM( id_set_xy(av), 'xu', nx+2, id_dim_xu_xy(av) )
1408	CALL handle_netcdf_error( 'netcdf', 388 )
1409
1410	nc_stat = NF90_DEF_VAR( id_set_xy(av), 'xu', NF90_DOUBLE, &
1411	id_dim_xu_xy(av), id_var_xu_xy(av) )
1412	CALL handle_netcdf_error( 'netcdf', 389 )
1413
1414	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_xu_xy(av), 'units', &
1415	'meters' )
1416	CALL handle_netcdf_error( 'netcdf', 390 )
1417
1418	!
1419	!-- Define y-axis (for scalar position)
1420	nc_stat = NF90_DEF_DIM( id_set_xy(av), 'y', ny+2, id_dim_y_xy(av) )
1421	CALL handle_netcdf_error( 'netcdf', 116 )
1422
1423	nc_stat = NF90_DEF_VAR( id_set_xy(av), 'y', NF90_DOUBLE, &
1424	id_dim_y_xy(av), id_var_y_xy(av) )
1425	CALL handle_netcdf_error( 'netcdf', 117 )
1426
1427	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_y_xy(av), 'units', &
1428	'meters' )
1429	CALL handle_netcdf_error( 'netcdf', 118 )
1430
1431	!
1432	!-- Define y-axis (for scalar position)
1433	nc_stat = NF90_DEF_DIM( id_set_xy(av), 'yv', ny+2, id_dim_yv_xy(av) )
1434	CALL handle_netcdf_error( 'netcdf', 364 )
1435
1436	nc_stat = NF90_DEF_VAR( id_set_xy(av), 'yv', NF90_DOUBLE, &
1437	id_dim_yv_xy(av), id_var_yv_xy(av) )
1438	CALL handle_netcdf_error( 'netcdf', 365 )
1439
1440	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_yv_xy(av), 'units', &
1441	'meters' )
1442	CALL handle_netcdf_error( 'netcdf', 366 )
1443
1444	!
1445	!-- In case of non-flat topography define 2d-arrays containing the height
1446	!-- informations
1447	IF ( TRIM( topography ) /= 'flat' ) THEN
1448	!
1449	!-- Define zusi = zu(nzb_s_inner)
1450	nc_stat = NF90_DEF_VAR( id_set_xy(av), 'zusi', NF90_DOUBLE, &
1451	(/ id_dim_x_xy(av), id_dim_y_xy(av) /), &
1452	id_var_zusi_xy(av) )
1453	CALL handle_netcdf_error( 'netcdf', 421 )
1454
1455	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_zusi_xy(av), &
1456	'units', 'meters' )
1457	CALL handle_netcdf_error( 'netcdf', 422 )
1458
1459	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_zusi_xy(av), &
1460	'long_name', 'zu(nzb_s_inner)' )
1461	CALL handle_netcdf_error( 'netcdf', 423 )
1462
1463	!
1464	!-- Define zwwi = zw(nzb_w_inner)
1465	nc_stat = NF90_DEF_VAR( id_set_xy(av), 'zwwi', NF90_DOUBLE, &
1466	(/ id_dim_x_xy(av), id_dim_y_xy(av) /), &
1467	id_var_zwwi_xy(av) )
1468	CALL handle_netcdf_error( 'netcdf', 424 )
1469
1470	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_zwwi_xy(av), &
1471	'units', 'meters' )
1472	CALL handle_netcdf_error( 'netcdf', 425 )
1473
1474	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_zwwi_xy(av), &
1475	'long_name', 'zw(nzb_w_inner)' )
1476	CALL handle_netcdf_error( 'netcdf', 426 )
1477
1478	ENDIF
1479
1480
1481	!
1482	!-- Define the variables
1483	var_list = ';'
1484	i = 1
1485
1486	DO WHILE ( do2d(av,i)(1:1) /= ' ' )
1487
1488	IF ( INDEX( do2d(av,i), 'xy' ) /= 0 ) THEN
1489	!
1490	!-- If there is a star in the variable name (u* or t*), it is a
1491	!-- surface variable. Define it with id_dim_zu1_xy.
1492	IF ( INDEX( do2d(av,i), '*' ) /= 0 ) THEN
1493
1494	nc_stat = NF90_DEF_VAR( id_set_xy(av), do2d(av,i), &
1495	nc_precision(1), &
1496	(/ id_dim_x_xy(av), id_dim_y_xy(av),&
1497	id_dim_zu1_xy(av), &
1498	id_dim_time_xy(av) /), &
1499	id_var_do2d(av,i) )
1500
1501	var_list = TRIM(var_list) // TRIM( do2d(av,i) ) // ';'
1502
1503	ELSE
1504
1505	!
1506	!-- Check for the grid
1507	found = .TRUE.
1508	SELECT CASE ( do2d(av,i) )
1509	!
1510	!-- Most variables are defined on the zu grid
1511	CASE ( 'e_xy', 'lpt_xy', 'p_xy', 'pc_xy', 'pr_xy', 'pt_xy',&
1512	'q_xy', 'ql_xy', 'ql_c_xy', 'ql_v_xy', 'ql_vp_xy', &
1513	'qv_xy', 'rho_xy', 's_xy', 'sa_xy', 'vpt_xy' )
1514
1515	grid_x = 'x'
1516	grid_y = 'y'
1517	grid_z = 'zu'
1518	!
1519	!-- u grid
1520	CASE ( 'u_xy' )
1521
1522	grid_x = 'xu'
1523	grid_y = 'y'
1524	grid_z = 'zu'
1525	!
1526	!-- v grid
1527	CASE ( 'v_xy' )
1528
1529	grid_x = 'x'
1530	grid_y = 'yv'
1531	grid_z = 'zu'
1532	!
1533	!-- w grid
1534	CASE ( 'w_xy' )
1535
1536	grid_x = 'x'
1537	grid_y = 'y'
1538	grid_z = 'zw'
1539
1540	CASE DEFAULT
1541	!
1542	!-- Check for user-defined quantities
1543	CALL user_define_netcdf_grid( do2d(av,i), found, &
1544	grid_x, grid_y, grid_z )
1545
1546	END SELECT
1547
1548	!
1549	!-- Select the respective dimension ids
1550	IF ( grid_x == 'x' ) THEN
1551	id_x = id_dim_x_xy(av)
1552	ELSEIF ( grid_x == 'xu' ) THEN
1553	id_x = id_dim_xu_xy(av)
1554	ENDIF
1555
1556	IF ( grid_y == 'y' ) THEN
1557	id_y = id_dim_y_xy(av)
1558	ELSEIF ( grid_y == 'yv' ) THEN
1559	id_y = id_dim_yv_xy(av)
1560	ENDIF
1561
1562	IF ( grid_z == 'zu' ) THEN
1563	id_z = id_dim_zu_xy(av)
1564	ELSEIF ( grid_z == 'zw' ) THEN
1565	id_z = id_dim_zw_xy(av)
1566	ENDIF
1567
1568	!
1569	!-- Define the grid
1570	nc_stat = NF90_DEF_VAR( id_set_xy(av), do2d(av,i), &
1571	nc_precision(1), &
1572	(/ id_x, id_y, id_z, id_dim_time_xy(av) /), &
1573	id_var_do2d(av,i) )
1574
1575	IF ( .NOT. found ) THEN
1576	WRITE ( message_string, * ) 'no grid defined for', &
1577	' variable ', TRIM( do2d(av,i) )
1578	CALL message( 'define_netcdf_header', 'PA0244',&
1579	0, 1, 0, 6, 0 )
1580	ENDIF
1581
1582	var_list = TRIM( var_list ) // TRIM( do2d(av,i) ) // ';'
1583
1584	ENDIF
1585
1586	CALL handle_netcdf_error( 'netcdf', 119 )
1587	!
1588	!-- Store the 'real' name of the variable (with *, for example)
1589	!-- in the long_name attribute. This is evaluated by Ferret,
1590	!-- for example.
1591	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_do2d(av,i), &
1592	'long_name', do2d(av,i) )
1593	CALL handle_netcdf_error( 'netcdf', 120 )
1594	!
1595	!-- Define the variable's unit
1596	nc_stat = NF90_PUT_ATT( id_set_xy(av), id_var_do2d(av,i), &
1597	'units', TRIM( do2d_unit(av,i) ) )
1598	CALL handle_netcdf_error( 'netcdf', 354 )
1599	#if defined( __netcdf4 )
1600	!
1601	!-- Set collective io operations for parallel io
1602	IF ( netcdf_data_format > 2 ) THEN
1603	nc_stat = NF90_VAR_PAR_ACCESS( id_set_xy(av), &
1604	id_var_do2d(av,i), &
1605	NF90_COLLECTIVE )
1606	CALL handle_netcdf_error( 'netcdf', 448 )
1607	ENDIF
1608	#endif
1609	ENDIF
1610
1611	i = i + 1
1612
1613	ENDDO
1614
1615	!
1616	!-- No arrays to output. Close the netcdf file and return.
1617	IF ( i == 1 ) RETURN
1618
1619	!
1620	!-- Write the list of variables as global attribute (this is used by
1621	!-- restart runs and by combine_plot_fields)
1622	nc_stat = NF90_PUT_ATT( id_set_xy(av), NF90_GLOBAL, 'VAR_LIST', &
1623	var_list )
1624	CALL handle_netcdf_error( 'netcdf', 121 )
1625
1626	!
1627	!-- Leave NetCDF define mode
1628	nc_stat = NF90_ENDDEF( id_set_xy(av) )
1629	CALL handle_netcdf_error( 'netcdf', 122 )
1630
1631	!
1632	!-- Write axis data: z_xy, x, y
1633	ALLOCATE( netcdf_data(1:ns) )
1634
1635	!
1636	!-- Write zu data
1637	DO i = 1, ns
1638	IF( section(i,1) == -1 ) THEN
1639	netcdf_data(i) = -1.0 ! section averaged along z
1640	ELSE
1641	netcdf_data(i) = zu( section(i,1) )
1642	ENDIF
1643	ENDDO
1644	nc_stat = NF90_PUT_VAR( id_set_xy(av), id_var_zu_xy(av), &
1645	netcdf_data, start = (/ 1 /), &
1646	count = (/ ns /) )
1647	CALL handle_netcdf_error( 'netcdf', 123 )
1648
1649	!
1650	!-- Write zw data
1651	DO i = 1, ns
1652	IF( section(i,1) == -1 ) THEN
1653	netcdf_data(i) = -1.0 ! section averaged along z
1654	ELSE
1655	netcdf_data(i) = zw( section(i,1) )
1656	ENDIF
1657	ENDDO
1658	nc_stat = NF90_PUT_VAR( id_set_xy(av), id_var_zw_xy(av), &
1659	netcdf_data, start = (/ 1 /), &
1660	count = (/ ns /) )
1661	CALL handle_netcdf_error( 'netcdf', 124 )
1662
1663	!
1664	!-- Write gridpoint number data
1665	netcdf_data(1:ns) = section(1:ns,1)
1666	nc_stat = NF90_PUT_VAR( id_set_xy(av), id_var_ind_z_xy(av), &
1667	netcdf_data, start = (/ 1 /), &
1668	count = (/ ns /) )
1669	CALL handle_netcdf_error( 'netcdf', 125 )
1670
1671	DEALLOCATE( netcdf_data )
1672
1673	!
1674	!-- Write the cross section height u, t
1675	nc_stat = NF90_PUT_VAR( id_set_xy(av), id_var_zu1_xy(av), &
1676	(/ zu(nzb+1) /), start = (/ 1 /), &
1677	count = (/ 1 /) )
1678	CALL handle_netcdf_error( 'netcdf', 126 )
1679
1680	!
1681	!-- Write data for x (shifted by +dx/2) and xu axis
1682	ALLOCATE( netcdf_data(0:nx+1) )
1683
1684	DO i = 0, nx+1
1685	netcdf_data(i) = ( i + 0.5 ) * dx
1686	ENDDO
1687
1688	nc_stat = NF90_PUT_VAR( id_set_xy(av), id_var_x_xy(av), netcdf_data, &
1689	start = (/ 1 /), count = (/ nx+2 /) )
1690	CALL handle_netcdf_error( 'netcdf', 127 )
1691
1692	DO i = 0, nx+1
1693	netcdf_data(i) = i * dx
1694	ENDDO
1695
1696	nc_stat = NF90_PUT_VAR( id_set_xy(av), id_var_xu_xy(av), &
1697	netcdf_data, start = (/ 1 /), &
1698	count = (/ nx+2 /) )
1699	CALL handle_netcdf_error( 'netcdf', 367 )
1700
1701	DEALLOCATE( netcdf_data )
1702
1703	!
1704	!-- Write data for y (shifted by +dy/2) and yv axis
1705	ALLOCATE( netcdf_data(0:ny+1) )
1706
1707	DO i = 0, ny+1
1708	netcdf_data(i) = ( i + 0.5 ) * dy
1709	ENDDO
1710
1711	nc_stat = NF90_PUT_VAR( id_set_xy(av), id_var_y_xy(av), netcdf_data, &
1712	start = (/ 1 /), count = (/ ny+2 /))
1713	CALL handle_netcdf_error( 'netcdf', 128 )
1714
1715	DO i = 0, ny+1
1716	netcdf_data(i) = i * dy
1717	ENDDO
1718
1719	nc_stat = NF90_PUT_VAR( id_set_xy(av), id_var_yv_xy(av), &
1720	netcdf_data, start = (/ 1 /), &
1721	count = (/ ny+2 /))
1722	CALL handle_netcdf_error( 'netcdf', 368 )
1723
1724	DEALLOCATE( netcdf_data )
1725
1726	!
1727	!-- In case of non-flat topography write height information
1728	IF ( TRIM( topography ) /= 'flat' ) THEN
1729
1730	nc_stat = NF90_PUT_VAR( id_set_xy(av), id_var_zusi_xy(av), &
1731	zu_s_inner(0:nx+1,0:ny+1), &
1732	start = (/ 1, 1 /), &
1733	count = (/ nx+2, ny+2 /) )
1734	CALL handle_netcdf_error( 'netcdf', 427 )
1735
1736	nc_stat = NF90_PUT_VAR( id_set_xy(av), id_var_zwwi_xy(av), &
1737	zw_w_inner(0:nx+1,0:ny+1), &
1738	start = (/ 1, 1 /), &
1739	count = (/ nx+2, ny+2 /) )
1740	CALL handle_netcdf_error( 'netcdf', 428 )
1741
1742	ENDIF
1743
1744
1745	CASE ( 'xy_ext' )
1746
1747	!
1748	!-- Get the list of variables and compare with the actual run.
1749	!-- First var_list_old has to be reset, since GET_ATT does not assign
1750	!-- trailing blanks.
1751	var_list_old = ' '
1752	nc_stat = NF90_GET_ATT( id_set_xy(av), NF90_GLOBAL, 'VAR_LIST', &
1753	var_list_old )
1754	CALL handle_netcdf_error( 'netcdf', 129 )
1755
1756	var_list = ';'
1757	i = 1
1758	DO WHILE ( do2d(av,i)(1:1) /= ' ' )
1759	IF ( INDEX( do2d(av,i), 'xy' ) /= 0 ) THEN
1760	var_list = TRIM( var_list ) // TRIM( do2d(av,i) ) // ';'
1761	ENDIF
1762	i = i + 1
1763	ENDDO
1764
1765	IF ( av == 0 ) THEN
1766	var = '(xy)'
1767	ELSE
1768	var = '(xy_av)'
1769	ENDIF
1770
1771	IF ( TRIM( var_list ) /= TRIM( var_list_old ) ) THEN
1772	message_string = 'NetCDF file for cross-sections ' // &
1773	TRIM( var ) // ' from previous run found,' // &
1774	'& but this file cannot be extended due to' // &
1775	' variable mismatch.' // &
1776	'&New file is created instead.'
1777	CALL message( 'define_netcdf_header', 'PA0249', 0, 1, 0, 6, 0 )
1778	extend = .FALSE.
1779	RETURN
1780	ENDIF
1781
1782	!
1783	!-- Calculate the number of current sections
1784	ns = 1
1785	DO WHILE ( section(ns,1) /= -9999 .AND. ns <= 100 )
1786	ns = ns + 1
1787	ENDDO
1788	ns = ns - 1
1789
1790	!
1791	!-- Get and compare the number of horizontal cross sections
1792	nc_stat = NF90_INQ_VARID( id_set_xy(av), 'zu_xy', id_var_zu_xy(av) )
1793	CALL handle_netcdf_error( 'netcdf', 130 )
1794
1795	nc_stat = NF90_INQUIRE_VARIABLE( id_set_xy(av), id_var_zu_xy(av), &
1796	dimids = id_dim_zu_xy_old )
1797	CALL handle_netcdf_error( 'netcdf', 131 )
1798	id_dim_zu_xy(av) = id_dim_zu_xy_old(1)
1799
1800	nc_stat = NF90_INQUIRE_DIMENSION( id_set_xy(av), id_dim_zu_xy(av), &
1801	len = ns_old )
1802	CALL handle_netcdf_error( 'netcdf', 132 )
1803
1804	IF ( ns /= ns_old ) THEN
1805	message_string = 'NetCDF file for cross-sections ' // &
1806	TRIM( var ) // ' from previous run found,' // &
1807	'&but this file cannot be extended due to' // &
1808	' mismatch in number of' // &
1809	'&cross sections.' // &
1810	'&New file is created instead.'
1811	CALL message( 'define_netcdf_header', 'PA0250', 0, 1, 0, 6, 0 )
1812	extend = .FALSE.
1813	RETURN
1814	ENDIF
1815
1816	!
1817	!-- Get and compare the heights of the cross sections
1818	ALLOCATE( netcdf_data(1:ns_old) )
1819
1820	nc_stat = NF90_GET_VAR( id_set_xy(av), id_var_zu_xy(av), netcdf_data )
1821	CALL handle_netcdf_error( 'netcdf', 133 )
1822
1823	DO i = 1, ns
1824	IF ( section(i,1) /= -1 ) THEN
1825	IF ( zu(section(i,1)) /= netcdf_data(i) ) THEN
1826	message_string = 'NetCDF file for cross-sections ' // &
1827	TRIM( var ) // ' from previous run found,' // &
1828	'&but this file cannot be extended' // &
1829	' due to mismatch in cross' // &
1830	'&section levels.' // &
1831	'&New file is created instead.'
1832	CALL message( 'define_netcdf_header', 'PA0251', &
1833	0, 1, 0, 6, 0 )
1834	extend = .FALSE.
1835	RETURN
1836	ENDIF
1837	ELSE
1838	IF ( -1.0 /= netcdf_data(i) ) THEN
1839	message_string = 'NetCDF file for cross-sections ' // &
1840	TRIM( var ) // ' from previous run found,' // &
1841	'&but this file cannot be extended' // &
1842	' due to mismatch in cross' // &
1843	'&section levels.' // &
1844	'&New file is created instead.'
1845	CALL message( 'define_netcdf_header', 'PA0251',&
1846	0, 1, 0, 6, 0 )
1847	extend = .FALSE.
1848	RETURN
1849	ENDIF
1850	ENDIF
1851	ENDDO
1852
1853	DEALLOCATE( netcdf_data )
1854
1855	!
1856	!-- Get the id of the time coordinate (unlimited coordinate) and its
1857	!-- last index on the file. The next time level is do2d..count+1.
1858	!-- The current time must be larger than the last output time
1859	!-- on the file.
1860	nc_stat = NF90_INQ_VARID( id_set_xy(av), 'time', id_var_time_xy(av) )
1861	CALL handle_netcdf_error( 'netcdf', 134 )
1862
1863	nc_stat = NF90_INQUIRE_VARIABLE( id_set_xy(av), id_var_time_xy(av), &
1864	dimids = id_dim_time_old )
1865	CALL handle_netcdf_error( 'netcdf', 135 )
1866	id_dim_time_xy(av) = id_dim_time_old(1)
1867
1868	nc_stat = NF90_INQUIRE_DIMENSION( id_set_xy(av), id_dim_time_xy(av), &
1869	len = do2d_xy_time_count(av) )
1870	CALL handle_netcdf_error( 'netcdf', 136 )
1871
1872	nc_stat = NF90_GET_VAR( id_set_xy(av), id_var_time_xy(av), &
1873	last_time_coordinate, &
1874	start = (/ do2d_xy_time_count(av) /), &
1875	count = (/ 1 /) )
1876	CALL handle_netcdf_error( 'netcdf', 137 )
1877
1878	IF ( last_time_coordinate(1) >= simulated_time ) THEN
1879	message_string = 'NetCDF file for cross sections ' // &
1880	TRIM( var ) // ' from previous run found,' // &
1881	'&but this file cannot be extended becaus' // &
1882	'e the current output time' // &
1883	'&is less or equal than the last output t' // &
1884	'ime on this file.' // &
1885	'&New file is created instead.'
1886	CALL message( 'define_netcdf_header', 'PA0252', 0, 1, 0, 6, 0 )
1887	do2d_xy_time_count(av) = 0
1888	extend = .FALSE.
1889	RETURN
1890	ENDIF
1891
1892	!
1893	!-- Dataset seems to be extendable.
1894	!-- Now get the variable ids.
1895	i = 1
1896	DO WHILE ( do2d(av,i)(1:1) /= ' ' )
1897	IF ( INDEX( do2d(av,i), 'xy' ) /= 0 ) THEN
1898	nc_stat = NF90_INQ_VARID( id_set_xy(av), do2d(av,i), &
1899	id_var_do2d(av,i) )
1900	CALL handle_netcdf_error( 'netcdf', 138 )
1901	#if defined( __netcdf4 )
1902	!
1903	!-- Set collective io operations for parallel io
1904	IF ( netcdf_data_format > 2 ) THEN
1905	nc_stat = NF90_VAR_PAR_ACCESS( id_set_xy(av), &
1906	id_var_do2d(av,i), &
1907	NF90_COLLECTIVE )
1908	CALL handle_netcdf_error( 'netcdf', 454 )
1909	ENDIF
1910	#endif
1911	ENDIF
1912	i = i + 1
1913	ENDDO
1914
1915	!
1916	!-- Update the title attribute on file
1917	!-- In order to avoid 'data mode' errors if updated attributes are larger
1918	!-- than their original size, NF90_PUT_ATT is called in 'define mode'
1919	!-- enclosed by NF90_REDEF and NF90_ENDDEF calls. This implies a possible
1920	!-- performance loss due to data copying; an alternative strategy would be
1921	!-- to ensure equal attribute size in a job chain. Maybe revise later.
1922	IF ( av == 0 ) THEN
1923	time_average_text = ' '
1924	ELSE
1925	WRITE (time_average_text, '('', '',F7.1,'' s average'')') &
1926	averaging_interval
1927	ENDIF
1928	nc_stat = NF90_REDEF( id_set_xy(av) )
1929	CALL handle_netcdf_error( 'netcdf', 431 )
1930	nc_stat = NF90_PUT_ATT( id_set_xy(av), NF90_GLOBAL, 'title', &
1931	TRIM( run_description_header ) // &
1932	TRIM( time_average_text ) )
1933	CALL handle_netcdf_error( 'netcdf', 139 )
1934	nc_stat = NF90_ENDDEF( id_set_xy(av) )
1935	CALL handle_netcdf_error( 'netcdf', 432 )
1936	message_string = 'NetCDF file for cross-sections ' // &
1937	TRIM( var ) // ' from previous run found.' // &
1938	'&This file will be extended.'
1939	CALL message( 'define_netcdf_header', 'PA0253', 0, 0, 0, 6, 0 )
1940
1941
1942	CASE ( 'xz_new' )
1943
1944	!
1945	!-- Define some global attributes of the dataset
1946	nc_stat = NF90_PUT_ATT( id_set_xz(av), NF90_GLOBAL, 'Conventions', &
1947	'COARDS' )
1948	CALL handle_netcdf_error( 'netcdf', 140 )
1949
1950	IF ( av == 0 ) THEN
1951	time_average_text = ' '
1952	ELSE
1953	WRITE (time_average_text, '('', '',F7.1,'' s average'')') &
1954	averaging_interval
1955	ENDIF
1956	nc_stat = NF90_PUT_ATT( id_set_xz(av), NF90_GLOBAL, 'title', &
1957	TRIM( run_description_header ) // &
1958	TRIM( time_average_text ) )
1959	CALL handle_netcdf_error( 'netcdf', 141 )
1960	IF ( av == 1 ) THEN
1961	WRITE ( time_average_text,'(F7.1,'' s avg'')' ) averaging_interval
1962	nc_stat = NF90_PUT_ATT( id_set_xz(av), NF90_GLOBAL, 'time_avg', &
1963	TRIM( time_average_text ) )
1964	CALL handle_netcdf_error( 'netcdf', 141 )
1965	ENDIF
1966
1967	!
1968	!-- Define time coordinate for xz sections (unlimited dimension)
1969	nc_stat = NF90_DEF_DIM( id_set_xz(av), 'time', NF90_UNLIMITED, &
1970	id_dim_time_xz(av) )
1971	CALL handle_netcdf_error( 'netcdf', 142 )
1972
1973	nc_stat = NF90_DEF_VAR( id_set_xz(av), 'time', NF90_DOUBLE, &
1974	id_dim_time_xz(av), id_var_time_xz(av) )
1975	CALL handle_netcdf_error( 'netcdf', 143 )
1976
1977	nc_stat = NF90_PUT_ATT( id_set_xz(av), id_var_time_xz(av), 'units', &
1978	'seconds')
1979	CALL handle_netcdf_error( 'netcdf', 144 )
1980
1981	!
1982	!-- Define the spatial dimensions and coordinates for xz-sections.
1983	!-- First, determine the number of vertical sections to be written.
1984	IF ( section(1,2) == -9999 ) THEN
1985	RETURN
1986	ELSE
1987	ns = 1
1988	DO WHILE ( section(ns,2) /= -9999 .AND. ns <= 100 )
1989	ns = ns + 1
1990	ENDDO
1991	ns = ns - 1
1992	ENDIF
1993
1994	!
1995	!-- Define y-axis (for scalar position)
1996	nc_stat = NF90_DEF_DIM( id_set_xz(av), 'y_xz', ns, id_dim_y_xz(av) )
1997	CALL handle_netcdf_error( 'netcdf', 145 )
1998
1999	nc_stat = NF90_DEF_VAR( id_set_xz(av), 'y_xz', NF90_DOUBLE, &
2000	id_dim_y_xz(av), id_var_y_xz(av) )
2001	CALL handle_netcdf_error( 'netcdf', 146 )
2002
2003	nc_stat = NF90_PUT_ATT( id_set_xz(av), id_var_y_xz(av), 'units', &
2004	'meters' )
2005	CALL handle_netcdf_error( 'netcdf', 147 )
2006
2007	!
2008	!-- Define y-axis (for v position)
2009	nc_stat = NF90_DEF_DIM( id_set_xz(av), 'yv_xz', ns, id_dim_yv_xz(av) )
2010	CALL handle_netcdf_error( 'netcdf', 369 )
2011
2012	nc_stat = NF90_DEF_VAR( id_set_xz(av), 'yv_xz', NF90_DOUBLE, &
2013	id_dim_yv_xz(av), id_var_yv_xz(av) )
2014	CALL handle_netcdf_error( 'netcdf', 370 )
2015
2016	nc_stat = NF90_PUT_ATT( id_set_xz(av), id_var_yv_xz(av), 'units', &
2017	'meters' )
2018	CALL handle_netcdf_error( 'netcdf', 371 )
2019
2020	!
2021	!-- Define a variable to store the layer indices of the vertical cross
2022	!-- sections
2023	nc_stat = NF90_DEF_VAR( id_set_xz(av), 'ind_y_xz', NF90_DOUBLE, &
2024	id_dim_y_xz(av), id_var_ind_y_xz(av) )
2025	CALL handle_netcdf_error( 'netcdf', 148 )
2026
2027	nc_stat = NF90_PUT_ATT( id_set_xz(av), id_var_ind_y_xz(av), 'units', &
2028	'gridpoints')
2029	CALL handle_netcdf_error( 'netcdf', 149 )
2030
2031	!
2032	!-- Define x-axis (for scalar position)
2033	nc_stat = NF90_DEF_DIM( id_set_xz(av), 'x', nx+2, id_dim_x_xz(av) )
2034	CALL handle_netcdf_error( 'netcdf', 150 )
2035
2036	nc_stat = NF90_DEF_VAR( id_set_xz(av), 'x', NF90_DOUBLE, &
2037	id_dim_x_xz(av), id_var_x_xz(av) )
2038	CALL handle_netcdf_error( 'netcdf', 151 )
2039
2040	nc_stat = NF90_PUT_ATT( id_set_xz(av), id_var_x_xz(av), 'units', &
2041	'meters' )
2042	CALL handle_netcdf_error( 'netcdf', 152 )
2043
2044	!
2045	!-- Define x-axis (for u position)
2046	nc_stat = NF90_DEF_DIM( id_set_xz(av), 'xu', nx+2, id_dim_xu_xz(av) )
2047	CALL handle_netcdf_error( 'netcdf', 372 )
2048
2049	nc_stat = NF90_DEF_VAR( id_set_xz(av), 'xu', NF90_DOUBLE, &
2050	id_dim_xu_xz(av), id_var_xu_xz(av) )
2051	CALL handle_netcdf_error( 'netcdf', 373 )
2052
2053	nc_stat = NF90_PUT_ATT( id_set_xz(av), id_var_xu_xz(av), 'units', &
2054	'meters' )
2055	CALL handle_netcdf_error( 'netcdf', 374 )
2056
2057	!
2058	!-- Define the two z-axes (zu and zw)
2059	nc_stat = NF90_DEF_DIM( id_set_xz(av), 'zu', nz+2, id_dim_zu_xz(av) )
2060	CALL handle_netcdf_error( 'netcdf', 153 )
2061
2062	nc_stat = NF90_DEF_VAR( id_set_xz(av), 'zu', NF90_DOUBLE, &
2063	id_dim_zu_xz(av), id_var_zu_xz(av) )
2064	CALL handle_netcdf_error( 'netcdf', 154 )
2065
2066	nc_stat = NF90_PUT_ATT( id_set_xz(av), id_var_zu_xz(av), 'units', &
2067	'meters' )
2068	CALL handle_netcdf_error( 'netcdf', 155 )
2069
2070	nc_stat = NF90_DEF_DIM( id_set_xz(av), 'zw', nz+2, id_dim_zw_xz(av) )
2071	CALL handle_netcdf_error( 'netcdf', 156 )
2072
2073	nc_stat = NF90_DEF_VAR( id_set_xz(av), 'zw', NF90_DOUBLE, &
2074	id_dim_zw_xz(av), id_var_zw_xz(av) )
2075	CALL handle_netcdf_error( 'netcdf', 157 )
2076
2077	nc_stat = NF90_PUT_ATT( id_set_xz(av), id_var_zw_xz(av), 'units', &
2078	'meters' )
2079	CALL handle_netcdf_error( 'netcdf', 158 )
2080
2081
2082	!
2083	!-- Define the variables
2084	var_list = ';'
2085	i = 1
2086
2087	DO WHILE ( do2d(av,i)(1:1) /= ' ' )
2088
2089	IF ( INDEX( do2d(av,i), 'xz' ) /= 0 ) THEN
2090
2091	!
2092	!-- Check for the grid
2093	found = .TRUE.
2094	SELECT CASE ( do2d(av,i) )
2095	!
2096	!-- Most variables are defined on the zu grid
2097	CASE ( 'e_xz', 'lpt_xz', 'p_xz', 'pc_xz', 'pr_xz', 'pt_xz', &
2098	'q_xz', 'ql_xz', 'ql_c_xz', 'ql_v_xz', 'ql_vp_xz', &
2099	'qv_xz', 'rho_xz', 's_xz', 'sa_xz', 'vpt_xz' )
2100
2101	grid_x = 'x'
2102	grid_y = 'y'
2103	grid_z = 'zu'
2104	!
2105	!-- u grid
2106	CASE ( 'u_xz' )
2107
2108	grid_x = 'xu'
2109	grid_y = 'y'
2110	grid_z = 'zu'
2111	!
2112	!-- v grid
2113	CASE ( 'v_xz' )
2114
2115	grid_x = 'x'
2116	grid_y = 'yv'
2117	grid_z = 'zu'
2118	!
2119	!-- w grid
2120	CASE ( 'w_xz' )
2121
2122	grid_x = 'x'
2123	grid_y = 'y'
2124	grid_z = 'zw'
2125
2126	CASE DEFAULT
2127	!
2128	!-- Check for user-defined quantities
2129	CALL user_define_netcdf_grid( do2d(av,i), found, &
2130	grid_x, grid_y, grid_z )
2131
2132	END SELECT
2133
2134	!
2135	!-- Select the respective dimension ids
2136	IF ( grid_x == 'x' ) THEN
2137	id_x = id_dim_x_xz(av)
2138	ELSEIF ( grid_x == 'xu' ) THEN
2139	id_x = id_dim_xu_xz(av)
2140	ENDIF
2141
2142	IF ( grid_y == 'y' ) THEN
2143	id_y = id_dim_y_xz(av)
2144	ELSEIF ( grid_y == 'yv' ) THEN
2145	id_y = id_dim_yv_xz(av)
2146	ENDIF
2147
2148	IF ( grid_z == 'zu' ) THEN
2149	id_z = id_dim_zu_xz(av)
2150	ELSEIF ( grid_z == 'zw' ) THEN
2151	id_z = id_dim_zw_xz(av)
2152	ENDIF
2153
2154	!
2155	!-- Define the grid
2156	nc_stat = NF90_DEF_VAR( id_set_xz(av), do2d(av,i), &
2157	nc_precision(2), &
2158	(/ id_x, id_y, id_z, id_dim_time_xz(av) /), &
2159	id_var_do2d(av,i) )
2160
2161	IF ( .NOT. found ) THEN
2162	WRITE ( message_string, * ) 'no grid defined for', &
2163	' variable ', TRIM( do2d(av,i) )
2164	CALL message( 'define_netcdf_header', 'PA0244',&
2165	0, 1, 0, 6, 0 )
2166	ENDIF
2167
2168	var_list = TRIM( var_list ) // TRIM( do2d(av,i) ) // ';'
2169
2170	CALL handle_netcdf_error( 'netcdf', 159 )
2171	!
2172	!-- Store the 'real' name of the variable (with *, for example)
2173	!-- in the long_name attribute. This is evaluated by Ferret,
2174	!-- for example.
2175	nc_stat = NF90_PUT_ATT( id_set_xz(av), id_var_do2d(av,i), &
2176	'long_name', do2d(av,i) )
2177	CALL handle_netcdf_error( 'netcdf', 160 )
2178	!
2179	!-- Define the variable's unit
2180	nc_stat = NF90_PUT_ATT( id_set_xz(av), id_var_do2d(av,i), &
2181	'units', TRIM( do2d_unit(av,i) ) )
2182	CALL handle_netcdf_error( 'netcdf', 355 )
2183	#if defined( __netcdf4 )
2184	!
2185	!-- Set independent io operations for parallel io. Collective io
2186	!-- is only allowed in case of a 1d-decomposition along x, because
2187	!-- otherwise, not all PEs have output data.
2188	IF ( netcdf_data_format > 2 ) THEN
2189	IF ( npey == 1 ) THEN
2190	nc_stat = NF90_VAR_PAR_ACCESS( id_set_xz(av), &
2191	id_var_do2d(av,i), &
2192	NF90_COLLECTIVE )
2193	ELSE
2194	!
2195	!-- ATTENTION: Due to a probable bug in the NetCDF4
2196	!-- installation, independet output does not work
2197	!-- A workaround is used in data_output_2d on those
2198	!-- PEs having no data
2199	nc_stat = NF90_VAR_PAR_ACCESS( id_set_xz(av), &
2200	id_var_do2d(av,i), &
2201	NF90_COLLECTIVE )
2202	! nc_stat = NF90_VAR_PAR_ACCESS( id_set_xz(av), &
2203	! id_var_do2d(av,i), &
2204	! NF90_INDEPENDENT )
2205	ENDIF
2206	CALL handle_netcdf_error( 'netcdf', 449 )
2207	ENDIF
2208	#endif
2209	ENDIF
2210
2211	i = i + 1
2212
2213	ENDDO
2214
2215	!
2216	!-- No arrays to output. Close the netcdf file and return.
2217	IF ( i == 1 ) RETURN
2218
2219	!
2220	!-- Write the list of variables as global attribute (this is used by
2221	!-- restart runs and by combine_plot_fields)
2222	nc_stat = NF90_PUT_ATT( id_set_xz(av), NF90_GLOBAL, 'VAR_LIST', &
2223	var_list )
2224	CALL handle_netcdf_error( 'netcdf', 161 )
2225
2226	!
2227	!-- Leave NetCDF define mode
2228	nc_stat = NF90_ENDDEF( id_set_xz(av) )
2229	CALL handle_netcdf_error( 'netcdf', 162 )
2230
2231	!
2232	!-- Write axis data: y_xz, x, zu, zw
2233	ALLOCATE( netcdf_data(1:ns) )
2234
2235	!
2236	!-- Write y_xz data (shifted by +dy/2)
2237	DO i = 1, ns
2238	IF( section(i,2) == -1 ) THEN
2239	netcdf_data(i) = -1.0 ! section averaged along y
2240	ELSE
2241	netcdf_data(i) = ( section(i,2) + 0.5 ) * dy
2242	ENDIF
2243	ENDDO
2244	nc_stat = NF90_PUT_VAR( id_set_xz(av), id_var_y_xz(av), netcdf_data, &
2245	start = (/ 1 /), count = (/ ns /) )
2246	CALL handle_netcdf_error( 'netcdf', 163 )
2247
2248	!
2249	!-- Write yv_xz data
2250	DO i = 1, ns
2251	IF( section(i,2) == -1 ) THEN
2252	netcdf_data(i) = -1.0 ! section averaged along y
2253	ELSE
2254	netcdf_data(i) = section(i,2) * dy
2255	ENDIF
2256	ENDDO
2257	nc_stat = NF90_PUT_VAR( id_set_xz(av), id_var_yv_xz(av), &
2258	netcdf_data, start = (/ 1 /), &
2259	count = (/ ns /) )
2260	CALL handle_netcdf_error( 'netcdf', 375 )
2261
2262	!
2263	!-- Write gridpoint number data
2264	netcdf_data(1:ns) = section(1:ns,2)
2265	nc_stat = NF90_PUT_VAR( id_set_xz(av), id_var_ind_y_xz(av), &
2266	netcdf_data, start = (/ 1 /), &
2267	count = (/ ns /) )
2268	CALL handle_netcdf_error( 'netcdf', 164 )
2269
2270
2271	DEALLOCATE( netcdf_data )
2272
2273	!
2274	!-- Write data for x (shifted by +dx/2) and xu axis
2275	ALLOCATE( netcdf_data(0:nx+1) )
2276
2277	DO i = 0, nx+1
2278	netcdf_data(i) = ( i + 0.5 ) * dx
2279	ENDDO
2280
2281	nc_stat = NF90_PUT_VAR( id_set_xz(av), id_var_x_xz(av), netcdf_data, &
2282	start = (/ 1 /), count = (/ nx+2 /) )
2283	CALL handle_netcdf_error( 'netcdf', 165 )
2284
2285	DO i = 0, nx+1
2286	netcdf_data(i) = i * dx
2287	ENDDO
2288
2289	nc_stat = NF90_PUT_VAR( id_set_xz(av), id_var_xu_xz(av), &
2290	netcdf_data, start = (/ 1 /), &
2291	count = (/ nx+2 /) )
2292	CALL handle_netcdf_error( 'netcdf', 377 )
2293
2294	DEALLOCATE( netcdf_data )
2295
2296	!
2297	!-- Write zu and zw data (vertical axes)
2298	ALLOCATE( netcdf_data(0:nz+1) )
2299
2300	netcdf_data(0:nz+1) = zu(nzb:nzt+1)
2301	nc_stat = NF90_PUT_VAR( id_set_xz(av), id_var_zu_xz(av), &
2302	netcdf_data, start = (/ 1 /), &
2303	count = (/ nz+2 /) )
2304	CALL handle_netcdf_error( 'netcdf', 166 )
2305
2306	netcdf_data(0:nz+1) = zw(nzb:nzt+1)
2307	nc_stat = NF90_PUT_VAR( id_set_xz(av), id_var_zw_xz(av), &
2308	netcdf_data, start = (/ 1 /), &
2309	count = (/ nz+2 /) )
2310	CALL handle_netcdf_error( 'netcdf', 167 )
2311
2312	DEALLOCATE( netcdf_data )
2313
2314
2315	CASE ( 'xz_ext' )
2316
2317	!
2318	!-- Get the list of variables and compare with the actual run.
2319	!-- First var_list_old has to be reset, since GET_ATT does not assign
2320	!-- trailing blanks.
2321	var_list_old = ' '
2322	nc_stat = NF90_GET_ATT( id_set_xz(av), NF90_GLOBAL, 'VAR_LIST', &
2323	var_list_old )
2324	CALL handle_netcdf_error( 'netcdf', 168 )
2325
2326	var_list = ';'
2327	i = 1
2328	DO WHILE ( do2d(av,i)(1:1) /= ' ' )
2329	IF ( INDEX( do2d(av,i), 'xz' ) /= 0 ) THEN
2330	var_list = TRIM( var_list ) // TRIM( do2d(av,i) ) // ';'
2331	ENDIF
2332	i = i + 1
2333	ENDDO
2334
2335	IF ( av == 0 ) THEN
2336	var = '(xz)'
2337	ELSE
2338	var = '(xz_av)'
2339	ENDIF
2340
2341	IF ( TRIM( var_list ) /= TRIM( var_list_old ) ) THEN
2342	message_string = 'NetCDF file for cross-sections ' // &
2343	TRIM( var ) // ' from previous run found,' // &
2344	'& but this file cannot be extended due to' // &
2345	' variable mismatch.' // &
2346	'&New file is created instead.'
2347	CALL message( 'define_netcdf_header', 'PA0249', 0, 1, 0, 6, 0 )
2348	extend = .FALSE.
2349	RETURN
2350	ENDIF
2351
2352	!
2353	!-- Calculate the number of current sections
2354	ns = 1
2355	DO WHILE ( section(ns,2) /= -9999 .AND. ns <= 100 )
2356	ns = ns + 1
2357	ENDDO
2358	ns = ns - 1
2359
2360	!
2361	!-- Get and compare the number of vertical cross sections
2362	nc_stat = NF90_INQ_VARID( id_set_xz(av), 'y_xz', id_var_y_xz(av) )
2363	CALL handle_netcdf_error( 'netcdf', 169 )
2364
2365	nc_stat = NF90_INQUIRE_VARIABLE( id_set_xz(av), id_var_y_xz(av), &
2366	dimids = id_dim_y_xz_old )
2367	CALL handle_netcdf_error( 'netcdf', 170 )
2368	id_dim_y_xz(av) = id_dim_y_xz_old(1)
2369
2370	nc_stat = NF90_INQUIRE_DIMENSION( id_set_xz(av), id_dim_y_xz(av), &
2371	len = ns_old )
2372	CALL handle_netcdf_error( 'netcdf', 171 )
2373
2374	IF ( ns /= ns_old ) THEN
2375	message_string = 'NetCDF file for cross-sections ' // &
2376	TRIM( var ) // ' from previous run found,' // &
2377	'&but this file cannot be extended due to' // &
2378	' mismatch in number of' // &
2379	'&cross sections.' // &
2380	'&New file is created instead.'
2381	CALL message( 'define_netcdf_header', 'PA0250', 0, 1, 0, 6, 0 )
2382	extend = .FALSE.
2383	RETURN
2384	ENDIF
2385
2386	!
2387	!-- Get and compare the heights of the cross sections
2388	ALLOCATE( netcdf_data(1:ns_old) )
2389
2390	nc_stat = NF90_GET_VAR( id_set_xz(av), id_var_y_xz(av), netcdf_data )
2391	CALL handle_netcdf_error( 'netcdf', 172 )
2392
2393	DO i = 1, ns
2394	IF ( section(i,2) /= -1 ) THEN
2395	IF ( ( ( section(i,2) + 0.5 ) * dy ) /= netcdf_data(i) ) THEN
2396	message_string = 'NetCDF file for cross-sections ' // &
2397	TRIM( var ) // ' from previous run found,' // &
2398	'&but this file cannot be extended' // &
2399	' due to mismatch in cross' // &
2400	'&section levels.' // &
2401	'&New file is created instead.'
2402	CALL message( 'define_netcdf_header', 'PA0251', &
2403	0, 1, 0, 6, 0 )
2404	extend = .FALSE.
2405	RETURN
2406	ENDIF
2407	ELSE
2408	IF ( -1.0 /= netcdf_data(i) ) THEN
2409	message_string = 'NetCDF file for cross-sections ' // &
2410	TRIM( var ) // ' from previous run found,' // &
2411	'&but this file cannot be extended' // &
2412	' due to mismatch in cross' // &
2413	'&section levels.' // &
2414	'&New file is created instead.'
2415	CALL message( 'define_netcdf_header', 'PA0251', &
2416	0, 1, 0, 6, 0 )
2417	extend = .FALSE.
2418	RETURN
2419	ENDIF
2420	ENDIF
2421	ENDDO
2422
2423	DEALLOCATE( netcdf_data )
2424
2425	!
2426	!-- Get the id of the time coordinate (unlimited coordinate) and its
2427	!-- last index on the file. The next time level is do2d..count+1.
2428	!-- The current time must be larger than the last output time
2429	!-- on the file.
2430	nc_stat = NF90_INQ_VARID( id_set_xz(av), 'time', id_var_time_xz(av) )
2431	CALL handle_netcdf_error( 'netcdf', 173 )
2432
2433	nc_stat = NF90_INQUIRE_VARIABLE( id_set_xz(av), id_var_time_xz(av), &
2434	dimids = id_dim_time_old )
2435	CALL handle_netcdf_error( 'netcdf', 174 )
2436	id_dim_time_xz(av) = id_dim_time_old(1)
2437
2438	nc_stat = NF90_INQUIRE_DIMENSION( id_set_xz(av), id_dim_time_xz(av), &
2439	len = do2d_xz_time_count(av) )
2440	CALL handle_netcdf_error( 'netcdf', 175 )
2441
2442	nc_stat = NF90_GET_VAR( id_set_xz(av), id_var_time_xz(av), &
2443	last_time_coordinate, &
2444	start = (/ do2d_xz_time_count(av) /), &
2445	count = (/ 1 /) )
2446	CALL handle_netcdf_error( 'netcdf', 176 )
2447
2448	IF ( last_time_coordinate(1) >= simulated_time ) THEN
2449	message_string = 'NetCDF file for cross sections ' // &
2450	TRIM( var ) // ' from previous run found,' // &
2451	'&but this file cannot be extended becaus' // &
2452	'e the current output time' // &
2453	'&is less or equal than the last output t' // &
2454	'ime on this file.' // &
2455	'&New file is created instead.'
2456	CALL message( 'define_netcdf_header', 'PA0252', 0, 1, 0, 6, 0 )
2457	do2d_xz_time_count(av) = 0
2458	extend = .FALSE.
2459	RETURN
2460	ENDIF
2461
2462	!
2463	!-- Dataset seems to be extendable.
2464	!-- Now get the variable ids.
2465	i = 1
2466	DO WHILE ( do2d(av,i)(1:1) /= ' ' )
2467	IF ( INDEX( do2d(av,i), 'xz' ) /= 0 ) THEN
2468	nc_stat = NF90_INQ_VARID( id_set_xz(av), do2d(av,i), &
2469	id_var_do2d(av,i) )
2470	CALL handle_netcdf_error( 'netcdf', 177 )
2471	#if defined( __netcdf4 )
2472	!
2473	!-- Set independent io operations for parallel io. Collective io
2474	!-- is only allowed in case of a 1d-decomposition along x, because
2475	!-- otherwise, not all PEs have output data.
2476	IF ( netcdf_data_format > 2 ) THEN
2477	IF ( npey == 1 ) THEN
2478	nc_stat = NF90_VAR_PAR_ACCESS( id_set_xz(av), &
2479	id_var_do2d(av,i), &
2480	NF90_COLLECTIVE )
2481	ELSE
2482	!
2483	!-- ATTENTION: Due to a probable bug in the NetCDF4
2484	!-- installation, independet output does not work
2485	!-- A workaround is used in data_output_2d on those
2486	!-- PEs having no data
2487	nc_stat = NF90_VAR_PAR_ACCESS( id_set_xz(av), &
2488	id_var_do2d(av,i), &
2489	NF90_COLLECTIVE )
2490	! nc_stat = NF90_VAR_PAR_ACCESS( id_set_xz(av), &
2491	! id_var_do2d(av,i), &
2492	! NF90_INDEPENDENT )
2493	ENDIF
2494	CALL handle_netcdf_error( 'netcdf', 455 )
2495	ENDIF
2496	#endif
2497	ENDIF
2498	i = i + 1
2499	ENDDO
2500
2501	!
2502	!-- Update the title attribute on file
2503	!-- In order to avoid 'data mode' errors if updated attributes are larger
2504	!-- than their original size, NF90_PUT_ATT is called in 'define mode'
2505	!-- enclosed by NF90_REDEF and NF90_ENDDEF calls. This implies a possible
2506	!-- performance loss due to data copying; an alternative strategy would be
2507	!-- to ensure equal attribute size in a job chain. Maybe revise later.
2508	IF ( av == 0 ) THEN
2509	time_average_text = ' '
2510	ELSE
2511	WRITE (time_average_text, '('', '',F7.1,'' s average'')') &
2512	averaging_interval
2513	ENDIF
2514	nc_stat = NF90_REDEF( id_set_xz(av) )
2515	CALL handle_netcdf_error( 'netcdf', 433 )
2516	nc_stat = NF90_PUT_ATT( id_set_xz(av), NF90_GLOBAL, 'title', &
2517	TRIM( run_description_header ) // &
2518	TRIM( time_average_text ) )
2519	CALL handle_netcdf_error( 'netcdf', 178 )
2520	nc_stat = NF90_ENDDEF( id_set_xz(av) )
2521	CALL handle_netcdf_error( 'netcdf', 434 )
2522	message_string = 'NetCDF file for cross-sections ' // &
2523	TRIM( var ) // ' from previous run found.' // &
2524	'&This file will be extended.'
2525	CALL message( 'define_netcdf_header', 'PA0253', 0, 0, 0, 6, 0 )
2526
2527
2528	CASE ( 'yz_new' )
2529
2530	!
2531	!-- Define some global attributes of the dataset
2532	nc_stat = NF90_PUT_ATT( id_set_yz(av), NF90_GLOBAL, 'Conventions', &
2533	'COARDS' )
2534	CALL handle_netcdf_error( 'netcdf', 179 )
2535
2536	IF ( av == 0 ) THEN
2537	time_average_text = ' '
2538	ELSE
2539	WRITE (time_average_text, '('', '',F7.1,'' s average'')') &
2540	averaging_interval
2541	ENDIF
2542	nc_stat = NF90_PUT_ATT( id_set_yz(av), NF90_GLOBAL, 'title', &
2543	TRIM( run_description_header ) // &
2544	TRIM( time_average_text ) )
2545	CALL handle_netcdf_error( 'netcdf', 180 )
2546	IF ( av == 1 ) THEN
2547	WRITE ( time_average_text,'(F7.1,'' s avg'')' ) averaging_interval
2548	nc_stat = NF90_PUT_ATT( id_set_yz(av), NF90_GLOBAL, 'time_avg', &
2549	TRIM( time_average_text ) )
2550	CALL handle_netcdf_error( 'netcdf', 180 )
2551	ENDIF
2552
2553	!
2554	!-- Define time coordinate for yz sections (unlimited dimension)
2555	nc_stat = NF90_DEF_DIM( id_set_yz(av), 'time', NF90_UNLIMITED, &
2556	id_dim_time_yz(av) )
2557	CALL handle_netcdf_error( 'netcdf', 181 )
2558
2559	nc_stat = NF90_DEF_VAR( id_set_yz(av), 'time', NF90_DOUBLE, &
2560	id_dim_time_yz(av), id_var_time_yz(av) )
2561	CALL handle_netcdf_error( 'netcdf', 182 )
2562
2563	nc_stat = NF90_PUT_ATT( id_set_yz(av), id_var_time_yz(av), 'units', &
2564	'seconds')
2565	CALL handle_netcdf_error( 'netcdf', 183 )
2566
2567	!
2568	!-- Define the spatial dimensions and coordinates for yz-sections.
2569	!-- First, determine the number of vertical sections to be written.
2570	IF ( section(1,3) == -9999 ) THEN
2571	RETURN
2572	ELSE
2573	ns = 1
2574	DO WHILE ( section(ns,3) /= -9999 .AND. ns <= 100 )
2575	ns = ns + 1
2576	ENDDO
2577	ns = ns - 1
2578	ENDIF
2579
2580	!
2581	!-- Define x axis (for scalar position)
2582	nc_stat = NF90_DEF_DIM( id_set_yz(av), 'x_yz', ns, id_dim_x_yz(av) )
2583	CALL handle_netcdf_error( 'netcdf', 184 )
2584
2585	nc_stat = NF90_DEF_VAR( id_set_yz(av), 'x_yz', NF90_DOUBLE, &
2586	id_dim_x_yz(av), id_var_x_yz(av) )
2587	CALL handle_netcdf_error( 'netcdf', 185 )
2588
2589	nc_stat = NF90_PUT_ATT( id_set_yz(av), id_var_x_yz(av), 'units', &
2590	'meters' )
2591	CALL handle_netcdf_error( 'netcdf', 186 )
2592
2593	!
2594	!-- Define x axis (for u position)
2595	nc_stat = NF90_DEF_DIM( id_set_yz(av), 'xu_yz', ns, id_dim_xu_yz(av) )
2596	CALL handle_netcdf_error( 'netcdf', 377 )
2597
2598	nc_stat = NF90_DEF_VAR( id_set_yz(av), 'xu_yz', NF90_DOUBLE, &
2599	id_dim_xu_yz(av), id_var_xu_yz(av) )
2600	CALL handle_netcdf_error( 'netcdf', 378 )
2601
2602	nc_stat = NF90_PUT_ATT( id_set_yz(av), id_var_xu_yz(av), 'units', &
2603	'meters' )
2604	CALL handle_netcdf_error( 'netcdf', 379 )
2605
2606	!
2607	!-- Define a variable to store the layer indices of the vertical cross
2608	!-- sections
2609	nc_stat = NF90_DEF_VAR( id_set_yz(av), 'ind_x_yz', NF90_DOUBLE, &
2610	id_dim_x_yz(av), id_var_ind_x_yz(av) )
2611	CALL handle_netcdf_error( 'netcdf', 187 )
2612
2613	nc_stat = NF90_PUT_ATT( id_set_yz(av), id_var_ind_x_yz(av), 'units', &
2614	'gridpoints')
2615	CALL handle_netcdf_error( 'netcdf', 188 )
2616
2617	!
2618	!-- Define y-axis (for scalar position)
2619	nc_stat = NF90_DEF_DIM( id_set_yz(av), 'y', ny+2, id_dim_y_yz(av) )
2620	CALL handle_netcdf_error( 'netcdf', 189 )
2621
2622	nc_stat = NF90_DEF_VAR( id_set_yz(av), 'y', NF90_DOUBLE, &
2623	id_dim_y_yz(av), id_var_y_yz(av) )
2624	CALL handle_netcdf_error( 'netcdf', 190 )
2625
2626	nc_stat = NF90_PUT_ATT( id_set_yz(av), id_var_y_yz(av), 'units', &
2627	'meters' )
2628	CALL handle_netcdf_error( 'netcdf', 191 )
2629
2630	!
2631	!-- Define y-axis (for v position)
2632	nc_stat = NF90_DEF_DIM( id_set_yz(av), 'yv', ny+2, id_dim_yv_yz(av) )
2633	CALL handle_netcdf_error( 'netcdf', 380 )
2634
2635	nc_stat = NF90_DEF_VAR( id_set_yz(av), 'yv', NF90_DOUBLE, &
2636	id_dim_yv_yz(av), id_var_yv_yz(av) )
2637	CALL handle_netcdf_error( 'netcdf', 381 )
2638
2639	nc_stat = NF90_PUT_ATT( id_set_yz(av), id_var_yv_yz(av), 'units', &
2640	'meters' )
2641	CALL handle_netcdf_error( 'netcdf', 382 )
2642
2643	!
2644	!-- Define the two z-axes (zu and zw)
2645	nc_stat = NF90_DEF_DIM( id_set_yz(av), 'zu', nz+2, id_dim_zu_yz(av) )
2646	CALL handle_netcdf_error( 'netcdf', 192 )
2647
2648	nc_stat = NF90_DEF_VAR( id_set_yz(av), 'zu', NF90_DOUBLE, &
2649	id_dim_zu_yz(av), id_var_zu_yz(av) )
2650	CALL handle_netcdf_error( 'netcdf', 193 )
2651
2652	nc_stat = NF90_PUT_ATT( id_set_yz(av), id_var_zu_yz(av), 'units', &
2653	'meters' )
2654	CALL handle_netcdf_error( 'netcdf', 194 )
2655
2656	nc_stat = NF90_DEF_DIM( id_set_yz(av), 'zw', nz+2, id_dim_zw_yz(av) )
2657	CALL handle_netcdf_error( 'netcdf', 195 )
2658
2659	nc_stat = NF90_DEF_VAR( id_set_yz(av), 'zw', NF90_DOUBLE, &
2660	id_dim_zw_yz(av), id_var_zw_yz(av) )
2661	CALL handle_netcdf_error( 'netcdf', 196 )
2662
2663	nc_stat = NF90_PUT_ATT( id_set_yz(av), id_var_zw_yz(av), 'units', &
2664	'meters' )
2665	CALL handle_netcdf_error( 'netcdf', 197 )
2666
2667
2668	!
2669	!-- Define the variables
2670	var_list = ';'
2671	i = 1
2672
2673	DO WHILE ( do2d(av,i)(1:1) /= ' ' )
2674
2675	IF ( INDEX( do2d(av,i), 'yz' ) /= 0 ) THEN
2676
2677	!
2678	!-- Check for the grid
2679	found = .TRUE.
2680	SELECT CASE ( do2d(av,i) )
2681	!
2682	!-- Most variables are defined on the zu grid
2683	CASE ( 'e_yz', 'lpt_yz', 'p_yz', 'pc_yz', 'pr_yz', 'pt_yz',&
2684	'q_yz', 'ql_yz', 'ql_c_yz', 'ql_v_yz', 'ql_vp_yz', &
2685	'qv_yz', 'rho_yz', 's_yz', 'sa_yz', 'vpt_yz' )
2686
2687	grid_x = 'x'
2688	grid_y = 'y'
2689	grid_z = 'zu'
2690	!
2691	!-- u grid
2692	CASE ( 'u_yz' )
2693
2694	grid_x = 'xu'
2695	grid_y = 'y'
2696	grid_z = 'zu'
2697	!
2698	!-- v grid
2699	CASE ( 'v_yz' )
2700
2701	grid_x = 'x'
2702	grid_y = 'yv'
2703	grid_z = 'zu'
2704	!
2705	!-- w grid
2706	CASE ( 'w_yz' )
2707
2708	grid_x = 'x'
2709	grid_y = 'y'
2710	grid_z = 'zw'
2711
2712	CASE DEFAULT
2713	!
2714	!-- Check for user-defined quantities
2715	CALL user_define_netcdf_grid( do2d(av,i), found, &
2716	grid_x, grid_y, grid_z )
2717
2718	END SELECT
2719
2720	!
2721	!-- Select the respective dimension ids
2722	IF ( grid_x == 'x' ) THEN
2723	id_x = id_dim_x_yz(av)
2724	ELSEIF ( grid_x == 'xu' ) THEN
2725	id_x = id_dim_xu_yz(av)
2726	ENDIF
2727
2728	IF ( grid_y == 'y' ) THEN
2729	id_y = id_dim_y_yz(av)
2730	ELSEIF ( grid_y == 'yv' ) THEN
2731	id_y = id_dim_yv_yz(av)
2732	ENDIF
2733
2734	IF ( grid_z == 'zu' ) THEN
2735	id_z = id_dim_zu_yz(av)
2736	ELSEIF ( grid_z == 'zw' ) THEN
2737	id_z = id_dim_zw_yz(av)
2738	ENDIF
2739
2740	!
2741	!-- Define the grid
2742	nc_stat = NF90_DEF_VAR( id_set_yz(av), do2d(av,i), &
2743	nc_precision(3), &
2744	(/ id_x, id_y, id_z, id_dim_time_yz(av) /), &
2745	id_var_do2d(av,i) )
2746
2747	IF ( .NOT. found ) THEN
2748	WRITE ( message_string, * ) 'no grid defined for', &
2749	' variable ', TRIM( do2d(av,i) )
2750	CALL message( 'define_netcdf_header', 'PA0244',&
2751	0, 1, 0, 6, 0 )
2752	ENDIF
2753
2754	var_list = TRIM( var_list ) // TRIM( do2d(av,i) ) // ';'
2755
2756	CALL handle_netcdf_error( 'netcdf', 198 )
2757	!
2758	!-- Store the 'real' name of the variable (with *, for example)
2759	!-- in the long_name attribute. This is evaluated by Ferret,
2760	!-- for example.
2761	nc_stat = NF90_PUT_ATT( id_set_yz(av), id_var_do2d(av,i), &
2762	'long_name', do2d(av,i) )
2763	CALL handle_netcdf_error( 'netcdf', 199 )
2764	!
2765	!-- Define the variable's unit
2766	nc_stat = NF90_PUT_ATT( id_set_yz(av), id_var_do2d(av,i), &
2767	'units', TRIM( do2d_unit(av,i) ) )
2768	CALL handle_netcdf_error( 'netcdf', 356 )
2769	#if defined( __netcdf4 )
2770	!
2771	!-- Set independent io operations for parallel io. Collective io
2772	!-- is only allowed in case of a 1d-decomposition along y, because
2773	!-- otherwise, not all PEs have output data.
2774	IF ( netcdf_data_format > 2 ) THEN
2775	IF ( npex == 1 ) THEN
2776	nc_stat = NF90_VAR_PAR_ACCESS( id_set_yz(av), &
2777	id_var_do2d(av,i), &
2778	NF90_COLLECTIVE )
2779	ELSE
2780	!
2781	!-- ATTENTION: Due to a probable bug in the NetCDF4
2782	!-- installation, independet output does not work
2783	!-- A workaround is used in data_output_2d on those
2784	!-- PEs having no data
2785	nc_stat = NF90_VAR_PAR_ACCESS( id_set_yz(av), &
2786	id_var_do2d(av,i), &
2787	NF90_COLLECTIVE )
2788	! nc_stat = NF90_VAR_PAR_ACCESS( id_set_yz(av), &
2789	! id_var_do2d(av,i), &
2790	! NF90_INDEPENDENT )
2791	ENDIF
2792	CALL handle_netcdf_error( 'netcdf', 450 )
2793	ENDIF
2794	#endif
2795	ENDIF
2796
2797	i = i + 1
2798
2799	ENDDO
2800
2801	!
2802	!-- No arrays to output. Close the netcdf file and return.
2803	IF ( i == 1 ) RETURN
2804
2805	!
2806	!-- Write the list of variables as global attribute (this is used by
2807	!-- restart runs and by combine_plot_fields)
2808	nc_stat = NF90_PUT_ATT( id_set_yz(av), NF90_GLOBAL, 'VAR_LIST', &
2809	var_list )
2810	CALL handle_netcdf_error( 'netcdf', 200 )
2811
2812	!
2813	!-- Leave NetCDF define mode
2814	nc_stat = NF90_ENDDEF( id_set_yz(av) )
2815	CALL handle_netcdf_error( 'netcdf', 201 )
2816
2817	!
2818	!-- Write axis data: x_yz, y, zu, zw
2819	ALLOCATE( netcdf_data(1:ns) )
2820
2821	!
2822	!-- Write x_yz data (shifted by +dx/2)
2823	DO i = 1, ns
2824	IF( section(i,3) == -1 ) THEN
2825	netcdf_data(i) = -1.0 ! section averaged along x
2826	ELSE
2827	netcdf_data(i) = ( section(i,3) + 0.5 ) * dx
2828	ENDIF
2829	ENDDO
2830	nc_stat = NF90_PUT_VAR( id_set_yz(av), id_var_x_yz(av), netcdf_data, &
2831	start = (/ 1 /), count = (/ ns /) )
2832	CALL handle_netcdf_error( 'netcdf', 202 )
2833
2834	!
2835	!-- Write x_yz data (xu grid)
2836	DO i = 1, ns
2837	IF( section(i,3) == -1 ) THEN
2838	netcdf_data(i) = -1.0 ! section averaged along x
2839	ELSE
2840	netcdf_data(i) = section(i,3) * dx
2841	ENDIF
2842	ENDDO
2843	nc_stat = NF90_PUT_VAR( id_set_yz(av), id_var_xu_yz(av), netcdf_data, &
2844	start = (/ 1 /), count = (/ ns /) )
2845	CALL handle_netcdf_error( 'netcdf', 383 )
2846
2847	!
2848	!-- Write gridpoint number data
2849	netcdf_data(1:ns) = section(1:ns,3)
2850	nc_stat = NF90_PUT_VAR( id_set_yz(av), id_var_ind_x_yz(av), &
2851	netcdf_data, start = (/ 1 /), &
2852	count = (/ ns /) )
2853	CALL handle_netcdf_error( 'netcdf', 203 )
2854
2855	DEALLOCATE( netcdf_data )
2856
2857	!
2858	!-- Write data for y (shifted by +dy/2) and yv axis
2859	ALLOCATE( netcdf_data(0:ny+1) )
2860
2861	DO j = 0, ny+1
2862	netcdf_data(j) = ( j + 0.5 ) * dy
2863	ENDDO
2864
2865	nc_stat = NF90_PUT_VAR( id_set_yz(av), id_var_y_yz(av), netcdf_data, &
2866	start = (/ 1 /), count = (/ ny+2 /) )
2867	CALL handle_netcdf_error( 'netcdf', 204 )
2868
2869	DO j = 0, ny+1
2870	netcdf_data(j) = j * dy
2871	ENDDO
2872
2873	nc_stat = NF90_PUT_VAR( id_set_yz(av), id_var_yv_yz(av), &
2874	netcdf_data, start = (/ 1 /), &
2875	count = (/ ny+2 /) )
2876	CALL handle_netcdf_error( 'netcdf', 384 )
2877
2878	DEALLOCATE( netcdf_data )
2879
2880	!
2881	!-- Write zu and zw data (vertical axes)
2882	ALLOCATE( netcdf_data(0:nz+1) )
2883
2884	netcdf_data(0:nz+1) = zu(nzb:nzt+1)
2885	nc_stat = NF90_PUT_VAR( id_set_yz(av), id_var_zu_yz(av), &
2886	netcdf_data, start = (/ 1 /), &
2887	count = (/ nz+2 /) )
2888	CALL handle_netcdf_error( 'netcdf', 205 )
2889
2890	netcdf_data(0:nz+1) = zw(nzb:nzt+1)
2891	nc_stat = NF90_PUT_VAR( id_set_yz(av), id_var_zw_yz(av), &
2892	netcdf_data, start = (/ 1 /), &
2893	count = (/ nz+2 /) )
2894	CALL handle_netcdf_error( 'netcdf', 206 )
2895
2896	DEALLOCATE( netcdf_data )
2897
2898
2899	CASE ( 'yz_ext' )
2900
2901	!
2902	!-- Get the list of variables and compare with the actual run.
2903	!-- First var_list_old has to be reset, since GET_ATT does not assign
2904	!-- trailing blanks.
2905	var_list_old = ' '
2906	nc_stat = NF90_GET_ATT( id_set_yz(av), NF90_GLOBAL, 'VAR_LIST', &
2907	var_list_old )
2908	CALL handle_netcdf_error( 'netcdf', 207 )
2909
2910	var_list = ';'
2911	i = 1
2912	DO WHILE ( do2d(av,i)(1:1) /= ' ' )
2913	IF ( INDEX( do2d(av,i), 'yz' ) /= 0 ) THEN
2914	var_list = TRIM( var_list ) // TRIM( do2d(av,i) ) // ';'
2915	ENDIF
2916	i = i + 1
2917	ENDDO
2918
2919	IF ( av == 0 ) THEN
2920	var = '(yz)'
2921	ELSE
2922	var = '(yz_av)'
2923	ENDIF
2924
2925	IF ( TRIM( var_list ) /= TRIM( var_list_old ) ) THEN
2926	message_string = 'NetCDF file for cross-sections ' // &
2927	TRIM( var ) // ' from previous run found,' // &
2928	'& but this file cannot be extended due to' // &
2929	' variable mismatch.' // &
2930	'&New file is created instead.'
2931	CALL message( 'define_netcdf_header', 'PA0249', 0, 1, 0, 6, 0 )
2932	extend = .FALSE.
2933	RETURN
2934	ENDIF
2935
2936	!
2937	!-- Calculate the number of current sections
2938	ns = 1
2939	DO WHILE ( section(ns,3) /= -9999 .AND. ns <= 100 )
2940	ns = ns + 1
2941	ENDDO
2942	ns = ns - 1
2943
2944	!
2945	!-- Get and compare the number of vertical cross sections
2946	nc_stat = NF90_INQ_VARID( id_set_yz(av), 'x_yz', id_var_x_yz(av) )
2947	CALL handle_netcdf_error( 'netcdf', 208 )
2948
2949	nc_stat = NF90_INQUIRE_VARIABLE( id_set_yz(av), id_var_x_yz(av), &
2950	dimids = id_dim_x_yz_old )
2951	CALL handle_netcdf_error( 'netcdf', 209 )
2952	id_dim_x_yz(av) = id_dim_x_yz_old(1)
2953
2954	nc_stat = NF90_INQUIRE_DIMENSION( id_set_yz(av), id_dim_x_yz(av), &
2955	len = ns_old )
2956	CALL handle_netcdf_error( 'netcdf', 210 )
2957
2958	IF ( ns /= ns_old ) THEN
2959	message_string = 'NetCDF file for cross-sections ' // &
2960	TRIM( var ) // ' from previous run found,' // &
2961	'&but this file cannot be extended due to' // &
2962	' mismatch in number of' // &
2963	'&cross sections.' // &
2964	'&New file is created instead.'
2965	CALL message( 'define_netcdf_header', 'PA0250', 0, 1, 0, 6, 0 )
2966	extend = .FALSE.
2967	RETURN
2968	ENDIF
2969
2970	!
2971	!-- Get and compare the heights of the cross sections
2972	ALLOCATE( netcdf_data(1:ns_old) )
2973
2974	nc_stat = NF90_GET_VAR( id_set_yz(av), id_var_x_yz(av), netcdf_data )
2975	CALL handle_netcdf_error( 'netcdf', 211 )
2976
2977	DO i = 1, ns
2978	IF ( section(i,3) /= -1 ) THEN
2979	IF ( ( ( section(i,3) + 0.5 ) * dx ) /= netcdf_data(i) ) THEN
2980	message_string = 'NetCDF file for cross-sections ' // &
2981	TRIM( var ) // ' from previous run found,' // &
2982	'&but this file cannot be extended' // &
2983	' due to mismatch in cross' // &
2984	'&section levels.' // &
2985	'&New file is created instead.'
2986	CALL message( 'define_netcdf_header', 'PA0251', &
2987	0, 1, 0, 6, 0 )
2988	extend = .FALSE.
2989	RETURN
2990	ENDIF
2991	ELSE
2992	IF ( -1.0 /= netcdf_data(i) ) THEN
2993	message_string = 'NetCDF file for cross-sections ' // &
2994	TRIM( var ) // ' from previous run found,' // &
2995	'&but this file cannot be extended' // &
2996	' due to mismatch in cross' // &
2997	'&section levels.' // &
2998	'&New file is created instead.'
2999	CALL message( 'define_netcdf_header', 'PA0251', &
3000	0, 1, 0, 6, 0 )
3001	extend = .FALSE.
3002	RETURN
3003	ENDIF
3004	ENDIF
3005	ENDDO
3006
3007	DEALLOCATE( netcdf_data )
3008
3009	!
3010	!-- Get the id of the time coordinate (unlimited coordinate) and its
3011	!-- last index on the file. The next time level is pl2d..count+1.
3012	!-- The current time must be larger than the last output time
3013	!-- on the file.
3014	nc_stat = NF90_INQ_VARID( id_set_yz(av), 'time', id_var_time_yz(av) )
3015	CALL handle_netcdf_error( 'netcdf', 212 )
3016
3017	nc_stat = NF90_INQUIRE_VARIABLE( id_set_yz(av), id_var_time_yz(av), &
3018	dimids = id_dim_time_old )
3019	CALL handle_netcdf_error( 'netcdf', 213 )
3020	id_dim_time_yz(av) = id_dim_time_old(1)
3021
3022	nc_stat = NF90_INQUIRE_DIMENSION( id_set_yz(av), id_dim_time_yz(av), &
3023	len = do2d_yz_time_count(av) )
3024	CALL handle_netcdf_error( 'netcdf', 214 )
3025
3026	nc_stat = NF90_GET_VAR( id_set_yz(av), id_var_time_yz(av), &
3027	last_time_coordinate, &
3028	start = (/ do2d_yz_time_count(av) /), &
3029	count = (/ 1 /) )
3030	CALL handle_netcdf_error( 'netcdf', 215 )
3031
3032	IF ( last_time_coordinate(1) >= simulated_time ) THEN
3033	message_string = 'NetCDF file for cross sections ' // &
3034	TRIM( var ) // ' from previous run found,' // &
3035	'&but this file cannot be extended becaus' // &
3036	'e the current output time' // &
3037	'&is less or equal than the last output t' // &
3038	'ime on this file.' // &
3039	'&New file is created instead.'
3040	CALL message( 'define_netcdf_header', 'PA0252', 0, 1, 0, 6, 0 )
3041	do2d_yz_time_count(av) = 0
3042	extend = .FALSE.
3043	RETURN
3044	ENDIF
3045
3046	!
3047	!-- Dataset seems to be extendable.
3048	!-- Now get the variable ids.
3049	i = 1
3050	DO WHILE ( do2d(av,i)(1:1) /= ' ' )
3051	IF ( INDEX( do2d(av,i), 'yz' ) /= 0 ) THEN
3052	nc_stat = NF90_INQ_VARID( id_set_yz(av), do2d(av,i), &
3053	id_var_do2d(av,i) )
3054	CALL handle_netcdf_error( 'netcdf', 216 )
3055	#if defined( __netcdf4 )
3056	!
3057	!-- Set independent io operations for parallel io. Collective io
3058	!-- is only allowed in case of a 1d-decomposition along y, because
3059	!-- otherwise, not all PEs have output data.
3060	IF ( netcdf_data_format > 2 ) THEN
3061	IF ( npex == 1 ) THEN
3062	nc_stat = NF90_VAR_PAR_ACCESS( id_set_yz(av), &
3063	id_var_do2d(av,i), &
3064	NF90_COLLECTIVE )
3065	ELSE
3066	!
3067	!-- ATTENTION: Due to a probable bug in the NetCDF4
3068	!-- installation, independet output does not work
3069	!-- A workaround is used in data_output_2d on those
3070	!-- PEs having no data
3071	nc_stat = NF90_VAR_PAR_ACCESS( id_set_yz(av), &
3072	id_var_do2d(av,i), &
3073	NF90_COLLECTIVE )
3074	! nc_stat = NF90_VAR_PAR_ACCESS( id_set_yz(av), &
3075	! id_var_do2d(av,i), &
3076	! NF90_INDEPENDENT )
3077	ENDIF
3078	CALL handle_netcdf_error( 'netcdf', 450 )
3079	ENDIF
3080	#endif
3081	ENDIF
3082	i = i + 1
3083	ENDDO
3084
3085	!
3086	!-- Update the title attribute on file
3087	!-- In order to avoid 'data mode' errors if updated attributes are larger
3088	!-- than their original size, NF90_PUT_ATT is called in 'define mode'
3089	!-- enclosed by NF90_REDEF and NF90_ENDDEF calls. This implies a possible
3090	!-- performance loss due to data copying; an alternative strategy would be
3091	!-- to ensure equal attribute size in a job chain. Maybe revise later.
3092	IF ( av == 0 ) THEN
3093	time_average_text = ' '
3094	ELSE
3095	WRITE (time_average_text, '('', '',F7.1,'' s average'')') &
3096	averaging_interval
3097	ENDIF
3098	nc_stat = NF90_REDEF( id_set_yz(av) )
3099	CALL handle_netcdf_error( 'netcdf', 435 )
3100	nc_stat = NF90_PUT_ATT( id_set_yz(av), NF90_GLOBAL, 'title', &
3101	TRIM( run_description_header ) // &
3102	TRIM( time_average_text ) )
3103	CALL handle_netcdf_error( 'netcdf', 217 )
3104	nc_stat = NF90_ENDDEF( id_set_yz(av) )
3105	CALL handle_netcdf_error( 'netcdf', 436 )
3106	message_string = 'NetCDF file for cross-sections ' // &
3107	TRIM( var ) // ' from previous run found.' // &
3108	'&This file will be extended.'
3109	CALL message( 'define_netcdf_header', 'PA0253', 0, 0, 0, 6, 0 )
3110
3111
3112	CASE ( 'pr_new' )
3113
3114	!
3115	!-- Define some global attributes of the dataset
3116	IF ( averaging_interval_pr /= 0.0 ) THEN
3117	WRITE (time_average_text,'('', '',F7.1,'' s average'')') &
3118	averaging_interval_pr
3119	nc_stat = NF90_PUT_ATT( id_set_pr, NF90_GLOBAL, 'title', &
3120	TRIM( run_description_header ) // &
3121	TRIM( time_average_text ) )
3122	CALL handle_netcdf_error( 'netcdf', 218 )
3123
3124	WRITE ( time_average_text,'(F7.1,'' s avg'')' ) averaging_interval_pr
3125	nc_stat = NF90_PUT_ATT( id_set_pr, NF90_GLOBAL, 'time_avg', &
3126	TRIM( time_average_text ) )
3127	ELSE
3128	nc_stat = NF90_PUT_ATT( id_set_pr, NF90_GLOBAL, 'title', &
3129	TRIM( run_description_header ) )
3130	ENDIF
3131	CALL handle_netcdf_error( 'netcdf', 219 )
3132
3133	!
3134	!-- Define time coordinate for profiles (unlimited dimension)
3135	nc_stat = NF90_DEF_DIM( id_set_pr, 'time', NF90_UNLIMITED, &
3136	id_dim_time_pr )
3137	CALL handle_netcdf_error( 'netcdf', 220 )
3138
3139	nc_stat = NF90_DEF_VAR( id_set_pr, 'time', NF90_DOUBLE, &
3140	id_dim_time_pr, id_var_time_pr )
3141	CALL handle_netcdf_error( 'netcdf', 221 )
3142
3143	nc_stat = NF90_PUT_ATT( id_set_pr, id_var_time_pr, 'units', 'seconds')
3144	CALL handle_netcdf_error( 'netcdf', 222 )
3145
3146	!
3147	!-- Define the variables
3148	var_list = ';'
3149	DO i = 1, dopr_n
3150
3151	IF ( statistic_regions == 0 ) THEN
3152
3153	!
3154	!-- Define the z-axes (each variable gets its own z-axis)
3155	nc_stat = NF90_DEF_DIM( id_set_pr, &
3156	'z' // TRIM( data_output_pr(i) ), &
3157	nzt+2-nzb, id_dim_z_pr(i,0) )
3158	CALL handle_netcdf_error( 'netcdf', 223 )
3159
3160	nc_stat = NF90_DEF_VAR( id_set_pr, &
3161	'z' // TRIM( data_output_pr(i) ), &
3162	NF90_DOUBLE, id_dim_z_pr(i,0), &
3163	id_var_z_pr(i,0) )
3164	CALL handle_netcdf_error( 'netcdf', 224 )
3165
3166	nc_stat = NF90_PUT_ATT( id_set_pr, id_var_z_pr(i,0), 'units', &
3167	'meters' )
3168	CALL handle_netcdf_error( 'netcdf', 225 )
3169	!
3170	!-- Define the variable
3171	nc_stat = NF90_DEF_VAR( id_set_pr, data_output_pr(i), &
3172	nc_precision(5), (/ id_dim_z_pr(i,0), &
3173	id_dim_time_pr /), id_var_dopr(i,0) )
3174	CALL handle_netcdf_error( 'netcdf', 226 )
3175
3176	nc_stat = NF90_PUT_ATT( id_set_pr, id_var_dopr(i,0), &
3177	'long_name', TRIM( data_output_pr(i) ) )
3178	CALL handle_netcdf_error( 'netcdf', 227 )
3179
3180	nc_stat = NF90_PUT_ATT( id_set_pr, id_var_dopr(i,0), &
3181	'units', TRIM( dopr_unit(i) ) )
3182	CALL handle_netcdf_error( 'netcdf', 228 )
3183
3184	var_list = TRIM( var_list ) // TRIM( data_output_pr(i) ) // ';'
3185
3186	ELSE
3187	!
3188	!-- If statistic regions are defined, add suffix _SR+#SR to the
3189	!-- names
3190	DO j = 0, statistic_regions
3191	WRITE ( suffix, '(''_'',I1)' ) j
3192
3193	!
3194	!-- Define the z-axes (each variable gets it own z-axis)
3195	nc_stat = NF90_DEF_DIM( id_set_pr, &
3196	'z'//TRIM(data_output_pr(i))//suffix, &
3197	nzt+2-nzb, id_dim_z_pr(i,j) )
3198	CALL handle_netcdf_error( 'netcdf', 229 )
3199
3200	nc_stat = NF90_DEF_VAR( id_set_pr, &
3201	'z'//TRIM(data_output_pr(i))//suffix, &
3202	nc_precision(5), id_dim_z_pr(i,j), &
3203	id_var_z_pr(i,j) )
3204	CALL handle_netcdf_error( 'netcdf', 230 )
3205
3206	nc_stat = NF90_PUT_ATT( id_set_pr, id_var_z_pr(i,j), &
3207	'units', 'meters' )
3208	CALL handle_netcdf_error( 'netcdf', 231 )
3209
3210	!
3211	!-- Define the variable
3212	nc_stat = NF90_DEF_VAR( id_set_pr, &
3213	TRIM(data_output_pr(i)) // suffix, &
3214	nc_precision(5), &
3215	(/ id_dim_z_pr(i,j), &
3216	id_dim_time_pr /), id_var_dopr(i,j) )
3217	CALL handle_netcdf_error( 'netcdf', 232 )
3218
3219	nc_stat = NF90_PUT_ATT( id_set_pr, id_var_dopr(i,j), &
3220	'long_name', &
3221	TRIM( data_output_pr(i) ) // ' SR ' &
3222	// suffix(2:2) )
3223	CALL handle_netcdf_error( 'netcdf', 233 )
3224
3225	nc_stat = NF90_PUT_ATT( id_set_pr, id_var_dopr(i,j), &
3226	'units', TRIM( dopr_unit(i) ) )
3227	CALL handle_netcdf_error( 'netcdf', 234 )
3228
3229	var_list = TRIM( var_list ) // TRIM( data_output_pr(i) ) // &
3230	suffix // ';'
3231
3232	ENDDO
3233
3234	ENDIF
3235
3236	ENDDO
3237
3238	!
3239	!-- Write the list of variables as global attribute (this is used by
3240	!-- restart runs)
3241	nc_stat = NF90_PUT_ATT( id_set_pr, NF90_GLOBAL, 'VAR_LIST', var_list )
3242	CALL handle_netcdf_error( 'netcdf', 235 )
3243
3244	!
3245	!-- Define normalization variables (as time series)
3246	DO i = 1, dopr_norm_num
3247
3248	nc_stat = NF90_DEF_VAR( id_set_pr, 'NORM_' // &
3249	TRIM( dopr_norm_names(i) ), &
3250	nc_precision(5), (/ id_dim_time_pr /), &
3251	id_var_norm_dopr(i) )
3252	CALL handle_netcdf_error( 'netcdf', 236 )
3253
3254	nc_stat = NF90_PUT_ATT( id_set_pr, id_var_norm_dopr(i), &
3255	'long_name', &
3256	TRIM( dopr_norm_longnames(i) ) )
3257	CALL handle_netcdf_error( 'netcdf', 237 )
3258
3259	ENDDO
3260
3261	!
3262	!-- Leave NetCDF define mode
3263	nc_stat = NF90_ENDDEF( id_set_pr )
3264	CALL handle_netcdf_error( 'netcdf', 238 )
3265
3266	!
3267	!-- Write z-axes data
3268	DO i = 1, dopr_n
3269	DO j = 0, statistic_regions
3270
3271	nc_stat = NF90_PUT_VAR( id_set_pr, id_var_z_pr(i,j), &
3272	hom(nzb:nzt+1,2,dopr_index(i),0), &
3273	start = (/ 1 /), &
3274	count = (/ nzt-nzb+2 /) )
3275	CALL handle_netcdf_error( 'netcdf', 239 )
3276
3277	ENDDO
3278	ENDDO
3279
3280
3281	CASE ( 'pr_ext' )
3282
3283	!
3284	!-- Get the list of variables and compare with the actual run.
3285	!-- First var_list_old has to be reset, since GET_ATT does not assign
3286	!-- trailing blanks.
3287	var_list_old = ' '
3288	nc_stat = NF90_GET_ATT( id_set_pr, NF90_GLOBAL, 'VAR_LIST', &
3289	var_list_old )
3290	CALL handle_netcdf_error( 'netcdf', 240 )
3291
3292	var_list = ';'
3293	DO i = 1, dopr_n
3294
3295	IF ( statistic_regions == 0 ) THEN
3296	var_list = TRIM( var_list ) // TRIM( data_output_pr(i) ) // ';'
3297	ELSE
3298	DO j = 0, statistic_regions
3299	WRITE ( suffix, '(''_'',I1)' ) j
3300	var_list = TRIM( var_list ) // TRIM( data_output_pr(i) ) // &
3301	suffix // ';'
3302	ENDDO
3303	ENDIF
3304
3305	ENDDO
3306
3307	IF ( TRIM( var_list ) /= TRIM( var_list_old ) ) THEN
3308	message_string = 'NetCDF file for vertical profiles ' // &
3309	'from previous run found,' // &
3310	'& but this file cannot be extended due to' // &
3311	' variable mismatch.' // &
3312	'&New file is created instead.'
3313	CALL message( 'define_netcdf_header', 'PA0254', 0, 1, 0, 6, 0 )
3314	extend = .FALSE.
3315	RETURN
3316	ENDIF
3317
3318	!
3319	!-- Get the id of the time coordinate (unlimited coordinate) and its
3320	!-- last index on the file. The next time level is dopr..count+1.
3321	!-- The current time must be larger than the last output time
3322	!-- on the file.
3323	nc_stat = NF90_INQ_VARID( id_set_pr, 'time', id_var_time_pr )
3324	CALL handle_netcdf_error( 'netcdf', 241 )
3325
3326	nc_stat = NF90_INQUIRE_VARIABLE( id_set_pr, id_var_time_pr, &
3327	dimids = id_dim_time_old )
3328	CALL handle_netcdf_error( 'netcdf', 242 )
3329	id_dim_time_pr = id_dim_time_old(1)
3330
3331	nc_stat = NF90_INQUIRE_DIMENSION( id_set_pr, id_dim_time_pr, &
3332	len = dopr_time_count )
3333	CALL handle_netcdf_error( 'netcdf', 243 )
3334
3335	nc_stat = NF90_GET_VAR( id_set_pr, id_var_time_pr, &
3336	last_time_coordinate, &
3337	start = (/ dopr_time_count /), &
3338	count = (/ 1 /) )
3339	CALL handle_netcdf_error( 'netcdf', 244 )
3340
3341	IF ( last_time_coordinate(1) >= simulated_time ) THEN
3342	message_string = 'NetCDF file for vertical profiles ' // &
3343	'from previous run found,' // &
3344	'&but this file cannot be extended becaus' // &
3345	'e the current output time' // &
3346	'&is less or equal than the last output t' // &
3347	'ime on this file.' // &
3348	'&New file is created instead.'
3349	CALL message( 'define_netcdf_header', 'PA0255', 0, 1, 0, 6, 0 )
3350	dopr_time_count = 0
3351	extend = .FALSE.
3352	RETURN
3353	ENDIF
3354
3355	!
3356	!-- Dataset seems to be extendable.
3357	!-- Now get the variable ids.
3358	i = 1
3359	DO i = 1, dopr_n
3360
3361	IF ( statistic_regions == 0 ) THEN
3362	nc_stat = NF90_INQ_VARID( id_set_pr, data_output_pr(i), &
3363	id_var_dopr(i,0) )
3364	CALL handle_netcdf_error( 'netcdf', 245 )
3365	ELSE
3366	DO j = 0, statistic_regions
3367	WRITE ( suffix, '(''_'',I1)' ) j
3368	netcdf_var_name = TRIM( data_output_pr(i) ) // suffix
3369	nc_stat = NF90_INQ_VARID( id_set_pr, netcdf_var_name, &
3370	id_var_dopr(i,j) )
3371	CALL handle_netcdf_error( 'netcdf', 246 )
3372	ENDDO
3373	ENDIF
3374
3375	ENDDO
3376
3377	!
3378	!-- Get ids of the normalization variables
3379	DO i = 1, dopr_norm_num
3380	nc_stat = NF90_INQ_VARID( id_set_pr, &
3381	'NORM_' // TRIM( dopr_norm_names(i) ), &
3382	id_var_norm_dopr(i) )
3383	CALL handle_netcdf_error( 'netcdf', 247 )
3384	ENDDO
3385
3386	!
3387	!-- Update the title attribute on file
3388	!-- In order to avoid 'data mode' errors if updated attributes are larger
3389	!-- than their original size, NF90_PUT_ATT is called in 'define mode'
3390	!-- enclosed by NF90_REDEF and NF90_ENDDEF calls. This implies a possible
3391	!-- performance loss due to data copying; an alternative strategy would be
3392	!-- to ensure equal attribute size in a job chain. Maybe revise later.
3393	IF ( averaging_interval_pr == 0.0 ) THEN
3394	time_average_text = ' '
3395	ELSE
3396	WRITE (time_average_text, '('', '',F7.1,'' s average'')') &
3397	averaging_interval_pr
3398	ENDIF
3399	nc_stat = NF90_REDEF( id_set_pr )
3400	CALL handle_netcdf_error( 'netcdf', 437 )
3401	nc_stat = NF90_PUT_ATT( id_set_pr, NF90_GLOBAL, 'title', &
3402	TRIM( run_description_header ) // &
3403	TRIM( time_average_text ) )
3404	CALL handle_netcdf_error( 'netcdf', 248 )
3405	nc_stat = NF90_ENDDEF( id_set_pr )
3406	CALL handle_netcdf_error( 'netcdf', 438 )
3407	message_string = 'NetCDF file for vertical profiles ' // &
3408	'from previous run found.' // &
3409	'&This file will be extended.'
3410	CALL message( 'define_netcdf_header', 'PA0256', 0, 0, 0, 6, 0 )
3411
3412
3413	CASE ( 'ts_new' )
3414
3415	!
3416	!-- Define some global attributes of the dataset
3417	nc_stat = NF90_PUT_ATT( id_set_ts, NF90_GLOBAL, 'title', &
3418	TRIM( run_description_header ) )
3419	CALL handle_netcdf_error( 'netcdf', 249 )
3420
3421	!
3422	!-- Define time coordinate for time series (unlimited dimension)
3423	nc_stat = NF90_DEF_DIM( id_set_ts, 'time', NF90_UNLIMITED, &
3424	id_dim_time_ts )
3425	CALL handle_netcdf_error( 'netcdf', 250 )
3426
3427	nc_stat = NF90_DEF_VAR( id_set_ts, 'time', NF90_DOUBLE, &
3428	id_dim_time_ts, id_var_time_ts )
3429	CALL handle_netcdf_error( 'netcdf', 251 )
3430
3431	nc_stat = NF90_PUT_ATT( id_set_ts, id_var_time_ts, 'units', 'seconds')
3432	CALL handle_netcdf_error( 'netcdf', 252 )
3433
3434	!
3435	!-- Define the variables
3436	var_list = ';'
3437	DO i = 1, dots_num
3438
3439	IF ( statistic_regions == 0 ) THEN
3440
3441	nc_stat = NF90_DEF_VAR( id_set_ts, dots_label(i), &
3442	nc_precision(6), (/ id_dim_time_ts /), &
3443	id_var_dots(i,0) )
3444	CALL handle_netcdf_error( 'netcdf', 253 )
3445
3446	nc_stat = NF90_PUT_ATT( id_set_ts, id_var_dots(i,0), &
3447	'long_name', TRIM( dots_label(i) ) )
3448	CALL handle_netcdf_error( 'netcdf', 254 )
3449
3450	nc_stat = NF90_PUT_ATT( id_set_ts, id_var_dots(i,0), &
3451	'units', TRIM( dots_unit(i) ) )
3452	CALL handle_netcdf_error( 'netcdf', 255 )
3453
3454	var_list = TRIM( var_list ) // TRIM( dots_label(i) ) // ';'
3455
3456	ELSE
3457	!
3458	!-- If statistic regions are defined, add suffix _SR+#SR to the
3459	!-- names
3460	DO j = 0, statistic_regions
3461	WRITE ( suffix, '(''_'',I1)' ) j
3462
3463	nc_stat = NF90_DEF_VAR( id_set_ts, &
3464	TRIM( dots_label(i) ) // suffix, &
3465	nc_precision(6), &
3466	(/ id_dim_time_ts /), &
3467	id_var_dots(i,j) )
3468	CALL handle_netcdf_error( 'netcdf', 256 )
3469
3470	nc_stat = NF90_PUT_ATT( id_set_ts, id_var_dots(i,j), &
3471	'long_name', &
3472	TRIM( dots_label(i) ) // ' SR ' // &
3473	suffix(2:2) )
3474	CALL handle_netcdf_error( 'netcdf', 257 )
3475
3476	nc_stat = NF90_PUT_ATT( id_set_ts, id_var_dots(i,j), &
3477	'units', TRIM( dots_unit(i) ) )
3478	CALL handle_netcdf_error( 'netcdf', 347 )
3479
3480	var_list = TRIM( var_list ) // TRIM( dots_label(i) ) // &
3481	suffix // ';'
3482
3483	ENDDO
3484
3485	ENDIF
3486
3487	ENDDO
3488
3489	!
3490	!-- Write the list of variables as global attribute (this is used by
3491	!-- restart runs)
3492	nc_stat = NF90_PUT_ATT( id_set_ts, NF90_GLOBAL, 'VAR_LIST', var_list )
3493	CALL handle_netcdf_error( 'netcdf', 258 )
3494
3495	!
3496	!-- Leave NetCDF define mode
3497	nc_stat = NF90_ENDDEF( id_set_ts )
3498	CALL handle_netcdf_error( 'netcdf', 259 )
3499
3500
3501	CASE ( 'ts_ext' )
3502
3503	!
3504	!-- Get the list of variables and compare with the actual run.
3505	!-- First var_list_old has to be reset, since GET_ATT does not assign
3506	!-- trailing blanks.
3507	var_list_old = ' '
3508	nc_stat = NF90_GET_ATT( id_set_ts, NF90_GLOBAL, 'VAR_LIST', &
3509	var_list_old )
3510	CALL handle_netcdf_error( 'netcdf', 260 )
3511
3512	var_list = ';'
3513	i = 1
3514	DO i = 1, dots_num
3515
3516	IF ( statistic_regions == 0 ) THEN
3517	var_list = TRIM( var_list ) // TRIM( dots_label(i) ) // ';'
3518	ELSE
3519	DO j = 0, statistic_regions
3520	WRITE ( suffix, '(''_'',I1)' ) j
3521	var_list = TRIM( var_list ) // TRIM( dots_label(i) ) // &
3522	suffix // ';'
3523	ENDDO
3524	ENDIF
3525
3526	ENDDO
3527
3528	IF ( TRIM( var_list ) /= TRIM( var_list_old ) ) THEN
3529	message_string = 'NetCDF file for time series ' // &
3530	'from previous run found,' // &
3531	'& but this file cannot be extended due to' // &
3532	' variable mismatch.' // &
3533	'&New file is created instead.'
3534	CALL message( 'define_netcdf_header', 'PA0257', 0, 1, 0, 6, 0 )
3535	extend = .FALSE.
3536	RETURN
3537	ENDIF
3538
3539	!
3540	!-- Get the id of the time coordinate (unlimited coordinate) and its
3541	!-- last index on the file. The next time level is dots..count+1.
3542	!-- The current time must be larger than the last output time
3543	!-- on the file.
3544	nc_stat = NF90_INQ_VARID( id_set_ts, 'time', id_var_time_ts )
3545	CALL handle_netcdf_error( 'netcdf', 261 )
3546
3547	nc_stat = NF90_INQUIRE_VARIABLE( id_set_ts, id_var_time_ts, &
3548	dimids = id_dim_time_old )
3549	CALL handle_netcdf_error( 'netcdf', 262 )
3550	id_dim_time_ts = id_dim_time_old(1)
3551
3552	nc_stat = NF90_INQUIRE_DIMENSION( id_set_ts, id_dim_time_ts, &
3553	len = dots_time_count )
3554	CALL handle_netcdf_error( 'netcdf', 263 )
3555
3556	nc_stat = NF90_GET_VAR( id_set_ts, id_var_time_ts, &
3557	last_time_coordinate, &
3558	start = (/ dots_time_count /), &
3559	count = (/ 1 /) )
3560	CALL handle_netcdf_error( 'netcdf', 264 )
3561
3562	IF ( last_time_coordinate(1) >= simulated_time ) THEN
3563	message_string = 'NetCDF file for time series ' // &
3564	'from previous run found,' // &
3565	'&but this file cannot be extended becaus' // &
3566	'e the current output time' // &
3567	'&is less or equal than the last output t' // &
3568	'ime on this file.' // &
3569	'&New file is created instead.'
3570	CALL message( 'define_netcdf_header', 'PA0258', 0, 1, 0, 6, 0 )
3571	dots_time_count = 0
3572	extend = .FALSE.
3573	RETURN
3574	ENDIF
3575
3576	!
3577	!-- Dataset seems to be extendable.
3578	!-- Now get the variable ids
3579	i = 1
3580	DO i = 1, dots_num
3581
3582	IF ( statistic_regions == 0 ) THEN
3583	nc_stat = NF90_INQ_VARID( id_set_ts, dots_label(i), &
3584	id_var_dots(i,0) )
3585	CALL handle_netcdf_error( 'netcdf', 265 )
3586	ELSE
3587	DO j = 0, statistic_regions
3588	WRITE ( suffix, '(''_'',I1)' ) j
3589	netcdf_var_name = TRIM( dots_label(i) ) // suffix
3590	nc_stat = NF90_INQ_VARID( id_set_ts, netcdf_var_name, &
3591	id_var_dots(i,j) )
3592	CALL handle_netcdf_error( 'netcdf', 266 )
3593	ENDDO
3594	ENDIF
3595
3596	ENDDO
3597
3598	!
3599	!-- Update the title attribute on file
3600	!-- In order to avoid 'data mode' errors if updated attributes are larger
3601	!-- than their original size, NF90_PUT_ATT is called in 'define mode'
3602	!-- enclosed by NF90_REDEF and NF90_ENDDEF calls. This implies a possible
3603	!-- performance loss due to data copying; an alternative strategy would be
3604	!-- to ensure equal attribute size in a job chain. Maybe revise later.
3605	nc_stat = NF90_REDEF( id_set_ts )
3606	CALL handle_netcdf_error( 'netcdf', 439 )
3607	nc_stat = NF90_PUT_ATT( id_set_ts, NF90_GLOBAL, 'title', &
3608	TRIM( run_description_header ) )
3609	CALL handle_netcdf_error( 'netcdf', 267 )
3610	nc_stat = NF90_ENDDEF( id_set_ts )
3611	CALL handle_netcdf_error( 'netcdf', 440 )
3612	message_string = 'NetCDF file for time series ' // &
3613	'from previous run found.' // &
3614	'&This file will be extended.'
3615	CALL message( 'define_netcdf_header', 'PA0259', 0, 0, 0, 6, 0 )
3616
3617
3618	CASE ( 'sp_new' )
3619
3620	!
3621	!-- Define some global attributes of the dataset
3622	IF ( averaging_interval_sp /= 0.0 ) THEN
3623	WRITE (time_average_text,'('', '',F7.1,'' s average'')') &
3624	averaging_interval_sp
3625	nc_stat = NF90_PUT_ATT( id_set_sp, NF90_GLOBAL, 'title', &
3626	TRIM( run_description_header ) // &
3627	TRIM( time_average_text ) )
3628	CALL handle_netcdf_error( 'netcdf', 268 )
3629
3630	WRITE ( time_average_text,'(F7.1,'' s avg'')' ) averaging_interval_sp
3631	nc_stat = NF90_PUT_ATT( id_set_sp, NF90_GLOBAL, 'time_avg', &
3632	TRIM( time_average_text ) )
3633	ELSE
3634	nc_stat = NF90_PUT_ATT( id_set_sp, NF90_GLOBAL, 'title', &
3635	TRIM( run_description_header ) )
3636	ENDIF
3637	CALL handle_netcdf_error( 'netcdf', 269 )
3638
3639	!
3640	!-- Define time coordinate for spectra (unlimited dimension)
3641	nc_stat = NF90_DEF_DIM( id_set_sp, 'time', NF90_UNLIMITED, &
3642	id_dim_time_sp )
3643	CALL handle_netcdf_error( 'netcdf', 270 )
3644
3645	nc_stat = NF90_DEF_VAR( id_set_sp, 'time', NF90_DOUBLE, &
3646	id_dim_time_sp, id_var_time_sp )
3647	CALL handle_netcdf_error( 'netcdf', 271 )
3648
3649	nc_stat = NF90_PUT_ATT( id_set_sp, id_var_time_sp, 'units', 'seconds')
3650	CALL handle_netcdf_error( 'netcdf', 272 )
3651
3652	!
3653	!-- Define the spatial dimensions and coordinates for spectra.
3654	!-- First, determine the number of vertical levels for which spectra
3655	!-- are to be output.
3656	ns = 1
3657	DO WHILE ( comp_spectra_level(ns) /= 999999 .AND. ns <= 100 )
3658	ns = ns + 1
3659	ENDDO
3660	ns = ns - 1
3661
3662	!
3663	!-- Define vertical coordinate grid (zu grid)
3664	nc_stat = NF90_DEF_DIM( id_set_sp, 'zu_sp', ns, id_dim_zu_sp )
3665	CALL handle_netcdf_error( 'netcdf', 273 )
3666
3667	nc_stat = NF90_DEF_VAR( id_set_sp, 'zu_sp', NF90_DOUBLE, &
3668	id_dim_zu_sp, id_var_zu_sp )
3669	CALL handle_netcdf_error( 'netcdf', 274 )
3670
3671	nc_stat = NF90_PUT_ATT( id_set_sp, id_var_zu_sp, 'units', 'meters' )
3672	CALL handle_netcdf_error( 'netcdf', 275 )
3673
3674	!
3675	!-- Define vertical coordinate grid (zw grid)
3676	nc_stat = NF90_DEF_DIM( id_set_sp, 'zw_sp', ns, id_dim_zw_sp )
3677	CALL handle_netcdf_error( 'netcdf', 276 )
3678
3679	nc_stat = NF90_DEF_VAR( id_set_sp, 'zw_sp', NF90_DOUBLE, &
3680	id_dim_zw_sp, id_var_zw_sp )
3681	CALL handle_netcdf_error( 'netcdf', 277 )
3682
3683	nc_stat = NF90_PUT_ATT( id_set_sp, id_var_zw_sp, 'units', 'meters' )
3684	CALL handle_netcdf_error( 'netcdf', 278 )
3685
3686	!
3687	!-- Define x-axis
3688	nc_stat = NF90_DEF_DIM( id_set_sp, 'k_x', nx/2, id_dim_x_sp )
3689	CALL handle_netcdf_error( 'netcdf', 279 )
3690
3691	nc_stat = NF90_DEF_VAR( id_set_sp, 'k_x', NF90_DOUBLE, id_dim_x_sp, &
3692	id_var_x_sp )
3693	CALL handle_netcdf_error( 'netcdf', 280 )
3694
3695	nc_stat = NF90_PUT_ATT( id_set_sp, id_var_x_sp, 'units', 'm-1' )
3696	CALL handle_netcdf_error( 'netcdf', 281 )
3697
3698	!
3699	!-- Define y-axis
3700	nc_stat = NF90_DEF_DIM( id_set_sp, 'k_y', ny/2, id_dim_y_sp )
3701	CALL handle_netcdf_error( 'netcdf', 282 )
3702
3703	nc_stat = NF90_DEF_VAR( id_set_sp, 'k_y', NF90_DOUBLE, id_dim_y_sp, &
3704	id_var_y_sp )
3705	CALL handle_netcdf_error( 'netcdf', 283 )
3706
3707	nc_stat = NF90_PUT_ATT( id_set_sp, id_var_y_sp, 'units', 'm-1' )
3708	CALL handle_netcdf_error( 'netcdf', 284 )
3709
3710	!
3711	!-- Define the variables
3712	var_list = ';'
3713	i = 1
3714	DO WHILE ( data_output_sp(i) /= ' ' .AND. i <= 10 )
3715	!
3716	!-- First check for the vertical grid
3717	found = .TRUE.
3718	SELECT CASE ( data_output_sp(i) )
3719	!
3720	!-- Most variables are defined on the zu levels
3721	CASE ( 'e', 'lpt', 'p', 'pc', 'pr', 'pt', 'q', 'ql', 'ql_c', &
3722	'ql_v', 'ql_vp', 'qv', 'rho', 's', 'sa', 'u', 'v', 'vpt' )
3723
3724	grid_z = 'zu'
3725	!
3726	!-- zw levels
3727	CASE ( 'w' )
3728
3729	grid_z = 'zw'
3730
3731	CASE DEFAULT
3732	!
3733	!-- Check for user-defined quantities (found, grid_x and grid_y
3734	!-- are dummies)
3735	CALL user_define_netcdf_grid( data_output_sp(i), found, &
3736	grid_x, grid_y, grid_z )
3737
3738	END SELECT
3739
3740	IF ( INDEX( spectra_direction(i), 'x' ) /= 0 ) THEN
3741
3742	!
3743	!-- Define the variable
3744	netcdf_var_name = TRIM( data_output_sp(i) ) // '_x'
3745	IF ( TRIM( grid_z ) == 'zw' ) THEN
3746	nc_stat = NF90_DEF_VAR( id_set_sp, netcdf_var_name, &
3747	nc_precision(7), (/ id_dim_x_sp, &
3748	id_dim_zw_sp, id_dim_time_sp /), &
3749	id_var_dospx(i) )
3750	ELSE
3751	nc_stat = NF90_DEF_VAR( id_set_sp, netcdf_var_name, &
3752	nc_precision(7), (/ id_dim_x_sp, &
3753	id_dim_zu_sp, id_dim_time_sp /), &
3754	id_var_dospx(i) )
3755	ENDIF
3756	CALL handle_netcdf_error( 'netcdf', 285 )
3757
3758	nc_stat = NF90_PUT_ATT( id_set_sp, id_var_dospx(i), &
3759	'long_name', netcdf_var_name )
3760	CALL handle_netcdf_error( 'netcdf', 286 )
3761
3762	nc_stat = NF90_PUT_ATT( id_set_sp, id_var_dospx(i), &
3763	'units', 'unknown' )
3764	CALL handle_netcdf_error( 'netcdf', 287 )
3765
3766	var_list = TRIM( var_list ) // TRIM( netcdf_var_name ) // ';'
3767
3768	ENDIF
3769
3770	IF ( INDEX( spectra_direction(i), 'y' ) /= 0 ) THEN
3771
3772	!
3773	!-- Define the variable
3774	netcdf_var_name = TRIM( data_output_sp(i) ) // '_y'
3775	IF ( TRIM( grid_z ) == 'zw' ) THEN
3776	nc_stat = NF90_DEF_VAR( id_set_sp, netcdf_var_name, &
3777	nc_precision(7), (/ id_dim_y_sp, &
3778	id_dim_zw_sp, id_dim_time_sp /), &
3779	id_var_dospy(i) )
3780	ELSE
3781	nc_stat = NF90_DEF_VAR( id_set_sp, netcdf_var_name, &
3782	nc_precision(7), (/ id_dim_y_sp, &
3783	id_dim_zu_sp, id_dim_time_sp /), &
3784	id_var_dospy(i) )
3785	ENDIF
3786	CALL handle_netcdf_error( 'netcdf', 288 )
3787
3788	nc_stat = NF90_PUT_ATT( id_set_sp, id_var_dospy(i), &
3789	'long_name', netcdf_var_name )
3790	CALL handle_netcdf_error( 'netcdf', 289 )
3791
3792	nc_stat = NF90_PUT_ATT( id_set_sp, id_var_dospy(i), &
3793	'units', 'unknown' )
3794	CALL handle_netcdf_error( 'netcdf', 290 )
3795
3796	var_list = TRIM( var_list ) // TRIM( netcdf_var_name ) // ';'
3797
3798	ENDIF
3799
3800	i = i + 1
3801
3802	ENDDO
3803
3804	!
3805	!-- Write the list of variables as global attribute (this is used by
3806	!-- restart runs)
3807	nc_stat = NF90_PUT_ATT( id_set_sp, NF90_GLOBAL, 'VAR_LIST', var_list )
3808	CALL handle_netcdf_error( 'netcdf', 291 )
3809
3810	!
3811	!-- Leave NetCDF define mode
3812	nc_stat = NF90_ENDDEF( id_set_sp )
3813	CALL handle_netcdf_error( 'netcdf', 292 )
3814
3815	!
3816	!-- Write axis data: zu_sp, zw_sp, k_x, k_y
3817	ALLOCATE( netcdf_data(1:ns) )
3818
3819	!
3820	!-- Write zu data
3821	netcdf_data(1:ns) = zu( comp_spectra_level(1:ns) )
3822	nc_stat = NF90_PUT_VAR( id_set_sp, id_var_zu_sp, netcdf_data, &
3823	start = (/ 1 /), count = (/ ns /) )
3824	CALL handle_netcdf_error( 'netcdf', 293 )
3825
3826	!
3827	!-- Write zw data
3828	netcdf_data(1:ns) = zw( comp_spectra_level(1:ns) )
3829	nc_stat = NF90_PUT_VAR( id_set_sp, id_var_zw_sp, netcdf_data, &
3830	start = (/ 1 /), count = (/ ns /) )
3831	CALL handle_netcdf_error( 'netcdf', 294 )
3832
3833	DEALLOCATE( netcdf_data )
3834
3835	!
3836	!-- Write data for x and y axis (wavenumbers)
3837	ALLOCATE( netcdf_data(nx/2) )
3838	DO i = 1, nx/2
3839	netcdf_data(i) = 2.0 * pi * i / ( dx * ( nx + 1 ) )
3840	ENDDO
3841
3842	nc_stat = NF90_PUT_VAR( id_set_sp, id_var_x_sp, netcdf_data, &
3843	start = (/ 1 /), count = (/ nx/2 /) )
3844	CALL handle_netcdf_error( 'netcdf', 295 )
3845
3846	DEALLOCATE( netcdf_data )
3847
3848	ALLOCATE( netcdf_data(ny/2) )
3849	DO i = 1, ny/2
3850	netcdf_data(i) = 2.0 * pi * i / ( dy * ( ny + 1 ) )
3851	ENDDO
3852
3853	nc_stat = NF90_PUT_VAR( id_set_sp, id_var_y_sp, netcdf_data, &
3854	start = (/ 1 /), count = (/ ny/2 /) )
3855	CALL handle_netcdf_error( 'netcdf', 296 )
3856
3857	DEALLOCATE( netcdf_data )
3858
3859
3860	CASE ( 'sp_ext' )
3861
3862	!
3863	!-- Get the list of variables and compare with the actual run.
3864	!-- First var_list_old has to be reset, since GET_ATT does not assign
3865	!-- trailing blanks.
3866	var_list_old = ' '
3867	nc_stat = NF90_GET_ATT( id_set_sp, NF90_GLOBAL, 'VAR_LIST', &
3868	var_list_old )
3869	CALL handle_netcdf_error( 'netcdf', 297 )
3870	var_list = ';'
3871	i = 1
3872	DO WHILE ( data_output_sp(i) /= ' ' .AND. i <= 10 )
3873
3874	IF ( INDEX( spectra_direction(i), 'x' ) /= 0 ) THEN
3875	netcdf_var_name = TRIM( data_output_sp(i) ) // '_x'
3876	var_list = TRIM( var_list ) // TRIM( netcdf_var_name ) // ';'
3877	ENDIF
3878
3879	IF ( INDEX( spectra_direction(i), 'y' ) /= 0 ) THEN
3880	netcdf_var_name = TRIM( data_output_sp(i) ) // '_y'
3881	var_list = TRIM( var_list ) // TRIM( netcdf_var_name ) // ';'
3882	ENDIF
3883
3884	i = i + 1
3885
3886	ENDDO
3887
3888	IF ( TRIM( var_list ) /= TRIM( var_list_old ) ) THEN
3889	message_string = 'NetCDF file for spectra ' // &
3890	'from previous run found,' // &
3891	'& but this file cannot be extended due to' // &
3892	' variable mismatch.' // &
3893	'&New file is created instead.'
3894	CALL message( 'define_netcdf_header', 'PA0260', 0, 1, 0, 6, 0 )
3895	extend = .FALSE.
3896	RETURN
3897	ENDIF
3898
3899	!
3900	!-- Determine the number of current vertical levels for which spectra
3901	!-- shall be output
3902	ns = 1
3903	DO WHILE ( comp_spectra_level(ns) /= 999999 .AND. ns <= 100 )
3904	ns = ns + 1
3905	ENDDO
3906	ns = ns - 1
3907
3908	!
3909	!-- Get and compare the number of vertical levels
3910	nc_stat = NF90_INQ_VARID( id_set_sp, 'zu_sp', id_var_zu_sp )
3911	CALL handle_netcdf_error( 'netcdf', 298 )
3912
3913	nc_stat = NF90_INQUIRE_VARIABLE( id_set_sp, id_var_zu_sp, &
3914	dimids = id_dim_zu_sp_old )
3915	CALL handle_netcdf_error( 'netcdf', 299 )
3916	id_dim_zu_sp = id_dim_zu_sp_old(1)
3917
3918	nc_stat = NF90_INQUIRE_DIMENSION( id_set_sp, id_dim_zu_sp, &
3919	len = ns_old )
3920	CALL handle_netcdf_error( 'netcdf', 300 )
3921
3922	IF ( ns /= ns_old ) THEN
3923	message_string = 'NetCDF file for spectra ' // &
3924	' from previous run found,' // &
3925	'&but this file cannot be extended due to' // &
3926	' mismatch in number of' // &
3927	'&vertical levels.' // &
3928	'&New file is created instead.'
3929	CALL message( 'define_netcdf_header', 'PA0261', 0, 1, 0, 6, 0 )
3930	extend = .FALSE.
3931	RETURN
3932	ENDIF
3933
3934	!
3935	!-- Get and compare the heights of the cross sections
3936	ALLOCATE( netcdf_data(1:ns_old) )
3937
3938	nc_stat = NF90_GET_VAR( id_set_sp, id_var_zu_sp, netcdf_data )
3939	CALL handle_netcdf_error( 'netcdf', 301 )
3940
3941	DO i = 1, ns
3942	IF ( zu(comp_spectra_level(i)) /= netcdf_data(i) ) THEN
3943	message_string = 'NetCDF file for spectra ' // &
3944	' from previous run found,' // &
3945	'&but this file cannot be extended due to' // &
3946	' mismatch in heights of' // &
3947	'&vertical levels.' // &
3948	'&New file is created instead.'
3949	CALL message( 'define_netcdf_header', 'PA0262', 0, 1, 0, 6, 0 )
3950	extend = .FALSE.
3951	RETURN
3952	ENDIF
3953	ENDDO
3954
3955	DEALLOCATE( netcdf_data )
3956
3957	!
3958	!-- Get the id of the time coordinate (unlimited coordinate) and its
3959	!-- last index on the file. The next time level is plsp..count+1.
3960	!-- The current time must be larger than the last output time
3961	!-- on the file.
3962	nc_stat = NF90_INQ_VARID( id_set_sp, 'time', id_var_time_sp )
3963	CALL handle_netcdf_error( 'netcdf', 302 )
3964
3965	nc_stat = NF90_INQUIRE_VARIABLE( id_set_sp, id_var_time_sp, &
3966	dimids = id_dim_time_old )
3967	CALL handle_netcdf_error( 'netcdf', 303 )
3968	id_dim_time_sp = id_dim_time_old(1)
3969
3970	nc_stat = NF90_INQUIRE_DIMENSION( id_set_sp, id_dim_time_sp, &
3971	len = dosp_time_count )
3972	CALL handle_netcdf_error( 'netcdf', 304 )
3973
3974	nc_stat = NF90_GET_VAR( id_set_sp, id_var_time_sp, &
3975	last_time_coordinate, &
3976	start = (/ dosp_time_count /), &
3977	count = (/ 1 /) )
3978	CALL handle_netcdf_error( 'netcdf', 305 )
3979
3980	IF ( last_time_coordinate(1) >= simulated_time ) THEN
3981	message_string = 'NetCDF file for spectra ' // &
3982	'from previous run found,' // &
3983	'&but this file cannot be extended becaus' // &
3984	'e the current output time' // &
3985	'&is less or equal than the last output t' // &
3986	'ime on this file.' // &
3987	'&New file is created instead.'
3988	CALL message( 'define_netcdf_header', 'PA0263', 0, 1, 0, 6, 0 )
3989	dosp_time_count = 0
3990	extend = .FALSE.
3991	RETURN
3992	ENDIF
3993
3994	!
3995	!-- Dataset seems to be extendable.
3996	!-- Now get the variable ids.
3997	i = 1
3998	DO WHILE ( data_output_sp(i) /= ' ' .AND. i <= 10 )
3999
4000	IF ( INDEX( spectra_direction(i), 'x' ) /= 0 ) THEN
4001	netcdf_var_name = TRIM( data_output_sp(i) ) // '_x'
4002	nc_stat = NF90_INQ_VARID( id_set_sp, netcdf_var_name, &
4003	id_var_dospx(i) )
4004	CALL handle_netcdf_error( 'netcdf', 306 )
4005	ENDIF
4006
4007	IF ( INDEX( spectra_direction(i), 'y' ) /= 0 ) THEN
4008	netcdf_var_name = TRIM( data_output_sp(i) ) // '_y'
4009	nc_stat = NF90_INQ_VARID( id_set_sp, netcdf_var_name, &
4010	id_var_dospy(i) )
4011	CALL handle_netcdf_error( 'netcdf', 307 )
4012	ENDIF
4013
4014	i = i + 1
4015
4016	ENDDO
4017
4018	!
4019	!-- Update the title attribute on file
4020	!-- In order to avoid 'data mode' errors if updated attributes are larger
4021	!-- than their original size, NF90_PUT_ATT is called in 'define mode'
4022	!-- enclosed by NF90_REDEF and NF90_ENDDEF calls. This implies a possible
4023	!-- performance loss due to data copying; an alternative strategy would be
4024	!-- to ensure equal attribute size in a job chain. Maybe revise later.
4025	nc_stat = NF90_REDEF( id_set_sp )
4026	CALL handle_netcdf_error( 'netcdf', 441 )
4027	IF ( averaging_interval_sp /= 0.0 ) THEN
4028	WRITE (time_average_text,'('', '',F7.1,'' s average'')') &
4029	averaging_interval_sp
4030	nc_stat = NF90_PUT_ATT( id_set_sp, NF90_GLOBAL, 'title', &
4031	TRIM( run_description_header ) // &
4032	TRIM( time_average_text ) )
4033	CALL handle_netcdf_error( 'netcdf', 308 )
4034
4035	WRITE ( time_average_text,'(F7.1,'' s avg'')' ) averaging_interval_sp
4036	nc_stat = NF90_PUT_ATT( id_set_sp, NF90_GLOBAL, 'time_avg', &
4037	TRIM( time_average_text ) )
4038	ELSE
4039	nc_stat = NF90_PUT_ATT( id_set_sp, NF90_GLOBAL, 'title', &
4040	TRIM( run_description_header ) )
4041	ENDIF
4042	CALL handle_netcdf_error( 'netcdf', 309 )
4043	nc_stat = NF90_ENDDEF( id_set_sp )
4044	CALL handle_netcdf_error( 'netcdf', 442 )
4045	message_string = 'NetCDF file for spectra ' // &
4046	'from previous run found.' // &
4047	'&This file will be extended.'
4048	CALL message( 'define_netcdf_header', 'PA0264', 0, 0, 0, 6, 0 )
4049
4050
4051	CASE ( 'pt_new' )
4052
4053	!
4054	!-- Define some global attributes of the dataset
4055	nc_stat = NF90_PUT_ATT( id_set_prt, NF90_GLOBAL, 'title', &
4056	TRIM( run_description_header ) )
4057	CALL handle_netcdf_error( 'netcdf', 310 )
4058
4059	!
4060	!-- Define time coordinate for particles (unlimited dimension)
4061	nc_stat = NF90_DEF_DIM( id_set_prt, 'time', NF90_UNLIMITED, &
4062	id_dim_time_prt )
4063	CALL handle_netcdf_error( 'netcdf', 311 )
4064
4065	nc_stat = NF90_DEF_VAR( id_set_prt, 'time', NF90_DOUBLE, &
4066	id_dim_time_prt, id_var_time_prt )
4067	CALL handle_netcdf_error( 'netcdf', 312 )
4068
4069	nc_stat = NF90_PUT_ATT( id_set_prt, id_var_time_prt, 'units', &
4070	'seconds' )
4071	CALL handle_netcdf_error( 'netcdf', 313 )
4072
4073	!
4074	!-- Define particle coordinate (maximum particle number)
4075	IF ( netcdf_data_format < 3 ) THEN
4076	nc_stat = NF90_DEF_DIM( id_set_prt, 'particle_number', &
4077	maximum_number_of_particles, id_dim_prtnum)
4078	ELSE
4079	!
4080	!-- NetCDF4 allows more than one unlimited dimension
4081	nc_stat = NF90_DEF_DIM( id_set_prt, 'particle_number', &
4082	NF90_UNLIMITED, id_dim_prtnum)
4083	ENDIF
4084	CALL handle_netcdf_error( 'netcdf', 314 )
4085
4086	nc_stat = NF90_DEF_VAR( id_set_prt, 'particle_number', NF90_DOUBLE, &
4087	id_dim_prtnum, id_var_prtnum )
4088	CALL handle_netcdf_error( 'netcdf', 315 )
4089
4090	nc_stat = NF90_PUT_ATT( id_set_prt, id_var_prtnum, 'units', &
4091	'particle number' )
4092	CALL handle_netcdf_error( 'netcdf', 316 )
4093
4094	!
4095	!-- Define variable which contains the real number of particles in use
4096	nc_stat = NF90_DEF_VAR( id_set_prt, 'real_num_of_prt', NF90_INT, &
4097	id_dim_time_prt, id_var_rnop_prt )
4098	CALL handle_netcdf_error( 'netcdf', 317 )
4099
4100	nc_stat = NF90_PUT_ATT( id_set_prt, id_var_rnop_prt, 'units', &
4101	'particle number' )
4102	CALL handle_netcdf_error( 'netcdf', 318 )
4103
4104	!
4105	!-- Define the variables
4106	DO i = 1, 17
4107
4108	nc_stat = NF90_DEF_VAR( id_set_prt, prt_var_names(i), &
4109	nc_precision(8), &
4110	(/ id_dim_prtnum, id_dim_time_prt /), &
4111	id_var_prt(i) )
4112	CALL handle_netcdf_error( 'netcdf', 319 )
4113
4114	nc_stat = NF90_PUT_ATT( id_set_prt, id_var_prt(i), &
4115	'long_name', TRIM( prt_var_names(i) ) )
4116	CALL handle_netcdf_error( 'netcdf', 320 )
4117
4118	nc_stat = NF90_PUT_ATT( id_set_prt, id_var_prt(i), &
4119	'units', TRIM( prt_var_units(i) ) )
4120	CALL handle_netcdf_error( 'netcdf', 321 )
4121
4122	ENDDO
4123
4124	!
4125	!-- Leave NetCDF define mode
4126	nc_stat = NF90_ENDDEF( id_set_prt )
4127	CALL handle_netcdf_error( 'netcdf', 322 )
4128
4129
4130	CASE ( 'pt_ext' )
4131
4132	!
4133	!-- Get the id of the time coordinate (unlimited coordinate) and its
4134	!-- last index on the file. The next time level is prt..count+1.
4135	!-- The current time must be larger than the last output time
4136	!-- on the file.
4137	nc_stat = NF90_INQ_VARID( id_set_prt, 'time', id_var_time_prt )
4138	CALL handle_netcdf_error( 'netcdf', 323 )
4139
4140	nc_stat = NF90_INQUIRE_VARIABLE( id_set_prt, id_var_time_prt, &
4141	dimids = id_dim_time_old )
4142	CALL handle_netcdf_error( 'netcdf', 324 )
4143	id_dim_time_prt = id_dim_time_old(1)
4144
4145	nc_stat = NF90_INQUIRE_DIMENSION( id_set_prt, id_dim_time_prt, &
4146	len = prt_time_count )
4147	CALL handle_netcdf_error( 'netcdf', 325 )
4148
4149	nc_stat = NF90_GET_VAR( id_set_prt, id_var_time_prt, &
4150	last_time_coordinate, &
4151	start = (/ prt_time_count /), &
4152	count = (/ 1 /) )
4153	CALL handle_netcdf_error( 'netcdf', 326 )
4154
4155	IF ( last_time_coordinate(1) >= simulated_time ) THEN
4156	message_string = 'NetCDF file for particles ' // &
4157	'from previous run found,' // &
4158	'&but this file cannot be extended becaus' // &
4159	'e the current output time' // &
4160	'&is less or equal than the last output t' // &
4161	'ime on this file.' // &
4162	'&New file is created instead.'
4163	CALL message( 'define_netcdf_header', 'PA0265', 0, 1, 0, 6, 0 )
4164	prt_time_count = 0
4165	extend = .FALSE.
4166	RETURN
4167	ENDIF
4168
4169	!
4170	!-- Dataset seems to be extendable.
4171	!-- Now get the variable ids.
4172	nc_stat = NF90_INQ_VARID( id_set_prt, 'real_num_of_prt', &
4173	id_var_rnop_prt )
4174	CALL handle_netcdf_error( 'netcdf', 327 )
4175
4176	DO i = 1, 17
4177
4178	nc_stat = NF90_INQ_VARID( id_set_prt, prt_var_names(i), &
4179	id_var_prt(i) )
4180	CALL handle_netcdf_error( 'netcdf', 328 )
4181
4182	ENDDO
4183
4184	message_string = 'NetCDF file for particles ' // &
4185	'from previous run found.' // &
4186	'&This file will be extended.'
4187	CALL message( 'define_netcdf_header', 'PA0266', 0, 0, 0, 6, 0 )
4188
4189
4190
4191	CASE ( 'ps_new' )
4192
4193	!
4194	!-- Define some global attributes of the dataset
4195	nc_stat = NF90_PUT_ATT( id_set_pts, NF90_GLOBAL, 'title', &
4196	TRIM( run_description_header ) )
4197	CALL handle_netcdf_error( 'netcdf', 396 )
4198
4199	!
4200	!-- Define time coordinate for particle time series (unlimited dimension)
4201	nc_stat = NF90_DEF_DIM( id_set_pts, 'time', NF90_UNLIMITED, &
4202	id_dim_time_pts )
4203	CALL handle_netcdf_error( 'netcdf', 397 )
4204
4205	nc_stat = NF90_DEF_VAR( id_set_pts, 'time', NF90_DOUBLE, &
4206	id_dim_time_pts, id_var_time_pts )
4207	CALL handle_netcdf_error( 'netcdf', 398 )
4208
4209	nc_stat = NF90_PUT_ATT( id_set_pts, id_var_time_pts, 'units', &
4210	'seconds')
4211	CALL handle_netcdf_error( 'netcdf', 399 )
4212
4213	!
4214	!-- Define the variables. If more than one particle group is defined,
4215	!-- define seperate variables for each group
4216	var_list = ';'
4217	DO i = 1, dopts_num
4218
4219	DO j = 0, number_of_particle_groups
4220
4221	IF ( j == 0 ) THEN
4222	suffix1 = ''
4223	ELSE
4224	WRITE ( suffix1, '(''_'',I2.2)' ) j
4225	ENDIF
4226
4227	nc_stat = NF90_DEF_VAR( id_set_pts, &
4228	TRIM( dopts_label(i) ) // suffix1, &
4229	nc_precision(6), &
4230	(/ id_dim_time_pts /), &
4231	id_var_dopts(i,j) )
4232	CALL handle_netcdf_error( 'netcdf', 400 )
4233
4234	IF ( j == 0 ) THEN
4235	nc_stat = NF90_PUT_ATT( id_set_pts, id_var_dopts(i,j), &
4236	'long_name', &
4237	TRIM( dopts_label(i) ) )
4238	ELSE
4239	nc_stat = NF90_PUT_ATT( id_set_pts, id_var_dopts(i,j), &
4240	'long_name', &
4241	TRIM( dopts_label(i) ) // ' PG ' // &
4242	suffix1(2:3) )
4243	ENDIF
4244	CALL handle_netcdf_error( 'netcdf', 401 )
4245
4246	nc_stat = NF90_PUT_ATT( id_set_pts, id_var_dopts(i,j), &
4247	'units', TRIM( dopts_unit(i) ) )
4248	CALL handle_netcdf_error( 'netcdf', 402 )
4249
4250	var_list = TRIM( var_list ) // TRIM( dopts_label(i) ) // &
4251	suffix1 // ';'
4252
4253	IF ( number_of_particle_groups == 1 ) EXIT
4254
4255	ENDDO
4256
4257	ENDDO
4258
4259	!
4260	!-- Write the list of variables as global attribute (this is used by
4261	!-- restart runs)
4262	nc_stat = NF90_PUT_ATT( id_set_pts, NF90_GLOBAL, 'VAR_LIST', &
4263	var_list )
4264	CALL handle_netcdf_error( 'netcdf', 403 )
4265
4266
4267	!
4268	!-- Leave NetCDF define mode
4269	nc_stat = NF90_ENDDEF( id_set_pts )
4270	CALL handle_netcdf_error( 'netcdf', 404 )
4271
4272
4273	CASE ( 'ps_ext' )
4274
4275	!
4276	!-- Get the list of variables and compare with the actual run.
4277	!-- First var_list_old has to be reset, since GET_ATT does not assign
4278	!-- trailing blanks.
4279	var_list_old = ' '
4280	nc_stat = NF90_GET_ATT( id_set_pts, NF90_GLOBAL, 'VAR_LIST', &
4281	var_list_old )
4282	CALL handle_netcdf_error( 'netcdf', 405 )
4283
4284	var_list = ';'
4285	i = 1
4286	DO i = 1, dopts_num
4287
4288	DO j = 0, number_of_particle_groups
4289
4290	IF ( j == 0 ) THEN
4291	suffix1 = ''
4292	ELSE
4293	WRITE ( suffix1, '(''_'',I2.2)' ) j
4294	ENDIF
4295
4296	var_list = TRIM( var_list ) // TRIM( dopts_label(i) ) // &
4297	suffix1 // ';'
4298
4299	IF ( number_of_particle_groups == 1 ) EXIT
4300
4301	ENDDO
4302
4303	ENDDO
4304
4305	IF ( TRIM( var_list ) /= TRIM( var_list_old ) ) THEN
4306	message_string = 'NetCDF file for particle time series ' // &
4307	'from previous run found,' // &
4308	'& but this file cannot be extended due to' // &
4309	' variable mismatch.' // &
4310	'&New file is created instead.'
4311	CALL message( 'define_netcdf_header', 'PA0267', 0, 1, 0, 6, 0 )
4312	extend = .FALSE.
4313	RETURN
4314	ENDIF
4315
4316	!
4317	!-- Get the id of the time coordinate (unlimited coordinate) and its
4318	!-- last index on the file. The next time level is dots..count+1.
4319	!-- The current time must be larger than the last output time
4320	!-- on the file.
4321	nc_stat = NF90_INQ_VARID( id_set_pts, 'time', id_var_time_pts )
4322	CALL handle_netcdf_error( 'netcdf', 406 )
4323
4324	nc_stat = NF90_INQUIRE_VARIABLE( id_set_pts, id_var_time_pts, &
4325	dimids = id_dim_time_old )
4326	CALL handle_netcdf_error( 'netcdf', 407 )
4327	id_dim_time_pts = id_dim_time_old(1)
4328
4329	nc_stat = NF90_INQUIRE_DIMENSION( id_set_pts, id_dim_time_pts, &
4330	len = dopts_time_count )
4331	CALL handle_netcdf_error( 'netcdf', 408 )
4332
4333	nc_stat = NF90_GET_VAR( id_set_pts, id_var_time_pts, &
4334	last_time_coordinate, &
4335	start = (/ dopts_time_count /), &
4336	count = (/ 1 /) )
4337	CALL handle_netcdf_error( 'netcdf', 409 )
4338
4339	IF ( last_time_coordinate(1) >= simulated_time ) THEN
4340	message_string = 'NetCDF file for particle time series ' // &
4341	'from previous run found,' // &
4342	'&but this file cannot be extended becaus' // &
4343	'e the current output time' // &
4344	'&is less or equal than the last output t' // &
4345	'ime on this file.' // &
4346	'&New file is created instead.'
4347	CALL message( 'define_netcdf_header', 'PA0268', 0, 1, 0, 6, 0 )
4348	dopts_time_count = 0
4349	extend = .FALSE.
4350	RETURN
4351	ENDIF
4352
4353	!
4354	!-- Dataset seems to be extendable.
4355	!-- Now get the variable ids
4356	i = 1
4357	DO i = 1, dopts_num
4358
4359	DO j = 0, number_of_particle_groups
4360
4361	IF ( j == 0 ) THEN
4362	suffix1 = ''
4363	ELSE
4364	WRITE ( suffix1, '(''_'',I2.2)' ) j
4365	ENDIF
4366
4367	netcdf_var_name = TRIM( dopts_label(i) ) // suffix1
4368
4369	nc_stat = NF90_INQ_VARID( id_set_pts, netcdf_var_name, &
4370	id_var_dopts(i,j) )
4371	CALL handle_netcdf_error( 'netcdf', 410 )
4372
4373	IF ( number_of_particle_groups == 1 ) EXIT
4374
4375	ENDDO
4376
4377	ENDDO
4378
4379	!
4380	!-- Update the title attribute on file
4381	!-- In order to avoid 'data mode' errors if updated attributes are larger
4382	!-- than their original size, NF90_PUT_ATT is called in 'define mode'
4383	!-- enclosed by NF90_REDEF and NF90_ENDDEF calls. This implies a possible
4384	!-- performance loss due to data copying; an alternative strategy would be
4385	!-- to ensure equal attribute size in a job chain. Maybe revise later.
4386	nc_stat = NF90_REDEF( id_set_pts )
4387	CALL handle_netcdf_error( 'netcdf', 443 )
4388	nc_stat = NF90_PUT_ATT( id_set_pts, NF90_GLOBAL, 'title', &
4389	TRIM( run_description_header ) )
4390	CALL handle_netcdf_error( 'netcdf', 411 )
4391	nc_stat = NF90_ENDDEF( id_set_pts )
4392	CALL handle_netcdf_error( 'netcdf', 444 )
4393	message_string = 'NetCDF file for particle time series ' // &
4394	'from previous run found.' // &
4395	'&This file will be extended.'
4396	CALL message( 'define_netcdf_header', 'PA0269', 0, 0, 0, 6, 0 )
4397
4398
4399	CASE DEFAULT
4400
4401	message_string = 'mode "' // TRIM( mode) // '" not supported'
4402	CALL message( 'define_netcdf_header', 'PA0270', 0, 0, 0, 6, 0 )
4403
4404	END SELECT
4405
4406	#endif
4407	END SUBROUTINE define_netcdf_header
4408
4409
4410	SUBROUTINE handle_netcdf_error( routine_name, errno )
4411	#if defined( __netcdf )
4412
4413	!------------------------------------------------------------------------------!
4414	!
4415	! Description:
4416	! ------------
4417	! Prints out a text message corresponding to the current status.
4418	!------------------------------------------------------------------------------!
4419
4420	USE control_parameters
4421	USE netcdf
4422	USE netcdf_control
4423	USE pegrid
4424
4425	IMPLICIT NONE
4426
4427	CHARACTER(LEN=6) :: message_identifier
4428	CHARACTER(LEN=*) :: routine_name
4429
4430	INTEGER :: errno
4431
4432	IF ( nc_stat /= NF90_NOERR ) THEN
4433
4434	WRITE( message_identifier, '(''NC'',I4.4)' ) errno
4435	message_string = TRIM( NF90_STRERROR( nc_stat ) )
4436
4437	CALL message( routine_name, message_identifier, 2, 2, 0, 6, 1 )
4438
4439	ENDIF
4440
4441	#endif
4442	END SUBROUTINE handle_netcdf_error

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

Download in other formats:

| Impressum | ©Leibniz Universität Hannover |