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

Last change on this file since 4400 was 4400, checked in by suehring, 20 months ago

Revision of the virtual-measurement module: data input from NetCDF file; removed binary output - instead parallel NetCDF output using the new data-output module; variable attributes added; further variables added that can be sampled, file connections added; Functions for coordinate transformation moved to basic_constants_and_equations; netcdf_data_input_mod: unused routines netcdf_data_input_att and netcdf_data_input_var removed; new routines to inquire fill values added; Preprocessing script (palm_cvd) to setup virtual-measurement input files provided; postprocessor combine_virtual_measurements deleted

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