! ! 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 Clock Module module ESMF_ClockMod ! !============================================================================== ! ! This file contains the Clock class definition and all Clock 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_ClockMod ! ! !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\_Clock.h} for complete description ! !------------------------------------------------------------------------------ ! !USES: ! inherit from ESMF base class use ESMF_BaseMod ! associated derived types use ESMF_TimeIntervalMod ! , only : ESMF_TimeInterval, & ! ESMF_TimeIntervalIsPositive use ESMF_TimeMod ! , only : ESMF_Time use ESMF_AlarmMod, only : ESMF_Alarm implicit none ! !------------------------------------------------------------------------------ ! !PRIVATE TYPES: private !------------------------------------------------------------------------------ ! ! ESMF_Clock ! ! ! F90 class type to match C++ Clock class in size only; ! ! all dereferencing within class is performed by C++ implementation ! internals for ESMF_Clock type ESMF_ClockInt type(ESMF_TimeInterval) :: TimeStep type(ESMF_Time) :: StartTime type(ESMF_Time) :: StopTime type(ESMF_Time) :: RefTime type(ESMF_Time) :: CurrTime type(ESMF_Time) :: PrevTime integer(ESMF_KIND_I8) :: AdvanceCount integer :: ClockMutex integer :: NumAlarms ! Note: to mimic ESMF 2.1.0+, AlarmList is maintained ! within ESMF_Clock even though copies of each alarm are ! returned from ESMF_AlarmCreate() at the same time they ! are copied into the AlarmList! This duplication is not ! as hideous as it might be because the ESMF_Alarm type ! has data members that are all POINTERs (thus the horrible ! shallow-copy-masquerading-as-reference-copy hack works). type(ESMF_Alarm), pointer, dimension(:) :: AlarmList end type ! Actual public type: this bit allows easy mimic of "deep" ESMF_ClockCreate ! in ESMF 2.1.0+ ! NOTE: DO NOT ADD NON-POINTER STATE TO THIS DATA TYPE. It emulates ESMF ! shallow-copy-masquerading-as-reference-copy. type ESMF_Clock type(ESMF_ClockInt), pointer :: clockint end type !------------------------------------------------------------------------------ ! !PUBLIC TYPES: public ESMF_Clock public ESMF_ClockInt ! needed on AIX but not PGI !------------------------------------------------------------------------------ ! ! !PUBLIC MEMBER FUNCTIONS: public ESMF_ClockCreate public ESMF_ClockDestroy public ESMF_ClockSet ! public ESMF_ClockSetOLD public ESMF_ClockGet ! public ESMF_ClockGetAdvanceCount ! public ESMF_ClockGetTimeStep ! public ESMF_ClockSetTimeStep ! public ESMF_ClockGetCurrTime ! public ESMF_ClockSetCurrTime ! public ESMF_ClockGetStartTime ! public ESMF_ClockGetStopTime ! public ESMF_ClockGetRefTime ! public ESMF_ClockGetPrevTime ! public ESMF_ClockGetCurrSimTime ! public ESMF_ClockGetPrevSimTime ! This must be public for ESMF_AlarmClockMod... public ESMF_ClockAddAlarm public ESMF_ClockGetAlarmList ! public ESMF_ClockGetNumAlarms ! public ESMF_ClockSyncToWallClock public ESMF_ClockAdvance public ESMF_ClockIsStopTime public ESMF_ClockStopTimeDisable ! Required inherited and overridden ESMF_Base class methods ! public ESMF_ClockRead ! public ESMF_ClockWrite public ESMF_ClockValidate public ESMF_ClockPrint !EOPI !============================================================================== contains !============================================================================== ! ! This section includes the Set methods. ! !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockSetOLD - Initialize a clockint ! !INTERFACE: subroutine ESMF_ClockSetOLD(clockint, TimeStep, StartTime, & StopTime, RefTime, rc) ! !ARGUMENTS: type(ESMF_ClockInt), intent(out) :: clockint type(ESMF_TimeInterval), intent(in), optional :: TimeStep type(ESMF_Time), intent(in) :: StartTime type(ESMF_Time), intent(in) :: StopTime type(ESMF_Time), intent(in), optional :: RefTime integer, intent(out), optional :: rc ! Local integer i ! !DESCRIPTION: ! Initialize an {\tt ESMF\_Clock} ! ! The arguments are: ! \begin{description} ! \item[clockint] ! The object instance to initialize ! \item[{[TimeStep]}] ! The {\tt ESMF\_Clock}s time step interval ! \item[StartTime] ! The {\tt ESMF\_Clock}s starting time ! \item[StopTime] ! The {\tt ESMF\_Clock}s stopping time ! \item[{[RefTime]}] ! The {\tt ESMF\_Clock}s reference time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG3.1, TMG3.4.4 !EOP IF ( PRESENT(TimeStep) ) clockint%TimeStep = TimeStep IF ( PRESENT(RefTime) )THEN clockint%RefTime = RefTime ELSE clockint%RefTime = StartTime END IF clockint%CurrTime = StartTime clockint%StartTime = StartTime clockint%StopTime = StopTime clockint%NumAlarms = 0 clockint%AdvanceCount = 0 ALLOCATE(clockint%AlarmList((2*(25)+10))) ! TBH: This incredible hack can be removed once ESMF_*Validate() ! TBH: can tell if a deep ESMF_* was created or not. DO i = 1, (2*(25)+10) NULLIFY( clockint%AlarmList( i )%alarmint ) ENDDO IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS end subroutine ESMF_ClockSetOLD ! !IROUTINE: ESMF_ClockSet - Set clock properties -- for compatibility with ESMF 2.0.1 ! !INTERFACE: subroutine ESMF_ClockSet(clock, TimeStep, StartTime, StopTime, & RefTime, CurrTime, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(inout) :: clock type(ESMF_TimeInterval), intent(in), optional :: TimeStep type(ESMF_Time), intent(in), optional :: StartTime type(ESMF_Time), intent(in), optional :: StopTime type(ESMF_Time), intent(in), optional :: RefTime type(ESMF_Time), intent(in), optional :: CurrTime integer, intent(out), optional :: rc ! Local integer ierr ! !DESCRIPTION: ! Initialize an {\tt ESMF\_Clock} ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to initialize ! \item[{[TimeStep]}] ! The {\tt ESMF\_Clock}s time step interval ! \item[StartTime] ! The {\tt ESMF\_Clock}s starting time ! \item[StopTime] ! The {\tt ESMF\_Clock}s stopping time ! \item[{[RefTime]}] ! The {\tt ESMF\_Clock}s reference time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG3.1, TMG3.4.4 !EOP ierr = ESMF_SUCCESS IF ( PRESENT(TimeStep) ) THEN CALL ESMF_ClockSetTimeStep ( clock, TimeStep, rc=ierr ) ENDIF IF ( PRESENT(RefTime) ) clock%clockint%RefTime = RefTime IF ( PRESENT(StartTime) ) clock%clockint%StartTime = StartTime IF ( PRESENT(StopTime) ) clock%clockint%StopTime = StopTime IF ( PRESENT(CurrTime) ) THEN CALL ESMF_ClockSetCurrTime(clock, CurrTime, rc=ierr) ENDIF IF ( PRESENT(rc) ) rc = ierr end subroutine ESMF_ClockSet ! Create ESMF_Clock using ESMF 2.1.0+ semantics FUNCTION ESMF_ClockCreate( name, TimeStep, StartTime, StopTime, & RefTime, rc ) ! return value type(ESMF_Clock) :: ESMF_ClockCreate ! !ARGUMENTS: character (len=*), intent(in), optional :: name type(ESMF_TimeInterval), intent(in), optional :: TimeStep type(ESMF_Time), intent(in) :: StartTime type(ESMF_Time), intent(in) :: StopTime type(ESMF_Time), intent(in), optional :: RefTime integer, intent(out), optional :: rc ! locals type(ESMF_Clock) :: clocktmp ! TBH: ignore allocate errors, for now ALLOCATE( clocktmp%clockint ) CALL ESMF_ClockSetOLD( clocktmp%clockint, & TimeStep= TimeStep, & StartTime=StartTime, & StopTime= StopTime, & RefTime=RefTime, rc=rc ) ESMF_ClockCreate = clocktmp END FUNCTION ESMF_ClockCreate ! Deallocate memory for ESMF_Clock SUBROUTINE ESMF_ClockDestroy( clock, rc ) TYPE(ESMF_Clock), INTENT(INOUT) :: clock INTEGER, INTENT( OUT), OPTIONAL :: rc ! TBH: ignore deallocate errors, for now DEALLOCATE( clock%clockint%AlarmList ) DEALLOCATE( clock%clockint ) IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS END SUBROUTINE ESMF_ClockDestroy !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockGet - Get clock properties -- for compatibility with ESMF 2.0.1 ! !INTERFACE: subroutine ESMF_ClockGet(clock, StartTime, CurrTime, & AdvanceCount, StopTime, TimeStep, & PrevTime, RefTime, & rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock type(ESMF_Time), intent(out), optional :: StartTime type(ESMF_Time), intent(out), optional :: CurrTime type(ESMF_Time), intent(out), optional :: StopTime type(ESMF_Time), intent(out), optional :: PrevTime type(ESMF_Time), intent(out), optional :: RefTime integer(ESMF_KIND_I8), intent(out), optional :: AdvanceCount type(ESMF_TimeInterval), intent(out), optional :: TimeStep integer, intent(out), optional :: rc integer :: ierr ! !DESCRIPTION: ! Returns the number of times the {\tt ESMF\_Clock} has been advanced ! (time stepped) ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to get the advance count from ! \item[StartTime] ! The start time ! \item[CurrTime] ! The current time ! \item[AdvanceCount] ! The number of times the {\tt ESMF\_Clock} has been advanced ! \item[StopTime] ! The {\tt ESMF\_Clock}s stopping time ! \item[{[TimeStep]}] ! The {\tt ESMF\_Clock}s time step interval ! \item[{[PrevTime]}] ! The {\tt ESMF\_Clock}s previous current time ! \item[{[PrevTime]}] ! The {\tt ESMF\_Clock}s reference time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !REQUIREMENTS: ! TMG3.5.1 !EOP ierr = ESMF_SUCCESS IF ( PRESENT (StartTime) ) THEN CALL ESMF_ClockGetStartTime( clock, StartTime=StartTime, rc=ierr ) ENDIF IF ( PRESENT (CurrTime) ) THEN CALL ESMF_ClockGetCurrTime( clock , CurrTime, ierr ) ENDIF IF ( PRESENT (StopTime) ) THEN CALL ESMF_ClockGetStopTime( clock , StopTime, ierr ) ENDIF IF ( PRESENT (AdvanceCount) ) THEN CALL ESMF_ClockGetAdvanceCount(clock, AdvanceCount, ierr) ENDIF IF ( PRESENT (TimeStep) ) THEN CALL ESMF_ClockGetTimeStep(clock, TimeStep, ierr) ENDIF IF ( PRESENT (PrevTime) ) THEN CALL ESMF_ClockGetPrevTime(clock, PrevTime, ierr) ENDIF IF ( PRESENT (RefTime) ) THEN CALL ESMF_ClockGetRefTime(clock, RefTime, ierr) ENDIF IF ( PRESENT (rc) ) THEN rc = ierr ENDIF end subroutine ESMF_ClockGet ! !IROUTINE: ESMF_ClockGetAdvanceCount - Get the clocks advance count ! !INTERFACE: subroutine ESMF_ClockGetAdvanceCount(clock, AdvanceCount, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock integer(ESMF_KIND_I8), intent(out) :: AdvanceCount integer, intent(out), optional :: rc ! !DESCRIPTION: ! Returns the number of times the {\tt ESMF\_Clock} has been advanced ! (time stepped) ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to get the advance count from ! \item[AdvanceCount] ! The number of times the {\tt ESMF\_Clock} has been advanced ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !REQUIREMENTS: ! TMG3.5.1 !EOP AdvanceCount = clock%clockint%AdvanceCount IF ( PRESENT(rc) ) rc = ESMF_SUCCESS end subroutine ESMF_ClockGetAdvanceCount !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockGetTimeStep - Get a clocks timestep interval ! !INTERFACE: subroutine ESMF_ClockGetTimeStep(clock, TimeStep, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock type(ESMF_TimeInterval), intent(out) :: TimeStep integer, intent(out), optional :: rc ! !DESCRIPTION: ! Get an {\tt ESMF\_Clock}s timestep interval ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to get the time step from ! \item[TimeStep] ! The time step ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG3.5.2 !EOP TimeStep = clock%clockint%TimeStep IF ( PRESENT(rc) ) rc = ESMF_SUCCESS end subroutine ESMF_ClockGetTimeStep !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockSetTimeStep - Set a clocks timestep interval ! !INTERFACE: subroutine ESMF_ClockSetTimeStep(clock, TimeStep, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(inout) :: clock ! really INTENT(OUT) type(ESMF_TimeInterval), intent(in) :: TimeStep integer, intent(out), optional :: rc ! !DESCRIPTION: ! Set an {\tt ESMF\_Clock}s timestep interval ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to set the time step ! \item[TimeStep] ! The time step ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG3.4.2 !EOP clock%clockint%TimeStep = TimeStep IF ( PRESENT(rc) ) rc = ESMF_SUCCESS end subroutine ESMF_ClockSetTimeStep !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockGetCurrTime - Get a clocks current time ! !INTERFACE: subroutine ESMF_ClockGetCurrTime(clock, CurrTime, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock type(ESMF_Time), intent(out) :: CurrTime integer, intent(out), optional :: rc ! !DESCRIPTION: ! Get an {\tt ESMF\_Clock}s current time ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to get the current time from ! \item[CurrTime] ! The current time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG3.5.4 !EOP CurrTime = clock%clockint%CurrTime IF ( PRESENT(rc) ) rc = ESMF_SUCCESS end subroutine ESMF_ClockGetCurrTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockSetCurrTime - Set a clocks current time ! !INTERFACE: subroutine ESMF_ClockSetCurrTime(clock, CurrTime, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(inout) :: clock ! really INTENT(OUT) type(ESMF_Time), intent(in) :: CurrTime integer, intent(out), optional :: rc ! !DESCRIPTION: ! Set an {\tt ESMF\_Clock}s current time ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to set the current time from ! \item[CurrTime] ! The current time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG3.4.3 !EOP clock%clockint%CurrTime = CurrTime IF ( PRESENT(rc) ) rc = ESMF_SUCCESS end subroutine ESMF_ClockSetCurrTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockGetStartTime - Get a clocks start time ! !INTERFACE: subroutine ESMF_ClockGetStartTime(clock, StartTime, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock type(ESMF_Time), intent(out) :: StartTime integer, intent(out), optional :: rc ! !DESCRIPTION: ! Get an {\tt ESMF\_Clock}s start time ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to get the start time from ! \item[StartTime] ! The start time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG3.5.3 !EOP StartTime = clock%clockint%StartTime IF ( PRESENT(rc) ) rc = ESMF_SUCCESS end subroutine ESMF_ClockGetStartTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockGetStopTime - Get a clocks stop time ! !INTERFACE: subroutine ESMF_ClockGetStopTime(clock, StopTime, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock type(ESMF_Time), intent(out) :: StopTime integer, intent(out), optional :: rc ! !DESCRIPTION: ! Get an {\tt ESMF\_Clock}s stop time ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to get the stop time from ! \item[StopTime] ! The stop time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG3.5.3 !EOP StopTime = clock%clockint%StopTime IF ( PRESENT(rc) ) rc = ESMF_SUCCESS end subroutine ESMF_ClockGetStopTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockGetRefTime - Get a clocks reference time ! !INTERFACE: subroutine ESMF_ClockGetRefTime(clock, RefTime, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock type(ESMF_Time), intent(out) :: RefTime integer, intent(out), optional :: rc ! !DESCRIPTION: ! Get an {\tt ESMF\_Clock}s reference time ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to get the reference time from ! \item[RefTime] ! The reference time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG3.5.3 !EOP refTime = clock%clockint%RefTime IF ( PRESENT(rc) ) rc = ESMF_SUCCESS end subroutine ESMF_ClockGetRefTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockGetPrevTime - Get a clocks previous current time ! !INTERFACE: subroutine ESMF_ClockGetPrevTime(clock, PrevTime, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock type(ESMF_Time), intent(out) :: PrevTime integer, intent(out), optional :: rc ! !DESCRIPTION: ! Get an {\tt ESMF\_Clock}s previous current time ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to get the previous current time from ! \item[PrevTime] ! The previous current time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG3.5.4 !EOP ! hack for bug in PGI 5.1-x ! prevTime = Clock%clockint%CurrTime - Clock%clockint%TimeStep prevTime = ESMF_TimeDec( Clock%clockint%CurrTime, & Clock%clockint%TimeStep ) IF ( PRESENT(rc) ) rc = ESMF_SUCCESS end subroutine ESMF_ClockGetPrevTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockGetCurrSimTime - Get a clocks current simulation time ! !INTERFACE: subroutine ESMF_ClockGetCurrSimTime(clock, CurrSimTime, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock type(ESMF_TimeInterval), intent(out) :: CurrSimTime integer, intent(out), optional :: rc ! !DESCRIPTION: ! Get an {\tt ESMF\_Clock}s current simulation time ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to get the current simulation time from ! \item[CurrSimTime] ! The current simulation time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG3.5.5 !EOP CALL wrf_error_fatal( 'ESMF_ClockGetCurrSimTime not supported' ) end subroutine ESMF_ClockGetCurrSimTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockGetPrevSimTime - Get a clocks previous simulation time ! !INTERFACE: subroutine ESMF_ClockGetPrevSimTime(clock, PrevSimTime, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock type(ESMF_TimeInterval), intent(out) :: PrevSimTime integer, intent(out), optional :: rc ! !DESCRIPTION: ! Get an {\tt ESMF\_Clock}s previous simulation time ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to get the previous simulation time from ! \item[PrevSimTime] ! The previous simulation time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG3.5.5 !EOP CALL wrf_error_fatal( 'ESMF_ClockGetPrevSimTime not supported' ) end subroutine ESMF_ClockGetPrevSimTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockAddAlarm - Add an alarm to a clocks alarm list ! !INTERFACE: subroutine ESMF_ClockAddAlarm(clock, Alarm, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(inout) :: clock type(ESMF_Alarm), intent(inout) :: Alarm integer, intent(out), optional :: rc ! !DESCRIPTION: ! Add an {\tt ESMF\_Alarm} to an {\tt ESMF\_Clock}s {\tt ESMF\_Alarm} list ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to add an {\tt ESMF\_Alarm} to ! \item[Alarm] ! The {\tt ESMF\_Alarm} to add to the {\tt ESMF\_Clock}s ! {\tt ESMF\_Alarm} list ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG4.1, TMG4.2 !EOP IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS clock%clockint%NumAlarms = clock%clockint%NumAlarms + 1 IF ( clock%clockint%NumAlarms > SIZE (clock%clockint%AlarmList) ) THEN CALL wrf_error_fatal ( 'ESMF_ClockAddAlarm: too many alarms' ) ELSE IF ( .NOT. ASSOCIATED( Alarm%alarmint ) ) THEN CALL wrf_error_fatal ( & 'ESMF_ClockAddAlarm: alarm not created' ) ELSE IF ( Alarm%alarmint%RingTimeSet ) THEN Alarm%alarmint%PrevRingTime = Alarm%alarmint%RingTime ELSE !TBH: This has the nasty side-effect of forcing us to explicitly turn on !TBH: alarms that are created with RingInterval only, if we want them to start !TBH: ringing right away. And this is done (see !TBH: COMPUTE_VORTEX_CENTER_ALARM). Straighten this out... Alarm%alarmint%PrevRingTime = clock%clockint%CurrTime ENDIF Alarm%alarmint%Ringing = .FALSE. ! finally, load the alarm into the list ! write(0,*)ESMF_ClockAddAlarm ,clock%clockint%NumAlarms clock%clockint%AlarmList(clock%clockint%NumAlarms) = Alarm ENDIF end subroutine ESMF_ClockAddAlarm !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockGetAlarmList - Get a clocks alarm list ! !INTERFACE: subroutine ESMF_ClockGetAlarmList(clock, AlarmList, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock type(ESMF_Alarm), pointer :: AlarmList(:) integer, intent(out), optional :: rc ! !DESCRIPTION: ! Get an {\tt ESMF\_Clock}s {\tt ESMF\_Alarm} list ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to get the {\tt ESMF\_Alarm} list from ! \item[AlarmList] ! The {\tt ESMF\_Clock}s {\tt ESMF\_Alarm} list ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG4.3 !EOP AlarmList => clock%clockint%AlarmList IF ( PRESENT(rc) ) rc = ESMF_SUCCESS end subroutine ESMF_ClockGetAlarmList !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockGetNumAlarms - Get the number of alarms in a clocks alarm list ! !INTERFACE: subroutine ESMF_ClockGetNumAlarms(clock, NumAlarms, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock integer, intent(out) :: NumAlarms integer, intent(out), optional :: rc ! !DESCRIPTION: ! Get the number of {\tt ESMF\_Alarm}s in an {\tt ESMF\_Clock}s ! {\tt ESMF\_Alarm} list ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to get the number of {\tt ESMF\_Alarm}s from ! \item[NumAlarms] ! The number of {\tt ESMF\_Alarm}s in the {\tt ESMF\_Clock}s ! {\tt ESMF\_Alarm} list ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG4.3 !EOP NumAlarms = clock%clockint%NumAlarms IF ( PRESENT(rc) ) rc = ESMF_SUCCESS end subroutine ESMF_ClockGetNumAlarms !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockSyncToWallClock - Set clocks current time to wall clock time ! !INTERFACE: subroutine ESMF_ClockSyncToWallClock(clock, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(inout) :: clock integer, intent(out), optional :: rc ! !DESCRIPTION: ! Set an {\tt ESMF\_Clock}s current time to wall clock time ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to synchronize to wall clock time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG3.4.5 !EOP CALL wrf_error_fatal( 'ESMF_ClockSyncToWallClock not supported' ) end subroutine ESMF_ClockSyncToWallClock !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockAdvance - Advance a clocks current time by one time step ! !INTERFACE: subroutine ESMF_ClockAdvance(clock, RingingAlarmList, & NumRingingAlarms, rc) use esmf_timemod ! !ARGUMENTS: type(ESMF_Clock), intent(inout) :: clock type(ESMF_Alarm), dimension((2*(25)+10)), intent(out), optional :: & RingingAlarmList integer, intent(out), optional :: NumRingingAlarms integer, intent(out), optional :: rc ! Local logical pred1, pred2, pred3 integer i, n type(ESMF_Alarm) :: alarm logical :: positive_timestep ! ! !DESCRIPTION: ! Advance an {\tt ESMF\_Clock}s current time by one time step ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to advance ! \item[{[RingingAlarmList]}] ! Return a list of any ringing alarms after the time step ! \item[{[NumRingingAlarms]}] ! The number of ringing alarms returned ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG3.4.1 !EOP ! hack for bug in PGI 5.1-x ! clock%clockint%CurrTime = clock%clockint%CurrTime + & ! clock%clockint%TimeStep clock%clockint%CurrTime = ESMF_TimeInc( clock%clockint%CurrTime, & clock%clockint%TimeStep ) positive_timestep = ESMF_TimeIntervalIsPositive( clock%clockint%TimeStep ) IF ( Present(NumRingingAlarms) ) NumRingingAlarms = 0 clock%clockint%AdvanceCount = clock%clockint%AdvanceCount + 1 DO i = 1, (2*(25)+10) alarm = clock%clockint%AlarmList(i) ! TBH: This is really dangerous. We need to be able to NULLIFY ! TBH: alarmint at compile-time (F95 synax) to make this safe. !$$$TBH: see if F95 compile-time pointer-nullification is supported by all !$$$TBH: compilers we support IF ( ASSOCIATED( alarm%alarmint ) ) THEN IF ( alarm%alarmint%Enabled ) THEN IF ( alarm%alarmint%RingIntervalSet ) THEN pred1 = .FALSE. ; pred2 = .FALSE. ; pred3 = .FALSE. ! alarm cannot ring if clock has passed the alarms stop time IF ( alarm%alarmint%StopTimeSet ) THEN IF ( positive_timestep ) THEN ! hack for bug in PGI 5.1-x ! PRED1 = clock%clockint%CurrTime > alarm%alarmint%StopTime PRED1 = ESMF_TimeGT( clock%clockint%CurrTime, & alarm%alarmint%StopTime ) ELSE ! in this case time step is negative and stop time is ! less than start time ! PRED1 = clock%clockint%CurrTime < alarm%alarmint%StopTime PRED1 = ESMF_TimeLT( clock%clockint%CurrTime, & alarm%alarmint%StopTime ) ENDIF ENDIF ! one-shot alarm: check for ring time ! TBH: Need to remove duplicated code. Need to enforce only one of ! TBH: alarm%alarmint%RingTimeSet or alarm%alarmint%RingIntervalSet ever ! TBH: being .TRUE. and simplify the logic. Also, the simpler ! TBH: implementation in the duplicated code below should be sufficient. IF ( alarm%alarmint%RingTimeSet ) THEN IF ( positive_timestep ) THEN ! hack for bug in PGI 5.1-x ! PRED2 = ( alarm%alarmint%RingTime <= clock%clockint%CurrTime & ! .AND. clock%clockint%CurrTime < alarm%alarmint%RingTime + & ! clock%clockint%TimeStep ) PRED2 = ( ESMF_TimeLE( alarm%alarmint%RingTime, & clock%clockint%CurrTime ) & .AND. ESMF_TimeLT( clock%clockint%CurrTime, & ESMF_TimeInc( alarm%alarmint%RingTime, & clock%clockint%TimeStep ) ) ) ELSE ! in this case time step is negative and stop time is ! less than start time ! hack for bug in PGI 5.1-x ! PRED2 = ( alarm%alarmint%RingTime >= clock%clockint%CurrTime & ! .AND. clock%clockint%CurrTime > alarm%alarmint%RingTime + & ! clock%clockint%TimeStep ) PRED2 = ( ESMF_TimeGE( alarm%alarmint%RingTime, & clock%clockint%CurrTime ) & .AND. ESMF_TimeGT( clock%clockint%CurrTime, & ESMF_TimeInc( alarm%alarmint%RingTime, & clock%clockint%TimeStep ) ) ) ENDIF ENDIF ! repeating alarm: check for ring interval IF ( alarm%alarmint%RingIntervalSet ) THEN IF ( positive_timestep ) THEN ! hack for bug in PGI 5.1-x ! PRED3 = ( alarm%alarmint%PrevRingTime + alarm%alarmint%RingInterval <= & ! clock%clockint%CurrTime ) PRED3 = ( ESMF_TimeLE( ESMF_TimeInc( & alarm%alarmint%PrevRingTime, & alarm%alarmint%RingInterval ), & clock%clockint%CurrTime ) ) ELSE ! in this case time step is negative and stop time is ! less than start time ! ring interval must always be positive ! hack for bug in PGI 5.1-x ! PRED3 = ( alarm%alarmint%PrevRingTime - alarm%alarmint%RingInterval >= & ! clock%clockint%CurrTime ) PRED3 = ( ESMF_TimeGE( ESMF_TimeDec( & alarm%alarmint%PrevRingTime, & alarm%alarmint%RingInterval ), & clock%clockint%CurrTime ) ) ENDIF ENDIF IF ( (.NOT. pred1) .AND. pred2 ) THEN alarm%alarmint%Ringing = .TRUE. alarm%alarmint%PrevRingTime = clock%clockint%CurrTime alarm%alarmint%RingTimeSet = .FALSE. !it is a one time alarm, it rang, now let it resort to interval IF ( PRESENT( RingingAlarmList ) .AND. & PRESENT ( NumRingingAlarms ) ) THEN NumRingingAlarms = NumRingingAlarms + 1 RingingAlarmList( NumRingingAlarms ) = alarm ENDIF ELSE IF ( (.NOT. pred1) .AND. pred3 ) THEN alarm%alarmint%Ringing = .TRUE. IF ( positive_timestep ) THEN ! hack for bug in PGI 5.1-x ! IF ( PRED3) alarm%alarmint%PrevRingTime = alarm%alarmint%PrevRingTime + & ! alarm%alarmint%RingInterval IF ( PRED3 ) & alarm%alarmint%PrevRingTime = & ESMF_TimeInc( alarm%alarmint%PrevRingTime, & alarm%alarmint%RingInterval ) ELSE ! in this case time step is negative and stop time is ! less than start time ! ring interval must always be positive ! hack for bug in PGI 5.1-x ! IF ( PRED3) alarm%alarmint%PrevRingTime = alarm%alarmint%PrevRingTime - & ! alarm%alarmint%RingInterval IF ( PRED3 ) & alarm%alarmint%PrevRingTime = & ESMF_TimeDec( alarm%alarmint%PrevRingTime, & alarm%alarmint%RingInterval ) ENDIF IF ( PRESENT( RingingAlarmList ) .AND. & PRESENT ( NumRingingAlarms ) ) THEN NumRingingAlarms = NumRingingAlarms + 1 RingingAlarmList( NumRingingAlarms ) = alarm ENDIF ENDIF ELSE IF ( alarm%alarmint%RingTimeSet ) THEN ! TBH: Need to remove duplicated code. Need to enforce only one of ! TBH: alarm%alarmint%RingTimeSet or alarm%alarmint%RingIntervalSet ever ! TBH: being .TRUE. and simplify the logic. Also, the simpler ! TBH: implementation in here should be sufficient. IF ( positive_timestep ) THEN ! hack for bug in PGI 5.1-x ! IF ( alarm%alarmint%RingTime <= clock%clockint%CurrTime ) THEN IF ( ESMF_TimeLE( alarm%alarmint%RingTime, & clock%clockint%CurrTime ) ) THEN alarm%alarmint%RingTimeSet = .FALSE. !it is a one time alarm, it rang, now let it resort to interval alarm%alarmint%Ringing = .TRUE. alarm%alarmint%PrevRingTime = clock%clockint%CurrTime IF ( PRESENT( RingingAlarmList ) .AND. & PRESENT ( NumRingingAlarms ) ) THEN NumRingingAlarms = NumRingingAlarms + 1 RingingAlarmList( NumRingingAlarms ) = alarm ENDIF ENDIF ELSE ! in this case time step is negative and stop time is ! less than start time ! hack for bug in PGI 5.1-x ! IF ( alarm%alarmint%RingTime >= clock%clockint%CurrTime ) THEN IF ( ESMF_TimeGE( alarm%alarmint%RingTime, & clock%clockint%CurrTime ) ) THEN alarm%alarmint%RingTimeSet = .FALSE. !it is a one time alarm, it rang, now let it resort to interval alarm%alarmint%Ringing = .TRUE. alarm%alarmint%PrevRingTime = clock%clockint%CurrTime IF ( PRESENT( RingingAlarmList ) .AND. & PRESENT ( NumRingingAlarms ) ) THEN NumRingingAlarms = NumRingingAlarms + 1 RingingAlarmList( NumRingingAlarms ) = alarm ENDIF ENDIF ENDIF ENDIF IF ( alarm%alarmint%StopTimeSet ) THEN ! TBH: what is this for??? ENDIF ENDIF ENDIF clock%clockint%AlarmList(i) = alarm ENDDO IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS end subroutine ESMF_ClockAdvance !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockStopTimeDisable - NOOP for compatibility with ESMF 2.1.0+ ! !INTERFACE: subroutine ESMF_ClockStopTimeDisable(clock, rc) ! ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock integer, intent(out), optional :: rc rc = ESMF_SUCCESS end subroutine ESMF_ClockStopTimeDisable !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockIsStopTime - Has the clock reached its stop time ? ! !INTERFACE: function ESMF_ClockIsStopTime(clock, rc) ! ! !RETURN VALUE: logical :: ESMF_ClockIsStopTime ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock integer, intent(out), optional :: rc logical :: positive_timestep ! !DESCRIPTION: ! Return true if {\tt ESMF\_Clock} has reached its stop time, false ! otherwise ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to check ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !REQUIREMENTS: ! TMG3.5.6 !EOP positive_timestep = ESMF_TimeIntervalIsPositive( clock%clockint%TimeStep ) IF ( positive_timestep ) THEN ! hack for bug in PGI 5.1-x ! if ( clock%clockint%CurrTime .GE. clock%clockint%StopTime ) THEN if ( ESMF_TimeGE( clock%clockint%CurrTime, & clock%clockint%StopTime ) ) THEN ESMF_ClockIsStopTime = .TRUE. else ESMF_ClockIsStopTime = .FALSE. endif ELSE ! hack for bug in PGI 5.1-x ! if ( clock%clockint%CurrTime .LE. clock%clockint%StopTime ) THEN if ( ESMF_TimeLE( clock%clockint%CurrTime, & clock%clockint%StopTime ) ) THEN ESMF_ClockIsStopTime = .TRUE. else ESMF_ClockIsStopTime = .FALSE. endif ENDIF IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS end function ESMF_ClockIsStopTime !------------------------------------------------------------------------------ ! ! This section defines the overridden Read, Write, Validate and Print methods ! from the ESMF_Base class ! !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockRead - Restores a clock ! !INTERFACE: subroutine ESMF_ClockRead(clock, TimeStep, StartTime, StopTime, & RefTime, CurrTime, PrevTime, AdvanceCount, & AlarmList, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(out) :: clock type(ESMF_TimeInterval), intent(in) :: TimeStep type(ESMF_Time), intent(in) :: StartTime type(ESMF_Time), intent(in) :: StopTime type(ESMF_Time), intent(in) :: RefTime type(ESMF_Time), intent(in) :: CurrTime type(ESMF_Time), intent(in) :: PrevTime integer(ESMF_KIND_I8), intent(in) :: AdvanceCount type(ESMF_Alarm), dimension((2*(25)+10)), intent(in) :: AlarmList integer, intent(out), optional :: rc ! !DESCRIPTION: ! Restore an {\tt ESMF\_Clock} ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to restore ! \item[TimeStep] ! The {\tt ESMF\_Clock}s time step interval ! \item[StartTime] ! The {\tt ESMF\_Clock}s starting time ! \item[StopTime] ! The {\tt ESMF\_Clock}s stopping time ! \item[RefTime] ! The {\tt ESMF\_Clock}s reference time ! \item[CurrTime] ! The {\tt ESMF\_Clock}s current time ! \item[PrevTime] ! The {\tt ESMF\_Clock}s previous time ! \item[AdvanceCount] ! The number of times the {\tt ESMF\_Clock} has been advanced ! \item[AlarmList] ! The {\tt ESMF\_Clock}s {\tt ESMF\_Alarm} list ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: !EOP CALL wrf_error_fatal( 'ESMF_ClockRead not supported' ) end subroutine ESMF_ClockRead !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockWrite - Saves a clock ! !INTERFACE: subroutine ESMF_ClockWrite(clock, TimeStep, StartTime, StopTime, & RefTime, CurrTime, PrevTime, AdvanceCount, & AlarmList, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock type(ESMF_TimeInterval), intent(out) :: TimeStep type(ESMF_Time), intent(out) :: StartTime type(ESMF_Time), intent(out) :: StopTime type(ESMF_Time), intent(out) :: RefTime type(ESMF_Time), intent(out) :: CurrTime type(ESMF_Time), intent(out) :: PrevTime integer(ESMF_KIND_I8), intent(out) :: AdvanceCount type(ESMF_Alarm), dimension((2*(25)+10)), intent(out) :: AlarmList integer, intent(out), optional :: rc ! !DESCRIPTION: ! Save an {\tt ESMF\_Clock} ! ! The arguments are: ! \begin{description} ! \item[clock] ! The object instance to save ! \item[TimeStep] ! The {\tt ESMF\_Clock}s time step interval ! \item[StartTime] ! The {\tt ESMF\_Clock}s starting time ! \item[StopTime] ! The {\tt ESMF\_Clock}s stopping time ! \item[RefTime] ! The {\tt ESMF\_Clock}s reference time ! \item[CurrTime] ! The {\tt ESMF\_Clock}s current time ! \item[PrevTime] ! The {\tt ESMF\_Clock}s previous time ! \item[AdvanceCount] ! The number of times the {\tt ESMF\_Clock} has been advanced ! \item[AlarmList] ! The {\tt ESMF\_Clock}s {\tt ESMF\_Alarm} list ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: !EOP CALL wrf_error_fatal( 'ESMF_ClockWrite not supported' ) end subroutine ESMF_ClockWrite !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockValidate - Validate a Clocks properties ! !INTERFACE: subroutine ESMF_ClockValidate(clock, opts, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock character (len=*), intent(in), optional :: opts integer, intent(out), optional :: rc ! !DESCRIPTION: ! Perform a validation check on an {\tt ESMF\_Clock}s properties ! ! The arguments are: ! \begin{description} ! \item[clock] ! {\tt ESMF\_Clock} to validate ! \item[{[opts]}] ! Validate options ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMGn.n.n !EOP CALL wrf_error_fatal( 'ESMF_ClockValidate not supported' ) end subroutine ESMF_ClockValidate !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_ClockPrint - Print out a Clocks properties ! !INTERFACE: subroutine ESMF_ClockPrint(clock, opts, rc) ! !ARGUMENTS: type(ESMF_Clock), intent(in) :: clock character (len=*), intent(in), optional :: opts integer, intent(out), optional :: rc ! !DESCRIPTION: ! To support testing/debugging, print out an {\tt ESMF\_Clock}s ! properties. ! ! The arguments are: ! \begin{description} ! \item[clock] ! {\tt ESMF\_Clock} to print out ! \item[{[opts]}] ! Print options ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMGn.n.n !EOP CALL wrf_error_fatal( 'ESMF_ClockPrint not supported' ) end subroutine ESMF_ClockPrint !------------------------------------------------------------------------------ end module ESMF_ClockMod