Home

Context Navigation

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

Last change on this file since 2772 was 2772, checked in by suehring, 7 years ago
Enable initialization via inifor without running land-surface model; small bugfix in chemistry model string treatment
Property svn:keywords set to `Id`
File size: 188.8 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

| Impressum | ©Leibniz Universität Hannover |