Format for output a 2-part Julian Date (or in the case of UTC a quasi-JD form that includes special provision for leap seconds).
Status: support routine.
SCALE identifies the time scale. Only the value 'UTC' (in upper case) is significant, and enables handling of leap seconds (see Note 4).
NDP is the number of decimal places in the seconds field, and can have negative as well as positive values, such as:
NDP resolution -4 1 00 00 -3 0 10 00 -2 0 01 00 -1 0 00 10 0 0 00 01 1 0 00 00.1 2 0 00 00.01 3 0 00 00.001
The limits are platform dependent, but a safe range is -5 to +9.
D1+D2 is Julian Date, apportioned in any convenient way between the two arguments, for example where D1 is the Julian Day Number and D2 is the fraction of a day. In the case of UTC, where the use of JD is problematical, special conventions apply: see the next note.
JD cannot unambiguously represent UTC during a leap second unless special measures are taken. The SOFA internal convention is that the quasi-JD day represents UTC days whether the length is 86399, 86400 or 86401 SI seconds. In the 1960-1972 era there were smaller jumps (in either direction) each time the linear UTC(TAI) expression was changed, and these "mini-leaps" are also included in the SOFA convention.
The warning status "dubious year" flags UTCs that predate the introduction of the time scale or that are too far in the future to be trusted. See DAT for further details.
For calendar conventions and limitations, see CAL2JD.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character(len=*), | intent(in) | :: | scale | time scale ID (Note 1) |
||
| integer, | intent(in) | :: | ndp | resolution (Note 2) |
||
| real(kind=wp), | intent(in) | :: | d1 | time as a 2-part Julian Date (Notes 3,4) |
||
| real(kind=wp), | intent(in) | :: | d2 | time as a 2-part Julian Date (Notes 3,4) |
||
| integer, | intent(out) | :: | iy | year in Gregorian calendar (Note 5) |
||
| integer, | intent(out) | :: | im | month in Gregorian calendar (Note 5) |
||
| integer, | intent(out) | :: | id | day in Gregorian calendar (Note 5) |
||
| integer, | intent(out), | dimension(4) | :: | ihmsf | hours, minutes, seconds, fraction (Note 1) |
|
| integer, | intent(out) | :: | j |
|
subroutine D2DTF ( scale, ndp, d1, d2, iy, im, id, ihmsf, j )
implicit none
character(len=*),intent(in) :: scale !! time scale ID (Note 1)
integer,intent(in) :: ndp !! resolution (Note 2)
real(wp),intent(in) :: d1 !! time as a 2-part Julian Date (Notes 3,4)
real(wp),intent(in) :: d2 !! time as a 2-part Julian Date (Notes 3,4)
integer,intent(out) :: iy !! year in Gregorian calendar (Note 5)
integer,intent(out) :: im !! month in Gregorian calendar (Note 5)
integer,intent(out) :: id !! day in Gregorian calendar (Note 5)
integer,dimension(4),intent(out) :: ihmsf !! hours, minutes, seconds, fraction (Note 1)
integer,intent(out) :: j !! status:
!! * +1 = dubious year (Note 5)
!! * 0 = OK
!! * -1 = unacceptable date (Note 6)
logical :: leap
character(len=1) :: s
integer :: iy1, im1, id1, js, iy2, im2, id2, ihmsf1(4), i
real(wp) :: a1, b1, fd, dat0, dat12, w, dat24, dleap
main : block
! The two-part JD.
a1 = d1
b1 = d2
! Provisional calendar date.
call JD2CAL ( a1, b1, iy1, im1, id1, fd, js )
if ( js/=0 ) exit main
! Is this a leap second day?
leap = .false.
if ( scale=='UTC' ) then
! TAI-UTC at 0h today.
call DAT ( iy1, im1, id1, 0.0_wp, dat0, js )
if ( js<0 ) exit main
! TAI-UTC at 12h today (to detect drift).
call DAT ( iy1, im1, id1, 0.5_wp, dat12, js )
if ( js<0 ) exit main
! TAI-UTC at 0h tomorrow (to detect jumps).
call JD2CAL ( a1+1.5_wp, b1-fd, iy2, im2, id2, w, js )
if ( js/=0 ) exit main
call DAT ( iy2, im2, id2, 0.0_wp, dat24, js )
if ( js<0 ) exit main
! Any sudden change in TAI-UTC (seconds).
dleap = dat24 - ( 2.0_wp * dat12 - dat0 )
! If leap second day, scale the fraction of a day into SI.
leap = dleap/=0.0_wp
if ( leap ) fd = fd + fd*dleap/d2s
end if
! Provisional time of day.
call D2TF ( ndp, fd, s, ihmsf1 )
! Has the (rounded) time gone past 24h?
if ( ihmsf1(1)>23 ) then
! Yes. We probably need tomorrow's calendar date.
call JD2CAL ( a1+1.5_wp, b1-fd, iy2, im2, id2, w, js )
if ( js<0 ) exit main
! Is today a leap second day?
if ( .not. leap ) then
! No. Use 0h tomorrow.
iy1 = iy2
im1 = im2
id1 = id2
ihmsf1(1) = 0
ihmsf1(2) = 0
ihmsf1(3) = 0
else
! Yes. Are we past the leap second itself?
if ( ihmsf1(3)>0 ) then
! Yes. Use tomorrow but allow for the leap second.
iy1 = iy2
im1 = im2
id1 = id2
ihmsf1(1) = 0
ihmsf1(2) = 0
ihmsf1(3) = 0
else
! No. Use 23 59 60... today.
ihmsf1(1) = 23
ihmsf1(2) = 59
ihmsf1(3) = 60
end if
! If rounding to 10s or coarser always go up to new day.
if ( ndp<0 .and. ihmsf1(3)==60 ) then
iy1 = iy2
im1 = im2
id1 = id2
ihmsf1(1) = 0
ihmsf1(2) = 0
ihmsf1(3) = 0
end if
end if
end if
! Results.
iy = iy1
im = im1
id = id1
do i=1,4
ihmsf(i) = ihmsf1(i)
end do
end block main
! Status.
j = js
end subroutine D2DTF