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

              Line data    Source code
           1             : !------------------------------------------------------------------------------
           2             : !                   Harmonized Emissions Component (HEMCO)                    !
           3             : !------------------------------------------------------------------------------
           4             : !BOP
           5             : !
           6             : ! !MODULE: hco_readlist_mod.F90
           7             : !
           8             : ! !DESCRIPTION: Module HCO\_ReadList\_Mod contains routines and variables
           9             : ! for the HEMCO ReadList. ReadList is a collection of all data containers
          10             : ! used by HEMCO. They are categorized according to their reading update
          11             : ! frequency, i.e all data containers that need to be updated on an annual
          12             : ! basis are stored in ReadList 'Year', etc. The following reading update
          13             : ! frequencies are supported:
          14             : !\\
          15             : !\\
          16             : ! \begin{itemize}
          17             : ! \item Year: update every year (annual data)
          18             : ! \item Month: update every month (monthly data)
          19             : ! \item Day: update every day (daily data)
          20             : ! \item Hour: update every hour (hourly data)
          21             : ! \item Hour3: update every 3 hours (3-hourly data)
          22             : ! \item Once: update only once (time-invariant data)
          23             : ! \item Always: update every time step
          24             : ! \end{itemize}
          25             : !
          26             : ! !INTERFACE:
          27             : !
          28             : MODULE HCO_ReadList_Mod
          29             : !
          30             : ! !USES:
          31             : !
          32             :   USE HCO_Types_Mod
          33             :   USE HCO_Error_MOD
          34             :   USE HCO_State_MOD,    ONLY : HCO_State
          35             :
          36             :   IMPLICIT NONE
          37             :   PRIVATE
          38             : !
          39             : ! !PUBLIC MEMBER FUNCTIONS:
          40             : !
          41             :   PUBLIC  :: ReadList_Init
          42             :   PUBLIC  :: ReadList_Read
          43             :   PUBLIC  :: ReadList_Set
          44             :   PUBLIC  :: ReadList_Print
          45             :   PUBLIC  :: ReadList_Cleanup
          46             :   PUBLIC  :: ReadList_Remove
          47             : !
          48             : ! !PRIVATE MEMBER FUNCTIONS:
          49             : !
          50             :   PRIVATE :: DtCont_Add
          51             :   PRIVATE :: ReadList_Fill
          52             : !
          53             : ! !REVISION HISTORY:
          54             : !  20 Apr 2013 - C. Keller   - Initial version
          55             : !  See https://github.com/geoschem/hemco for complete history
          56             : !EOP
          57             : !-----------------------------------------------------------------------------
          58             : !BOC
          59             : !
          60             : ! !PRIVATE TYPES:
          61             : !
          62             : CONTAINS
          63             : !EOC
          64             : !------------------------------------------------------------------------------
          65             : !                   Harmonized Emissions Component (HEMCO)                    !
          66             : !------------------------------------------------------------------------------
          67             : !BOP
          68             : !
          69             : ! !IROUTINE: ReadList_Set
          70             : !
          71             : ! !DESCRIPTION: Subroutine ReadList\_Set places the passed data container
          72             : ! Dct in one of the reading lists, according to the data update
          73             : ! frequency specified in the HEMCO configuration file. Containers are
          74             : ! sorted with increasing container ID.
          75             : !\\
          76             : !\\
          77             : ! !INTERFACE:
          78             : !
          79           0 :   SUBROUTINE ReadList_Set( HcoState, Dct, RC )
          80             : !
          81             : ! !USES:
          82             : !
          83             :     USE HCO_LOGFILE_MOD, ONLY : HCO_PrintDataCont
          84             : !
          85             : ! !INPUT/OUTPUT PARAMETERS:
          86             : !
          87             :     TYPE(HCO_State),  POINTER        :: HcoState
          88             :     TYPE(DataCont),   POINTER        :: Dct
          89             :     INTEGER,          INTENT(INOUT)  :: RC
          90             : !
          91             : ! !REVISION HISTORY:
          92             : !  20 Apr 2013 - C. Keller - Initial version
          93             : !  See https://github.com/geoschem/hemco for complete history
          94             : !EOP
          95             : !------------------------------------------------------------------------------
          96             : !BOC
          97             : !
          98             : ! !LOCAL VARIABLES:
          99             : !
         100             :     INTEGER            :: intv
         101             :     LOGICAL            :: verb
         102             :     CHARACTER(LEN=255) :: MSG, LOC
         103             :
         104             :     ! ================================================================
         105             :     ! ReadList_Set begins here
         106             :     ! ================================================================
         107           0 :     LOC = 'ReadList_Set (HCO_READLIST_MOD.F90)'
         108             :
         109             :     ! For error handling
         110           0 :     CALL HCO_ENTER (HcoState%Config%Err, LOC, RC )
         111           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         112           0 :         CALL HCO_ERROR( 'ERROR 0', RC, THISLOC=LOC )
         113           0 :         RETURN
         114             :     ENDIF
         115             :
         116             :     ! Verbose mode
         117           0 :     verb = HCO_IsVerb( HcoState%Config%Err )
         118             :
         119             :     ! Add container to ReadList according to update freqency.
         120             :     ! Fields in list 'Hour' will be updated (i.e. re-read) every hour,
         121             :     ! fields in list 'Day' every day, etc.
         122             :     ! If a time range instead of a single time stamp is given,
         123             :     ! categorize the field according to the most rapidly changing time
         124             :     ! stamp.
         125             :     ! If no time attribute exist, put the field into the 'Once' list
         126             :     ! which reads the file only at the beginning. Similarly, fields
         127             :     ! with an update flag of 'always' will be put into the 'Always'
         128             :     ! list. The always update flag is set in routine HCO_ExtractTime,
         129             :     ! which is called from Config_ReadCont (hco_config_mod.F90).
         130           0 :     IF     ( Dct%Dta%UpdtFlag == HCO_UFLAG_ALWAYS ) THEN
         131             :        intv = 1
         132           0 :     ELSEIF ( Dct%Dta%UpdtFlag == HCO_UFLAG_3HR ) THEN
         133             :        intv = 7
         134           0 :     ELSEIF ( Dct%Dta%ncHrs(1) /= Dct%Dta%ncHrs(2) ) THEN
         135             :        intv = 2
         136           0 :     ELSEIF ( Dct%Dta%ncDys(1) /= Dct%Dta%ncDys(2) ) THEN
         137             :        intv = 3
         138           0 :     ELSEIF ( Dct%Dta%ncMts(1) /= Dct%Dta%ncMts(2) ) THEN
         139             :        intv = 4
         140           0 :     ELSEIF ( Dct%Dta%ncYrs(1) /= Dct%Dta%ncYrs(2) ) THEN
         141             :        intv = 5
         142             :     ELSE
         143           0 :        intv = 6
         144             :     ENDIF
         145             :
         146             :     ! NOTE: In an ESMF environment, data I/O is organized through
         147             :     ! ESMF/MAPL. The hemco reading call (HCOIO_DATAREAD) sets a
         148             :     ! pointer of the data container array to the data array provided
         149             :     ! by MAPL. These arrays are already interpolated / updated (over
         150             :     ! time) by MAPL, and a pointer needs to be established only once.
         151             :     ! Hence, make sure that all containers are added to the one-time
         152             :     ! reading list!
         153           0 :     IF ( HcoState%Options%isESMF .AND. Dct%Dta%ncRead ) THEN
         154           0 :        intv = 6
         155             :     ENDIF
         156             :
         157             :     ! Special handling of data with 'EXACT' or 'RANGE' flag:
         158             :     ! These data sets should be evaluated whenever the data
         159             :     ! changes (to see if it still falls within the selected
         160             :     ! time window).
         161           0 :     IF ( Dct%Dta%CycleFlag == HCO_CFLAG_RANGE .OR. &
         162             :          Dct%Dta%CycleFlag == HCO_CFLAG_EXACT ) THEN
         163           0 :        IF ( intv == 6 ) THEN
         164           0 :           IF ( Dct%Dta%ncHrs(1) == -1 .OR. &
         165             :                Dct%Dta%ncHrs(1) /= Dct%Dta%ncHrs(2) ) THEN
         166             :              intv = 2
         167           0 :           ELSEIF ( Dct%Dta%ncDys(1) == -1 .OR. &
         168             :                Dct%Dta%ncDys(1) /= Dct%Dta%ncDys(2) ) THEN
         169             :              intv = 3
         170           0 :           ELSEIF ( Dct%Dta%ncMts(1) == -1 .OR. &
         171             :                Dct%Dta%ncMts(1) /= Dct%Dta%ncMts(2) ) THEN
         172             :              intv = 4
         173           0 :           ELSEIF ( Dct%Dta%ncYrs(1) == -1 .OR. &
         174             :                Dct%Dta%ncYrs(1) /= Dct%Dta%ncYrs(2) ) THEN
         175             :              intv = 5
         176             :           ! Read always
         177             :           ELSE
         178             :              intv = 1
         179             :           ENDIF
         180             :        ENDIF
         181             :     ENDIF
         182             :
         183             :     ! Add to ReadList according to interval flag
         184           0 :     IF (     intv == 1 ) THEN
         185           0 :        CALL DtCont_Add( HcoState%ReadLists%Always, Dct )
         186           0 :     ELSEIF ( intv == 2 ) THEN
         187           0 :        CALL DtCont_Add( HcoState%ReadLists%Hour,   Dct )
         188           0 :     ELSEIF ( intv == 3 ) THEN
         189           0 :        CALL DtCont_Add( HcoState%ReadLists%Day,    Dct )
         190           0 :     ELSEIF ( intv == 4 ) THEN
         191           0 :        CALL DtCont_Add( HcoState%ReadLists%Month,  Dct )
         192           0 :     ELSEIF ( intv == 5 ) THEN
         193           0 :        CALL DtCont_Add( HcoState%ReadLists%Year,   Dct )
         194           0 :     ELSEIF (intv == 7 ) THEN
         195           0 :        CALL DtCont_Add( HcoState%ReadLists%Hour3,  Dct )
         196             :     ELSE
         197           0 :        CALL DtCont_Add( HcoState%ReadLists%Once,   Dct )
         198             :     ENDIF
         199             :
         200             :     ! Verbose
         201           0 :     IF ( Verb ) THEN
         202           0 :        WRITE(MSG,*) 'New container set to ReadList:'
         203           0 :        CALL HCO_MSG(HcoState%Config%Err, MSG)
         204           0 :        CALL HCO_PrintDataCont( HcoState, Dct )
         205             :     ENDIF
         206             :
         207             :     ! Leave w/ success
         208           0 :     CALL HCO_LEAVE ( HcoState%Config%Err, RC )
         209             :
         210             :   END SUBROUTINE ReadList_Set
         211             : !EOC
         212             : !------------------------------------------------------------------------------
         213             : !                   Harmonized Emissions Component (HEMCO)                    !
         214             : !------------------------------------------------------------------------------
         215             : !BOP
         216             : !
         217             : ! !IROUTINE: ReadList_Read
         218             : !
         219             : ! !DESCRIPTION: Subroutine ReadList\_Read makes sure that all arrays in the
         220             : ! reading lists are up to date, i.e. it invokes the data reading calls for
         221             : ! those lists that need to be refreshed.
         222             : !\\
         223             : !\\
         224             : ! !INTERFACE:
         225             : !
         226           0 :   SUBROUTINE ReadList_Read( HcoState, RC, ReadAll )
         227             : !
         228             : ! !USES:
         229             : !
         230             :     USE HCO_CLOCK_MOD, ONLY : HcoClock_NewYear
         231             :     USE HCO_CLOCK_MOD, ONLY : HcoClock_NewMonth
         232             :     USE HCO_CLOCK_MOD, ONLY : HcoClock_NewDay
         233             :     USE HCO_CLOCK_MOD, ONLY : HcoClock_NewHour
         234             :     USE HCO_CLOCK_MOD, ONLY : HcoClock_New3Hour
         235             :     USE HCO_CLOCK_MOD, ONLY : HcoClock_First
         236             : !
         237             : ! !INPUT PARAMETERS:
         238             : !
         239             :     LOGICAL, OPTIONAL, INTENT(IN   )  :: ReadAll    ! read all fields?
         240             : !
         241             : ! !INPUT/OUTPUT PARAMETERS:
         242             : !
         243             :     TYPE(HCO_State),   POINTER        :: HcoState   ! HEMCO state object
         244             :     INTEGER,           INTENT(INOUT)  :: RC         ! Success or failure?
         245             : !
         246             : ! !REVISION HISTORY:
         247             : !  20 Apr 2013 - C. Keller - Initial version
         248             : !  See https://github.com/geoschem/hemco for complete history
         249             : !EOP
         250             : !------------------------------------------------------------------------------
         251             : !BOC
         252             : !
         253             : ! !LOCAL VARIABLES:
         254             : !
         255             :     LOGICAL            :: verb, RdAll
         256             :     CHARACTER(LEN=255) :: MSG
         257             :     CHARACTER(LEN=255) :: LOC = 'ReadList_Read (HCO_ReadList_Mod.F90)'
         258             :
         259             :     ! ================================================================
         260             :     ! ReadList_Read begins here
         261             :     ! ================================================================
         262             :
         263             :     ! For error handling
         264           0 :     CALL HCO_ENTER ( HcoState%Config%Err, LOC, RC )
         265           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         266           0 :        MSG = 'Error in HCO_ENTER called from HEMCO ReadList_Read'
         267           0 :        CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         268           0 :        RETURN
         269             :     ENDIF
         270             :
         271             :     ! Verbose mode
         272           0 :     verb = HCO_IsVerb( HcoState%Config%Err )
         273             :
         274             :     ! Read all fields?
         275           0 :     RdAll = .FALSE.
         276           0 :     IF ( PRESENT(ReadAll) ) RdAll = ReadAll
         277             :     ! Now use internal counter to determine first-time reading
         278             :     ! (ckeller, 02/07/2019).
         279             :     !IF ( HcoClock_First( HcoState%Clock, .FALSE. ) ) RdAll = .TRUE.
         280           0 :     IF ( HcoState%ReadLists%Counter == 0 ) RdAll = .TRUE.
         281             :
         282             :     ! Read content from one-time list on the first call
         283           0 :     IF ( RdAll ) THEN
         284           0 :        IF ( Verb ) THEN
         285           0 :           WRITE(MSG,*) 'Now reading once list!'
         286           0 :           CALL HCO_MSG(HcoState%Config%Err,MSG)
         287             :        ENDIF
         288           0 :        CALL ReadList_Fill( HcoState, HcoState%ReadLists%Once, RC )
         289           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         290           0 :           MSG = 'Error in ReadList_Fill (1) called from HEMCO ReadList_Read'
         291           0 :           CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         292           0 :           RETURN
         293             :        ENDIF
         294             :     ENDIF
         295             :
         296             :     ! Read content from year list if it's a new year
         297           0 :     IF ( HcoClock_NewYear( HcoState%Clock, .FALSE. ) .OR. RdAll ) THEN
         298           0 :        IF ( Verb ) THEN
         299           0 :           WRITE(MSG,*) 'Now reading year list!'
         300           0 :           CALL HCO_MSG(HcoState%Config%Err,MSG)
         301             :        ENDIF
         302           0 :        CALL ReadList_Fill( HcoState, HcoState%ReadLists%Year, RC )
         303           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         304           0 :           MSG = 'Error in ReadList_Fill (2) called from HEMCO ReadList_Read'
         305           0 :           CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         306           0 :           RETURN
         307             :        ENDIF
         308             :     ENDIF
         309             :
         310             :     ! Read content from month list if it's a new month
         311           0 :     IF ( HcoClock_NewMonth( HcoState%Clock, .FALSE. ) .OR. RdAll ) THEN
         312           0 :        IF ( Verb ) THEN
         313           0 :           WRITE(MSG,*) 'Now reading month list!'
         314           0 :           CALL HCO_MSG(HcoState%Config%Err,MSG)
         315             :        ENDIF
         316           0 :        CALL ReadList_Fill( HcoState, HcoState%ReadLists%Month, RC )
         317           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         318           0 :           MSG = 'Error in ReadList_Fill (3) called from HEMCO ReadList_Read'
         319           0 :           CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         320           0 :           RETURN
         321             :        ENDIF
         322             :     ENDIF
         323             :
         324             :     ! Read content from day list if it's a new day
         325           0 :     IF ( HcoClock_NewDay( HcoState%Clock, .FALSE. ) .OR. RdAll ) THEN
         326           0 :        IF ( Verb ) THEN
         327           0 :           WRITE(MSG,*) 'Now reading day list!'
         328           0 :           CALL HCO_MSG(HcoState%Config%Err,MSG)
         329             :        ENDIF
         330           0 :        CALL ReadList_Fill( HcoState, HcoState%ReadLists%Day, RC )
         331           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         332           0 :           MSG = 'Error in ReadList_Fill (4) called from HEMCO ReadList_Read'
         333           0 :           CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         334           0 :           RETURN
         335             :        ENDIF
         336             :     ENDIF
         337             :
         338             :     ! Read content from hour list if it's a new hour
         339           0 :     IF ( HcoClock_NewHour( HcoState%Clock, .FALSE. ) .OR. RdAll ) THEN
         340           0 :        IF ( Verb ) THEN
         341           0 :           WRITE(MSG,*) 'Now reading hour list!'
         342           0 :           CALL HCO_MSG(HcoState%Config%Err,MSG)
         343             :        ENDIF
         344           0 :        CALL ReadList_Fill( HcoState, HcoState%ReadLists%Hour, RC )
         345           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         346           0 :           MSG = 'Error in ReadList_Fill (5) called from HEMCO ReadList_Read'
         347           0 :           CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         348           0 :           RETURN
         349             :        ENDIF
         350             :     ENDIF
         351             :
         352             :     ! Read content from 3-hour list if it's a new hour
         353           0 :     IF ( HcoClock_New3Hour( HcoState%Clock, .FALSE. ) .OR. RdAll ) THEN
         354           0 :        IF ( Verb ) THEN
         355           0 :           WRITE(MSG,*) 'Now reading 3-hour list!'
         356           0 :           CALL HCO_MSG(HcoState%Config%Err,MSG)
         357             :        ENDIF
         358           0 :        CALL ReadList_Fill( HcoState, HcoState%ReadLists%Hour3, RC )
         359           0 :        IF ( RC /= HCO_SUCCESS ) THEN
         360           0 :           MSG = 'Error in ReadList_Fill (6) called from HEMCO ReadList_Read'
         361           0 :           CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         362           0 :           RETURN
         363             :        ENDIF
         364             :     ENDIF
         365             :
         366             :     ! Always add/update content from always-list
         367           0 :     IF ( Verb ) THEN
         368           0 :        WRITE(MSG,*) 'Now reading always list!'
         369           0 :        CALL HCO_MSG(HcoState%Config%Err,MSG)
         370             :     ENDIF
         371           0 :     CALL ReadList_Fill( HcoState, HcoState%ReadLists%Always, RC )
         372           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         373           0 :        MSG = 'Error in called ReadList_Fill (7) from HEMCO ReadList_Read'
         374           0 :        CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         375           0 :        RETURN
         376             :     ENDIF
         377             :
         378             :     ! Update counter
         379           0 :     HcoState%ReadLists%Counter = HcoState%ReadLists%Counter + 1
         380             :
         381             :     ! Leave w/ success
         382           0 :     CALL HCO_LEAVE ( HcoState%Config%Err, RC )
         383             :
         384             :   END SUBROUTINE ReadList_Read
         385             : !EOC
         386             : !------------------------------------------------------------------------------
         387             : !                   Harmonized Emissions Component (HEMCO)                    !
         388             : !------------------------------------------------------------------------------
         389             : !BOP
         390             : !
         391             : ! !IROUTINE: ReadList_Fill
         392             : !
         393             : ! !DESCRIPTION: Subroutine ReadList\_Fill (re-)reads the data from all
         394             : ! containers of the passed ReadList. In a non-ESMF environment, this
         395             : ! routine calls the HEMCO generic (netCDF) reading and remapping
         396             : ! routines. In an ESMF environment, the arrays are obtained through
         397             : ! the ESMF/MAPL software framework. ReadLIst\_Fill provides the
         398             : ! interface between HEMCO and the data reading interface. See module
         399             : ! HCOI\_DATAREAD\_MOD.F90 for more details on data reading.
         400             : !\\
         401             : !\\
         402             : ! The ReadList containers are added to EmisList immediately after data
         403             : ! filling. This has the advantage that data arrays are immediately
         404             : ! available through routine HCO\_GetPtr. This is required for country
         405             : ! mappings that depend on the country mask input field.
         406             : !\\
         407             : !\\
         408             : ! !INTERFACE:
         409             : !
         410           0 :   SUBROUTINE ReadList_Fill( HcoState, ReadList, RC )
         411             : !
         412             : ! !USES:
         413             : !
         414             :     USE HCOIO_Util_Mod,     ONLY : HCOIO_ReadOther
         415             :     USE HCOIO_Read_Mod,     ONLY : HCOIO_CloseAll
         416             :     USE HCOIO_DataRead_Mod, ONLY : HCOIO_DataRead
         417             :     USE HCO_FileData_Mod,   ONLY : FileData_ArrIsDefined
         418             :     USE HCO_FileData_Mod,   ONLY : FileData_ArrIsTouched
         419             :     USE HCO_EmisList_Mod,   ONLY : EmisList_Pass
         420             :     USE HCO_DataCont_Mod,   ONLY : DataCont_Cleanup
         421             :     USE HCO_TIDX_MOD,       ONLY : tIDx_Assign
         422             : !
         423             : ! !INPUT/OUTPUT PARAMETERS:
         424             : !
         425             :     TYPE(HCO_State), POINTER        :: HcoState   ! HEMCO state object
         426             :     TYPE(ListCont),  POINTER        :: ReadList   ! Current reading list
         427             :     INTEGER,         INTENT(INOUT)  :: RC         ! Success or failure?
         428             : !
         429             : ! !REMARKS:
         430             : !  Different HCOI_DATAREAD routines may be invoked depending on the
         431             : !  model environment.
         432             : !
         433             : ! !REVISION HISTORY:
         434             : !  20 Apr 2013 - C. Keller - Initial version
         435             : !  See https://github.com/geoschem/hemco for complete history
         436             : !EOP
         437             : !------------------------------------------------------------------------------
         438             : !BOC
         439             : !
         440             : ! !LOCAL VARIABLES:
         441             : !
         442             :     TYPE(ListCont), POINTER  :: Lct
         443             :     LOGICAL                  :: verb
         444             :     CHARACTER(LEN=255)       :: MSG
         445             :     CHARACTER(LEN=255)       :: LOC = 'ReadList_Fill (HCO_ReadList_Mod.F90)'
         446             :
         447             :     ! ================================================================
         448             :     ! ReadList_Fill begins here
         449             :     ! ================================================================
         450             :
         451             :     ! For error handling
         452           0 :     CALL HCO_ENTER (HcoState%Config%Err, LOC, RC )
         453           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         454           0 :        MSG = 'Error in HCO_ENTER called from HEMCO ReadList_Fill'
         455           0 :        CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         456           0 :        RETURN
         457             :     ENDIF
         458             :
         459             :     ! Verbose mode?
         460           0 :     verb = HCO_IsVerb ( HcoState%Config%Err )
         461             :
         462             :     ! Loop over all containers
         463           0 :     Lct => ReadList
         464           0 :     DO WHILE ( ASSOCIATED ( Lct ) )
         465             :
         466             :        ! Check if data has already been touched. Multiple data
         467             :        ! containers can have the same file data object, and we
         468             :        ! only need to read it once. For each file data object,
         469             :        ! we assign a 'home container'. Reading will only be
         470             :        ! performed on this container. The DtaHome flag is
         471             :        ! initialized to -999. Hence, the first time we read data
         472             :        ! for a given container, check if this data file object
         473             :        ! has not yet been read, in which case we define this
         474             :        ! container as the home container (flag=1). Otherwise, set
         475             :        ! flag to 0 (not home), but make sure that the DoShare flag
         476             :        ! of the corresponding data file object is enabled.
         477           0 :        IF ( Lct%Dct%DtaHome < 0 ) THEN
         478           0 :           IF ( FileData_ArrIsTouched(Lct%Dct%Dta) ) THEN
         479           0 :              Lct%Dct%DtaHome     = 0
         480           0 :              Lct%Dct%Dta%DoShare = .TRUE.
         481             :           ELSE
         482           0 :              Lct%Dct%DtaHome = 1
         483             :           ENDIF
         484             :        ENDIF
         485             :
         486             :        ! Read if this is the home container
         487           0 :        IF ( Lct%Dct%DtaHome == 1 ) THEN
         488             :
         489             :           ! Read from other source if it's not a netCDF file
         490           0 :           IF ( .NOT. Lct%Dct%Dta%NcRead ) THEN
         491           0 :              CALL HCOIO_ReadOther( HcoState, Lct, RC )
         492           0 :              IF ( RC /= HCO_SUCCESS ) THEN
         493           0 :                 MSG = 'Error in HCOIO_ReadOther called from HEMCO ReadList_Fill: ' // TRIM(Lct%Dct%cname)
         494           0 :                 CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         495           0 :                 RETURN
         496             :              ENDIF
         497             :
         498             :           ! Read from netCDF file otherwise
         499             :           ELSE
         500             :
         501             :              ! Read data
         502           0 :              CALL HCOIO_DATAREAD( HcoState, Lct, RC )
         503           0 :              IF ( RC /= HCO_SUCCESS ) THEN
         504           0 :                 MSG = 'Error in HCOIO_DATAREAD called from HEMCO ReadList_Fill: ' // TRIM(Lct%Dct%cname)
         505           0 :                 CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         506           0 :                 RETURN
         507             :              ENDIF
         508             :           ENDIF
         509             :
         510             :           ! We now have touched this data container
         511           0 :           Lct%Dct%Dta%IsTouched = .TRUE.
         512             :
         513             :        ENDIF
         514             :
         515             :        ! Pass container to EmisList (only if array is defined)
         516           0 :        IF ( FileData_ArrIsDefined(Lct%Dct%Dta) ) THEN
         517             :
         518             :           ! Set time index pointer tIDx of this data container.
         519             :           ! tIDx will be set according to the number of time slices
         520             :           ! (and the tim einterval between them) hold by this data
         521             :           ! container. For hourly data (24 time slices), for example,
         522             :           ! tIDx will point to the corresponding 'HOURLY' or
         523             :           ! 'HOURLY_GRID' time index collection type defined in
         524             :           ! hco_tidx_mod.
         525           0 :           CALL tIDx_Assign ( HcoState, Lct%Dct, RC )
         526           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         527           0 :              MSG = 'Error in tIDx_Assign called from HEMCO ReadList_Fill: ' // TRIM(Lct%Dct%cname)
         528           0 :              CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         529           0 :              RETURN
         530             :           ENDIF
         531             :
         532             :           ! Container is now read to be passed to emissions list.
         533           0 :           CALL EmisList_Pass( HcoState, Lct, RC )
         534           0 :           IF ( RC /= HCO_SUCCESS ) THEN
         535           0 :              MSG = 'Error in EmisList_Pass called from HEMCO ReadList_Fill: ' // TRIM(Lct%Dct%cname)
         536           0 :              CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         537           0 :              RETURN
         538             :           ENDIF
         539             :
         540             :        ENDIF
         541             :
         542             :        ! Advance to next container
         543           0 :        Lct => Lct%NextCont
         544             :     ENDDO
         545             :
         546             :     ! Make sure that all netCDF files are closed
         547           0 :     CALL HCOIO_CloseAll ( HcoState, RC )
         548           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         549           0 :        MSG = 'Error in HCOIO_CloseAll called from HEMCO ReadList_Fill: ' // TRIM(Lct%Dct%cname)
         550           0 :        CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         551           0 :        RETURN
         552             :     ENDIF
         553             :
         554             :     ! Second loop to clean up all data that is not used in EmisList.
         555             :     ! This cannot be done within EmisList_Pass since it is possible
         556             :     ! that some container data is used by multiple containers.
         557           0 :     Lct => ReadList
         558           0 :     DO WHILE ( ASSOCIATED(Lct) )
         559             :
         560             :        ! Remove array if not used in the emissions list
         561           0 :        IF ( .NOT. Lct%Dct%Dta%IsInList ) THEN
         562           0 :           CALL DataCont_Cleanup( Lct%Dct, ArrOnly=.TRUE. )
         563             :
         564             :           ! Verbose mode
         565           0 :           IF ( verb ) THEN
         566           0 :              MSG = 'Remove data array of ' // TRIM(Lct%Dct%cName)
         567           0 :              CALL HCO_MSG( HcoState%Config%Err, MSG )
         568             :           ENDIF
         569             :        ENDIF
         570             :
         571             :        ! Advance in list
         572           0 :        Lct => Lct%NextCont
         573             :     ENDDO
         574             :
         575             :     ! Cleanup
         576           0 :     Lct => NULL()
         577             :
         578             :     ! Leave with success
         579           0 :     CALL HCO_LEAVE ( HcoState%Config%Err, RC )
         580             :
         581             :   END SUBROUTINE ReadList_Fill
         582             : !EOC
         583             : !------------------------------------------------------------------------------
         584             : !         Harmonized Emissions Component (HEMCO)                              !
         585             : !------------------------------------------------------------------------------
         586             : !BOP
         587             : !
         588             : ! !IROUTINE: DtCont_Add
         589             : !
         590             : ! !DESCRIPTION: Subroutine DtCont\_Add adds a new container to the
         591             : ! specified reading list.
         592             : !\\
         593             : !\\
         594             : ! !INTERFACE:
         595             : !
         596           0 :   SUBROUTINE DtCont_Add( ReadList, Dct )
         597             : !
         598             : ! !INPUT PARAMETERS:
         599             : !
         600             :     TYPE(ListCont), POINTER :: ReadList
         601             :     TYPE(DataCont), POINTER :: Dct
         602             : !
         603             : ! !REVISION HISTORY:
         604             : !  20 Apr 2013 - C. Keller - Initial version
         605             : !  See https://github.com/geoschem/hemco for complete history
         606             : !EOP
         607             : !------------------------------------------------------------------------------
         608             : !BOC
         609             : !
         610             : ! !LOCAL VARIABLES:
         611             : !
         612             :     TYPE(ListCont), POINTER :: Lct
         613             :     TYPE(ListCont), POINTER :: TmpLct
         614             :     INTEGER                 :: cID
         615             :
         616             :     ! ================================================================
         617             :     ! DtCont_Add begins here
         618             :     ! ================================================================
         619             :
         620             :     ! Init
         621           0 :     Lct    => NULL()
         622           0 :     TmpLct => NULL()
         623             :
         624             :     ! Create new container (to be added to ReadList)
         625           0 :     ALLOCATE ( Lct )
         626           0 :     Lct%NextCont => NULL()
         627             :
         628             :     ! Make container point to passed data container
         629           0 :     Lct%Dct => Dct
         630             :
         631             :     ! If ReadList is not defined yet, set new container to head of
         632             :     ! list.
         633           0 :     IF ( .NOT. ASSOCIATED ( ReadList ) ) THEN
         634           0 :        ReadList => Lct
         635             :
         636             :     ! If list is already defined, place current container according
         637             :     ! to its container ID. Containers are sorted with increasing
         638             :     ! cID.
         639             :     ELSE
         640             :
         641             :        ! cID of current container
         642           0 :        cID = Lct%Dct%cID
         643             :
         644             :        ! TmpLct is the temporary pointer to the ReadList containers
         645           0 :        TmpLct => ReadList
         646             :
         647             :        ! Check if cID of first container is higher than current ID.
         648             :        ! In this case, we can place current container at beginning
         649             :        ! of list
         650           0 :        IF ( TmpLct%Dct%cID > cID ) THEN
         651           0 :           Lct%NextCont => TmpLct
         652           0 :           ReadList     => Lct
         653             :        ELSE
         654             :
         655             :           ! Loop over containers in list until we encounter first
         656             :           ! container where the upcoming container has higher cID
         657             :           ! than currCont.
         658           0 :           DO WHILE ( ASSOCIATED ( TmpLct%NextCont ) )
         659           0 :              IF ( TmpLct%NextCont%Dct%cID > cID ) EXIT
         660           0 :              TmpLct => TmpLct%NextCont
         661             :           ENDDO
         662             :
         663             :           ! Now place current container AFTER TmpLct
         664           0 :           Lct%NextCont    => TmpLct%NextCont
         665           0 :           TmpLct%NextCont => Lct
         666             :        ENDIF
         667             :     ENDIF
         668             :
         669             :     ! Cleanup
         670           0 :     TmpLct => NULL()
         671           0 :     Lct    => NULL()
         672             :
         673           0 :   END SUBROUTINE DtCont_Add
         674             : !EOC
         675             : !------------------------------------------------------------------------------
         676             : !                   Harmonized Emissions Component (HEMCO)                    !
         677             : !------------------------------------------------------------------------------
         678             : !BOP
         679             : !
         680             : ! !IROUTINE: ReadList_Init
         681             : !
         682             : ! !DESCRIPTION: Subroutine ReadList\_Init initializes the ReadList.
         683             : !\\
         684             : !\\
         685             : ! !INTERFACE:
         686             : !
         687           0 :   SUBROUTINE ReadList_Init( ReadLists, RC )
         688             : !
         689             : ! !INPUT/OUTPUT PARAMETERS:
         690             : !
         691             :     TYPE(RdList),     POINTER        :: ReadLists
         692             :     INTEGER,          INTENT(INOUT)  :: RC
         693             : !
         694             : ! !REVISION HISTORY:
         695             : !  20 Apr 2013 - C. Keller - Initial version
         696             : !  See https://github.com/geoschem/hemco for complete history
         697             : !EOP
         698             : !------------------------------------------------------------------------------
         699             : !BOC
         700             :
         701             :     CHARACTER(LEN=255) :: errMsg, thisLoc
         702             :
         703             :     ! ================================================================
         704             :     ! ReadList_Init begins here
         705             :     ! ================================================================
         706             :
         707             :     ! Initialize
         708           0 :     RC = HCO_SUCCESS
         709             :
         710             :     ! Allocate the ReadLists object (which is really HcoState%ReadLists).
         711           0 :     ALLOCATE( ReadLists, STAT=RC )
         712           0 :     IF ( RC /= HCO_SUCCESS ) THEN
         713           0 :        errMsg = 'Could not allocate ReadLists (=> HcoState%ReadLists)!'
         714           0 :        CALL HCO_Error( errMsg, RC, thisLoc )
         715           0 :        RETURN
         716             :     ENDIF
         717             :
         718             :     ! Nullify pointer fields
         719           0 :     ReadLists%Once          => NULL()
         720           0 :     ReadLists%Year          => NULL()
         721           0 :     ReadLists%Month         => NULL()
         722           0 :     ReadLists%Day           => NULL()
         723           0 :     ReadLists%Hour          => NULL()
         724           0 :     ReadLists%Hour3         => NULL()
         725           0 :     ReadLists%Always        => NULL()
         726             :
         727             :     ! No file in buffer yet
         728           0 :     ReadLists%FileInArchive = ''
         729           0 :     ReadLists%FileLun       = -1
         730             :
         731             :     ! Initialize counter
         732           0 :     ReadLists%Counter       = 0
         733             :
         734             :   END SUBROUTINE ReadList_Init
         735             : !EOC
         736             : !------------------------------------------------------------------------------
         737             : !                   Harmonized Emissions Component (HEMCO)                    !
         738             : !------------------------------------------------------------------------------
         739             : !BOP
         740             : !
         741             : ! !IROUTINE: ReadList_Print
         742             : !
         743             : ! !DESCRIPTION: Subroutine ReadList\_Print displays the content of
         744             : ! ReadList.
         745             : !\\
         746             : !\\
         747             : ! !INTERFACE:
         748             : !
         749           0 :   SUBROUTINE ReadList_Print( HcoState, ReadLists )
         750             : !
         751             : ! !USES:
         752             : !
         753             :     USE HCO_LOGFILE_MOD,  ONLY : HCO_PrintList
         754             : !
         755             : ! !INPUT ARGUMENTS
         756             : !
         757             :     TYPE(HCO_State), POINTER       :: HcoState
         758             :     TYPE(RdList),    POINTER       :: ReadLists
         759             : !
         760             : ! !REVISION HISTORY:
         761             : !  20 Apr 2013 - C. Keller - Initial version
         762             : !  See https://github.com/geoschem/hemco for complete history
         763             : !EOP
         764             : !------------------------------------------------------------------------------
         765             : !BOC
         766             :
         767             :     CHARACTER(LEN=255) :: MSG
         768             :
         769             :     ! ================================================================
         770             :     ! ReadList_Print begins here
         771             :     ! ================================================================
         772             :
         773             :     ! Nothing to do if HEMCO verbose level is below passed verbose number
         774           0 :     IF ( .NOT. HCO_IsVerb(HcoState%Config%Err ) ) RETURN
         775             :
         776             :     ! Print content of all lists
         777           0 :     IF ( ASSOCIATED(ReadLists) .and. HcoState%amIRoot ) THEN
         778             :
         779           0 :        WRITE(MSG,*) 'Contents of one-time list:'
         780           0 :        CALL HCO_MSG(HcoState%Config%Err,MSG,SEP1='=')
         781           0 :        CALL HCO_PrintList ( HcoState, ReadLists%Once )
         782             :
         783           0 :        WRITE(MSG,*) 'Contents of year list:'
         784           0 :        CALL HCO_MSG(HcoState%Config%Err,MSG,SEP1='=')
         785           0 :        CALL HCO_PrintList ( HcoState, ReadLists%Year )
         786             :
         787           0 :        WRITE(MSG,*) 'Contents of month list:'
         788           0 :        CALL HCO_MSG(HcoState%Config%Err,MSG,SEP1='=')
         789           0 :        CALL HCO_PrintList ( HcoState, ReadLists%Month )
         790             :
         791           0 :        WRITE(MSG,*) 'Contents of day list:'
         792           0 :        CALL HCO_MSG(HcoState%Config%Err,MSG,SEP1='=')
         793           0 :        CALL HCO_PrintList ( HcoState, ReadLists%Day )
         794             :
         795           0 :        WRITE(MSG,*) 'Contents of 3-hour list:'
         796           0 :        CALL HCO_MSG(HcoState%Config%Err,MSG,SEP1='=' )
         797           0 :        CALL HCO_PrintList ( HcoState, ReadLists%Hour3 )
         798             :
         799           0 :        WRITE(MSG,*) 'Contents of hour list:'
         800           0 :        CALL HCO_MSG(HcoState%Config%Err,MSG,SEP1='=')
         801           0 :        CALL HCO_PrintList ( HcoState, ReadLists%Hour )
         802             :
         803           0 :        WRITE(MSG,*) 'Contents of always-to-read list:'
         804           0 :        CALL HCO_MSG(HcoState%Config%Err,MSG,SEP1='=')
         805           0 :        CALL HCO_PrintList ( HcoState, ReadLists%Always )
         806             :
         807             :     ELSE
         808           0 :        WRITE(MSG,*) 'ReadList not defined yet!!'
         809           0 :        CALL HCO_MSG(HcoState%Config%Err,MSG,SEP1='=')
         810             :     ENDIF
         811             :
         812             :   END SUBROUTINE ReadList_Print
         813             : !EOC
         814             : !------------------------------------------------------------------------------
         815             : !                   Harmonized Emissions Component (HEMCO)                    !
         816             : !------------------------------------------------------------------------------
         817             : !BOP
         818             : !
         819             : ! !IROUTINE: ReadList_Remove
         820             : !
         821             : ! !DESCRIPTION: Subroutine ReadList\_Remove removes the container given by
         822             : ! name from the ReadList. If no container with the given name exist, nothing
         823             : ! is done. This routine returns an error if the container already holds data.
         824             : !\\
         825             : !\\
         826             : ! !INTERFACE:
         827             : !
         828           0 :   SUBROUTINE ReadList_Remove( HcoState, cName, RC )
         829             : !
         830             : ! !USES:
         831             : !
         832             : !
         833             : ! !INPUT PARAMETERS:
         834             : !
         835             :     TYPE(HCO_State),  POINTER         :: HcoState
         836             :     CHARACTER(LEN=*), INTENT(IN   )   :: cName
         837             : !
         838             : ! !INPUT/OUTPUT PARAMETERS:
         839             : !
         840             :     INTEGER,          INTENT(INOUT)   :: RC
         841             : !
         842             : ! !REVISION HISTORY:
         843             : !  13 Jan 2015 - 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             :     INTEGER                   :: I
         852             :     TYPE(ListCont), POINTER   :: This
         853             :     TYPE(ListCont), POINTER   :: Prev
         854             :     TYPE(ListCont), POINTER   :: Next
         855             :     LOGICAL                   :: FOUND
         856             :     CHARACTER(LEN=255)        :: MSG
         857             :     CHARACTER(LEN=255)        :: LOC = 'ReadList_Remove (HCO_ReadList_Mod.F90)'
         858             :
         859             :     ! ================================================================
         860             :     ! ReadList_Remove begins here
         861             :     ! ================================================================
         862             :
         863             :     ! Assume success until otherwise
         864           0 :     RC = HCO_SUCCESS
         865           0 :     IF ( .NOT. ASSOCIATED(HcoState%ReadLists) ) RETURN
         866             :
         867             :     ! Init
         868             :     This => NULL()
         869           0 :     Prev => NULL()
         870             :     Next => NULL()
         871             :
         872             :     ! Search for the given container
         873           0 :     DO I = 1,7
         874             :
         875             :        ! Select list to be used
         876           0 :        IF ( I == 1 ) This => HcoState%ReadLists%Once
         877           0 :        IF ( I == 2 ) This => HcoState%ReadLists%Year
         878           0 :        IF ( I == 3 ) This => HcoState%ReadLists%Month
         879           0 :        IF ( I == 4 ) This => HcoState%ReadLists%Day
         880           0 :        IF ( I == 5 ) This => HcoState%ReadLists%Hour
         881           0 :        IF ( I == 6 ) This => HcoState%ReadLists%Always
         882           0 :        IF ( I == 7 ) This => HcoState%ReadLists%Hour3
         883             :
         884             :        ! Initialize working variables
         885           0 :        FOUND = .FALSE.
         886           0 :        Prev => This
         887             :
         888             :        ! Walk through list, looking for this container
         889           0 :        DO WHILE ( ASSOCIATED(This) )
         890             :
         891             :           ! Next container in list
         892           0 :           Next => This%NextCont
         893             :
         894             :           ! Is that the container of interest?
         895           0 :           IF ( TRIM(This%Dct%cName) == TRIM(cName) ) THEN
         896           0 :              FOUND = .TRUE.
         897           0 :              EXIT
         898             :           ENDIF
         899             :
         900             :           ! Advance
         901           0 :           Prev => This
         902           0 :           This => Next
         903             :        ENDDO !This
         904             :
         905             :        ! Advance if not found
         906           0 :        IF ( .NOT. FOUND ) CYCLE
         907             :
         908             :        ! Check first if data has already been read. In this case, the data home
         909             :        ! flag is updated.
         910           0 :        IF ( This%Dct%DtaHome >= 0 ) THEN
         911             :           MSG = 'Cannot remove from ReadList. Data has already been read: ' // &
         912           0 :                 TRIM(This%Dct%cName)
         913           0 :           CALL HCO_ERROR( MSG, RC, THISLOC = LOC )
         914             :        ENDIF
         915             :
         916             :        ! Connect previous container to next container in list:
         917             :        ! - Special case that this is the first container in the list
         918           0 :        IF ( Prev%Dct%cID == This%Dct%cID ) THEN
         919           0 :           IF ( I == 1 ) HcoState%ReadLists%Once   => Next
         920           0 :           IF ( I == 2 ) HcoState%ReadLists%Year   => Next
         921           0 :           IF ( I == 3 ) HcoState%ReadLists%Month  => Next
         922           0 :           IF ( I == 4 ) HcoState%ReadLists%Day    => Next
         923           0 :           IF ( I == 5 ) HcoState%ReadLists%Hour   => Next
         924           0 :           IF ( I == 6 ) HcoState%ReadLists%Always => Next
         925           0 :           IF ( I == 7 ) HcoState%ReadLists%Hour3  => Next
         926             :
         927             :        ! - Otherwise, just pop out this container from list
         928             :        ELSE
         929           0 :           Prev%NextCont => Next
         930             :        ENDIF
         931             :
         932             :        ! Remove pointer to data container, detach this container from list
         933           0 :        This%Dct      => NULL()
         934           0 :        This%NextCont => NULL()
         935             :
         936             :        ! Deallocate this container
         937           0 :        DEALLOCATE(This)
         938             :
         939             :        ! If we make it to here, we have successfully removed the container and
         940             :        ! don't need to cycle thorugh the loop any more
         941           0 :        EXIT
         942             :
         943             :     ENDDO !
         944             :
         945             :     ! Free pointer
         946           0 :     This => NULL()
         947           0 :     Prev => NULL()
         948           0 :     Next => NULL()
         949             :
         950             :     ! Return w/ success
         951           0 :     RC = HCO_SUCCESS
         952             :
         953             :   END SUBROUTINE ReadList_Remove
         954             : !EOC
         955             : !------------------------------------------------------------------------------
         956             : !                   Harmonized Emissions Component (HEMCO)                    !
         957             : !------------------------------------------------------------------------------
         958             : !BOP
         959             : !
         960             : ! !IROUTINE: ReadList_Cleanup
         961             : !
         962             : ! !DESCRIPTION: Subroutine ReadList\_Cleanup removes all content of ReadList.
         963             : ! If RemoveDct is set to True, the content of the data containers will be
         964             : ! also removed, otherwise the corresponding pointer is just nullified.
         965             : !\\
         966             : !\\
         967             : ! !INTERFACE:
         968             : !
         969           0 :   SUBROUTINE ReadList_Cleanup( ReadLists, RemoveDct )
         970             : !
         971             : ! !USES:
         972             : !
         973             :     USE HCO_DataCont_Mod, ONLY : ListCont_Cleanup
         974             : !
         975             : ! !INPUT PARAMETERS:
         976             : !
         977             :
         978             :     LOGICAL,          INTENT(IN   )   :: RemoveDct
         979             : !
         980             : ! !INPUT/OUTPUT PARAMETERS:
         981             : !
         982             :     TYPE(RdList),     POINTER         :: ReadLists
         983             : !
         984             : ! !REVISION HISTORY:
         985             : !  20 Apr 2013 - C. Keller - Initial version
         986             : !  See https://github.com/geoschem/hemco for complete history
         987             : !EOP
         988             : !------------------------------------------------------------------------------
         989             : !BOC
         990             :
         991             :     ! ================================================================
         992             :     ! ReadList_Cleanup begins here
         993             :     ! ================================================================
         994             :
         995           0 :     IF ( ASSOCIATED(ReadLists) ) THEN
         996             :
         997             :        ! Remove all sublists in ReadList
         998           0 :        CALL ListCont_Cleanup ( ReadLists%Once,   RemoveDct )
         999           0 :        CALL ListCont_Cleanup ( ReadLists%Year,   RemoveDct )
        1000           0 :        CALL ListCont_Cleanup ( ReadLists%Month,  RemoveDct )
        1001           0 :        CALL ListCont_Cleanup ( ReadLists%Day,    RemoveDct )
        1002           0 :        CALL ListCont_Cleanup ( ReadLists%Hour,   RemoveDct )
        1003           0 :        CALL ListCont_Cleanup ( ReadLists%Hour3,  RemoveDct )
        1004           0 :        CALL ListCont_Cleanup ( ReadLists%Always, RemoveDct )
        1005             :
        1006             :        ! Remove ReadList
        1007           0 :        DEALLOCATE ( ReadLists )
        1008             :     ENDIF
        1009           0 :     ReadLists => NULL()
        1010             :
        1011           0 :   END SUBROUTINE ReadList_Cleanup
        1012             : !EOC
        1013             : END MODULE HCO_ReadList_Mod

Generated by: LCOV version 1.14