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

Last change on this file since 993 was 993, checked in by hoffmann, 9 years ago

last commit documented

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