ESMF_TimeInterval.F90
References to this file elsewhere.
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 TimeInterval Module
13 module ESMF_TimeIntervalMod
14 !
15 !==============================================================================
16 !
17 ! This file contains the TimeInterval class definition and all TimeInterval
18 ! class methods.
19 !
20 !------------------------------------------------------------------------------
21 ! INCLUDES
22 #include <ESMF_TimeMgr.inc>
23 !
24 !===============================================================================
25 !BOPI
26 ! !MODULE: ESMF_TimeIntervalMod
27 !
28 ! !DESCRIPTION:
29 ! Part of Time Manager F90 API wrapper of C++ implemenation
30 !
31 ! Defines F90 wrapper entry points for corresponding
32 ! C++ implementaion of class {\tt ESMC\_TimeInterval}
33 !
34 ! See {\tt ../include/ESMC\_TimeInterval.h} for complete description
35 !
36 !------------------------------------------------------------------------------
37 ! !USES:
38 ! inherit from ESMF base class
39 use ESMF_BaseMod
40
41 ! inherit from base time class
42 use ESMF_BaseTimeMod
43
44 ! associated derived types
45 use ESMF_FractionMod, only : ESMF_Fraction
46 use ESMF_CalendarMod
47
48 implicit none
49 !
50 !------------------------------------------------------------------------------
51 ! !PRIVATE TYPES:
52 private
53 !------------------------------------------------------------------------------
54 ! ! ESMF_TimeInterval
55 !
56 ! ! F90 class type to match C++ TimeInterval class in size only;
57 ! ! all dereferencing within class is performed by C++ implementation
58
59 type ESMF_TimeInterval
60 ! time interval is expressed as basetime
61 type(ESMF_BaseTime) :: basetime ! inherit base class
62 ! Relative year and month fields support monthly or yearly time
63 ! intervals. Many operations are undefined when these fields are
64 ! non-zero!
65 INTEGER :: YR ! relative year
66 INTEGER :: MM ! relative month
67 end type
68
69 !------------------------------------------------------------------------------
70 ! !PUBLIC TYPES:
71 public ESMF_TimeInterval
72 !------------------------------------------------------------------------------
73 !
74 ! !PUBLIC MEMBER FUNCTIONS:
75 public ESMF_TimeIntervalGet
76 public ESMF_TimeIntervalSet
77 public ESMFold_TimeIntervalGetString
78 public ESMF_TimeIntervalAbsValue
79 public ESMF_TimeIntervalNegAbsValue
80
81 ! Required inherited and overridden ESMF_Base class methods
82
83 !!!!!!!!! added 20051012, JM
84 ! public WRFADDITION_TimeIntervalDIVQuot
85 !!!!!!!!! renamed to simplify testing 20060320, TH
86 public ESMF_TimeIntervalDIVQuot
87
88 ! This convenience routine is only used by other modules in
89 ! esmf_time_f90.
90 public ESMF_TimeIntervalIsPositive
91
92
93 ! !PRIVATE MEMBER FUNCTIONS:
94
95 ! overloaded operator functions
96
97 public operator(/)
98 private ESMF_TimeIntervalQuotI
99
100 public operator(*)
101 private ESMF_TimeIntervalProdI
102
103 ! Inherited and overloaded from ESMF_BaseTime
104
105 public operator(+)
106 private ESMF_TimeIntervalSum
107
108 public operator(-)
109 private ESMF_TimeIntervalDiff
110
111 public operator(.EQ.)
112 private ESMF_TimeIntervalEQ
113
114 public operator(.NE.)
115 private ESMF_TimeIntervalNE
116
117 public operator(.LT.)
118 private ESMF_TimeIntervalLT
119
120 public operator(.GT.)
121 private ESMF_TimeIntervalGT
122
123 public operator(.LE.)
124 private ESMF_TimeIntervalLE
125
126 public operator(.GE.)
127 private ESMF_TimeIntervalGE
128 !EOPI
129
130 !==============================================================================
131 !
132 ! INTERFACE BLOCKS
133 !
134 !==============================================================================
135 !BOP
136 ! !INTERFACE:
137 interface operator(*)
138
139 ! !PRIVATE MEMBER FUNCTIONS:
140 module procedure ESMF_TimeIntervalProdI
141
142 ! !DESCRIPTION:
143 ! This interface overloads the * operator for the {\tt ESMF\_TimeInterval}
144 ! class
145 !
146 !EOP
147 end interface
148 !
149 !------------------------------------------------------------------------------
150 !BOP
151 ! !INTERFACE:
152 interface operator(/)
153
154 ! !PRIVATE MEMBER FUNCTIONS:
155 module procedure ESMF_TimeIntervalQuotI
156
157 ! !DESCRIPTION:
158 ! This interface overloads the / operator for the
159 ! {\tt ESMF\_TimeInterval} class
160 !
161 !EOP
162 end interface
163 !
164 !------------------------------------------------------------------------------
165 !BOP
166 ! !INTERFACE:
167 interface operator(+)
168
169 ! !PRIVATE MEMBER FUNCTIONS:
170 module procedure ESMF_TimeIntervalSum
171
172 ! !DESCRIPTION:
173 ! This interface overloads the + operator for the
174 ! {\tt ESMF\_TimeInterval} class
175 !
176 !EOP
177 end interface
178 !
179 !------------------------------------------------------------------------------
180 !BOP
181 ! !INTERFACE:
182 interface operator(-)
183
184 ! !PRIVATE MEMBER FUNCTIONS:
185 module procedure ESMF_TimeIntervalDiff
186
187 ! !DESCRIPTION:
188 ! This interface overloads the - operator for the
189 ! {\tt ESMF\_TimeInterval} class
190 !
191 !EOP
192 end interface
193 !
194 !------------------------------------------------------------------------------
195 !BOP
196 ! !INTERFACE:
197 interface operator(.EQ.)
198
199 ! !PRIVATE MEMBER FUNCTIONS:
200 module procedure ESMF_TimeIntervalEQ
201
202 ! !DESCRIPTION:
203 ! This interface overloads the .EQ. operator for the
204 ! {\tt ESMF\_TimeInterval} class
205 !
206 !EOP
207 end interface
208 !
209 !------------------------------------------------------------------------------
210 !BOP
211 ! !INTERFACE:
212 interface operator(.NE.)
213
214 ! !PRIVATE MEMBER FUNCTIONS:
215 module procedure ESMF_TimeIntervalNE
216
217 ! !DESCRIPTION:
218 ! This interface overloads the .NE. operator for the
219 ! {\tt ESMF\_TimeInterval} class
220 !
221 !EOP
222 end interface
223 !
224 !------------------------------------------------------------------------------
225 !BOP
226 ! !INTERFACE:
227 interface operator(.LT.)
228
229 ! !PRIVATE MEMBER FUNCTIONS:
230 module procedure ESMF_TimeIntervalLT
231
232 ! !DESCRIPTION:
233 ! This interface overloads the .LT. operator for the
234 ! {\tt ESMF\_TimeInterval} class
235 !
236 !EOP
237 end interface
238 !
239 !------------------------------------------------------------------------------
240 !BOP
241 ! !INTERFACE:
242 interface operator(.GT.)
243
244 ! !PRIVATE MEMBER FUNCTIONS:
245 module procedure ESMF_TimeIntervalGT
246
247 ! !DESCRIPTION:
248 ! This interface overloads the .GT. operator for the
249 ! {\tt ESMF\_TimeInterval} class
250 !
251 !EOP
252 end interface
253 !
254 !------------------------------------------------------------------------------
255 !BOP
256 ! !INTERFACE:
257 interface operator(.LE.)
258
259 ! !PRIVATE MEMBER FUNCTIONS:
260 module procedure ESMF_TimeIntervalLE
261
262 ! !DESCRIPTION:
263 ! This interface overloads the .LE. operator for the
264 ! {\tt ESMF\_TimeInterval} class
265 !
266 !EOP
267 end interface
268 !
269 !------------------------------------------------------------------------------
270 !BOP
271 ! !INTERFACE:
272 interface operator(.GE.)
273
274 ! !PRIVATE MEMBER FUNCTIONS:
275 module procedure ESMF_TimeIntervalGE
276
277 ! !DESCRIPTION:
278 ! This interface overloads the .GE. operator for the
279 ! {\tt ESMF\_TimeInterval} class
280 !
281 !EOP
282 end interface
283 !
284 !------------------------------------------------------------------------------
285
286 !==============================================================================
287
288 contains
289
290 !==============================================================================
291 !
292 ! Generic Get/Set routines which use F90 optional arguments
293 !
294 !------------------------------------------------------------------------------
295 !BOP
296 ! !IROUTINE: ESMF_TimeIntervalGet - Get value in user-specified units
297
298 ! !INTERFACE:
299 subroutine ESMF_TimeIntervalGet(timeinterval, D, d_r8, S, Sn, Sd, &
300 TimeString, rc )
301
302 ! !ARGUMENTS:
303 type(ESMF_TimeInterval), intent(in) :: timeinterval
304 integer, intent(out), optional :: D
305 real(ESMF_KIND_R8), intent(out), optional :: d_r8
306 integer, intent(out), optional :: S
307 integer, intent(out), optional :: Sn
308 integer, intent(out), optional :: Sd
309 character*(*), optional, intent(out) :: TimeString
310 integer, intent(out), optional :: rc
311
312
313 ! !DESCRIPTION:
314 ! Get the value of the {\tt ESMF\_TimeInterval} in units specified by the
315 ! user via F90 optional arguments.
316 !
317 ! Time manager represents and manipulates time internally with integers
318 ! to maintain precision. Hence, user-specified floating point values are
319 ! converted internally from integers.
320 !
321 ! See {\tt ../include/ESMC\_BaseTime.h} and
322 ! {\tt ../include/ESMC\_TimeInterval.h} for complete description.
323 !
324 ! The arguments are:
325 ! \begin{description}
326 ! \item[timeinterval]
327 ! The object instance to query
328 ! \item[{[YY]}]
329 ! Integer years (>= 32-bit)
330 ! \item[{[YYl]}]
331 ! Integer years (large, >= 64-bit)
332 ! \item[{[MO]}]
333 ! Integer months (>= 32-bit)
334 ! \item[{[MOl]}]
335 ! Integer months (large, >= 64-bit)
336 ! \item[{[D]}]
337 ! Integer days (>= 32-bit)
338 ! \item[{[Dl]}]
339 ! Integer days (large, >= 64-bit)
340 ! \item[{[H]}]
341 ! Integer hours
342 ! \item[{[M]}]
343 ! Integer minutes
344 ! \item[{[S]}]
345 ! Integer seconds (>= 32-bit)
346 ! \item[{[Sl]}]
347 ! Integer seconds (large, >= 64-bit)
348 ! \item[{[MS]}]
349 ! Integer milliseconds
350 ! \item[{[US]}]
351 ! Integer microseconds
352 ! \item[{[NS]}]
353 ! Integer nanoseconds
354 ! \item[{[d\_]}]
355 ! Double precision days
356 ! \item[{[h\_]}]
357 ! Double precision hours
358 ! \item[{[m\_]}]
359 ! Double precision minutes
360 ! \item[{[s\_]}]
361 ! Double precision seconds
362 ! \item[{[ms\_]}]
363 ! Double precision milliseconds
364 ! \item[{[us\_]}]
365 ! Double precision microseconds
366 ! \item[{[ns\_]}]
367 ! Double precision nanoseconds
368 ! \item[{[Sn]}]
369 ! Integer fractional seconds - numerator
370 ! \item[{[Sd]}]
371 ! Integer fractional seconds - denominator
372 ! \item[{[rc]}]
373 ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
374 ! \end{description}
375 !
376 ! !REQUIREMENTS:
377 ! TMG1.1
378 !EOP
379 INTEGER(ESMF_KIND_I8) :: seconds
380 INTEGER :: ierr
381
382 ierr = ESMF_SUCCESS
383 seconds = timeinterval%basetime%S
384 ! note that S is overwritten below (if present) if other args are also
385 ! present
386 IF ( PRESENT(S) ) S = seconds
387 IF ( PRESENT( D ) ) THEN
388 D = seconds / SECONDS_PER_DAY
389 IF ( PRESENT(S) ) S = MOD( seconds, SECONDS_PER_DAY )
390 ENDIF
391 IF ( PRESENT( d_r8 ) ) THEN
392 D_r8 = REAL( seconds, ESMF_KIND_R8 ) / &
393 REAL( SECONDS_PER_DAY, ESMF_KIND_R8 )
394 IF ( PRESENT(S) ) S = MOD( seconds, SECONDS_PER_DAY )
395 ENDIF
396 IF ( PRESENT(Sn) ) THEN
397 Sn = timeinterval%basetime%Sn
398 ENDIF
399 IF ( PRESENT(Sd) ) THEN
400 Sd = timeinterval%basetime%Sd
401 ENDIF
402 IF ( PRESENT( timeString ) ) THEN
403 CALL ESMFold_TimeIntervalGetString( timeinterval, timeString, rc=ierr )
404 ENDIF
405 IF ( PRESENT(rc) ) rc = ierr
406
407 end subroutine ESMF_TimeIntervalGet
408
409 !------------------------------------------------------------------------------
410 !BOP
411 ! !IROUTINE: ESMF_TimeIntervalSet - Initialize via user-specified unit set
412
413 ! !INTERFACE:
414 subroutine ESMF_TimeIntervalSet(timeinterval, YY, YYl, MM, MOl, D, Dl, &
415 H, M, S, Sl, MS, US, NS, &
416 d_, h_, m_, s_, ms_, us_, ns_, &
417 Sn, Sd, rc)
418
419 ! !ARGUMENTS:
420 type(ESMF_TimeInterval), intent(out) :: timeinterval
421 integer, intent(in), optional :: YY
422 integer(ESMF_KIND_I8), intent(in), optional :: YYl
423 integer, intent(in), optional :: MM
424 integer(ESMF_KIND_I8), intent(in), optional :: MOl
425 integer, intent(in), optional :: D
426 integer(ESMF_KIND_I8), intent(in), optional :: Dl
427 integer, intent(in), optional :: H
428 integer, intent(in), optional :: M
429 integer, intent(in), optional :: S
430 integer(ESMF_KIND_I8), intent(in), optional :: Sl
431 integer, intent(in), optional :: MS
432 integer, intent(in), optional :: US
433 integer, intent(in), optional :: NS
434 double precision, intent(in), optional :: d_
435 double precision, intent(in), optional :: h_
436 double precision, intent(in), optional :: m_
437 double precision, intent(in), optional :: s_
438 double precision, intent(in), optional :: ms_
439 double precision, intent(in), optional :: us_
440 double precision, intent(in), optional :: ns_
441 integer, intent(in), optional :: Sn
442 integer, intent(in), optional :: Sd
443 integer, intent(out), optional :: rc
444 ! locals
445 INTEGER :: nfeb
446
447 ! !DESCRIPTION:
448 ! Set the value of the {\tt ESMF\_TimeInterval} in units specified by
449 ! the user via F90 optional arguments
450 !
451 ! Time manager represents and manipulates time internally with integers
452 ! to maintain precision. Hence, user-specified floating point values are
453 ! converted internally to integers.
454 !
455 ! See {\tt ../include/ESMC\_BaseTime.h} and
456 ! {\tt ../include/ESMC\_TimeInterval.h} for complete description.
457 !
458 ! The arguments are:
459 ! \begin{description}
460 ! \item[timeinterval]
461 ! The object instance to initialize
462 ! \item[{[YY]}]
463 ! Integer number of interval years (>= 32-bit)
464 ! \item[{[YYl]}]
465 ! Integer number of interval years (large, >= 64-bit)
466 ! \item[{[MM]}]
467 ! Integer number of interval months (>= 32-bit)
468 ! \item[{[MOl]}]
469 ! Integer number of interval months (large, >= 64-bit)
470 ! \item[{[D]}]
471 ! Integer number of interval days (>= 32-bit)
472 ! \item[{[Dl]}]
473 ! Integer number of interval days (large, >= 64-bit)
474 ! \item[{[H]}]
475 ! Integer hours
476 ! \item[{[M]}]
477 ! Integer minutes
478 ! \item[{[S]}]
479 ! Integer seconds (>= 32-bit)
480 ! \item[{[Sl]}]
481 ! Integer seconds (large, >= 64-bit)
482 ! \item[{[MS]}]
483 ! Integer milliseconds
484 ! \item[{[US]}]
485 ! Integer microseconds
486 ! \item[{[NS]}]
487 ! Integer nanoseconds
488 ! \item[{[d\_]}]
489 ! Double precision days
490 ! \item[{[h\_]}]
491 ! Double precision hours
492 ! \item[{[m\_]}]
493 ! Double precision minutes
494 ! \item[{[s\_]}]
495 ! Double precision seconds
496 ! \item[{[ms\_]}]
497 ! Double precision milliseconds
498 ! \item[{[us\_]}]
499 ! Double precision microseconds
500 ! \item[{[ns\_]}]
501 ! Double precision nanoseconds
502 ! \item[{[Sn]}]
503 ! Integer fractional seconds - numerator
504 ! \item[{[Sd]}]
505 ! Integer fractional seconds - denominator
506 ! \item[{[rc]}]
507 ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
508 ! \end{description}
509 !
510 ! !REQUIREMENTS:
511 ! TMGn.n.n
512 !EOP
513
514 IF ( PRESENT(rc) ) rc = ESMF_FAILURE
515 ! note that YR and MM are relative
516 timeinterval%YR = 0
517 IF ( PRESENT( YY ) ) THEN
518 timeinterval%YR = YY
519 ENDIF
520 timeinterval%MM = 0
521 IF ( PRESENT( MM ) ) THEN
522 timeinterval%MM = MM
523 ENDIF
524 ! Rollover months to years
525 IF ( abs(timeinterval%MM) .GE. MONTHS_PER_YEAR ) THEN
526 timeinterval%YR = timeinterval%YR + timeinterval%MM/MONTHS_PER_YEAR
527 timeinterval%MM = mod(timeinterval%MM,MONTHS_PER_YEAR)
528 ENDIF
529
530 timeinterval%basetime%S = 0
531 ! For 365-day calendar, immediately convert years to days since we know
532 ! how to do it in this case.
533 !$$$ replace this hack with something saner...
534 IF ( nfeb( 2004 ) == 28 ) THEN
535 timeinterval%basetime%S = timeinterval%basetime%S + &
536 ( 365_ESMF_KIND_I8 * &
537 INT( timeinterval%YR, ESMF_KIND_I8 ) * SECONDS_PER_DAY )
538 timeinterval%YR = 0
539 ENDIF
540 IF ( PRESENT( D ) ) THEN
541 timeinterval%basetime%S = timeinterval%basetime%S + &
542 ( SECONDS_PER_DAY * INT( D, ESMF_KIND_I8 ) )
543 ENDIF
544 !$$$ Push H,M,S,Sn,Sd,MS down into BaseTime constructor from EVERYWHERE
545 !$$$ and THEN add ESMF scaling behavior when other args are present...
546 IF ( PRESENT( H ) ) THEN
547 timeinterval%basetime%S = timeinterval%basetime%S + &
548 ( SECONDS_PER_HOUR * INT( H, ESMF_KIND_I8 ) )
549 ENDIF
550 IF ( PRESENT( M ) ) THEN
551 timeinterval%basetime%S = timeinterval%basetime%S + &
552 ( SECONDS_PER_MINUTE * INT( M, ESMF_KIND_I8 ) )
553 ENDIF
554 IF ( PRESENT( S ) ) THEN
555 timeinterval%basetime%S = timeinterval%basetime%S + &
556 INT( S, ESMF_KIND_I8 )
557 ENDIF
558 IF ( PRESENT( Sn ) .AND. ( .NOT. PRESENT( Sd ) ) ) THEN
559 CALL wrf_error_fatal( &
560 "ESMF_TimeIntervalSet: Must specify Sd if Sn is specified")
561 ENDIF
562 IF ( PRESENT( Sd ) .AND. PRESENT( MS ) ) THEN
563 CALL wrf_error_fatal( &
564 "ESMF_TimeIntervalSet: Must not specify both Sd and MS")
565 ENDIF
566 timeinterval%basetime%Sn = 0
567 timeinterval%basetime%Sd = 0
568 IF ( PRESENT( MS ) ) THEN
569 timeinterval%basetime%Sn = MS
570 timeinterval%basetime%Sd = 1000_ESMF_KIND_I8
571 ELSE IF ( PRESENT( Sd ) ) THEN
572 timeinterval%basetime%Sd = Sd
573 IF ( PRESENT( Sn ) ) THEN
574 timeinterval%basetime%Sn = Sn
575 ENDIF
576 ENDIF
577 CALL normalize_timeint( timeinterval )
578
579 IF ( PRESENT(rc) ) rc = ESMF_SUCCESS
580
581 end subroutine ESMF_TimeIntervalSet
582
583 !------------------------------------------------------------------------------
584 !BOP
585 ! !IROUTINE: ESMFold_TimeIntervalGetString - Get time interval value in string format
586
587 ! !INTERFACE:
588 subroutine ESMFold_TimeIntervalGetString(timeinterval, TimeString, rc)
589
590 ! !ARGUMENTS:
591 type(ESMF_TimeInterval), intent(in) :: timeinterval
592 character*(*), intent(out) :: TimeString
593 integer, intent(out), optional :: rc
594 ! locals
595 integer :: signnormtimeint
596 LOGICAL :: negative
597 INTEGER(ESMF_KIND_I8) :: iS, iSn, iSd, H, M, S
598 character (len=1) :: signstr
599
600 ! !DESCRIPTION:
601 ! Convert {\tt ESMF\_TimeInterval}'s value into string format
602 !
603 ! The arguments are:
604 ! \begin{description}
605 ! \item[timeinterval]
606 ! The object instance to convert
607 ! \item[TimeString]
608 ! The string to return
609 ! \item[{[rc]}]
610 ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
611 ! \end{description}
612 !
613 ! !REQUIREMENTS:
614 ! TMG1.5.9
615 !EOP
616
617 ! NOTE: YR, MM, Sn, and Sd are not yet included in the returned string...
618 !PRINT *,'DEBUG ESMFold_TimeIntervalGetString(): YR,MM,S,Sn,Sd = ', &
619 ! timeinterval%YR, &
620 ! timeinterval%MM, &
621 ! timeinterval%basetime%S, &
622 ! timeinterval%basetime%Sn, &
623 ! timeinterval%basetime%Sd
624
625 negative = ( signnormtimeint( timeInterval ) == -1 )
626 IF ( negative ) THEN
627 iS = -timeinterval%basetime%S
628 iSn = -timeinterval%basetime%Sn
629 signstr = '-'
630 ELSE
631 iS = timeinterval%basetime%S
632 iSn = timeinterval%basetime%Sn
633 signstr = ''
634 ENDIF
635 iSd = timeinterval%basetime%Sd
636
637 H = mod( iS, SECONDS_PER_DAY ) / SECONDS_PER_HOUR
638 M = mod( iS, SECONDS_PER_HOUR) / SECONDS_PER_MINUTE
639 S = mod( iS, SECONDS_PER_MINUTE )
640
641 !$$$here... need to print Sn and Sd when they are used ???
642
643 write(TimeString,FMT="(A,I10.10,'_',I3.3,':',I3.3,':',I3.3)") &
644 TRIM(signstr), ( iS / SECONDS_PER_DAY ), H, M, S
645
646 !write(0,*)'TimeIntervalGetString Sn ',timeinterval%basetime%Sn,' Sd ',timeinterval%basetime%Sd
647
648 rc = ESMF_SUCCESS
649
650 end subroutine ESMFold_TimeIntervalGetString
651
652 !------------------------------------------------------------------------------
653 !BOP
654 ! !IROUTINE: ESMF_TimeIntervalAbsValue - Get the absolute value of a time interval
655
656 ! !INTERFACE:
657 function ESMF_TimeIntervalAbsValue(timeinterval)
658
659 ! !RETURN VALUE:
660 type(ESMF_TimeInterval) :: ESMF_TimeIntervalAbsValue
661
662 ! !ARGUMENTS:
663 type(ESMF_TimeInterval), intent(in) :: timeinterval
664 ! !LOCAL:
665 integer :: rc
666
667 ! !DESCRIPTION:
668 ! Return a {\tt ESMF\_TimeInterval}'s absolute value.
669 !
670 ! The arguments are:
671 ! \begin{description}
672 ! \item[timeinterval]
673 ! The object instance to take the absolute value of.
674 ! Absolute value returned as value of function.
675 ! \end{description}
676 !
677 ! !REQUIREMENTS:
678 ! TMG1.5.8
679 !EOP
680 CALL timeintchecknormalized( timeinterval, 'ESMF_TimeIntervalAbsValue arg1' )
681 ESMF_TimeIntervalAbsValue = timeinterval
682 !$$$here... move implementation into BaseTime
683 ESMF_TimeIntervalAbsValue%basetime%S = &
684 abs(ESMF_TimeIntervalAbsValue%basetime%S)
685 ESMF_TimeIntervalAbsValue%basetime%Sn = &
686 abs(ESMF_TimeIntervalAbsValue%basetime%Sn )
687
688 end function ESMF_TimeIntervalAbsValue
689
690 !------------------------------------------------------------------------------
691 !BOP
692 ! !IROUTINE: ESMF_TimeIntervalNegAbsValue - Get the negative absolute value of a time interval
693
694 ! !INTERFACE:
695 function ESMF_TimeIntervalNegAbsValue(timeinterval)
696
697 ! !RETURN VALUE:
698 type(ESMF_TimeInterval) :: ESMF_TimeIntervalNegAbsValue
699
700 ! !ARGUMENTS:
701 type(ESMF_TimeInterval), intent(in) :: timeinterval
702 ! !LOCAL:
703 integer :: rc
704
705 ! !DESCRIPTION:
706 ! Return a {\tt ESMF\_TimeInterval}'s negative absolute value.
707 !
708 ! The arguments are:
709 ! \begin{description}
710 ! \item[timeinterval]
711 ! The object instance to take the negative absolute value of.
712 ! Negative absolute value returned as value of function.
713 ! \end{description}
714 !
715 ! !REQUIREMENTS:
716 ! TMG1.5.8
717 !EOP
718 CALL timeintchecknormalized( timeinterval, 'ESMF_TimeIntervalNegAbsValue arg1' )
719
720 ESMF_TimeIntervalNegAbsValue = timeinterval
721 !$$$here... move implementation into BaseTime
722 ESMF_TimeIntervalNegAbsValue%basetime%S = &
723 -abs(ESMF_TimeIntervalNegAbsValue%basetime%S)
724 ESMF_TimeIntervalNegAbsValue%basetime%Sn = &
725 -abs(ESMF_TimeIntervalNegAbsValue%basetime%Sn )
726
727 end function ESMF_TimeIntervalNegAbsValue
728
729 !------------------------------------------------------------------------------
730 !
731 ! This section includes overloaded operators defined only for TimeInterval
732 ! (not inherited from BaseTime)
733 ! Note: these functions do not have a return code, since F90 forbids more
734 ! than 2 arguments for arithmetic overloaded operators
735 !
736 !------------------------------------------------------------------------------
737
738 !!!!!!!!!!!!!!!!!! added jm 20051012
739 ! new WRF-specific function, Divide two time intervals and return the whole integer, without remainder
740 function ESMF_TimeIntervalDIVQuot(timeinterval1, timeinterval2)
741
742 ! !RETURN VALUE:
743 INTEGER :: ESMF_TimeIntervalDIVQuot
744
745 ! !ARGUMENTS:
746 type(ESMF_TimeInterval), intent(in) :: timeinterval1
747 type(ESMF_TimeInterval), intent(in) :: timeinterval2
748
749 ! !LOCAL
750 INTEGER :: retval, isgn, rc
751 type(ESMF_TimeInterval) :: zero, i1,i2
752
753 ! !DESCRIPTION:
754 ! Returns timeinterval1 divided by timeinterval2 as a fraction quotient.
755 !
756 ! The arguments are:
757 ! \begin{description}
758 ! \item[timeinterval1]
759 ! The dividend
760 ! \item[timeinterval2]
761 ! The divisor
762 ! \end{description}
763 !
764 ! !REQUIREMENTS:
765 ! TMG1.5.5
766 !EOP
767
768 CALL timeintchecknormalized( timeinterval1, 'ESMF_TimeIntervalDIVQuot arg1' )
769 CALL timeintchecknormalized( timeinterval2, 'ESMF_TimeIntervalDIVQuot arg2' )
770
771 call ESMF_TimeIntervalSet( zero, rc=rc )
772 i1 = timeinterval1
773 i2 = timeinterval2
774 isgn = 1
775 if ( i1 .LT. zero ) then
776 i1 = ESMF_TimeIntervalProdI(i1, -1)
777 isgn = -isgn
778 endif
779 if ( i2 .LT. zero ) then
780 i2 = ESMF_TimeIntervalProdI(i2, -1)
781 isgn = -isgn
782 endif
783 ! repeated subtraction
784 retval = 0
785 DO WHILE ( i1 .GE. i2 )
786 i1 = i1 - i2
787 retval = retval + 1
788 ENDDO
789 retval = retval * isgn
790
791 ESMF_TimeIntervalDIVQuot = retval
792
793 end function ESMF_TimeIntervalDIVQuot
794 !!!!!!!!!!!!!!!!!!
795
796
797
798 !------------------------------------------------------------------------------
799 !BOP
800 ! !IROUTINE: ESMF_TimeIntervalQuotI - Divide time interval by an integer, return time interval result
801
802 ! !INTERFACE:
803 function ESMF_TimeIntervalQuotI(timeinterval, divisor)
804
805 ! !RETURN VALUE:
806 type(ESMF_TimeInterval) :: ESMF_TimeIntervalQuotI
807
808 ! !ARGUMENTS:
809 type(ESMF_TimeInterval), intent(in) :: timeinterval
810 integer, intent(in) :: divisor
811
812 ! !DESCRIPTION:
813 ! Divides a {\tt ESMF\_TimeInterval} by an integer divisor, returns
814 ! quotient as a {\tt ESMF\_TimeInterval}
815 !
816 ! The arguments are:
817 ! \begin{description}
818 ! \item[timeinterval]
819 ! The dividend
820 ! \item[divisor]
821 ! Integer divisor
822 ! \end{description}
823 !
824 ! !REQUIREMENTS:
825 ! TMG1.5.6, TMG5.3, TMG7.2
826 !EOP
827
828 !PRINT *,'DEBUG ESMF_TimeIntervalQuotI() A: S,Sn,Sd = ', &
829 ! timeinterval%basetime%S,timeinterval%basetime%Sn,timeinterval%basetime%Sd
830 !PRINT *,'DEBUG ESMF_TimeIntervalQuotI() A: divisor = ', divisor
831
832 CALL timeintchecknormalized( timeinterval, 'ESMF_TimeIntervalQuotI arg1' )
833
834 IF ( divisor == 0 ) THEN
835 CALL wrf_error_fatal( 'ESMF_TimeIntervalQuotI: divide by zero' )
836 ENDIF
837 ESMF_TimeIntervalQuotI = timeinterval
838 !PRINT *,'DEBUG ESMF_TimeIntervalQuotI() B: S,Sn,Sd = ', &
839 ! ESMF_TimeIntervalQuotI%basetime%S,ESMF_TimeIntervalQuotI%basetime%Sn,ESMF_TimeIntervalQuotI%basetime%Sd
840 ESMF_TimeIntervalQuotI%basetime = &
841 timeinterval%basetime / divisor
842 !PRINT *,'DEBUG ESMF_TimeIntervalQuotI() C: S,Sn,Sd = ', &
843 ! ESMF_TimeIntervalQuotI%basetime%S,ESMF_TimeIntervalQuotI%basetime%Sn,ESMF_TimeIntervalQuotI%basetime%Sd
844
845 CALL normalize_timeint( ESMF_TimeIntervalQuotI )
846 !PRINT *,'DEBUG ESMF_TimeIntervalQuotI() D: S,Sn,Sd = ', &
847 ! ESMF_TimeIntervalQuotI%basetime%S,ESMF_TimeIntervalQuotI%basetime%Sn,ESMF_TimeIntervalQuotI%basetime%Sd
848
849 end function ESMF_TimeIntervalQuotI
850
851 !------------------------------------------------------------------------------
852 !BOP
853 ! !IROUTINE: ESMF_TimeIntervalProdI - Multiply a time interval by an integer
854
855 ! !INTERFACE:
856 function ESMF_TimeIntervalProdI(timeinterval, multiplier)
857
858 ! !RETURN VALUE:
859 type(ESMF_TimeInterval) :: ESMF_TimeIntervalProdI
860
861 ! !ARGUMENTS:
862 type(ESMF_TimeInterval), intent(in) :: timeinterval
863 integer, intent(in) :: multiplier
864 ! !LOCAL:
865 integer :: rc
866
867 ! !DESCRIPTION:
868 ! Multiply a {\tt ESMF\_TimeInterval} by an integer, return product as a
869 ! {\tt ESMF\_TimeInterval}
870 !
871 ! The arguments are:
872 ! \begin{description}
873 ! \item[timeinterval]
874 ! The multiplicand
875 ! \item[mutliplier]
876 ! Integer multiplier
877 ! \end{description}
878 !
879 ! !REQUIREMENTS:
880 ! TMG1.5.7, TMG7.2
881 !EOP
882 CALL timeintchecknormalized( timeinterval, 'ESMF_TimeIntervalProdI arg1' )
883
884 CALL ESMF_TimeIntervalSet( ESMF_TimeIntervalProdI, rc=rc )
885 !$$$move this into overloaded operator(*) in BaseTime
886 ESMF_TimeIntervalProdI%basetime%S = &
887 timeinterval%basetime%S * INT( multiplier, ESMF_KIND_I8 )
888 ESMF_TimeIntervalProdI%basetime%Sn = &
889 timeinterval%basetime%Sn * INT( multiplier, ESMF_KIND_I8 )
890 ! Don't multiply Sd
891 ESMF_TimeIntervalProdI%basetime%Sd = timeinterval%basetime%Sd
892 CALL normalize_timeint( ESMF_TimeIntervalProdI )
893
894 end function ESMF_TimeIntervalProdI
895
896 !------------------------------------------------------------------------------
897 !
898 ! This section includes the inherited ESMF_BaseTime class overloaded operators
899 !
900 !------------------------------------------------------------------------------
901 !BOP
902 ! !IROUTINE: ESMF_TimeIntervalSum - Add two time intervals together
903
904 ! !INTERFACE:
905 function ESMF_TimeIntervalSum(timeinterval1, timeinterval2)
906
907 ! !RETURN VALUE:
908 type(ESMF_TimeInterval) :: ESMF_TimeIntervalSum
909
910 ! !ARGUMENTS:
911 type(ESMF_TimeInterval), intent(in) :: timeinterval1
912 type(ESMF_TimeInterval), intent(in) :: timeinterval2
913 ! !LOCAL:
914 integer :: rc
915 ! !DESCRIPTION:
916 ! Add two {\tt ESMF\_TimeIntervals}, return sum as a
917 ! {\tt ESMF\_TimeInterval}. Maps overloaded (+) operator interface
918 ! function to {\tt ESMF\_BaseTime} base class.
919 !
920 ! The arguments are:
921 ! \begin{description}
922 ! \item[timeinterval1]
923 ! The augend
924 ! \item[timeinterval2]
925 ! The addend
926 ! \end{description}
927 !
928 ! !REQUIREMENTS:
929 ! TMG1.5.4, TMG2.4.4, TMG2.4.5, TMG2.4.6, TMG5.1, TMG5.2,
930 ! TMG7.2
931 !EOP
932 CALL timeintchecknormalized( timeinterval1, 'ESMF_TimeIntervalSum arg1' )
933 CALL timeintchecknormalized( timeinterval2, 'ESMF_TimeIntervalSum arg2' )
934
935 ESMF_TimeIntervalSum = timeinterval1
936 ESMF_TimeIntervalSum%basetime = ESMF_TimeIntervalSum%basetime + &
937 timeinterval2%basetime
938
939 CALL normalize_timeint( ESMF_TimeIntervalSum )
940
941 end function ESMF_TimeIntervalSum
942
943 !------------------------------------------------------------------------------
944 !BOP
945 ! !IROUTINE: ESMF_TimeIntervalDiff - Subtract one time interval from another
946
947 ! !INTERFACE:
948 function ESMF_TimeIntervalDiff(timeinterval1, timeinterval2)
949
950 ! !RETURN VALUE:
951 type(ESMF_TimeInterval) :: ESMF_TimeIntervalDiff
952
953 ! !ARGUMENTS:
954 type(ESMF_TimeInterval), intent(in) :: timeinterval1
955 type(ESMF_TimeInterval), intent(in) :: timeinterval2
956 ! !LOCAL:
957 integer :: rc
958 ! !DESCRIPTION:
959 ! Subtract timeinterval2 from timeinterval1, return remainder as a
960 ! {\tt ESMF\_TimeInterval}.
961 ! Map overloaded (-) operator interface function to {\tt ESMF\_BaseTime}
962 ! base class.
963 !
964 ! The arguments are:
965 ! \begin{description}
966 ! \item[timeinterval1]
967 ! The minuend
968 ! \item[timeinterval2]
969 ! The subtrahend
970 ! \end{description}
971 !
972 ! !REQUIREMENTS:
973 ! TMG1.5.4, TMG2.4.4, TMG2.4.5, TMG2.4.6, TMG5.1, TMG5.2, TMG7.2
974 !EOP
975 CALL timeintchecknormalized( timeinterval1, 'ESMF_TimeIntervalDiff arg1' )
976 CALL timeintchecknormalized( timeinterval2, 'ESMF_TimeIntervalDiff arg2' )
977
978 ESMF_TimeIntervalDiff = timeinterval1
979 ESMF_TimeIntervalDiff%basetime = ESMF_TimeIntervalDiff%basetime - &
980 timeinterval2%basetime
981 CALL normalize_timeint( ESMF_TimeIntervalDiff )
982
983 end function ESMF_TimeIntervalDiff
984
985 !------------------------------------------------------------------------------
986 !BOP
987 ! !IROUTINE: ESMF_TimeIntervalEQ - Compare two time intervals for equality
988
989 ! !INTERFACE:
990 function ESMF_TimeIntervalEQ(timeinterval1, timeinterval2)
991 !
992 ! !RETURN VALUE:
993 logical :: ESMF_TimeIntervalEQ
994
995 ! !ARGUMENTS:
996 type(ESMF_TimeInterval), intent(in) :: timeinterval1
997 type(ESMF_TimeInterval), intent(in) :: timeinterval2
998
999 !DESCRIPTION:
1000 ! Return true if both given time intervals are equal, false otherwise.
1001 ! Maps overloaded (==) operator interface function to {\tt ESMF\_BaseTime}
1002 ! base class.
1003 !
1004 ! The arguments are:
1005 ! \begin{description}
1006 ! \item[timeinterval1]
1007 ! First time interval to compare
1008 ! \item[timeinterval2]
1009 ! Second time interval to compare
1010 ! \end{description}
1011 !
1012 ! !REQUIREMENTS:
1013 ! TMG1.5.3, TMG2.4.3, TMG7.2
1014 !EOP
1015 CALL timeintchecknormalized( timeinterval1, 'ESMF_TimeIntervalEQ arg1' )
1016 CALL timeintchecknormalized( timeinterval2, 'ESMF_TimeIntervalEQ arg2' )
1017
1018 !$$$here... move all this out of Meat.F90 ?
1019 ! call ESMC_BaseTime base class function
1020 call c_ESMC_BaseTimeIntEQ(timeinterval1, timeinterval2, ESMF_TimeIntervalEQ)
1021
1022 end function ESMF_TimeIntervalEQ
1023
1024 !------------------------------------------------------------------------------
1025 !BOP
1026 ! !IROUTINE: ESMF_TimeIntervalNE - Compare two time intervals for inequality
1027
1028 ! !INTERFACE:
1029 function ESMF_TimeIntervalNE(timeinterval1, timeinterval2)
1030 !
1031 ! !RETURN VALUE:
1032 logical :: ESMF_TimeIntervalNE
1033
1034 ! !ARGUMENTS:
1035 type(ESMF_TimeInterval), intent(in) :: timeinterval1
1036 type(ESMF_TimeInterval), intent(in) :: timeinterval2
1037
1038 ! !DESCRIPTION:
1039 ! Return true if both given time intervals are not equal, false otherwise.
1040 ! Maps overloaded (/=) operator interface function to {\tt ESMF\_BaseTime}
1041 ! base class.
1042 !
1043 ! The arguments are:
1044 ! \begin{description}
1045 ! \item[timeinterval1]
1046 ! First time interval to compare
1047 ! \item[timeinterval2]
1048 ! Second time interval to compare
1049 ! \end{description}
1050 !
1051 ! !REQUIREMENTS:
1052 ! TMG1.5.3, TMG2.4.3, TMG7.2
1053 !EOP
1054 CALL timeintchecknormalized( timeinterval1, 'ESMF_TimeIntervalNE arg1' )
1055 CALL timeintchecknormalized( timeinterval2, 'ESMF_TimeIntervalNE arg2' )
1056
1057 ! call ESMC_BaseTime base class function
1058 call c_ESMC_BaseTimeIntNE(timeinterval1, timeinterval2, ESMF_TimeIntervalNE)
1059
1060 end function ESMF_TimeIntervalNE
1061
1062 !------------------------------------------------------------------------------
1063 !BOP
1064 ! !IROUTINE: ESMF_TimeIntervalLT - Time interval 1 less than time interval 2 ?
1065
1066 ! !INTERFACE:
1067 function ESMF_TimeIntervalLT(timeinterval1, timeinterval2)
1068 !
1069 ! !RETURN VALUE:
1070 logical :: ESMF_TimeIntervalLT
1071
1072 ! !ARGUMENTS:
1073 type(ESMF_TimeInterval), intent(in) :: timeinterval1
1074 type(ESMF_TimeInterval), intent(in) :: timeinterval2
1075
1076 ! !DESCRIPTION:
1077 ! Return true if first time interval is less than second time interval,
1078 ! false otherwise. Maps overloaded (<) operator interface function to
1079 ! {\tt ESMF\_BaseTime} base class.
1080 !
1081 ! The arguments are:
1082 ! \begin{description}
1083 ! \item[timeinterval1]
1084 ! First time interval to compare
1085 ! \item[timeinterval2]
1086 ! Second time interval to compare
1087 ! \end{description}
1088 !
1089 ! !REQUIREMENTS:
1090 ! TMG1.5.3, TMG2.4.3, TMG7.2
1091 !EOP
1092 CALL timeintchecknormalized( timeinterval1, 'ESMF_TimeIntervalLT arg1' )
1093 CALL timeintchecknormalized( timeinterval2, 'ESMF_TimeIntervalLT arg2' )
1094
1095 ! call ESMC_BaseTime base class function
1096 call c_ESMC_BaseTimeIntLT(timeinterval1, timeinterval2, ESMF_TimeIntervalLT)
1097
1098 end function ESMF_TimeIntervalLT
1099
1100 !------------------------------------------------------------------------------
1101 !BOP
1102 ! !IROUTINE: ESMF_TimeIntervalGT - Time interval 1 greater than time interval 2?
1103
1104 ! !INTERFACE:
1105 function ESMF_TimeIntervalGT(timeinterval1, timeinterval2)
1106 !
1107 ! !RETURN VALUE:
1108 logical :: ESMF_TimeIntervalGT
1109
1110 ! !ARGUMENTS:
1111 type(ESMF_TimeInterval), intent(in) :: timeinterval1
1112 type(ESMF_TimeInterval), intent(in) :: timeinterval2
1113
1114 ! !DESCRIPTION:
1115 ! Return true if first time interval is greater than second time interval,
1116 ! false otherwise. Maps overloaded (>) operator interface function to
1117 ! {\tt ESMF\_BaseTime} base class.
1118 !
1119 ! The arguments are:
1120 ! \begin{description}
1121 ! \item[timeinterval1]
1122 ! First time interval to compare
1123 ! \item[timeinterval2]
1124 ! Second time interval to compare
1125 ! \end{description}
1126 !
1127 ! !REQUIREMENTS:
1128 ! TMG1.5.3, TMG2.4.3, TMG7.2
1129 !EOP
1130 CALL timeintchecknormalized( timeinterval1, 'ESMF_TimeIntervalGT arg1' )
1131 CALL timeintchecknormalized( timeinterval2, 'ESMF_TimeIntervalGT arg2' )
1132
1133 ! call ESMC_BaseTime base class function
1134 call c_ESMC_BaseTimeIntGT(timeinterval1, timeinterval2, ESMF_TimeIntervalGT)
1135
1136 end function ESMF_TimeIntervalGT
1137
1138 !------------------------------------------------------------------------------
1139 !BOP
1140 ! !IROUTINE: ESMF_TimeIntervalLE - Time interval 1 less than or equal to time interval 2 ?
1141
1142 ! !INTERFACE:
1143 function ESMF_TimeIntervalLE(timeinterval1, timeinterval2)
1144
1145 ! !RETURN VALUE:
1146 logical :: ESMF_TimeIntervalLE
1147
1148 ! !ARGUMENTS:
1149 type(ESMF_TimeInterval), intent(in) :: timeinterval1
1150 type(ESMF_TimeInterval), intent(in) :: timeinterval2
1151
1152 ! !DESCRIPTION:
1153 ! Return true if first time interval is less than or equal to second time
1154 ! interval, false otherwise.
1155 ! Maps overloaded (<=) operator interface function to {\tt ESMF\_BaseTime}
1156 ! base class.
1157 !
1158 ! The arguments are:
1159 ! \begin{description}
1160 ! \item[timeinterval1]
1161 ! First time interval to compare
1162 ! \item[timeinterval2]
1163 ! Second time interval to compare
1164 ! \end{description}
1165 !
1166 ! !REQUIREMENTS:
1167 ! TMG1.5.3, TMG2.4.3, TMG7.2
1168 !EOP
1169 CALL timeintchecknormalized( timeinterval1, 'ESMF_TimeIntervalLE arg1' )
1170 CALL timeintchecknormalized( timeinterval2, 'ESMF_TimeIntervalLE arg2' )
1171
1172 ! call ESMC_BaseTime base class function
1173 call c_ESMC_BaseTimeIntLE(timeinterval1, timeinterval2, ESMF_TimeIntervalLE)
1174
1175 end function ESMF_TimeIntervalLE
1176
1177 !------------------------------------------------------------------------------
1178 !BOP
1179 ! !IROUTINE: ESMF_TimeIntervalGE - Time interval 1 greater than or equal to time interval 2 ?
1180
1181 ! !INTERFACE:
1182 function ESMF_TimeIntervalGE(timeinterval1, timeinterval2)
1183 !
1184 ! !RETURN VALUE:
1185 logical :: ESMF_TimeIntervalGE
1186
1187 ! !ARGUMENTS:
1188 type(ESMF_TimeInterval), intent(in) :: timeinterval1
1189 type(ESMF_TimeInterval), intent(in) :: timeinterval2
1190
1191 ! !DESCRIPTION:
1192 ! Return true if first time interval is greater than or equal to second
1193 ! time interval, false otherwise. Maps overloaded (>=) operator interface
1194 ! function to {\tt ESMF\_BaseTime} base class.
1195 !
1196 ! The arguments are:
1197 ! \begin{description}
1198 ! \item[timeinterval1]
1199 ! First time interval to compare
1200 ! \item[timeinterval2]
1201 ! Second time interval to compare
1202 ! \end{description}
1203 !
1204 ! !REQUIREMENTS:
1205 ! TMG1.5.3, TMG2.4.3, TMG7.2
1206 !EOP
1207 CALL timeintchecknormalized( timeinterval1, 'ESMF_TimeIntervalGE arg1' )
1208 CALL timeintchecknormalized( timeinterval2, 'ESMF_TimeIntervalGE arg2' )
1209
1210 ! call ESMC_BaseTime base class function
1211 call c_ESMC_BaseTimeIntGE(timeinterval1, timeinterval2, ESMF_TimeIntervalGE)
1212
1213 end function ESMF_TimeIntervalGE
1214
1215
1216 !------------------------------------------------------------------------------
1217 !BOP
1218 ! !IROUTINE: ESMF_TimeIntervalIsPositive - Time interval greater than zero?
1219
1220 ! !INTERFACE:
1221 function ESMF_TimeIntervalIsPositive(timeinterval)
1222 !
1223 ! !RETURN VALUE:
1224 logical :: ESMF_TimeIntervalIsPositive
1225
1226 ! !ARGUMENTS:
1227 type(ESMF_TimeInterval), intent(in) :: timeinterval
1228
1229 ! !LOCALS:
1230 type(ESMF_TimeInterval) :: zerotimeint
1231 integer :: rcint
1232
1233 ! !DESCRIPTION:
1234 ! Return true if time interval is greater than zero,
1235 ! false otherwise.
1236 !
1237 ! The arguments are:
1238 ! \begin{description}
1239 ! \item[timeinterval]
1240 ! Time interval to compare
1241 ! \end{description}
1242 !EOP
1243 CALL timeintchecknormalized( timeinterval, &
1244 'ESMF_TimeIntervalIsPositive arg' )
1245
1246 CALL ESMF_TimeIntervalSet ( zerotimeint, rc=rcint )
1247 IF ( rcint /= ESMF_SUCCESS ) THEN
1248 CALL wrf_error_fatal( &
1249 'ESMF_TimeIntervalIsPositive: ESMF_TimeIntervalSet failed' )
1250 ENDIF
1251 ! hack for bug in PGI 5.1-x
1252 ! ESMF_TimeIntervalIsPositive = timeinterval > zerotimeint
1253 ESMF_TimeIntervalIsPositive = ESMF_TimeIntervalGT( timeinterval, &
1254 zerotimeint )
1255 end function ESMF_TimeIntervalIsPositive
1256
1257 end module ESMF_TimeIntervalMod
1258
1259