!> @file src/inifor_io.f90 !------------------------------------------------------------------------------! ! This file is part of the PALM model system. ! ! PALM is free software: you can redistribute it and/or modify it under the ! terms of the GNU General Public License as published by the Free Software ! Foundation, either version 3 of the License, or (at your option) any later ! version. ! ! PALM is distributed in the hope that it will be useful, but WITHOUT ANY ! WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR ! A PARTICULAR PURPOSE. See the GNU General Public License for more details. ! ! You should have received a copy of the GNU General Public License along with ! PALM. If not, see . ! ! Copyright 2017-2018 Leibniz Universitaet Hannover ! Copyright 2017-2018 Deutscher Wetterdienst Offenbach !------------------------------------------------------------------------------! ! ! Current revisions: ! ----------------- ! ! ! Former revisions: ! ----------------- ! $Id: inifor_io.f90 3764 2019-02-26 13:42:09Z eckhard $ ! Removed dependency on radiation input files ! ! ! 3716 2019-02-05 17:02:38Z eckhard ! Removed dependency on soilmoisture input files ! ! ! 3680 2019-01-18 14:54:12Z knoop ! Moved get_input_file_list() here from grid module, added check for presence of ! input files ! ! ! ! ! 3618 2018-12-10 13:25:22Z eckhard ! Prefixed all INIFOR modules with inifor_ ! ! ! 3615 2018-12-10 07:21:03Z raasch ! bugfix: abort replaced by inifor_abort ! ! 3557 2018-11-22 16:01:22Z eckhard ! Updated documentation, removed unused subroutine write_netcdf_variable_2d() ! ! ! 3537 2018-11-20 10:53:14Z eckhard ! New routine get_netcdf_dim_vector() ! ! ! 3534 2018-11-19 15:35:16Z raasch ! bugfix: INTENT attribute changed ! ! 3456 2018-10-30 14:29:54Z eckhard ! NetCDf output of internal arrays only with --debug option ! ! ! 3447 2018-10-29 15:52:54Z eckhard ! Removed INCLUDE statement for get_netcdf_variable() ! Renamed source files for compatibilty with PALM build system ! ! ! 3395 2018-10-22 17:32:49Z eckhard ! Added command-line options for configuring the computation of geostrophic ! winds (--averagin-mode, --averaging-angle) ! Added command-line option --input-prefix for setting input file prefixes all ! at once ! Added --debug option for more verbose terminal output ! Added option-specific *_is_set LOGICALs to indicate invocation from the ! command-line ! Improved error messages in case of empty file-name strings ! Improved routine naming ! ! 3183 2018-07-27 14:25:55Z suehring ! Introduced new PALM grid stretching ! Updated variable names and metadata for PIDS v1.9 compatibility ! Improved handling of the start date string ! Better compatibility with older Intel compilers: ! - avoiding implicit array allocation with new get_netcdf_variable() ! subroutine instead of function ! Improved command line interface: ! - Added configuration validation ! - New options to configure input file prefixes ! - GNU-style short and long option names ! - Added version and copyright output ! ! ! 3182 2018-07-27 13:36:03Z suehring ! Initial revision ! ! ! ! Authors: ! -------- !> @author Eckhard Kadasch (Deutscher Wetterdienst, Offenbach) ! ! Description: ! ------------ !> The io module contains the functions needed to read and write netCDF data in !> INIFOR. !------------------------------------------------------------------------------! #if defined ( __netcdf ) MODULE inifor_io USE inifor_control USE inifor_defs, & ONLY: DATE, SNAME, PATH, PI, dp, hp, TO_RADIANS, TO_DEGREES, VERSION USE inifor_types USE inifor_util, & ONLY: add_hours_to, reverse, str, real_to_str USE netcdf IMPLICIT NONE !------------------------------------------------------------------------------! ! Description: ! ------------ !> get_netcdf_variable() reads the netCDF data and metadate for the netCDF !> variable 'in_var % name' from the file 'in_file'. The netCDF data array is !> stored in the 'buffer' array and metadata added to the respective members of !> the given 'in_var'. !------------------------------------------------------------------------------! INTERFACE get_netcdf_variable MODULE PROCEDURE get_netcdf_variable_int MODULE PROCEDURE get_netcdf_variable_real END INTERFACE get_netcdf_variable PRIVATE :: get_netcdf_variable_int, get_netcdf_variable_real CONTAINS !------------------------------------------------------------------------------! ! Description: ! ------------ !> get_netcdf_variable_int() implements the integer variant for the !> get_netcdf_variable interface. !------------------------------------------------------------------------------! SUBROUTINE get_netcdf_variable_int(in_file, in_var, buffer) CHARACTER(LEN=PATH), INTENT(IN) :: in_file TYPE(nc_var), INTENT(INOUT) :: in_var INTEGER(hp), ALLOCATABLE, INTENT(INOUT) :: buffer(:,:,:) INTEGER :: ncid INTEGER, DIMENSION(3) :: start, count IF ( nf90_open( TRIM(in_file), NF90_NOWRITE, ncid ) .EQ. NF90_NOERR .AND. & nf90_inq_varid( ncid, in_var % name, in_var % varid ) .EQ. NF90_NOERR ) THEN CALL get_input_dimensions(in_var, ncid) CALL get_netcdf_start_and_count(in_var, start, count) CALL run_control('time', 'read') ALLOCATE( buffer( count(1), count(2), count(3) ) ) CALL run_control('time', 'alloc') CALL check(nf90_get_var( ncid, in_var % varid, buffer, & start = start, & count = count )) ELSE message = "Failed to read '" // TRIM(in_var % name) // & "' from file '" // TRIM(in_file) // "'." CALL inifor_abort('get_netcdf_variable', message) END IF CALL check(nf90_close(ncid)) CALL run_control('time', 'read') END SUBROUTINE get_netcdf_variable_int !------------------------------------------------------------------------------! ! Description: ! ------------ !> get_netcdf_variable_real() implements the real variant for the !> get_netcdf_variable interface. !------------------------------------------------------------------------------! SUBROUTINE get_netcdf_variable_real(in_file, in_var, buffer) CHARACTER(LEN=PATH), INTENT(IN) :: in_file TYPE(nc_var), INTENT(INOUT) :: in_var REAL(dp), ALLOCATABLE, INTENT(INOUT) :: buffer(:,:,:) INTEGER :: ncid INTEGER, DIMENSION(3) :: start, count IF ( nf90_open( TRIM(in_file), NF90_NOWRITE, ncid ) .EQ. NF90_NOERR .AND. & nf90_inq_varid( ncid, in_var % name, in_var % varid ) .EQ. NF90_NOERR ) THEN CALL get_input_dimensions(in_var, ncid) CALL get_netcdf_start_and_count(in_var, start, count) CALL run_control('time', 'read') ALLOCATE( buffer( count(1), count(2), count(3) ) ) CALL run_control('time', 'alloc') CALL check(nf90_get_var( ncid, in_var % varid, buffer, & start = start, & count = count )) ELSE message = "Failed to read '" // TRIM(in_var % name) // & "' from file '" // TRIM(in_file) // "'." CALL inifor_abort('get_netcdf_variable', message) END IF CALL check(nf90_close(ncid)) CALL run_control('time', 'read') END SUBROUTINE get_netcdf_variable_real !------------------------------------------------------------------------------! ! Description: ! ------------ !> get_netcdf_dim_vector() reads the coordinate array 'coordname' from the !> netCDF file 'filename'. !------------------------------------------------------------------------------! SUBROUTINE get_netcdf_dim_vector(filename, coordname, coords) CHARACTER(LEN=*), INTENT(IN) :: filename CHARACTER(LEN=*), INTENT(IN) :: coordname REAL(dp), ALLOCATABLE, INTENT(INOUT) :: coords(:) INTEGER :: ncid, varid, dimlen INTEGER :: dimids(NF90_MAX_VAR_DIMS) IF ( nf90_open( TRIM(filename), NF90_NOWRITE, ncid ) .EQ. NF90_NOERR .AND. & nf90_inq_varid( ncid, coordname, varid ) .EQ. NF90_NOERR ) THEN CALL check(nf90_inquire_variable( ncid, varid, dimids = dimids )) CALL check(nf90_inquire_dimension( ncid, dimids(1), len = dimlen )) ALLOCATE(coords(dimlen)) CALL check(nf90_get_var( ncid, varid, coords)) ELSE message = "Failed to read '" // TRIM(coordname) // & "' from file '" // TRIM(filename) // "'." CALL inifor_abort('get_netcdf_dim_vector', message) END IF END SUBROUTINE get_netcdf_dim_vector !------------------------------------------------------------------------------! ! Description: ! ------------ !> get_input_dimensions() reads dimensions metadata of the netCDF variable given !> by 'in_var % name' into 'in_var' data structure. !------------------------------------------------------------------------------! SUBROUTINE get_input_dimensions(in_var, ncid) TYPE(nc_var), INTENT(INOUT) :: in_var INTEGER, INTENT(IN) :: ncid INTEGER :: i CALL check(nf90_get_att( ncid, in_var % varid, "long_name", & in_var % long_name)) CALL check(nf90_get_att( ncid, in_var % varid, "units", & in_var % units )) CALL check(nf90_inquire_variable( ncid, in_var % varid, & ndims = in_var % ndim, & dimids = in_var % dimids )) DO i = 1, in_var % ndim CALL check(nf90_inquire_dimension( ncid, in_var % dimids(i), & name = in_var % dimname(i), & len = in_var % dimlen(i) )) END DO END SUBROUTINE get_input_dimensions !------------------------------------------------------------------------------! ! Description: ! ------------ !> get_netcdf_start_and_count() gets the start position and element counts for !> the given netCDF file. This information is used in get_netcdf_variable_int() !> and _real() for reading input variables.. !------------------------------------------------------------------------------! SUBROUTINE get_netcdf_start_and_count(in_var, start, count) TYPE(nc_var), INTENT(INOUT) :: in_var INTEGER, DIMENSION(3), INTENT(OUT) :: start, count INTEGER :: ndim IF ( in_var % ndim .LT. 2 .OR. in_var % ndim .GT. 4 ) THEN message = "Failed reading NetCDF variable " // & TRIM(in_var % name) // " with " // TRIM(str(in_var % ndim)) // & " dimensions because only two- and and three-dimensional" // & " variables are supported." CALL inifor_abort('get_netcdf_start_and_count', message) END IF start = (/ 1, 1, 1 /) IF ( TRIM(in_var % name) .EQ. 'T_SO' ) THEN ! !-- Skip depth = 0.0 for T_SO and reduce number of depths from 9 to 8 in_var % dimlen(3) = in_var % dimlen(3) - 1 ! !-- Start reading from second level, e.g. depth = 0.005 instead of 0.0 start(3) = 2 END IF IF (in_var % ndim .EQ. 2) THEN in_var % dimlen(3) = 1 ENDIF ndim = MIN(in_var % ndim, 3) count = (/ 1, 1, 1 /) count(1:ndim) = in_var % dimlen(1:ndim) END SUBROUTINE get_netcdf_start_and_count !------------------------------------------------------------------------------! ! Description: ! ------------ !> Routine for defining netCDF variables in the dynamic driver, INIFOR's netCDF !> output. !------------------------------------------------------------------------------! SUBROUTINE netcdf_define_variable(var, ncid) TYPE(nc_var), INTENT(INOUT) :: var INTEGER, INTENT(IN) :: ncid CALL check(nf90_def_var(ncid, var % name, NF90_FLOAT, var % dimids(1:var % ndim), var % varid)) CALL check(nf90_put_att(ncid, var % varid, "long_name", var % long_name)) CALL check(nf90_put_att(ncid, var % varid, "units", var % units)) IF ( var % lod .GE. 0 ) THEN CALL check(nf90_put_att(ncid, var % varid, "lod", var % lod)) END IF CALL check(nf90_put_att(ncid, var % varid, "source", var % source)) CALL check(nf90_put_att(ncid, var % varid, "_FillValue", NF90_FILL_REAL)) END SUBROUTINE netcdf_define_variable !------------------------------------------------------------------------------! ! Description: ! ------------ !> netcdf_get_dimensions() reads in all dimensions and their lengths and stores !> them in the given the 'var' data structure. This information is used later !> for writing output variables in update_output(). !------------------------------------------------------------------------------! SUBROUTINE netcdf_get_dimensions(var, ncid) TYPE(nc_var), INTENT(INOUT) :: var INTEGER, INTENT(IN) :: ncid INTEGER :: i CHARACTER(SNAME) :: null DO i = 1, var % ndim CALL check(nf90_inquire_dimension(ncid, var % dimids(i), & name = null, & len = var % dimlen(i) ) ) END DO END SUBROUTINE netcdf_get_dimensions !------------------------------------------------------------------------------! ! Description: ! ------------ !> This routine parses and interpretes the command-line options and stores the !> resulting settings in the 'cfg' data structure. !------------------------------------------------------------------------------! SUBROUTINE parse_command_line_arguments( cfg ) TYPE(inifor_config), INTENT(INOUT) :: cfg CHARACTER(LEN=PATH) :: option, arg INTEGER :: arg_count, i cfg % p0_is_set = .FALSE. cfg % ug_is_set = .FALSE. cfg % vg_is_set = .FALSE. cfg % flow_prefix_is_set = .FALSE. cfg % input_prefix_is_set = .FALSE. cfg % radiation_prefix_is_set = .FALSE. cfg % soil_prefix_is_set = .FALSE. cfg % soilmoisture_prefix_is_set = .FALSE. arg_count = COMMAND_ARGUMENT_COUNT() IF (arg_count .GT. 0) THEN message = "The -clon and -clat command line options are depricated. " // & "Please remove them form your inifor command and specify the " // & "location of the PALM-4U origin either" // NEW_LINE(' ') // & " - by setting the namelist parameters 'longitude' and 'latitude', or" // NEW_LINE(' ') // & " - by providing a static driver netCDF file via the -static command-line option." i = 1 DO WHILE (i .LE. arg_count) CALL GET_COMMAND_ARGUMENT( i, option ) SELECT CASE( TRIM(option) ) CASE( '--averaging-mode' ) CALL get_option_argument( i, arg ) cfg % averaging_mode = TRIM(arg) CASE( '-date', '-d', '--date' ) CALL get_option_argument( i, arg ) cfg % start_date = TRIM(arg) CASE( '--debug' ) cfg % debug = .TRUE. CASE( '-z0', '-z', '--elevation' ) CALL get_option_argument( i, arg ) READ(arg, *) cfg % z0 CASE( '-p0', '-r', '--surface-pressure' ) cfg % p0_is_set = .TRUE. CALL get_option_argument( i, arg ) READ(arg, *) cfg % p0 CASE( '-ug', '-u', '--geostrophic-u' ) cfg % ug_is_set = .TRUE. CALL get_option_argument( i, arg ) READ(arg, *) cfg % ug CASE( '-vg', '-v', '--geostrophic-v' ) cfg % vg_is_set = .TRUE. CALL get_option_argument( i, arg ) READ(arg, *) cfg % vg CASE( '-clon', '-clat' ) CALL inifor_abort('parse_command_line_arguments', message) CASE( '-path', '-p', '--path' ) CALL get_option_argument( i, arg ) cfg % input_path = TRIM(arg) CASE( '-hhl', '-l', '--hhl-file' ) CALL get_option_argument( i, arg ) cfg % hhl_file = TRIM(arg) CASE( '--input-prefix') CALL get_option_argument( i, arg ) cfg % input_prefix = TRIM(arg) cfg % input_prefix_is_set = .TRUE. CASE( '-a', '--averaging-angle' ) CALL get_option_argument( i, arg ) READ(arg, *) cfg % averaging_angle CASE( '-static', '-t', '--static-driver' ) CALL get_option_argument( i, arg ) cfg % static_driver_file = TRIM(arg) CASE( '-soil', '-s', '--soil-file') CALL get_option_argument( i, arg ) cfg % soiltyp_file = TRIM(arg) CASE( '--flow-prefix') CALL get_option_argument( i, arg ) cfg % flow_prefix = TRIM(arg) cfg % flow_prefix_is_set = .TRUE. CASE( '--radiation-prefix') CALL get_option_argument( i, arg ) cfg % radiation_prefix = TRIM(arg) cfg % radiation_prefix_is_set = .TRUE. CASE( '--soil-prefix') CALL get_option_argument( i, arg ) cfg % soil_prefix = TRIM(arg) cfg % soil_prefix_is_set = .TRUE. CASE( '--soilmoisture-prefix') CALL get_option_argument( i, arg ) cfg % soilmoisture_prefix = TRIM(arg) cfg % soilmoisture_prefix_is_set = .TRUE. CASE( '-o', '--output' ) CALL get_option_argument( i, arg ) cfg % output_file = TRIM(arg) CASE( '-n', '--namelist' ) CALL get_option_argument( i, arg ) cfg % namelist_file = TRIM(arg) CASE( '-mode', '-i', '--init-mode' ) CALL get_option_argument( i, arg ) cfg % ic_mode = TRIM(arg) CASE( '-f', '--forcing-mode' ) CALL get_option_argument( i, arg ) cfg % bc_mode = TRIM(arg) CASE( '--version' ) CALL print_version() STOP CASE( '--help' ) CALL print_version() PRINT *, "" PRINT *, "For a list of command-line options have a look at the README file." STOP CASE DEFAULT message = "unknown option '" // TRIM(option) // "'." CALL inifor_abort('parse_command_line_arguments', message) END SELECT i = i + 1 END DO ELSE message = "No arguments present, using default input and output files" CALL report('parse_command_line_arguments', message) END IF END SUBROUTINE parse_command_line_arguments SUBROUTINE get_datetime_file_list( start_date_string, start_hour, end_hour, & step_hour, input_path, prefix, suffix, & file_list ) CHARACTER (LEN=DATE), INTENT(IN) :: start_date_string CHARACTER (LEN=*), INTENT(IN) :: prefix, suffix, input_path INTEGER, INTENT(IN) :: start_hour, end_hour, step_hour CHARACTER(LEN=*), ALLOCATABLE, INTENT(INOUT) :: file_list(:) INTEGER :: number_of_intervals, hour, i CHARACTER(LEN=DATE) :: date_string number_of_intervals = CEILING( REAL(end_hour - start_hour) / step_hour ) ALLOCATE( file_list(number_of_intervals + 1) ) DO i = 0, number_of_intervals hour = start_hour + i * step_hour date_string = add_hours_to(start_date_string, hour) file_list(i+1) = TRIM(input_path) // TRIM(prefix) // & TRIM(date_string) // TRIM(suffix) // '.nc' END DO END SUBROUTINE get_datetime_file_list !------------------------------------------------------------------------------! ! Description: ! ------------ !> Establish a list of files based on the given start and end times and file !> prefixes and suffixes. !------------------------------------------------------------------------------! SUBROUTINE get_input_file_list( start_date_string, start_hour, end_hour, & step_hour, input_path, prefix, suffix, & file_list, nocheck ) CHARACTER (LEN=DATE), INTENT(IN) :: start_date_string CHARACTER (LEN=*), INTENT(IN) :: prefix, suffix, input_path INTEGER, INTENT(IN) :: start_hour, end_hour, step_hour CHARACTER(LEN=*), ALLOCATABLE, INTENT(INOUT) :: file_list(:) LOGICAL, OPTIONAL, INTENT(IN) :: nocheck INTEGER :: number_of_intervals, hour, i CHARACTER(LEN=DATE) :: date_string CHARACTER(LEN=PATH) :: file_name LOGICAL :: check_files CALL get_datetime_file_list( start_date_string, start_hour, end_hour, & step_hour, input_path, prefix, suffix, & file_list ) check_files = .TRUE. IF ( PRESENT ( nocheck ) ) THEN IF ( nocheck ) check_files = .FALSE. END IF IF ( check_files ) THEN tip = "Please check if you specified the correct file prefix " // & "using the options --input-prefix, --flow-prefix, etc." DO i = 1, SIZE(file_list) CALL verify_file(file_list(i), 'input', tip) END DO END IF END SUBROUTINE get_input_file_list !------------------------------------------------------------------------------! ! Description: ! ------------ !> Abort INIFOR if the given file is not present. !------------------------------------------------------------------------------! SUBROUTINE verify_file(file_name, file_kind, tip) CHARACTER(LEN=*), INTENT(IN) :: file_name, file_kind CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: tip IF (.NOT. file_present(file_name)) THEN IF (LEN(TRIM(file_name)) == 0) THEN message = "No name was given for the " // TRIM(file_kind) // " file." ELSE message = "The " // TRIM(file_kind) // " file '" // & TRIM(file_name) // "' was not found." IF (PRESENT(tip)) THEN message = TRIM(message) // " " // TRIM(tip) END IF END IF CALL inifor_abort('verify_file', message) END IF message = "Set up input file name '" // TRIM(file_name) // "'" CALL report('verify_file', message) END SUBROUTINE verify_file !------------------------------------------------------------------------------! ! Description: ! ------------ !> Get the argument of the i'th command line option, which is at the location !> i+1 of the argument list. !------------------------------------------------------------------------------! SUBROUTINE get_option_argument(i, arg) CHARACTER(LEN=PATH), INTENT(INOUT) :: arg INTEGER, INTENT(INOUT) :: i i = i + 1 CALL GET_COMMAND_ARGUMENT(i, arg) END SUBROUTINE !------------------------------------------------------------------------------! ! Description: ! ------------ !> Checks the INIFOR configuration 'cfg' for plausibility. !------------------------------------------------------------------------------! SUBROUTINE validate_config(cfg) TYPE(inifor_config), INTENT(IN) :: cfg CALL verify_file(cfg % hhl_file, 'HHL') CALL verify_file(cfg % namelist_file, 'NAMELIST') CALL verify_file(cfg % soiltyp_file, 'SOILTYP') ! !-- Only check optional static driver file name, if it has been given. IF (TRIM(cfg % static_driver_file) .NE. '') THEN CALL verify_file(cfg % static_driver_file, 'static driver') END IF SELECT CASE( TRIM(cfg % ic_mode) ) CASE( 'profile', 'volume') CASE DEFAULT message = "Initialization mode '" // TRIM(cfg % ic_mode) //& "' is not supported. " //& "Please select either 'profile' or 'volume', " //& "or omit the -i/--init-mode/-mode option entirely, which corresponds "//& "to the latter." CALL inifor_abort( 'validate_config', message ) END SELECT SELECT CASE( TRIM(cfg % bc_mode) ) CASE( 'real', 'ideal') CASE DEFAULT message = "Forcing mode '" // TRIM(cfg % bc_mode) //& "' is not supported. " //& "Please select either 'real' or 'ideal', " //& "or omit the -f/--forcing-mode option entirely, which corresponds "//& "to the latter." CALL inifor_abort( 'validate_config', message ) END SELECT SELECT CASE( TRIM(cfg % averaging_mode) ) CASE( 'level', 'height') CASE DEFAULT message = "Averaging mode '" // TRIM(cfg % averaging_mode) //& "' is not supported. " //& "Please select either 'height' or 'level', " //& "or omit the --averaging-mode option entirely, which corresponds "//& "to the latter." CALL inifor_abort( 'validate_config', message ) END SELECT IF ( cfg % ug_is_set .NEQV. cfg % vg_is_set ) THEN message = "You specified only one component of the geostrophic " // & "wind. Please specify either both or none." CALL inifor_abort( 'validate_config', message ) END IF END SUBROUTINE validate_config !------------------------------------------------------------------------------! ! Description: ! ------------ !> Check whether the given file is present on the filesystem. !------------------------------------------------------------------------------! LOGICAL FUNCTION file_present(filename) CHARACTER(LEN=PATH), INTENT(IN) :: filename INQUIRE(FILE=filename, EXIST=file_present) END FUNCTION file_present !------------------------------------------------------------------------------! ! Description: ! ------------ !> This routine initializes the dynamic driver file, i.e. INIFOR's netCDF output !> file. !> !> Besides writing metadata, such as global attributes, coordinates, variables, !> in the netCDF file, various netCDF IDs are saved for later, when INIFOR !> writes the actual data. !------------------------------------------------------------------------------! SUBROUTINE setup_netcdf_dimensions(output_file, palm_grid, & start_date_string, origin_lon, origin_lat) TYPE(nc_file), INTENT(INOUT) :: output_file TYPE(grid_definition), INTENT(IN) :: palm_grid CHARACTER (LEN=DATE), INTENT(IN) :: start_date_string REAL(dp), INTENT(IN) :: origin_lon, origin_lat CHARACTER (LEN=8) :: date_string CHARACTER (LEN=10) :: time_string CHARACTER (LEN=5) :: zone_string CHARACTER (LEN=SNAME) :: history_string INTEGER :: ncid, nx, ny, nz, nt, dimids(3), dimvarids(3) REAL(dp) :: z0 message = "Initializing PALM-4U dynamic driver file '" // & TRIM(output_file % name) // "' and setting up dimensions." CALL report('setup_netcdf_dimensions', message) ! !-- Create the netCDF file as in netCDF-4/HDF5 format if __netcdf4 preprocessor flag is given #if defined( __netcdf4 ) CALL check(nf90_create(TRIM(output_file % name), OR(NF90_CLOBBER, NF90_HDF5), ncid)) #else CALL check(nf90_create(TRIM(output_file % name), NF90_CLOBBER, ncid)) #endif !------------------------------------------------------------------------------ !- Section 1: Define NetCDF dimensions and coordinates !------------------------------------------------------------------------------ nt = SIZE(output_file % time) nx = palm_grid % nx ny = palm_grid % ny nz = palm_grid % nz z0 = palm_grid % z0 ! !------------------------------------------------------------------------------ !- Section 2: Write global NetCDF attributes !------------------------------------------------------------------------------ CALL date_and_time(DATE=date_string, TIME=time_string, ZONE=zone_string) history_string = & 'Created on '// date_string // & ' at ' // time_string(1:2) // ':' // time_string(3:4) // & ' (UTC' // zone_string // ')' CALL check(nf90_put_att(ncid, NF90_GLOBAL, 'title', 'PALM input file for scenario ...')) CALL check(nf90_put_att(ncid, NF90_GLOBAL, 'institution', 'Deutscher Wetterdienst, Offenbach')) CALL check(nf90_put_att(ncid, NF90_GLOBAL, 'author', 'Eckhard Kadasch, eckhard.kadasch@dwd.de')) CALL check(nf90_put_att(ncid, NF90_GLOBAL, 'history', TRIM(history_string))) CALL check(nf90_put_att(ncid, NF90_GLOBAL, 'references', '--')) CALL check(nf90_put_att(ncid, NF90_GLOBAL, 'comment', '--')) CALL check(nf90_put_att(ncid, NF90_GLOBAL, 'origin_lat', TRIM(real_to_str(origin_lat*TO_DEGREES, '(F18.13)')))) CALL check(nf90_put_att(ncid, NF90_GLOBAL, 'origin_lon', TRIM(real_to_str(origin_lon*TO_DEGREES, '(F18.13)')))) ! !-- FIXME: This is the elevation relative to COSMO-DE/D2 sea level and does !-- FIXME: not necessarily comply with DHHN2016 (c.f. PALM Input Data !-- FIXME: Standard v1.9., origin_z) CALL check(nf90_put_att(ncid, NF90_GLOBAL, 'origin_z', TRIM(real_to_str(z0, '(F18.13)')))) CALL check(nf90_put_att(ncid, NF90_GLOBAL, 'inifor_version', TRIM(VERSION))) CALL check(nf90_put_att(ncid, NF90_GLOBAL, 'palm_version', '--')) ! ! !------------------------------------------------------------------------------ !- Section 2a: Define dimensions for cell centers (scalars in soil and atmosph.) !------------------------------------------------------------------------------ ! !-- reset dimids first dimids = (/0, 0, 0/) CALL check( nf90_def_dim(ncid, "x", nx+1, dimids(1)) ) CALL check( nf90_def_dim(ncid, "y", ny+1, dimids(2)) ) CALL check( nf90_def_dim(ncid, "z", nz, dimids(3)) ) ! !-- save dimids for later output_file % dimids_scl = dimids ! !-- reset dimvarids first dimvarids = (/0, 0, 0/) CALL check(nf90_def_var(ncid, "x", NF90_FLOAT, dimids(1), dimvarids(1))) CALL check(nf90_put_att(ncid, dimvarids(1), "standard_name", "x coordinate of cell centers")) CALL check(nf90_put_att(ncid, dimvarids(1), "units", "m")) CALL check(nf90_def_var(ncid, "y", NF90_FLOAT, dimids(2), dimvarids(2))) CALL check(nf90_put_att(ncid, dimvarids(2), "standard_name", "y coordinate of cell centers")) CALL check(nf90_put_att(ncid, dimvarids(2), "units", "m")) CALL check(nf90_def_var(ncid, "z", NF90_FLOAT, dimids(3), dimvarids(3))) CALL check(nf90_put_att(ncid, dimvarids(3), "standard_name", "z coordinate of cell centers")) CALL check(nf90_put_att(ncid, dimvarids(3), "units", "m")) ! !-- save dimvarids for later output_file % dimvarids_scl = dimvarids ! !-- overwrite third dimid with the one of depth CALL check(nf90_def_dim(ncid, "zsoil", SIZE(palm_grid % depths), dimids(3)) ) ! !-- save dimids for later output_file % dimids_soil = dimids ! !-- overwrite third dimvarid with the one of depth CALL check(nf90_def_var(ncid, "zsoil", NF90_FLOAT, output_file % dimids_soil(3), dimvarids(3))) CALL check(nf90_put_att(ncid, dimvarids(3), "standard_name", "depth_below_land")) CALL check(nf90_put_att(ncid, dimvarids(3), "positive", "down")) CALL check(nf90_put_att(ncid, dimvarids(3), "units", "m")) ! !-- save dimvarids for later output_file % dimvarids_soil = dimvarids ! !------------------------------------------------------------------------------ !- Section 2b: Define dimensions for cell faces/velocities !------------------------------------------------------------------------------ ! !-- reset dimids first dimids = (/0, 0, 0/) CALL check(nf90_def_dim(ncid, "xu", nx, dimids(1)) ) CALL check(nf90_def_dim(ncid, "yv", ny, dimids(2)) ) CALL check(nf90_def_dim(ncid, "zw", nz-1, dimids(3)) ) ! !-- save dimids for later output_file % dimids_vel = dimids ! !-- reset dimvarids first dimvarids = (/0, 0, 0/) CALL check(nf90_def_var(ncid, "xu", NF90_FLOAT, dimids(1), dimvarids(1))) CALL check(nf90_put_att(ncid, dimvarids(1), "standard_name", "x coordinate of cell faces")) CALL check(nf90_put_att(ncid, dimvarids(1), "units", "m")) CALL check(nf90_def_var(ncid, "yv", NF90_FLOAT, dimids(2), dimvarids(2))) CALL check(nf90_put_att(ncid, dimvarids(2), "standard_name", "y coordinate of cell faces")) CALL check(nf90_put_att(ncid, dimvarids(2), "units", "m")) CALL check(nf90_def_var(ncid, "zw", NF90_FLOAT, dimids(3), dimvarids(3))) CALL check(nf90_put_att(ncid, dimvarids(3), "standard_name", "z coordinate of cell faces")) CALL check(nf90_put_att(ncid, dimvarids(3), "units", "m")) ! !-- save dimvarids for later output_file % dimvarids_vel = dimvarids ! !------------------------------------------------------------------------------ !- Section 2c: Define time dimension !------------------------------------------------------------------------------ CALL check(nf90_def_dim(ncid, "time", nt, output_file % dimid_time) ) CALL check(nf90_def_var(ncid, "time", NF90_FLOAT, & output_file % dimid_time, & output_file % dimvarid_time)) CALL check(nf90_put_att(ncid, output_file % dimvarid_time, "standard_name", "time")) CALL check(nf90_put_att(ncid, output_file % dimvarid_time, "long_name", "time")) CALL check(nf90_put_att(ncid, output_file % dimvarid_time, "units", & "seconds since " // start_date_string // " UTC")) CALL check(nf90_enddef(ncid)) ! !------------------------------------------------------------------------------ !- Section 3: Write grid coordinates !------------------------------------------------------------------------------ CALL check(nf90_put_var(ncid, output_file % dimvarids_scl(1), palm_grid%x)) CALL check(nf90_put_var(ncid, output_file % dimvarids_scl(2), palm_grid%y)) CALL check(nf90_put_var(ncid, output_file % dimvarids_scl(3), palm_grid%z)) CALL check(nf90_put_var(ncid, output_file % dimvarids_vel(1), palm_grid%xu)) CALL check(nf90_put_var(ncid, output_file % dimvarids_vel(2), palm_grid%yv)) CALL check(nf90_put_var(ncid, output_file % dimvarids_vel(3), palm_grid%zw)) ! !-- TODO Read in soil depths from input file before this. CALL check(nf90_put_var(ncid, output_file % dimvarids_soil(3), palm_grid%depths)) ! !-- Write time vector CALL check(nf90_put_var(ncid, output_file % dimvarid_time, output_file % time)) ! !-- Close the file CALL check(nf90_close(ncid)) END SUBROUTINE setup_netcdf_dimensions !------------------------------------------------------------------------------! ! Description: ! ------------ !> Defines the netCDF variables to be written to the dynamic driver file !------------------------------------------------------------------------------! SUBROUTINE setup_netcdf_variables(filename, output_variable_table, debug) CHARACTER (LEN=*), INTENT(IN) :: filename TYPE(nc_var), INTENT(INOUT), TARGET :: output_variable_table(:) LOGICAL, INTENT(IN) :: debug TYPE(nc_var), POINTER :: var INTEGER :: i, ncid LOGICAL :: to_be_written message = "Defining variables in dynamic driver '" // TRIM(filename) // "'." CALL report('setup_netcdf_variables', message) CALL check(nf90_open(TRIM(filename), NF90_WRITE, ncid)) CALL check(nf90_redef(ncid)) DO i = 1, SIZE(output_variable_table) var => output_variable_table(i) to_be_written = ( var % to_be_processed .AND. .NOT. var % is_internal) .OR. & ( var % is_internal .AND. debug ) IF ( to_be_written ) THEN message = " variable #" // TRIM(str(i)) // " '" // TRIM(var%name) // "'." CALL report('setup_netcdf_variables', message) CALL netcdf_define_variable(var, ncid) CALL netcdf_get_dimensions(var, ncid) END IF END DO CALL check(nf90_enddef(ncid)) CALL check(nf90_close(ncid)) message = "Dynamic driver '" // TRIM(filename) // "' initialized successfully." CALL report('setup_netcdf_variables', message) END SUBROUTINE setup_netcdf_variables !------------------------------------------------------------------------------! ! Description: ! ------------ !> This routine reads and returns all input variables of the given IO group !> It accomodates the data by allocating a container variable that represents a !> list of arrays of the same length as the groups variable list. (This list !> will typically contain one or two items.) After the container, its members !> are allocated one by one with the appropriate, possibly different, !> dimensions. !> !> The 'group' is an INTENT(INOUT) variable so that 'get_netcdf_variable()' can !> record netCDF IDs in the 'in_var_list()' member variable. !------------------------------------------------------------------------------! SUBROUTINE read_input_variables(group, iter, buffer) TYPE(io_group), INTENT(INOUT), TARGET :: group INTEGER, INTENT(IN) :: iter TYPE(container), ALLOCATABLE, INTENT(INOUT) :: buffer(:) INTEGER :: hour, buf_id TYPE(nc_var), POINTER :: input_var CHARACTER(LEN=PATH), POINTER :: input_file INTEGER :: ivar, nbuffers message = "Reading data for I/O group '" // TRIM(group % in_var_list(1) % name) // "'." CALL report('read_input_variables', message) input_file => group % in_files(iter) ! !------------------------------------------------------------------------------ !- Section 1: Load input buffers for accumulated variables !------------------------------------------------------------------------------ ! !-- radiation budgets, precipitation IF (group % kind == 'running average' .OR. & group % kind == 'accumulated') THEN IF (SIZE(group % in_var_list) .GT. 1 ) THEN message = "I/O groups may not contain more than one " // & "accumulated variable. Group '" // TRIM(group % kind) //& "' contains " // & TRIM( str(SIZE(group % in_var_list)) ) // "." CALL inifor_abort('read_input_variables | accumulation', message) END IF ! !-- use two buffer arrays nbuffers = 2 IF ( .NOT. ALLOCATED( buffer ) ) ALLOCATE( buffer(nbuffers) ) ! !-- hour of the day hour = iter - 1 ! !-- chose correct buffer array buf_id = select_buffer(hour) CALL run_control('time', 'read') IF ( ALLOCATED(buffer(buf_id) % array) ) DEALLOCATE(buffer(buf_id) % array) CALL run_control('time', 'alloc') input_var => group % in_var_list(1) CALL get_netcdf_variable(input_file, input_var, buffer(buf_id) % array) CALL report('read_input_variables', "Read accumulated " // TRIM(group % in_var_list(1) % name)) IF ( input_var % is_upside_down ) CALL reverse(buffer(buf_id) % array) CALL run_control('time', 'comp') !------------------------------------------------------------------------------ !- Section 2: Load input buffers for normal I/O groups !------------------------------------------------------------------------------ ELSE ! !-- Allocate one input buffer per input_variable. If more quantities !-- have to be computed than input variables exist in this group, !-- allocate more buffers. For instance, in the thermodynamics group, !-- there are three input variabels (PP, T, Qv) and four quantities !-- necessart (P, Theta, Rho, qv) for the corresponding output fields !-- (p0, Theta, qv, ug, and vg) nbuffers = MAX( group % n_inputs, group % n_output_quantities ) ALLOCATE( buffer(nbuffers) ) CALL run_control('time', 'alloc') ! !-- Read in all input variables, leave extra buffers-if any-untouched. DO ivar = 1, group % n_inputs input_var => group % in_var_list(ivar) ! ! Check wheather P or PP is present in input file IF (input_var % name == 'P') THEN input_var % name = TRIM( get_pressure_varname(input_file) ) CALL run_control('time', 'read') END IF CALL get_netcdf_variable(input_file, input_var, buffer(ivar) % array) IF ( input_var % is_upside_down ) CALL reverse(buffer(ivar) % array) CALL run_control('time', 'comp') END DO END IF END SUBROUTINE read_input_variables !------------------------------------------------------------------------------! ! Description: ! ------------ !> Select the appropriate buffer ID for accumulated COSMO input variables !> depending on the current hour. !------------------------------------------------------------------------------! INTEGER FUNCTION select_buffer(hour) INTEGER, INTENT(IN) :: hour INTEGER :: step select_buffer = 0 step = MODULO(hour, 3) + 1 SELECT CASE(step) CASE(1, 3) select_buffer = 1 CASE(2) select_buffer = 2 CASE DEFAULT message = "Invalid step '" // TRIM(str(step)) CALL inifor_abort('select_buffer', message) END SELECT END FUNCTION select_buffer !------------------------------------------------------------------------------! ! Description: ! ------------ !> Checks if the input_file contains the absolute pressure, 'P', or the pressure !> perturbation, 'PP', and returns the appropriate string. !------------------------------------------------------------------------------! CHARACTER(LEN=2) FUNCTION get_pressure_varname(input_file) RESULT(var) CHARACTER(LEN=*) :: input_file INTEGER :: ncid, varid CALL check(nf90_open( TRIM(input_file), NF90_NOWRITE, ncid )) IF ( nf90_inq_varid( ncid, 'P', varid ) .EQ. NF90_NOERR ) THEN var = 'P' ELSE IF ( nf90_inq_varid( ncid, 'PP', varid ) .EQ. NF90_NOERR ) THEN var = 'PP' CALL report('get_pressure_var', 'Using PP instead of P') ELSE message = "Failed to read '" // TRIM(var) // & "' from file '" // TRIM(input_file) // "'." CALL inifor_abort('get_pressure_var', message) END IF CALL check(nf90_close(ncid)) END FUNCTION get_pressure_varname !------------------------------------------------------------------------------! ! Description: ! ------------ !> Read the given global attribute form the given netCDF file. !------------------------------------------------------------------------------! FUNCTION get_netcdf_attribute(filename, attribute) RESULT(attribute_value) CHARACTER(LEN=*), INTENT(IN) :: filename, attribute REAL(dp) :: attribute_value INTEGER :: ncid IF ( nf90_open( TRIM(filename), NF90_NOWRITE, ncid ) == NF90_NOERR ) THEN CALL check(nf90_get_att(ncid, NF90_GLOBAL, TRIM(attribute), attribute_value)) CALL check(nf90_close(ncid)) ELSE message = "Failed to read '" // TRIM(attribute) // & "' from file '" // TRIM(filename) // "'." CALL inifor_abort('get_netcdf_attribute', message) END IF END FUNCTION get_netcdf_attribute !------------------------------------------------------------------------------! ! Description: ! ------------ !> Updates the dynamic driver with the interpolated field of the current !> variable at the current time step. !------------------------------------------------------------------------------! SUBROUTINE update_output(var, array, iter, output_file, cfg) TYPE(nc_var), INTENT(IN) :: var REAL(dp), INTENT(IN) :: array(:,:,:) INTEGER, INTENT(IN) :: iter TYPE(nc_file), INTENT(IN) :: output_file TYPE(inifor_config) :: cfg INTEGER :: ncid, ndim, start(4), count(4) LOGICAL :: var_is_time_dependent var_is_time_dependent = ( & var % dimids( var % ndim ) == output_file % dimid_time & ) ! !-- Skip time dimension for output ndim = var % ndim IF ( var_is_time_dependent ) ndim = var % ndim - 1 start(:) = (/1,1,1,1/) start(ndim+1) = iter count(1:ndim) = var%dimlen(1:ndim) CALL check(nf90_open(output_file % name, NF90_WRITE, ncid)) ! !-- Reduce dimension of output array according to variable kind SELECT CASE (TRIM(var % kind)) CASE ( 'init scalar profile', 'init u profile', 'init v profile', & 'init w profile' ) CALL check(nf90_put_var( ncid, var%varid, array(1,1,:) ) ) CASE ( 'init soil', 'init scalar', 'init u', 'init v', 'init w' ) CALL check(nf90_put_var( ncid, var%varid, array(:,:,:) ) ) CASE( 'left scalar', 'right scalar', 'left w', 'right w' ) CALL check(nf90_put_var( ncid, var%varid, array(1,:,:), & start=start(1:ndim+1), & count=count(1:ndim) ) ) IF (.NOT. SIZE(array, 2) .EQ. var % dimlen(1)) THEN PRINT *, "inifor: update_output: Dimension ", 1, " of variable ", & TRIM(var % name), " (", var % dimlen(1), & ") does not match the dimension of the output array (", & SIZE(array, 2), ")." STOP END IF CASE( 'north scalar', 'south scalar', 'north w', 'south w' ) CALL check(nf90_put_var( ncid, var%varid, array(:,1,:), & start=start(1:ndim+1), & count=count(1:ndim) ) ) CASE( 'surface forcing', 'top scalar', 'top w' ) CALL check(nf90_put_var( ncid, var%varid, array(:,:,1), & start=start(1:ndim+1), & count=count(1:ndim) ) ) CASE ( 'left u', 'right u', 'left v', 'right v' ) CALL check(nf90_put_var( ncid, var%varid, array(1,:,:), & start=start(1:ndim+1), & count=count(1:ndim) ) ) CASE ( 'north u', 'south u', 'north v', 'south v' ) CALL check(nf90_put_var( ncid, var%varid, array(:,1,:), & start=start(1:ndim+1), & count=count(1:ndim) ) ) CASE ( 'top u', 'top v' ) CALL check(nf90_put_var( ncid, var%varid, array(:,:,1), & start=start(1:ndim+1), & count=count(1:ndim) ) ) CASE ( 'time series' ) CALL check(nf90_put_var( ncid, var%varid, array(1,1,1), & start=start(1:ndim+1) ) ) CASE ( 'constant scalar profile', 'geostrophic' ) CALL check(nf90_put_var( ncid, var%varid, array(1,1,:), & start=start(1:ndim+1), & count=count(1:ndim) ) ) CASE ( 'internal profile' ) IF ( cfg % debug ) THEN CALL check(nf90_put_var( ncid, var%varid, array(1,1,:), & start=start(1:ndim+1), & count=count(1:ndim) ) ) END IF CASE ( 'large-scale scalar forcing', 'large-scale w forcing' ) message = "Doing nothing in terms of writing large-scale forings." CALL report('update_output', message) CASE DEFAULT message = "Variable kind '" // TRIM(var % kind) // & "' not recognized." CALL inifor_abort('update_output', message) END SELECT CALL check(nf90_close(ncid)) END SUBROUTINE update_output !------------------------------------------------------------------------------! ! Description: ! ------------ !> Checks the status of a netCDF API call and aborts if an error occured !------------------------------------------------------------------------------! SUBROUTINE check(status) INTEGER, INTENT(IN) :: status IF (status /= nf90_noerr) THEN message = "NetCDF API call failed with error: " // & TRIM( nf90_strerror(status) ) CALL inifor_abort('io.check', message) END IF END SUBROUTINE check END MODULE inifor_io #endif