source: palm/trunk/SOURCE/netcdf_data_input_mod.f90 @ 3942

Last change on this file since 3942 was 3942, checked in by kanani, 2 years ago

Fix too short driver attribute lengths, and individualize error messages (netcdf_data_input_mod, netcdf_interface_mod)

  • Property svn:keywords set to Id
File size: 282.8 KB
Line 
1!> @file netcdf_data_input_mod.f90
2!------------------------------------------------------------------------------!
3! This file is part of the PALM model system.
4!
5! PALM is free software: you can redistribute it and/or modify it under the
6! terms of the GNU General Public License as published by the Free Software
7! Foundation, either version 3 of the License, or (at your option) any later
8! version.
9!
10! PALM is distributed in the hope that it will be useful, but WITHOUT ANY
11! WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
12! A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
13!
14! You should have received a copy of the GNU General Public License along with
15! PALM. If not, see <http://www.gnu.org/licenses/>.
16!
17! Copyright 1997-2019 Leibniz Universitaet Hannover
18!------------------------------------------------------------------------------!
19!
20! Current revisions:
21! -----------------
22!
23!
24! Former revisions:
25! -----------------
26! $Id: netcdf_data_input_mod.f90 3942 2019-04-30 13:08:30Z kanani $
27! Fix: increase LEN of all NetCDF attribute values (caused crash in
28! netcdf_create_global_atts due to insufficient length)
29!
30! 3941 2019-04-30 09:48:33Z suehring
31! Move check for grid dimension to an earlier point in time when first array
32! is read.
33! Improve checks for building types / IDs with respect to 2D/3D buildings.
34!
35! 3885 2019-04-11 11:29:34Z kanani
36! Changes related to global restructuring of location messages and introduction
37! of additional debug messages
38!
39! 3864 2019-04-05 09:01:56Z monakurppa
40! get_variable_4d_to_3d_real modified to enable read in data of type
41! data(t,y,x,n) one timestep at a time + some routines made public
42!
43! 3855 2019-04-03 10:00:59Z suehring
44! Typo removed
45!
46! 3854 2019-04-02 16:59:33Z suehring
47! Bugfix in one of the checks. Typo removed.
48!
49! 3744 2019-02-15 18:38:58Z suehring
50! Enable mesoscale offline nesting for chemistry variables as well as
51! initialization of chemistry via dynamic input file.
52!
53! 3705 2019-01-29 19:56:39Z suehring
54! Interface for attribute input of 8-bit and 32-bit integer
55!
56! 3704 2019-01-29 19:51:41Z suehring
57! unused variables removed
58!
59! 3560 2018-11-23 09:20:21Z raasch
60! Some formatting adjustment
61!
62! 3556 2018-11-22 14:11:57Z suehring
63! variables documented and unused variables removed
64!
65! 3552 2018-11-22 10:28:35Z suehring
66! Revise ghost point exchange and resizing of input variables
67!
68! 3542 2018-11-20 17:04:13Z suehring
69! - read optional attributes from file
70! - set default origin_time
71!
72! 3518 2018-11-12 18:10:23Z suehring
73! Additional checks
74!
75! 3516 2018-11-12 15:49:39Z gronemeier
76! bugfix: - difference in z coordinate between file and PALM must be <1e-6
77!         - output of error 553 for all PEs
78!
79! 3498 2018-11-07 10:53:03Z gronemeier
80! Bugfix: print error message by processor which encounters the error
81!
82! 3485 2018-11-03 17:09:40Z gronemeier
83! - get central meridian from origin_lon if crs does not exist
84! - set default origin_lon to 0
85!
86! 3483 2018-11-02 14:19:26Z raasch
87! bugfix: misplaced directives for netCDF fixed
88!
89! 3474 2018-10-30 21:07:39Z kanani
90! Add UV exposure model input (Schrempf)
91!
92! 3472 2018-10-30 20:43:50Z suehring
93! Salsa implemented
94!
95! 3464 2018-10-30 18:08:55Z kanani
96! Define coordinate reference system (crs) and read from input dataset
97! Revise default values for reference coordinates
98!
99! 3459 2018-10-30 15:04:11Z gronemeier
100! from chemistry branch r3443, banzhafs, Russo:
101! Uncommented lines on dimension of surface_fractions
102! Removed par_emis_time_factor variable, moved to chem_emissions_mod
103! Initialized nspec and other emission variables at time of declaration
104! Modified EXPERT mode to PRE-PROCESSED mode
105! Introduced Chemistry static netcdf file
106! Added the routine for reading-in netcdf data for chemistry
107! Added routines to get_variable interface specific for chemistry files
108!
109! 3429 2018-10-25 13:04:23Z knoop
110! add default values of origin_x/y/z
111!
112! 3404 2018-10-23 13:29:11Z suehring
113! Consider time-dependent geostrophic wind components in offline nesting
114!
115! 3376 2018-10-19 10:15:32Z suehring
116! Additional check for consistent building initialization implemented
117!
118! 3347 2018-10-15 14:21:08Z suehring
119! Subroutine renamed
120!
121! 3257 2018-09-17 17:11:46Z suehring
122! (from branch resler)
123! Formatting
124!
125! 3298 2018-10-02 12:21:11Z kanani
126! Modified EXPERT mode to PRE-PROCESSED mode (Russo)
127! Introduced Chemistry static netcdf file (Russo)
128! Added the routine for reading-in netcdf data for chemistry (Russo)
129! Added routines to get_variable interface specific for chemistry files (Russo)
130!
131! 3257 2018-09-17 17:11:46Z suehring
132! Adjust checks for building_type and building_id, which is necessary after
133! topography filtering (building_type and id can be modified by the filtering).
134!
135! 3254 2018-09-17 10:53:57Z suehring
136! Additional check for surface_fractions and and checks for building_id and
137! building_type extended.
138!
139! 3241 2018-09-12 15:02:00Z raasch
140! unused variables removed
141!
142! 3215 2018-08-29 09:58:59Z suehring
143! - Separate input of soil properties from input of atmospheric data. This
144!   enables input of soil properties also in child domains without any
145!   dependence on atmospheric input
146! - Check for missing initial 1D/3D data in dynamic input file
147! - Revise checks for matching grid spacing in model and input file
148! - Bugfix, add netcdf4_parallel directive for collective read operation
149! - Revise error message numbers
150!
151! 3209 2018-08-27 16:58:37Z suehring
152! Read zsoil dimension length only if soil variables are provided
153!
154! 3183 2018-07-27 14:25:55Z suehring
155! Adjust input of dynamic driver according to revised Inifor version.
156! Replace simulated_time by time_since_reference_point.
157! Rename variables in mesoscale-offline nesting mode.
158!
159! 3182 2018-07-27 13:36:03Z suehring
160! Slightly revise check for surface_fraction in order to check only the relevant
161! fractions
162!
163! 3103 2018-07-04 17:30:52Z suehring
164! New check for negative terrain heights
165!
166! 3089 2018-06-27 13:20:38Z suehring
167! Revise call for message routine in case of local data inconsistencies.
168!
169! 3054 2018-06-01 16:08:59Z gronemeier
170! Bugfix: force an MPI abort if errors occur while reading building heights
171! from ASCII file
172!
173! 3053 2018-06-01 12:59:07Z suehring
174! Revise checks for variable surface_fraction
175!
176! 3051 2018-05-30 17:43:55Z suehring
177! - Speed-up NetCDF input
178! - Revise input routines and remove NetCDF input via IO-blocks since this is
179!   not working in parallel mode in case blocking collective read operations
180!   are done
181! - Temporarily revoke renaming of input variables in dynamic driver (tend_ug,
182!   tend_vg, zsoil) in order to keep dynamic input file working with current
183!   model version
184! - More detailed error messages created
185!
186! 3045 2018-05-28 07:55:41Z Giersch
187! Error messages revised
188!
189! 3041 2018-05-25 10:39:54Z gronemeier
190! Add data type for global file attributes
191! Add read of global attributes of static driver
192!
193! 3037 2018-05-24 10:39:29Z gronemeier
194! renamed 'depth' to 'zsoil'
195!
196! 3036 2018-05-24 10:18:26Z gronemeier
197! Revision of input vars according to UC2 data standard
198!  - renamed 'orography_2D' to 'zt'
199!  - renamed 'buildings_2D' to 'buildings_2d'
200!  - renamed 'buildings_3D' to 'buildings_3d'
201!  - renamed 'leaf_are_density' to 'lad'
202!  - renamed 'basal_are_density' to 'bad'
203!  - renamed 'root_are_density_lad' to 'root_area_dens_r'
204!  - renamed 'root_are_density_lsm' to 'root_area_dens_s'
205!  - renamed 'ls_forcing_ug' to 'tend_ug'
206!  - renamed 'ls_forcing_vg' to 'tend_vg'
207!
208! 3019 2018-05-13 07:05:43Z maronga
209! Improved reading speed of large NetCDF files
210!
211! 2963 2018-04-12 14:47:44Z suehring
212! - Revise checks for static input variables.
213! - Introduce index for vegetation/wall, pavement/green-wall and water/window
214!   surfaces, for clearer access of surface fraction, albedo, emissivity, etc. .
215!
216! 2958 2018-04-11 15:38:13Z suehring
217! Synchronize longitude and latitude between nested model domains, values are
218! taken from the root model.
219!
220! 2955 2018-04-09 15:14:01Z suehring
221! Extend checks for consistent setting of buildings, its ID and type.
222! Add log-points to measure CPU time of NetCDF data input.
223!
224! 2953 2018-04-09 11:26:02Z suehring
225! Bugfix in checks for initialization data
226!
227! 2947 2018-04-04 18:01:41Z suehring
228! Checks for dynamic input revised
229!
230! 2946 2018-04-04 17:01:23Z suehring
231! Bugfix for revision 2945, perform checks only if dynamic input file is
232! available.
233!
234! 2945 2018-04-04 16:27:14Z suehring
235! - Mimic for topography input slightly revised, in order to enable consistency
236!   checks
237! - Add checks for dimensions in dynamic input file and move already existing
238!   checks
239!
240! 2938 2018-03-27 15:52:42Z suehring
241! Initial read of geostrophic wind components from dynamic driver.
242!
243! 2773 2018-01-30 14:12:54Z suehring
244! Revise checks for surface_fraction.
245!
246! 2925 2018-03-23 14:54:11Z suehring
247! Check for further inconsistent settings of surface_fractions.
248! Some messages slightly rephrased and error numbers renamed.
249!
250! 2898 2018-03-15 13:03:01Z suehring
251! Check if each building has a type. Further, check if dimensions in static
252! input file match the model dimensions.
253!
254! 2897 2018-03-15 11:47:16Z suehring
255! Relax restrictions for topography input, terrain and building heights can be
256! input separately and are not mandatory any more.
257!
258! 2874 2018-03-13 10:55:42Z knoop
259! Bugfix: wrong placement of netcdf cpp-macros fixed
260!
261! 2794 2018-02-07 14:09:43Z knoop
262! Check if 3D building input is consistent to numeric grid.
263!
264! 2773 2018-01-30 14:12:54Z suehring
265! - Enable initialization with 3D topography.
266! - Move check for correct initialization in nesting mode to check_parameters.
267!
268! 2772 2018-01-29 13:10:35Z suehring
269! Initialization of simulation independent on land-surface model.
270!
271! 2746 2018-01-15 12:06:04Z suehring
272! Read plant-canopy variables independently on land-surface model usage
273!
274! 2718 2018-01-02 08:49:38Z maronga
275! Corrected "Former revisions" section
276!
277! 2711 2017-12-20 17:04:49Z suehring
278! Rename subroutine close_file to avoid double-naming.
279!
280! 2700 2017-12-15 14:12:35Z suehring
281!
282! 2696 2017-12-14 17:12:51Z kanani
283! Initial revision (suehring)
284!
285!
286!
287!
288! Authors:
289! --------
290! @author Matthias Suehring
291!
292! Description:
293! ------------
294!> Modulue contains routines to input data according to Palm input data
295!> standart using dynamic and static input files.
296!> @todo - Chemistry: revise reading of netcdf file and ajdust formatting according to standard!!!
297!> @todo - Order input alphabetically
298!> @todo - Revise error messages and error numbers
299!> @todo - Input of missing quantities (chemical species, emission rates)
300!> @todo - Defninition and input of still missing variable attributes
301!> @todo - Input of initial geostrophic wind profiles with cyclic conditions.
302!------------------------------------------------------------------------------!
303 MODULE netcdf_data_input_mod
304
305    USE control_parameters,                                                    &
306        ONLY:  coupling_char, io_blocks, io_group
307
308    USE cpulog,                                                                &
309        ONLY:  cpu_log, log_point_s
310
311    USE indices,                                                               &
312        ONLY:  nbgp
313
314    USE kinds
315
316#if defined ( __netcdf )
317    USE NETCDF
318#endif
319
320    USE pegrid
321
322    USE surface_mod,                                                           &
323        ONLY:  ind_pav_green, ind_veg_wall, ind_wat_win
324!
325!-- Define type for dimensions.
326    TYPE dims_xy
327       INTEGER(iwp) :: nx                             !< dimension length in x
328       INTEGER(iwp) :: ny                             !< dimension length in y
329       INTEGER(iwp) :: nz                             !< dimension length in z
330       REAL(wp), DIMENSION(:), ALLOCATABLE :: x       !< dimension array in x
331       REAL(wp), DIMENSION(:), ALLOCATABLE :: y       !< dimension array in y
332       REAL(wp), DIMENSION(:), ALLOCATABLE :: z       !< dimension array in z
333    END TYPE dims_xy
334!
335!-- Define data type for nesting in larger-scale models like COSMO.
336!-- Data type comprises u, v, w, pt, and q at lateral and top boundaries.
337    TYPE nest_offl_type
338
339       CHARACTER(LEN=16) ::  char_l = 'ls_forcing_left_'  !< leading substring for variables at left boundary
340       CHARACTER(LEN=17) ::  char_n = 'ls_forcing_north_' !< leading substring for variables at north boundary 
341       CHARACTER(LEN=17) ::  char_r = 'ls_forcing_right_' !< leading substring for variables at right boundary 
342       CHARACTER(LEN=17) ::  char_s = 'ls_forcing_south_' !< leading substring for variables at south boundary
343       CHARACTER(LEN=15) ::  char_t = 'ls_forcing_top_'   !< leading substring for variables at top boundary
344   
345       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names         !< list of variable in dynamic input file
346       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names_chem_l  !< names of mesoscale nested chemistry variables at left boundary
347       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names_chem_n  !< names of mesoscale nested chemistry variables at north boundary
348       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names_chem_r  !< names of mesoscale nested chemistry variables at right boundary
349       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names_chem_s  !< names of mesoscale nested chemistry variables at south boundary
350       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names_chem_t  !< names of mesoscale nested chemistry variables at top boundary
351
352       INTEGER(iwp) ::  nt     !< number of time levels in dynamic input file
353       INTEGER(iwp) ::  nzu    !< number of vertical levels on scalar grid in dynamic input file
354       INTEGER(iwp) ::  nzw    !< number of vertical levels on w grid in dynamic input file
355       INTEGER(iwp) ::  tind   !< time index for reference time in mesoscale-offline nesting
356       INTEGER(iwp) ::  tind_p !< time index for following time in mesoscale-offline nesting
357
358       LOGICAL      ::  init         = .FALSE. !< flag indicating that offline nesting is already initialized
359       
360       LOGICAL, DIMENSION(:), ALLOCATABLE ::  chem_from_file_l !< flags inidicating whether left boundary data for chemistry is in dynamic input file 
361       LOGICAL, DIMENSION(:), ALLOCATABLE ::  chem_from_file_n !< flags inidicating whether north boundary data for chemistry is in dynamic input file
362       LOGICAL, DIMENSION(:), ALLOCATABLE ::  chem_from_file_r !< flags inidicating whether right boundary data for chemistry is in dynamic input file
363       LOGICAL, DIMENSION(:), ALLOCATABLE ::  chem_from_file_s !< flags inidicating whether south boundary data for chemistry is in dynamic input file
364       LOGICAL, DIMENSION(:), ALLOCATABLE ::  chem_from_file_t !< flags inidicating whether top boundary data for chemistry is in dynamic input file
365
366       REAL(wp), DIMENSION(:), ALLOCATABLE ::  surface_pressure !< time dependent surface pressure
367       REAL(wp), DIMENSION(:), ALLOCATABLE ::  time             !< time levels in dynamic input file
368       REAL(wp), DIMENSION(:), ALLOCATABLE ::  zu_atmos         !< vertical levels at scalar grid in dynamic input file
369       REAL(wp), DIMENSION(:), ALLOCATABLE ::  zw_atmos         !< vertical levels at w grid in dynamic input file
370
371       REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  ug         !< domain-averaged geostrophic component
372       REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  vg         !< domain-averaged geostrophic component
373
374       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_left   !< u-component at left boundary
375       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_left   !< v-component at left boundary
376       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_left   !< w-component at left boundary
377       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  q_left   !< mixing ratio at left boundary
378       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  pt_left  !< potentital temperautre at left boundary
379
380       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_north  !< u-component at north boundary
381       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_north  !< v-component at north boundary
382       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_north  !< w-component at north boundary
383       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  q_north  !< mixing ratio at north boundary
384       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  pt_north !< potentital temperautre at north boundary
385
386       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_right  !< u-component at right boundary
387       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_right  !< v-component at right boundary
388       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_right  !< w-component at right boundary
389       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  q_right  !< mixing ratio at right boundary
390       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  pt_right !< potentital temperautre at right boundary
391
392       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_south  !< u-component at south boundary
393       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_south  !< v-component at south boundary
394       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_south  !< w-component at south boundary
395       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  q_south  !< mixing ratio at south boundary
396       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  pt_south !< potentital temperautre at south boundary
397
398       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_top    !< u-component at top boundary
399       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_top    !< v-component at top boundary
400       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_top    !< w-component at top boundary
401       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  q_top    !< mixing ratio at top boundary
402       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  pt_top   !< potentital temperautre at top boundary
403       
404       REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE ::  chem_left   !< chemical species at left boundary
405       REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE ::  chem_north  !< chemical species at left boundary
406       REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE ::  chem_right  !< chemical species at left boundary
407       REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE ::  chem_south  !< chemical species at left boundary
408       REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE ::  chem_top    !< chemical species at left boundary
409
410    END TYPE nest_offl_type
411
412    TYPE init_type
413
414       CHARACTER(LEN=16) ::  init_char = 'init_atmosphere_'          !< leading substring for init variables
415       CHARACTER(LEN=23) ::  origin_time = '2000-01-01 00:00:00 +00' !< reference time of input data
416       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names_chem !< list of chemistry variable names that can potentially be on file
417
418       INTEGER(iwp) ::  lod_msoil !< level of detail - soil moisture
419       INTEGER(iwp) ::  lod_pt    !< level of detail - pt
420       INTEGER(iwp) ::  lod_q     !< level of detail - q
421       INTEGER(iwp) ::  lod_tsoil !< level of detail - soil temperature
422       INTEGER(iwp) ::  lod_u     !< level of detail - u-component
423       INTEGER(iwp) ::  lod_v     !< level of detail - v-component
424       INTEGER(iwp) ::  lod_w     !< level of detail - w-component
425       INTEGER(iwp) ::  nx        !< number of scalar grid points along x in dynamic input file
426       INTEGER(iwp) ::  nxu       !< number of u grid points along x in dynamic input file
427       INTEGER(iwp) ::  ny        !< number of scalar grid points along y in dynamic input file
428       INTEGER(iwp) ::  nyv       !< number of v grid points along y in dynamic input file
429       INTEGER(iwp) ::  nzs       !< number of vertical soil levels in dynamic input file
430       INTEGER(iwp) ::  nzu       !< number of vertical levels on scalar grid in dynamic input file
431       INTEGER(iwp) ::  nzw       !< number of vertical levels on w grid in dynamic input file
432       
433       INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  lod_chem !< level of detail - chemistry variables
434
435       LOGICAL ::  from_file_msoil  = .FALSE. !< flag indicating whether soil moisture is already initialized from file
436       LOGICAL ::  from_file_pt     = .FALSE. !< flag indicating whether pt is already initialized from file
437       LOGICAL ::  from_file_q      = .FALSE. !< flag indicating whether q is already initialized from file
438       LOGICAL ::  from_file_tsoil  = .FALSE. !< flag indicating whether soil temperature is already initialized from file
439       LOGICAL ::  from_file_u      = .FALSE. !< flag indicating whether u is already initialized from file
440       LOGICAL ::  from_file_ug     = .FALSE. !< flag indicating whether ug is already initialized from file
441       LOGICAL ::  from_file_v      = .FALSE. !< flag indicating whether v is already initialized from file
442       LOGICAL ::  from_file_vg     = .FALSE. !< flag indicating whether ug is already initialized from file
443       LOGICAL ::  from_file_w      = .FALSE. !< flag indicating whether w is already initialized from file
444       
445       LOGICAL, DIMENSION(:), ALLOCATABLE ::  from_file_chem !< flag indicating whether chemistry variable is read from file
446
447       REAL(wp) ::  fill_msoil              !< fill value for soil moisture
448       REAL(wp) ::  fill_pt                 !< fill value for pt
449       REAL(wp) ::  fill_q                  !< fill value for q
450       REAL(wp) ::  fill_tsoil              !< fill value for soil temperature
451       REAL(wp) ::  fill_u                  !< fill value for u
452       REAL(wp) ::  fill_v                  !< fill value for v
453       REAL(wp) ::  fill_w                  !< fill value for w
454       REAL(wp) ::  latitude = 0.0_wp       !< latitude of the lower left corner
455       REAL(wp) ::  longitude = 0.0_wp      !< longitude of the lower left corner
456       REAL(wp) ::  origin_x = 500000.0_wp  !< UTM easting of the lower left corner
457       REAL(wp) ::  origin_y = 0.0_wp       !< UTM northing of the lower left corner
458       REAL(wp) ::  origin_z = 0.0_wp       !< reference height of input data
459       REAL(wp) ::  rotation_angle = 0.0_wp !< rotation angle of input data
460
461       REAL(wp), DIMENSION(:), ALLOCATABLE ::  fill_chem    !< fill value - chemistry variables
462       REAL(wp), DIMENSION(:), ALLOCATABLE ::  msoil_1d     !< initial vertical profile of soil moisture
463       REAL(wp), DIMENSION(:), ALLOCATABLE ::  pt_init      !< initial vertical profile of pt
464       REAL(wp), DIMENSION(:), ALLOCATABLE ::  q_init       !< initial vertical profile of q
465       REAL(wp), DIMENSION(:), ALLOCATABLE ::  tsoil_1d     !< initial vertical profile of soil temperature
466       REAL(wp), DIMENSION(:), ALLOCATABLE ::  u_init       !< initial vertical profile of u
467       REAL(wp), DIMENSION(:), ALLOCATABLE ::  ug_init      !< initial vertical profile of ug
468       REAL(wp), DIMENSION(:), ALLOCATABLE ::  v_init       !< initial vertical profile of v
469       REAL(wp), DIMENSION(:), ALLOCATABLE ::  vg_init      !< initial vertical profile of ug
470       REAL(wp), DIMENSION(:), ALLOCATABLE ::  w_init       !< initial vertical profile of w
471       REAL(wp), DIMENSION(:), ALLOCATABLE ::  z_soil       !< vertical levels in soil in dynamic input file, used for interpolation
472       REAL(wp), DIMENSION(:), ALLOCATABLE ::  zu_atmos     !< vertical levels at scalar grid in dynamic input file, used for interpolation
473       REAL(wp), DIMENSION(:), ALLOCATABLE ::  zw_atmos     !< vertical levels at w grid in dynamic input file, used for interpolation
474       
475       REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  chem_init  !< initial vertical profiles of chemistry variables
476
477
478       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  msoil_3d !< initial 3d soil moisture provide by Inifor and interpolated onto soil grid
479       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  tsoil_3d !< initial 3d soil temperature provide by Inifor and interpolated onto soil grid
480
481    END TYPE init_type
482
483!-- Data type for the general information of chemistry emissions, do not dependent on the particular chemical species
484    TYPE chem_emis_att_type
485
486       !-DIMENSIONS
487       INTEGER(iwp)                                 :: nspec=0                   !< number of chem species for which emission values are provided
488       INTEGER(iwp)                                 :: ncat=0                    !< number of emission categories
489       INTEGER(iwp)                                 :: nvoc=0                    !< number of VOCs components
490       INTEGER(iwp)                                 :: npm=0                     !< number of PMs components
491       INTEGER(iwp)                                 :: nnox=2                    !< number of NOx components: NO and NO2
492       INTEGER(iwp)                                 :: nsox=2                    !< number of SOx components: SO and SO4
493       INTEGER(iwp)                                 :: nhoursyear                !< number of hours of a specific year in the HOURLY mode
494                                                                                 !  of the default mode
495       INTEGER(iwp)                                 :: nmonthdayhour             !< number of month days and hours in the MDH mode
496                                                                                 !  of the default mode
497       INTEGER(iwp)                                 :: dt_emission               !< Number of emissions timesteps for one year
498                                                                                 !  in the pre-processed emissions case
499       !-- 1d emission input variables
500       CHARACTER (LEN=25),ALLOCATABLE, DIMENSION(:) :: pm_name                   !< Names of PMs components
501       CHARACTER (LEN=25),ALLOCATABLE, DIMENSION(:) :: cat_name                  !< Emission categories names
502       CHARACTER (LEN=25),ALLOCATABLE, DIMENSION(:) :: species_name              !< Names of emission chemical species
503       CHARACTER (LEN=25),ALLOCATABLE, DIMENSION(:) :: voc_name                  !< Names of VOCs components
504       CHARACTER (LEN=25)                           :: units                     !< Units
505
506       INTEGER(iwp)                                 :: i_hour                    !< indices for assigning the emission values at different timesteps
507       INTEGER(iwp),ALLOCATABLE, DIMENSION(:)       :: cat_index                 !< Index of emission categories
508       INTEGER(iwp),ALLOCATABLE, DIMENSION(:)       :: species_index             !< Index of emission chem species
509
510       REAL(wp),ALLOCATABLE, DIMENSION(:)           :: xm                        !< Molecular masses of emission chem species
511
512       !-- 2d emission input variables
513       REAL(wp),ALLOCATABLE, DIMENSION(:,:)         :: hourly_emis_time_factor   !< Time factors for HOURLY emissions (DEFAULT mode)
514       REAL(wp),ALLOCATABLE, DIMENSION(:,:)         :: mdh_emis_time_factor      !< Time factors for MDH emissions (DEFAULT mode)
515       REAL(wp),ALLOCATABLE, DIMENSION(:,:)         :: nox_comp                  !< Composition of NO and NO2
516       REAL(wp),ALLOCATABLE, DIMENSION(:,:)         :: sox_comp                  !< Composition of SO2 and SO4
517       REAL(wp),ALLOCATABLE, DIMENSION(:,:)         :: voc_comp                  !< Composition of different VOC components (number not fixed)
518
519       !-- 3d emission input variables
520       REAL(wp),ALLOCATABLE, DIMENSION(:,:,:)       :: pm_comp                   !< Composition of different PMs components (number not fixed)
521 
522    END TYPE chem_emis_att_type
523
524
525!-- Data type for the values of chemistry emissions ERUSSO
526    TYPE chem_emis_val_type
527
528       !REAL(wp),ALLOCATABLE, DIMENSION(:,:)         :: stack_height              !< stack height
529
530       !-- 3d emission input variables
531       REAL(wp),ALLOCATABLE, DIMENSION(:,:,:)     :: default_emission_data     !< Input Values emissions DEFAULT mode
532
533       !-- 4d emission input variables
534       REAL(wp),ALLOCATABLE, DIMENSION(:,:,:,:)   :: preproc_emission_data      !< Input Values emissions PRE-PROCESSED mode
535
536    END TYPE chem_emis_val_type
537
538!
539!-- Define data structures for different input data types.
540!-- 8-bit Integer 2D
541    TYPE int_2d_8bit
542       INTEGER(KIND=1) ::  fill = -127                      !< fill value
543       INTEGER(KIND=1), DIMENSION(:,:), ALLOCATABLE ::  var !< respective variable
544
545       LOGICAL ::  from_file = .FALSE.  !< flag indicating whether an input variable is available and read from file or default values are used
546    END TYPE int_2d_8bit
547!
548!-- 8-bit Integer 3D
549    TYPE int_3d_8bit
550       INTEGER(KIND=1) ::  fill = -127                           !< fill value
551       INTEGER(KIND=1), DIMENSION(:,:,:), ALLOCATABLE ::  var_3d !< respective variable
552
553       LOGICAL ::  from_file = .FALSE.  !< flag indicating whether an input variable is available and read from file or default values are used
554    END TYPE int_3d_8bit
555!
556!-- 32-bit Integer 2D
557    TYPE int_2d_32bit
558       INTEGER(iwp) ::  fill = -9999                      !< fill value
559       INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  var  !< respective variable
560
561       LOGICAL ::  from_file = .FALSE. !< flag indicating whether an input variable is available and read from file or default values are used
562    END TYPE int_2d_32bit
563
564!
565!-- Define data type to read 2D real variables
566    TYPE real_2d
567       LOGICAL ::  from_file = .FALSE.  !< flag indicating whether an input variable is available and read from file or default values are used
568
569       REAL(wp) ::  fill = -9999.9_wp                !< fill value
570       REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  var !< respective variable
571    END TYPE real_2d
572
573!
574!-- Define data type to read 3D real variables
575    TYPE real_3d
576       LOGICAL ::  from_file = .FALSE.  !< flag indicating whether an input variable is available and read from file or default values are used
577
578       INTEGER(iwp) ::  nz   !< number of grid points along vertical dimension
579
580       REAL(wp) ::  fill = -9999.9_wp                  !< fill value
581       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  var !< respective variable
582    END TYPE real_3d
583!
584!-- Define data structure where the dimension and type of the input depends
585!-- on the given level of detail.
586!-- For buildings, the input is either 2D float, or 3d byte.
587    TYPE build_in
588       INTEGER(iwp)    ::  lod = 1                               !< level of detail
589       INTEGER(KIND=1) ::  fill2 = -127                          !< fill value for lod = 2
590       INTEGER(iwp)    ::  nz                                    !< number of vertical layers in file
591       INTEGER(KIND=1), DIMENSION(:,:,:), ALLOCATABLE ::  var_3d !< 3d variable (lod = 2)
592
593       REAL(wp), DIMENSION(:), ALLOCATABLE ::  z                 !< vertical coordinate for 3D building, used for consistency check
594
595       LOGICAL ::  from_file = .FALSE.  !< flag indicating whether an input variable is available and read from file or default values are used
596
597       REAL(wp)                              ::  fill1 = -9999.9_wp !< fill values for lod = 1
598       REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  var_2d             !< 2d variable (lod = 1)
599    END TYPE build_in
600
601!
602!-- For soil_type, the input is either 2D or 3D one-byte integer.
603    TYPE soil_in
604       INTEGER(iwp)                                   ::  lod = 1      !< level of detail
605       INTEGER(KIND=1)                                ::  fill = -127  !< fill value for lod = 2
606       INTEGER(KIND=1), DIMENSION(:,:), ALLOCATABLE   ::  var_2d       !< 2d variable (lod = 1)
607       INTEGER(KIND=1), DIMENSION(:,:,:), ALLOCATABLE ::  var_3d       !< 3d variable (lod = 2)
608
609       LOGICAL ::  from_file = .FALSE.  !< flag indicating whether an input variable is available and read from file or default values are used
610    END TYPE soil_in
611
612!
613!-- Define data type for fractions between surface types
614    TYPE fracs
615       INTEGER(iwp)                            ::  nf             !< total number of fractions
616       INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  nfracs         !< dimension array for fraction
617
618       LOGICAL ::  from_file = .FALSE. !< flag indicating whether an input variable is available and read from file or default values are used
619
620       REAL(wp)                                ::  fill = -9999.9_wp !< fill value
621       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  frac              !< respective fraction between different surface types
622    END TYPE fracs
623!
624!-- Data type for parameter lists, Depending on the given level of detail,
625!-- the input is 3D or 4D
626    TYPE pars
627       INTEGER(iwp)                            ::  lod = 1         !< level of detail
628       INTEGER(iwp)                            ::  np              !< total number of parameters
629       INTEGER(iwp)                            ::  nz              !< vertical dimension - number of soil layers
630       INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  layers          !< dimension array for soil layers
631       INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  pars            !< dimension array for parameters
632
633       LOGICAL ::  from_file = .FALSE.  !< flag indicating whether an input variable is available and read from file or default values are used
634
635       REAL(wp)                                  ::  fill = -9999.9_wp !< fill value
636       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE   ::  pars_xy           !< respective parameters, level of detail = 1
637       REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE ::  pars_xyz          !< respective parameters, level of detail = 2
638    END TYPE pars
639!
640!-- Define type for global file attributes
641!-- Please refer to the PALM data standard for a detailed description of each
642!-- attribute.
643    TYPE global_atts_type
644       CHARACTER(LEN=200) ::  acronym = ' '                      !< acronym of institution
645       CHARACTER(LEN=7)   ::  acronym_char = 'acronym'           !< name of attribute
646       CHARACTER(LEN=200) ::  author  = ' '                      !< first name, last name, email adress
647       CHARACTER(LEN=6)   ::  author_char = 'author'             !< name of attribute
648       CHARACTER(LEN=200) ::  campaign = 'PALM-4U'               !< name of campaign
649       CHARACTER(LEN=8)   ::  campaign_char = 'campaign'         !< name of attribute
650       CHARACTER(LEN=200) ::  comment = ' '                      !< comment to data
651       CHARACTER(LEN=7)   ::  comment_char = 'comment'           !< name of attribute
652       CHARACTER(LEN=200) ::  contact_person = ' '               !< first name, last name, email adress
653       CHARACTER(LEN=14)  ::  contact_person_char = 'contact_person'  !< name of attribute
654       CHARACTER(LEN=200) ::  conventions = 'CF-1.7'             !< netCDF convention
655       CHARACTER(LEN=11)  ::  conventions_char = 'Conventions'   !< name of attribute
656       CHARACTER(LEN=23 ) ::  creation_time = ' '                !< creation time of data set
657       CHARACTER(LEN=13)  ::  creation_time_char = 'creation_time'  !< name of attribute
658       CHARACTER(LEN=200) ::  data_content = ' '                 !< content of data set
659       CHARACTER(LEN=12)  ::  data_content_char = 'data_content' !< name of attribute
660       CHARACTER(LEN=200) ::  dependencies = ' '                 !< dependencies of data set
661       CHARACTER(LEN=12)  ::  dependencies_char = 'dependencies' !< name of attribute
662       CHARACTER(LEN=200) ::  history = ' '                      !< information about data processing
663       CHARACTER(LEN=7)   ::  history_char = 'history'           !< name of attribute
664       CHARACTER(LEN=200) ::  institution = ' '                  !< name of responsible institution
665       CHARACTER(LEN=11)  ::  institution_char = 'institution'   !< name of attribute
666       CHARACTER(LEN=200) ::  keywords = ' '                     !< keywords of data set
667       CHARACTER(LEN=8)   ::  keywords_char = 'keywords'         !< name of attribute
668       CHARACTER(LEN=200) ::  licence = ' '                      !< licence of data set
669       CHARACTER(LEN=7)   ::  licence_char = 'licence'           !< name of attribute
670       CHARACTER(LEN=200) ::  location = ' '                     !< place which refers to data set
671       CHARACTER(LEN=8)   ::  location_char = 'location'         !< name of attribute
672       CHARACTER(LEN=10)  ::  origin_lat_char = 'origin_lat'     !< name of attribute
673       CHARACTER(LEN=10)  ::  origin_lon_char = 'origin_lon'     !< name of attribute
674       CHARACTER(LEN=23 ) ::  origin_time = '2000-01-01 00:00:00 +00'  !< reference time
675       CHARACTER(LEN=11)  ::  origin_time_char = 'origin_time'   !< name of attribute
676       CHARACTER(LEN=8)   ::  origin_x_char = 'origin_x'         !< name of attribute
677       CHARACTER(LEN=8)   ::  origin_y_char = 'origin_y'         !< name of attribute
678       CHARACTER(LEN=8)   ::  origin_z_char = 'origin_z'         !< name of attribute
679       CHARACTER(LEN=12)  ::  palm_version_char = 'palm_version' !< name of attribute
680       CHARACTER(LEN=200) ::  references = ' '                   !< literature referring to data set
681       CHARACTER(LEN=10)  ::  references_char = 'references'     !< name of attribute
682       CHARACTER(LEN=14)  ::  rotation_angle_char = 'rotation_angle'  !< name of attribute
683       CHARACTER(LEN=200) ::  site = ' '                         !< name of model domain
684       CHARACTER(LEN=4)   ::  site_char = 'site'                 !< name of attribute
685       CHARACTER(LEN=200) ::  source = ' '                       !< source of data set
686       CHARACTER(LEN=6)   ::  source_char = 'source'             !< name of attribute
687       CHARACTER(LEN=200) ::  title = ' '                        !< title of data set
688       CHARACTER(LEN=5)   ::  title_char = 'title'               !< name of attribute
689       CHARACTER(LEN=7)   ::  version_char = 'version'           !< name of attribute
690
691       INTEGER(iwp) ::  version              !< version of data set
692
693       REAL(wp) ::  origin_lat               !< latitude of lower left corner
694       REAL(wp) ::  origin_lon               !< longitude of lower left corner
695       REAL(wp) ::  origin_x                 !< easting (UTM coordinate) of lower left corner
696       REAL(wp) ::  origin_y                 !< northing (UTM coordinate) of lower left corner
697       REAL(wp) ::  origin_z                 !< reference height
698       REAL(wp) ::  palm_version             !< PALM version of data set
699       REAL(wp) ::  rotation_angle           !< rotation angle of coordinate system of data set
700    END TYPE global_atts_type
701!
702!-- Define type for coordinate reference system (crs)
703    TYPE crs_type
704       CHARACTER(LEN=200) ::  epsg_code = 'EPSG:25831'                   !< EPSG code
705       CHARACTER(LEN=200) ::  grid_mapping_name = 'transverse_mercator'  !< name of grid mapping
706       CHARACTER(LEN=200) ::  long_name = 'coordinate reference system'  !< name of variable crs
707       CHARACTER(LEN=200) ::  units = 'm'                                !< unit of crs
708
709       REAL(wp) ::  false_easting = 500000.0_wp                  !< false easting
710       REAL(wp) ::  false_northing = 0.0_wp                      !< false northing
711       REAL(wp) ::  inverse_flattening = 298.257223563_wp        !< 1/f (default for WGS84)
712       REAL(wp) ::  latitude_of_projection_origin = 0.0_wp       !< latitude of projection origin
713       REAL(wp) ::  longitude_of_central_meridian = 3.0_wp       !< longitude of central meridian of UTM zone (default: zone 31)
714       REAL(wp) ::  longitude_of_prime_meridian = 0.0_wp         !< longitude of prime meridian
715       REAL(wp) ::  scale_factor_at_central_meridian = 0.9996_wp !< scale factor of UTM coordinates
716       REAL(wp) ::  semi_major_axis = 6378137.0_wp               !< length of semi major axis (default for WGS84)
717    END TYPE crs_type
718
719!
720!-- Define variables
721    TYPE(crs_type)   ::  coord_ref_sys  !< coordinate reference system
722
723    TYPE(dims_xy)    ::  dim_static     !< data structure for x, y-dimension in static input file
724
725    TYPE(nest_offl_type) ::  nest_offl  !< data structure for data input at lateral and top boundaries (provided by Inifor) 
726
727    TYPE(init_type) ::  init_3d    !< data structure for the initialization of the 3D flow and soil fields
728    TYPE(init_type) ::  init_model !< data structure for the initialization of the model
729
730!
731!-- Define 2D variables of type NC_BYTE
732    TYPE(int_2d_8bit)  ::  albedo_type_f     !< input variable for albedo type
733    TYPE(int_2d_8bit)  ::  building_type_f   !< input variable for building type
734    TYPE(int_2d_8bit)  ::  pavement_type_f   !< input variable for pavenment type
735    TYPE(int_2d_8bit)  ::  street_crossing_f !< input variable for water type
736    TYPE(int_2d_8bit)  ::  street_type_f     !< input variable for water type
737    TYPE(int_2d_8bit)  ::  vegetation_type_f !< input variable for vegetation type
738    TYPE(int_2d_8bit)  ::  water_type_f      !< input variable for water type
739!
740!-- Define 3D variables of type NC_BYTE
741    TYPE(int_3d_8bit)  ::  building_obstruction_f    !< input variable for building obstruction
742    TYPE(int_3d_8bit)  ::  building_obstruction_full !< input variable for building obstruction
743!
744!-- Define 2D variables of type NC_INT
745    TYPE(int_2d_32bit) ::  building_id_f     !< input variable for building ID
746!
747!-- Define 2D variables of type NC_FLOAT
748    TYPE(real_2d) ::  terrain_height_f       !< input variable for terrain height
749    TYPE(real_2d) ::  uvem_irradiance_f      !< input variable for uvem irradiance lookup table
750    TYPE(real_2d) ::  uvem_integration_f     !< input variable for uvem integration
751!
752!-- Define 3D variables of type NC_FLOAT
753    TYPE(real_3d) ::  basal_area_density_f    !< input variable for basal area density - resolved vegetation
754    TYPE(real_3d) ::  leaf_area_density_f     !< input variable for leaf area density - resolved vegetation
755    TYPE(real_3d) ::  root_area_density_lad_f !< input variable for root area density - resolved vegetation
756    TYPE(real_3d) ::  root_area_density_lsm_f !< input variable for root area density - parametrized vegetation
757    TYPE(real_3d) ::  uvem_radiance_f         !< input variable for uvem radiance lookup table
758    TYPE(real_3d) ::  uvem_projarea_f         !< input variable for uvem projection area lookup table
759!
760!-- Define input variable for buildings
761    TYPE(build_in) ::  buildings_f           !< input variable for buildings
762!
763!-- Define input variables for soil_type
764    TYPE(soil_in)  ::  soil_type_f           !< input variable for soil type
765
766    TYPE(fracs) ::  surface_fraction_f       !< input variable for surface fraction
767
768    TYPE(pars)  ::  albedo_pars_f              !< input variable for albedo parameters
769    TYPE(pars)  ::  building_pars_f            !< input variable for building parameters
770    TYPE(pars)  ::  pavement_pars_f            !< input variable for pavement parameters
771    TYPE(pars)  ::  pavement_subsurface_pars_f !< input variable for pavement parameters
772    TYPE(pars)  ::  soil_pars_f                !< input variable for soil parameters
773    TYPE(pars)  ::  vegetation_pars_f          !< input variable for vegetation parameters
774    TYPE(pars)  ::  water_pars_f               !< input variable for water parameters
775
776    TYPE(chem_emis_att_type)                             ::  chem_emis_att    !< Input Information of Chemistry Emission Data from netcdf 
777    TYPE(chem_emis_val_type), ALLOCATABLE, DIMENSION(:)  ::  chem_emis        !< Input Chemistry Emission Data from netcdf 
778
779    CHARACTER(LEN=3)  ::  char_lod  = 'lod'         !< name of level-of-detail attribute in NetCDF file
780
781    CHARACTER(LEN=10) ::  char_fill = '_FillValue'        !< name of fill value attribute in NetCDF file
782
783    CHARACTER(LEN=100) ::  input_file_static  = 'PIDS_STATIC'  !< Name of file which comprises static input data
784    CHARACTER(LEN=100) ::  input_file_dynamic = 'PIDS_DYNAMIC' !< Name of file which comprises dynamic input data
785    CHARACTER(LEN=100) ::  input_file_chem    = 'PIDS_CHEM'    !< Name of file which comprises chemistry input data
786    CHARACTER(LEN=100) ::  input_file_uvem    = 'PIDS_UVEM'    !< Name of file which comprises static uv_exposure model input data
787    CHARACTER(LEN=100) ::  input_file_vm      = 'PIDS_VM'      !< Name of file which comprises virtual measurement data
788   
789    CHARACTER(LEN=25), ALLOCATABLE, DIMENSION(:)    ::  string_values  !< output of string variables read from netcdf input files
790
791    INTEGER(iwp)                                     ::  id_emis        !< NetCDF id of input file for chemistry emissions: TBD: It has to be removed
792
793    INTEGER(iwp) ::  nc_stat         !< return value of nf90 function call
794
795    LOGICAL ::  input_pids_static  = .FALSE.   !< Flag indicating whether Palm-input-data-standard file containing static information exists
796    LOGICAL ::  input_pids_dynamic = .FALSE.   !< Flag indicating whether Palm-input-data-standard file containing dynamic information exists
797    LOGICAL ::  input_pids_chem    = .FALSE.   !< Flag indicating whether Palm-input-data-standard file containing chemistry information exists
798    LOGICAL ::  input_pids_uvem    = .FALSE.   !< Flag indicating whether uv-expoure-model input file containing static information exists
799    LOGICAL ::  input_pids_vm      = .FALSE.   !< Flag indicating whether input file for virtual measurements exist
800
801    LOGICAL ::  collective_read = .FALSE.      !< Enable NetCDF collective read
802
803    TYPE(global_atts_type) ::  input_file_atts !< global attributes of input file
804
805    SAVE
806
807    PRIVATE
808
809    INTERFACE netcdf_data_input_interpolate
810       MODULE PROCEDURE netcdf_data_input_interpolate_1d
811       MODULE PROCEDURE netcdf_data_input_interpolate_1d_soil
812       MODULE PROCEDURE netcdf_data_input_interpolate_2d
813       MODULE PROCEDURE netcdf_data_input_interpolate_3d
814    END INTERFACE netcdf_data_input_interpolate
815
816    INTERFACE netcdf_data_input_check_dynamic
817       MODULE PROCEDURE netcdf_data_input_check_dynamic
818    END INTERFACE netcdf_data_input_check_dynamic
819
820    INTERFACE netcdf_data_input_check_static
821       MODULE PROCEDURE netcdf_data_input_check_static
822    END INTERFACE netcdf_data_input_check_static
823
824    INTERFACE netcdf_data_input_chemistry_data                       
825       MODULE PROCEDURE netcdf_data_input_chemistry_data
826    END INTERFACE netcdf_data_input_chemistry_data
827   
828    INTERFACE netcdf_data_input_get_dimension_length                       
829       MODULE PROCEDURE netcdf_data_input_get_dimension_length
830    END INTERFACE netcdf_data_input_get_dimension_length
831
832    INTERFACE netcdf_data_input_inquire_file
833       MODULE PROCEDURE netcdf_data_input_inquire_file
834    END INTERFACE netcdf_data_input_inquire_file
835
836    INTERFACE netcdf_data_input_init
837       MODULE PROCEDURE netcdf_data_input_init
838    END INTERFACE netcdf_data_input_init
839   
840    INTERFACE netcdf_data_input_att
841       MODULE PROCEDURE netcdf_data_input_att_int8
842       MODULE PROCEDURE netcdf_data_input_att_int32
843       MODULE PROCEDURE netcdf_data_input_att_real
844       MODULE PROCEDURE netcdf_data_input_att_string
845    END INTERFACE netcdf_data_input_att
846
847    INTERFACE netcdf_data_input_init_3d
848       MODULE PROCEDURE netcdf_data_input_init_3d
849    END INTERFACE netcdf_data_input_init_3d
850   
851    INTERFACE netcdf_data_input_init_lsm
852       MODULE PROCEDURE netcdf_data_input_init_lsm
853    END INTERFACE netcdf_data_input_init_lsm
854
855    INTERFACE netcdf_data_input_offline_nesting
856       MODULE PROCEDURE netcdf_data_input_offline_nesting
857    END INTERFACE netcdf_data_input_offline_nesting
858
859    INTERFACE netcdf_data_input_surface_data
860       MODULE PROCEDURE netcdf_data_input_surface_data
861    END INTERFACE netcdf_data_input_surface_data
862
863    INTERFACE netcdf_data_input_var
864       MODULE PROCEDURE netcdf_data_input_var_char
865       MODULE PROCEDURE netcdf_data_input_var_real_1d
866       MODULE PROCEDURE netcdf_data_input_var_real_2d
867    END INTERFACE netcdf_data_input_var
868
869    INTERFACE netcdf_data_input_uvem
870       MODULE PROCEDURE netcdf_data_input_uvem
871    END INTERFACE netcdf_data_input_uvem
872
873    INTERFACE get_variable
874       MODULE PROCEDURE get_variable_1d_char
875       MODULE PROCEDURE get_variable_1d_int
876       MODULE PROCEDURE get_variable_1d_real
877       MODULE PROCEDURE get_variable_2d_int8
878       MODULE PROCEDURE get_variable_2d_int32
879       MODULE PROCEDURE get_variable_2d_real
880       MODULE PROCEDURE get_variable_3d_int8
881       MODULE PROCEDURE get_variable_3d_real
882       MODULE PROCEDURE get_variable_3d_real_dynamic
883       MODULE PROCEDURE get_variable_4d_to_3d_real
884       MODULE PROCEDURE get_variable_4d_real
885       MODULE PROCEDURE get_variable_5d_to_4d_real
886       MODULE PROCEDURE get_variable_string       
887    END INTERFACE get_variable
888
889    INTERFACE get_variable_pr
890       MODULE PROCEDURE get_variable_pr
891    END INTERFACE get_variable_pr
892
893    INTERFACE get_attribute
894       MODULE PROCEDURE get_attribute_real
895       MODULE PROCEDURE get_attribute_int8
896       MODULE PROCEDURE get_attribute_int32
897       MODULE PROCEDURE get_attribute_string
898    END INTERFACE get_attribute
899
900!
901!-- Public variables
902    PUBLIC albedo_pars_f, albedo_type_f, basal_area_density_f, buildings_f,    &
903           building_id_f, building_pars_f, building_type_f,                    &
904           chem_emis, chem_emis_att, chem_emis_att_type, chem_emis_val_type,   &
905           coord_ref_sys,                                                      &
906           init_3d, init_model, input_file_atts, input_file_static,            &
907           input_pids_static,                                                  &
908           input_pids_dynamic, input_pids_vm, input_file_vm,                   &
909           leaf_area_density_f, nest_offl,                                     &
910           pavement_pars_f, pavement_subsurface_pars_f, pavement_type_f,       &
911           root_area_density_lad_f, root_area_density_lsm_f, soil_pars_f,      &
912           soil_type_f, street_crossing_f, street_type_f, surface_fraction_f,  &
913           terrain_height_f, vegetation_pars_f, vegetation_type_f,             &
914           water_pars_f, water_type_f
915!
916!-- Public uv exposure variables
917    PUBLIC building_obstruction_f, input_file_uvem, input_pids_uvem,           &
918           netcdf_data_input_uvem,                                             &
919           uvem_integration_f, uvem_irradiance_f,                              &
920           uvem_projarea_f, uvem_radiance_f
921
922!
923!-- Public subroutines
924    PUBLIC netcdf_data_input_check_dynamic, netcdf_data_input_check_static,    &
925           netcdf_data_input_chemistry_data,                                   &
926           netcdf_data_input_get_dimension_length,                             &
927           netcdf_data_input_inquire_file,                                     &
928           netcdf_data_input_init, netcdf_data_input_init_lsm,                 &
929           netcdf_data_input_init_3d, netcdf_data_input_att,                   &
930           netcdf_data_input_interpolate, netcdf_data_input_offline_nesting,   &
931           netcdf_data_input_surface_data, netcdf_data_input_topo,             &
932           netcdf_data_input_var, get_attribute, get_variable, open_read_file, &
933           check_existence, inquire_num_variables, inquire_variable_names
934
935
936 CONTAINS
937
938!------------------------------------------------------------------------------!
939! Description:
940! ------------
941!> Inquires whether NetCDF input files according to Palm-input-data standard
942!> exist. Moreover, basic checks are performed.
943!------------------------------------------------------------------------------!
944    SUBROUTINE netcdf_data_input_inquire_file
945
946       USE control_parameters,                                                 &
947           ONLY:  topo_no_distinct
948
949       IMPLICIT NONE
950
951#if defined ( __netcdf )
952       INQUIRE( FILE = TRIM( input_file_static )   // TRIM( coupling_char ),   &
953                EXIST = input_pids_static  )
954       INQUIRE( FILE = TRIM( input_file_dynamic ) // TRIM( coupling_char ),    &
955                EXIST = input_pids_dynamic )
956       INQUIRE( FILE = TRIM( input_file_chem )    // TRIM( coupling_char ),    &
957                EXIST = input_pids_chem )
958       INQUIRE( FILE = TRIM( input_file_uvem ) // TRIM( coupling_char ),       &
959                EXIST = input_pids_uvem  )
960       INQUIRE( FILE = TRIM( input_file_vm )      // TRIM( coupling_char ),    &
961                EXIST = input_pids_vm )
962#endif
963
964!
965!--    As long as topography can be input via ASCII format, no distinction
966!--    between building and terrain can be made. This case, classify all
967!--    surfaces as default type. Same in case land-surface and urban-surface
968!--    model are not applied.
969       IF ( .NOT. input_pids_static )  THEN
970          topo_no_distinct = .TRUE.
971       ENDIF
972
973    END SUBROUTINE netcdf_data_input_inquire_file
974
975!------------------------------------------------------------------------------!
976! Description:
977! ------------
978!> Reads global attributes and coordinate reference system required for
979!> initialization of the model.
980!------------------------------------------------------------------------------!
981    SUBROUTINE netcdf_data_input_init
982
983       IMPLICIT NONE
984
985       INTEGER(iwp) ::  id_mod     !< NetCDF id of input file
986       INTEGER(iwp) ::  var_id_crs !< NetCDF id of variable crs
987
988       IF ( .NOT. input_pids_static )  RETURN
989
990#if defined ( __netcdf )
991!
992!--    Open file in read-only mode
993       CALL open_read_file( TRIM( input_file_static ) //                       &
994                            TRIM( coupling_char ), id_mod )
995!
996!--    Read global attributes
997       CALL get_attribute( id_mod, input_file_atts%origin_lat_char,            &
998                           input_file_atts%origin_lat, .TRUE. )
999
1000       CALL get_attribute( id_mod, input_file_atts%origin_lon_char,            &
1001                           input_file_atts%origin_lon, .TRUE. )
1002
1003       CALL get_attribute( id_mod, input_file_atts%origin_time_char,           &
1004                           input_file_atts%origin_time, .TRUE. )
1005
1006       CALL get_attribute( id_mod, input_file_atts%origin_x_char,              &
1007                           input_file_atts%origin_x, .TRUE. )
1008
1009       CALL get_attribute( id_mod, input_file_atts%origin_y_char,              &
1010                           input_file_atts%origin_y, .TRUE. )
1011
1012       CALL get_attribute( id_mod, input_file_atts%origin_z_char,              &
1013                           input_file_atts%origin_z, .TRUE. )
1014
1015       CALL get_attribute( id_mod, input_file_atts%rotation_angle_char,        &
1016                           input_file_atts%rotation_angle, .TRUE. )
1017
1018       CALL get_attribute( id_mod, input_file_atts%author_char,                &
1019                           input_file_atts%author, .TRUE., no_abort=.FALSE. )
1020       CALL get_attribute( id_mod, input_file_atts%contact_person_char,        &
1021                           input_file_atts%contact_person, .TRUE., no_abort=.FALSE. )
1022       CALL get_attribute( id_mod, input_file_atts%institution_char,           &
1023                           input_file_atts%institution,    .TRUE., no_abort=.FALSE. )
1024       CALL get_attribute( id_mod, input_file_atts%acronym_char,               &
1025                           input_file_atts%acronym,        .TRUE., no_abort=.FALSE. )
1026
1027       CALL get_attribute( id_mod, input_file_atts%campaign_char,              &
1028                           input_file_atts%campaign, .TRUE., no_abort=.FALSE. )
1029       CALL get_attribute( id_mod, input_file_atts%location_char,              &
1030                           input_file_atts%location, .TRUE., no_abort=.FALSE. )
1031       CALL get_attribute( id_mod, input_file_atts%site_char,                  &
1032                           input_file_atts%site,     .TRUE., no_abort=.FALSE. )
1033
1034       CALL get_attribute( id_mod, input_file_atts%source_char,                &
1035                           input_file_atts%source,     .TRUE., no_abort=.FALSE. )
1036       CALL get_attribute( id_mod, input_file_atts%references_char,            &
1037                           input_file_atts%references, .TRUE., no_abort=.FALSE. )
1038       CALL get_attribute( id_mod, input_file_atts%keywords_char,              &
1039                           input_file_atts%keywords,   .TRUE., no_abort=.FALSE. )
1040       CALL get_attribute( id_mod, input_file_atts%licence_char,               &
1041                           input_file_atts%licence,    .TRUE., no_abort=.FALSE. )
1042       CALL get_attribute( id_mod, input_file_atts%comment_char,               &
1043                           input_file_atts%comment,    .TRUE., no_abort=.FALSE. )
1044!
1045!--    Read coordinate reference system if available
1046       nc_stat = NF90_INQ_VARID( id_mod, 'crs', var_id_crs )
1047       IF ( nc_stat == NF90_NOERR )  THEN
1048          CALL get_attribute( id_mod, 'epsg_code',                             &
1049                              coord_ref_sys%epsg_code,                         &
1050                              .FALSE., 'crs' )
1051          CALL get_attribute( id_mod, 'false_easting',                         &
1052                              coord_ref_sys%false_easting,                     &
1053                              .FALSE., 'crs' )
1054          CALL get_attribute( id_mod, 'false_northing',                        &
1055                              coord_ref_sys%false_northing,                    &
1056                              .FALSE., 'crs' )
1057          CALL get_attribute( id_mod, 'grid_mapping_name',                     &
1058                              coord_ref_sys%grid_mapping_name,                 &
1059                              .FALSE., 'crs' )
1060          CALL get_attribute( id_mod, 'inverse_flattening',                    &
1061                              coord_ref_sys%inverse_flattening,                &
1062                              .FALSE., 'crs' )
1063          CALL get_attribute( id_mod, 'latitude_of_projection_origin',         &
1064                              coord_ref_sys%latitude_of_projection_origin,     &
1065                              .FALSE., 'crs' )
1066          CALL get_attribute( id_mod, 'long_name',                             &
1067                              coord_ref_sys%long_name,                         &
1068                              .FALSE., 'crs' )
1069          CALL get_attribute( id_mod, 'longitude_of_central_meridian',         &
1070                              coord_ref_sys%longitude_of_central_meridian,     &
1071                              .FALSE., 'crs' )
1072          CALL get_attribute( id_mod, 'longitude_of_prime_meridian',           &
1073                              coord_ref_sys%longitude_of_prime_meridian,       &
1074                              .FALSE., 'crs' )
1075          CALL get_attribute( id_mod, 'scale_factor_at_central_meridian',      &
1076                              coord_ref_sys%scale_factor_at_central_meridian,  &
1077                              .FALSE., 'crs' )
1078          CALL get_attribute( id_mod, 'semi_major_axis',                       &
1079                              coord_ref_sys%semi_major_axis,                   &
1080                              .FALSE., 'crs' )
1081          CALL get_attribute( id_mod, 'units',                                 &
1082                              coord_ref_sys%units,                             &
1083                              .FALSE., 'crs' )
1084       ELSE
1085!
1086!--       Calculate central meridian from origin_lon
1087          coord_ref_sys%longitude_of_central_meridian = &
1088             CEILING( input_file_atts%origin_lon / 6.0_wp ) * 6.0_wp - 3.0_wp
1089       ENDIF
1090!
1091!--    Finally, close input file
1092       CALL close_input_file( id_mod )
1093#endif
1094!
1095!--    Copy latitude, longitude, origin_z, rotation angle on init type
1096       init_model%latitude        = input_file_atts%origin_lat
1097       init_model%longitude       = input_file_atts%origin_lon
1098       init_model%origin_time     = input_file_atts%origin_time 
1099       init_model%origin_x        = input_file_atts%origin_x
1100       init_model%origin_y        = input_file_atts%origin_y
1101       init_model%origin_z        = input_file_atts%origin_z 
1102       init_model%rotation_angle  = input_file_atts%rotation_angle 
1103           
1104!
1105!--    In case of nested runs, each model domain might have different longitude
1106!--    and latitude, which would result in different Coriolis parameters and
1107!--    sun-zenith angles. To avoid this, longitude and latitude in each model
1108!--    domain will be set to the values of the root model. Please note, this
1109!--    synchronization is required already here.
1110#if defined( __parallel )
1111       CALL MPI_BCAST( init_model%latitude,  1, MPI_REAL, 0,                   &
1112                       MPI_COMM_WORLD, ierr )
1113       CALL MPI_BCAST( init_model%longitude, 1, MPI_REAL, 0,                   &
1114                       MPI_COMM_WORLD, ierr )
1115#endif
1116
1117    END SUBROUTINE netcdf_data_input_init
1118   
1119!------------------------------------------------------------------------------!
1120! Description:
1121! ------------
1122!> Read an array of characters.
1123!------------------------------------------------------------------------------!
1124    SUBROUTINE netcdf_data_input_var_char( val, search_string, id_mod )
1125
1126       IMPLICIT NONE
1127
1128       CHARACTER(LEN=*) ::  search_string     !< name of the variable
1129       CHARACTER(LEN=*), DIMENSION(:) ::  val !< variable which should be read
1130       
1131       INTEGER(iwp) ::  id_mod   !< NetCDF id of input file
1132
1133#if defined ( __netcdf )
1134!
1135!--    Read variable
1136       CALL get_variable( id_mod, search_string, val )
1137#endif           
1138
1139    END SUBROUTINE netcdf_data_input_var_char
1140   
1141!------------------------------------------------------------------------------!
1142! Description:
1143! ------------
1144!> Read an 1D array of REAL values.
1145!------------------------------------------------------------------------------!
1146    SUBROUTINE netcdf_data_input_var_real_1d( val, search_string, id_mod )
1147
1148       IMPLICIT NONE
1149
1150       CHARACTER(LEN=*) ::  search_string     !< name of the variable     
1151       
1152       INTEGER(iwp) ::  id_mod        !< NetCDF id of input file
1153       
1154       REAL(wp), DIMENSION(:) ::  val !< variable which should be read
1155
1156#if defined ( __netcdf )
1157!
1158!--    Read variable
1159       CALL get_variable( id_mod, search_string, val )
1160#endif           
1161
1162    END SUBROUTINE netcdf_data_input_var_real_1d
1163   
1164!------------------------------------------------------------------------------!
1165! Description:
1166! ------------
1167!> Read an 1D array of REAL values.
1168!------------------------------------------------------------------------------!
1169    SUBROUTINE netcdf_data_input_var_real_2d( val, search_string,              &
1170                                              id_mod, d1s, d1e, d2s, d2e )
1171
1172       IMPLICIT NONE
1173
1174       CHARACTER(LEN=*) ::  search_string     !< name of the variable     
1175       
1176       INTEGER(iwp) ::  id_mod  !< NetCDF id of input file
1177       INTEGER(iwp) ::  d1e     !< end index of first dimension to be read
1178       INTEGER(iwp) ::  d2e     !< end index of second dimension to be read
1179       INTEGER(iwp) ::  d1s     !< start index of first dimension to be read
1180       INTEGER(iwp) ::  d2s     !< start index of second dimension to be read
1181       
1182       REAL(wp), DIMENSION(:,:) ::  val !< variable which should be read
1183
1184#if defined ( __netcdf )
1185!
1186!--    Read character variable
1187       CALL get_variable( id_mod, search_string, val, d1s, d1e, d2s, d2e )
1188#endif           
1189
1190    END SUBROUTINE netcdf_data_input_var_real_2d
1191   
1192!------------------------------------------------------------------------------!
1193! Description:
1194! ------------
1195!> Read a global string attribute
1196!------------------------------------------------------------------------------!
1197    SUBROUTINE netcdf_data_input_att_string( val, search_string, id_mod,       &
1198                                             input_file, global, openclose,    &
1199                                             variable_name )
1200
1201       IMPLICIT NONE
1202
1203       CHARACTER(LEN=*) ::  search_string !< name of the attribue
1204       CHARACTER(LEN=*) ::  val           !< attribute
1205       
1206       CHARACTER(LEN=*) ::  input_file    !< name of input file
1207       CHARACTER(LEN=*) ::  openclose     !< string indicating whether NetCDF needs to be opend or closed
1208       CHARACTER(LEN=*) ::  variable_name !< string indicating whether NetCDF needs to be opend or closed 
1209       
1210       INTEGER(iwp) ::  id_mod   !< NetCDF id of input file
1211       
1212       LOGICAL ::  global                 !< flag indicating a global or a variable's attribute
1213
1214#if defined ( __netcdf )
1215!
1216!--    Open file in read-only mode if necessary
1217       IF ( openclose == 'open' )  THEN
1218          CALL open_read_file( TRIM( input_file ) // TRIM( coupling_char ), &
1219                                  id_mod )
1220       ENDIF
1221!
1222!--    Read global attribute
1223       IF ( global )  THEN
1224          CALL get_attribute( id_mod, search_string, val, global )
1225!
1226!--    Read variable attribute
1227       ELSE
1228          CALL get_attribute( id_mod, search_string, val, global, variable_name )
1229       ENDIF
1230!
1231!--    Close input file
1232       IF ( openclose == 'close' )  CALL close_input_file( id_mod )
1233#endif           
1234
1235    END SUBROUTINE netcdf_data_input_att_string
1236   
1237!------------------------------------------------------------------------------!
1238! Description:
1239! ------------
1240!> Read a global 8-bit integer attribute
1241!------------------------------------------------------------------------------!
1242    SUBROUTINE netcdf_data_input_att_int8( val, search_string, id_mod,         &
1243                                           input_file, global, openclose,      &
1244                                           variable_name )
1245
1246       IMPLICIT NONE
1247
1248       CHARACTER(LEN=*) ::  search_string !< name of the attribue
1249       
1250       CHARACTER(LEN=*) ::  input_file    !< name of input file
1251       CHARACTER(LEN=*) ::  openclose     !< string indicating whether NetCDF needs to be opend or closed
1252       CHARACTER(LEN=*) ::  variable_name !< string indicating whether NetCDF needs to be opend or closed
1253       
1254       INTEGER(iwp) ::  id_mod   !< NetCDF id of input file
1255       INTEGER(KIND=1) ::  val      !< value of the attribute
1256       
1257       LOGICAL ::  global        !< flag indicating a global or a variable's attribute
1258
1259#if defined ( __netcdf )
1260!
1261!--    Open file in read-only mode
1262       IF ( openclose == 'open' )  THEN
1263          CALL open_read_file( TRIM( input_file ) // TRIM( coupling_char ), &
1264                                  id_mod )
1265       ENDIF
1266!
1267!--    Read global attribute
1268       IF ( global )  THEN
1269          CALL get_attribute( id_mod, search_string, val, global )
1270!
1271!--    Read variable attribute
1272       ELSE
1273          CALL get_attribute( id_mod, search_string, val, global, variable_name )
1274       ENDIF
1275!
1276!--    Finally, close input file
1277       IF ( openclose == 'close' )  CALL close_input_file( id_mod )
1278#endif           
1279
1280    END SUBROUTINE netcdf_data_input_att_int8
1281   
1282!------------------------------------------------------------------------------!
1283! Description:
1284! ------------
1285!> Read a global 32-bit integer attribute
1286!------------------------------------------------------------------------------!
1287    SUBROUTINE netcdf_data_input_att_int32( val, search_string, id_mod,        &
1288                                            input_file, global, openclose,     &
1289                                            variable_name )
1290
1291       IMPLICIT NONE
1292
1293       CHARACTER(LEN=*) ::  search_string !< name of the attribue
1294       
1295       CHARACTER(LEN=*) ::  input_file    !< name of input file
1296       CHARACTER(LEN=*) ::  openclose     !< string indicating whether NetCDF needs to be opend or closed
1297       CHARACTER(LEN=*) ::  variable_name !< string indicating whether NetCDF needs to be opend or closed
1298       
1299       INTEGER(iwp) ::  id_mod   !< NetCDF id of input file
1300       INTEGER(iwp) ::  val      !< value of the attribute
1301       
1302       LOGICAL ::  global        !< flag indicating a global or a variable's attribute
1303
1304#if defined ( __netcdf )
1305!
1306!--    Open file in read-only mode
1307       IF ( openclose == 'open' )  THEN
1308          CALL open_read_file( TRIM( input_file ) // TRIM( coupling_char ), &
1309                                  id_mod )
1310       ENDIF
1311!
1312!--    Read global attribute
1313       IF ( global )  THEN
1314          CALL get_attribute( id_mod, search_string, val, global )
1315!
1316!--    Read variable attribute
1317       ELSE
1318          CALL get_attribute( id_mod, search_string, val, global, variable_name )
1319       ENDIF
1320!
1321!--    Finally, close input file
1322       IF ( openclose == 'close' )  CALL close_input_file( id_mod )
1323#endif           
1324
1325    END SUBROUTINE netcdf_data_input_att_int32
1326   
1327!------------------------------------------------------------------------------!
1328! Description:
1329! ------------
1330!> Read a global real attribute
1331!------------------------------------------------------------------------------!
1332    SUBROUTINE netcdf_data_input_att_real( val, search_string, id_mod,         &
1333                                           input_file, global, openclose,      &
1334                                           variable_name )
1335
1336       IMPLICIT NONE
1337
1338       CHARACTER(LEN=*) ::  search_string !< name of the attribue
1339       
1340       CHARACTER(LEN=*) ::  input_file    !< name of input file
1341       CHARACTER(LEN=*) ::  openclose     !< string indicating whether NetCDF needs to be opend or closed
1342       CHARACTER(LEN=*) ::  variable_name !< string indicating whether NetCDF needs to be opend or closed
1343       
1344       INTEGER(iwp) ::  id_mod            !< NetCDF id of input file
1345       
1346       LOGICAL ::  global                 !< flag indicating a global or a variable's attribute
1347       
1348       REAL(wp) ::  val                   !< value of the attribute
1349
1350#if defined ( __netcdf )
1351!
1352!--    Open file in read-only mode
1353       IF ( openclose == 'open' )  THEN
1354          CALL open_read_file( TRIM( input_file ) // TRIM( coupling_char ), &
1355                                  id_mod )
1356       ENDIF
1357!
1358!--    Read global attribute
1359       IF ( global )  THEN
1360          CALL get_attribute( id_mod, search_string, val, global )
1361!
1362!--    Read variable attribute
1363       ELSE
1364          CALL get_attribute( id_mod, search_string, val, global, variable_name )
1365       ENDIF
1366!
1367!--    Finally, close input file
1368       IF ( openclose == 'close' )  CALL close_input_file( id_mod )
1369#endif           
1370
1371    END SUBROUTINE netcdf_data_input_att_real
1372
1373!------------------------------------------------------------------------------!
1374! Description:
1375! ------------
1376!> Reads Chemistry NETCDF Input data, such as emission values, emission species, etc. .
1377!------------------------------------------------------------------------------!
1378    SUBROUTINE netcdf_data_input_chemistry_data(emt_att,emt)
1379
1380       USE chem_modules,                                       &
1381           ONLY:  mode_emis, time_fac_type, surface_csflux_name
1382
1383       USE control_parameters,                                 &
1384           ONLY:  message_string
1385
1386       USE indices,                                            &
1387           ONLY:  nx, ny, nxl, nxr, nys, nyn
1388
1389       IMPLICIT NONE
1390
1391       TYPE(chem_emis_att_type), INTENT(INOUT)                                        :: emt_att
1392       TYPE(chem_emis_val_type), ALLOCATABLE, DIMENSION(:), INTENT(INOUT)             :: emt
1393   
1394       INTEGER(iwp)                                     :: ispec                 !< index for number of emission species in input
1395
1396       INTEGER(iwp)                                     :: num_vars              !< number of variables in netcdf input file
1397       INTEGER(iwp)                                     :: len_dims              !< Length of dimension
1398
1399       REAL(wp), ALLOCATABLE, DIMENSION(:,:,:)          :: dum_var_3d            !< variable for storing temporary data of 3-dimensional
1400                                                                                 !  variables read from netcdf for chemistry emissions
1401
1402       REAL(wp), ALLOCATABLE, DIMENSION(:,:,:,:)        :: dum_var_4d            !< variable for storing temporary data of 5-dimensional
1403                                                                                 !< variables read from netcdf for chemistry emissions
1404!--
1405       !> Start the processing of the data
1406
1407       !> Parameterized mode of the emissions
1408       IF (TRIM(mode_emis)=="PARAMETERIZED" .OR. TRIM(mode_emis)=="parameterized") THEN
1409
1410           ispec=1
1411           emt_att%nspec=0
1412
1413          !number of species
1414           DO  WHILE (TRIM( surface_csflux_name( ispec ) ) /= 'novalue' )
1415
1416             emt_att%nspec=emt_att%nspec+1
1417             ispec=ispec+1
1418
1419           ENDDO
1420
1421          !-- allocate emission values data type arrays
1422          ALLOCATE(emt(emt_att%nspec))
1423
1424          !-- Read EMISSION SPECIES NAMES
1425
1426          !Assign values
1427          ALLOCATE(emt_att%species_name(emt_att%nspec))
1428 
1429         DO ispec=1,emt_att%nspec
1430            emt_att%species_name(ispec) = TRIM(surface_csflux_name(ispec))
1431         ENDDO
1432
1433
1434       !> DEFAULT AND PRE-PROCESSED MODE
1435       ELSE
1436
1437#if defined ( __netcdf )       
1438          IF ( .NOT. input_pids_chem )  RETURN
1439
1440          !-- Open file in read-only mode
1441          CALL open_read_file( TRIM( input_file_chem ) //                       &
1442                               TRIM( coupling_char ), id_emis )
1443          !-- inquire number of variables
1444          CALL inquire_num_variables( id_emis, num_vars )
1445
1446          !-- Get General Dimension Lengths: only number of species and number of categories.
1447          !                                  the other dimensions depend on the mode of the emissions or on the presence of specific components
1448          !nspecies
1449          CALL netcdf_data_input_get_dimension_length( id_emis, emt_att%nspec, 'nspecies' )
1450
1451 
1452          !-- Allocate emission values data type arrays
1453          ALLOCATE(emt(1:emt_att%nspec))
1454
1455
1456          !-- Read EMISSION SPECIES NAMES
1457          !Allocate Arrays
1458          ALLOCATE(emt_att%species_name(emt_att%nspec)) 
1459
1460          !Call get Variable
1461          CALL get_variable( id_emis, 'emission_name', string_values, emt_att%nspec )
1462          emt_att%species_name=string_values
1463          ! If allocated, Deallocate var_string, an array only used for reading-in strings
1464          IF (ALLOCATED(string_values)) DEALLOCATE(string_values) 
1465
1466          !-- Read EMISSION SPECIES INDEX
1467          !Allocate Arrays
1468          ALLOCATE(emt_att%species_index(emt_att%nspec))
1469          !Call get Variable
1470          CALL get_variable( id_emis, 'emission_index', emt_att%species_index )
1471
1472
1473          !-- Now the routine has to distinguish between DEFAULT and PRE-PROCESSED chemistry emission modes
1474
1475          IF (TRIM(mode_emis)=="DEFAULT" .OR. TRIM(mode_emis)=="default") THEN
1476 
1477             !number of categories
1478             CALL netcdf_data_input_get_dimension_length( id_emis, emt_att%ncat, 'ncat' )
1479
1480             !-- Read EMISSION CATEGORIES INDEX
1481             !Allocate Arrays
1482             ALLOCATE(emt_att%cat_index(emt_att%ncat))
1483             !Call get Variable
1484             CALL get_variable( id_emis, 'emission_cat_index', emt_att%cat_index )
1485
1486 
1487             DO ispec=1,emt_att%nspec
1488                !-- EMISSION_VOC_NAME (1-DIMENSIONAL)
1489                IF (TRIM(emt_att%species_name(ispec))=="VOC" .OR. TRIM(emt_att%species_name(ispec))=="voc") THEN
1490                   !Allocate Array
1491                   CALL netcdf_data_input_get_dimension_length( id_emis, emt_att%nvoc, 'nvoc' )
1492                   ALLOCATE(emt_att%voc_name(1:emt_att%nvoc))
1493                   !Read-in Variable
1494                   CALL get_variable( id_emis,"emission_voc_name",string_values, emt_att%nvoc)
1495                   emt_att%voc_name=string_values
1496                   IF (ALLOCATED(string_values)) DEALLOCATE(string_values)
1497 
1498                !-- COMPOSITION VOC (2-DIMENSIONAL)
1499                   !Allocate Array
1500                   ALLOCATE(emt_att%voc_comp(1:emt_att%ncat,1:emt_att%nvoc))
1501                   !Read-in Variable
1502!               CALL get_variable(id_emis,"composition_voc",emt%voc_comp,1,1,emt%ncat,emt%nvoc)
1503                   CALL get_variable(id_emis,"composition_voc",emt_att%voc_comp,1,emt_att%ncat,1,emt_att%nvoc)
1504                ENDIF
1505
1506                !-- EMISSION_PM_NAME (1-DIMENSIONAL)
1507                IF (TRIM(emt_att%species_name(ispec))=="PM" .OR. TRIM(emt_att%species_name(ispec))=="pm") THEN
1508                   CALL netcdf_data_input_get_dimension_length( id_emis, emt_att%npm, 'npm' )
1509                   ALLOCATE(emt_att%pm_name(1:emt_att%npm))
1510                   !Read-in Variable
1511                   CALL get_variable( id_emis,"pm_name",string_values, emt_att%npm)
1512                   emt_att%pm_name=string_values
1513                   IF (ALLOCATED(string_values)) DEALLOCATE(string_values)     
1514
1515                !-- COMPOSITION PM (3-DIMENSIONAL)
1516                   !Allocate
1517                   len_dims=3  !> number of PMs: PM1, PM2.5 and PM10
1518                   ALLOCATE(emt_att%pm_comp(1:emt_att%ncat,1:emt_att%npm,1:len_dims))
1519                   !Read-in Variable
1520                   CALL get_variable(id_emis,"composition_pm",emt_att%pm_comp,1,emt_att%ncat,1,emt_att%npm,1,len_dims)                   
1521                ENDIF
1522
1523                !-- COMPOSITION_NOX (2-DIMENSIONAL)
1524                IF (TRIM(emt_att%species_name(ispec))=="NOx" .OR. TRIM(emt_att%species_name(ispec))=="nox") THEN
1525                   !Allocate array
1526                   ALLOCATE(emt_att%nox_comp(1:emt_att%ncat,1:emt_att%nnox))
1527                   !Read-in Variable
1528                   CALL get_variable(id_emis,"composition_nox",emt_att%nox_comp,1,emt_att%ncat,1,emt_att%nnox)
1529                ENDIF
1530
1531                !-- COMPOSITION-SOX (2-DIMENSIONAL)
1532                IF (TRIM(emt_att%species_name(ispec))=="SOx" .OR. TRIM(emt_att%species_name(ispec))=="sox") THEN
1533                   ALLOCATE(emt_att%sox_comp(1:emt_att%ncat,1:emt_att%nsox))
1534                   !Read-in Variable
1535                   CALL get_variable(id_emis,"composition_sox",emt_att%sox_comp,1,emt_att%ncat,1,emt_att%nsox)
1536                ENDIF
1537             ENDDO !>ispec
1538
1539!-- For reading the emission time factors, the distinction between HOUR and MDH data is necessary
1540     
1541             !-- EMISSION_TIME_SCALING_FACTORS
1542                !-- HOUR   
1543             IF (TRIM(time_fac_type)=="HOUR" .OR. TRIM(time_fac_type)=="hour") THEN
1544                !-- Allocate Array
1545                CALL netcdf_data_input_get_dimension_length( id_emis, emt_att%nhoursyear, 'nhoursyear' )
1546                ALLOCATE(emt_att%hourly_emis_time_factor(1:emt_att%ncat,1:emt_att%nhoursyear))
1547                !Read-in Variable
1548                CALL get_variable(id_emis,"emission_time_factors",emt_att%hourly_emis_time_factor,1,   &
1549                                  emt_att%ncat,1,emt_att%nhoursyear)
1550
1551                !-- MDH
1552             ELSE IF (TRIM(time_fac_type) == "MDH" .OR. TRIM(time_fac_type) == "mdh") THEN
1553                !-- Allocate Array
1554                CALL netcdf_data_input_get_dimension_length( id_emis, emt_att%nmonthdayhour, 'nmonthdayhour' )
1555                ALLOCATE(emt_att%mdh_emis_time_factor(1:emt_att%ncat,1:emt_att%nmonthdayhour))
1556                !-- Read-in Variable
1557                CALL get_variable(id_emis,"emission_time_factors",emt_att%mdh_emis_time_factor,1,       &
1558                                  emt_att%ncat,1,emt_att%nmonthdayhour)
1559
1560             ELSE
1561
1562             message_string = 'We are in the DEFAULT chemistry emissions mode: '            //          &
1563                              '     !no time-factor type specified!'                        //          &
1564                              'Please, specify the value of time_fac_type:'                 //          &
1565                              '         either "MDH" or "HOUR"'                 
1566             CALL message( 'netcdf_data_input_chemistry_data', 'CM0200', 2, 2, 0, 6, 0 ) 
1567 
1568
1569             ENDIF
1570
1571             !-- Finally read-in the emission values and their units (DEFAULT mode)
1572
1573             DO ispec=1,emt_att%nspec
1574
1575                IF ( .NOT. ALLOCATED( emt(ispec)%default_emission_data ) )                              &
1576                    ALLOCATE(emt(ispec)%default_emission_data(1:emt_att%ncat,1:ny+1,1:nx+1))
1577
1578                ALLOCATE(dum_var_3d(1:emt_att%ncat,nys+1:nyn+1,nxl+1:nxr+1))
1579
1580                CALL get_variable(id_emis,"emission_values",dum_var_3d,ispec,1,emt_att%ncat,nys,nyn,nxl,nxr)         
1581
1582                emt(ispec)%default_emission_data(:,nys+1:nyn+1,nxl+1:nxr+1) =                           &
1583                    dum_var_3d(1:emt_att%ncat,nys+1:nyn+1,nxl+1:nxr+1)
1584
1585                DEALLOCATE (dum_var_3d)
1586
1587             ENDDO
1588
1589             !-- UNITS
1590             CALL get_attribute(id_emis,"units",emt_att%units,.FALSE.,"emission_values")
1591
1592
1593          !-- PRE-PROCESSED MODE --
1594
1595          ELSE IF (TRIM(mode_emis)=="PRE-PROCESSED" .OR. TRIM(mode_emis)=="pre-processed") THEN
1596          !-- In the PRE-PROCESSED mode, only the VOC names, the VOC_composition, the emission values and their units remain to be read at this point
1597
1598             DO ispec=1,emt_att%nspec
1599
1600             !-- EMISSION_VOC_NAME (1-DIMENSIONAL)
1601                IF (TRIM(emt_att%species_name(ispec))=="VOC" .OR. TRIM(emt_att%species_name(ispec))=="voc") THEN
1602                   !Allocate Array
1603                   CALL netcdf_data_input_get_dimension_length( id_emis, emt_att%nvoc, 'nvoc' )
1604                   ALLOCATE(emt_att%voc_name(1:emt_att%nvoc))
1605                   !Read-in Variable
1606                   CALL get_variable( id_emis,"emission_voc_name",string_values, emt_att%nvoc)
1607                   emt_att%voc_name=string_values
1608                   IF (ALLOCATED(string_values)) DEALLOCATE(string_values)
1609 
1610             !-- COMPOSITION VOC (2-DIMENSIONAL)
1611                   !Allocate Array
1612                   ALLOCATE(emt_att%voc_comp(1:emt_att%ncat,1:emt_att%nvoc))
1613                   !Read-in Variable
1614                   CALL get_variable(id_emis,"composition_voc",emt_att%voc_comp,1,emt_att%ncat,1,emt_att%nvoc)
1615                ENDIF
1616 
1617             ENDDO !> ispec
1618
1619             !-- EMISSION_VALUES (4-DIMENSIONAL)
1620             !Calculate temporal dimension length
1621             CALL netcdf_data_input_get_dimension_length( id_emis, emt_att%dt_emission, 'time' )   
1622         
1623
1624             DO ispec=1,emt_att%nspec
1625
1626                !Allocation for the entire domain has to be done only for the first processor between all the subdomains     
1627                IF ( .NOT. ALLOCATED( emt(ispec)%preproc_emission_data ) )                              &
1628                    ALLOCATE(emt(ispec)%preproc_emission_data(emt_att%dt_emission,1,1:ny+1,1:nx+1))
1629
1630                !> allocate variable where to pass emission values read from netcdf
1631                ALLOCATE(dum_var_4d(1:emt_att%dt_emission,1,nys+1:nyn+1,nxl+1:nxr+1))
1632
1633                !Read-in Variable
1634                CALL get_variable(id_emis,"emission_values",dum_var_4d,ispec,1,emt_att%dt_emission,1,1,nys,nyn,nxl,nxr)         
1635
1636     
1637                emt(ispec)%preproc_emission_data(:,1,nys+1:nyn+1,nxl+1:nxr+1) =                         &
1638                      dum_var_4d(1:emt_att%dt_emission,1,nys+1:nyn+1,nxl+1:nxr+1)
1639
1640                DEALLOCATE ( dum_var_4d )
1641
1642             ENDDO
1643
1644             !-- UNITS
1645             CALL get_attribute(id_emis,"units",emt_att%units,.FALSE.,"emission_values")
1646       
1647          ENDIF
1648
1649       CALL close_input_file( id_emis )
1650
1651#endif
1652       ENDIF
1653
1654    END SUBROUTINE netcdf_data_input_chemistry_data
1655
1656!------------------------------------------------------------------------------!
1657! Description:
1658! ------------
1659!> Reads surface classification data, such as vegetation and soil type, etc. .
1660!------------------------------------------------------------------------------!
1661    SUBROUTINE netcdf_data_input_surface_data
1662
1663       USE control_parameters,                                                 &
1664           ONLY:  land_surface, plant_canopy, urban_surface
1665
1666       USE indices,                                                            &
1667           ONLY:  nbgp, nxl, nxr, nyn, nys
1668
1669
1670       IMPLICIT NONE
1671
1672       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names  !< variable names in static input file
1673
1674       INTEGER(iwp) ::  id_surf   !< NetCDF id of input file
1675       INTEGER(iwp) ::  k         !< running index along z-direction
1676       INTEGER(iwp) ::  k2        !< running index
1677       INTEGER(iwp) ::  num_vars  !< number of variables in input file
1678       INTEGER(iwp) ::  nz_soil   !< number of soil layers in file
1679
1680!
1681!--    If not static input file is available, skip this routine
1682       IF ( .NOT. input_pids_static )  RETURN
1683!
1684!--    Measure CPU time
1685       CALL cpu_log( log_point_s(82), 'NetCDF input', 'start' )
1686!
1687!--    Read plant canopy variables.
1688       IF ( plant_canopy )  THEN
1689#if defined ( __netcdf )
1690!
1691!--       Open file in read-only mode
1692          CALL open_read_file( TRIM( input_file_static ) //                    &
1693                               TRIM( coupling_char ) , id_surf )
1694!
1695!--       At first, inquire all variable names.
1696!--       This will be used to check whether an optional input variable
1697!--       exist or not.
1698          CALL inquire_num_variables( id_surf, num_vars )
1699
1700          ALLOCATE( var_names(1:num_vars) )
1701          CALL inquire_variable_names( id_surf, var_names )
1702
1703!
1704!--       Read leaf area density - resolved vegetation
1705          IF ( check_existence( var_names, 'lad' ) )  THEN
1706             leaf_area_density_f%from_file = .TRUE.
1707             CALL get_attribute( id_surf, char_fill,                           &
1708                                 leaf_area_density_f%fill,                     &
1709                                 .FALSE., 'lad' )
1710!
1711!--          Inquire number of vertical vegetation layer
1712             CALL netcdf_data_input_get_dimension_length( id_surf,             &
1713                                                 leaf_area_density_f%nz,       &
1714                                                 'zlad' )
1715!
1716!--          Allocate variable for leaf-area density
1717             ALLOCATE( leaf_area_density_f%var( 0:leaf_area_density_f%nz-1,    &
1718                                                nys:nyn,nxl:nxr) )
1719
1720             CALL get_variable( id_surf, 'lad', leaf_area_density_f%var,       &
1721                                nxl, nxr, nys, nyn,                            &
1722                                0, leaf_area_density_f%nz-1 )
1723
1724          ELSE
1725             leaf_area_density_f%from_file = .FALSE.
1726          ENDIF
1727
1728!
1729!--       Read basal area density - resolved vegetation
1730          IF ( check_existence( var_names, 'bad' ) )  THEN
1731             basal_area_density_f%from_file = .TRUE.
1732             CALL get_attribute( id_surf, char_fill,                           &
1733                                 basal_area_density_f%fill,                    &
1734                                 .FALSE., 'bad' )
1735!
1736!--          Inquire number of vertical vegetation layer
1737             CALL netcdf_data_input_get_dimension_length( id_surf,             &
1738                                                 basal_area_density_f%nz,      &
1739                                                 'zlad' )
1740!
1741!--          Allocate variable
1742             ALLOCATE( basal_area_density_f%var(0:basal_area_density_f%nz-1,   &
1743                                                nys:nyn,nxl:nxr) )
1744
1745             CALL get_variable( id_surf, 'bad', basal_area_density_f%var,      &
1746                                nxl, nxr, nys, nyn,                            &
1747                                0,  basal_area_density_f%nz-1 )
1748          ELSE
1749             basal_area_density_f%from_file = .FALSE.
1750          ENDIF
1751
1752!
1753!--       Read root area density - resolved vegetation
1754          IF ( check_existence( var_names, 'root_area_dens_r' ) )  THEN
1755             root_area_density_lad_f%from_file = .TRUE.
1756             CALL get_attribute( id_surf, char_fill,                           &
1757                                 root_area_density_lad_f%fill,                 &
1758                                 .FALSE., 'root_area_dens_r' )
1759!
1760!--          Inquire number of vertical soil layers
1761             CALL netcdf_data_input_get_dimension_length( id_surf,             &
1762                                                   root_area_density_lad_f%nz, &
1763                                                  'zsoil' )
1764!
1765!--          Allocate variable
1766             ALLOCATE( root_area_density_lad_f%var                             &
1767                                         (0:root_area_density_lad_f%nz-1,      &
1768                                          nys:nyn,nxl:nxr) )
1769
1770             CALL get_variable( id_surf, 'root_area_dens_r',                   &
1771                                root_area_density_lad_f%var,                   &
1772                                nxl, nxr, nys, nyn,                            &
1773                                0,  root_area_density_lad_f%nz-1 )
1774          ELSE
1775             root_area_density_lad_f%from_file = .FALSE.
1776          ENDIF
1777!
1778!--       Finally, close input file
1779          CALL close_input_file( id_surf )
1780#endif
1781       ENDIF
1782!
1783!--    Deallocate variable list. Will be re-allocated in case further
1784!--    variables are read from file.
1785       IF ( ALLOCATED( var_names ) )  DEALLOCATE( var_names )
1786!
1787!--    Skip the following if no land-surface or urban-surface module are
1788!--    applied. This case, no one of the following variables is used anyway.
1789       IF (  .NOT. land_surface  .AND.  .NOT. urban_surface )  RETURN
1790
1791#if defined ( __netcdf )
1792!
1793!--    Open file in read-only mode
1794       CALL open_read_file( TRIM( input_file_static ) //                       &
1795                            TRIM( coupling_char ) , id_surf )
1796!
1797!--    Inquire all variable names.
1798!--    This will be used to check whether an optional input variable exist
1799!--    or not.
1800       CALL inquire_num_variables( id_surf, num_vars )
1801
1802       ALLOCATE( var_names(1:num_vars) )
1803       CALL inquire_variable_names( id_surf, var_names )
1804!
1805!--    Read vegetation type and required attributes
1806       IF ( check_existence( var_names, 'vegetation_type' ) )  THEN
1807          vegetation_type_f%from_file = .TRUE.
1808          CALL get_attribute( id_surf, char_fill,                              &
1809                              vegetation_type_f%fill,                          &
1810                              .FALSE., 'vegetation_type' )
1811
1812          ALLOCATE ( vegetation_type_f%var(nys:nyn,nxl:nxr)  )
1813
1814          CALL get_variable( id_surf, 'vegetation_type',                       &
1815                             vegetation_type_f%var, nxl, nxr, nys, nyn )
1816       ELSE
1817          vegetation_type_f%from_file = .FALSE.
1818       ENDIF
1819
1820!
1821!--    Read soil type and required attributes
1822       IF ( check_existence( var_names, 'soil_type' ) )  THEN
1823             soil_type_f%from_file = .TRUE.
1824!
1825!--       Note, lod is currently not on file; skip for the moment
1826!           CALL get_attribute( id_surf, char_lod,                       &
1827!                                      soil_type_f%lod,                  &
1828!                                      .FALSE., 'soil_type' )
1829          CALL get_attribute( id_surf, char_fill,                              &
1830                              soil_type_f%fill,                                &
1831                              .FALSE., 'soil_type' )
1832
1833          IF ( soil_type_f%lod == 1 )  THEN
1834
1835             ALLOCATE ( soil_type_f%var_2d(nys:nyn,nxl:nxr)  )
1836
1837             CALL get_variable( id_surf, 'soil_type', soil_type_f%var_2d,      &
1838                                nxl, nxr, nys, nyn )
1839
1840          ELSEIF ( soil_type_f%lod == 2 )  THEN
1841!
1842!--          Obtain number of soil layers from file.
1843             CALL netcdf_data_input_get_dimension_length( id_surf, nz_soil,    &
1844                                                          'zsoil' )
1845
1846             ALLOCATE ( soil_type_f%var_3d(0:nz_soil,nys:nyn,nxl:nxr) )
1847
1848             CALL get_variable( id_surf, 'soil_type', soil_type_f%var_3d,      &
1849                                nxl, nxr, nys, nyn, 0, nz_soil )
1850 
1851          ENDIF
1852       ELSE
1853          soil_type_f%from_file = .FALSE.
1854       ENDIF
1855
1856!
1857!--    Read pavement type and required attributes
1858       IF ( check_existence( var_names, 'pavement_type' ) )  THEN
1859          pavement_type_f%from_file = .TRUE.
1860          CALL get_attribute( id_surf, char_fill,                              &
1861                              pavement_type_f%fill, .FALSE.,                   &
1862                              'pavement_type' )
1863
1864          ALLOCATE ( pavement_type_f%var(nys:nyn,nxl:nxr)  )
1865
1866          CALL get_variable( id_surf, 'pavement_type', pavement_type_f%var,    &
1867                             nxl, nxr, nys, nyn )
1868       ELSE
1869          pavement_type_f%from_file = .FALSE.
1870       ENDIF
1871
1872!
1873!--    Read water type and required attributes
1874       IF ( check_existence( var_names, 'water_type' ) )  THEN
1875          water_type_f%from_file = .TRUE.
1876          CALL get_attribute( id_surf, char_fill, water_type_f%fill,           &
1877                              .FALSE., 'water_type' )
1878
1879          ALLOCATE ( water_type_f%var(nys:nyn,nxl:nxr)  )
1880
1881          CALL get_variable( id_surf, 'water_type', water_type_f%var,          &
1882                             nxl, nxr, nys, nyn )
1883
1884       ELSE
1885          water_type_f%from_file = .FALSE.
1886       ENDIF
1887!
1888!--    Read relative surface fractions of vegetation, pavement and water.
1889       IF ( check_existence( var_names, 'surface_fraction' ) )  THEN
1890          surface_fraction_f%from_file = .TRUE.
1891          CALL get_attribute( id_surf, char_fill,                              &
1892                              surface_fraction_f%fill,                         &
1893                              .FALSE., 'surface_fraction' )
1894!
1895!--       Inquire number of surface fractions
1896          CALL netcdf_data_input_get_dimension_length( id_surf,                &
1897                                                       surface_fraction_f%nf,  &
1898                                                       'nsurface_fraction' )
1899!
1900!--       Allocate dimension array and input array for surface fractions
1901          ALLOCATE( surface_fraction_f%nfracs(0:surface_fraction_f%nf-1) )
1902          ALLOCATE( surface_fraction_f%frac(0:surface_fraction_f%nf-1,         &
1903                                            nys:nyn,nxl:nxr) )
1904!
1905!--       Get dimension of surface fractions
1906          CALL get_variable( id_surf, 'nsurface_fraction',                     &
1907                             surface_fraction_f%nfracs )
1908!
1909!--       Read surface fractions
1910          CALL get_variable( id_surf, 'surface_fraction',                      &
1911                             surface_fraction_f%frac, nxl, nxr, nys, nyn,      &
1912                             0, surface_fraction_f%nf-1 )
1913       ELSE
1914          surface_fraction_f%from_file = .FALSE.
1915       ENDIF
1916!
1917!--    Read building parameters and related information
1918       IF ( check_existence( var_names, 'building_pars' ) )  THEN
1919          building_pars_f%from_file = .TRUE.
1920          CALL get_attribute( id_surf, char_fill,                              &
1921                              building_pars_f%fill,                            &
1922                              .FALSE., 'building_pars' )
1923!
1924!--       Inquire number of building parameters
1925          CALL netcdf_data_input_get_dimension_length( id_surf,                &
1926                                                       building_pars_f%np,     &
1927                                                       'nbuilding_pars' )
1928!
1929!--       Allocate dimension array and input array for building parameters
1930          ALLOCATE( building_pars_f%pars(0:building_pars_f%np-1) )
1931          ALLOCATE( building_pars_f%pars_xy(0:building_pars_f%np-1,            &
1932                                            nys:nyn,nxl:nxr) )
1933!
1934!--       Get dimension of building parameters
1935          CALL get_variable( id_surf, 'nbuilding_pars',                        &
1936                             building_pars_f%pars )
1937!
1938!--       Read building_pars
1939          CALL get_variable( id_surf, 'building_pars',                         &
1940                             building_pars_f%pars_xy, nxl, nxr, nys, nyn,      &
1941                             0, building_pars_f%np-1 )
1942       ELSE
1943          building_pars_f%from_file = .FALSE.
1944       ENDIF
1945
1946!
1947!--    Read albedo type and required attributes
1948       IF ( check_existence( var_names, 'albedo_type' ) )  THEN
1949          albedo_type_f%from_file = .TRUE.
1950          CALL get_attribute( id_surf, char_fill, albedo_type_f%fill,          &
1951                              .FALSE.,  'albedo_type' )
1952
1953          ALLOCATE ( albedo_type_f%var(nys:nyn,nxl:nxr)  )
1954         
1955          CALL get_variable( id_surf, 'albedo_type', albedo_type_f%var,        &
1956                             nxl, nxr, nys, nyn )
1957       ELSE
1958          albedo_type_f%from_file = .FALSE.
1959       ENDIF
1960!
1961!--    Read albedo parameters and related information
1962       IF ( check_existence( var_names, 'albedo_pars' ) )  THEN
1963          albedo_pars_f%from_file = .TRUE.
1964          CALL get_attribute( id_surf, char_fill, albedo_pars_f%fill,          &
1965                              .FALSE., 'albedo_pars' )
1966!
1967!--       Inquire number of albedo parameters
1968          CALL netcdf_data_input_get_dimension_length( id_surf,                &
1969                                                       albedo_pars_f%np,       &
1970                                                       'nalbedo_pars' )
1971!
1972!--       Allocate dimension array and input array for albedo parameters
1973          ALLOCATE( albedo_pars_f%pars(0:albedo_pars_f%np-1) )
1974          ALLOCATE( albedo_pars_f%pars_xy(0:albedo_pars_f%np-1,                &
1975                                          nys:nyn,nxl:nxr) )
1976!
1977!--       Get dimension of albedo parameters
1978          CALL get_variable( id_surf, 'nalbedo_pars', albedo_pars_f%pars )
1979
1980          CALL get_variable( id_surf, 'albedo_pars', albedo_pars_f%pars_xy,    &
1981                             nxl, nxr, nys, nyn,                               &
1982                             0, albedo_pars_f%np-1 )
1983       ELSE
1984          albedo_pars_f%from_file = .FALSE.
1985       ENDIF
1986
1987!
1988!--    Read pavement parameters and related information
1989       IF ( check_existence( var_names, 'pavement_pars' ) )  THEN
1990          pavement_pars_f%from_file = .TRUE.
1991          CALL get_attribute( id_surf, char_fill,                              &
1992                              pavement_pars_f%fill,                            &
1993                              .FALSE., 'pavement_pars' )
1994!
1995!--       Inquire number of pavement parameters
1996          CALL netcdf_data_input_get_dimension_length( id_surf,                &
1997                                                       pavement_pars_f%np,     &
1998                                                       'npavement_pars' )
1999!
2000!--       Allocate dimension array and input array for pavement parameters
2001          ALLOCATE( pavement_pars_f%pars(0:pavement_pars_f%np-1) )
2002          ALLOCATE( pavement_pars_f%pars_xy(0:pavement_pars_f%np-1,            &
2003                                            nys:nyn,nxl:nxr) )
2004!
2005!--       Get dimension of pavement parameters
2006          CALL get_variable( id_surf, 'npavement_pars', pavement_pars_f%pars )
2007
2008          CALL get_variable( id_surf, 'pavement_pars', pavement_pars_f%pars_xy,&
2009                             nxl, nxr, nys, nyn,                               &
2010                             0, pavement_pars_f%np-1 )
2011       ELSE
2012          pavement_pars_f%from_file = .FALSE.
2013       ENDIF
2014
2015!
2016!--    Read pavement subsurface parameters and related information
2017       IF ( check_existence( var_names, 'pavement_subsurface_pars' ) )         &
2018       THEN
2019          pavement_subsurface_pars_f%from_file = .TRUE.
2020          CALL get_attribute( id_surf, char_fill,                              &
2021                              pavement_subsurface_pars_f%fill,                 &
2022                              .FALSE., 'pavement_subsurface_pars' )
2023!
2024!--       Inquire number of parameters
2025          CALL netcdf_data_input_get_dimension_length( id_surf,                &
2026                                                pavement_subsurface_pars_f%np, &
2027                                               'npavement_subsurface_pars' )
2028!
2029!--       Inquire number of soil layers
2030          CALL netcdf_data_input_get_dimension_length( id_surf,                &
2031                                                pavement_subsurface_pars_f%nz, &
2032                                                'zsoil' )
2033!
2034!--       Allocate dimension array and input array for pavement parameters
2035          ALLOCATE( pavement_subsurface_pars_f%pars                            &
2036                            (0:pavement_subsurface_pars_f%np-1) )
2037          ALLOCATE( pavement_subsurface_pars_f%pars_xyz                        &
2038                            (0:pavement_subsurface_pars_f%np-1,                &
2039                             0:pavement_subsurface_pars_f%nz-1,                &
2040                             nys:nyn,nxl:nxr) )
2041!
2042!--       Get dimension of pavement parameters
2043          CALL get_variable( id_surf, 'npavement_subsurface_pars',             &
2044                             pavement_subsurface_pars_f%pars )
2045
2046          CALL get_variable( id_surf, 'pavement_subsurface_pars',              &
2047                             pavement_subsurface_pars_f%pars_xyz,              &
2048                             nxl, nxr, nys, nyn,                               &
2049                             0, pavement_subsurface_pars_f%nz-1,               &
2050                             0, pavement_subsurface_pars_f%np-1 )
2051       ELSE
2052          pavement_subsurface_pars_f%from_file = .FALSE.
2053       ENDIF
2054
2055
2056!
2057!--    Read vegetation parameters and related information
2058       IF ( check_existence( var_names, 'vegetation_pars' ) )  THEN
2059          vegetation_pars_f%from_file = .TRUE.
2060          CALL get_attribute( id_surf, char_fill,                              &
2061                              vegetation_pars_f%fill,                          &
2062                              .FALSE.,  'vegetation_pars' )
2063!
2064!--       Inquire number of vegetation parameters
2065          CALL netcdf_data_input_get_dimension_length( id_surf,                &
2066                                                       vegetation_pars_f%np,   &
2067                                                       'nvegetation_pars' )
2068!
2069!--       Allocate dimension array and input array for surface fractions
2070          ALLOCATE( vegetation_pars_f%pars(0:vegetation_pars_f%np-1) )
2071          ALLOCATE( vegetation_pars_f%pars_xy(0:vegetation_pars_f%np-1,        &
2072                                              nys:nyn,nxl:nxr) )
2073!
2074!--       Get dimension of the parameters
2075          CALL get_variable( id_surf, 'nvegetation_pars',                      &
2076                             vegetation_pars_f%pars )
2077
2078          CALL get_variable( id_surf, 'vegetation_pars',                       &
2079                             vegetation_pars_f%pars_xy, nxl, nxr, nys, nyn,    &
2080                             0, vegetation_pars_f%np-1 )
2081       ELSE
2082          vegetation_pars_f%from_file = .FALSE.
2083       ENDIF
2084
2085!
2086!--    Read root parameters/distribution and related information
2087       IF ( check_existence( var_names, 'soil_pars' ) )  THEN
2088          soil_pars_f%from_file = .TRUE.
2089          CALL get_attribute( id_surf, char_fill,                              &
2090                              soil_pars_f%fill,                                &
2091                              .FALSE., 'soil_pars' )
2092
2093          CALL get_attribute( id_surf, char_lod,                               &
2094                              soil_pars_f%lod,                                 &
2095                              .FALSE., 'soil_pars' )
2096
2097!
2098!--       Inquire number of soil parameters
2099          CALL netcdf_data_input_get_dimension_length( id_surf,                &
2100                                                       soil_pars_f%np,         &
2101                                                       'nsoil_pars' )
2102!
2103!--       Read parameters array
2104          ALLOCATE( soil_pars_f%pars(0:soil_pars_f%np-1) )
2105          CALL get_variable( id_surf, 'nsoil_pars', soil_pars_f%pars )
2106
2107!
2108!--       In case of level of detail 2, also inquire number of vertical
2109!--       soil layers, allocate memory and read the respective dimension
2110          IF ( soil_pars_f%lod == 2 )  THEN
2111             CALL netcdf_data_input_get_dimension_length( id_surf,             &
2112                                                          soil_pars_f%nz,      &
2113                                                          'zsoil' )
2114
2115             ALLOCATE( soil_pars_f%layers(0:soil_pars_f%nz-1) )
2116             CALL get_variable( id_surf, 'zsoil', soil_pars_f%layers )
2117
2118          ENDIF
2119
2120!
2121!--       Read soil parameters, depending on level of detail
2122          IF ( soil_pars_f%lod == 1 )  THEN
2123             ALLOCATE( soil_pars_f%pars_xy(0:soil_pars_f%np-1,                 &
2124                                           nys:nyn,nxl:nxr) )
2125                 
2126             CALL get_variable( id_surf, 'soil_pars', soil_pars_f%pars_xy,     &
2127                                nxl, nxr, nys, nyn, 0, soil_pars_f%np-1 )
2128
2129          ELSEIF ( soil_pars_f%lod == 2 )  THEN
2130             ALLOCATE( soil_pars_f%pars_xyz(0:soil_pars_f%np-1,                &
2131                                            0:soil_pars_f%nz-1,                &
2132                                            nys:nyn,nxl:nxr) )
2133             CALL get_variable( id_surf, 'soil_pars',                          &
2134                                soil_pars_f%pars_xyz,                          &
2135                                nxl, nxr, nys, nyn, 0, soil_pars_f%nz-1,       &
2136                                0, soil_pars_f%np-1 )
2137
2138          ENDIF
2139       ELSE
2140          soil_pars_f%from_file = .FALSE.
2141       ENDIF
2142
2143!
2144!--    Read water parameters and related information
2145       IF ( check_existence( var_names, 'water_pars' ) )  THEN
2146          water_pars_f%from_file = .TRUE.
2147          CALL get_attribute( id_surf, char_fill,                              &
2148                              water_pars_f%fill,                               &
2149                              .FALSE., 'water_pars' )
2150!
2151!--       Inquire number of water parameters
2152          CALL netcdf_data_input_get_dimension_length( id_surf,                &
2153                                                       water_pars_f%np,        &
2154                                                       'nwater_pars' )
2155!
2156!--       Allocate dimension array and input array for water parameters
2157          ALLOCATE( water_pars_f%pars(0:water_pars_f%np-1) )
2158          ALLOCATE( water_pars_f%pars_xy(0:water_pars_f%np-1,                  &
2159                                         nys:nyn,nxl:nxr) )
2160!
2161!--       Get dimension of water parameters
2162          CALL get_variable( id_surf, 'nwater_pars', water_pars_f%pars )
2163
2164          CALL get_variable( id_surf, 'water_pars', water_pars_f%pars_xy,      &
2165                             nxl, nxr, nys, nyn, 0, water_pars_f%np-1 )
2166       ELSE
2167          water_pars_f%from_file = .FALSE.
2168       ENDIF
2169!
2170!--    Read root area density - parametrized vegetation
2171       IF ( check_existence( var_names, 'root_area_dens_s' ) )  THEN
2172          root_area_density_lsm_f%from_file = .TRUE.
2173          CALL get_attribute( id_surf, char_fill,                              &
2174                              root_area_density_lsm_f%fill,                    &
2175                              .FALSE., 'root_area_dens_s' )
2176!
2177!--       Obtain number of soil layers from file and allocate variable
2178          CALL netcdf_data_input_get_dimension_length( id_surf,                &
2179                                                   root_area_density_lsm_f%nz, &
2180                                                   'zsoil' )
2181          ALLOCATE( root_area_density_lsm_f%var                                &
2182                                        (0:root_area_density_lsm_f%nz-1,       &
2183                                         nys:nyn,nxl:nxr) )
2184
2185!
2186!--       Read root-area density
2187          CALL get_variable( id_surf, 'root_area_dens_s',                      &
2188                             root_area_density_lsm_f%var,                      &
2189                             nxl, nxr, nys, nyn,                               &
2190                             0, root_area_density_lsm_f%nz-1 )
2191
2192       ELSE
2193          root_area_density_lsm_f%from_file = .FALSE.
2194       ENDIF
2195!
2196!--    Read street type and street crossing
2197       IF ( check_existence( var_names, 'street_type' ) )  THEN
2198          street_type_f%from_file = .TRUE.
2199          CALL get_attribute( id_surf, char_fill,                              &
2200                              street_type_f%fill, .FALSE.,                     &
2201                              'street_type' )
2202
2203          ALLOCATE ( street_type_f%var(nys:nyn,nxl:nxr)  )
2204         
2205          CALL get_variable( id_surf, 'street_type', street_type_f%var,        &
2206                             nxl, nxr, nys, nyn )
2207       ELSE
2208          street_type_f%from_file = .FALSE.
2209       ENDIF
2210
2211       IF ( check_existence( var_names, 'street_crossing' ) )  THEN
2212          street_crossing_f%from_file = .TRUE.
2213          CALL get_attribute( id_surf, char_fill,                              &
2214                              street_crossing_f%fill, .FALSE.,                 &
2215                              'street_crossing' )
2216
2217          ALLOCATE ( street_crossing_f%var(nys:nyn,nxl:nxr)  )
2218
2219          CALL get_variable( id_surf, 'street_crossing',                       &
2220                             street_crossing_f%var, nxl, nxr, nys, nyn )
2221
2222       ELSE
2223          street_crossing_f%from_file = .FALSE.
2224       ENDIF
2225!
2226!--    Still missing: root_resolved and building_surface_pars.
2227!--    Will be implemented as soon as they are available.
2228
2229!
2230!--    Finally, close input file
2231       CALL close_input_file( id_surf )
2232#endif
2233!
2234!--    End of CPU measurement
2235       CALL cpu_log( log_point_s(82), 'NetCDF input', 'stop' )
2236!
2237!--    Exchange ghost points for surface variables. Therefore, resize
2238!--    variables.
2239       IF ( albedo_type_f%from_file )  THEN
2240          CALL resize_array_2d_int8( albedo_type_f%var, nys, nyn, nxl, nxr )
2241          CALL exchange_horiz_2d_byte( albedo_type_f%var, nys, nyn, nxl, nxr,  &
2242                                       nbgp )
2243       ENDIF
2244       IF ( pavement_type_f%from_file )  THEN
2245          CALL resize_array_2d_int8( pavement_type_f%var, nys, nyn, nxl, nxr )
2246          CALL exchange_horiz_2d_byte( pavement_type_f%var, nys, nyn, nxl, nxr,&
2247                                       nbgp )
2248       ENDIF
2249       IF ( soil_type_f%from_file  .AND.  ALLOCATED( soil_type_f%var_2d ) )  THEN
2250          CALL resize_array_2d_int8( soil_type_f%var_2d, nys, nyn, nxl, nxr )
2251          CALL exchange_horiz_2d_byte( soil_type_f%var_2d, nys, nyn, nxl, nxr, &
2252                                       nbgp )
2253       ENDIF
2254       IF ( vegetation_type_f%from_file )  THEN
2255          CALL resize_array_2d_int8( vegetation_type_f%var, nys, nyn, nxl, nxr )
2256          CALL exchange_horiz_2d_byte( vegetation_type_f%var, nys, nyn, nxl,   &
2257                                       nxr, nbgp )
2258       ENDIF
2259       IF ( water_type_f%from_file )  THEN
2260          CALL resize_array_2d_int8( water_type_f%var, nys, nyn, nxl, nxr )
2261          CALL exchange_horiz_2d_byte( water_type_f%var, nys, nyn, nxl, nxr,   &
2262                                       nbgp )
2263       ENDIF
2264!
2265!--    Exchange ghost points for 3/4-D variables. For the sake of simplicity,
2266!--    loop further dimensions to use 2D exchange routines. Unfortunately this
2267!--    is necessary, else new MPI-data types need to be introduced just for
2268!--    2 variables.
2269       IF ( soil_type_f%from_file  .AND.  ALLOCATED( soil_type_f%var_3d ) )    &
2270       THEN
2271          CALL resize_array_3d_int8( soil_type_f%var_3d, 0, nz_soil,           &
2272                                     nys, nyn, nxl, nxr )
2273          DO  k = 0, nz_soil
2274             CALL exchange_horiz_2d_int(                                       & 
2275                        soil_type_f%var_3d(k,:,:), nys, nyn, nxl, nxr, nbgp )
2276          ENDDO
2277       ENDIF
2278
2279       IF ( surface_fraction_f%from_file )  THEN
2280          CALL resize_array_3d_real( surface_fraction_f%frac,                  &
2281                                     0, surface_fraction_f%nf-1,               &
2282                                     nys, nyn, nxl, nxr )
2283          DO  k = 0, surface_fraction_f%nf-1
2284             CALL exchange_horiz_2d( surface_fraction_f%frac(k,:,:), nbgp )
2285          ENDDO
2286       ENDIF
2287
2288       IF ( building_pars_f%from_file )  THEN         
2289          CALL resize_array_3d_real( building_pars_f%pars_xy,                  &
2290                                     0, building_pars_f%np-1,                  &
2291                                     nys, nyn, nxl, nxr )
2292          DO  k = 0, building_pars_f%np-1
2293             CALL exchange_horiz_2d( building_pars_f%pars_xy(k,:,:), nbgp )
2294          ENDDO
2295       ENDIF
2296
2297       IF ( albedo_pars_f%from_file )  THEN         
2298          CALL resize_array_3d_real( albedo_pars_f%pars_xy,                    &
2299                                     0, albedo_pars_f%np-1,                    &
2300                                     nys, nyn, nxl, nxr )
2301          DO  k = 0, albedo_pars_f%np-1
2302             CALL exchange_horiz_2d( albedo_pars_f%pars_xy(k,:,:), nbgp )
2303          ENDDO
2304       ENDIF
2305
2306       IF ( pavement_pars_f%from_file )  THEN         
2307          CALL resize_array_3d_real( pavement_pars_f%pars_xy,                  &
2308                                     0, pavement_pars_f%np-1,                  &
2309                                     nys, nyn, nxl, nxr )
2310          DO  k = 0, pavement_pars_f%np-1
2311             CALL exchange_horiz_2d( pavement_pars_f%pars_xy(k,:,:), nbgp )
2312          ENDDO
2313       ENDIF
2314
2315       IF ( vegetation_pars_f%from_file )  THEN
2316          CALL resize_array_3d_real( vegetation_pars_f%pars_xy,                &
2317                                     0, vegetation_pars_f%np-1,                &
2318                                     nys, nyn, nxl, nxr )
2319          DO  k = 0, vegetation_pars_f%np-1
2320             CALL exchange_horiz_2d( vegetation_pars_f%pars_xy(k,:,:), nbgp )
2321          ENDDO
2322       ENDIF
2323
2324       IF ( water_pars_f%from_file )  THEN
2325          CALL resize_array_3d_real( water_pars_f%pars_xy,                     &
2326                                     0, water_pars_f%np-1,                     &
2327                                     nys, nyn, nxl, nxr )
2328          DO  k = 0, water_pars_f%np-1
2329             CALL exchange_horiz_2d( water_pars_f%pars_xy(k,:,:), nbgp )
2330          ENDDO
2331       ENDIF
2332
2333       IF ( root_area_density_lsm_f%from_file )  THEN
2334          CALL resize_array_3d_real( root_area_density_lsm_f%var,              &
2335                                     0, root_area_density_lsm_f%nz-1,          &
2336                                     nys, nyn, nxl, nxr )
2337          DO  k = 0, root_area_density_lsm_f%nz-1
2338             CALL exchange_horiz_2d( root_area_density_lsm_f%var(k,:,:), nbgp )
2339          ENDDO
2340       ENDIF
2341
2342       IF ( soil_pars_f%from_file )  THEN
2343          IF ( soil_pars_f%lod == 1 )  THEN
2344         
2345             CALL resize_array_3d_real( soil_pars_f%pars_xy,                   &
2346                                        0, soil_pars_f%np-1,                   &
2347                                        nys, nyn, nxl, nxr )
2348             DO  k = 0, soil_pars_f%np-1
2349                CALL exchange_horiz_2d( soil_pars_f%pars_xy(k,:,:), nbgp )
2350             ENDDO
2351             
2352          ELSEIF ( soil_pars_f%lod == 2 )  THEN
2353             CALL resize_array_4d_real( soil_pars_f%pars_xyz,                  &
2354                                        0, soil_pars_f%np-1,                   &
2355                                        0, soil_pars_f%nz-1,                   &
2356                                        nys, nyn, nxl, nxr )
2357
2358             DO  k2 = 0, soil_pars_f%nz-1
2359                DO  k = 0, soil_pars_f%np-1
2360                   CALL exchange_horiz_2d( soil_pars_f%pars_xyz(k,k2,:,:),     &
2361                                           nbgp )
2362                ENDDO
2363             ENDDO
2364          ENDIF
2365       ENDIF
2366
2367       IF ( pavement_subsurface_pars_f%from_file )  THEN         
2368          CALL resize_array_4d_real( pavement_subsurface_pars_f%pars_xyz,      &
2369                                     0, pavement_subsurface_pars_f%np-1,       &
2370                                     0, pavement_subsurface_pars_f%nz-1,       &
2371                                     nys, nyn, nxl, nxr )
2372
2373          DO  k2 = 0, pavement_subsurface_pars_f%nz-1
2374             DO  k = 0, pavement_subsurface_pars_f%np-1
2375                CALL exchange_horiz_2d(                                        &
2376                           pavement_subsurface_pars_f%pars_xyz(k,k2,:,:), nbgp )
2377             ENDDO
2378          ENDDO
2379       ENDIF
2380
2381    END SUBROUTINE netcdf_data_input_surface_data
2382
2383!------------------------------------------------------------------------------!
2384! Description:
2385! ------------
2386!> Reads uvem lookup table information.
2387!------------------------------------------------------------------------------!
2388    SUBROUTINE netcdf_data_input_uvem
2389       
2390       USE indices,                                                            &
2391           ONLY:  nxl, nxr, nyn, nys
2392
2393       IMPLICIT NONE
2394
2395       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names  !< variable names in static input file
2396
2397
2398       INTEGER(iwp) ::  id_uvem       !< NetCDF id of uvem lookup table input file
2399       INTEGER(iwp) ::  nli = 35      !< dimension length of lookup table in x
2400       INTEGER(iwp) ::  nlj =  9      !< dimension length of lookup table in y
2401       INTEGER(iwp) ::  nlk = 90      !< dimension length of lookup table in z
2402       INTEGER(iwp) ::  num_vars      !< number of variables in netcdf input file
2403!
2404!--    Input via uv exposure model lookup table input
2405       IF ( input_pids_uvem )  THEN
2406
2407#if defined ( __netcdf )
2408!
2409!--       Open file in read-only mode
2410          CALL open_read_file( TRIM( input_file_uvem ) //                    &
2411                               TRIM( coupling_char ), id_uvem )
2412!
2413!--       At first, inquire all variable names.
2414!--       This will be used to check whether an input variable exist or not.
2415          CALL inquire_num_variables( id_uvem, num_vars )
2416!
2417!--       Allocate memory to store variable names and inquire them.
2418          ALLOCATE( var_names(1:num_vars) )
2419          CALL inquire_variable_names( id_uvem, var_names )
2420!
2421!--       uvem integration
2422          IF ( check_existence( var_names, 'int_factors' ) )  THEN
2423             uvem_integration_f%from_file = .TRUE.
2424!
2425!--          Input 2D uvem integration.
2426             ALLOCATE ( uvem_integration_f%var(0:nlj,0:nli)  )
2427             
2428             CALL get_variable( id_uvem, 'int_factors', uvem_integration_f%var, 0, nli, 0, nlj )
2429          ELSE
2430             uvem_integration_f%from_file = .FALSE.
2431          ENDIF
2432!
2433!--       uvem irradiance
2434          IF ( check_existence( var_names, 'irradiance' ) )  THEN
2435             uvem_irradiance_f%from_file = .TRUE.
2436!
2437!--          Input 2D uvem irradiance.
2438             ALLOCATE ( uvem_irradiance_f%var(0:nlk, 0:2)  )
2439             
2440             CALL get_variable( id_uvem, 'irradiance', uvem_irradiance_f%var, 0, 2, 0, nlk )
2441          ELSE
2442             uvem_irradiance_f%from_file = .FALSE.
2443          ENDIF
2444!
2445!--       uvem porjection areas
2446          IF ( check_existence( var_names, 'projarea' ) )  THEN
2447             uvem_projarea_f%from_file = .TRUE.
2448!
2449!--          Input 3D uvem projection area (human geometgry)
2450             ALLOCATE ( uvem_projarea_f%var(0:2,0:nlj,0:nli)  )
2451           
2452             CALL get_variable( id_uvem, 'projarea', uvem_projarea_f%var, 0, nli, 0, nlj, 0, 2 )
2453          ELSE
2454             uvem_projarea_f%from_file = .FALSE.
2455          ENDIF
2456!
2457!--       uvem radiance
2458          IF ( check_existence( var_names, 'radiance' ) )  THEN
2459             uvem_radiance_f%from_file = .TRUE.
2460!
2461!--          Input 3D uvem radiance
2462             ALLOCATE ( uvem_radiance_f%var(0:nlk,0:nlj,0:nli)  )
2463             
2464             CALL get_variable( id_uvem, 'radiance', uvem_radiance_f%var, 0, nli, 0, nlj, 0, nlk )
2465          ELSE
2466             uvem_radiance_f%from_file = .FALSE.
2467          ENDIF
2468!
2469!--       Read building obstruction
2470          IF ( check_existence( var_names, 'obstruction' ) )  THEN
2471             building_obstruction_full%from_file = .TRUE.
2472!--          Input 3D uvem building obstruction
2473              ALLOCATE ( building_obstruction_full%var_3d(0:44,0:2,0:2) )
2474              CALL get_variable( id_uvem, 'obstruction', building_obstruction_full%var_3d,0, 2, 0, 2, 0, 44 )       
2475          ELSE
2476             building_obstruction_full%from_file = .FALSE.
2477          ENDIF
2478!
2479          IF ( check_existence( var_names, 'obstruction' ) )  THEN
2480             building_obstruction_f%from_file = .TRUE.
2481!
2482!--          Input 3D uvem building obstruction
2483             ALLOCATE ( building_obstruction_f%var_3d(0:44,nys:nyn,nxl:nxr) )
2484!
2485             CALL get_variable( id_uvem, 'obstruction', building_obstruction_f%var_3d,      &
2486                                nxl, nxr, nys, nyn, 0, 44 )       
2487          ELSE
2488             building_obstruction_f%from_file = .FALSE.
2489          ENDIF
2490!
2491!--       Close uvem lookup table input file
2492          CALL close_input_file( id_uvem )
2493#else
2494          CONTINUE
2495#endif
2496       ENDIF
2497    END SUBROUTINE netcdf_data_input_uvem
2498
2499!------------------------------------------------------------------------------!
2500! Description:
2501! ------------
2502!> Reads orography and building information.
2503!------------------------------------------------------------------------------!
2504    SUBROUTINE netcdf_data_input_topo
2505
2506       USE control_parameters,                                                 &
2507           ONLY:  message_string, topography
2508
2509       USE grid_variables,                                                     &
2510           ONLY:  dx, dy   
2511           
2512       USE indices,                                                            &
2513           ONLY:  nbgp, nx, nxl, nxr, ny, nyn, nys, nzb
2514
2515
2516       IMPLICIT NONE
2517
2518       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names  !< variable names in static input file
2519
2520
2521       INTEGER(iwp) ::  i             !< running index along x-direction
2522       INTEGER(iwp) ::  ii            !< running index for IO blocks
2523       INTEGER(iwp) ::  id_topo       !< NetCDF id of topograhy input file
2524       INTEGER(iwp) ::  j             !< running index along y-direction
2525       INTEGER(iwp) ::  num_vars      !< number of variables in netcdf input file
2526       INTEGER(iwp) ::  skip_n_rows   !< counting variable to skip rows while reading topography file
2527
2528       REAL(wp) ::  dum           !< dummy variable to skip columns while reading topography file
2529!
2530!--    CPU measurement
2531       CALL cpu_log( log_point_s(83), 'NetCDF/ASCII input topo', 'start' )
2532
2533!
2534!--    Input via palm-input data standard
2535       IF ( input_pids_static )  THEN
2536#if defined ( __netcdf )
2537!
2538!--       Open file in read-only mode
2539          CALL open_read_file( TRIM( input_file_static ) //                    &
2540                               TRIM( coupling_char ), id_topo )
2541!
2542!--       At first, inquire all variable names.
2543!--       This will be used to check whether an  input variable exist
2544!--       or not.
2545          CALL inquire_num_variables( id_topo, num_vars )
2546!
2547!--       Allocate memory to store variable names and inquire them.
2548          ALLOCATE( var_names(1:num_vars) )
2549          CALL inquire_variable_names( id_topo, var_names )
2550!
2551!--       Read x, y - dimensions. Only required for consistency checks.
2552          CALL netcdf_data_input_get_dimension_length( id_topo, dim_static%nx, 'x' )
2553          CALL netcdf_data_input_get_dimension_length( id_topo, dim_static%ny, 'y' )
2554          ALLOCATE( dim_static%x(0:dim_static%nx-1) )
2555          ALLOCATE( dim_static%y(0:dim_static%ny-1) )
2556          CALL get_variable( id_topo, 'x', dim_static%x )
2557          CALL get_variable( id_topo, 'y', dim_static%y )
2558!
2559!--       Check whether dimension size in input file matches the model dimensions
2560          IF ( dim_static%nx-1 /= nx  .OR.  dim_static%ny-1 /= ny )  THEN
2561             message_string = 'Static input file: horizontal dimension in ' // &
2562                              'x- and/or y-direction ' //                      &
2563                              'do not match the respective model dimension'
2564             CALL message( 'netcdf_data_input_mod', 'PA0548', 1, 2, 0, 6, 0 )
2565          ENDIF
2566!
2567!--       Check if grid spacing of provided input data matches the respective
2568!--       grid spacing in the model.
2569          IF ( ABS( dim_static%x(1) - dim_static%x(0) - dx ) > 10E-6_wp  .OR.  &
2570               ABS( dim_static%y(1) - dim_static%y(0) - dy ) > 10E-6_wp )  THEN
2571             message_string = 'Static input file: horizontal grid spacing ' // &
2572                              'in x- and/or y-direction ' //                   &
2573                              'do not match the respective model grid spacing.'
2574             CALL message( 'netcdf_data_input_mod', 'PA0549', 1, 2, 0, 6, 0 )
2575          ENDIF
2576!
2577!--       Terrain height. First, get variable-related _FillValue attribute
2578          IF ( check_existence( var_names, 'zt' ) )  THEN
2579             terrain_height_f%from_file = .TRUE.
2580             CALL get_attribute( id_topo, char_fill, terrain_height_f%fill,    &
2581                                 .FALSE., 'zt' )
2582!
2583!--          Input 2D terrain height.
2584             ALLOCATE ( terrain_height_f%var(nys:nyn,nxl:nxr)  )
2585             
2586             CALL get_variable( id_topo, 'zt', terrain_height_f%var,           &
2587                                nxl, nxr, nys, nyn )
2588
2589          ELSE
2590             terrain_height_f%from_file = .FALSE.
2591          ENDIF
2592
2593!
2594!--       Read building height. First, read its _FillValue attribute,
2595!--       as well as lod attribute
2596          buildings_f%from_file = .FALSE.
2597          IF ( check_existence( var_names, 'buildings_2d' ) )  THEN
2598             buildings_f%from_file = .TRUE.
2599             CALL get_attribute( id_topo, char_lod, buildings_f%lod,           &
2600                                 .FALSE., 'buildings_2d' )
2601
2602             CALL get_attribute( id_topo, char_fill, buildings_f%fill1,        &
2603                                 .FALSE., 'buildings_2d' )
2604
2605!
2606!--          Read 2D buildings
2607             IF ( buildings_f%lod == 1 )  THEN
2608                ALLOCATE ( buildings_f%var_2d(nys:nyn,nxl:nxr) )
2609
2610                CALL get_variable( id_topo, 'buildings_2d',                    &
2611                                   buildings_f%var_2d,                         &
2612                                   nxl, nxr, nys, nyn )
2613             ELSE
2614                message_string = 'NetCDF attribute lod ' //                    &
2615                                 '(level of detail) is not set ' //            &
2616                                 'properly for buildings_2d.'
2617                CALL message( 'netcdf_data_input_mod', 'PA0540',               &
2618                               1, 2, 0, 6, 0 )
2619             ENDIF
2620          ENDIF
2621!
2622!--       If available, also read 3D building information. If both are
2623!--       available, use 3D information.
2624          IF ( check_existence( var_names, 'buildings_3d' ) )  THEN
2625             buildings_f%from_file = .TRUE.
2626             CALL get_attribute( id_topo, char_lod, buildings_f%lod,           &
2627                                 .FALSE., 'buildings_3d' )     
2628
2629             CALL get_attribute( id_topo, char_fill, buildings_f%fill2,        &
2630                                 .FALSE., 'buildings_3d' )
2631
2632             CALL netcdf_data_input_get_dimension_length( id_topo,             &
2633                                                          buildings_f%nz, 'z' )
2634!
2635!--          Read 3D buildings
2636             IF ( buildings_f%lod == 2 )  THEN
2637                ALLOCATE( buildings_f%z(nzb:buildings_f%nz-1) )
2638                CALL get_variable( id_topo, 'z', buildings_f%z )
2639
2640                ALLOCATE( buildings_f%var_3d(nzb:buildings_f%nz-1,             &
2641                                             nys:nyn,nxl:nxr) )
2642                buildings_f%var_3d = 0
2643               
2644                CALL get_variable( id_topo, 'buildings_3d',                    &
2645                                   buildings_f%var_3d,                         &
2646                                   nxl, nxr, nys, nyn, 0, buildings_f%nz-1 )
2647             ELSE
2648                message_string = 'NetCDF attribute lod ' //                    &
2649                                 '(level of detail) is not set ' //            &
2650                                 'properly for buildings_3d.'
2651                CALL message( 'netcdf_data_input_mod', 'PA0541',               &
2652                               1, 2, 0, 6, 0 )
2653             ENDIF
2654          ENDIF
2655!
2656!--       Read building IDs and its FillValue attribute. Further required
2657!--       for mapping buildings on top of orography.
2658          IF ( check_existence( var_names, 'building_id' ) )  THEN
2659             building_id_f%from_file = .TRUE.
2660             CALL get_attribute( id_topo, char_fill,                           &
2661                                 building_id_f%fill, .FALSE.,                  &
2662                                 'building_id' )
2663
2664             ALLOCATE ( building_id_f%var(nys:nyn,nxl:nxr) )
2665             
2666             CALL get_variable( id_topo, 'building_id', building_id_f%var,     &
2667                                nxl, nxr, nys, nyn )
2668          ELSE
2669             building_id_f%from_file = .FALSE.
2670          ENDIF
2671!
2672!--       Read building_type and required attributes.
2673          IF ( check_existence( var_names, 'building_type' ) )  THEN
2674             building_type_f%from_file = .TRUE.
2675             CALL get_attribute( id_topo, char_fill,                           &
2676                                 building_type_f%fill, .FALSE.,                &
2677                                 'building_type' )
2678
2679             ALLOCATE ( building_type_f%var(nys:nyn,nxl:nxr) )
2680
2681             CALL get_variable( id_topo, 'building_type', building_type_f%var, &
2682                                nxl, nxr, nys, nyn )
2683
2684          ELSE
2685             building_type_f%from_file = .FALSE.
2686          ENDIF
2687!
2688!--       Close topography input file
2689          CALL close_input_file( id_topo )
2690#else
2691          CONTINUE
2692#endif
2693!
2694!--    ASCII input
2695       ELSEIF ( TRIM( topography ) == 'read_from_file' )  THEN
2696             
2697          DO  ii = 0, io_blocks-1
2698             IF ( ii == io_group )  THEN
2699
2700                OPEN( 90, FILE='TOPOGRAPHY_DATA'//TRIM( coupling_char ),       &
2701                      STATUS='OLD', FORM='FORMATTED', ERR=10 )
2702!
2703!--             Read topography PE-wise. Rows are read from nyn to nys, columns
2704!--             are read from nxl to nxr. At first, ny-nyn rows need to be skipped.
2705                skip_n_rows = 0
2706                DO WHILE ( skip_n_rows < ny - nyn )
2707                   READ( 90, * )
2708                   skip_n_rows = skip_n_rows + 1
2709                ENDDO
2710!
2711!--             Read data from nyn to nys and nxl to nxr. Therefore, skip
2712!--             column until nxl-1 is reached
2713                ALLOCATE ( buildings_f%var_2d(nys:nyn,nxl:nxr) )
2714                DO  j = nyn, nys, -1
2715                   READ( 90, *, ERR=11, END=11 )                               &
2716                                   ( dum, i = 0, nxl-1 ),                      &
2717                                   ( buildings_f%var_2d(j,i), i = nxl, nxr )
2718                ENDDO
2719
2720                GOTO 12
2721
2722 10             message_string = 'file TOPOGRAPHY_DATA'//                      &
2723                                 TRIM( coupling_char )// ' does not exist'
2724                CALL message( 'netcdf_data_input_mod', 'PA0208', 1, 2, 0, 6, 0 )
2725
2726 11             message_string = 'errors in file TOPOGRAPHY_DATA'//            &
2727                                 TRIM( coupling_char )
2728                CALL message( 'netcdf_data_input_mod', 'PA0209', 2, 2, 0, 6, 0 )
2729
2730 12             CLOSE( 90 )
2731                buildings_f%from_file = .TRUE.
2732
2733             ENDIF
2734#if defined( __parallel )
2735             CALL MPI_BARRIER( comm2d, ierr )
2736#endif
2737          ENDDO
2738
2739       ENDIF
2740!
2741!--    End of CPU measurement
2742       CALL cpu_log( log_point_s(83), 'NetCDF/ASCII input topo', 'stop' )
2743!
2744!--    Check for minimum requirement to setup building topography. If buildings
2745!--    are provided, also an ID and a type are required.
2746!--    Note, doing this check in check_parameters
2747!--    will be too late (data will be used for grid inititialization before).
2748       IF ( input_pids_static )  THEN
2749          IF ( buildings_f%from_file  .AND.                                    &
2750               .NOT. building_id_f%from_file )  THEN
2751             message_string = 'If building heights are prescribed in ' //      &
2752                              'static input file, also an ID is required.'
2753             CALL message( 'netcdf_data_input_mod', 'PA0542', 1, 2, 0, 6, 0 )
2754          ENDIF
2755       ENDIF
2756!
2757!--    In case no terrain height is provided by static input file, allocate
2758!--    array nevertheless and set terrain height to 0, which simplifies
2759!--    topography initialization.
2760       IF ( .NOT. terrain_height_f%from_file )  THEN
2761          ALLOCATE ( terrain_height_f%var(nys:nyn,nxl:nxr) )
2762          terrain_height_f%var = 0.0_wp
2763       ENDIF
2764!
2765!--    Finally, exchange 1 ghost point for building ID and type.
2766!--    In case of non-cyclic boundary conditions set Neumann conditions at the
2767!--    lateral boundaries.
2768       IF ( building_id_f%from_file )  THEN
2769          CALL resize_array_2d_int32( building_id_f%var, nys, nyn, nxl, nxr )
2770          CALL exchange_horiz_2d_int( building_id_f%var, nys, nyn, nxl, nxr,   &
2771                                      nbgp )
2772       ENDIF
2773
2774       IF ( building_type_f%from_file )  THEN
2775          CALL resize_array_2d_int8( building_type_f%var, nys, nyn, nxl, nxr )
2776          CALL exchange_horiz_2d_byte( building_type_f%var, nys, nyn, nxl, nxr,   &
2777                                       nbgp )
2778       ENDIF
2779
2780    END SUBROUTINE netcdf_data_input_topo
2781
2782!------------------------------------------------------------------------------!
2783! Description:
2784! ------------
2785!> Reads initialization data of u, v, w, pt, q, geostrophic wind components,
2786!> as well as soil moisture and soil temperature, derived from larger-scale
2787!> model (COSMO) by Inifor.
2788!------------------------------------------------------------------------------!
2789    SUBROUTINE netcdf_data_input_init_3d
2790
2791       USE arrays_3d,                                                          &
2792           ONLY:  q, pt, u, v, w, zu, zw
2793
2794       USE control_parameters,                                                 &
2795           ONLY:  air_chemistry, bc_lr_cyc, bc_ns_cyc, humidity,               &
2796                  message_string, neutral
2797
2798       USE indices,                                                            &
2799           ONLY:  nx, nxl, nxlu, nxr, ny, nyn, nys, nysv, nzb, nz, nzt
2800
2801       IMPLICIT NONE
2802
2803       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names
2804
2805       LOGICAL      ::  dynamic_3d = .TRUE. !< flag indicating that 3D data is read from dynamic file
2806       
2807       INTEGER(iwp) ::  id_dynamic !< NetCDF id of dynamic input file
2808       INTEGER(iwp) ::  n          !< running index for chemistry variables
2809       INTEGER(iwp) ::  num_vars   !< number of variables in netcdf input file
2810
2811       LOGICAL      ::  check_passed !< flag indicating if a check passed
2812
2813!
2814!--    Skip routine if no input file with dynamic input data is available.
2815       IF ( .NOT. input_pids_dynamic )  RETURN
2816!
2817!--    Please note, Inifor is designed to provide initial data for u and v for
2818!--    the prognostic grid points in case of lateral Dirichlet conditions.
2819!--    This means that Inifor provides data from nxlu:nxr (for u) and
2820!--    from nysv:nyn (for v) at the left and south domain boundary, respectively.
2821!--    However, as work-around for the moment, PALM will run with cyclic
2822!--    conditions and will be initialized with data provided by Inifor
2823!--    boundaries in case of Dirichlet.
2824!--    Hence, simply set set nxlu/nysv to 1 (will be reset to its original value
2825!--    at the end of this routine.
2826       IF ( bc_lr_cyc  .AND.  nxl == 0 )  nxlu = 1
2827       IF ( bc_ns_cyc  .AND.  nys == 0 )  nysv = 1
2828
2829!
2830!--    CPU measurement
2831       CALL cpu_log( log_point_s(85), 'NetCDF input init', 'start' )
2832
2833#if defined ( __netcdf )
2834!
2835!--    Open file in read-only mode
2836       CALL open_read_file( TRIM( input_file_dynamic ) //                      &
2837                            TRIM( coupling_char ), id_dynamic )
2838
2839!
2840!--    At first, inquire all variable names.
2841       CALL inquire_num_variables( id_dynamic, num_vars )
2842!
2843!--    Allocate memory to store variable names.
2844       ALLOCATE( var_names(1:num_vars) )
2845       CALL inquire_variable_names( id_dynamic, var_names )
2846!
2847!--    Read vertical dimension of scalar und w grid.
2848       CALL netcdf_data_input_get_dimension_length( id_dynamic, init_3d%nzu, 'z'     )
2849       CALL netcdf_data_input_get_dimension_length( id_dynamic, init_3d%nzw, 'zw'    )
2850!
2851!--    Read also the horizontal dimensions. These are used just used fo
2852!--    checking the compatibility with the PALM grid before reading.
2853       CALL netcdf_data_input_get_dimension_length( id_dynamic, init_3d%nx,  'x'  )
2854       CALL netcdf_data_input_get_dimension_length( id_dynamic, init_3d%nxu, 'xu' )
2855       CALL netcdf_data_input_get_dimension_length( id_dynamic, init_3d%ny,  'y'  )
2856       CALL netcdf_data_input_get_dimension_length( id_dynamic, init_3d%nyv, 'yv' )
2857
2858!
2859!--    Check for correct horizontal and vertical dimension. Please note,
2860!--    checks are performed directly here and not called from
2861!--    check_parameters as some varialbes are still not allocated there.
2862!--    Moreover, please note, u- and v-grid has 1 grid point less on
2863!--    Inifor grid.
2864       IF ( init_3d%nx-1 /= nx  .OR.  init_3d%nxu-1 /= nx - 1  .OR.            &
2865            init_3d%ny-1 /= ny  .OR.  init_3d%nyv-1 /= ny - 1 )  THEN
2866          message_string = 'Number of inifor horizontal grid points  '//       &
2867                           'does not match the number of numeric grid '//      &
2868                           'points.'
2869          CALL message( 'netcdf_data_input_mod', 'PA0543', 1, 2, 0, 6, 0 )
2870       ENDIF
2871
2872       IF ( init_3d%nzu /= nz )  THEN
2873          message_string = 'Number of inifor vertical grid points ' //         &
2874                           'does not match the number of numeric grid '//      &
2875                           'points.'
2876          CALL message( 'netcdf_data_input_mod', 'PA0543', 1, 2, 0, 6, 0 )
2877       ENDIF
2878!
2879!--    Read vertical dimensions. Later, these are required for eventual
2880!--    inter- and extrapolations of the initialization data.
2881       IF ( check_existence( var_names, 'z' ) )  THEN
2882          ALLOCATE( init_3d%zu_atmos(1:init_3d%nzu) )
2883          CALL get_variable( id_dynamic, 'z', init_3d%zu_atmos )
2884       ENDIF
2885       IF ( check_existence( var_names, 'zw' ) )  THEN
2886          ALLOCATE( init_3d%zw_atmos(1:init_3d%nzw) )
2887          CALL get_variable( id_dynamic, 'zw', init_3d%zw_atmos )
2888       ENDIF
2889!
2890!--    Check for consistency between vertical coordinates in dynamic
2891!--    driver and numeric grid.
2892!--    Please note, depending on compiler options both may be
2893!--    equal up to a certain threshold, and differences between
2894!--    the numeric grid and vertical coordinate in the driver can built-
2895!--    up to 10E-1-10E-0 m. For this reason, the check is performed not
2896!--    for exactly matching values.
2897       IF ( ANY( ABS( zu(1:nzt)   - init_3d%zu_atmos(1:init_3d%nzu) )    &
2898                      > 10E-1 )  .OR.                                    &
2899            ANY( ABS( zw(1:nzt-1) - init_3d%zw_atmos(1:init_3d%nzw) )    &
2900                      > 10E-1 ) )  THEN
2901          message_string = 'Vertical grid in dynamic driver does not '// &
2902                           'match the numeric grid.'
2903          CALL message( 'netcdf_data_input_mod', 'PA0543', 1, 2, 0, 6, 0 )
2904       ENDIF
2905!
2906!--    Read initial geostrophic wind components at
2907!--    t = 0 (index 1 in file).
2908       IF ( check_existence( var_names, 'ls_forcing_ug' ) )  THEN
2909          ALLOCATE( init_3d%ug_init(nzb:nzt+1) )
2910          init_3d%ug_init = 0.0_wp
2911
2912          CALL get_variable_pr( id_dynamic, 'ls_forcing_ug', 1,          &
2913                                init_3d%ug_init(1:nzt) )
2914!
2915!--       Set top-boundary condition (Neumann)
2916          init_3d%ug_init(nzt+1) = init_3d%ug_init(nzt)
2917
2918          init_3d%from_file_ug = .TRUE.
2919       ELSE
2920          init_3d%from_file_ug = .FALSE.
2921       ENDIF
2922       IF ( check_existence( var_names, 'ls_forcing_vg' ) )  THEN
2923          ALLOCATE( init_3d%vg_init(nzb:nzt+1) )
2924          init_3d%vg_init = 0.0_wp
2925
2926          CALL get_variable_pr( id_dynamic, 'ls_forcing_vg', 1,          &
2927                                init_3d%vg_init(1:nzt) )
2928!
2929!--       Set top-boundary condition (Neumann)
2930          init_3d%vg_init(nzt+1) = init_3d%vg_init(nzt)
2931
2932          init_3d%from_file_vg = .TRUE.
2933       ELSE
2934          init_3d%from_file_vg = .FALSE.
2935       ENDIF
2936!
2937!--    Read inital 3D data of u, v, w, pt and q,
2938!--    derived from COSMO model. Read PE-wise yz-slices.
2939!--    Please note, the u-, v- and w-component are defined on different
2940!--    grids with one element less in the x-, y-,
2941!--    and z-direction, respectively. Hence, reading is subdivided
2942!--    into separate loops. 
2943!--    Read u-component
2944       IF ( check_existence( var_names, 'init_atmosphere_u' ) )  THEN
2945!
2946!--       Read attributes for the fill value and level-of-detail
2947          CALL get_attribute( id_dynamic, char_fill, init_3d%fill_u,           &
2948                              .FALSE., 'init_atmosphere_u' )
2949          CALL get_attribute( id_dynamic, char_lod, init_3d%lod_u,             &
2950                              .FALSE., 'init_atmosphere_u' )
2951!
2952!--       level-of-detail 1 - read initialization profile
2953          IF ( init_3d%lod_u == 1 )  THEN
2954             ALLOCATE( init_3d%u_init(nzb:nzt+1) )
2955             init_3d%u_init = 0.0_wp
2956
2957             CALL get_variable( id_dynamic, 'init_atmosphere_u',               &
2958                                init_3d%u_init(nzb+1:nzt) )
2959!
2960!--          Set top-boundary condition (Neumann)
2961             init_3d%u_init(nzt+1) = init_3d%u_init(nzt)
2962!
2963!--       level-of-detail 2 - read 3D initialization data
2964          ELSEIF ( init_3d%lod_u == 2 )  THEN
2965             CALL get_variable( id_dynamic, 'init_atmosphere_u',               &
2966                                u(nzb+1:nzt,nys:nyn,nxlu:nxr),                 &
2967                                nxlu, nys+1, nzb+1,                            &
2968                                nxr-nxlu+1, nyn-nys+1, init_3d%nzu,            &
2969                                dynamic_3d )
2970!
2971!--          Set value at leftmost model grid point nxl = 0. This is because
2972!--          Inifor provides data only from 1:nx-1 since it assumes non-cyclic
2973!--          conditions.
2974             IF ( nxl == 0 )                                                   &
2975                u(nzb+1:nzt,nys:nyn,nxl) = u(nzb+1:nzt,nys:nyn,nxlu)
2976!
2977!--          Set bottom and top-boundary
2978             u(nzb,:,:)   = u(nzb+1,:,:)
2979             u(nzt+1,:,:) = u(nzt,:,:)
2980             
2981          ENDIF
2982          init_3d%from_file_u = .TRUE.
2983       ELSE
2984          message_string = 'Missing initial data for u-component'
2985          CALL message( 'netcdf_data_input_mod', 'PA0544', 1, 2, 0, 6, 0 )
2986       ENDIF
2987!
2988!--    Read v-component
2989       IF ( check_existence( var_names, 'init_atmosphere_v' ) )  THEN
2990!
2991!--       Read attributes for the fill value and level-of-detail
2992          CALL get_attribute( id_dynamic, char_fill, init_3d%fill_v,           &
2993                              .FALSE., 'init_atmosphere_v' )
2994          CALL get_attribute( id_dynamic, char_lod, init_3d%lod_v,             &
2995                              .FALSE., 'init_atmosphere_v' )
2996!
2997!--       level-of-detail 1 - read initialization profile
2998          IF ( init_3d%lod_v == 1 )  THEN
2999             ALLOCATE( init_3d%v_init(nzb:nzt+1) )
3000             init_3d%v_init = 0.0_wp
3001
3002             CALL get_variable( id_dynamic, 'init_atmosphere_v',               &
3003                                init_3d%v_init(nzb+1:nzt) )
3004!
3005!--          Set top-boundary condition (Neumann)
3006             init_3d%v_init(nzt+1) = init_3d%v_init(nzt)
3007!
3008!--       level-of-detail 2 - read 3D initialization data
3009          ELSEIF ( init_3d%lod_v == 2 )  THEN
3010         
3011             CALL get_variable( id_dynamic, 'init_atmosphere_v',               &
3012                                v(nzb+1:nzt,nysv:nyn,nxl:nxr),                 &
3013                                nxl+1, nysv, nzb+1,                            &
3014                                nxr-nxl+1, nyn-nysv+1, init_3d%nzu,            &
3015                                dynamic_3d )
3016!
3017!--          Set value at southmost model grid point nys = 0. This is because
3018!--          Inifor provides data only from 1:ny-1 since it assumes non-cyclic
3019!--          conditions.
3020             IF ( nys == 0 )                                                   &
3021                v(nzb+1:nzt,nys,nxl:nxr) = v(nzb+1:nzt,nysv,nxl:nxr)                               
3022!
3023!--          Set bottom and top-boundary
3024             v(nzb,:,:)   = v(nzb+1,:,:)
3025             v(nzt+1,:,:) = v(nzt,:,:)
3026             
3027          ENDIF
3028          init_3d%from_file_v = .TRUE.
3029       ELSE
3030          message_string = 'Missing initial data for v-component'
3031          CALL message( 'netcdf_data_input_mod', 'PA0544', 1, 2, 0, 6, 0 )
3032       ENDIF
3033!
3034!--    Read w-component
3035       IF ( check_existence( var_names, 'init_atmosphere_w' ) )  THEN
3036!
3037!--       Read attributes for the fill value and level-of-detail
3038          CALL get_attribute( id_dynamic, char_fill, init_3d%fill_w,           &
3039                              .FALSE., 'init_atmosphere_w' )
3040          CALL get_attribute( id_dynamic, char_lod, init_3d%lod_w,             &
3041                              .FALSE., 'init_atmosphere_w' )
3042!
3043!--       level-of-detail 1 - read initialization profile
3044          IF ( init_3d%lod_w == 1 )  THEN
3045             ALLOCATE( init_3d%w_init(nzb:nzt+1) )
3046             init_3d%w_init = 0.0_wp
3047
3048             CALL get_variable( id_dynamic, 'init_atmosphere_w',               &
3049                                init_3d%w_init(nzb+1:nzt-1) )
3050!
3051!--          Set top-boundary condition (Neumann)
3052             init_3d%w_init(nzt:nzt+1) = init_3d%w_init(nzt-1)
3053!
3054!--       level-of-detail 2 - read 3D initialization data
3055          ELSEIF ( init_3d%lod_w == 2 )  THEN
3056
3057             CALL get_variable( id_dynamic, 'init_atmosphere_w',                &
3058                                w(nzb+1:nzt-1,nys:nyn,nxl:nxr),                 &
3059                                nxl+1, nys+1, nzb+1,                            &
3060                                nxr-nxl+1, nyn-nys+1, init_3d%nzw,              &
3061                                dynamic_3d )
3062!
3063!--          Set bottom and top-boundary                               
3064             w(nzb,:,:)   = 0.0_wp 
3065             w(nzt,:,:)   = w(nzt-1,:,:)
3066             w(nzt+1,:,:) = w(nzt-1,:,:)
3067
3068          ENDIF
3069          init_3d%from_file_w = .TRUE.
3070       ELSE
3071          message_string = 'Missing initial data for w-component'
3072          CALL message( 'netcdf_data_input_mod', 'PA0544', 1, 2, 0, 6, 0 )
3073       ENDIF
3074!
3075!--    Read potential temperature
3076       IF ( .NOT. neutral )  THEN
3077          IF ( check_existence( var_names, 'init_atmosphere_pt' ) )  THEN
3078!
3079!--          Read attributes for the fill value and level-of-detail
3080             CALL get_attribute( id_dynamic, char_fill, init_3d%fill_pt,       &
3081                                 .FALSE., 'init_atmosphere_pt' )
3082             CALL get_attribute( id_dynamic, char_lod, init_3d%lod_pt,         &
3083                                 .FALSE., 'init_atmosphere_pt' )
3084!
3085!--          level-of-detail 1 - read initialization profile
3086             IF ( init_3d%lod_pt == 1 )  THEN
3087                ALLOCATE( init_3d%pt_init(nzb:nzt+1) )
3088
3089                CALL get_variable( id_dynamic, 'init_atmosphere_pt',           &
3090                                   init_3d%pt_init(nzb+1:nzt) )
3091!
3092!--             Set Neumann top and surface boundary condition for initial
3093!--             profil
3094                init_3d%pt_init(nzb)   = init_3d%pt_init(nzb+1)
3095                init_3d%pt_init(nzt+1) = init_3d%pt_init(nzt)
3096!
3097!--          level-of-detail 2 - read 3D initialization data
3098             ELSEIF ( init_3d%lod_pt == 2 )  THEN
3099
3100                CALL get_variable( id_dynamic, 'init_atmosphere_pt',           &
3101                                   pt(nzb+1:nzt,nys:nyn,nxl:nxr),              &
3102                                   nxl+1, nys+1, nzb+1,                        &
3103                                   nxr-nxl+1, nyn-nys+1, init_3d%nzu,          &
3104                                   dynamic_3d )
3105                                   
3106!
3107!--             Set bottom and top-boundary
3108                pt(nzb,:,:)   = pt(nzb+1,:,:)
3109                pt(nzt+1,:,:) = pt(nzt,:,:)             
3110
3111             ENDIF
3112             init_3d%from_file_pt = .TRUE.
3113          ELSE
3114             message_string = 'Missing initial data for ' //                   &
3115                              'potential temperature'
3116             CALL message( 'netcdf_data_input_mod', 'PA0544', 1, 2, 0, 6, 0 )
3117          ENDIF
3118       ENDIF
3119!
3120!--    Read mixing ratio
3121       IF ( humidity )  THEN
3122          IF ( check_existence( var_names, 'init_atmosphere_qv' ) )  THEN
3123!
3124!--          Read attributes for the fill value and level-of-detail
3125             CALL get_attribute( id_dynamic, char_fill, init_3d%fill_q,        &
3126                                 .FALSE., 'init_atmosphere_qv' )
3127             CALL get_attribute( id_dynamic, char_lod, init_3d%lod_q,          &
3128                                 .FALSE., 'init_atmosphere_qv' )
3129!
3130!--          level-of-detail 1 - read initialization profile
3131             IF ( init_3d%lod_q == 1 )  THEN
3132                ALLOCATE( init_3d%q_init(nzb:nzt+1) )
3133
3134                CALL get_variable( id_dynamic, 'init_atmosphere_qv',           &
3135                                    init_3d%q_init(nzb+1:nzt) )
3136!
3137!--             Set bottom and top boundary condition (Neumann)
3138                init_3d%q_init(nzb)   = init_3d%q_init(nzb+1)
3139                init_3d%q_init(nzt+1) = init_3d%q_init(nzt)
3140!
3141!--          level-of-detail 2 - read 3D initialization data
3142             ELSEIF ( init_3d%lod_q == 2 )  THEN
3143             
3144                CALL get_variable( id_dynamic, 'init_atmosphere_qv',           &
3145                                   q(nzb+1:nzt,nys:nyn,nxl:nxr),               &
3146                                   nxl+1, nys+1, nzb+1,                        &
3147                                   nxr-nxl+1, nyn-nys+1, init_3d%nzu,          &
3148                                   dynamic_3d )
3149                                   
3150!
3151!--             Set bottom and top-boundary
3152                q(nzb,:,:)   = q(nzb+1,:,:)
3153                q(nzt+1,:,:) = q(nzt,:,:)
3154               
3155             ENDIF
3156             init_3d%from_file_q = .TRUE.
3157          ELSE
3158             message_string = 'Missing initial data for ' //                   &
3159                              'mixing ratio'
3160             CALL message( 'netcdf_data_input_mod', 'PA0544', 1, 2, 0, 6, 0 )
3161          ENDIF
3162       ENDIF       
3163!
3164!--    Read chemistry variables.
3165!--    Please note, for the moment, only LOD=1 is allowed
3166       IF ( air_chemistry )  THEN
3167!
3168!--       Allocate chemistry input profiles, as well as arrays for fill values
3169!--       and LOD's.
3170          ALLOCATE( init_3d%chem_init(nzb:nzt+1,                               &
3171                                      1:UBOUND(init_3d%var_names_chem, 1 )) )
3172          ALLOCATE( init_3d%fill_chem(1:UBOUND(init_3d%var_names_chem, 1)) )   
3173          ALLOCATE( init_3d%lod_chem(1:UBOUND(init_3d%var_names_chem, 1))  ) 
3174         
3175          DO  n = 1, UBOUND(init_3d%var_names_chem, 1)
3176             IF ( check_existence( var_names,                                  &
3177                                   TRIM( init_3d%var_names_chem(n) ) ) )  THEN
3178!
3179!--             Read attributes for the fill value and level-of-detail
3180                CALL get_attribute( id_dynamic, char_fill,                     &
3181                                    init_3d%fill_chem(n),                      &
3182                                    .FALSE.,                                   &
3183                                    TRIM( init_3d%var_names_chem(n) ) )
3184                CALL get_attribute( id_dynamic, char_lod,                      &
3185                                    init_3d%lod_chem(n),                       &
3186                                    .FALSE.,                                   &
3187                                    TRIM( init_3d%var_names_chem(n) ) )
3188!
3189!--             Give message that only LOD=1 is allowed.
3190                IF ( init_3d%lod_chem(n) /= 1 )  THEN               
3191                   message_string = 'For chemistry variables only LOD=1 is ' //&
3192                                    'allowed.'
3193                   CALL message( 'netcdf_data_input_mod', 'PA0586',            &
3194                                 1, 2, 0, 6, 0 )
3195                ENDIF
3196!
3197!--             level-of-detail 1 - read initialization profile
3198                CALL get_variable( id_dynamic,                                 &
3199                                   TRIM( init_3d%var_names_chem(n) ),          &
3200                                   init_3d%chem_init(nzb+1:nzt,n) )
3201!
3202!--             Set bottom and top boundary condition (Neumann)
3203                init_3d%chem_init(nzb,n)   = init_3d%chem_init(nzb+1,n)
3204                init_3d%chem_init(nzt+1,n) = init_3d%chem_init(nzt,n)
3205               
3206                init_3d%from_file_chem(n) = .TRUE.
3207             ENDIF
3208          ENDDO
3209       ENDIF
3210!
3211!--    Close input file
3212       CALL close_input_file( id_dynamic )
3213#endif
3214!
3215!--    End of CPU measurement
3216       CALL cpu_log( log_point_s(85), 'NetCDF input init', 'stop' )
3217!
3218!--    Finally, check if the input data has any fill values. Please note,
3219!--    checks depend on the LOD of the input data.
3220       IF ( init_3d%from_file_u )  THEN
3221          check_passed = .TRUE.
3222          IF ( init_3d%lod_u == 1 )  THEN
3223             IF ( ANY( init_3d%u_init(nzb+1:nzt+1) == init_3d%fill_u ) )       &
3224                check_passed = .FALSE.
3225          ELSEIF ( init_3d%lod_u == 2 )  THEN
3226             IF ( ANY( u(nzb+1:nzt+1,nys:nyn,nxlu:nxr) == init_3d%fill_u ) )   &
3227                check_passed = .FALSE.
3228          ENDIF
3229          IF ( .NOT. check_passed )  THEN
3230             message_string = 'NetCDF input for init_atmosphere_u must ' //    &
3231                              'not contain any _FillValues'
3232             CALL message( 'netcdf_data_input_mod', 'PA0545', 2, 2, 0, 6, 0 )
3233          ENDIF
3234       ENDIF
3235
3236       IF ( init_3d%from_file_v )  THEN
3237          check_passed = .TRUE.
3238          IF ( init_3d%lod_v == 1 )  THEN
3239             IF ( ANY( init_3d%v_init(nzb+1:nzt+1) == init_3d%fill_v ) )       &
3240                check_passed = .FALSE.
3241          ELSEIF ( init_3d%lod_v == 2 )  THEN
3242             IF ( ANY( v(nzb+1:nzt+1,nysv:nyn,nxl:nxr) == init_3d%fill_v ) )   &
3243                check_passed = .FALSE.
3244          ENDIF
3245          IF ( .NOT. check_passed )  THEN
3246             message_string = 'NetCDF input for init_atmosphere_v must ' //    &
3247                              'not contain any _FillValues'
3248             CALL message( 'netcdf_data_input_mod', 'PA0545', 2, 2, 0, 6, 0 )
3249          ENDIF
3250       ENDIF
3251
3252       IF ( init_3d%from_file_w )  THEN
3253          check_passed = .TRUE.
3254          IF ( init_3d%lod_w == 1 )  THEN
3255             IF ( ANY( init_3d%w_init(nzb+1:nzt) == init_3d%fill_w ) )         &
3256                check_passed = .FALSE.
3257          ELSEIF ( init_3d%lod_w == 2 )  THEN
3258             IF ( ANY( w(nzb+1:nzt,nys:nyn,nxl:nxr) == init_3d%fill_w ) )      &
3259                check_passed = .FALSE.
3260          ENDIF
3261          IF ( .NOT. check_passed )  THEN
3262             message_string = 'NetCDF input for init_atmosphere_w must ' //    &
3263                              'not contain any _FillValues'
3264             CALL message( 'netcdf_data_input_mod', 'PA0545', 2, 2, 0, 6, 0 )
3265          ENDIF
3266       ENDIF
3267
3268       IF ( init_3d%from_file_pt )  THEN
3269          check_passed = .TRUE.
3270          IF ( init_3d%lod_pt == 1 )  THEN
3271             IF ( ANY( init_3d%pt_init(nzb+1:nzt+1) == init_3d%fill_pt ) )     &
3272                check_passed = .FALSE.
3273          ELSEIF ( init_3d%lod_pt == 2 )  THEN
3274             IF ( ANY( pt(nzb+1:nzt+1,nys:nyn,nxl:nxr) == init_3d%fill_pt ) )  &
3275                check_passed = .FALSE.
3276          ENDIF
3277          IF ( .NOT. check_passed )  THEN
3278             message_string = 'NetCDF input for init_atmosphere_pt must ' //   &
3279                              'not contain any _FillValues'
3280             CALL message( 'netcdf_data_input_mod', 'PA0545', 2, 2, 0, 6, 0 )
3281          ENDIF
3282       ENDIF
3283
3284       IF ( init_3d%from_file_q )  THEN
3285          check_passed = .TRUE.
3286          IF ( init_3d%lod_q == 1 )  THEN
3287             IF ( ANY( init_3d%q_init(nzb+1:nzt+1) == init_3d%fill_q ) )       &
3288                check_passed = .FALSE.
3289          ELSEIF ( init_3d%lod_q == 2 )  THEN
3290             IF ( ANY( q(nzb+1:nzt+1,nys:nyn,nxl:nxr) == init_3d%fill_q ) )    &
3291                check_passed = .FALSE.
3292          ENDIF
3293          IF ( .NOT. check_passed )  THEN
3294             message_string = 'NetCDF input for init_atmosphere_q must ' //    &
3295                              'not contain any _FillValues'
3296             CALL message( 'netcdf_data_input_mod', 'PA0545', 2, 2, 0, 6, 0 )
3297          ENDIF
3298       ENDIF
3299!
3300!--    Workaround for cyclic conditions. Please see above for further explanation.
3301       IF ( bc_lr_cyc  .AND.  nxl == 0 )  nxlu = nxl
3302       IF ( bc_ns_cyc  .AND.  nys == 0 )  nysv = nys
3303
3304    END SUBROUTINE netcdf_data_input_init_3d
3305   
3306!------------------------------------------------------------------------------!
3307! Description:
3308! ------------
3309!> Reads initialization data of u, v, w, pt, q, geostrophic wind components,
3310!> as well as soil moisture and soil temperature, derived from larger-scale
3311!> model (COSMO) by Inifor.
3312!------------------------------------------------------------------------------!
3313    SUBROUTINE netcdf_data_input_init_lsm
3314
3315       USE control_parameters,                                                 &
3316           ONLY:  message_string
3317
3318       USE indices,                                                            &
3319           ONLY:  nx, nxl, nxr, ny, nyn, nys
3320
3321       IMPLICIT NONE
3322
3323       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names !< string containing all variables on file
3324     
3325       INTEGER(iwp) ::  id_dynamic !< NetCDF id of dynamic input file
3326       INTEGER(iwp) ::  num_vars   !< number of variables in netcdf input file
3327
3328!
3329!--    Skip routine if no input file with dynamic input data is available.
3330       IF ( .NOT. input_pids_dynamic )  RETURN
3331!
3332!--    CPU measurement
3333       CALL cpu_log( log_point_s(85), 'NetCDF input init', 'start' )
3334
3335#if defined ( __netcdf )
3336!
3337!--    Open file in read-only mode
3338       CALL open_read_file( TRIM( input_file_dynamic ) //                      &
3339                            TRIM( coupling_char ), id_dynamic )
3340
3341!
3342!--    At first, inquire all variable names.
3343       CALL inquire_num_variables( id_dynamic, num_vars )
3344!
3345!--    Allocate memory to store variable names.
3346       ALLOCATE( var_names(1:num_vars) )
3347       CALL inquire_variable_names( id_dynamic, var_names )
3348!
3349!--    Read vertical dimension for soil depth.
3350       IF ( check_existence( var_names, 'zsoil' ) )                            &
3351          CALL netcdf_data_input_get_dimension_length( id_dynamic, init_3d%nzs,&
3352                                                       'zsoil' )
3353!
3354!--    Read also the horizontal dimensions required for soil initialization.
3355!--    Please note, in case of non-nested runs or in case of root domain,
3356!--    these data is already available, but will be read again for the sake
3357!--    of clearness.
3358       CALL netcdf_data_input_get_dimension_length( id_dynamic, init_3d%nx,    &
3359                                                    'x'  )
3360       CALL netcdf_data_input_get_dimension_length( id_dynamic, init_3d%ny,    &
3361                                                    'y'  )
3362!
3363!--    Check for correct horizontal and vertical dimension. Please note,
3364!--    in case of non-nested runs or in case of root domain, these checks
3365!--    are already performed
3366       IF ( init_3d%nx-1 /= nx  .OR.  init_3d%ny-1 /= ny )  THEN
3367          message_string = 'Number of inifor horizontal grid points  '//       &
3368                           'does not match the number of numeric grid points.'
3369          CALL message( 'netcdf_data_input_mod', 'PA0543', 1, 2, 0, 6, 0 )
3370       ENDIF
3371!
3372!--    Read vertical dimensions. Later, these are required for eventual
3373!--    inter- and extrapolations of the initialization data.
3374       IF ( check_existence( var_names, 'zsoil' ) )  THEN
3375          ALLOCATE( init_3d%z_soil(1:init_3d%nzs) )
3376          CALL get_variable( id_dynamic, 'zsoil', init_3d%z_soil )
3377       ENDIF
3378!
3379!--    Read initial data for soil moisture
3380       IF ( check_existence( var_names, 'init_soil_m' ) )  THEN
3381!
3382!--       Read attributes for the fill value and level-of-detail
3383          CALL get_attribute( id_dynamic, char_fill,                           &
3384                              init_3d%fill_msoil,                              &
3385                              .FALSE., 'init_soil_m' )
3386          CALL get_attribute( id_dynamic, char_lod,                            &
3387                              init_3d%lod_msoil,                               &
3388                              .FALSE., 'init_soil_m' )
3389!
3390!--       level-of-detail 1 - read initialization profile
3391          IF ( init_3d%lod_msoil == 1 )  THEN
3392             ALLOCATE( init_3d%msoil_1d(0:init_3d%nzs-1) )
3393
3394             CALL get_variable( id_dynamic, 'init_soil_m',                     &
3395                                init_3d%msoil_1d(0:init_3d%nzs-1) )
3396!
3397!--       level-of-detail 2 - read 3D initialization data
3398          ELSEIF ( init_3d%lod_msoil == 2 )  THEN
3399             ALLOCATE ( init_3d%msoil_3d(0:init_3d%nzs-1,nys:nyn,nxl:nxr) )
3400
3401            CALL get_variable( id_dynamic, 'init_soil_m',                      &   
3402                             init_3d%msoil_3d(0:init_3d%nzs-1,nys:nyn,nxl:nxr),&
3403                             nxl, nxr, nys, nyn, 0, init_3d%nzs-1 )
3404
3405          ENDIF
3406          init_3d%from_file_msoil = .TRUE.
3407       ENDIF
3408!
3409!--    Read soil temperature
3410       IF ( check_existence( var_names, 'init_soil_t' ) )  THEN
3411!
3412!--       Read attributes for the fill value and level-of-detail
3413          CALL get_attribute( id_dynamic, char_fill,                           &
3414                              init_3d%fill_tsoil,                              &
3415                              .FALSE., 'init_soil_t' )
3416          CALL get_attribute( id_dynamic, char_lod,                            &
3417                              init_3d%lod_tsoil,                               &
3418                              .FALSE., 'init_soil_t' )
3419!
3420!--       level-of-detail 1 - read initialization profile
3421          IF ( init_3d%lod_tsoil == 1 )  THEN
3422             ALLOCATE( init_3d%tsoil_1d(0:init_3d%nzs-1) )
3423
3424             CALL get_variable( id_dynamic, 'init_soil_t',                     &
3425                                init_3d%tsoil_1d(0:init_3d%nzs-1) )
3426
3427!
3428!--       level-of-detail 2 - read 3D initialization data
3429          ELSEIF ( init_3d%lod_tsoil == 2 )  THEN
3430             ALLOCATE ( init_3d%tsoil_3d(0:init_3d%nzs-1,nys:nyn,nxl:nxr) )
3431             
3432             CALL get_variable( id_dynamic, 'init_soil_t',                     &   
3433                             init_3d%tsoil_3d(0:init_3d%nzs-1,nys:nyn,nxl:nxr),&
3434                             nxl, nxr, nys, nyn, 0, init_3d%nzs-1 )
3435          ENDIF
3436          init_3d%from_file_tsoil = .TRUE.
3437       ENDIF
3438!
3439!--    Close input file
3440       CALL close_input_file( id_dynamic )
3441#endif
3442!
3443!--    End of CPU measurement
3444       CALL cpu_log( log_point_s(85), 'NetCDF input init', 'stop' )
3445
3446    END SUBROUTINE netcdf_data_input_init_lsm   
3447
3448!------------------------------------------------------------------------------!
3449! Description:
3450! ------------
3451!> Reads data at lateral and top boundaries derived from larger-scale model
3452!> (COSMO) by Inifor.
3453!------------------------------------------------------------------------------!
3454    SUBROUTINE netcdf_data_input_offline_nesting
3455
3456       USE control_parameters,                                                 &
3457           ONLY:  air_chemistry, bc_dirichlet_l, bc_dirichlet_n,               &
3458                  bc_dirichlet_r, bc_dirichlet_s, humidity, neutral,           &
3459                  nesting_offline, time_since_reference_point
3460
3461       USE indices,                                                            &
3462           ONLY:  nxl, nxlu, nxr, nyn, nys, nysv, nzb, nzt
3463
3464       IMPLICIT NONE
3465       
3466       INTEGER(iwp) ::  id_dynamic !< NetCDF id of dynamic input file
3467       INTEGER(iwp) ::  n          !< running index for chemistry variables
3468       INTEGER(iwp) ::  num_vars   !< number of variables in netcdf input file
3469       INTEGER(iwp) ::  t          !< running index time dimension
3470!
3471!--    Skip input if no forcing from larger-scale models is applied.
3472       IF ( .NOT. nesting_offline )  RETURN
3473
3474!
3475!--    CPU measurement
3476       CALL cpu_log( log_point_s(86), 'NetCDF input forcing', 'start' )
3477
3478#if defined ( __netcdf )
3479!
3480!--    Open file in read-only mode
3481       CALL open_read_file( TRIM( input_file_dynamic ) //                      &
3482                            TRIM( coupling_char ), id_dynamic )
3483!
3484!--    Initialize INIFOR forcing.
3485       IF ( .NOT. nest_offl%init )  THEN
3486!
3487!--       At first, inquire all variable names.
3488          CALL inquire_num_variables( id_dynamic, num_vars )
3489!
3490!--       Allocate memory to store variable names.
3491          ALLOCATE( nest_offl%var_names(1:num_vars) )
3492          CALL inquire_variable_names( id_dynamic, nest_offl%var_names )
3493!
3494!--       Read time dimension, allocate memory and finally read time array
3495          CALL netcdf_data_input_get_dimension_length( id_dynamic,             &
3496                                                       nest_offl%nt, 'time' )
3497
3498          IF ( check_existence( nest_offl%var_names, 'time' ) )  THEN
3499             ALLOCATE( nest_offl%time(0:nest_offl%nt-1) )
3500             CALL get_variable( id_dynamic, 'time', nest_offl%time )
3501          ENDIF
3502!
3503!--       Read vertical dimension of scalar und w grid
3504          CALL netcdf_data_input_get_dimension_length( id_dynamic,             &
3505                                                       nest_offl%nzu, 'z' )
3506          CALL netcdf_data_input_get_dimension_length( id_dynamic,             &
3507                                                       nest_offl%nzw, 'zw' )
3508
3509          IF ( check_existence( nest_offl%var_names, 'z' ) )  THEN
3510             ALLOCATE( nest_offl%zu_atmos(1:nest_offl%nzu) )
3511             CALL get_variable( id_dynamic, 'z', nest_offl%zu_atmos )
3512          ENDIF
3513          IF ( check_existence( nest_offl%var_names, 'zw' ) )  THEN
3514             ALLOCATE( nest_offl%zw_atmos(1:nest_offl%nzw) )
3515             CALL get_variable( id_dynamic, 'zw', nest_offl%zw_atmos )
3516          ENDIF
3517
3518!
3519!--       Read surface pressure
3520          IF ( check_existence( nest_offl%var_names,                           &
3521                                'surface_forcing_surface_pressure' ) )  THEN
3522             ALLOCATE( nest_offl%surface_pressure(0:nest_offl%nt-1) )
3523             CALL get_variable( id_dynamic,                                    &
3524                                'surface_forcing_surface_pressure',            &
3525                                nest_offl%surface_pressure )
3526          ENDIF
3527!
3528!--       Set control flag to indicate that initialization is already done
3529          nest_offl%init = .TRUE.
3530
3531       ENDIF
3532
3533!
3534!--    Obtain time index for current input starting at 0.
3535!--    @todo: At the moment INIFOR and simulated time correspond
3536!--           to each other. If required, adjust to daytime.
3537       nest_offl%tind = MINLOC( ABS( nest_offl%time -                          &
3538                                     time_since_reference_point ), DIM = 1 )   &
3539                        - 1
3540       nest_offl%tind_p = nest_offl%tind + 1       
3541!
3542!--    Read geostrophic wind components
3543       DO  t = nest_offl%tind, nest_offl%tind_p
3544          CALL get_variable_pr( id_dynamic, 'ls_forcing_ug', t+1,              &
3545                                nest_offl%ug(t-nest_offl%tind,nzb+1:nzt) )
3546          CALL get_variable_pr( id_dynamic, 'ls_forcing_vg', t+1,              &
3547                                nest_offl%vg(t-nest_offl%tind,nzb+1:nzt) )
3548       ENDDO
3549!
3550!--    Read data at lateral and top boundaries. Please note, at left and
3551!--    right domain boundary, yz-layers are read for u, v, w, pt and q.
3552!--    For the v-component, the data starts at nysv, while for the other
3553!--    quantities the data starts at nys. This is equivalent at the north
3554!--    and south domain boundary for the u-component.
3555!--    Further, lateral data is not accessed by parallel IO, indicated by the
3556!--    last passed flag in the subroutine get_variable(). This is because
3557!--    not every PE participates in this collective blocking read operation.
3558       IF ( bc_dirichlet_l )  THEN
3559          CALL get_variable( id_dynamic, 'ls_forcing_left_u',                  &
3560                           nest_offl%u_left(0:1,nzb+1:nzt,nys:nyn),            &
3561                           nys+1, nzb+1, nest_offl%tind+1,                     &
3562                           nyn-nys+1, nest_offl%nzu, 2, .FALSE. )
3563     
3564          CALL get_variable( id_dynamic, 'ls_forcing_left_v',                  &
3565                           nest_offl%v_left(0:1,nzb+1:nzt,nysv:nyn),           &
3566                           nysv, nzb+1, nest_offl%tind+1,                      &
3567                           nyn-nysv+1, nest_offl%nzu, 2, .FALSE. )
3568
3569          CALL get_variable( id_dynamic, 'ls_forcing_left_w',                  &
3570                           nest_offl%w_left(0:1,nzb+1:nzt-1,nys:nyn),          &
3571                           nys+1, nzb+1, nest_offl%tind+1,                     &
3572                           nyn-nys+1, nest_offl%nzw, 2, .FALSE. )
3573
3574          IF ( .NOT. neutral )  THEN
3575             CALL get_variable( id_dynamic, 'ls_forcing_left_pt',              &
3576                           nest_offl%pt_left(0:1,nzb+1:nzt,nys:nyn),           &
3577                           nys+1, nzb+1, nest_offl%tind+1,                     &
3578                           nyn-nys+1, nest_offl%nzu, 2, .FALSE. )
3579          ENDIF
3580
3581          IF ( humidity )  THEN
3582             CALL get_variable( id_dynamic, 'ls_forcing_left_qv',              &
3583                           nest_offl%q_left(0:1,nzb+1:nzt,nys:nyn),            &
3584                           nys+1, nzb+1, nest_offl%tind+1,                     &
3585                           nyn-nys+1, nest_offl%nzu, 2, .FALSE. )
3586          ENDIF
3587         
3588          IF ( air_chemistry )  THEN
3589             DO  n = 1, UBOUND(nest_offl%var_names_chem_l, 1)
3590                IF ( check_existence( nest_offl%var_names,                     &
3591                                      nest_offl%var_names_chem_l(n) ) )        &
3592                THEN
3593                   CALL get_variable( id_dynamic,                              &
3594                              TRIM( nest_offl%var_names_chem_l(n) ),           &
3595                              nest_offl%chem_left(0:1,nzb+1:nzt,nys:nyn,n),    &
3596                              nys+1, nzb+1, nest_offl%tind+1,                  &
3597                              nyn-nys+1, nest_offl%nzu, 2, .FALSE. )
3598                   nest_offl%chem_from_file_l(n) = .TRUE.
3599                ENDIF
3600             ENDDO
3601          ENDIF
3602
3603       ENDIF
3604
3605       IF ( bc_dirichlet_r )  THEN
3606          CALL get_variable( id_dynamic, 'ls_forcing_right_u',                 &
3607                           nest_offl%u_right(0:1,nzb+1:nzt,nys:nyn),           &
3608                           nys+1, nzb+1, nest_offl%tind+1,                     &
3609                           nyn-nys+1, nest_offl%nzu, 2, .FALSE. )
3610                           
3611          CALL get_variable( id_dynamic, 'ls_forcing_right_v',                 &
3612                           nest_offl%v_right(0:1,nzb+1:nzt,nysv:nyn),          &
3613                           nysv, nzb+1, nest_offl%tind+1,                      &
3614                           nyn-nysv+1, nest_offl%nzu, 2, .FALSE. )
3615                           
3616          CALL get_variable( id_dynamic, 'ls_forcing_right_w',                 &
3617                           nest_offl%w_right(0:1,nzb+1:nzt-1,nys:nyn),         &
3618                           nys+1, nzb+1, nest_offl%tind+1,                     &
3619                           nyn-nys+1, nest_offl%nzw, 2, .FALSE. )
3620                           
3621          IF ( .NOT. neutral )  THEN
3622             CALL get_variable( id_dynamic, 'ls_forcing_right_pt',             &
3623                           nest_offl%pt_right(0:1,nzb+1:nzt,nys:nyn),          &
3624                           nys+1, nzb+1, nest_offl%tind+1,                     &
3625                           nyn-nys+1, nest_offl%nzu, 2, .FALSE. )
3626          ENDIF
3627          IF ( humidity )  THEN
3628             CALL get_variable( id_dynamic, 'ls_forcing_right_qv',             &
3629                           nest_offl%q_right(0:1,nzb+1:nzt,nys:nyn),           &
3630                           nys+1, nzb+1, nest_offl%tind+1,                     &
3631                           nyn-nys+1, nest_offl%nzu, 2, .FALSE. )
3632          ENDIF
3633         
3634          IF ( air_chemistry )  THEN
3635             DO  n = 1, UBOUND(nest_offl%var_names_chem_r, 1)
3636                IF ( check_existence( nest_offl%var_names,                     &
3637                                      nest_offl%var_names_chem_r(n) ) )        &
3638                THEN
3639                   CALL get_variable( id_dynamic,                              &
3640                              TRIM( nest_offl%var_names_chem_r(n) ),           &
3641                              nest_offl%chem_right(0:1,nzb+1:nzt,nys:nyn,n),   &
3642                              nys+1, nzb+1, nest_offl%tind+1,                  &
3643                              nyn-nys+1, nest_offl%nzu, 2, .FALSE. )
3644                   nest_offl%chem_from_file_r(n) = .TRUE.
3645                ENDIF
3646             ENDDO
3647          ENDIF
3648       ENDIF
3649
3650       IF ( bc_dirichlet_n )  THEN
3651       
3652          CALL get_variable( id_dynamic, 'ls_forcing_north_u',                 &
3653                           nest_offl%u_north(0:1,nzb+1:nzt,nxlu:nxr),          &
3654                           nxlu, nzb+1, nest_offl%tind+1,                      &
3655                           nxr-nxlu+1, nest_offl%nzu, 2, .FALSE. )
3656                           
3657          CALL get_variable( id_dynamic, 'ls_forcing_north_v',                 &
3658                           nest_offl%v_north(0:1,nzb+1:nzt,nxl:nxr),           &
3659                           nxl+1, nzb+1, nest_offl%tind+1,                     &
3660                           nxr-nxl+1, nest_offl%nzu, 2, .FALSE. )
3661                           
3662          CALL get_variable( id_dynamic, 'ls_forcing_north_w',                 &
3663                           nest_offl%w_north(0:1,nzb+1:nzt-1,nxl:nxr),         &
3664                           nxl+1, nzb+1, nest_offl%tind+1,                     &
3665                           nxr-nxl+1, nest_offl%nzw, 2, .FALSE. )
3666                           
3667          IF ( .NOT. neutral )  THEN
3668             CALL get_variable( id_dynamic, 'ls_forcing_north_pt',             &
3669                           nest_offl%pt_north(0:1,nzb+1:nzt,nxl:nxr),          &
3670                           nxl+1, nzb+1, nest_offl%tind+1,                     &
3671                           nxr-nxl+1, nest_offl%nzu, 2, .FALSE. )
3672          ENDIF
3673          IF ( humidity )  THEN
3674             CALL get_variable( id_dynamic, 'ls_forcing_north_qv',             &
3675                           nest_offl%q_north(0:1,nzb+1:nzt,nxl:nxr),           &
3676                           nxl+1, nzb+1, nest_offl%tind+1,                     &
3677                           nxr-nxl+1, nest_offl%nzu, 2, .FALSE. )
3678          ENDIF
3679         
3680          IF ( air_chemistry )  THEN
3681             DO  n = 1, UBOUND(nest_offl%var_names_chem_n, 1)
3682                IF ( check_existence( nest_offl%var_names,                     &
3683                                      nest_offl%var_names_chem_n(n) ) )        &
3684                THEN
3685                   CALL get_variable( id_dynamic,                              &
3686                              TRIM( nest_offl%var_names_chem_n(n) ),           &
3687                              nest_offl%chem_north(0:1,nzb+1:nzt,nxl:nxr,n),   &
3688                              nxl+1, nzb+1, nest_offl%tind+1,                  &
3689                              nxr-nxl+1, nest_offl%nzu, 2, .FALSE. )
3690                   nest_offl%chem_from_file_n(n) = .TRUE.
3691                ENDIF
3692             ENDDO
3693          ENDIF
3694       ENDIF
3695
3696       IF ( bc_dirichlet_s )  THEN
3697          CALL get_variable( id_dynamic, 'ls_forcing_south_u',                 &
3698                           nest_offl%u_south(0:1,nzb+1:nzt,nxlu:nxr),          &
3699                           nxlu, nzb+1, nest_offl%tind+1,                      &
3700                           nxr-nxlu+1, nest_offl%nzu, 2, .FALSE. )
3701
3702          CALL get_variable( id_dynamic, 'ls_forcing_south_v',                 &
3703                           nest_offl%v_south(0:1,nzb+1:nzt,nxl:nxr),           &
3704                           nxl+1, nzb+1, nest_offl%tind+1,                     &
3705                           nxr-nxl+1, nest_offl%nzu, 2, .FALSE. )
3706                           
3707          CALL get_variable( id_dynamic, 'ls_forcing_south_w',                 &
3708                           nest_offl%w_south(0:1,nzb+1:nzt-1,nxl:nxr),         &
3709                           nxl+1, nzb+1, nest_offl%tind+1,                     &
3710                           nxr-nxl+1, nest_offl%nzw, 2, .FALSE. )
3711                           
3712          IF ( .NOT. neutral )  THEN
3713             CALL get_variable( id_dynamic, 'ls_forcing_south_pt',             &
3714                           nest_offl%pt_south(0:1,nzb+1:nzt,nxl:nxr),          &
3715                           nxl+1, nzb+1, nest_offl%tind+1,                     &
3716                           nxr-nxl+1, nest_offl%nzu, 2, .FALSE. )
3717          ENDIF
3718          IF ( humidity )  THEN
3719             CALL get_variable( id_dynamic, 'ls_forcing_south_qv',             &
3720                           nest_offl%q_south(0:1,nzb+1:nzt,nxl:nxr),           &
3721                           nxl+1, nzb+1, nest_offl%tind+1,                     &
3722                           nxr-nxl+1, nest_offl%nzu, 2, .FALSE. )
3723          ENDIF
3724         
3725          IF ( air_chemistry )  THEN
3726             DO  n = 1, UBOUND(nest_offl%var_names_chem_s, 1)
3727                IF ( check_existence( nest_offl%var_names,                     &
3728                                      nest_offl%var_names_chem_s(n) ) )        &
3729                THEN
3730                   CALL get_variable( id_dynamic,                              &
3731                              TRIM( nest_offl%var_names_chem_s(n) ),           &
3732                              nest_offl%chem_south(0:1,nzb+1:nzt,nxl:nxr,n),   &
3733                              nxl+1, nzb+1, nest_offl%tind+1,                  &
3734                              nxr-nxl+1, nest_offl%nzu, 2, .FALSE. )
3735                   nest_offl%chem_from_file_s(n) = .TRUE.
3736                ENDIF
3737             ENDDO
3738          ENDIF
3739       ENDIF
3740
3741!
3742!--    Top boundary
3743       CALL get_variable( id_dynamic, 'ls_forcing_top_u',                      &
3744                             nest_offl%u_top(0:1,nys:nyn,nxlu:nxr),            &
3745                             nxlu, nys+1, nest_offl%tind+1,                    &
3746                             nxr-nxlu+1, nyn-nys+1, 2, .TRUE. )
3747
3748       CALL get_variable( id_dynamic, 'ls_forcing_top_v',                      &
3749                             nest_offl%v_top(0:1,nysv:nyn,nxl:nxr),            &
3750                             nxl+1, nysv, nest_offl%tind+1,                    &
3751                             nxr-nxl+1, nyn-nysv+1, 2, .TRUE. )
3752                             
3753       CALL get_variable( id_dynamic, 'ls_forcing_top_w',                      &
3754                             nest_offl%w_top(0:1,nys:nyn,nxl:nxr),             &
3755                             nxl+1, nys+1, nest_offl%tind+1,                   &
3756                             nxr-nxl+1, nyn-nys+1, 2, .TRUE. )
3757                             
3758       IF ( .NOT. neutral )  THEN
3759          CALL get_variable( id_dynamic, 'ls_forcing_top_pt',                  &
3760                                nest_offl%pt_top(0:1,nys:nyn,nxl:nxr),         &
3761                                nxl+1, nys+1, nest_offl%tind+1,                &
3762                                nxr-nxl+1, nyn-nys+1, 2, .TRUE. )
3763       ENDIF
3764       IF ( humidity )  THEN
3765          CALL get_variable( id_dynamic, 'ls_forcing_top_qv',                  &
3766                                nest_offl%q_top(0:1,nys:nyn,nxl:nxr),          &
3767                                nxl+1, nys+1, nest_offl%tind+1,                &
3768                                nxr-nxl+1, nyn-nys+1, 2, .TRUE. )
3769       ENDIF
3770       
3771       IF ( air_chemistry )  THEN
3772          DO  n = 1, UBOUND(nest_offl%var_names_chem_t, 1)
3773             IF ( check_existence( nest_offl%var_names,                     &
3774                                   nest_offl%var_names_chem_t(n) ) )  THEN     
3775                CALL get_variable( id_dynamic,                                 &
3776                              TRIM( nest_offl%var_names_chem_t(n) ),           &
3777                              nest_offl%chem_top(0:1,nys:nyn,nxl:nxr,n),       &
3778                              nxl+1, nys+1, nest_offl%tind+1,                  &
3779                              nxr-nxl+1, nyn-nys+1, 2, .TRUE. )
3780                nest_offl%chem_from_file_t(n) = .TRUE.
3781             ENDIF
3782          ENDDO
3783       ENDIF
3784
3785!
3786!--    Close input file
3787       CALL close_input_file( id_dynamic )
3788#endif
3789!
3790!--    End of CPU measurement
3791       CALL cpu_log( log_point_s(86), 'NetCDF input forcing', 'stop' )
3792
3793    END SUBROUTINE netcdf_data_input_offline_nesting
3794
3795
3796!------------------------------------------------------------------------------!
3797! Description:
3798! ------------
3799!> Checks input file for consistency and minimum requirements.
3800!------------------------------------------------------------------------------!
3801    SUBROUTINE netcdf_data_input_check_dynamic
3802
3803       USE control_parameters,                                                 &
3804           ONLY:  initializing_actions, message_string, nesting_offline
3805
3806       IMPLICIT NONE
3807
3808!
3809!--    In case of forcing, check whether dynamic input file is present
3810       IF ( .NOT. input_pids_dynamic  .AND.  nesting_offline  )  THEN
3811          message_string = 'nesting_offline = .TRUE. requires dynamic '  //    &
3812                            'input file ' //                                   &
3813                            TRIM( input_file_dynamic ) // TRIM( coupling_char )
3814          CALL message( 'netcdf_data_input_mod', 'PA0546', 1, 2, 0, 6, 0 )
3815       ENDIF
3816!
3817!--    Dynamic input file must also be present if initialization via inifor is
3818!--    prescribed.
3819       IF ( .NOT. input_pids_dynamic  .AND.                                    &
3820            TRIM( initializing_actions ) == 'inifor' )  THEN
3821          message_string = 'initializing_actions = inifor requires dynamic ' //&
3822                           'input file ' // TRIM( input_file_dynamic ) //      &
3823                           TRIM( coupling_char )
3824          CALL message( 'netcdf_data_input_mod', 'PA0547', 1, 2, 0, 6, 0 )
3825       ENDIF
3826
3827    END SUBROUTINE netcdf_data_input_check_dynamic
3828
3829!------------------------------------------------------------------------------!
3830! Description:
3831! ------------
3832!> Checks input file for consistency and minimum requirements.
3833!------------------------------------------------------------------------------!
3834    SUBROUTINE netcdf_data_input_check_static
3835
3836       USE arrays_3d,                                                          &
3837           ONLY:  zu
3838
3839       USE control_parameters,                                                 &
3840           ONLY:  land_surface, message_string, urban_surface
3841
3842       USE indices,                                                            &
3843           ONLY:  nxl, nxr, nyn, nys
3844
3845       IMPLICIT NONE
3846
3847       INTEGER(iwp) ::  i      !< loop index along x-direction
3848       INTEGER(iwp) ::  j      !< loop index along y-direction
3849       INTEGER(iwp) ::  n_surf !< number of different surface types at given location
3850
3851       LOGICAL      ::  check_passed !< flag indicating if a check passed
3852
3853!
3854!--    Return if no static input file is available
3855       IF ( .NOT. input_pids_static )  RETURN
3856!
3857!--    Check for correct dimension of surface_fractions, should run from 0-2.
3858       IF ( surface_fraction_f%from_file )  THEN
3859          IF ( surface_fraction_f%nf-1 > 2 )  THEN
3860             message_string = 'nsurface_fraction must not be larger than 3.' 
3861             CALL message( 'netcdf_data_input_mod', 'PA0580', 1, 2, 0, 6, 0 )
3862          ENDIF
3863       ENDIF
3864!
3865!--    Check orography for fill-values. For the moment, give an error message.
3866!--    More advanced methods, e.g. a nearest neighbor algorithm as used in GIS
3867!--    systems might be implemented later.
3868!--    Please note, if no terrain height is provided, it is set to 0.
3869       IF ( ANY( terrain_height_f%var == terrain_height_f%fill ) )  THEN
3870          message_string = 'NetCDF variable zt is not ' //                     &
3871                           'allowed to have missing data'
3872          CALL message( 'netcdf_data_input_mod', 'PA0550', 2, 2, myid, 6, 0 )
3873       ENDIF
3874!
3875!--    Check for negative terrain heights
3876       IF ( ANY( terrain_height_f%var < 0.0_wp ) )  THEN
3877          message_string = 'NetCDF variable zt is not ' //                     &
3878                           'allowed to have negative values'
3879          CALL message( 'netcdf_data_input_mod', 'PA0551', 2, 2, myid, 6, 0 )
3880       ENDIF
3881!
3882!--    If 3D buildings are read, check if building information is consistent
3883!--    to numeric grid.
3884       IF ( buildings_f%from_file )  THEN
3885          IF ( buildings_f%lod == 2 )  THEN
3886             IF ( buildings_f%nz > SIZE( zu ) )  THEN
3887                message_string = 'Reading 3D building data - too much ' //     &
3888                                 'data points along the vertical coordinate.'
3889                CALL message( 'netcdf_data_input_mod', 'PA0552', 2, 2, 0, 6, 0 )
3890             ENDIF
3891
3892             IF ( ANY( ABS( buildings_f%z(0:buildings_f%nz-1) -                &
3893                       zu(0:buildings_f%nz-1) ) > 1E-6_wp ) )  THEN
3894                message_string = 'Reading 3D building data - vertical ' //     &
3895                                 'coordinate do not match numeric grid.'
3896                CALL message( 'netcdf_data_input_mod', 'PA0553', 2, 2, myid, 6, 0 )
3897             ENDIF
3898          ENDIF
3899       ENDIF
3900
3901!
3902!--    Skip further checks concerning buildings and natural surface properties
3903!--    if no urban surface and land surface model are applied.
3904       IF (  .NOT. land_surface  .AND.  .NOT. urban_surface )  RETURN
3905!
3906!--    Check for minimum requirement of surface-classification data in case
3907!--    static input file is used.
3908       IF ( ( .NOT. vegetation_type_f%from_file  .OR.                          &
3909              .NOT. pavement_type_f%from_file    .OR.                          &
3910              .NOT. water_type_f%from_file       .OR.                          &
3911              .NOT. soil_type_f%from_file             ) .OR.                   &
3912             ( urban_surface  .AND.  .NOT. building_type_f%from_file ) )  THEN
3913          message_string = 'Minimum requirement for surface classification ' //&
3914                           'is not fulfilled. At least ' //                    &
3915                           'vegetation_type, pavement_type, ' //               &
3916                           'soil_type and water_type are '//                   &
3917                           'required. If urban-surface model is applied, ' //  &
3918                           'also building_type is required'
3919          CALL message( 'netcdf_data_input_mod', 'PA0554', 1, 2, 0, 6, 0 )
3920       ENDIF
3921!
3922!--    Check for general availability of input variables.
3923!--    If vegetation_type is 0 at any location, vegetation_pars as well as
3924!--    root_area_dens_s are required.
3925       IF ( vegetation_type_f%from_file )  THEN
3926          IF ( ANY( vegetation_type_f%var == 0 ) )  THEN
3927             IF ( .NOT. vegetation_pars_f%from_file )  THEN
3928                message_string = 'If vegetation_type = 0 at any location, ' // &
3929                                 'vegetation_pars is required'
3930                CALL message( 'netcdf_data_input_mod', 'PA0555', 2, 2, -1, 6, 0 )
3931             ENDIF
3932             IF ( .NOT. root_area_density_lsm_f%from_file )  THEN
3933                message_string = 'If vegetation_type = 0 at any location, ' // &
3934                                 'root_area_dens_s is required'
3935                CALL message( 'netcdf_data_input_mod', 'PA0556', 2, 2, myid, 6, 0 )
3936             ENDIF
3937          ENDIF
3938       ENDIF
3939!
3940!--    If soil_type is zero at any location, soil_pars is required.
3941       IF ( soil_type_f%from_file )  THEN
3942          check_passed = .TRUE.
3943          IF ( ALLOCATED( soil_type_f%var_2d ) )  THEN
3944             IF ( ANY( soil_type_f%var_2d == 0 ) )  THEN
3945                IF ( .NOT. soil_pars_f%from_file )  check_passed = .FALSE.
3946             ENDIF
3947          ELSE
3948             IF ( ANY( soil_type_f%var_3d == 0 ) )  THEN
3949                IF ( .NOT. soil_pars_f%from_file )  check_passed = .FALSE.
3950             ENDIF
3951          ENDIF
3952          IF ( .NOT. check_passed )  THEN
3953             message_string = 'If soil_type = 0 at any location, ' //          &
3954                              'soil_pars is required'
3955             CALL message( 'netcdf_data_input_mod', 'PA0557', 2, 2, myid, 6, 0 )
3956          ENDIF
3957       ENDIF
3958!
3959!--    Buildings require a type in case of urban-surface model.
3960       IF ( buildings_f%from_file  .AND.  .NOT. building_type_f%from_file  )  THEN
3961          message_string = 'If buildings are provided, also building_type ' // &
3962                           'is required'
3963          CALL message( 'netcdf_data_input_mod', 'PA0581', 2, 2, myid, 6, 0 )
3964       ENDIF
3965!
3966!--    Buildings require an ID.
3967       IF ( buildings_f%from_file  .AND.  .NOT. building_id_f%from_file  )  THEN
3968          message_string = 'If buildings are provided, also building_id ' //   &
3969                           'is required'
3970          CALL message( 'netcdf_data_input_mod', 'PA0582', 2, 2, myid, 6, 0 )
3971       ENDIF
3972!
3973!--    If building_type is zero at any location, building_pars is required.
3974       IF ( building_type_f%from_file )  THEN
3975          IF ( ANY( building_type_f%var == 0 ) )  THEN
3976             IF ( .NOT. building_pars_f%from_file )  THEN
3977                message_string = 'If building_type = 0 at any location, ' //   &
3978                                 'building_pars is required'
3979                CALL message( 'netcdf_data_input_mod', 'PA0558', 2, 2, myid, 6, 0 )
3980             ENDIF
3981          ENDIF
3982       ENDIF
3983!
3984!--    If building_type is provided, also building_id is needed (due to the
3985!--    filtering algorithm).
3986       IF ( building_type_f%from_file  .AND.  .NOT. building_id_f%from_file )  &
3987       THEN
3988          message_string = 'If building_type is provided, also building_id '// &
3989                           'is required'
3990          CALL message( 'netcdf_data_input_mod', 'PA0519', 2, 2, myid, 6, 0 )
3991       ENDIF       
3992!
3993!--    If albedo_type is zero at any location, albedo_pars is required.
3994       IF ( albedo_type_f%from_file )  THEN
3995          IF ( ANY( albedo_type_f%var == 0 ) )  THEN
3996             IF ( .NOT. albedo_pars_f%from_file )  THEN
3997                message_string = 'If albedo_type = 0 at any location, ' //     &
3998                                 'albedo_pars is required'
3999                CALL message( 'netcdf_data_input_mod', 'PA0559', 2, 2, myid, 6, 0 )
4000             ENDIF
4001          ENDIF
4002       ENDIF
4003!
4004!--    If pavement_type is zero at any location, pavement_pars is required.
4005       IF ( pavement_type_f%from_file )  THEN
4006          IF ( ANY( pavement_type_f%var == 0 ) )  THEN
4007             IF ( .NOT. pavement_pars_f%from_file )  THEN
4008                message_string = 'If pavement_type = 0 at any location, ' //   &
4009                                 'pavement_pars is required'
4010                CALL message( 'netcdf_data_input_mod', 'PA0560', 2, 2, myid, 6, 0 )
4011             ENDIF
4012          ENDIF
4013       ENDIF
4014!
4015!--    If pavement_type is zero at any location, also pavement_subsurface_pars
4016!--    is required.
4017       IF ( pavement_type_f%from_file )  THEN
4018          IF ( ANY( pavement_type_f%var == 0 ) )  THEN
4019             IF ( .NOT. pavement_subsurface_pars_f%from_file )  THEN
4020                message_string = 'If pavement_type = 0 at any location, ' //   &
4021                                 'pavement_subsurface_pars is required'
4022                CALL message( 'netcdf_data_input_mod', 'PA0561', 2, 2, myid, 6, 0 )
4023             ENDIF
4024          ENDIF
4025       ENDIF
4026!
4027!--    If water_type is zero at any location, water_pars is required.
4028       IF ( water_type_f%from_file )  THEN
4029          IF ( ANY( water_type_f%var == 0 ) )  THEN
4030             IF ( .NOT. water_pars_f%from_file )  THEN
4031                message_string = 'If water_type = 0 at any location, ' //      &
4032                                 'water_pars is required'
4033                CALL message( 'netcdf_data_input_mod', 'PA0562', 2, 2,myid, 6, 0 )
4034             ENDIF
4035          ENDIF
4036       ENDIF
4037!
4038!--    Check for local consistency of the input data.
4039       DO  i = nxl, nxr
4040          DO  j = nys, nyn
4041!
4042!--          For each (y,x)-location at least one of the parameters
4043!--          vegetation_type, pavement_type, building_type, or water_type
4044!--          must be set to a non­missing value.
4045             IF ( land_surface  .AND.  .NOT. urban_surface )  THEN
4046                IF ( vegetation_type_f%var(j,i) == vegetation_type_f%fill  .AND.&
4047                     pavement_type_f%var(j,i)   == pavement_type_f%fill    .AND.&
4048                     water_type_f%var(j,i)      == water_type_f%fill )  THEN
4049                   WRITE( message_string, * )                                  &
4050                                    'At least one of the parameters '//        &
4051                                    'vegetation_type, pavement_type, '     //  &
4052                                    'or water_type must be set '//             &
4053                                    'to a non-missing value. Grid point: ', j, i
4054                   CALL message( 'netcdf_data_input_mod', 'PA0563', 2, 2, myid, 6, 0 )
4055                ENDIF
4056             ELSEIF ( land_surface  .AND.  urban_surface )  THEN
4057                IF ( vegetation_type_f%var(j,i) == vegetation_type_f%fill  .AND.&
4058                     pavement_type_f%var(j,i)   == pavement_type_f%fill    .AND.&
4059                     building_type_f%var(j,i)   == building_type_f%fill    .AND.&
4060                     water_type_f%var(j,i)      == water_type_f%fill )  THEN
4061                   WRITE( message_string, * )                                  &
4062                                 'At least one of the parameters '//           &
4063                                 'vegetation_type, pavement_type, '  //        &
4064                                 'building_type, or water_type must be set '// &
4065                                 'to a non-missing value. Grid point: ', j, i
4066                   CALL message( 'netcdf_data_input_mod', 'PA0563', 2, 2, myid, 6, 0 )
4067                ENDIF
4068             ENDIF
4069               
4070!
4071!--          Note that a soil_type is required for each location (y,x) where
4072!--          either vegetation_type or pavement_type is a non­missing value.
4073             IF ( ( vegetation_type_f%var(j,i) /= vegetation_type_f%fill  .OR. &
4074                    pavement_type_f%var(j,i)   /= pavement_type_f%fill ) )  THEN
4075                check_passed = .TRUE.
4076                IF ( ALLOCATED( soil_type_f%var_2d ) )  THEN
4077                   IF ( soil_type_f%var_2d(j,i) == soil_type_f%fill )          &
4078                      check_passed = .FALSE.
4079                ELSE
4080                   IF ( ANY( soil_type_f%var_3d(:,j,i) == soil_type_f%fill) )  &
4081                      check_passed = .FALSE.
4082                ENDIF
4083
4084                IF ( .NOT. check_passed )  THEN
4085                   message_string = 'soil_type is required for each '//        &
4086                                 'location (y,x) where vegetation_type or ' // &
4087                                 'pavement_type is a non-missing value.'
4088                   CALL message( 'netcdf_data_input_mod', 'PA0564',            &
4089                                  2, 2, myid, 6, 0 )
4090                ENDIF
4091             ENDIF
4092!
4093!--          Check for consistency of surface fraction. If more than one type
4094!--          is set, surface fraction need to be given and the sum must not
4095!--          be larger than 1.
4096             n_surf = 0
4097             IF ( vegetation_type_f%var(j,i) /= vegetation_type_f%fill )       &
4098                n_surf = n_surf + 1
4099             IF ( water_type_f%var(j,i)      /= water_type_f%fill )            &
4100                n_surf = n_surf + 1
4101             IF ( pavement_type_f%var(j,i)   /= pavement_type_f%fill )         &
4102                n_surf = n_surf + 1
4103
4104             IF ( n_surf > 1 )  THEN
4105                IF ( .NOT. surface_fraction_f%from_file )  THEN
4106                   message_string = 'If more than one surface type is ' //     &
4107                                 'given at a location, surface_fraction ' //   &
4108                                 'must be provided.'
4109                   CALL message( 'netcdf_data_input_mod', 'PA0565',            &
4110                                  2, 2, myid, 6, 0 )
4111                ELSEIF ( ANY ( surface_fraction_f%frac(:,j,i) ==               &
4112                               surface_fraction_f%fill ) )  THEN
4113                   message_string = 'If more than one surface type is ' //     &
4114                                 'given at a location, surface_fraction ' //   &
4115                                 'must be provided.'
4116                   CALL message( 'netcdf_data_input_mod', 'PA0565',            &
4117                                  2, 2, myid, 6, 0 )
4118                ENDIF
4119             ENDIF
4120!
4121!--          Check for further mismatches. e.g. relative fractions exceed 1 or
4122!--          vegetation_type is set but surface vegetation fraction is zero,
4123!--          etc..
4124             IF ( surface_fraction_f%from_file )  THEN
4125!
4126!--             Sum of relative fractions must not exceed 1.
4127                IF ( SUM ( surface_fraction_f%frac(0:2,j,i) ) > 1.0_wp )  THEN
4128                   message_string = 'surface_fraction must not exceed 1'
4129                   CALL message( 'netcdf_data_input_mod', 'PA0566',            &
4130                                  2, 2, myid, 6, 0 )
4131                ENDIF
4132!
4133!--             Relative fraction for a type must not be zero at locations where
4134!--             this type is set.
4135                IF (                                                           &
4136                  ( vegetation_type_f%var(j,i) /= vegetation_type_f%fill  .AND.&
4137                 ( surface_fraction_f%frac(ind_veg_wall,j,i) == 0.0_wp .OR.    &
4138                   surface_fraction_f%frac(ind_veg_wall,j,i) ==                &
4139                                                     surface_fraction_f%fill ) &
4140                  )  .OR.                                                      &
4141                  ( pavement_type_f%var(j,i) /= pavement_type_f%fill     .AND. &
4142                 ( surface_fraction_f%frac(ind_pav_green,j,i) == 0.0_wp .OR.   &
4143                   surface_fraction_f%frac(ind_pav_green,j,i) ==               &
4144                                                     surface_fraction_f%fill ) &
4145                  )  .OR.                                                      &
4146                  ( water_type_f%var(j,i) /= water_type_f%fill           .AND. &
4147                 ( surface_fraction_f%frac(ind_wat_win,j,i) == 0.0_wp .OR.     &
4148                   surface_fraction_f%frac(ind_wat_win,j,i) ==                 &
4149                                                     surface_fraction_f%fill ) &
4150                  ) )  THEN
4151                   WRITE( message_string, * ) 'Mismatch in setting of '     // &
4152                             'surface_fraction. Vegetation-, pavement-, or '// &
4153                             'water surface is given at (i,j) = ( ', i, j,     &
4154                             ' ), but surface fraction is 0 for the given type.'
4155                   CALL message( 'netcdf_data_input_mod', 'PA0567',            &
4156                                  2, 2, myid, 6, 0 )
4157                ENDIF
4158!
4159!--             Relative fraction for a type must not contain non-zero values
4160!--             if this type is not set.
4161                IF (                                                           &
4162                  ( vegetation_type_f%var(j,i) == vegetation_type_f%fill  .AND.&
4163                 ( surface_fraction_f%frac(ind_veg_wall,j,i) /= 0.0_wp .AND.   &
4164                   surface_fraction_f%frac(ind_veg_wall,j,i) /=                &
4165                                                     surface_fraction_f%fill ) &
4166                  )  .OR.                                                      &
4167                  ( pavement_type_f%var(j,i) == pavement_type_f%fill     .AND. &
4168                 ( surface_fraction_f%frac(ind_pav_green,j,i) /= 0.0_wp .AND.  &
4169                   surface_fraction_f%frac(ind_pav_green,j,i) /=               &
4170                                                     surface_fraction_f%fill ) &
4171                  )  .OR.                                                      &
4172                  ( water_type_f%var(j,i) == water_type_f%fill           .AND. &
4173                 ( surface_fraction_f%frac(ind_wat_win,j,i) /= 0.0_wp .AND.    &
4174                   surface_fraction_f%frac(ind_wat_win,j,i) /=                 &
4175                                                     surface_fraction_f%fill ) &
4176                  ) )  THEN
4177                   WRITE( message_string, * ) 'Mismatch in setting of '     // &
4178                             'surface_fraction. Vegetation-, pavement-, or '// &
4179                             'water surface is not given at (i,j) = ( ', i, j, &
4180                             ' ), but surface fraction is not 0 for the ' //   &
4181                             'given type.'
4182                   CALL message( 'netcdf_data_input_mod', 'PA0568',            &
4183                                  2, 2, myid, 6, 0 )
4184                ENDIF
4185             ENDIF
4186!
4187!--          Check vegetation_pars. If vegetation_type is 0, all parameters
4188!--          need to be set, otherwise, single parameters set by
4189!--          vegetation_type can be overwritten.
4190             IF ( vegetation_type_f%from_file )  THEN
4191                IF ( vegetation_type_f%var(j,i) == 0 )  THEN
4192                   IF ( ANY( vegetation_pars_f%pars_xy(:,j,i) ==               &
4193                             vegetation_pars_f%fill ) )  THEN
4194                      message_string = 'If vegetation_type(y,x) = 0, all '  // &
4195                                       'parameters of vegetation_pars at '//   &
4196                                       'this location must be set.'
4197                      CALL message( 'netcdf_data_input_mod', 'PA0569',         &
4198                                     2, 2, myid, 6, 0 )
4199                   ENDIF
4200                ENDIF
4201             ENDIF
4202!
4203!--          Check root distribution. If vegetation_type is 0, all levels must
4204!--          be set.
4205             IF ( vegetation_type_f%from_file )  THEN
4206                IF ( vegetation_type_f%var(j,i) == 0 )  THEN
4207                   IF ( ANY( root_area_density_lsm_f%var(:,j,i) ==             &
4208                             root_area_density_lsm_f%fill ) )  THEN
4209                      message_string = 'If vegetation_type(y,x) = 0, all ' //  &
4210                                       'levels of root_area_dens_s ' //        &
4211                                       'must be set at this location.'
4212                      CALL message( 'netcdf_data_input_mod', 'PA0570',         &
4213                                     2, 2, myid, 6, 0 )
4214                   ENDIF
4215                ENDIF
4216             ENDIF
4217!
4218!--          Check soil parameters. If soil_type is 0, all parameters
4219!--          must be set.
4220             IF ( soil_type_f%from_file )  THEN
4221                check_passed = .TRUE.
4222                IF ( ALLOCATED( soil_type_f%var_2d ) )  THEN
4223                   IF ( soil_type_f%var_2d(j,i) == 0 )  THEN
4224                      IF ( ANY( soil_pars_f%pars_xy(:,j,i) ==                  &
4225                                soil_pars_f%fill ) )  check_passed = .FALSE.
4226                   ENDIF
4227                ELSE
4228                   IF ( ANY( soil_type_f%var_3d(:,j,i) == 0 ) )  THEN
4229                      IF ( ANY( soil_pars_f%pars_xy(:,j,i) ==                  &
4230                                soil_pars_f%fill ) )  check_passed = .FALSE.
4231                   ENDIF
4232                ENDIF
4233                IF ( .NOT. check_passed )  THEN
4234                   message_string = 'If soil_type(y,x) = 0, all levels of '  //&
4235                                    'soil_pars at this location must be set.'
4236                   CALL message( 'netcdf_data_input_mod', 'PA0571',            &
4237                                  2, 2, myid, 6, 0 )
4238                ENDIF
4239             ENDIF
4240
4241!
4242!--          Check building parameters. If building_type is 0, all parameters
4243!--          must be set.
4244             IF ( building_type_f%from_file )  THEN
4245                IF ( building_type_f%var(j,i) == 0 )  THEN
4246                   IF ( ANY( building_pars_f%pars_xy(:,j,i) ==                 &
4247                             building_pars_f%fill ) )  THEN
4248                      message_string = 'If building_type(y,x) = 0, all ' //    &
4249                                       'parameters of building_pars at this '//&
4250                                       'location must be set.'
4251                      CALL message( 'netcdf_data_input_mod', 'PA0572',         &
4252                                     2, 2, myid, 6, 0 )
4253                   ENDIF
4254                ENDIF
4255             ENDIF
4256!
4257!--          Check if building_type is set at each building and vice versa.
4258             IF ( building_type_f%from_file  .AND.  buildings_f%from_file )  THEN
4259                IF ( buildings_f%lod == 1 )  THEN
4260                   IF ( buildings_f%var_2d(j,i)  /= buildings_f%fill1  .AND.   &
4261                        building_type_f%var(j,i) == building_type_f%fill  .OR. &
4262                        buildings_f%var_2d(j,i)  == buildings_f%fill1  .AND.   &
4263                        building_type_f%var(j,i) /= building_type_f%fill )  THEN
4264                      WRITE( message_string, * ) 'Each location where a ' //   &
4265                                      '2D building is set requires a type ' // &
4266                                      '( and vice versa ) in case the ' //     &
4267                                      'urban-surface model is applied. ' //    &
4268                                      'i, j = ', i, j
4269                      CALL message( 'netcdf_data_input_mod', 'PA0573',         &
4270                                     2, 2, myid, 6, 0 )
4271                   ENDIF
4272                ENDIF
4273                IF ( buildings_f%lod == 2 )  THEN
4274                   IF ( ANY( buildings_f%var_3d(:,j,i) == 1 )  .AND.           &
4275                        building_type_f%var(j,i) == building_type_f%fill  .OR. &
4276                  .NOT. ANY( buildings_f%var_3d(:,j,i) == 1 )  .AND.           &
4277                        building_type_f%var(j,i) /= building_type_f%fill )  THEN
4278                      WRITE( message_string, * ) 'Each location where a ' //   &
4279                                      '3D building is set requires a type ' // &
4280                                      '( and vice versa ) in case the ' //     &
4281                                      'urban-surface model is applied. ' //    &
4282                                      'i, j = ', i, j
4283                      CALL message( 'netcdf_data_input_mod', 'PA0573',         &
4284                                     2, 2, myid, 6, 0 )
4285                   ENDIF
4286                ENDIF
4287             ENDIF
4288!
4289!--          Check if at each location where a building is present also an ID
4290!--          is set and vice versa.
4291             IF ( buildings_f%from_file )  THEN
4292                IF ( buildings_f%lod == 1 )  THEN
4293                   IF ( buildings_f%var_2d(j,i) /= buildings_f%fill1  .AND.    &
4294                        building_id_f%var(j,i)  == building_id_f%fill  .OR.    &
4295                        buildings_f%var_2d(j,i) == buildings_f%fill1  .AND.    &
4296                        building_id_f%var(j,i)  /= building_id_f%fill )  THEN
4297                      WRITE( message_string, * ) 'Each location where a ' //   &
4298                                      '2D building is set requires an ID ' //  &
4299                                      '( and vice versa ). i, j = ', i, j
4300                      CALL message( 'netcdf_data_input_mod', 'PA0574',         &
4301                                     2, 2, myid, 6, 0 )
4302                   ENDIF
4303                ELSEIF ( buildings_f%lod == 2 )  THEN
4304                   IF ( ANY( buildings_f%var_3d(:,j,i) == 1 )  .AND.           &
4305                        building_id_f%var(j,i) == building_id_f%fill  .OR.     &
4306                  .NOT. ANY( buildings_f%var_3d(:,j,i) == 1 )  .AND.           &
4307                        building_id_f%var(j,i) /= building_id_f%fill )  THEN
4308                      WRITE( message_string, * ) 'Each location where a ' //   &
4309                                      '3D building is set requires an ID ' //  &
4310                                      '( and vice versa ). i, j = ', i, j
4311                      CALL message( 'netcdf_data_input_mod', 'PA0574',         &
4312                                     2, 2, myid, 6, 0 )
4313                   ENDIF
4314                ENDIF
4315             ENDIF
4316!
4317!--          Check if building ID is set where a bulding is defined.
4318             IF ( buildings_f%from_file )  THEN
4319                IF ( buildings_f%lod == 1 )  THEN
4320                   IF ( buildings_f%var_2d(j,i) /= buildings_f%fill1  .AND.   &
4321                        building_id_f%var(j,i)  == building_id_f%fill )  THEN
4322                      WRITE( message_string, * ) 'Each building grid point '// &
4323                                                 'requires an ID.', i, j
4324                      CALL message( 'netcdf_data_input_mod', 'PA0575',         &
4325                                     2, 2, myid, 6, 0 )
4326                   ENDIF
4327                ELSEIF ( buildings_f%lod == 2 )  THEN
4328                   IF ( ANY( buildings_f%var_3d(:,j,i) == 1 )  .AND.           &
4329                        building_id_f%var(j,i) == building_id_f%fill )  THEN
4330                      WRITE( message_string, * ) 'Each building grid point '// &
4331                                                 'requires an ID.', i, j
4332                      CALL message( 'netcdf_data_input_mod', 'PA0575',         &
4333                                     2, 2, myid, 6, 0 )
4334                   ENDIF
4335                ENDIF
4336             ENDIF
4337!
4338!--          Check albedo parameters. If albedo_type is 0, all parameters
4339!--          must be set.
4340             IF ( albedo_type_f%from_file )  THEN
4341                IF ( albedo_type_f%var(j,i) == 0 )  THEN
4342                   IF ( ANY( albedo_pars_f%pars_xy(:,j,i) ==                   &
4343                             albedo_pars_f%fill ) )  THEN
4344                      message_string = 'If albedo_type(y,x) = 0, all ' //      &
4345                                       'parameters of albedo_pars at this ' // &
4346                                       'location must be set.'
4347                      CALL message( 'netcdf_data_input_mod', 'PA0576',         &
4348                                     2, 2, myid, 6, 0 )
4349                   ENDIF
4350                ENDIF
4351             ENDIF
4352
4353!
4354!--          Check pavement parameters. If pavement_type is 0, all parameters
4355!--          of pavement_pars must be set at this location.
4356             IF ( pavement_type_f%from_file )  THEN
4357                IF ( pavement_type_f%var(j,i) == 0 )  THEN
4358                   IF ( ANY( pavement_pars_f%pars_xy(:,j,i) ==                 &
4359                             pavement_pars_f%fill ) )  THEN
4360                      message_string = 'If pavement_type(y,x) = 0, all ' //    &
4361                                       'parameters of pavement_pars at this '//&
4362                                       'location must be set.'
4363                      CALL message( 'netcdf_data_input_mod', 'PA0577',         &
4364                                     2, 2, myid, 6, 0 )
4365                   ENDIF
4366                ENDIF
4367             ENDIF
4368!
4369!--          Check pavement-subsurface parameters. If pavement_type is 0,
4370!--          all parameters of pavement_subsurface_pars must be set  at this
4371!--          location.
4372             IF ( pavement_type_f%from_file )  THEN
4373                IF ( pavement_type_f%var(j,i) == 0 )  THEN
4374                   IF ( ANY( pavement_subsurface_pars_f%pars_xyz(:,:,j,i) ==   &
4375                             pavement_subsurface_pars_f%fill ) )  THEN
4376                      message_string = 'If pavement_type(y,x) = 0, all ' //    &
4377                                       'parameters of '                  //    &
4378                                       'pavement_subsurface_pars at this '//   &
4379                                       'location must be set.'
4380                      CALL message( 'netcdf_data_input_mod', 'PA0578',         &
4381                                     2, 2, myid, 6, 0 )
4382                   ENDIF
4383                ENDIF
4384             ENDIF
4385
4386!
4387!--          Check water parameters. If water_type is 0, all parameters
4388!--          must be set  at this location.
4389             IF ( water_type_f%from_file )  THEN
4390                IF ( water_type_f%var(j,i) == 0 )  THEN
4391                   IF ( ANY( water_pars_f%pars_xy(:,j,i) ==                    &
4392                             water_pars_f%fill ) )  THEN
4393                      message_string = 'If water_type(y,x) = 0, all ' //       &
4394                                       'parameters of water_pars at this ' //  &
4395                                       'location must be set.'
4396                      CALL message( 'netcdf_data_input_mod', 'PA0579',         &
4397                                     2, 2, myid, 6, 0 )
4398                   ENDIF
4399                ENDIF
4400             ENDIF
4401
4402          ENDDO
4403       ENDDO
4404
4405    END SUBROUTINE netcdf_data_input_check_static
4406
4407!------------------------------------------------------------------------------!
4408! Description:
4409! ------------
4410!> Resize 8-bit 2D Integer array: (nys:nyn,nxl:nxr) -> (nysg:nyng,nxlg:nxrg)
4411!------------------------------------------------------------------------------!
4412    SUBROUTINE resize_array_2d_int8( var, js, je, is, ie )
4413   
4414       IMPLICIT NONE
4415
4416       INTEGER(iwp) ::  je !< upper index bound along y direction
4417       INTEGER(iwp) ::  js !< lower index bound along y direction
4418       INTEGER(iwp) ::  ie !< upper index bound along x direction
4419       INTEGER(iwp) ::  is !< lower index bound along x direction
4420       
4421       INTEGER(KIND=1), DIMENSION(:,:), ALLOCATABLE ::  var     !< treated variable
4422       INTEGER(KIND=1), DIMENSION(:,:), ALLOCATABLE ::  var_tmp !< temporary copy
4423!
4424!--    Allocate temporary variable
4425       ALLOCATE( var_tmp(js-nbgp:je+nbgp,is-nbgp:ie+nbgp) )
4426!
4427!--    Temporary copy of the variable
4428       var_tmp(js:je,is:ie) = var(js:je,is:ie)
4429!
4430!--    Resize the array
4431       DEALLOCATE( var )
4432       ALLOCATE( var(js-nbgp:je+nbgp,is-nbgp:ie+nbgp) )
4433!
4434!--    Transfer temporary copy back to original array
4435       var(js:je,is:ie) = var_tmp(js:je,is:ie)
4436
4437    END SUBROUTINE resize_array_2d_int8
4438   
4439!------------------------------------------------------------------------------!
4440! Description:
4441! ------------
4442!> Resize 32-bit 2D Integer array: (nys:nyn,nxl:nxr) -> (nysg:nyng,nxlg:nxrg)
4443!------------------------------------------------------------------------------!
4444    SUBROUTINE resize_array_2d_int32( var, js, je, is, ie )
4445
4446       IMPLICIT NONE
4447       
4448       INTEGER(iwp) ::  je !< upper index bound along y direction
4449       INTEGER(iwp) ::  js !< lower index bound along y direction
4450       INTEGER(iwp) ::  ie !< upper index bound along x direction
4451       INTEGER(iwp) ::  is !< lower index bound along x direction
4452
4453       INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  var     !< treated variable
4454       INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  var_tmp !< temporary copy
4455!
4456!--    Allocate temporary variable
4457       ALLOCATE( var_tmp(js-nbgp:je+nbgp,is-nbgp:ie+nbgp) )
4458!
4459!--    Temporary copy of the variable
4460       var_tmp(js:je,is:ie) = var(js:je,is:ie)
4461!
4462!--    Resize the array
4463       DEALLOCATE( var )
4464       ALLOCATE( var(js-nbgp:je+nbgp,is-nbgp:ie+nbgp) )
4465!
4466!--    Transfer temporary copy back to original array
4467       var(js:je,is:ie) = var_tmp(js:je,is:ie)
4468
4469    END SUBROUTINE resize_array_2d_int32
4470   
4471!------------------------------------------------------------------------------!
4472! Description:
4473! ------------
4474!> Resize 8-bit 3D Integer array: (:,nys:nyn,nxl:nxr) -> (:,nysg:nyng,nxlg:nxrg)
4475!------------------------------------------------------------------------------!
4476    SUBROUTINE resize_array_3d_int8( var, ks, ke, js, je, is, ie )
4477
4478       IMPLICIT NONE
4479
4480       INTEGER(iwp) ::  je !< upper index bound along y direction
4481       INTEGER(iwp) ::  js !< lower index bound along y direction
4482       INTEGER(iwp) ::  ie !< upper index bound along x direction
4483       INTEGER(iwp) ::  is !< lower index bound along x direction
4484       INTEGER(iwp) ::  ke !< upper bound of treated array in z-direction 
4485       INTEGER(iwp) ::  ks !< lower bound of treated array in z-direction 
4486       
4487       INTEGER(KIND=1), DIMENSION(:,:,:), ALLOCATABLE ::  var     !< treated variable
4488       INTEGER(KIND=1), DIMENSION(:,:,:), ALLOCATABLE ::  var_tmp !< temporary copy
4489!
4490!--    Allocate temporary variable
4491       ALLOCATE( var_tmp(ks:ke,js-nbgp:je+nbgp,is-nbgp:ie+nbgp) )
4492!
4493!--    Temporary copy of the variable
4494       var_tmp(ks:ke,js:je,is:ie) = var(ks:ke,js:je,is:ie)
4495!
4496!--    Resize the array
4497       DEALLOCATE( var )
4498       ALLOCATE( var(ks:ke,js-nbgp:je+nbgp,is-nbgp:ie+nbgp) )
4499!
4500!--    Transfer temporary copy back to original array
4501       var(ks:ke,js:je,is:ie) = var_tmp(ks:ke,js:je,is:ie)
4502
4503    END SUBROUTINE resize_array_3d_int8
4504   
4505!------------------------------------------------------------------------------!
4506! Description:
4507! ------------
4508!> Resize 3D Real array: (:,nys:nyn,nxl:nxr) -> (:,nysg:nyng,nxlg:nxrg)
4509!------------------------------------------------------------------------------!
4510    SUBROUTINE resize_array_3d_real( var, ks, ke, js, je, is, ie )
4511
4512       IMPLICIT NONE
4513
4514       INTEGER(iwp) ::  je !< upper index bound along y direction
4515       INTEGER(iwp) ::  js !< lower index bound along y direction
4516       INTEGER(iwp) ::  ie !< upper index bound along x direction
4517       INTEGER(iwp) ::  is !< lower index bound along x direction
4518       INTEGER(iwp) ::  ke !< upper bound of treated array in z-direction 
4519       INTEGER(iwp) ::  ks !< lower bound of treated array in z-direction 
4520       
4521       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  var     !< treated variable
4522       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  var_tmp !< temporary copy
4523!
4524!--    Allocate temporary variable
4525       ALLOCATE( var_tmp(ks:ke,js-nbgp:je+nbgp,is-nbgp:ie+nbgp) )
4526!
4527!--    Temporary copy of the variable
4528       var_tmp(ks:ke,js:je,is:ie) = var(ks:ke,js:je,is:ie)
4529!
4530!--    Resize the array
4531       DEALLOCATE( var )
4532       ALLOCATE( var(ks:ke,js-nbgp:je+nbgp,is-nbgp:ie+nbgp) )
4533!
4534!--    Transfer temporary copy back to original array
4535       var(ks:ke,js:je,is:ie) = var_tmp(ks:ke,js:je,is:ie)
4536
4537    END SUBROUTINE resize_array_3d_real
4538   
4539!------------------------------------------------------------------------------!
4540! Description:
4541! ------------
4542!> Resize 4D Real array: (:,:,nys:nyn,nxl:nxr) -> (:,nysg:nyng,nxlg:nxrg)
4543!------------------------------------------------------------------------------!
4544    SUBROUTINE resize_array_4d_real( var, k1s, k1e, k2s, k2e, js, je, is, ie )
4545
4546       IMPLICIT NONE
4547       
4548       INTEGER(iwp) ::  je  !< upper index bound along y direction
4549       INTEGER(iwp) ::  js  !< lower index bound along y direction
4550       INTEGER(iwp) ::  ie  !< upper index bound along x direction
4551       INTEGER(iwp) ::  is  !< lower index bound along x direction
4552       INTEGER(iwp) ::  k1e !< upper bound of treated array in z-direction 
4553       INTEGER(iwp) ::  k1s !< lower bound of treated array in z-direction
4554       INTEGER(iwp) ::  k2e !< upper bound of treated array along parameter space 
4555       INTEGER(iwp) ::  k2s !< lower bound of treated array along parameter space 
4556       
4557       REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE ::  var     !< treated variable
4558       REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE ::  var_tmp !< temporary copy
4559!
4560!--    Allocate temporary variable
4561       ALLOCATE( var_tmp(k1s:k1e,k2s:k2e,js-nbgp:je+nbgp,is-nbgp:ie+nbgp) )
4562!
4563!--    Temporary copy of the variable
4564       var_tmp(k1s:k1e,k2s:k2e,js:je,is:ie) = var(k1s:k1e,k2s:k2e,js:je,is:ie)
4565!
4566!--    Resize the array
4567       DEALLOCATE( var )
4568       ALLOCATE( var(k1s:k1e,k2s:k2e,js-nbgp:je+nbgp,is-nbgp:ie+nbgp) )
4569!
4570!--    Transfer temporary copy back to original array
4571       var(k1s:k1e,k2s:k2e,js:je,is:ie) = var_tmp(k1s:k1e,k2s:k2e,js:je,is:ie)
4572
4573    END SUBROUTINE resize_array_4d_real
4574   
4575!------------------------------------------------------------------------------!
4576! Description:
4577! ------------
4578!> Vertical interpolation and extrapolation of 1D variables.
4579!------------------------------------------------------------------------------!
4580    SUBROUTINE netcdf_data_input_interpolate_1d( var, z_grid, z_file)
4581
4582       IMPLICIT NONE
4583
4584       INTEGER(iwp) ::  k       !< running index z-direction file
4585       INTEGER(iwp) ::  kk      !< running index z-direction stretched model grid
4586       INTEGER(iwp) ::  kl      !< lower index bound along z-direction
4587       INTEGER(iwp) ::  ku      !< upper index bound along z-direction
4588
4589       REAL(wp), DIMENSION(:) ::  z_grid                  !< grid levels on numeric grid
4590       REAL(wp), DIMENSION(:) ::  z_file                  !< grid levels on file grid
4591       REAL(wp), DIMENSION(:), INTENT(INOUT) ::  var      !< treated variable
4592       REAL(wp), DIMENSION(:), ALLOCATABLE   ::  var_tmp  !< temporary variable
4593
4594
4595       kl = LBOUND(var,1)
4596       ku = UBOUND(var,1)
4597       ALLOCATE( var_tmp(kl:ku) )
4598
4599       DO  k = kl, ku
4600
4601          kk = MINLOC( ABS( z_file - z_grid(k) ), DIM = 1 )
4602
4603          IF ( kk < ku )  THEN
4604             IF ( z_file(kk) - z_grid(k) <= 0.0_wp )  THEN
4605                var_tmp(k) = var(kk) +                                         &
4606                                       ( var(kk+1)        - var(kk)    ) /     &
4607                                       ( z_file(kk+1)     - z_file(kk) ) *     &
4608                                       ( z_grid(k)        - z_file(kk) )
4609
4610             ELSEIF ( z_file(kk) - z_grid(k) > 0.0_wp )  THEN
4611                var_tmp(k) = var(kk-1) +                                       &
4612                                         ( var(kk)     - var(kk-1)    ) /      &
4613                                         ( z_file(kk)  - z_file(kk-1) ) *      &
4614                                         ( z_grid(k)   - z_file(kk-1) )
4615             ENDIF
4616!
4617!--       Extrapolate
4618          ELSE
4619
4620             var_tmp(k) = var(ku) +   ( var(ku)    - var(ku-1)      ) /        &
4621                                      ( z_file(ku) - z_file(ku-1)   ) *        &
4622                                      ( z_grid(k)  - z_file(ku)     )
4623
4624          ENDIF
4625
4626       ENDDO
4627       var(:) = var_tmp(:)
4628
4629       DEALLOCATE( var_tmp )
4630
4631
4632    END SUBROUTINE netcdf_data_input_interpolate_1d
4633
4634
4635!------------------------------------------------------------------------------!
4636! Description:
4637! ------------
4638!> Vertical interpolation and extrapolation of 1D variables from Inifor grid
4639!> onto Palm grid, where both have same dimension. Please note, the passed
4640!> paramter list in 1D version is different compared to 2D version.
4641!------------------------------------------------------------------------------!
4642    SUBROUTINE netcdf_data_input_interpolate_1d_soil( var, var_file,           &
4643                                                      z_grid, z_file,          &
4644                                                      nzb_var, nzt_var,        &
4645                                                      nzb_file, nzt_file )
4646
4647       IMPLICIT NONE
4648
4649       INTEGER(iwp) ::  k        !< running index z-direction file
4650       INTEGER(iwp) ::  kk       !< running index z-direction stretched model grid
4651       INTEGER(iwp) ::  ku       !< upper index bound along z-direction for varialbe from file
4652       INTEGER(iwp) ::  nzb_var  !< lower bound of final array
4653       INTEGER(iwp) ::  nzt_var  !< upper bound of final array
4654       INTEGER(iwp) ::  nzb_file !< lower bound of file array
4655       INTEGER(iwp) ::  nzt_file !< upper bound of file array
4656
4657!        LOGICAL, OPTIONAL ::  zsoil !< flag indicating reverse z-axis, i.e. zsoil instead of height, e.g. in case of ocean or soil
4658
4659       REAL(wp), DIMENSION(nzb_var:nzt_var)   ::  z_grid   !< grid levels on numeric grid
4660       REAL(wp), DIMENSION(nzb_file:nzt_file) ::  z_file   !< grid levels on file grid
4661       REAL(wp), DIMENSION(nzb_var:nzt_var)   ::  var      !< treated variable
4662       REAL(wp), DIMENSION(nzb_file:nzt_file) ::  var_file !< temporary variable
4663
4664       ku = nzt_file
4665
4666       DO  k = nzb_var, nzt_var
4667!
4668!--       Determine index on Inifor grid which is closest to the actual height
4669          kk = MINLOC( ABS( z_file - z_grid(k) ), DIM = 1 )
4670!
4671!--       If closest index on Inifor grid is smaller than top index,
4672!--       interpolate the data
4673          IF ( kk < nzt_file )  THEN
4674             IF ( z_file(kk) - z_grid(k) <= 0.0_wp )  THEN
4675                var(k) = var_file(kk) + ( var_file(kk+1) - var_file(kk) ) /    &
4676                                        ( z_file(kk+1)   - z_file(kk)   ) *    &
4677                                        ( z_grid(k)      - z_file(kk)   )
4678
4679             ELSEIF ( z_file(kk) - z_grid(k) > 0.0_wp )  THEN
4680                var(k) = var_file(kk-1) + ( var_file(kk) - var_file(kk-1) ) /  &
4681                                          ( z_file(kk)   - z_file(kk-1)   ) *  &
4682                                          ( z_grid(k)    - z_file(kk-1)   )
4683             ENDIF
4684!
4685!--       Extrapolate if actual height is above the highest Inifor level
4686          ELSE
4687             var(k) = var_file(ku) + ( var_file(ku) - var_file(ku-1) ) /       &
4688                                     ( z_file(ku)   - z_file(ku-1)   ) *       &
4689                                     ( z_grid(k)    - z_file(ku)     )
4690
4691          ENDIF
4692
4693       ENDDO
4694
4695    END SUBROUTINE netcdf_data_input_interpolate_1d_soil
4696
4697!------------------------------------------------------------------------------!
4698! Description:
4699! ------------
4700!> Vertical interpolation and extrapolation of 2D variables at lateral boundaries.
4701!------------------------------------------------------------------------------!
4702    SUBROUTINE netcdf_data_input_interpolate_2d( var, z_grid, z_file)
4703
4704       IMPLICIT NONE
4705
4706       INTEGER(iwp) ::  i       !< running index x- or y -direction
4707       INTEGER(iwp) ::  il      !< lower index bound along x- or y-direction
4708       INTEGER(iwp) ::  iu      !< upper index bound along x- or y-direction
4709       INTEGER(iwp) ::  k       !< running index z-direction file
4710       INTEGER(iwp) ::  kk      !< running index z-direction stretched model grid
4711       INTEGER(iwp) ::  kl      !< lower index bound along z-direction
4712       INTEGER(iwp) ::  ku      !< upper index bound along z-direction
4713
4714       REAL(wp), DIMENSION(:) ::  z_grid                  !< grid levels on numeric grid
4715       REAL(wp), DIMENSION(:) ::  z_file                  !< grid levels on file grid
4716       REAL(wp), DIMENSION(:,:), INTENT(INOUT) ::  var    !< treated variable
4717       REAL(wp), DIMENSION(:), ALLOCATABLE   ::  var_tmp  !< temporary variable
4718
4719
4720       il = LBOUND(var,2)
4721       iu = UBOUND(var,2)
4722       kl = LBOUND(var,1)
4723       ku = UBOUND(var,1)
4724       ALLOCATE( var_tmp(kl:ku) )
4725
4726       DO  i = il, iu
4727          DO  k = kl, ku
4728
4729             kk = MINLOC( ABS( z_file - z_grid(k) ), DIM = 1 )
4730
4731             IF ( kk < ku )  THEN
4732                IF ( z_file(kk) - z_grid(k) <= 0.0_wp )  THEN
4733                   var_tmp(k) = var(kk,i) +                                    &
4734                                          ( var(kk+1,i)      - var(kk,i)  ) /  &
4735                                          ( z_file(kk+1)     - z_file(kk) ) *  &
4736                                          ( z_grid(k)        - z_file(kk) )
4737
4738                ELSEIF ( z_file(kk) - z_grid(k) > 0.0_wp )  THEN
4739                   var_tmp(k) = var(kk-1,i) +                                  &
4740                                            ( var(kk,i)   - var(kk-1,i)  ) /   &
4741                                            ( z_file(kk)  - z_file(kk-1) ) *   &
4742                                            ( z_grid(k)   - z_file(kk-1) )
4743                ENDIF
4744!
4745!--          Extrapolate
4746             ELSE
4747
4748                var_tmp(k) = var(ku,i) + ( var(ku,i)  - var(ku-1,i)    ) /     &
4749                                         ( z_file(ku) - z_file(ku-1)   ) *     &
4750                                         ( z_grid(k)  - z_file(ku)     )
4751
4752             ENDIF
4753
4754          ENDDO
4755          var(:,i) = var_tmp(:)
4756
4757       ENDDO
4758
4759       DEALLOCATE( var_tmp )
4760
4761
4762    END SUBROUTINE netcdf_data_input_interpolate_2d
4763
4764!------------------------------------------------------------------------------!
4765! Description:
4766! ------------
4767!> Vertical interpolation and extrapolation of 3D variables.
4768!------------------------------------------------------------------------------!
4769    SUBROUTINE netcdf_data_input_interpolate_3d( var, z_grid, z_file )
4770
4771       IMPLICIT NONE
4772
4773       INTEGER(iwp) ::  i       !< running index x-direction
4774       INTEGER(iwp) ::  il      !< lower index bound along x-direction
4775       INTEGER(iwp) ::  iu      !< upper index bound along x-direction
4776       INTEGER(iwp) ::  j       !< running index y-direction
4777       INTEGER(iwp) ::  jl      !< lower index bound along x-direction
4778       INTEGER(iwp) ::  ju      !< upper index bound along x-direction
4779       INTEGER(iwp) ::  k       !< running index z-direction file
4780       INTEGER(iwp) ::  kk      !< running index z-direction stretched model grid
4781       INTEGER(iwp) ::  kl      !< lower index bound along z-direction
4782       INTEGER(iwp) ::  ku      !< upper index bound along z-direction
4783
4784       REAL(wp), DIMENSION(:) ::  z_grid                      !< grid levels on numeric grid
4785       REAL(wp), DIMENSION(:) ::  z_file                      !< grid levels on file grid
4786       REAL(wp), DIMENSION(:,:,:), INTENT(INOUT) ::  var      !< treated variable
4787       REAL(wp), DIMENSION(:), ALLOCATABLE       ::  var_tmp  !< temporary variable
4788
4789       il = LBOUND(var,3)
4790       iu = UBOUND(var,3)
4791       jl = LBOUND(var,2)
4792       ju = UBOUND(var,2)
4793       kl = LBOUND(var,1)
4794       ku = UBOUND(var,1)
4795
4796       ALLOCATE( var_tmp(kl:ku) )
4797
4798       DO  i = il, iu
4799          DO  j = jl, ju
4800             DO  k = kl, ku
4801
4802                kk = MINLOC( ABS( z_file - z_grid(k) ), DIM = 1 )
4803
4804                IF ( kk < ku )  THEN
4805                   IF ( z_file(kk) - z_grid(k) <= 0.0_wp )  THEN
4806                      var_tmp(k) = var(kk,j,i) +                               &
4807                                             ( var(kk+1,j,i) - var(kk,j,i) ) / &
4808                                             ( z_file(kk+1)  - z_file(kk)  ) * &
4809                                             ( z_grid(k)     - z_file(kk)  )
4810
4811                   ELSEIF ( z_file(kk) - z_grid(k) > 0.0_wp )  THEN
4812                      var_tmp(k) = var(kk-1,j,i) +                             &
4813                                             ( var(kk,j,i) - var(kk-1,j,i) ) / &
4814                                             ( z_file(kk)  - z_file(kk-1)  ) * &
4815                                             ( z_grid(k)   - z_file(kk-1)  )
4816                   ENDIF
4817!
4818!--             Extrapolate
4819                ELSE
4820                   var_tmp(k) = var(ku,j,i) +                                  &
4821                                       ( var(ku,j,i)  - var(ku-1,j,i)   ) /    &
4822                                       ( z_file(ku)   - z_file(ku-1)    ) *    &
4823                                       ( z_grid(k)    - z_file(ku)      )
4824
4825                ENDIF
4826             ENDDO
4827             var(:,j,i) = var_tmp(:)
4828          ENDDO
4829       ENDDO
4830
4831       DEALLOCATE( var_tmp )
4832
4833
4834    END SUBROUTINE netcdf_data_input_interpolate_3d
4835
4836!------------------------------------------------------------------------------!
4837! Description:
4838! ------------
4839!> Checks if a given variables is on file
4840!------------------------------------------------------------------------------!
4841    FUNCTION check_existence( vars_in_file, var_name )
4842
4843       IMPLICIT NONE
4844
4845       CHARACTER(LEN=*) ::  var_name                   !< variable to be checked
4846       CHARACTER(LEN=*), DIMENSION(:) ::  vars_in_file !< list of variables in file
4847
4848       INTEGER(iwp) ::  i                              !< loop variable
4849
4850       LOGICAL ::  check_existence                     !< flag indicating whether a variable exist or not - actual return value
4851
4852       i = 1
4853       check_existence = .FALSE.
4854       DO  WHILE ( i <= SIZE( vars_in_file ) )
4855          check_existence = TRIM( vars_in_file(i) ) == TRIM( var_name )  .OR.  &
4856                            check_existence
4857          i = i + 1
4858       ENDDO
4859
4860       RETURN
4861
4862    END FUNCTION check_existence
4863
4864
4865!------------------------------------------------------------------------------!
4866! Description:
4867! ------------
4868!> Closes an existing netCDF file.
4869!------------------------------------------------------------------------------!
4870    SUBROUTINE close_input_file( id )
4871#if defined( __netcdf )
4872
4873       USE pegrid
4874
4875       IMPLICIT NONE
4876
4877       INTEGER(iwp), INTENT(INOUT)        ::  id        !< file id
4878
4879       nc_stat = NF90_CLOSE( id )
4880       CALL handle_error( 'close', 540 )
4881#endif
4882    END SUBROUTINE close_input_file
4883
4884!------------------------------------------------------------------------------!
4885! Description:
4886! ------------
4887!> Opens an existing netCDF file for reading only and returns its id.
4888!------------------------------------------------------------------------------!
4889    SUBROUTINE open_read_file( filename, id )
4890#if defined( __netcdf )
4891
4892       USE pegrid
4893
4894       IMPLICIT NONE
4895
4896       CHARACTER (LEN=*), INTENT(IN) ::  filename  !< filename
4897       INTEGER(iwp), INTENT(INOUT)   ::  id        !< file id
4898
4899#if defined( __netcdf4_parallel )
4900!      if __netcdf4_parallel is defined, parrallel NetCDF will be used unconditionally
4901       nc_stat = NF90_OPEN( filename, IOR( NF90_WRITE, NF90_MPIIO ), id,  &
4902                            COMM = comm2d, INFO = MPI_INFO_NULL )
4903       IF(nc_stat /= NF90_NOERR )  THEN                                       !possible NetCDF 3 file
4904           nc_stat = NF90_OPEN( filename, NF90_NOWRITE, id )
4905           collective_read = .FALSE.
4906       ELSE
4907           collective_read = .TRUE.
4908       END IF
4909#else
4910!      All MPI processes open und read
4911       nc_stat = NF90_OPEN( filename, NF90_NOWRITE, id )
4912#endif
4913
4914       CALL handle_error( 'open_read_file', 539 )
4915
4916#endif
4917    END SUBROUTINE open_read_file
4918
4919!------------------------------------------------------------------------------!
4920! Description:
4921! ------------
4922!> Reads global or variable-related attributes of type INTEGER (32-bit)
4923!------------------------------------------------------------------------------!
4924     SUBROUTINE get_attribute_int32( id, attribute_name, value, global,        &
4925                                     variable_name )
4926
4927       USE pegrid
4928
4929       IMPLICIT NONE