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

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