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

Last change on this file since 2925 was 2925, checked in by suehring, 4 years ago

Check for further inconsistent settings of surface_fractions; error messages slightly rephrased and error numbers changed.

  • Property svn:keywords set to Id
File size: 194.1 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-2018 Leibniz Universitaet Hannover
18!------------------------------------------------------------------------------!
19!
20! Current revisions:
21! -----------------
22!
23!
24! Former revisions:
25! -----------------
26! $Id: netcdf_data_input_mod.f90 2925 2018-03-23 14:54:11Z suehring $
27! Check for further inconsistent settings of surface_fractions.
28! Some messages slightly rephrased and error numbers renamed.
29!
30! 2898 2018-03-15 13:03:01Z suehring
31! Check if each building has a type. Further, check if dimensions in static
32! input file match the model dimensions.
33!
34! 2897 2018-03-15 11:47:16Z suehring
35! Relax restrictions for topography input, terrain and building heights can be
36! input separately and are not mandatory any more.
37!
38! 2874 2018-03-13 10:55:42Z knoop
39! Bugfix: wrong placement of netcdf cpp-macros fixed
40!
41! 2794 2018-02-07 14:09:43Z knoop
42! Check if 3D building input is consistent to numeric grid.
43!
44! 2773 2018-01-30 14:12:54Z suehring
45! - Enable initialization with 3D topography.
46! - Move check for correct initialization in nesting mode to check_parameters.
47!
48! 2772 2018-01-29 13:10:35Z suehring
49! Initialization of simulation independent on land-surface model.
50!
51! 2746 2018-01-15 12:06:04Z suehring
52! Read plant-canopy variables independently on land-surface model usage
53!
54! 2718 2018-01-02 08:49:38Z maronga
55! Corrected "Former revisions" section
56!
57! 2711 2017-12-20 17:04:49Z suehring
58! Rename subroutine close_file to avoid double-naming. 
59!
60! 2700 2017-12-15 14:12:35Z suehring
61!
62! 2696 2017-12-14 17:12:51Z kanani
63! Initial revision (suehring)
64!
65!
66!
67!
68! Authors:
69! --------
70! @author Matthias Suehring
71!
72! Description:
73! ------------
74!> Modulue contains routines to input data according to Palm input data       
75!> standart using dynamic and static input files.
76!>
77!> @todo - Order input alphabetically
78!> @todo - Revise error messages and error numbers
79!> @todo - Input of missing quantities (chemical species, emission rates)
80!> @todo - Defninition and input of still missing variable attributes
81!> @todo - Input of initial geostrophic wind profiles with cyclic conditions.
82!------------------------------------------------------------------------------!
83 MODULE netcdf_data_input_mod
84 
85    USE control_parameters,                                                    &
86        ONLY:  coupling_char, io_blocks, io_group
87
88    USE kinds
89
90#if defined ( __netcdf )
91    USE NETCDF
92#endif
93
94    USE pegrid
95!
96!-- Define type for dimensions.
97    TYPE dims_xy
98       INTEGER(iwp) :: nx                             !< dimension length in x
99       INTEGER(iwp) :: ny                             !< dimension length in y
100       REAL(wp), DIMENSION(:), ALLOCATABLE :: x       !< dimension array in x
101       REAL(wp), DIMENSION(:), ALLOCATABLE :: y       !< dimension array in y
102    END TYPE dims_xy
103!
104!-- Define data type for nesting in larger-scale models like COSMO.
105!-- Data type comprises u, v, w, pt, and q at lateral and top boundaries.
106    TYPE force_type
107
108       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names
109
110       INTEGER(iwp) ::  nt     !< number of time levels in dynamic input file
111       INTEGER(iwp) ::  nzu    !< number of vertical levels on scalar grid in dynamic input file
112       INTEGER(iwp) ::  nzw    !< number of vertical levels on w grid in dynamic input file
113       INTEGER(iwp) ::  tind   !< time index for reference time in large-scale forcing data
114       INTEGER(iwp) ::  tind_p !< time index for following time in large-scale forcing data
115
116       LOGICAL      ::  init         = .FALSE.
117       LOGICAL      ::  interpolated = .FALSE.
118       LOGICAL      ::  from_file    = .FALSE.
119
120       REAL(wp), DIMENSION(:), ALLOCATABLE ::  surface_pressure !< time dependent surface pressure
121       REAL(wp), DIMENSION(:), ALLOCATABLE ::  time             !< time levels in dynamic input file
122       REAL(wp), DIMENSION(:), ALLOCATABLE ::  zu_atmos         !< vertical levels at scalar grid in dynamic input file
123       REAL(wp), DIMENSION(:), ALLOCATABLE ::  zw_atmos         !< vertical levels at w grid in dynamic input file
124
125       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_left   !< u-component at left boundary
126       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_left   !< v-component at left boundary
127       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_left   !< w-component at left boundary
128       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  q_left   !< mixing ratio at left boundary
129       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  pt_left  !< potentital temperautre at left boundary
130
131       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_north  !< u-component at north boundary
132       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_north  !< v-component at north boundary
133       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_north  !< w-component at north boundary
134       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  q_north  !< mixing ratio at north boundary
135       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  pt_north !< potentital temperautre at north boundary
136
137       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_right  !< u-component at right boundary
138       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_right  !< v-component at right boundary
139       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_right  !< w-component at right boundary
140       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  q_right  !< mixing ratio at right boundary
141       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  pt_right !< potentital temperautre at right boundary
142
143       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_south  !< u-component at south boundary
144       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_south  !< v-component at south boundary
145       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_south  !< w-component at south boundary
146       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  q_south  !< mixing ratio at south boundary
147       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  pt_south !< potentital temperautre at south boundary
148
149       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_top    !< u-component at top boundary
150       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_top    !< v-component at top boundary
151       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_top    !< w-component at top boundary
152       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  q_top    !< mixing ratio at top boundary
153       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  pt_top   !< potentital temperautre at top boundary
154
155    END TYPE force_type
156
157    TYPE init_type
158
159       INTEGER(iwp) ::  lod_msoil !< level of detail - soil moisture
160       INTEGER(iwp) ::  lod_pt    !< level of detail - pt
161       INTEGER(iwp) ::  lod_q     !< level of detail - q
162       INTEGER(iwp) ::  lod_tsoil !< level of detail - soil temperature
163       INTEGER(iwp) ::  lod_u     !< level of detail - u-component
164       INTEGER(iwp) ::  lod_v     !< level of detail - v-component
165       INTEGER(iwp) ::  lod_w     !< level of detail - w-component
166       INTEGER(iwp) ::  nx        !< number of scalar grid points along x in dynamic input file
167       INTEGER(iwp) ::  nxu       !< number of u grid points along x in dynamic input file
168       INTEGER(iwp) ::  ny        !< number of scalar grid points along y in dynamic input file
169       INTEGER(iwp) ::  nyv       !< number of v grid points along y in dynamic input file
170       INTEGER(iwp) ::  nzs       !< number of vertical soil levels in dynamic input file
171       INTEGER(iwp) ::  nzu       !< number of vertical levels on scalar grid in dynamic input file
172       INTEGER(iwp) ::  nzw       !< number of vertical levels on w grid in dynamic input file
173
174       LOGICAL ::  from_file_msoil  = .FALSE. !< flag indicating whether soil moisture is already initialized from file
175       LOGICAL ::  from_file_pt     = .FALSE. !< flag indicating whether pt is already initialized from file
176       LOGICAL ::  from_file_q      = .FALSE. !< flag indicating whether q is already initialized from file 
177       LOGICAL ::  from_file_tsoil  = .FALSE. !< flag indicating whether soil temperature is already initialized from file
178       LOGICAL ::  from_file_u      = .FALSE. !< flag indicating whether u is already initialized from file
179       LOGICAL ::  from_file_v      = .FALSE. !< flag indicating whether v is already initialized from file
180       LOGICAL ::  from_file_w      = .FALSE. !< flag indicating whether w is already initialized from file
181
182       REAL(wp) ::  fill_msoil       !< fill value for soil moisture
183       REAL(wp) ::  fill_pt          !< fill value for pt
184       REAL(wp) ::  fill_q           !< fill value for q
185       REAL(wp) ::  fill_tsoil       !< fill value for soil temperature
186       REAL(wp) ::  fill_u           !< fill value for u
187       REAL(wp) ::  fill_v           !< fill value for v
188       REAL(wp) ::  fill_w           !< fill value for w
189       REAL(wp) ::  latitude         !< latitude of the southern model boundary
190       REAL(wp) ::  longitude        !< longitude of the western model boundary
191
192       REAL(wp), DIMENSION(:), ALLOCATABLE ::  msoil_init   !< initial vertical profile of soil moisture
193       REAL(wp), DIMENSION(:), ALLOCATABLE ::  pt_init      !< initial vertical profile of pt
194       REAL(wp), DIMENSION(:), ALLOCATABLE ::  q_init       !< initial vertical profile of q
195       REAL(wp), DIMENSION(:), ALLOCATABLE ::  tsoil_init   !< initial vertical profile of soil temperature
196       REAL(wp), DIMENSION(:), ALLOCATABLE ::  u_init       !< initial vertical profile of u
197       REAL(wp), DIMENSION(:), ALLOCATABLE ::  ug_init      !< initial vertical profile of ug
198       REAL(wp), DIMENSION(:), ALLOCATABLE ::  v_init       !< initial vertical profile of v
199       REAL(wp), DIMENSION(:), ALLOCATABLE ::  vg_init      !< initial vertical profile of ug
200       REAL(wp), DIMENSION(:), ALLOCATABLE ::  w_init       !< initial vertical profile of w
201       REAL(wp), DIMENSION(:), ALLOCATABLE ::  z_soil       !< vertical levels in soil in dynamic input file, used for interpolation
202       REAL(wp), DIMENSION(:), ALLOCATABLE ::  zu_atmos     !< vertical levels at scalar grid in dynamic input file, used for interpolation
203       REAL(wp), DIMENSION(:), ALLOCATABLE ::  zw_atmos     !< vertical levels at w grid in dynamic input file, used for interpolation
204
205
206       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  msoil        !< initial 3d soil moisture provide by Inifor and interpolated onto soil grid
207       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  tsoil        !< initial 3d soil temperature provide by Inifor and interpolated onto soil grid
208
209    END TYPE init_type
210
211!
212!-- Define data structures for different input data types.
213!-- 8-bit Integer 2D
214    TYPE int_2d_8bit
215       INTEGER(KIND=1) ::  fill = -127                      !< fill value
216       INTEGER(KIND=1), DIMENSION(:,:), ALLOCATABLE ::  var !< respective variable
217       
218       LOGICAL ::  from_file = .FALSE.  !< flag indicating whether an input variable is available and read from file or default values are used 
219    END TYPE int_2d_8bit
220!
221!-- 32-bit Integer 2D
222    TYPE int_2d_32bit
223       INTEGER(iwp) ::  fill = -9999                      !< fill value
224       INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  var  !< respective variable
225
226       LOGICAL ::  from_file = .FALSE. !< flag indicating whether an input variable is available and read from file or default values are used 
227    END TYPE int_2d_32bit
228
229!
230!-- Define data type to read 2D real variables
231    TYPE real_2d
232       LOGICAL ::  from_file = .FALSE.  !< flag indicating whether an input variable is available and read from file or default values are used 
233
234       REAL(wp) ::  fill = -9999.9_wp                !< fill value
235       REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  var !< respective variable
236    END TYPE real_2d
237
238!
239!-- Define data type to read 2D real variables
240    TYPE real_3d
241       LOGICAL ::  from_file = .FALSE.  !< flag indicating whether an input variable is available and read from file or default values are used 
242
243       INTEGER(iwp) ::  nz   !< number of grid points along vertical dimension                     
244
245       REAL(wp) ::  fill = -9999.9_wp                  !< fill value
246       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  var !< respective variable
247    END TYPE real_3d
248!
249!-- Define data structure where the dimension and type of the input depends
250!-- on the given level of detail.
251!-- For buildings, the input is either 2D float, or 3d byte.
252    TYPE build_in
253       INTEGER(iwp)    ::  lod = 1                               !< level of detail                 
254       INTEGER(KIND=1) ::  fill2 = -127                          !< fill value for lod = 2
255       INTEGER(iwp)    ::  nz                                    !< number of vertical layers in file
256       INTEGER(KIND=1), DIMENSION(:,:,:), ALLOCATABLE ::  var_3d !< 3d variable (lod = 2)
257
258       REAL(wp), DIMENSION(:), ALLOCATABLE ::  z                 !< vertical coordinate for 3D building, used for consistency check
259
260       LOGICAL ::  from_file = .FALSE.  !< flag indicating whether an input variable is available and read from file or default values are used 
261
262       REAL(wp)                              ::  fill1 = -9999.9_wp !< fill values for lod = 1
263       REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  var_2d             !< 2d variable (lod = 1)
264    END TYPE build_in
265
266!
267!-- For soil_type, the input is either 2D or 3D one-byte integer.
268    TYPE soil_in
269       INTEGER(iwp)                                   ::  lod = 1      !< level of detail                 
270       INTEGER(KIND=1)                                ::  fill = -127  !< fill value for lod = 2
271       INTEGER(KIND=1), DIMENSION(:,:), ALLOCATABLE   ::  var_2d       !< 2d variable (lod = 1)
272       INTEGER(KIND=1), DIMENSION(:,:,:), ALLOCATABLE ::  var_3d       !< 3d variable (lod = 2)
273
274       LOGICAL ::  from_file = .FALSE.  !< flag indicating whether an input variable is available and read from file or default values are used 
275    END TYPE soil_in
276
277!
278!-- Define data type for fractions between surface types
279    TYPE fracs
280       INTEGER(iwp)                            ::  nf             !< total number of fractions
281       INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  nfracs         !< dimension array for fraction
282
283       LOGICAL ::  from_file = .FALSE. !< flag indicating whether an input variable is available and read from file or default values are used 
284
285       REAL(wp)                                ::  fill = -9999.9_wp !< fill value
286       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  frac              !< respective fraction between different surface types
287    END TYPE fracs
288!
289!-- Data type for parameter lists, Depending on the given level of detail,
290!-- the input is 3D or 4D
291    TYPE pars
292       INTEGER(iwp)                            ::  lod = 1         !< level of detail
293       INTEGER(iwp)                            ::  np              !< total number of parameters
294       INTEGER(iwp)                            ::  nz              !< vertical dimension - number of soil layers
295       INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  layers          !< dimension array for soil layers
296       INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  pars            !< dimension array for parameters
297
298       LOGICAL ::  from_file = .FALSE.  !< flag indicating whether an input variable is available and read from file or default values are used 
299
300       REAL(wp)                                  ::  fill = -9999.9_wp !< fill value
301       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE   ::  pars_xy           !< respective parameters, level of detail = 1
302       REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE ::  pars_xyz          !< respective parameters, level of detail = 2
303    END TYPE pars
304!
305!-- Define variables
306    TYPE(dims_xy)    ::  dim_static !< data structure for x, y-dimension in static input file
307
308    TYPE(force_type) ::  force     !< data structure for data input at lateral and top boundaries (provided by Inifor) 
309
310    TYPE(init_type) ::  init_3d    !< data structure for the initialization of the 3D flow and soil fields
311    TYPE(init_type) ::  init_model !< data structure for the initialization of the model
312
313!
314!-- Define 2D variables of type NC_BYTE
315    TYPE(int_2d_8bit)  ::  albedo_type_f     !< input variable for albedo type
316    TYPE(int_2d_8bit)  ::  building_type_f   !< input variable for building type
317    TYPE(int_2d_8bit)  ::  pavement_type_f   !< input variable for pavenment type
318    TYPE(int_2d_8bit)  ::  street_crossing_f !< input variable for water type
319    TYPE(int_2d_8bit)  ::  street_type_f     !< input variable for water type
320    TYPE(int_2d_8bit)  ::  vegetation_type_f !< input variable for vegetation type
321    TYPE(int_2d_8bit)  ::  water_type_f      !< input variable for water type
322
323!
324!-- Define 2D variables of type NC_INT
325    TYPE(int_2d_32bit) ::  building_id_f     !< input variable for building ID
326!
327!-- Define 2D variables of type NC_FLOAT
328    TYPE(real_2d) ::  terrain_height_f       !< input variable for terrain height
329!
330!-- Define 3D variables of type NC_FLOAT
331    TYPE(real_3d) ::  basal_area_density_f    !< input variable for basal area density - resolved vegetation
332    TYPE(real_3d) ::  leaf_area_density_f     !< input variable for leaf area density - resolved vegetation
333    TYPE(real_3d) ::  root_area_density_lad_f !< input variable for root area density - resolved vegetation
334    TYPE(real_3d) ::  root_area_density_lsm_f !< input variable for root area density - parametrized vegetation
335
336!
337!-- Define input variable for buildings
338    TYPE(build_in) ::  buildings_f           !< input variable for buildings
339!
340!-- Define input variables for soil_type
341    TYPE(soil_in)  ::  soil_type_f           !< input variable for soil type
342
343    TYPE(fracs) ::  surface_fraction_f       !< input variable for surface fraction
344
345    TYPE(pars)  ::  albedo_pars_f              !< input variable for albedo parameters
346    TYPE(pars)  ::  building_pars_f            !< input variable for building parameters
347    TYPE(pars)  ::  pavement_pars_f            !< input variable for pavement parameters
348    TYPE(pars)  ::  pavement_subsurface_pars_f !< input variable for pavement parameters
349    TYPE(pars)  ::  soil_pars_f                !< input variable for soil parameters
350    TYPE(pars)  ::  vegetation_pars_f          !< input variable for vegetation parameters
351    TYPE(pars)  ::  water_pars_f               !< input variable for water parameters
352
353
354    CHARACTER(LEN=3)  ::  char_lod  = 'lod'         !< name of level-of-detail attribute in NetCDF file
355
356    CHARACTER(LEN=10) ::  char_fill = '_FillValue'  !< name of fill value attribute in NetCDF file
357    CHARACTER(LEN=10) ::  char_lon  = 'origin_lon'  !< name of global attribute for longitude in NetCDF file
358    CHARACTER(LEN=10) ::  char_lat  = 'origin_lat'  !< name of global attribute for latitude in NetCDF file
359
360    CHARACTER(LEN=100) ::  input_file_static  = 'PIDS_STATIC'  !< Name of file which comprises static input data
361    CHARACTER(LEN=100) ::  input_file_dynamic = 'PIDS_DYNAMIC' !< Name of file which comprises dynamic input data
362
363    INTEGER(iwp) ::  nc_stat         !< return value of nf90 function call
364
365    LOGICAL ::  input_pids_static  = .FALSE.   !< Flag indicating whether Palm-input-data-standard file containing static information exists
366    LOGICAL ::  input_pids_dynamic = .FALSE.   !< Flag indicating whether Palm-input-data-standard file containing dynamic information exists
367
368    SAVE
369
370    PRIVATE
371
372    INTERFACE netcdf_data_input_interpolate
373       MODULE PROCEDURE netcdf_data_input_interpolate_1d
374       MODULE PROCEDURE netcdf_data_input_interpolate_1d_soil
375       MODULE PROCEDURE netcdf_data_input_interpolate_2d
376       MODULE PROCEDURE netcdf_data_input_interpolate_3d
377    END INTERFACE netcdf_data_input_interpolate
378
379    INTERFACE netcdf_data_input_check_dynamic
380       MODULE PROCEDURE netcdf_data_input_check_dynamic
381    END INTERFACE netcdf_data_input_check_dynamic
382
383    INTERFACE netcdf_data_input_check_static
384       MODULE PROCEDURE netcdf_data_input_check_static
385    END INTERFACE netcdf_data_input_check_static
386
387    INTERFACE netcdf_data_input_inquire_file
388       MODULE PROCEDURE netcdf_data_input_inquire_file
389    END INTERFACE netcdf_data_input_inquire_file
390
391    INTERFACE netcdf_data_input_init
392       MODULE PROCEDURE netcdf_data_input_init
393    END INTERFACE netcdf_data_input_init
394
395    INTERFACE netcdf_data_input_init_3d
396       MODULE PROCEDURE netcdf_data_input_init_3d
397    END INTERFACE netcdf_data_input_init_3d
398
399    INTERFACE netcdf_data_input_lsf
400       MODULE PROCEDURE netcdf_data_input_lsf
401    END INTERFACE netcdf_data_input_lsf
402
403    INTERFACE netcdf_data_input_surface_data
404       MODULE PROCEDURE netcdf_data_input_surface_data
405    END INTERFACE netcdf_data_input_surface_data
406
407    INTERFACE netcdf_data_input_topo
408       MODULE PROCEDURE netcdf_data_input_topo
409    END INTERFACE netcdf_data_input_topo
410
411    INTERFACE get_variable
412       MODULE PROCEDURE get_variable_1d_int
413       MODULE PROCEDURE get_variable_1d_real
414       MODULE PROCEDURE get_variable_2d_int8
415       MODULE PROCEDURE get_variable_2d_int32
416       MODULE PROCEDURE get_variable_2d_real
417       MODULE PROCEDURE get_variable_3d_int8
418       MODULE PROCEDURE get_variable_3d_real
419       MODULE PROCEDURE get_variable_4d_real
420    END INTERFACE get_variable
421
422    INTERFACE get_attribute
423       MODULE PROCEDURE get_attribute_real
424       MODULE PROCEDURE get_attribute_int8
425       MODULE PROCEDURE get_attribute_int32
426       MODULE PROCEDURE get_attribute_string
427    END INTERFACE get_attribute
428
429!
430!-- Public variables
431    PUBLIC albedo_pars_f, albedo_type_f, basal_area_density_f, buildings_f,    &
432           building_id_f, building_pars_f, building_type_f, force, init_3d,    &
433           init_model, input_file_static, input_pids_static,                   &
434           input_pids_dynamic, leaf_area_density_f,                            &
435           pavement_pars_f, pavement_subsurface_pars_f, pavement_type_f,       &
436           root_area_density_lad_f, root_area_density_lsm_f, soil_pars_f,      &
437           soil_type_f, street_crossing_f, street_type_f, surface_fraction_f,  &
438           terrain_height_f, vegetation_pars_f, vegetation_type_f,             &
439           water_pars_f, water_type_f
440
441!
442!-- Public subroutines
443    PUBLIC netcdf_data_input_check_dynamic, netcdf_data_input_check_static,    &
444           netcdf_data_input_inquire_file,                                     &
445           netcdf_data_input_init, netcdf_data_input_init_3d,                  &
446           netcdf_data_input_interpolate, netcdf_data_input_lsf,               &
447           netcdf_data_input_surface_data, netcdf_data_input_topo
448
449 CONTAINS
450
451!------------------------------------------------------------------------------!
452! Description:
453! ------------
454!> Inquires whether NetCDF input files according to Palm-input-data standard
455!> exist. Moreover, basic checks are performed.
456!------------------------------------------------------------------------------!
457    SUBROUTINE netcdf_data_input_inquire_file
458
459       USE control_parameters,                                                 &
460           ONLY:  land_surface, message_string, topo_no_distinct, urban_surface
461
462       IMPLICIT NONE
463
464       LOGICAL ::  check_nest  !< flag indicating whether a check passed or not
465
466#if defined ( __netcdf )
467       INQUIRE( FILE = TRIM( input_file_static ) // TRIM( coupling_char ),     &
468                EXIST = input_pids_static  )
469       INQUIRE( FILE = TRIM( input_file_dynamic ) // TRIM( coupling_char ),    &
470                EXIST = input_pids_dynamic )
471#endif
472
473!
474!--    As long as topography can be input via ASCII format, no distinction
475!--    between building and terrain can be made. This case, classify all
476!--    surfaces as default type. Same in case land-surface and urban-surface
477!--    model are not applied.
478       IF ( .NOT. input_pids_static )  THEN
479          topo_no_distinct = .TRUE. 
480       ENDIF
481
482    END SUBROUTINE netcdf_data_input_inquire_file
483
484!------------------------------------------------------------------------------!
485! Description:
486! ------------
487!> Reads global attributes required for initialization of the model.
488!------------------------------------------------------------------------------!
489    SUBROUTINE netcdf_data_input_init
490
491       IMPLICIT NONE
492
493       INTEGER(iwp) ::  id_mod   !< NetCDF id of input file
494       INTEGER(iwp) ::  ii       !< running index for IO blocks
495
496       IF ( .NOT. input_pids_static )  RETURN 
497
498       DO  ii = 0, io_blocks-1
499          IF ( ii == io_group )  THEN
500#if defined ( __netcdf )
501!
502!--          Open file in read-only mode
503             CALL open_read_file( TRIM( input_file_static ) //                 &
504                                  TRIM( coupling_char ), id_mod )
505!
506!--          Read global attribute for latitude and longitude
507             CALL get_attribute( id_mod, char_lat,                             &
508                                 init_model%latitude, .TRUE. )
509
510             CALL get_attribute( id_mod, char_lon,                             &
511                                 init_model%longitude, .TRUE. )
512!
513!--          Finally, close input file
514             CALL close_input_file( id_mod )
515#endif
516          ENDIF
517#if defined( __parallel )
518          CALL MPI_BARRIER( comm2d, ierr )
519#endif
520       ENDDO
521
522    END SUBROUTINE netcdf_data_input_init
523
524!------------------------------------------------------------------------------!
525! Description:
526! ------------
527!> Reads surface classification data, such as vegetation and soil type, etc. .
528!------------------------------------------------------------------------------!
529    SUBROUTINE netcdf_data_input_surface_data
530
531       USE control_parameters,                                                 &
532           ONLY:  bc_lr_cyc, bc_ns_cyc, land_surface, message_string,          &
533                  plant_canopy, urban_surface
534
535       USE indices,                                                            &
536           ONLY:  nbgp, nx, nxl, nxlg, nxr, nxrg, ny, nyn, nyng, nys, nysg
537
538
539       IMPLICIT NONE
540
541       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names  !< variable names in static input file
542
543       INTEGER(iwp) ::  i         !< running index along x-direction
544       INTEGER(iwp) ::  ii        !< running index for IO blocks
545       INTEGER(iwp) ::  id_surf   !< NetCDF id of input file
546       INTEGER(iwp) ::  j         !< running index along y-direction
547       INTEGER(iwp) ::  k         !< running index along z-direction
548       INTEGER(iwp) ::  k2        !< running index
549       INTEGER(iwp) ::  num_vars  !< number of variables in input file
550       INTEGER(iwp) ::  nz_soil   !< number of soil layers in file
551
552       INTEGER(iwp), DIMENSION(nysg:nyng,nxlg:nxrg) ::  var_exchange_int !< dummy variables used to exchange 32-bit Integer arrays
553       INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE  ::  var_dum_int_3d !< dummy variables used to exchange real arrays
554
555       REAL(wp), DIMENSION(nysg:nyng,nxlg:nxrg) ::  var_exchange_real !< dummy variables used to exchange real arrays
556
557       REAL(wp), DIMENSION(:,:,:),   ALLOCATABLE ::  var_dum_real_3d !< dummy variables used to exchange real arrays
558       REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE ::  var_dum_real_4d !< dummy variables used to exchange real arrays
559
560!
561!--    If not static input file is available, skip this routine
562       IF ( .NOT. input_pids_static )  RETURN
563!
564!--    Read plant canopy variables.
565       IF ( plant_canopy )  THEN
566          DO  ii = 0, io_blocks-1
567             IF ( ii == io_group )  THEN
568#if defined ( __netcdf )
569!
570!--             Open file in read-only mode
571                CALL open_read_file( TRIM( input_file_static ) //              &
572                                     TRIM( coupling_char ) , id_surf )
573!
574!--             At first, inquire all variable names.
575!--             This will be used to check whether an optional input variable
576!--             exist or not.
577                CALL inquire_num_variables( id_surf, num_vars )
578
579                ALLOCATE( var_names(1:num_vars) )
580                CALL inquire_variable_names( id_surf, var_names )
581
582!
583!--             Read leaf area density - resolved vegetation
584                IF ( check_existence( var_names, 'leaf_area_density' ) )  THEN
585                   leaf_area_density_f%from_file = .TRUE. 
586                   CALL get_attribute( id_surf, char_fill,                     &
587                                       leaf_area_density_f%fill,               &
588                                       .FALSE., 'leaf_area_density' ) 
589!
590!--                Inquire number of vertical vegetation layer
591                   CALL get_dimension_length( id_surf, leaf_area_density_f%nz, &
592                                              'zlad' )
593!           
594!--                Allocate variable for leaf-area density
595                   ALLOCATE( leaf_area_density_f%var(                          &
596                                                   0:leaf_area_density_f%nz-1, &
597                                                   nys:nyn,nxl:nxr) )
598
599                   DO  i = nxl, nxr
600                      DO  j = nys, nyn
601                         CALL get_variable( id_surf, 'leaf_area_density',      &
602                                            i, j,                              &
603                                            leaf_area_density_f%var(:,j,i) ) 
604                      ENDDO
605                   ENDDO
606                ELSE
607                   leaf_area_density_f%from_file = .FALSE. 
608                ENDIF
609
610!
611!--             Read basal area density - resolved vegetation
612                IF ( check_existence( var_names, 'basal_area_density' ) )  THEN
613                   basal_area_density_f%from_file = .TRUE. 
614                   CALL get_attribute( id_surf, char_fill,                     &
615                                       basal_area_density_f%fill,              &
616                                       .FALSE., 'basal_area_density' ) 
617!
618!--                Inquire number of vertical vegetation layer
619                   CALL get_dimension_length( id_surf,                         &
620                                              basal_area_density_f%nz,         &
621                                              'zlad' )
622!           
623!--                Allocate variable
624                   ALLOCATE( basal_area_density_f%var(                         &
625                                                  0:basal_area_density_f%nz-1, &
626                                                  nys:nyn,nxl:nxr) )
627
628                   DO  i = nxl, nxr
629                      DO  j = nys, nyn
630                         CALL get_variable( id_surf, 'basal_area_density',     &
631                                            i, j,                              &
632                                            basal_area_density_f%var(:,j,i) ) 
633                      ENDDO
634                   ENDDO
635                ELSE
636                   basal_area_density_f%from_file = .FALSE. 
637                ENDIF
638
639!
640!--             Read root area density - resolved vegetation
641                IF ( check_existence( var_names, 'root_area_density_lad' ) )  THEN
642                   root_area_density_lad_f%from_file = .TRUE. 
643                   CALL get_attribute( id_surf, char_fill,                     &
644                                       root_area_density_lad_f%fill,           &
645                                       .FALSE., 'root_area_density_lad' ) 
646!
647!--                Inquire number of vertical soil layers
648                   CALL get_dimension_length( id_surf,                         &
649                                              root_area_density_lad_f%nz,      &
650                                              'zsoil' )
651!           
652!--                Allocate variable
653                   ALLOCATE( root_area_density_lad_f%var                       &
654                                               (0:root_area_density_lad_f%nz-1,&
655                                                nys:nyn,nxl:nxr) )
656
657                   DO  i = nxl, nxr
658                      DO  j = nys, nyn
659                         CALL get_variable( id_surf, 'root_area_density_lad',  &
660                                            i, j,                              &
661                                            root_area_density_lad_f%var(:,j,i) ) 
662                      ENDDO
663                   ENDDO
664                ELSE
665                   root_area_density_lad_f%from_file = .FALSE. 
666                ENDIF
667!
668!--             Finally, close input file
669                CALL close_input_file( id_surf )
670#endif
671             ENDIF
672#if defined( __parallel )
673             CALL MPI_BARRIER( comm2d, ierr )
674#endif
675          ENDDO
676!
677!--       Deallocate variable list. Will be re-allocated in case further
678!--       variables are read from file.         
679          IF ( ALLOCATED( var_names ) )  DEALLOCATE( var_names )
680
681       ENDIF
682!
683!--    Skip the following if no land-surface or urban-surface module are
684!--    applied. This case, no one of the following variables is used anyway. 
685       IF (  .NOT. land_surface  .OR.  .NOT. urban_surface )  RETURN
686!
687!--    Initialize dummy arrays used for ghost-point exchange
688       var_exchange_int  = 0
689       var_exchange_real = 0.0_wp
690
691       DO  ii = 0, io_blocks-1
692          IF ( ii == io_group )  THEN
693#if defined ( __netcdf )
694!
695!--          Open file in read-only mode
696             CALL open_read_file( TRIM( input_file_static ) //                 &
697                                  TRIM( coupling_char ) , id_surf )
698
699!
700!--          Inquire all variable names.
701!--          This will be used to check whether an optional input variable exist
702!--          or not.
703             CALL inquire_num_variables( id_surf, num_vars )
704
705             ALLOCATE( var_names(1:num_vars) )
706             CALL inquire_variable_names( id_surf, var_names )
707
708!
709!--          Read vegetation type and required attributes
710             IF ( check_existence( var_names, 'vegetation_type' ) )  THEN
711                vegetation_type_f%from_file = .TRUE.
712                CALL get_attribute( id_surf, char_fill,                        &
713                                    vegetation_type_f%fill,                    &
714                                    .FALSE., 'vegetation_type' )
715!
716!--             PE-wise reading of 2D vegetation type.
717                ALLOCATE ( vegetation_type_f%var(nys:nyn,nxl:nxr)  )
718
719                DO  i = nxl, nxr
720                   CALL get_variable( id_surf, 'vegetation_type',              &
721                                      i, vegetation_type_f%var(:,i) )
722                ENDDO
723             ELSE
724                vegetation_type_f%from_file = .FALSE.
725             ENDIF
726
727!
728!--          Read soil type and required attributes
729             IF ( check_existence( var_names, 'soil_type' ) )  THEN
730                   soil_type_f%from_file = .TRUE. 
731!
732!--             Note, lod is currently not on file; skip for the moment
733!                 CALL get_attribute( id_surf, char_lod,                       &
734!                                            soil_type_f%lod,                  &
735!                                            .FALSE., 'soil_type' )
736                CALL get_attribute( id_surf, char_fill,                        &
737                                    soil_type_f%fill,                          &
738                                    .FALSE., 'soil_type' ) 
739
740                IF ( soil_type_f%lod == 1 )  THEN
741!
742!--                PE-wise reading of 2D soil type.
743                   ALLOCATE ( soil_type_f%var_2d(nys:nyn,nxl:nxr)  )
744                   DO  i = nxl, nxr
745                      CALL get_variable( id_surf, 'soil_type',                 &
746                                         i, soil_type_f%var_2d(:,i) ) 
747                   ENDDO
748                ELSEIF ( soil_type_f%lod == 2 )  THEN
749!
750!--                Obtain number of soil layers from file.
751                   CALL get_dimension_length( id_surf, nz_soil, 'zsoil' )
752!
753!--                PE-wise reading of 3D soil type.
754                   ALLOCATE ( soil_type_f%var_3d(0:nz_soil,nys:nyn,nxl:nxr) )
755                   DO  i = nxl, nxr
756                      DO  j = nys, nyn
757                         CALL get_variable( id_surf, 'soil_type', i, j,        &
758                                            soil_type_f%var_3d(:,j,i) )   
759                      ENDDO
760                   ENDDO
761                ENDIF
762             ELSE
763                soil_type_f%from_file = .FALSE.
764             ENDIF
765
766!
767!--          Read pavement type and required attributes
768             IF ( check_existence( var_names, 'pavement_type' ) )  THEN
769                pavement_type_f%from_file = .TRUE. 
770                CALL get_attribute( id_surf, char_fill,                        &
771                                    pavement_type_f%fill, .FALSE.,             &
772                                    'pavement_type' ) 
773!
774!--             PE-wise reading of 2D pavement type.
775                ALLOCATE ( pavement_type_f%var(nys:nyn,nxl:nxr)  )
776                DO  i = nxl, nxr
777                   CALL get_variable( id_surf, 'pavement_type',                &
778                                      i, pavement_type_f%var(:,i) ) 
779                ENDDO
780             ELSE
781                pavement_type_f%from_file = .FALSE.
782             ENDIF
783
784!
785!--          Read water type and required attributes
786             IF ( check_existence( var_names, 'water_type' ) )  THEN
787                water_type_f%from_file = .TRUE. 
788                CALL get_attribute( id_surf, char_fill, water_type_f%fill,     &
789                                    .FALSE., 'water_type' )
790!
791!--             PE-wise reading of 2D water type.
792                ALLOCATE ( water_type_f%var(nys:nyn,nxl:nxr)  )
793                DO  i = nxl, nxr
794                   CALL get_variable( id_surf, 'water_type', i,                &
795                                      water_type_f%var(:,i) ) 
796                ENDDO
797             ELSE
798                water_type_f%from_file = .FALSE.
799             ENDIF
800!
801!--          Read surface fractions and related information
802             IF ( check_existence( var_names, 'surface_fraction' ) )  THEN
803                surface_fraction_f%from_file = .TRUE. 
804                CALL get_attribute( id_surf, char_fill,                        &
805                                    surface_fraction_f%fill,                   &
806                                    .FALSE., 'surface_fraction' )
807!
808!--             Inquire number of surface fractions
809                CALL get_dimension_length( id_surf,                            &
810                                           surface_fraction_f%nf,              &
811                                           'nsurface_fraction' )
812!           
813!--             Allocate dimension array and input array for surface fractions
814                ALLOCATE( surface_fraction_f%nfracs(0:surface_fraction_f%nf-1) )
815                ALLOCATE( surface_fraction_f%frac(0:surface_fraction_f%nf-1,   &
816                                                  nys:nyn,nxl:nxr) )
817!
818!--             Get dimension of surface fractions
819                CALL get_variable( id_surf, 'nsurface_fraction',               &
820                                   surface_fraction_f%nfracs )
821!
822!--             Read surface fractions
823                DO  i = nxl, nxr
824                   DO  j = nys, nyn
825                      CALL get_variable( id_surf, 'surface_fraction', i, j,    &
826                                         surface_fraction_f%frac(:,j,i) ) 
827                   ENDDO
828                ENDDO
829             ELSE
830                surface_fraction_f%from_file = .FALSE. 
831             ENDIF
832!
833!--          Read building parameters and related information
834             IF ( check_existence( var_names, 'building_pars' ) )  THEN
835                building_pars_f%from_file = .TRUE. 
836                CALL get_attribute( id_surf, char_fill,                        &
837                                    building_pars_f%fill,                      &
838                                    .FALSE., 'building_pars' ) 
839!
840!--             Inquire number of building parameters
841                CALL get_dimension_length( id_surf,                            &
842                                           building_pars_f%np,                 &
843                                           'nbuilding_pars' )
844!           
845!--             Allocate dimension array and input array for building parameters
846                ALLOCATE( building_pars_f%pars(0:building_pars_f%np-1) )
847                ALLOCATE( building_pars_f%pars_xy(0:building_pars_f%np-1,      &
848                                                  nys:nyn,nxl:nxr) )
849!
850!--             Get dimension of building parameters
851                CALL get_variable( id_surf, 'nbuilding_pars',                  &
852                                   building_pars_f%pars )
853!
854!--             Read building_pars
855                DO  i = nxl, nxr
856                   DO  j = nys, nyn
857                      CALL get_variable( id_surf, 'building_pars', i, j,       &
858                                         building_pars_f%pars_xy(:,j,i) )   
859                   ENDDO
860                ENDDO
861             ELSE
862                building_pars_f%from_file = .FALSE. 
863             ENDIF
864
865!
866!--          Read albedo type and required attributes
867             IF ( check_existence( var_names, 'albedo_type' ) )  THEN
868                albedo_type_f%from_file = .TRUE. 
869                CALL get_attribute( id_surf, char_fill, albedo_type_f%fill,    &
870                                    .FALSE.,  'albedo_type' ) 
871!
872!--             PE-wise reading of 2D water type.
873                ALLOCATE ( albedo_type_f%var(nys:nyn,nxl:nxr)  )
874                DO  i = nxl, nxr
875                   CALL get_variable( id_surf, 'albedo_type',                  &
876                                      i, albedo_type_f%var(:,i) ) 
877                ENDDO
878             ELSE
879                albedo_type_f%from_file = .FALSE.
880             ENDIF
881!
882!--          Read albedo parameters and related information
883             IF ( check_existence( var_names, 'albedo_pars' ) )  THEN
884                albedo_pars_f%from_file = .TRUE. 
885                CALL get_attribute( id_surf, char_fill, albedo_pars_f%fill,    &
886                                    .FALSE., 'albedo_pars' ) 
887!
888!--             Inquire number of albedo parameters
889                CALL get_dimension_length( id_surf, albedo_pars_f%np,          &
890                                           'nalbedo_pars' )
891!           
892!--             Allocate dimension array and input array for albedo parameters
893                ALLOCATE( albedo_pars_f%pars(0:albedo_pars_f%np-1) )
894                ALLOCATE( albedo_pars_f%pars_xy(0:albedo_pars_f%np-1,          &
895                                                nys:nyn,nxl:nxr) )
896!
897!--             Get dimension of albedo parameters
898                CALL get_variable( id_surf, 'nalbedo_pars', albedo_pars_f%pars )
899
900                DO  i = nxl, nxr
901                   DO  j = nys, nyn
902                      CALL get_variable( id_surf, 'albedo_pars', i, j,         &
903                                         albedo_pars_f%pars_xy(:,j,i) )   
904                   ENDDO
905                ENDDO
906             ELSE
907                albedo_pars_f%from_file = .FALSE. 
908             ENDIF
909
910!
911!--          Read pavement parameters and related information
912             IF ( check_existence( var_names, 'pavement_pars' ) )  THEN
913                pavement_pars_f%from_file = .TRUE. 
914                CALL get_attribute( id_surf, char_fill,                        &
915                                    pavement_pars_f%fill,                      &
916                                    .FALSE., 'pavement_pars' ) 
917!
918!--             Inquire number of pavement parameters
919                CALL get_dimension_length( id_surf, pavement_pars_f%np,        &
920                                           'npavement_pars' )
921!           
922!--             Allocate dimension array and input array for pavement parameters
923                ALLOCATE( pavement_pars_f%pars(0:pavement_pars_f%np-1) )
924                ALLOCATE( pavement_pars_f%pars_xy(0:pavement_pars_f%np-1,      &
925                                                  nys:nyn,nxl:nxr) )
926!
927!--             Get dimension of pavement parameters
928                CALL get_variable( id_surf, 'npavement_pars',                  &
929                                   pavement_pars_f%pars )
930   
931                DO  i = nxl, nxr
932                   DO  j = nys, nyn
933                      CALL get_variable( id_surf, 'pavement_pars', i, j,       &
934                                         pavement_pars_f%pars_xy(:,j,i) )   
935                   ENDDO
936                ENDDO
937             ELSE
938                pavement_pars_f%from_file = .FALSE. 
939             ENDIF
940
941!
942!--          Read pavement subsurface parameters and related information
943             IF ( check_existence( var_names, 'pavement_subsurface_pars' ) )   &
944             THEN
945                pavement_subsurface_pars_f%from_file = .TRUE. 
946                CALL get_attribute( id_surf, char_fill,                        &
947                                    pavement_subsurface_pars_f%fill,           &
948                                    .FALSE., 'pavement_subsurface_pars' ) 
949!
950!--             Inquire number of parameters
951                CALL get_dimension_length( id_surf,                            &
952                                           pavement_subsurface_pars_f%np,      &
953                                           'npavement_subsurface_pars' )
954!
955!--             Inquire number of soil layers
956                CALL get_dimension_length( id_surf,                            &
957                                           pavement_subsurface_pars_f%nz,      &
958                                           'zsoil' )
959!           
960!--             Allocate dimension array and input array for pavement parameters
961                ALLOCATE( pavement_subsurface_pars_f%pars                      &
962                                  (0:pavement_subsurface_pars_f%np-1) )
963                ALLOCATE( pavement_subsurface_pars_f%pars_xyz                  &
964                                  (0:pavement_subsurface_pars_f%np-1,          &
965                                   0:pavement_subsurface_pars_f%nz-1,          &
966                                   nys:nyn,nxl:nxr) )
967!
968!--             Get dimension of pavement parameters
969                CALL get_variable( id_surf, 'npavement_subsurface_pars',       &
970                                   pavement_subsurface_pars_f%pars )
971   
972                DO  i = nxl, nxr
973                   DO  j = nys, nyn
974                      CALL get_variable(                                       &
975                                  id_surf, 'pavement_subsurface_pars',         &
976                                  i, j,                                        &
977                                  pavement_subsurface_pars_f%pars_xyz(:,:,j,i),&
978                                  pavement_subsurface_pars_f%nz,               &
979                                  pavement_subsurface_pars_f%np )   
980                   ENDDO
981                ENDDO
982             ELSE
983                pavement_subsurface_pars_f%from_file = .FALSE. 
984             ENDIF
985
986
987!
988!--          Read vegetation parameters and related information
989             IF ( check_existence( var_names, 'vegetation_pars' ) )  THEN
990                vegetation_pars_f%from_file = .TRUE. 
991                CALL get_attribute( id_surf, char_fill,                        &
992                                    vegetation_pars_f%fill,                    &
993                                    .FALSE.,  'vegetation_pars' )
994!
995!--             Inquire number of vegetation parameters
996                CALL get_dimension_length( id_surf, vegetation_pars_f%np,      &
997                                           'nvegetation_pars' )
998!           
999!--             Allocate dimension array and input array for surface fractions
1000                ALLOCATE( vegetation_pars_f%pars(0:vegetation_pars_f%np-1) )
1001                ALLOCATE( vegetation_pars_f%pars_xy(0:vegetation_pars_f%np-1,  &
1002                                                    nys:nyn,nxl:nxr) )
1003!
1004!--             Get dimension of the parameters
1005                CALL get_variable( id_surf, 'nvegetation_pars',                &
1006                                   vegetation_pars_f%pars )
1007
1008                DO  i = nxl, nxr
1009                   DO  j = nys, nyn
1010                      CALL get_variable( id_surf, 'vegetation_pars', i, j,     &
1011                                         vegetation_pars_f%pars_xy(:,j,i) ) 
1012                   ENDDO
1013                ENDDO
1014             ELSE
1015                vegetation_pars_f%from_file = .FALSE. 
1016             ENDIF
1017
1018!
1019!--          Read root parameters/distribution and related information
1020             IF ( check_existence( var_names, 'soil_pars' ) )  THEN
1021                soil_pars_f%from_file = .TRUE. 
1022                CALL get_attribute( id_surf, char_fill,                        &
1023                                    soil_pars_f%fill,                          & 
1024                                    .FALSE., 'soil_pars' ) 
1025
1026                CALL get_attribute( id_surf, char_lod,                         &
1027                                    soil_pars_f%lod,                           &
1028                                    .FALSE., 'soil_pars' ) 
1029
1030!
1031!--             Inquire number of soil parameters
1032                CALL get_dimension_length( id_surf,                            &
1033                                           soil_pars_f%np,                     &
1034                                           'nsoil_pars' )
1035!
1036!--             Read parameters array
1037                ALLOCATE( soil_pars_f%pars(0:soil_pars_f%np-1) )
1038                CALL get_variable( id_surf, 'nsoil_pars', soil_pars_f%pars )
1039
1040!
1041!--             In case of level of detail 2, also inquire number of vertical
1042!--             soil layers, allocate memory and read the respective dimension
1043                IF ( soil_pars_f%lod == 2 )  THEN
1044                   CALL get_dimension_length( id_surf, soil_pars_f%nz, 'zsoil' )
1045
1046                   ALLOCATE( soil_pars_f%layers(0:soil_pars_f%nz-1) )
1047                   CALL get_variable( id_surf, 'zsoil', soil_pars_f%layers )
1048
1049                ENDIF
1050
1051!
1052!--             Read soil parameters, depending on level of detail
1053                IF ( soil_pars_f%lod == 1 )  THEN     
1054                   ALLOCATE( soil_pars_f%pars_xy(0:soil_pars_f%np-1,           &
1055                                                 nys:nyn,nxl:nxr) )       
1056                   DO  i = nxl, nxr
1057                      DO  j = nys, nyn
1058                         CALL get_variable( id_surf, 'soil_pars', i, j,        &
1059                                            soil_pars_f%pars_xy(:,j,i) ) 
1060                      ENDDO
1061                   ENDDO
1062
1063                ELSEIF ( soil_pars_f%lod == 2 )  THEN
1064                   ALLOCATE( soil_pars_f%pars_xyz(0:soil_pars_f%np-1,          &
1065                                                  0:soil_pars_f%nz-1,          &
1066                                                  nys:nyn,nxl:nxr) )
1067                   DO  i = nxl, nxr
1068                      DO  j = nys, nyn
1069                         CALL get_variable( id_surf, 'soil_pars', i, j,        &
1070                                            soil_pars_f%pars_xyz(:,:,j,i),     &
1071                                            soil_pars_f%nz, soil_pars_f%np ) 
1072                      ENDDO
1073                   ENDDO
1074                ENDIF
1075             ELSE
1076                soil_pars_f%from_file = .FALSE. 
1077             ENDIF
1078
1079!
1080!--          Read water parameters and related information
1081             IF ( check_existence( var_names, 'water_pars' ) )  THEN
1082                water_pars_f%from_file = .TRUE. 
1083                CALL get_attribute( id_surf, char_fill,                        &
1084                                    water_pars_f%fill,                         &
1085                                    .FALSE., 'water_pars' ) 
1086!
1087!--             Inquire number of water parameters
1088                CALL get_dimension_length( id_surf,                            & 
1089                                           water_pars_f%np,                    &
1090                                           'nwater_pars' )
1091!           
1092!--             Allocate dimension array and input array for water parameters
1093                ALLOCATE( water_pars_f%pars(0:water_pars_f%np-1) )
1094                ALLOCATE( water_pars_f%pars_xy(0:water_pars_f%np-1,            &
1095                                               nys:nyn,nxl:nxr) )
1096!
1097!--             Get dimension of water parameters
1098                CALL get_variable( id_surf, 'nwater_pars', water_pars_f%pars )
1099
1100                DO  i = nxl, nxr
1101                   DO  j = nys, nyn
1102                      CALL get_variable( id_surf, 'water_pars', i, j,          &
1103                                         water_pars_f%pars_xy(:,j,i) )   
1104                   ENDDO
1105                ENDDO
1106             ELSE
1107                water_pars_f%from_file = .FALSE. 
1108             ENDIF
1109!
1110!--          Read root area density - parametrized vegetation
1111             IF ( check_existence( var_names, 'root_area_density_lsm' ) )  THEN
1112                root_area_density_lsm_f%from_file = .TRUE.
1113                CALL get_attribute( id_surf, char_fill,                        &
1114                                    root_area_density_lsm_f%fill,              &
1115                                    .FALSE., 'root_area_density_lsm' )
1116!
1117!--             Obtain number of soil layers from file and allocate variable
1118                CALL get_dimension_length( id_surf, root_area_density_lsm_f%nz,&
1119                                           'zsoil' )
1120                ALLOCATE( root_area_density_lsm_f%var                          &
1121                                              (0:root_area_density_lsm_f%nz-1, &
1122                                               nys:nyn,nxl:nxr) )
1123
1124!
1125!--             Read root-area density
1126                DO  i = nxl, nxr
1127                   DO  j = nys, nyn
1128                      CALL get_variable( id_surf, 'root_area_density_lsm',     &
1129                                         i, j,                                 &
1130                                         root_area_density_lsm_f%var(:,j,i) )   
1131                   ENDDO
1132                ENDDO
1133
1134             ELSE
1135                root_area_density_lsm_f%from_file = .FALSE.
1136             ENDIF
1137!
1138!--          Read street type and street crossing
1139             IF ( check_existence( var_names, 'street_type' ) )  THEN
1140                street_type_f%from_file = .TRUE. 
1141                CALL get_attribute( id_surf, char_fill,                        &
1142                                    street_type_f%fill, .FALSE.,               &
1143                                    'street_type' ) 
1144!
1145!--             PE-wise reading of 2D pavement type.
1146                ALLOCATE ( street_type_f%var(nys:nyn,nxl:nxr)  )
1147                DO  i = nxl, nxr
1148                   CALL get_variable( id_surf, 'street_type',                  &
1149                                      i, street_type_f%var(:,i) ) 
1150                ENDDO
1151             ELSE
1152                street_type_f%from_file = .FALSE.
1153             ENDIF
1154
1155             IF ( check_existence( var_names, 'street_crossing' ) )  THEN
1156                street_crossing_f%from_file = .TRUE. 
1157                CALL get_attribute( id_surf, char_fill,                        &
1158                                    street_crossing_f%fill, .FALSE.,           &
1159                                    'street_crossing' ) 
1160!
1161!--             PE-wise reading of 2D pavement type.
1162                ALLOCATE ( street_crossing_f%var(nys:nyn,nxl:nxr)  )
1163                DO  i = nxl, nxr
1164                   CALL get_variable( id_surf, 'street_crossing',              &
1165                                      i, street_crossing_f%var(:,i) ) 
1166                ENDDO
1167             ELSE
1168                street_crossing_f%from_file = .FALSE.
1169             ENDIF
1170!
1171!--          Still missing: root_resolved and building_surface_pars.
1172!--          Will be implemented as soon as they are available.
1173
1174!
1175!--          Finally, close input file
1176             CALL close_input_file( id_surf )
1177#endif
1178          ENDIF
1179#if defined( __parallel )
1180          CALL MPI_BARRIER( comm2d, ierr )
1181#endif
1182       ENDDO
1183!
1184!--    Exchange 1 ghost points for surface variables. Please note, ghost point
1185!--    exchange for 3D parameter lists should be revised by using additional
1186!--    MPI datatypes or rewriting exchange_horiz.
1187!--    Moreover, varialbes will be resized in the following, including ghost
1188!--    points.
1189!--    Start with 2D Integer variables. Please note, for 8-bit integer
1190!--    variables must be swapt to 32-bit integer before calling exchange_horiz.
1191       IF ( albedo_type_f%from_file )  THEN
1192          var_exchange_int                  = INT( albedo_type_f%fill, KIND = 1 )
1193          var_exchange_int(nys:nyn,nxl:nxr) =                                  &
1194                            INT( albedo_type_f%var(nys:nyn,nxl:nxr), KIND = 4 )
1195          CALL exchange_horiz_2d_int( var_exchange_int, nys, nyn, nxl, nxr, nbgp )
1196          DEALLOCATE( albedo_type_f%var )
1197          ALLOCATE( albedo_type_f%var(nysg:nyng,nxlg:nxrg) )
1198          albedo_type_f%var = INT( var_exchange_int, KIND = 1 )
1199       ENDIF
1200       IF ( pavement_type_f%from_file )  THEN
1201          var_exchange_int                  = INT( pavement_type_f%fill, KIND = 1 )
1202          var_exchange_int(nys:nyn,nxl:nxr) =                                  &
1203                          INT( pavement_type_f%var(nys:nyn,nxl:nxr), KIND = 4 )
1204          CALL exchange_horiz_2d_int( var_exchange_int, nys, nyn, nxl, nxr, nbgp )
1205          DEALLOCATE( pavement_type_f%var )
1206          ALLOCATE( pavement_type_f%var(nysg:nyng,nxlg:nxrg) )
1207          pavement_type_f%var = INT( var_exchange_int, KIND = 1 )
1208       ENDIF
1209       IF ( soil_type_f%from_file  .AND.  ALLOCATED( soil_type_f%var_2d ) )  THEN
1210          var_exchange_int                  = INT( soil_type_f%fill, KIND = 1 )
1211          var_exchange_int(nys:nyn,nxl:nxr) =                                  &
1212                            INT( soil_type_f%var_2d(nys:nyn,nxl:nxr), KIND = 4 )
1213          CALL exchange_horiz_2d_int( var_exchange_int, nys, nyn, nxl, nxr, nbgp )
1214          DEALLOCATE( soil_type_f%var_2d )
1215          ALLOCATE( soil_type_f%var_2d(nysg:nyng,nxlg:nxrg) )
1216          soil_type_f%var_2d = INT( var_exchange_int, KIND = 1 )
1217       ENDIF
1218       IF ( vegetation_type_f%from_file )  THEN
1219          var_exchange_int                  = INT( vegetation_type_f%fill, KIND = 1 )
1220          var_exchange_int(nys:nyn,nxl:nxr) =                                  &
1221                        INT( vegetation_type_f%var(nys:nyn,nxl:nxr), KIND = 4 )
1222          CALL exchange_horiz_2d_int( var_exchange_int, nys, nyn, nxl, nxr, nbgp )
1223          DEALLOCATE( vegetation_type_f%var )
1224          ALLOCATE( vegetation_type_f%var(nysg:nyng,nxlg:nxrg) )
1225          vegetation_type_f%var = INT( var_exchange_int, KIND = 1 )
1226       ENDIF
1227       IF ( water_type_f%from_file )  THEN
1228          var_exchange_int                  = INT( water_type_f%fill, KIND = 1 )
1229          var_exchange_int(nys:nyn,nxl:nxr) =                                  &
1230                         INT( water_type_f%var(nys:nyn,nxl:nxr), KIND = 4 )
1231          CALL exchange_horiz_2d_int( var_exchange_int, nys, nyn, nxl, nxr, nbgp )
1232          DEALLOCATE( water_type_f%var )
1233          ALLOCATE( water_type_f%var(nysg:nyng,nxlg:nxrg) )
1234          water_type_f%var = INT( var_exchange_int, KIND = 1 )
1235       ENDIF
1236!
1237!--    Exchange 1 ghost point for 3/4-D variables. For the sake of simplicity,
1238!--    loop further dimensions to use 2D exchange routines.
1239!--    This should be revised later by introducing new MPI datatypes.
1240       IF ( soil_type_f%from_file  .AND.  ALLOCATED( soil_type_f%var_3d ) )    &
1241       THEN
1242          ALLOCATE( var_dum_int_3d(0:nz_soil,nys:nyn,nxl:nxr) ) 
1243          var_dum_int_3d = soil_type_f%var_3d
1244          DEALLOCATE( soil_type_f%var_3d )
1245          ALLOCATE( soil_type_f%var_3d(0:nz_soil,nysg:nyng,nxlg:nxrg) )
1246          soil_type_f%var_3d = soil_type_f%fill
1247
1248          DO  k = 0, nz_soil
1249             var_exchange_int(nys:nyn,nxl:nxr) = var_dum_int_3d(k,nys:nyn,nxl:nxr)
1250             CALL exchange_horiz_2d_int( var_exchange_int, nys, nyn, nxl, nxr, nbgp )
1251             soil_type_f%var_3d(k,:,:) = INT( var_exchange_int(:,:), KIND = 1 )
1252          ENDDO
1253          DEALLOCATE( var_dum_int_3d )
1254       ENDIF
1255
1256       IF ( surface_fraction_f%from_file )  THEN
1257          ALLOCATE( var_dum_real_3d(0:surface_fraction_f%nf-1,nys:nyn,nxl:nxr) )
1258          var_dum_real_3d = surface_fraction_f%frac
1259          DEALLOCATE( surface_fraction_f%frac )
1260          ALLOCATE( surface_fraction_f%frac(0:surface_fraction_f%nf-1,         &
1261                                            nysg:nyng,nxlg:nxrg) )
1262          surface_fraction_f%frac = surface_fraction_f%fill
1263
1264          DO  k = 0, surface_fraction_f%nf-1
1265             var_exchange_real(nys:nyn,nxl:nxr) = var_dum_real_3d(k,nys:nyn,nxl:nxr)
1266             CALL exchange_horiz_2d( var_exchange_real, nbgp )
1267             surface_fraction_f%frac(k,:,:) = var_exchange_real(:,:)
1268          ENDDO
1269          DEALLOCATE( var_dum_real_3d )
1270       ENDIF
1271
1272       IF ( building_pars_f%from_file )  THEN
1273          ALLOCATE( var_dum_real_3d(0:building_pars_f%np-1,nys:nyn,nxl:nxr) )
1274          var_dum_real_3d = building_pars_f%pars_xy
1275          DEALLOCATE( building_pars_f%pars_xy )
1276          ALLOCATE( building_pars_f%pars_xy(0:building_pars_f%np-1,            &
1277                                            nysg:nyng,nxlg:nxrg) )
1278          building_pars_f%pars_xy = building_pars_f%fill
1279          DO  k = 0, building_pars_f%np-1
1280             var_exchange_real(nys:nyn,nxl:nxr) =                              &
1281                                              var_dum_real_3d(k,nys:nyn,nxl:nxr)
1282             CALL exchange_horiz_2d( var_exchange_real, nbgp )
1283             building_pars_f%pars_xy(k,:,:) = var_exchange_real(:,:)
1284          ENDDO
1285          DEALLOCATE( var_dum_real_3d )
1286       ENDIF
1287
1288       IF ( albedo_pars_f%from_file )  THEN
1289          ALLOCATE( var_dum_real_3d(0:albedo_pars_f%np-1,nys:nyn,nxl:nxr) )
1290          var_dum_real_3d = albedo_pars_f%pars_xy
1291          DEALLOCATE( albedo_pars_f%pars_xy )
1292          ALLOCATE( albedo_pars_f%pars_xy(0:albedo_pars_f%np-1,                &
1293                                          nysg:nyng,nxlg:nxrg) )
1294          albedo_pars_f%pars_xy = albedo_pars_f%fill
1295          DO  k = 0, albedo_pars_f%np-1
1296             var_exchange_real(nys:nyn,nxl:nxr) =                              &
1297                                              var_dum_real_3d(k,nys:nyn,nxl:nxr)
1298             CALL exchange_horiz_2d( var_exchange_real, nbgp )
1299             albedo_pars_f%pars_xy(k,:,:) = var_exchange_real(:,:)
1300          ENDDO
1301          DEALLOCATE( var_dum_real_3d )
1302       ENDIF
1303
1304       IF ( pavement_pars_f%from_file )  THEN
1305          ALLOCATE( var_dum_real_3d(0:pavement_pars_f%np-1,nys:nyn,nxl:nxr) )
1306          var_dum_real_3d = pavement_pars_f%pars_xy
1307          DEALLOCATE( pavement_pars_f%pars_xy )
1308          ALLOCATE( pavement_pars_f%pars_xy(0:pavement_pars_f%np-1,            &
1309                                            nysg:nyng,nxlg:nxrg) )
1310          pavement_pars_f%pars_xy = pavement_pars_f%fill
1311          DO  k = 0, pavement_pars_f%np-1
1312             var_exchange_real(nys:nyn,nxl:nxr) =                              &
1313                                              var_dum_real_3d(k,nys:nyn,nxl:nxr)
1314             CALL exchange_horiz_2d( var_exchange_real, nbgp )
1315             pavement_pars_f%pars_xy(k,:,:) = var_exchange_real(:,:)
1316          ENDDO
1317          DEALLOCATE( var_dum_real_3d )
1318       ENDIF
1319
1320       IF ( vegetation_pars_f%from_file )  THEN
1321          ALLOCATE( var_dum_real_3d(0:vegetation_pars_f%np-1,nys:nyn,nxl:nxr) )
1322          var_dum_real_3d = vegetation_pars_f%pars_xy
1323          DEALLOCATE( vegetation_pars_f%pars_xy )
1324          ALLOCATE( vegetation_pars_f%pars_xy(0:vegetation_pars_f%np-1,        &
1325                                            nysg:nyng,nxlg:nxrg) )
1326          vegetation_pars_f%pars_xy = vegetation_pars_f%fill
1327          DO  k = 0, vegetation_pars_f%np-1
1328             var_exchange_real(nys:nyn,nxl:nxr) =                              &
1329                                              var_dum_real_3d(k,nys:nyn,nxl:nxr)
1330             CALL exchange_horiz_2d( var_exchange_real, nbgp )
1331             vegetation_pars_f%pars_xy(k,:,:) = var_exchange_real(:,:)
1332          ENDDO
1333          DEALLOCATE( var_dum_real_3d )
1334       ENDIF
1335
1336       IF ( water_pars_f%from_file )  THEN
1337          ALLOCATE( var_dum_real_3d(0:water_pars_f%np-1,nys:nyn,nxl:nxr) )
1338          var_dum_real_3d = water_pars_f%pars_xy
1339          DEALLOCATE( water_pars_f%pars_xy )
1340          ALLOCATE( water_pars_f%pars_xy(0:water_pars_f%np-1,                  &
1341                                         nysg:nyng,nxlg:nxrg) )
1342          water_pars_f%pars_xy = water_pars_f%fill
1343          DO  k = 0, water_pars_f%np-1
1344             var_exchange_real(nys:nyn,nxl:nxr) =                              &
1345                                              var_dum_real_3d(k,nys:nyn,nxl:nxr)
1346             CALL exchange_horiz_2d( var_exchange_real, nbgp )
1347             water_pars_f%pars_xy(k,:,:) = var_exchange_real(:,:)
1348          ENDDO
1349          DEALLOCATE( var_dum_real_3d )
1350       ENDIF
1351
1352       IF ( root_area_density_lsm_f%from_file )  THEN
1353          ALLOCATE( var_dum_real_3d(0:root_area_density_lsm_f%nz-1,nys:nyn,nxl:nxr) )
1354          var_dum_real_3d = root_area_density_lsm_f%var
1355          DEALLOCATE( root_area_density_lsm_f%var )
1356          ALLOCATE( root_area_density_lsm_f%var(0:root_area_density_lsm_f%nz-1,&
1357                                                nysg:nyng,nxlg:nxrg) )
1358          root_area_density_lsm_f%var = root_area_density_lsm_f%fill
1359
1360          DO  k = 0, root_area_density_lsm_f%nz-1
1361             var_exchange_real(nys:nyn,nxl:nxr) =                              &
1362                                              var_dum_real_3d(k,nys:nyn,nxl:nxr)
1363             CALL exchange_horiz_2d( var_exchange_real, nbgp )
1364             root_area_density_lsm_f%var(k,:,:) = var_exchange_real(:,:)
1365          ENDDO
1366          DEALLOCATE( var_dum_real_3d )
1367       ENDIF
1368
1369       IF ( soil_pars_f%from_file )  THEN
1370          IF ( soil_pars_f%lod == 1 )  THEN
1371
1372             ALLOCATE( var_dum_real_3d(0:soil_pars_f%np-1,nys:nyn,nxl:nxr) )
1373             var_dum_real_3d = soil_pars_f%pars_xy
1374             DEALLOCATE( soil_pars_f%pars_xy )
1375             ALLOCATE( soil_pars_f%pars_xy(0:soil_pars_f%np-1,                 &
1376                                            nysg:nyng,nxlg:nxrg) )
1377             soil_pars_f%pars_xy = soil_pars_f%fill
1378
1379             DO  k = 0, soil_pars_f%np-1
1380                var_exchange_real(nys:nyn,nxl:nxr) =                           &
1381                                              var_dum_real_3d(k,nys:nyn,nxl:nxr)
1382                CALL exchange_horiz_2d( var_exchange_real, nbgp )
1383                soil_pars_f%pars_xy(k,:,:) = var_exchange_real(:,:)
1384             ENDDO
1385             DEALLOCATE( var_dum_real_3d )
1386          ELSEIF ( soil_pars_f%lod == 2 )  THEN
1387             ALLOCATE( var_dum_real_4d(0:soil_pars_f%np-1,                     &
1388                                       0:soil_pars_f%nz-1,                     &
1389                                       nys:nyn,nxl:nxr) )
1390             var_dum_real_4d = soil_pars_f%pars_xyz
1391             DEALLOCATE( soil_pars_f%pars_xyz )
1392             ALLOCATE( soil_pars_f%pars_xyz(0:soil_pars_f%np-1,                &
1393                                            0:soil_pars_f%nz-1,                &
1394                                            nysg:nyng,nxlg:nxrg) )
1395             soil_pars_f%pars_xyz = soil_pars_f%fill
1396
1397             DO  k2 = 0, soil_pars_f%nz-1
1398                DO  k = 0, soil_pars_f%np-1
1399                   var_exchange_real(nys:nyn,nxl:nxr) =                        &
1400                                           var_dum_real_4d(k,k2,nys:nyn,nxl:nxr)
1401                   CALL exchange_horiz_2d( var_exchange_real, nbgp )
1402
1403                   soil_pars_f%pars_xyz(k,k2,:,:) = var_exchange_real(:,:)
1404                ENDDO
1405             ENDDO
1406             DEALLOCATE( var_dum_real_4d )
1407          ENDIF
1408       ENDIF
1409
1410       IF ( pavement_subsurface_pars_f%from_file )  THEN
1411          ALLOCATE( var_dum_real_4d(0:pavement_subsurface_pars_f%np-1,         &
1412                                    0:pavement_subsurface_pars_f%nz-1,         &
1413                                    nys:nyn,nxl:nxr) )
1414          var_dum_real_4d = pavement_subsurface_pars_f%pars_xyz
1415          DEALLOCATE( pavement_subsurface_pars_f%pars_xyz )
1416          ALLOCATE( pavement_subsurface_pars_f%pars_xyz                        &
1417                                          (0:pavement_subsurface_pars_f%np-1,  &
1418                                           0:pavement_subsurface_pars_f%nz-1,  &
1419                                           nysg:nyng,nxlg:nxrg) )
1420          pavement_subsurface_pars_f%pars_xyz = pavement_subsurface_pars_f%fill
1421
1422          DO  k2 = 0, pavement_subsurface_pars_f%nz-1
1423             DO  k = 0, pavement_subsurface_pars_f%np-1
1424                var_exchange_real(nys:nyn,nxl:nxr) =                           &
1425                                          var_dum_real_4d(k,k2,nys:nyn,nxl:nxr)
1426                CALL exchange_horiz_2d( var_exchange_real, nbgp )
1427                pavement_subsurface_pars_f%pars_xyz(k,k2,:,:) =                &
1428                                                        var_exchange_real(:,:)
1429             ENDDO
1430          ENDDO
1431          DEALLOCATE( var_dum_real_4d )
1432       ENDIF
1433
1434!
1435!--    In case of non-cyclic boundary conditions, set Neumann conditions at the
1436!--    lateral boundaries.
1437       IF ( .NOT. bc_ns_cyc )  THEN
1438          IF ( nys == 0  )  THEN
1439             IF ( albedo_type_f%from_file )                                    &
1440                albedo_type_f%var(-1,:) = albedo_type_f%var(0,:)
1441             IF ( pavement_type_f%from_file )                                  &
1442                pavement_type_f%var(-1,:) = pavement_type_f%var(0,:)
1443             IF ( soil_type_f%from_file )  THEN
1444                IF ( ALLOCATED( soil_type_f%var_2d ) )  THEN
1445                   soil_type_f%var_2d(-1,:) = soil_type_f%var_2d(0,:)
1446                ELSE
1447                   soil_type_f%var_3d(:,-1,:) = soil_type_f%var_3d(:,0,:)
1448                ENDIF
1449             ENDIF
1450             IF ( vegetation_type_f%from_file )                                &
1451                vegetation_type_f%var(-1,:) = vegetation_type_f%var(0,:)
1452             IF ( water_type_f%from_file )                                     &
1453                water_type_f%var(-1,:) = water_type_f%var(0,:)
1454             IF ( surface_fraction_f%from_file )                               &
1455                surface_fraction_f%frac(:,-1,:) = surface_fraction_f%frac(:,0,:)
1456             IF ( building_pars_f%from_file )                                  &
1457                building_pars_f%pars_xy(:,-1,:) = building_pars_f%pars_xy(:,0,:)
1458             IF ( albedo_pars_f%from_file )                                    &
1459                albedo_pars_f%pars_xy(:,-1,:) = albedo_pars_f%pars_xy(:,0,:)
1460             IF ( pavement_pars_f%from_file )                                  &
1461                pavement_pars_f%pars_xy(:,-1,:) = pavement_pars_f%pars_xy(:,0,:)
1462             IF ( vegetation_pars_f%from_file )                                &
1463                vegetation_pars_f%pars_xy(:,-1,:) =                            &
1464                                               vegetation_pars_f%pars_xy(:,0,:)
1465             IF ( water_pars_f%from_file )                                     &
1466                water_pars_f%pars_xy(:,-1,:) = water_pars_f%pars_xy(:,0,:)
1467             IF ( root_area_density_lsm_f%from_file )                          &
1468                root_area_density_lsm_f%var(:,-1,:) =                          &
1469                                            root_area_density_lsm_f%var(:,0,:)
1470             IF ( soil_pars_f%from_file )  THEN
1471                IF ( soil_pars_f%lod == 1 )  THEN
1472                   soil_pars_f%pars_xy(:,-1,:) = soil_pars_f%pars_xy(:,0,:)
1473                ELSE
1474                   soil_pars_f%pars_xyz(:,:,-1,:) = soil_pars_f%pars_xyz(:,:,0,:)
1475                ENDIF
1476             ENDIF
1477             IF ( pavement_subsurface_pars_f%from_file )                       &
1478                pavement_subsurface_pars_f%pars_xyz(:,:,-1,:) =                &
1479                                   pavement_subsurface_pars_f%pars_xyz(:,:,0,:)
1480          ENDIF
1481
1482          IF ( nyn == ny )  THEN
1483             IF ( albedo_type_f%from_file )                                    &
1484                albedo_type_f%var(ny+1,:) = albedo_type_f%var(ny,:)
1485             IF ( pavement_type_f%from_file )                                  &
1486                pavement_type_f%var(ny+1,:) = pavement_type_f%var(ny,:)
1487             IF ( soil_type_f%from_file )  THEN
1488                IF ( ALLOCATED( soil_type_f%var_2d ) )  THEN
1489                   soil_type_f%var_2d(ny+1,:) = soil_type_f%var_2d(ny,:)
1490                ELSE
1491                   soil_type_f%var_3d(:,ny+1,:) = soil_type_f%var_3d(:,ny,:)
1492                ENDIF
1493             ENDIF
1494             IF ( vegetation_type_f%from_file )                                &
1495                vegetation_type_f%var(ny+1,:) = vegetation_type_f%var(ny,:)
1496             IF ( water_type_f%from_file )                                     &
1497                water_type_f%var(ny+1,:) = water_type_f%var(ny,:)
1498             IF ( surface_fraction_f%from_file )                               &
1499                surface_fraction_f%frac(:,ny+1,:) =                            &
1500                                             surface_fraction_f%frac(:,ny,:)
1501             IF ( building_pars_f%from_file )                                  &
1502                building_pars_f%pars_xy(:,ny+1,:) =                            &
1503                                             building_pars_f%pars_xy(:,ny,:)
1504             IF ( albedo_pars_f%from_file )                                    &
1505                albedo_pars_f%pars_xy(:,ny+1,:) = albedo_pars_f%pars_xy(:,ny,:)
1506             IF ( pavement_pars_f%from_file )                                  &
1507                pavement_pars_f%pars_xy(:,ny+1,:) =                            &
1508                                             pavement_pars_f%pars_xy(:,ny,:)
1509             IF ( vegetation_pars_f%from_file )                                &
1510                vegetation_pars_f%pars_xy(:,ny+1,:) =                          &
1511                                               vegetation_pars_f%pars_xy(:,ny,:)
1512             IF ( water_pars_f%from_file )                                     &
1513                water_pars_f%pars_xy(:,ny+1,:) = water_pars_f%pars_xy(:,ny,:)
1514             IF ( root_area_density_lsm_f%from_file )                          &
1515                root_area_density_lsm_f%var(:,ny+1,:) =                        &
1516                                            root_area_density_lsm_f%var(:,ny,:)
1517             IF ( soil_pars_f%from_file )  THEN
1518                IF ( soil_pars_f%lod == 1 )  THEN
1519                   soil_pars_f%pars_xy(:,ny+1,:) = soil_pars_f%pars_xy(:,ny,:)
1520                ELSE
1521                   soil_pars_f%pars_xyz(:,:,ny+1,:) =                          &
1522                                              soil_pars_f%pars_xyz(:,:,ny,:)
1523                ENDIF
1524             ENDIF
1525             IF ( pavement_subsurface_pars_f%from_file )                       &
1526                pavement_subsurface_pars_f%pars_xyz(:,:,ny+1,:) =              &
1527                                   pavement_subsurface_pars_f%pars_xyz(:,:,ny,:)
1528          ENDIF
1529       ENDIF
1530
1531       IF ( .NOT. bc_lr_cyc )  THEN
1532          IF ( nxl == 0 )  THEN
1533            IF ( albedo_type_f%from_file )                                     &
1534                albedo_type_f%var(:,-1) = albedo_type_f%var(:,0)
1535             IF ( pavement_type_f%from_file )                                  &
1536                pavement_type_f%var(:,-1) = pavement_type_f%var(:,0)
1537             IF ( soil_type_f%from_file )  THEN
1538                IF ( ALLOCATED( soil_type_f%var_2d ) )  THEN
1539                   soil_type_f%var_2d(:,-1) = soil_type_f%var_2d(:,0)
1540                ELSE
1541                   soil_type_f%var_3d(:,:,-1) = soil_type_f%var_3d(:,:,0)
1542                ENDIF
1543             ENDIF
1544             IF ( vegetation_type_f%from_file )                                &
1545                vegetation_type_f%var(:,-1) = vegetation_type_f%var(:,0)
1546             IF ( water_type_f%from_file )                                     &
1547                water_type_f%var(:,-1) = water_type_f%var(:,0)
1548             IF ( surface_fraction_f%from_file )                               &
1549                surface_fraction_f%frac(:,:,-1) = surface_fraction_f%frac(:,:,0)
1550             IF ( building_pars_f%from_file )                                  &
1551                building_pars_f%pars_xy(:,:,-1) = building_pars_f%pars_xy(:,:,0)
1552             IF ( albedo_pars_f%from_file )                                    &
1553                albedo_pars_f%pars_xy(:,:,-1) = albedo_pars_f%pars_xy(:,:,0)
1554             IF ( pavement_pars_f%from_file )                                  &
1555                pavement_pars_f%pars_xy(:,:,-1) = pavement_pars_f%pars_xy(:,:,0)
1556             IF ( vegetation_pars_f%from_file )                                &
1557                vegetation_pars_f%pars_xy(:,:,-1) =                            &
1558                                               vegetation_pars_f%pars_xy(:,:,0)
1559             IF ( water_pars_f%from_file )                                     &
1560                water_pars_f%pars_xy(:,:,-1) = water_pars_f%pars_xy(:,:,0)
1561             IF ( root_area_density_lsm_f%from_file )                          &
1562                root_area_density_lsm_f%var(:,:,-1) =                          &
1563                                            root_area_density_lsm_f%var(:,:,0)
1564             IF ( soil_pars_f%from_file )  THEN
1565                IF ( soil_pars_f%lod == 1 )  THEN
1566                   soil_pars_f%pars_xy(:,:,-1) = soil_pars_f%pars_xy(:,:,0)
1567                ELSE
1568                   soil_pars_f%pars_xyz(:,:,:,-1) = soil_pars_f%pars_xyz(:,:,:,0)
1569                ENDIF
1570             ENDIF
1571             IF ( pavement_subsurface_pars_f%from_file )                       &
1572                pavement_subsurface_pars_f%pars_xyz(:,:,:,-1) =                &
1573                                    pavement_subsurface_pars_f%pars_xyz(:,:,:,0)
1574          ENDIF
1575
1576          IF ( nxr == nx )  THEN
1577             IF ( albedo_type_f%from_file )                                    &
1578                albedo_type_f%var(:,nx+1) = albedo_type_f%var(:,nx)
1579             IF ( pavement_type_f%from_file )                                  &
1580                pavement_type_f%var(:,nx+1) = pavement_type_f%var(:,nx)
1581             IF ( soil_type_f%from_file )  THEN
1582                IF ( ALLOCATED( soil_type_f%var_2d ) )  THEN
1583                   soil_type_f%var_2d(:,nx+1) = soil_type_f%var_2d(:,nx)
1584                ELSE
1585                   soil_type_f%var_3d(:,:,nx+1) = soil_type_f%var_3d(:,:,nx)
1586                ENDIF
1587             ENDIF
1588             IF ( vegetation_type_f%from_file )                                &
1589                vegetation_type_f%var(:,nx+1) = vegetation_type_f%var(:,nx)
1590             IF ( water_type_f%from_file )                                     &
1591                water_type_f%var(:,nx+1) = water_type_f%var(:,nx)
1592             IF ( surface_fraction_f%from_file )                               &
1593                surface_fraction_f%frac(:,:,nx+1) =                            &
1594                                             surface_fraction_f%frac(:,:,nx)
1595             IF ( building_pars_f%from_file )                                  &
1596                building_pars_f%pars_xy(:,:,nx+1) =                            &
1597                                             building_pars_f%pars_xy(:,:,nx)
1598             IF ( albedo_pars_f%from_file )                                    &
1599                albedo_pars_f%pars_xy(:,:,nx+1) = albedo_pars_f%pars_xy(:,:,nx)
1600             IF ( pavement_pars_f%from_file )                                  &
1601                pavement_pars_f%pars_xy(:,:,nx+1) =                            &
1602                                             pavement_pars_f%pars_xy(:,:,nx)
1603             IF ( vegetation_pars_f%from_file )                                &
1604                vegetation_pars_f%pars_xy(:,:,nx+1) =                          &
1605                                               vegetation_pars_f%pars_xy(:,:,nx)
1606             IF ( water_pars_f%from_file )                                     &
1607                water_pars_f%pars_xy(:,:,nx+1) = water_pars_f%pars_xy(:,:,nx)
1608             IF ( root_area_density_lsm_f%from_file )                          &
1609                root_area_density_lsm_f%var(:,:,nx+1) =                        &
1610                                            root_area_density_lsm_f%var(:,:,nx)
1611             IF ( soil_pars_f%from_file )  THEN
1612                IF ( soil_pars_f%lod == 1 )  THEN
1613                   soil_pars_f%pars_xy(:,:,nx+1) = soil_pars_f%pars_xy(:,:,nx)
1614                ELSE
1615                   soil_pars_f%pars_xyz(:,:,:,nx+1) =                          &
1616                                              soil_pars_f%pars_xyz(:,:,:,nx)
1617                ENDIF
1618             ENDIF
1619             IF ( pavement_subsurface_pars_f%from_file )                       &
1620                pavement_subsurface_pars_f%pars_xyz(:,:,:,nx+1) =              &
1621                                   pavement_subsurface_pars_f%pars_xyz(:,:,:,nx)
1622          ENDIF
1623       ENDIF
1624
1625    END SUBROUTINE netcdf_data_input_surface_data
1626
1627!------------------------------------------------------------------------------!
1628! Description:
1629! ------------
1630!> Reads orography and building information.
1631!------------------------------------------------------------------------------!
1632    SUBROUTINE netcdf_data_input_topo
1633
1634       USE control_parameters,                                                 &
1635           ONLY:  bc_lr_cyc, bc_ns_cyc, message_string, topography
1636
1637       USE indices,                                                            &
1638           ONLY:  nbgp, nx, nxl, nxr, ny, nyn, nys, nzb, nzt
1639                 
1640
1641       IMPLICIT NONE
1642
1643       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names  !< variable names in static input file
1644
1645
1646       INTEGER(iwp) ::  i             !< running index along x-direction
1647       INTEGER(iwp) ::  ii            !< running index for IO blocks
1648       INTEGER(iwp) ::  id_topo       !< NetCDF id of topograhy input file
1649       INTEGER(iwp) ::  j             !< running index along y-direction
1650       INTEGER(iwp) ::  k             !< running index along z-direction
1651       INTEGER(iwp) ::  num_vars      !< number of variables in netcdf input file
1652       INTEGER(iwp) ::  skip_n_rows   !< counting variable to skip rows while reading topography file
1653
1654       INTEGER(iwp), DIMENSION(nys-nbgp:nyn+nbgp,nxl-nbgp:nxr+nbgp) ::  var_exchange_int !< dummy variables used to exchange 32-bit Integer arrays
1655
1656       REAL(wp) ::  dum           !< dummy variable to skip columns while reading topography file   
1657
1658       IF ( TRIM( topography ) /= 'read_from_file' )  RETURN
1659
1660       DO  ii = 0, io_blocks-1
1661          IF ( ii == io_group )  THEN
1662!
1663!--          Input via palm-input data standard
1664             IF ( input_pids_static )  THEN
1665#if defined ( __netcdf )
1666!
1667!--             Open file in read-only mode
1668                CALL open_read_file( TRIM( input_file_static ) //              &
1669                                     TRIM( coupling_char ), id_topo ) 
1670
1671!
1672!--             At first, inquire all variable names.
1673!--             This will be used to check whether an  input variable exist
1674!--             or not.
1675                CALL inquire_num_variables( id_topo, num_vars )
1676!
1677!--             Allocate memory to store variable names and inquire them.
1678                ALLOCATE( var_names(1:num_vars) )
1679                CALL inquire_variable_names( id_topo, var_names )
1680!
1681!--             Read x, y - dimensions
1682                CALL get_dimension_length( id_topo, dim_static%nx, 'x' )
1683                CALL get_dimension_length( id_topo, dim_static%ny, 'y' )
1684                ALLOCATE( dim_static%x(0:dim_static%nx-1) )
1685                ALLOCATE( dim_static%y(0:dim_static%ny-1) )
1686                CALL get_variable( id_topo, 'x', dim_static%x )
1687                CALL get_variable( id_topo, 'y', dim_static%y )
1688!
1689!--             Terrain height. First, get variable-related _FillValue attribute
1690                IF ( check_existence( var_names, 'orography_2D' ) )  THEN
1691                   terrain_height_f%from_file = .TRUE. 
1692                   CALL get_attribute( id_topo, char_fill,                     &
1693                                       terrain_height_f%fill,                  &
1694                                       .FALSE., 'orography_2D' ) 
1695!
1696!--                PE-wise reading of 2D terrain height.
1697                   ALLOCATE ( terrain_height_f%var(nys:nyn,nxl:nxr)  )
1698                   DO  i = nxl, nxr
1699                      CALL get_variable( id_topo, 'orography_2D',              &
1700                                         i, terrain_height_f%var(:,i) ) 
1701                   ENDDO
1702                ELSE
1703                   terrain_height_f%from_file = .FALSE. 
1704                ENDIF
1705
1706!
1707!--             Read building height. First, read its _FillValue attribute,
1708!--             as well as lod attribute
1709                buildings_f%from_file = .FALSE. 
1710                IF ( check_existence( var_names, 'buildings_2D' ) )  THEN
1711                   buildings_f%from_file = .TRUE. 
1712                   CALL get_attribute( id_topo, char_lod, buildings_f%lod,     &
1713                                       .FALSE., 'buildings_2D' )     
1714
1715                   CALL get_attribute( id_topo, char_fill,                     &
1716                                       buildings_f%fill1,                      &
1717                                       .FALSE., 'buildings_2D' )
1718
1719!
1720!--                Read 2D topography
1721                   IF ( buildings_f%lod == 1 )  THEN
1722                      ALLOCATE ( buildings_f%var_2d(nys:nyn,nxl:nxr) )
1723                      DO  i = nxl, nxr
1724                         CALL get_variable( id_topo, 'buildings_2D',           &
1725                                            i, buildings_f%var_2d(:,i) ) 
1726                      ENDDO
1727                   ELSE
1728                      message_string = 'NetCDF attribute lod ' //              &
1729                                       '(level of detail) is not set ' //      &
1730                                       'properly for buildings_2D.'
1731                      CALL message( 'netcdf_data_input_mod', 'NDI000',         &
1732                                     1, 2, 0, 6, 0 )
1733                   ENDIF
1734                ENDIF
1735!
1736!--             If available, also read 3D building information. If both are
1737!--             available, use 3D information.
1738                IF ( check_existence( var_names, 'buildings_3D' ) )  THEN
1739                   buildings_f%from_file = .TRUE. 
1740                   CALL get_attribute( id_topo, char_lod, buildings_f%lod,     &
1741                                       .FALSE., 'buildings_3D' )     
1742
1743                   CALL get_attribute( id_topo, char_fill,                     &
1744                                       buildings_f%fill2,                      &
1745                                       .FALSE., 'buildings_3D' )
1746
1747                   CALL get_dimension_length( id_topo, buildings_f%nz, 'z' )
1748 
1749                   IF ( buildings_f%lod == 2 )  THEN
1750                      ALLOCATE( buildings_f%z(nzb:buildings_f%nz-1) )
1751                      CALL get_variable( id_topo, 'z', buildings_f%z )
1752
1753                      ALLOCATE( buildings_f%var_3d(nzb:buildings_f%nz-1,       &
1754                                                   nys:nyn,nxl:nxr) )
1755                      buildings_f%var_3d = 0
1756!
1757!--                   Read data PE-wise. Read yz-slices.
1758                      DO  i = nxl, nxr
1759                         DO  j = nys, nyn
1760                            CALL get_variable( id_topo, 'buildings_3D',        &
1761                                               i, j,                           &
1762                                               buildings_f%var_3d(:,j,i) )
1763                         ENDDO
1764                      ENDDO
1765                   ELSE
1766                      message_string = 'NetCDF attribute lod ' //              &
1767                                       '(level of detail) is not set ' //      &
1768                                       'properly for buildings_3D.'
1769                      CALL message( 'netcdf_data_input_mod', 'NDI001',         &
1770                                     1, 2, 0, 6, 0 )
1771                   ENDIF
1772                ENDIF
1773!
1774!--             Read building IDs and its FillValue attribute. Further required
1775!--             for mapping buildings on top of orography.
1776                IF ( check_existence( var_names, 'building_id' ) )  THEN
1777                   building_id_f%from_file = .TRUE. 
1778                   CALL get_attribute( id_topo, char_fill,                     &
1779                                       building_id_f%fill, .FALSE.,            &
1780                                       'building_id' )
1781             
1782
1783                   ALLOCATE ( building_id_f%var(nys:nyn,nxl:nxr) )
1784                   DO  i = nxl, nxr
1785                      CALL get_variable( id_topo, 'building_id',               &
1786                                          i, building_id_f%var(:,i) ) 
1787                   ENDDO
1788                ELSE
1789                   building_id_f%from_file = .FALSE. 
1790                ENDIF
1791!
1792!--             Read building_type and required attributes.
1793                IF ( check_existence( var_names, 'building_type' ) )  THEN
1794                   building_type_f%from_file = .TRUE. 
1795                   CALL get_attribute( id_topo, char_fill,                     &
1796                                       building_type_f%fill, .FALSE.,          &
1797                                       'building_type' ) 
1798               
1799                   ALLOCATE ( building_type_f%var(nys:nyn,nxl:nxr) )
1800                   DO  i = nxl, nxr
1801                      CALL get_variable( id_topo, 'building_type',             &
1802                                         i, building_type_f%var(:,i) )
1803                   ENDDO
1804                ELSE
1805                   building_type_f%from_file = .FALSE.
1806                ENDIF
1807
1808!
1809!--             Close topography input file
1810                CALL close_input_file( id_topo )
1811#else
1812                CONTINUE
1813#endif
1814!
1815!--          ASCII input
1816             ELSE
1817
1818                OPEN( 90, FILE='TOPOGRAPHY_DATA'//TRIM( coupling_char ),       &
1819                      STATUS='OLD', FORM='FORMATTED', ERR=10 )
1820!
1821!--             Read topography PE-wise. Rows are read from nyn to nys, columns
1822!--             are read from nxl to nxr. At first, ny-nyn rows need to be skipped.
1823                skip_n_rows = 0
1824                DO WHILE ( skip_n_rows < ny - nyn )
1825                   READ( 90, * ) 
1826                   skip_n_rows = skip_n_rows + 1
1827                ENDDO
1828!
1829!--             Read data from nyn to nys and nxl to nxr. Therefore, skip
1830!--             column until nxl-1 is reached
1831                ALLOCATE ( buildings_f%var_2d(nys:nyn,nxl:nxr) )
1832                DO  j = nyn, nys, -1
1833                   READ( 90, *, ERR=11, END=11 )                               &
1834                                   ( dum, i = 0, nxl-1 ),                      &
1835                                   ( buildings_f%var_2d(j,i), i = nxl, nxr )
1836                ENDDO
1837
1838                GOTO 12
1839         
1840 10             message_string = 'file TOPOGRAPHY'//TRIM( coupling_char )//    &
1841                                 ' does not exist'
1842                CALL message( 'netcdf_data_input_mod', 'PA0208', 1, 2, 0, 6, 0 )
1843
1844 11             message_string = 'errors in file TOPOGRAPHY_DATA'//            &
1845                                 TRIM( coupling_char )
1846                CALL message( 'netcdf_data_input_mod', 'PA0209', 1, 2, 0, 6, 0 )
1847
1848 12             CLOSE( 90 )
1849                buildings_f%from_file = .TRUE.
1850
1851             ENDIF
1852
1853          ENDIF
1854#if defined( __parallel )
1855          CALL MPI_BARRIER( comm2d, ierr )
1856#endif
1857       ENDDO
1858!
1859!--    Check for minimum requirement to setup building topography. If buildings
1860!--    are provided, also an ID and a type are required.
1861!--    Note, doing this check in check_parameters
1862!--    will be too late (data will be used for grid inititialization before).
1863       IF ( input_pids_static )  THEN
1864          IF ( buildings_f%from_file  .AND.                                    &
1865               .NOT. building_id_f%from_file )  THEN                       
1866             message_string = 'If building heigths are prescribed in ' //      &
1867                              'static input file, also an ID is required.'
1868             CALL message( 'netcdf_data_input_mod', 'NDI002', 1, 2, 0, 6, 0 )
1869          ENDIF
1870       ENDIF
1871!
1872!--    In case no terrain height is provided by static input file, allocate
1873!--    array nevertheless and set terrain height to 0, which simplifies
1874!--    topography initialization.
1875       IF ( .NOT. terrain_height_f%from_file )  THEN
1876          ALLOCATE ( terrain_height_f%var(nys:nyn,nxl:nxr) )
1877          terrain_height_f%var = 0.0_wp
1878       ENDIF
1879!
1880!--    Finally, exchange 1 ghost point for building ID and type.
1881!--    In case of non-cyclic boundary conditions set Neumann conditions at the
1882!--    lateral boundaries.
1883       IF ( building_id_f%from_file )  THEN
1884          var_exchange_int                  = building_id_f%fill
1885          var_exchange_int(nys:nyn,nxl:nxr) = building_id_f%var(nys:nyn,nxl:nxr)
1886          CALL exchange_horiz_2d_int( var_exchange_int, nys, nyn, nxl, nxr, nbgp )
1887          DEALLOCATE( building_id_f%var )
1888          ALLOCATE( building_id_f%var(nys-nbgp:nyn+nbgp,nxl-nbgp:nxr+nbgp) )
1889          building_id_f%var = var_exchange_int
1890
1891          IF ( .NOT. bc_ns_cyc )  THEN
1892             IF ( nys == 0  )  building_id_f%var(-1,:)   = building_id_f%var(0,:)
1893             IF ( nyn == ny )  building_id_f%var(ny+1,:) = building_id_f%var(ny,:)
1894          ENDIF
1895          IF ( .NOT. bc_lr_cyc )  THEN
1896             IF ( nxl == 0  )  building_id_f%var(:,-1)   = building_id_f%var(:,0) 
1897             IF ( nxr == nx )  building_id_f%var(:,nx+1) = building_id_f%var(:,nx)       
1898          ENDIF
1899       ENDIF
1900
1901       IF ( building_type_f%from_file )  THEN
1902          var_exchange_int                  = INT( building_type_f%fill, KIND = 4 )
1903          var_exchange_int(nys:nyn,nxl:nxr) =                                  &
1904                          INT( building_type_f%var(nys:nyn,nxl:nxr), KIND = 4 )
1905          CALL exchange_horiz_2d_int( var_exchange_int, nys, nyn, nxl, nxr, nbgp )
1906          DEALLOCATE( building_type_f%var )
1907          ALLOCATE( building_type_f%var(nys-nbgp:nyn+nbgp,nxl-nbgp:nxr+nbgp) )
1908          building_type_f%var = INT( var_exchange_int, KIND = 1 )
1909
1910          IF ( .NOT. bc_ns_cyc )  THEN
1911             IF ( nys == 0  )  building_type_f%var(-1,:)   = building_type_f%var(0,:)
1912             IF ( nyn == ny )  building_type_f%var(ny+1,:) = building_type_f%var(ny,:)
1913          ENDIF
1914          IF ( .NOT. bc_lr_cyc )  THEN
1915             IF ( nxl == 0  )  building_type_f%var(:,-1)   = building_type_f%var(:,0) 
1916             IF ( nxr == nx )  building_type_f%var(:,nx+1) = building_type_f%var(:,nx)       
1917          ENDIF
1918       ENDIF
1919
1920    END SUBROUTINE netcdf_data_input_topo
1921
1922!------------------------------------------------------------------------------!
1923! Description:
1924! ------------
1925!> Reads initialization data of u, v, w, pt, q, geostrophic wind components,
1926!> as well as soil moisture and soil temperature, derived from larger-scale
1927!> model (COSMO) by Inifor.
1928!------------------------------------------------------------------------------!
1929    SUBROUTINE netcdf_data_input_init_3d
1930
1931       USE arrays_3d,                                                          &
1932           ONLY:  q, pt, u, v, w
1933
1934       USE control_parameters,                                                 &
1935           ONLY:  bc_lr_cyc, bc_ns_cyc, forcing, humidity, land_surface,       &
1936                  message_string, neutral, surface_pressure
1937
1938       USE indices,                                                            &
1939           ONLY:  nx, nxl, nxlu, nxr, ny, nyn, nys, nysv, nzb, nzt
1940
1941       IMPLICIT NONE
1942
1943       CHARACTER(LEN=100), DIMENSION(:), ALLOCATABLE ::  var_names
1944
1945       INTEGER(iwp) ::  i          !< running index along x-direction
1946       INTEGER(iwp) ::  ii         !< running index for IO blocks
1947       INTEGER(iwp) ::  id_dynamic !< NetCDF id of dynamic input file
1948       INTEGER(iwp) ::  j          !< running index along y-direction
1949       INTEGER(iwp) ::  k          !< running index along z-direction
1950       INTEGER(iwp) ::  num_vars   !< number of variables in netcdf input file
1951       INTEGER(iwp) ::  off_i      !< offset in x-direction used for reading the u-component
1952       INTEGER(iwp) ::  off_j      !< offset in y-direction used for reading the v-component
1953
1954!
1955!--    Skip routine if no input file with dynamic input data is available.
1956       IF ( .NOT. input_pids_dynamic )  RETURN
1957!
1958!--    Please note, Inifor is designed to provide initial data for u and v for
1959!--    the prognostic grid points in case of lateral Dirichlet conditions.
1960!--    This means that Inifor provides data from nxlu:nxr (for u) and
1961!--    from nysv:nyn (for v) at the left and south domain boundary, respectively.
1962!--    However, as work-around for the moment, PALM will run with cyclic
1963!--    conditions and will be initialized with data provided by Inifor
1964!--    boundaries in case of Dirichlet.
1965!--    Hence, simply set set nxlu/nysv to 1 (will be reset to its original value
1966!--    at the end of this routine.
1967       IF ( bc_lr_cyc  .AND.  nxl == 0 )  nxlu = 1 
1968       IF ( bc_ns_cyc  .AND.  nys == 0 )  nysv = 1
1969
1970       DO  ii = 0, io_blocks-1
1971          IF ( ii == io_group )  THEN
1972#if defined ( __netcdf )
1973!
1974!--          Open file in read-only mode
1975             CALL open_read_file( TRIM( input_file_dynamic ) //                &
1976                                  TRIM( coupling_char ), id_dynamic ) 
1977
1978!
1979!--          At first, inquire all variable names.
1980             CALL inquire_num_variables( id_dynamic, num_vars )
1981!
1982!--          Allocate memory to store variable names.
1983             ALLOCATE( var_names(1:num_vars) )
1984             CALL inquire_variable_names( id_dynamic, var_names )
1985!
1986!--          Read vertical dimension of scalar und w grid. Will be used for
1987!--          inter- and extrapolation in case of stretched numeric grid.
1988!--          This will be removed when Inifor is able to handle stretched grids.
1989             CALL get_dimension_length( id_dynamic, init_3d%nzu, 'z'     )
1990             CALL get_dimension_length( id_dynamic, init_3d%nzw, 'zw'    )
1991             CALL get_dimension_length( id_dynamic, init_3d%nzs, 'depth' )
1992!
1993!--          Read also the horizontal dimensions. These are used just used fo
1994!--          checking the compatibility with the PALM grid before reading.
1995             CALL get_dimension_length( id_dynamic, init_3d%nx,  'x'  )
1996             CALL get_dimension_length( id_dynamic, init_3d%nxu, 'xu' )
1997             CALL get_dimension_length( id_dynamic, init_3d%ny,  'y'  )
1998             CALL get_dimension_length( id_dynamic, init_3d%nyv, 'yv' )
1999!
2000!--          Check for correct horizontal dimension. Please note, u- and v-grid
2001!--          hase 1 grid point less on Inifor grid.
2002             IF ( init_3d%nx-1 /= nx  .OR.  init_3d%nxu-1 /= nx - 1  .OR.      &
2003                  init_3d%ny-1 /= ny  .OR.  init_3d%nyv-1 /= ny - 1 )  THEN
2004                message_string = 'Number of inifor grid points does not '  //  &
2005                                 'match the number of numeric grid points.'
2006                CALL message( 'netcdf_data_input_mod', 'NDI003', 1, 2, 0, 6, 0 )
2007             ENDIF
2008!
2009!--          Read vertical dimensions. Later, these are required for eventual
2010!--          inter- and extrapolations of the initialization data.
2011             IF ( check_existence( var_names, 'z' ) )  THEN
2012                ALLOCATE( init_3d%zu_atmos(1:init_3d%nzu) )
2013                CALL get_variable( id_dynamic, 'z', init_3d%zu_atmos )
2014             ENDIF
2015             IF ( check_existence( var_names, 'zw' ) )  THEN
2016                ALLOCATE( init_3d%zw_atmos(1:init_3d%nzw) )
2017                CALL get_variable( id_dynamic, 'zw', init_3d%zw_atmos )
2018             ENDIF
2019             IF ( check_existence( var_names, 'depth' ) )  THEN
2020                ALLOCATE( init_3d%z_soil(1:init_3d%nzs) )
2021                CALL get_variable( id_dynamic, 'depth', init_3d%z_soil )
2022             ENDIF
2023!
2024!--          Read geostrophic wind components
2025!              IF ( check_existence( var_names, 'ls_forcing_ug' ) )  THEN
2026!
2027!              ENDIF
2028!              IF ( check_existence( var_names, 'ls_forcing_vg' ) )  THEN
2029!
2030!              ENDIF
2031
2032!
2033!--          Read inital 3D data of u, v, w, pt and q,
2034!--          derived from COSMO model. Read PE-wise yz-slices.
2035!--          Please note, the u-, v- and w-component are defined on different
2036!--          grids with one element less in the x-, y-,
2037!--          and z-direction, respectively. Hence, reading is subdivided
2038!--          into separate loops. Moreover, i and j are used
2039!--          as start index in the NF90 interface.
2040!--          The passed arguments for u, and v are (i,j)-1, respectively,
2041!--          in contrast to the remaining quantities. This is because in case
2042!--          of forcing is applied, the input data for u and v has one
2043!--          element less along the x- and y-direction respectively.
2044!--          Read u-component
2045             IF ( check_existence( var_names, 'init_u' ) )  THEN
2046!
2047!--             Read attributes for the fill value and level-of-detail
2048                CALL get_attribute( id_dynamic, char_fill, init_3d%fill_u,     &
2049                                    .FALSE., 'init_u' )
2050                CALL get_attribute( id_dynamic, char_lod, init_3d%lod_u,       &
2051                                    .FALSE., 'init_u' )
2052!
2053!--             level-of-detail 1 - read initialization profile
2054                IF ( init_3d%lod_u == 1 )  THEN
2055                   ALLOCATE( init_3d%u_init(nzb:nzt+1) )
2056                   init_3d%u_init = 0.0_wp
2057
2058                   CALL get_variable( id_dynamic, 'init_u',                    &
2059                                      init_3d%u_init(nzb+1:nzt+1) )
2060!
2061!--             level-of-detail 2 - read 3D initialization data
2062                ELSEIF ( init_3d%lod_u == 2 )  THEN
2063!
2064!--                Set offset value. In case of Dirichlet conditions at the left
2065!--                domain boundary, the u component starts at nxl+1. This case,
2066!--                the passed start-index for reading the NetCDF data is shifted
2067!--                by -1. 
2068                   off_i = 1 !MERGE( 1, 0, forcing )
2069
2070                   DO  i = nxlu, nxr
2071                      DO  j = nys, nyn   
2072                         CALL get_variable( id_dynamic, 'init_u', i-off_i, j,  &
2073                                            u(nzb+1:nzt+1,j,i) )
2074                      ENDDO
2075                   ENDDO
2076
2077                ENDIF
2078                init_3d%from_file_u = .TRUE.
2079             ENDIF
2080!
2081!--          Read v-component
2082             IF ( check_existence( var_names, 'init_v' ) )  THEN
2083!
2084!--             Read attributes for the fill value and level-of-detail
2085                CALL get_attribute( id_dynamic, char_fill, init_3d%fill_v,     &
2086                                    .FALSE., 'init_v' )
2087                CALL get_attribute( id_dynamic, char_lod, init_3d%lod_v,       &
2088                                    .FALSE., 'init_v' )
2089!
2090!--             level-of-detail 1 - read initialization profile
2091                IF ( init_3d%lod_v == 1 )  THEN
2092                   ALLOCATE( init_3d%v_init(nzb:nzt+1) )
2093                   init_3d%v_init = 0.0_wp
2094
2095                   CALL get_variable( id_dynamic, 'init_v',                    &
2096                                      init_3d%v_init(nzb+1:nzt+1) )
2097
2098!
2099!--             level-of-detail 2 - read 3D initialization data
2100                ELSEIF ( init_3d%lod_v == 2 )  THEN
2101!
2102!--                Set offset value. In case of Dirichlet conditions at the south
2103!--                domain boundary, the v component starts at nys+1. This case,
2104!--                the passed start-index for reading the NetCDF data is shifted
2105!--                by -1. 
2106                   off_j = 1 !MERGE( 1, 0, forcing )
2107
2108                   DO  i = nxl, nxr
2109                      DO  j = nysv, nyn   
2110                         CALL get_variable( id_dynamic, 'init_v', i, j-off_j,  &
2111                                            v(nzb+1:nzt+1,j,i) )
2112                      ENDDO
2113                   ENDDO
2114
2115                ENDIF
2116                init_3d%from_file_v = .TRUE.
2117             ENDIF
2118!
2119!--          Read w-component
2120             IF ( check_existence( var_names, 'init_w' ) )  THEN
2121!
2122!--             Read attributes for the fill value and level-of-detail
2123                CALL get_attribute( id_dynamic, char_fill, init_3d%fill_w,     &
2124                                    .FALSE., 'init_w' )
2125                CALL get_attribute( id_dynamic, char_lod, init_3d%lod_w,       &
2126                                    .FALSE., 'init_w' )
2127!
2128!--             level-of-detail 1 - read initialization profile
2129                IF ( init_3d%lod_w == 1 )  THEN
2130                   ALLOCATE( init_3d%w_init(nzb:nzt+1) )
2131                   init_3d%w_init = 0.0_wp
2132
2133                   CALL get_variable( id_dynamic, 'init_w',                    &
2134                                      init_3d%w_init(nzb+1:nzt) )
2135
2136!
2137!--             level-of-detail 2 - read 3D initialization data
2138                ELSEIF ( init_3d%lod_w == 2 )  THEN
2139                   DO  i = nxl, nxr
2140                      DO  j = nys, nyn
2141                         CALL get_variable( id_dynamic, 'init_w', i, j,        &
2142                                            w(nzb+1:nzt,j,i) )
2143                      ENDDO
2144                   ENDDO
2145
2146                ENDIF
2147                init_3d%from_file_w = .TRUE.
2148             ENDIF
2149!
2150!--          Read potential temperature
2151             IF ( .NOT. neutral )  THEN     
2152                IF ( check_existence( var_names, 'init_pt' ) )  THEN   
2153!
2154!--                Read attributes for the fill value and level-of-detail
2155                   CALL get_attribute( id_dynamic, char_fill, init_3d%fill_pt, &
2156                                       .FALSE., 'init_pt' )
2157                   CALL get_attribute( id_dynamic, char_lod, init_3d%lod_pt,   &
2158                                       .FALSE., 'init_pt' )
2159!
2160!--                level-of-detail 1 - read initialization profile
2161                   IF ( init_3d%lod_pt == 1 )  THEN
2162                      ALLOCATE( init_3d%pt_init(nzb:nzt+1) )
2163
2164                      CALL get_variable( id_dynamic, 'init_pt',                &
2165                                         init_3d%pt_init(nzb+1:nzt+1) )
2166!
2167!--                   Set Neumann surface boundary condition for initial profil
2168                      init_3d%pt_init(nzb) = init_3d%pt_init(nzb+1)
2169!
2170!--                level-of-detail 2 - read 3D initialization data
2171                   ELSEIF ( init_3d%lod_pt == 2 )  THEN
2172                      DO  i = nxl, nxr
2173                         DO  j = nys, nyn
2174                            CALL get_variable( id_dynamic, 'init_pt', i, j,    &
2175                                               pt(nzb+1:nzt+1,j,i) )
2176                         ENDDO
2177                      ENDDO
2178
2179                   ENDIF
2180                   init_3d%from_file_pt = .TRUE.
2181                ENDIF
2182             ENDIF
2183!
2184!--          Read mixing ratio
2185             IF ( humidity )  THEN
2186                IF ( check_existence( var_names, 'init_qv' ) )  THEN
2187!
2188!--                Read attributes for the fill value and level-of-detail
2189                   CALL get_attribute( id_dynamic, char_fill, init_3d%fill_q,  &
2190                                       .FALSE., 'init_qv' )
2191                   CALL get_attribute( id_dynamic, char_lod, init_3d%lod_q,    &
2192                                       .FALSE., 'init_qv' )
2193!
2194!--                level-of-detail 1 - read initialization profile
2195                   IF ( init_3d%lod_q == 1 )  THEN
2196                      ALLOCATE( init_3d%q_init(nzb:nzt+1) )
2197
2198                      CALL get_variable( id_dynamic, 'init_qv',               &
2199                                         init_3d%q_init(nzb+1:nzt+1) )
2200!
2201!--                   Set Neumann surface boundary condition for initial profil
2202                      init_3d%q_init(nzb) = init_3d%q_init(nzb+1)
2203
2204!
2205!--                level-of-detail 2 - read 3D initialization data
2206                   ELSEIF ( init_3d%lod_q == 2 )  THEN
2207                      DO  i = nxl, nxr
2208                         DO  j = nys, nyn
2209                            CALL get_variable( id_dynamic, 'init_qv', i, j,    &
2210                                               q(nzb+1:nzt+1,j,i) )
2211                         ENDDO
2212                      ENDDO
2213
2214                   ENDIF
2215                   init_3d%from_file_q = .TRUE.
2216                ENDIF
2217             ENDIF
2218!
2219!--          Read soil moisture
2220             IF ( land_surface )  THEN
2221                IF ( check_existence( var_names, 'init_soil_m' ) )  THEN
2222!
2223!--                Read attributes for the fill value and level-of-detail
2224                   CALL get_attribute( id_dynamic, char_fill,                  &
2225                                       init_3d%fill_msoil,                     &
2226                                       .FALSE., 'init_soil_m' )
2227                   CALL get_attribute( id_dynamic, char_lod,                   &
2228                                       init_3d%lod_msoil,                      &
2229                                       .FALSE., 'init_soil_m' )
2230!
2231!--                level-of-detail 1 - read initialization profile
2232                   IF ( init_3d%lod_msoil == 1 )  THEN
2233                      ALLOCATE( init_3d%msoil_init(0:init_3d%nzs-1) )
2234
2235                      CALL get_variable( id_dynamic, 'init_soil_m',            &
2236                                         init_3d%msoil_init(0:init_3d%nzs-1) )
2237!
2238!--                level-of-detail 2 - read 3D initialization data
2239                   ELSEIF ( init_3d%lod_msoil == 2 )  THEN  ! need to be corrected
2240                      ALLOCATE ( init_3d%msoil(0:init_3d%nzs-1,nys:nyn,nxl:nxr) )
2241                      DO  i = nxl, nxr
2242                         DO  j = nys, nyn
2243                            CALL get_variable( id_dynamic, 'init_soil_m', i, j,&
2244                                               init_3d%msoil(0:init_3d%nzs-1,j,i) )
2245                         ENDDO
2246                      ENDDO
2247                   ENDIF
2248                   init_3d%from_file_msoil = .TRUE.
2249                ENDIF
2250!
2251!--             Read soil temperature
2252                IF ( check_existence( var_names, 'init_soil_t' ) )  THEN
2253!
2254!--                Read attributes for the fill value and level-of-detail
2255                   CALL get_attribute( id_dynamic, char_fill,                  &
2256                                       init_3d%fill_tsoil,                     &
2257                                       .FALSE., 'init_soil_t' )
2258                   CALL get_attribute( id_dynamic, char_lod,                   &
2259                                       init_3d%lod_tsoil,                      &
2260                                       .FALSE., 'init_soil_t' )
2261!
2262!--                level-of-detail 1 - read initialization profile
2263                   IF ( init_3d%lod_tsoil == 1 )  THEN
2264                      ALLOCATE( init_3d%tsoil_init(0:init_3d%nzs-1) )
2265
2266                      CALL get_variable( id_dynamic, 'init_soil_t',            &
2267                                         init_3d%tsoil_init(0:init_3d%nzs-1) )
2268
2269!
2270!--                level-of-detail 2 - read 3D initialization data
2271                   ELSEIF ( init_3d%lod_tsoil == 2 )  THEN  ! need to be corrected
2272                      ALLOCATE ( init_3d%tsoil(0:init_3d%nzs-1,nys:nyn,nxl:nxr) )
2273                      DO  i = nxl, nxr
2274                         DO  j = nys, nyn
2275                            CALL get_variable( id_dynamic, 'init_soil_t', i, j,&
2276                                               init_3d%tsoil(0:init_3d%nzs-1,j,i) )
2277                         ENDDO
2278                      ENDDO
2279                   ENDIF
2280                   init_3d%from_file_tsoil = .TRUE.
2281                ENDIF
2282             ENDIF
2283!
2284!--          Close input file
2285             CALL close_input_file( id_dynamic )
2286#endif
2287          ENDIF
2288#if defined( __parallel )
2289          CALL MPI_BARRIER( comm2d, ierr )
2290#endif
2291       ENDDO
2292!
2293!--    Finally, check if the input data has any fill values.
2294       IF ( init_3d%from_file_u )  THEN
2295          IF ( ANY( u(nzb+1:nzt+1,nys:nyn,nxlu:nxr) == init_3d%fill_u ) )  THEN
2296             message_string = 'NetCDF input for u_init must not contain ' //   &
2297                              'any _FillValues'
2298             CALL message( 'netcdf_data_input_mod', 'NDI004', 2, 2, 0, 6, 0 )
2299          ENDIF
2300       ENDIF
2301       IF ( init_3d%from_file_v )  THEN
2302          IF ( ANY( v(nzb+1:nzt+1,nysv:nyn,nxl:nxr) == init_3d%fill_v ) )  THEN
2303             message_string = 'NetCDF input for v_init must not contain ' //   &
2304                              'any _FillValues'
2305             CALL message( 'netcdf_data_input_mod', 'NDI005', 2, 2, 0, 6, 0 )
2306          ENDIF
2307       ENDIF
2308       IF ( init_3d%from_file_w )  THEN
2309          IF ( ANY( w(nzb+1:nzt,nys:nyn,nxl:nxr) == init_3d%fill_w ) )  THEN
2310             message_string = 'NetCDF input for w_init must not contain ' //   &
2311                              'any _FillValues'
2312             CALL message( 'netcdf_data_input_mod', 'NDI006', 2, 2, 0, 6, 0 )
2313          ENDIF
2314       ENDIF
2315       IF ( init_3d%from_file_pt )  THEN
2316          IF ( ANY( pt(nzb+1:nzt+1,nys:nyn,nxl:nxr) == init_3d%fill_pt ) )  THEN
2317             message_string = 'NetCDF input for pt_init must not contain ' //  &
2318                              'any _FillValues'
2319             CALL message( 'netcdf_data_input_mod', 'NDI007', 2, 2, 0, 6, 0 )
2320          ENDIF
2321       ENDIF
2322       IF ( init_3d%from_file_q )  THEN
2323          IF ( ANY( q(nzb+1:nzt+1,nys:nyn,nxl:nxr) == init_3d%fill_q ) )  THEN
2324             message_string = 'NetCDF input for q_init must not contain ' //   &
2325                              'any _FillValues'
2326             CALL message( 'netcdf_data_input_mod', 'NDI008', 2, 2, 0, 6, 0 )
2327          ENDIF
2328       ENDIF
2329!
2330!--    Workaround for cyclic conditions. Please see above for further explanation.
2331       IF ( bc_lr_cyc  .AND.  nxl == 0 )  nxlu = nxl 
2332       IF ( bc_ns_cyc  .AND.  nys == 0 )  nysv = nys
2333
2334    END SUBROUTINE netcdf_data_input_init_3d
2335
2336!------------------------------------------------------------------------------!
2337! Description:
2338! ------------
2339!> Reads data at lateral and top boundaries derived from larger-scale model
2340!> (COSMO) by Inifor.
2341!------------------------------------------------------------------------------!
2342    SUBROUTINE netcdf_data_input_lsf
2343
2344       USE control_parameters,                                                 &
2345           ONLY:  force_bound_l, force_bound_n, force_bound_r, force_bound_s,  &
2346                  forcing, humidity, message_string, neutral, simulated_time
2347
2348       USE indices,                                                            &
2349           ONLY:  nx, nxl, nxlu, nxr, ny, nyn, nys, nysv, nzb, nzt
2350
2351       IMPLICIT NONE
2352
2353
2354       INTEGER(iwp) ::  i          !< running index along x-direction
2355       INTEGER(iwp) ::  ii         !< running index for IO blocks
2356       INTEGER(iwp) ::  id_dynamic !< NetCDF id of dynamic input file
2357       INTEGER(iwp) ::  j          !< running index along y-direction
2358       INTEGER(iwp) ::  k          !< running index along z-direction
2359       INTEGER(iwp) ::  num_vars   !< number of variables in netcdf input file
2360       INTEGER(iwp) ::  t          !< running index time dimension
2361
2362       REAL(wp) ::  dum           !< dummy variable to skip columns while reading topography file   
2363
2364       force%from_file = MERGE( .TRUE., .FALSE., input_pids_dynamic ) 
2365!
2366!--    Skip input if no forcing from larger-scale models is applied.
2367       IF ( .NOT. forcing )  RETURN
2368
2369       DO  ii = 0, io_blocks-1
2370          IF ( ii == io_group )  THEN
2371#if defined ( __netcdf )
2372!
2373!--          Open file in read-only mode
2374             CALL open_read_file( TRIM( input_file_dynamic ) //                &
2375                                  TRIM( coupling_char ), id_dynamic ) 
2376!
2377!--          Initialize INIFOR forcing.
2378             IF ( .NOT. force%init )  THEN
2379!
2380!--             At first, inquire all variable names.
2381                CALL inquire_num_variables( id_dynamic, num_vars )
2382!
2383!--             Allocate memory to store variable names.
2384                ALLOCATE( force%var_names(1:num_vars) )
2385                CALL inquire_variable_names( id_dynamic, force%var_names )
2386!
2387!--             Read time dimension, allocate memory and finally read time array
2388                CALL get_dimension_length( id_dynamic, force%nt, 'time' )
2389
2390                IF ( check_existence( force%var_names, 'time' ) )  THEN
2391                   ALLOCATE( force%time(0:force%nt-1) )
2392                   CALL get_variable( id_dynamic, 'time', force%time )
2393                ENDIF
2394!
2395!--             Read vertical dimension of scalar und w grid
2396                CALL get_dimension_length( id_dynamic, force%nzu, 'z' )
2397                CALL get_dimension_length( id_dynamic, force%nzw, 'zw' )
2398
2399                IF ( check_existence( force%var_names, 'z' ) )  THEN
2400                   ALLOCATE( force%zu_atmos(1:force%nzu) )
2401                   CALL get_variable( id_dynamic, 'z', force%zu_atmos )
2402                ENDIF
2403                IF ( check_existence( force%var_names, 'zw' ) )  THEN
2404                   ALLOCATE( force%zw_atmos(1:force%nzw) )
2405                   CALL get_variable( id_dynamic, 'zw', force%zw_atmos )
2406                ENDIF
2407
2408!
2409!--             Read surface pressure
2410                IF ( check_existence( force%var_names,                         &
2411                                  'surface_forcing_surface_pressure' ) )  THEN
2412                   ALLOCATE( force%surface_pressure(0:force%nt-1) )
2413                   CALL get_variable( id_dynamic,                              &
2414                                      'surface_forcing_surface_pressure',      &
2415                                      force%surface_pressure )
2416                ENDIF
2417!
2418!--             Set control flag to indicate that initialization is already done
2419                force%init = .TRUE.
2420
2421             ENDIF
2422
2423!
2424!--          Obtain time index for current input starting at 0.
2425!--          @todo: At the moment time, in INIFOR and simulated time correspond
2426!--                 to each other. If required, adjust to daytime.
2427             force%tind = MINLOC( ABS( force%time - simulated_time ), DIM = 1 )&
2428                          - 1
2429             force%tind_p = force%tind + 1 
2430!
2431!--          Read data at lateral and top boundaries. Please note, at left and
2432!--          right domain boundary, yz-layers are read for u, v, w, pt and q.
2433!--          For the v-component, the data starts at nysv, while for the other
2434!--          quantities the data starts at nys. This is equivalent at the north
2435!--          and south domain boundary for the u-component.
2436!--          The function get_variable_bc assumes the start indices with respect
2437!--          to the netcdf file convention (data starts at index 1). For this
2438!--          reason, nys+1 / nxl+1 are passed instead of nys / nxl. For the
2439!--          the u- and v-component at the north/south, and left/right boundary,
2440!--          nxlu and nysv are passed, respectively, since these always starts
2441!--          at index 1 in case of forcing.
2442
2443             IF ( force_bound_l )  THEN
2444                DO  j = nys, nyn
2445                   DO  t = force%tind, force%tind_p
2446                      CALL get_variable_bc( id_dynamic, 'ls_forcing_left_u',   &
2447                                      t+1,                                     &
2448                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2449                                      j+1, 1,                                  &
2450                                      force%u_left(t-force%tind,nzb+1:nzt+1,j) )
2451                   ENDDO
2452                ENDDO
2453
2454                DO  j = nysv, nyn
2455                   DO  t = force%tind, force%tind_p
2456                      CALL get_variable_bc( id_dynamic, 'ls_forcing_left_v',   &
2457                                      t+1,                                     &
2458                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2459                                      j, 1,                                    &
2460                                      force%v_left(t-force%tind,nzb+1:nzt+1,j) )
2461                   ENDDO
2462                ENDDO
2463                DO  j = nys, nyn
2464                   DO  t = force%tind, force%tind_p
2465                      CALL get_variable_bc( id_dynamic,                        &
2466                                      'ls_forcing_left_w',                     &
2467                                      t+1,                                     &
2468                                      nzb+1, nzt-(nzb+1) + 1,                  &
2469                                      j+1, 1,                                  &
2470                                      force%w_left(t-force%tind,nzb+1:nzt,j) )
2471                   ENDDO
2472                ENDDO
2473                IF ( .NOT. neutral )  THEN
2474                   DO  j = nys, nyn
2475                      DO  t = force%tind, force%tind_p
2476                         CALL get_variable_bc( id_dynamic,                     &
2477                                      'ls_forcing_left_pt',                    &
2478                                      t+1,                                     &
2479                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2480                                      j+1, 1,                                  &
2481                                      force%pt_left(t-force%tind,nzb+1:nzt+1,j) )
2482                      ENDDO
2483                   ENDDO
2484                ENDIF
2485                IF ( humidity )  THEN
2486                   DO  j = nys, nyn
2487                      DO  t = force%tind, force%tind_p
2488                         CALL get_variable_bc( id_dynamic,                     &
2489                                      'ls_forcing_left_qv',                    &
2490                                      t+1,                                     &
2491                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2492                                      j+1, 1,                                  &
2493                                      force%q_left(t-force%tind,nzb+1:nzt+1,j) )
2494                      ENDDO
2495                   ENDDO
2496                ENDIF
2497             ENDIF
2498
2499             IF ( force_bound_r )  THEN
2500                DO  j = nys, nyn
2501                   DO  t = force%tind, force%tind_p
2502                      CALL get_variable_bc( id_dynamic, 'ls_forcing_right_u',  &
2503                                      t+1,                                     &
2504                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2505                                      j+1, 1,                                  &
2506                                      force%u_right(t-force%tind,nzb+1:nzt+1,j) )
2507                   ENDDO
2508                ENDDO
2509                DO  j = nysv, nyn
2510                   DO  t = force%tind, force%tind_p
2511                      CALL get_variable_bc( id_dynamic, 'ls_forcing_right_v',  &
2512                                      t+1,                                     &
2513                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2514                                      j, 1,                                    &
2515                                      force%v_right(t-force%tind,nzb+1:nzt+1,j) )
2516                   ENDDO
2517                ENDDO
2518                DO  j = nys, nyn
2519                   DO  t = force%tind, force%tind_p
2520                      CALL get_variable_bc( id_dynamic, 'ls_forcing_right_w',  &
2521                                      t+1,                                     &
2522                                      nzb+1, nzt-(nzb+1)+1,                    &
2523                                      j+1, 1,                                  &
2524                                      force%w_right(t-force%tind,nzb+1:nzt,j) )
2525                   ENDDO
2526                ENDDO
2527                IF ( .NOT. neutral )  THEN
2528                   DO  j = nys, nyn
2529                      DO  t = force%tind, force%tind_p
2530                         CALL get_variable_bc( id_dynamic,                     &
2531                                      'ls_forcing_right_pt',                   &
2532                                      t+1,                                     &
2533                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2534                                      j+1, 1,                                  &
2535                                      force%pt_right(t-force%tind,nzb+1:nzt+1,j) )
2536                      ENDDO
2537                   ENDDO
2538                ENDIF
2539                IF ( humidity )  THEN
2540                   DO  j = nys, nyn
2541                      DO  t = force%tind, force%tind_p
2542                         CALL get_variable_bc( id_dynamic,                     &
2543                                      'ls_forcing_right_qv',                   &
2544                                      t+1,                                     &
2545                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2546                                      j+1, 1,                                  &
2547                                      force%q_right(t-force%tind,nzb+1:nzt+1,j) )
2548                      ENDDO
2549                   ENDDO
2550                ENDIF
2551             ENDIF
2552
2553             IF ( force_bound_n )  THEN
2554                DO  i = nxlu, nxr
2555                   DO  t = force%tind, force%tind_p
2556                      CALL get_variable_bc( id_dynamic, 'ls_forcing_north_u',  &
2557                                      t+1,                                     &
2558                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2559                                      i, 1,                                    &
2560                                      force%u_north(t-force%tind,nzb+1:nzt+1,i) )
2561                   ENDDO
2562                ENDDO
2563                DO  i = nxl, nxr
2564                   DO  t = force%tind, force%tind_p
2565                      CALL get_variable_bc( id_dynamic, 'ls_forcing_north_v',  &
2566                                      t+1,                                     &
2567                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2568                                      i+1, 1,                                  &
2569                                      force%v_north(t-force%tind,nzb+1:nzt+1,i) )
2570                   ENDDO
2571                ENDDO
2572                DO  i = nxl, nxr
2573                   DO  t = force%tind, force%tind_p
2574                      CALL get_variable_bc( id_dynamic, 'ls_forcing_north_w',  &
2575                                      t+1,                                     &
2576                                      nzb+1, nzt-(nzb+1)+1,                    &
2577                                      i+1, 1,                                  &
2578                                      force%w_north(t-force%tind,nzb+1:nzt,i) )
2579                   ENDDO
2580                ENDDO
2581                IF ( .NOT. neutral )  THEN
2582                   DO  i = nxl, nxr
2583                      DO  t = force%tind, force%tind_p
2584                         CALL get_variable_bc( id_dynamic,                     &
2585                                      'ls_forcing_north_pt',                   &
2586                                      t+1,                                     &
2587                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2588                                      i+1, 1,                                  &
2589                                      force%pt_north(t-force%tind,nzb+1:nzt+1,i) )
2590                      ENDDO
2591                   ENDDO
2592                ENDIF
2593                IF ( humidity )  THEN
2594                   DO  i = nxl, nxr
2595                      DO  t = force%tind, force%tind_p
2596                         CALL get_variable_bc( id_dynamic,                     &
2597                                      'ls_forcing_north_qv',                   &
2598                                      t+1,                                     &
2599                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2600                                      i+1, 1,                                  &
2601                                      force%q_north(t-force%tind,nzb+1:nzt+1,i) )
2602                      ENDDO
2603                   ENDDO
2604                ENDIF
2605             ENDIF
2606
2607             IF ( force_bound_s )  THEN
2608                DO  i = nxlu, nxr
2609                   DO  t = force%tind, force%tind_p
2610                      CALL get_variable_bc( id_dynamic, 'ls_forcing_south_u',  &
2611                                      t+1,                                     &
2612                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2613                                      i, 1,                                    &
2614                                      force%u_south(t-force%tind,nzb+1:nzt+1,i) )
2615                   ENDDO
2616                ENDDO
2617                DO  i = nxl, nxr
2618                   DO  t = force%tind, force%tind_p
2619                      CALL get_variable_bc( id_dynamic, 'ls_forcing_south_v',  &
2620                                      t+1,                                     &
2621                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2622                                      i+1, 1,                                  &
2623                                      force%v_south(t-force%tind,nzb+1:nzt+1,i) )
2624                   ENDDO
2625                ENDDO
2626                DO  i = nxl, nxr
2627                   DO  t = force%tind, force%tind_p
2628                      CALL get_variable_bc( id_dynamic, 'ls_forcing_south_w',  &
2629                                      t+1,                                     &
2630                                      nzb+1, nzt-(nzb+1)+1,                    &
2631                                      i+1, 1,                                  &
2632                                      force%w_south(t-force%tind,nzb+1:nzt,i) )
2633                   ENDDO
2634                ENDDO
2635                IF ( .NOT. neutral )  THEN
2636                   DO  i = nxl, nxr
2637                      DO  t = force%tind, force%tind_p
2638                         CALL get_variable_bc( id_dynamic,                     &
2639                                      'ls_forcing_south_pt',                   &
2640                                      t+1,                                     &
2641                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2642                                      i+1, 1,                                  &
2643                                      force%pt_south(t-force%tind,nzb+1:nzt+1,i) )
2644                      ENDDO
2645                   ENDDO
2646                ENDIF
2647                IF ( humidity )  THEN
2648                   DO  i = nxl, nxr
2649                      DO  t = force%tind, force%tind_p
2650                         CALL get_variable_bc( id_dynamic,                     &
2651                                      'ls_forcing_south_qv',                   &
2652                                      t+1,                                     &
2653                                      nzb+1, nzt+1-(nzb+1)+1,                  &
2654                                      i+1, 1,                                  &
2655                                      force%q_south(t-force%tind,nzb+1:nzt+1,i) )
2656                      ENDDO
2657                   ENDDO
2658                ENDIF
2659             ENDIF
2660!
2661!--          Top boundary
2662             DO  i = nxlu, nxr
2663                DO  t = force%tind, force%tind_p
2664                   CALL get_variable_bc( id_dynamic, 'ls_forcing_top_u',       &
2665                                   t+1,                                        &
2666                                   nys+1, nyn-nys+1,                           &
2667                                   i, 1,                                       &
2668                                   force%u_top(t-force%tind,nys:nyn,i) )
2669                ENDDO
2670             ENDDO
2671             DO  i = nxl, nxr
2672                DO  t = force%tind, force%tind_p
2673                   CALL get_variable_bc( id_dynamic, 'ls_forcing_top_v',       &
2674                                   t+1,                                        &
2675                                   nysv, nyn-nysv+1,                           &
2676                                   i+1, 1,                                     &
2677                                   force%v_top(t-force%tind,nysv:nyn,i) )
2678                ENDDO
2679             ENDDO
2680             DO  i = nxl, nxr
2681                DO  t = force%tind, force%tind_p
2682                   CALL get_variable_bc( id_dynamic, 'ls_forcing_top_w',       &
2683                                   t+1,                                        &
2684                                   nys+1, nyn-nys+1,                           &
2685                                   i+1, 1,                                     &
2686                                   force%w_top(t-force%tind,nys:nyn,i) )
2687                ENDDO
2688             ENDDO
2689             IF ( .NOT. neutral )  THEN
2690                DO  i = nxl, nxr
2691                   DO  t = force%tind, force%tind_p
2692                      CALL get_variable_bc( id_dynamic, 'ls_forcing_top_pt',   &
2693                                      t+1,                                     &
2694                                      nys+1, nyn-nys+1,                        &
2695                                      i+1, 1,                                  &
2696                                      force%pt_top(t-force%tind,nys:nyn,i) )
2697                   ENDDO
2698                ENDDO
2699             ENDIF
2700             IF ( humidity )  THEN
2701                DO  i = nxl, nxr
2702                   DO  t = force%tind, force%tind_p
2703                      CALL get_variable_bc( id_dynamic, 'ls_forcing_top_qv',   &
2704                                      t+1,                                     &
2705                                      nys+1, nyn-nys+1,                        &
2706                                      i+1, 1,                                  &
2707                                      force%q_top(t-force%tind,nys:nyn,i) )
2708                   ENDDO
2709                ENDDO
2710             ENDIF
2711
2712!
2713!--          Close input file
2714             CALL close_input_file( id_dynamic )
2715#endif
2716          ENDIF
2717#if defined( __parallel )
2718          CALL MPI_BARRIER( comm2d, ierr )
2719#endif
2720       ENDDO
2721
2722!
2723!--    Finally, after data input set control flag indicating that vertical
2724!--    inter- and/or extrapolation is required.
2725!--    Please note, inter/extrapolation of INIFOR data is only a workaroud,
2726!--    as long as INIFOR delivers vertically equidistant data.
2727       force%interpolated = .FALSE. 
2728
2729    END SUBROUTINE netcdf_data_input_lsf
2730
2731
2732!------------------------------------------------------------------------------!
2733! Description:
2734! ------------
2735!> Checks input file for consistency and minimum requirements.
2736!------------------------------------------------------------------------------!
2737    SUBROUTINE netcdf_data_input_check_dynamic
2738
2739       USE control_parameters,                                                 &
2740           ONLY:  initializing_actions, forcing, message_string
2741
2742       IMPLICIT NONE
2743
2744!
2745!--    In case of forcing, check whether dynamic input file is present
2746       IF ( .NOT. input_pids_dynamic  .AND.  forcing )  THEN
2747          message_string = 'forcing = .TRUE. requires dynamic input file ' //  &
2748                            TRIM( input_file_dynamic ) // TRIM( coupling_char )
2749          CALL message( 'netcdf_data_input_mod', 'NDI009', 1, 2, 0, 6, 0 )
2750       ENDIF
2751!
2752!--    Dynamic input file must also be present if initialization via inifor is
2753!--    prescribed.
2754       IF ( .NOT. input_pids_dynamic  .AND.                                    &
2755            TRIM( initializing_actions ) == 'inifor' )  THEN
2756          message_string = 'initializing_actions = inifor requires dynamic ' //&
2757                           'input file ' // TRIM( input_file_dynamic ) //      &
2758                           TRIM( coupling_char )
2759          CALL message( 'netcdf_data_input_mod', 'NDI010', 1, 2, 0, 6, 0 )
2760       ENDIF
2761
2762    END SUBROUTINE netcdf_data_input_check_dynamic
2763
2764!------------------------------------------------------------------------------!
2765! Description:
2766! ------------
2767!> Checks input file for consistency and minimum requirements.
2768!------------------------------------------------------------------------------!
2769    SUBROUTINE netcdf_data_input_check_static
2770
2771       USE arrays_3d,                                                          &
2772           ONLY:  zu
2773
2774       USE control_parameters,                                                 &
2775           ONLY:  land_surface, message_string, urban_surface
2776
2777       USE grid_variables,                                                     &
2778           ONLY:  dx, dy
2779
2780       USE indices,                                                            &
2781           ONLY:  nx, nxl, nxr, ny, nyn, nys
2782
2783       IMPLICIT NONE
2784
2785       INTEGER(iwp) ::  i      !< loop index along x-direction
2786       INTEGER(iwp) ::  j      !< loop index along y-direction
2787
2788       LOGICAL      ::  check_passed !< flag indicating if a check passed
2789
2790!
2791!--    Return if no static input file is available
2792       IF ( .NOT. input_pids_static )  RETURN
2793!
2794!--    Check whether dimension size in input file matches the model dimensions
2795       IF ( dim_static%nx-1 /= nx  .OR.  dim_static%ny-1 /= ny )  THEN
2796          message_string = 'Static input file: horizontal dimension in ' //    &
2797                           'x- and/or y-direction ' //                         &
2798                           'do not match the respective model dimension'
2799          CALL message( 'netcdf_data_input_mod', 'NDI011', 1, 2, 0, 6, 0 )
2800       ENDIF
2801!
2802!--    Check if grid spacing of provided input data matches the respective
2803!--    grid spacing in the model.
2804       IF ( dim_static%x(1) - dim_static%x(0) /= dx  .OR.                      &
2805            dim_static%y(1) - dim_static%y(0) /= dy )  THEN
2806          message_string = 'Static input file: horizontal grid spacing ' //    &
2807                           'in x- and/or y-direction ' //                      &
2808                           'do not match the respective model grid spacing.'
2809          CALL message( 'netcdf_data_input_mod', 'NDI012', 1, 2, 0, 6, 0 )
2810       ENDIF
2811!
2812!--    Check orography for fill-values. For the moment, give an error message.
2813!--    More advanced methods, e.g. a nearest neighbor algorithm as used in GIS
2814!--    systems might be implemented later.
2815       IF ( ANY( terrain_height_f%var == terrain_height_f%fill ) )  THEN
2816          message_string = 'NetCDF variable orography_2D is not ' //           &
2817                           'allowed to have missing data'
2818          CALL message( 'netcdf_data_input_mod', 'NDI013', 2, 2, 0, 6, 0 )
2819       ENDIF
2820!
2821!--    If 3D buildings are read, check if building information is consistent
2822!--    to numeric grid.
2823       IF ( buildings_f%from_file )  THEN
2824          IF ( buildings_f%lod == 2 )  THEN
2825             IF ( buildings_f%nz > SIZE( zu ) )  THEN
2826                message_string = 'Reading 3D building data - too much ' //     &
2827                                 'data points along the vertical coordinate.' 
2828                CALL message( 'netcdf_data_input_mod', 'NDI014', 2, 2, 0, 6, 0 )
2829             ENDIF
2830
2831             IF ( ANY( buildings_f%z(0:buildings_f%nz-1) /=                    &
2832                       zu(0:buildings_f%nz-1) ) )  THEN
2833                message_string = 'Reading 3D building data - vertical ' //     &
2834                                 'coordinate do not match numeric grid.'
2835                CALL message( 'netcdf_data_input_mod', 'NDI015', 2, 2, 0, 6, 0 )
2836             ENDIF
2837          ENDIF
2838       ENDIF
2839
2840!
2841!--    Skip further checks concerning buildings and natural surface properties
2842!--    if no urban surface and land surface model are applied.
2843       IF (  .NOT. land_surface  .OR.  .NOT. urban_surface )  RETURN 
2844!
2845!--    Check for minimum requirement of surface-classification data in case
2846!--    static input file is used.
2847       IF ( .NOT. vegetation_type_f%from_file  .OR.                            &
2848            .NOT. pavement_type_f%from_file    .OR.                            &
2849            .NOT. building_type_f%from_file    .OR.                            &
2850            .NOT. water_type_f%from_file       .OR.                            &
2851            .NOT. soil_type_f%from_file             )  THEN
2852          message_string = 'Minimum requirement for surface classification ' //&
2853                           'is not fulfilled. At least ' //                    &
2854                           'vegetation_type, pavement_type, ' //               &
2855                           'building_type, soil_type and water_type are '//    &
2856                           'required.'
2857          CALL message( 'netcdf_data_input_mod', 'NDI016', 1, 2, 0, 6, 0 )
2858       ENDIF
2859!
2860!--    Check for general availability of input variables.
2861!--    If vegetation_type is 0 at any location, vegetation_pars as well as
2862!--    root_area_density_lsm are required.
2863       IF ( vegetation_type_f%from_file )  THEN
2864          IF ( ANY( vegetation_type_f%var == 0 ) )  THEN
2865             IF ( .NOT. vegetation_pars_f%from_file )  THEN
2866                message_string = 'If vegegation_type = 0 at any location, ' // &
2867                                 'vegetation_pars is required'
2868                CALL message( 'netcdf_data_input_mod', 'NDI017', 2, 2, 0, 6, 0 )
2869             ENDIF
2870             IF ( .NOT. root_area_density_lsm_f%from_file )  THEN
2871                message_string = 'If vegegation_type = 0 at any location, ' // &
2872                                 'root_area_density_lsm is required'
2873                CALL message( 'netcdf_data_input_mod', 'NDI018', 2, 2, 0, 6, 0 )
2874             ENDIF
2875          ENDIF
2876       ENDIF
2877!
2878!--    If soil_type is zero at any location, soil_pars is required.
2879       IF ( soil_type_f%from_file )  THEN
2880          check_passed = .TRUE. 
2881          IF ( ALLOCATED( soil_type_f%var_2d ) )  THEN
2882             IF ( ANY( soil_type_f%var_2d == 0 ) )  THEN
2883                IF ( .NOT. soil_pars_f%from_file )  check_passed = .FALSE.
2884             ENDIF
2885          ELSE
2886             IF ( ANY( soil_type_f%var_3d == 0 ) )  THEN
2887                IF ( .NOT. soil_pars_f%from_file )  check_passed = .FALSE.
2888             ENDIF
2889          ENDIF
2890          IF ( .NOT. check_passed )  THEN
2891             message_string = 'If soil_type = 0 at any location, ' //          &
2892                              'soil_pars is required'
2893             CALL message( 'netcdf_data_input_mod', 'NDI019', 2, 2, 0, 6, 0 )         
2894          ENDIF
2895       ENDIF
2896!
2897!--    If building_type is zero at any location, building_pars is required.
2898       IF ( building_type_f%from_file )  THEN
2899          IF ( ANY( building_type_f%var == 0 ) )  THEN
2900             IF ( .NOT. building_pars_f%from_file )  THEN
2901                message_string = 'If building_type = 0 at any location, ' //   &
2902                                 'building_pars is required'
2903                CALL message( 'netcdf_data_input_mod', 'NDI020', 2, 2, 0, 6, 0 )         
2904             ENDIF
2905          ENDIF
2906       ENDIF
2907!
2908!--    If albedo_type is zero at any location, albedo_pars is required.
2909       IF ( albedo_type_f%from_file )  THEN
2910          IF ( ANY( albedo_type_f%var == 0 ) )  THEN
2911             IF ( .NOT. albedo_pars_f%from_file )  THEN
2912                message_string = 'If albedo_type = 0 at any location, ' //     &
2913                                 'albedo_pars is required'
2914                CALL message( 'netcdf_data_input_mod', 'NDI021', 2, 2, 0, 6, 0 )     
2915             ENDIF     
2916          ENDIF
2917       ENDIF
2918!
2919!--    If pavement_type is zero at any location, pavement_pars is required.
2920       IF ( pavement_type_f%from_file )  THEN
2921          IF ( ANY( pavement_type_f%var == 0 ) )  THEN
2922             IF ( .NOT. pavement_pars_f%from_file )  THEN
2923                message_string = 'If pavement_type = 0 at any location, ' //   &
2924                                 'pavement_pars is required'
2925                CALL message( 'netcdf_data_input_mod', 'NDI022', 2, 2, 0, 6, 0 )     
2926             ENDIF     
2927          ENDIF
2928       ENDIF
2929!
2930!--    If pavement_type is zero at any location, also pavement_subsurface_pars
2931!--    is required.
2932       IF ( pavement_type_f%from_file )  THEN
2933          IF ( ANY( pavement_type_f%var == 0 ) )  THEN
2934             IF ( .NOT. pavement_subsurface_pars_f%from_file )  THEN
2935                message_string = 'If pavement_type = 0 at any location, ' //   &
2936                                 'pavement_subsurface_pars is required'
2937                CALL message( 'netcdf_data_input_mod', 'NDI023', 2, 2, 0, 6, 0 )     
2938             ENDIF     
2939          ENDIF
2940       ENDIF
2941!
2942!--    If water_type is zero at any location, water_pars is required.
2943       IF ( water_type_f%from_file )  THEN
2944          IF ( ANY( water_type_f%var == 0 ) )  THEN
2945             IF ( .NOT. water_pars_f%from_file )  THEN
2946                message_string = 'If water_type = 0 at any location, ' //      &
2947                                 'water_pars is required'
2948                CALL message( 'netcdf_data_input_mod', 'NDI024', 2, 2, 0, 6, 0 )     
2949             ENDIF     
2950          ENDIF
2951       ENDIF
2952!
2953!--    Check for local consistency of the input data.
2954       DO  i = nxl, nxr
2955          DO  j = nys, nyn
2956!
2957!--          For each (y,x)-location at least one of the parameters
2958!--          vegetation_type, pavement_type, building_type, or water_type
2959!--          must be set to a non­missing value.
2960             IF ( vegetation_type_f%var(j,i) == vegetation_type_f%fill  .AND.  &
2961                  pavement_type_f%var(j,i)   == pavement_type_f%fill    .AND.  &
2962                  building_type_f%var(j,i)   == building_type_f%fill    .AND.  &
2963                  water_type_f%var(j,i)      == water_type_f%fill )  THEN
2964                message_string = 'At least one of the paramters '       //     &
2965                                 'vegetation_type, pavement_type, '     //     &
2966                                 'building_type, or water_type must be set '// &
2967                                 'to a non-missing value'
2968                CALL message( 'netcdf_data_input_mod', 'NDI025', 2, 2, 0, 6, 0 )
2969             ENDIF
2970!
2971!--          Note that a soil_type is required for each location (y,x) where
2972!--          either vegetation_type or pavement_type is a non­missing value.
2973             IF ( ( vegetation_type_f%var(j,i) /= vegetation_type_f%fill  .OR. &
2974                    pavement_type_f%var(j,i)   /= pavement_type_f%fill ) )  THEN
2975                check_passed = .TRUE.
2976                IF ( ALLOCATED( soil_type_f%var_2d ) )  THEN
2977                   IF ( soil_type_f%var_2d(j,i) == soil_type_f%fill )          &
2978                      check_passed = .FALSE.
2979                ELSE
2980                   IF ( ANY( soil_type_f%var_3d(:,j,i) == soil_type_f%fill) )  &
2981                      check_passed = .FALSE.
2982                ENDIF
2983
2984                IF ( .NOT. check_passed )  THEN
2985                   message_string = 'soil_type is required for each '//        &
2986                                 'location (y,x) where vegetation_type or ' // &
2987                                 'pavement_type is a non-missing value.'
2988                   CALL message( 'netcdf_data_input_mod', 'NDI026',            &
2989                                  2, 2, 0, 6, 0 )
2990                ENDIF
2991             ENDIF
2992!
2993!--          Check for consistency of surface fraction.
2994!--          Sum of surface fractions must not exceed one.
2995             IF ( ANY ( surface_fraction_f%frac(:,j,i) ==                      &
2996                        surface_fraction_f%fill ) )  THEN
2997                message_string = 'If more than one natural surface type is ' //&
2998                              'given at a location, surface_fraction ' //      &
2999                              'must be provided.'
3000                CALL message( 'netcdf_data_input_mod', 'NDI027',               &
3001                                  2, 2, 0, 6, 0 )
3002             ENDIF
3003             IF ( SUM ( surface_fraction_f%frac(:,j,i) ) > 1.0_wp )  THEN
3004                message_string = 'surface_fraction must not exceed 1'
3005                CALL message( 'netcdf_data_input_mod', 'NDI028',               &
3006                               2, 2, 0, 6, 0 )
3007             ENDIF
3008!
3009!--          Check for further mismatches, e.g. vegetation_type is set but
3010!--          surface vegetation fraction is zero.
3011             IF ( ( vegetation_type_f%var(j,i) /= vegetation_type_f%fill  .AND.  &
3012                    surface_fraction_f%frac(0,j,i) == 0.0_wp )  .OR.             &
3013                  ( pavement_type_f%var(j,i) /= pavement_type_f%fill     .AND.   &
3014                    surface_fraction_f%frac(1,j,i) == 0.0_wp )  .OR.             &
3015                  ( water_type_f%var(j,i) /= water_type_f%fill           .AND.   &
3016                    surface_fraction_f%frac(2,j,i) == 0.0_wp ) )  THEN
3017                WRITE( message_string, * ) 'Mismatch in setting of '     //      &
3018                               'surface_fraction. Vegetation-, pavement-, or '// &
3019                               'water surface is given at (i,j) = ( ', i, j,     &
3020                               ' ), but surface fraction is 0 for the given type.'
3021                CALL message( 'netcdf_data_input_mod', 'NDI029',                 &
3022                               2, 2, 0, 6, 0 )
3023             ENDIF
3024!
3025!--          Check for further mismatches, e.g. vegetation_type is not set       
3026!--          surface vegetation fraction is non-zero.
3027             IF ( ( vegetation_type_f%var(j,i) == vegetation_type_f%fill  .AND.  &
3028                    surface_fraction_f%frac(0,j,i) /= 0.0_wp )  .OR.             &
3029                  ( pavement_type_f%var(j,i) == pavement_type_f%fill     .AND.   &
3030                    surface_fraction_f%frac(1,j,i) /= 0.0_wp )  .OR.             &
3031                  ( water_type_f%var(j,i) == water_type_f%fill           .AND.   &
3032                    surface_fraction_f%frac(2,j,i) /= 0.0_wp ) )  THEN
3033                WRITE( message_string, * ) 'Mismatch in setting of '     //      &
3034                               'surface_fraction. Vegetation-, pavement-, or '// &
3035                               'water surface is not given at (i,j) = ( ', i, j, &
3036                               ' ), but surface fraction is not 0 for the ' //   &
3037                               'given type.'
3038                CALL message( 'netcdf_data_input_mod', 'NDI030',                 &
3039                               2, 2, 0, 6, 0 )
3040             ENDIF
3041!
3042!--          Check vegetation_pars. If vegetation_type is 0, all parameters
3043!--          need to be set, otherwise, single parameters set by
3044!--          vegetation_type can be overwritten.
3045             IF ( vegetation_type_f%from_file )  THEN
3046                IF ( vegetation_type_f%var(j,i) == 0 )  THEN
3047                   IF ( ANY( vegetation_pars_f%pars_xy(:,j,i) ==               &
3048                             vegetation_pars_f%fill ) )  THEN
3049                      message_string = 'If vegetation_type(y,x) = 0, all '  // &
3050                                       'parameters of vegetation_pars at '//   & 
3051                                       'this location must be set.' 
3052                      CALL message( 'netcdf_data_input_mod', 'NDI031',         &
3053                                     2, 2, 0, 6, 0 )
3054                   ENDIF
3055                ENDIF
3056             ENDIF
3057!
3058!--          Check root distribution. If vegetation_type is 0, all levels must
3059!--          be set.
3060             IF ( vegetation_type_f%from_file )  THEN
3061                IF ( vegetation_type_f%var(j,i) == 0 )  THEN
3062                   IF ( ANY( root_area_density_lsm_f%var(:,j,i) ==             &
3063                             root_area_density_lsm_f%fill ) )  THEN
3064                      message_string = 'If vegetation_type(y,x) = 0, all ' //  &
3065                                       'levels of root_area_density_lsm ' //   &
3066                                       'must be set at this location.' 
3067                      CALL message( 'netcdf_data_input_mod', 'NDI032',         &
3068                                     2, 2, 0, 6, 0 )
3069                   ENDIF
3070                ENDIF
3071             ENDIF
3072!
3073!--          Check soil parameters. If soil_type is 0, all parameters 
3074!--          must be set.
3075             IF ( soil_type_f%from_file )  THEN
3076                check_passed = .TRUE.
3077                IF ( ALLOCATED( soil_type_f%var_2d ) )  THEN
3078                   IF ( soil_type_f%var_2d(j,i) == 0 )  THEN
3079                      IF ( ANY( soil_pars_f%pars_xy(:,j,i) ==                  &
3080                                soil_pars_f%fill ) )  check_passed = .FALSE.
3081                   ENDIF
3082                ELSE
3083                   IF ( ANY( soil_type_f%var_3d(:,j,i) == 0 ) )  THEN
3084                      IF ( ANY( soil_pars_f%pars_xy(:,j,i) ==                  &
3085                                soil_pars_f%fill ) )  check_passed = .FALSE.
3086                   ENDIF
3087                ENDIF
3088                IF ( .NOT. check_passed )  THEN
3089                   message_string = 'If soil_type(y,x) = 0, all levels of '  //& 
3090                                    'soil_pars at this location must be set.' 
3091                   CALL message( 'netcdf_data_input_mod', 'NDI033',            &
3092                                  2, 2, 0, 6, 0 )
3093                ENDIF
3094             ENDIF
3095
3096!
3097!--          Check building parameters. If building_type is 0, all parameters 
3098!--          must be set.
3099             IF ( building_type_f%from_file )  THEN
3100                IF ( building_type_f%var(j,i) == 0 )  THEN
3101                   IF ( ANY( building_pars_f%pars_xy(:,j,i) ==                 &
3102                             building_pars_f%fill ) )  THEN
3103                      message_string = 'If building_type(y,x) = 0, all ' //    &
3104                                       'parameters of building_pars at this '//&
3105                                       'location must be set.' 
3106                      CALL message( 'netcdf_data_input_mod', 'NDI034',         &
3107                                     2, 2, 0, 6, 0 )
3108                   ENDIF
3109                ENDIF
3110             ENDIF
3111!
3112!--          Check if building_type is set at each building
3113             IF ( building_type_f%from_file  .AND.  buildings_f%from_file )  THEN
3114                IF ( buildings_f%lod == 1 )  THEN
3115                   IF ( buildings_f%var_2d(j,i)  /= buildings_f%fill1  .AND.   &
3116                        building_type_f%var(j,i) == building_type_f%fill )  THEN
3117                      WRITE( message_string, * ) 'Each building requires ' //  &
3118                                                 'a type in case the ' //      &
3119                                                 'urban-surface model is ' //  &
3120                                                 'applied. i, j = ', i, j
3121                      CALL message( 'netcdf_data_input_mod', 'NDI035',         &
3122                                     2, 2, 0, 6, 0 )
3123                   ENDIF
3124                ENDIF
3125                IF ( buildings_f%lod == 2 )  THEN
3126                   IF ( ANY( buildings_f%var_3d(:,j,i) == 1 )                  &
3127                  .AND. building_type_f%var(j,i) == building_type_f%fill )  THEN
3128                      WRITE( message_string, * ) 'Each building requires ' //  &
3129                                                 'a type in case the ' //      &
3130                                                 'urban-surface model is ' //  &
3131                                                 'applied. i, j = ', i, j
3132                      CALL message( 'netcdf_data_input_mod', 'NDI036',         &
3133                                     2, 2, 0, 6, 0 )
3134                   ENDIF
3135                ENDIF
3136             ENDIF
3137!
3138!--          Check albedo parameters. If albedo_type is 0, all parameters 
3139!--          must be set.
3140             IF ( albedo_type_f%from_file )  THEN
3141                IF ( albedo_type_f%var(j,i) == 0 )  THEN
3142                   IF ( ANY( albedo_pars_f%pars_xy(:,j,i) ==                   &
3143                             albedo_pars_f%fill ) )  THEN
3144                      message_string = 'If albedo_type(y,x) = 0, all ' //      &
3145                                       'parameters of albedo_pars at this ' // &
3146                                       'location must be set.' 
3147                      CALL message( 'netcdf_data_input_mod', 'NDI037',         &
3148                                     2, 2, 0, 6, 0 )
3149                   ENDIF
3150                ENDIF
3151             ENDIF
3152
3153!
3154!--          Check pavement parameters. If pavement_type is 0, all parameters 
3155!--          of pavement_pars must be set at this location.
3156             IF ( pavement_type_f%from_file )  THEN
3157                IF ( pavement_type_f%var(j,i) == 0 )  THEN
3158                   IF ( ANY( pavement_pars_f%pars_xy(:,j,i) ==                 &
3159                             pavement_pars_f%fill ) )  THEN
3160                      message_string = 'If pavement_type(y,x) = 0, all ' //    &
3161                                       'parameters of pavement_pars at this '//&
3162                                       'location must be set.' 
3163                      CALL message( 'netcdf_data_input_mod', 'NDI038',         &
3164                                     2, 2, 0, 6, 0 )
3165                   ENDIF
3166                ENDIF
3167             ENDIF
3168!
3169!--          Check pavement-subsurface parameters. If pavement_type is 0,
3170!--          all parameters of pavement_subsurface_pars must be set  at this
3171!--          location.
3172             IF ( pavement_type_f%from_file )  THEN
3173                IF ( pavement_type_f%var(j,i) == 0 )  THEN
3174                   IF ( ANY( pavement_subsurface_pars_f%pars_xyz(:,:,j,i) ==   &
3175                             pavement_subsurface_pars_f%fill ) )  THEN
3176                      message_string = 'If pavement_type(y,x) = 0, all ' //    &
3177                                       'parameters of '                  //    &
3178                                       'pavement_subsurface_pars at this '//   &
3179                                       'location must be set.' 
3180                      CALL message( 'netcdf_data_input_mod', 'NDI039',         &
3181                                     2, 2, 0, 6, 0 )
3182                   ENDIF
3183                ENDIF
3184             ENDIF
3185
3186!
3187!--          Check water parameters. If water_type is 0, all parameters 
3188!--          must be set  at this location.
3189             IF ( water_type_f%from_file )  THEN
3190                IF ( water_type_f%var(j,i) == 0 )  THEN
3191                   IF ( ANY( water_pars_f%pars_xy(:,j,i) ==                    &
3192                             water_pars_f%fill ) )  THEN
3193                      message_string = 'If water_type(y,x) = 0, all ' //       &
3194                                       'parameters of water_pars at this ' //  &
3195                                       'location must be set.' 
3196                      CALL message( 'netcdf_data_input_mod', 'NDI040',         &
3197                                     2, 2, 0, 6, 0 )
3198                   ENDIF
3199                ENDIF
3200             ENDIF
3201
3202          ENDDO
3203       ENDDO
3204
3205    END SUBROUTINE netcdf_data_input_check_static
3206
3207!------------------------------------------------------------------------------!
3208! Description:
3209! ------------
3210!> Vertical interpolation and extrapolation of 1D variables.
3211!------------------------------------------------------------------------------!
3212    SUBROUTINE netcdf_data_input_interpolate_1d( var, z_grid, z_file)
3213
3214       IMPLICIT NONE
3215
3216       LOGICAL      ::  top     !< flag indicating extrapolation at model top
3217
3218       INTEGER(iwp) ::  k       !< running index z-direction file
3219       INTEGER(iwp) ::  kk      !< running index z-direction stretched model grid
3220       INTEGER(iwp) ::  kl      !< lower index bound along z-direction
3221       INTEGER(iwp) ::  ku      !< upper index bound along z-direction
3222       INTEGER(iwp) ::  nz_file !< number of vertical levels on file
3223
3224
3225       REAL(wp), DIMENSION(:) ::  z_grid                  !< grid levels on numeric grid
3226       REAL(wp), DIMENSION(:) ::  z_file                  !< grid levels on file grid
3227       REAL(wp), DIMENSION(:), INTENT(INOUT) ::  var      !< treated variable
3228       REAL(wp), DIMENSION(:), ALLOCATABLE   ::  var_tmp  !< temporary variable
3229
3230
3231       kl = LBOUND(var,1)
3232       ku = UBOUND(var,1)
3233       ALLOCATE( var_tmp(kl:ku) )
3234
3235       DO  k = kl, ku
3236
3237          kk = MINLOC( ABS( z_file - z_grid(k) ), DIM = 1 )
3238
3239          IF ( kk < ku )  THEN
3240             IF ( z_file(kk) - z_grid(k) <= 0.0_wp )  THEN
3241                var_tmp(k) = var(kk) +                                         &
3242                                       ( var(kk+1)        - var(kk)    ) /     &
3243                                       ( z_file(kk+1)     - z_file(kk) ) *     &
3244                                       ( z_grid(k)        - z_file(kk) ) 
3245
3246             ELSEIF ( z_file(kk) - z_grid(k) > 0.0_wp )  THEN
3247                var_tmp(k) = var(kk-1) +                                       &
3248                                         ( var(kk)     - var(kk-1)    ) /      &
3249                                         ( z_file(kk)  - z_file(kk-1) ) *      &
3250                                         ( z_grid(k)   - z_file(kk-1) ) 
3251             ENDIF
3252!
3253!--       Extrapolate
3254          ELSE
3255     
3256             var_tmp(k) = var(ku) +   ( var(ku)    - var(ku-1)      ) /        &
3257                                      ( z_file(ku) - z_file(ku-1)   ) *        &
3258                                      ( z_grid(k)  - z_file(ku)     ) 
3259   
3260          ENDIF
3261
3262       ENDDO
3263       var(:) = var_tmp(:)
3264
3265       DEALLOCATE( var_tmp )
3266
3267
3268    END SUBROUTINE netcdf_data_input_interpolate_1d
3269
3270
3271!------------------------------------------------------------------------------!
3272! Description:
3273! ------------
3274!> Vertical interpolation and extrapolation of 1D variables from Inifor grid
3275!> onto Palm grid, where both have same dimension. Please note, the passed
3276!> paramter list in 1D version is different compared to 2D version.
3277!------------------------------------------------------------------------------!
3278    SUBROUTINE netcdf_data_input_interpolate_1d_soil( var, var_file,           &
3279                                                      z_grid, z_file,          &
3280                                                      nzb_var, nzt_var,        & 
3281                                                      nzb_file, nzt_file )
3282
3283       IMPLICIT NONE
3284
3285       INTEGER(iwp) ::  i        !< running index x-direction
3286       INTEGER(iwp) ::  j        !< running index y-direction
3287       INTEGER(iwp) ::  k        !< running index z-direction file
3288       INTEGER(iwp) ::  kk       !< running index z-direction stretched model grid
3289       INTEGER(iwp) ::  ku       !< upper index bound along z-direction for varialbe from file
3290       INTEGER(iwp) ::  nzb_var  !< lower bound of final array
3291       INTEGER(iwp) ::  nzt_var  !< upper bound of final array
3292       INTEGER(iwp) ::  nzb_file !< lower bound of file array
3293       INTEGER(iwp) ::  nzt_file !< upper bound of file array
3294
3295!        LOGICAL, OPTIONAL ::  depth !< flag indicating reverse z-axis, i.e. depth instead of height, e.g. in case of ocean or soil
3296
3297       REAL(wp), DIMENSION(nzb_var:nzt_var)   ::  z_grid   !< grid levels on numeric grid
3298       REAL(wp), DIMENSION(nzb_file:nzt_file) ::  z_file   !< grid levels on file grid
3299       REAL(wp), DIMENSION(nzb_var:nzt_var)   ::  var      !< treated variable
3300       REAL(wp), DIMENSION(nzb_file:nzt_file) ::  var_file !< temporary variable
3301
3302       ku = nzt_file
3303
3304       DO  k = nzb_var, nzt_var
3305!
3306!--       Determine index on Inifor grid which is closest to the actual height
3307          kk = MINLOC( ABS( z_file - z_grid(k) ), DIM = 1 )
3308!
3309!--       If closest index on Inifor grid is smaller than top index,
3310!--       interpolate the data
3311          IF ( kk < nzt_file )  THEN
3312             IF ( z_file(kk) - z_grid(k) <= 0.0_wp )  THEN
3313                var(k) = var_file(kk) + ( var_file(kk+1) - var_file(kk) ) /    &
3314                                        ( z_file(kk+1)   - z_file(kk)   ) *    &
3315                                        ( z_grid(k)      - z_file(kk)   ) 
3316
3317             ELSEIF ( z_file(kk) - z_grid(k) > 0.0_wp )  THEN
3318                var(k) = var_file(kk-1) + ( var_file(kk) - var_file(kk-1) ) /  &
3319                                          ( z_file(kk)   - z_file(kk-1)   ) *  &
3320                                          ( z_grid(k)    - z_file(kk-1)   ) 
3321             ENDIF
3322!
3323!--       Extrapolate if actual height is above the highest Inifor level
3324          ELSE
3325             var(k) = var_file(ku) + ( var_file(ku) - var_file(ku-1) ) /       &
3326                                     ( z_file(ku)   - z_file(ku-1)   ) *       &
3327                                     ( z_grid(k)    - z_file(ku)     ) 
3328
3329          ENDIF
3330
3331       ENDDO
3332
3333    END SUBROUTINE netcdf_data_input_interpolate_1d_soil
3334
3335!------------------------------------------------------------------------------!
3336! Description:
3337! ------------
3338!> Vertical interpolation and extrapolation of 2D variables at lateral boundaries.
3339!------------------------------------------------------------------------------!
3340    SUBROUTINE netcdf_data_input_interpolate_2d( var, z_grid, z_file)
3341
3342       IMPLICIT NONE
3343
3344       LOGICAL      ::  top     !< flag indicating extrapolation at model top
3345
3346       INTEGER(iwp) ::  i       !< running index x- or y -direction
3347       INTEGER(iwp) ::  il      !< lower index bound along x- or y-direction
3348       INTEGER(iwp) ::  iu      !< upper index bound along x- or y-direction
3349       INTEGER(iwp) ::  k       !< running index z-direction file
3350       INTEGER(iwp) ::  kk      !< running index z-direction stretched model grid
3351       INTEGER(iwp) ::  kl      !< lower index bound along z-direction
3352       INTEGER(iwp) ::  ku      !< upper index bound along z-direction
3353       INTEGER(iwp) ::  nz_file !< number of vertical levels on file
3354
3355
3356       REAL(wp), DIMENSION(:) ::  z_grid                  !< grid levels on numeric grid
3357       REAL(wp), DIMENSION(:) ::  z_file                  !< grid levels on file grid
3358       REAL(wp), DIMENSION(:,:), INTENT(INOUT) ::  var    !< treated variable
3359       REAL(wp), DIMENSION(:), ALLOCATABLE   ::  var_tmp  !< temporary variable
3360
3361
3362       il = LBOUND(var,2)
3363       iu = UBOUND(var,2)
3364       kl = LBOUND(var,1)
3365       ku = UBOUND(var,1)
3366       ALLOCATE( var_tmp(kl:ku) )
3367
3368       DO  i = il, iu
3369          DO  k = kl, ku
3370
3371             kk = MINLOC( ABS( z_file - z_grid(k) ), DIM = 1 )
3372
3373             IF ( kk < ku )  THEN
3374                IF ( z_file(kk) - z_grid(k) <= 0.0_wp )  THEN
3375                   var_tmp(k) = var(kk,i) +                                    &
3376                                          ( var(kk+1,i)      - var(kk,i)  ) /  &
3377                                          ( z_file(kk+1)     - z_file(kk) ) *  &
3378                                          ( z_grid(k)        - z_file(kk) ) 
3379
3380                ELSEIF ( z_file(kk) - z_grid(k) > 0.0_wp )  THEN
3381                   var_tmp(k) = var(kk-1,i) +                                  &
3382                                            ( var(kk,i)   - var(kk-1,i)  ) /   &
3383                                            ( z_file(kk)  - z_file(kk-1) ) *   &
3384                                            ( z_grid(k)   - z_file(kk-1) ) 
3385                ENDIF
3386!
3387!--          Extrapolate
3388             ELSE
3389     
3390                var_tmp(k) = var(ku,i) + ( var(ku,i)  - var(ku-1,i)    ) /     &
3391                                         ( z_file(ku) - z_file(ku-1)   ) *     &
3392                                         ( z_grid(k)  - z_file(ku)     ) 
3393   
3394             ENDIF
3395
3396          ENDDO
3397          var(:,i) = var_tmp(:)
3398
3399       ENDDO
3400
3401       DEALLOCATE( var_tmp )
3402
3403
3404    END SUBROUTINE netcdf_data_input_interpolate_2d
3405
3406!------------------------------------------------------------------------------!
3407! Description:
3408! ------------
3409!> Vertical interpolation and extrapolation of 3D variables.
3410!------------------------------------------------------------------------------!
3411    SUBROUTINE netcdf_data_input_interpolate_3d( var, z_grid, z_file )
3412
3413       IMPLICIT NONE
3414
3415       INTEGER(iwp) ::  i       !< running index x-direction
3416       INTEGER(iwp) ::  il      !< lower index bound along x-direction
3417       INTEGER(iwp) ::  iu      !< upper index bound along x-direction
3418       INTEGER(iwp) ::  j       !< running index y-direction
3419       INTEGER(iwp) ::  jl      !< lower index bound along x-direction
3420       INTEGER(iwp) ::  ju      !< upper index bound along x-direction
3421       INTEGER(iwp) ::  k       !< running index z-direction file
3422       INTEGER(iwp) ::  kk      !< running index z-direction stretched model grid
3423       INTEGER(iwp) ::  kl      !< lower index bound along z-direction
3424       INTEGER(iwp) ::  ku      !< upper index bound along z-direction
3425       INTEGER(iwp) ::  nz_file !< number of vertical levels on file
3426
3427       REAL(wp), DIMENSION(:) ::  z_grid                      !< grid levels on numeric grid
3428       REAL(wp), DIMENSION(:) ::  z_file                      !< grid levels on file grid
3429       REAL(wp), DIMENSION(:,:,:), INTENT(INOUT) ::  var      !< treated variable
3430       REAL(wp), DIMENSION(:), ALLOCATABLE       ::  var_tmp  !< temporary variable
3431
3432       il = LBOUND(var,3)
3433       iu = UBOUND(var,3)
3434       jl = LBOUND(var,2)
3435       ju = UBOUND(var,2)
3436       kl = LBOUND(var,1)
3437       ku = UBOUND(var,1)
3438
3439       ALLOCATE( var_tmp(kl:ku) )
3440
3441       DO  i = il, iu
3442          DO  j = jl, ju
3443             DO  k = kl, ku
3444
3445                kk = MINLOC( ABS( z_file - z_grid(k) ), DIM = 1 ) 
3446
3447                IF ( kk < ku )  THEN
3448                   IF ( z_file(kk) - z_grid(k) <= 0.0_wp )  THEN
3449                      var_tmp(k) = var(kk,j,i) +                               &
3450                                             ( var(kk+1,j,i) - var(kk,j,i) ) / &
3451                                             ( z_file(kk+1)  - z_file(kk)  ) * &
3452                                             ( z_grid(k)     - z_file(kk)  ) 
3453
3454                   ELSEIF ( z_file(kk) - z_grid(k) > 0.0_wp )  THEN
3455                      var_tmp(k) = var(kk-1,j,i) +                             &
3456                                             ( var(kk,j,i) - var(kk-1,j,i) ) / &
3457                                             ( z_file(kk)  - z_file(kk-1)  ) * &
3458                                             ( z_grid(k)   - z_file(kk-1)  ) 
3459                   ENDIF
3460!
3461!--             Extrapolate
3462                ELSE
3463                   var_tmp(k) = var(ku,j,i) +                                  &
3464                                       ( var(ku,j,i)  - var(ku-1,j,i)   ) /    &
3465                                       ( z_file(ku)   - z_file(ku-1)    ) *    &
3466                                       ( z_grid(k)    - z_file(ku)      ) 
3467
3468                ENDIF
3469             ENDDO
3470             var(:,j,i) = var_tmp(:)
3471          ENDDO
3472       ENDDO
3473
3474       DEALLOCATE( var_tmp )
3475
3476
3477    END SUBROUTINE netcdf_data_input_interpolate_3d
3478
3479!------------------------------------------------------------------------------!
3480! Description:
3481! ------------
3482!> Checks if a given variables is on file
3483!------------------------------------------------------------------------------!
3484    FUNCTION check_existence( vars_in_file, var_name )
3485
3486       IMPLICIT NONE
3487
3488       CHARACTER(LEN=*) ::  var_name                   !< variable to be checked
3489       CHARACTER(LEN=*), DIMENSION(:) ::  vars_in_file !< list of variables in file
3490
3491       INTEGER(iwp) ::  i                              !< loop variable
3492
3493       LOGICAL ::  check_existence                     !< flag indicating whether a variable exist or not - actual return value
3494
3495       i = 1
3496       check_existence = .FALSE.
3497       DO  WHILE ( i <= SIZE( vars_in_file ) )
3498          check_existence = TRIM( vars_in_file(i) ) == TRIM( var_name )  .OR.  &
3499                            check_existence
3500          i = i + 1
3501       ENDDO
3502
3503       RETURN
3504
3505    END FUNCTION check_existence
3506
3507
3508!------------------------------------------------------------------------------!
3509! Description:
3510! ------------
3511!> Closes an existing netCDF file.
3512!------------------------------------------------------------------------------!
3513    SUBROUTINE close_input_file( id )
3514#if defined( __netcdf )
3515
3516       USE pegrid
3517
3518       IMPLICIT NONE
3519
3520       INTEGER(iwp), INTENT(INOUT)        ::  id        !< file id
3521
3522       nc_stat = NF90_CLOSE( id )
3523       CALL handle_error( 'close', 537 )
3524#endif
3525    END SUBROUTINE close_input_file
3526
3527!------------------------------------------------------------------------------!
3528! Description:
3529! ------------
3530!> Opens an existing netCDF file for reading only and returns its id.
3531!------------------------------------------------------------------------------!
3532    SUBROUTINE open_read_file( filename, id )
3533#if defined( __netcdf )
3534
3535       USE pegrid
3536
3537       IMPLICIT NONE
3538
3539       CHARACTER (LEN=*), INTENT(IN) ::  filename  !< filename
3540       INTEGER(iwp), INTENT(INOUT)   ::  id        !< file id
3541       LOGICAL                       ::  file_open = .FALSE.
3542
3543       nc_stat = NF90_OPEN( filename, NF90_NOWRITE, id )
3544
3545       CALL handle_error( 'open_read_file', 536 )
3546
3547#endif
3548    END SUBROUTINE open_read_file
3549
3550!------------------------------------------------------------------------------!
3551! Description:
3552! ------------
3553!> Reads global or variable-related attributes of type INTEGER (32-bit)
3554!------------------------------------------------------------------------------!
3555     SUBROUTINE get_attribute_int32( id, attribute_name, value, global,        &
3556                                     variable_name )
3557
3558       USE pegrid
3559
3560       IMPLICIT NONE
3561
3562       CHARACTER(LEN=*)            ::  attribute_name   !< attribute name
3563       CHARACTER(LEN=*), OPTIONAL  ::  variable_name    !< variable name
3564
3565       INTEGER(iwp), INTENT(IN)    ::  id               !< file id
3566       INTEGER(iwp)                ::  id_var           !< variable id
3567       INTEGER(iwp), INTENT(INOUT) ::  value            !< read value
3568
3569       LOGICAL, INTENT(IN) ::  global                   !< flag indicating global attribute
3570#if defined( __netcdf )
3571
3572!
3573!--    Read global attribute
3574       IF ( global )  THEN
3575          nc_stat = NF90_GET_ATT( id, NF90_GLOBAL, TRIM( attribute_name ), value )
3576          CALL handle_error( 'get_attribute_int32 global', 522 )
3577!
3578!--    Read attributes referring to a single variable. Therefore, first inquire
3579!--    variable id
3580       ELSE
3581          nc_stat = NF90_INQ_VARID( id, TRIM( variable_name ), id_var )
3582          CALL handle_error( 'get_attribute_int32', 522 )
3583          nc_stat = NF90_GET_ATT( id, id_var, TRIM( attribute_name ), value )
3584          CALL handle_error( 'get_attribute_int32', 522 )       
3585       ENDIF
3586#endif
3587    END SUBROUTINE get_attribute_int32
3588
3589!------------------------------------------------------------------------------!
3590! Description:
3591! ------------
3592!> Reads global or variable-related attributes of type INTEGER (8-bit)
3593!------------------------------------------------------------------------------!
3594     SUBROUTINE get_attribute_int8( id, attribute_name, value, global,         &
3595                                    variable_name )
3596
3597       USE pegrid
3598
3599       IMPLICIT NONE
3600
3601       CHARACTER(LEN=*)            ::  attribute_name   !< attribute name
3602       CHARACTER(LEN=*), OPTIONAL  ::  variable_name    !< variable name
3603
3604       INTEGER(iwp), INTENT(IN)    ::  id               !< file id
3605       INTEGER(iwp)                ::  id_var           !< variable id
3606       INTEGER(KIND=1), INTENT(INOUT) ::  value         !< read value
3607
3608       LOGICAL, INTENT(IN) ::  global                   !< flag indicating global attribute
3609#if defined( __netcdf )
3610
3611!
3612!--    Read global attribute
3613       IF ( global )  THEN
3614          nc_stat = NF90_GET_ATT( id, NF90_GLOBAL, TRIM( attribute_name ), value )
3615          CALL handle_error( 'get_attribute_int8 global', 523 )
3616!
3617!--    Read attributes referring to a single variable. Therefore, first inquire
3618!--    variable id
3619       ELSE
3620          nc_stat = NF90_INQ_VARID( id, TRIM( variable_name ), id_var )
3621          CALL handle_error( 'get_attribute_int8', 523 )
3622          nc_stat = NF90_GET_ATT( id, id_var, TRIM( attribute_name ), value )
3623          CALL handle_error( 'get_attribute_int8', 523 )       
3624       ENDIF
3625#endif
3626    END SUBROUTINE get_attribute_int8
3627
3628!------------------------------------------------------------------------------!
3629! Description:
3630! ------------
3631!> Reads global or variable-related attributes of type REAL
3632!------------------------------------------------------------------------------!
3633     SUBROUTINE get_attribute_real( id, attribute_name, value, global,         &
3634                                    variable_name )
3635
3636       USE pegrid
3637
3638       IMPLICIT NONE
3639
3640       CHARACTER(LEN=*)            ::  attribute_name   !< attribute name
3641       CHARACTER(LEN=*), OPTIONAL  ::  variable_name    !< variable name
3642
3643       INTEGER(iwp), INTENT(IN)    ::  id               !< file id
3644       INTEGER(iwp)                ::  id_var           !< variable id
3645
3646       LOGICAL, INTENT(IN) ::  global                   !< flag indicating global attribute
3647
3648       REAL(wp), INTENT(INOUT)     ::  value            !< read value
3649#if defined( __netcdf )
3650
3651
3652!
3653!-- Read global attribute
3654       IF ( global )  THEN
3655          nc_stat = NF90_GET_ATT( id, NF90_GLOBAL, TRIM( attribute_name ), value )
3656          CALL handle_error( 'get_attribute_real global', 524 )
3657!
3658!-- Read attributes referring to a single variable. Therefore, first inquire
3659!-- variable id
3660       ELSE
3661          nc_stat = NF90_INQ_VARID( id, TRIM( variable_name ), id_var )
3662          CALL handle_error( 'get_attribute_real', 524 )
3663          nc_stat = NF90_GET_ATT( id, id_var, TRIM( attribute_name ), value )
3664          CALL handle_error( 'get_attribute_real', 524 )       
3665       ENDIF
3666#endif
3667    END SUBROUTINE get_attribute_real
3668
3669!------------------------------------------------------------------------------!
3670! Description:
3671! ------------
3672!> Reads global or variable-related attributes of type CHARACTER
3673!> Remark: reading attributes of type NF_STRING return an error code 56 -
3674!> Attempt to convert between text & numbers.
3675!------------------------------------------------------------------------------!
3676     SUBROUTINE get_attribute_string( id, attribute_name, value, global,       &
3677                                      variable_name )
3678
3679       USE pegrid
3680
3681       IMPLICIT NONE
3682
3683       CHARACTER(LEN=*)                ::  attribute_name   !< attribute name
3684       CHARACTER(LEN=*), OPTIONAL      ::  variable_name    !< variable name
3685       CHARACTER(LEN=*), INTENT(INOUT) ::  value            !< read value
3686
3687       INTEGER(iwp), INTENT(IN)    ::  id               !< file id
3688       INTEGER(iwp)                ::  id_var           !< variable id
3689
3690       LOGICAL, INTENT(IN) ::  global                   !< flag indicating global attribute
3691#if defined( __netcdf )
3692
3693!
3694!--    Read global attribute
3695       IF ( global )  THEN
3696          nc_stat = NF90_GET_ATT( id, NF90_GLOBAL, TRIM( attribute_name ), value )
3697          CALL handle_error( 'get_attribute_string global', 525 )
3698!
3699!--    Read attributes referring to a single variable. Therefore, first inquire
3700!--    variable id
3701       ELSE
3702          nc_stat = NF90_INQ_VARID( id, TRIM( variable_name ), id_var )
3703          CALL handle_error( 'get_attribute_string', 525 )
3704
3705          nc_stat = NF90_GET_ATT( id, id_var, TRIM( attribute_name ), value )
3706          CALL handle_error( 'get_attribute_string',525 ) 
3707
3708       ENDIF
3709#endif
3710    END SUBROUTINE get_attribute_string
3711
3712
3713
3714!------------------------------------------------------------------------------!
3715! Description:
3716! ------------
3717!> Get dimension array for a given dimension
3718!------------------------------------------------------------------------------!
3719     SUBROUTINE get_dimension_length( id, dim_len, variable_name )
3720#if defined( __netcdf )
3721
3722       USE pegrid
3723
3724       IMPLICIT NONE
3725
3726       CHARACTER(LEN=*)            ::  variable_name    !< dimension name
3727       CHARACTER(LEN=100)          ::  dum              !< dummy variable to receive return character
3728
3729       INTEGER(iwp)                ::  dim_len          !< dimension size
3730       INTEGER(iwp), INTENT(IN)    ::  id               !< file id
3731       INTEGER(iwp)                ::  id_dim           !< dimension id
3732
3733!
3734!--    First, inquire dimension ID
3735       nc_stat = NF90_INQ_DIMID( id, TRIM( variable_name ), id_dim )
3736       CALL handle_error( 'get_dimension_length', 526 )
3737!
3738!--    Inquire dimension length
3739       nc_stat = NF90_INQUIRE_DIMENSION( id, id_dim, dum, LEN = dim_len )
3740       CALL handle_error( 'get_dimension_length', 526 ) 
3741
3742#endif
3743    END SUBROUTINE get_dimension_length
3744
3745!------------------------------------------------------------------------------!
3746! Description:
3747! ------------
3748!> Reads a 1D integer variable from file.
3749!------------------------------------------------------------------------------!
3750     SUBROUTINE get_variable_1d_int( id, variable_name, var )
3751
3752       USE pegrid
3753
3754       IMPLICIT NONE
3755
3756       CHARACTER(LEN=*)            ::  variable_name    !< variable name
3757
3758       INTEGER(iwp), INTENT(IN)    ::  id               !< file id
3759       INTEGER(iwp)                ::  id_var           !< dimension id
3760
3761       INTEGER(iwp), DIMENSION(:), INTENT(INOUT) ::  var  !< variable to be read
3762#if defined( __netcdf )
3763
3764!
3765!--    First, inquire variable ID
3766       nc_stat = NF90_INQ_VARID( id, TRIM( variable_name ), id_var )
3767       CALL handle_error( 'get_variable_1d_int', 527 )
3768!
3769!--    Inquire dimension length
3770       nc_stat = NF90_GET_VAR( id, id_var, var )
3771       CALL handle_error( 'get_variable_1d_int', 527 ) 
3772
3773#endif
3774    END SUBROUTINE get_variable_1d_int
3775
3776!------------------------------------------------------------------------------!
3777! Description:
3778! ------------
3779!> Reads a 1D float variable from file.
3780!------------------------------------------------------------------------------!
3781     SUBROUTINE get_variable_1d_real( id, variable_name, var )
3782
3783       USE pegrid
3784
3785       IMPLICIT NONE
3786
3787       CHARACTER(LEN=*)            ::  variable_name    !< variable name
3788
3789       INTEGER(iwp), INTENT(IN)    ::  id               !< file id
3790       INTEGER(iwp)                ::  id_var           !< dimension id
3791
3792       REAL(wp), DIMENSION(:), INTENT(INOUT) ::  var  !< variable to be read
3793#if defined( __netcdf )
3794
3795!
3796!--    First, inquire variable ID
3797       nc_stat = NF90_INQ_VARID( id, TRIM( variable_name ), id_var )
3798       CALL handle_error( 'get_variable_1d_real', 527 )
3799!
3800!--    Inquire dimension length
3801       nc_stat = NF90_GET_VAR( id, id_var, var )
3802       CALL handle_error( 'get_variable_1d_real', 527 ) 
3803
3804#endif
3805    END SUBROUTINE get_variable_1d_real
3806
3807!------------------------------------------------------------------------------!
3808! Description:
3809! ------------
3810!> Reads a 2D REAL variable from a file. Reading is done processor-wise,
3811!> i.e. each core reads its own domain in slices along x.
3812!------------------------------------------------------------------------------!
3813    SUBROUTINE get_variable_2d_real( id, variable_name, i, var )
3814
3815       USE indices
3816       USE pegrid
3817
3818       IMPLICIT NONE
3819
3820       CHARACTER(LEN=*)              ::  variable_name   !< variable name
3821
3822       INTEGER(iwp), INTENT(IN)      ::  i               !< index along x direction
3823       INTEGER(iwp), INTENT(IN)      ::  id              !< file id
3824       INTEGER(iwp)                  ::  id_var          !< variable id
3825
3826       REAL(wp), DIMENSION(nys:nyn), INTENT(INOUT) ::  var  !< variable to be read
3827#if defined( __netcdf )
3828!
3829!--    Inquire variable id
3830       nc_stat = NF90_INQ_VARID( id, TRIM( variable_name ), id_var )
3831!
3832!--    Get variable
3833       nc_stat = NF90_GET_VAR( id, id_var, var(nys:nyn),                       &
3834                               start = (/ i+1, nys+1 /),                       &
3835                               count = (/ 1, nyn - nys + 1 /) )
3836
3837       CALL handle_error( 'get_variable_2d_real', 528 )
3838#endif
3839    END SUBROUTINE get_variable_2d_real
3840
3841!------------------------------------------------------------------------------!
3842! Description:
3843! ------------
3844!> Reads a 2D 32-bit INTEGER variable from file. Reading is done processor-wise,
3845!> i.e. each core reads its own domain in slices along x.
3846!------------------------------------------------------------------------------!
3847    SUBROUTINE get_variable_2d_int32( id, variable_name, i, var )
3848
3849       USE indices
3850       USE pegrid
3851
3852       IMPLICIT NONE
3853
3854       CHARACTER(LEN=*)              ::  variable_name   !< variable name
3855
3856       INTEGER(iwp), INTENT(IN)      ::  i               !< index along x direction
3857       INTEGER(iwp), INTENT(IN)      ::  id              !< file id
3858       INTEGER(iwp)                  ::  id_var          !< variable id
3859       INTEGER(iwp), DIMENSION(nys:nyn), INTENT(INOUT) ::  var  !< variable to be read
3860#if defined( __netcdf )
3861!
3862!--    Inquire variable id
3863       nc_stat = NF90_INQ_VARID( id, TRIM( variable_name ), id_var )
3864!
3865!--    Get variable
3866       nc_stat = NF90_GET_VAR( id, id_var, var(nys:nyn),                       &
3867                               start = (/ i+1, nys+1 /),                       &
3868                               count = (/ 1, nyn - nys + 1 /) )
3869
3870       CALL handle_error( 'get_variable_2d_int32', 529 )
3871#endif
3872    END SUBROUTINE get_variable_2d_int32
3873
3874!------------------------------------------------------------------------------!
3875! Description:
3876! ------------
3877!> Reads a 2D 8-bit INTEGER variable from file. Reading is done processor-wise,
3878!> i.e. each core reads its own domain in slices along x.
3879!------------------------------------------------------------------------------!
3880    SUBROUTINE get_variable_2d_int8( id, variable_name, i, var )
3881
3882       USE indices
3883       USE pegrid
3884
3885       IMPLICIT NONE
3886
3887       CHARACTER(LEN=*)              ::  variable_name   !< variable name
3888
3889       INTEGER(iwp), INTENT(IN)      ::  i               !< index along x direction
3890       INTEGER(iwp), INTENT(IN)      ::  id              !< file id
3891       INTEGER(iwp)                  ::  id_var          !< variable id
3892       INTEGER(KIND=1), DIMENSION(nys:nyn), INTENT(INOUT) ::  var  !< variable to be read
3893#if defined( __netcdf )
3894!
3895!--    Inquire variable id
3896       nc_stat = NF90_INQ_VARID( id, TRIM( variable_name ), id_var )
3897!
3898!--    Get variable
3899       nc_stat = NF90_GET_VAR( id, id_var, var(nys:nyn),                       &
3900                               start = (/ i+1, nys+1 /),                       &
3901                               count = (/ 1, nyn - nys + 1 /) )
3902
3903       CALL handle_error( 'get_variable_2d_int8', 530 )
3904#endif
3905    END SUBROUTINE get_variable_2d_int8
3906
3907!------------------------------------------------------------------------------!
3908! Description:
3909! ------------
3910!> Reads a 3D 8-bit INTEGER variable from file.
3911!------------------------------------------------------------------------------!
3912    SUBROUTINE get_variable_3d_int8( id, variable_name, i, j, var )
3913
3914       USE indices
3915       USE pegrid
3916
3917       IMPLICIT NONE
3918
3919       CHARACTER(LEN=*)              ::  variable_name   !< variable name
3920
3921       INTEGER(iwp), INTENT(IN)      ::  i               !< index along x direction
3922       INTEGER(iwp), INTENT(IN)      ::  id              !< file id
3923       INTEGER(iwp)                  ::  id_var          !< variable id
3924       INTEGER(iwp), INTENT(IN)      ::  j               !< index along y direction
3925       INTEGER(iwp)                  ::  n_file          !< number of data-points along 3rd dimension
3926
3927       INTEGER(iwp), DIMENSION(1:3)  ::  id_dim
3928
3929       INTEGER( KIND = 1 ), DIMENSION(nzb:nzt+1), INTENT(INOUT) ::  var  !< variable to be read
3930#if defined( __netcdf )
3931
3932!
3933!--    Inquire variable id
3934       nc_stat = NF90_INQ_VARID( id, TRIM( variable_name ), id_var )
3935!
3936!--    Get length of first dimension, required for the count parameter.
3937!--    Therefore, first inquired dimension ids
3938       nc_stat = NF90_INQUIRE_VARIABLE( id, id_var, DIMIDS = id_dim )
3939       nc_stat = NF90_INQUIRE_DIMENSION( id, id_dim(3), LEN = n_file )
3940!
3941!--    Get variable
3942       nc_stat = NF90_GET_VAR( id, id_var, var,                  &
3943                               start = (/ i+1, j+1, 1 /),                      &
3944                               count = (/ 1, 1, n_file /) )
3945
3946       CALL handle_error( 'get_variable_3d_int8', 531 )
3947#endif
3948    END SUBROUTINE get_variable_3d_int8
3949
3950
3951!------------------------------------------------------------------------------!
3952! Description:
3953! ------------
3954!> Reads a 3D float variable from file. 
3955!------------------------------------------------------------------------------!
3956    SUBROUTINE get_variable_3d_real( id, variable_name, i, j, var )
3957
3958       USE indices
3959       USE pegrid
3960
3961       IMPLICIT NONE
3962
3963       CHARACTER(LEN=*)              ::  variable_name   !< variable name
3964
3965       INTEGER(iwp), INTENT(IN)      ::  i               !< index along x direction
3966       INTEGER(iwp), INTENT(IN)      ::  id              !< file id
3967       INTEGER(iwp)                  ::  id_var          !< variable id
3968       INTEGER(iwp), INTENT(IN)      ::  j               !< index along y direction
3969       INTEGER(iwp)                  ::  n3              !< number of data-points along 3rd dimension
3970
3971       INTEGER(iwp), DIMENSION(3)    ::  id_dim
3972
3973       REAL(wp), DIMENSION(:), INTENT(INOUT) ::  var     !< variable to be read
3974#if defined( __netcdf )
3975
3976!
3977!--    Inquire variable id
3978       nc_stat = NF90_INQ_VARID( id, TRIM( variable_name ), id_var )
3979!
3980!--    Get length of first dimension, required for the count parameter.
3981!--    Therefore, first inquired dimension ids
3982       nc_stat = NF90_INQUIRE_VARIABLE( id, id_var, DIMIDS = id_dim )
3983       nc_stat = NF90_INQUIRE_DIMENSION( id, id_dim(3), LEN = n3 )
3984!
3985!--    Get variable
3986       nc_stat = NF90_GET_VAR( id, id_var, var,                                &
3987                               start = (/ i+1, j+1, 1 /),                      &
3988                               count = (/ 1, 1, n3 /) )
3989
3990       CALL handle_error( 'get_variable_3d_real', 532 )
3991#endif
3992    END SUBROUTINE get_variable_3d_real
3993
3994
3995!------------------------------------------------------------------------------!
3996! Description:
3997! ------------
3998!> Reads a 4D float variable from file. Note, in constrast to 3D versions,
3999!> dimensions are already inquired and passed so that they are known here.
4000!------------------------------------------------------------------------------!
4001    SUBROUTINE get_variable_4d_real( id, variable_name, i, j, var, n3, n4 )
4002
4003       USE indices
4004       USE pegrid
4005
4006       IMPLICIT NONE
4007
4008       CHARACTER(LEN=*)              ::  variable_name   !< variable name
4009
4010       INTEGER(iwp), INTENT(IN)      ::  i               !< index along x direction
4011       INTEGER(iwp), INTENT(IN)      ::  id              !< file id
4012       INTEGER(iwp)                  ::  id_var          !< variable id
4013       INTEGER(iwp), INTENT(IN)      ::  j               !< index along y direction
4014       INTEGER(iwp), INTENT(IN)      ::  n3              !< number of data-points along 3rd dimension
4015       INTEGER(iwp), INTENT(IN)      ::  n4              !< number of data-points along 4th dimension
4016
4017       INTEGER(iwp), DIMENSION(3)    ::  id_dim
4018
4019       REAL(wp), DIMENSION(:,:), INTENT(INOUT) ::  var     !< variable to be read
4020#if defined( __netcdf )
4021
4022!
4023!--    Inquire variable id
4024       nc_stat = NF90_INQ_VARID( id, TRIM( variable_name ), id_var )
4025!
4026!--    Get variable
4027       nc_stat = NF90_GET_VAR( id, id_var, var,                                &
4028                               start = (/ i+1, j+1, 1, 1 /),                   &
4029                               count = (/ 1, 1, n3, n4 /) )
4030
4031       CALL handle_error( 'get_variable_4d_real', 533 )
4032#endif
4033    END SUBROUTINE get_variable_4d_real
4034
4035
4036
4037!------------------------------------------------------------------------------!
4038! Description:
4039! ------------
4040!> Reads a 3D float variable at left, right, north, south and top boundaries.
4041!------------------------------------------------------------------------------!
4042    SUBROUTINE get_variable_bc( id, variable_name, t_start,                    &
4043                                i2_s, count_2, i3_s, count_3,  var )
4044
4045       USE indices
4046       USE pegrid
4047
4048       IMPLICIT NONE
4049
4050       CHARACTER(LEN=*)              ::  variable_name   !< variable name
4051
4052       INTEGER(iwp)                  ::  count_2         !< number of elements in second dimension
4053       INTEGER(iwp)                  ::  count_3         !< number of elements in third dimension (usually 1)
4054       INTEGER(iwp)                  ::  i2_s            !< start index of second dimension
4055       INTEGER(iwp)                  ::  i3_s            !< start index of third dimension
4056       INTEGER(iwp), INTENT(IN)      ::  id              !< file id
4057       INTEGER(iwp)                  ::  id_var          !< variable id
4058       INTEGER(iwp)                  ::  t_start         !< start index at time dimension with respect to netcdf convention
4059
4060       REAL(wp), DIMENSION(:), INTENT(INOUT) ::  var     !< input variable
4061#if defined( __netcdf )
4062
4063!
4064!--    Inquire variable id
4065       nc_stat = NF90_INQ_VARID( id, TRIM( variable_name ), id_var )
4066!
4067!--    Get variable
4068       nc_stat = NF90_GET_VAR( id, id_var, var,                              &
4069                               start = (/ i3_s, i2_s, t_start /),            & 
4070                               count = (/ count_3, count_2, 1 /) )       
4071
4072       CALL handle_error( 'get_variable_bc', 532 )
4073#endif
4074    END SUBROUTINE get_variable_bc
4075
4076
4077
4078!------------------------------------------------------------------------------!
4079! Description:
4080! ------------
4081!> Inquires the number of variables in a file 
4082!------------------------------------------------------------------------------!
4083    SUBROUTINE inquire_num_variables( id, num_vars )
4084
4085       USE indices
4086       USE pegrid
4087
4088       IMPLICIT NONE
4089
4090       INTEGER(iwp), INTENT(IN)      ::  id              !< file id
4091       INTEGER(iwp), INTENT(INOUT)   ::  num_vars        !< number of variables in a file
4092#if defined( __netcdf )
4093
4094       nc_stat = NF90_INQUIRE( id, NVARIABLES = num_vars )
4095       CALL handle_error( 'inquire_num_variables', 534 )
4096
4097#endif
4098    END SUBROUTINE inquire_num_variables
4099
4100
4101!------------------------------------------------------------------------------!
4102! Description:
4103! ------------
4104!> Inquires the variable names belonging to a file.
4105!------------------------------------------------------------------------------!
4106    SUBROUTINE inquire_variable_names( id, var_names )
4107
4108       USE indices
4109       USE pegrid
4110
4111       IMPLICIT NONE
4112
4113       CHARACTER(LEN=*), DIMENSION(:), INTENT(INOUT) ::  var_names   !< return variable - variable names
4114       INTEGER(iwp)                                  ::  i           !< loop variable
4115       INTEGER(iwp), INTENT(IN)                      ::  id          !< file id
4116       INTEGER(iwp)                                  ::  num_vars    !< number of variables (unused return parameter)
4117       INTEGER(iwp), DIMENSION(:), ALLOCATABLE       ::  varids      !< dummy array to strore variable ids temporarily
4118#if defined( __netcdf )
4119
4120       ALLOCATE( varids(1:SIZE(var_names)) )
4121       nc_stat = NF90_INQ_VARIDS( id, NVARS = num_vars, VARIDS = varids )
4122       CALL handle_error( 'inquire_variable_names', 535 )
4123
4124       DO  i = 1, SIZE(var_names)
4125          nc_stat = NF90_INQUIRE_VARIABLE( id, varids(i), NAME = var_names(i) )
4126          CALL handle_error( 'inquire_variable_names', 535 )
4127       ENDDO
4128
4129       DEALLOCATE( varids )
4130#endif
4131    END SUBROUTINE inquire_variable_names
4132
4133!------------------------------------------------------------------------------!
4134! Description:
4135! ------------
4136!> Prints out a text message corresponding to the current status.
4137!------------------------------------------------------------------------------!
4138    SUBROUTINE handle_error( routine_name, errno )
4139
4140       USE control_parameters,                                                 &
4141           ONLY:  message_string
4142
4143       IMPLICIT NONE
4144
4145       CHARACTER(LEN=6) ::  message_identifier
4146       CHARACTER(LEN=*) ::  routine_name
4147
4148       INTEGER(iwp) ::  errno
4149#if defined( __netcdf )
4150
4151       IF ( nc_stat /= NF90_NOERR )  THEN
4152
4153          WRITE( message_identifier, '(''NC'',I4.4)' )  errno
4154          message_string = TRIM( NF90_STRERROR( nc_stat ) )
4155
4156          CALL message( routine_name, message_identifier, 2, 2, 0, 6, 1 )
4157
4158       ENDIF
4159
4160#endif
4161    END SUBROUTINE handle_error
4162
4163
4164 END MODULE netcdf_data_input_mod
Note: See TracBrowser for help on using the repository browser.