! $Id$ ! ! 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 GPL. ! !============================================================================== ! ! ESMF Alarm Module module ESMF_AlarmMod ! !============================================================================== ! ! This file contains the Alarm class definition and all Alarm class ! methods. ! !------------------------------------------------------------------------------ ! INCLUDES #include !=============================================================================== !BOPI ! ! !MODULE: ESMF_AlarmMod ! ! !DESCRIPTION: ! Part of Time Manager F90 API wrapper of C++ implemenation ! ! Defines F90 wrapper entry points for corresponding ! C++ class {\tt ESMC\_Alarm} ! ! See {\tt ../include/ESMC\_Alarm.h} for complete description ! !------------------------------------------------------------------------------ ! !USES: ! inherit from ESMF base class use ESMF_BaseMod ! associated derived types use ESMF_TimeIntervalMod use ESMF_TimeMod implicit none !------------------------------------------------------------------------------ ! !PRIVATE TYPES: private !------------------------------------------------------------------------------ ! ! ESMF_Alarm ! ! ! F90 class type to match C++ Alarm class in size only; ! ! all dereferencing within class is performed by C++ implementation ! internals for ESMF_Alarm type ESMF_AlarmInt character(len=256) :: name = " " type(ESMF_TimeInterval) :: RingInterval type(ESMF_Time) :: RingTime type(ESMF_Time) :: PrevRingTime type(ESMF_Time) :: StopTime integer :: ID integer :: AlarmMutex logical :: Ringing logical :: Enabled logical :: RingTimeSet logical :: RingIntervalSet logical :: StopTimeSet end type ! Actual public type: this bit allows easy mimic of "deep" ESMF_AlarmCreate ! in ESMF 2.1.0+. Note that ESMF_AlarmCreate is in a separate module to avoid ! cyclic dependence. ! NOTE: DO NOT ADD NON-POINTER STATE TO THIS DATA TYPE. It emulates ESMF ! shallow-copy-masquerading-as-reference-copy insanity. type ESMF_Alarm type(ESMF_AlarmInt), pointer :: alarmint end type !------------------------------------------------------------------------------ ! !PUBLIC TYPES: public ESMF_Alarm public ESMF_AlarmInt ! needed on AIX but not PGI !------------------------------------------------------------------------------ ! !PUBLIC MEMBER FUNCTIONS: public ESMF_AlarmDestroy public ESMF_AlarmSet public ESMF_AlarmGet ! public ESMF_AlarmGetRingInterval ! public ESMF_AlarmSetRingInterval ! public ESMF_AlarmGetRingTime ! public ESMF_AlarmSetRingTime ! public ESMF_AlarmGetPrevRingTime ! public ESMF_AlarmSetPrevRingTime ! public ESMF_AlarmGetStopTime ! public ESMF_AlarmSetStopTime public ESMF_AlarmEnable public ESMF_AlarmDisable public ESMF_AlarmRingerOn public ESMF_AlarmRingerOff public ESMF_AlarmIsRinging ! public ESMF_AlarmCheckRingTime public operator(==) ! Required inherited and overridden ESMF_Base class methods ! public ESMF_AlarmRead ! public ESMF_AlarmWrite public ESMF_AlarmValidate public ESMF_AlarmPrint ! !PRIVATE MEMBER FUNCTIONS: private ESMF_AlarmEQ !EOPI !------------------------------------------------------------------------------ ! The following line turns the CVS identifier string into a printable variable. character(*), parameter, private :: version = & '$Id$' !============================================================================== ! ! INTERFACE BLOCKS ! !============================================================================== !BOP ! !INTERFACE: interface operator(==) ! !PRIVATE MEMBER FUNCTIONS: module procedure ESMF_AlarmEQ ! !DESCRIPTION: ! This interface overloads the == operator for the {\tt ESMF\_Alarm} class ! !EOP end interface ! !------------------------------------------------------------------------------ !============================================================================== contains !============================================================================== !------------------------------------------------------------------------------ ! ! This section includes the Set methods. ! !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmSet - Initializes an alarm ! !INTERFACE: subroutine ESMF_AlarmSet(alarm, name, RingTime, RingInterval, & StopTime, Enabled, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(out) :: alarm character(len=*), intent(in), optional :: name type(ESMF_Time), intent(in), optional :: RingTime type(ESMF_TimeInterval), intent(in), optional :: RingInterval type(ESMF_Time), intent(in), optional :: StopTime logical, intent(in), optional :: Enabled integer, intent(out), optional :: rc ! !DESCRIPTION: ! Initializes an {\tt ESMF\_Alarm} ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to initialize ! \item[{[RingTime]}] ! Optional ring time for one-shot or first repeating alarm ! \item[{[RingInterval]}] ! Optional ring interval for repeating alarms ! \item[{[StopTime]}] ! Optional stop time for repeating alarms ! \item[Enabled] ! Alarm enabled/disabled ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG4.1, TMG4.7 !EOP IF ( ASSOCIATED( alarm%alarmint ) ) THEN alarm%alarmint%RingTimeSet = .FALSE. alarm%alarmint%RingIntervalSet = .FALSE. alarm%alarmint%StopTimeSet = .FALSE. IF ( PRESENT( name ) ) THEN alarm%alarmint%name = name END IF IF ( PRESENT( RingInterval ) ) THEN alarm%alarmint%RingInterval = RingInterval alarm%alarmint%RingIntervalSet = .TRUE. ENDIF IF ( PRESENT( RingTime ) ) THEN alarm%alarmint%RingTime = RingTime alarm%alarmint%RingTimeSet = .TRUE. ENDIF IF ( PRESENT( StopTime ) ) THEN alarm%alarmint%StopTime = StopTime alarm%alarmint%StopTimeSet = .TRUE. ENDIF alarm%alarmint%Enabled = .TRUE. IF ( PRESENT( Enabled ) ) THEN alarm%alarmint%Enabled = Enabled ENDIF IF ( PRESENT( rc ) ) THEN rc = ESMF_SUCCESS ENDIF alarm%alarmint%Ringing = .FALSE. alarm%alarmint%Enabled = .TRUE. ELSE IF ( PRESENT( rc ) ) rc = ESMF_FAILURE ENDIF end subroutine ESMF_AlarmSet ! Deallocate memory for ESMF_Alarm SUBROUTINE ESMF_AlarmDestroy( alarm, rc ) TYPE(ESMF_Alarm), INTENT(INOUT) :: alarm INTEGER, INTENT( OUT), OPTIONAL :: rc IF ( ASSOCIATED( alarm%alarmint ) ) THEN DEALLOCATE( alarm%alarmint ) ENDIF ! TBH: ignore deallocate errors, for now IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS END SUBROUTINE ESMF_AlarmDestroy !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmGetRingInterval - Get an alarm's ring interval ! ! !INTERFACE: subroutine ESMF_AlarmGetRingInterval(alarm, RingInterval, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(in) :: alarm type(ESMF_TimeInterval), intent(out) :: RingInterval integer, intent(out), optional :: rc ! !DESCRIPTION: ! Get an {\tt ESMF\_Alarm}'s ring interval ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to get the ring interval ! \item[RingInterval] ! The {\tt Alarm}'s ring interval ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !REQUIREMENTS: ! TMG4.7 !EOP IF ( ASSOCIATED( alarm%alarmint ) ) THEN IF ( alarm%alarmint%RingIntervalSet )THEN RingInterval= alarm%alarmint%RingInterval IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS ELSE IF ( PRESENT( rc ) ) rc = ESMF_FAILURE END IF ELSE IF ( PRESENT( rc ) ) rc = ESMF_FAILURE ENDIF end subroutine ESMF_AlarmGetRingInterval !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmSetRingInterval - Set an alarm's ring interval ! ! !INTERFACE: subroutine ESMF_AlarmSetRingInterval(alarm, RingInterval, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(out) :: alarm type(ESMF_TimeInterval), intent(in) :: RingInterval integer, intent(out), optional :: rc ! !DESCRIPTION: ! Set an {\tt ESMF\_Alarm}'s ring interval ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to set the ring interval ! \item[RingInterval] ! The {\tt Alarm}'s ring interval ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG4.5.2, TMG4.7 !EOP CALL wrf_error_fatal( 'ESMF_AlarmSetRingInterval not supported' ) end subroutine ESMF_AlarmSetRingInterval !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmGetRingTime - Get an alarm's time to ring ! ! !INTERFACE: subroutine ESMF_AlarmGetRingTime(alarm, RingTime, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(in) :: alarm type(ESMF_Time), intent(out) :: RingTime integer, intent(out), optional :: rc ! !DESCRIPTION: ! Get an {\tt ESMF\_Alarm}'s time to ring ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to get the ring time ! \item[RingTime] ! The {\tt ESMF\_Alarm}'s ring time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG4.7, TMG4.8 !EOP type(ESMF_Time) :: PrevRingTime type(ESMF_TimeInterval) :: RingInterval integer :: ierr IF ( ASSOCIATED( alarm%alarmint ) ) THEN IF ( alarm%alarmint%RingIntervalSet )THEN PrevRingTime = alarm%alarmint%PrevRingTime call ESMF_AlarmGetRingInterval( alarm, RingInterval, ierr) IF ( PRESENT( rc ) .AND. (ierr /= ESMF_SUCCESS) )THEN rc = ierr return END IF RingTime = PrevRingTime + RingInterval IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS ELSE IF ( alarm%alarmint%RingTimeSet )THEN RingTime = alarm%alarmint%RingTime IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS ELSE IF ( PRESENT( rc ) ) rc = ESMF_FAILURE END IF ELSE IF ( PRESENT( rc ) ) rc = ESMF_FAILURE ENDIF end subroutine ESMF_AlarmGetRingTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmSetRingTime - Set an alarm's time to ring ! ! !INTERFACE: subroutine ESMF_AlarmSetRingTime(alarm, RingTime, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(out) :: alarm type(ESMF_Time), intent(in) :: RingTime integer, intent(out), optional :: rc ! !DESCRIPTION: ! Set an {\tt ESMF\_Alarm}'s time to ring ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to set the ring time ! \item[RingTime] ! The {\tt ESMF\_Alarm}'s ring time to set ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG4.5.1, TMG4.7, TMG4.8 !EOP CALL wrf_error_fatal( 'ESMF_AlarmSetRingTime not supported' ) end subroutine ESMF_AlarmSetRingTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmGet - Get an alarm's parameters -- compatibility with ESMF 2.0.1 ! ! !INTERFACE: subroutine ESMF_AlarmGet(alarm, name, RingTime, PrevRingTime, RingInterval, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(in) :: alarm character(len=*), intent(out), optional :: name type(ESMF_Time), intent(out), optional :: RingTime type(ESMF_Time), intent(out), optional :: PrevRingTime type(ESMF_TimeInterval), intent(out), optional :: RingInterval integer, intent(out), optional :: rc integer :: ierr ! !DESCRIPTION: ! Get an {\tt ESMF\_Alarm}'s previous ring time ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to get ! \item[ringTime] ! The ring time for a one-shot alarm or the next repeating alarm. ! \item[ringInterval] ! The ring interval for repeating (interval) alarms. ! \item[PrevRingTime] ! The {\tt ESMF\_Alarm}'s previous ring time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG4.7, TMG4.8 !EOP ierr = ESMF_SUCCESS IF ( PRESENT(name) ) THEN IF ( ASSOCIATED( alarm%alarmint ) ) THEN name = alarm%alarmint%name ELSE ierr = ESMF_FAILURE END IF ENDIF IF ( PRESENT(PrevRingTime) ) THEN CALL ESMF_AlarmGetPrevRingTime(alarm, PrevRingTime, rc=ierr) ENDIF IF ( PRESENT(RingTime) ) THEN CALL ESMF_AlarmGetRingTime(alarm, RingTime, rc=ierr) ENDIF IF ( PRESENT(RingInterval) ) THEN CALL ESMF_AlarmGetRingInterval(alarm, RingInterval, rc=ierr) ENDIF IF ( PRESENT(rc) ) THEN rc = ierr ENDIF end subroutine ESMF_AlarmGet !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmGetPrevRingTime - Get an alarm's previous ring time ! ! !INTERFACE: subroutine ESMF_AlarmGetPrevRingTime(alarm, PrevRingTime, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(in) :: alarm type(ESMF_Time), intent(out) :: PrevRingTime integer, intent(out), optional :: rc ! !DESCRIPTION: ! Get an {\tt ESMF\_Alarm}'s previous ring time ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to get the previous ring time ! \item[PrevRingTime] ! The {\tt ESMF\_Alarm}'s previous ring time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG4.7, TMG4.8 !EOP IF ( ASSOCIATED( alarm%alarmint ) ) THEN PrevRingTime = alarm%alarmint%PrevRingTime IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS ELSE IF ( PRESENT( rc ) ) rc = ESMF_FAILURE ENDIF end subroutine ESMF_AlarmGetPrevRingTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmSetPrevRingTime - Set an alarm's previous ring time ! ! !INTERFACE: subroutine ESMF_AlarmSetPrevRingTime(alarm, PrevRingTime, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(out) :: alarm type(ESMF_Time), intent(in) :: PrevRingTime integer, intent(out), optional :: rc ! !DESCRIPTION: ! Set an {\tt ESMF\_Alarm}'s previous ring time ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to set the previous ring time ! \item[PrevRingTime] ! The {\tt ESMF\_Alarm}'s previous ring time to set ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG4.7, TMG4.8 !EOP CALL wrf_error_fatal( 'ESMF_AlarmSetPrevRingTime not supported' ) end subroutine ESMF_AlarmSetPrevRingTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmGetStopTime - Get an alarm's stop time ! ! !INTERFACE: subroutine ESMF_AlarmGetStopTime(alarm, StopTime, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(in) :: alarm type(ESMF_Time), intent(out) :: StopTime integer, intent(out), optional :: rc ! !DESCRIPTION: ! Get an {\tt ESMF\_Alarm}'s stop time ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to get the stop time ! \item[StopTime] ! The {\tt ESMF\_Alarm}'s stop time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG4.5.2, TMG4.7 !EOP CALL wrf_error_fatal( 'ESMF_AlarmGetStopTime not supported' ) end subroutine ESMF_AlarmGetStopTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmSetStopTime - Set an alarm's stop time ! ! !INTERFACE: subroutine ESMF_AlarmSetStopTime(alarm, StopTime, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(out) :: alarm type(ESMF_Time), intent(in) :: StopTime integer, intent(out), optional :: rc ! !DESCRIPTION: ! Set an {\tt ESMF\_Alarm}'s stop time ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to set the stop time ! \item[StopTime] ! The {\tt ESMF\_Alarm}'s stop time ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG4.5.2, TMG4.7 !EOP CALL wrf_error_fatal( 'ESMF_AlarmSetStopTime not supported' ) end subroutine ESMF_AlarmSetStopTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmEnable - Enables an alarm ! !INTERFACE: subroutine ESMF_AlarmEnable(alarm, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(out) :: alarm integer, intent(out), optional :: rc ! !DESCRIPTION: ! Enables an {\tt ESMF\_Alarm} to function ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to enable ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !REQUIREMENTS: ! TMG4.5.3 !EOP IF ( ASSOCIATED( alarm%alarmint ) ) THEN alarm%alarmint%Enabled = .TRUE. IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS ELSE IF ( PRESENT( rc ) ) rc = ESMF_FAILURE ENDIF end subroutine ESMF_AlarmEnable !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmDisable - Disables an alarm ! !INTERFACE: subroutine ESMF_AlarmDisable(alarm, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(out) :: alarm integer, intent(out), optional :: rc ! !DESCRIPTION: ! Disables an {\tt ESMF\_Alarm} ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to disable ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !REQUIREMENTS: ! TMG4.5.3 !EOP IF ( ASSOCIATED( alarm%alarmint ) ) THEN alarm%alarmint%Enabled = .FALSE. IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS ELSE IF ( PRESENT( rc ) ) rc = ESMF_FAILURE ENDIF end subroutine ESMF_AlarmDisable !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmRingerOn - Turn on an alarm ! !INTERFACE: subroutine ESMF_AlarmRingerOn(alarm, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(out) :: alarm integer, intent(out), optional :: rc ! !DESCRIPTION: ! Turn on an {\tt ESMF\_Alarm}; sets ringing state ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to turn on ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: ! TMG4.6 !EOP IF ( ASSOCIATED( alarm%alarmint ) ) THEN IF ( alarm%alarmint%Enabled ) THEN alarm%alarmint%Ringing = .TRUE. IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS ELSE alarm%alarmint%Ringing = .FALSE. IF ( PRESENT( rc ) ) rc = ESMF_FAILURE ENDIF ELSE IF ( PRESENT( rc ) ) rc = ESMF_FAILURE ENDIF end subroutine ESMF_AlarmRingerOn !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmRingerOff - Turn off an alarm ! !INTERFACE: subroutine ESMF_AlarmRingerOff(alarm, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(out) :: alarm integer, intent(out), optional :: rc ! !DESCRIPTION: ! Turn off an {\tt ESMF\_Alarm}; unsets ringing state ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to turn off ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !REQUIREMENTS: ! TMG4.6 !EOP IF ( ASSOCIATED( alarm%alarmint ) ) THEN alarm%alarmint%Ringing = .FALSE. IF ( alarm%alarmint%Enabled ) THEN IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS ELSE IF ( PRESENT( rc ) ) rc = ESMF_FAILURE ENDIF ELSE IF ( PRESENT( rc ) ) rc = ESMF_FAILURE ENDIF end subroutine ESMF_AlarmRingerOff !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmIsRinging - Check if alarm is ringing ! !INTERFACE: function ESMF_AlarmIsRinging(alarm, rc) ! ! !RETURN VALUE: logical :: ESMF_AlarmIsRinging ! !ARGUMENTS: type(ESMF_Alarm), intent(in) :: alarm integer, intent(out), optional :: rc ! !DESCRIPTION: ! Check if {\tt ESMF\_Alarm} is ringing. ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to check for ringing state ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !REQUIREMENTS: ! TMG4.4 !EOP IF ( ASSOCIATED( alarm%alarmint ) ) THEN IF ( alarm%alarmint%Enabled ) THEN ESMF_AlarmIsRinging = alarm%alarmint%Ringing IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS ELSE ESMF_AlarmIsRinging = .FALSE. IF ( PRESENT( rc ) ) rc = ESMF_FAILURE ENDIF ELSE IF ( PRESENT( rc ) ) rc = ESMF_FAILURE ENDIF end function ESMF_AlarmIsRinging !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmCheckRingTime - Method used by a clock to check whether to trigger an alarm ! ! !INTERFACE: function ESMF_AlarmCheckRingTime(alarm, ClockCurrTime, positive, rc) ! ! !RETURN VALUE: logical :: ESMF_AlarmCheckRingTime ! ! !ARGUMENTS: type(ESMF_Alarm), intent(inout) :: alarm type(ESMF_Time), intent(in) :: ClockCurrTime integer, intent(in) :: positive integer, intent(out), optional :: rc ! ! !DESCRIPTION: ! Main method used by a {\tt ESMF\_Clock} to check whether to trigger ! the {\tt ESMF\_Alarm} ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to check if time to ring ! \item[ClockCurrTime] ! The {\tt ESMF\_Clock}'s current time ! \item[positive] ! Whether to check ring time in the positive or negative direction ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !REQUIREMENTS: ! TMG4.4, TMG4.6 !EOP CALL wrf_error_fatal( 'ESMF_AlarmCheckRingTime not supported' ) ESMF_AlarmCheckRingTime = .FALSE. ! keep compilers happy end function ESMF_AlarmCheckRingTime !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmEQ - Compare two alarms for equality ! ! !INTERFACE: function ESMF_AlarmEQ(alarm1, alarm2) ! ! !RETURN VALUE: logical :: ESMF_AlarmEQ ! !ARGUMENTS: type(ESMF_Alarm), intent(in) :: alarm1 type(ESMF_Alarm), intent(in) :: alarm2 ! !DESCRIPTION: ! Compare two alarms for equality; return true if equal, false otherwise ! Maps to overloaded (==) operator interface function ! ! The arguments are: ! \begin{description} ! \item[alarm1] ! The first {\tt ESMF\_Alarm} to compare ! \item[alarm2] ! The second {\tt ESMF\_Alarm} to compare ! \end{description} ! ! !REQUIREMENTS: !EOP CALL wrf_error_fatal( 'ESMF_AlarmEQ not supported ' ) ESMF_AlarmEQ = .FALSE. ! keep compilers happy end function ESMF_AlarmEQ !------------------------------------------------------------------------------ ! ! This section defines the overridden Read, Write, Validate and Print methods ! from the ESMF_Base class ! !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmRead - restores an alarm ! !INTERFACE: subroutine ESMF_AlarmRead(alarm, RingInterval, RingTime, & PrevRingTime, StopTime, Ringing, & Enabled, ID, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(out) :: alarm type(ESMF_TimeInterval), intent(in) :: RingInterval type(ESMF_Time), intent(in) :: RingTime type(ESMF_Time), intent(in) :: PrevRingTime type(ESMF_Time), intent(in) :: StopTime logical, intent(in) :: Ringing logical, intent(in) :: Enabled integer, intent(in) :: ID integer, intent(out), optional :: rc ! !DESCRIPTION: ! Restores an {\tt ESMF\_Alarm} ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to restore ! \item[RingInterval] ! The ring interval for repeating alarms ! \item[RingTime] ! Ring time for one-shot or first repeating alarm ! \item[PrevRingTime] ! The {\tt ESMF\_Alarm}'s previous ring time ! \item[StopTime] ! Stop time for repeating alarms ! \item[Ringing] ! The {\tt ESMF\_Alarm}'s ringing state ! \item[Enabled] ! {\tt ESMF\_Alarm} enabled/disabled ! \item[ID] ! The {\tt ESMF\_Alarm}'s ID ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: !EOP CALL wrf_error_fatal( 'ESMF_AlarmRead not supported' ) end subroutine ESMF_AlarmRead !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmWrite - saves an alarm ! !INTERFACE: subroutine ESMF_AlarmWrite(alarm, RingInterval, RingTime, & PrevRingTime, StopTime, Ringing, & Enabled, ID, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(in) :: alarm type(ESMF_TimeInterval), intent(out) :: RingInterval type(ESMF_Time), intent(out) :: RingTime type(ESMF_Time), intent(out) :: PrevRingTime type(ESMF_Time), intent(out) :: StopTime logical, intent(out) :: Ringing logical, intent(out) :: Enabled integer, intent(out) :: ID integer, intent(out), optional :: rc ! !DESCRIPTION: ! Saves an {\tt ESMF\_Alarm} ! ! The arguments are: ! \begin{description} ! \item[alarm] ! The object instance to save ! \item[RingInterval] ! Ring interval for repeating alarms ! \item[RingTime] ! Ring time for one-shot or first repeating alarm ! \item[PrevRingTime] ! The {\tt ESMF\_Alarm}'s previous ring time ! \item[StopTime] ! Stop time for repeating alarms ! \item[Ringing] ! The {\tt ESMF\_Alarm}'s ringing state ! \item[Enabled] ! {\tt ESMF\_Alarm} enabled/disabled ! \item[ID] ! The {\tt ESMF\_Alarm}'s ID ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! ! !REQUIREMENTS: !EOP CALL wrf_error_fatal( 'ESMF_AlarmWrite not supported' ) end subroutine ESMF_AlarmWrite !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmValidate - Validate an Alarm's properties ! !INTERFACE: subroutine ESMF_AlarmValidate(alarm, opts, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(in) :: alarm character (len=*), intent(in), optional :: opts integer, intent(out), optional :: rc ! !DESCRIPTION: ! Perform a validation check on a {\tt ESMF\_Alarm}'s properties ! ! The arguments are: ! \begin{description} ! \item[alarm] ! {\tt ESMF\_Alarm} 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_AlarmValidate not supported' ) end subroutine ESMF_AlarmValidate !------------------------------------------------------------------------------ !BOP ! !IROUTINE: ESMF_AlarmPrint - Print out an Alarm's properties ! !INTERFACE: subroutine ESMF_AlarmPrint(alarm, opts, rc) ! !ARGUMENTS: type(ESMF_Alarm), intent(in) :: alarm character (len=*), intent(in), optional :: opts integer, intent(out), optional :: rc ! !DESCRIPTION: ! To support testing/debugging, print out a {\tt ESMF\_Alarm}'s ! properties. ! ! The arguments are: ! \begin{description} ! \item[alarm] ! {\tt ESMF\_Alarm} 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 integer :: ierr type(ESMF_Time) :: ringtime type(ESMF_Time) :: prevringtime type(ESMF_TimeInterval) :: ringinterval character(len=256) :: name IF ( ASSOCIATED( alarm%alarmint ) ) THEN IF ( alarm%alarmint%RingTimeSet )THEN call ESMF_AlarmGet( alarm, name=name, ringtime=ringtime, & prevringtime=prevringtime, rc=ierr ) IF ( PRESENT(rc) .AND. (ierr /= ESMF_SUCCESS) )THEN rc = ierr END IF print *, 'Alarm name: ', trim(name) print *, 'Next ring time' call ESMF_TimePrint( ringtime ) print *, 'Previous ring time' call ESMF_TimePrint( prevringtime ) END IF IF ( alarm%alarmint%RingIntervalSet )THEN call ESMF_AlarmGet( alarm, ringinterval=ringinterval, rc=ierr ) IF ( PRESENT(rc) .AND. (ierr /= ESMF_SUCCESS) )THEN rc = ierr END IF print *, 'Ring Interval' call ESMF_TimeIntervalPrint( ringinterval ) END IF END IF end subroutine ESMF_AlarmPrint !------------------------------------------------------------------------------ end module ESMF_AlarmMod