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

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

Bugfix, missing initialization of surface attributes in case of inifor-initialization branch

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