Home

Context Navigation

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

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