LCOV - code coverage report
Current view: top level - hemco/HEMCO/src/Core - hco_extlist_mod.F90 (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 385 0.0 %
Date: 2024-12-17 17:57:11 Functions: 0 16 0.0 %

          Line data    Source code
       1             : !------------------------------------------------------------------------------
       2             : !                   Harmonized Emissions Component (HEMCO)                    !
       3             : !------------------------------------------------------------------------------
       4             : !BOP
       5             : !
       6             : ! !MODULE: hco_extlist_mod
       7             : !
       8             : ! !DESCRIPTION: Module HCO\_EXTLIST\_MOD contains routines and
       9             : ! variables to organize HEMCO extensions and the corresponding
      10             : ! settings (options). This is done through the ExtList object,
      11             : ! which is a simple list containing all enabled HEMCO extensions
      12             : ! (name and ext. ID) and the corresponding options, as defined in
      13             : ! the HEMCO configuration file. The general HEMCO settings are
      14             : ! stored as options of the HEMCO core extension (Extension number
      15             : ! = 0). The CORE extension is activated in every HEMCO run, while
      16             : ! all other extensions are only activated if enabled in the
      17             : ! configuration file.
      18             : !\\
      19             : !\\
      20             : ! Extension number -999 is used as 'wildcard' value, e.g. data
      21             : ! containers with extension number -999 will always be read by
      22             : ! HEMCO but will be ignored for emission calculation. This is
      23             : ! particularly useful for data fields that shall be used outside
      24             : ! of HEMCO, e.g. stratospheric chemistry prod/loss rates, etc.
      25             : !\\
      26             : !\\
      27             : ! Extension options are 'flexible' in a sense that any option
      28             : ! name/value pair can be assigned to an extension. The value of
      29             : ! any of these options can be queried using subroutine GetExtOpt
      30             : ! or function HCO\_GetOpt. In fact, the HEMCO filename parser
      31             : ! (in hco\_chartools\_mod.F90) will attempt to find an option
      32             : ! value for any HEMCO 'token' (a character starting with the
      33             : ! HEMCO token sign (which is, the dollar sign '\$'). This allows
      34             : ! the user to specify as many individual tokens as HEMCO
      35             : ! settings as needed.
      36             : !\\
      37             : !\\
      38             : ! !INTERFACE:
      39             : !
      40             : MODULE HCO_ExtList_Mod
      41             : !
      42             : ! !USES:
      43             : !
      44             :   USE HCO_Error_Mod
      45             :   USE HCO_Types_Mod
      46             : 
      47             :   IMPLICIT NONE
      48             :   PRIVATE
      49             : !
      50             : ! !PUBLIC MEMBER FUNCTIONS:
      51             : !
      52             :   PUBLIC  :: AddExt
      53             :   PUBLIC  :: AddExtOpt
      54             :   PUBLIC  :: GetExtOpt
      55             :   PUBLIC  :: GetExtNr
      56             :   PUBLIC  :: GetExtSpcStr
      57             :   PUBLIC  :: GetExtSpcVal
      58             :   PUBLIC  :: SetExtNr
      59             :   PUBLIC  :: ExtNrInUse
      60             :   PUBLIC  :: ExtFinal
      61             :   PUBLIC  :: HCO_GetOpt
      62             :   PUBLIC  :: HCO_SetDefaultToken
      63             :   PUBLIC  :: HCO_ROOT
      64             : 
      65             :   PRIVATE :: HCO_AddOpt
      66             :   PRIVATE :: HCO_CleanupOpt
      67             : 
      68             :   ! Core extension number
      69             :   INTEGER, PARAMETER, PUBLIC  :: CoreNr = -1
      70             : !
      71             : ! !REVISION HISTORY:
      72             : !  02 Oct 2013 - C. Keller   - Initial version
      73             : !  See https://github.com/geoschem/hemco for complete history
      74             : !EOP
      75             : !-----------------------------------------------------------------------------
      76             : !BOC
      77             : !
      78             : ! !PRIVATE TYPES:
      79             : !
      80             :   ! Lenght of maximum token character length
      81             :   CHARACTER(LEN=OPTLEN), PARAMETER  :: EMPTYOPT = '---'
      82             : 
      83             :   !---------------------------------------------------------------------------
      84             :   ! Default tokens
      85             :   ! HEMCO has three tokens that can be specified in the HEMCO configuration
      86             :   ! file: ROOT (root directory), MET/met (met fields), and RES (horizontal
      87             :   ! resolution). These tokens can be used in file names to be dynamically
      88             :   ! replaced, e.g. file.$MET.$RES.nc becomes file.GEOSFP.4x5.nc if MET is set
      89             :   ! to 'GEOSFP' and RES to '4x5'. Opts are also allowed for dates ($YYYY,
      90             :   ! $MM, $DD, $HH, see routine HCO_CharParse).
      91             :   ! The default tokens below will be used if by default, i.e. if the
      92             :   ! corresponding token is not specified in the HEMCO configuration file.
      93             :   !---------------------------------------------------------------------------
      94             : 
      95             :   ! Default root directory
      96             :   CHARACTER(LEN=OPTLEN), PARAMETER :: DEF_ROOT = '/please/provide/root/path'
      97             : 
      98             :   ! Default values for characters that can be changed
      99             :   ! through the configuration file
     100             :   CHARACTER(LEN=1),    PARAMETER :: DEF_COLON     = ':'
     101             :   CHARACTER(LEN=1),    PARAMETER :: DEF_SEPARATOR = '/'
     102             :   CHARACTER(LEN=1),    PARAMETER :: DEF_WILDCARD  = '*'
     103             : 
     104             :   ! Met field and grid tokens
     105             :   CHARACTER(LEN=15)              :: DEF_MET_UC = 'UNKNOWN_MET'
     106             :   CHARACTER(LEN=15)              :: DEF_MET_LC = 'unknown_met'
     107             :   CHARACTER(LEN=15)              :: DEF_MET_EXT= 'unknown_extension'
     108             :   CHARACTER(LEN=15)              :: DEF_CN_YR  = 'unknown_year'
     109             :   CHARACTER(LEN=15)              :: DEF_RES    = 'unknown_res'
     110             :   CHARACTER(LEN=15)              :: DEF_NC_VER = 'nc'
     111             : 
     112             :   INTERFACE GetExtSpcVal
     113             :      MODULE PROCEDURE GetExtSpcVal_Char
     114             :      MODULE PROCEDURE GetExtSpcVal_Int
     115             :      MODULE PROCEDURE GetExtSpcVal_Sp
     116             :   END INTERFACE GetExtSpcVal
     117             : 
     118             : CONTAINS
     119             : !EOC
     120             : !------------------------------------------------------------------------------
     121             : !                   Harmonized Emissions Component (HEMCO)                    !
     122             : !------------------------------------------------------------------------------
     123             : !BOP
     124             : !
     125             : ! !IROUTINE: AddExt
     126             : !
     127             : ! !DESCRIPTION: Subroutine AddExt adds a new extension to the extensions
     128             : ! list. The extension name, number and species (multiple species separated
     129             : ! by the HEMCO separator sign) need to be provided. Extension options are
     130             : ! left blank but can be added lateron using AddExtOpt.
     131             : !\\
     132             : !\\
     133             : ! !INTERFACE:
     134             : !
     135           0 :   SUBROUTINE AddExt( HcoConfig, ExtName, ExtNr, InUse, Spcs, RC )
     136             : !
     137             : ! !USES:
     138             : !
     139             :     USE HCO_CHARPAK_MOD,  ONLY : TRANLC
     140             : !
     141             : ! !INPUT PARAMETERS::
     142             : !
     143             :     TYPE(ConfigObj),  POINTER       :: HcoConfig
     144             :     CHARACTER(LEN=*), INTENT(IN   ) :: ExtName
     145             :     INTEGER,          INTENT(IN   ) :: ExtNr
     146             :     LOGICAL,          INTENT(IN   ) :: InUse
     147             :     CHARACTER(LEN=*), INTENT(IN   ) :: Spcs
     148             : !
     149             : ! !INPUT/OUTPUT PARAMETERS::
     150             : !
     151             :     INTEGER,          INTENT(INOUT) :: RC
     152             : !
     153             : ! !REVISION HISTORY:
     154             : !  03 Oct 2013 - C. Keller - Initial version
     155             : !  See https://github.com/geoschem/hemco for complete history
     156             : !EOP
     157             : !------------------------------------------------------------------------------
     158             : !BOC
     159             : !
     160             : ! !INTERNAL VARIABLES:
     161             : !
     162             :     INTEGER             :: OrigExtNr
     163             :     CHARACTER(LEN=255)  :: MSG, lcName
     164             :     TYPE(Ext), POINTER  :: NewExt
     165             :     TYPE(Ext), POINTER  :: ThisExt
     166             : 
     167             :     !======================================================================
     168             :     ! AddExt
     169             :     !======================================================================
     170             : 
     171             :     ! Init
     172           0 :     NewExt  => NULL()
     173           0 :     ThisExt => NULL()
     174             : 
     175             :     ! All extension names are lower case
     176           0 :     lcName = TRIM(ExtName)
     177           0 :     CALL TRANLC( lcName )
     178             : 
     179             :     ! Check if extension already exists
     180           0 :     OrigExtNr = GetExtNr( HcoConfig%ExtList, TRIM(lcName) )
     181           0 :     IF ( OrigExtNr /= -999 ) THEN
     182             : 
     183             :        ! Return w/ error if extension numbers do not match
     184           0 :        IF ( OrigExtNr /= ExtNr ) THEN
     185           0 :           WRITE(MSG,*) 'Cannot create extension - extension already exists', &
     186           0 :                        TRIM(lcName), ExtNr, OrigExtNr
     187           0 :           CALL HCO_ERROR(MSG,RC,THISLOC='AddExt (hco_extlist_mod.F90)')
     188           0 :           RETURN
     189             : 
     190             :        ! Nothing to do otherwise
     191             :        ELSE
     192           0 :           RC = HCO_SUCCESS
     193           0 :           RETURN
     194             :        ENDIF
     195             :     ENDIF
     196             : 
     197             :     ! Allocate type
     198           0 :     ALLOCATE ( NewExt )
     199           0 :     NewExt%NextExt => NULL()
     200             : 
     201             :     ! Set extension name
     202           0 :     NewExt%ExtName = lcName
     203             : 
     204             :     ! Set extension number and species. Set to invalid values if not used.
     205           0 :     IF ( InUse ) THEN
     206           0 :        NewExt%ExtNr = ExtNr
     207           0 :        NewExt%Spcs  = Spcs
     208             :     ELSE
     209           0 :        NewExt%ExtNr = -1
     210           0 :        NewExt%Spcs  = 'None'
     211             :     ENDIF
     212             : 
     213             :     ! Initialize extension options. These will be filled lateron
     214           0 :     NewExt%Opts    => NULL()
     215             : 
     216             :     ! Place at end of extension list
     217             :     ! The rational for this is simply that the more often used extension options
     218             :     ! (of the HEMCO 'core' and 'base' extensions) are set first and we better have
     219             :     ! them at the beginning of ExtList for better efficiency.
     220             : 
     221             :     ! If this is the first entry...
     222           0 :     IF ( .NOT. ASSOCIATED(HcoConfig%ExtList) ) THEN
     223           0 :        HcoConfig%ExtList => NewExt
     224             : 
     225             :     ! Otherwise, scan list until last extension is encountered
     226             :     ELSE
     227             :        ThisExt => HcoConfig%ExtList
     228           0 :        DO WHILE(ASSOCIATED(ThisExt))
     229           0 :           IF ( .NOT. ASSOCIATED(ThisExt%NextExt) ) EXIT
     230           0 :           ThisExt => ThisExt%NextExt
     231             :        END DO
     232             : 
     233             :        ! Append new extension to the list
     234           0 :        ThisExt%NextExt => NewExt
     235             :     ENDIF
     236             : 
     237             :     ! Verbose
     238           0 :     IF ( HcoConfig%amIRoot .AND. HCO_IsVerb(HcoConfig%Err) .AND. InUse ) THEN
     239           0 :        WRITE(MSG,*) 'Added HEMCO extension: ', TRIM(ExtName), ExtNr
     240           0 :        CALL HCO_MSG(HcoConfig%Err,MSG)
     241             :     ENDIF
     242             : 
     243             :     ! Cleanup
     244           0 :     ThisExt => NULL()
     245             : 
     246             :     ! Return w/ success
     247           0 :     RC = HCO_SUCCESS
     248             : 
     249           0 :   END SUBROUTINE AddExt
     250             : !EOC
     251             : !------------------------------------------------------------------------------
     252             : !                   Harmonized Emissions Component (HEMCO)                    !
     253             : !------------------------------------------------------------------------------
     254             : !BOP
     255             : !
     256             : ! !IROUTINE: AddExtOpt
     257             : !
     258             : ! !DESCRIPTION: Function AddExtOpt appends the given string to the options
     259             : ! character of the desired extension (identified by its extension number).
     260             : ! The options string is expected to contain an option name and value,
     261             : ! separated by a colon (:).
     262             : ! Function GetExtOpt can be used to extract the option value at a later
     263             : ! point.
     264             : !\\
     265             : !\\
     266             : ! !INTERFACE:
     267             : !
     268           0 :   SUBROUTINE AddExtOpt( HcoConfig, Opt, ExtNr, RC, IgnoreIfExist )
     269             : !
     270             : ! !USES:
     271             : !
     272             :   USE HCO_CHARPAK_MOD,       ONLY : STRSPLIT, TRANLC
     273             : !
     274             : ! !INPUT PARAMETERS:
     275             : !
     276             :     TYPE(ConfigObj),  POINTER                 :: HcoConfig      ! Configuration object
     277             :     CHARACTER(LEN=*), INTENT(IN   )           :: Opt            ! Option name & value
     278             :     INTEGER,          INTENT(IN   )           :: ExtNr          ! Add to this extension
     279             :     LOGICAL,          INTENT(IN   ), OPTIONAL :: IgnoreIfExist  ! Ignore this entry if it exists already?
     280             : !
     281             : ! !INPUT/OUTPUT PARAMETERS:
     282             : !
     283             :     INTEGER,          INTENT(INOUT)           :: RC
     284             : !
     285             : ! !REVISION HISTORY:
     286             : !  03 Oct 2013 - C. Keller - Initial version
     287             : !  See https://github.com/geoschem/hemco for complete history
     288             : !EOP
     289             : !------------------------------------------------------------------------------
     290             : !BOC
     291             : !
     292             : ! !INTERNAL VARIABLES:
     293             : !
     294             :     INTEGER               :: IDX
     295             :     CHARACTER(LEN=255)    :: MSG, LOC
     296             :     CHARACTER(LEN=OPTLEN) :: TmpStr, OptName, OptValue
     297             : 
     298             :     !======================================================================
     299             :     ! AddExtOpt begins here
     300             :     !======================================================================
     301           0 :     LOC = 'AddExtOpt (HCO_EXTLIST_MOD.F90)'
     302             : 
     303             :     ! Parse option name and option value. These must be separated by colon.
     304           0 :     IDX = INDEX( TRIM(Opt), ':' )
     305             : 
     306             :     ! Error check
     307           0 :     IF ( IDX <= 0 ) THEN
     308             :        MSG = 'Cannot extract option name/value pair - these must be ' // &
     309           0 :              'separated by a colon (:) character: ' // TRIM(Opt)
     310           0 :        CALL HCO_ERROR(MSG,RC,THISLOC='AddExtOpt (hco_extlist_mod)')
     311           0 :        RETURN
     312             :     ENDIF
     313             : 
     314             :     ! Now split option name / value pair
     315           0 :     OptName  = Opt(1:(IDX-1))
     316           0 :     OptValue = Opt((IDX+1):LEN(Opt))
     317             : 
     318             :     ! Also check for '-->' option indicatior. This string must be stripped
     319             :     ! off the option name!
     320           0 :     IDX = INDEX( TRIM(OptName), '-->' )
     321           0 :     IF ( IDX > 0 ) THEN
     322           0 :        TmpStr  = OptName( (IDX+3) : LEN(TRIM(OptName)) )
     323           0 :        OptName = TmpStr
     324             :     ENDIF
     325             : 
     326             :     ! Pass to options
     327             :     CALL HCO_AddOpt( HcoConfig, OptName, OptValue, ExtNr, RC, &
     328           0 :                      IgnoreIfExist=IgnoreIfExist )
     329           0 :     IF ( RC /= HCO_SUCCESS ) THEN
     330           0 :         CALL HCO_ERROR( 'ERROR 0', RC, THISLOC=LOC )
     331           0 :         RETURN
     332             :     ENDIF
     333             : 
     334             :     ! Cleanup and leave
     335           0 :     RC = HCO_SUCCESS
     336             : 
     337             :   END SUBROUTINE AddExtOpt
     338             : !EOC
     339             : !------------------------------------------------------------------------------
     340             : !                   Harmonized Emissions Component (HEMCO)                    !
     341             : !------------------------------------------------------------------------------
     342             : !BOP
     343             : !
     344             : ! !IROUTINE: GetExtOpt
     345             : !
     346             : ! !DESCRIPTION: Function GetExtOpt returns the option value for a given
     347             : ! extension and option name. The type of the return value depends on the
     348             : ! provided argument (real, boolean, character). The optional output
     349             : ! argument FOUND returns TRUE if the given option name was found, and
     350             : ! FALSE otherwise. If the FOUND argument is provided, no error is
     351             : ! returned if the option name is not found!
     352             : ! If the ExtNr is set to -999, the settings of all extensions are searched.
     353             : !\\
     354             : !\\
     355             : ! !INTERFACE:
     356             : !
     357           0 :   SUBROUTINE GetExtOpt ( HcoConfig,  ExtNr,      OptName,   OptValHp, &
     358             :                          OptValSp,   OptValDp,   OptValInt,           &
     359             :                          OptValBool, OptValChar, Found,     RC )
     360             : !
     361             : ! !USES:
     362             : !
     363             :   USE HCO_CHARPAK_MOD,       ONLY : STRSPLIT, TRANLC
     364             : !
     365             : ! !INPUT PARAMETERS:
     366             : !
     367             :     TYPE(ConfigObj),  POINTER                  :: HcoConfig
     368             :     INTEGER,          INTENT(IN   )            :: ExtNr
     369             :     CHARACTER(LEN=*), INTENT(IN   )            :: OptName
     370             : !
     371             : ! !OUTPUT PARAMETERS:
     372             : !
     373             :     REAL(hp),         INTENT(  OUT), OPTIONAL  :: OptValHp
     374             :     REAL(sp),         INTENT(  OUT), OPTIONAL  :: OptValSp
     375             :     REAL(dp),         INTENT(  OUT), OPTIONAL  :: OptValDp
     376             :     INTEGER,          INTENT(  OUT), OPTIONAL  :: OptValInt
     377             :     LOGICAL,          INTENT(  OUT), OPTIONAL  :: OptValBool
     378             :     CHARACTER(LEN=*), INTENT(  OUT), OPTIONAL  :: OptValChar
     379             :     LOGICAL,          INTENT(  OUT), OPTIONAL  :: Found
     380             : !
     381             : ! !INPUT/OUTPUT PARAMETERS:
     382             : !
     383             :     INTEGER,          INTENT(INOUT)            :: RC
     384             : !
     385             : ! !REVISION HISTORY:
     386             : !  03 Oct 2013 - C. Keller   - Initial version
     387             : !  See https://github.com/geoschem/hemco for complete history
     388             : !EOP
     389             : !------------------------------------------------------------------------------
     390             : !BOC
     391             : !
     392             : ! !INTERNAL VARIABLES:
     393             : !
     394             :     CHARACTER(LEN=OPTLEN) :: OptValue
     395             :     LOGICAL               :: OptFound
     396             :     CHARACTER(LEN=255)    :: MSG, LOC
     397             : 
     398             :     !======================================================================
     399             :     ! GetExtOpt begins here
     400             :     !======================================================================
     401             : 
     402             :     ! Init
     403           0 :     LOC = 'GetExtOpt (hco_extlist_mod)'
     404             : 
     405             :     ! Get option
     406           0 :     OptValue = HCO_GetOpt( HcoConfig%ExtList, OptName, ExtNr=ExtNr )
     407           0 :     IF ( TRIM(OptValue) == TRIM(EMPTYOPT) ) THEN
     408             :        OptFound = .FALSE.
     409             :     ELSE
     410           0 :        OptFound = .TRUE.
     411             :     ENDIF
     412             : 
     413             :     ! Check if option was found. Handling depends on presence
     414             :     ! of argument 'FOUND'. If FOUND is not present and option
     415             :     ! was not found, return with error.
     416           0 :     IF ( PRESENT(FOUND) ) THEN
     417           0 :        FOUND = OptFound
     418           0 :     ELSEIF ( .NOT. OptFound ) THEN
     419           0 :        WRITE(MSG,*) '(A) Cannot find option ', TRIM(OptName),  &
     420           0 :        ' in extension ', ExtNr
     421           0 :        CALL HCO_ERROR(MSG,RC,THISLOC=LOC )
     422           0 :        RETURN
     423             :     ENDIF
     424             : 
     425             :     ! Pass option value to output
     426           0 :     IF ( PRESENT(OptValSp) ) THEN
     427           0 :        IF ( OptFound ) THEN
     428           0 :           READ( OptValue, * ) OptValSp
     429             :        ELSE
     430           0 :           OptValSp = -999.0_sp
     431             :        ENDIF
     432           0 :     ELSEIF ( PRESENT(OptValDp) ) THEN
     433           0 :        IF ( OptFound ) THEN
     434           0 :           READ( OptValue, * ) OptValDp
     435             :        ELSE
     436           0 :           OptValDp = -999.0_dp
     437             :        ENDIF
     438           0 :     ELSEIF ( PRESENT(OptValHp) ) THEN
     439           0 :        IF ( OptFound ) THEN
     440           0 :           READ( OptValue, * ) OptValHp
     441             :        ELSE
     442           0 :           OptValHp = -999.0_hp
     443             :        ENDIF
     444           0 :     ELSEIF ( PRESENT(OptValInt) ) THEN
     445           0 :        IF ( OptFound ) THEN
     446           0 :           READ( OptValue, * ) OptValInt
     447             :        ELSE
     448           0 :           OptValInt = -999
     449             :        ENDIF
     450           0 :     ELSEIF ( PRESENT(OptValBool) ) THEN
     451           0 :        IF ( OptFound ) THEN
     452           0 :           CALL TRANLC( OptValue )
     453           0 :           IF ( INDEX( TRIM(OptValue), 'true' ) > 0 ) THEN
     454           0 :              OptValBool = .TRUE.
     455             :           ELSE
     456           0 :              OptValBool = .FALSE.
     457             :           ENDIF
     458             :        ELSE
     459           0 :           OptValBool = .FALSE.
     460             :        ENDIF
     461           0 :     ELSEIF ( PRESENT(OptValChar) ) THEN
     462           0 :        IF ( OptFound ) THEN
     463           0 :           OptValChar = ADJUSTL( TRIM(OptValue) )
     464             :        ELSE
     465           0 :           OptValChar = ''
     466             :        ENDIF
     467             :     ENDIF
     468             : 
     469             :     ! Cleanup and leave
     470           0 :     RC = HCO_SUCCESS
     471             : 
     472           0 :   END SUBROUTINE GetExtOpt
     473             : !EOC
     474             : !------------------------------------------------------------------------------
     475             : !                   Harmonized Emissions Component (HEMCO)                    !
     476             : !------------------------------------------------------------------------------
     477             : !BOP
     478             : !
     479             : ! !IROUTINE: GetExtNr
     480             : !
     481             : ! !DESCRIPTION: Function GetExtNr returns the extension number of
     482             : ! extension ExtName. Returns -999 if no extension with the given name is
     483             : ! found.
     484             : !\\
     485             : !\\
     486             : ! !INTERFACE:
     487             : !
     488           0 :   FUNCTION GetExtNr( ExtList, ExtName ) Result ( ExtNr )
     489             : !
     490             : ! !USES:
     491             : !
     492             :     USE HCO_CHARPAK_MOD,  ONLY : TRANLC
     493             : !
     494             : ! !INPUT PARAMETERS:
     495             : !
     496             :     TYPE(Ext),        POINTER       :: ExtList
     497             :     CHARACTER(LEN=*), INTENT(IN   ) :: ExtName
     498             : !
     499             : ! !RETURN VALUE:
     500             : !
     501             :     INTEGER                         :: ExtNr
     502             : !
     503             : ! !REVISION HISTORY:
     504             : !  03 Oct 2013 - C. Keller - Initial version
     505             : !  See https://github.com/geoschem/hemco for complete history
     506             : !EOP
     507             : !------------------------------------------------------------------------------
     508             : !BOC
     509             : !
     510             : ! !INTERNAL VARIABLES:
     511             : !
     512             :     TYPE(Ext), POINTER  :: ThisExt
     513             :     CHARACTER(LEN=255)  :: LCname
     514             : 
     515             :     !======================================================================
     516             :     ! GetExtNr begins here
     517             :     !======================================================================
     518             : 
     519             :     ! Init
     520           0 :     ThisExt => NULL()
     521             : 
     522             :     ! Pass name to module
     523           0 :     LCname = TRIM(ExtName)
     524             : 
     525             :     ! Set to lower case
     526           0 :     CALL TRANLC( LCname )
     527             : 
     528             :     ! Init output
     529           0 :     ExtNr = -999
     530             : 
     531             :     ! Point to header of extensions list
     532           0 :     ThisExt => ExtList
     533             : 
     534             :     ! Loop over all used extensions and check if any of them matches
     535             :     ! ExtName.
     536           0 :     DO WHILE ( ASSOCIATED ( ThisExt ) )
     537             : 
     538             :        ! Compare extension names
     539           0 :        IF ( TRIM(ThisExt%ExtName) == TRIM(LCname) ) THEN
     540           0 :           ExtNr = ThisExt%ExtNr
     541           0 :           EXIT
     542             :        ENDIF
     543             : 
     544             :        ! Advance to next extension
     545           0 :        ThisExt => ThisExt%NextExt
     546             :     ENDDO
     547             : 
     548             :     ! Cleanup
     549           0 :     ThisExt => NULL()
     550             : 
     551           0 :   END FUNCTION GetExtNr
     552             : !EOC
     553             : !------------------------------------------------------------------------------
     554             : !                   Harmonized Emissions Component (HEMCO)                    !
     555             : !------------------------------------------------------------------------------
     556             : !BOP
     557             : !
     558             : ! !ROUTINE: GetExtSpcStr
     559             : !
     560             : ! !DESCRIPTION: Subroutine GetExtSpcStr returns the HEMCO species names
     561             : ! string of all species assigned to the given extension (identified by its
     562             : ! extension number).
     563             : !\\
     564             : !\\
     565             : ! !INTERFACE:
     566             : !
     567           0 :   SUBROUTINE GetExtSpcStr( HcoConfig, ExtNr, SpcStr, RC )
     568             : !
     569             : ! !INPUT PARAMETERS:
     570             : !
     571             :     TYPE(ConfigObj),  POINTER       :: HcoConfig
     572             :     INTEGER,          INTENT(IN   ) :: ExtNr    ! Extension Nr.
     573             : !
     574             : ! !OUTPUT PARAMETERS:
     575             : !
     576             :     CHARACTER(LEN=*), INTENT(  OUT) :: SpcStr   ! Species string
     577             : !
     578             : ! !INPUT/OUTPUT PARAMETERS:
     579             : !
     580             :     INTEGER,          INTENT(INOUT) :: RC       ! Success or failure?
     581             : !
     582             : ! !REVISION HISTORY:
     583             : !  10 Jan 2014 - C. Keller: Initialization (update)
     584             : !  See https://github.com/geoschem/hemco for complete history
     585             : !EOP
     586             : !------------------------------------------------------------------------------
     587             : !BOC
     588             : !
     589             : ! !LOCAL ARGUMENTS:
     590             : !
     591             :     CHARACTER(LEN=255)        :: MSG, LOC
     592             :     TYPE(Ext), POINTER        :: ThisExt
     593             : 
     594             :     !======================================================================
     595             :     ! GetExtSpcStr begins here
     596             :     !======================================================================
     597             : 
     598             :     ! Enter
     599           0 :     LOC = 'GetExtSpcStr (hco_extlist_mod.F90)'
     600           0 :     RC  = HCO_SUCCESS
     601           0 :     ThisExt => NULL()
     602             : 
     603             :     ! Find extension of interest
     604           0 :     ThisExt => HcoConfig%ExtList
     605           0 :     DO WHILE ( ASSOCIATED ( ThisExt ) )
     606           0 :        IF ( ThisExt%ExtNr == ExtNr ) EXIT
     607           0 :        ThisExt => ThisExt%NextExt
     608             :     ENDDO
     609             : 
     610           0 :     IF ( .NOT. ASSOCIATED( ThisExt ) ) THEN
     611           0 :        WRITE(MSG,*) 'Cannot find extension Nr. ', ExtNr
     612           0 :        CALL HCO_ERROR(  MSG, RC, THISLOC=LOC )
     613           0 :        RETURN
     614             :     ENDIF
     615             : 
     616             :     ! Get species string
     617           0 :     SpcStr  = TRIM(ThisExt%Spcs)
     618           0 :     ThisExt => NULL()
     619             : 
     620             :     ! Return w/ success
     621           0 :     RC = HCO_SUCCESS
     622             : 
     623           0 :     END SUBROUTINE GetExtSpcStr
     624             : !EOC
     625             : !------------------------------------------------------------------------------
     626             : !                   Harmonized Emissions Component (HEMCO)                    !
     627             : !------------------------------------------------------------------------------
     628             : !BOP
     629             : !
     630             : ! !ROUTINE: GetExtSpcVal_Sp
     631             : !
     632             : ! !DESCRIPTION: Subroutine GetExtSpcVal\_Sp returns single precision values
     633             : ! associated with the species for a given extension. Specifically, this routine
     634             : ! searches for extension setting '<Prefix>\_SpecName' for every species passed
     635             : ! through input argument SpcNames and writes those into output argument SpcScal.
     636             : ! The default value DefValue is assigned to all elements of SpcScal with no
     637             : ! corresponding extension setting.
     638             : !\\
     639             : !\\
     640             : ! !INTERFACE:
     641             : !
     642           0 :   SUBROUTINE GetExtSpcVal_sp( HcoConfig, extNr,    NSPC,    spcNames,        &
     643             :                               prefix,    defValue, spcScal, RC              )
     644             : !
     645             : ! !INPUT PARAMETERS:
     646             : !
     647             :     TYPE(ConfigObj),       POINTER       :: HcoConfig      ! HEMCO config obj
     648             :     INTEGER,               INTENT(IN)    :: extNr          ! Extension Nr.
     649             :     INTEGER,               INTENT(IN)    :: NSPC           ! # of species
     650             :     CHARACTER(LEN=*),      INTENT(IN)    :: spcNames(NSPC) ! Species string
     651             :     CHARACTER(LEN=*),      INTENT(IN)    :: prefix         ! Search prefix
     652             :     REAL(sp),              INTENT(IN)    :: defValue       ! Default value
     653             : !
     654             : ! !INPUT/OUTPUT PARAMETERS:
     655             : !
     656             :     REAL(sp), ALLOCATABLE, INTENT(INOUT) :: spcScal(:)     ! Species scalefacs
     657             : !
     658             : ! !OUTPUT PARAMETERS:
     659             : !
     660             :     INTEGER,               INTENT(OUT)   :: RC             ! Success or failure?
     661             : !
     662             : ! !REVISION HISTORY:
     663             : !  10 Jun 2015 - C. Keller - Initial version
     664             : !  See https://github.com/geoschem/hemco for complete history
     665             : !EOP
     666             : !------------------------------------------------------------------------------
     667             : !BOC
     668             : 
     669             :     ! Scalars
     670             :     LOGICAL            :: found
     671             :     INTEGER            :: I
     672             :     REAL(sp)           :: scaleFac
     673             : 
     674             :     ! Strings
     675             :     CHARACTER(LEN= 61) :: name
     676             :     CHARACTER(LEN=255) :: errMsg
     677             :     CHARACTER(LEN=255) :: thisLoc
     678             : 
     679             :     !========================================================================
     680             :     ! GetExtSpcVal_sp begins here
     681             :     !========================================================================
     682             : 
     683             :     ! Initialize
     684           0 :     RC      = HCO_SUCCESS
     685           0 :     errMsg  = ''
     686             :     thisLoc = &
     687           0 :      ' -> at GetExtSpcVal_sp (in module src/Core/hco_extlist_mod.F90)'
     688             : 
     689             :     !========================================================================
     690             :     ! Make sure output array SpcScal is properly allocated
     691             :     !========================================================================
     692           0 :     IF ( ALLOCATED( spcScal ) ) DEALLOCATE( spcScal )
     693           0 :     ALLOCATE( SpcScal(NSPC), STAT=RC )
     694           0 :     IF ( RC /= HCO_SUCCESS ) THEN
     695           0 :        errMsg = 'Could not allocate SpcScal array!'
     696           0 :        CALL HCO_ERROR( errMsg, RC, thisLoc )
     697           0 :        RETURN
     698             :     ENDIF
     699             : 
     700             :     ! Initialize to default values
     701           0 :     spcScal = defValue
     702             : 
     703             :     !========================================================================
     704             :     ! Look for species scale factors; save to spcScal array
     705             :     !========================================================================
     706           0 :     DO I = 1, NSPC
     707             : 
     708             :        ! Species name
     709           0 :        name = TRIM( prefix ) // '_' // TRIM( spcNames(I) )
     710             : 
     711             :        ! Look for the scale factor
     712             :        CALL GetExtOpt(                                                       &
     713             :             HcoConfig = HcoConfig,                                           &
     714             :             extNr     = extNr,                                               &
     715             :             optName   = name,                                                &
     716             :             optValSp  = scaleFac,                                            &
     717             :             found     = found,                                               &
     718           0 :             RC        = RC                                                  )
     719             : 
     720             :        ! Trap errors
     721           0 :        IF ( RC /= HCO_SUCCESS ) THEN
     722           0 :           errMsg = 'Error encountered in "GetExtOpt" routine!'
     723           0 :           CALL HCO_ERROR( errMsg, RC, thisLoc )
     724           0 :           RETURN
     725             :        ENDIF
     726             : 
     727             :        ! If scale factor was found, assign it to SpcScal
     728           0 :        IF ( found ) spcScal(I) = scaleFac
     729             :     ENDDO
     730             : 
     731             :   END SUBROUTINE GetExtSpcVal_sp
     732             : !EOC
     733             : !------------------------------------------------------------------------------
     734             : !                   Harmonized Emissions Component (HEMCO)                    !
     735             : !------------------------------------------------------------------------------
     736             : !BOP
     737             : !
     738             : ! !ROUTINE: GetExtSpcVal_Int
     739             : !
     740             : ! !DESCRIPTION: Subroutine GetExtSpcVal\_Int returns integer values
     741             : ! associated with the species for a given extension. Specifically, this routine
     742             : ! searches for extension setting '<Prefix>\_SpecName' for every species passed
     743             : ! through input argument SpcNames and writes those into output argument SpcScal.
     744             : ! The default value DefValue is assigned to all elements of SpcScal with no
     745             : ! corresponding extension setting.
     746             : !\\
     747             : !\\
     748             : ! !INTERFACE:
     749             : !
     750           0 :   SUBROUTINE GetExtSpcVal_int( HcoConfig, extNr,    NSPC,    spcNames,       &
     751             :                                prefix,    defValue, spcScal, RC             )
     752             : !
     753             : ! !INPUT PARAMETERS:
     754             : !
     755             :     TYPE(ConfigObj),       POINTER       :: HcoConfig
     756             :     INTEGER,               INTENT(IN)    :: extNr          ! Extension Nr.
     757             :     INTEGER,               INTENT(IN)    :: NSPC           ! # of species
     758             :     CHARACTER(LEN=*),      INTENT(IN)    :: spcNames(NSPC) ! Species string
     759             :     CHARACTER(LEN=*),      INTENT(IN)    :: prefix         ! search prefix
     760             :     INTEGER,               INTENT(IN)    :: defValue       ! default value
     761             : !
     762             : ! !INPUT/OUTPUT PARAMETERS:
     763             : !
     764             :     INTEGER,  ALLOCATABLE, INTENT(INOUT) :: spcScal(:)     ! Species scalefacs
     765             : !
     766             : ! !OUTPUT PARAMETERS::
     767             : !
     768             :     INTEGER,               INTENT(OUT)   :: RC             ! Success or failure?
     769             : !
     770             : ! !REVISION HISTORY:
     771             : !  10 Jun 2015 - C. Keller - Initial version
     772             : !  See https://github.com/geoschem/hemco for complete history
     773             : !EOP
     774             : !------------------------------------------------------------------------------
     775             : !BOC
     776             : 
     777             :     ! Scalars
     778             :     LOGICAL            :: found
     779             :     INTEGER            :: I
     780             :     INTEGER            :: scaleFac
     781             : 
     782             :     ! Strings
     783             :     CHARACTER(LEN= 61) :: name
     784             :     CHARACTER(LEN=255) :: errMsg
     785             :     CHARACTER(LEN=255) :: thisLoc
     786             : 
     787             :     !========================================================================
     788             :     ! GetExtSpcVal_int begins here
     789             :     !========================================================================
     790             : 
     791             :     ! Initialize
     792           0 :     RC      = HCO_SUCCESS
     793           0 :     errMsg  = ''
     794             :     thisLoc = &
     795           0 :      ' -> at GetExtSpcVal_Int (in module src/Core/hco_extlist_mod.F90)'
     796             : 
     797             :     !========================================================================
     798             :     ! Make sure output array SpcScal is properly allocated
     799             :     !========================================================================
     800           0 :     IF ( ALLOCATED( spcScal ) ) DEALLOCATE( spcScal )
     801           0 :     ALLOCATE( SpcScal(NSPC), STAT=RC )
     802           0 :     IF ( RC /= HCO_SUCCESS ) THEN
     803           0 :        errMsg = 'Could not allocate SpcScal array!'
     804           0 :        CALL HCO_ERROR( errMsg, RC, thisLoc )
     805           0 :        RETURN
     806             :     ENDIF
     807             : 
     808             :     ! Initialize to default values
     809           0 :     spcScal = defValue
     810             : 
     811             :     !========================================================================
     812             :     ! Look for species scale factors; save to spcScal array
     813             :     !========================================================================
     814           0 :     DO I = 1, NSPC
     815             : 
     816             :        ! Species name
     817           0 :        name = TRIM( prefix ) // '_' // TRIM( spcNames(I) )
     818             : 
     819             :        ! Look for the scale factor
     820             :        CALL GetExtOpt(                                                       &
     821             :             HcoConfig = HcoConfig,                                           &
     822             :             extNr     = extNr,                                               &
     823             :             optName   = name,                                                &
     824             :             optValInt = scaleFac,                                            &
     825             :             found     = found,                                               &
     826           0 :             RC        = RC                                                  )
     827             : 
     828             :        ! Trap errors
     829           0 :        IF ( RC /= HCO_SUCCESS ) THEN
     830           0 :           errMsg = 'Error encountered in "GetExtOpt" routine!'
     831           0 :           CALL HCO_ERROR( errMsg, RC, thisLoc )
     832           0 :           RETURN
     833             :        ENDIF
     834             : 
     835             :        ! If scale factor was found, assign it to SpcScal
     836           0 :        IF ( found ) spcScal(I) = scaleFac
     837             :     ENDDO
     838             : 
     839             :   END SUBROUTINE GetExtSpcVal_int
     840             : !EOC
     841             : !------------------------------------------------------------------------------
     842             : !                   Harmonized Emissions Component (HEMCO)                    !
     843             : !------------------------------------------------------------------------------
     844             : !BOP
     845             : !
     846             : ! !ROUTINE: GetExtSpcVal_char
     847             : !
     848             : ! !DESCRIPTION: Subroutine GetExtSpcVal\_char returns character values
     849             : ! associated with the species for a given extension. Specifically, this routine
     850             : ! searches for extension setting '<Prefix>\_SpecName' for every species passed
     851             : ! through input argument SpcNames and writes those into output argument SpcScal.
     852             : ! The default value DefValue is assigned to all elements of SpcScal with no
     853             : ! corresponding extension setting.
     854             : !\\
     855             : !\\
     856             : ! !INTERFACE:
     857             : !
     858           0 :   SUBROUTINE GetExtSpcVal_char( HcoConfig, extNr,    NSPC,    spcNames,      &
     859             :                                 prefix,    defValue, spcScal, RC            )
     860             : !
     861             : ! !INPUT PARAMETERS:
     862             : !
     863             :     TYPE(ConfigObj),   POINTER       :: HcoConfig      ! HEMCO config object
     864             :     INTEGER,           INTENT(IN)    :: extNr          ! Extension Nr.
     865             :     INTEGER,           INTENT(IN)    :: NSPC           ! # of species
     866             :     CHARACTER(LEN=*),  INTENT(IN)    :: spcNames(NSPC) ! Species string
     867             :     CHARACTER(LEN=*),  INTENT(IN)    :: prefix         ! search prefix
     868             :     CHARACTER(LEN=*),  INTENT(IN)    :: defValue       ! default value
     869             : !
     870             : ! !INPUT/OUTPUT PARAMETERS:
     871             : !
     872             :     CHARACTER(LEN=*), &
     873             :           ALLOCATABLE, INTENT(INOUT) :: SpcScal(:)     ! Species scale factors
     874             : !
     875             : ! !OUTPUT PARAMETERS:
     876             : !
     877             :     INTEGER,           INTENT(OUT)   :: RC             ! Success or failure?
     878             : !
     879             : ! !REVISION HISTORY:
     880             : !  10 Jun 2015 - C. Keller - Initial version
     881             : !  See https://github.com/geoschem/hemco for complete history
     882             : !EOP
     883             : !------------------------------------------------------------------------------
     884             : !BOC
     885             : 
     886             :     ! Scalars
     887             :     LOGICAL            :: found
     888             :     INTEGER            :: I
     889             : 
     890             :     ! Strings
     891             :     CHARACTER(LEN= 61) :: name
     892             :     CHARACTER(LEN=255) :: scaleFac
     893             :     CHARACTER(LEN=255) :: errMsg
     894             :     CHARACTER(LEN=255) :: thisLoc
     895             : 
     896             :     !========================================================================
     897             :     ! GetExtSpcVal_Char begins here
     898             :     !========================================================================
     899             : 
     900             :     ! Initialize
     901           0 :     RC      = HCO_SUCCESS
     902           0 :     errMsg  = ''
     903             :     thisLoc = &
     904           0 :      ' -> at GetExtSpcVal_Char (in module src/Core/hco_extlist_mod.F90)'
     905             : 
     906             :     !========================================================================
     907             :     ! Make sure output array SpcScal is properly allocated
     908             :     !========================================================================
     909           0 :     IF ( ALLOCATED( spcScal ) ) DEALLOCATE( spcScal )
     910           0 :     ALLOCATE( SpcScal(NSPC), STAT=RC )
     911           0 :     IF ( RC /= HCO_SUCCESS ) THEN
     912           0 :        errMsg = 'Could not allocate SpcScal array!'
     913           0 :        CALL HCO_ERROR( errMsg, RC, thisLoc )
     914           0 :        RETURN
     915             :     ENDIF
     916             : 
     917             :     ! Initialize to default values
     918           0 :     spcScal = defValue
     919             : 
     920             :     !========================================================================
     921             :     ! Look for species scale factors; save to spcScal array
     922             :     !========================================================================
     923           0 :     DO I = 1, NSPC
     924             : 
     925             :        ! Species name
     926           0 :        name = TRIM( prefix ) // '_' // TRIM( spcNames(I) )
     927             : 
     928             :        ! Look for the scale factor
     929             :        CALL GetExtOpt(                                                       &
     930             :             HcoConfig  = HcoConfig,                                          &
     931             :             extNr      = extNr,                                              &
     932             :             optName    = name,                                               &
     933             :             optValChar = scaleFac,                                           &
     934             :             found      = found,                                              &
     935           0 :             RC         = RC                                                 )
     936             : 
     937             :        ! Trap errors
     938           0 :        IF ( RC /= HCO_SUCCESS ) THEN
     939           0 :           errMsg = 'Error encountered in "GetExtOpt" routine!'
     940           0 :           CALL HCO_ERROR( errMsg, RC, thisLoc )
     941           0 :           RETURN
     942             :        ENDIF
     943             : 
     944             :        ! If scale factor was found, assign it to SpcScal
     945           0 :        IF ( found ) spcScal(I) = scaleFac
     946             :     ENDDO
     947             : 
     948           0 :   END SUBROUTINE GetExtSpcVal_char
     949             : !EOC
     950             : !------------------------------------------------------------------------------
     951             : !                   Harmonized Emissions Component (HEMCO)                    !
     952             : !------------------------------------------------------------------------------
     953             : !BOP
     954             : !
     955             : ! !IROUTINE: SetExtNr
     956             : !
     957             : ! !DESCRIPTION: Subroutine SetExtNr overwrites the extension number of a
     958             : ! given extension. The extension of interest is provided in argument
     959             : ! ExtName. If this argument is omitted, the extension numbers of all
     960             : ! extensions currently listed in ExtList will be set to the provided
     961             : ! number. This is useful to disable all extensions by setting the ExtNr
     962             : ! to a negative value.
     963             : !\\
     964             : !\\
     965             : ! !INTERFACE:
     966             : !
     967           0 :   SUBROUTINE SetExtNr( HcoConfig, ExtNr, ExtName, RC )
     968             : !
     969             : ! !USES:
     970             : !
     971             :     USE HCO_CHARPAK_MOD,  ONLY : TRANLC
     972             : !
     973             : ! !INPUT PARAMETERS:
     974             : !
     975             :     TYPE(ConfigObj),  POINTER                 :: HcoConfig
     976             :     INTEGER,          INTENT(IN   )           :: ExtNr
     977             :     CHARACTER(LEN=*), INTENT(IN   ), OPTIONAL :: ExtName
     978             : !
     979             : ! !INPUT/OUTPUT PARAMETER:
     980             : !
     981             :     INTEGER,          INTENT(INOUT)           :: RC
     982             : !
     983             : ! !REVISION HISTORY:
     984             : !  12 Jan 2015 - C. Keller - Initial version
     985             : !  See https://github.com/geoschem/hemco for complete history
     986             : !EOP
     987             : !------------------------------------------------------------------------------
     988             : !BOC
     989             : !
     990             : ! !INTERNAL VARIABLES:
     991             : !
     992             :     TYPE(Ext), POINTER  :: ThisExt
     993             :     CHARACTER(LEN=255)  :: LCname
     994             :     CHARACTER(LEN=255)  :: MSG
     995             :     LOGICAL             :: verb, overwrite
     996             : 
     997             :     !======================================================================
     998             :     ! SetExtNr begins here
     999             :     !======================================================================
    1000             : 
    1001             :     ! verbose?
    1002           0 :     verb = HCO_IsVerb( HcoConfig%Err )
    1003             : 
    1004             :     ! Pass name to module and set to lower case
    1005           0 :     IF ( PRESENT(ExtName) ) THEN
    1006           0 :        LCname = TRIM(ExtName)
    1007           0 :        CALL TRANLC( LCname )  ! lower case
    1008             :     ELSE
    1009           0 :        LCname = ''
    1010             :     ENDIF
    1011             : 
    1012             :     ! Point to header of extensions list
    1013           0 :     ThisExt => HcoConfig%ExtList
    1014             : 
    1015             :     ! Loop over all used extensions and check if any of them matches
    1016             :     ! ExtName.
    1017           0 :     DO WHILE ( ASSOCIATED ( ThisExt ) )
    1018             : 
    1019             :        ! Overwrite this ExtNr?
    1020           0 :        overwrite = .FALSE.
    1021             : 
    1022             :        ! If argument ExtName is given, only overwrite extension number
    1023             :        ! of that particular extension.
    1024           0 :        IF ( PRESENT(ExtName) ) THEN
    1025           0 :           IF ( TRIM(ThisExt%ExtName) == TRIM(LCname) ) overwrite = .TRUE.
    1026             : 
    1027             :        ! If argument is not given, overwrite all extensions except for
    1028             :        ! HEMCO core
    1029           0 :        ELSEIF ( ThisExt%ExtNr /= CoreNr ) THEN
    1030             :           overwrite = .TRUE.
    1031             :        ENDIF
    1032             : 
    1033             :        ! Overwrite extension number if needed
    1034             :        IF ( overwrite ) THEN
    1035           0 :           ThisExt%ExtNr = ExtNr
    1036           0 :           IF ( verb ) THEN
    1037           0 :              WRITE(MSG,*) 'Force ExtNr of extension ', TRIM(ThisExt%ExtName), &
    1038           0 :                           ' to ', ExtNr
    1039           0 :              CALL HCO_MSG(HcoConfig%Err,MSG)
    1040             :           ENDIF
    1041             :        ENDIF
    1042             : 
    1043             :        ! Advance to next extension
    1044           0 :        ThisExt => ThisExt%NextExt
    1045             :     ENDDO
    1046             : 
    1047             :     ! Cleanup
    1048           0 :     ThisExt => NULL()
    1049             : 
    1050             :     ! Return w/ success
    1051           0 :     RC = HCO_SUCCESS
    1052             : 
    1053           0 :   END SUBROUTINE SetExtNr
    1054             : !EOC
    1055             : !------------------------------------------------------------------------------
    1056             : !                   Harmonized Emissions Component (HEMCO)                    !
    1057             : !------------------------------------------------------------------------------
    1058             : !BOP
    1059             : !
    1060             : ! !IROUTINE: ExtNrInUse
    1061             : !
    1062             : ! !DESCRIPTION: Function ExtNrInUse checks if extension number ExtNr is
    1063             : ! in the list of used extensions or not.
    1064             : !\\
    1065             : !\\
    1066             : ! !INTERFACE:
    1067             : !
    1068           0 :   FUNCTION ExtNrInUse( ExtList, ExtNr ) Result ( InUse )
    1069             : !
    1070             : ! !INPUT PARAMETERS:
    1071             : !
    1072             :     TYPE(Ext), POINTER       :: ExtList
    1073             :     INTEGER,   INTENT(IN   ) :: ExtNr
    1074             : !
    1075             : ! !RETURN VALUE::
    1076             : !
    1077             :     LOGICAL                  :: InUse
    1078             : !
    1079             : ! !REVISION HISTORY:
    1080             : !  03 Oct 2013 - C. Keller - Initial version
    1081             : !  See https://github.com/geoschem/hemco for complete history
    1082             : !EOP
    1083             : !------------------------------------------------------------------------------
    1084             : !BOC
    1085             : !
    1086             : ! !INTERNAL VARIABLES:
    1087             : !
    1088             :     TYPE(Ext), POINTER  :: ThisExt
    1089             :     CHARACTER(LEN=255)  :: LCname
    1090             : 
    1091             :     !======================================================================
    1092             :     ! ExtNrInUse begins here
    1093             :     !======================================================================
    1094             : 
    1095             :     ! Use number -999 for wildcard values
    1096           0 :     IF ( ExtNr == -999 ) THEN
    1097           0 :        InUse = .TRUE.
    1098             :        RETURN
    1099             :     ENDIF
    1100             : 
    1101             :     ! Init output
    1102           0 :     InUse = .FALSE.
    1103             : 
    1104             :     ! Point to header of extensions list
    1105           0 :     ThisExt => ExtList
    1106             : 
    1107             :     ! Loop over all used extensions and check if any of them matches
    1108             :     ! ExtName.
    1109           0 :     DO WHILE ( ASSOCIATED ( ThisExt ) )
    1110             : 
    1111             :        ! Compare extension names
    1112           0 :        IF ( ThisExt%ExtNr == ExtNr ) THEN
    1113             :           InUse = .TRUE.
    1114             :           EXIT
    1115             :        ENDIF
    1116             : 
    1117             :        ! Advance to next extension
    1118           0 :        ThisExt => ThisExt%NextExt
    1119             :     ENDDO
    1120             : 
    1121             :     ! Cleanup
    1122           0 :     ThisExt => NULL()
    1123             : 
    1124             :   END FUNCTION ExtNrInUse
    1125             : !EOC
    1126             : !------------------------------------------------------------------------------
    1127             : !                   Harmonized Emissions Component (HEMCO)                    !
    1128             : !------------------------------------------------------------------------------
    1129             : !BOP
    1130             : !
    1131             : ! !IROUTINE: ExtFinal
    1132             : !
    1133             : ! !DESCRIPTION: Function ExtFinal finalizes the extensions list.
    1134             : !\\
    1135             : !\\
    1136             : ! !INTERFACE:
    1137             : !
    1138           0 :   SUBROUTINE ExtFinal( ExtList )
    1139             : !
    1140             : ! !INPUT/OUTPUT ARGUMENT:
    1141             : !
    1142             :     TYPE(Ext), POINTER       :: ExtList
    1143             : !
    1144             : ! !REVISION HISTORY:
    1145             : !  03 Oct 2013 - C. Keller - Initial version
    1146             : !  See https://github.com/geoschem/hemco for complete history
    1147             : !EOP
    1148             : !------------------------------------------------------------------------------
    1149             : !BOC
    1150             : !
    1151             : ! !INTERNAL VARIABLES:
    1152             : !
    1153             :     TYPE(Ext), POINTER  :: ThisExt
    1154             :     TYPE(Ext), POINTER  :: NextExt
    1155             : 
    1156             :     !======================================================================
    1157             :     ! ExtFinal begins here
    1158             :     !======================================================================
    1159             : 
    1160             :     ! Point to header of extensions list
    1161           0 :     ThisExt => ExtList
    1162           0 :     NextExt => NULL()
    1163             : 
    1164             :     ! Loop over all extensions and deallocate the types
    1165           0 :     DO WHILE ( ASSOCIATED ( ThisExt ) )
    1166             : 
    1167             :        ! First set pointer to next entry
    1168           0 :        NextExt => ThisExt%NextExt
    1169             : 
    1170             :        ! Now clean up this entry
    1171           0 :        ThisExt%NextExt => NULL()
    1172           0 :        CALL HCO_CleanupOpt( ThisExt%Opts )
    1173           0 :        DEALLOCATE ( ThisExt )
    1174             : 
    1175             :        ! Advance to next extension
    1176           0 :        ThisExt => NextExt
    1177             :     ENDDO
    1178             : 
    1179             :     ! Cleanup
    1180           0 :     ThisExt => NULL()
    1181           0 :     ExtList => NULL()
    1182             : 
    1183           0 :   END SUBROUTINE ExtFinal
    1184             : !EOC
    1185             : !------------------------------------------------------------------------------
    1186             : !                   Harmonized Emissions Component (HEMCO)                    !
    1187             : !------------------------------------------------------------------------------
    1188             : !BOP
    1189             : !
    1190             : ! !IROUTINE: HCO_AddOpt
    1191             : !
    1192             : ! !DESCRIPTION: Subroutine HCO\_AddOpt adds a option name/value pair to the
    1193             : ! list of options.
    1194             : !\\
    1195             : !\\
    1196             : ! !INTERFACE:
    1197             : !
    1198           0 :   SUBROUTINE HCO_AddOpt ( HcoConfig, OptName, OptValue, ExtNr, RC, &
    1199             :                           VERB,      IgnoreIfExist )
    1200             : !
    1201             : ! !INPUT PARAMETERS:
    1202             : !
    1203             :     TYPE(ConfigObj),  POINTER                 :: HcoConfig      ! HEMCO config obj
    1204             :     CHARACTER(LEN=*), INTENT(IN   )           :: OptName        ! OptName
    1205             :     CHARACTER(LEN=*), INTENT(IN   )           :: OptValue       ! OptValue
    1206             :     INTEGER,          INTENT(IN   )           :: ExtNr          ! Extension Nr.
    1207             :     LOGICAL,          INTENT(IN   ), OPTIONAL :: VERB           ! Verbose on
    1208             :     LOGICAL,          INTENT(IN   ), OPTIONAL :: IgnoreIfExist  ! Ignore if already exists
    1209             : !
    1210             : ! !OUTPUT PARAMETERS:
    1211             : !
    1212             :     INTEGER,          INTENT(INOUT)           :: RC             ! Return code
    1213             : !
    1214             : ! !REVISION HISTORY:
    1215             : !  18 Sep 2015 - C. Keller - Initial version
    1216             : !  See https://github.com/geoschem/hemco for complete history
    1217             : !EOP
    1218             : !------------------------------------------------------------------------------
    1219             : !BOC
    1220             : !
    1221             : ! !LOCAL VARIABLES:
    1222             : !
    1223             :     TYPE(Ext), POINTER      :: ThisExt
    1224             :     TYPE(Opt), POINTER      :: NewOpt
    1225             :     CHARACTER(LEN=OPTLEN)   :: DUM
    1226             :     LOGICAL                 :: Exists
    1227             :     LOGICAL                 :: VRB
    1228             :     LOGICAL                 :: Ignore
    1229             :     CHARACTER(LEN=255)      :: MSG
    1230             :     CHARACTER(LEN=255)      :: LOC = 'HCO_AddOpt (hco_extlist_mod.F90)'
    1231             : 
    1232             :     !=================================================================
    1233             :     ! HCO_AddOpt begins here!
    1234             :     !=================================================================
    1235             : 
    1236             :     ! Nullify
    1237           0 :     ThisExt => NULL()
    1238           0 :     NewOpt  => NULL()
    1239             : 
    1240             :     ! Init optional variables
    1241           0 :     VRB    = .TRUE.
    1242           0 :     Ignore = .FALSE.
    1243           0 :     IF ( PRESENT(VERB)          ) VRB    = VERB
    1244           0 :     IF ( PRESENT(IgnoreIfExist) ) Ignore = IgnoreIfExist
    1245             : 
    1246             :     ! Check if this option already exists
    1247           0 :     DUM = HCO_GetOpt( HcoConfig%ExtList, OptName, ExtNr=ExtNr )
    1248             : 
    1249             :     ! If option already exists...
    1250           0 :     IF ( TRIM(DUM) /= TRIM(EMPTYOPT) ) THEN
    1251             : 
    1252             :        ! Can leave here if we shall ignore the option if it already exists
    1253           0 :        IF ( Ignore ) THEN
    1254             : 
    1255             :           ! If option exists and is the same, nothing to do
    1256           0 :           IF ( TRIM(DUM) /= ADJUSTL(TRIM(OptValue)) ) THEN
    1257           0 :              WRITE(*,*) 'Option is already defined - use original value of ', &
    1258           0 :                         TRIM(DUM), ' and ignore the following value: ',       &
    1259           0 :                         TRIM(OptName), ': ', TRIM(OptValue)
    1260             :           ENDIF
    1261           0 :           RC = HCO_SUCCESS
    1262           0 :           RETURN
    1263             : 
    1264             :        ! If ignore flag is false:
    1265             :        ELSE
    1266             :           ! Error if values are not the same
    1267           0 :           IF ( TRIM(DUM) /= ADJUSTL(TRIM(OptValue)) ) THEN
    1268             :              MSG = 'Cannot add option pair: '//TRIM(OptName)//': '//TRIM(OptValue) &
    1269           0 :                 // ' - option already exists: '//TRIM(OptName)//': '//TRIM(DUM)
    1270           0 :              CALL HCO_ERROR (  MSG, RC, THISLOC=LOC )
    1271           0 :              RETURN
    1272             :           ! Return with no error if values are the same
    1273             :           ELSE
    1274           0 :              RC = HCO_SUCCESS
    1275           0 :              RETURN
    1276             :           ENDIF
    1277             :        ENDIF
    1278             :     ENDIF
    1279             : 
    1280             :     ! Find extension of interest
    1281           0 :     ThisExt => HcoConfig%ExtList
    1282           0 :     DO WHILE ( ASSOCIATED ( ThisExt ) )
    1283           0 :        IF ( ThisExt%ExtNr == ExtNr ) EXIT
    1284           0 :        ThisExt => ThisExt%NextExt
    1285             :     ENDDO
    1286             : 
    1287           0 :     IF ( .NOT. ASSOCIATED( ThisExt ) ) THEN
    1288           0 :        WRITE(MSG,*) 'Cannot add option to extension Nr. ', ExtNr
    1289           0 :        MSG = TRIM(MSG) // '. Make sure this extension is activated!'
    1290           0 :        CALL HCO_ERROR(MSG,RC,THISLOC='AddOpt (hco_extlist_mod)')
    1291           0 :        RETURN
    1292             :     ENDIF
    1293             : 
    1294             :     ! Create new option
    1295           0 :     ALLOCATE(NewOpt)
    1296           0 :     NewOpt%OptName  = ADJUSTL( TRIM(OptName ) )
    1297           0 :     NewOpt%OptValue = ADJUSTL( TRIM(OptValue) )
    1298             : 
    1299             :     ! Add to option linked list
    1300           0 :     IF ( ASSOCIATED(ThisExt%Opts) ) THEN
    1301           0 :        NewOpt%NextOpt => ThisExt%Opts
    1302             :     ELSE
    1303           0 :        NewOpt%NextOpt => NULL()
    1304             :     ENDIF
    1305           0 :     ThisExt%Opts => NewOpt
    1306             : 
    1307             :     ! Verbose
    1308           0 :     IF ( VRB .AND. HcoConfig%amIRoot .AND. HCO_IsVerb(HcoConfig%Err) ) THEN
    1309           0 :        MSG = 'Added the following option: ' // TRIM(OptName)//': '//TRIM(OptValue)
    1310           0 :        CALL HCO_MSG(HcoConfig%Err,MSG)
    1311             :     ENDIF
    1312             : 
    1313             :     ! Cleanup and return w/ success
    1314           0 :     ThisExt => NULL()
    1315           0 :     RC      =  HCO_SUCCESS
    1316             : 
    1317             :   END SUBROUTINE HCO_AddOpt
    1318             : !EOC
    1319             : !------------------------------------------------------------------------------
    1320             : !                   Harmonized Emissions Component (HEMCO)                    !
    1321             : !------------------------------------------------------------------------------
    1322             : !BOP
    1323             : !
    1324             : ! !IROUTINE: HCO_GetOpt
    1325             : !
    1326             : ! !DESCRIPTION: Subroutine HCO\_GetOpt returns a option value for the given
    1327             : ! option name.
    1328             : !\\
    1329             : !\\
    1330             : ! !INTERFACE:
    1331             : !
    1332           0 :   FUNCTION HCO_GetOpt ( ExtList, OptName, ExtNr ) RESULT ( OptValue )
    1333             : !
    1334             : ! !INPUT PARAMETERS:
    1335             : !
    1336             :     TYPE(Ext),        POINTER                 :: ExtList        ! Extension list
    1337             :     CHARACTER(LEN=*), INTENT(IN   )           :: OptName  ! OptName
    1338             :     INTEGER,          INTENT(IN   ), OPTIONAL :: ExtNr      ! Extension Nr.
    1339             : !
    1340             : ! !OUTPUT PARAMETERS:
    1341             : !
    1342             :     CHARACTER(LEN=OPTLEN)                     :: OptValue ! OptValue
    1343             : !
    1344             : ! !REVISION HISTORY:
    1345             : !  18 Sep 2015 - C. Keller - Initial version
    1346             : !  See https://github.com/geoschem/hemco for complete history
    1347             : !EOP
    1348             : !------------------------------------------------------------------------------
    1349             : !BOC
    1350             : !
    1351             : ! !LOCAL VARIABLES:
    1352             : !
    1353             :     INTEGER               :: ThisExtNr
    1354             :     LOGICAL               :: OptFound
    1355             :     TYPE(Opt), POINTER    :: ThisOpt
    1356             :     TYPE(Ext), POINTER    :: ThisExt
    1357             : 
    1358             :     !=================================================================
    1359             :     ! HCO_GetOpt begins here!
    1360             :     !=================================================================
    1361             : 
    1362             :     ! Init
    1363           0 :     OptValue = EMPTYOPT
    1364           0 :     OptFound = .FALSE.
    1365           0 :     ThisOpt  => NULL()
    1366           0 :     ThisExt  => NULL()
    1367             : 
    1368             :     ! Extension number to search for. If not explicitly set through the
    1369             :     ! input argument, set to -999 to search all extensions.
    1370           0 :     IF ( PRESENT(ExtNr) ) THEN
    1371           0 :        ThisExtNr = ExtNr
    1372             :     ELSE
    1373             :        ThisExtNr = -999
    1374             :     ENDIF
    1375             : 
    1376             :     ! Find extension of interest
    1377           0 :     ThisExt => ExtList
    1378           0 :     DO WHILE ( ASSOCIATED ( ThisExt ) )
    1379             : 
    1380             :        ! Check if this is the extension of interest. If extension number
    1381             :        ! is set to -999, scan through all extensions.
    1382           0 :        IF ( ThisExtNr /= -999 .AND. ThisExt%ExtNr /= ThisExtNr ) THEN
    1383           0 :           ThisExt => ThisExt%NextExt
    1384           0 :           CYCLE
    1385             :        ENDIF
    1386             : 
    1387             :        ! Walk through token list until we find the given value
    1388           0 :        ThisOpt => ThisExt%Opts
    1389           0 :        DO WHILE ( ASSOCIATED(ThisOpt) )
    1390             : 
    1391             :           ! Check if this is the token of interest
    1392           0 :           IF ( TRIM(ThisOpt%OptName) == ADJUSTL(TRIM(OptName)) ) THEN
    1393           0 :              OptValue = ADJUSTL( TRIM(ThisOpt%OptValue) )
    1394           0 :              OptFound = .TRUE.
    1395           0 :              EXIT
    1396             :           ENDIF
    1397             : 
    1398             :           ! Advance in list
    1399           0 :           ThisOpt => ThisOpt%NextOpt
    1400             :        END DO
    1401             : 
    1402             :        ! Advance to next extension
    1403           0 :        IF ( OptFound ) THEN
    1404             :           ThisExt => NULL()
    1405             :        ELSE
    1406           0 :           ThisExt => ThisExt%NextExt
    1407             :        ENDIF
    1408             :     ENDDO
    1409             : 
    1410             :     ! Free pointer
    1411           0 :     ThisOpt => NULL()
    1412           0 :     ThisExt => NULL()
    1413             : 
    1414           0 :   END FUNCTION HCO_GetOpt
    1415             : !EOC
    1416             : !------------------------------------------------------------------------------
    1417             : !                   Harmonized Emissions Component (HEMCO)                    !
    1418             : !------------------------------------------------------------------------------
    1419             : !BOP
    1420             : !
    1421             : ! !IROUTINE: HCO_ROOT
    1422             : !
    1423             : ! !DESCRIPTION: Function HCO\_ROOT returns the root character string. This is
    1424             : ! a wrapper routine equivalent to HCO\_GetOpt('ROOT'). Since the ROOT character
    1425             : ! is called very frequently, it is recommended to use this routine instead.
    1426             : !\\
    1427             : !\\
    1428             : ! !INTERFACE:
    1429             : !
    1430           0 :   FUNCTION HCO_ROOT ( HcoConfig ) RESULT ( OutRoot )
    1431             : !
    1432             : ! !INPUT PARAMETERS:
    1433             : !
    1434             : !
    1435             : ! !OUTPUT PARAMETERS:
    1436             : !
    1437             :     TYPE(ConfigObj), POINTER                  :: HcoConfig
    1438             :     CHARACTER(LEN=OPTLEN)                     :: OutRoot ! Root output
    1439             : !
    1440             : ! !REVISION HISTORY:
    1441             : !  18 Sep 2015 - C. Keller - Initial version
    1442             : !  See https://github.com/geoschem/hemco for complete history
    1443             : !EOP
    1444             : !------------------------------------------------------------------------------
    1445             : !BOC
    1446             : 
    1447           0 :     OutRoot = HcoConfig%ROOT
    1448             : 
    1449           0 :   END FUNCTION HCO_ROOT
    1450             : !EOC
    1451             : !------------------------------------------------------------------------------
    1452             : !                   Harmonized Emissions Component (HEMCO)                    !
    1453             : !------------------------------------------------------------------------------
    1454             : !BOP
    1455             : !
    1456             : ! !IROUTINE: HCO_CleanupOpt
    1457             : !
    1458             : ! !DESCRIPTION: Subroutine HCO\_CleanupOpt cleans up the given options linked
    1459             : !  list.
    1460             : !\\
    1461             : !\\
    1462             : ! !INTERFACE:
    1463             : !
    1464           0 :   SUBROUTINE HCO_CleanupOpt ( OptList )
    1465             : !
    1466             : ! !INPUT PARAMETERS:
    1467             : !
    1468             : !
    1469             : ! !OUTPUT PARAMETERS:
    1470             : !
    1471             :     TYPE(Opt), POINTER        :: OptList
    1472             : !
    1473             : ! !REVISION HISTORY:
    1474             : !  18 Sep 2015 - C. Keller - Initial version
    1475             : !  See https://github.com/geoschem/hemco for complete history
    1476             : !EOP
    1477             : !------------------------------------------------------------------------------
    1478             : !BOC
    1479             : !
    1480             : ! !LOCAL VARIABLES:
    1481             : !
    1482             :     TYPE(Opt), POINTER    :: ThisOpt
    1483             :     TYPE(Opt), POINTER    :: NextOpt
    1484             : 
    1485             :     !=================================================================
    1486             :     ! HCO_CleanupOpt begins here!
    1487             :     !=================================================================
    1488             : 
    1489             :     ! Walk through option list until we find the given value
    1490           0 :     NextOpt => NULL()
    1491           0 :     ThisOpt => OptList
    1492           0 :     DO WHILE ( ASSOCIATED(ThisOpt) )
    1493             : 
    1494             :        ! Archive next option in list
    1495           0 :        NextOpt => ThisOpt%NextOpt
    1496             : 
    1497             :        ! Free the memory allocated to ThisOpt (this avoids memory leaks)
    1498           0 :        ThisOpt%NextOpt => NULL()
    1499           0 :        DEALLOCATE( ThisOpt )
    1500             : 
    1501             :        ! Go to next option in list (previously archived)
    1502           0 :        ThisOpt => NextOpt
    1503             :     END DO
    1504             : 
    1505             :     ! Free pointer
    1506           0 :     ThisOpt => NULL()
    1507           0 :     NextOpt => NULL()
    1508             : 
    1509           0 :   END SUBROUTINE HCO_CleanupOpt
    1510             : !EOC
    1511             : !------------------------------------------------------------------------------
    1512             : !                   Harmonized Emissions Component (HEMCO)                    !
    1513             : !------------------------------------------------------------------------------
    1514             : !BOP
    1515             : !
    1516             : ! !IROUTINE: HCO_SetDefaultToken
    1517             : !
    1518             : ! !DESCRIPTION: Subroutine HCO\_SetDefaultToken is a wrapper routine to
    1519             : ! initialize the default set of HEMCO tokens. These can be obtained at any
    1520             : ! place in the HEMCO code via subroutine HCO\_GetOpt, e.g. HCO\_GetOpt('RES')
    1521             : ! will return the 'RES' token.
    1522             : !\\
    1523             : !\\
    1524             : ! !INTERFACE:
    1525             : !
    1526           0 :   SUBROUTINE HCO_SetDefaultToken( CF, RC )
    1527             : !
    1528             : ! !USES:
    1529             : !
    1530             : !
    1531             : ! !INPUT PARAMETERS:
    1532             : !
    1533             :     TYPE(ConfigObj),  POINTER                 :: CF         ! Config object
    1534             : !
    1535             : ! !OUTPUT PARAMETERS:
    1536             : !
    1537             :     INTEGER,          INTENT(INOUT)           :: RC         ! Return code
    1538             : !
    1539             : ! !REVISION HISTORY:
    1540             : !  18 Sep 2015 - C. Keller - Initial version
    1541             : !  See https://github.com/geoschem/hemco for complete history
    1542             : !EOP
    1543             : !------------------------------------------------------------------------------
    1544             : !BOC
    1545             : !
    1546             : ! !LOCAL VARIABLES:
    1547             : !
    1548             :     CHARACTER(LEN=OPTLEN)     :: DUM
    1549             :     CHARACTER(LEN=255)        :: LOC
    1550             :     LOGICAL                   :: FOUND
    1551             : 
    1552             :     !=================================================================
    1553             :     ! HCO_SetDefaultToken begins here!
    1554             :     !=================================================================
    1555           0 :     LOC = 'HCO_SetDefaultToken (HCO_EXTLIST_MOD)'
    1556             : 
    1557           0 :     IF ( Trim(CF%MetField) == 'GEOSFP' ) THEN
    1558           0 :        DEF_MET_UC = 'GEOSFP'
    1559           0 :        DEF_MET_LC = 'geosfp'
    1560           0 :        DEF_CN_YR  = '2011'  ! Constant met fld year
    1561           0 :        DEF_NC_VER = 'nc'    ! NetCDF extension
    1562           0 :     ELSE IF ( TRIM(CF%MetField) == 'MERRA2' ) THEN
    1563           0 :        DEF_MET_UC = 'MERRA2'
    1564           0 :        DEF_MET_LC = 'merra2'
    1565           0 :        DEF_CN_YR  = '2015'  ! Constant met fld year
    1566           0 :        DEF_NC_VER = 'nc4'   ! NetCDF extension
    1567           0 :     ELSE IF ( TRIM(CF%MetField) == 'GEOSIT' ) THEN
    1568           0 :        DEF_MET_UC = 'GEOSIT'
    1569           0 :        DEF_MET_LC = 'geosit'
    1570           0 :        DEF_CN_YR  = '1998' ! Constant met fld year
    1571           0 :        DEF_NC_VER = 'nc'   ! NetCDF extension
    1572             :     ENDIF
    1573             : 
    1574           0 :     IF ( TRIM(CF%GridRes) == '4.0x5.0' ) THEN
    1575           0 :        DEF_RES = '4x5'
    1576           0 :     ELSE IF ( TRIM(CF%GridRes) == '2.0x2.5' ) THEN
    1577           0 :        DEF_RES = '2x25'
    1578           0 :     ELSE IF ( TRIM(CF%GridRes) == '0.5x0.625' ) THEN
    1579           0 :        DEF_RES = '05x0625'
    1580           0 :     ELSE IF ( TRIM(CF%GridRes) == '0.25x0.3125' ) THEN
    1581           0 :        DEF_RES = '025x03125'
    1582             :     ENDIF
    1583             : 
    1584             :     ! Wildcard character
    1585           0 :     CALL GetExtOpt( CF, CoreNr, 'Wildcard', OptValChar=DUM, Found=FOUND, RC=RC )
    1586           0 :     IF ( RC /= HCO_SUCCESS ) THEN
    1587           0 :         CALL HCO_ERROR( 'ERROR 4', RC, THISLOC=LOC )
    1588           0 :         RETURN
    1589             :     ENDIF
    1590           0 :     IF ( .NOT. FOUND) DUM = DEF_WILDCARD
    1591           0 :     CALL HCO_AddOpt( CF, 'Wildcard', DUM, CoreNr, RC, VERB=.FALSE. )
    1592             : 
    1593             :     ! Separator
    1594           0 :     CALL GetExtOpt( CF, CoreNr, 'Separator', OptValChar=DUM, Found=FOUND, RC=RC )
    1595           0 :     IF ( RC /= HCO_SUCCESS ) THEN
    1596           0 :         CALL HCO_ERROR( 'ERROR 5', RC, THISLOC=LOC )
    1597           0 :         RETURN
    1598             :     ENDIF
    1599           0 :     IF ( .NOT. FOUND) DUM = DEF_SEPARATOR
    1600           0 :     CALL HCO_AddOpt( CF, 'Separator', DUM, CoreNr, RC, VERB=.FALSE. )
    1601             : 
    1602             :     ! Colon
    1603           0 :     CALL GetExtOpt( CF, CoreNr, 'Colon', OptValChar=DUM, Found=FOUND, RC=RC )
    1604           0 :     IF ( RC /= HCO_SUCCESS ) THEN
    1605           0 :         CALL HCO_ERROR( 'ERROR 6', RC, THISLOC=LOC )
    1606           0 :         RETURN
    1607             :     ENDIF
    1608           0 :     IF ( .NOT. FOUND) DUM = DEF_COLON
    1609           0 :     CALL HCO_AddOpt( CF, 'Colon', DUM, CoreNr, RC, VERB=.FALSE. )
    1610             : 
    1611             :     ! Root directory
    1612           0 :     CALL GetExtOpt( CF, CoreNr, 'ROOT', OptValChar=DUM, Found=FOUND, RC=RC )
    1613           0 :     IF ( RC /= HCO_SUCCESS ) THEN
    1614           0 :         CALL HCO_ERROR( 'ERROR 7', RC, THISLOC=LOC )
    1615           0 :         RETURN
    1616             :     ENDIF
    1617           0 :     IF ( .NOT. FOUND) DUM = DEF_ROOT
    1618           0 :     CALL HCO_AddOpt( CF, 'ROOT', DUM, CoreNr, RC, VERB=.FALSE. )
    1619             : 
    1620             :     ! Also save in local variable (for fast access via HCO_ROOT)
    1621           0 :     CF%ROOT = ADJUSTL( TRIM(DUM) )
    1622             : 
    1623             :     ! Meteorology token (uppercase)
    1624           0 :     CALL GetExtOpt( CF, CoreNr, 'MET', OptValChar=DUM, Found=FOUND, RC=RC )
    1625           0 :     IF ( RC /= HCO_SUCCESS ) THEN
    1626           0 :         CALL HCO_ERROR( 'ERROR 8', RC, THISLOC=LOC )
    1627           0 :         RETURN
    1628             :     ENDIF
    1629           0 :     IF ( .NOT. FOUND) DUM = DEF_MET_UC
    1630           0 :     CALL HCO_AddOpt( CF, 'MET', DUM, CoreNr, RC, VERB=.FALSE. )
    1631             : 
    1632             :     ! Meteorology token (lowercase)
    1633           0 :     CALL GetExtOpt( CF, CoreNr, 'met', OptValChar=DUM, Found=FOUND, RC=RC )
    1634           0 :     IF ( RC /= HCO_SUCCESS ) THEN
    1635           0 :         CALL HCO_ERROR( 'ERROR 9', RC, THISLOC=LOC )
    1636           0 :         RETURN
    1637             :     ENDIF
    1638           0 :     IF ( .NOT. FOUND) DUM = DEF_MET_LC
    1639           0 :     CALL HCO_AddOpt( CF, 'met', DUM, CoreNr, RC, VERB=.FALSE. )
    1640             : 
    1641             :     ! Year for constant met fields
    1642           0 :     CALL GetExtOpt( CF, CoreNr, 'CNYR', OptValChar=DUM, Found=FOUND, RC=RC )
    1643           0 :     IF ( RC /= HCO_SUCCESS ) THEN
    1644           0 :         CALL HCO_ERROR( 'ERROR 10', RC, THISLOC=LOC )
    1645           0 :         RETURN
    1646             :     ENDIF
    1647           0 :     IF ( .NOT. FOUND) DUM = DEF_CN_YR
    1648           0 :     CALL HCO_AddOpt( CF, 'CNYR', DUM, CoreNr, RC, VERB=.FALSE. )
    1649             : 
    1650             :     ! NetCDF version extension
    1651           0 :     CALL GetExtOpt( CF, CoreNr, 'NC', OptValChar=DUM, Found=FOUND, RC=RC )
    1652           0 :     IF ( RC /= HCO_SUCCESS ) THEN
    1653           0 :         CALL HCO_ERROR( 'ERROR 11', RC, THISLOC=LOC )
    1654           0 :         RETURN
    1655             :     ENDIF
    1656           0 :     IF ( .NOT. FOUND) DUM = DEF_NC_VER
    1657           0 :     CALL HCO_AddOpt( CF, 'NC', DUM, CoreNr, RC, VERB=.FALSE. )
    1658             : 
    1659             :     ! Resolution token
    1660           0 :     CALL GetExtOpt( CF, CoreNr, 'RES', OptValChar=DUM, Found=FOUND, RC=RC )
    1661           0 :     IF ( RC /= HCO_SUCCESS ) THEN
    1662           0 :         CALL HCO_ERROR( 'ERROR 12', RC, THISLOC=LOC )
    1663           0 :         RETURN
    1664             :     ENDIF
    1665           0 :     IF ( .NOT. FOUND ) DUM = DEF_RES
    1666           0 :     CALL HCO_AddOpt( CF, 'RES', DUM, CoreNr, RC, VERB=.FALSE. )
    1667             : 
    1668             :     ! Return w/ success
    1669           0 :     RC =  HCO_SUCCESS
    1670             : 
    1671             :   END SUBROUTINE HCO_SetDefaultToken
    1672             : !EOC
    1673             : END MODULE HCO_ExtList_Mod

Generated by: LCOV version 1.14