dcdatetimecreate.f90

Go to the documentation of this file.

! -*- mode: f90; coding: utf-8 -*-
!-----------------------------------------------------------------------
! Copyright (c) 2000-2026 Gtool Development Group. All rights reserved.
!-----------------------------------------------------------------------
!>
!> @author    Yasuhiro MORIKAWA, Eizi TOYODA
!> @copyright Copyright (C) GFD Dennou Club, 2000-2026. All rights reserved. <br/>
!>            License is BSD-2-Clause. see [COPYRIGHT](@ref COPYRIGHT) in detail
!> @en
!> @brief Create DC_DATETIME and DC_DIFFTIME type variables
!> @details
!> Procedures described in this file are provided from "dc_date" module.
!> @enden
!>
!> @ja
!> @brief dc_date_types#DC_DATETIME, dc_date_types#DC_DIFFTIME 型変数の生成
!> @details
!> このファイルで提供される手続き群は dc_date モジュールにて提供されます.
!> @endja
!>
 
!> @en
!> @brief Create DC_DATETIME type variable
!> @details
!> Create dc_date_types#DC_DATETIME type variable.
!> If all arguments `year`, `mon`, `day`, `hour`, `min`, `sec` are not given,
!> the current time is used.
!>
!> Set calendar type with `caltype` argument.
!> Use one of dc_date_types#CAL_CYCLIC, dc_date_types#CAL_NOLEAP,
!> dc_date_types#CAL_JULIAN, dc_date_types#CAL_GREGORIAN.
!> If `caltype` is not specified, calendar is set to dc_date_types#CAL_GREGORIAN.
!> Calendar can also be specified by string with `caltype_str`.
!> Corresponding strings (case insensitive) are:
!>
!> | caltype                      | caltype_str |
!> |------------------------------|-------------|
!> | dc_date_types#CAL_CYCLIC     | cyclic      |
!> | dc_date_types#CAL_NOLEAP     | noleap      |
!> | dc_date_types#CAL_JULIAN     | julian      |
!> | dc_date_types#CAL_GREGORIAN  | gregorian   |
!>
!> Set timezone from UTC with `zone` argument.
!> Specify timezone as 6 characters like '+09:00' or '-13:00'.
!> If `zone` is not specified, timezone obtained from date_and_time
!> intrinsic subroutine is used.
!> Timezone can also be specified with `zone_hour` or `zone_min` as integer.
!>
!> Set seconds per day with `day_seconds` argument.
!> If not specified, dc_date_types#day_seconds value is used.
!> dc_date_types#day_seconds can be changed with SetSecOfDay.
!>
!> If invalid value is given to `caltype` or `zone`, an error occurs.
!> If `err` argument is given, `.true.` is returned to `err` and
!> the program continues.
!>
!> @param[out] time Created DC_DATETIME variable
!> @param[in] year Year
!> @param[in] mon Month
!> @param[in] day Day
!> @param[in] hour Hour
!> @param[in] min Minute
!> @param[in] sec Second
!> @param[in] zone Timezone from UTC
!> @param[in] zone_hour Timezone (hour)
!> @param[in] zone_min Timezone (minute)
!> @param[in] caltype Calendar type
!> @param[in] caltype_str Calendar type (string)
!> @param[in] day_seconds Seconds per day
!> @param[in] sclyear Year (DC_SCALED_SEC type)
!> @param[in] sclmon Month (DC_SCALED_SEC type)
!> @param[in] sclday Day (DC_SCALED_SEC type)
!> @param[in] sclsec Second (DC_SCALED_SEC type)
!> @param[out] err Exception handling flag
!> @enden
!>
!> @ja
!> @brief DC_DATETIME 型変数を生成
!> @details
!> dc_date_types#DC_DATETIME 型変数の生成を行います.
!> 引数 `year`, `mon`, `day`, `hour`, `min`, `sec` の全てを与えない場合,
!> このサブルーチンが呼ばれた際の時刻が使用されます.
!>
!> 引数 `caltype` には暦法を設定します.
!> dc_date_types#CAL_CYCLIC, dc_date_types#CAL_NOLEAP,
!> dc_date_types#CAL_JULIAN, dc_date_types#CAL_GREGORIAN
!> のいづれかを与えてください. 引数 `caltype` を指定しない場合, 暦法は
!> dc_date_types#CAL_GREGORIAN に設定されます.
!> 暦法は `caltype_str` に文字列を与えることでも指定可能です.
!> 上記の暦法に対応する文字列は以下の通りです. (大文字小文字は区別しません)
!>
!> | caltype                      | caltype_str |
!> |------------------------------|-------------|
!> | dc_date_types#CAL_CYCLIC     | cyclic      |
!> | dc_date_types#CAL_NOLEAP     | noleap      |
!> | dc_date_types#CAL_JULIAN     | julian      |
!> | dc_date_types#CAL_GREGORIAN  | gregorian   |
!>
!> 引数 `zone` には UTC からの時差を設定します.
!> '+09:00' や '-13:00' のように時差を 6 文字で指定してください.
!> 引数 `zone` を指定しない場合, date_and_time 組み込みサブルーチン
!> によって得られる時差を設定します.
!> 時差は `zone_hour` または `zone_min` に整数型を与えることでも
!> 指定可能です.
!>
!> 引数 `day_seconds` には 1 日何秒かを設定します. この引数を
!> 指定しない場合, dc_date_types#day_seconds の値が用いられます.
!> dc_date_types#day_seconds は SetSecOfDay で変更可能です.
!>
!> 引数 `caltype` および, `zone` に不適切な値が与えられた場合,
!> エラーを発生させます.
!> 引数 `err` を与えている場合には `err` に .true. が返り,
!> プログラムは続行します.
!>
!> @param[out] time 生成される DC_DATETIME 変数
!> @param[in] year 年
!> @param[in] mon 月
!> @param[in] day 日
!> @param[in] hour 時
!> @param[in] min 分
!> @param[in] sec 秒
!> @param[in] zone UTC からの時差
!> @param[in] zone_hour UTC からの時差 (時)
!> @param[in] zone_min UTC からの時差 (分)
!> @param[in] caltype 暦法
!> @param[in] caltype_str 暦法 (文字型による指定)
!> @param[in] day_seconds 1 日の秒数
!> @param[in] sclyear 年 (DC_SCALED_SEC 型)
!> @param[in] sclmon 月 (DC_SCALED_SEC 型)
!> @param[in] sclday 日 (DC_SCALED_SEC 型)
!> @param[in] sclsec 秒 (DC_SCALED_SEC 型)
!> @param[out] err 例外処理用フラグ
!> @endja
subroutine dcdatetimecreate1(time, &
  & year, mon, day, hour, min, sec, &
  & zone, zone_hour, zone_min, caltype, caltype_str, day_seconds, &
  & sclyear, sclmon, sclday, sclsec, err)
 
  use dc_date_generic, only: dcdifftimecreate, &
    & validcaltype, validzone, tochar
  use dc_date_internal, only: dcdate_set_day_seconds_scl
  use dc_date_types, only: dc_datetime, dc_difftime, &
    & caltype_default => caltype, &
    & flag_set_day_seconds_scl, day_seconds_scl, &
    & cyclic_mdays, cal_noleap, cal_julian, cal_cyclic, cal_gregorian, &
    & min_seconds, hour_seconds, four_years, year_months
  use dc_error, only: storeerror, dc_ebadcaltype, dc_ebadtimezone, dc_noerr
  use dc_message, only: messagenotify
  use dc_trace, only: beginsub, endsub
  use dc_present, only: present_select
  use dc_string, only: lchar, cprintf
  use dc_scaledsec, only: dc_scaled_sec, &
    & assignment(=), dcscaledsecputline, &
    & operator(==), operator(>), operator(<), operator(>=), operator(<=), &
    & operator(+), operator(-), operator(*), operator(/), mod, modulo, &
    & abs, int, sign, floor, dcscaledsecputline
  use dc_types,      only: dp, string
  implicit none
  type(dc_datetime), intent(out) :: time
  integer, intent(in), optional:: year
  integer, intent(in), optional:: mon
  integer, intent(in), optional:: day
  integer, intent(in), optional:: hour
  integer, intent(in), optional:: min
  real(DP),intent(in), optional:: sec
  character(*), intent(in), optional :: zone
  integer, intent(in), optional :: zone_hour
  integer, intent(in), optional :: zone_min
  integer, intent(in), optional:: caltype
  character(*), intent(in), optional:: caltype_str
  real(DP),intent(in), optional:: day_seconds
  type(dc_scaled_sec), intent(in), optional:: sclyear
  type(dc_scaled_sec), intent(in), optional:: sclmon
  type(dc_scaled_sec), intent(in), optional:: sclday
  type(dc_scaled_sec), intent(in), optional:: sclsec
  logical, intent(out), optional:: err
 
  real(DP):: gcsec
  integer :: gcday, gcmon, gcyear
  real(DP):: essec, esds
  integer :: esday
  type(dc_scaled_sec):: iday, imon, month, iyear, century, isec
  character(6) :: izone
  integer, parameter:: year_default = 0, mon_default = 1
  integer, parameter:: day_default = 1
  integer, parameter:: sec_default = 0
  logical :: current_time_used
  type(dc_difftime):: zonediff
  character(STRING):: zone_str_long
  integer :: stat, cause_i
  character(STRING) :: cause_c
  character(*), parameter :: subname = 'DCDateTimeCreate1'
continue
  current_time_used = .not. present(year) &
    & .and. .not. present(mon) &
    & .and. .not. present(day) &
    & .and. .not. present(hour) &
    & .and. .not. present(min) &
    & .and. .not. present(sec) &
    & .and. .not. present(sclyear) &
    & .and. .not. present(sclmon) &
    & .and. .not. present(sclday) &
    & .and. .not. present(sclsec)
  call beginsub(subname, 'current_time_used=<%y>', l=(/current_time_used/))
  stat = dc_noerr
  cause_i = dc_noerr
  cause_c = ''
 
  if ( present(day_seconds) ) then
    time % day_seconds = day_seconds
  else
    if ( .not. flag_set_day_seconds_scl ) call dcdate_set_day_seconds_scl
    time % day_seconds = day_seconds_scl
  end if
 
  call get_current_time(gcyear, gcmon, gcday, gcsec, izone) ! (out)
  iyear = gcyear
  imon = gcmon
  iday = gcday
  isec = gcsec
 
  if (.not. current_time_used) then
    if ( present(zone_hour) .or. present(zone_min) ) then
      call dcdifftimecreate( zonediff, &     ! (out)
        & hour = zone_hour, min = zone_min ) ! (in)
      zone_str_long = tochar(zonediff)
      if ( zone_str_long(1:1) == '-' ) then
        izone(1:1) = '-'
      else
        izone(1:1) = '+'
      end if
      izone(2:6) = zone_str_long(13:17)
    end if
    if (present(zone)) then
      izone = zone
    end if
    if ( .not. validzone(izone)) then
      stat = dc_ebadtimezone
      cause_c = izone
      if (present(err)) then
        call messagenotify('W', subname, &
          & 'zone=<%c> is invalid.', &
          & c1=trim(izone))
      else
        goto 999
      end if
    end if
 
    if ( present(sclsec) ) then
      isec = sclsec
    elseif( present(sec) ) then
      isec = sec
    else
      isec = sec_default
    end if
    if (present(min)) then
      isec = isec + min * min_seconds
    end if
    if (present(hour)) then
      isec = isec + hour * hour_seconds
    end if
 
    if ( present(sclday) ) then
      iday = sclday
    elseif( present(day) ) then
      iday = day
    else
      iday = day_default
    end if
 
    if ( present(sclday) ) then
      iday = sclday
    elseif( present(day) ) then
      iday = day
    else
      iday = day_default
    end if
    iday = iday + floor(isec / time % day_seconds)
 
    if ( present(sclmon) ) then
      imon = sclmon
    elseif( present(mon) ) then
      imon = mon
    else
      imon = mon_default
    end if
 
    if ( present(sclyear) ) then
      iyear = sclyear
    elseif( present(year) ) then
      iyear = year
    else
      iyear = year_default
    end if
  end if
 
  time % zone = izone
  time % sec = modulo(isec, time % day_seconds)
  time % caltype = caltype_default
  if (present(caltype_str)) then
    select case( lchar(trim(caltype_str)) )
    case('cyclic')
      time % caltype = cal_cyclic
    case('noleap')
      time % caltype = cal_noleap
    case('julian')
      time % caltype = cal_julian
    case('gregorian')
      time % caltype = cal_gregorian
    case('')
      time % caltype = cal_gregorian
    case default
      stat = dc_ebadcaltype
      cause_i = 0
      call messagenotify('W', subname, &
        & 'caltype=<%c> is invalid calender type.', &
        & c1 = trim(caltype_str) )
      if ( .not. present(err) ) then
        goto 999
      end if
    end select
  end if
 
  if (present(caltype)) then
    if (validcaltype(caltype)) then
      time % caltype = caltype
    else
      stat = dc_ebadcaltype
      cause_i = caltype
      if (present(err)) then
        call messagenotify('W', subname, &
          & 'caltype=<%d> is invalid calender type.', &
          & i=(/caltype/))
      else
        goto 999
      end if
    end if
  end if
  if (time % caltype == cal_cyclic) then
    time % day = int( iday + imon * cyclic_mdays )
    goto 999
  endif
  month = modulo(imon - 3, year_months) + 3
  iyear = iyear + int( (imon - month) / year_months )
  iday = iday + int( (month * 306 - 914) / 10 )
  if (time % caltype == cal_noleap) then
    time % day = iday + iyear * 365 + 90
  else
    iday = iday + int( (iyear * four_years - modulo(iyear * four_years, 4)) / 4 )
    if (time % caltype == cal_julian) then
      time % day = iday + 91
    elseif (iday < 640116) then
      time % day = iday + 91
    else
      century = (iyear - modulo(iyear, 100)) / 100 + 1
      time % day = iday - int( (century * 3 - modulo(century * 3, 4)) / 4 ) + 93
    endif
  endif
 
 
999 continue
  call storeerror(stat, subname, err, cause_c, cause_i)
  esday = time % day ; essec = time % sec ; esds = time % day_seconds
  call endsub(subname, 'time (caltype=%d, day=%d, sec=%f, zone=%c, day_seconds=%f)', &
    & i=(/time % caltype, esday/), d=(/essec, esds/), &
    & c1=trim(time % zone))
 
  contains
    !> @en
    !> @brief Get current time using date_and_time intrinsic subroutine
    !> @details
    !> Returns current time and timezone from UTC using date_and_time intrinsic subroutine.
    !> @param[out] jyear Year
    !> @param[out] jmon Month
    !> @param[out] jday Day
    !> @param[out] jsec Second
    !> @param[out] jzone Timezone
    !> @enden
    !>
    !> @ja
    !> @brief date_and_time 組み込みサブルーチンを用いて現在時刻を取得
    !> @details
    !> date_and_time 組み込みサブルーチンを用いて, 現在
    !> 時刻と UTC からの時差を返します.
    !> @param[out] jyear 年
    !> @param[out] jmon 月
    !> @param[out] jday 日
    !> @param[out] jsec 秒
    !> @param[out] jzone タイムゾーン
    !> @endja
    subroutine get_current_time(jyear, jmon, jday, jsec, jzone)
      use dc_types, only: dp
      use dc_string, only: stod
      implicit none
      integer, intent(out) :: jyear, jmon, jday
      real(DP), intent(out) :: jsec
      character(*), intent(out) :: jzone
 
      integer :: date_time_values(1:8)
      character(5)  :: zone_raw
    continue
 
      call date_and_time(zone=zone_raw, values=date_time_values)
 
      jzone = zone_raw(1:3) // ":" // zone_raw(4:5)
 
      jyear = date_time_values(1)
      jmon  = date_time_values(2)
      jday  = date_time_values(3)
      jsec  = real(date_time_values(5), dp) * hour_seconds &
        &     + real(date_time_values(6), dp) * min_seconds &
        &     + real(date_time_values(7), dp)
 
    end subroutine get_current_time
 
end subroutine dcdatetimecreate1
 
 
!> @en
!> @brief Create DC_DIFFTIME type variable
!> @details
!> Create dc_date_types#DC_DIFFTIME type variable.
!> If arguments `year`, `mon`, `day`, `hour`, `min`, `sec`, `nondim` are not given,
!> 0 is used.
!>
!> Set seconds per day with `day_seconds` argument.
!> If not specified, dc_date_types#day_seconds value is used.
!> dc_date_types#day_seconds can be changed with SetSecOfDay.
!>
!> @param[out] diff Created DC_DIFFTIME variable
!> @param[in] year Year
!> @param[in] mon Month
!> @param[in] day Day
!> @param[in] hour Hour
!> @param[in] min Minute
!> @param[in] sec Second
!> @param[in] day_seconds Seconds per day
!> @param[in] nondim Nondimensional time
!> @param[in] sclyear Year (DC_SCALED_SEC type)
!> @param[in] sclmon Month (DC_SCALED_SEC type)
!> @param[in] sclday Day (DC_SCALED_SEC type)
!> @param[in] sclsec Second (DC_SCALED_SEC type)
!> @enden
!>
!> @ja
!> @brief DC_DIFFTIME 型変数を生成
!> @details
!> dc_date_types#DC_DIFFTIME 型変数の生成を行います.
!> 引数 `year`, `mon`, `day`, `hour`, `min`, `sec`, `nondim` を与えない場合,
!> 0 が与えられたことになります.
!>
!> 引数 `day_seconds` には 1 日何秒かを設定します. この引数を
!> 指定しない場合, dc_date_types#day_seconds の値が用いられます.
!> dc_date_types#day_seconds は SetSecOfDay で変更可能です.
!>
!> @param[out] diff 生成される DC_DIFFTIME 変数
!> @param[in] year 年
!> @param[in] mon 月
!> @param[in] day 日
!> @param[in] hour 時
!> @param[in] min 分
!> @param[in] sec 秒
!> @param[in] day_seconds 1 日の秒数
!> @param[in] nondim 無次元時間
!> @param[in] sclyear 年 (DC_SCALED_SEC 型)
!> @param[in] sclmon 月 (DC_SCALED_SEC 型)
!> @param[in] sclday 日 (DC_SCALED_SEC 型)
!> @param[in] sclsec 秒 (DC_SCALED_SEC 型)
!> @endja
subroutine dcdifftimecreate1(diff, &
  & year, mon, day, hour, min, sec, day_seconds, nondim, &
  & sclyear, sclmon, sclday, sclsec )
  use dc_date_internal, only: dcdate_normalize
  use dc_date_generic, only: validcaltype
  use dc_date_types, only: dc_difftime, &
    & day_seconds_default => day_seconds, &
    & min_seconds, hour_seconds, year_months
  use dc_message, only: messagenotify
  use dc_trace, only: beginsub, endsub, debug
  use dc_present, only: present_select
  use dc_scaledsec, only: dc_scaled_sec, &
    & assignment(=), dcscaledsecputline, &
    & operator(==), operator(>), operator(<), operator(>=), operator(<=), &
    & operator(+), operator(-), operator(*), operator(/), mod, modulo, &
    & abs, int, sign, floor
  use dc_string, only: cprintf
  use dc_types,      only: dp, string
  implicit none
  type(dc_difftime), intent(out) :: diff
  integer,  intent(in), optional:: year
  integer,  intent(in), optional:: mon
  integer,  intent(in), optional:: day
  integer,  intent(in), optional:: hour
  integer,  intent(in), optional:: min
  real(DP), intent(in), optional:: sec
  real(DP), intent(in), optional:: day_seconds
  real(DP), intent(in), optional:: nondim
  type(dc_scaled_sec), intent(in), optional:: sclyear
  type(dc_scaled_sec), intent(in), optional:: sclmon
  type(dc_scaled_sec), intent(in), optional:: sclday
  type(dc_scaled_sec), intent(in), optional:: sclsec
 
  type(dc_scaled_sec):: iyear, imon, iday, ihour, imin, isec
  integer, parameter:: year_default = 0, mon_default = 0
  integer, parameter:: day_default = 0, hour_default = 0, min_default = 0
  integer, parameter:: sec_default = 0
  real(DP):: essec, esds
  integer :: esmon, esday
  character(STRING):: endsub_msb
  logical:: dbg_mode
  character(*), parameter :: subname = 'DCDiffTimeCreate1'
continue
  call beginsub(subname)
 
  if ( present(nondim) ) then
    diff % nondim_flag = .true.
    diff % mon = 0
    diff % day = 0
    diff % sec = nondim
    goto 999
  else
    diff % nondim_flag = .false.
  end if
 
  if ( present(sclyear) ) then
    iyear = sclyear
  elseif( present(year) ) then
    iyear = year
  else
    iyear = year_default
  end if
 
  if ( present(sclmon) ) then
    imon = sclmon
  elseif( present(mon) ) then
    imon = mon
  else
    imon = mon_default
  end if
 
  if ( present(sclday) ) then
    iday = sclday
  elseif( present(day) ) then
    iday = day
  else
    iday = day_default
  end if
 
  ihour = present_select(.false., hour_default, hour)
  imin  = present_select(.false., min_default, min)
 
  if ( present(sclsec) ) then
    isec = sclsec
  elseif( present(sec) ) then
    isec = sec
  else
    isec = sec_default
  end if
 
  diff % mon = iyear * year_months + imon
  diff % day = iday
  diff % sec =   ihour * hour_seconds &
    &          + imin  * min_seconds &
    &          + isec
 
  if( present(day_seconds) ) then
    diff % day_seconds = day_seconds
  else
    diff % day_seconds = day_seconds_default
  end if
 
  call dcdate_normalize(diff % day, diff % sec, diff % day_seconds, diff % nondim_flag)
 
999 continue
  call debug( dbg_mode )
  if ( dbg_mode ) then
    esmon = diff % mon ; esday = diff % day
    essec = diff % sec ; esds = diff % day_seconds
    endsub_msb = &
      & cprintf( 'mon=%d, day=%d, sec=%f, day_seconds=%f, nondim_flag=%b', &
      &          i = (/ esmon, esday /), d = (/ essec, esds /), &
      &          l = (/ diff % nondim_flag /) )
  else
    endsub_msb = ''
  end if
  call endsub(subname, 'diff (%c)', c1 = trim(endsub_msb) )
end subroutine dcdifftimecreate1
 
 
!> @en
!> @brief Create DC_DIFFTIME type variable with value and unit
!> @details
!> Create dc_date_types#DC_DIFFTIME type variable.
!> Specify value with `value` argument and unit with `unit` string
!> or unit symbol with `unit_symbol`.
!>
!> Valid strings for `unit` (case insensitive):
!>
!> | Unit          | String                       |
!> |---------------|------------------------------|
!> | Year          | dc_date_types#UNIT_YEAR      |
!> | Month         | dc_date_types#UNIT_MONTH     |
!> | Day           | dc_date_types#UNIT_DAY       |
!> | Hour          | dc_date_types#UNIT_HOUR      |
!> | Minute        | dc_date_types#UNIT_MIN       |
!> | Second        | dc_date_types#UNIT_SEC       |
!> | Nondimensional| dc_date_types#UNIT_NONDIM    |
!>
!> If invalid string is given to `unit`, an error occurs.
!>
!> Valid symbols for `unit_symbol`:
!>
!> | Unit          | Symbol                              |
!> |---------------|-------------------------------------|
!> | Year          | dc_date_types#UNIT_SYMBOL_YEAR      |
!> | Month         | dc_date_types#UNIT_SYMBOL_MONTH     |
!> | Day           | dc_date_types#UNIT_SYMBOL_DAY       |
!> | Hour          | dc_date_types#UNIT_SYMBOL_HOUR      |
!> | Minute        | dc_date_types#UNIT_SYMBOL_MIN       |
!> | Second        | dc_date_types#UNIT_SYMBOL_SEC       |
!> | Nondimensional| dc_date_types#UNIT_SYMBOL_NONDIM    |
!>
!> If invalid symbol is given to `unit_symbol`, an error occurs.
!> If `err` argument is given, `.true.` is returned to `err` and
!> the program continues.
!>
!> @param[out] diff Created DC_DIFFTIME variable
!> @param[in] value Value
!> @param[in] unit Unit string
!> @param[in] unit_symbol Unit symbol
!> @param[out] err Exception handling flag
!> @enden
!>
!> @ja
!> @brief 値と単位から DC_DIFFTIME 型変数を生成
!> @details
!> dc_date_types#DC_DIFFTIME 型変数の生成を行います.
!> 引数 `value` に数値を, `unit` に単位を表す文字列を,
!> または `unit_symbol` に単位を表すシンボルを与えてください.
!>
!> `unit` に指定できるのは以下の文字列です. (大文字小文字は区別しません).
!>
!> | 単位       | 文字列                       |
!> |------------|------------------------------|
!> | 年         | dc_date_types#UNIT_YEAR      |
!> | 月         | dc_date_types#UNIT_MONTH     |
!> | 日         | dc_date_types#UNIT_DAY       |
!> | 時         | dc_date_types#UNIT_HOUR      |
!> | 分         | dc_date_types#UNIT_MIN       |
!> | 秒         | dc_date_types#UNIT_SEC       |
!> | 無次元時間 | dc_date_types#UNIT_NONDIM    |
!>
!> これらに該当しない文字列を `unit` に与えた場合, エラーを発生させます.
!>
!> `unit_symbol` に指定できるのは以下のシンボルです.
!>
!> | 単位       | シンボル                            |
!> |------------|-------------------------------------|
!> | 年         | dc_date_types#UNIT_SYMBOL_YEAR      |
!> | 月         | dc_date_types#UNIT_SYMBOL_MONTH     |
!> | 日         | dc_date_types#UNIT_SYMBOL_DAY       |
!> | 時         | dc_date_types#UNIT_SYMBOL_HOUR      |
!> | 分         | dc_date_types#UNIT_SYMBOL_MIN       |
!> | 秒         | dc_date_types#UNIT_SYMBOL_SEC       |
!> | 無次元時間 | dc_date_types#UNIT_SYMBOL_NONDIM    |
!>
!> これらに該当しないシンボルを `unit_symbol` に与えた場合,
!> エラーを発生させます.
!>
!> 引数 `err` を与えている場合には `err` に .true. が返り,
!> プログラムは続行します.
!>
!> @param[out] diff 生成される DC_DIFFTIME 変数
!> @param[in] value 値
!> @param[in] unit 単位文字列
!> @param[in] unit_symbol 単位シンボル
!> @param[out] err 例外処理用フラグ
!> @endja
subroutine dcdifftimecreate2d(diff, value, unit, unit_symbol, err)
  use dc_types, only: dp, string
  use dc_trace, only: beginsub, endsub
  use dc_error, only: storeerror, dc_ebadunit, dc_noerr
  use dc_string, only: strieq
  use dc_date_generic, only: dcdifftimecreate, parsetimeunits
  use dc_date_types, only: dc_difftime, &
    & unit_symbol_year, unit_symbol_month, unit_symbol_day, &
    & unit_symbol_hour, unit_symbol_min, unit_symbol_sec, unit_symbol_nondim, &
    & unit_symbol_err, &
    & min_seconds, hour_seconds, day_seconds, cyclic_mdays, year_months
  use dc_scaledsec, only: dc_scaled_sec, &
    & assignment(=), dcscaledsecputline, &
    & operator(==), operator(>), operator(<), operator(>=), operator(<=), &
    & operator(+), operator(-), operator(*), operator(/), mod, modulo, &
    & abs, int, sign, floor
  implicit none
  type(dc_difftime), intent(out) :: diff
  real(DP), intent(in) :: value
  character(*), intent(in) :: unit
  integer, intent(in), optional :: unit_symbol
  logical, intent(out), optional :: err
 
  real(DP):: essec
  integer :: esmon, esday
  integer :: stat, val_int
  type(dc_scaled_sec):: val_scl, val_dec
  character(STRING) :: cause_c
  integer:: symbol
 
  character(*), parameter :: subname = 'DCDiffTimeCreate2'
continue
  call beginsub(subname, 'value=%f', d=(/value/))
  stat = dc_noerr
  cause_c = ''
  symbol = unit_symbol_err
  if ( present(unit_symbol) ) then
    symbol = unit_symbol
  else
    symbol = parsetimeunits(unit)
  end if
 
  if ( symbol == unit_symbol_sec ) then
    call dcdifftimecreate(diff, sec=value)
    goto 999
  elseif ( symbol == unit_symbol_nondim ) then
    call dcdifftimecreate(diff, nondim=value)
    goto 999
  end if
 
  val_int = int(value)
  val_scl = int(value)
  val_dec = value - int(value)
 
  if ( symbol == unit_symbol_min ) then
    call dcdifftimecreate(diff, min = val_int, sclsec = val_dec * min_seconds)
  elseif ( symbol == unit_symbol_hour ) then
    call dcdifftimecreate(diff, hour = val_int, sclsec = val_dec * hour_seconds)
  elseif ( symbol == unit_symbol_day ) then
    call dcdifftimecreate(diff, sclday = val_scl, sclsec = val_dec * day_seconds)
  elseif ( symbol == unit_symbol_month ) then
    call dcdifftimecreate(diff, sclmon = val_scl, &
      & sclsec = int(val_dec * cyclic_mdays) * day_seconds)
  elseif ( symbol == unit_symbol_year ) then
    call dcdifftimecreate(diff, sclyear = val_scl, &
      & sclsec = int(val_dec * cyclic_mdays * year_months) * day_seconds)
  else
    stat = dc_ebadunit
    cause_c = unit
  end if
 
999 continue
  call storeerror(stat, subname, err, cause_c)
  esmon = diff % mon ; esday = diff % day ; essec = diff % sec
  call endsub(subname, 'diff (mon=%d, day=%d, sec=%f)', &
    & i=(/esmon, esday/), d=(/essec/))
end subroutine dcdifftimecreate2d
 
!> @en
!> @brief Create DC_DIFFTIME type variable with single precision value and unit
!> @param[out] diff Created DC_DIFFTIME variable
!> @param[in] value Value (single precision)
!> @param[in] unit Unit string
!> @param[in] unit_symbol Unit symbol
!> @param[out] err Exception handling flag
!> @enden
!>
!> @ja
!> @brief 単精度値と単位から DC_DIFFTIME 型変数を生成
!> @param[out] diff 生成される DC_DIFFTIME 変数
!> @param[in] value 値 (単精度)
!> @param[in] unit 単位文字列
!> @param[in] unit_symbol 単位シンボル
!> @param[out] err 例外処理用フラグ
!> @endja
subroutine dcdifftimecreate2r(diff, value, unit, unit_symbol, err)
  use dc_types, only: dp
  use dc_date_generic, only: dcdifftimecreate
  use dc_date_types, only: dc_difftime
  implicit none
  type(dc_difftime), intent(out) :: diff
  real, intent(in) :: value
  character(*), intent(in) :: unit
  integer, intent(in), optional :: unit_symbol
  logical, intent(out), optional :: err
continue
  call dcdifftimecreate(diff, real( value, dp ), unit, unit_symbol, err)
end subroutine dcdifftimecreate2r
 
!> @en
!> @brief Create DC_DIFFTIME type variable with integer value and unit
!> @param[out] diff Created DC_DIFFTIME variable
!> @param[in] value Value (integer)
!> @param[in] unit Unit string
!> @param[in] unit_symbol Unit symbol
!> @param[out] err Exception handling flag
!> @enden
!>
!> @ja
!> @brief 整数値と単位から DC_DIFFTIME 型変数を生成
!> @param[out] diff 生成される DC_DIFFTIME 変数
!> @param[in] value 値 (整数)
!> @param[in] unit 単位文字列
!> @param[in] unit_symbol 単位シンボル
!> @param[out] err 例外処理用フラグ
!> @endja
subroutine dcdifftimecreate2i(diff, value, unit, unit_symbol, err)
  use dc_types, only: dp
  use dc_date_generic, only: dcdifftimecreate
  use dc_date_types, only: dc_difftime
  implicit none
  type(dc_difftime), intent(out) :: diff
  integer, intent(in) :: value
  character(*), intent(in) :: unit
  integer, intent(in), optional :: unit_symbol
  logical, intent(out), optional :: err
continue
  call dcdifftimecreate(diff, real( value, dp ), unit, unit_symbol, err)
end subroutine dcdifftimecreate2i
 
!> @en
!> @brief Create DC_DATETIME type variable with integer seconds
!> @details
!> Create dc_date_types#DC_DATETIME type variable.
!> Specify seconds with `sec` argument.
!> Use Create for year/month/day/hour/minute specification.
!>
!> @param[out] time Created DC_DATETIME variable
!> @param[in] sec Seconds (integer)
!> @enden
!>
!> @ja
!> @brief 整数秒数から DC_DATETIME 型変数を生成
!> @details
!> dc_date_types#DC_DATETIME 型変数の生成を行います.
!> 引数 `sec` には秒数を与えてください. 年月日, 時分を使って
!> 指定を行いたい場合は Create を利用してください.
!>
!> @param[out] time 生成される DC_DATETIME 変数
!> @param[in] sec 秒数 (整数)
!> @endja
subroutine dcdatetimecreatei(time, sec)
  use dc_types, only: dp
  use dc_date_types, only: dc_datetime
  use dc_date_generic, only: dcdatetimecreate
  use dc_scaledsec, only: dc_scaled_sec, assignment(=)
  implicit none
  type(dc_datetime), intent(out):: time
  integer, intent(in):: sec
continue
  call dcdatetimecreate(time, sec = real(sec, dp) )
end subroutine dcdatetimecreatei
 
!> @en
!> @brief Create DC_DATETIME type variable with single precision seconds
!> @details
!> Create dc_date_types#DC_DATETIME type variable.
!> Specify seconds with `sec` argument.
!> Use Create for year/month/day/hour/minute specification.
!>
!> @param[out] time Created DC_DATETIME variable
!> @param[in] sec Seconds (single precision)
!> @enden
!>
!> @ja
!> @brief 単精度秒数から DC_DATETIME 型変数を生成
!> @details
!> dc_date_types#DC_DATETIME 型変数の生成を行います.
!> 引数 `sec` には秒数を与えてください. 年月日, 時分を使って
!> 指定を行いたい場合は Create を利用してください.
!>
!> @param[out] time 生成される DC_DATETIME 変数
!> @param[in] sec 秒数 (単精度)
!> @endja
subroutine dcdatetimecreater(time, sec)
  use dc_types, only: dp
  use dc_date_types, only: dc_datetime
  use dc_date_generic, only: dcdatetimecreate
  use dc_scaledsec, only: dc_scaled_sec, assignment(=)
  implicit none
  type(dc_datetime), intent(out):: time
  real, intent(in):: sec
continue
  call dcdatetimecreate(time, sec = real(sec, dp) )
end subroutine dcdatetimecreater
 
!> @en
!> @brief Create DC_DATETIME type variable with double precision seconds
!> @param[out] time Created DC_DATETIME variable
!> @param[in] sec Seconds (double precision)
!> @enden
!>
!> @ja
!> @brief 倍精度秒数から DC_DATETIME 型変数を生成
!> @param[out] time 生成される DC_DATETIME 変数
!> @param[in] sec 秒数 (倍精度)
!> @endja
subroutine dcdatetimecreated(time, sec)
  use dc_types, only: dp
  use dc_date_types, only: dc_datetime
  use dc_date_generic, only: dcdatetimecreate
  use dc_scaledsec, only: dc_scaled_sec, assignment(=)
  implicit none
  type(dc_datetime), intent(out):: time
  real(DP), intent(in):: sec
continue
  call dcdatetimecreate(time, sec = sec)
end subroutine dcdatetimecreated
 
!> @en
!> @brief Create DC_DIFFTIME type variable with integer seconds
!> @details
!> Create dc_date_types#DC_DIFFTIME type variable.
!> Specify seconds with `sec` argument.
!> Use Create for year/month/day/hour/minute specification.
!>
!> @param[out] diff Created DC_DIFFTIME variable
!> @param[in] sec Seconds (integer)
!> @enden
!>
!> @ja
!> @brief 整数秒数から DC_DIFFTIME 型変数を生成
!> @details
!> dc_date_types#DC_DIFFTIME 型変数の生成を行います.
!> 引数 `sec` には秒数を与えてください. 年月日, 時分を使って
!> 指定を行いたい場合は Create を利用してください.
!>
!> @param[out] diff 生成される DC_DIFFTIME 変数
!> @param[in] sec 秒数 (整数)
!> @endja
subroutine dcdifftimecreatei(diff, sec)
  use dc_types, only: dp
  use dc_date_types, only: dc_difftime
  use dc_date_generic, only: dcdifftimecreate
  use dc_scaledsec, only: dc_scaled_sec, assignment(=)
  implicit none
  type(dc_difftime), intent(out):: diff
  integer, intent(in):: sec
continue
  call dcdifftimecreate(diff, sec = real(sec, dp) )
end subroutine dcdifftimecreatei
 
!> @en
!> @brief Create DC_DIFFTIME type variable with single precision seconds
!> @details
!> Create dc_date_types#DC_DIFFTIME type variable.
!> Specify seconds with `sec` argument.
!> Use Create for year/month/day/hour/minute specification.
!>
!> @param[out] diff Created DC_DIFFTIME variable
!> @param[in] sec Seconds (single precision)
!> @enden
!>
!> @ja
!> @brief 単精度秒数から DC_DIFFTIME 型変数を生成
!> @details
!> dc_date_types#DC_DIFFTIME 型変数の生成を行います.
!> 引数 `sec` には秒数を与えてください. 年月日, 時分を使って
!> 指定を行いたい場合は Create を利用してください.
!>
!> @param[out] diff 生成される DC_DIFFTIME 変数
!> @param[in] sec 秒数 (単精度)
!> @endja
subroutine dcdifftimecreater(diff, sec)
  use dc_types, only: dp
  use dc_date_types, only: dc_difftime
  use dc_date_generic, only: dcdifftimecreate
  use dc_scaledsec, only: dc_scaled_sec, assignment(=)
  implicit none
  type(dc_difftime), intent(out):: diff
  real, intent(in):: sec
continue
  call dcdifftimecreate(diff, sec = real(sec, dp) )
end subroutine dcdifftimecreater
 
!> @en
!> @brief Create DC_DIFFTIME type variable with double precision seconds
!> @param[out] diff Created DC_DIFFTIME variable
!> @param[in] sec Seconds (double precision)
!> @enden
!>
!> @ja
!> @brief 倍精度秒数から DC_DIFFTIME 型変数を生成
!> @param[out] diff 生成される DC_DIFFTIME 変数
!> @param[in] sec 秒数 (倍精度)
!> @endja
subroutine dcdifftimecreated(diff, sec)
  use dc_types, only: dp
  use dc_date_types, only: dc_difftime
  use dc_date_generic, only: dcdifftimecreate
  use dc_scaledsec, only: dc_scaled_sec, assignment(=)
  implicit none
  type(dc_difftime), intent(out):: diff
  real(DP), intent(in):: sec
continue
  call dcdifftimecreate(diff, sec = sec)
end subroutine dcdifftimecreated
 
 
!-----------------------------------------------
! For backward compatibility
!> @en
!> @brief Create DC_DATETIME (backward compatibility)
!> @enden
!> @ja
!> @brief DC_DATETIME 生成 (後方互換用)
!> @endja
subroutine dcdatetimecreate1_bc(time, &
  & year, mon, day, hour, min, sec, &
  & zone, caltype, day_seconds, err)
  use dc_types, only: dp
  use dc_date_types, only: dc_datetime
  use dc_date_generic, only: dcdatetimecreate
  type(dc_datetime), intent(out):: time
  integer, intent(in), optional:: year, mon, day, hour, min
  real(DP),intent(in), optional:: sec, day_seconds
  character(*), intent(in), optional :: zone
  integer, intent(in), optional:: caltype
  logical, intent(out), optional:: err
continue
  call dcdatetimecreate( time, &
    & year, mon, day, hour, min, sec, &
    & zone, caltype, day_seconds = day_seconds, err = err )
end subroutine dcdatetimecreate1_bc
 
!> @en
!> @brief Create DC_DIFFTIME (backward compatibility)
!> @enden
!> @ja
!> @brief DC_DIFFTIME 生成 (後方互換用)
!> @endja
subroutine dcdifftimecreate1_bc(diff, &
  & year, mon, day, hour, min, sec, day_seconds)
  use dc_types, only: dp
  use dc_date_types, only: dc_difftime
  use dc_date_generic, only: dcdifftimecreate
  type(dc_difftime), intent(out) :: diff
  integer, intent(in), optional:: year, mon, day, hour, min
  real(DP),intent(in), optional:: sec, day_seconds
continue
  call dcdifftimecreate( diff, &
    & year, mon, day, hour, min, sec, day_seconds )
end subroutine dcdifftimecreate1_bc
 
!> @en
!> @brief Create DC_DIFFTIME with value and unit (backward compatibility)
!> @enden
!> @ja
!> @brief 値と単位から DC_DIFFTIME 生成 (後方互換用)
!> @endja
subroutine dcdifftimecreate2_bc(diff, value, unit, err)
  use dc_types, only: dp
  use dc_date_types, only: dc_difftime
  use dc_date_generic, only: dcdifftimecreate
  type(dc_difftime), intent(out) :: diff
  real(DP), intent(in) :: value
  character(*), intent(in) :: unit
  logical, intent(out), optional :: err
continue
  call dcdifftimecreate( diff, value, unit, err = err )
end subroutine dcdifftimecreate2_bc