source: palm/trunk/SOURCE/netcdf_interface_mod.f90 @ 4313

Last change on this file since 4313 was 4307, checked in by maronga, 18 months ago

your commit message

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