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

Last change on this file since 3485 was 3485, checked in by gronemeier, 3 years ago

Add information about reference point to output files; corrected calculation of longitude values in case crs is not defined in input file

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