LCOV - code coverage report
Current view: | top level - hemco/HEMCO/src/Core - hco_error_mod.F90 (source / functions) |  |  | Hit | Total | Coverage
Test: | coverage.info |  | Lines: | 0 | 189 | 0.0 %
Date: | 2024-12-17 22:39:59 |  | Functions: | 0 | 14 | 0.0 %

              Line data    Source code
           1             : !------------------------------------------------------------------------------
           2             : !                   Harmonized Emissions Component (HEMCO)                    !
           3             : !------------------------------------------------------------------------------
           4             : !BOP
           5             : !
           6             : ! !MODULE: hco_error_mod.F90
           7             : !
           8             : ! !DESCRIPTION: Module HCO\_Error\_Mod contains routines and variables
           9             : ! for error handling and logfile messages in HEMCO. It also contains
          10             : ! definitions of some globally used parameter, such as the single/double
          11             : ! precision as well as the HEMCO precision definitions. The HEMCO precision
          12             : ! is used for almost all HEMCO internal data arrays and can be changed below
          13             : ! if required.
          14             : !\\
          15             : !\\
          16             : ! The error settings are specified in the HEMCO configuration file and
          17             : ! error handling is performed according to these settings. They include:
          18             : !
          19             : ! \begin{enumerate}
          20             : ! \item HEMCO logfile: all HEMCO information is written into the specified
          21             : !     logfile. The logfile can be set to the wildcard character, in which
          22             : !     case the standard output will be used (this may be another opened
          23             : !     logfile).
          24             : ! \item Verbose: Number indicating the verbose level to be used.
          25             : !     0 = no verbose, 3 = very verbose. The verbose level can be set in
          26             : !     the HEMCO configuration file. The default value is 0.
          27             : ! \item Warnings: Number indicating the warning level to be shown.
          28             : !     0 = no warnings, 3 = all warnings.
          29             : ! \end{enumerate}
          30             : !
          31             : ! The error settings are set via subroutine HCO\_ERROR\_SET, called when
          32             : ! reading section 'settings' of the HEMCO configuration file (subroutine
          33             : ! Config\_ReadFile in hco\_config\_mod.F90). The currently active verbose
          34             : ! settings can be checked using subroutines HCO\_IsVerb and
          35             : ! HCO\_VERBOSE\_INQ. Messages can be written into the logfile using
          36             : ! subroutine HCO\_MSG. Note that the logfile actively need to be opened
          37             : ! (HCO\_LOGFILE\_OPEN) before writing to it.
          38             : !\\
          39             : !\\
          40             : ! The verbose and warning settings are all set to false if it's not the
          41             : ! root CPU.
          42             : !\\
          43             : !\\
          44             : ! As of HEMCO v2.0, all HEMCO error variables are organized in derived
          45             : ! type object HcoErr. HcoErr is a component of the HEMCO configuration
          46             : ! object (type ConfigObj, see hco\_types\_mod.F90). It must be passed
          47             : ! explicitly to all error routines. This design allows the invocation
          48             : ! of multiple independent HEMCO instances at the same time (which may
          49             : ! have different HEMCO error settings).
          50             : ! !INTERFACE:
          51             : !
          52             : MODULE HCO_Error_Mod
          53             : !
          54             : ! !USES:
          55             : !
          56             : #if defined( MAPL_ESMF )
          57             :     USE MAPL_Base, ONLY: MAPL_UNDEF
          58             : #endif
          59             :   USE ISO_Fortran_Env, ONLY : INT32, INT64, REAL32, REAL64
          60             :
          61             :   IMPLICIT NONE
          62             :   PRIVATE
          63             : !
          64             : ! !PUBLIC MEMBER FUNCTIONS:
          65             : !
          66             :   PUBLIC           :: HCO_ERROR
          67             :   PUBLIC           :: HCO_WARNING
          68             :   PUBLIC           :: HCO_MSG
          69             :   PUBLIC           :: HCO_ENTER
          70             :   PUBLIC           :: HCO_LEAVE
          71             :   PUBLIC           :: HCO_ERROR_SET
          72             :   PUBLIC           :: HCO_ERROR_FINAL
          73             :   PUBLIC           :: HCO_IsVerb
          74             :   PUBLIC           :: HCO_LOGFILE_OPEN
          75             :   PUBLIC           :: HCO_LOGFILE_CLOSE
          76             : !
          77             : ! !MODULE VARIABLES:
          78             : !
          79             :   ! Double and single precision definitions
          80             :   INTEGER, PARAMETER, PUBLIC  :: dp = REAL64         ! Double (r8)
          81             :   INTEGER, PARAMETER, PUBLIC  :: sp = REAL32         ! Single (r4)
          82             : #ifdef USE_REAL8
          83             :   INTEGER, PARAMETER, PUBLIC  :: hp = dp             ! HEMCO precision = r8
          84             : #else
          85             :   INTEGER, PARAMETER, PUBLIC  :: hp = sp             ! HEMCO precision = r4
          86             : #endif
          87             :   INTEGER, PARAMETER, PUBLIC  :: i4 = INT32          ! FourByteInt
          88             :   INTEGER, PARAMETER, PUBLIC  :: i8 = INT64          ! EightByteInt
          89             :
          90             :   ! Error success/failure definitions
          91             :   INTEGER, PARAMETER, PUBLIC  :: HCO_SUCCESS = 0
          92             :   INTEGER, PARAMETER, PUBLIC  :: HCO_FAIL    = -999
          93             :
          94             :   ! Tiny value for math operations:
          95             :   ! --> deprecated. Use TINY(1.0_hp) instead!
          96             :   REAL(hp), PARAMETER, PUBLIC :: HCO_TINY    = 1.0e-32_hp
          97             :
          98             :   ! Missing value
          99             :   ! Note: define missing value as single precision because all data arrays
         100             :   ! are read/stored in single precision.
         101             : #if defined( MAPL_ESMF )
         102             :   REAL(sp), PARAMETER, PUBLIC :: HCO_MISSVAL = MAPL_UNDEF
         103             : #else
         104             :   REAL(sp), PARAMETER, PUBLIC :: HCO_MISSVAL = -1.e31_sp
         105             : #endif
         106             :
         107             :   ! HEMCO version number.
         108             :   CHARACTER(LEN=12), PARAMETER, PUBLIC :: HCO_VERSION = '3.9.0'
         109             :
         110             :   INTERFACE HCO_Error
         111             :      MODULE PROCEDURE HCO_ErrorNoErr
         112             :      MODULE PROCEDURE HCO_ErrorErr
         113             :   END INTERFACE HCO_Error
         114             :
         115             :   INTERFACE HCO_Warning
         116             :      MODULE PROCEDURE HCO_WarningNoErr
         117             :      MODULE PROCEDURE HCO_WarningErr
         118             :   END INTERFACE HCO_Warning
         119             :
         120             :   INTERFACE HCO_MSG
         121             :      MODULE PROCEDURE HCO_MsgNoErr
         122             :      MODULE PROCEDURE HCO_MsgErr
         123             :   END INTERFACE HCO_MSG
         124             :
         125             : !
         126             : ! !REVISION HISTORY:
         127             : !  23 Sep 2013 - C. Keller   - Initialization
         128             : !  See https://github.com/geoschem/hemco for complete history
         129             : !EOP
         130             : !------------------------------------------------------------------------------
         131             : !BOC
         132             : !
         133             : ! !PRIVATE VARIABLES:
         134             : !
         135             :   TYPE, PUBLIC :: HcoErr
         136             :      LOGICAL                     :: FirstOpen = .TRUE.
         137             :      LOGICAL                     :: IsRoot    = .FALSE.
         138             :      LOGICAL                     :: LogIsOpen = .FALSE.
         139             :      LOGICAL                     :: doVerbose = .FALSE.
         140             :      INTEGER                     :: nWarnings =  0
         141             :      INTEGER                     :: CurrLoc   =  -1
         142             :      CHARACTER(LEN=255), POINTER :: Loc(:)    => NULL()
         143             :      CHARACTER(LEN=255)          :: LogFile   =  ''
         144             :      INTEGER                     :: Lun       =  -1
         145             :   END TYPE HcoErr
         146             :
         147             :   ! MAXNEST is the maximum accepted subroutines nesting level.
         148             :   ! This only applies to routines with activated error tracking,
         149             :   ! i.e. which use HCO_ENTER/HCO_LEAVE statements.
         150             :   INTEGER, PARAMETER       :: MAXNEST =  10
         151             :
         152             : CONTAINS
         153             : !EOC
         154             : !------------------------------------------------------------------------------
         155             : !                   Harmonized Emissions Component (HEMCO)                    !
         156             : !------------------------------------------------------------------------------
         157             : !BOP
         158             : !
         159             : ! !IROUTINE: HCO_Error
         160             : !
         161             : ! !DESCRIPTION: Subroutine HCO\_Error promts an error message and sets RC to
         162             : ! HCO\_FAIL. Note that this routine does not stop a run, but it will cause a
         163             : ! stop at higher level (when RC gets evaluated).
         164             : !\\
         165             : !\\
         166             : ! !INTERFACE:
         167             : !
         168           0 :   SUBROUTINE HCO_ErrorErr( Err, ErrMsg, RC, THISLOC )
         169             : !
         170             : ! !INPUT PARAMETERS:
         171             : !
         172             :     TYPE(HcoErr),     POINTER                  :: Err
         173             :     CHARACTER(LEN=*), INTENT(IN   )            :: ErrMsg
         174             :     CHARACTER(LEN=*), INTENT(IN   ), OPTIONAL  :: THISLOC
         175             : !
         176             : ! !INPUT/OUTPUT PARAMETERS:
         177             : !
         178             :     INTEGER,          INTENT(INOUT)            :: RC
         179             : !
         180             : ! !REVISION HISTORY:
         181             : !  23 Sep 2013 - C. Keller - Initialization
         182             : !  See https://github.com/geoschem/hemco for complete history
         183             : !EOP
         184             : !------------------------------------------------------------------------------
         185             : !BOC
         186             :     INTEGER :: I, J
         187             :     CHARACTER(LEN=1023) :: MSG
         188             :
         189             :     !======================================================================
         190             :     ! HCO_ERROR begins here
         191             :     !======================================================================
         192             :
         193             :     ! Print error message
         194           0 :     MSG =  'HEMCO ERROR: ' // TRIM(ErrMsg)
         195           0 :     CALL HCO_MSG ( Err, MSG, SEP1='!' )
         196             :
         197             :     ! Print error location
         198           0 :     IF ( PRESENT(THISLOC) ) THEN
         199           0 :        MSG = 'ERROR LOCATION: ' // TRIM( THISLOC )
         200           0 :        CALL HCO_MSG ( Err, MSG )
         201             :
         202             :     ! Traceback
         203             :     ELSE
         204           0 :        DO I = 0, Err%CurrLoc-1
         205           0 :           J = Err%CurrLoc-I
         206           0 :           MSG =  'ERROR LOCATION: ' // TRIM( Err%Loc(J) )
         207           0 :           CALL HCO_MSG ( Err, MSG )
         208             :        ENDDO
         209             :     ENDIF
         210             :
         211           0 :     MSG = ''
         212           0 :     CALL HCO_MSG ( Err, MSG, SEP2='!' )
         213             :
         214             :     ! Return w/ error
         215           0 :     RC = HCO_FAIL
         216             :
         217           0 :   END SUBROUTINE HCO_ErrorErr
         218             : !EOC
         219             : !------------------------------------------------------------------------------
         220             : !                   Harmonized Emissions Component (HEMCO)                    !
         221             : !------------------------------------------------------------------------------
         222             : !BOP
         223             : !
         224             : ! !IROUTINE: HCO_Error
         225             : !
         226             : ! !DESCRIPTION: Subroutine HCO\_Error promts an error message and sets RC to
         227             : ! HCO\_FAIL. Note that this routine does not stop a run, but it will cause a
         228             : ! stop at higher level (when RC gets evaluated).
         229             : !\\
         230             : !\\
         231             : ! !INTERFACE:
         232             : !
         233           0 :   SUBROUTINE HCO_ErrorNoErr( ErrMsg, RC, THISLOC )
         234             : !
         235             : ! !USES:
         236             : !
         237             : #if defined( ESMF_ )
         238             : #include "MAPL_Generic.h"
         239             :     USE ESMF
         240             :     USE MAPLBase_Mod
         241             : #endif
         242             : !
         243             : ! !INPUT PARAMETERS:
         244             : !
         245             :     CHARACTER(LEN=*), INTENT(IN   )            :: ErrMsg
         246             :     CHARACTER(LEN=*), INTENT(IN   ), OPTIONAL  :: THISLOC
         247             : !
         248             : ! !INPUT/OUTPUT PARAMETERS:
         249             : !
         250             :     INTEGER,          INTENT(INOUT)            :: RC
         251             : !
         252             : ! !REVISION HISTORY:
         253             : !  23 Sep 2013 - C. Keller - Initialization
         254             : !  See https://github.com/geoschem/hemco for complete history
         255             : !EOP
         256             : !------------------------------------------------------------------------------
         257             : !BOC
         258             :     INTEGER :: I, J
         259             :     CHARACTER(LEN=1023) :: MSG, MSG1, MSG2
         260             : #if defined( ESMF_)
         261             :     INTEGER             :: localPET, STATUS
         262             :     CHARACTER(4)        :: localPETchar
         263             :     TYPE(ESMF_VM)       :: VM
         264             : #endif
         265             :
         266             :     !======================================================================
         267             :     ! HCO_ERROR begins here
         268             :     !======================================================================
         269             :
         270             :     ! Construct error message
         271             : #if defined( ESMF_ )
         272             :     ! Get current thread number
         273             :     CALL ESMF_VMGetCurrent(VM, RC=STATUS)
         274             :     CALL ESMF_VmGet( VM, localPET=localPET, __RC__ )
         275             :     WRITE(localPETchar,'(I4.4)') localPET
         276             :     MSG1 = 'HEMCO ERROR ['//TRIM(localPETchar)//']: '//TRIM(ErrMsg)
         277             : #else
         278           0 :     MSG1 = 'HEMCO ERROR: '//TRIM(ErrMsg)
         279             : #endif
         280           0 :     MSG2 = ''
         281           0 :     IF ( PRESENT(THISLOC) ) THEN
         282           0 :        MSG2 = NEW_LINE('a') // ' --> LOCATION: ' // TRIM( THISLOC )
         283             :     ENDIF
         284           0 :     MSG = NEW_LINE('a') // TRIM(MSG1) // TRIM(MSG2)
         285             :
         286             :     ! Print error message
         287           0 :     WRITE(*,*) TRIM(MSG)
         288             :
         289             :     ! Return w/ error
         290           0 :     RC = HCO_FAIL
         291             :
         292           0 :   END SUBROUTINE HCO_ErrorNoErr
         293             : !EOC
         294             : !------------------------------------------------------------------------------
         295             : !                   Harmonized Emissions Component (HEMCO)                    !
         296             : !------------------------------------------------------------------------------
         297             : !BOP
         298             : !
         299             : ! !IROUTINE: HCO_Warning
         300             : !
         301             : ! !DESCRIPTION: Subroutine HCO\_Warning promts a warning message without
         302             : ! forcing HEMCO to stop, i.e. return code is set to HCO\_SUCCESS.
         303             : !\\
         304             : !\\
         305             : ! !INTERFACE:
         306             : !
         307           0 :   SUBROUTINE HCO_WarningErr( Err, ErrMsg, RC, THISLOC )
         308             : !
         309             : ! !INPUT PARAMETERS"
         310             : !
         311             :     TYPE(HcoErr),     POINTER                  :: Err
         312             :     CHARACTER(LEN=*), INTENT(IN   )            :: ErrMsg
         313             :     CHARACTER(LEN=*), INTENT(IN   ), OPTIONAL  :: THISLOC
         314             : !
         315             : ! !INPUT/OUTPUT PARAMETERS:
         316             : !
         317             :     INTEGER,          INTENT(INOUT)            :: RC
         318             : !
         319             : ! !REVISION HISTORY:
         320             : !  23 Sep 2013 - C. Keller - Initialization
         321             : !  See https://github.com/geoschem/hemco for complete history
         322             : !EOP
         323             : !------------------------------------------------------------------------------
         324             : !BOC
         325             :     INTEGER            :: WLEV
         326             :     CHARACTER(LEN=255) :: MSG
         327             :
         328             :     !======================================================================
         329             :     ! HCO_WARNING begins here
         330             :     !======================================================================
         331             :
         332             :     ! Only print warnings when verbose output is requested
         333           0 :     IF ( HCO_IsVerb( Err ) ) THEN
         334             :
         335             :        ! Print warning
         336           0 :        MSG = 'HEMCO WARNING: ' // TRIM( ErrMsg )
         337           0 :        CALL HCO_MSG ( Err, MSG )
         338             :
         339             :        ! Print location
         340           0 :        IF ( PRESENT(THISLOC) ) THEN
         341           0 :           MSG = '--> LOCATION: ' // TRIM(THISLOC)
         342           0 :           CALL HCO_MSG ( Err, MSG )
         343           0 :        ELSEIF ( Err%CurrLoc > 0 ) THEN
         344           0 :           MSG = '--> LOCATION: ' // TRIM(Err%Loc(Err%CurrLoc))
         345           0 :           CALL HCO_MSG ( Err, MSG )
         346             :        ENDIF
         347             :
         348             :        ! Increase # of warnings
         349           0 :        Err%nWarnings = Err%nWarnings + 1
         350             :     ENDIF
         351             :
         352             :     ! Return w/ success
         353           0 :     RC = HCO_SUCCESS
         354             :
         355           0 :   END SUBROUTINE HCO_WarningErr
         356             : !EOC
         357             : !------------------------------------------------------------------------------
         358             : !                   Harmonized Emissions Component (HEMCO)                    !
         359             : !------------------------------------------------------------------------------
         360             : !BOP
         361             : !
         362             : ! !IROUTINE: HCO_Warning
         363             : !
         364             : ! !DESCRIPTION: Subroutine HCO\_Warning promts a warning message without
         365             : ! forcing HEMCO to stop, i.e. return code is set to HCO\_SUCCESS.
         366             : !\\
         367             : !\\
         368             : ! !INTERFACE:
         369             : !
         370           0 :   SUBROUTINE HCO_WarningNoErr( ErrMsg, RC, verb, THISLOC )
         371             : !
         372             : ! !INPUT PARAMETERS"
         373             : !
         374             :     CHARACTER(LEN=*), INTENT(IN   )            :: ErrMsg
         375             :     LOGICAL         , INTENT(IN   ), OPTIONAL  :: verb
         376             :     CHARACTER(LEN=*), INTENT(IN   ), OPTIONAL  :: THISLOC
         377             : !
         378             : ! !INPUT/OUTPUT PARAMETERS:
         379             : !
         380             :     INTEGER,          INTENT(INOUT)            :: RC
         381             : !
         382             : ! !REVISION HISTORY:
         383             : !  23 Sep 2013 - C. Keller - Initialization
         384             : !  See https://github.com/geoschem/hemco for complete history
         385             : !EOP
         386             : !------------------------------------------------------------------------------
         387             : !BOC
         388             :     INTEGER            :: WLEV
         389             :     CHARACTER(LEN=255) :: MSG
         390             :
         391             :     !======================================================================
         392             :     ! HCO_WARNING begins here
         393             :     !======================================================================
         394             :
         395             :     ! Exit if verbose output is not requested
         396           0 :     IF ( .not. verb ) RETURN
         397             :
         398             :     ! Print warning
         399           0 :     MSG = 'HEMCO WARNING: ' // TRIM( ErrMsg )
         400           0 :     WRITE( 6, '(a)' ) TRIM(MSG)
         401             :
         402             :     ! Print location
         403           0 :     IF ( PRESENT(THISLOC) ) THEN
         404           0 :        MSG = '--> LOCATION: ' // TRIM(THISLOC)
         405           0 :        WRITE( 6, '(a)' ) TRIM(MSG)
         406             :     ENDIF
         407             :
         408             :     ! Return w/ success
         409           0 :     RC = HCO_SUCCESS
         410             :
         411             :   END SUBROUTINE HCO_WarningNoErr
         412             : !EOC
         413             : !------------------------------------------------------------------------------
         414             : !                   Harmonized Emissions Component (HEMCO)                    !
         415             : !------------------------------------------------------------------------------
         416             : !BOP
         417             : !
         418             : ! !IROUTINE: HCO_MSG
         419             : !
         420             : ! !DESCRIPTION: Subroutine HCO\_MSG passes message msg to the HEMCO
         421             : ! logfile (or to standard output if the logfile is not open).
         422             : ! Sep1 and Sep2 denote line delimiters before and after the message,
         423             : ! respectively.
         424             : ! The optional argument Verb denotes the minimum verbose level associated
         425             : ! with this message. The message will only be prompted if the verbose level
         426             : ! on this CPU (e.g. of this Err object) is at least as high as Verb.
         427             : !\\
         428             : !\\
         429             : ! !INTERFACE:
         430             : !
         431           0 :   SUBROUTINE HCO_MSGErr( Err, Msg, Sep1, Sep2 )
         432             : !
         433             : ! !INPUT PARAMETERS:
         434             : !
         435             :     TYPE(HcoErr),     POINTER                  :: Err
         436             :     CHARACTER(LEN=*), INTENT(IN   ), OPTIONAL  :: Msg
         437             :     CHARACTER(LEN=1), INTENT(IN   ), OPTIONAL  :: Sep1
         438             :     CHARACTER(LEN=1), INTENT(IN   ), OPTIONAL  :: Sep2
         439             : !
         440             : ! !REMARKS:
         441             : !  Refactored to avoid ELSE statements, which are a computational bottleneck.
         442             : !
         443             : ! !REVISION HISTORY:
         444             : !  23 Sep 2013 - C. Keller   - Initialization
         445             : !  See https://github.com/geoschem/hemco for complete history
         446             : !EOP
         447             : !------------------------------------------------------------------------------
         448             : !BOC
         449             :     INTEGER :: LUN
         450             :
         451             :     !=======================================================================
         452             :     ! HCO_MSG begins here
         453             :     !=======================================================================
         454             :
         455             :     ! Exit if Err is NULL
         456           0 :     IF ( .NOT. ASSOCIATED( Err) ) RETURN
         457             :
         458             :     ! Exit if we are not on the root core
         459           0 :     IF ( .NOT. Err%IsRoot ) RETURN
         460             :
         461             :     ! Exit if Verbose is turned off
         462           0 :     IF ( .not. Err%doVerbose ) RETURN
         463             :
         464             :     !=======================================================================
         465             :     ! Write message
         466             :     !=======================================================================
         467             :
         468             :     ! Get the file unit, or if the file is not open, use stdout
         469           0 :     LUN = Err%LUN
         470           0 :     IF ( ( .not. Err%LogIsOpen ) .or. ( LUN <= 0 ) ) LUN = 6
         471             :
         472             :     ! If logfile is open then write to it
         473             :     ! Otherwise write to stdout (unit #6)
         474           0 :     IF ( PRESENT(SEP1) ) THEN
         475           0 :        WRITE( LUN,'(a)' ) REPEAT( SEP1, 79 )
         476             :     ENDIF
         477           0 :     IF ( PRESENT(MSG) ) THEN
         478           0 :        WRITE( LUN,'(a)' ) TRIM( MSG )
         479             :     ENDIF
         480           0 :     IF ( PRESENT(SEP2) ) THEN
         481           0 :        WRITE( LUN,'(a)' ) REPEAT( SEP2, 79 )
         482             :     ENDIF
         483             :
         484             :   END SUBROUTINE HCO_MsgErr
         485             : !EOC
         486             : !------------------------------------------------------------------------------
         487             : !                   Harmonized Emissions Component (HEMCO)                    !
         488             : !------------------------------------------------------------------------------
         489             : !BOP
         490             : !
         491             : ! !IROUTINE: HCO_MSG
         492             : !
         493             : ! !DESCRIPTION: Subroutine HCO\_MSG passes message msg to the HEMCO
         494             : ! logfile (or to standard output if the logfile is not open).
         495             : ! Sep1 and Sep2 denote line delimiters before and after the message,
         496             : ! respectively.
         497             : ! The optional argument Verb denotes the minimum verbose level associated
         498             : ! with this message. The message will only be prompted if the verbose level
         499             : ! on this CPU (e.g. of this Err object) is at least as high as Verb.
         500             : !\\
         501             : !\\
         502             : ! !INTERFACE:
         503             : !
         504           0 :   SUBROUTINE HCO_MSGnoErr( Msg, Sep1, Sep2, Verb )
         505             : !
         506             : ! !INPUT PARAMETERS:
         507             : !
         508             :     CHARACTER(LEN=*), INTENT(IN   ), OPTIONAL  :: Msg
         509             :     CHARACTER(LEN=1), INTENT(IN   ), OPTIONAL  :: Sep1
         510             :     CHARACTER(LEN=1), INTENT(IN   ), OPTIONAL  :: Sep2
         511             :     LOGICAL,          INTENT(IN   ), OPTIONAL  :: Verb
         512             : !
         513             : ! !REVISION HISTORY:
         514             : !  23 Sep 2013 - C. Keller   - Initialization
         515             : !  See https://github.com/geoschem/hemco for complete history
         516             : !EOP
         517             : !------------------------------------------------------------------------------
         518             : !BOC
         519             :
         520             :     !======================================================================
         521             :     ! HCO_MSG begins here
         522             :     !======================================================================
         523             :
         524             :     ! Exit if verbose is not requested
         525           0 :     IF ( .not. Verb ) RETURN
         526             :
         527             :     ! Print message and optional separator lines
         528           0 :     IF ( PRESENT( SEP1 ) ) THEN
         529           0 :        WRITE( 6, '(a)' ) REPEAT( SEP1, 79 )
         530             :     ENDIF
         531           0 :     IF ( PRESENT( msg ) ) THEN
         532           0 :        WRITE( 6, '(a)' ) TRIM( msg )
         533             :     ENDIF
         534           0 :     IF ( PRESENT( SEP2 ) ) THEN
         535           0 :        WRITE( 6, '(a)' ) REPEAT( SEP2, 79 )
         536             :     ENDIF
         537             :
         538           0 :   END SUBROUTINE HCO_MsgNoErr
         539             : !EOC
         540             : !------------------------------------------------------------------------------
         541             : !                   Harmonized Emissions Component (HEMCO)                    !
         542             : !------------------------------------------------------------------------------
         543             : !BOP
         544             : !
         545             : ! !IROUTINE: HCO_Enter
         546             : !
         547             : ! !DESCRIPTION: Subroutine HCO\_Enter is called upon entering a routine.
         548             : ! It organizes the traceback handling. It is recommended to call this
         549             : ! routine for 'big' routines but NOT for routines/functions that are
         550             : ! frequently called, e.g. inside of loops!
         551             : !\\
         552             : !\\
         553             : ! Note that all subroutines calling HCO\_Enter must also call HCO\_Leave!
         554             : !\\
         555             : !\\
         556             : ! !INTERFACE:
         557             : !
         558           0 :   SUBROUTINE HCO_Enter( Err, thisLoc, RC )
         559             : !
         560             : ! !INPUT PARAMETERS:
         561             : !
         562             :     TYPE(HcoErr),     POINTER       :: Err
         563             :     CHARACTER(LEN=*), INTENT(IN   ) :: thisLoc
         564             : !
         565             : ! !INPUT/OUTPUT PARAMETERS:
         566             : !
         567             :     INTEGER,          INTENT(INOUT) :: RC
         568             : !
         569             : ! !REVISION HISTORY:
         570             : !  23 Sep 2013 - C. Keller - Initialization
         571             : !  See https://github.com/geoschem/hemco for complete history
         572             : !EOP
         573             : !------------------------------------------------------------------------------
         574             : !BOC
         575             :     CHARACTER(LEN=255)  :: Msg, Loc
         576             :
         577             :     !======================================================================
         578             :     ! HCO_ENTER begins here
         579             :     !======================================================================
         580             :
         581           0 :     IF ( .NOT. ASSOCIATED(Err) ) RETURN
         582             :
         583             :     ! Increment position
         584           0 :     Err%CurrLoc = Err%CurrLoc + 1
         585           0 :     IF ( Err%CurrLoc > MaxNest ) THEN
         586           0 :        Msg = 'MaxNest too low, cannot enter ' // TRIM(thisLoc)
         587           0 :        CALL HCO_Error( Err, Msg, RC )
         588           0 :        RETURN
         589             :     ENDIF
         590             :
         591             :     ! Error trap
         592           0 :     IF ( Err%CurrLoc <= 0 ) THEN
         593           0 :        Msg = 'CurrLoc is zero, cannot enter: ' // TRIM(thisLoc)
         594           0 :        CALL HCO_Error( Err, Msg, RC )
         595           0 :        RETURN
         596             :     ENDIF
         597             :
         598             :     ! Register current routine
         599           0 :     Err%Loc(Err%CurrLoc) = thisLoc
         600             :
         601             :     ! Track location if enabled
         602           0 :     IF ( HCO_IsVerb( Err ) ) THEN
         603           0 :        WRITE(MSG,100) TRIM(thisLoc), Err%CurrLoc
         604           0 :        CALL HCO_Msg( Err, MSG )
         605             :     ENDIF
         606             :
         607             :     ! Set RC to success
         608           0 :     RC = HCO_SUCCESS
         609             :
         610             : 100 FORMAT( 'HEMCO: Entering ', a, ' (', i2, ')' )
         611             :
         612           0 :   END SUBROUTINE HCO_Enter
         613             : !EOC
         614             : !------------------------------------------------------------------------------
         615             : !                   Harmonized Emissions Component (HEMCO)                    !
         616             : !------------------------------------------------------------------------------
         617             : !BOP
         618             : !
         619             : ! !IROUTINE: HCO_Leave
         620             : !
         621             : ! !DESCRIPTION: Subroutine HCO\_Leave is called upon leaving a routine.
         622             : ! It organizes the traceback handling. It is recommended to call this
         623             : ! routine for 'big' routines but NOT for routines/functions that are
         624             : ! frequently called, e.g. inside of loops!
         625             : !\\
         626             : !\\
         627             : ! Note that all subroutines calling HCO\_Leave must also call HCO\_Enter!
         628             : !\\
         629             : !\\
         630             : ! !INTERFACE:
         631             : !
         632           0 :   SUBROUTINE HCO_Leave( Err, RC )
         633             : !
         634             : ! !INPUT/OUTPUT PARAMETERS:
         635             : !
         636             :     TYPE(HcoErr),     POINTER       :: Err
         637             :     INTEGER,          INTENT(INOUT) :: RC
         638             : !
         639             : ! !REVISION HISTORY:
         640             : !  23 Sep 2013 - C. Keller - Initialization
         641             : !  See https://github.com/geoschem/hemco for complete history
         642             : !EOP
         643             : !------------------------------------------------------------------------------
         644             : !BOC
         645             :     CHARACTER(LEN=255)  :: MSG, LOC
         646             :
         647             :     !======================================================================
         648             :     ! HCO_LEAVE begins here
         649             :     !======================================================================
         650             :
         651           0 :     IF ( .NOT. ASSOCIATED(Err) ) RETURN
         652             :
         653             :     ! Track location if enabled
         654           0 :     IF ( HCO_IsVerb( Err ) ) THEN
         655           0 :        WRITE(MSG,110) TRIM(Err%Loc(Err%CurrLoc)), Err%CurrLoc
         656           0 :        CALL HCO_MSG( Err, MSG )
         657             :     ENDIF
         658             :
         659             :     ! Remove from list
         660           0 :     Err%Loc(Err%CurrLoc) = ''
         661             :
         662             :     ! Remove current position
         663           0 :     Err%CurrLoc = Err%CurrLoc - 1
         664             :
         665             :     ! Error trap
         666           0 :     IF ( Err%CurrLoc < 0 ) THEN
         667           0 :        Msg = 'CurrLoc is below zero, this should never happen!!'
         668           0 :        CALL HCO_ERROR ( Err, Msg, RC )
         669           0 :        RETURN
         670             :     ENDIF
         671             :
         672             :     ! Return w/ success
         673           0 :     RC = HCO_SUCCESS
         674             :
         675             : 110 FORMAT( 'HEMCO: Leaving ', a, ' (', i2, ')' )
         676             :
         677             :   END SUBROUTINE HCO_Leave
         678             : !EOC
         679             : !------------------------------------------------------------------------------
         680             : !                   Harmonized Emissions Component (HEMCO)                    !
         681             : !------------------------------------------------------------------------------
         682             : !BOP
         683             : !
         684             : ! !IROUTINE: HCO_Error_Set
         685             : !
         686             : ! !DESCRIPTION: Subroutine HCO\_Error\_Set defines the HEMCO error
         687             : ! settings. This routine is called at the beginning of a HEMCO
         688             : ! simulation. Its input parameter are directly taken from the
         689             : ! HEMCO configuration file. If LogFile is set to '*' (asterik),
         690             : ! all output is directed to the standard output.
         691             : !\\
         692             : !\\
         693             : ! !INTERFACE:
         694             : !
         695           0 :   SUBROUTINE HCO_ERROR_SET( am_I_Root, Err,             LogFile,             &
         696             :                             doVerbose, doVerboseOnRoot, RC                  )
         697             :
         698             : !
         699             : !  !INPUT PARAMETERS:
         700             : !
         701             :     LOGICAL,          INTENT(IN)     :: am_I_Root       ! Root CPU?
         702             :     TYPE(HcoErr),     POINTER        :: Err             ! Error object
         703             :     CHARACTER(LEN=*), INTENT(IN)     :: LogFile         ! logfile path+name
         704             : !
         705             : ! !INPUT/OUTPUT PARAMETERS:
         706             : !
         707             :     LOGICAL,          INTENT(INOUT)  :: doVerbose       ! Verbose output T/F?
         708             :     LOGICAL,          INTENT(INOUT)  :: doVerboseOnRoot ! =T: Verbose on root
         709             :                                                         ! =F: Verbose on all
         710             :     INTEGER,          INTENT(INOUT)  :: RC
         711             : !
         712             : ! !REVISION HISTORY:
         713             : !  23 Sep 2013 - C. Keller - Initialization
         714             : !  See https://github.com/geoschem/hemco for complete history
         715             : !EOP
         716             : !------------------------------------------------------------------------------
         717             : !BOC
         718             :
         719             :     INTEGER :: Lun
         720             :
         721             :     !======================================================================
         722             :     ! HCO_ERROR_SET begins here
         723             :     !======================================================================
         724             :
         725             :     ! Nothing to do if already defined
         726           0 :     RC = HCO_SUCCESS
         727           0 :     IF ( ASSOCIATED(Err) ) RETURN
         728             :
         729             :     ! Allocate error type
         730           0 :     ALLOCATE(Err)
         731           0 :     ALLOCATE(Err%Loc(MAXNEST))
         732           0 :     Err%Loc(:) = ''
         733             :
         734             :     ! Pass values
         735           0 :     Err%IsRoot  = am_I_Root
         736           0 :     Err%LogFile = TRIM(LogFile)
         737             :
         738             :     ! Specify if verbose will be printed on the root core, or all cores
         739           0 :     IF ( doVerboseOnRoot ) THEN
         740           0 :        Err%doVerbose = ( doVerbose .and. am_I_Root )
         741             :     ELSE
         742           0 :        Err%doVerbose = doVerbose
         743             :     ENDIF
         744             :
         745             :     ! Init misc. values
         746           0 :     Err%FirstOpen = .TRUE.
         747           0 :     Err%LogIsOpen = .FALSE.
         748           0 :     Err%CurrLoc   = 0
         749             :
         750             :     ! If Logfile is set to '*', set lun to -1 (--> write into default file).
         751             :     ! Otherwise, set lun to 0 (--> write into specified logfile)
         752           0 :     IF ( TRIM(Err%LogFile) == '*' ) THEN
         753             :        LUN = -1
         754             :     ELSE
         755           0 :        LUN = 0
         756             :     ENDIF
         757           0 :     Err%Lun = LUN
         758             :
         759             :     ! Return w/ success
         760           0 :     RC = HCO_SUCCESS
         761             :
         762             :   END SUBROUTINE HCO_ERROR_SET
         763             : !EOC
         764             : !------------------------------------------------------------------------------
         765             : !                   Harmonized Emissions Component (HEMCO)                    !
         766             : !------------------------------------------------------------------------------
         767             : !BOP
         768             : !
         769             : ! !IROUTINE: HCO_Error_Final
         770             : !
         771             : ! !DESCRIPTION: Subroutine HCO\_Error\_Final finalizes the error type.
         772             : !\\
         773             : !\\
         774             : ! !INTERFACE:
         775             : !
         776           0 :   SUBROUTINE HCO_Error_Final ( Err )
         777             : !
         778             : !  !INPUT/OUTPUT PARAMETERS:
         779             : !
         780             :     TYPE(HcoErr),     POINTER        :: Err            ! Error object
         781             : !
         782             : ! !REVISION HISTORY:
         783             : !  23 Sep 2013 - C. Keller - Initialization
         784             : !  See https://github.com/geoschem/hemco for complete history
         785             : !EOP
         786             : !------------------------------------------------------------------------------
         787             : !BOC
         788             :
         789             :     INTEGER :: STAT
         790             :
         791             :     !======================================================================
         792             :     ! HCO_ERROR_FINAL begins here
         793             :     !======================================================================
         794             :
         795             :     ! Eventually close logfile
         796           0 :     CALL HCO_Logfile_Close( Err, ShowSummary=.TRUE. )
         797             :
         798           0 :     IF ( ASSOCIATED(Err) ) THEN
         799           0 :        IF ( ASSOCIATED(Err%Loc) ) DEALLOCATE(Err%Loc)
         800           0 :        DEALLOCATE(Err)
         801             :     ENDIF
         802           0 :     Err => NULL()
         803             :
         804           0 :   END SUBROUTINE HCO_Error_Final
         805             : !EOC
         806             : !------------------------------------------------------------------------------
         807             : !                   Harmonized Emissions Component (HEMCO)                    !
         808             : !------------------------------------------------------------------------------
         809             : !BOP
         810             : !
         811             : ! !IROUTINE: HCO_IsVerb
         812             : !
         813             : ! !DESCRIPTION: Returns true if the HEMCO verbose output is turned on.
         814             : !\\
         815             : !\\
         816             : ! !INTERFACE:
         817             : !
         818           0 :   FUNCTION HCO_IsVerb( Err ) RESULT ( IsVerb )
         819             : !
         820             : ! !INPUT PARAMETERS:
         821             : !
         822             :     TYPE(HcoErr),  POINTER :: Err            ! Error object
         823             : !
         824             : ! !OUTPUT PARAMETERS:
         825             : !
         826             :     LOGICAL                :: isVerb
         827             : !EOP
         828             : !------------------------------------------------------------------------------
         829             : !BOC
         830             :
         831             :     !======================================================================
         832             :     ! HCO_IsVerb begins here
         833             :     !======================================================================
         834             :
         835             :     ! Initialize
         836           0 :     isVerb = .FALSE.
         837             :
         838             :     ! Return if the Err object is null
         839           0 :     IF ( .not. ASSOCIATED( Err ) ) RETURN
         840             :
         841             :     ! Check if "Verbose: 3" was set in the HEMCO_Config.rc file
         842           0 :     isVerb = Err%doVerbose
         843             :
         844           0 :   END FUNCTION HCO_IsVerb
         845             : !EOC
         846             : !------------------------------------------------------------------------------
         847             : !                   Harmonized Emissions Component (HEMCO)                    !
         848             : !------------------------------------------------------------------------------
         849             : !BOP
         850             : !
         851             : ! !ROUTINE: HCO_LOGFILE_OPEN
         852             : !
         853             : ! !DESCRIPTION: Subroutine HCO\_LOGFILE\_OPEN opens the HEMCO logfile
         854             : ! (if not yet open).
         855             : !\\
         856             : !\\
         857             : ! !INTERFACE:
         858             : !
         859           0 :   SUBROUTINE HCO_LogFile_Open( Err, RC )
         860             : !
         861             : ! !USES:
         862             : !
         863             :     USE HCO_inquireMod,   ONLY : findFreeLUN
         864             : !
         865             : ! !INPUT/OUTPUT PARAMETERS:
         866             : !
         867             :     TYPE(HcoErr),  POINTER    :: Err            ! Error object
         868             :     INTEGER,   INTENT(INOUT)  :: RC
         869             : !
         870             : ! !REVISION HISTORY:
         871             : !  23 Sep 2013 - C. Keller   - Initialization
         872             : !  See https://github.com/geoschem/hemco for complete history
         873             : !EOP
         874             : !------------------------------------------------------------------------------
         875             : !BOC
         876             :     CHARACTER(LEN=255) :: MSG
         877             :     INTEGER            :: IOS, LUN, FREELUN
         878             :     LOGICAL            :: isopen, exists
         879             :
         880             :     !======================================================================
         881             :     ! HCO_LOGFILE_OPEN begins here
         882             :     !======================================================================
         883             :
         884             :     ! Init
         885           0 :     RC = HCO_SUCCESS
         886             :
         887             :     ! Check if object exists
         888           0 :     IF ( .NOT. ASSOCIATED(Err)) THEN
         889           0 :        PRINT *, 'Cannot open logfile - Err object not defined!'
         890           0 :        RC = HCO_FAIL
         891           0 :        RETURN
         892             :     ENDIF
         893             :
         894             :     ! Never open if we are not on the root CPU
         895           0 :     IF ( .NOT. Err%IsRoot ) RETURN
         896             :
         897             :     ! Don't do anything if we write into standard output!
         898           0 :     IF ( Err%LUN < 0 ) THEN
         899           0 :        Err%LogIsOpen = .TRUE.
         900             :
         901             :     ! Explicit HEMCO logfile:
         902             :     ELSE
         903             :
         904             :        ! Find free LUN just in case we need it!
         905           0 :        FREELUN = findFreeLun()
         906             :
         907             :        ! Inquire if file is already open
         908           0 :        INQUIRE( FILE=TRIM(Err%LogFile), OPENED=isOpen, EXIST=exists, NUMBER=LUN )
         909             :
         910             :        ! File exists and is opened ==> nothing to do
         911           0 :        IF ( exists .AND. isOpen ) THEN
         912           0 :           Err%LUN       = LUN
         913           0 :           Err%LogIsOpen = .TRUE.
         914             :
         915             :        ! File exists but not opened ==> reopen
         916           0 :        ELSEIF (exists .AND. .NOT. isOpen ) THEN
         917             :
         918             :           ! Replace existing file on first call
         919           0 :           IF ( Err%FirstOpen ) THEN
         920             :              OPEN ( UNIT=FREELUN,   FILE=TRIM(Err%LogFile), STATUS='REPLACE', &
         921           0 :                     ACTION='WRITE', FORM='FORMATTED',       IOSTAT=IOS         )
         922           0 :              IF ( IOS /= 0 ) THEN
         923           0 :                 PRINT *, 'Cannot create logfile: ' // TRIM(Err%LogFile)
         924           0 :                 RC = HCO_FAIL
         925           0 :                 RETURN
         926             :              ENDIF
         927             :
         928             :        ! File exists and is opened ==> nothing to do
         929             :
         930             :
         931             :           ! Reopen otherwise
         932             :           ELSE
         933             :              OPEN ( UNIT=FREELUN,   FILE=TRIM(Err%LogFile), STATUS='OLD',     &
         934             :                     ACTION='WRITE', POSITION='APPEND', FORM='FORMATTED',    &  ! NAG did not like ACCESS='APPEND' -- use standard-compliant position='append'
         935           0 :                     IOSTAT=IOS   )
         936           0 :              IF ( IOS /= 0 ) THEN
         937           0 :                 PRINT *, 'Cannot reopen logfile: ' // TRIM(Err%LogFile)
         938           0 :                 RC = HCO_FAIL
         939           0 :                 RETURN
         940             :              ENDIF
         941             :           ENDIF
         942             :
         943           0 :           Err%LUN       = FREELUN
         944           0 :           Err%LogIsOpen = .TRUE.
         945             :
         946             :        ! File does not yet exist ==> open new file
         947             :        ELSE
         948             :           OPEN ( UNIT=FREELUN,    FILE=TRIM(Err%LogFile),      &
         949             :                  STATUS='NEW',    ACTION='WRITE', IOSTAT=IOS,  &
         950           0 :                  FORM='FORMATTED'                             )
         951           0 :           IF ( IOS /= 0 ) THEN
         952           0 :              PRINT *, 'Cannot create logfile: ' // TRIM(Err%LogFile)
         953           0 :              RC = HCO_FAIL
         954           0 :              RETURN
         955             :           ENDIF
         956           0 :           Err%LUN       = FREELUN
         957           0 :           Err%LogIsOpen = .TRUE.
         958             :        ENDIF
         959             :     ENDIF
         960             :
         961             :     ! Write header on first call
         962           0 :     IF ( Err%FirstOpen ) THEN
         963           0 :        LUN = Err%Lun                ! Log gets written to file
         964           0 :        IF ( Err%LUN < 0 ) LUN = 6   ! or to stdout if file isn't open
         965             :
         966             :        ! Only write the version info if verbose output is requested
         967           0 :        IF ( HCO_IsVerb( Err ) ) THEN
         968             :
         969             :           ! Write header
         970           0 :           WRITE( LUN, '(a)'      ) REPEAT( '-', 79)
         971           0 :           WRITE( LUN, '(a12, a)' ) 'Using HEMCO ', HCO_VERSION
         972           0 :           WRITE( LUN, '(a)'        )
         973             : #ifdef USE_REAL8
         974           0 :           WRITE( LUN,  100       )
         975             : 100       FORMAT('HEMCO precision (hp) is set to is 8-byte real (aka REAL*8)')
         976             : #else
         977             :           WRITE( LUN,  110       )
         978             : 110       FORMAT('HEMCO precision (hp) is set to is 4-byte real (aka REAL*4)')
         979             : #endif
         980           0 :           WRITE( LUN, '(a)'      ) REPEAT( '-', 79)
         981             :        ENDIF
         982             :
         983           0 :        Err%FirstOpen = .FALSE.
         984             :     ENDIF
         985             :
         986             :     ! Return w/ success
         987           0 :     RC = HCO_SUCCESS
         988             :
         989             :   END SUBROUTINE HCO_Logfile_Open
         990             : !EOC
         991             : !------------------------------------------------------------------------------
         992             : !                   Harmonized Emissions Component (HEMCO)                    !
         993             : !------------------------------------------------------------------------------
         994             : !BOP
         995             : !
         996             : ! !IROUTINE: HCO_LogFile_Close
         997             : !
         998             : ! !DESCRIPTION: Subroutine HCO\_LOGFILE\_CLOSE closes the HEMCO logfile.
         999             : ! If argument ShowSummary is enabled, it will prompt a summary of the
        1000             : ! HEMCO run up to this point (number of warnings, etc.).
        1001             : !\\
        1002             : !\\
        1003             : ! !INTERFACE:
        1004             : !
        1005           0 :   SUBROUTINE HCO_LogFile_Close( Err, ShowSummary )
        1006             : !
        1007             : ! !INPUT PARAMETERS:
        1008             : !
        1009             :     TYPE(HcoErr),  POINTER        :: Err            ! Error object
        1010             :     LOGICAL, INTENT(IN), OPTIONAL :: ShowSummary
        1011             : !
        1012             : ! !REVISION HISTORY:
        1013             : !  23 Sep 2013 - C. Keller - Initialization
        1014             : !  See https://github.com/geoschem/hemco for complete history
        1015             : !EOP
        1016             : !------------------------------------------------------------------------------
        1017             : !BOC
        1018             :     INTEGER            :: IOS
        1019             :     LOGICAL            :: Summary
        1020             :     CHARACTER(LEN=255) :: MSG
        1021             :
        1022             :     !======================================================================
        1023             :     ! HCO_LOGFILE_CLOSE begins here
        1024             :     !======================================================================
        1025             :
        1026             :     ! Check if object exists
        1027           0 :     IF ( .NOT. ASSOCIATED(Err)) RETURN
        1028           0 :     IF ( .NOT. Err%LogIsOpen  ) RETURN
        1029           0 :     IF ( .NOT. Err%IsRoot     ) RETURN
        1030             :
        1031             :     ! Show summary?
        1032           0 :     IF ( PRESENT(ShowSummary) ) THEN
        1033           0 :        Summary = ShowSummary
        1034             :     ELSE
        1035             :        Summary = .FALSE.
        1036             :     ENDIF
        1037             :
        1038             :     ! Eventually print summary
        1039           0 :     IF ( Summary ) THEN
        1040           0 :        MSG = ' '
        1041           0 :        CALL HCO_MSG ( Err, MSG )
        1042           0 :        MSG = 'HEMCO ' // TRIM(HCO_VERSION) // ' FINISHED.'
        1043           0 :        CALL HCO_MSG ( Err, MSG, SEP1='-' )
        1044             :
        1045             :        WRITE(MSG,'(A16,I1,A12,I6)') &
        1046           0 :           'Warnings: ', Err%nWarnings
        1047           0 :        CALL HCO_MSG ( Err, MSG, SEP2='-' )
        1048             :     ENDIF
        1049             :
        1050             :     ! Close logfile only if lun is defined
        1051           0 :     IF ( Err%Lun>0 ) THEN
        1052           0 :        CLOSE ( UNIT=Err%Lun, IOSTAT=IOS )
        1053           0 :        IF ( IOS/= 0 ) THEN
        1054           0 :           PRINT *, 'Cannot close logfile: ' // TRIM(Err%LogFile)
        1055             :        ENDIF
        1056             :     ENDIF
        1057           0 :     Err%LogIsOpen = .FALSE.
        1058             :
        1059             :   END SUBROUTINE HCO_LogFile_Close
        1060             : !EOC
        1061           0 : END MODULE HCO_Error_Mod

Generated by: LCOV version 1.14