LCOV - code coverage report
Current view: | top level - hemco/HEMCO/src/Core - hco_arr_mod.F90 (source / functions) |  |  | Hit | Total | Coverage
Test: | coverage.info |  | Lines: | 0 | 409 | 0.0 %
Date: | 2025-01-13 21:54:50 |  | Functions: | 0 | 38 | 0.0 %

              Line data    Source code
           1             : !------------------------------------------------------------------------------
           2             : !                   Harmonized Emissions Component (HEMCO)                    !
           3             : !------------------------------------------------------------------------------
           4             : !BOP
           5             : !
           6             : ! !MODULE: hco_arr_mod.F90
           7             : !
           8             : ! !DESCRIPTION: Module HCO\_Arr\_Mod contains routines and variables to
           9             : ! initialize, validate, and cleanup HEMCO data arrays. HEMCO data arrays
          10             : ! can be 2D or 3D. They can be organized as single arrays or as vector
          11             : ! of arrays to represent an additional dimension (time).
          12             : !\\
          13             : !\\
          14             : ! The public data types Arr2D\_Hp and Arr3D\_Hp represent the 2D/3D arrays
          15             : ! used by HEMCO. The HEMCO precision HP is defined in HCO\_Error\_Mod. There
          16             : ! is also an integer 2D array (type Arr2D\_I) that can be used to store
          17             : ! integer data. Additional data types can be added as needed.
          18             : !\\
          19             : !\\
          20             : ! Data values are stored in array 'Val'. Val can be self-allocated or a
          21             : ! pointer to existing data, as denoted by the Alloc flag.
          22             : !\\
          23             : !\\
          24             : ! At the moment, the following HEMCO structures use HEMCO arrays:
          25             : !\begin{itemize}
          26             : !\item FileData: emission data (base emissions, scale factors, masks) stored
          27             : !  in the FileData derived type. These data are read from disk as specified in
          28             : !  the configuration file. See HCO\_FileData\_Mod.F90.
          29             : !\item FluxArr: the HEMCO flux arrays (emissions and deposition velocities)
          30             : !  stored in the HEMCO state object. See HCO\_State\_Mod.F90.
          31             : !\item Grid: all grid information arrays (x midpoints, y midpoints, etc.)
          32             : !  stored in the HEMCO state object.
          33             : !\item ExtDat: external data required by the extensions (primarily met fields).
          34             : !  See HCOX\_State\_Mod.F90.
          35             : !\end{itemize}
          36             : ! !INTERFACE:
          37             : !
          38             : MODULE HCO_Arr_Mod
          39             : !
          40             : ! !USES:
          41             : !
          42             :   USE HCO_Error_Mod
          43             :
          44             :   IMPLICIT NONE
          45             :   PRIVATE
          46             : !
          47             : ! !PUBLIC MEMBER FUNCTIONS:
          48             : !
          49             :   PUBLIC  :: HCO_ArrInit
          50             :   PUBLIC  :: HCO_ArrAssert
          51             :   PUBLIC  :: HCO_ArrCleanup
          52             : !
          53             : ! !PRIVATE MEMBER FUNCTIONS:
          54             : !
          55             :   PRIVATE :: HCO_ArrInit_3D_Hp
          56             :   PRIVATE :: HCO_ArrInit_2D_Hp
          57             :   PRIVATE :: HCO_ArrInit_3D_Sp
          58             :   PRIVATE :: HCO_ArrInit_2D_Sp
          59             :   PRIVATE :: HCO_ArrInit_2D_I
          60             :   PRIVATE :: HCO_ArrVecInit_3D_Hp
          61             :   PRIVATE :: HCO_ArrVecInit_2D_Hp
          62             :   PRIVATE :: HCO_ArrVecInit_3D_Sp
          63             :   PRIVATE :: HCO_ArrVecInit_2D_Sp
          64             :   PRIVATE :: HCO_ValInit
          65             :   PRIVATE :: HCO_ValInit_3D_Sp
          66             :   PRIVATE :: HCO_ValInit_3D_Dp
          67             :   PRIVATE :: HCO_ValInit_2D_Sp
          68             :   PRIVATE :: HCO_ValInit_2D_Dp
          69             :   PRIVATE :: HCO_ValInit_2D_I
          70             :   PRIVATE :: HCO_ArrAssert_2D_Hp
          71             :   PRIVATE :: HCO_ArrAssert_3D_Hp
          72             :   PRIVATE :: HCO_ArrAssert_2D_Sp
          73             :   PRIVATE :: HCO_ArrAssert_3D_Sp
          74             :   PRIVATE :: HCO_ArrCleanup_3D_Hp
          75             :   PRIVATE :: HCO_ArrCleanup_2D_Hp
          76             :   PRIVATE :: HCO_ArrCleanup_3D_Sp
          77             :   PRIVATE :: HCO_ArrCleanup_2D_Sp
          78             :   PRIVATE :: HCO_ArrCleanup_2D_I
          79             :   PRIVATE :: HCO_ArrVecCleanup_3D_Hp
          80             :   PRIVATE :: HCO_ArrVecCleanup_2D_Hp
          81             :   PRIVATE :: HCO_ArrVecCleanup_3D_Sp
          82             :   PRIVATE :: HCO_ArrVecCleanup_2D_Sp
          83             :   PRIVATE :: HCO_ValCleanup_3D_Sp
          84             :   PRIVATE :: HCO_ValCleanup_3D_Dp
          85             :   PRIVATE :: HCO_ValCleanup_2D_Sp
          86             :   PRIVATE :: HCO_ValCleanup_2D_Dp
          87             :   PRIVATE :: HCO_ValCleanup_2D_I
          88             : !
          89             : ! !PUBLIC DATA MEMBERS:
          90             : !
          91             :   ! 2D arrays
          92             :   TYPE, PUBLIC :: Arr2D_Hp
          93             :      REAL(hp), POINTER :: Val(:,:)    ! x,y
          94             :      LOGICAL           :: Alloc       ! Allocated?
          95             :   END TYPE Arr2D_Hp
          96             :
          97             :   TYPE, PUBLIC :: Arr2D_I
          98             :      INTEGER,  POINTER :: Val(:,:)    ! x,y
          99             :      LOGICAL           :: Alloc       ! Allocated?
         100             :   END TYPE Arr2D_I
         101             :
         102             :   TYPE, PUBLIC :: Arr2D_Sp
         103             :      REAL(sp), POINTER :: Val(:,:)    ! x,y
         104             :      LOGICAL           :: Alloc       ! Allocated?
         105             :   END TYPE Arr2D_Sp
         106             :
         107             :   ! 3D arrays
         108             :   TYPE, PUBLIC :: Arr3D_Hp
         109             :      REAL(hp), POINTER :: Val(:,:,:)  ! x,y,z
         110             :      LOGICAL           :: Alloc       ! Allocated?
         111             :   END TYPE Arr3D_Hp
         112             :
         113             :   TYPE, PUBLIC :: Arr3D_Sp
         114             :      REAL(sp), POINTER :: Val(:,:,:)  ! x,y,z
         115             :      LOGICAL           :: Alloc       ! Allocated?
         116             :   END TYPE Arr3D_Sp
         117             : !
         118             : ! !PRIVATE TYPES:
         119             : !
         120             :   INTERFACE HCO_ArrInit
         121             :      MODULE PROCEDURE HCO_ArrInit_3D_Hp
         122             :      MODULE PROCEDURE HCO_ArrInit_2D_Hp
         123             :      MODULE PROCEDURE HCO_ArrInit_3D_Sp
         124             :      MODULE PROCEDURE HCO_ArrInit_2D_Sp
         125             :      MODULE PROCEDURE HCO_ArrInit_2D_I
         126             :      MODULE PROCEDURE HCO_ArrVecInit_3D_Hp
         127             :      MODULE PROCEDURE HCO_ArrVecInit_2D_Hp
         128             :      MODULE PROCEDURE HCO_ArrVecInit_3D_Sp
         129             :      MODULE PROCEDURE HCO_ArrVecInit_2D_Sp
         130             :   END INTERFACE HCO_ArrInit
         131             :
         132             :   INTERFACE HCO_ValInit
         133             :      MODULE PROCEDURE HCO_ValInit_3D_Sp
         134             :      MODULE PROCEDURE HCO_ValInit_3D_Dp
         135             :      MODULE PROCEDURE HCO_ValInit_2D_Sp
         136             :      MODULE PROCEDURE HCO_ValInit_2D_Dp
         137             :      MODULE PROCEDURE HCO_ValInit_2D_I
         138             :   END INTERFACE HCO_ValInit
         139             :
         140             :   INTERFACE HCO_ArrAssert
         141             :      MODULE PROCEDURE HCO_ArrAssert_2D_Hp
         142             :      MODULE PROCEDURE HCO_ArrAssert_3D_Hp
         143             :      MODULE PROCEDURE HCO_ArrAssert_2D_Sp
         144             :      MODULE PROCEDURE HCO_ArrAssert_3D_Sp
         145             :      MODULE PROCEDURE HCO_ArrAssert_2D_I
         146             :   END INTERFACE HCO_ArrAssert
         147             :
         148             :   INTERFACE HCO_ArrCleanup
         149             :      MODULE PROCEDURE HCO_ArrCleanup_3D_Hp
         150             :      MODULE PROCEDURE HCO_ArrCleanup_2D_Hp
         151             :      MODULE PROCEDURE HCO_ArrCleanup_2D_I
         152             :      MODULE PROCEDURE HCO_ArrCleanup_3D_Sp
         153             :      MODULE PROCEDURE HCO_ArrCleanup_2D_Sp
         154             :      MODULE PROCEDURE HCO_ArrVecCleanup_3D_Hp
         155             :      MODULE PROCEDURE HCO_ArrVecCleanup_2D_Hp
         156             :      MODULE PROCEDURE HCO_ArrVecCleanup_3D_Sp
         157             :      MODULE PROCEDURE HCO_ArrVecCleanup_2D_Sp
         158             :   END INTERFACE HCO_ArrCleanup
         159             :
         160             :   INTERFACE HCO_ValCleanup
         161             :      MODULE PROCEDURE HCO_ValCleanup_3D_Sp
         162             :      MODULE PROCEDURE HCO_ValCleanup_3D_Dp
         163             :      MODULE PROCEDURE HCO_ValCleanup_2D_Sp
         164             :      MODULE PROCEDURE HCO_ValCleanup_2D_Dp
         165             :      MODULE PROCEDURE HCO_ValCleanup_2D_I
         166             :   END INTERFACE HCO_ValCleanup
         167             : !
         168             : ! !REVISION HISTORY:
         169             : !  19 Dec 2013 - C. Keller   - Initialization
         170             : !  See https://github.com/geoschem/hemco for complete history
         171             : !EOP
         172             : !------------------------------------------------------------------------------
         173             : !BOC
         174             : CONTAINS
         175             : !EOC
         176             : !------------------------------------------------------------------------------
         177             : !                   Harmonized Emissions Component (HEMCO)                    !
         178             : !------------------------------------------------------------------------------
         179             : !BOP
         180             : !
         181             : ! !IROUTINE: HCO_ArrInit_2D_Hp
         182             : !
         183             : ! !DESCRIPTION: Subroutine HCO\_ArrInit\_2D\_Hp initializes the given data
         184             : ! container 2D array. nx and ny denote the array size dimensions. If nx is
         185             : ! set to 0, no data is allocated but Val is set to a (nullified) pointer
         186             : ! instead.
         187             : !\\
         188             : !\\
         189             : ! !INTERFACE:
         190             : !
         191           0 :   SUBROUTINE HCO_ArrInit_2D_Hp( Arr, nx, ny, RC )
         192             : !
         193             : ! !INPUT PARAMETERS:
         194             : !
         195             :     INTEGER,        INTENT(IN)  :: nx        ! x-dim
         196             :     INTEGER,        INTENT(IN)  :: ny        ! y-dim
         197             : !
         198             : ! INPUT/OUTPUT PARAMETERS:
         199             : !
         200             :     TYPE(Arr2D_Hp), POINTER     :: Arr       ! Array
         201             : !
         202             : ! !OUTPUT PARAMETERS:
         203             : !
         204             :     INTEGER,        INTENT(OUT) :: RC        ! Success or failure?
         205             : !
         206             : ! !REVISION HISTORY:
         207             : !  20 Apr 2013 - C. Keller - Initial version
         208             : !  See https://github.com/geoschem/hemco for complete history
         209             : !EOP
         210             : !------------------------------------------------------------------------------
         211             : !BOC
         212             : !
         213             : ! !LOCAL VARIABLES:
         214             : !
         215             :     ! Strings
         216             :     CHARACTER(LEN=255)  :: errMsg, thisLoc
         217             :
         218             :     ! ================================================================
         219             :     ! HCO_ArrInit_2D_Hp begins here
         220             :     ! ================================================================
         221             :
         222             :     ! Initialize
         223           0 :     RC      = HCO_SUCCESS
         224           0 :     errMsg  = ''
         225           0 :     thisLoc = 'HCO_ArrInit_2D_Hp (HCO_ARR_MOD.F90)'
         226             :
         227             :     ! NOTE: This may cause a memory leak
         228           0 :     Arr => NULL()
         229             :
         230             :     ! Initialize the Arr object
         231             :     !IF ( .not. ASSOCIATED( Arr ) ) THEN
         232           0 :        ALLOCATE( Arr, STAT=RC )
         233           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         234           0 :           errMsg = 'Could not allocate the "Arr" object!'
         235           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
         236           0 :           RETURN
         237             :        ENDIF
         238           0 :        Arr%Val   => NULL()
         239           0 :        Arr%Alloc = .FALSE.
         240             :     !ENDIF
         241             :
         242             :     ! Initialize the Arr%Val array
         243           0 :     CALL HCO_ValInit( Arr%Val, nx, ny, Arr%Alloc, RC )
         244           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         245           0 :        errMsg = 'Could not allocate the "Arr%Val" array!'
         246           0 :        CALL HCO_ERROR( errMsg, RC, thisLoc )
         247           0 :        RETURN
         248             :     ENDIF
         249             :
         250             :   END SUBROUTINE HCO_ArrInit_2D_Hp
         251             : !EOC
         252             : !------------------------------------------------------------------------------
         253             : !                   Harmonized Emissions Component (HEMCO)                    !
         254             : !------------------------------------------------------------------------------
         255             : !BOP
         256             : !
         257             : ! !IROUTINE: HCO_ArrInit_2D_Sp
         258             : !
         259             : ! !DESCRIPTION: Subroutine HCO\_ArrInit\_2D\_Sp initializes the given data
         260             : ! container 2D array. nx and ny denote the array size dimensions. If nx is
         261             : ! set to 0, no data is allocated but Val is set to a (nullified) pointer
         262             : ! instead.
         263             : !\\
         264             : !\\
         265             : ! !INTERFACE:
         266             : !
         267           0 :   SUBROUTINE HCO_ArrInit_2D_Sp( Arr, nx, ny, RC )
         268             : !
         269             : ! !INPUT PARAMETERS:
         270             : !
         271             :     INTEGER,        INTENT(IN)  :: nx        ! x-dim
         272             :     INTEGER,        INTENT(IN)  :: ny        ! y-dim
         273             : !
         274             : ! INPUT/OUTPUT PARAMETERS:
         275             : !
         276             :     TYPE(Arr2D_Sp), POINTER     :: Arr       ! Array
         277             : !
         278             : ! !OUTPUT PARAMETERS:
         279             : !
         280             :     INTEGER,        INTENT(OUT) :: RC        ! Success or failure?
         281             : !
         282             : ! !REVISION HISTORY:
         283             : !  20 Apr 2013 - C. Keller - Initial version
         284             : !  See https://github.com/geoschem/hemco for complete history
         285             : !EOP
         286             : !------------------------------------------------------------------------------
         287             : !BOC
         288             : !
         289             : ! !LOCAL VARIABLES:
         290             : !
         291             :     ! Strings
         292             :     CHARACTER(LEN=255)  :: errMsg, thisLoc
         293             :
         294             :     ! ================================================================
         295             :     ! HCO_ArrInit_2D_Sp begins here
         296             :     ! ================================================================
         297             :
         298             :     ! Initialize
         299           0 :     RC      = HCO_SUCCESS
         300           0 :     errMsg  = ''
         301           0 :     thisLoc = 'HCO_ArrInit_2D_Sp (HCO_ARR_MOD.F90)'
         302             :
         303             :     ! NOTE: This may cause a memory leak
         304           0 :     Arr => NULL()
         305             :
         306             :     ! Initialize the Arr object
         307             :     !IF ( .not. ASSOCIATED( Arr ) ) THEN
         308           0 :        ALLOCATE( Arr, STAT=RC )
         309           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         310           0 :           errMsg = 'Could not allocate the "Arr" object!'
         311           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
         312           0 :           RETURN
         313             :        ENDIF
         314           0 :        Arr%Val   => NULL()
         315           0 :        Arr%Alloc = .FALSE.
         316             :     !ENDIF
         317             :
         318             :     ! Initialize the Arr%Val array
         319           0 :     CALL HCO_ValInit( Arr%Val, nx, ny, Arr%Alloc, RC )
         320           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         321           0 :        errMsg = 'Could not allocate the "Arr%Val" array!'
         322           0 :        CALL HCO_ERROR( errMsg, RC, thisLoc )
         323           0 :        RETURN
         324             :     ENDIF
         325             :
         326             :   END SUBROUTINE HCO_ArrInit_2D_Sp
         327             : !EOC
         328             : !------------------------------------------------------------------------------
         329             : !                   Harmonized Emissions Component (HEMCO)                    !
         330             : !------------------------------------------------------------------------------
         331             : !BOP
         332             : !
         333             : ! !IROUTINE: HCO_ArrInit_2D_I
         334             : !
         335             : ! !DESCRIPTION: Subroutine HCO\_ArrInit\_2D\_I initializes the given data
         336             : ! container integer 2D array. nx and ny denote the array size dimensions.
         337             : ! If nx is set to 0, no data is allocated but Val is set to a (nullified)
         338             : ! pointer instead.
         339             : !\\
         340             : !\\
         341             : ! !INTERFACE:
         342             : !
         343           0 :   SUBROUTINE HCO_ArrInit_2D_I( Arr, nx, ny, RC )
         344             : !
         345             : ! !INPUT PARAMETERS:
         346             : !
         347             :     INTEGER,        INTENT(IN)  :: nx        ! x-dim
         348             :     INTEGER,        INTENT(IN)  :: ny        ! y-dim
         349             : !
         350             : ! INPUT/OUTPUT PARAMETERS:
         351             : !
         352             :     TYPE(Arr2D_I), POINTER      :: Arr       ! Array
         353             : !
         354             : ! !OUTPUT PARAMETERS:
         355             : !
         356             :     INTEGER,        INTENT(OUT) :: RC        ! Success or failure?
         357             : !
         358             : ! !REVISION HISTORY:
         359             : !  20 Apr 2013 - C. Keller - Initial version
         360             : !  See https://github.com/geoschem/hemco for complete history
         361             : !EOP
         362             : !------------------------------------------------------------------------------
         363             : !BOC
         364             : !
         365             : ! !LOCAL VARIABLES:
         366             : !
         367             :     ! Strings
         368             :     CHARACTER(LEN=255)  :: errMsg, thisLoc
         369             :
         370             :     ! ================================================================
         371             :     ! HCO_ArrInit_2D_I begins here
         372             :     ! ================================================================
         373             :
         374             :     ! Initialize
         375           0 :     RC      = HCO_SUCCESS
         376           0 :     errMsg  = ''
         377           0 :     thisLoc = 'HCO_ArrInit_2D_I (hco_arr_mod.F90)'
         378             :
         379             :     ! NOTE: This may cause a memory leak
         380           0 :     Arr => NULL()
         381             :
         382             :     ! Initialize the Arr object
         383             :     !IF ( .not. ASSOCIATED( Arr ) ) THEN
         384           0 :        ALLOCATE( Arr, STAT=RC )
         385           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         386           0 :           errMsg = 'Could not allocate the "Arr" object!'
         387           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
         388           0 :           RETURN
         389             :        ENDIF
         390           0 :        Arr%Val   => NULL()
         391           0 :        Arr%Alloc = .FALSE.
         392             :     !ENDIF
         393             :
         394             :     ! Initialize the Arr%Val array
         395           0 :     CALL HCO_ValInit( Arr%Val, nx, ny, Arr%Alloc, RC )
         396           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         397           0 :        errMsg = 'Could not allocate the "Arr%Val" array!'
         398           0 :        CALL HCO_ERROR( errMsg, RC, thisLoc )
         399           0 :        RETURN
         400             :     ENDIF
         401             :
         402             :   END SUBROUTINE HCO_ArrInit_2D_I
         403             : !EOC
         404             : !------------------------------------------------------------------------------
         405             : !                   Harmonized Emissions Component (HEMCO)                    !
         406             : !------------------------------------------------------------------------------
         407             : !BOP
         408             : !
         409             : ! !IROUTINE: HCO_ArrInit_3D_Hp
         410             : !
         411             : ! !DESCRIPTION: Subroutine HCO\_ArrInit\_3D\_Hp initializes the given data
         412             : ! container 3D array. nx and ny denote the array size dimensions. If nx is
         413             : ! set to 0, no data is allocated but Val is set to a (nullified) pointer
         414             : ! instead.
         415             : !\\
         416             : !\\
         417             : ! !INTERFACE:
         418             : !
         419           0 :   SUBROUTINE HCO_ArrInit_3D_Hp( Arr, nx, ny, nz, RC )
         420             : !
         421             : ! !INPUT PARAMETERS:
         422             : !
         423             :     INTEGER,        INTENT(IN)  :: nx        ! x-dim
         424             :     INTEGER,        INTENT(IN)  :: ny        ! y-dim
         425             :     INTEGER,        INTENT(IN)  :: nz        ! z-dim
         426             : !
         427             : ! INPUT/OUTPUT PARAMETERS:
         428             : !
         429             :     TYPE(Arr3D_Hp), POINTER     :: Arr       ! Array
         430             : !
         431             : ! !OUTPUT PARAMETERS:
         432             : !
         433             :     INTEGER,        INTENT(OUT) :: RC        ! Success or failure?
         434             : !
         435             : ! !REVISION HISTORY:
         436             : !  20 Apr 2013 - C. Keller - Initial version
         437             : !  See https://github.com/geoschem/hemco for complete history
         438             : !EOP
         439             : !------------------------------------------------------------------------------
         440             : !BOC
         441             : !
         442             : ! !LOCAL VARIABLES:
         443             : !
         444             :     CHARACTER(LEN=255)  :: errMsg, thisLoc
         445             :
         446             :     ! ================================================================
         447             :     ! HCO_ArrInit_3D_Hp begins here
         448             :     ! ================================================================
         449             :
         450             :     ! Initialize
         451           0 :     RC      = HCO_SUCCESS
         452           0 :     errMsg  = ''
         453           0 :     thisLoc = 'HCO_ArrInit_3D_Hp (hco_arr_mod.F90)'
         454             :
         455             :     ! NOTE: This may cause a memory leak
         456           0 :     Arr => NULL()
         457             :
         458             :     ! Initialize the Arr object
         459             :     !IF ( .not. ASSOCIATED( Arr ) ) THEN
         460           0 :        ALLOCATE( Arr, STAT=RC )
         461           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         462           0 :           errMsg = 'Could not allocate the Arr object!'
         463           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
         464           0 :           RETURN
         465             :        ENDIF
         466           0 :        Arr%Val   => NULL()
         467           0 :        Arr%Alloc = .FALSE.
         468             :     !ENDIF
         469             :
         470             :     ! Initialize the Arr%Val array
         471           0 :     CALL HCO_ValInit( Arr%Val, nx, ny, nz, Arr%Alloc, RC )
         472           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         473           0 :        errMsg = 'Could not allocate the "Arr%Val" array!'
         474           0 :        CALL HCO_Error( errMsg, RC, thisLoc )
         475           0 :        RETURN
         476             :     ENDIF
         477             :
         478             :   END SUBROUTINE HCO_ArrInit_3D_Hp
         479             : !EOC
         480             : !------------------------------------------------------------------------------
         481             : !                   Harmonized Emissions Component (HEMCO)                    !
         482             : !------------------------------------------------------------------------------
         483             : !BOP
         484             : !
         485             : ! !IROUTINE: HCO_ArrInit_3D_Sp
         486             : !
         487             : ! !DESCRIPTION: Subroutine HCO\_ArrInit\_3D\_Sp initializes the given data
         488             : ! container 3D array. nx and ny denote the array size dimensions. If nx is
         489             : ! set to 0, no data is allocated but Val is set to a (nullified) pointer
         490             : ! instead.
         491             : !\\
         492             : !\\
         493             : ! !INTERFACE:
         494             : !
         495           0 :   SUBROUTINE HCO_ArrInit_3D_Sp( Arr, nx, ny, nz, RC )
         496             : !
         497             : ! !INPUT PARAMETERS:
         498             : !
         499             :     INTEGER,        INTENT(IN)  :: nx        ! x-dim
         500             :     INTEGER,        INTENT(IN)  :: ny        ! y-dim
         501             :     INTEGER,        INTENT(IN)  :: nz        ! z-dim
         502             : !
         503             : ! INPUT/OUTPUT PARAMETERS:
         504             : !
         505             :     TYPE(Arr3D_Sp), POINTER     :: Arr       ! Array
         506             : !
         507             : ! !OUTPUT PARAMETERS:
         508             : !
         509             :     INTEGER,        INTENT(OUT) :: RC        ! Success or failure?
         510             : !
         511             : ! !REVISION HISTORY:
         512             : !  20 Apr 2013 - C. Keller - Initial version
         513             : !  See https://github.com/geoschem/hemco for complete history
         514             : !EOP
         515             : !------------------------------------------------------------------------------
         516             : !BOC
         517             : !
         518             : ! !LOCAL VARIABLES:
         519             : !
         520             :     ! Scalars
         521             :     INTEGER            :: I
         522             :
         523             :     ! Strings
         524             :     CHARACTER(LEN=255) :: errMsg, thisLoc
         525             :
         526             :     ! ================================================================
         527             :     ! HCO_ArrInit_3D_Sp begins here
         528             :     ! ================================================================
         529             :
         530             :     ! Initialize
         531           0 :     RC      = HCO_SUCCESS
         532           0 :     errMsg  = ''
         533           0 :     thisLoc = 'HCO_ArrInit_3D_Sp (hco_arr_mod.F90)'
         534             :
         535             :     ! NOTE: This may cause a memory leak
         536           0 :     Arr => NULL()
         537             :
         538             :     ! Initialize the Arr object
         539             :     !IF ( .not. ASSOCIATED( Arr ) ) THEN
         540           0 :        ALLOCATE( Arr, STAT=RC )
         541           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         542           0 :           errMsg = 'Could not allocate the Arr object!'
         543           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
         544           0 :           RETURN
         545             :        ENDIF
         546           0 :        Arr%Val   => NULL()
         547           0 :        Arr%Alloc = .FALSE.
         548             :     !ENDIF
         549             :
         550             :     ! Initialize the Arr%Val array
         551           0 :     CALL HCO_ValInit( Arr%Val, nx, ny, nz, Arr%Alloc, RC )
         552           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         553           0 :        errMsg = 'Could not allocate the "Arr%Val" array!'
         554           0 :        CALL HCO_Error( errMsg, RC, thisLoc )
         555           0 :        RETURN
         556             :     ENDIF
         557             :
         558             :   END SUBROUTINE HCO_ArrInit_3D_Sp
         559             : !EOC
         560             : !------------------------------------------------------------------------------
         561             : !                   Harmonized Emissions Component (HEMCO)                    !
         562             : !------------------------------------------------------------------------------
         563             : !BOP
         564             : !
         565             : ! !IROUTINE: HCO_ArrVecInit_2D_Hp
         566             : !
         567             : ! !DESCRIPTION: Subroutine HCO\_ArrVecInit\_2D\_Hp initializes the given data
         568             : ! container 2D array vector. nn denotes the number of 2D arrays, and nx and ny
         569             : ! denote the array size dimensions. If nx is set to 0, no data is allocated but
         570             : ! Val is set to a (nullified) pointer instead.
         571             : !\\
         572             : !\\
         573             : ! !INTERFACE:
         574             : !
         575           0 :   SUBROUTINE HCO_ArrVecInit_2D_Hp( ArrVec, nn, nx, ny, RC )
         576             : !
         577             : ! !INPUT PARAMETERS:
         578             : !
         579             :     INTEGER,          INTENT(IN)  :: nn           ! vector length
         580             :     INTEGER,          INTENT(IN)  :: nx           ! x-dim
         581             :     INTEGER,          INTENT(IN)  :: ny           ! y-dim
         582             : !
         583             : ! !INPUT/OUTPUT PARAMETERS:
         584             : !
         585             :     TYPE(Arr2D_Hp),   POINTER     :: ArrVec(:)    ! Array vector
         586             : !
         587             : ! !INPUT/OUTPUT PARAMETERS:
         588             : !
         589             :     INTEGER,          INTENT(OUT) :: RC           ! Success or failure?
         590             : !
         591             : ! !REVISION HISTORY:
         592             : !  20 Apr 2013 - C. Keller - Initial version
         593             : !  See https://github.com/geoschem/hemco for complete history
         594             : !EOP
         595             : !------------------------------------------------------------------------------
         596             : !BOC
         597             : !
         598             : ! !LOCAL VARIABLES:
         599             : !
         600             :     ! Scalars
         601             :     INTEGER            :: I
         602             :
         603             :     ! Strings
         604             :     CHARACTER(LEN=255) :: errMsg, thisLoc
         605             :
         606             :     ! ================================================================
         607             :     ! HCO_ArrVecInit_2D_Hp begins here
         608             :     ! ================================================================
         609             :
         610             :     ! Initialize
         611           0 :     RC      = HCO_SUCCESS
         612           0 :     errMsg  = ''
         613           0 :     thisLoc = 'HCO_ArrVecInit_2D_Hp (hco_arr_mod.F90)'
         614             :
         615             :     ! If dimension is zero, return a null pointer
         616           0 :     IF ( nn < 1 ) THEN
         617           0 :        ArrVec => NULL()
         618           0 :        RETURN
         619             :     ENDIF
         620             :
         621             :     ! Allocate ArrVec if necessary
         622           0 :     IF ( .not. ASSOCIATED( ArrVec ) ) THEN
         623           0 :        ALLOCATE( ArrVec( nn ), STAT=RC )
         624           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         625           0 :           errMsg = 'Could not allocate "ArrVec"!'
         626           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
         627           0 :           RETURN
         628             :        ENDIF
         629             :     ENDIF
         630             :
         631             :     ! Reset values in ArrVec
         632           0 :     DO I = 1, nn
         633           0 :        CALL HCO_ValInit( ArrVec(I)%Val, nx, ny, ArrVec(I)%Alloc, RC )
         634           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         635           0 :           errMsg = 'Error encountered in "HCO_ValInit"!'
         636           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
         637           0 :           RETURN
         638             :        ENDIF
         639             :     ENDDO
         640             :
         641             :   END SUBROUTINE HCO_ArrVecInit_2D_Hp
         642             : !EOC
         643             : !------------------------------------------------------------------------------
         644             : !                   Harmonized Emissions Component (HEMCO)                    !
         645             : !------------------------------------------------------------------------------
         646             : !BOP
         647             : !
         648             : ! !IROUTINE: HCO_ArrVecInit_2D_Sp
         649             : !
         650             : ! !DESCRIPTION: Subroutine HCO\_ArrVecInit\_2D\_Sp initializes the given data
         651             : ! container 2D array vector. nn denotes the number of 2D arrays, and nx and ny
         652             : ! denote the array size dimensions. If nx is set to 0, no data is allocated but
         653             : ! Val is set to a (nullified) pointer instead.
         654             : !\\
         655             : !\\
         656             : ! !INTERFACE:
         657             : !
         658           0 :   SUBROUTINE HCO_ArrVecInit_2D_Sp( ArrVec, nn, nx, ny, RC )
         659             : !
         660             : ! !INPUT PARAMETERS:
         661             : !
         662             :     INTEGER,          INTENT(IN)  :: nn           ! vector length
         663             :     INTEGER,          INTENT(IN)  :: nx           ! x-dim
         664             :     INTEGER,          INTENT(IN)  :: ny           ! y-dim
         665             : !
         666             : ! !INPUT/OUTPUT PARAMETERS:
         667             : !
         668             :     TYPE(Arr2D_Sp),   POINTER     :: ArrVec(:)    ! Array vector
         669             : !
         670             : ! !INPUT/OUTPUT PARAMETERS:
         671             : !
         672             :     INTEGER,          INTENT(OUT) :: RC           ! Success or failure?
         673             : !
         674             : ! !REVISION HISTORY:
         675             : !  20 Apr 2013 - C. Keller - Initial version
         676             : !  See https://github.com/geoschem/hemco for complete history
         677             : !EOP
         678             : !------------------------------------------------------------------------------
         679             : !BOC
         680             : !
         681             : ! !LOCAL VARIABLES:
         682             : !
         683             :     ! Scalars
         684             :     INTEGER            :: I
         685             :
         686             :     ! Strings
         687             :     CHARACTER(LEN=255) :: errMsg, thisLoc
         688             :
         689             :     ! ================================================================
         690             :     ! HCO_ArrVecInit_2D_Sp begins here
         691             :     ! ================================================================
         692             :
         693             :     ! Initialize
         694           0 :     RC      = HCO_SUCCESS
         695           0 :     errMsg  = ''
         696           0 :     thisLoc = 'HCO_ArrVecInit_2D_Sp (hco_arr_mod.F90)'
         697             :
         698             :     ! If dimension is zero, return a null pointer
         699           0 :     IF ( nn < 1 ) THEN
         700           0 :        ArrVec => NULL()
         701           0 :        RETURN
         702             :     ENDIF
         703             :
         704             :     ! Allocate ArrVec if necessary
         705           0 :     IF ( .not. ASSOCIATED( ArrVec ) ) THEN
         706           0 :        ALLOCATE( ArrVec( nn ), STAT=RC )
         707           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         708           0 :           errMsg = 'Could not allocate "ArrVec"!'
         709           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
         710           0 :           RETURN
         711             :        ENDIF
         712             :     ENDIF
         713             :
         714             :     ! Reset values in ArrVec
         715           0 :     DO I = 1, nn
         716           0 :        CALL HCO_ValInit( ArrVec(I)%Val, nx, ny, ArrVec(I)%Alloc, RC )
         717           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         718           0 :           errMsg = 'Error encountered in "HCO_ValInit"!'
         719           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
         720           0 :           RETURN
         721             :        ENDIF
         722             :     ENDDO
         723             :
         724             :   END SUBROUTINE HCO_ArrVecInit_2D_Sp
         725             : !EOC
         726             : !------------------------------------------------------------------------------
         727             : !                   Harmonized Emissions Component (HEMCO)                    !
         728             : !------------------------------------------------------------------------------
         729             : !BOP
         730             : !
         731             : ! !IROUTINE: HCO_ArrVecInit_3D_Hp
         732             : !
         733             : ! !DESCRIPTION: Subroutine HCO\_ArrVecInit\_3D\_Hp initializes the given data
         734             : ! container 3D array vector. nn denotes the number of 2D arrays, and nx and ny
         735             : ! denote the array size dimensions. If nx is set to 0, no data is allocated but
         736             : ! Val is set to a (nullified) pointer instead.
         737             : !\\
         738             : !\\
         739             : ! !INTERFACE:
         740             : !
         741           0 :   SUBROUTINE HCO_ArrVecInit_3D_Hp( ArrVec, nn, nx, ny, nz, RC )
         742             : !
         743             : ! !INPUT PARAMETERS:
         744             : !
         745             :     INTEGER,          INTENT(IN)  :: nn           ! vector length
         746             :     INTEGER,          INTENT(IN)  :: nx           ! x-dim
         747             :     INTEGER,          INTENT(IN)  :: ny           ! y-dim
         748             :     INTEGER,          INTENT(IN)  :: nz           ! z-dim
         749             : !
         750             : ! !INPUT/OUTPUT PARAMETERS:
         751             : !
         752             :     TYPE(Arr3D_Hp),   POINTER     :: ArrVec(:)    ! Array vector
         753             : !
         754             : ! !INPUT/OUTPUT PARAMETERS:
         755             : !
         756             :     INTEGER,          INTENT(OUT) :: RC           ! Success or failure?
         757             : !
         758             : ! !REVISION HISTORY:
         759             : !  20 Apr 2013 - C. Keller - Initial version
         760             : !  See https://github.com/geoschem/hemco for complete history
         761             : !EOP
         762             : !------------------------------------------------------------------------------
         763             : !BOC
         764             : !
         765             : ! !LOCAL VARIABLES:
         766             : !
         767             :     ! Scalars
         768             :     INTEGER            :: I
         769             :
         770             :     ! Strings
         771             :     CHARACTER(LEN=255) :: errMsg, thisLoc
         772             :
         773             :     ! ================================================================
         774             :     ! HCO_ArrVecInit_3D_Hp begins here
         775             :     ! ================================================================
         776             :
         777             :     ! Initialize
         778           0 :     RC      = HCO_SUCCESS
         779           0 :     errMsg  = ''
         780           0 :     thisLoc = 'HCO_ArrVecInit_3D_Hp (hco_arr_mod.F90)'
         781             :
         782             :     ! If dimension is zero, return a null pointer
         783           0 :     IF ( nn < 1 ) THEN
         784           0 :        ArrVec => NULL()
         785           0 :        RETURN
         786             :     ENDIF
         787             :
         788             :     ! Allocate ArrVec if necessary
         789           0 :     IF ( .not. ASSOCIATED( ArrVec ) ) THEN
         790           0 :        ALLOCATE( ArrVec( nn ), STAT=RC )
         791           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         792           0 :           errMsg = 'Could not allocate "ArrVec"!'
         793           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
         794           0 :           RETURN
         795             :        ENDIF
         796             :     ENDIF
         797             :
         798             :     ! Reset values of ArrVec
         799           0 :     DO I = 1, nn
         800           0 :        CALL HCO_ValInit( ArrVec(I)%Val, nx, ny, nz, ArrVec(I)%Alloc, RC )
         801           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         802           0 :           errMsg = 'Error encountered in "HCO_ValInit"!'
         803           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
         804           0 :           RETURN
         805             :        ENDIF
         806             :     ENDDO
         807             :
         808             :   END SUBROUTINE HCO_ArrVecInit_3D_Hp
         809             : !EOC
         810             : !------------------------------------------------------------------------------
         811             : !                   Harmonized Emissions Component (HEMCO)                    !
         812             : !------------------------------------------------------------------------------
         813             : !BOP
         814             : !
         815             : ! !IROUTINE: HCO_ArrVecInit_3D_Sp
         816             : !
         817             : ! !DESCRIPTION: Subroutine HCO\_ArrVecInit\_3D\_Sp initializes the given data
         818             : ! container 3D array vector. nn denotes the number of 2D arrays, and nx and ny
         819             : ! denote the array size dimensions. If nx is set to 0, no data is allocated but
         820             : ! Val is set to a (nullified) pointer instead.
         821             : !\\
         822             : !\\
         823             : ! !INTERFACE:
         824             : !
         825           0 :   SUBROUTINE HCO_ArrVecInit_3D_Sp( ArrVec, nn, nx, ny, nz, RC )
         826             : !
         827             : ! !INPUT PARAMETERS:
         828             : !
         829             :     INTEGER,          INTENT(IN)  :: nn           ! vector length
         830             :     INTEGER,          INTENT(IN)  :: nx           ! x-dim
         831             :     INTEGER,          INTENT(IN)  :: ny           ! y-dim
         832             :     INTEGER,          INTENT(IN)  :: nz           ! z-dim
         833             : !
         834             : ! !INPUT/OUTPUT PARAMETERS:
         835             : !
         836             :     TYPE(Arr3D_Sp),   POINTER     :: ArrVec(:)    ! Array vector
         837             : !
         838             : ! !INPUT/OUTPUT PARAMETERS:
         839             : !
         840             :     INTEGER,          INTENT(OUT) :: RC           ! Success or failure?
         841             : !
         842             : ! !REVISION HISTORY:
         843             : !  20 Apr 2013 - C. Keller - Initial version
         844             : !  See https://github.com/geoschem/hemco for complete history
         845             : !EOP
         846             : !------------------------------------------------------------------------------
         847             : !BOC
         848             : !
         849             : ! !LOCAL VARIABLES:
         850             : !
         851             :     ! Scalars
         852             :     INTEGER            :: I
         853             :
         854             :     ! Strings
         855             :     CHARACTER(LEN=255) :: errMsg, thisLoc
         856             :
         857             :     ! ================================================================
         858             :     ! HCO_ArrVecInit_3D_Sp begins here
         859             :     ! ================================================================
         860             :
         861             :     ! Initialize
         862           0 :     RC      = HCO_SUCCESS
         863           0 :     errMsg  = ''
         864           0 :     thisLoc = 'HCO_ArrVecInit_3D_Sp (hco_arr_mod.F90)'
         865             :
         866             :     ! If dimension is zero, return a null pointer
         867           0 :     IF ( nn < 1 ) THEN
         868           0 :        ArrVec => NULL()
         869           0 :        RETURN
         870             :     ENDIF
         871             :
         872             :     ! Allocate ArrVec if necessary
         873           0 :     IF ( .not. ASSOCIATED( ArrVec ) ) THEN
         874           0 :        ALLOCATE( ArrVec( nn ), STAT=RC )
         875           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         876           0 :           errMsg = 'Could not allocate "ArrVec"!'
         877           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
         878           0 :           RETURN
         879             :        ENDIF
         880             :     ENDIF
         881             :
         882             :     ! Reset values of ArrVec
         883           0 :     DO I = 1, nn
         884           0 :        CALL HCO_ValInit( ArrVec(I)%Val, nx, ny, nz, ArrVec(I)%Alloc, RC )
         885           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         886           0 :           errMsg = 'Error encountered in "HCO_ValInit"!'
         887           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
         888           0 :           RETURN
         889             :        ENDIF
         890             :     ENDDO
         891             :
         892             :   END SUBROUTINE HCO_ArrVecInit_3D_Sp
         893             : !EOC
         894             : !------------------------------------------------------------------------------
         895             : !                   Harmonized Emissions Component (HEMCO)                    !
         896             : !------------------------------------------------------------------------------
         897             : !BOP
         898             : !
         899             : ! !IROUTINE: HCO_ValInit_2D_Sp
         900             : !
         901             : ! !DESCRIPTION: Subroutine HCO\_ValInit\_2D\_Sp initializes the given data
         902             : ! container 2D single precision array. nx and ny denote the array size
         903             : ! dimensions. If nx is set to 0, no data is allocated but Val is set to a
         904             : ! (nullified) pointer instead.
         905             : !\\
         906             : !\\
         907             : ! !INTERFACE:
         908             : !
         909           0 :   SUBROUTINE HCO_ValInit_2D_Sp( Val, nx, ny, Alloc, RC )
         910             : !
         911             : ! !INPUT PARAMETERS:
         912             : !
         913             :     INTEGER,  INTENT(IN)  :: nx             ! x-dim
         914             :     INTEGER,  INTENT(IN)  :: ny             ! y-dim
         915             : !
         916             : ! !INPUT/OUTPUT PARAMETERS:
         917             : !
         918             :     REAL(sp), POINTER     :: Val(:,:)       ! Array
         919             : !
         920             : ! !INPUT/OUTPUT PARAMETERS:
         921             : !
         922             :     LOGICAL,  INTENT(OUT) :: Alloc          ! allocated?
         923             :     INTEGER,  INTENT(OUT) :: RC             ! Success or failure?
         924             : !
         925             : ! !REVISION HISTORY:
         926             : !  20 Apr 2013 - C. Keller - Initial version
         927             : !  See https://github.com/geoschem/hemco for complete history
         928             : !EOP
         929             : !------------------------------------------------------------------------------
         930             : !BOC
         931             : !
         932             : ! !LOCAL VARIABLES:
         933             : !
         934             :     ! Strings
         935             :     CHARACTER(LEN=255) :: errMsg, thisLoc
         936             :
         937             :     ! ================================================================
         938             :     ! HCO_ValInit_2D_Sp begins here
         939             :     ! ================================================================
         940             :
         941             :     ! Initialize
         942           0 :     RC      =  HCO_SUCCESS
         943           0 :     errMsg  =  ''
         944           0 :     thisLoc =  'HCO_ValInit_2D_Sp (hco_arr_mod.F90)'
         945             :
         946             :     ! If dimensions are zero, just return a null pointer to Val
         947           0 :     IF ( nx == 0 .or. ny == 0 ) THEN
         948           0 :        Val   => NULL()
         949           0 :        Alloc = .FALSE.
         950           0 :        RETURN
         951             :     ENDIF
         952             :
         953             :     ! Initialize Val if dimensions are nonzero
         954           0 :     ALLOCATE( Val( nx, ny ), STAT=RC )
         955           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         956           0 :        errMsg = 'Could not allocate Val!'
         957           0 :        CALL HCO_Error( errMsg, RC, thisLoc )
         958           0 :        RETURN
         959             :     ENDIF
         960           0 :     Val   = 0.0_sp
         961           0 :     alloc = .TRUE.
         962             :
         963             :   END SUBROUTINE HCO_ValInit_2D_Sp
         964             : !EOC
         965             : !------------------------------------------------------------------------------
         966             : !                   Harmonized Emissions Component (HEMCO)                    !
         967             : !------------------------------------------------------------------------------
         968             : !BOP
         969             : !
         970             : ! !IROUTINE: HCO_ValInit_2D_Dp
         971             : !
         972             : ! !DESCRIPTION: Subroutine HCO\_ValInit\_2D\_Dp initializes the given data
         973             : ! container 2D double precision array. nx and ny denote the array size
         974             : ! dimensions. If nx is set to 0, no data is allocated but Val is set to a
         975             : ! (nullified) pointer instead.
         976             : !\\
         977             : !\\
         978             : ! !INTERFACE:
         979             : !
         980           0 :   SUBROUTINE HCO_ValInit_2D_Dp( Val, nx, ny, Alloc, RC )
         981             : !
         982             : ! !INPUT PARAMETERS:
         983             : !
         984             :     INTEGER,  INTENT(IN)  :: nx             ! x-dim
         985             :     INTEGER,  INTENT(IN)  :: ny             ! y-dim
         986             : !
         987             : ! !INPUT/OUTPUT PARAMETERS:
         988             : !
         989             :     REAL(dp), POINTER     :: Val(:,:)       ! Array
         990             : !
         991             : ! !INPUT/OUTPUT PARAMETERS:
         992             : !
         993             :     LOGICAL,  INTENT(OUT) :: Alloc          ! allocated?
         994             :     INTEGER,  INTENT(OUT) :: RC             ! Success or failure?!
         995             : !
         996             : ! !REVISION HISTORY:
         997             : !  20 Apr 2013 - C. Keller - Initial version
         998             : !  See https://github.com/geoschem/hemco for complete history
         999             : !EOP
        1000             : !------------------------------------------------------------------------------
        1001             : !BOC
        1002             : !
        1003             : ! !LOCAL VARIABLES:
        1004             : !
        1005             :     ! Strings
        1006             :     CHARACTER(LEN=255) :: errMsg, thisLoc
        1007             :
        1008             :     ! ================================================================
        1009             :     ! HCO_ValInit_2D_Dp begins here
        1010             :     ! ================================================================
        1011             :
        1012             :     ! Initialize
        1013           0 :     RC      =  HCO_SUCCESS
        1014           0 :     errMsg  =  ''
        1015           0 :     thisLoc =  'HCO_ValInit_2D_Dp (hco_arr_mod.F90)'
        1016             :
        1017             :     ! If dimensions are zero, just return a null pointer to Val
        1018           0 :     IF ( nx == 0 .or. ny == 0 ) THEN
        1019           0 :        Val     => NULL()
        1020           0 :        Alloc   = .FALSE.
        1021           0 :        RETURN
        1022             :     ENDIF
        1023             :
        1024             :     ! Initialize Val if dimensions are nonzero
        1025           0 :     ALLOCATE( Val( nx, ny ), STAT=RC )
        1026           0 :     IF ( RC /= HCO_SUCCESS ) THEN
        1027           0 :        errMsg = 'Could not allocate Val!'
        1028           0 :        CALL HCO_Error( errMsg, RC, thisLoc )
        1029           0 :        RETURN
        1030             :     ENDIF
        1031           0 :     Val   = 0.0_dp
        1032           0 :     alloc = .TRUE.
        1033             :
        1034             :   END SUBROUTINE HCO_ValInit_2D_Dp
        1035             : !EOC
        1036             : !------------------------------------------------------------------------------
        1037             : !                   Harmonized Emissions Component (HEMCO)                    !
        1038             : !------------------------------------------------------------------------------
        1039             : !BOP
        1040             : !
        1041             : ! !IROUTINE: HCO_ValInit_2D_I
        1042             : !
        1043             : ! !DESCRIPTION: Subroutine HCO\_ValInit\_2D\_I initializes the given data
        1044             : ! container 2D integer array. nx and ny denote the array size
        1045             : ! dimensions. If nx is set to 0, no data is allocated but Val is set to a
        1046             : ! (nullified) pointer instead.
        1047             : !\\
        1048             : !\\
        1049             : ! !INTERFACE:
        1050             : !
        1051           0 :   SUBROUTINE HCO_ValInit_2D_I( Val, nx, ny, alloc, RC )
        1052             : !
        1053             : ! !INPUT PARAMETERS:
        1054             : !
        1055             :     INTEGER,  INTENT(IN)  :: nx             ! x-dim
        1056             :     INTEGER,  INTENT(IN)  :: ny             ! y-dim
        1057             : !
        1058             : ! !INPUT/OUTPUT PARAMETERS:
        1059             : !
        1060             :     INTEGER,  POINTER     :: Val(:,:)       ! Array
        1061             : !
        1062             : ! !INPUT/OUTPUT PARAMETERS:
        1063             : !
        1064             :     LOGICAL,  INTENT(OUT) :: Alloc          ! allocated?
        1065             :     INTEGER,  INTENT(OUT) :: RC             ! Success or failure?
        1066             : !
        1067             : ! !REVISION HISTORY:
        1068             : !  20 Apr 2013 - C. Keller - Initial version
        1069             : !  See https://github.com/geoschem/hemco for complete history
        1070             : !EOP
        1071             : !------------------------------------------------------------------------------
        1072             : !BOC
        1073             : !
        1074             : ! !LOCAL VARIABLES:
        1075             : !
        1076             :     ! Strings
        1077             :     CHARACTER(LEN=255) :: errMsg, thisLoc
        1078             :
        1079             :     ! ================================================================
        1080             :     ! HCO_ValInit_2D_I begins here
        1081             :     ! ================================================================
        1082             :
        1083             :     ! Initialize
        1084           0 :     RC      =  HCO_SUCCESS
        1085           0 :     errMsg  =  ''
        1086           0 :     thisLoc =  'HCO_ValInit_2D_I (hco_arr_mod.F90)'
        1087             :
        1088             :     ! If dimensions are zero, just return a null pointer to Val
        1089           0 :     IF ( nx == 0 .or. ny == 0 ) THEN
        1090           0 :        Val     => NULL()
        1091           0 :        Alloc   = .FALSE.
        1092           0 :        RETURN
        1093             :     ENDIF
        1094             :
        1095             :     ! Initialize Val if dimensions are nonzero
        1096           0 :     ALLOCATE( Val( nx, ny ), STAT=RC )
        1097           0 :     IF ( RC /= HCO_SUCCESS ) THEN
        1098           0 :        errMsg = 'Could not allocate Val!'
        1099           0 :        CALL HCO_Error( errMsg, RC, thisLoc )
        1100           0 :        RETURN
        1101             :     ENDIF
        1102           0 :     Val   = 0
        1103           0 :     alloc = .TRUE.
        1104             :
        1105             :   END SUBROUTINE HCO_ValInit_2D_I
        1106             : !EOC
        1107             : !------------------------------------------------------------------------------
        1108             : !                   Harmonized Emissions Component (HEMCO)                    !
        1109             : !------------------------------------------------------------------------------
        1110             : !BOP
        1111             : !
        1112             : ! !IROUTINE: HCO_ValInit_3D_Dp
        1113             : !
        1114             : ! !DESCRIPTION: Subroutine HCO\_ValInit\_3D\_Dp initializes the given data
        1115             : ! container 3D double precision array. nx and ny denote the array size
        1116             : ! dimensions. If nx is set to 0, no data is allocated but Val is set to a
        1117             : ! (nullified) pointer instead.
        1118             : !\\
        1119             : !\\
        1120             : ! !INTERFACE:
        1121             : !
        1122           0 :   SUBROUTINE HCO_ValInit_3D_Dp( Val, nx, ny, nz, Alloc, RC )
        1123             : !
        1124             : ! !INPUT PARAMETERS:
        1125             : !
        1126             :     INTEGER,  INTENT(IN)  :: nx             ! x-dim
        1127             :     INTEGER,  INTENT(IN)  :: ny             ! y-dim
        1128             :     INTEGER,  INTENT(IN)  :: nz             ! z-dim
        1129             : !
        1130             : ! !INPUT/OUTPUT PARAMETERS:
        1131             : !
        1132             :     REAL(dp), POINTER     :: Val(:,:,:)     ! Array
        1133             : !
        1134             : ! !INPUT/OUTPUT PARAMETERS:
        1135             : !
        1136             :     LOGICAL,  INTENT(OUT) :: Alloc          ! allocated?
        1137             :     INTEGER,  INTENT(OUT) :: RC             ! Success or failure?
        1138             : !
        1139             : ! !REVISION HISTORY:
        1140             : !  20 Apr 2013 - C. Keller - Initial version
        1141             : !  See https://github.com/geoschem/hemco for complete history
        1142             : !EOP
        1143             : !------------------------------------------------------------------------------
        1144             : !BOC
        1145             : !
        1146             : ! !LOCAL VARIABLES:
        1147             : !
        1148             :     ! Strings
        1149             :     CHARACTER(LEN=255) :: errMsg, thisLoc
        1150             :
        1151             :     ! ================================================================
        1152             :     ! HCO_ValInit_3D_Dp begins here
        1153             :     ! ================================================================
        1154             :
        1155             :     ! Initialize
        1156           0 :     RC      =  HCO_SUCCESS
        1157           0 :     errMsg  =  ''
        1158           0 :     thisLoc =  'HCO_ValInit_3D_Dp (hco_arr_mod.F90)'
        1159             :
        1160             :     ! If dimensions are zero, return a null pointer
        1161           0 :     IF ( nx == 0 .or. ny == 0 .or. nz == 0 ) THEN
        1162           0 :        Val   => NULL()
        1163           0 :        Alloc = .FALSE.
        1164           0 :        RETURN
        1165             :     ENDIF
        1166             :
        1167             :     ! Initialize Val if dimensions are nonzero
        1168           0 :     ALLOCATE( Val( nx, ny, nz ), STAT=RC )
        1169           0 :     IF ( RC /= HCO_SUCCESS ) THEN
        1170           0 :        errMsg = 'Could not allocate Val!'
        1171           0 :        CALL HCO_Error( errMsg, RC, thisLoc )
        1172           0 :        RETURN
        1173             :     ENDIF
        1174           0 :     Val   = 0.0_dp
        1175           0 :     alloc = .TRUE.
        1176             :
        1177             :   END SUBROUTINE HCO_ValInit_3D_Dp
        1178             : !EOC
        1179             : !------------------------------------------------------------------------------
        1180             : !                   Harmonized Emissions Component (HEMCO)                    !
        1181             : !------------------------------------------------------------------------------
        1182             : !BOP
        1183             : !
        1184             : ! !IROUTINE: HCO_ValInit_3D_Sp
        1185             : !
        1186             : ! !DESCRIPTION: Subroutine HCO\_ValInit\_3D\_Sp initializes the given data
        1187             : ! container 3D single precision array. nx and ny denote the array size
        1188             : ! dimensions. If nx is set to 0, no data is allocated but Val is set to a
        1189             : ! (nullified) pointer instead.
        1190             : !\\
        1191             : !\\
        1192             : ! !INTERFACE:
        1193             : !
        1194           0 :   SUBROUTINE HCO_ValInit_3D_Sp( Val, nx, ny, nz, Alloc, RC )
        1195             : !
        1196             : ! !INPUT PARAMETERS:
        1197             : !
        1198             :     INTEGER,  INTENT(IN)  :: nx             ! x-dim
        1199             :     INTEGER,  INTENT(IN)  :: ny             ! y-dim
        1200             :     INTEGER,  INTENT(IN)  :: nz             ! z-dim
        1201             : !
        1202             : ! !INPUT/OUTPUT PARAMETERS:
        1203             : !
        1204             :     REAL(sp), POINTER     :: Val(:,:,:)     ! Array
        1205             : !
        1206             : ! !INPUT/OUTPUT PARAMETERS:
        1207             : !
        1208             :     LOGICAL,  INTENT(OUT) :: Alloc          ! allocated?
        1209             :     INTEGER,  INTENT(OUT) :: RC             ! Success or failure?
        1210             : !
        1211             : ! !REVISION HISTORY:
        1212             : !  20 Apr 2013 - C. Keller - Initial version
        1213             : !  See https://github.com/geoschem/hemco for complete history
        1214             : !EOP
        1215             : !------------------------------------------------------------------------------
        1216             : !BOC
        1217             : !
        1218             : ! !LOCAL VARIABLES:
        1219             : !
        1220             :      ! Strings
        1221             :     CHARACTER(LEN=255) :: errMsg, thisLoc
        1222             :
        1223             :     ! ================================================================
        1224             :     ! HCO_ValInit_3D_Sp begins here
        1225             :     ! ================================================================
        1226             :
        1227             :     ! Initialize
        1228           0 :     RC      = HCO_SUCCESS
        1229           0 :     errMsg  = ''
        1230           0 :     thisLoc = 'HCO_ValInit_3D_Sp (hco_arr_mod.F90)'
        1231             :
        1232             :     ! If dimensions are zero, return a null pointer
        1233           0 :     IF ( nx == 0 .or. ny == 0 .or. nz == 0 ) THEN
        1234           0 :        Val     => NULL()
        1235           0 :        Alloc   = .FALSE.
        1236           0 :        RETURN
        1237             :     ENDIF
        1238             :
        1239             :     ! Initialize Val if dimensions are nonzero
        1240           0 :     ALLOCATE( Val( nx, ny, nz ), STAT=RC )
        1241           0 :     IF ( RC /= HCO_SUCCESS ) THEN
        1242           0 :        errMsg = 'Could not allocate Val!'
        1243           0 :        CALL HCO_Error( errMsg, RC, thisLoc )
        1244           0 :        RETURN
        1245             :     ENDIF
        1246           0 :     Val   = 0.0_sp
        1247           0 :     alloc = .TRUE.
        1248             :
        1249             :   END SUBROUTINE HCO_ValInit_3D_Sp
        1250             : !EOC
        1251             : !------------------------------------------------------------------------------
        1252             : !                   Harmonized Emissions Component (HEMCO)                    !
        1253             : !------------------------------------------------------------------------------
        1254             : !BOP
        1255             : !
        1256             : ! !IROUTINE: HCO_ArrAssert_3D_Hp
        1257             : !
        1258             : ! !DESCRIPTION: Routine HCO\_ArrAssert\_3D\_Hp makes sure that the passed
        1259             : ! 3D array is allocated.
        1260             : !\\
        1261             : !\\
        1262             : ! !INTERFACE:
        1263             : !
        1264           0 :   SUBROUTINE HCO_ArrAssert_3D_Hp( ThisArr3D, I, J, L, RC )
        1265             : !
        1266             : ! !INPUT PARAMETERS:
        1267             : !
        1268             :     INTEGER,         INTENT(IN)  :: I, J, L       ! Array dims
        1269             : !
        1270             : ! !INPUT/OUTPUT PARAMETERS:
        1271             : !
        1272             :     TYPE(Arr3D_Hp),  POINTER     :: ThisArr3D     ! 3D array
        1273             : !
        1274             : ! !OUTPUT PARAMETERS:
        1275             : !
        1276             :     INTEGER,         INTENT(OUT) :: RC            ! Success or failure?
        1277             : !
        1278             : ! !REVISION HISTORY:
        1279             : !  01 May 2013 - C. Keller - Initial version
        1280             : !  See https://github.com/geoschem/hemco for complete history
        1281             : !EOP
        1282             : !------------------------------------------------------------------------------
        1283             : !BOC
        1284             : !
        1285             : ! !LOCAL VARIABLES:
        1286             : !
        1287             :     ! Strings
        1288             :     CHARACTER(LEN=255) :: errMsg, thisLoc
        1289             :
        1290             :     !=====================================================================
        1291             :     ! HCO_ArrAssert_3D_Hp begins here!
        1292             :     !=====================================================================
        1293             :
        1294             :     ! Initialize
        1295           0 :     RC      = HCO_SUCCESS
        1296           0 :     errMsg  = ''
        1297           0 :     thisLoc = 'HCO_ArrAssert_3D_Hp (hco_arr_mod.F90)'
        1298             :
        1299             :     ! Check flux array
        1300           0 :     IF ( .not. ASSOCIATED ( ThisArr3D ) ) THEN
        1301           0 :        CALL HCO_ArrInit( ThisArr3D, I, J, L, RC )
        1302           0 :        IF ( RC /= HCO_SUCCESS ) THEN
        1303           0 :           errMsg = 'Error encountered in "HCO_ArrInit"!'
        1304           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
        1305           0 :           RETURN
        1306             :        ENDIF
        1307             :
        1308           0 :     ELSE IF ( .not. ASSOCIATED ( ThisArr3D%Val ) ) THEN
        1309           0 :        CALL HCO_ValInit( ThisArr3D%Val, I, J, L, ThisArr3D%Alloc, RC )
        1310           0 :        IF ( RC /= HCO_SUCCESS ) THEN
        1311           0 :           errMsg = 'Error encountered in "HCO_ValInit"!'
        1312           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
        1313           0 :           RETURN
        1314             :        ENDIF
        1315             :
        1316             :     ENDIF
        1317             :
        1318             :   END SUBROUTINE HCO_ArrAssert_3D_Hp
        1319             : !EOC
        1320             : !------------------------------------------------------------------------------
        1321             : !                   Harmonized Emissions Component (HEMCO)                    !
        1322             : !------------------------------------------------------------------------------
        1323             : !BOP
        1324             : !
        1325             : ! !IROUTINE: HCO_ArrAssert_3D_Sp
        1326             : !
        1327             : ! !DESCRIPTION: Routine HCO\_ArrAssert\_3D\_Sp makes sure that the passed
        1328             : ! 3D array is allocated.
        1329             : !\\
        1330             : !\\
        1331             : ! !INTERFACE:
        1332             : !
        1333           0 :   SUBROUTINE HCO_ArrAssert_3D_Sp( ThisArr3D, I, J, L, RC )
        1334             : !
        1335             : ! !INPUT PARAMETERS:
        1336             : !
        1337             :     INTEGER,         INTENT(IN)  :: I, J, L       ! Array dims
        1338             : !
        1339             : ! !INPUT/OUTPUT PARAMETERS:
        1340             : !
        1341             :     TYPE(Arr3D_Sp),  POINTER     :: ThisArr3D     ! 3D array
        1342             : !
        1343             : ! !OUTPUT PARAMETERS:
        1344             : !
        1345             :     INTEGER,         INTENT(OUT) :: RC            ! Success or failure?
        1346             : !
        1347             : ! !REVISION HISTORY:
        1348             : !  01 May 2013 - C. Keller - Initial version
        1349             : !  See https://github.com/geoschem/hemco for complete history
        1350             : !EOP
        1351             : !------------------------------------------------------------------------------
        1352             : !BOC
        1353             : !
        1354             : ! !LOCAL VARIABLES:
        1355             : !
        1356             :     ! Strings
        1357             :     CHARACTER(LEN=255) :: errMsg, thisLoc
        1358             :
        1359             :     !=====================================================================
        1360             :     ! HCO_ArrAssert_3D_Sp begins here!
        1361             :     !=====================================================================
        1362             :
        1363             :     ! Initialize
        1364           0 :     RC      = HCO_SUCCESS
        1365           0 :     errMsg  = ''
        1366           0 :     thisLoc = 'HCO_ArrAssert_3D_Sp (hco_arr_mod.F90)'
        1367             :
        1368             :     ! Check flux array
        1369           0 :     IF ( .not. ASSOCIATED ( ThisArr3D ) ) THEN
        1370           0 :        CALL HCO_ArrInit( ThisArr3D, I, J, L, RC )
        1371           0 :        IF ( RC /= HCO_SUCCESS ) THEN
        1372           0 :           errMsg = 'Error encountered in "HCO_ArrInit"!'
        1373           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
        1374           0 :           RETURN
        1375             :        ENDIF
        1376             :
        1377           0 :     ELSE IF ( .not. ASSOCIATED ( ThisArr3D%Val ) ) THEN
        1378           0 :        CALL HCO_ValInit ( ThisArr3D%Val, I, J, L, ThisArr3D%Alloc, RC )
        1379           0 :        IF ( RC /= HCO_SUCCESS ) THEN
        1380           0 :           errMsg = 'Error encountered in "HCO_ValInit"!'
        1381           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
        1382           0 :           RETURN
        1383             :        ENDIF
        1384             :
        1385             :     ENDIF
        1386             :
        1387             :   END SUBROUTINE HCO_ArrAssert_3D_Sp
        1388             : !EOC
        1389             : !------------------------------------------------------------------------------
        1390             : !                   Harmonized Emissions Component (HEMCO)                    !
        1391             : !------------------------------------------------------------------------------
        1392             : !BOP
        1393             : !
        1394             : ! !IROUTINE: HCO_ArrAssert_2D_Hp
        1395             : !
        1396             : ! !DESCRIPTION: Routine HCO\_ArrAssert\_2D\_Hp makes sure that the passed
        1397             : ! 2D array is allocated.
        1398             : !\\
        1399             : !\\
        1400             : ! !INTERFACE:
        1401             : !
        1402           0 :   SUBROUTINE HCO_ArrAssert_2D_Hp( ThisArr2D, I, J, RC )
        1403             : !
        1404             : ! !INPUT PARAMETERS:
        1405             : !
        1406             :     INTEGER,         INTENT(IN)  :: I, J          ! Array dims
        1407             : !
        1408             : ! !INPUT/OUTPUT PARAMETERS:
        1409             : !
        1410             :     TYPE(Arr2D_Hp),  POINTER     :: ThisArr2D     ! 2D array
        1411             : !
        1412             : ! !OUTPUT PARAMETERS:
        1413             : !
        1414             :     INTEGER,         INTENT(OUT) :: RC            ! Success or failure?
        1415             : !
        1416             : ! !REVISION HISTORY:
        1417             : !  01 May 2013 - C. Keller - Initial version
        1418             : !  See https://github.com/geoschem/hemco for complete history
        1419             : !EOP
        1420             : !------------------------------------------------------------------------------
        1421             : !BOC
        1422             : !
        1423             : ! !LOCAL VARIABLES:
        1424             : !
        1425             :     ! Strings
        1426             :     CHARACTER(LEN=255) :: errMsg, thisLoc
        1427             :
        1428             :     !=====================================================================
        1429             :     ! HCO_ArrAssert_2D_Hp begins here!
        1430             :     !=====================================================================
        1431             :
        1432             :     ! Initialize
        1433           0 :     RC      = HCO_SUCCESS
        1434           0 :     errMsg  = ''
        1435           0 :     thisLoc = 'HCO_ArrAssert_2D_Hp (hco_arr_mod.F90)'
        1436             :
        1437             :     ! Check flux array
        1438           0 :     IF ( .not. ASSOCIATED ( ThisArr2D ) ) THEN
        1439           0 :        CALL HCO_ArrInit( ThisArr2D, I, J, RC )
        1440           0 :        IF ( RC /= HCO_SUCCESS ) THEN
        1441           0 :           errMsg = 'Error encountered in "HCO_ArrInit"!'
        1442           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
        1443           0 :           RETURN
        1444             :        ENDIF
        1445             :
        1446           0 :     ELSE IF ( .not. ASSOCIATED ( ThisArr2D%Val ) ) THEN
        1447           0 :        CALL HCO_ValInit( ThisArr2D%Val, I, J, ThisArr2D%Alloc, RC )
        1448           0 :        IF ( RC /= HCO_SUCCESS ) THEN
        1449           0 :           errMsg = 'Error encountered in "HCO_ValInit"!'
        1450           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
        1451           0 :           RETURN
        1452             :        ENDIF
        1453             :
        1454             :     ENDIF
        1455             :
        1456             :   END SUBROUTINE HCO_ArrAssert_2D_Hp
        1457             : !EOC
        1458             : !------------------------------------------------------------------------------
        1459             : !                   Harmonized Emissions Component (HEMCO)                    !
        1460             : !------------------------------------------------------------------------------
        1461             : !BOP
        1462             : !
        1463             : ! !IROUTINE: HCO_ArrAssert_2D_Sp
        1464             : !
        1465             : ! !DESCRIPTION: Routine HCO\_ArrAssert\_2D\_Sp makes sure that the passed
        1466             : ! 2D array is allocated.
        1467             : !\\
        1468             : !\\
        1469             : ! !INTERFACE:
        1470             : !
        1471           0 :   SUBROUTINE HCO_ArrAssert_2D_Sp( ThisArr2D, I, J, RC )
        1472             : !
        1473             : ! !INPUT PARAMETERS:
        1474             : !
        1475             :     INTEGER,         INTENT(IN)  :: I, J          ! Array dims
        1476             : !
        1477             : ! !INPUT/OUTPUT PARAMETERS:
        1478             : !
        1479             :     TYPE(Arr2D_Sp),  POINTER     :: ThisArr2D     ! 2D array
        1480             : !
        1481             : ! !OUTPUT PARAMETERS:
        1482             : !
        1483             :     INTEGER,         INTENT(OUT) :: RC            ! Success or failure?
        1484             : !
        1485             : ! !REVISION HISTORY:
        1486             : !  01 May 2013 - C. Keller - Initial version
        1487             : !  See https://github.com/geoschem/hemco for complete history
        1488             : !EOP
        1489             : !------------------------------------------------------------------------------
        1490             : !BOC
        1491             : !
        1492             : ! !LOCAL VARIABLES:
        1493             : !
        1494             :     ! Strings
        1495             :     CHARACTER(LEN=255) :: errMsg, thisLoc
        1496             :
        1497             :     !=====================================================================
        1498             :     ! HCO_ArrAssert_2D_Sp begins here!
        1499             :     !=====================================================================
        1500             :
        1501             :     ! Initialize
        1502           0 :     RC      = HCO_SUCCESS
        1503           0 :     errMsg  = ''
        1504           0 :     thisLoc = 'HCO_ArrAssert_2D_Sp (hco_arr_mod.F90)'
        1505             :
        1506             :     ! Check flux array
        1507           0 :     IF ( .not. ASSOCIATED ( ThisArr2D ) ) THEN
        1508           0 :        CALL HCO_ArrInit( ThisArr2D, I, J, RC )
        1509           0 :        IF ( RC /= HCO_SUCCESS ) THEN
        1510           0 :           errMsg = 'Error encountered in "HCO_ArrInit"!'
        1511           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
        1512           0 :           RETURN
        1513             :        ENDIF
        1514             :
        1515           0 :     ELSE IF ( .not. ASSOCIATED ( ThisArr2D%Val ) ) THEN
        1516           0 :        CALL HCO_ValInit ( ThisArr2D%Val, I, J, ThisArr2D%Alloc, RC )
        1517           0 :        IF ( RC /= HCO_SUCCESS ) THEN
        1518           0 :           errMsg = 'Error encountered in "HCO_ValInit"!'
        1519           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
        1520           0 :           RETURN
        1521             :        ENDIF
        1522             :
        1523             :     ENDIF
        1524             :
        1525             :   END SUBROUTINE HCO_ArrAssert_2D_Sp
        1526             : !EOC
        1527             : !------------------------------------------------------------------------------
        1528             : !                   Harmonized Emissions Component (HEMCO)                    !
        1529             : !------------------------------------------------------------------------------
        1530             : !BOP
        1531             : !
        1532             : ! !IROUTINE: HCO_ArrAssert_2D_I
        1533             : !
        1534             : ! !DESCRIPTION: Routine HCO\_ArrAssert\_2D\_I makes sure that the passed
        1535             : ! 2D array is allocated.
        1536             : !\\
        1537             : !\\
        1538             : ! !INTERFACE:
        1539             : !
        1540           0 :   SUBROUTINE HCO_ArrAssert_2D_I( ThisArr2D, I, J, RC )
        1541             : !
        1542             : ! !INPUT PARAMETERS:
        1543             : !
        1544             :     INTEGER,         INTENT(IN)  :: I, J          ! Array dims
        1545             : !
        1546             : ! !INPUT/OUTPUT PARAMETERS:
        1547             : !
        1548             :     TYPE(Arr2D_I),   POINTER     :: ThisArr2D     ! 2D array
        1549             : !
        1550             : ! !OUTPUT PARAMETERS:
        1551             : !
        1552             :     INTEGER,         INTENT(OUT) :: RC            ! Success or failure?
        1553             : !
        1554             : ! !REVISION HISTORY:
        1555             : !  01 May 2013 - C. Keller - Initial version
        1556             : !  See https://github.com/geoschem/hemco for complete history
        1557             : !EOP
        1558             : !------------------------------------------------------------------------------
        1559             : !BOC
        1560             : !
        1561             : ! !LOCAL VARIABLES:
        1562             : !
        1563             :     ! Strings
        1564             :     CHARACTER(LEN=255) :: errMsg, thisLoc
        1565             :
        1566             :     !=====================================================================
        1567             :     ! HCO_ArrAssert_2D_I begins here!
        1568             :     !=====================================================================
        1569             :
        1570             :     ! Initialize
        1571           0 :     RC      = HCO_SUCCESS
        1572           0 :     errMsg  = ''
        1573           0 :     thisLoc = 'HCO_ArrAssert_2D_I (hco_arr_mod.F90)'
        1574             :
        1575             :     ! Check flux array
        1576           0 :     IF ( .not. ASSOCIATED ( ThisArr2D ) ) THEN
        1577           0 :        CALL HCO_ArrInit( ThisArr2D, I, J, RC )
        1578           0 :        IF ( RC /= HCO_SUCCESS ) THEN
        1579           0 :           errMsg = 'Error encountered in "HCO_ArrInit"!'
        1580           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
        1581           0 :           RETURN
        1582             :        ENDIF
        1583             :
        1584           0 :     ELSE IF ( .not. ASSOCIATED ( ThisArr2D%Val ) ) THEN
        1585           0 :        CALL HCO_ValInit ( ThisArr2D%Val, I, J, ThisArr2D%Alloc, RC )
        1586           0 :        IF ( RC /= HCO_SUCCESS ) THEN
        1587           0 :           errMsg = 'Error encountered in "HCO_ValInit"!'
        1588           0 :           CALL HCO_Error( errMsg, RC, thisLoc )
        1589           0 :           RETURN
        1590             :        ENDIF
        1591             :
        1592             :     ENDIF
        1593             :
        1594             :   END SUBROUTINE HCO_ArrAssert_2D_I
        1595             : !EOC
        1596             : !------------------------------------------------------------------------------
        1597             : !                   Harmonized Emissions Component (HEMCO)                    !
        1598             : !------------------------------------------------------------------------------
        1599             : !BOP
        1600             : !
        1601             : ! !IROUTINE: HCO_ArrCleanup_2D_Hp
        1602             : !
        1603             : ! !DESCRIPTION: Subroutine HCO\_ArrCleanup\_2D\_Hp cleans up the given
        1604             : ! container 2D array.
        1605             : !\\
        1606             : !\\
        1607             : ! !INTERFACE:
        1608             : !
        1609           0 :   SUBROUTINE HCO_ArrCleanup_2D_Hp( Arr, DeepClean )
        1610             : !
        1611             : ! !INPUT PARAMETERS:
        1612             : !
        1613             :     TYPE(Arr2D_Hp),      POINTER  :: Arr       ! Array
        1614             :     LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate allocated array?
        1615             : !
        1616             : ! !REVISION HISTORY:
        1617             : !  20 Apr 2013 - C. Keller - Initial version
        1618             : !  See https://github.com/geoschem/hemco for complete history
        1619             : !EOP
        1620             : !------------------------------------------------------------------------------
        1621             : !BOC
        1622             : !
        1623             : ! !LOCAL VARIABLES:
        1624             : !
        1625             :     LOGICAL :: DC
        1626             :
        1627             :     ! ================================================================
        1628             :     ! HCO_ArrCleanup_2D_Hp begins here
        1629             :     ! ================================================================
        1630           0 :     IF ( ASSOCIATED( Arr ) ) THEN
        1631             :
        1632             :        ! Optional argument handling
        1633           0 :        DC = .TRUE.
        1634           0 :        IF ( PRESENT( DeepClean ) ) DC = DeepClean
        1635             :
        1636             :        ! Finalize Arr%Val and Arr
        1637           0 :        CALL HCO_ValCleanup( Arr%Val, Arr%Alloc, DeepClean=DC )
        1638           0 :        DEALLOCATE( Arr )
        1639             :     ENDIF
        1640             :
        1641           0 :   END SUBROUTINE HCO_ArrCleanup_2D_Hp
        1642             : !EOC
        1643             : !------------------------------------------------------------------------------
        1644             : !                   Harmonized Emissions Component (HEMCO)                    !
        1645             : !------------------------------------------------------------------------------
        1646             : !BOP
        1647             : !
        1648             : ! !IROUTINE: HCO_ArrCleanup_2D_Sp
        1649             : !
        1650             : ! !DESCRIPTION: Subroutine HCO\_ArrCleanup\_2D\_Sp cleans up the given
        1651             : ! container 2D array.
        1652             : !\\
        1653             : !\\
        1654             : ! !INTERFACE:
        1655             : !
        1656           0 :   SUBROUTINE HCO_ArrCleanup_2D_Sp( Arr, DeepClean )
        1657             : !
        1658             : ! !INPUT PARAMETERS:
        1659             : !
        1660             :     TYPE(Arr2D_Sp),      POINTER  :: Arr       ! Array
        1661             :     LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate allocated array?
        1662             : !
        1663             : ! !REVISION HISTORY:
        1664             : !  20 Apr 2013 - C. Keller - Initial version
        1665             : !  See https://github.com/geoschem/hemco for complete history
        1666             : !EOP
        1667             : !------------------------------------------------------------------------------
        1668             : !BOC
        1669             : !
        1670             : ! !LOCAL VARIABLES:
        1671             : !
        1672             :     LOGICAL :: DC
        1673             :
        1674             :     ! ================================================================
        1675             :     ! HCO_ArrCleanup_2D_Sp begins here
        1676             :     ! ================================================================
        1677           0 :     IF ( ASSOCIATED( Arr ) ) THEN
        1678             :
        1679             :        ! Optional argument handling
        1680           0 :        DC = .TRUE.
        1681           0 :        IF ( PRESENT( DeepClean ) ) DC = DeepClean
        1682             :
        1683             :        ! Finalize Arr%Val and Arr
        1684           0 :        CALL HCO_ValCleanup( Arr%Val, Arr%Alloc, DeepClean=DC )
        1685           0 :        DEALLOCATE( Arr )
        1686             :     ENDIF
        1687             :
        1688           0 :   END SUBROUTINE HCO_ArrCleanup_2D_Sp
        1689             : !EOC
        1690             : !------------------------------------------------------------------------------
        1691             : !                   Harmonized Emissions Component (HEMCO)                    !
        1692             : !------------------------------------------------------------------------------
        1693             : !BOP
        1694             : !
        1695             : ! !IROUTINE: HCO_ArrCleanup_2D_I
        1696             : !
        1697             : ! !DESCRIPTION: Subroutine HCO\_ArrCleanup\_2D\_I cleans up the given
        1698             : ! container 2D array.
        1699             : !\\
        1700             : !\\
        1701             : ! !INTERFACE:
        1702             : !
        1703           0 :   SUBROUTINE HCO_ArrCleanup_2D_I( Arr, DeepClean )
        1704             : !
        1705             : ! !INPUT PARAMETERS:
        1706             : !
        1707             :     TYPE(Arr2D_I),       POINTER  :: Arr       ! Array
        1708             :     LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate array?
        1709             : !
        1710             : ! !REVISION HISTORY:
        1711             : !  20 Apr 2013 - C. Keller - Initial version
        1712             : !  See https://github.com/geoschem/hemco for complete history
        1713             : !EOP
        1714             : !------------------------------------------------------------------------------
        1715             : !BOC
        1716             : !
        1717             : ! !LOCAL VARIABLES:
        1718             : !
        1719             :     LOGICAL :: DC
        1720             :
        1721             :     ! ================================================================
        1722             :     ! HCO_ArrCleanup_2D_I begins here
        1723             :     ! ================================================================
        1724           0 :     IF ( ASSOCIATED( Arr ) ) THEN
        1725             :
        1726             :        ! Optional argument handling
        1727           0 :        DC = .TRUE.
        1728           0 :        IF ( PRESENT( DeepClean ) ) DC = DeepClean
        1729             :
        1730             :        ! Finalize Arr%Val and Arr
        1731           0 :        CALL HCO_ValCleanup( Arr%Val, Arr%Alloc, DeepClean=DC )
        1732           0 :        DEALLOCATE( Arr )
        1733             :     ENDIF
        1734             :
        1735           0 :   END SUBROUTINE HCO_ArrCleanup_2D_I
        1736             : !EOC
        1737             : !------------------------------------------------------------------------------
        1738             : !                   Harmonized Emissions Component (HEMCO)                    !
        1739             : !------------------------------------------------------------------------------
        1740             : !BOP
        1741             : !
        1742             : ! !IROUTINE: HCO_ArrCleanup_3D_Hp
        1743             : !
        1744             : ! !DESCRIPTION: Subroutine HCO\_ArrCleanup\_3D\_Hp cleans up the given
        1745             : ! container 3D array.
        1746             : !\\
        1747             : !\\
        1748             : ! !INTERFACE:
        1749             : !
        1750           0 :   SUBROUTINE HCO_ArrCleanup_3D_Hp( Arr, DeepClean )
        1751             : !
        1752             : ! !INPUT PARAMETERS:
        1753             : !
        1754             :     TYPE(Arr3D_Hp),      POINTER  :: Arr       ! Array
        1755             :     LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate array?
        1756             : !
        1757             : ! !REVISION HISTORY:
        1758             : !  20 Apr 2013 - C. Keller - Initial version
        1759             : !  See https://github.com/geoschem/hemco for complete history
        1760             : !EOP
        1761             : !------------------------------------------------------------------------------
        1762             : !BOC
        1763             : !
        1764             : ! !LOCAL VARIABLES:
        1765             : !
        1766             :     LOGICAL :: DC
        1767             :
        1768             :     ! ================================================================
        1769             :     ! HCO_ArrCleanup_3D_Hp begins here
        1770             :     ! ================================================================
        1771           0 :     IF ( ASSOCIATED( Arr ) ) THEN
        1772             :
        1773             :        ! Optional argument handling
        1774           0 :        DC = .TRUE.
        1775           0 :        IF ( PRESENT( DeepClean ) ) DC = DeepClean
        1776             :
        1777             :        ! Finalize Arr%Val and Arr
        1778           0 :        CALL HCO_ValCleanup( Arr%Val, Arr%Alloc, DeepClean=DC )
        1779           0 :        DEALLOCATE( Arr )
        1780             :     ENDIF
        1781           0 :   END SUBROUTINE HCO_ArrCleanup_3D_Hp
        1782             : !EOC
        1783             : !------------------------------------------------------------------------------
        1784             : !                   Harmonized Emissions Component (HEMCO)                    !
        1785             : !------------------------------------------------------------------------------
        1786             : !BOP
        1787             : !
        1788             : ! !IROUTINE: HCO_ArrCleanup_3D_Sp
        1789             : !
        1790             : ! !DESCRIPTION: Subroutine HCO\_ArrCleanup\_3D\_Sp cleans up the given
        1791             : ! container 3D array.
        1792             : !\\
        1793             : !\\
        1794             : ! !INTERFACE:
        1795             : !
        1796           0 :   SUBROUTINE HCO_ArrCleanup_3D_Sp( Arr, DeepClean )
        1797             : !
        1798             : ! !INPUT PARAMETERS:
        1799             : !
        1800             :     TYPE(Arr3D_Sp),      POINTER  :: Arr       ! Array
        1801             :     LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate array?
        1802             : !
        1803             : ! !REVISION HISTORY:
        1804             : !  20 Apr 2013 - C. Keller - Initial version
        1805             : !  See https://github.com/geoschem/hemco for complete history
        1806             : !EOP
        1807             : !------------------------------------------------------------------------------
        1808             : !BOC
        1809             : !
        1810             : ! !LOCAL VARIABLES:
        1811             : !
        1812             :     LOGICAL :: DC
        1813             :
        1814             :     ! ================================================================
        1815             :     ! HCO_ArrCleanup_3D_Sp begins here
        1816             :     ! ================================================================
        1817           0 :     IF ( ASSOCIATED( Arr ) ) THEN
        1818             :
        1819             :        ! Optional argument handling
        1820           0 :        DC = .TRUE.
        1821           0 :        IF ( PRESENT( DeepClean ) ) DC = DeepClean
        1822             :
        1823             :        ! Finalize Arr%Val and Arr
        1824           0 :        CALL HCO_ValCleanup( Arr%Val, Arr%Alloc, DeepClean=DC )
        1825           0 :        DEALLOCATE( Arr )
        1826             :     ENDIF
        1827             :
        1828           0 :   END SUBROUTINE HCO_ArrCleanup_3D_Sp
        1829             : !EOC
        1830             : !------------------------------------------------------------------------------
        1831             : !                   Harmonized Emissions Component (HEMCO)                    !
        1832             : !------------------------------------------------------------------------------
        1833             : !BOP
        1834             : !
        1835             : ! !IROUTINE: HCO_ArrVecCleanup_2D_Hp
        1836             : !
        1837             : ! !DESCRIPTION: Subroutine HCO\_ArrVecCleanup\_2D\_Hp cleans up the given
        1838             : ! container 2D array vector.
        1839             : !\\
        1840             : !\\
        1841             : ! !INTERFACE:
        1842             : !
        1843           0 :   SUBROUTINE HCO_ArrVecCleanup_2D_Hp( ArrVec, DeepClean )
        1844             : !
        1845             : ! !INPUT PARAMETERS:
        1846             : !
        1847             :     TYPE(Arr2D_Hp),      POINTER  :: ArrVec(:) ! Array
        1848             :     LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate array?
        1849             : !
        1850             : ! !REVISION HISTORY:
        1851             : !  20 Apr 2013 - C. Keller - Initial version
        1852             : !  See https://github.com/geoschem/hemco for complete history
        1853             : !EOP
        1854             : !------------------------------------------------------------------------------
        1855             : !BOC
        1856             : !
        1857             : ! !LOCAL VARIABLES:
        1858             : !
        1859             :     LOGICAL :: DC
        1860             :     INTEGER :: I
        1861             :
        1862             :     ! ================================================================
        1863             :     ! HCO_ArrVecCleanup_2D_Hp begins here
        1864             :     ! ================================================================
        1865           0 :     IF ( ASSOCIATED( ArrVec ) ) THEN
        1866             :
        1867             :        ! Optional argument handling
        1868           0 :        DC = .TRUE.
        1869           0 :        IF ( PRESENT(DeepClean) ) DC = DeepClean
        1870             :
        1871             :        ! Finalize ArrVec
        1872           0 :        DO I = 1, SIZE(ArrVec,1)
        1873           0 :           CALL HCO_ValCleanup( ArrVec(I)%Val, ArrVec(I)%Alloc, DC )
        1874             :        ENDDO
        1875           0 :        DEALLOCATE( ArrVec )
        1876             :
        1877             :     ENDIF
        1878             :
        1879           0 :   END SUBROUTINE HCO_ArrVecCleanup_2D_Hp
        1880             : !EOC
        1881             : !------------------------------------------------------------------------------
        1882             : !                   Harmonized Emissions Component (HEMCO)                    !
        1883             : !------------------------------------------------------------------------------
        1884             : !BOP
        1885             : !
        1886             : ! !IROUTINE: HCO_ArrVecCleanup_2D_Sp
        1887             : !
        1888             : ! !DESCRIPTION: Subroutine HCO\_ArrVecCleanup\_2D\_Sp cleans up the given
        1889             : ! container 2D array vector.
        1890             : !\\
        1891             : !\\
        1892             : ! !INTERFACE:
        1893             : !
        1894           0 :   SUBROUTINE HCO_ArrVecCleanup_2D_Sp( ArrVec, DeepClean )
        1895             : !
        1896             : ! !INPUT PARAMETERS:
        1897             : !
        1898             :     TYPE(Arr2D_Sp),      POINTER  :: ArrVec(:) ! Array
        1899             :     LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate array?
        1900             : !
        1901             : ! !REVISION HISTORY:
        1902             : !  20 Apr 2013 - C. Keller - Initial version
        1903             : !  See https://github.com/geoschem/hemco for complete history
        1904             : !EOP
        1905             : !------------------------------------------------------------------------------
        1906             : !BOC
        1907             : !
        1908             : ! !LOCAL VARIABLES:
        1909             : !
        1910             :     LOGICAL :: DC
        1911             :     INTEGER :: I
        1912             :
        1913             :     ! ================================================================
        1914             :     ! HCO_ArrVecCleanup_2D_Sp begins here
        1915             :     ! ================================================================
        1916           0 :     IF ( ASSOCIATED(ArrVec) ) THEN
        1917             :
        1918             :        ! Optional argument handling
        1919           0 :        DC = .TRUE.
        1920           0 :        IF ( PRESENT( DeepClean) ) DC = DeepClean
        1921             :
        1922             :        ! Finalize ArrVec
        1923           0 :        DO I = 1, SIZE(ArrVec,1)
        1924           0 :           CALL HCO_ValCleanup( ArrVec(I)%Val, ArrVec(I)%Alloc, DC )
        1925             :        ENDDO
        1926           0 :        DEALLOCATE ( ArrVec )
        1927             :
        1928             :     ENDIF
        1929             :
        1930           0 :   END SUBROUTINE HCO_ArrVecCleanup_2D_Sp
        1931             : !EOC
        1932             : !------------------------------------------------------------------------------
        1933             : !                   Harmonized Emissions Component (HEMCO)                    !
        1934             : !------------------------------------------------------------------------------
        1935             : !BOP
        1936             : !
        1937             : ! !IROUTINE: HCO_ArrVecCleanup_3D_Hp
        1938             : !
        1939             : ! !DESCRIPTION: Subroutine HCO\_ArrVecCleanup\_3D\_Hp cleans up the given
        1940             : ! container 3D array vector.
        1941             : !\\
        1942             : !\\
        1943             : ! !INTERFACE:
        1944             : !
        1945           0 :   SUBROUTINE HCO_ArrVecCleanup_3D_Hp( ArrVec, DeepClean )
        1946             : !
        1947             : ! !INPUT PARAMETERS:
        1948             : !
        1949             :     TYPE(Arr3D_Hp),      POINTER  :: ArrVec(:) ! Array
        1950             :     LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate array?
        1951             : !
        1952             : ! !REVISION HISTORY:
        1953             : !  20 Apr 2013 - C. Keller - Initial version
        1954             : !  See https://github.com/geoschem/hemco for complete history
        1955             : !EOP
        1956             : !------------------------------------------------------------------------------
        1957             : !BOC
        1958             : !
        1959             : ! !LOCAL VARIABLES:
        1960             : !
        1961             :     LOGICAL :: DC
        1962             :     INTEGER :: I
        1963             :
        1964             :     ! ================================================================
        1965             :     ! HCO_ArrVecCleanup_3D_Hp begins here
        1966             :     ! ================================================================
        1967           0 :     IF ( ASSOCIATED( ArrVec ) ) THEN
        1968             :
        1969             :        ! Optional argument handling
        1970           0 :        DC = .TRUE.
        1971           0 :        IF ( PRESENT(DeepClean) ) DC = DeepClean
        1972             :
        1973             :        ! Finalize ArrVec
        1974           0 :        DO I = 1, SIZE(ArrVec,1)
        1975           0 :           CALL HCO_ValCleanup( ArrVec(I)%Val, ArrVec(I)%Alloc, DC )
        1976             :        ENDDO
        1977           0 :        DEALLOCATE ( ArrVec )
        1978             :
        1979             :     ENDIF
        1980             :
        1981           0 :   END SUBROUTINE HCO_ArrVecCleanup_3D_Hp
        1982             : !EOC
        1983             : !------------------------------------------------------------------------------
        1984             : !                   Harmonized Emissions Component (HEMCO)                    !
        1985             : !------------------------------------------------------------------------------
        1986             : !BOP
        1987             : !
        1988             : ! !IROUTINE: HCO_ArrVecCleanup_3D_Sp
        1989             : !
        1990             : ! !DESCRIPTION: Subroutine HCO\_ArrVecCleanup\_3D\_Sp cleans up the given
        1991             : ! container 3D array vector.
        1992             : !\\
        1993             : !\\
        1994             : ! !INTERFACE:
        1995             : !
        1996           0 :   SUBROUTINE HCO_ArrVecCleanup_3D_Sp( ArrVec, DeepClean )
        1997             : !
        1998             : ! !INPUT PARAMETERS:
        1999             : !
        2000             :     TYPE(Arr3D_Sp),      POINTER  :: ArrVec(:) ! Array
        2001             :     LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate array?
        2002             : !
        2003             : ! !REVISION HISTORY:
        2004             : !  20 Apr 2013 - C. Keller - Initial version
        2005             : !  See https://github.com/geoschem/hemco for complete history
        2006             : !EOP
        2007             : !------------------------------------------------------------------------------
        2008             : !BOC
        2009             : !
        2010             : ! !LOCAL VARIABLES:
        2011             : !
        2012             :     LOGICAL :: DC
        2013             :     INTEGER :: I
        2014             :
        2015             :     ! ================================================================
        2016             :     ! HCO_ArrVecCleanup_3D_Sp begins here
        2017             :     ! ================================================================
        2018           0 :     IF ( ASSOCIATED( ArrVec ) ) THEN
        2019             :
        2020             :        ! Optional argument handling
        2021           0 :        DC = .TRUE.
        2022           0 :        IF ( PRESENT(DeepClean) ) DC = DeepClean
        2023             :
        2024             :        ! Finalize ArrVec
        2025           0 :        DO I = 1, SIZE(ArrVec,1)
        2026           0 :           CALL HCO_ValCleanup( ArrVec(I)%Val, ArrVec(I)%Alloc, DC )
        2027             :        ENDDO
        2028           0 :        DEALLOCATE ( ArrVec )
        2029             :
        2030             :     ENDIF
        2031             :
        2032           0 :   END SUBROUTINE HCO_ArrVecCleanup_3D_Sp
        2033             : !EOC
        2034             : !------------------------------------------------------------------------------
        2035             : !                   Harmonized Emissions Component (HEMCO)                    !
        2036             : !------------------------------------------------------------------------------
        2037             : !BOP
        2038             : !
        2039             : ! !IROUTINE: HCO_ValCleanup_2D_Dp
        2040             : !
        2041             : ! !DESCRIPTION: Subroutine HCO\_ValCleanup\_2D\_Dp cleans up the given
        2042             : ! container 2D array. If DeepClean is set to TRUE and the array is
        2043             : ! indeed allocated (as determined by the Alloc flag), the array becomes
        2044             : ! deallocated. Otherwise, it is just nullified.
        2045             : !\\
        2046             : !\\
        2047             : ! !INTERFACE:
        2048             : !
        2049           0 :   SUBROUTINE HCO_ValCleanup_2D_Dp( Val, Alloc, DeepClean )
        2050             : !
        2051             : ! !INPUT PARAMETERS:
        2052             : !
        2053             :     LOGICAL, INTENT(IN) :: Alloc     ! Allocated?
        2054             :     LOGICAL, INTENT(IN) :: DeepClean ! Deallocate array?
        2055             : !
        2056             : ! !INPUT/OUTPUT PARAMETERS:
        2057             : !
        2058             :     REAL(dp), POINTER   :: Val(:,:)  ! Array
        2059             : !
        2060             : ! !REVISION HISTORY:
        2061             : !  20 Apr 2013 - C. Keller - Initial version
        2062             : !  See https://github.com/geoschem/hemco for complete history
        2063             : !EOP
        2064             : !------------------------------------------------------------------------------
        2065             : !BOC
        2066           0 :     IF ( DeepClean .AND. ASSOCIATED(Val) .AND. Alloc ) THEN
        2067           0 :        DEALLOCATE( Val )
        2068             :     ENDIF
        2069           0 :     Val => NULL()
        2070             :
        2071           0 :   END SUBROUTINE HCO_ValCleanup_2D_Dp
        2072             : !EOC
        2073             : !------------------------------------------------------------------------------
        2074             : !                   Harmonized Emissions Component (HEMCO)                    !
        2075             : !------------------------------------------------------------------------------
        2076             : !BOP
        2077             : !
        2078             : ! !IROUTINE: HCO_ValCleanup_2D_Sp
        2079             : !
        2080             : ! !DESCRIPTION: Subroutine HCO\_ValCleanup\_2D\_Sp cleans up the given
        2081             : ! container 2D array. If DeepClean is set to TRUE and the array is
        2082             : ! indeed allocated (as determined by the Alloc flag), the array becomes
        2083             : ! deallocated. Otherwise, it is just nullified.
        2084             : !\\
        2085             : !\\
        2086             : ! !INTERFACE:
        2087             : !
        2088           0 :   SUBROUTINE HCO_ValCleanup_2D_Sp( Val, Alloc, DeepClean )
        2089             : !
        2090             : ! !INPUT PARAMETERS:
        2091             : !
        2092             :     LOGICAL,  INTENT(IN) :: Alloc     ! Allocated?
        2093             :     LOGICAL,  INTENT(IN) :: DeepClean ! Deallocate array?
        2094             : !
        2095             : ! !INPUT/OUTPUT PARAMETERS:
        2096             : !
        2097             :     REAL(sp), POINTER    :: Val(:,:)  ! Array
        2098             : !
        2099             : ! !REVISION HISTORY:
        2100             : !  20 Apr 2013 - C. Keller - Initial version
        2101             : !  See https://github.com/geoschem/hemco for complete history
        2102             : !EOP
        2103             : !------------------------------------------------------------------------------
        2104             : !BOC
        2105           0 :     IF ( DeepClean .AND. ASSOCIATED(Val) .AND. Alloc ) THEN
        2106           0 :        DEALLOCATE( Val )
        2107             :     ENDIF
        2108           0 :     Val => NULL()
        2109             :
        2110           0 :   END SUBROUTINE HCO_ValCleanup_2D_Sp
        2111             : !EOC
        2112             : !------------------------------------------------------------------------------
        2113             : !                   Harmonized Emissions Component (HEMCO)                    !
        2114             : !------------------------------------------------------------------------------
        2115             : !BOP
        2116             : !
        2117             : ! !IROUTINE: HCO_ValCleanup_2D_I
        2118             : !
        2119             : ! !DESCRIPTION: Subroutine HCO\_ValCleanup\_2D\_I cleans up the given
        2120             : ! container 2D array. If DeepClean is set to TRUE and the array is
        2121             : ! indeed allocated (as determined by the Alloc flag), the array becomes
        2122             : ! deallocated. Otherwise, it is just nullified.
        2123             : !\\
        2124             : !\\
        2125             : ! !INTERFACE:
        2126             : !
        2127           0 :   SUBROUTINE HCO_ValCleanup_2D_I( Val, Alloc, DeepClean )
        2128             : !
        2129             : ! !INPUT PARAMETERS:
        2130             : !
        2131             :     LOGICAL, INTENT(IN) :: Alloc     ! Allocated?
        2132             :     LOGICAL, INTENT(IN) :: DeepClean ! Deallocate array?
        2133             : !
        2134             : ! !INPUT/OUTPUT PARAMETERS:
        2135             : !
        2136             :     INTEGER, POINTER    :: Val(:,:)  ! Array
        2137             : !
        2138             : ! !REVISION HISTORY:
        2139             : !  20 Apr 2013 - C. Keller - Initial version
        2140             : !  See https://github.com/geoschem/hemco for complete history
        2141             : !EOP
        2142             : !------------------------------------------------------------------------------
        2143             : !BOC
        2144           0 :     IF ( DeepClean .AND. ASSOCIATED(Val) .AND. Alloc ) THEN
        2145           0 :        DEALLOCATE( Val )
        2146             :     ENDIF
        2147           0 :     Val => NULL()
        2148             :
        2149           0 :   END SUBROUTINE HCO_ValCleanup_2D_I
        2150             : !EOC
        2151             : !------------------------------------------------------------------------------
        2152             : !                   Harmonized Emissions Component (HEMCO)                    !
        2153             : !------------------------------------------------------------------------------
        2154             : !BOP
        2155             : !
        2156             : ! !IROUTINE: HCO_ValCleanup_3D_Dp
        2157             : !
        2158             : ! !DESCRIPTION: Subroutine HCO\_ValCleanup\_3D\_Dp cleans up the given
        2159             : ! container 3D array. If DeepClean is set to TRUE and the array is
        2160             : ! indeed allocated (as determined by the Alloc flag), the array becomes
        2161             : ! deallocated. Otherwise, it is just nullified.
        2162             : !\\
        2163             : !\\
        2164             : ! !INTERFACE:
        2165             : !
        2166           0 :   SUBROUTINE HCO_ValCleanup_3D_Dp( Val, Alloc, DeepClean )
        2167             : !
        2168             : ! !INPUT PARAMETERS:
        2169             : !
        2170             :     LOGICAL,  INTENT(IN) :: Alloc      ! Allocated?
        2171             :     LOGICAL,  INTENT(IN) :: DeepClean  ! Deallocate array?
        2172             : !
        2173             : ! !INPUT/OUTPUT PARAMETERS:
        2174             : !
        2175             :     REAL(dp), POINTER    :: Val(:,:,:) ! Array
        2176             : !
        2177             : ! !REVISION HISTORY:
        2178             : !  20 Apr 2013 - C. Keller - Initial version
        2179             : !  See https://github.com/geoschem/hemco for complete history
        2180             : !EOP
        2181             : !------------------------------------------------------------------------------
        2182             : !BOC
        2183           0 :     IF ( DeepClean .AND. ASSOCIATED(Val) .AND. Alloc ) THEN
        2184           0 :        DEALLOCATE( Val )
        2185             :     ENDIF
        2186           0 :     Val => NULL()
        2187             :
        2188           0 :   END SUBROUTINE HCO_ValCleanup_3D_Dp
        2189             : !EOC
        2190             : !------------------------------------------------------------------------------
        2191             : !                   Harmonized Emissions Component (HEMCO)                    !
        2192             : !------------------------------------------------------------------------------
        2193             : !BOP
        2194             : !
        2195             : ! !IROUTINE: HCO_ValCleanup_3D_Sp
        2196             : !
        2197             : ! !DESCRIPTION: Subroutine HCO\_ValCleanup\_3D\_Sp cleans up the given
        2198             : ! container 3D array. If DeepClean is set to TRUE and the array is
        2199             : ! indeed allocated (as determined by the Alloc flag), the array becomes
        2200             : ! deallocated. Otherwise, it is just nullified.
        2201             : !\\
        2202             : !\\
        2203             : ! !INTERFACE:
        2204             : !
        2205           0 :   SUBROUTINE HCO_ValCleanup_3D_Sp( Val, Alloc, DeepClean )
        2206             : !
        2207             : ! !INPUT PARAMETERS:
        2208             : !
        2209             :     LOGICAL,  INTENT(IN) :: Alloc      ! Allocated?
        2210             :     LOGICAL,  INTENT(IN) :: DeepClean  ! Deallocate array?
        2211             : !
        2212             : ! !INPUT/OUTPUT PARAMETERS:
        2213             : !
        2214             :     REAL(sp), POINTER    :: Val(:,:,:) ! Array
        2215             : !
        2216             : ! !REVISION HISTORY:
        2217             : !  20 Apr 2013 - C. Keller - Initial version
        2218             : !  See https://github.com/geoschem/hemco for complete history
        2219             : !EOP
        2220             : !------------------------------------------------------------------------------
        2221             : !BOC
        2222           0 :     IF ( DeepClean .AND. ASSOCIATED(Val) .AND. Alloc ) THEN
        2223           0 :        DEALLOCATE( Val )
        2224             :     ENDIF
        2225           0 :     Val => NULL()
        2226             :
        2227           0 :   END SUBROUTINE HCO_ValCleanup_3D_Sp
        2228             : !EOC
        2229           0 : END MODULE HCO_Arr_Mod

Generated by: LCOV version 1.14