! ! Earth System Modeling Framework ! Copyright 2002-2003, University Corporation for Atmospheric Research, ! Massachusetts Institute of Technology, Geophysical Fluid Dynamics ! Laboratory, University of Michigan, National Centers for Environmental ! Prediction, Los Alamos National Laboratory, Argonne National Laboratory, ! NASA Goddard Space Flight Center. ! Licensed under the University of Illinois-NCSA license. ! !============================================================================== ! ! ESMF Time Module module ESMF_TimeMod ! !============================================================================== ! ! This file contains the Time class definition and all Time class methods. ! !------------------------------------------------------------------------------ ! INCLUDES ! Note that MAX_ALARMS must match MAX_WRF_ALARMS defined in ! ../../frame/module_domain.F !!! Eliminate this dependence with ! grow-as-you-go AlarmList in ESMF_Clock... ! TBH: TODO: Hook this into the WRF build so WRF can use either "no-leap" or ! TBH: Gregorian calendar. Now WRF is hard-wired to use Gregorian. !#undef NO_LEAP_CALENDAR !#ifdef COUP_CSM !#define NO_LEAP_CALENDAR !#endif ! TBH: When NO_DT_COMPONENT_INIT is set, code that uses F95 compile-time ! TBH: initialization of components of derived types is not included. ! TBH: Some older compilers like PGI 5.x do not support this F95 ! TBH: feature. !#ifdef NO_LEAP_CALENDAR !#undef NO_DT_COMPONENT_INIT !#else !#define NO_DT_COMPONENT_INIT !#endif !============================================================================== !BOPI ! !MODULE: ESMF_TimeMod ! ! !DESCRIPTION: ! Part of Time Manager F90 API wrapper of C++ implemenation ! ! Defines F90 wrapper entry points for corresponding ! C++ class {\tt ESMC\_Time} implementation ! ! See {\tt ../include/ESMC\_Time.h} for complete description ! !------------------------------------------------------------------------------ ! !USES: ! inherit from ESMF base class use ESMF_BaseMod ! inherit from base time class use ESMF_BaseTimeMod ! associated derived types use ESMF_TimeIntervalMod use ESMF_CalendarMod use ESMF_Stubs implicit none ! !------------------------------------------------------------------------------ ! !PRIVATE TYPES: private !------------------------------------------------------------------------------ ! ! ESMF_Time ! ! ! F90 class type to match C++ Time class in size only; ! ! all dereferencing within class is performed by C++ implementation type ESMF_Time type(ESMF_BaseTime) :: basetime ! inherit base class ! time instant is expressed as year + basetime integer :: YR type(ESMF_Calendar), pointer :: calendar ! associated calendar end type !------------------------------------------------------------------------------ ! !PUBLIC TYPES: public ESMF_Time !------------------------------------------------------------------------------ ! ! !PUBLIC MEMBER FUNCTIONS: public ESMF_TimeGet public ESMF_TimeSet ! Required inherited and overridden ESMF_Base class methods public ESMF_TimeCopy ! !PRIVATE MEMBER FUNCTIONS: private ESMF_TimeGetDayOfYear private ESMF_TimeGetDayOfYearInteger ! Inherited and overloaded from ESMF_BaseTime ! NOTE: ESMF_TimeInc, ESMF_TimeDec, ESMF_TimeDiff, ESMF_TimeEQ, ! ESMF_TimeNE, ESMF_TimeLT, ESMF_TimeGT, ESMF_TimeLE, and ! ESMF_TimeGE are PUBLIC only to work around bugs in the ! PGI 5.1-x compilers. They should all be PRIVATE. public operator(+) public ESMF_TimeInc public operator(-) public ESMF_TimeDec public ESMF_TimeDec2 public ESMF_TimeDiff public operator(.EQ.) public ESMF_TimeEQ public operator(.NE.) public ESMF_TimeNE public operator(.LT.) public ESMF_TimeLT public operator(.GT.) public ESMF_TimeGT public operator(.LE.) public ESMF_TimeLE public operator(.GE.) public ESMF_TimeGE !EOPI !============================================================================== ! ! INTERFACE BLOCKS ! !============================================================================== !BOP ! !INTERFACE: interface ESMF_TimeGetDayOfYear ! !PRIVATE MEMBER FUNCTIONS: module procedure ESMF_TimeGetDayOfYearInteger ! !DESCRIPTION: ! This interface overloads the {\tt ESMF\_GetDayOfYear} method ! for the {\tt ESMF\_Time} class ! !EOP end interface ! !------------------------------------------------------------------------------ !BOP ! !INTERFACE: interface operator(+) ! !PRIVATE MEMBER FUNCTIONS: module procedure ESMF_TimeInc, ESMF_TimeInc2 ! !DESCRIPTION: ! This interface overloads the + operator for the {\tt ESMF\_Time} class ! !EOP end interface ! !------------------------------------------------------------------------------ !BOP ! !INTERFACE: interface assignment (=) ! !PRIVATE MEMBER FUNCTIONS: module procedure ESMF_TimeCopy ! !DESCRIPTION: ! This interface overloads the = operator for the {\tt ESMF\_Time} class ! !EOP end interface ! !------------------------------------------------------------------------------ !BOP ! !INTERFACE: interface operator(-) ! !PRIVATE MEMBER FUNCTIONS: module procedure ESMF_TimeDec, ESMF_TimeDec2 ! !DESCRIPTION: ! This interface overloads the - operator for the {\tt ESMF\_Time} class ! !EOP end interface ! !------------------------------------------------------------------------------ !BOP ! !INTERFACE: interface operator(-) ! !PRIVATE MEMBER FUNCTIONS: module procedure ESMF_TimeDiff ! !DESCRIPTION: ! This interface overloads the - operator for the {\tt ESMF\_Time} class ! !EOP end interface ! !------------------------------------------------------------------------------ !BOP ! !INTERFACE: interface operator(.EQ.) ! !PRIVATE MEMBER FUNCTIONS: module procedure ESMF_TimeEQ ! !DESCRIPTION: ! This interface overloads the .EQ. operator for the {\tt ESMF\_Time} class ! !EOP end interface ! !------------------------------------------------------------------------------ !BOP ! !INTERFACE: interface operator(.NE.) ! !PRIVATE MEMBER FUNCTIONS: module procedure ESMF_TimeNE ! !DESCRIPTION: ! This interface overloads the .NE. operator for the {\tt ESMF\_Time} class ! !EOP end interface ! !------------------------------------------------------------------------------ !BOP ! !INTERFACE: interface operator(.LT.) ! !PRIVATE MEMBER FUNCTIONS: module procedure ESMF_TimeLT ! !DESCRIPTION: ! This interface overloads the .LT. operator for the {\tt ESMF\_Time} class ! !EOP end interface ! !------------------------------------------------------------------------------ !BOP ! !INTERFACE: interface operator(.GT.) ! !PRIVATE MEMBER FUNCTIONS: module procedure ESMF_TimeGT ! !DESCRIPTION: ! This interface overloads the .GT. operator for the {\tt ESMF\_Time} class ! !EOP end interface ! !------------------------------------------------------------------------------ !BOP ! !INTERFACE: interface operator(.LE.) ! !PRIVATE MEMBER FUNCTIONS: module procedure ESMF_TimeLE ! !DESCRIPTION: ! This interface overloads the .LE. operator for the {\tt ESMF\_Time} class ! !EOP end interface ! !------------------------------------------------------------------------------ !BOP ! !INTERFACE: interface operator(.GE.) ! !PRIVATE MEMBER FUNCTIONS: module procedure ESMF_TimeGE ! !DESCRIPTION: ! This interface overloads the .GE. operator for the {\tt ESMF\_Time} class ! !EOP end interface ! !------------------------------------------------------------------------------ !============================================================================== contains !============================================================================== ! ! Generic Get/Set routines which use F90 optional arguments ! !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_TimeGet - Get value in user-specified units ! !INTERFACE: subroutine ESMF_TimeGet(time, YY, YRl, MM, DD, D, Dl, H, M, S, Sl, MS, & US, NS, d_, h_, m_, s_, ms_, us_, ns_, Sn, Sd, & dayOfYear, dayOfYear_r8, dayOfYear_intvl, & timeString, rc) ! !ARGUMENTS: type(ESMF_Time), intent(in) :: time integer, intent(out), optional :: YY integer(ESMF_KIND_I8), intent(out), optional :: YRl integer, intent(out), optional :: MM integer, intent(out), optional :: DD integer, intent(out), optional :: D integer(ESMF_KIND_I8), intent(out), optional :: Dl integer, intent(out), optional :: H integer, intent(out), optional :: M integer, intent(out), optional :: S integer(ESMF_KIND_I8), intent(out), optional :: Sl integer, intent(out), optional :: MS integer, intent(out), optional :: US integer, intent(out), optional :: NS double precision, intent(out), optional :: d_ double precision, intent(out), optional :: h_ double precision, intent(out), optional :: m_ double precision, intent(out), optional :: s_ double precision, intent(out), optional :: ms_ double precision, intent(out), optional :: us_ double precision, intent(out), optional :: ns_ integer, intent(out), optional :: Sn integer, intent(out), optional :: Sd integer, intent(out), optional :: dayOfYear ! dayOfYear_r8 = 1.0 at 0Z on 1 January, 1.5 at 12Z on ! 1 January, etc. real(ESMF_KIND_R8), intent(out), optional :: dayOfYear_r8 character (len=*), intent(out), optional :: timeString type(ESMF_TimeInterval), intent(out), optional :: dayOfYear_intvl integer, intent(out), optional :: rc type(ESMF_TimeInterval) :: day_step integer :: ierr ! !DESCRIPTION: ! Get the value of the {\tt ESMF\_Time} in units specified by the user ! via F90 optional arguments. ! ! Time manager represents and manipulates time internally with integers ! to maintain precision. Hence, user-specified floating point values are ! converted internally from integers. ! ! See {\tt ../include/ESMC\_BaseTime.h and ../include/ESMC\_Time.h} for ! complete description. ! ! The arguments are: ! \begin{description} ! \item[time] ! The object instance to query ! \item[{[YY]}] ! Integer year CCYR (>= 32-bit) ! \item[{[YRl]}] ! Integer year CCYR (large, >= 64-bit) ! \item[{[MM]}] ! Integer month 1-12 ! \item[{[DD]}] ! Integer day of the month 1-31 ! \item[{[D]}] ! Integer Julian days (>= 32-bit) ! \item[{[Dl]}] ! Integer Julian days (large, >= 64-bit) ! \item[{[H]}] ! Integer hours ! \item[{[M]}] ! Integer minutes ! \item[{[S]}] ! Integer seconds (>= 32-bit) ! \item[{[Sl]}] ! Integer seconds (large, >= 64-bit) ! \item[{[MS]}] ! Integer milliseconds ! \item[{[US]}] ! Integer microseconds ! \item[{[NS]}] ! Integer nanoseconds ! \item[{[d\_]}] ! Double precision days ! \item[{[h\_]}] ! Double precision hours ! \item[{[m\_]}] ! Double precision minutes ! \item[{[s\_]}] ! Double precision seconds ! \item[{[ms\_]}] ! Double precision milliseconds ! \item[{[us\_]}] ! Double precision microseconds ! \item[{[ns\_]}] ! Double precision nanoseconds ! \item[{[Sn]}] ! Integer fractional seconds - numerator ! \item[{[Sd]}] ! Integer fractional seconds - denominator ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG2.1, TMG2.5.1, TMG2.5.6 !EOP TYPE(ESMF_Time) :: begofyear INTEGER :: year, month, dayofmonth, hour, minute, second REAL(ESMF_KIND_R8) :: rsec ierr = ESMF_SUCCESS IF ( PRESENT( YY ) ) THEN YY = time%YR ENDIF IF ( PRESENT( MM ) ) THEN CALL timegetmonth( time, MM ) ENDIF IF ( PRESENT( DD ) ) THEN CALL timegetdayofmonth( time, DD ) ENDIF ! !$$$ Push HMS down into ESMF_BaseTime from EVERYWHERE !$$$ and THEN add ESMF scaling behavior when other args are present... IF ( PRESENT( H ) ) THEN H = mod( time%basetime%S, 86400_ESMF_KIND_I8 ) / 3600_ESMF_KIND_I8 ENDIF IF ( PRESENT( M ) ) THEN M = mod( time%basetime%S, 3600_ESMF_KIND_I8) / 60_ESMF_KIND_I8 ENDIF IF ( PRESENT( S ) ) THEN S = mod( time%basetime%S, 60_ESMF_KIND_I8 ) ENDIF ! TBH: HACK to allow DD and S to behave as in ESMF 2.1.0+ when ! TBH: both are present and H and M are not. IF ( PRESENT( S ) .AND. PRESENT( DD ) ) THEN IF ( ( .NOT. PRESENT( H ) ) .AND. ( .NOT. PRESENT( M ) ) ) THEN S = mod( time%basetime%S, 86400_ESMF_KIND_I8 ) ENDIF ENDIF IF ( PRESENT( MS ) ) THEN IF ( time%basetime%Sd /= 0 ) THEN MS = NINT( ( time%basetime%Sn*1.0D0 / time%basetime%Sd*1.0D0 ) * 1000.0D0 ) ELSE MS = 0 ENDIF ENDIF IF ( PRESENT( Sd ) .AND. PRESENT( Sn ) ) THEN Sd = time%basetime%Sd Sn = time%basetime%Sn ENDIF IF ( PRESENT( dayOfYear ) ) THEN CALL ESMF_TimeGetDayOfYear( time, dayOfYear, rc=ierr ) ENDIF IF ( PRESENT( dayOfYear_r8 ) ) THEN ! 64-bit IEEE 754 has 52-bit mantisssa -- only need 25 bits to hold ! number of seconds in a year... rsec = REAL( time%basetime%S, ESMF_KIND_R8 ) IF ( time%basetime%Sd /= 0 ) THEN rsec = rsec + ( REAL( time%basetime%Sn, ESMF_KIND_R8 ) / & REAL( time%basetime%Sd, ESMF_KIND_R8 ) ) ENDIF dayOfYear_r8 = rsec / REAL( 86400_ESMF_KIND_I8, ESMF_KIND_R8 ) ! start at 1 dayOfYear_r8 = dayOfYear_r8 + 1.0_ESMF_KIND_R8 ENDIF IF ( PRESENT( timeString ) ) THEN ! This duplication for YMD is an optimization that avoids calling ! timegetmonth() and timegetdayofmonth() when it is not needed. year = time%YR CALL timegetmonth( time, month ) CALL timegetdayofmonth( time, dayofmonth ) !$$$ push HMS down into ESMF_BaseTime hour = mod( time%basetime%S, 86400_ESMF_KIND_I8 ) / 3600_ESMF_KIND_I8 minute = mod( time%basetime%S, 3600_ESMF_KIND_I8) / 60_ESMF_KIND_I8 second = mod( time%basetime%S, 60_ESMF_KIND_I8 ) CALL ESMFold_TimeGetString( year, month, dayofmonth, & hour, minute, second, timeString ) ENDIF IF ( PRESENT( dayOfYear_intvl ) ) THEN year = time%YR CALL ESMF_TimeSet( begofyear, yy=year, mm=1, dd=1, s=0, & calendar=time%calendar, rc=ierr ) IF ( ierr == ESMF_FAILURE)THEN rc = ierr RETURN END IF CALL ESMF_TimeIntervalSet( day_step, d=1, s=0, rc=ierr ) dayOfYear_intvl = time - begofyear + day_step ENDIF IF ( PRESENT( rc ) ) THEN rc = ierr ENDIF end subroutine ESMF_TimeGet !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_TimeSet - Initialize via user-specified unit set ! !INTERFACE: subroutine ESMF_TimeSet(time, YY, YRl, MM, DD, D, Dl, H, M, S, Sl, & MS, US, NS, d_, h_, m_, s_, ms_, us_, ns_, & Sn, Sd, calendar, rc) ! !ARGUMENTS: type(ESMF_Time), intent(inout) :: time integer, intent(in), optional :: YY integer(ESMF_KIND_I8), intent(in), optional :: YRl integer, intent(in), optional :: MM integer, intent(in), optional :: DD integer, intent(in), optional :: D integer(ESMF_KIND_I8), intent(in), optional :: Dl integer, intent(in), optional :: H integer, intent(in), optional :: M integer, intent(in), optional :: S integer(ESMF_KIND_I8), intent(in), optional :: Sl integer, intent(in), optional :: MS integer, intent(in), optional :: US integer, intent(in), optional :: NS double precision, intent(in), optional :: d_ double precision, intent(in), optional :: h_ double precision, intent(in), optional :: m_ double precision, intent(in), optional :: s_ double precision, intent(in), optional :: ms_ double precision, intent(in), optional :: us_ double precision, intent(in), optional :: ns_ integer, intent(in), optional :: Sn integer, intent(in), optional :: Sd type(ESMF_Calendar), intent(in), target, optional :: calendar integer, intent(out), optional :: rc ! locals INTEGER :: ierr ! !DESCRIPTION: ! Initializes a {\tt ESMF\_Time} with a set of user-specified units ! via F90 optional arguments. ! ! Time manager represents and manipulates time internally with integers ! to maintain precision. Hence, user-specified floating point values are ! converted internally to integers. ! ! See {\tt ../include/ESMC\_BaseTime.h and ../include/ESMC\_Time.h} for ! complete description. ! ! The arguments are: ! \begin{description} ! \item[time] ! The object instance to initialize ! \item[{[YY]}] ! Integer year CCYR (>= 32-bit) ! \item[{[YRl]}] ! Integer year CCYR (large, >= 64-bit) ! \item[{[MM]}] ! Integer month 1-12 ! \item[{[DD]}] ! Integer day of the month 1-31 ! \item[{[D]}] ! Integer Julian days (>= 32-bit) ! \item[{[Dl]}] ! Integer Julian days (large, >= 64-bit) ! \item[{[H]}] ! Integer hours ! \item[{[M]}] ! Integer minutes ! \item[{[S]}] ! Integer seconds (>= 32-bit) ! \item[{[Sl]}] ! Integer seconds (large, >= 64-bit) ! \item[{[MS]}] ! Integer milliseconds ! \item[{[US]}] ! Integer microseconds ! \item[{[NS]}] ! Integer nanoseconds ! \item[{[d\_]}] ! Double precision days ! \item[{[h\_]}] ! Double precision hours ! \item[{[m\_]}] ! Double precision minutes ! \item[{[s\_]}] ! Double precision seconds ! \item[{[ms\_]}] ! Double precision milliseconds ! \item[{[us\_]}] ! Double precision microseconds ! \item[{[ns\_]}] ! Double precision nanoseconds ! \item[{[Sn]}] ! Integer fractional seconds - numerator ! \item[{[Sd]}] ! Integer fractional seconds - denominator ! \item[{[cal]}] ! Associated {\tt Calendar} ! \item[{[tz]}] ! Associated timezone (hours offset from GMT, e.g. EST = -5) ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMGn.n.n !EOP ! PRINT *,DEBUG: BEGIN ESMF_TimeSet() !$$$ push this down into ESMF_BaseTime constructor time%basetime%S = 0 time%basetime%Sn = 0 time%basetime%Sd = 0 IF ( PRESENT( rc ) ) rc = ESMF_FAILURE time%YR = 0 IF ( PRESENT( YY ) ) THEN ! PRINT *,DEBUG: ESMF_TimeSet(): YY = ,YY time%YR = YY ENDIF IF ( PRESENT( MM ) ) THEN ! PRINT *,DEBUG: ESMF_TimeSet(): MM = ,MM CALL timeaddmonths( time, MM, ierr ) IF ( ierr == ESMF_FAILURE ) THEN IF ( PRESENT( rc ) ) THEN rc = ESMF_FAILURE RETURN ENDIF ENDIF ! PRINT *,DEBUG: ESMF_TimeSet(): back from timeaddmonths ENDIF IF ( PRESENT( DD ) ) THEN !$$$ no check for DD in range of days of month MM yet !$$$ Must separate D and DD for correct interface! ! PRINT *,DEBUG: ESMF_TimeSet(): DD = ,DD time%basetime%S = time%basetime%S + & ( 86400_ESMF_KIND_I8 * INT( (DD-1), ESMF_KIND_I8 ) ) ENDIF !$$$ push H,M,S,Sn,Sd,MS down into ESMF_BaseTime constructor IF ( PRESENT( H ) ) THEN ! PRINT *,DEBUG: ESMF_TimeSet(): H = ,H time%basetime%S = time%basetime%S + & ( 3600_ESMF_KIND_I8 * INT( H, ESMF_KIND_I8 ) ) ENDIF IF ( PRESENT( M ) ) THEN ! PRINT *,DEBUG: ESMF_TimeSet(): M = ,M time%basetime%S = time%basetime%S + & ( 60_ESMF_KIND_I8 * INT( M, ESMF_KIND_I8 ) ) ENDIF IF ( PRESENT( S ) ) THEN ! PRINT *,DEBUG: ESMF_TimeSet(): S = ,S time%basetime%S = time%basetime%S + & INT( S, ESMF_KIND_I8 ) ENDIF IF ( PRESENT( Sn ) .AND. ( .NOT. PRESENT( Sd ) ) ) THEN CALL wrf_error_fatal( & "ESMF_TimeSet: Must specify Sd if Sn is specified") ENDIF IF ( PRESENT( Sd ) .AND. PRESENT( MS ) ) THEN CALL wrf_error_fatal( & "ESMF_TimeSet: Must not specify both Sd and MS") ENDIF time%basetime%Sn = 0 time%basetime%Sd = 0 IF ( PRESENT( MS ) ) THEN ! PRINT *,DEBUG: ESMF_TimeSet(): MS = ,MS time%basetime%Sn = MS time%basetime%Sd = 1000_ESMF_KIND_I8 ELSE IF ( PRESENT( Sd ) ) THEN ! PRINT *,DEBUG: ESMF_TimeSet(): Sd = ,Sd time%basetime%Sd = Sd IF ( PRESENT( Sn ) ) THEN ! PRINT *,DEBUG: ESMF_TimeSet(): Sn = ,Sn time%basetime%Sn = Sn ENDIF ENDIF IF ( PRESENT(calendar) )THEN ! PRINT *,DEBUG: ESMF_TimeSet(): using passed-in calendar ! Note that the ugly hack of wrapping the call to ESMF_CalendarInitialized() ! inside this #ifdef is due to lack of support for compile-time initialization ! of components of Fortran derived types. Some older compilers like PGI 5.1-x ! do not support this F95 feature. In this case we only lose a safety check. IF ( .not. ESMF_CalendarInitialized( calendar ) )THEN call wrf_error_fatal( "Error:: ESMF_CalendarCreate not "// & "called on input Calendar") END IF time%Calendar => calendar ELSE ! PRINT *,DEBUG: ESMF_TimeSet(): using default calendar IF ( .not. ESMF_IsInitialized() )THEN call wrf_error_fatal( "Error:: ESMF_Initialize not called") END IF time%Calendar => defaultCal END IF ! PRINT *,DEBUG: ESMF_TimeSet(): calling normalize_time() !$$$DEBUG !IF ( time%basetime%Sd > 0 ) THEN ! PRINT *,DEBUG ESMF_TimeSet() before normalize: S,Sn,Sd = , & ! time%basetime%S, time%basetime%Sn, time%basetime%Sd !ENDIF !$$$END DEBUG CALL normalize_time( time ) !$$$DEBUG !IF ( time%basetime%Sd > 0 ) THEN ! PRINT *,DEBUG ESMF_TimeSet() after normalize: S,Sn,Sd = , & ! time%basetime%S, time%basetime%Sn, time%basetime%Sd !ENDIF !$$$END DEBUG ! PRINT *,DEBUG: ESMF_TimeSet(): back from normalize_time() IF ( PRESENT( rc ) ) THEN rc = ESMF_SUCCESS ENDIF end subroutine ESMF_TimeSet !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMFold_TimeGetString - Get time instant value in string format ! !INTERFACE: subroutine ESMFold_TimeGetString( year, month, dayofmonth, & hour, minute, second, TimeString ) ! !ARGUMENTS: integer, intent(in) :: year integer, intent(in) :: month integer, intent(in) :: dayofmonth integer, intent(in) :: hour integer, intent(in) :: minute integer, intent(in) :: second character*(*), intent(out) :: TimeString ! !DESCRIPTION: ! Convert {\tt ESMF\_Time}s value into ISO 8601 format YYYY-MM-DDThh:mm:ss ! ! The arguments are: ! \begin{description} ! \item[time] ! The object instance to convert ! \item[TimeString] ! The string to return ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG2.4.7 !EOP !PRINT *,DEBUG: ESMF_TimePrint(): YR,S,Sn,Sd = ,time%YR,time%basetime%S,time%basetime%Sn,time%basetime%Sd !PRINT *,DEBUG: ESMF_TimePrint(): year = ,year !PRINT *,DEBUG: ESMF_TimePrint(): month, dayofmonth = ,month,dayofmonth !PRINT *,DEBUG: ESMF_TimePrint(): hour = ,hour !PRINT *,DEBUG: ESMF_TimePrint(): minute = ,minute !PRINT *,DEBUG: ESMF_TimePrint(): second = ,second !$$$here... add negative sign for YR<0 !$$$here... add Sn, Sd ?? write(TimeString,FMT="(I4.4,'-',I2.2,'-',I2.2,'_',I2.2,':',I2.2,':',I2.2)") & year,month,dayofmonth,hour,minute,second end subroutine ESMFold_TimeGetString !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_TimeGetDayOfYearInteger - Get time instants day of the year as an integer value ! ! !INTERFACE: subroutine ESMF_TimeGetDayOfYearInteger(time, DayOfYear, rc) ! ! !ARGUMENTS: type(ESMF_Time), intent(in) :: time integer, intent(out) :: DayOfYear integer, intent(out), optional :: rc ! ! !DESCRIPTION: ! Get the day of the year the given {\tt ESMF\_Time} instant falls on ! (1-365). Returned as an integer value ! ! The arguments are: ! \begin{description} ! \item[time] ! The object instance to query ! \item[DayOfYear] ! The {\tt ESMF\_Time} instants day of the year (1-365) ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: !EOP ! requires that time be normalized !$$$ bug when Sn>0? test !$$$ add tests DayOfYear = ( time%basetime%S / 86400_ESMF_KIND_I8 ) + 1 IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS end subroutine ESMF_TimeGetDayOfYearInteger !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_TimeInc - Increment time instant with a time interval ! ! !INTERFACE: function ESMF_TimeInc(time, timeinterval) ! ! !RETURN VALUE: type(ESMF_Time) :: ESMF_TimeInc ! ! !ARGUMENTS: type(ESMF_Time), intent(in) :: time type(ESMF_TimeInterval), intent(in) :: timeinterval ! !LOCAL: integer :: rc ! ! !DESCRIPTION: ! Increment {\tt ESMF\_Time} instant with a {\tt ESMF\_TimeInterval}, ! return resulting {\tt ESMF\_Time} instant ! ! Maps overloaded (+) operator interface function to ! {\tt ESMF\_BaseTime} base class ! ! The arguments are: ! \begin{description} ! \item[time] ! The given {\tt ESMF\_Time} to increment ! \item[timeinterval] ! The {\tt ESMF\_TimeInterval} to add to the given {\tt ESMF\_Time} ! \end{description} ! ! !REQUIREMENTS: ! TMG1.5.4, TMG2.4.4, TMG2.4.5, TMG2.4.6, TMG5.1, TMG5.2, TMG7.2 !EOP ! copy ESMF_Time specific properties (e.g. calendar, timezone) ESMF_TimeInc = time ! call ESMC_BaseTime base class function call c_ESMC_BaseTimeSum(time, timeinterval, ESMF_TimeInc) end function ESMF_TimeInc ! ! this is added for certain compilers that dont deal with commutativity ! function ESMF_TimeInc2(timeinterval, time) type(ESMF_Time) :: ESMF_TimeInc2 type(ESMF_Time), intent(in) :: time type(ESMF_TimeInterval), intent(in) :: timeinterval ESMF_TimeInc2 = ESMF_TimeInc( time, timeinterval ) end function ESMF_TimeInc2 ! !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_TimeDec - Decrement time instant with a time interval ! ! !INTERFACE: function ESMF_TimeDec(time, timeinterval) ! ! !RETURN VALUE: type(ESMF_Time) :: ESMF_TimeDec ! ! !ARGUMENTS: type(ESMF_Time), intent(in) :: time type(ESMF_TimeInterval), intent(in) :: timeinterval ! !LOCAL: integer :: rc ! ! !DESCRIPTION: ! Decrement {\tt ESMF\_Time} instant with a {\tt ESMF\_TimeInterval}, ! return resulting {\tt ESMF\_Time} instant ! ! Maps overloaded (-) operator interface function to ! {\tt ESMF\_BaseTime} base class ! ! The arguments are: ! \begin{description} ! \item[time] ! The given {\tt ESMF\_Time} to decrement ! \item[timeinterval] ! The {\tt ESMF\_TimeInterval} to subtract from the given ! {\tt ESMF\_Time} ! \end{description} ! ! !REQUIREMENTS: ! TMG1.5.4, TMG2.4.4, TMG2.4.5, TMG2.4.6, TMG5.1, TMG5.2, TMG7.2 !EOP ! copy ESMF_Time specific properties (e.g. calendar, timezone) ESMF_TimeDec = time ! call ESMC_BaseTime base class function call c_ESMC_BaseTimeDec(time, timeinterval, ESMF_TimeDec) end function ESMF_TimeDec ! ! this is added for certain compilers that dont deal with commutativity ! function ESMF_TimeDec2(timeinterval, time) type(ESMF_Time) :: ESMF_TimeDec2 type(ESMF_Time), intent(in) :: time type(ESMF_TimeInterval), intent(in) :: timeinterval ESMF_TimeDec2 = ESMF_TimeDec( time, timeinterval ) end function ESMF_TimeDec2 ! !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_TimeDiff - Return the difference between two time instants ! ! !INTERFACE: function ESMF_TimeDiff(time1, time2) ! ! !RETURN VALUE: type(ESMF_TimeInterval) :: ESMF_TimeDiff ! ! !ARGUMENTS: type(ESMF_Time), intent(in) :: time1 type(ESMF_Time), intent(in) :: time2 ! !LOCAL: integer :: rc ! !DESCRIPTION: ! Return the {\tt ESMF\_TimeInterval} difference between two ! {\tt ESMF\_Time} instants ! ! Maps overloaded (-) operator interface function to ! {\tt ESMF\_BaseTime} base class ! ! The arguments are: ! \begin{description} ! \item[time1] ! The first {\tt ESMF\_Time} instant ! \item[time2] ! The second {\tt ESMF\_Time} instant ! \end{description} ! ! !REQUIREMENTS: ! TMG1.5.4, TMG2.4.4, TMG2.4.5, TMG2.4.6, TMG5.1, TMG5.2, TMG7.2 !EOP ! call ESMC_BaseTime base class function CALL ESMF_TimeIntervalSet( ESMF_TimeDiff, rc=rc ) call c_ESMC_BaseTimeDiff(time1, time2, ESMF_TimeDiff) end function ESMF_TimeDiff !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_TimeEQ - Compare two times for equality ! ! !INTERFACE: function ESMF_TimeEQ(time1, time2) ! ! !RETURN VALUE: logical :: ESMF_TimeEQ ! ! !ARGUMENTS: type(ESMF_Time), intent(in) :: time1 type(ESMF_Time), intent(in) :: time2 ! ! !DESCRIPTION: ! Return true if both given {\tt ESMF\_Time} instants are equal, false ! otherwise. Maps overloaded (==) operator interface function to ! {\tt ESMF\_BaseTime} base class. ! ! The arguments are: ! \begin{description} ! \item[time1] ! First time instant to compare ! \item[time2] ! Second time instant to compare ! \end{description} ! ! !REQUIREMENTS: ! TMG1.5.3, TMG2.4.3, TMG7.2 !EOP ! invoke C to C++ entry point for ESMF_BaseTime base class function call c_ESMC_BaseTimeEQ(time1, time2, ESMF_TimeEQ) end function ESMF_TimeEQ !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_TimeNE - Compare two times for non-equality ! ! !INTERFACE: function ESMF_TimeNE(time1, time2) ! ! !RETURN VALUE: logical :: ESMF_TimeNE ! ! !ARGUMENTS: type(ESMF_Time), intent(in) :: time1 type(ESMF_Time), intent(in) :: time2 ! !DESCRIPTION: ! Return true if both given {\tt ESMF\_Time} instants are not equal, false ! otherwise. Maps overloaded (/=) operator interface function to ! {\tt ESMF\_BaseTime} base class. ! ! The arguments are: ! \begin{description} ! \item[time1] ! First time instant to compare ! \item[time2] ! Second time instant to compare ! \end{description} ! ! !REQUIREMENTS: ! TMG1.5.3, TMG2.4.3, TMG7.2 !EOP ! call ESMC_BaseTime base class function call c_ESMC_BaseTimeNE(time1, time2, ESMF_TimeNE) end function ESMF_TimeNE !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_TimeLT - Time instant 1 less than time instant 2 ? ! ! !INTERFACE: function ESMF_TimeLT(time1, time2) ! ! !RETURN VALUE: logical :: ESMF_TimeLT ! ! !ARGUMENTS: type(ESMF_Time), intent(in) :: time1 type(ESMF_Time), intent(in) :: time2 ! ! !DESCRIPTION: ! Return true if first {\tt ESMF\_Time} instant is less than second ! {\tt ESMF\_Time} instant, false otherwise. Maps overloaded (<) ! operator interface function to {\tt ESMF\_BaseTime} base class. ! ! The arguments are: ! \begin{description} ! \item[time1] ! First time instant to compare ! \item[time2] ! Second time instant to compare ! \end{description} ! ! !REQUIREMENTS: ! TMG1.5.3, TMG2.4.3, TMG7.2 !EOP ! call ESMC_BaseTime base class function call c_ESMC_BaseTimeLT(time1, time2, ESMF_TimeLT) end function ESMF_TimeLT !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_TimeGT - Time instant 1 greater than time instant 2 ? ! ! !INTERFACE: function ESMF_TimeGT(time1, time2) ! ! !RETURN VALUE: logical :: ESMF_TimeGT ! ! !ARGUMENTS: type(ESMF_Time), intent(in) :: time1 type(ESMF_Time), intent(in) :: time2 ! ! !DESCRIPTION: ! Return true if first {\tt ESMF\_Time} instant is greater than second ! {\tt ESMF\_Time} instant, false otherwise. Maps overloaded (>) operator ! interface function to {\tt ESMF\_BaseTime} base class. ! ! The arguments are: ! \begin{description} ! \item[time1] ! First time instant to compare ! \item[time2] ! Second time instant to compare ! \end{description} ! ! !REQUIREMENTS: ! TMG1.5.3, TMG2.4.3, TMG7.2 !EOP ! call ESMC_BaseTime base class function call c_ESMC_BaseTimeGT(time1, time2, ESMF_TimeGT) end function ESMF_TimeGT !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_TimeLE - Time instant 1 less than or equal to time instant 2 ? ! ! !INTERFACE: function ESMF_TimeLE(time1, time2) ! ! !RETURN VALUE: logical :: ESMF_TimeLE ! ! !ARGUMENTS: type(ESMF_Time), intent(in) :: time1 type(ESMF_Time), intent(in) :: time2 ! ! !DESCRIPTION: ! Return true if first {\tt ESMF\_Time} instant is less than or equal to ! second {\tt ESMF\_Time} instant, false otherwise. Maps overloaded (<=) ! operator interface function to {\tt ESMF\_BaseTime} base class. ! ! The arguments are: ! \begin{description} ! \item[time1] ! First time instant to compare ! \item[time2] ! Second time instant to compare ! \end{description} ! ! !REQUIREMENTS: ! TMG1.5.3, TMG2.4.3, TMG7.2 !EOP ! call ESMC_BaseTime base class function call c_ESMC_BaseTimeLE(time1, time2, ESMF_TimeLE) end function ESMF_TimeLE !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_TimeGE - Time instant 1 greater than or equal to time instant 2 ? ! ! !INTERFACE: function ESMF_TimeGE(time1, time2) ! ! !RETURN VALUE: logical :: ESMF_TimeGE ! ! !ARGUMENTS: type(ESMF_Time), intent(in) :: time1 type(ESMF_Time), intent(in) :: time2 ! ! !DESCRIPTION: ! Return true if first {\tt ESMF\_Time} instant is greater than or equal to ! second {\tt ESMF\_Time} instant, false otherwise. Maps overloaded (>=) ! operator interface function to {\tt ESMF\_BaseTime} base class. ! ! The arguments are: ! \begin{description} ! \item[time1] ! First time instant to compare ! \item[time2] ! Second time instant to compare ! \end{description} ! ! !REQUIREMENTS: ! TMG1.5.3, TMG2.4.3, TMG7.2 !EOP ! call ESMC_BaseTime base class function call c_ESMC_BaseTimeGE(time1, time2, ESMF_TimeGE) end function ESMF_TimeGE !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_TimeCopy - Copy a time-instance ! !INTERFACE: subroutine ESMF_TimeCopy(timeout, timein) ! !ARGUMENTS: type(ESMF_Time), intent(out) :: timeout type(ESMF_Time), intent(in) :: timein ! !DESCRIPTION: ! Copy a time-instance to a new instance. ! ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMGn.n.n !EOP timeout%basetime = timein%basetime timeout%YR = timein%YR timeout%Calendar => timein%Calendar end subroutine ESMF_TimeCopy end module ESMF_TimeMod