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

Last change on this file since 565 was 565, checked in by helmke, 11 years ago

last commit documented

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