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

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

Nesting for chemical species implemented; Bugfix passive scalar boundary condition after anterpolation; Timeseries output of surface temperature; Enable initialization of 3D topography (was commented out so far)

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