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

Last change on this file since 4125 was 4125, checked in by suehring, 2 years ago

Enable netcdf parallel input for lateral boundary conditions in dynamic input file

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