json_utils.f90

Go to the documentation of this file.

! Copyright (c) 2019-2024, The Neko Authors
! All rights reserved.
!
! Redistribution and use in source and binary forms, with or without
! modification, are permitted provided that the following conditions
! are met:
!
!   * Redistributions of source code must retain the above copyright
!     notice, this list of conditions and the following disclaimer.
!
!   * Redistributions in binary form must reproduce the above
!     copyright notice, this list of conditions and the following
!     disclaimer in the documentation and/or other materials provided
!     with the distribution.
!
!   * Neither the name of the authors nor the names of its
!     contributors may be used to endorse or promote products derived
!     from this software without specific prior written permission.
!
! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
! "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
! LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
! FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
! COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
! INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
! BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
! LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
! CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! POSSIBILITY OF SUCH DAMAGE.
!
!
! These are json-fortran type codes:
! json_unknown = 0
! json_null = 1
! json_object = 2
! json_array = 3
! json_logical = 4
! json_integer = 5
! json_real = 6
! json_string = 7
module json_utils
  use num_types, only : dp, sp
  use json_module, only : json_file, json_value, json_core
  use utils, only : neko_error
  implicit none
  private
 
  public :: json_get, json_get_or_default, json_extract_item, &
       json_no_defaults, json_get_or_lookup, json_get_or_lookup_or_default, &
       json_get_subdict_or_empty
 
  logical :: json_no_defaults = .false.
 
  interface json_get
     module procedure json_get_real, json_get_double, json_get_integer, &
          json_get_logical, json_get_string, json_get_real_array, &
          json_get_double_array, json_get_integer_array, &
          json_get_logical_array, json_get_string_array, json_get_subdict
  end interface json_get
 
  interface json_get_or_default
     module procedure json_get_or_default_real, json_get_or_default_double, &
          json_get_or_default_integer, json_get_or_default_string, &
          json_get_or_default_logical
  end interface json_get_or_default
 
  interface json_get_or_lookup
     module procedure json_get_or_lookup_real, json_get_or_lookup_double, &
          json_get_or_lookup_real_array, json_get_or_lookup_double_array, &
          json_get_or_lookup_integer, json_get_or_lookup_integer_array
  end interface json_get_or_lookup
 
  interface json_get_or_lookup_or_default
     module procedure json_get_or_lookup_or_default_real, &
          json_get_or_lookup_or_default_double, &
          json_get_or_lookup_or_default_integer
  end interface json_get_or_lookup_or_default
 
  interface json_extract_item
     module procedure json_extract_item_from_array, json_extract_item_from_name
  end interface json_extract_item
 
  interface
     module subroutine json_get_or_lookup_real(json, name, val)
       type(json_file), intent(inout) :: json
       character(len=*), intent(in) :: name
       real(kind=sp), intent(out) :: val
     end subroutine json_get_or_lookup_real
 
     module subroutine json_get_or_lookup_double(json, name, val)
       type(json_file), intent(inout) :: json
       character(len=*), intent(in) :: name
       real(kind=dp), intent(out) :: val
     end subroutine json_get_or_lookup_double
 
     module subroutine json_get_or_lookup_integer(json, name, val)
       type(json_file), intent(inout) :: json
       character(len=*), intent(in) :: name
       integer, intent(out) :: val
     end subroutine json_get_or_lookup_integer
 
     module subroutine json_get_or_lookup_or_default_real(json, &
          name, val, default)
       type(json_file), intent(inout) :: json
       character(len=*), intent(in) :: name
       real(kind=sp), intent(out) :: val
       real(kind=sp), intent(in) :: default
     end subroutine json_get_or_lookup_or_default_real
 
     module subroutine json_get_or_lookup_or_default_double(json, &
          name, val, default)
       type(json_file), intent(inout) :: json
       character(len=*), intent(in) :: name
       real(kind=dp), intent(out) :: val
       real(kind=dp), intent(in) :: default
     end subroutine json_get_or_lookup_or_default_double
 
     module subroutine json_get_or_lookup_or_default_integer(json,&
          name, val, default)
       type(json_file), intent(inout) :: json
       character(len=*), intent(in) :: name
       integer, intent(out) :: val
       integer, intent(in) :: default
     end subroutine json_get_or_lookup_or_default_integer
 
     module subroutine json_get_or_lookup_real_array(json, name, val)
       type(json_file), intent(inout) :: json
       character(len=*), intent(in) :: name
       real(kind=sp), allocatable, intent(inout) :: val(:)
     end subroutine json_get_or_lookup_real_array
 
     module subroutine json_get_or_lookup_double_array(json, name, val)
       type(json_file), intent(inout) :: json
       character(len=*), intent(in) :: name
       real(kind=dp), allocatable, intent(inout) :: val(:)
     end subroutine json_get_or_lookup_double_array
 
     module subroutine json_get_or_lookup_integer_array(json, name, val)
       type(json_file), intent(inout) :: json
       character(len=*), intent(in) :: name
       integer, allocatable, intent(inout) :: val(:)
     end subroutine json_get_or_lookup_integer_array
 
  end interface
contains
 
  subroutine json_get_real(json, name, value)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    real(kind=sp), intent(out) :: value
    logical :: found
    integer :: var_type
 
    call json%info(name, found = found, var_type = var_type)
    if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    else if (var_type .ne. 6) then
       call neko_error("Parameter " // name // " is not a real")
    end if
 
    call json%get(name, value)
  end subroutine json_get_real
 
  subroutine json_get_double(json, name, value)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    real(kind=dp), intent(out) :: value
    logical :: found
    integer :: var_type
 
    call json%info(name, found = found, var_type = var_type)
    if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    else if (var_type .ne. 6) then
       call neko_error("Parameter " // name // " is not a real")
    end if
 
    call json%get(name, value)
  end subroutine json_get_double
 
  subroutine json_get_integer(json, name, value)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    integer, intent(out) :: value
    logical :: found
    integer :: var_type
 
    call json%info(name, found = found, var_type = var_type)
    if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    else if (var_type .ne. 5) then
       call neko_error("Parameter " // name // " is not an integer")
    end if
 
    call json%get(name, value)
  end subroutine json_get_integer
 
  subroutine json_get_logical(json, name, value)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    logical, intent(out) :: value
    logical :: found
    integer :: var_type
 
    call json%info(name, found = found, var_type = var_type)
    if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    else if (var_type .ne. 4) then
       call neko_error("Parameter " // name // " is not a logical")
    end if
 
    call json%get(name, value)
  end subroutine json_get_logical
 
  subroutine json_get_string(json, name, value)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    character(len=:), allocatable, intent(out) :: value
    logical :: found
    integer :: var_type
 
    call json%info(name, found = found, var_type = var_type)
    if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    else if (var_type .ne. 7) then
       call neko_error("Parameter " // name // " is not a string")
    end if
 
    call json%get(name, value)
  end subroutine json_get_string
 
  subroutine json_get_real_array(json, name, value, expected_size)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    real(kind=sp), allocatable, intent(out) :: value(:)
    integer, optional, intent(in) :: expected_size
    logical :: found
    integer :: var_type
    integer :: actual_size
 
    call json%info(name, found = found, var_type = var_type, &
         n_children = actual_size)
 
    if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    else if (var_type .ne. 3) then
       call neko_error("Parameter " // name // " is not an array")
    end if
 
    if (present(expected_size)) then
       call check_expected_size(name, actual_size, expected_size)
    end if
 
    call json%get(name, value)
  end subroutine json_get_real_array
 
  subroutine json_get_double_array(json, name, value, expected_size)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    real(kind=dp), allocatable, intent(out) :: value(:)
    integer, optional, intent(in) :: expected_size
    logical :: found
    integer :: var_type
    integer :: actual_size
 
    call json%info(name, found = found, var_type = var_type, &
         n_children = actual_size)
 
    if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    else if (var_type .ne. 3) then
       call neko_error("Parameter " // name // " is not an array")
    end if
 
    if (present(expected_size)) then
       call check_expected_size(name, actual_size, expected_size)
    end if
 
    call json%get(name, value)
  end subroutine json_get_double_array
 
  subroutine json_get_integer_array(json, name, value, expected_size)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    integer, allocatable, intent(out) :: value(:)
    integer, optional, intent(in) :: expected_size
    logical :: found
    integer :: var_type
    integer :: actual_size
 
    call json%info(name, found = found, var_type = var_type, &
         n_children = actual_size)
 
    if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    end if
 
    if (present(expected_size)) then
       call check_expected_size(name, actual_size, expected_size)
    end if
 
    call json%get(name, value)
  end subroutine json_get_integer_array
 
  subroutine json_get_logical_array(json, name, value, expected_size)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    logical, allocatable, intent(out) :: value(:)
    integer, optional, intent(in) :: expected_size
    logical :: found
    integer :: var_type
    integer :: actual_size
 
    call json%info(name, found = found, var_type = var_type, &
         n_children = actual_size)
 
    if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    else if (var_type .ne. 3) then
       call neko_error("Parameter " // name // " is not a array")
    end if
 
    if (present(expected_size)) then
       call check_expected_size(name, actual_size, expected_size)
    end if
 
    call json%get(name, value)
  end subroutine json_get_logical_array
 
  subroutine json_get_string_array(json, name, value, filler)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    character(len=*), allocatable, intent(out) :: value(:)
    character(len=*), optional, intent(in) :: filler
    logical :: found
    type(json_value), pointer :: json_val, val_ptr
    type(json_core) :: core
    character(len=:), allocatable :: string_value
    character(len=16) :: len_buf
    integer :: i, n_children
    integer :: var_type
 
    call json%info(name, found = found, var_type = var_type, &
         n_children = n_children)
    if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    else if (var_type .ne. 3) then
       call neko_error("Parameter " // name // " is not an array")
    end if
 
    if (.not. allocated(value)) then
       allocate(value(n_children))
    else if (size(value) .lt. n_children) then
       deallocate(value)
       allocate(value(n_children))
    end if
 
    call json%get(name, json_val, found)
    call json%get_core(core)
 
    do i = 1, n_children
       call core%get_child(json_val, i, val_ptr, found)
       call core%get(val_ptr, string_value)
 
       ! Assigning into the fixed length elements of `value` would silently
       ! truncate anything longer, so reject it rather than hand the caller
       ! a string that is not what the case file says.
       if (len(string_value) .gt. len(value)) then
          write (len_buf, '(I0)') len(value)
          call neko_error("An entry of the array parameter " // name // &
               " is longer than the " // trim(len_buf) // &
               " characters available for it")
       end if
 
       if (len(string_value) .gt. 0) then
          value(i) = string_value
       else if (present(filler)) then
          value(i) = filler
       end if
    end do
 
  end subroutine json_get_string_array
 
  subroutine json_get_subdict(json, key, output)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: key
    type(json_file), intent(inout) :: output
 
    type(json_value), pointer :: ptr
    type(json_core) :: core
    logical :: found
    character(len=:), allocatable :: buffer
 
    call json%get_core(core)
    call json%get(key, ptr, found)
 
    if (.not. found) then
       call neko_error("Parameter " // &
            trim(key) // " missing from the case file")
    end if
 
    call core%print_to_string(ptr, buffer)
    call output%destroy()
    call output%initialize(strict_type_checking = .true.)
    call output%load_from_string(buffer)
 
  end subroutine json_get_subdict
 
  subroutine json_get_subdict_or_empty(json, key, output)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: key
    type(json_file), intent(inout) :: output
 
    type(json_value), pointer :: ptr
    type(json_core) :: core
    logical :: found
    character(len=:), allocatable :: buffer
 
    ! Initialize empty object to return
    call output%destroy()
    call output%initialize(strict_type_checking = .true.)
 
    call json%get_core(core)
    call json%get(key, ptr, found)
 
    ! Load the contents if found, otherwise the object stays empty.
    if (found) then
       call core%print_to_string(ptr, buffer)
       call output%load_from_string(buffer)
    end if
 
  end subroutine json_get_subdict_or_empty
 
  subroutine json_get_or_default_real(json, name, value, default)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    real(kind=sp), intent(out) :: value
    real(kind=sp), intent(in) :: default
    logical :: found
    integer :: var_type
 
    call json%info(name, found = found, var_type = var_type)
 
    if (found .and. (var_type .ne. 6)) then
       call neko_error("Parameter " // name // " present, but is not a real")
    end if
 
    call json%get(name, value, found)
 
    if ((.not. found) .and. (.not. json_no_defaults)) then
       value = default
       call json%add(name, value)
    else if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    end if
  end subroutine json_get_or_default_real
 
  subroutine json_get_or_default_double(json, name, value, default)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    real(kind=dp), intent(out) :: value
    real(kind=dp), intent(in) :: default
    logical :: found
    integer :: var_type
 
    call json%info(name, found = found, var_type = var_type)
 
    if (found .and. (var_type .ne. 6)) then
       call neko_error("Parameter " // name // " present, but is not a real")
    end if
 
    call json%get(name, value, found)
 
    if ((.not. found) .and. (.not. json_no_defaults)) then
       value = default
       call json%add(name, value)
    else if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    end if
  end subroutine json_get_or_default_double
 
  subroutine json_get_or_default_integer(json, name, value, default)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    integer, intent(out) :: value
    integer, intent(in) :: default
    logical :: found
    integer :: var_type
 
    call json%info(name, found = found, var_type = var_type)
 
    if (found .and. (var_type .ne. 5)) then
       call neko_error("Parameter " // name // " present, but " // &
            "is not an integer")
    end if
 
    call json%get(name, value, found)
 
    if ((.not. found) .and. (.not. json_no_defaults)) then
       value = default
       call json%add(name, value)
    else if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    end if
  end subroutine json_get_or_default_integer
 
  subroutine json_get_or_default_logical(json, name, value, default)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    logical, intent(out) :: value
    logical, intent(in) :: default
    logical :: found
    integer :: var_type
 
    call json%info(name, found = found, var_type = var_type)
 
    if ((found) .and. (var_type .ne. 4)) then
       call neko_error("Parameter " // name // " present, but is not a logical")
    end if
 
    call json%get(name, value, found)
 
    if ((.not. found) .and. (.not. json_no_defaults)) then
       value = default
       call json%add(name, value)
    else if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    end if
  end subroutine json_get_or_default_logical
 
  subroutine json_get_or_default_string(json, name, value, default)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    character(len=:), allocatable, intent(out) :: value
    character(len=*), intent(in) :: default
    logical :: found
    integer :: var_type
 
    call json%info(name, found = found, var_type = var_type)
 
    if (found .and. (var_type .ne. 7)) then
       call neko_error("Parameter " // name // &
            " present, but is not a string")
    end if
 
    call json%get(name, value, found)
 
    if ((.not. found) .and. (.not. json_no_defaults)) then
       value = default
       call json%add(name, value)
    else if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    end if
  end subroutine json_get_or_default_string
 
  subroutine json_extract_item_from_array(core, array, i, item)
    type(json_core), intent(inout) :: core
    type(json_value), pointer, intent(in) :: array
    integer, intent(in) :: i
    type(json_file), intent(inout) :: item
    type(json_value), pointer :: ptr
    logical :: found
    character(len=:), allocatable :: buffer
 
    call core%get_child(array, i, ptr, found)
    call core%print_to_string(ptr, buffer)
    call item%destroy()
    call item%initialize(strict_type_checking = .true.)
    call item%load_from_string(buffer)
 
  end subroutine json_extract_item_from_array
 
  subroutine json_extract_item_from_name(json, name, i, item)
    type(json_file), intent(inout) :: json
    character(len=*), intent(in) :: name
    integer, intent(in) :: i
    type(json_file), intent(out) :: item
 
    type(json_core) :: core
    type(json_value), pointer :: array
    type(json_value), pointer :: ptr
    logical :: found
    character(len=:), allocatable :: buffer
 
    call json%get_core(core)
    call json%get(name, array, found)
 
    if (.not. found) then
       call neko_error("Parameter " // name // " missing from the case file")
    end if
 
    call core%get_child(array, i, ptr, found)
    call core%print_to_string(ptr, buffer)
    call item%destroy()
    call item%initialize(strict_type_checking = .true.)
    call item%load_from_string(buffer)
 
  end subroutine json_extract_item_from_name
 
  subroutine check_expected_size(name, actual_size, expected_size)
    character(len=*), intent(in) :: name
    integer, intent(in) :: actual_size, expected_size
    character(len=32) :: str_actual, str_expected
 
    if (actual_size /= expected_size) then
       write(str_actual, '(I0)') actual_size
       write(str_expected, '(I0)') expected_size
       call neko_error("Parameter '" // trim(name) // &
            "' has incorrect size: got " // &
            trim(str_actual) // ", but expected " // trim(str_expected))
    end if
  end subroutine check_expected_size
 
end module json_utils