time_state.f90

Go to the documentation of this file.

! Copyright (c) 2025, 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.
 
module time_state
  use num_types, only : rp, dp
  use logger, only : neko_log, log_size, neko_log_quiet
  use json_module, only : json_file
  use json_utils, only : json_get_or_lookup, json_get_or_default, &
       json_get_or_lookup_or_default
  implicit none
  private
 
  type, public :: time_state_t
     real(kind=dp), dimension(10) :: tlag = 0.0_dp 
     real(kind=dp), dimension(10) :: dtlag = 0.0_dp 
     real(kind=dp) :: t = 0.0_dp 
     real(kind=dp) :: dt = 0.0_dp 
     real(kind=dp) :: start_time = 0.0_dp 
     real(kind=dp) :: end_time = 0.0_dp 
     integer :: tstep = 0
 
   contains
     generic :: init => init_from_components, init_from_json
     procedure, pass(this) :: init_from_components => &
          time_state_init_from_components
     procedure, pass(this) :: init_from_json => time_state_init_from_json
     procedure, pass(this) :: reset => time_state_reset
     procedure, pass(this) :: status => time_state_status
     procedure, pass(this) :: is_done => time_state_is_done
     procedure, pass(this) :: tolerance => time_state_tolerance
  end type time_state_t
 
contains
 
  subroutine time_state_init_from_json(this, params)
    class(time_state_t), intent(inout) :: this
    type(json_file), intent(inout) :: params
 
    real(kind=dp) :: time_step
    real(kind=dp) :: start_time
    real(kind=dp) :: end_time
    logical :: is_variable
 
    call json_get_or_lookup_or_default(params, 'start_time', start_time, 0.0_dp)
    call json_get_or_lookup(params, 'end_time', end_time)
    call json_get_or_default(params, 'variable_timestep', is_variable, .false.)
    if (.not. is_variable) then
       call json_get_or_lookup(params, 'timestep', time_step)
    else
       ! randomly set an initial dt to get cfl when dt is variable
       time_step = 1.0_dp
    end if
 
    call this%init_from_components(start_time, end_time, time_step)
 
  end subroutine time_state_init_from_json
 
  subroutine time_state_init_from_components(this, start_time, end_time, dt)
    class(time_state_t), intent(inout) :: this
    real(kind=dp), intent(in) :: start_time
    real(kind=dp), intent(in) :: end_time
    real(kind=dp), intent(in) :: dt
 
    if (dt .gt. 0.0_dp .and. start_time .gt. end_time .or. &
         dt .lt. 0.0_dp .and. start_time .lt. end_time) then
       call neko_log%error('Time step size must match direction of time.')
    end if
 
    this%start_time = start_time
    this%end_time = end_time
    this%dt = dt
 
    this%t = start_time
    this%tstep = 0
    this%tlag = start_time
    this%dtlag = dt
 
  end subroutine time_state_init_from_components
 
  subroutine time_state_reset(this)
    class(time_state_t), intent(inout) :: this
 
    this%t = this%start_time
    this%tstep = 0
    this%tlag = this%start_time
    this%dtlag = this%dt
 
  end subroutine time_state_reset
 
  subroutine time_state_status(this)
    class(time_state_t), intent(in) :: this
    character(len=LOG_SIZE) :: log_buf
    character(len=64) :: log_fmt
    real(kind=dp) :: t_prog
    integer :: time_digits, time_width, pad_width
 
    t_prog = 100.0_dp * (this%t - this%start_time) / &
         (this%end_time - this%start_time)
 
    time_digits = precision(this%t)
    time_width = time_digits + 8
    pad_width = max(1, log_size - (34 + time_width) - 1)
 
    write(log_fmt, '(A,I0,A,I0,A,I0,A,I0,A)') &
         '(A7,1X,I10,1X,A4,ES', time_width, '.', time_digits, ',', &
         pad_width, 'X,A2,F6.2,A3)'
    write(log_buf, log_fmt) 'Step = ', this%tstep, 't = ', this%t, &
         '[ ', t_prog, '% ]'
 
    call neko_log%message(repeat('-', log_size - 1))
    call neko_log%message(log_buf, neko_log_quiet)
    call neko_log%message(repeat('-', log_size - 1))
 
  end subroutine time_state_status
 
  pure function time_state_is_done(this) result(is_done)
    class(time_state_t), intent(in) :: this
    logical :: is_done
    real(kind=dp) :: span, tol
 
    span = abs(this%end_time - this%start_time)
    tol = this%tolerance()
 
    is_done = sign(1.0_dp, this%end_time - this%start_time) * &
         (this%t - this%start_time) .ge. span - tol &
         .and. this%tstep .gt. 0
 
  end function time_state_is_done
 
  pure function time_state_tolerance(this) result(tol)
    class(time_state_t), intent(in) :: this
    real(kind=dp) :: tol
 
    tol = 1.0e-9_dp * abs(this%end_time - this%start_time)
    tol = min(tol, 1.0e-2_dp * abs(this%dt))
 
  end function time_state_tolerance
 
end module time_state