wrfv2_fire/external/esmf_time_f90/ESMF_Clock.F90

   1 !
   2 ! Earth System Modeling Framework
   3 ! Copyright 2002-2003, University Corporation for Atmospheric Research,
   4 ! Massachusetts Institute of Technology, Geophysical Fluid Dynamics
   5 ! Laboratory, University of Michigan, National Centers for Environmental
   6 ! Prediction, Los Alamos National Laboratory, Argonne National Laboratory,
   7 ! NASA Goddard Space Flight Center.
   8 ! Licensed under the University of Illinois-NCSA license.
   9 !
  10 !==============================================================================
  11 !
  12 !     ESMF Clock Module
  13       module ESMF_ClockMod
  14 !
  15 !==============================================================================
  16 !
  17 ! This file contains the Clock class definition and all Clock class methods.
  18 !
  19 !------------------------------------------------------------------------------
  20 ! INCLUDES
  21 #include <ESMF_TimeMgr.inc>
  22
  23 !==============================================================================
  24 !BOPI
  25 ! !MODULE: ESMF_ClockMod
  26 !
  27 ! !DESCRIPTION:
  28 ! Part of Time Manager F90 API wrapper of C++ implemenation
  29 !
  30 ! Defines F90 wrapper entry points for corresponding
  31 ! C++ class {\tt ESMC\_Time} implementation
  32 !
  33 ! See {\tt ../include/ESMC\_Clock.h} for complete description
  34 !
  35 !------------------------------------------------------------------------------
  36 ! !USES:
  37       ! inherit from ESMF base class
  38       use ESMF_BaseMod
  39
  40       ! associated derived types
  41       use ESMF_TimeIntervalMod   ! , only : ESMF_TimeInterval, &
  42                                  !          ESMF_TimeIntervalIsPositive
  43       use ESMF_TimeMod           ! , only : ESMF_Time
  44       use ESMF_AlarmMod,        only : ESMF_Alarm
  45
  46       implicit none
  47 !
  48 !------------------------------------------------------------------------------
  49 ! !PRIVATE TYPES:
  50       private
  51 !------------------------------------------------------------------------------
  52 !     ! ESMF_Clock
  53 !
  54 !     ! F90 class type to match C++ Clock class in size only;
  55 !     !  all dereferencing within class is performed by C++ implementation
  56
  57 ! internals for ESMF_Clock
  58       type ESMF_ClockInt
  59         type(ESMF_TimeInterval) :: TimeStep
  60         type(ESMF_Time)  :: StartTime
  61         type(ESMF_Time)  :: StopTime
  62         type(ESMF_Time)  :: RefTime
  63         type(ESMF_Time)  :: CurrTime
  64         type(ESMF_Time)  :: PrevTime
  65         integer(ESMF_KIND_I8) :: AdvanceCount
  66         integer :: ClockMutex
  67         integer :: NumAlarms
  68         ! Note:  to mimic ESMF 2.1.0+, AlarmList is maintained
  69         ! within ESMF_Clock even though copies of each alarm are
  70         ! returned from ESMF_AlarmCreate() at the same time they
  71         ! are copied into the AlarmList!  This duplication is not
  72         ! as hideous as it might be because the ESMF_Alarm type
  73         ! has data members that are all POINTERs (thus the horrible
  74         ! shallow-copy-masquerading-as-reference-copy hack works).
  75         type(ESMF_Alarm), pointer, dimension(:) :: AlarmList
  76       end type
  77
  78 ! Actual public type:  this bit allows easy mimic of "deep" ESMF_ClockCreate
  79 ! in ESMF 2.1.0+
  80 ! NOTE:  DO NOT ADD NON-POINTER STATE TO THIS DATA TYPE.  It emulates ESMF
  81 !        shallow-copy-masquerading-as-reference-copy.
  82       type ESMF_Clock
  83         type(ESMF_ClockInt), pointer  :: clockint
  84       end type
  85
  86 !------------------------------------------------------------------------------
  87 ! !PUBLIC TYPES:
  88       public ESMF_Clock
  89       public ESMF_ClockInt   ! needed on AIX but not PGI
  90 !------------------------------------------------------------------------------
  91 !
  92 ! !PUBLIC MEMBER FUNCTIONS:
  93       public ESMF_ClockCreate
  94       public ESMF_ClockDestroy
  95       public ESMF_ClockSet
  96 !      public ESMF_ClockSetOLD
  97       public ESMF_ClockGet
  98 !      public ESMF_ClockGetAdvanceCount
  99 !      public ESMF_ClockGetTimeStep
 100 !      public ESMF_ClockSetTimeStep
 101 !      public ESMF_ClockGetCurrTime
 102 !      public ESMF_ClockSetCurrTime
 103 !      public ESMF_ClockGetStartTime
 104 !      public ESMF_ClockGetStopTime
 105 !      public ESMF_ClockGetRefTime
 106 !      public ESMF_ClockGetPrevTime
 107 !      public ESMF_ClockGetCurrSimTime
 108 !      public ESMF_ClockGetPrevSimTime
 109 ! This must be public for ESMF_AlarmClockMod...
 110       public ESMF_ClockAddAlarm
 111       public ESMF_ClockGetAlarmList
 112 !      public ESMF_ClockGetNumAlarms
 113 !      public ESMF_ClockSyncToWallClock
 114       public ESMF_ClockAdvance
 115       public ESMF_ClockIsStopTime
 116       public ESMF_ClockStopTimeDisable
 117
 118 ! Required inherited and overridden ESMF_Base class methods
 119
 120 !      public ESMF_ClockRead
 121 !      public ESMF_ClockWrite
 122       public ESMF_ClockValidate
 123       public ESMF_ClockPrint
 124 !EOPI
 125
 126 !==============================================================================
 127
 128       contains
 129
 130 !==============================================================================
 131 !
 132 ! This section includes the Set methods.
 133 !
 134 !------------------------------------------------------------------------------
 135 !BOP
 136 ! !IROUTINE: ESMF_ClockSetOLD - Initialize a clockint
 137
 138 ! !INTERFACE:
 139       subroutine ESMF_ClockSetOLD(clockint, TimeStep, StartTime, &
 140                                   StopTime, RefTime, rc)
 141
 142 ! !ARGUMENTS:
 143       type(ESMF_ClockInt), intent(out) :: clockint
 144       type(ESMF_TimeInterval), intent(in), optional :: TimeStep
 145       type(ESMF_Time), intent(in) :: StartTime
 146       type(ESMF_Time), intent(in) :: StopTime
 147       type(ESMF_Time), intent(in), optional :: RefTime
 148       integer, intent(out), optional :: rc
 149 ! Local
 150       integer i
 151
 152 ! !DESCRIPTION:
 153 !     Initialize an {\tt ESMF\_Clock}
 154 !
 155 !     The arguments are:
 156 !     \begin{description}
 157 !     \item[clockint]
 158 !          The object instance to initialize
 159 !     \item[{[TimeStep]}]
 160 !          The {\tt ESMF\_Clock}'s time step interval
 161 !     \item[StartTime]
 162 !          The {\tt ESMF\_Clock}'s starting time
 163 !     \item[StopTime]
 164 !          The {\tt ESMF\_Clock}'s stopping time
 165 !     \item[{[RefTime]}]
 166 !          The {\tt ESMF\_Clock}'s reference time
 167 !     \item[{[rc]}]
 168 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 169 !     \end{description}
 170 !
 171 ! !REQUIREMENTS:
 172 !     TMG3.1, TMG3.4.4
 173 !EOP
 174       IF ( PRESENT(TimeStep) ) clockint%TimeStep = TimeStep
 175       IF ( PRESENT(RefTime) )THEN
 176          clockint%RefTime = RefTime
 177       ELSE
 178          clockint%RefTime = StartTime
 179       END IF
 180       clockint%CurrTime = StartTime
 181       clockint%StartTime = StartTime
 182       clockint%StopTime = StopTime
 183       clockint%NumAlarms = 0
 184       clockint%AdvanceCount = 0
 185       ALLOCATE(clockint%AlarmList(MAX_ALARMS))
 186       ! TBH:  This incredible hack can be removed once ESMF_*Validate()
 187       ! TBH:  can tell if a deep ESMF_* was created or not.
 188       DO i = 1, MAX_ALARMS
 189         NULLIFY( clockint%AlarmList( i )%alarmint )
 190       ENDDO
 191       IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS
 192
 193       end subroutine ESMF_ClockSetOLD
 194
 195
 196 ! !IROUTINE: ESMF_ClockSet - Set clock properties -- for compatibility with ESMF 2.0.1
 197
 198 ! !INTERFACE:
 199       subroutine ESMF_ClockSet(clock, TimeStep, StartTime, StopTime, &
 200                                RefTime, CurrTime, rc)
 201
 202 ! !ARGUMENTS:
 203       type(ESMF_Clock), intent(inout) :: clock
 204       type(ESMF_TimeInterval), intent(in), optional :: TimeStep
 205       type(ESMF_Time), intent(in), optional :: StartTime
 206       type(ESMF_Time), intent(in), optional :: StopTime
 207       type(ESMF_Time), intent(in), optional :: RefTime
 208       type(ESMF_Time), intent(in), optional :: CurrTime
 209       integer, intent(out), optional :: rc
 210 ! Local
 211       integer ierr
 212
 213 ! !DESCRIPTION:
 214 !     Initialize an {\tt ESMF\_Clock}
 215 !
 216 !     The arguments are:
 217 !     \begin{description}
 218 !     \item[clock]
 219 !          The object instance to initialize
 220 !     \item[{[TimeStep]}]
 221 !          The {\tt ESMF\_Clock}'s time step interval
 222 !     \item[StartTime]
 223 !          The {\tt ESMF\_Clock}'s starting time
 224 !     \item[StopTime]
 225 !          The {\tt ESMF\_Clock}'s stopping time
 226 !     \item[{[RefTime]}]
 227 !          The {\tt ESMF\_Clock}'s reference time
 228 !     \item[{[rc]}]
 229 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 230 !     \end{description}
 231 !
 232 ! !REQUIREMENTS:
 233 !     TMG3.1, TMG3.4.4
 234 !EOP
 235       ierr = ESMF_SUCCESS
 236       IF ( PRESENT(TimeStep) ) THEN
 237         CALL ESMF_ClockSetTimeStep ( clock, TimeStep, rc=ierr )
 238       ENDIF
 239       IF ( PRESENT(RefTime) ) clock%clockint%RefTime = RefTime
 240       IF ( PRESENT(StartTime) ) clock%clockint%StartTime = StartTime
 241       IF ( PRESENT(StopTime) ) clock%clockint%StopTime = StopTime
 242       IF ( PRESENT(CurrTime) ) THEN
 243         CALL ESMF_ClockSetCurrTime(clock, CurrTime, rc=ierr)
 244       ENDIF
 245       IF ( PRESENT(rc) ) rc = ierr
 246
 247       end subroutine ESMF_ClockSet
 248
 249
 250 ! Create ESMF_Clock using ESMF 2.1.0+ semantics
 251       FUNCTION ESMF_ClockCreate( name, TimeStep, StartTime, StopTime, &
 252                                  RefTime, rc )
 253         ! return value
 254         type(ESMF_Clock) :: ESMF_ClockCreate
 255         ! !ARGUMENTS:
 256         character (len=*),       intent(in),  optional :: name
 257         type(ESMF_TimeInterval), intent(in), optional :: TimeStep
 258         type(ESMF_Time), intent(in) :: StartTime
 259         type(ESMF_Time), intent(in) :: StopTime
 260         type(ESMF_Time), intent(in), optional :: RefTime
 261         integer, intent(out), optional :: rc
 262         ! locals
 263         type(ESMF_Clock) :: clocktmp
 264          ! TBH:  ignore allocate errors, for now
 265         ALLOCATE( clocktmp%clockint )
 266         CALL ESMF_ClockSetOLD( clocktmp%clockint,   &
 267                                TimeStep= TimeStep,  &
 268                                StartTime=StartTime, &
 269                                StopTime= StopTime,  &
 270                                RefTime=RefTime, rc=rc )
 271         ESMF_ClockCreate = clocktmp
 272       END FUNCTION ESMF_ClockCreate
 273
 274
 275 ! Deallocate memory for ESMF_Clock
 276       SUBROUTINE ESMF_ClockDestroy( clock, rc )
 277          TYPE(ESMF_Clock), INTENT(INOUT) :: clock
 278          INTEGER,          INTENT(  OUT), OPTIONAL :: rc
 279          ! TBH:  ignore deallocate errors, for now
 280          DEALLOCATE( clock%clockint%AlarmList )
 281          DEALLOCATE( clock%clockint )
 282          IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS
 283       END SUBROUTINE ESMF_ClockDestroy
 284
 285
 286 !------------------------------------------------------------------------------
 287 !BOP
 288 ! !IROUTINE: ESMF_ClockGet - Get clock properties -- for compatibility with ESMF 2.0.1
 289
 290 ! !INTERFACE:
 291       subroutine ESMF_ClockGet(clock, StartTime, CurrTime,       &
 292                                AdvanceCount, StopTime, TimeStep, &
 293                                PrevTime, RefTime, &
 294                                rc)
 295
 296 ! !ARGUMENTS:
 297       type(ESMF_Clock), intent(in) :: clock
 298       type(ESMF_Time), intent(out), optional :: StartTime
 299       type(ESMF_Time), intent(out), optional :: CurrTime
 300       type(ESMF_Time), intent(out), optional :: StopTime
 301       type(ESMF_Time), intent(out), optional :: PrevTime
 302       type(ESMF_Time), intent(out), optional :: RefTime
 303       integer(ESMF_KIND_I8), intent(out), optional :: AdvanceCount
 304       type(ESMF_TimeInterval), intent(out), optional :: TimeStep
 305       integer, intent(out), optional :: rc
 306       integer :: ierr
 307
 308 ! !DESCRIPTION:
 309 !     Returns the number of times the {\tt ESMF\_Clock} has been advanced
 310 !     (time stepped)
 311 !
 312 !     The arguments are:
 313 !     \begin{description}
 314 !     \item[clock]
 315 !          The object instance to get the advance count from
 316 !     \item[StartTime]
 317 !          The start time
 318 !     \item[CurrTime]
 319 !          The current time
 320 !     \item[AdvanceCount]
 321 !          The number of times the {\tt ESMF\_Clock} has been advanced
 322 !     \item[StopTime]
 323 !          The {\tt ESMF\_Clock}'s stopping time
 324 !     \item[{[TimeStep]}]
 325 !          The {\tt ESMF\_Clock}'s time step interval
 326 !     \item[{[PrevTime]}]
 327 !          The {\tt ESMF\_Clock}'s previous current time
 328 !     \item[{[PrevTime]}]
 329 !          The {\tt ESMF\_Clock}'s reference time
 330 !     \item[{[rc]}]
 331 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 332 !     \end{description}
 333
 334 ! !REQUIREMENTS:
 335 !     TMG3.5.1
 336 !EOP
 337       ierr = ESMF_SUCCESS
 338
 339       IF ( PRESENT (StartTime) ) THEN
 340         CALL ESMF_ClockGetStartTime( clock, StartTime=StartTime, rc=ierr )
 341       ENDIF
 342       IF ( PRESENT (CurrTime) ) THEN
 343         CALL ESMF_ClockGetCurrTime( clock , CurrTime, ierr )
 344       ENDIF
 345       IF ( PRESENT (StopTime) ) THEN
 346         CALL ESMF_ClockGetStopTime( clock , StopTime, ierr )
 347       ENDIF
 348       IF ( PRESENT (AdvanceCount) ) THEN
 349         CALL ESMF_ClockGetAdvanceCount(clock, AdvanceCount, ierr)
 350       ENDIF
 351       IF ( PRESENT (TimeStep) ) THEN
 352         CALL ESMF_ClockGetTimeStep(clock, TimeStep, ierr)
 353       ENDIF
 354       IF ( PRESENT (PrevTime) ) THEN
 355         CALL ESMF_ClockGetPrevTime(clock, PrevTime, ierr)
 356       ENDIF
 357       IF ( PRESENT (RefTime) ) THEN
 358         CALL ESMF_ClockGetRefTime(clock, RefTime, ierr)
 359       ENDIF
 360
 361       IF ( PRESENT (rc) ) THEN
 362         rc = ierr
 363       ENDIF
 364
 365       end subroutine ESMF_ClockGet
 366
 367
 368 ! !IROUTINE: ESMF_ClockGetAdvanceCount - Get the clock's advance count
 369
 370 ! !INTERFACE:
 371       subroutine ESMF_ClockGetAdvanceCount(clock, AdvanceCount, rc)
 372
 373 ! !ARGUMENTS:
 374       type(ESMF_Clock), intent(in) :: clock
 375       integer(ESMF_KIND_I8), intent(out) :: AdvanceCount
 376       integer, intent(out), optional :: rc
 377
 378 ! !DESCRIPTION:
 379 !     Returns the number of times the {\tt ESMF\_Clock} has been advanced
 380 !     (time stepped)
 381 !
 382 !     The arguments are:
 383 !     \begin{description}
 384 !     \item[clock]
 385 !          The object instance to get the advance count from
 386 !     \item[AdvanceCount]
 387 !          The number of times the {\tt ESMF\_Clock} has been advanced
 388 !     \item[{[rc]}]
 389 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 390 !     \end{description}
 391
 392 ! !REQUIREMENTS:
 393 !     TMG3.5.1
 394 !EOP
 395
 396       AdvanceCount = clock%clockint%AdvanceCount
 397
 398       IF ( PRESENT(rc) ) rc = ESMF_SUCCESS
 399
 400       end subroutine ESMF_ClockGetAdvanceCount
 401
 402 !------------------------------------------------------------------------------
 403 !BOP
 404 ! !IROUTINE: ESMF_ClockGetTimeStep - Get a clock's timestep interval
 405
 406 ! !INTERFACE:
 407       subroutine ESMF_ClockGetTimeStep(clock, TimeStep, rc)
 408
 409 ! !ARGUMENTS:
 410       type(ESMF_Clock), intent(in) :: clock
 411       type(ESMF_TimeInterval), intent(out) :: TimeStep
 412       integer, intent(out), optional :: rc
 413
 414 ! !DESCRIPTION:
 415 !     Get an {\tt ESMF\_Clock}'s timestep interval
 416 !
 417 !     The arguments are:
 418 !     \begin{description}
 419 !     \item[clock]
 420 !          The object instance to get the time step from
 421 !     \item[TimeStep]
 422 !          The time step
 423 !     \item[{[rc]}]
 424 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 425 !     \end{description}
 426 !
 427 ! !REQUIREMENTS:
 428 !     TMG3.5.2
 429 !EOP
 430
 431       TimeStep = clock%clockint%TimeStep
 432       IF ( PRESENT(rc) ) rc = ESMF_SUCCESS
 433
 434       end subroutine ESMF_ClockGetTimeStep
 435
 436 !------------------------------------------------------------------------------
 437 !BOP
 438 ! !IROUTINE: ESMF_ClockSetTimeStep - Set a clock's timestep interval
 439
 440 ! !INTERFACE:
 441       subroutine ESMF_ClockSetTimeStep(clock, TimeStep, rc)
 442
 443 ! !ARGUMENTS:
 444       type(ESMF_Clock), intent(inout) :: clock  ! really INTENT(OUT)
 445       type(ESMF_TimeInterval), intent(in) :: TimeStep
 446       integer, intent(out), optional      :: rc
 447
 448 ! !DESCRIPTION:
 449 !     Set an {\tt ESMF\_Clock}'s timestep interval
 450 !
 451 !     The arguments are:
 452 !     \begin{description}
 453 !     \item[clock]
 454 !          The object instance to set the time step
 455 !     \item[TimeStep]
 456 !          The time step
 457 !     \item[{[rc]}]
 458 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 459 !     \end{description}
 460 !
 461 ! !REQUIREMENTS:
 462 !     TMG3.4.2
 463 !EOP
 464
 465       clock%clockint%TimeStep = TimeStep
 466       IF ( PRESENT(rc) ) rc = ESMF_SUCCESS
 467
 468       end subroutine ESMF_ClockSetTimeStep
 469
 470 !------------------------------------------------------------------------------
 471 !BOP
 472 ! !IROUTINE: ESMF_ClockGetCurrTime - Get a clock's current time
 473
 474 ! !INTERFACE:
 475       subroutine ESMF_ClockGetCurrTime(clock, CurrTime, rc)
 476
 477 ! !ARGUMENTS:
 478       type(ESMF_Clock), intent(in) :: clock
 479       type(ESMF_Time), intent(out) :: CurrTime
 480       integer, intent(out), optional :: rc
 481
 482 ! !DESCRIPTION:
 483 !     Get an {\tt ESMF\_Clock}'s current time
 484 !
 485 !     The arguments are:
 486 !     \begin{description}
 487 !     \item[clock]
 488 !          The object instance to get the current time from
 489 !     \item[CurrTime]
 490 !          The current time
 491 !     \item[{[rc]}]
 492 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 493 !     \end{description}
 494 !
 495 ! !REQUIREMENTS:
 496 !     TMG3.5.4
 497 !EOP
 498
 499       CurrTime = clock%clockint%CurrTime
 500       IF ( PRESENT(rc) ) rc = ESMF_SUCCESS
 501       end subroutine ESMF_ClockGetCurrTime
 502
 503 !------------------------------------------------------------------------------
 504 !BOP
 505 ! !IROUTINE: ESMF_ClockSetCurrTime - Set a clock's current time
 506
 507 ! !INTERFACE:
 508       subroutine ESMF_ClockSetCurrTime(clock, CurrTime, rc)
 509
 510 ! !ARGUMENTS:
 511       type(ESMF_Clock), intent(inout) :: clock  ! really INTENT(OUT)
 512       type(ESMF_Time), intent(in) :: CurrTime
 513       integer, intent(out), optional :: rc
 514
 515 ! !DESCRIPTION:
 516 !     Set an {\tt ESMF\_Clock}'s current time
 517 !
 518 !     The arguments are:
 519 !     \begin{description}
 520 !     \item[clock]
 521 !          The object instance to set the current time from
 522 !     \item[CurrTime]
 523 !          The current time
 524 !     \item[{[rc]}]
 525 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 526 !     \end{description}
 527 !
 528 ! !REQUIREMENTS:
 529 !     TMG3.4.3
 530 !EOP
 531
 532       clock%clockint%CurrTime = CurrTime
 533       IF ( PRESENT(rc) ) rc = ESMF_SUCCESS
 534
 535       end subroutine ESMF_ClockSetCurrTime
 536
 537 !------------------------------------------------------------------------------
 538 !BOP
 539 ! !IROUTINE: ESMF_ClockGetStartTime - Get a clock's start time
 540
 541 ! !INTERFACE:
 542       subroutine ESMF_ClockGetStartTime(clock, StartTime, rc)
 543
 544 ! !ARGUMENTS:
 545       type(ESMF_Clock), intent(in) :: clock
 546       type(ESMF_Time), intent(out) :: StartTime
 547       integer, intent(out), optional :: rc
 548
 549 ! !DESCRIPTION:
 550 !     Get an {\tt ESMF\_Clock}'s start time
 551 !
 552 !     The arguments are:
 553 !     \begin{description}
 554 !     \item[clock]
 555 !          The object instance to get the start time from
 556 !     \item[StartTime]
 557 !          The start time
 558 !     \item[{[rc]}]
 559 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 560 !     \end{description}
 561 !
 562 ! !REQUIREMENTS:
 563 !     TMG3.5.3
 564 !EOP
 565
 566       StartTime = clock%clockint%StartTime
 567       IF ( PRESENT(rc) ) rc = ESMF_SUCCESS
 568
 569       end subroutine ESMF_ClockGetStartTime
 570
 571 !------------------------------------------------------------------------------
 572 !BOP
 573 ! !IROUTINE: ESMF_ClockGetStopTime - Get a clock's stop time
 574
 575 ! !INTERFACE:
 576       subroutine ESMF_ClockGetStopTime(clock, StopTime, rc)
 577
 578 ! !ARGUMENTS:
 579       type(ESMF_Clock), intent(in) :: clock
 580       type(ESMF_Time), intent(out) :: StopTime
 581       integer, intent(out), optional :: rc
 582
 583 ! !DESCRIPTION:
 584 !     Get an {\tt ESMF\_Clock}'s stop time
 585 !
 586 !     The arguments are:
 587 !     \begin{description}
 588 !     \item[clock]
 589 !          The object instance to get the stop time from
 590 !     \item[StopTime]
 591 !          The stop time
 592 !     \item[{[rc]}]
 593 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 594 !     \end{description}
 595 !
 596 ! !REQUIREMENTS:
 597 !     TMG3.5.3
 598 !EOP
 599
 600       StopTime = clock%clockint%StopTime
 601       IF ( PRESENT(rc) ) rc = ESMF_SUCCESS
 602
 603       end subroutine ESMF_ClockGetStopTime
 604
 605 !------------------------------------------------------------------------------
 606 !BOP
 607 ! !IROUTINE: ESMF_ClockGetRefTime - Get a clock's reference time
 608
 609 ! !INTERFACE:
 610       subroutine ESMF_ClockGetRefTime(clock, RefTime, rc)
 611
 612 ! !ARGUMENTS:
 613       type(ESMF_Clock), intent(in) :: clock
 614       type(ESMF_Time), intent(out) :: RefTime
 615       integer, intent(out), optional :: rc
 616
 617 ! !DESCRIPTION:
 618 !     Get an {\tt ESMF\_Clock}'s reference time
 619 !
 620 !     The arguments are:
 621 !     \begin{description}
 622 !     \item[clock]
 623 !          The object instance to get the reference time from
 624 !     \item[RefTime]
 625 !          The reference time
 626 !     \item[{[rc]}]
 627 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 628 !     \end{description}
 629 !
 630 ! !REQUIREMENTS:
 631 !     TMG3.5.3
 632 !EOP
 633       refTime = clock%clockint%RefTime
 634       IF ( PRESENT(rc) ) rc = ESMF_SUCCESS
 635       end subroutine ESMF_ClockGetRefTime
 636
 637 !------------------------------------------------------------------------------
 638 !BOP
 639 ! !IROUTINE: ESMF_ClockGetPrevTime - Get a clock's previous current time
 640
 641 ! !INTERFACE:
 642       subroutine ESMF_ClockGetPrevTime(clock, PrevTime, rc)
 643
 644 ! !ARGUMENTS:
 645       type(ESMF_Clock), intent(in) :: clock
 646       type(ESMF_Time), intent(out) :: PrevTime
 647       integer, intent(out), optional :: rc
 648
 649 ! !DESCRIPTION:
 650 !     Get an {\tt ESMF\_Clock}'s previous current time
 651 !
 652 !     The arguments are:
 653 !     \begin{description}
 654 !     \item[clock]
 655 !          The object instance to get the previous current time from
 656 !     \item[PrevTime]
 657 !          The previous current time
 658 !     \item[{[rc]}]
 659 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 660 !     \end{description}
 661 !
 662 ! !REQUIREMENTS:
 663 !     TMG3.5.4
 664 !EOP
 665
 666 ! hack for bug in PGI 5.1-x
 667 !      prevTime = Clock%clockint%CurrTime - Clock%clockint%TimeStep
 668       prevTime = ESMF_TimeDec( Clock%clockint%CurrTime, &
 669                                Clock%clockint%TimeStep )
 670
 671       IF ( PRESENT(rc) ) rc = ESMF_SUCCESS
 672       end subroutine ESMF_ClockGetPrevTime
 673
 674 !------------------------------------------------------------------------------
 675 !BOP
 676 ! !IROUTINE: ESMF_ClockGetCurrSimTime - Get a clock's current simulation time
 677
 678 ! !INTERFACE:
 679       subroutine ESMF_ClockGetCurrSimTime(clock, CurrSimTime, rc)
 680
 681 ! !ARGUMENTS:
 682       type(ESMF_Clock), intent(in) :: clock
 683       type(ESMF_TimeInterval), intent(out) :: CurrSimTime
 684       integer, intent(out), optional :: rc
 685
 686 ! !DESCRIPTION:
 687 !     Get an {\tt ESMF\_Clock}'s current simulation time
 688 !
 689 !     The arguments are:
 690 !     \begin{description}
 691 !     \item[clock]
 692 !          The object instance to get the current simulation time from
 693 !     \item[CurrSimTime]
 694 !          The current simulation time
 695 !     \item[{[rc]}]
 696 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 697 !     \end{description}
 698 !
 699 ! !REQUIREMENTS:
 700 !     TMG3.5.5
 701 !EOP
 702       CALL wrf_error_fatal( 'ESMF_ClockGetCurrSimTime not supported' )
 703       end subroutine ESMF_ClockGetCurrSimTime
 704
 705 !------------------------------------------------------------------------------
 706 !BOP
 707 ! !IROUTINE: ESMF_ClockGetPrevSimTime - Get a clock's previous simulation time
 708
 709 ! !INTERFACE:
 710       subroutine ESMF_ClockGetPrevSimTime(clock, PrevSimTime, rc)
 711
 712 ! !ARGUMENTS:
 713       type(ESMF_Clock), intent(in) :: clock
 714       type(ESMF_TimeInterval), intent(out) :: PrevSimTime
 715       integer, intent(out), optional :: rc
 716
 717 ! !DESCRIPTION:
 718 !     Get an {\tt ESMF\_Clock}'s previous simulation time
 719 !
 720 !     The arguments are:
 721 !     \begin{description}
 722 !     \item[clock]
 723 !          The object instance to get the previous simulation time from
 724 !     \item[PrevSimTime]
 725 !          The previous simulation time
 726 !     \item[{[rc]}]
 727 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 728 !     \end{description}
 729 !
 730 ! !REQUIREMENTS:
 731 !     TMG3.5.5
 732 !EOP
 733       CALL wrf_error_fatal( 'ESMF_ClockGetPrevSimTime not supported' )
 734       end subroutine ESMF_ClockGetPrevSimTime
 735
 736 !------------------------------------------------------------------------------
 737 !BOP
 738 ! !IROUTINE: ESMF_ClockAddAlarm - Add an alarm to a clock's alarm list
 739
 740 ! !INTERFACE:
 741       subroutine ESMF_ClockAddAlarm(clock, Alarm, rc)
 742
 743 ! !ARGUMENTS:
 744       type(ESMF_Clock), intent(inout) :: clock
 745       type(ESMF_Alarm), intent(inout) :: Alarm
 746       integer, intent(out), optional :: rc
 747
 748 ! !DESCRIPTION:
 749 !     Add an {\tt ESMF\_Alarm} to an {\tt ESMF\_Clock}'s {\tt ESMF\_Alarm} list
 750 !
 751 !     The arguments are:
 752 !     \begin{description}
 753 !     \item[clock]
 754 !          The object instance to add an {\tt ESMF\_Alarm} to
 755 !     \item[Alarm]
 756 !          The {\tt ESMF\_Alarm} to add to the {\tt ESMF\_Clock}'s
 757 !          {\tt ESMF\_Alarm} list
 758 !     \item[{[rc]}]
 759 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 760 !     \end{description}
 761 !
 762 ! !REQUIREMENTS:
 763 !     TMG4.1, TMG4.2
 764 !EOP
 765
 766       IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS
 767       clock%clockint%NumAlarms = clock%clockint%NumAlarms + 1
 768       IF ( clock%clockint%NumAlarms > SIZE (clock%clockint%AlarmList) ) THEN
 769         CALL wrf_error_fatal ( 'ESMF_ClockAddAlarm:  too many alarms' )
 770       ELSE IF ( .NOT. ASSOCIATED( Alarm%alarmint ) ) THEN
 771         CALL wrf_error_fatal ( &
 772                'ESMF_ClockAddAlarm:  alarm not created' )
 773       ELSE
 774         IF ( Alarm%alarmint%RingTimeSet ) THEN
 775            Alarm%alarmint%PrevRingTime = Alarm%alarmint%RingTime
 776         ELSE
 777 !TBH:  This has the nasty side-effect of forcing us to explicitly turn on
 778 !TBH:  alarms that are created with RingInterval only, if we want them to start
 779 !TBH:  ringing right away.  And this is done (see
 780 !TBH:  COMPUTE_VORTEX_CENTER_ALARM).  Straighten this out...
 781            Alarm%alarmint%PrevRingTime = clock%clockint%CurrTime
 782         ENDIF
 783         Alarm%alarmint%Ringing = .FALSE.
 784
 785         ! finally, load the alarm into the list
 786         clock%clockint%AlarmList(clock%clockint%NumAlarms) = Alarm
 787       ENDIF
 788
 789       end subroutine ESMF_ClockAddAlarm
 790
 791 !------------------------------------------------------------------------------
 792 !BOP
 793 ! !IROUTINE: ESMF_ClockGetAlarmList - Get a clock's alarm list
 794
 795 ! !INTERFACE:
 796       subroutine ESMF_ClockGetAlarmList(clock, AlarmList, rc)
 797
 798 ! !ARGUMENTS:
 799       type(ESMF_Clock), intent(in) :: clock
 800       type(ESMF_Alarm), pointer :: AlarmList(:)
 801       integer, intent(out), optional :: rc
 802
 803 ! !DESCRIPTION:
 804 !     Get an {\tt ESMF\_Clock}'s {\tt ESMF\_Alarm} list
 805 !
 806 !     The arguments are:
 807 !     \begin{description}
 808 !     \item[clock]
 809 !          The object instance to get the {\tt ESMF\_Alarm} list from
 810 !     \item[AlarmList]
 811 !          The {\tt ESMF\_Clock}'s {\tt ESMF\_Alarm} list
 812 !     \item[{[rc]}]
 813 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 814 !     \end{description}
 815 !
 816 ! !REQUIREMENTS:
 817 !     TMG4.3
 818 !EOP
 819
 820       AlarmList => clock%clockint%AlarmList
 821       IF ( PRESENT(rc) ) rc = ESMF_SUCCESS
 822
 823       end subroutine ESMF_ClockGetAlarmList
 824
 825 !------------------------------------------------------------------------------
 826 !BOP
 827 ! !IROUTINE: ESMF_ClockGetNumAlarms - Get the number of alarms in a clock's alarm list
 828
 829 ! !INTERFACE:
 830       subroutine ESMF_ClockGetNumAlarms(clock, NumAlarms, rc)
 831
 832 ! !ARGUMENTS:
 833       type(ESMF_Clock), intent(in) :: clock
 834       integer, intent(out) :: NumAlarms
 835       integer, intent(out), optional :: rc
 836
 837 ! !DESCRIPTION:
 838 !     Get the number of {\tt ESMF\_Alarm}s in an {\tt ESMF\_Clock}'s
 839 !       {\tt ESMF\_Alarm} list
 840 !
 841 !     The arguments are:
 842 !     \begin{description}
 843 !     \item[clock]
 844 !          The object instance to get the number of {\tt ESMF\_Alarm}s from
 845 !     \item[NumAlarms]
 846 !          The number of {\tt ESMF\_Alarm}s in the {\tt ESMF\_Clock}'s
 847 !            {\tt ESMF\_Alarm} list
 848 !     \item[{[rc]}]
 849 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 850 !     \end{description}
 851 !
 852 ! !REQUIREMENTS:
 853 !     TMG4.3
 854 !EOP
 855
 856       NumAlarms = clock%clockint%NumAlarms
 857       IF ( PRESENT(rc) ) rc = ESMF_SUCCESS
 858
 859       end subroutine ESMF_ClockGetNumAlarms
 860
 861 !------------------------------------------------------------------------------
 862 !BOP
 863 ! !IROUTINE: ESMF_ClockSyncToWallClock - Set clock's current time to wall clock time
 864
 865 ! !INTERFACE:
 866       subroutine ESMF_ClockSyncToWallClock(clock, rc)
 867
 868 ! !ARGUMENTS:
 869       type(ESMF_Clock), intent(inout) :: clock
 870       integer, intent(out), optional :: rc
 871
 872 ! !DESCRIPTION:
 873 !     Set an {\tt ESMF\_Clock}'s current time to wall clock time
 874 !
 875 !     The arguments are:
 876 !     \begin{description}
 877 !     \item[clock]
 878 !          The object instance to synchronize to wall clock time
 879 !     \item[{[rc]}]
 880 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 881 !     \end{description}
 882 !
 883 ! !REQUIREMENTS:
 884 !     TMG3.4.5
 885 !EOP
 886       CALL wrf_error_fatal( 'ESMF_ClockSyncToWallClock not supported' )
 887       end subroutine ESMF_ClockSyncToWallClock
 888
 889 !------------------------------------------------------------------------------
 890 !BOP
 891 ! !IROUTINE: ESMF_ClockAdvance - Advance a clock's current time by one time step
 892
 893 ! !INTERFACE:
 894       subroutine ESMF_ClockAdvance(clock, RingingAlarmList, &
 895                                    NumRingingAlarms, rc)
 896
 897 use esmf_timemod
 898
 899 ! !ARGUMENTS:
 900       type(ESMF_Clock), intent(inout) :: clock
 901       type(ESMF_Alarm), dimension(MAX_ALARMS), intent(out), optional :: &
 902                                         RingingAlarmList
 903       integer, intent(out), optional :: NumRingingAlarms
 904       integer, intent(out), optional :: rc
 905 ! Local
 906       logical pred1, pred2, pred3
 907       integer i, n
 908       type(ESMF_Alarm) :: alarm
 909       logical :: positive_timestep
 910 !
 911 ! !DESCRIPTION:
 912 !     Advance an {\tt ESMF\_Clock}'s current time by one time step
 913 !
 914 !     The arguments are:
 915 !     \begin{description}
 916 !     \item[clock]
 917 !          The object instance to advance
 918 !     \item[{[RingingAlarmList]}]
 919 !          Return a list of any ringing alarms after the time step
 920 !     \item[{[NumRingingAlarms]}]
 921 !          The number of ringing alarms returned
 922 !     \item[{[rc]}]
 923 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
 924 !     \end{description}
 925 !
 926 ! !REQUIREMENTS:
 927 !     TMG3.4.1
 928 !EOP
 929 ! hack for bug in PGI 5.1-x
 930 !      clock%clockint%CurrTime = clock%clockint%CurrTime + &
 931 !                                clock%clockint%TimeStep
 932       clock%clockint%CurrTime = ESMF_TimeInc( clock%clockint%CurrTime, &
 933                                               clock%clockint%TimeStep )
 934       positive_timestep = ESMF_TimeIntervalIsPositive( clock%clockint%TimeStep )
 935
 936       IF ( Present(NumRingingAlarms) ) NumRingingAlarms = 0
 937       clock%clockint%AdvanceCount = clock%clockint%AdvanceCount + 1
 938       DO i = 1, MAX_ALARMS
 939         alarm = clock%clockint%AlarmList(i)
 940         ! TBH:  This is really dangerous.  We need to be able to NULLIFY
 941         ! TBH:  alarmint at compile-time (F95 synax) to make this safe.
 942 !$$$TBH:  see if F95 compile-time pointer-nullification is supported by all
 943 !$$$TBH:  compilers we support
 944         IF ( ASSOCIATED( alarm%alarmint ) ) THEN
 945           IF ( alarm%alarmint%Enabled ) THEN
 946             IF ( alarm%alarmint%RingIntervalSet ) THEN
 947               pred1 = .FALSE. ; pred2 = .FALSE. ; pred3 = .FALSE.
 948               ! alarm cannot ring if clock has passed the alarms stop time
 949               IF ( alarm%alarmint%StopTimeSet ) THEN
 950                 IF ( positive_timestep ) THEN
 951 ! hack for bug in PGI 5.1-x
 952 !                  PRED1 = clock%clockint%CurrTime > alarm%alarmint%StopTime
 953                   PRED1 = ESMF_TimeGT( clock%clockint%CurrTime, &
 954                                        alarm%alarmint%StopTime )
 955                 ELSE
 956                   ! in this case time step is negative and stop time is
 957                   ! less than start time
 958 !                  PRED1 = clock%clockint%CurrTime < alarm%alarmint%StopTime
 959                   PRED1 = ESMF_TimeLT( clock%clockint%CurrTime, &
 960                                        alarm%alarmint%StopTime )
 961                 ENDIF
 962               ENDIF
 963               ! one-shot alarm:  check for ring time
 964 ! TBH:  Need to remove duplicated code.  Need to enforce only one of
 965 ! TBH:  alarm%alarmint%RingTimeSet or alarm%alarmint%RingIntervalSet ever
 966 ! TBH:  being .TRUE. and simplify the logic.  Also, the simpler
 967 ! TBH:  implementation in the duplicated code below should be sufficient.
 968               IF ( alarm%alarmint%RingTimeSet ) THEN
 969                 IF ( positive_timestep ) THEN
 970 ! hack for bug in PGI 5.1-x
 971 !                   PRED2 = ( alarm%alarmint%RingTime <= clock%clockint%CurrTime     &
 972 !                          .AND. clock%clockint%CurrTime < alarm%alarmint%RingTime + &
 973 !                                clock%clockint%TimeStep )
 974                    PRED2 = ( ESMF_TimeLE( alarm%alarmint%RingTime,       &
 975                                           clock%clockint%CurrTime )      &
 976                              .AND. ESMF_TimeLT( clock%clockint%CurrTime, &
 977                                ESMF_TimeInc( alarm%alarmint%RingTime,    &
 978                                              clock%clockint%TimeStep ) ) )
 979                 ELSE
 980                   ! in this case time step is negative and stop time is
 981                   ! less than start time
 982 ! hack for bug in PGI 5.1-x
 983 !                   PRED2 = ( alarm%alarmint%RingTime >= clock%clockint%CurrTime     &
 984 !                          .AND. clock%clockint%CurrTime > alarm%alarmint%RingTime + &
 985 !                                clock%clockint%TimeStep )
 986                    PRED2 = ( ESMF_TimeGE( alarm%alarmint%RingTime,       &
 987                                           clock%clockint%CurrTime )      &
 988                              .AND. ESMF_TimeGT( clock%clockint%CurrTime, &
 989                                ESMF_TimeInc( alarm%alarmint%RingTime,    &
 990                                              clock%clockint%TimeStep ) ) )
 991                 ENDIF
 992               ENDIF
 993               ! repeating alarm:  check for ring interval
 994               IF ( alarm%alarmint%RingIntervalSet ) THEN
 995                 IF ( positive_timestep ) THEN
 996 ! hack for bug in PGI 5.1-x
 997 !                   PRED3 = ( alarm%alarmint%PrevRingTime + alarm%alarmint%RingInterval <= &
 998 !                             clock%clockint%CurrTime )
 999
1000                    PRED3 = ( ESMF_TimeLE( ESMF_TimeInc(                  &
1001                                           alarm%alarmint%PrevRingTime,   &
1002                                           alarm%alarmint%RingInterval ), &
1003                              clock%clockint%CurrTime ) )
1004                 ELSE
1005                   ! in this case time step is negative and stop time is
1006                   ! less than start time
1007                   ! ring interval must always be positive
1008 ! hack for bug in PGI 5.1-x
1009 !                   PRED3 = ( alarm%alarmint%PrevRingTime - alarm%alarmint%RingInterval >= &
1010 !                             clock%clockint%CurrTime )
1011
1012                    PRED3 = ( ESMF_TimeGE( ESMF_TimeDec(                  &
1013                                           alarm%alarmint%PrevRingTime,   &
1014                                           alarm%alarmint%RingInterval ), &
1015                              clock%clockint%CurrTime ) )
1016                 ENDIF
1017               ENDIF
1018               IF ( ( .NOT. ( pred1 ) ) .AND. &
1019                    ( ( pred2 ) .OR. ( pred3 ) ) ) THEN
1020                  alarm%alarmint%Ringing = .TRUE.
1021                  IF ( positive_timestep ) THEN
1022 ! hack for bug in PGI 5.1-x
1023 !                   IF ( PRED3) alarm%alarmint%PrevRingTime = alarm%alarmint%PrevRingTime + &
1024 !                                                    alarm%alarmint%RingInterval
1025                    IF ( PRED3 )                                   &
1026                      alarm%alarmint%PrevRingTime =                &
1027                        ESMF_TimeInc( alarm%alarmint%PrevRingTime, &
1028                                      alarm%alarmint%RingInterval )
1029                  ELSE
1030                    ! in this case time step is negative and stop time is
1031                    ! less than start time
1032                    ! ring interval must always be positive
1033 ! hack for bug in PGI 5.1-x
1034 !                   IF ( PRED3) alarm%alarmint%PrevRingTime = alarm%alarmint%PrevRingTime - &
1035 !                                                    alarm%alarmint%RingInterval
1036                    IF ( PRED3 )                                   &
1037                      alarm%alarmint%PrevRingTime =                &
1038                        ESMF_TimeDec( alarm%alarmint%PrevRingTime, &
1039                                      alarm%alarmint%RingInterval )
1040                  ENDIF
1041                  IF ( PRESENT( RingingAlarmList ) .AND. &
1042                       PRESENT ( NumRingingAlarms ) ) THEN
1043                    NumRingingAlarms = NumRingingAlarms + 1
1044                    RingingAlarmList( NumRingingAlarms ) = alarm
1045                  ENDIF
1046               ENDIF
1047             ELSE IF ( alarm%alarmint%RingTimeSet ) THEN
1048 ! TBH:  Need to remove duplicated code.  Need to enforce only one of
1049 ! TBH:  alarm%alarmint%RingTimeSet or alarm%alarmint%RingIntervalSet ever
1050 ! TBH:  being .TRUE. and simplify the logic.  Also, the simpler
1051 ! TBH:  implementation in here should be sufficient.
1052               IF ( positive_timestep ) THEN
1053 ! hack for bug in PGI 5.1-x
1054 !                IF ( alarm%alarmint%RingTime <= clock%clockint%CurrTime ) THEN
1055                 IF ( ESMF_TimeLE( alarm%alarmint%RingTime, &
1056                                   clock%clockint%CurrTime ) ) THEN
1057                    alarm%alarmint%Ringing = .TRUE.
1058                    IF ( PRESENT( RingingAlarmList ) .AND. &
1059                         PRESENT ( NumRingingAlarms ) ) THEN
1060                      NumRingingAlarms = NumRingingAlarms + 1
1061                      RingingAlarmList( NumRingingAlarms ) = alarm
1062                    ENDIF
1063                 ENDIF
1064               ELSE
1065                 ! in this case time step is negative and stop time is
1066                 ! less than start time
1067 ! hack for bug in PGI 5.1-x
1068 !                IF ( alarm%alarmint%RingTime >= clock%clockint%CurrTime ) THEN
1069                 IF ( ESMF_TimeGE( alarm%alarmint%RingTime, &
1070                                   clock%clockint%CurrTime ) ) THEN
1071                    alarm%alarmint%Ringing = .TRUE.
1072                    IF ( PRESENT( RingingAlarmList ) .AND. &
1073                         PRESENT ( NumRingingAlarms ) ) THEN
1074                      NumRingingAlarms = NumRingingAlarms + 1
1075                      RingingAlarmList( NumRingingAlarms ) = alarm
1076                    ENDIF
1077                 ENDIF
1078               ENDIF
1079             ENDIF
1080             IF ( alarm%alarmint%StopTimeSet ) THEN
1081 ! TBH:  what is this for???
1082             ENDIF
1083           ENDIF
1084         ENDIF
1085         clock%clockint%AlarmList(i) = alarm
1086       ENDDO
1087       IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS
1088
1089       end subroutine ESMF_ClockAdvance
1090
1091 !------------------------------------------------------------------------------
1092 !BOP
1093 ! !IROUTINE: ESMF_ClockStopTimeDisable - NOOP for compatibility with ESMF 2.1.0+
1094
1095 ! !INTERFACE:
1096       subroutine ESMF_ClockStopTimeDisable(clock, rc)
1097 !
1098 ! !ARGUMENTS:
1099       type(ESMF_Clock), intent(in) :: clock
1100       integer, intent(out), optional :: rc
1101
1102       rc = ESMF_SUCCESS
1103
1104       end subroutine ESMF_ClockStopTimeDisable
1105
1106 !------------------------------------------------------------------------------
1107 !BOP
1108 ! !IROUTINE: ESMF_ClockIsStopTime - Has the clock reached its stop time ?
1109
1110 ! !INTERFACE:
1111       function ESMF_ClockIsStopTime(clock, rc)
1112 !
1113 ! !RETURN VALUE:
1114       logical :: ESMF_ClockIsStopTime
1115
1116 ! !ARGUMENTS:
1117       type(ESMF_Clock), intent(in) :: clock
1118       integer, intent(out), optional :: rc
1119       logical :: positive_timestep
1120
1121 ! !DESCRIPTION:
1122 !     Return true if {\tt ESMF\_Clock} has reached its stop time, false
1123 !     otherwise
1124 !
1125 !     The arguments are:
1126 !     \begin{description}
1127 !     \item[clock]
1128 !          The object instance to check
1129 !     \item[{[rc]}]
1130 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
1131 !     \end{description}
1132
1133 ! !REQUIREMENTS:
1134 !     TMG3.5.6
1135 !EOP
1136
1137       positive_timestep = ESMF_TimeIntervalIsPositive( clock%clockint%TimeStep )
1138       IF ( positive_timestep ) THEN
1139 ! hack for bug in PGI 5.1-x
1140 !        if ( clock%clockint%CurrTime .GE. clock%clockint%StopTime ) THEN
1141         if ( ESMF_TimeGE( clock%clockint%CurrTime, &
1142                           clock%clockint%StopTime ) ) THEN
1143           ESMF_ClockIsStopTime = .TRUE.
1144         else
1145           ESMF_ClockIsStopTime = .FALSE.
1146         endif
1147       ELSE
1148 ! hack for bug in PGI 5.1-x
1149 !        if ( clock%clockint%CurrTime .LE. clock%clockint%StopTime ) THEN
1150         if ( ESMF_TimeLE( clock%clockint%CurrTime, &
1151                           clock%clockint%StopTime ) ) THEN
1152           ESMF_ClockIsStopTime = .TRUE.
1153         else
1154           ESMF_ClockIsStopTime = .FALSE.
1155         endif
1156       ENDIF
1157       IF ( PRESENT( rc ) ) rc = ESMF_SUCCESS
1158
1159       end function ESMF_ClockIsStopTime
1160
1161 !------------------------------------------------------------------------------
1162 !
1163 ! This section defines the overridden Read, Write, Validate and Print methods
1164 ! from the ESMF_Base class
1165 !
1166 !------------------------------------------------------------------------------
1167 !BOP
1168 ! !IROUTINE: ESMF_ClockRead - Restores a clock
1169
1170 ! !INTERFACE:
1171       subroutine ESMF_ClockRead(clock, TimeStep, StartTime, StopTime, &
1172                                 RefTime, CurrTime, PrevTime, AdvanceCount, &
1173                                 AlarmList, rc)
1174
1175 ! !ARGUMENTS:
1176       type(ESMF_Clock), intent(out) :: clock
1177       type(ESMF_TimeInterval), intent(in) :: TimeStep
1178       type(ESMF_Time), intent(in) :: StartTime
1179       type(ESMF_Time), intent(in) :: StopTime
1180       type(ESMF_Time), intent(in) :: RefTime
1181       type(ESMF_Time), intent(in) :: CurrTime
1182       type(ESMF_Time), intent(in) :: PrevTime
1183       integer(ESMF_KIND_I8), intent(in) :: AdvanceCount
1184       type(ESMF_Alarm), dimension(MAX_ALARMS), intent(in) :: AlarmList
1185       integer, intent(out), optional :: rc
1186
1187 ! !DESCRIPTION:
1188 !     Restore an {\tt ESMF\_Clock}
1189 !
1190 !     The arguments are:
1191 !     \begin{description}
1192 !     \item[clock]
1193 !          The object instance to restore
1194 !     \item[TimeStep]
1195 !          The {\tt ESMF\_Clock}'s time step interval
1196 !     \item[StartTime]
1197 !          The {\tt ESMF\_Clock}'s starting time
1198 !     \item[StopTime]
1199 !          The {\tt ESMF\_Clock}'s stopping time
1200 !     \item[RefTime]
1201 !          The {\tt ESMF\_Clock}'s reference time
1202 !     \item[CurrTime]
1203 !          The {\tt ESMF\_Clock}'s current time
1204 !     \item[PrevTime]
1205 !          The {\tt ESMF\_Clock}'s previous time
1206 !     \item[AdvanceCount]
1207 !          The number of times the {\tt ESMF\_Clock} has been advanced
1208 !     \item[AlarmList]
1209 !          The {\tt ESMF\_Clock}'s {\tt ESMF\_Alarm} list
1210 !     \item[{[rc]}]
1211 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
1212 !     \end{description}
1213 !
1214 ! !REQUIREMENTS:
1215 !EOP
1216       CALL wrf_error_fatal( 'ESMF_ClockRead not supported' )
1217       end subroutine ESMF_ClockRead
1218
1219 !------------------------------------------------------------------------------
1220 !BOP
1221 ! !IROUTINE: ESMF_ClockWrite - Saves a clock
1222
1223 ! !INTERFACE:
1224       subroutine ESMF_ClockWrite(clock, TimeStep, StartTime, StopTime, &
1225                             RefTime, CurrTime, PrevTime, AdvanceCount, &
1226                             AlarmList, rc)
1227
1228 ! !ARGUMENTS:
1229       type(ESMF_Clock), intent(in) :: clock
1230       type(ESMF_TimeInterval), intent(out) :: TimeStep
1231       type(ESMF_Time), intent(out) :: StartTime
1232       type(ESMF_Time), intent(out) :: StopTime
1233       type(ESMF_Time), intent(out) :: RefTime
1234       type(ESMF_Time), intent(out) :: CurrTime
1235       type(ESMF_Time), intent(out) :: PrevTime
1236       integer(ESMF_KIND_I8), intent(out) :: AdvanceCount
1237       type(ESMF_Alarm), dimension(MAX_ALARMS), intent(out) :: AlarmList
1238       integer, intent(out), optional :: rc
1239
1240 ! !DESCRIPTION:
1241 !     Save an {\tt ESMF\_Clock}
1242 !
1243 !     The arguments are:
1244 !     \begin{description}
1245 !     \item[clock]
1246 !          The object instance to save
1247 !     \item[TimeStep]
1248 !          The {\tt ESMF\_Clock}'s time step interval
1249 !     \item[StartTime]
1250 !          The {\tt ESMF\_Clock}'s starting time
1251 !     \item[StopTime]
1252 !          The {\tt ESMF\_Clock}'s stopping time
1253 !     \item[RefTime]
1254 !          The {\tt ESMF\_Clock}'s reference time
1255 !     \item[CurrTime]
1256 !          The {\tt ESMF\_Clock}'s current time
1257 !     \item[PrevTime]
1258 !          The {\tt ESMF\_Clock}'s previous time
1259 !     \item[AdvanceCount]
1260 !          The number of times the {\tt ESMF\_Clock} has been advanced
1261 !     \item[AlarmList]
1262 !          The {\tt ESMF\_Clock}'s {\tt ESMF\_Alarm} list
1263 !     \item[{[rc]}]
1264 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
1265 !     \end{description}
1266 !
1267 ! !REQUIREMENTS:
1268 !EOP
1269       CALL wrf_error_fatal( 'ESMF_ClockWrite not supported' )
1270       end subroutine ESMF_ClockWrite
1271
1272 !------------------------------------------------------------------------------
1273 !BOP
1274 ! !IROUTINE:  ESMF_ClockValidate - Validate a Clock's properties
1275
1276 ! !INTERFACE:
1277       subroutine ESMF_ClockValidate(clock, opts, rc)
1278
1279 ! !ARGUMENTS:
1280       type(ESMF_Clock), intent(in) :: clock
1281       character (len=*), intent(in), optional :: opts
1282       integer, intent(out), optional :: rc
1283
1284 ! !DESCRIPTION:
1285 !     Perform a validation check on an {\tt ESMF\_Clock}'s properties
1286 !
1287 !     The arguments are:
1288 !     \begin{description}
1289 !     \item[clock]
1290 !          {\tt ESMF\_Clock} to validate
1291 !     \item[{[opts]}]
1292 !          Validate options
1293 !     \item[{[rc]}]
1294 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
1295 !     \end{description}
1296 !
1297 ! !REQUIREMENTS:
1298 !     TMGn.n.n
1299 !EOP
1300       CALL wrf_error_fatal( 'ESMF_ClockValidate not supported' )
1301       end subroutine ESMF_ClockValidate
1302
1303 !------------------------------------------------------------------------------
1304 !BOP
1305 ! !IROUTINE:  ESMF_ClockPrint - Print out a Clock's properties
1306
1307 ! !INTERFACE:
1308       subroutine ESMF_ClockPrint(clock, opts, rc)
1309
1310 ! !ARGUMENTS:
1311       type(ESMF_Clock), intent(in) :: clock
1312       character (len=*), intent(in), optional :: opts
1313       integer, intent(out), optional :: rc
1314
1315 ! !DESCRIPTION:
1316 !     To support testing/debugging, print out an {\tt ESMF\_Clock}'s
1317 !     properties.
1318 !
1319 !     The arguments are:
1320 !     \begin{description}
1321 !     \item[clock]
1322 !          {\tt ESMF\_Clock} to print out
1323 !     \item[{[opts]}]
1324 !          Print options
1325 !     \item[{[rc]}]
1326 !          Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
1327 !     \end{description}
1328 !
1329 ! !REQUIREMENTS:
1330 !     TMGn.n.n
1331 !EOP
1332       CALL wrf_error_fatal( 'ESMF_ClockPrint not supported' )
1333       end subroutine ESMF_ClockPrint
1334
1335 !------------------------------------------------------------------------------
1336
1337       end module ESMF_ClockMod