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

              Line data    Source code
           1             : !------------------------------------------------------------------------------
           2             : !                   Harmonized Emissions Component (HEMCO)                    !
           3             : !------------------------------------------------------------------------------
           4             : !BOP
           5             : !
           6             : ! !MODULE: hcox_driver_mod.F90
           7             : !
           8             : ! !DESCRIPTION: Module hcox\_driver\_mod.F90 contains the driver routines
           9             : ! (INIT, RUN, FINAL) for the HEMCO extensions. It determines the extensions
          10             : ! to be used (based on the settings specified in the configuration file)
          11             : ! and invokes the respective extension module calls.
          12             : !\\
          13             : !\\
          14             : ! Call this module at the HEMCO - model interface level to execute the
          15             : ! HEMCO extensions.
          16             : !\\
          17             : !\\
          18             : ! !INTERFACE:
          19             : !
          20             : MODULE HCOX_Driver_Mod
          21             : !
          22             : ! !USES:
          23             : !
          24             :   USE HCO_Error_Mod
          25             :   USE HCO_State_Mod,  ONLY : HCO_State
          26             :   USE HCOX_State_Mod, ONLY : Ext_State
          27             :
          28             :   IMPLICIT NONE
          29             :   PRIVATE
          30             : !
          31             : ! !PUBLIC MEMBER FUNCTIONS:
          32             : !
          33             :   PUBLIC :: HCOX_Init
          34             :   PUBLIC :: HCOX_Run
          35             :   PUBLIC :: HCOX_Final
          36             :
          37             :   PRIVATE :: HCOX_DiagnDefine
          38             :   PRIVATE :: HCOX_DiagnFill
          39             : !
          40             : ! !REMARKS:
          41             : ! (1) The extension option objects (e.g. meteorological variables) are
          42             : !     defined in the HEMCO - model interface module and passed to this
          43             : !     module.
          44             : ! (2) To add/remove HEMCO extensions from a model application, just
          45             : !     add/remove the corresponding initialize, run, and finalize calls
          46             : !     in the respective driver routines!
          47             : !
          48             : ! !REVISION HISTORY:
          49             : !  15 Dec 2013 - C. Keller   - Initial version
          50             : !  See https://github.com/geoschem/hemco for complete history
          51             : !EOP
          52             : !------------------------------------------------------------------------------
          53             : !BOC
          54             : !
          55             : ! !PRIVATE VARIABLES
          56             : !
          57             :
          58             :   ! Variables for diagnostics: diagnostics toggle and output frequency.
          59             :   LOGICAL, PARAMETER            :: DoDiagn   = .FALSE.
          60             :
          61             :   ! Arrays needed for diagnostics. Diagnostics are defined / filled via
          62             :   ! subroutines HCOX_DiagnDefine and HCOX_DiagnFill, respectively.
          63             :   REAL(sp), ALLOCATABLE, TARGET :: DGN_SUNCOS   (:,:  )
          64             :   REAL(sp), ALLOCATABLE, TARGET :: DGN_DRYTOTN  (:,:  )
          65             :   REAL(sp), ALLOCATABLE, TARGET :: DGN_WETTOTN  (:,:  )
          66             :   REAL(sp), ALLOCATABLE, TARGET :: DGN_LAI      (:,:  )
          67             : !  REAL(sp), ALLOCATABLE, TARGET :: DGN_T2M      (:,:  )
          68             : !  REAL(sp), ALLOCATABLE, TARGET :: DGN_GWET     (:,:  )
          69             : !  REAL(sp), ALLOCATABLE, TARGET :: DGN_U10M     (:,:  )
          70             : !  REAL(sp), ALLOCATABLE, TARGET :: DGN_V10M     (:,:  )
          71             : !  REAL(sp), ALLOCATABLE, TARGET :: DGN_PARDR    (:,:  )
          72             : !  REAL(sp), ALLOCATABLE, TARGET :: DGN_PARDF    (:,:  )
          73             : !  REAL(sp), ALLOCATABLE, TARGET :: DGN_SZAFACT  (:,:  )
          74             : !  REAL(sp), ALLOCATABLE, TARGET :: DGN_CLDFRC   (:,:  )
          75             : !  REAL(sp), ALLOCATABLE, TARGET :: DGN_ALBD     (:,:  )
          76             : !  REAL(sp), ALLOCATABLE, TARGET :: DGN_WLI      (:,:  )
          77             : !  REAL(sp), ALLOCATABLE, TARGET :: DGN_TROPP    (:,:  )
          78             :
          79             : CONTAINS
          80             : !EOC
          81             : !------------------------------------------------------------------------------
          82             : !                   Harmonized Emissions Component (HEMCO)                    !
          83             : !------------------------------------------------------------------------------
          84             : !BOP
          85             : !
          86             : ! !IROUTINE: HCOX_Init
          87             : !
          88             : ! !DESCRIPTION: Subroutine HCOX\_Init is the driver routine to initialize
          89             : !  all enabled HEMCO extensions.
          90             : !\\
          91             : ! !INTERFACE:
          92             : !
          93           0 :   SUBROUTINE HCOX_Init( HcoState, ExtState, RC )
          94             : !
          95             : ! !USES:
          96             : !
          97             :     USE HCOX_State_MOD,         ONLY : ExtStateInit
          98             :     USE HCOX_Custom_Mod,        ONLY : HCOX_Custom_Init
          99             :     USE HCOX_SeaFlux_Mod,       ONLY : HCOX_SeaFlux_Init
         100             :     USE HCOX_ParaNOx_Mod,       ONLY : HCOX_ParaNOx_Init
         101             :     USE HCOX_LightNox_Mod,      ONLY : HCOX_LightNox_Init
         102             :     USE HCOX_SoilNox_Mod,       ONLY : HCOX_SoilNox_Init
         103             :     USE HCOX_DustDead_Mod,      ONLY : HCOX_DustDead_Init
         104             :     USE HCOX_DustGinoux_Mod,    ONLY : HCOX_DustGinoux_Init
         105             :     USE HCOX_SeaSalt_Mod,       ONLY : HCOX_SeaSalt_Init
         106             :     USE HCOX_GFED_Mod,          ONLY : HCOX_GFED_Init
         107             :     USE HCOX_MEGAN_Mod,         ONLY : HCOX_MEGAN_Init
         108             :     USE HCOX_Finn_Mod,          ONLY : HCOX_FINN_Init
         109             :     USE HCOX_GC_RnPbBe_Mod,     ONLY : HCOX_GC_RnPbBe_Init
         110             :     USE HCOX_GC_POPs_Mod,       ONLY : HCOX_GC_POPs_Init
         111             :     USE HCOX_Volcano_Mod,       ONLY : HCOX_Volcano_Init
         112             :     USE HCOX_Iodine_Mod,        ONLY : HCOX_Iodine_Init
         113             : #if defined( TOMAS )
         114             :     USE HCOX_TOMAS_Jeagle_Mod,   ONLY : HCOX_TOMAS_Jeagle_Init
         115             :     USE HCOX_TOMAS_DustDead_Mod, ONLY : HCOX_TOMAS_DustDead_Init
         116             : #endif
         117             : !
         118             : ! !INPUT/OUTPUT PARAMETERS:
         119             : !
         120             :     TYPE(HCO_State),  POINTER        :: HcoState       ! HEMCO state object
         121             :     TYPE(Ext_State),  POINTER        :: ExtState       ! HEMCO extension object
         122             :     INTEGER,          INTENT(INOUT)  :: RC             ! Failure or success
         123             : !
         124             : ! !REMARKS:
         125             : !  By default we will call routine ExtStateInit, which initializes the
         126             : !  ExtState object.  In some instances, we may want to call ExtStateInit
         127             : !  from a higher-level routine.  For example, this allows us to pass
         128             : !  via ExtState additional scalar quantities from the driving model to
         129             : !  HEMCO.  To do this, you will need to (1) call ExtStateInit separately,
         130             : !  and (2) set the optional argument NoExtStateInit=.FALSE. flag in the
         131             : !  call to HCOX_INIT.
         132             : !
         133             : ! !REVISION HISTORY:
         134             : !  12 Sep 2013 - C. Keller   - Initial version
         135             : !  See https://github.com/geoschem/hemco for complete history
         136             : !EOP
         137             : !------------------------------------------------------------------------------
         138             : !BOC
         139             : !
         140             : ! !LOCAL VARIABLES:
         141             : !
         142             :     CHARACTER(LEN=255) :: ErrMsg, ThisLoc, LOC
         143             :
         144             :     !=======================================================================
         145             :     ! HCOX_INIT begins here!
         146             :     !=======================================================================
         147           0 :     LOC = 'HCOX_INIT (HCOX_DRIVER_MOD.F90)'
         148             :
         149             :     ! Initialize
         150           0 :     RC      = HCO_SUCCESS
         151           0 :     ErrMsg  = ''
         152             :     ThisLoc = &
         153           0 :        ' -> at HCOX_INIT (in module HEMCO/Extensions/hcox_driver_mod.F90'
         154             :
         155             :     ! Error handling
         156           0 :     CALL HCO_ENTER(HcoState%Config%Err, LOC, RC )
         157           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         158           0 :         CALL HCO_ERROR( 'ERROR 0', RC, THISLOC=LOC )
         159           0 :         RETURN
         160             :     ENDIF
         161             :
         162             :     !=======================================================================
         163             :     ! Initialize extensions
         164             :     !=======================================================================
         165           0 :     CALL ExtStateInit( ExtState, RC )
         166           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         167           0 :        ErrMsg = 'Error encountered in "ExtState_Init"!'
         168           0 :        CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         169           0 :        RETURN
         170             :     ENDIF
         171             :
         172             :     !=======================================================================
         173             :     ! The LIGHTNOX, PARANOX, and VOLCANO extensions read data files
         174             :     ! (lookup tables or text files) whose formats cannot be read by
         175             :     ! the HCOIO_READ_* routines.  Therefore we need to always initialize
         176             :     ! these extensions so that we can print out the required file paths
         177             :     ! when performing a GEOS-Chem dry-run or HEMCO standalone dry-run.
         178             :     !=======================================================================
         179             :
         180             :     !-----------------------------------------------------------------------
         181             :     ! ParaNox
         182             :     !-----------------------------------------------------------------------
         183           0 :     CALL HCOX_PARANOX_INIT( HcoState, 'ParaNOx', ExtState, RC )
         184           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         185           0 :        ErrMsg = 'Error encountered in "HCOX_ParaNOx_Init"!'
         186           0 :        CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         187           0 :        RETURN
         188             :     ENDIF
         189             :
         190             :     !-----------------------------------------------------------------------
         191             :     ! LightNox
         192             :     !-----------------------------------------------------------------------
         193           0 :     CALL HCOX_LightNox_Init( HcoState, 'LightNOx', ExtState, RC )
         194           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         195           0 :        ErrMsg = 'Error encountered in "HCOX_LightNox_Init"!'
         196           0 :        CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         197           0 :        RETURN
         198             :     ENDIF
         199             :
         200             :     !-----------------------------------------------------------------------
         201             :     ! Volcano emissions
         202             :     !-----------------------------------------------------------------------
         203           0 :     CALL HCOX_Volcano_Init( HcoState, 'Volcano', ExtState,  RC )
         204           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         205           0 :        ErrMsg = 'Error encountered in "HCOX_Volcano_Init"!'
         206           0 :        CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         207           0 :        RETURN
         208             :     ENDIF
         209             :
         210             :     !=======================================================================
         211             :     ! We can skip initializing all of the other extensions when
         212             :     ! performing a GEOS-Chem dry-run or HEMCO standalone dry-run.
         213             :     !=======================================================================
         214           0 :     IF ( .not. HcoState%Options%isDryRun ) THEN
         215             :
         216             :        !--------------------------------------------------------------------
         217             :        ! Custom
         218             :        !--------------------------------------------------------------------
         219           0 :        CALL HCOX_Custom_Init( HcoState, 'Custom', ExtState, RC )
         220           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         221           0 :           ErrMsg = 'Error encountered in "HCOX_Custom_Init"!'
         222           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         223           0 :           RETURN
         224             :        ENDIF
         225             :
         226             :        !--------------------------------------------------------------------
         227             :        ! SeaFlux
         228             :        !--------------------------------------------------------------------
         229           0 :        CALL HCOX_SeaFlux_Init( HcoState, 'SeaFlux', ExtState, RC )
         230           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         231           0 :           ErrMsg = 'Error encountered in "HCOX_SeaFlux_Init"!'
         232           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         233           0 :           RETURN
         234             :        ENDIF
         235             :
         236             :        !--------------------------------------------------------------------
         237             :        ! SoilNox
         238             :        !--------------------------------------------------------------------
         239           0 :        CALL HCOX_SoilNox_Init( HcoState, 'SoilNOx', ExtState, RC )
         240           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         241           0 :           ErrMsg = 'Error encountered in "HCOX_SoilNox_Init"!'
         242           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         243           0 :           RETURN
         244             :        ENDIF
         245             :
         246             :        !--------------------------------------------------------------------
         247             :        ! Dust emissions (DEAD model)
         248             :        !--------------------------------------------------------------------
         249           0 :        CALL HCOX_DustDead_Init( HcoState, 'DustDead', ExtState,  RC )
         250           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         251           0 :           ErrMsg = 'Error encountered in "HCOX_DustDead_Init"!'
         252           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         253           0 :           RETURN
         254             :        ENDIF
         255             : #if defined( TOMAS )
         256             :        CALL HCOX_TOMAS_DustDead_Init( HcoState, 'TOMAS_DustDead', &
         257             :                                       ExtState, RC )
         258             :        IF ( RC /= HCO_SUCCESS ) THEN
         259             :           ErrMsg = 'Error encountered in "HCOX_TOMAS_DustDead_Init"!'
         260             :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         261             :           RETURN
         262             :        ENDIF
         263             : #endif
         264             :
         265             :        !--------------------------------------------------------------------
         266             :        ! Dust Ginoux emissions
         267             :        !--------------------------------------------------------------------
         268           0 :        CALL HCOX_DustGinoux_Init( HcoState, 'DustGinoux', ExtState, RC )
         269           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         270           0 :           ErrMsg = 'Error encountered in "HCOX_DustGinoux_Init"!'
         271           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         272           0 :           RETURN
         273             :        ENDIF
         274             :
         275             :        !--------------------------------------------------------------------
         276             :        ! SeaSalt aerosol extension
         277             :        !--------------------------------------------------------------------
         278           0 :        CALL HCOX_SeaSalt_Init( HcoState, 'SeaSalt', ExtState, RC )
         279           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         280           0 :           ErrMsg = 'Error encountered in "HCOX_SeaSalt_Init"!'
         281           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         282           0 :           RETURN
         283             :        ENDIF
         284             :
         285             :        !--------------------------------------------------------------------
         286             :        ! MEGAN extension
         287             :        !--------------------------------------------------------------------
         288           0 :        CALL HCOX_Megan_Init( HcoState, 'MEGAN', ExtState, RC )
         289           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         290           0 :           ErrMsg = 'Error encountered in "HCOX_Megan_Init"!'
         291           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         292           0 :           RETURN
         293             :        ENDIF
         294             :
         295             :        !--------------------------------------------------------------------
         296             :        ! GFED extension
         297             :        !--------------------------------------------------------------------
         298           0 :        CALL HCOX_GFED_Init( HcoState, 'GFED', ExtState, RC )
         299           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         300           0 :           ErrMsg = 'Error encountered in "HCOX_GFED_Init"!'
         301           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         302           0 :           RETURN
         303             :        ENDIF
         304             :
         305             :        !--------------------------------------------------------------------
         306             :        ! FINN biomass burning emissions
         307             :        !--------------------------------------------------------------------
         308           0 :        CALL HCOX_FINN_Init( HcoState, 'FINN', ExtState, RC )
         309           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         310           0 :           ErrMsg = 'Error encountered in "HCOX_FINN_Init"!'
         311           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         312           0 :           RETURN
         313             :        ENDIF
         314             :
         315             :        !--------------------------------------------------------------------
         316             :        ! Extension for GEOS-Chem Rn-Pb-Be specialty simulation
         317             :        !--------------------------------------------------------------------
         318           0 :        CALL HCOX_GC_RnPbBe_Init( HcoState, 'GC_Rn-Pb-Be', ExtState,  RC )
         319           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         320           0 :           ErrMsg = 'Error encountered in "HCOX_GC_RnPbBe_Init"!'
         321           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         322           0 :           RETURN
         323             :        ENDIF
         324             :
         325             :        !--------------------------------------------------------------------
         326             :        ! Extension for GEOS-Chem POPs specialty simulation
         327             :        !--------------------------------------------------------------------
         328           0 :        CALL HCOX_GC_POPs_Init( HcoState, 'GC_POPs', ExtState,  RC )
         329           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         330           0 :           ErrMsg = 'Error encountered in "HCOX_GC_POPs_Init"!'
         331           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         332           0 :           RETURN
         333             :        ENDIF
         334             :
         335             :        !--------------------------------------------------------------------
         336             :        ! Ocean inorganic iodine emissions
         337             :        !--------------------------------------------------------------------
         338           0 :        CALL HCOX_Iodine_Init( HcoState, 'Inorg_Iodine', ExtState,  RC )
         339           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         340           0 :           ErrMsg = 'Error encountered in "HCOX_Iodine_Init"!'
         341           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         342           0 :           RETURN
         343             :        ENDIF
         344             :
         345             : #if defined( TOMAS )
         346             :        !--------------------------------------------------------------------
         347             :        ! TOMAS sectional sea salt aerosol emissions
         348             :        !--------------------------------------------------------------------
         349             :        CALL HCOX_TOMAS_Jeagle_Init( HcoState, 'TOMAS_Jeagle', ExtState,  RC )
         350             :        IF ( RC /= HCO_SUCCESS ) THEN
         351             :           ErrMsg = 'Error encountered in "HCOX_TOMAS_Jeagle_Init"!'
         352             :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         353             :           RETURN
         354             :        ENDIF
         355             : #endif
         356             :
         357             :        !--------------------------------------------------------------------
         358             :        ! Add extensions here ...
         359             :        !--------------------------------------------------------------------
         360             :     ENDIF
         361             :
         362             :     !=======================================================================
         363             :     ! Sanity checks
         364             :     !=======================================================================
         365             :
         366             :     ! Cannot have both DustDead and DustGinoux turned on!
         367           0 :     IF ( ExtState%DustDead > 0 .AND. ExtState%DustGinoux > 0 ) THEN
         368           0 :        ErrMsg = 'Ginoux and DEAD dust emissions switched on!'
         369           0 :        CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         370           0 :        RETURN
         371             :     ENDIF
         372             :
         373             :     !=======================================================================
         374             :     ! Define diagnostics (can skip for dry-run)
         375             :     !=======================================================================
         376           0 :     IF ( .not. HcoState%Options%isDryRun ) THEN
         377           0 :        CALL HCOX_DiagnDefine( HcoState, ExtState, RC )
         378           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         379           0 :           ErrMsg = 'Error encountered in "ExtState_Init"!'
         380           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         381           0 :           RETURN
         382             :        ENDIF
         383             :     ENDIF
         384             :
         385             :     !=======================================================================
         386             :     ! Leave w/ success
         387             :     !=======================================================================
         388           0 :     CALL HCO_LEAVE( HcoState%Config%Err,RC )
         389             :
         390             :   END SUBROUTINE HCOX_Init
         391             : !EOC
         392             : !------------------------------------------------------------------------------
         393             : !                   Harmonized Emissions Component (HEMCO)                    !
         394             : !------------------------------------------------------------------------------
         395             : !BOP
         396             : !
         397             : ! !IROUTINE: HCOX_Run
         398             : !
         399             : ! !DESCRIPTION: Subroutine HCOX\_Run is the driver routine to run the HEMCO
         400             : ! extensions. All enabled emission extensions are executed, and the
         401             : ! emissions calculated therein become added to the respective flux arrays
         402             : ! in HcoState.\\
         403             : !\\
         404             : !\\
         405             : ! !INTERFACE:
         406             : !
         407           0 :   SUBROUTINE HCOX_Run( HcoState, ExtState, RC )
         408             : !
         409             : ! !USES:
         410             : !
         411             :     USE HCO_Clock_Mod,          ONLY : HcoClock_Get
         412             :     USE HCOX_Custom_Mod,        ONLY : HCOX_Custom_Run
         413             :     USE HCOX_SeaFlux_Mod,       ONLY : HCOX_SeaFlux_Run
         414             :     USE HCOX_ParaNox_Mod,       ONLY : HCOX_ParaNox_Run
         415             :     USE HCOX_LightNox_Mod,      ONLY : HCOX_LightNox_Run
         416             :     USE HCOX_SoilNox_Mod,       ONLY : HCOX_SoilNox_Run
         417             :     USE HCOX_DustDead_Mod,      ONLY : HCOX_DustDead_Run
         418             :     USE HCOX_DustGinoux_Mod,    ONLY : HCOX_DustGinoux_Run
         419             :     USE HCOX_SeaSalt_Mod,       ONLY : HCOX_SeaSalt_Run
         420             :     USE HCOX_Megan_Mod,         ONLY : HCOX_Megan_Run
         421             :     USE HCOX_GFED_Mod,          ONLY : HCOX_GFED_Run
         422             :     USE HCOX_FINN_Mod,          ONLY : HCOX_FINN_Run
         423             :     USE HCOX_GC_RnPbBe_Mod,     ONLY : HCOX_GC_RnPbBe_Run
         424             :     USE HCOX_GC_POPs_Mod,       ONLY : HCOX_GC_POPs_Run
         425             :     USE HCOX_Volcano_Mod,       ONLY : HCOX_Volcano_Run
         426             :     USE HCOX_Iodine_Mod,        ONLY : HCOX_Iodine_Run
         427             : #if defined( TOMAS )
         428             :     USE HCOX_TOMAS_Jeagle_Mod,   ONLY : HCOX_TOMAS_Jeagle_Run
         429             :     USE HCOX_TOMAS_DustDead_Mod, ONLY : HCOX_TOMAS_DustDead_Run
         430             : #endif
         431             : !
         432             : ! !INPUT/OUTPUT PARAMETERS:
         433             : !
         434             :     TYPE(HCO_State),  POINTER        :: HcoState   ! HEMCO state object
         435             :     TYPE(Ext_State),  POINTER        :: ExtState   ! Extension options object
         436             :     INTEGER,          INTENT(INOUT)  :: RC         ! Failure or success
         437             : !
         438             : ! !NOTE:
         439             : !
         440             : ! The ExtState object contains all extension option objects. In particular,
         441             : ! it contains the pointers to all met fields used by the extensions. These
         442             : ! pointers have to be set in the HEMCO-model interface module beforehand!
         443             : !
         444             : ! !REVISION HISTORY:
         445             : !  15 Dec 2013 - C. Keller   - Initial version
         446             : !  See https://github.com/geoschem/hemco for complete history
         447             : !EOP
         448             : !------------------------------------------------------------------------------
         449             : !BOC
         450             : !
         451             : ! !LOCAL VARIABLES:
         452             : !
         453             :     CHARACTER(LEN=255) :: ErrMsg, ThisLoc, LOC
         454             :     LOGICAL            :: IsEmisTime
         455             :
         456             :     !=======================================================================
         457             :     ! HCOX_RUN begins here!
         458             :     !=======================================================================
         459             :
         460             :     ! Initialize
         461           0 :     LOC     = 'HCOX_RUN (HCOX_DRIVER_MOD.F90)'
         462           0 :     RC      = HCO_SUCCESS
         463           0 :     ErrMsg  = ''
         464           0 :     ThisLoc = ' -> at HCOX_RUN (in module HEMCO/Extensions/hcox_driver_mod.F90'
         465             :
         466             :     ! For error handling
         467           0 :     CALL HCO_ENTER( HcoState%Config%Err, LOC, RC )
         468           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         469           0 :         CALL HCO_ERROR( 'ERROR 1', RC, THISLOC=LOC )
         470           0 :         RETURN
         471             :     ENDIF
         472             :
         473             :     ! Is it time for emissions?
         474           0 :     CALL HcoClock_Get ( HcoState%Clock, IsEmisTime=IsEmisTime, RC=RC )
         475           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         476           0 :         CALL HCO_ERROR( 'ERROR 2', RC, THISLOC=LOC )
         477           0 :         RETURN
         478             :     ENDIF
         479             :
         480             :     ! Can leave here if it's not time for emissions
         481           0 :     IF ( .NOT. IsEmisTime ) THEN
         482           0 :        CALL HCO_LEAVE( HcoState%Config%Err,RC )
         483           0 :        RETURN
         484             :     ENDIF
         485             :
         486             :     !=======================================================================
         487             :     ! The VOLCANO extension is the only extension that reads data files
         488             :     ! from text files in the Run phase.  Therefore, we always need to
         489             :     ! run the VOLCANO extension, so that we can print out the path names
         490             :     ! of files being read in to the dry-run log file.
         491             :     !=======================================================================
         492             :
         493             :     !-----------------------------------------------------------------------
         494             :     ! AeroCom volcano emissions
         495             :     !-----------------------------------------------------------------------
         496           0 :     IF ( ExtState%Volcano > 0 ) THEN
         497           0 :        CALL HCOX_Volcano_Run( ExtState, HcoState, RC )
         498           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         499           0 :           ErrMsg = 'Error encountered in "HCOX_Volcano_Run"!'
         500           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         501           0 :           RETURN
         502             :        ENDIF
         503             :     ENDIF
         504             :
         505             :     !=======================================================================
         506             :     ! We can skip running all of the other extensions when
         507             :     ! performing a GEOS-Chem dry-run or HEMCO standalone dry-run.
         508             :     !
         509             :     ! NOTE: LIGHTNING and PARANOX read data in the Init phase, and
         510             :     ! not the Run phase.  So we can skip running these as well.
         511             :     !=======================================================================
         512           0 :     IF ( .not. HcoState%Options%isDryRun ) THEN
         513             :
         514             :        !--------------------------------------------------------------------
         515             :        ! Customized emissions
         516             :        !--------------------------------------------------------------------
         517           0 :        IF ( ExtState%Custom > 0 ) THEN
         518           0 :           CALL HCOX_Custom_Run( ExtState, HcoState, RC)
         519           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         520           0 :              ErrMsg = 'Error encountered in "HCOX_Custom_Run"!'
         521           0 :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         522           0 :              RETURN
         523             :           ENDIF
         524             :        ENDIF
         525             :
         526             :        !--------------------------------------------------------------------
         527             :        ! SeaFlux (Air-sea exchange)
         528             :        !--------------------------------------------------------------------
         529           0 :        IF ( ExtState%SeaFlux > 0 ) THEN
         530           0 :           CALL HCOX_SeaFlux_Run( ExtState, HcoState, RC)
         531           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         532           0 :              ErrMsg = 'Error encountered in "HCOX_SeaFlux_Run"!'
         533           0 :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         534           0 :              RETURN
         535             :           ENDIF
         536             :        ENDIF
         537             :
         538             :        !--------------------------------------------------------------------
         539             :        ! ParaNox (Ship NO emissions)
         540             :        !--------------------------------------------------------------------
         541           0 :        IF ( ExtState%ParaNOx > 0 ) THEN
         542           0 :           CALL HCOX_ParaNox_Run( ExtState, HcoState, RC )
         543           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         544           0 :              ErrMsg = 'Error encountered in "HCOX_ParaNOx_Run"!'
         545           0 :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         546           0 :              RETURN
         547             :           ENDIF
         548             :        ENDIF
         549             :
         550             :        !--------------------------------------------------------------------
         551             :        ! Lightning NOx
         552             :        !--------------------------------------------------------------------
         553           0 :        IF ( ExtState%LightNOx > 0 ) THEN
         554           0 :           CALL HCOX_LightNox_Run( ExtState, HcoState, RC )
         555           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         556           0 :              ErrMsg = 'Error encountered in "HCOX_LightNox_Run"!'
         557           0 :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         558           0 :              RETURN
         559             :           ENDIF
         560             :        ENDIF
         561             :
         562             :        !--------------------------------------------------------------------
         563             :        ! SoilNOx
         564             :        !--------------------------------------------------------------------
         565           0 :        IF ( ExtState%SoilNOx > 0 ) THEN
         566           0 :           CALL HCOX_SoilNox_Run( ExtState, HcoState, RC )
         567           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         568           0 :              ErrMsg = 'Error encountered in "HCOX_SoilNOx_Run"!'
         569           0 :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         570           0 :              RETURN
         571             :           ENDIF
         572             :        ENDIF
         573             :
         574             :        !--------------------------------------------------------------------
         575             :        ! Dust emissions (DEAD model)
         576             :        !--------------------------------------------------------------------
         577           0 :        IF ( ExtState%DustDead > 0 ) THEN
         578           0 :           CALL HCOX_DustDead_Run( ExtState, HcoState, RC )
         579           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         580           0 :              ErrMsg = 'Error encountered in "HCOX_DustDead_Run"!'
         581           0 :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         582           0 :              RETURN
         583             :           ENDIF
         584             :        ENDIF
         585             :
         586             : #ifdef TOMAS
         587             :        IF ( ExtState%TOMAS_DustDead > 0 ) THEN
         588             :           !print*, 'JACK TOMAS_DustDead is on'
         589             :           CALL HCOX_TOMAS_DustDead_Run( ExtState, HcoState, RC )
         590             :           IF ( RC /= HCO_SUCCESS ) THEN
         591             :              ErrMsg = 'Error encountered in "HCOX_TOMAS_DustDead_Run"!'
         592             :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         593             :              RETURN
         594             :           ENDIF
         595             :        ENDIF
         596             : #endif
         597             :
         598             :        !--------------------------------------------------------------------
         599             :        ! Dust emissions (Ginoux)
         600             :        !--------------------------------------------------------------------
         601           0 :        IF ( ExtState%DustGinoux > 0 ) THEN
         602           0 :           CALL HCOX_DustGinoux_Run( ExtState, HcoState, RC )
         603           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         604           0 :              ErrMsg = 'Error encountered in "HCOX_DustGinoux_Run"!'
         605           0 :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         606           0 :              RETURN
         607             :           ENDIF
         608             :        ENDIF
         609             :
         610             :        !--------------------------------------------------------------------
         611             :        ! Sea salt aerosols
         612             :        !--------------------------------------------------------------------
         613           0 :        IF ( ExtState%SeaSalt > 0 ) THEN
         614           0 :           CALL HCOX_SeaSalt_Run( ExtState, HcoState, RC )
         615           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         616           0 :              ErrMsg = 'Error encountered in "HCOX_SeaSalt_Run"!'
         617           0 :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         618           0 :              RETURN
         619             :           ENDIF
         620             :        ENDIF
         621             :
         622             :        !--------------------------------------------------------------------
         623             :        ! MEGAN biogenic emissions
         624             :        !--------------------------------------------------------------------
         625           0 :        IF ( ExtState%Megan > 0 ) THEN
         626           0 :           CALL HCOX_Megan_Run( ExtState, HcoState, RC )
         627           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         628           0 :              ErrMsg = 'Error encountered in "HCOX__Run"!'
         629           0 :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         630           0 :              RETURN
         631             :           ENDIF
         632             :        ENDIF
         633             :
         634             :        !--------------------------------------------------------------------
         635             :        ! GFED biomass burning emissions
         636             :        !--------------------------------------------------------------------
         637           0 :        IF ( ExtState%GFED > 0 ) THEN
         638           0 :           CALL HCOX_GFED_Run( ExtState, HcoState, RC )
         639           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         640           0 :              ErrMsg = 'Error encountered in "HCOX_GFED_Run"!'
         641           0 :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         642           0 :              RETURN
         643             :           ENDIF
         644             :        ENDIF
         645             :
         646             :        !--------------------------------------------------------------------
         647             :        ! FINN biomass burning emissions
         648             :        ! -------------------------------------------------------------------
         649           0 :        IF ( ExtState%FINN > 0 ) THEN
         650           0 :           CALL HCOX_FINN_Run( ExtState, HcoState, RC )
         651           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         652           0 :              ErrMsg = 'Error encountered in "HCOX_FINN_Run"!'
         653           0 :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         654           0 :              RETURN
         655             :           ENDIF
         656             :        ENDIF
         657             :
         658             :        !--------------------------------------------------------------------
         659             :        ! Emissions for GEOS-Chem Rn-Pb-Be specialty simulation
         660             :        !--------------------------------------------------------------------
         661           0 :        IF ( ExtState%GC_RnPbBe > 0 ) THEN
         662           0 :           CALL HCOX_GC_RnPbBe_Run( ExtState, HcoState, RC )
         663           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         664           0 :              ErrMsg = 'Error encountered in "HCOX_GC_RnPbBe_Run"!'
         665           0 :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         666           0 :              RETURN
         667             :           ENDIF
         668             :        ENDIF
         669             :
         670             :        !--------------------------------------------------------------------
         671             :        ! Emissions for GEOS-Chem POPs specialty simulation
         672             :        !--------------------------------------------------------------------
         673           0 :        IF ( ExtState%GC_POPs > 0 ) THEN
         674           0 :           CALL HCOX_GC_POPs_Run( ExtState, HcoState, RC )
         675           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         676           0 :              ErrMsg = 'Error encountered in "HCOX_GC_POPs_Run"!'
         677           0 :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         678           0 :              RETURN
         679             :           ENDIF
         680             :        ENDIF
         681             :
         682             : #ifdef TOMAS
         683             :        !--------------------------------------------------------------------
         684             :        ! TOMAS sectional sea salt emissions
         685             :        !--------------------------------------------------------------------
         686             :        IF ( ExtState%TOMAS_Jeagle > 0 ) THEN
         687             :           CALL HCOX_TOMAS_Jeagle_Run( ExtState, HcoState, RC )
         688             :           IF ( RC /= HCO_SUCCESS ) THEN
         689             :              ErrMsg = 'Error encountered in "HCOX_TOMAS_Jeagle_Run"!'
         690             :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         691             :              RETURN
         692             :           ENDIF
         693             :        ENDIF
         694             : #endif
         695             :
         696             :        !--------------------------------------------------------------------
         697             :        ! Ocean inorganic iodine emissions
         698             :        !--------------------------------------------------------------------
         699           0 :        IF ( ExtState%Inorg_Iodine > 0 ) THEN
         700           0 :           CALL HCOX_Iodine_Run( ExtState, HcoState, RC )
         701           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         702           0 :              ErrMsg = 'Error encountered in "HCOX_Iodine_Run"!'
         703           0 :              CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         704           0 :              RETURN
         705             :           ENDIF
         706             :        ENDIF
         707             :
         708             :        !--------------------------------------------------------------------
         709             :        ! Add extensions here ...
         710             :        !--------------------------------------------------------------------
         711             :
         712             :        !====================================================================
         713             :        ! Fill diagnostics
         714             :        !
         715             :        ! This updates the diagnostics defined in HCOX_DiagnDefine.
         716             :        ! Subroutine HCOIO_DIAGN_WRITEOUT can be used to write out
         717             :        ! diagnostics to disk.  This subroutine is called in higher-level
         718             :        ! routines.
         719             :        !
         720             :        ! Skip for GEOS-Chem dry-run or HEMCO standalone dry-run
         721             :        !====================================================================
         722           0 :        CALL HCOX_DiagnFill( HcoState, ExtState, RC )
         723           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         724           0 :           ErrMsg = 'Error encountered in "HCOX_DiagnFill_Run"!'
         725           0 :           CALL HCO_ERROR( ErrMsg, RC, ThisLoc )
         726           0 :           RETURN
         727             :        ENDIF
         728             :
         729             :     ENDIF
         730             :
         731             :     !=======================================================================
         732             :     ! Return w/ success
         733             :     !=======================================================================
         734           0 :     CALL HCO_LEAVE( HcoState%Config%Err, RC )
         735             :
         736             :   END SUBROUTINE HCOX_Run
         737             : !EOC
         738             : !------------------------------------------------------------------------------
         739             : !                   Harmonized Emissions Component (HEMCO)                    !
         740             : !------------------------------------------------------------------------------
         741             : !BOP
         742             : !
         743             : ! !IROUTINE: HCOX_Final
         744             : !
         745             : ! !DESCRIPTION: Subroutine HCOX\_Final finalizes all HEMCO extensions.
         746             : !\\
         747             : !\\
         748             : ! !INTERFACE:
         749             : !
         750           0 :   SUBROUTINE HCOX_Final( HcoState, ExtState, RC )
         751             : !
         752             : ! !USES:
         753             : !
         754             :     USE HCOX_State_Mod,         ONLY : ExtStateFinal
         755             :     USE HCOX_Custom_Mod,        ONLY : HCOX_Custom_Final
         756             :     USE HCOX_SeaFlux_Mod,       ONLY : HCOX_SeaFlux_Final
         757             :     USE HCOX_ParaNOx_Mod,       ONLY : HCOX_PARANOX_Final
         758             :     USE HCOX_LightNox_Mod,      ONLY : HCOX_LightNox_Final
         759             :     USE HCOX_SoilNox_Mod,       ONLY : HCOX_SoilNox_Final
         760             :     USE HCOX_DustDead_Mod,      ONLY : HCOX_DustDead_Final
         761             :     USE HCOX_DustGinoux_Mod,    ONLY : HCOX_DustGinoux_Final
         762             :     USE HCOX_SeaSalt_Mod,       ONLY : HCOX_SeaSalt_Final
         763             :     USE HCOX_MEGAN_Mod,         ONLY : HCOX_MEGAN_Final
         764             :     USE HCOX_GFED_Mod,          ONLY : HCOX_GFED_Final
         765             :     USE HCOX_FINN_Mod,          ONLY : HCOX_FINN_Final
         766             :     USE HCOX_GC_RnPbBe_Mod,     ONLY : HCOX_GC_RnPbBe_Final
         767             :     USE HCOX_GC_POPs_Mod,       ONLY : HCOX_GC_POPs_Final
         768             :     USE HCOX_Volcano_Mod,       ONLY : HCOX_Volcano_Final
         769             :     USE HCOX_Iodine_Mod,        ONLY : HCOX_Iodine_Final
         770             : #if defined( TOMAS )
         771             :     USE HCOX_TOMAS_Jeagle_Mod,   ONLY : HCOX_TOMAS_Jeagle_Final
         772             :     USE HCOX_TOMAS_DustDead_Mod, ONLY : HCOX_TOMAS_DustDead_Final
         773             : #endif
         774             : !
         775             : ! !INPUT/OUTPUT PARAMETERS:
         776             : !
         777             :     TYPE(HCO_State),  POINTER        :: HcoState   ! HEMCO state object
         778             :     TYPE(Ext_State),  POINTER        :: ExtState   ! Extension options object
         779             :     INTEGER,          INTENT(INOUT)  :: RC         ! Failure or success
         780             : !
         781             : ! !REVISION HISTORY:
         782             : !  12 Sep 2013 - C. Keller   - Initial version
         783             : !  See https://github.com/geoschem/hemco for complete history
         784             : !EOP
         785             : !------------------------------------------------------------------------------
         786             : !BOC
         787             : !
         788             : ! !LOCAL VARIABLES:
         789             : !
         790             :
         791             :     !=======================================================================
         792             :     ! HCOX_FINAL begins here!
         793             :     !=======================================================================
         794             :
         795           0 :     IF ( ASSOCIATED( ExtState ) ) THEN
         796             :
         797             :        ! Nullify all ExtState object pointers
         798           0 :        CALL ExtStateFinal( ExtState )
         799             :
         800             :        !--------------------------------------------------------------------
         801             :        ! NOTE: For the GEOS-Chem dry-run or the HEMCO-standalone dry-run,
         802             :        ! we don't actually allocate any memory to the extensions.  We only
         803             :        ! print out the file paths of data files that are read independently
         804             :        ! of the HCOIO_READ_* routines.  Therefore, we can skip finalizing
         805             :        ! these extensions when performing a dry-run.
         806             :        !--------------------------------------------------------------------
         807           0 :        IF ( .not. HcoState%Options%IsDryRun ) THEN
         808             :
         809             :           ! Call individual cleanup routines
         810           0 :           IF ( ExtState%Custom  > 0 ) THEN
         811           0 :              CALL HCOX_Custom_Final ( ExtState )
         812             :           ENDIF
         813             :
         814           0 :           IF ( ExtState%SeaFlux > 0 ) THEN
         815           0 :              CALL HCOX_SeaFlux_Final( ExtState )
         816             :           ENDIF
         817             :
         818           0 :           IF ( ExtState%ParaNOx > 0   ) THEN
         819           0 :              CALL HCOX_PARANOX_Final( HcoState, ExtState, RC )
         820             :           ENDIF
         821             :
         822           0 :           IF ( ExtState%LightNOx > 0  ) THEN
         823           0 :              CALL HCOX_LIGHTNOX_Final( ExtState )
         824             :           ENDIF
         825             :
         826           0 :           IF ( ExtState%DustDead > 0 ) THEN
         827           0 :              CALL HCOX_DustDead_Final( ExtState )
         828             :           ENDIF
         829             :
         830             : #ifdef TOMAS
         831             :           IF ( ExtState%TOMAS_DustDead > 0 ) THEN
         832             :              CALL HCOX_TOMAS_DustDead_Final( ExtState )
         833             :           ENDIF
         834             :
         835             :           IF ( ExtState%TOMAS_Jeagle > 0  ) THEN
         836             :              CALL HCOX_TOMAS_Jeagle_Final( ExtState )
         837             :           ENDIF
         838             : #endif
         839           0 :           IF ( ExtState%DustGinoux > 0 ) THEN
         840           0 :              CALL HCOX_DustGinoux_Final( ExtState )
         841             :           ENDIF
         842             :
         843           0 :           IF ( ExtState%SeaSalt > 0  ) THEN
         844           0 :              CALL HCOX_SeaSalt_Final( ExtState )
         845             :           ENDIF
         846             :
         847           0 :           IF ( ExtState%Megan > 0 ) THEN
         848           0 :              CALL HCOX_Megan_Final( HcoState, ExtState, RC)
         849             :           ENDIF
         850             :
         851           0 :           IF ( ExtState%GFED > 0 ) THEN
         852           0 :              CALL HCOX_GFED_Final( ExtState )
         853             :           ENDIF
         854             :
         855           0 :           IF ( ExtState%SoilNOx > 0 ) THEN
         856           0 :              CALL HCOX_SoilNox_Final( HcoState, ExtState, RC )
         857             :           ENDIF
         858             :
         859           0 :           IF ( ExtState%FINN > 0      ) THEN
         860           0 :              CALL HcoX_FINN_Final( ExtState )
         861             :           ENDIF
         862             :
         863           0 :           IF ( ExtState%GC_RnPbBe > 0 ) THEN
         864           0 :              CALL HCOX_GC_RnPbBe_Final( ExtState )
         865             :           ENDIF
         866             :
         867           0 :           IF ( ExtState%GC_POPs > 0  ) THEN
         868           0 :              CALL HCOX_GC_POPs_Final( ExtState )
         869             :           ENDIF
         870             :
         871           0 :           IF ( ExtState%Volcano > 0 ) THEN
         872           0 :              CALL HCOX_Volcano_Final( ExtState )
         873             :           ENDIF
         874             :
         875           0 :           IF ( ExtState%Inorg_Iodine > 0 ) THEN
         876           0 :              CALL HCOX_Iodine_Final( ExtState )
         877             :           ENDIF
         878             :
         879             :        ENDIF
         880             :
         881             :        ! Deallocate ExtState object
         882           0 :        DEALLOCATE( ExtState )
         883             :        ExtState => NULL()
         884             :     ENDIF
         885             :
         886             :     ! Eventually deallocate diagnostics array
         887           0 :     IF ( ALLOCATED( DGN_LAI      ) ) DEALLOCATE( DGN_LAI      )
         888             : !    IF ( ALLOCATED( DGN_T2M      ) ) DEALLOCATE( DGN_T2M      )
         889             : !    IF ( ALLOCATED( DGN_GWET     ) ) DEALLOCATE( DGN_GWET     )
         890             : !    IF ( ALLOCATED( DGN_U10M     ) ) DEALLOCATE( DGN_U10M     )
         891             : !    IF ( ALLOCATED( DGN_V10M     ) ) DEALLOCATE( DGN_V10M     )
         892             : !    IF ( ALLOCATED( DGN_PARDR    ) ) DEALLOCATE( DGN_PARDR    )
         893             : !    IF ( ALLOCATED( DGN_PARDF    ) ) DEALLOCATE( DGN_PARDF    )
         894             : !    IF ( ALLOCATED( DGN_SZAFACT  ) ) DEALLOCATE( DGN_SZAFACT  )
         895             : !    IF ( ALLOCATED( DGN_CLDFRC   ) ) DEALLOCATE( DGN_CLDFRC   )
         896             : !    IF ( ALLOCATED( DGN_ALBD     ) ) DEALLOCATE( DGN_ALBD     )
         897             : !    IF ( ALLOCATED( DGN_WLI      ) ) DEALLOCATE( DGN_WLI      )
         898             : !    IF ( ALLOCATED( DGN_TROPP    ) ) DEALLOCATE( DGN_TROPP    )
         899           0 :     IF ( ALLOCATED( DGN_SUNCOS   ) ) DEALLOCATE( DGN_SUNCOS   )
         900           0 :     IF ( ALLOCATED( DGN_DRYTOTN  ) ) DEALLOCATE( DGN_DRYTOTN  )
         901           0 :     IF ( ALLOCATED( DGN_WETTOTN  ) ) DEALLOCATE( DGN_WETTOTN  )
         902             :
         903             :     ! Return w/ success
         904           0 :     RC = HCO_SUCCESS
         905             :
         906           0 :   END SUBROUTINE HCOX_Final
         907             : !EOC
         908             : !------------------------------------------------------------------------------
         909             : !                   Harmonized Emissions Component (HEMCO)                    !
         910             : !------------------------------------------------------------------------------
         911             : !BOP
         912             : !
         913             : ! !IROUTINE: HCOX_DiagnDefine
         914             : !
         915             : ! !DESCRIPTION: Subroutine HCOX\_DiagnDefine creates custom-defined diagnostics.
         916             : !  This is very preliminary and for testing only.
         917             : !\\
         918             : !\\
         919             : ! !INTERFACE:
         920             : !
         921           0 :   SUBROUTINE HCOX_DiagnDefine( HcoState, ExtState, RC )
         922             : !
         923             : ! !INPUT/OUTPUT PARAMETERS:
         924             : !
         925             :     TYPE(HCO_State),  POINTER        :: HcoState   ! HEMCO state object
         926             :     TYPE(Ext_State),  POINTER        :: ExtState   ! Extension options object
         927             :     INTEGER,          INTENT(INOUT)  :: RC         ! Failure or success
         928             : !
         929             : ! !REVISION HISTORY:
         930             : !  19 Feb 2015 - C. Keller   - Initial version
         931             : !  See https://github.com/geoschem/hemco for complete history
         932             : !EOP
         933             : !------------------------------------------------------------------------------
         934             : !
         935             : ! !LOCAL VARIABLES:
         936             : !
         937             :     INTEGER            :: I,  J, AS
         938             :     INTEGER            :: ExtNr, II
         939             :     CHARACTER(LEN=255) :: LOC = 'HCOX_DiagnDefine (hcox_driver_mod.F90)'
         940             :
         941             :     !=======================================================================
         942             :     ! HCOX_DiagnDefine begins here!
         943             :     !=======================================================================
         944             :
         945           0 :     I = HcoState%NX
         946           0 :     J = HcoState%NY
         947           0 :     ExtNr = -1
         948             :
         949             :     IF ( DoDiagn ) THEN
         950             :
         951             :        ALLOCATE( DGN_LAI(I,J), STAT=AS )
         952             :        IF ( AS /= 0 ) THEN
         953             :           CALL HCO_ERROR( 'Diagnostics allocation error 1', RC, THISLOC=LOC )
         954             :           RETURN
         955             :        ENDIF
         956             : !       ALLOCATE( DGN_GWET(I,J), STAT=AS )
         957             : !       IF ( AS /= 0 ) THEN
         958             : !          CALL HCO_ERROR( 'Diagnostics allocation error 1', RC, THISLOC=LOC )
         959             : !          RETURN
         960             : !       ENDIF
         961             : !       ALLOCATE( DGN_T2M(I,J), DGN_V10M(I,J), DGN_U10M(I,J), STAT=AS )
         962             : !       IF ( AS /= 0 ) THEN
         963             : !          CALL HCO_ERROR( 'Diagnostics allocation error 2', RC, THISLOC=LOC )
         964             : !          RETURN
         965             : !       ENDIF
         966             : !       ALLOCATE( DGN_PARDR(I,J), DGN_PARDF(I,J), DGN_SZAFACT(I,J), STAT=AS )
         967             : !       IF ( AS /= 0 ) THEN
         968             : !          CALL HCO_ERROR( 'Diagnostics allocation error 3', RC, THISLOC=LOC )
         969             : !          RETURN
         970             : !       ENDIF
         971             : !       ALLOCATE( DGN_CLDFRC(I,J), DGN_ALBD(I,J), DGN_WLI(I,J), STAT=AS )
         972             : !       IF ( AS /= 0 ) THEN
         973             : !          CALL HCO_ERROR( 'Diagnostics allocation error 4', RC, THISLOC=LOC )
         974             : !          RETURN
         975             : !       ENDIF
         976             : !       ALLOCATE( DGN_TROPP(I,J), STAT=AS )
         977             : !       IF ( AS /= 0 ) THEN
         978             : !          CALL HCO_ERROR( 'Diagnostics allocation error 5', RC, THISLOC=LOC )
         979             : !          RETURN
         980             : !       ENDIF
         981             :
         982             :        ALLOCATE( DGN_SUNCOS(I,J), DGN_DRYTOTN(I,J), DGN_WETTOTN(I,J), STAT=AS )
         983             :        IF ( AS /= 0 ) THEN
         984             :           CALL HCO_ERROR( 'Diagnostics allocation error 6', RC, THISLOC=LOC )
         985             :           RETURN
         986             :        ENDIF
         987             :
         988             :        DGN_LAI     = 0.0_sp
         989             : !       DGN_T2M     = 0.0_sp
         990             : !       DGN_GWET    = 0.0_sp
         991             : !       DGN_V10M    = 0.0_sp
         992             : !       DGN_U10M    = 0.0_sp
         993             : !       DGN_PARDR   = 0.0_sp
         994             : !       DGN_PARDF   = 0.0_sp
         995             : !       DGN_SZAFACT = 0.0_sp
         996             : !       DGN_CLDFRC  = 0.0_sp
         997             : !       DGN_ALBD    = 0.0_sp
         998             : !       DGN_WLI     = 0.0_sp
         999             : !       DGN_TROPP   = 0.0_sp
        1000             :        DGN_SUNCOS  = 0.0_sp
        1001             :        DGN_DRYTOTN = 0.0_sp
        1002             :        DGN_WETTOTN = 0.0_sp
        1003             :
        1004             : !       CALL DgnDefine ( HcoState, 'HCO_T2M', DGN_T2M, RC )
        1005             : !       IF ( RC /= HCO_SUCCESS ) RETURN
        1006             : !
        1007             : !       CALL DgnDefine ( HcoState, 'HCO_GWET', DGN_GWET, RC )
        1008             : !       IF ( RC /= HCO_SUCCESS ) RETURN
        1009             : !
        1010             :        CALL DgnDefine ( HcoState, 'HCO_LAI', DGN_LAI, RC )
        1011             :        IF ( RC /= HCO_SUCCESS ) THEN
        1012             :            CALL HCO_ERROR( 'ERROR 3', RC, THISLOC=LOC )
        1013             :            RETURN
        1014             :        ENDIF
        1015             :
        1016             : !       CALL DgnDefine ( HcoState, 'HCO_U10M', DGN_U10M, RC )
        1017             : !       IF ( RC /= HCO_SUCCESS ) RETURN
        1018             : !
        1019             : !       CALL DgnDefine ( HcoState, 'HCO_V10M', DGN_V10M, RC )
        1020             : !       IF ( RC /= HCO_SUCCESS ) RETURN
        1021             : !
        1022             : !       CALL DgnDefine ( HcoState, 'HCO_PARDR', DGN_PARDR, RC )
        1023             : !       IF ( RC /= HCO_SUCCESS ) RETURN
        1024             : !
        1025             : !       CALL DgnDefine ( HcoState, 'HCO_PARDF', DGN_PARDF, RC )
        1026             : !       IF ( RC /= HCO_SUCCESS ) RETURN
        1027             : !
        1028             : !       CALL DgnDefine ( HcoState, 'HCO_SZAFACT', DGN_SZAFACT, RC )
        1029             : !       IF ( RC /= HCO_SUCCESS ) RETURN
        1030             : !
        1031             : !       CALL DgnDefine ( HcoState, 'HCO_CLDFRC', DGN_CLDFRC, RC )
        1032             : !       IF ( RC /= HCO_SUCCESS ) RETURN
        1033             : !
        1034             : !       CALL DgnDefine ( HcoState, 'HCO_ALBD', DGN_ALBD, RC )
        1035             : !       IF ( RC /= HCO_SUCCESS ) RETURN
        1036             : !
        1037             : !       CALL DgnDefine ( HcoState, 'HCO_WLI', DGN_WLI, RC )
        1038             : !       IF ( RC /= HCO_SUCCESS ) RETURN
        1039             : !
        1040             : !       CALL DgnDefine ( HcoState, 'HCO_TROPP', DGN_TROPP, RC )
        1041             : !       IF ( RC /= HCO_SUCCESS ) RETURN
        1042             :
        1043             :        CALL DgnDefine ( HcoState, 'HCO_SUNCOS', DGN_SUNCOS, RC )
        1044             :        IF ( RC /= HCO_SUCCESS ) THEN
        1045             :            CALL HCO_ERROR( 'ERROR 4', RC, THISLOC=LOC )
        1046             :            RETURN
        1047             :        ENDIF
        1048             :
        1049             :        CALL DgnDefine ( HcoState, 'DRY_TOTN', DGN_DRYTOTN, RC )
        1050             :        IF ( RC /= HCO_SUCCESS ) THEN
        1051             :            CALL HCO_ERROR( 'ERROR 5', RC, THISLOC=LOC )
        1052             :            RETURN
        1053             :        ENDIF
        1054             :
        1055             :        CALL DgnDefine ( HcoState, 'WET_TOTN', DGN_WETTOTN, RC )
        1056             :        IF ( RC /= HCO_SUCCESS ) THEN
        1057             :            CALL HCO_ERROR( 'ERROR 6', RC, THISLOC=LOC )
        1058             :            RETURN
        1059             :        ENDIF
        1060             :
        1061             :     ENDIF
        1062             :
        1063             :     ! Return w/ success
        1064           0 :     RC = HCO_SUCCESS
        1065             :
        1066             :   END SUBROUTINE HCOX_DiagnDefine
        1067             : !EOC
        1068             : !------------------------------------------------------------------------------
        1069             : !                   Harmonized Emissions Component (HEMCO)                    !
        1070             : !------------------------------------------------------------------------------
        1071             : !BOP
        1072             : !
        1073             : ! !IROUTINE: DgnDefine
        1074             : !
        1075             : ! !DESCRIPTION: Helper routine to define a target diagnostics.
        1076             : !\\
        1077             : !\\
        1078             : ! !INTERFACE:
        1079             : !
        1080             :   SUBROUTINE DgnDefine ( HcoState, DgnName, Trgt2D, RC )
        1081             : !
        1082             : ! !USES:
        1083             : !
        1084             :     USE HCO_DIAGN_MOD, ONLY : Diagn_Create
        1085             : !
        1086             : ! !INPUT/OUTPUT PARAMETERS:
        1087             : !
        1088             :     TYPE(HCO_State),  POINTER        :: HcoState   ! HEMCO state object
        1089             :     CHARACTER(LEN=*), INTENT(IN   )  :: DgnName      ! diagnostics name
        1090             :     REAL(sp),         INTENT(IN   )  :: Trgt2D(HcoState%NX,HcoState%NY)
        1091             :     INTEGER,          INTENT(INOUT)  :: RC         ! Failure or success
        1092             : !
        1093             : ! !REVISION HISTORY:
        1094             : !  19 Feb 2015 - C. Keller   - Initial version
        1095             : !  See https://github.com/geoschem/hemco for complete history
        1096             : !EOP
        1097             : !------------------------------------------------------------------------------
        1098             : !BOC
        1099             : !
        1100             : ! !LOCAL VARIABLES:
        1101             : !
        1102             :     CHARACTER(LEN=255)  :: LOC
        1103             :
        1104             :     LOC = 'DgnDefine (HCOX_DRIVER_MOD.F90)'
        1105             :
        1106             :     CALL Diagn_Create ( HcoState   = HcoState,          &
        1107             :                         cName      = TRIM(DgnName),     &
        1108             :                         ExtNr      = -1,                &
        1109             :                         Cat        = -1,                &
        1110             :                         Hier       = -1,                &
        1111             :                         HcoID      = -1,                &
        1112             :                         SpaceDim   = 2,                 &
        1113             :                         OutUnit    = '1',               &
        1114             :                         AutoFill   = 0,                 &
        1115             :                         Trgt2D     = Trgt2D,            &
        1116             :                         COL = HcoState%Diagn%HcoDiagnIDDefault, &
        1117             :                         RC         = RC                  )
        1118             :     IF ( RC /= HCO_SUCCESS ) THEN
        1119             :         CALL HCO_ERROR( 'ERROR 7', RC, THISLOC=LOC )
        1120             :         RETURN
        1121             :     ENDIF
        1122             :
        1123             :     ! Return w/ success
        1124             :     RC = HCO_SUCCESS
        1125             :
        1126             :   END SUBROUTINE DgnDefine
        1127             : !EOC
        1128             : !------------------------------------------------------------------------------
        1129             : !                   Harmonized Emissions Component (HEMCO)                    !
        1130             : !------------------------------------------------------------------------------
        1131             : !BOP
        1132             : !
        1133             : ! !IROUTINE: HCOX_DiagnFill
        1134             : !
        1135             : ! !DESCRIPTION: Subroutine HCOX\_DiagnFill fills custom-defined diagnostics.
        1136             : !\\
        1137             : !\\
        1138             : ! !INTERFACE:
        1139             : !
        1140           0 :   SUBROUTINE HCOX_DiagnFill( HcoState, ExtState, RC )
        1141             : !
        1142             : ! !INPUT/OUTPUT PARAMETERS:
        1143             : !
        1144             :     TYPE(HCO_State),  POINTER        :: HcoState   ! HEMCO state object
        1145             :     TYPE(Ext_State),  POINTER        :: ExtState   ! Extension options object
        1146             :     INTEGER,          INTENT(INOUT)  :: RC         ! Failure or success
        1147             : !
        1148             : ! !REVISION HISTORY:
        1149             : !  19 Feb 2015 - C. Keller   - Initial version
        1150             : !  See https://github.com/geoschem/hemco for complete history
        1151             : !EOP
        1152             : !------------------------------------------------------------------------------
        1153             :
        1154             :     IF ( DoDiagn ) THEN
        1155             :        DGN_LAI     = ExtState%LAI%Arr%Val
        1156             : !       DGN_T2M     = ExtState%T2M%Arr%Val
        1157             : !       DGN_GWET    = ExtState%GWETTOP%Arr%Val
        1158             : !       DGN_U10M    = ExtState%U10M%Arr%Val
        1159             : !       DGN_V10M    = ExtState%V10M%Arr%Val
        1160             : !       DGN_PARDR   = ExtState%PARDR%Arr%Val
        1161             : !       DGN_PARDF   = ExtState%PARDF%Arr%Val
        1162             : !       DGN_SZAFACT = ExtState%SZAFACT%Arr%Val
        1163             : !       DGN_CLDFRC  = ExtState%CLDFRC%Arr%Val
        1164             : !       DGN_ALBD    = ExtState%ALBD%Arr%Val
        1165             : !       DGN_WLI     = ExtState%WLI%Arr%Val
        1166             : !       DGN_TROPP   = ExtState%TROPP%Arr%Val
        1167             :        DGN_SUNCOS  = ExtState%SUNCOS%Arr%Val
        1168             :        DGN_DRYTOTN = ExtState%DRY_TOTN%Arr%Val
        1169             :        DGN_WETTOTN = ExtState%WET_TOTN%Arr%Val
        1170             :     ENDIF
        1171             :
        1172             :     ! Return w/ success
        1173           0 :     RC = HCO_SUCCESS
        1174             :
        1175           0 :   END SUBROUTINE HCOX_DiagnFill
        1176             : !EOC
        1177             : END MODULE HCOX_Driver_Mod

Generated by: LCOV version 1.14