scale_time_manager.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
#include "scaleFElib.h"
module scale_time_manager
  !-----------------------------------------------------------------------------
  !
  !++ used modules
  !
  use scale_const, only: &
    undef8 => const_undef8  
  use scale_precision
  use scale_prc
  use scale_io
  
  use scale_time, only: &
    time_startdaysec,           &
    time_nowdate,               &
    time_nowday,                &
    time_nowdaysec,             &               
    time_nowsec,                &
    time_nowsubsec,             &
    time_nowstep,               &   
    time_nstep,                 &
    time_dtsec,                 &
    time_offset_year,           &
    time_dtsec_wallclock_check, &
    time_dstep_wallclock_check
 
  
  use scale_calendar, only: &
    calendar_date2daysec,    &
    calendar_daysec2date,    &
    calendar_combine_daysec, &
    calendar_adjust_daysec,  &
    calendar_unit2sec,       &
    calendar_cfunits2sec,    &
    calendar_date2char
 
  !-----------------------------------------------------------------------------
  implicit none
  private
 
  !-----------------------------------------------------------------------------
  !
  !++ Public type & procedure
  !  
  public :: time_manager_init
  public :: time_manager_final
  public :: time_manager_regist_component
  public :: time_manager_checkstate
  public :: time_manager_advance
  public :: time_manager_report_timeintervals
 
  
  type :: time_manager_process
    real(DP) :: dtsec
    integer :: dstep
    integer :: res_step
    logical :: do_step
    integer :: inner_itr_num
    character(len=H_SHORT) :: process_name
  contains
    procedure, public :: Init => time_manager_process_init
    procedure, public :: Check_state => time_manager_process_checkstate
    procedure, public :: Final => time_manager_process_final
  end type time_manager_process
 
  integer, private, parameter :: TIME_MANAGER_PROCESS_MAX_NUM = 10
  type, public :: time_manager_component
    real(dp) :: dtsec
    integer :: dstep
    integer :: res_step
    logical :: do_step
    !-
    real(dp) :: dtsec_restart
    integer :: dstep_restart
    integer :: res_step_restart
    logical :: do_restart
    character(len=H_SHORT) :: comp_name
    !--
    type(time_manager_process) :: process_list(time_manager_process_max_num)
    integer :: process_num
  contains
    procedure, public :: init => time_manager_component_init
    procedure, public :: regist_process => time_manager_component_regist_process
    procedure, public :: check_state => time_manager_component_checkstate
    procedure, public :: do_process => time_manager_component_do_process
    procedure, public :: get_process_inner_itr_num => time_manager_component_get_process_inner_itr_num
    procedure, public :: final => time_manager_component_final
  end type time_manager_component
 
  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  integer, public :: time_startdate(6) = (/ -999, 1, 1, 0, 0, 0 /)
  real(dp), public :: time_startms     = 0.0_dp 
  real(dp), public :: time_startsubsec
  integer, public :: time_startday
  real(dp), public :: time_startsec
 
  integer, public  :: time_enddate(6)
  real(dp), public :: time_endsubsec
  integer, public  :: time_endday
  real(dp), public :: time_endsec
 
  real(dp), public :: time_durationsec
 
  logical, public :: time_doresume
  logical, public :: time_doend
 
  real(dp), public :: time_dtsec_resume
  integer, public :: time_dstep_resume
 
  public :: time_startdaysec
  public :: time_nowdate,  time_nowsubsec, time_nowday,  time_nowdaysec, time_nowsec
  public :: time_nowstep, time_nstep
  public :: time_dtsec
  public :: time_offset_year
 
  !-----------------------------------------------------------------------------
  !
  !++ Private type & procedure
  !
  !-----------------------------------------------------------------------------
 
  !-----------------------------------------------------------------------------
  !
  !++ Private parameters & variables
  !
  
  !-----------------------------------------------------------------------------
 
  integer, private :: time_res_resume
  
  real(dp), private :: time_wallclock_start             ! Start time of wall clock             [sec]
  real(dp), private :: time_wallclock_limit   = -1.0_dp ! Elapse time limit of wall clock time [sec]
  real(dp), private :: time_wallclock_safe    =  0.9_dp ! Safety coefficient for elapse time limit
  real(dp), private :: time_wallclock_safelim           ! TIME_WALLCLOCK_LIMIT * TIME_WALLCLOCK_SAFE
 
  real(dp), private, parameter :: eps = 1.e-6_dp
 
 
  integer, private, parameter :: time_manager_component_max_num = 20
  type time_manager_component_ptr
    type(time_manager_component), pointer :: ptr
  end type time_manager_component_ptr
  type(time_manager_component_ptr), private :: time_manager_comp_ptr_list(time_manager_component_max_num)
  integer, private :: time_manager_component_num
 
  logical :: setup_tinteg_flag
 
contains
 
  subroutine time_manager_init( &
      setup_TimeIntegration,    &
      restart_in_basename       )
 
    use scale_file, only: &
      file_get_attribute
 
    implicit none
 
    logical, intent(in), optional :: setup_timeintegration
    character(len=*), intent(in), optional :: restart_in_basename
    
    real(dp)               :: time_duration                = undef8
    character(len=H_SHORT) :: time_duration_unit           = "SEC"
    real(dp)               :: time_dt                      = undef8
    character(len=H_SHORT) :: time_dt_unit                 = "SEC"
 
    real(dp)               :: time_dt_resume               = undef8
    character(len=H_SHORT) :: time_dt_resume_unit          = ""
 
    real(dp)               :: time_dt_wallclock_check      = undef8
    character(len=H_SHORT) :: time_dt_wallclock_check_unit = ""
 
    namelist /param_time/ &
       time_startdate,               &
       time_startms,                 &
       time_duration,                &
       time_duration_unit,           &
       time_dt,                      &
       time_dt_unit,                 &
       time_dt_resume,               &
       time_dt_resume_unit,          &
       time_dt_wallclock_check,      &
       time_dt_wallclock_check_unit, &
       time_wallclock_limit,         &
       time_wallclock_safe
 
    integer              :: dateday
    real(dp)             :: datesec
    real(dp)             :: cftime(1)
    character(len=H_MID) :: cfunits
   
    character(len=27) :: startchardate
    character(len=27) :: endchardate
   
    integer :: ierr
    integer :: n
    !---------------------------------------------------------------------------
    
    log_newline
    log_info("TIME_manager_setup",*) 'Setup'
 
    !--- read namelist
    rewind(io_fid_conf)
    read(io_fid_conf,nml=param_time,iostat=ierr)
    if( ierr < 0 ) then !--- missing
       log_info("TIME_manager_setup",*) 'Not found namelist. Default used.'
    elseif( ierr > 0 ) then !--- fatal error
       log_error("TIME_manager_setup",*) 'Not appropriate names in namelist PARAM_TIME. Check!'
       call prc_abort
    endif
    log_nml(param_time)
 
    if ( present(setup_timeintegration) ) then
      setup_tinteg_flag = setup_timeintegration
    else
      setup_tinteg_flag = .true.
    end if
 
    if ( setup_tinteg_flag ) then
      if ( time_dt == undef8 ) then
        log_error("TIME_manager_setup",*) 'Not found TIME_DT. STOP.'
        call prc_abort
      endif
      if ( time_duration == undef8 ) then
        log_error("TIME_manager_setup",*) 'Not found TIME_DURATION. STOP.'
        call prc_abort
      endif
            
      if ( time_dt_resume == undef8 ) then
        time_dt_resume = time_duration
      endif
      if ( time_dt_resume_unit == '' ) then
          log_info_cont(*) 'Not found TIME_DT_RESUME_UNIT.        TIME_DURATION_UNIT is used.'
          time_dt_resume_unit = time_duration_unit
      endif
    end if
 
    !--- calculate time
    if ( time_startdate(1) == -999 ) then
      if ( present(restart_in_basename) ) then
        if ( restart_in_basename /= '' ) then ! read start time from the restart data
          call file_get_attribute( restart_in_basename, & ! [IN]
                                   "global",            & ! [IN]
                                   'time_start',        & ! [IN]
                                   cftime(:),           & ! [OUT]
                                   rankid = prc_myrank, & ! [IN]
                                   single = .false.     ) ! [IN]
 
          call file_get_attribute( restart_in_basename, & ! [IN]
                                   "global",            & ! [IN]
                                   'time_units',        & ! [IN]
                                   cfunits,             & ! [OUT]
                                   rankid = prc_myrank, & ! [IN]
                                   single = .false.     ) ! [IN]
 
         dateday = 0
         datesec = calendar_cfunits2sec( cftime(1), cfunits, 0 )
 
         call calendar_adjust_daysec( dateday, datesec )
 
         call calendar_daysec2date( time_startdate,   & ! [OUT]
                                    time_startsubsec, & ! [OUT]
                                    dateday,          & ! [IN]
                                    datesec,          & ! [IN]
                                    0                 ) ! [IN]
        end if
      else
         time_startdate   = (/ 0, 1, 1, 0, 0, 0 /)
         time_startsubsec = 0.0_dp
      endif
    else
      time_startsubsec = time_startms * 1.e-3_dp
    endif
 
    time_offset_year = time_startdate(1)
    
    call calendar_date2daysec( time_startday, time_startsec,                        & ! [OUT]
                               time_startdate(:), time_startms,  time_offset_year   ) ! [IN]
 
    call calendar_date2char( startchardate,                        & ! [OUT]
                             time_startdate(:), time_startsubsec   ) ! [IN]
  
    time_startdaysec  = calendar_combine_daysec( time_startday, time_startsec )
 
    time_nowdate(:)   = time_startdate(:)
    time_nowsubsec    = time_startms
    time_nowday       = time_startday
    time_nowsec       = time_startsec
    time_nowdaysec    = calendar_combine_daysec( time_nowday, time_nowsec )
 
    time_endday       = time_startday
    if (setup_tinteg_flag) then
      call calendar_unit2sec( time_durationsec, time_duration, time_duration_unit )
      time_endsec = time_startsec + time_durationsec
    else
      time_endsec = time_startsec
    end if
 
    call calendar_adjust_daysec( time_endday, time_endsec ) ! [INOUT]
 
    call calendar_daysec2date( time_enddate(:), & ! [OUT]
                               time_endsubsec,  & ! [OUT]
                               time_endday,     & ! [IN]
                               time_endsec,     & ! [IN]
                               time_offset_year ) ! [IN]
 
    call calendar_date2char( endchardate,     & ! [OUT]
                             time_enddate(:), & ! [IN]
                             time_endsubsec   ) ! [IN]
 
    log_newline
    log_info("TIME_manager_setup",*) 'Global date / time setting '
    log_info_cont('(1x,A,A)') 'START Date     : ', startchardate
    log_info_cont('(1x,A,A)') 'END   Date     : ', endchardate
 
    if (setup_tinteg_flag) then
      call calendar_unit2sec( time_dtsec, time_dt, time_dt_unit )
      time_nstep   = int( time_durationsec / time_dtsec )
      time_nowstep = 1
 
      call calendar_unit2sec( time_dtsec_resume, time_dt_resume, time_dt_resume_unit )
      time_dstep_resume = nint( time_dtsec_resume / time_dtsec )
      time_res_resume = time_dstep_resume - 1
    else
      time_dtsec = 1.0_rp
    end if
 
    !--
    time_manager_component_num = 0
    do n=1, time_manager_component_max_num
      nullify( time_manager_comp_ptr_list(n)%ptr )
    end do
    
    !--
    time_wallclock_start = prc_mpitime()
 
    if ( time_wallclock_limit > 0.0_dp ) then
      log_newline
      log_info("TIME_manager_setup",*) 'Wall clock time limit of execution is specified.'
 
      if ( time_dt_wallclock_check == undef8 ) then
        log_info_cont(*) 'Not found TIME_DT_WALLCLOCK_CHECK. TIME_DT is used.'
        time_dtsec_wallclock_check = time_dtsec
     else
        if ( time_dt_wallclock_check_unit == '' ) then
           log_info_cont(*) 'Not found TIME_DT_WALLCLOCK_CHECK_UNIT. TIME_DURATION_UNIT is used.'
           time_dt_wallclock_check_unit = time_duration_unit
        endif
        call calendar_unit2sec( time_dtsec_wallclock_check, time_dt_wallclock_check, time_dt_wallclock_check_unit )
        time_dtsec_wallclock_check = max( time_dtsec_wallclock_check, time_dtsec )
     endif
 
     time_dstep_wallclock_check = int( time_dtsec_wallclock_check / time_dtsec )
 
     time_wallclock_safe    = max( min( time_wallclock_safe, 1.0_dp ), 0.0_dp )
     time_wallclock_safelim = time_wallclock_limit * time_wallclock_safe
 
     log_info_cont('(1x,A,F10.1,A)')      'This job stops after ', time_wallclock_safelim, ' seconds.'
     log_info_cont('(1x,A,F10.3,A,I8,A)') 'Time interval for check     : ', time_dtsec_wallclock_check, &
                                          ' (step interval=', time_dstep_wallclock_check, ')'
    end if
 
    return
  end subroutine time_manager_init
 
  subroutine time_manager_final()
    implicit none
 
    integer :: n
    !---------------------------------------------------------------------------
 
    do n=1, time_manager_component_num
      nullify( time_manager_comp_ptr_list(n)%ptr )
    end do
    time_manager_component_num = 0
 
    return
  end subroutine time_manager_final  
 
  subroutine time_manager_advance()
    implicit none
    !---------------------------------------------------------------------------
 
    time_nowstep = time_nowstep + 1
    time_nowday  = time_startday
    time_nowsec  = time_startsec + real(time_nowstep-1,kind=dp) * time_dtsec
    
    ! reallocate day & sub-day
    call calendar_adjust_daysec( time_nowday, time_nowsec ) ! [INOUT]
  
    call calendar_daysec2date( time_nowdate(:), time_nowsubsec,           & ! [OUT]
                               time_nowday, time_nowsec, time_offset_year ) ! [IN]
  
    time_nowdaysec = calendar_combine_daysec( time_nowday, time_nowsec )
  
    if (time_nowstep > time_nstep) then
      time_doend = .true.
    end if
 
    return
  end subroutine time_manager_advance
  
  subroutine time_manager_checkstate()
    use scale_calendar, only: calendar_date2char    
    implicit none
 
    integer :: n
    type(time_manager_component), pointer :: tm_comp
 
    real(dp)          :: wallclock_elapse
    character(len=27) :: nowchardate
    logical           :: to_stdout
    !---------------------------------------------------------------------------
 
    do n=1, time_manager_component_num
      tm_comp => time_manager_comp_ptr_list(n)%ptr
      call tm_comp%Check_state()
    end do
 
    time_doresume   = .false.
    time_res_resume = time_res_resume + 1
 
    if (time_res_resume == time_dstep_resume) then
      time_doresume   = .true.
      time_res_resume =  0
    end if
 
    !----
 
    to_stdout = .false.
    if ( io_step_to_stdout > 0 ) then
       if( mod(time_nowstep-1,io_step_to_stdout) == 0 ) to_stdout = .true.
    endif
 
    call calendar_date2char( nowchardate,     & ! [OUT]
                             time_nowdate(:), & ! [IN]
                             time_nowsubsec   ) ! [IN]
 
    wallclock_elapse = prc_mpitime() - time_wallclock_start
 
    log_newline
    if ( time_wallclock_limit > 0.0_dp ) then
       log_progress('(1x,2A,2(A,I7),2(A,F10.1))') 'TIME: ', nowchardate,' STEP:',time_nowstep, '/', time_nstep, &
                                                                 ' WCLOCK:', wallclock_elapse, '/', time_wallclock_safelim
       if ( prc_universal_ismaster .AND. to_stdout ) then ! universal master node
          write(*,'(1x,2A,2(A,I7),2(A,F10.1))') 'TIME: ', nowchardate,' STEP:',time_nowstep, '/', time_nstep, &
                                                ' WCLOCK:', wallclock_elapse, '/', time_wallclock_safelim
       endif
    else
       log_progress('(1x,2A,2(A,I7),A,F10.1)') 'TIME: ', nowchardate,' STEP:',time_nowstep, '/', time_nstep, &
                                                              ' WCLOCK:', wallclock_elapse
       if ( prc_universal_ismaster .AND. to_stdout ) then ! universal master node
          write(*,'(1x,2A,2(A,I7),A,F10.1)') 'TIME: ', nowchardate,' STEP:',time_nowstep, '/', time_nstep, &
                                             ' WCLOCK:', wallclock_elapse
       endif
    endif
 
    return
  end subroutine time_manager_checkstate
 
  subroutine time_manager_report_timeintervals()    
    implicit none
 
    integer :: n, p
    type(time_manager_component), pointer :: tm_comp
    type(time_manager_process), pointer :: tm_process
    !-------------------------------------------------------------------
 
    log_newline
    log_info("TIME_manager_report_timeintervals",*) 'Time interval for each component (sec.)'
 
    do n=1, time_manager_component_num
      tm_comp => time_manager_comp_ptr_list(n)%ptr
      log_info_cont(*) trim(tm_comp%comp_name)
      do p=1, tm_comp%process_num
        tm_process => tm_comp%process_list(p)
        log_info_cont('(1x,A,F10.3)')        trim(tm_process%process_name)//' (time)             : ', tm_process%dtsec
        if (tm_process%inner_itr_num > 1) then
          log_info_cont('(1x,A,I10)') ' (step)             : ', tm_process%inner_itr_num 
        end if
        log_info_cont('(1x,A,I8,A)')  ' (step interval=', tm_process%dstep,    ')' 
      end do
    end do
 
    log_newline
    log_info_cont(*)                     'Time interval for restart (sec.)'
 
    do n=1, time_manager_component_num
      tm_comp => time_manager_comp_ptr_list(n)%ptr
      log_info_cont('(1x,A,F10.3,A,I8,A)') trim(tm_comp%comp_name)//' variables       : ', tm_comp%dtsec_restart, &
                                         ' (step interval=', tm_comp%dstep_restart, ')'
    end do
    log_info_cont('(1x,A,F10.3,A,I8,A)') 'Resume                      : ', time_dtsec_resume, &
    ' (step interval=', time_dstep_resume,        ')'
 
    return
  end subroutine time_manager_report_timeintervals
 
  subroutine time_manager_regist_component( tmanager_comp )
    implicit none
 
    type(time_manager_component), intent(in), target :: tmanager_comp
    !------------------------------------------------------------------------
 
    time_manager_component_num = time_manager_component_num + 1
    if (time_manager_component_num > time_manager_component_max_num) then
      log_error("TIME_manager_regist_component",*) 'The number of TIME_manager_component registered exceeds ', &
        time_manager_component_num, time_manager_component_max_num
      call prc_abort
    end if
 
    time_manager_comp_ptr_list(time_manager_component_num)%ptr => tmanager_comp
    return
  end subroutine time_manager_regist_component
 
!---
  subroutine time_manager_component_init( this, comp_name, &
    dt, dt_unit, dt_restart, dt_restart_unit )
    implicit none
 
    class(time_manager_component), intent(inout) :: this
    character(*), intent(in) :: comp_name
    real(dp), intent(in) :: dt
    character(*), intent(in) :: dt_unit
    real(dp), intent(in) :: dt_restart
    character(*), intent(in) :: dt_restart_unit
 
    real(rp) :: start_sec, end_sec
    real(rp) :: absday, absdaysec, abssec
    !------------------------------------------------------------------------
 
    this%process_num = 0
    this%res_step = 0
    this%res_step_restart = 0
    this%comp_name = comp_name
 
    !--
    if (.not. setup_tinteg_flag) return
 
    if (dt == undef8) then
      log_info_cont(*) 'Not found TIME_DT_'//trim(comp_name)//'. TIME_DTSEC is used.'
      this%dtsec = time_dtsec
    else 
      call calendar_unit2sec( this%dtsec, dt, dt_unit )
    end if
    
    this%dstep = nint( this%dtsec / time_dtsec )
 
    if ( abs(this%dtsec - real(this%dstep,kind=dp)*time_dtsec) > eps ) then
      log_error("TIME_manager_component_Init",*) 'delta t('//trim(comp_name)//') must be a multiple of delta t ', &
        this%dtsec, real(this%dstep,kind=dp)*time_dtsec
      call prc_abort
    end if
 
    !--
 
    if (dt_restart == undef8) then
      log_info_cont(*) 'Not found TIME_DT_'//trim(comp_name)//'_RESTART.       TIME_DURATION is used.'
      this%dtsec_restart = time_durationsec
    else 
      call calendar_unit2sec( this%dtsec_restart, dt_restart, dt_restart_unit )
    end if
 
    this%dstep_restart = nint( this%dtsec_restart / time_dtsec )
 
    if ( abs(this%dtsec_restart - real(this%dstep_restart,kind=dp)*time_dtsec) > eps ) then
      log_error("TIME_manager_component_Init",*) 'delta t('//trim(comp_name)//'_RESTART) must be a multiple of delta t ', &
        this%dtsec_restart, real(this%dstep_restart,kind=dp)*time_dtsec
      call prc_abort
    end if
 
    !--
 
    return
  end subroutine time_manager_component_init
 
  subroutine time_manager_component_checkstate( this )    
    implicit none
    class(time_manager_component), intent(inout), target :: this
 
    integer :: n
    type(time_manager_process), pointer :: tm_process
    !--------------------------------------------------
 
    this%do_step = .false.      
 
    if (this%process_num > 0) then
      do n=1, this%process_num
        tm_process => this%process_list(n)
        call tm_process%Check_state()
        if (tm_process%do_step) this%do_step = .true.
      end do  
    else
      this%res_step = this%res_step + 1
      if ( this%res_step == this%dstep ) then
        this%do_step = .true.
        this%res_step = 0
      end if  
    end if
 
    !-
    this%do_restart = .false.
 
    this%res_step_restart = this%res_step_restart + 1
    if ( this%res_step_restart == this%dstep_restart ) then
      this%do_restart = .true.
      this%res_step_restart = 0
    end if  
 
    return
  end subroutine time_manager_component_checkstate
 
  subroutine time_manager_component_regist_process( this, &
      process_name, dt, dt_unit,                          &
      tm_process_id )    
    implicit none
 
    class(time_manager_component), intent(inout), target :: this
    character(*), intent(in) :: process_name
    real(dp), intent(in) :: dt
    character(*), intent(in) :: dt_unit
    integer, intent(out) :: tm_process_id
 
    type(time_manager_process), pointer :: tm_process
    !--------------------------------------------------
 
    this%process_num = this%process_num + 1
    tm_process_id = this%process_num 
 
    if( this%process_num > time_manager_process_max_num) then
      log_error("TIME_manager_component_Regist_process",*) 'The number of TIME_manager_process registered exceeds ', &
        this%process_num, time_manager_process_max_num
      call prc_abort
    end if
 
    tm_process => this%process_list(this%process_num)
    call tm_process%Init( process_name, dt, dt_unit )
 
    return
  end subroutine time_manager_component_regist_process
 
  subroutine time_manager_component_final( this )    
    implicit none
    class(time_manager_component), intent(inout) :: this
 
    integer :: n
    !--------------------------------------------------
 
    do n=1, this%process_num
      call this%process_list(n)%Final()
    end do
    this%process_num = 0
 
    return
  end subroutine time_manager_component_final
 
  function time_manager_component_do_process( this, tm_process_id ) result(do_step)
    implicit none
    class(time_manager_component), intent(inout) :: this
    integer, intent(in) :: tm_process_id
    logical :: do_step
    !--------------------------------------------------
    do_step = this%process_list(tm_process_id)%do_step
    return
  end function time_manager_component_do_process
 
  function time_manager_component_get_process_inner_itr_num( this, tm_process_id ) result(itr_num)
    implicit none
    class(time_manager_component), intent(inout) :: this
    integer, intent(in) :: tm_process_id
    integer :: itr_num
    !--------------------------------------------------
    itr_num = this%process_list(tm_process_id)%inner_itr_num
    return
  end function time_manager_component_get_process_inner_itr_num
 
  !---
 
  subroutine time_manager_process_init( this, process_name, &
      dt, dt_unit )    
    implicit none
 
    class(time_manager_process), intent(inout) :: this
    character(*), intent(in) :: process_name
    real(dp), intent(in) :: dt
    character(*), intent(in) :: dt_unit
    !--------------------------------------------------
 
    this%res_step = 0
    this%process_name = process_name
 
    if (.not. setup_tinteg_flag) return
 
    if (dt == undef8) then
      log_info_cont(*) 'Not found TIME_DT_'//trim(process_name)//'. TIME_DTSEC is used.'
      this%dtsec = time_dtsec
    else 
      call calendar_unit2sec( this%dtsec, dt, dt_unit )
    end if
 
    this%inner_itr_num = max( nint(time_dtsec/this%dtsec), 1 )
    this%dstep = nint( this%dtsec / time_dtsec * dble(this%inner_itr_num) )
 
    if ( abs(  real(this%inner_itr_num, kind=dp)*this%dtsec         &
             - real(this%dstep         ,kind=dp)*time_dtsec          ) > eps ) then
      log_error("TIME_manager_process_Init",*) 'delta t('//trim(process_name)//') must be a multiple of delta t ', &
        this%dtsec, real(this%dstep,kind=dp)*time_dtsec
      call prc_abort
    end if
 
    return
  end subroutine time_manager_process_init  
 
 
  subroutine time_manager_process_final( this )    
    implicit none
    class(time_manager_process), intent(inout) :: this
    !--------------------------------------------------
 
    return
  end subroutine time_manager_process_final
 
  subroutine time_manager_process_checkstate( this )    
    implicit none
    class(time_manager_process), intent(inout) :: this
    !--------------------------------------------------
 
    this%do_step = .false.
    this%res_step = this%res_step + 1
    if ( this%res_step == this%dstep ) then
      this%do_step = .true.
      this%res_step = 0
    end if
 
    return
  end subroutine time_manager_process_checkstate
 
!--
 
end module scale_time_manager