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

              Line data    Source code
           1             : !-------------------------------------------------------------------------
           2             : !  NASA/GFSC, SIVO, Code 610.3
           3             : !-------------------------------------------------------------------------
           4             : !BOP
           5             : !
           6             : ! !MODULE:  HCO_m_netcdf_io_read
           7             : !
           8             : ! !INTERFACE:
           9             : !
          10             : MODULE HCO_m_netcdf_io_read
          11             : !
          12             : ! !USES:
          13             : !
          14             :   IMPLICIT NONE
          15             :   PRIVATE
          16             : !
          17             : ! !PUBLIC MEMBER FUNCTIONS:
          18             : !
          19             :   ! Public interface
          20             :   PUBLIC :: NcRd
          21             :
          22             :   ! Private methods overloaded by public interface
          23             :   ! (see below for info about these routines & the arguments they take)
          24             :   INTERFACE NcRd
          25             :      MODULE PROCEDURE Ncrd_Scal
          26             :      MODULE PROCEDURE Ncrd_Scal_Int
          27             :      MODULE PROCEDURE Ncrd_1d_R8
          28             :      MODULE PROCEDURE Ncrd_1d_R4
          29             :      MODULE PROCEDURE Ncrd_1d_Int
          30             :      MODULE PROCEDURE Ncrd_1d_Char
          31             :      MODULE PROCEDURE Ncrd_2d_R8
          32             :      MODULE PROCEDURE Ncrd_2d_R4
          33             :      MODULE PROCEDURE Ncrd_2d_Int
          34             :      MODULE PROCEDURE Ncrd_2d_Char
          35             :      MODULE PROCEDURE Ncrd_3d_R8
          36             :      MODULE PROCEDURE Ncrd_3d_R4
          37             :      MODULE PROCEDURE Ncrd_3d_Int
          38             :      MODULE PROCEDURE Ncrd_4d_R8
          39             :      MODULE PROCEDURE Ncrd_4d_R4
          40             :      MODULE PROCEDURE Ncrd_4d_Int
          41             :      MODULE PROCEDURE Ncrd_5d_R8
          42             :      MODULE PROCEDURE Ncrd_5d_R4
          43             :      MODULE PROCEDURE Ncrd_6d_R8
          44             :      MODULE PROCEDURE Ncrd_6d_R4
          45             :      MODULE PROCEDURE Ncrd_7d_R8
          46             :      MODULE PROCEDURE Ncrd_7d_R4
          47             :   END INTERFACE NcRd
          48             : !
          49             : ! !DESCRIPTION: Routines for reading variables in a netCDF file.
          50             : !\\
          51             : !\\
          52             : ! !AUTHOR:
          53             : !  Jules Kouatchou
          54             : !
          55             : ! !REVISION HISTORY:
          56             : !  See https://github.com/geoschem/hemco for complete history
          57             : !EOP
          58             : !-------------------------------------------------------------------------
          59             : !BOC
          60             : CONTAINS
          61             : !EOC
          62             : !-------------------------------------------------------------------------
          63             : !BOP
          64             : !
          65             : ! !IROUTINE: Ncrd_Scal
          66             : !
          67             : ! !INTERFACE:
          68             : !
          69           0 :   subroutine Ncrd_Scal(varrd_scal, ncid, varname)
          70             : !
          71             : ! !USES:
          72             : !
          73             :     use netCDF
          74             :     use m_do_err_out
          75             : !
          76             : ! !INPUT PARAMETERS:
          77             : !!  ncid       : netCDF file id to read variable from
          78             : !!  varname    : netCDF variable name
          79             :     integer          , intent(in)   :: ncid
          80             :     character (len=*), intent(in)   :: varname
          81             : !
          82             : ! !OUTPUT PARAMETERS:
          83             : !!  varrd_scal : variable to fill
          84             :     real*8           , intent(out)  :: varrd_scal
          85             : !
          86             : ! !DESCRIPTION: Reads in a netCDF scalar variable.
          87             : !\\
          88             : !\\
          89             : ! !AUTHOR:
          90             : !  John Tannahill (LLNL) and Jules Kouatchou
          91             : !
          92             : ! !REVISION HISTORY:
          93             : !  See https://github.com/geoschem/hemco for complete history
          94             : !EOP
          95             : !-------------------------------------------------------------------------
          96             : !BOC
          97             : !
          98             : ! !LOCAL VARIABLES:
          99             :     character (len=512) :: err_msg
         100             :     integer             :: ierr
         101             :     integer             :: varid
         102             :     real*4              :: varrd_scal_tmp
         103             : !
         104           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
         105             :
         106           0 :     if (ierr /= NF90_NOERR) then
         107             :        err_msg = 'In Ncrd_Scal #1:  ' // Trim (varname) // &
         108           0 :             ', ' // NF90_Strerror(ierr)
         109           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
         110             :     end if
         111             :
         112           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_scal_tmp)
         113             :
         114           0 :     if (ierr /= NF90_NOERR) then
         115           0 :        err_msg = 'In Ncrd_Scal #2:  ' // NF90_Strerror(ierr)
         116           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
         117             :     end if
         118             :
         119           0 :     varrd_scal = varrd_scal_tmp
         120             :
         121           0 :     return
         122             :
         123             :   end subroutine Ncrd_Scal
         124             : !EOC
         125             : !-------------------------------------------------------------------------
         126             : !BOP
         127             : !
         128             : ! !IROUTINE: Ncrd_Scal_Int
         129             : !
         130             : ! !INTERFACE:
         131             : !
         132           0 :   subroutine Ncrd_Scal_Int(varrd_scali, ncid, varname)
         133             : !
         134             : ! !USES:
         135             : !
         136             :     use netCDF
         137             :     use m_do_err_out
         138             : !
         139             : ! !INPUT PARAMETERS:
         140             : !!  ncid       : netCDF file id to read variable from
         141             : !!  varname    : netCDF variable name
         142             :     integer          , intent(in)   :: ncid
         143             :     character (len=*), intent(in)   :: varname
         144             : !
         145             : ! !OUTPUT PARAMETERS:
         146             : !!  varrd_scali : integer variable to fill
         147             :     integer          , intent(out)  :: varrd_scali
         148             : !
         149             : ! !DESCRIPTION: Reads in a netCDF integer scalar variable.
         150             : !\\
         151             : !\\
         152             : ! !AUTHOR:
         153             : !  John Tannahill (LLNL) and Jules Kouatchou
         154             : !
         155             : ! !REVISION HISTORY:
         156             : !  See https://github.com/geoschem/hemco for complete history
         157             : !EOP
         158             : !-------------------------------------------------------------------------
         159             : !BOC
         160             : !
         161             : ! !LOCAL VARIABLES:
         162             :     character (len=512) :: err_msg
         163             :     integer             :: ierr
         164             :     integer             :: varid
         165             : !
         166           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
         167             :
         168           0 :     if (ierr /= NF90_NOERR) then
         169             :        err_msg = 'In Ncrd_Scal_Int #1:  ' // Trim (varname) // &
         170           0 :                  ', ' // NF90_Strerror(ierr)
         171           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
         172             :     end if
         173             :
         174           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_scali)
         175             :
         176           0 :     if (ierr /= NF90_NOERR) then
         177           0 :        err_msg = 'In Ncrd_Scal_Int #2:  ' // NF90_Strerror(ierr)
         178           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
         179             :     end if
         180             :
         181           0 :     return
         182             :
         183             :   end subroutine Ncrd_Scal_Int
         184             : !EOC
         185             : !-------------------------------------------------------------------------
         186             : !BOP
         187             : !
         188             : ! !IROUTINE: Ncrd_1d_R8
         189             : !
         190             : ! !INTERFACE:
         191             : !
         192           0 :   subroutine Ncrd_1d_R8(varrd_1d, ncid, varname, strt1d, cnt1d, err_stop, stat)
         193             : !
         194             : ! !USES:
         195             : !
         196             :     use netCDF
         197             :     use m_do_err_out
         198             : !
         199             : ! !INPUT PARAMETERS:
         200             : !!  ncid     : netCDF file id to read array input data from
         201             : !!  varname  : netCDF variable name for array
         202             : !!  strt1d   : vector specifying the index in varrd_1d where
         203             : !!             the first of the data values will be read
         204             : !!  cnt1d    : varrd_1d dimension
         205             :     integer          , intent(in)   :: ncid
         206             :     character (len=*), intent(in)   :: varname
         207             :     integer          , intent(in)   :: strt1d(1)
         208             :     integer          , intent(in)   :: cnt1d (1)
         209             :     logical, optional, intent(in)   :: err_stop
         210             : !
         211             : ! !OUTPUT PARAMETERS:
         212             : !!  varrd_1d : array to fill
         213             :     real*8           , intent(out)  :: varrd_1d(cnt1d(1))
         214             :     integer, optional, intent(out)  :: stat
         215             : !
         216             : ! !DESCRIPTION: Reads in a 1D netCDF real array and does some error checking.
         217             : !\\
         218             : !\\
         219             : ! !AUTHOR:
         220             : !  John Tannahill (LLNL) and Jules Kouatchou
         221             : !
         222             : ! !REVISION HISTORY:
         223             : !  See https://github.com/geoschem/hemco for complete history
         224             : !EOP
         225             : !-------------------------------------------------------------------------
         226             : !BOC
         227             : !
         228             : ! !LOCAL VARIABLES:
         229             : !
         230             :     character (len=512) :: err_msg
         231             :     integer             :: ierr
         232             :     integer             :: varid
         233             :     logical             :: dostop
         234             :
         235             :     ! set dostop flag
         236           0 :     dostop = .true.
         237           0 :     if ( present ( err_stop ) ) dostop = err_stop
         238             :
         239           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
         240             :
         241           0 :     if (ierr /= NF90_NOERR) then
         242           0 :        if ( dostop ) then
         243             :           err_msg = 'In Ncrd_1d_R8 #1:  ' // Trim (varname) // &
         244           0 :                ', ' // NF90_Strerror(ierr)
         245           0 :           call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
         246             :        else
         247           0 :           varrd_1d(:) = -999d0
         248           0 :           if ( present ( stat ) ) stat = 1
         249           0 :           return
         250             :        end if
         251             :     end if
         252             :
         253           0 :     ierr =  NF90_Get_Var(ncid, varid, varrd_1d, start=strt1d, count=cnt1d)
         254             :
         255           0 :     if (ierr /= NF90_NOERR) then
         256           0 :        if ( dostop ) then
         257           0 :           err_msg = 'In Ncrd_1d_R8 #2:  ' // NF90_Strerror(ierr)
         258           0 :           call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
         259             :        else
         260           0 :           varrd_1d(:) = -999d0
         261           0 :           if ( present ( stat ) ) stat = 2
         262           0 :           return
         263             :        endif
         264             :     end if
         265             :
         266             :     ! set stat to 0 (= success)
         267           0 :     if ( present ( stat ) ) stat = 0
         268             :
         269             :   end subroutine Ncrd_1d_R8
         270             : !EOC
         271             : !-------------------------------------------------------------------------
         272             : !BOP
         273             : !
         274             : ! !IROUTINE: Ncrd_1d_R4
         275             : !
         276             : ! !INTERFACE:
         277             : !
         278           0 :   subroutine Ncrd_1d_R4(varrd_1d, ncid, varname, strt1d, cnt1d, err_stop, stat)
         279             : !
         280             : ! !USES:
         281             : !
         282             :     use netCDF
         283             :     use m_do_err_out
         284             : !
         285             : ! !INPUT PARAMETERS:
         286             : !!  ncid     : netCDF file id to read array input data from
         287             : !!  varname  : netCDF variable name for array
         288             : !!  strt1d   : vector specifying the index in varrd_1d where
         289             : !!             the first of the data values will be read
         290             : !!  cnt1d    : varrd_1d dimension
         291             :     integer          , intent(in)   :: ncid
         292             :     character (len=*), intent(in)   :: varname
         293             :     integer          , intent(in)   :: strt1d(1)
         294             :     integer          , intent(in)   :: cnt1d (1)
         295             :     logical, optional, intent(in)   :: err_stop
         296             : !
         297             : ! !OUTPUT PARAMETERS:
         298             : !!  varrd_1d : array to fill
         299             :     real*4           , intent(out)  :: varrd_1d(cnt1d(1))
         300             :     integer, optional, intent(out)  :: stat
         301             : !
         302             : ! !DESCRIPTION: Reads in a 1D netCDF real array and does some error checking.
         303             : !\\
         304             : !\\
         305             : ! !AUTHOR:
         306             : !  John Tannahill (LLNL) and Jules Kouatchou
         307             : !
         308             : ! !REVISION HISTORY:
         309             : !  See https://github.com/geoschem/hemco for complete history
         310             : !EOP
         311             : !-------------------------------------------------------------------------
         312             : !BOC
         313             : !
         314             : ! !LOCAL VARIABLES:
         315             : !
         316             :     character (len=512) :: err_msg
         317             :     integer             :: ierr
         318             :     integer             :: varid
         319             :     logical             :: dostop
         320             :
         321             :     ! set dostop flag
         322           0 :     dostop = .true.
         323           0 :     if ( present ( err_stop ) ) dostop = err_stop
         324             :
         325           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
         326             :
         327           0 :     if (ierr /= NF90_NOERR) then
         328           0 :        if ( dostop ) then
         329             :           err_msg = 'In Ncrd_1d_R4 #1:  ' // Trim (varname) // &
         330           0 :                      ', ' // NF90_Strerror(ierr)
         331           0 :           call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
         332             :        else
         333           0 :           varrd_1d(:) = -999.0
         334           0 :           if ( present ( stat ) ) stat = 1
         335           0 :           return
         336             :        end if
         337             :     end if
         338             :
         339           0 :     ierr =  NF90_Get_Var(ncid, varid, varrd_1d, start=strt1d, count=cnt1d)
         340             :
         341           0 :     if (ierr /= NF90_NOERR) then
         342           0 :        if ( dostop ) then
         343           0 :           err_msg = 'In Ncrd_1d_R4 #2:  ' // NF90_Strerror(ierr)
         344           0 :           call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
         345             :        else
         346           0 :           varrd_1d(:) = -999.0
         347           0 :           if ( present ( stat ) ) stat = 2
         348           0 :           return
         349             :        endif
         350             :     end if
         351             :
         352             :     ! set stat to 0 (= success)
         353           0 :     if ( present ( stat ) ) stat = 0
         354             :     return
         355             :
         356             :   end subroutine Ncrd_1d_R4
         357             : !EOC
         358             : !-------------------------------------------------------------------------
         359             : !BOP
         360             : !
         361             : ! !IROUTINE: Ncrd_1d_Int
         362             : !
         363             : ! !INTERFACE:
         364             : !
         365           0 :   subroutine Ncrd_1d_Int(varrd_1di, ncid,     varname, strt1d, &
         366             :                          cnt1d,     err_stop, stat)
         367             : !
         368             : ! !USES:
         369             : !
         370             :     use netCDF
         371             :     use m_do_err_out
         372             : !
         373             : ! !INPUT PARAMETERS:
         374             : !
         375             : !!  ncid     : netCDF file id to read array input data from
         376             : !!  varname  : netCDF variable name for array
         377             : !!  strt1d   : vector specifying the index in varrd_1di where
         378             : !!             the first of the data values will be read
         379             : !!  cnt1d    : varrd_1di dimension
         380             :     integer          , intent(in)   :: ncid
         381             :     character (len=*), intent(in)   :: varname
         382             :     integer          , intent(in)   :: strt1d(1)
         383             :     integer          , intent(in)   :: cnt1d (1)
         384             :     logical, optional, intent(in)   :: err_stop
         385             : !
         386             : ! !OUTPUT PARAMETERS:
         387             : !!  varrd_1di : intger array to fill
         388             :     integer          , intent(out)  :: varrd_1di(cnt1d(1))
         389             :     integer, optional, intent(out)  :: stat
         390             : !
         391             : ! !DESCRIPTION: Reads in a 1D netCDF integer array and does some error
         392             : !  checking.
         393             : !\\
         394             : !\\
         395             : ! !AUTHOR:
         396             : !  John Tannahill (LLNL) and Jules Kouatchou
         397             : !
         398             : ! !REVISION HISTORY:
         399             : !  See https://github.com/geoschem/hemco for complete history
         400             : !EOP
         401             : !-------------------------------------------------------------------------
         402             : !BOC
         403             : !
         404             : ! !LOCAL VARIABLES:
         405             : !
         406             :     character (len=512) :: err_msg
         407             :     integer             :: ierr
         408             :     integer             :: varid
         409             :     logical             :: dostop
         410             :
         411             :     ! set dostop flag
         412           0 :     dostop = .true.
         413           0 :     if ( present ( err_stop ) ) dostop = err_stop
         414             :
         415           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
         416             :
         417           0 :     if (ierr /= NF90_NOERR) then
         418           0 :        if ( dostop ) then
         419             :           err_msg = 'In Ncrd_1d_Int #1:  ' // Trim (varname) // &
         420           0 :                     ', ' // NF90_Strerror(ierr)
         421           0 :           call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
         422             :        else
         423           0 :           varrd_1di(:) = -999
         424           0 :           if ( present ( stat ) ) stat = 1
         425           0 :           return
         426             :        end if
         427             :     end if
         428             :
         429           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_1di, start=strt1d, count=cnt1d)
         430             :
         431           0 :     if (ierr /= NF90_NOERR) then
         432           0 :        if ( dostop ) then
         433           0 :           err_msg = 'In Ncrd_1d_Int #2:  ' // NF90_Strerror(ierr)
         434           0 :           call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
         435             :        else
         436           0 :           varrd_1di(:) = -999
         437           0 :           if ( present ( stat ) ) stat = 2
         438           0 :           return
         439             :        endif
         440             :     end if
         441             :
         442             :     ! set stat to 0 (= success)
         443           0 :     if ( present ( stat ) ) stat = 0
         444             :
         445             :     return
         446             :
         447             :   end subroutine Ncrd_1d_Int
         448             : !EOC
         449             : !-------------------------------------------------------------------------
         450             : !BOP
         451             : !
         452             : ! !IROUTINE: Ncrd_2d_R8
         453             : !
         454             : ! !INTERFACE:
         455             : !
         456           0 :   subroutine Ncrd_2d_R8(varrd_2d, ncid, varname, strt2d, cnt2d)
         457             : !
         458             : ! !USES:
         459             : !
         460             :     use netCDF
         461             :     use m_do_err_out
         462             :
         463             : !!  ncid     : netCDF file id to read array input data from
         464             : !!  varname  : netCDF variable name for array
         465             : !!  strt2d   : vector specifying the index in varrd_2d where
         466             : !!               the first of the data values will be read
         467             : !!  cnt2d    : varrd_2d dimensions
         468             :     integer          , intent(in)   :: ncid
         469             :     character (len=*), intent(in)   :: varname
         470             :     integer          , intent(in)   :: strt2d(2)
         471             :     integer          , intent(in)   :: cnt2d (2)
         472             : !
         473             : ! !OUTPUT PARAMETERS:
         474             : !!  varrd_2d : array to fill
         475             :     real*8           , intent(out)  :: varrd_2d(cnt2d(1), cnt2d(2))
         476             : !
         477             : ! !DESCRIPTION: Reads in a 2D netCDF real array and does some error checking.
         478             : !\\
         479             : !\\
         480             : ! !AUTHOR:
         481             : !  John Tannahill (LLNL) and Jules Kouatchou
         482             : !
         483             : ! !REVISION HISTORY:
         484             : !  See https://github.com/geoschem/hemco for complete history
         485             : !EOP
         486             : !-------------------------------------------------------------------------
         487             : !BOC
         488             : !
         489             : ! !LOCAL VARIABLES:
         490             :     character (len=512) :: err_msg
         491             :     integer             :: ierr
         492             :     integer             :: varid
         493             : !
         494           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
         495             :
         496           0 :     if (ierr /= NF90_NOERR) then
         497             :        err_msg = 'In Ncrd_2d_R8 #1:  ' // Trim (varname) // &
         498           0 :                  ', ' // NF90_Strerror(ierr)
         499           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
         500             :     end if
         501             :
         502           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_2d, start=strt2d, count=cnt2d)
         503             :
         504           0 :     if (ierr /= NF90_NOERR) then
         505           0 :        err_msg = 'In Ncrd_2d_R8 #2:  ' // NF90_Strerror(ierr)
         506           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
         507             :     end if
         508             :
         509           0 :   end subroutine Ncrd_2d_R8
         510             : !EOC
         511             : !-------------------------------------------------------------------------
         512             : !BOP
         513             : !
         514             : ! !IROUTINE: Ncrd_2d_R4
         515             : !
         516             : ! !INTERFACE:
         517             : !
         518           0 :   subroutine Ncrd_2d_R4(varrd_2d, ncid, varname, strt2d, cnt2d)
         519             : !
         520             : ! !USES:
         521             : !
         522             :     use netCDF
         523             :     use m_do_err_out
         524             : !
         525             : ! !INPUT PARAMETERS:
         526             : !!  ncid     : netCDF file id to read array input data from
         527             : !!  varname  : netCDF variable name for array
         528             : !!  strt2d   : vector specifying the index in varrd_2d where
         529             : !!             the first of the data values will be read
         530             : !!  cnt2d    : varrd_2d dimensions
         531             :     integer          , intent(in)   :: ncid
         532             :     character (len=*), intent(in)   :: varname
         533             :     integer          , intent(in)   :: strt2d(2)
         534             :     integer          , intent(in)   :: cnt2d (2)
         535             : !
         536             : ! !OUTPUT PARAMETERS:
         537             : !!  varrd_2d : array to fill
         538             :     real*4           , intent(out)  :: varrd_2d(cnt2d(1), cnt2d(2))
         539             : !
         540             : ! !DESCRIPTION: Reads in a 2D netCDF real array and does some error checking.
         541             : !\\
         542             : !\\
         543             : ! !AUTHOR:
         544             : !  John Tannahill (LLNL) and Jules Kouatchou
         545             : !
         546             : ! !REVISION HISTORY:
         547             : !  See https://github.com/geoschem/hemco for complete history
         548             : !EOP
         549             : !-------------------------------------------------------------------------
         550             : !BOC
         551             : !
         552             : ! !LOCAL VARIABLES:
         553             :     character (len=512) :: err_msg
         554             :     integer             :: ierr
         555             :     integer             :: varid
         556             : !
         557           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
         558             :
         559           0 :     if (ierr /= NF90_NOERR) then
         560             :        err_msg = 'In Ncrd_2d_R4 #1:  ' // Trim (varname) // &
         561           0 :                   ', ' // NF90_Strerror(ierr)
         562           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
         563             :     end if
         564             :
         565           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_2d, start=strt2d, count=cnt2d)
         566             :
         567           0 :     if (ierr /= NF90_NOERR) then
         568           0 :        err_msg = 'In Ncrd_2d_R4 #2:  ' // NF90_Strerror(ierr)
         569           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
         570             :     end if
         571             :
         572           0 :   end subroutine Ncrd_2d_R4
         573             : !EOC
         574             : !-------------------------------------------------------------------------
         575             : !BOP
         576             : !
         577             : ! !IROUTINE: Ncrd_2d_Int
         578             : !
         579             : ! !INTERFACE:
         580             : !
         581           0 :   subroutine Ncrd_2d_Int(varrd_2di, ncid, varname, strt2d, cnt2d)
         582             : !
         583             : ! !USES:
         584             : !
         585             :     use netCDF
         586             :     use m_do_err_out
         587             : !
         588             : ! !INPUT PARAMETERS:
         589             : !!  ncid     : netCDF file id to read array input data from
         590             : !!  varname  : netCDF variable name for array
         591             : !!  strt2d   : vector specifying the index in varrd_2d where
         592             : !!             the first of the data values will be read
         593             : !!  cnt2d    : varrd_2di dimensions
         594             :     integer          , intent(in)   :: ncid
         595             :     character (len=*), intent(in)   :: varname
         596             :     integer          , intent(in)   :: strt2d(2)
         597             :     integer          , intent(in)   :: cnt2d (2)
         598             : !
         599             : ! !OUTPUT PARAMETERS:
         600             : !!  varrd_2di : intger array to fill
         601             :     integer          , intent(out)  :: varrd_2di(cnt2d(1), cnt2d(2))
         602             : !
         603             : ! !DESCRIPTION: Reads in a 2D netCDF integer array and does some error
         604             : !  checking.
         605             : !\\
         606             : !\\
         607             : ! !AUTHOR:
         608             : !  John Tannahill (LLNL) and Jules Kouatchou
         609             : !
         610             : ! !REVISION HISTORY:
         611             : !  See https://github.com/geoschem/hemco for complete history
         612             : !EOP
         613             : !-------------------------------------------------------------------------
         614             : !BOC
         615             : !
         616             : ! !LOCAL VARIABLES:
         617             :     character (len=512) :: err_msg
         618             :     integer             :: ierr
         619             :     integer             :: varid
         620             : !
         621           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
         622             :
         623           0 :     if (ierr /= NF90_NOERR) then
         624             :        err_msg = 'In Ncrd_2d_Int #1:  ' // Trim (varname) // &
         625           0 :                   ', ' // NF90_Strerror(ierr)
         626           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
         627             :     end if
         628             :
         629           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_2di, start=strt2d, count=cnt2d)
         630             :
         631           0 :     if (ierr /= NF90_NOERR) then
         632           0 :        err_msg = 'In Ncrd_2d_Int #2:  ' // NF90_Strerror(ierr)
         633           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
         634             :     end if
         635             :
         636           0 :   end subroutine Ncrd_2d_Int
         637             : !EOC
         638             : !-------------------------------------------------------------------------
         639             : !BOP
         640             : !
         641             : ! !IROUTINE: Ncrd_3d_R8
         642             : !
         643             : ! !INTERFACE:
         644             : !
         645           0 :   subroutine Ncrd_3d_R8(varrd_3d, ncid, varname, strt3d, cnt3d)
         646             : !
         647             : ! !USES:
         648             : !
         649             :     use netCDF
         650             :     use m_do_err_out
         651             : !
         652             : ! !INPUT PARAMETERS:
         653             : !!  ncid     : netCDF file id to read array input data from
         654             : !!  varname  : netCDF variable name for array
         655             : !!  strt3d   : vector specifying the index in varrd_3d where
         656             : !!               the first of the data values will be read
         657             : !!  cnt3d    : varrd_3d dimensions
         658             :     integer          , intent(in)   :: ncid
         659             :     character (len=*), intent(in)   :: varname
         660             :     integer          , intent(in)   :: strt3d(3)
         661             :     integer          , intent(in)   :: cnt3d (3)
         662             : !
         663             : ! !OUTPUT PARAMETERS:
         664             : !!  varrd_3d : array to fill
         665             :     real*8           , intent(out)  :: varrd_3d(cnt3d(1), cnt3d(2), &
         666             :                                                 cnt3d(3))
         667             : !
         668             : ! !DESCRIPTION: Reads in a 3D netCDF real array and does some error checking.
         669             : !\\
         670             : !\\
         671             : ! !AUTHOR:
         672             : !  John Tannahill (LLNL) and Jules Kouatchou
         673             : !
         674             : ! !REVISION HISTORY:
         675             : !  See https://github.com/geoschem/hemco for complete history
         676             : !EOP
         677             : !-------------------------------------------------------------------------
         678             : !BOC
         679             : !
         680             : ! !LOCAL VARIABLES:
         681             :     character (len=512) :: err_msg
         682             :     integer             :: ierr
         683             :     integer             :: varid
         684             : !
         685           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
         686             :
         687           0 :     if (ierr /= NF90_NOERR) then
         688             :        err_msg = 'In Ncrd_3d_R8 #1:  ' // Trim (varname) // &
         689           0 :                  ', ' // NF90_Strerror(ierr)
         690           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
         691             :     end if
         692             :
         693           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_3d, start=strt3d, count=cnt3d)
         694             :
         695           0 :     if (ierr /= NF90_NOERR) then
         696           0 :        err_msg = 'In Ncrd_3d_R8 #2:  ' // NF90_Strerror(ierr)
         697           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
         698             :     end if
         699             :
         700           0 :   end subroutine Ncrd_3d_R8
         701             : !EOC
         702             : !-------------------------------------------------------------------------
         703             : !BOP
         704             : !
         705             : ! !IROUTINE: Ncrd_3d_R4
         706             : !
         707             : ! !INTERFACE:
         708             : !
         709           0 :   subroutine Ncrd_3d_R4(varrd_3d, ncid, varname, strt3d, cnt3d)
         710             : !
         711             : ! !USES:
         712             : !
         713             :     use netCDF
         714             :     use m_do_err_out
         715             : !
         716             : ! !INPUT PARAMETERS:
         717             : !!  ncid     : netCDF file id to read array input data from
         718             : !!  varname  : netCDF variable name for array
         719             : !!  strt3d   : vector specifying the index in varrd_3d where
         720             : !!             the first of the data values will be read
         721             : !!  cnt3d    : varrd_3d dimensions
         722             :     integer          , intent(in)   :: ncid
         723             :     character (len=*), intent(in)   :: varname
         724             :     integer          , intent(in)   :: strt3d(3)
         725             :     integer          , intent(in)   :: cnt3d (3)
         726             : !
         727             : ! !OUTPUT PARAMETERS:
         728             : !!  varrd_3d : array to fill
         729             :     real*4           , intent(out)  :: varrd_3d(cnt3d(1), cnt3d(2), &
         730             :                                                 cnt3d(3))
         731             : !
         732             : ! !DESCRIPTION: Reads in a 3D netCDF real array and does some error checking.
         733             : !\\
         734             : !\\
         735             : ! !AUTHOR:
         736             : !  John Tannahill (LLNL) and Jules Kouatchou
         737             : !
         738             : ! !REVISION HISTORY:
         739             : !  See https://github.com/geoschem/hemco for complete history
         740             : !EOP
         741             : !-------------------------------------------------------------------------
         742             : !BOC
         743             : !
         744             : ! !LOCAL VARIABLES:
         745             :     character (len=512) :: err_msg
         746             :     integer             :: ierr
         747             :     integer             :: varid
         748             : !
         749           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
         750             :
         751           0 :     if (ierr /= NF90_NOERR) then
         752             :        err_msg = 'In Ncrd_3d_R4 #1:  ' // Trim (varname) // &
         753           0 :                  ', ' // NF90_Strerror(ierr)
         754           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
         755             :     end if
         756             :
         757           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_3d, start=strt3d, count=cnt3d)
         758             :
         759           0 :     if (ierr /= NF90_NOERR) then
         760           0 :        err_msg = 'In Ncrd_3d_R4 #2:  ' // NF90_Strerror(ierr)
         761           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
         762             :     end if
         763             :
         764           0 :   end subroutine Ncrd_3d_R4
         765             : !EOC
         766             : !-------------------------------------------------------------------------
         767             : !BOP
         768             : !
         769             : ! !IROUTINE: Ncrd_3d_Int
         770             : !
         771             : ! !INTERFACE:
         772             : !
         773           0 :   subroutine Ncrd_3d_Int(varrd_3di, ncid, varname, strt3d, cnt3d)
         774             : !
         775             : ! !USES:
         776             : !
         777             :     use netCDF
         778             :     use m_do_err_out
         779             : !
         780             : ! !INPUT PARAMETERS:
         781             : !!  ncid     : netCDF file id to read array input data from
         782             : !!  varname  : netCDF variable name for array
         783             : !!  strt3d   : vector specifying the index in varrd_3d where
         784             : !!             the first of the data values will be read
         785             : !!  cnt3d    : varrd_3di dimensions
         786             :     integer          , intent(in)   :: ncid
         787             :     character (len=*), intent(in)   :: varname
         788             :     integer          , intent(in)   :: strt3d(3)
         789             :     integer          , intent(in)   :: cnt3d (3)
         790             : !
         791             : ! !OUTPUT PARAMETERS:
         792             : !!  varrd_3di : intger array to fill
         793             :     integer          , intent(out)  :: varrd_3di(cnt3d(1), cnt3d(2), &
         794             :                                                  cnt3d(3))
         795             : !
         796             : ! !DESCRIPTION: Reads in a 3D netCDF integer array and does some error
         797             : !  checking.
         798             : !\\
         799             : !\\
         800             : ! !AUTHOR:
         801             : !  John Tannahill (LLNL) and Jules Kouatchou
         802             : !
         803             : ! !REVISION HISTORY:
         804             : !  See https://github.com/geoschem/hemco for complete history
         805             : !EOP
         806             : !-------------------------------------------------------------------------
         807             : !BOC
         808             : !
         809             : ! !LOCAL VARIABLES:
         810             :     character (len=512) :: err_msg
         811             :     integer             :: ierr
         812             :     integer             :: varid
         813             : !
         814           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
         815             :
         816           0 :     if (ierr /= NF90_NOERR) then
         817             :        err_msg = 'In Ncrd_3d_Int #1:  ' // Trim (varname) // &
         818           0 :                   ', ' // NF90_Strerror(ierr)
         819           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
         820             :     end if
         821             :
         822           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_3di, start=strt3d, count=cnt3d)
         823             :
         824           0 :     if (ierr /= NF90_NOERR) then
         825           0 :        err_msg = 'In Ncrd_3d_Int #2:  ' // NF90_Strerror(ierr)
         826           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
         827             :     end if
         828             :
         829           0 :   end subroutine Ncrd_3d_Int
         830             : !EOC
         831             : !-------------------------------------------------------------------------
         832             : !BOP
         833             : !
         834             : ! !IROUTINE: Ncrd_4d_R8
         835             : !
         836             : ! !INTERFACE:
         837             : !
         838           0 :   subroutine Ncrd_4d_R8(varrd_4d, ncid, varname, strt4d, cnt4d)
         839             : !
         840             : ! !USES:
         841             : !
         842             :     use netCDF
         843             :     use m_do_err_out
         844             : !
         845             :     implicit none
         846             : !
         847             : ! !INPUT PARAMETERS:
         848             : !!  ncid     : netCDF file id to read array input data from
         849             : !!  varname  : netCDF variable name for array
         850             : !!  strt4d   : vector specifying the index in varrd_4d where
         851             : !!             the first of the data values will be read
         852             : !!  cnt4d    : varrd_4d dimensions
         853             :     integer          , intent(in)   :: ncid
         854             :     character (len=*), intent(in)   :: varname
         855             :     integer          , intent(in)   :: strt4d(4)
         856             :     integer          , intent(in)   :: cnt4d (4)
         857             : !
         858             : ! !OUTPUT PARAMETERS:
         859             : !!  varrd_4d : array to fill
         860             :     real*8           , intent(out)  :: varrd_4d(cnt4d(1), cnt4d(2), &
         861             :                                                 cnt4d(3), cnt4d(4))
         862             : !
         863             : ! !DESCRIPTION: Reads in a 4D netCDF real array and does some error checking.
         864             : !\\
         865             : !\\
         866             : ! !AUTHOR:
         867             : !  John Tannahill (LLNL) and Jules Kouatchou
         868             : !
         869             : ! !REVISION HISTORY:
         870             : !  See https://github.com/geoschem/hemco for complete history
         871             : !EOP
         872             : !-------------------------------------------------------------------------
         873             : !BOC
         874             : !
         875             : ! !LOCAL VARIABLES:
         876             :     character (len=512) :: err_msg
         877             :     integer             :: ierr
         878             :     integer             :: varid
         879             : !
         880           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
         881             :
         882           0 :     if (ierr /= NF90_NOERR) then
         883             :        err_msg = 'In Ncrd_4d_R8 #1:  ' // Trim (varname) // &
         884           0 :                  ', ' // NF90_Strerror(ierr)
         885           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
         886             :     end if
         887             :
         888           0 :     ierr =  NF90_Get_Var(ncid, varid, varrd_4d, start=strt4d, count=cnt4d)
         889             :
         890           0 :     if (ierr /= NF90_NOERR) then
         891           0 :        err_msg = 'In Ncrd_4d_R8 #2:  ' // NF90_Strerror(ierr)
         892           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
         893             :     end if
         894             :
         895           0 :   end subroutine Ncrd_4d_R8
         896             : !EOC
         897             : !-------------------------------------------------------------------------
         898             : !BOP
         899             : !
         900             : ! !IROUTINE: Ncrd_4d_R4
         901             : !
         902             : ! !INTERFACE:
         903             : !
         904           0 :   subroutine Ncrd_4d_R4(varrd_4d, ncid, varname, strt4d, cnt4d)
         905             : !
         906             : ! !USES:
         907             : !
         908             :     use netCDF
         909             :     use m_do_err_out
         910             : !
         911             : ! !INPUT PARAMETERS:
         912             : !!  ncid     : netCDF file id to read array input data from
         913             : !!  varname  : netCDF variable name for array
         914             : !!  strt4d   : vector specifying the index in varrd_4d where
         915             : !!             the first of the data values will be read
         916             : !!  cnt4d    : varrd_4d dimensions
         917             :     integer          , intent(in)   :: ncid
         918             :     character (len=*), intent(in)   :: varname
         919             :     integer          , intent(in)   :: strt4d(4)
         920             :     integer          , intent(in)   :: cnt4d (4)
         921             : !
         922             : ! !OUTPUT PARAMETERS:
         923             : !!  varrd_4d : array to fill
         924             :     real*4           , intent(out)  :: varrd_4d(cnt4d(1), cnt4d(2), &
         925             :                                                 cnt4d(3), cnt4d(4))
         926             : !
         927             : ! !DESCRIPTION: Reads in a 4D netCDF real array and does some error checking.
         928             : !\\
         929             : !\\
         930             : ! !AUTHOR:
         931             : !  John Tannahill (LLNL) and Jules Kouatchou
         932             : !
         933             : ! !REVISION HISTORY:
         934             : !  See https://github.com/geoschem/hemco for complete history
         935             : !EOP
         936             : !-------------------------------------------------------------------------
         937             : !BOC
         938             : !
         939             : ! !LOCAL VARIABLES:
         940             :     character (len=512) :: err_msg
         941             :     integer             :: ierr
         942             :     integer             :: varid
         943             : !
         944           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
         945             :
         946           0 :     if (ierr /= NF90_NOERR) then
         947             :        err_msg = 'In Ncrd_4d_R4 #1:  ' // Trim (varname) // &
         948           0 :                   ', ' // NF90_Strerror(ierr)
         949           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
         950             :     end if
         951             :
         952           0 :     ierr =  NF90_Get_Var(ncid, varid, varrd_4d, start=strt4d, count=cnt4d)
         953             :
         954           0 :     if (ierr /= NF90_NOERR) then
         955           0 :        err_msg = 'In Ncrd_4d_R4 #2:  ' // NF90_Strerror(ierr)
         956           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
         957             :     end if
         958             :
         959           0 :   end subroutine Ncrd_4d_R4
         960             : !EOC
         961             : !-------------------------------------------------------------------------
         962             : !BOP
         963             : !
         964             : ! !IROUTINE: Ncrd_4d_Int
         965             : !
         966             : ! !INTERFACE:
         967             : !
         968           0 :   subroutine Ncrd_4d_Int(varrd_4di, ncid, varname, strt4d, cnt4d)
         969             : !
         970             : ! !USES:
         971             : !
         972             :     use netCDF
         973             :     use m_do_err_out
         974             : !
         975             : ! !INPUT PARAMETERS:
         976             : !!  ncid     : netCDF file id to read array input data from
         977             : !!  varname  : netCDF variable name for array
         978             : !!  strt3d   : vector specifying the index in varrd_3d where
         979             : !!             the first of the data values will be read
         980             : !!  cnt3d    : varrd_3di dimensions
         981             :     integer          , intent(in)   :: ncid
         982             :     character (len=*), intent(in)   :: varname
         983             :     integer          , intent(in)   :: strt4d(4)
         984             :     integer          , intent(in)   :: cnt4d (4)
         985             : !
         986             : ! !OUTPUT PARAMETERS:
         987             : !!  varrd_3di : intger array to fill
         988             :     integer          , intent(out)  :: varrd_4di(cnt4d(1), cnt4d(2), &
         989             :                                                  cnt4d(3), cnt4d(4))
         990             : !
         991             : ! !DESCRIPTION: Reads in a 3D netCDF integer array and does some error
         992             : !  checking.
         993             : !\\
         994             : !\\
         995             : ! !AUTHOR:
         996             : !  John Tannahill (LLNL) and Jules Kouatchou
         997             : !
         998             : ! !REVISION HISTORY:
         999             : !  See https://github.com/geoschem/hemco for complete history
        1000             : !EOP
        1001             : !-------------------------------------------------------------------------
        1002             : !BOC
        1003             : !
        1004             : ! !LOCAL VARIABLES:
        1005             :     character (len=512) :: err_msg
        1006             :     integer             :: ierr
        1007             :     integer             :: varid
        1008             : !
        1009           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
        1010             :
        1011           0 :     if (ierr /= NF90_NOERR) then
        1012             :        err_msg = 'In Ncrd_3d_Int #1:  ' // Trim (varname) // &
        1013           0 :                   ', ' // NF90_Strerror(ierr)
        1014           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
        1015             :     end if
        1016             :
        1017           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_4di, start=strt4d, count=cnt4d)
        1018             :
        1019           0 :     if (ierr /= NF90_NOERR) then
        1020           0 :        err_msg = 'In Ncrd_3d_Int #2:  ' // NF90_Strerror(ierr)
        1021           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
        1022             :     end if
        1023             :
        1024           0 :   end subroutine Ncrd_4d_Int
        1025             : !EOC
        1026             : !-------------------------------------------------------------------------
        1027             : !BOP
        1028             : !
        1029             : ! !IROUTINE: Ncrd_5d_R8
        1030             : !
        1031             : ! !INTERFACE:
        1032             : !
        1033           0 :       subroutine Ncrd_5d_R8 (varrd_5d, ncid, varname, strt5d, cnt5d)
        1034             : !
        1035             : ! !USES:
        1036             : !
        1037             :     use netCDF
        1038             :     use m_do_err_out
        1039             : !
        1040             : ! !INPUT PARAMETERS:
        1041             : !!  ncid     : netCDF file id to read array input data from
        1042             : !!  varname  : netCDF variable name for array
        1043             : !!  strt5d   : vector specifying the index in varrd_5d where
        1044             : !!             the first of the data values will be read
        1045             : !!  cnt5d    : varrd_5d dimensions
        1046             :     integer          , intent(in)   :: ncid
        1047             :     character (len=*), intent(in)   :: varname
        1048             :     integer          , intent(in)   :: strt5d(5)
        1049             :     integer          , intent(in)   :: cnt5d (5)
        1050             : !
        1051             : ! !OUTPUT PARAMETERS:
        1052             : !!  varrd_5d : array to fill
        1053             :     real*8         , intent(out)  :: varrd_5d(cnt5d(1), cnt5d(2), &
        1054             :                                               cnt5d(3), cnt5d(4), &
        1055             :                                               cnt5d(5))
        1056             : !
        1057             : ! !DESCRIPTION: Reads in a 5D netCDF real array and does some error checking.
        1058             : !\\
        1059             : !\\
        1060             : ! !AUTHOR:
        1061             : !  John Tannahill (LLNL) and Jules Kouatchou
        1062             : !
        1063             : ! !REVISION HISTORY:
        1064             : !  See https://github.com/geoschem/hemco for complete history
        1065             : !EOP
        1066             : !-------------------------------------------------------------------------
        1067             : !BOC
        1068             : !
        1069             : ! !LOCAL VARIABLES:
        1070             :     character (len=512) :: err_msg
        1071             :     integer             :: ierr
        1072             :     integer             :: varid
        1073             : !
        1074           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
        1075             :
        1076           0 :     if (ierr /= NF90_NOERR) then
        1077             :         err_msg = 'In Ncrd_5d_R8 #1:  ' // Trim (varname) // &
        1078           0 :                   ', ' // NF90_Strerror(ierr)
        1079           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
        1080             :      end if
        1081             :
        1082           0 :      ierr = NF90_Get_Var(ncid, varid, varrd_5d, start=strt5d, count=cnt5d)
        1083             :
        1084           0 :      if (ierr /= NF90_NOERR) then
        1085           0 :         err_msg = 'In Ncrd_5d_R8 #2:  ' // NF90_Strerror(ierr)
        1086           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
        1087             :      end if
        1088             :
        1089           0 :   end subroutine Ncrd_5d_R8
        1090             : !EOC
        1091             : !-------------------------------------------------------------------------
        1092             : !BOP
        1093             : !
        1094             : ! !IROUTINE: Ncrd_5d_R4
        1095             : !
        1096             : ! !INTERFACE:
        1097             : !
        1098           0 :   subroutine Ncrd_5d_R4(varrd_5d, ncid, varname, strt5d, cnt5d)
        1099             : !
        1100             : ! !USES:
        1101             : !
        1102             :     use netCDF
        1103             :     use m_do_err_out
        1104             : !
        1105             : ! !INPUT PARAMETERS:
        1106             : !!  ncid     : netCDF file id to read array input data from
        1107             : !!  varname  : netCDF variable name for array
        1108             : !!  strt5d   : vector specifying the index in varrd_5d where
        1109             : !!             the first of the data values will be read
        1110             : !!  cnt5d    : varrd_5d dimensions
        1111             :     integer          , intent(in)   :: ncid
        1112             :     character (len=*), intent(in)   :: varname
        1113             :     integer          , intent(in)   :: strt5d(5)
        1114             :     integer          , intent(in)   :: cnt5d (5)
        1115             : !
        1116             : ! !OUTPUT PARAMETERS:
        1117             : !!  varrd_5d : array to fill
        1118             :     real*4          , intent(out)  :: varrd_5d(cnt5d(1), cnt5d(2), &
        1119             :                                                 cnt5d(3), cnt5d(4), &
        1120             :                                                 cnt5d(5))
        1121             : !
        1122             : ! !DESCRIPTION: Reads in a 5D netCDF real array and does some error checking.
        1123             : !\\
        1124             : !\\
        1125             : ! !AUTHOR:
        1126             : !  John Tannahill (LLNL) and Jules Kouatchou
        1127             : !
        1128             : ! !REVISION HISTORY:
        1129             : !  See https://github.com/geoschem/hemco for complete history
        1130             : !EOP
        1131             : !-------------------------------------------------------------------------
        1132             : !BOC
        1133             : !
        1134             : ! !LOCAL VARIABLES:
        1135             :     character (len=512) :: err_msg
        1136             :     integer             :: ierr
        1137             :     integer             :: varid
        1138             : !
        1139           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
        1140             :
        1141           0 :     if (ierr /= NF90_NOERR) then
        1142             :        err_msg = 'In Ncrd_5d_R4 #1:  ' // Trim (varname) // &
        1143           0 :                   ', ' // NF90_Strerror(ierr)
        1144           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
        1145             :     end if
        1146             :
        1147           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_5d, start=strt5d, count=cnt5d)
        1148             :
        1149           0 :     if (ierr /= NF90_NOERR) then
        1150           0 :        err_msg = 'In Ncrd_5d_R4 #2:  ' // NF90_Strerror(ierr)
        1151           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
        1152             :     end if
        1153             :
        1154           0 :   end subroutine Ncrd_5d_R4
        1155             : !EOC
        1156             : !-------------------------------------------------------------------------
        1157             : !BOP
        1158             : !
        1159             : ! !IROUTINE: Ncrd_6d_R8
        1160             : !
        1161             : ! !INTERFACE:
        1162             : !
        1163           0 :   subroutine Ncrd_6d_R8(varrd_6d, ncid, varname, strt6d, cnt6d)
        1164             : !
        1165             : ! !USES:
        1166             : !
        1167             :     use netCDF
        1168             :     use m_do_err_out
        1169             : !
        1170             : ! !INPUT PARAMETERS:
        1171             : !!  ncid     : netCDF file id to read array input data from
        1172             : !!  varname  : netCDF variable name for array
        1173             : !!  strt5d   : vector specifying the index in varrd_5d where
        1174             : !!               the first of the data values will be read
        1175             : !!  cnt5d    : varrd_5d dimensions
        1176             :     integer          , intent(in)   :: ncid
        1177             :     character (len=*), intent(in)   :: varname
        1178             :     integer          , intent(in)   :: strt6d(6)
        1179             :     integer          , intent(in)   :: cnt6d (6)
        1180             : !
        1181             : ! !OUTPUT PARAMETERS:
        1182             : !!  varrd_5d : array to fill
        1183             :     real*8         , intent(out)  :: varrd_6d(cnt6d(1), cnt6d(2), &
        1184             :                                               cnt6d(3), cnt6d(4), &
        1185             :                                               cnt6d(5), cnt6d(6))
        1186             : !
        1187             : ! !DESCRIPTION: Reads in a 5D netCDF real array and does some error checking.
        1188             : !\\
        1189             : !\\
        1190             : ! !AUTHOR:
        1191             : !  John Tannahill (LLNL) and Jules Kouatchou
        1192             : !
        1193             : ! !REVISION HISTORY:
        1194             : !  20 Dec 2011 - R. Yantosca - Initial version
        1195             : !  See https://github.com/geoschem/hemco for complete history
        1196             : !EOP
        1197             : !-------------------------------------------------------------------------
        1198             : !BOC
        1199             : !
        1200             : ! !LOCAL VARIABLES:
        1201             :     character (len=512) :: err_msg
        1202             :     integer             :: ierr
        1203             :     integer             :: varid
        1204             : !
        1205           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
        1206             :
        1207           0 :     if (ierr /= NF90_NOERR) then
        1208             :        err_msg = 'In Ncrd_6d_R8 #1:  ' // Trim (varname) // &
        1209           0 :                  ', ' // NF90_Strerror(ierr)
        1210           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
        1211             :     end if
        1212             :
        1213           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_6d, start=strt6d, count=cnt6d)
        1214             :
        1215           0 :     if (ierr /= NF90_NOERR) then
        1216           0 :        err_msg = 'In Ncrd_6d_R8 #2:  ' // NF90_Strerror(ierr)
        1217           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
        1218             :     end if
        1219             :
        1220           0 :   end subroutine Ncrd_6d_R8
        1221             : !EOC
        1222             : !-------------------------------------------------------------------------
        1223             : !BOP
        1224             : !
        1225             : ! !IROUTINE: Ncrd_6d_R4
        1226             : !
        1227             : ! !INTERFACE:
        1228             : !
        1229           0 :   subroutine Ncrd_6d_R4(varrd_6d, ncid, varname, strt6d, cnt6d)
        1230             : !
        1231             : ! !USES:
        1232             : !
        1233             :     use netCDF
        1234             :     use m_do_err_out
        1235             : !
        1236             : ! !INPUT PARAMETERS:
        1237             : !!  ncid     : netCDF file id to read array input data from
        1238             : !!  varname  : netCDF variable name for array
        1239             : !!  strt5d   : vector specifying the index in varrd_5d where
        1240             : !!             the first of the data values will be read
        1241             : !!  cnt5d    : varrd_5d dimensions
        1242             :     integer          , intent(in)   :: ncid
        1243             :     character (len=*), intent(in)   :: varname
        1244             :     integer          , intent(in)   :: strt6d(6)
        1245             :     integer          , intent(in)   :: cnt6d (6)
        1246             : !
        1247             : ! !OUTPUT PARAMETERS:
        1248             : !!  varrd_5d : array to fill
        1249             :     real*4          , intent(out)  :: varrd_6d(cnt6d(1), cnt6d(2), &
        1250             :                                                cnt6d(3), cnt6d(4), &
        1251             :                                                cnt6d(5), cnt6d(6))
        1252             : !
        1253             : ! !DESCRIPTION: Reads in a 5D netCDF real array and does some error checking.
        1254             : !\\
        1255             : !\\
        1256             : ! !AUTHOR:
        1257             : !  John Tannahill (LLNL) and Jules Kouatchou
        1258             : !
        1259             : ! !REVISION HISTORY:
        1260             : !  See https://github.com/geoschem/hemco for complete history
        1261             : !EOP
        1262             : !-------------------------------------------------------------------------
        1263             : !BOC
        1264             : !
        1265             : ! !LOCAL VARIABLES:
        1266             :     character (len=512) :: err_msg
        1267             :     integer             :: ierr
        1268             :     integer             :: varid
        1269             : !
        1270           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
        1271             :
        1272           0 :     if ( ierr /= NF90_NOERR) then
        1273             :        err_msg = 'In Ncrd_6d_R4 #1:  ' // Trim (varname) // &
        1274           0 :                   ', ' // NF90_Strerror(ierr)
        1275           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
        1276             :     end if
        1277             :
        1278           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_6d, start=strt6d, count=cnt6d)
        1279             :
        1280           0 :     if (ierr /= NF90_NOERR) then
        1281           0 :        err_msg = 'In Ncrd_6d_R4 #2:  ' // NF90_Strerror(ierr)
        1282           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
        1283             :     end if
        1284             :
        1285           0 :   end subroutine Ncrd_6d_R4
        1286             : !EOC
        1287             : !-------------------------------------------------------------------------
        1288             : !BOP
        1289             : !
        1290             : ! !IROUTINE: Ncrd_7d_R8
        1291             : !
        1292             : ! !INTERFACE:
        1293             : !
        1294           0 :   subroutine Ncrd_7d_R8(varrd_7d, ncid, varname, strt7d, cnt7d)
        1295             : !
        1296             : ! !USES:
        1297             : !
        1298             :     use netCDF
        1299             :     use m_do_err_out
        1300             : !
        1301             : ! !INPUT PARAMETERS:
        1302             : !!  ncid     : netCDF file id to read array input data from
        1303             : !!  varname  : netCDF variable name for array
        1304             : !!  strt7d   : vector specifying the index in varrd_7d where
        1305             : !!             the first of the data values will be read
        1306             : !!  cnt7d    : varrd_7d dimensions
        1307             :     integer          , intent(in)   :: ncid
        1308             :     character (len=*), intent(in)   :: varname
        1309             :     integer          , intent(in)   :: strt7d(7)
        1310             :     integer          , intent(in)   :: cnt7d (7)
        1311             : !
        1312             : ! !OUTPUT PARAMETERS:
        1313             : !!  varrd_5d : array to fill
        1314             :     real*8           , intent(out)  :: varrd_7d(cnt7d(1), cnt7d(2), &
        1315             :                                                 cnt7d(3), cnt7d(4), &
        1316             :                                                 cnt7d(5), cnt7d(6), &
        1317             :                                                 cnt7d(7))
        1318             : !
        1319             : ! !DESCRIPTION: Reads in a 7D netCDF real array and does some error checking.
        1320             : !\\
        1321             : !\\
        1322             : ! !AUTHOR:
        1323             : !  John Tannahill (LLNL) and Jules Kouatchou
        1324             : !
        1325             : ! !REVISION HISTORY:
        1326             : !  20 Dec 2011 - R. Yantosca - Initial version
        1327             : !  See https://github.com/geoschem/hemco for complete history
        1328             : !EOP
        1329             : !-------------------------------------------------------------------------
        1330             : !BOC
        1331             : !
        1332             : ! !LOCAL VARIABLES:
        1333             :     character (len=512) :: err_msg
        1334             :     integer             :: ierr
        1335             :     integer             :: varid
        1336             : !
        1337           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
        1338             :
        1339           0 :     if (ierr /= NF90_NOERR) then
        1340             :        err_msg = 'In Ncrd_7d_R8 #1:  ' // Trim (varname) // &
        1341           0 :                   ', ' // NF90_Strerror(ierr)
        1342           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
        1343             :     end if
        1344             :
        1345           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_7d, start=strt7d, count=cnt7d)
        1346             :
        1347           0 :     if (ierr /= NF90_NOERR) then
        1348           0 :        err_msg = 'In Ncrd_7d_R8 #2:  ' // NF90_Strerror(ierr)
        1349           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
        1350             :     end if
        1351             :
        1352           0 :   end subroutine Ncrd_7d_R8
        1353             : !EOC
        1354             : !-------------------------------------------------------------------------
        1355             : !BOP
        1356             : !
        1357             : ! !IROUTINE: Ncrd_7d_R4
        1358             : !
        1359             : ! !INTERFACE:
        1360             : !
        1361           0 :   subroutine Ncrd_7d_R4(varrd_7d, ncid, varname, strt7d, cnt7d)
        1362             : !
        1363             : ! !USES:
        1364             : !
        1365             :     use netCDF
        1366             :     use m_do_err_out
        1367             : !
        1368             : ! !INPUT PARAMETERS:
        1369             : !!  ncid     : netCDF file id to read array input data from
        1370             : !!  varname  : netCDF variable name for array
        1371             : !!  strt7d   : vector specifying the index in varrd_7d where
        1372             : !!             the first of the data values will be read
        1373             : !!  cnt7d    : varrd_7d dimensions
        1374             :     integer          , intent(in)   :: ncid
        1375             :     character (len=*), intent(in)   :: varname
        1376             :     integer          , intent(in)   :: strt7d(7)
        1377             :     integer          , intent(in)   :: cnt7d (7)
        1378             : !
        1379             : ! !OUTPUT PARAMETERS:
        1380             : !!  varrd_7d : array to fill
        1381             :     real*4          , intent(out)  :: varrd_7d(cnt7d(1), cnt7d(2), &
        1382             :                                                cnt7d(3), cnt7d(4), &
        1383             :                                                cnt7d(5), cnt7d(6), &
        1384             :                                                cnt7d(7))
        1385             : !
        1386             : ! !DESCRIPTION: Reads in a 7D netCDF real array and does some error checking.
        1387             : !\\
        1388             : !\\
        1389             : ! !AUTHOR:
        1390             : !  John Tannahill (LLNL) and Jules Kouatchou
        1391             : !
        1392             : ! !REVISION HISTORY:
        1393             : !  20 Dec 2011 - R. Yantosca - Initial version
        1394             : !  See https://github.com/geoschem/hemco for complete history
        1395             : !EOP
        1396             : !-------------------------------------------------------------------------
        1397             : !BOC
        1398             : !
        1399             : ! !LOCAL VARIABLES:
        1400             :     character (len=512) :: err_msg
        1401             :     integer             :: ierr
        1402             :     integer             :: varid
        1403             : !
        1404           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
        1405             :
        1406           0 :     if (ierr /= NF90_NOERR) then
        1407             :        err_msg = 'In Ncrd_7d_R4 #1:  ' // Trim (varname) // &
        1408           0 :                  ', ' // NF90_Strerror(ierr)
        1409           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
        1410             :     end if
        1411             :
        1412           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_7d, start=strt7d, count=cnt7d)
        1413             :
        1414           0 :     if (ierr /= NF90_NOERR) then
        1415           0 :        err_msg = 'In Ncrd_7d_R4 #2:  ' // NF90_Strerror(ierr)
        1416           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
        1417             :     end if
        1418             :
        1419           0 :   end subroutine Ncrd_7d_R4
        1420             : !EOC
        1421             : !-------------------------------------------------------------------------
        1422             : !BOP
        1423             : !
        1424             : ! !IROUTINE: Ncrd_1d_Char
        1425             : !
        1426             : ! !INTERFACE:
        1427             : !
        1428           0 :   subroutine Ncrd_1d_Char(varrd_1dc, ncid, varname, strt1d, cnt1d)
        1429             : !
        1430             : ! !USES:
        1431             : !
        1432             :     use netCDF
        1433             :     use m_do_err_out
        1434             : !
        1435             : ! !INPUT PARAMETERS:
        1436             : !
        1437             : !!  ncid     : netCDF file id to read array input data from
        1438             : !!  varname  : netCDF variable name for array
        1439             : !!  strt1d   : vector specifying the index in varrd_1dc where
        1440             : !!             the first of the data values will be read
        1441             : !!  cnt1d    : varrd_1dc dimension
        1442             :     integer          , intent(in)   :: ncid
        1443             :     character (len=*), intent(in)   :: varname
        1444             :     integer          , intent(in)   :: strt1d(1)
        1445             :     integer          , intent(in)   :: cnt1d (1)
        1446             : !
        1447             : ! !OUTPUT PARAMETERS:
        1448             : !!  varrd_1dc : intger array to fill
        1449             :     character (len=1), intent(out)  :: varrd_1dc(cnt1d(1))
        1450             : !
        1451             : ! !DESCRIPTION: Reads in a 1D netCDF character array and does some error
        1452             : !  checking.
        1453             : !\\
        1454             : !\\ !AUTHOR:
        1455             : !  Jules Kouatchou
        1456             : !
        1457             : ! !REVISION HISTORY:
        1458             : !  See https://github.com/geoschem/hemco for complete history
        1459             : !EOP
        1460             : !-------------------------------------------------------------------------
        1461             : !BOC
        1462             : !
        1463             : ! !LOCAL VARIABLES:
        1464             :     character (len=512) :: err_msg
        1465             :     integer             :: ierr
        1466             :     integer             :: varid
        1467             : !
        1468           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
        1469             :
        1470           0 :     if (ierr /= NF90_NOERR) then
        1471             :        err_msg = 'In Ncrd_1d_Char #1:  ' // Trim (varname) // &
        1472           0 :                   ', ' // NF90_Strerror(ierr)
        1473           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
        1474             :     end if
        1475             :
        1476           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_1dc, start=strt1d, count=cnt1d)
        1477             :
        1478           0 :     if (ierr /= NF90_NOERR) then
        1479           0 :        err_msg = 'In Ncrd_1d_Char #2:  ' // NF90_Strerror(ierr)
        1480           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
        1481             :     end if
        1482             :
        1483           0 :   end subroutine Ncrd_1d_Char
        1484             : !EOC
        1485             : !-------------------------------------------------------------------------
        1486             : !BOP
        1487             : !
        1488             : ! !IROUTINE: Ncrd_2d_Char
        1489             : !
        1490             : ! !INTERFACE:
        1491             : !
        1492           0 :   subroutine Ncrd_2d_Char(varrd_2dc, ncid, varname, strt2d, cnt2d)
        1493             : !
        1494             : ! !USES:
        1495             : !
        1496             :     use netCDF
        1497             :     use m_do_err_out
        1498             : !
        1499             : ! !INPUT PARAMETERS:
        1500             : !!  ncid     : netCDF file id to read array input data from
        1501             : !!  varname  : netCDF variable name for array
        1502             : !!  strt2d   : vector specifying the index in varrd_2dc where
        1503             : !!             the first of the data values will be read
        1504             : !!  cnt2d    : varrd_2dc dimensions
        1505             :     integer          , intent(in)   :: ncid
        1506             :     character (len=*), intent(in)   :: varname
        1507             :     integer          , intent(in)   :: strt2d(2)
        1508             :     integer          , intent(in)   :: cnt2d (2)
        1509             : !
        1510             : ! !OUTPUT PARAMETERS:
        1511             : !!  varrd_2dc : charcter array to fill
        1512             :     character        , intent(out)  :: varrd_2dc(cnt2d(1), cnt2d(2))
        1513             : !
        1514             : ! !DESCRIPTION: Reads in a 2D netCDF character array and does some error
        1515             : !  checking.
        1516             : !\\
        1517             : !\\
        1518             : ! !AUTHOR:
        1519             : !  Jules Kouatchou
        1520             : !
        1521             : ! !REVISION HISTORY:
        1522             : !  See https://github.com/geoschem/hemco for complete history
        1523             : !EOP
        1524             : !-------------------------------------------------------------------------
        1525             : !BOC
        1526             : !
        1527             : ! !LOCAL VARIABLES:
        1528             :     character (len=512) :: err_msg
        1529             :     integer             :: ierr
        1530             :     integer             :: varid
        1531             : !
        1532           0 :     ierr = NF90_Inq_VarId(ncid, varname, varid)
        1533             :
        1534           0 :     if (ierr /= NF90_NOERR) then
        1535             :        err_msg = 'In Ncrd_2d_Char #1:  ' // Trim (varname) // &
        1536           0 :                   ', ' // NF90_Strerror(ierr)
        1537           0 :        call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
        1538             :     end if
        1539             :
        1540           0 :     ierr = NF90_Get_Var(ncid, varid, varrd_2dc, start=strt2d, count=cnt2d)
        1541             :
        1542           0 :     if (ierr /= NF90_NOERR) then
        1543           0 :        err_msg = 'In Ncrd_2d_Char #2:  ' // NF90_Strerror(ierr)
        1544           0 :        call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
        1545             :     end if
        1546             :
        1547           0 :   end subroutine Ncrd_2d_Char
        1548             : !EOC
        1549             : !------------------------------------------------------------------------
        1550             : end module HCO_m_netcdf_io_read
        1551             :

Generated by: LCOV version 1.14