Home

Context Navigation

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

Last change on this file since 3039 was 3037, checked in by gronemeier, 7 years ago
renamed input dimension "depth" to "zsoil"
Property svn:keywords set to `Id`
File size: 210.3 KB

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