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

              Line data    Source code
           1             : !------------------------------------------------------------------------------
           2             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
           3             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
           4             : !------------------------------------------------------------------------------
           5             : !BOP
           6             : !
           7             : ! !MODULE: HCO_m_netcdf_io_readattr.F90
           8             : !
           9             : ! !INTERFACE:
          10             : !
          11             : MODULE HCO_m_netcdf_io_readattr
          12             : !
          13             : ! !USES:
          14             : !
          15             :   IMPLICIT NONE
          16             :   PRIVATE
          17             : !
          18             : ! !PUBLIC MEMBER FUNCTIONS:
          19             : !
          20             :   PUBLIC :: NcGet_Var_Attributes
          21             :   INTERFACE NcGet_Var_Attributes
          22             :      MODULE PROCEDURE NcGet_Var_Attr_C
          23             :      MODULE PROCEDURE NcGet_Var_Attr_C_nostop
          24             :      MODULE PROCEDURE NcGet_Var_Attr_I4
          25             :      MODULE PROCEDURE NcGet_Var_Attr_R4
          26             :      MODULE PROCEDURE NcGet_Var_Attr_R8
          27             :      MODULE PROCEDURE NcGet_Var_Attr_I4_arr
          28             :      MODULE PROCEDURE NcGet_Var_Attr_R4_arr
          29             :      MODULE PROCEDURE NcGet_Var_Attr_R8_arr
          30             :   END INTERFACE
          31             :
          32             :   PUBLIC :: NcGet_Glob_Attributes
          33             :   INTERFACE NcGet_Glob_Attributes
          34             :      MODULE PROCEDURE NcGet_Glob_Attr_C
          35             :      MODULE PROCEDURE NcGet_Glob_Attr_I4
          36             :      MODULE PROCEDURE NcGet_Glob_Attr_R4
          37             :      MODULE PROCEDURE NcGet_Glob_Attr_R8
          38             :      MODULE PROCEDURE NcGet_Glob_Attr_I4_arr
          39             :      MODULE PROCEDURE NcGet_Glob_Attr_R4_arr
          40             :      MODULE PROCEDURE NcGet_Glob_Attr_R8_arr
          41             :   END INTERFACE
          42             : !
          43             : ! !PRIVATE MEMBER FUNCTIONS:
          44             : !
          45             :   PRIVATE :: NcGet_Var_Attr_C
          46             :   PRIVATE :: NcGet_Var_Attr_I4
          47             :   PRIVATE :: NcGet_Var_Attr_R4
          48             :   PRIVATE :: NcGet_Var_Attr_R8
          49             :   PRIVATE :: NcGet_Var_Attr_I4_arr
          50             :   PRIVATE :: NcGet_Var_Attr_R4_arr
          51             :   PRIVATE :: NcGet_Var_Attr_R8_arr
          52             :   PRIVATE :: NcGet_Glob_Attr_C
          53             :   PRIVATE :: NcGet_Glob_Attr_I4
          54             :   PRIVATE :: NcGet_Glob_Attr_R4
          55             :   PRIVATE :: NcGet_Glob_Attr_R8
          56             :   PRIVATE :: NcGet_Glob_Attr_I4_arr
          57             :   PRIVATE :: NcGet_Glob_Attr_R4_arr
          58             :   PRIVATE :: NcGet_Glob_Attr_R8_arr
          59             : !
          60             : ! !DESCRIPTION: Provides netCDF utility routines to read both netCDF
          61             : !  variable attributes and global attributes.  Individual routines for
          62             : !  reading attributes of different types are overloaded with F90
          63             : !  interfaces.
          64             : !\\
          65             : !\\
          66             : ! !AUTHOR:
          67             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
          68             : !
          69             : ! !REVISION HISTORY:
          70             : !  See https://github.com/geoschem/hemco for complete history
          71             : !EOP
          72             : !------------------------------------------------------------------------------
          73             : !BOC
          74             : CONTAINS
          75             : !EOC
          76             : !------------------------------------------------------------------------------
          77             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
          78             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
          79             : !------------------------------------------------------------------------------
          80             : !BOP
          81             : !
          82             : ! !IROUTINE: NcGet_Var_Attr_C
          83             : !
          84             : ! !DESCRIPTION: Returns a variable attribute of type CHARACTER.
          85             : !\\
          86             : !\\
          87             : ! !INTERFACE:
          88             : !
          89           0 :   SUBROUTINE NcGet_Var_Attr_C( fid, varName, attName, attValue )
          90             : !
          91             : ! USES:
          92             : !
          93             :     USE netCDF
          94             :     USE m_do_err_out
          95             : !
          96             : ! !INPUT PARAMETERS:
          97             : !
          98             :     INTEGER,          INTENT(IN)  :: fId        ! netCDF file ID
          99             :     CHARACTER(LEN=*), INTENT(IN)  :: varName    ! netCDF variable name
         100             :     CHARACTER(LEN=*), INTENT(IN)  :: attName    ! Name of variable attribute
         101             : !
         102             : ! !OUTPUT PARAMETERS:
         103             : !
         104             :     CHARACTER(LEN=*), INTENT(OUT) :: attValue   ! Attribute value
         105             : !
         106             : ! !DESCRIPTION: Reads a variable attribute (CHARACTER type) from a netCDF file.
         107             : !\\
         108             : !\\
         109             : ! !AUTHOR:
         110             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
         111             : !
         112             : ! !REVISION HISTORY:
         113             : !  See https://github.com/geoschem/hemco for complete history
         114             : !EOP
         115             : !------------------------------------------------------------------------------
         116             : !BOC
         117             : !
         118             : ! !LOCAL VARIABLES:
         119             : !
         120             :     CHARACTER(LEN=512) :: errMsg
         121             :     INTEGER            :: status, vId, EC
         122             :
         123             :     ! Zero return value
         124           0 :     attValue = ''
         125             :
         126             :     ! Check if VARNAME is a valid variable
         127           0 :     status = NF90_Inq_VarId( fId, varName, vId )
         128             :
         129             :     ! Exit w/ error message if VARNAME is not valid
         130           0 :     IF ( status /= NF90_NOERR ) THEN
         131             :        errMsg = 'In NcGet_Var_Attr_C: ' // TRIM( varName )        // &
         132           0 :                  ', '                   // NF90_Strerror( status )
         133           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
         134             :     ENDIF
         135             :
         136             :     !  Get the attribute
         137           0 :     status = NF90_Get_Att( fId, vId, attName, attValue )
         138             :
         139             :     ! Exit w/ error message if unsuccessful
         140           0 :     IF ( status /= NF90_NOERR ) THEN
         141             :        errMsg = 'In NcGet_Var_Attr_C: cannot read attribute : ' // &
         142           0 :                  TRIM( attName )
         143           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
         144             :     endif
         145             :
         146           0 :   END SUBROUTINE NcGet_Var_Attr_C
         147             : !EOC
         148             : !------------------------------------------------------------------------------
         149             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
         150             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
         151             : !------------------------------------------------------------------------------
         152             : !BOP
         153             : !
         154             : ! !IROUTINE: NcGet_Var_Attr_I4
         155             : !
         156             : ! !DESCRIPTION: Returns a variable attribute of type INTEGER*4.
         157             : !\\
         158             : !\\
         159             : ! !INTERFACE:
         160             : !
         161           0 :   SUBROUTINE NcGet_Var_Attr_I4( fid, varName, attName, attValue )
         162             : !
         163             : ! USES:
         164             : !
         165             :     USE netCDF
         166             :     USE m_do_err_out
         167             : !
         168             : ! !INPUT PARAMETERS:
         169             : !
         170             :     INTEGER,          INTENT(IN)  :: fId        ! netCDF file ID
         171             :     CHARACTER(LEN=*), INTENT(IN)  :: varName    ! netCDF variable name
         172             :     CHARACTER(LEN=*), INTENT(IN)  :: attName    ! Name of variable attribute
         173             : !
         174             : ! !OUTPUT PARAMETERS:
         175             : !
         176             :     INTEGER,          INTENT(OUT) :: attValue   ! Attribute value
         177             : !
         178             : ! !DESCRIPTION: Reads a variable attribute (INTEGER type) from a netCDF file.
         179             : !\\
         180             : !\\
         181             : ! !AUTHOR:
         182             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
         183             : !
         184             : ! !REVISION HISTORY:
         185             : !  See https://github.com/geoschem/hemco for complete history
         186             : !EOP
         187             : !------------------------------------------------------------------------------
         188             : !BOC
         189             : !
         190             : ! !LOCAL VARIABLES:
         191             : !
         192             :     CHARACTER(LEN=512) :: errMsg
         193             :     INTEGER            :: status, vId
         194             :
         195             :     ! Zero return value
         196           0 :     attValue = 0
         197             :
         198             :     ! Check if VARNAME is a valid variable
         199           0 :     status = NF90_Inq_VarId( fId, varName, vId )
         200             :
         201             :     ! Exit w/ error message if VARNAME is not valid
         202           0 :     IF ( status /= NF90_NOERR ) THEN
         203             :        errMsg = 'In NcGet_Var_Attr_I4: ' // TRIM( varName )        // &
         204           0 :                  ', '                   // NF90_Strerror( status )
         205           0 :        CALL Do_Err_Out ( errMsg, .TRUE., 1, fId, 0, 0, 0.0d0, 0.0d0)
         206             :     ENDIF
         207             :
         208             :     ! Get the attribute
         209           0 :     status = NF90_Get_Att( fId, vId, attName, attValue )
         210             :
         211             :     ! Exit w/ error message if unsuccessful
         212           0 :     IF ( status /= NF90_NOERR ) THEN
         213             :        errMsg = 'In NcGet_Var_Attr_I4: cannot read attribute : ' // &
         214           0 :                  TRIM( attName )
         215           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
         216             :     endif
         217             :
         218           0 :   END SUBROUTINE NcGet_Var_Attr_I4
         219             : !EOC
         220             : !------------------------------------------------------------------------------
         221             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
         222             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
         223             : !------------------------------------------------------------------------------
         224             : !BOP
         225             : !
         226             : ! !IROUTINE: NcGet_Var_Attr_R4
         227             : !
         228             : ! !DESCRIPTION: Returns a variable attribute of type REAL*4.
         229             : !\\
         230             : !\\
         231             : ! !INTERFACE:
         232             : !
         233           0 :   SUBROUTINE NcGet_Var_Attr_R4( fid, varName, attName, attValue )
         234             : !
         235             : ! USES:
         236             : !
         237             :     USE netCDF
         238             :     USE m_do_err_out
         239             : !
         240             : ! !INPUT PARAMETERS:
         241             : !
         242             :     INTEGER,          INTENT(IN)  :: fId        ! netCDF file ID
         243             :     CHARACTER(LEN=*), INTENT(IN)  :: varName    ! netCDF variable name
         244             :     CHARACTER(LEN=*), INTENT(IN)  :: attName    ! Name of variable attribute
         245             : !
         246             : ! !OUTPUT PARAMETERS:
         247             : !
         248             :     REAL*4,           INTENT(OUT) :: attValue   ! Attribute value
         249             : !
         250             : ! !DESCRIPTION: Reads a variable attribute (REAL*4 type) from a netCDF file.
         251             : !\\
         252             : !\\
         253             : ! !AUTHOR:
         254             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
         255             : !
         256             : ! !REVISION HISTORY:
         257             : !  See https://github.com/geoschem/hemco for complete history
         258             : !EOP
         259             : !------------------------------------------------------------------------------
         260             : !BOC
         261             : !
         262             : ! !LOCAL VARIABLES:
         263             : !
         264             :     CHARACTER(LEN=512) :: errMsg
         265             :     INTEGER            :: status, vId
         266             :
         267             :     ! Zero return value
         268           0 :     attValue = 0e0
         269             :
         270             :     ! Check if VARNAME is a valid variable
         271           0 :     status = NF90_Inq_VarId( fId, varName, vId )
         272             :
         273             :     ! Exit w/ error message if VARNAME is not valid
         274           0 :     IF ( status /= NF90_NOERR ) THEN
         275             :        errMsg = 'In NcGet_Var_Attr_R4: ' // TRIM( varName )        // &
         276           0 :                  ', '                   // NF90_Strerror( status )
         277           0 :        CALL Do_Err_Out ( errMsg, .TRUE., 1, fId, 0, 0, 0.0d0, 0.0d0)
         278             :     ENDIF
         279             :
         280             :     ! Get the attribute
         281           0 :     status = NF90_Get_Att( fId, vId, attName, attValue )
         282             :
         283             :     ! Exit w/ error message if unsuccessful
         284           0 :     IF ( status /= NF90_NOERR ) THEN
         285             :        errMsg = 'In NcGet_Var_Attr_R4: cannot read attribute : ' // &
         286           0 :                  TRIM( attName )
         287           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
         288             :     endif
         289             :
         290           0 :   END SUBROUTINE NcGet_Var_Attr_R4
         291             : !EOC
         292             : !------------------------------------------------------------------------------
         293             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
         294             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
         295             : !------------------------------------------------------------------------------
         296             : !BOP
         297             : !
         298             : ! !IROUTINE: NcGet_Var_Attr_R8
         299             : !
         300             : ! !DESCRIPTION: Returns a variable attribute of type REAL*8.
         301             : !\\
         302             : !\\
         303             : ! !INTERFACE:
         304             : !
         305           0 :   SUBROUTINE NcGet_Var_Attr_R8( fid, varName, attName, attValue )
         306             : !
         307             : ! USES:
         308             : !
         309             :     USE netCDF
         310             :     USE m_do_err_out
         311             : !
         312             : ! !INPUT PARAMETERS:
         313             : !
         314             :     INTEGER,          INTENT(IN)  :: fId        ! netCDF file ID
         315             :     CHARACTER(LEN=*), INTENT(IN)  :: varName    ! netCDF variable name
         316             :     CHARACTER(LEN=*), INTENT(IN)  :: attName    ! Name of variable attribute
         317             : !
         318             : ! !OUTPUT PARAMETERS:
         319             : !
         320             :     REAL*8,           INTENT(OUT) :: attValue   ! Attribute value
         321             : !
         322             : ! !DESCRIPTION: Reads a variable attribute (REAL*4 type) from a netCDF file.
         323             : !\\
         324             : !\\
         325             : ! !AUTHOR:
         326             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
         327             : !
         328             : ! !REVISION HISTORY:
         329             : !  See https://github.com/geoschem/hemco for complete history
         330             : !EOP
         331             : !------------------------------------------------------------------------------
         332             : !BOC
         333             : !
         334             : ! !LOCAL VARIABLES:
         335             : !
         336             :     CHARACTER(LEN=512) :: errMsg
         337             :     INTEGER            :: status, vId
         338             :
         339             :     ! Zero return value
         340           0 :     attValue = 0d0
         341             :
         342             :     ! Check if VARNAME is a valid variable
         343           0 :     status = NF90_Inq_VarId( fId, varName, vId )
         344             :
         345             :     ! Exit w/ error message if VARNAME is not valid
         346           0 :     IF ( status /= NF90_NOERR ) THEN
         347             :        errMsg = 'In NcGet_Var_Attr_R8: ' // TRIM( varName )        // &
         348           0 :                  ', '                   // NF90_Strerror( status )
         349           0 :        CALL Do_Err_Out ( errMsg, .TRUE., 1, fId, 0, 0, 0.0d0, 0.0d0)
         350             :     ENDIF
         351             :
         352             :     ! Get the attribute
         353           0 :     status = NF90_Get_Att( fId, vId, attName, attValue )
         354             :
         355             :     ! Exit w/ error message if unsuccessful
         356           0 :     IF ( status /= NF90_NOERR ) THEN
         357             :        errMsg = 'In NcGet_Var_Attr_R8: cannot read attribute : ' // &
         358           0 :                  TRIM( attName )
         359           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
         360             :     endif
         361             :
         362           0 :   END SUBROUTINE NcGet_Var_Attr_R8
         363             : !EOC
         364             : !------------------------------------------------------------------------------
         365             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
         366             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
         367             : !------------------------------------------------------------------------------
         368             : !BOP
         369             : !
         370             : ! !IROUTINE: NcGet_Var_Attr_I4_arr
         371             : !
         372             : ! !DESCRIPTION: Returns a vector variable attribute of type INTEGER*4.
         373             : !\\
         374             : !\\
         375             : ! !INTERFACE:
         376             : !
         377           0 :   SUBROUTINE NcGet_Var_Attr_I4_arr( fid, varName, attName, attValue )
         378             : !
         379             : ! USES:
         380             : !
         381             :     USE netCDF
         382             :     USE m_do_err_out
         383             : !
         384             : ! !INPUT PARAMETERS:
         385             : !
         386             :     INTEGER,          INTENT(IN)  :: fId          ! netCDF file ID
         387             :     CHARACTER(LEN=*), INTENT(IN)  :: varName      ! netCDF variable name
         388             :     CHARACTER(LEN=*), INTENT(IN)  :: attName      ! Name of variable attribute
         389             : !
         390             : ! !OUTPUT PARAMETERS:
         391             : !
         392             :     INTEGER,          INTENT(OUT) :: attValue(:)  ! Attribute value
         393             : !
         394             : ! !DESCRIPTION: Reads a variable attribute (INTEGER type) from a netCDF file.
         395             : !\\
         396             : !\\
         397             : ! !AUTHOR:
         398             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
         399             : !
         400             : ! !REVISION HISTORY:
         401             : !  See https://github.com/geoschem/hemco for complete history
         402             : !EOP
         403             : !------------------------------------------------------------------------------
         404             : !BOC
         405             : !
         406             : ! !LOCAL VARIABLES:
         407             : !
         408             :     CHARACTER(LEN=512) :: errMsg
         409             :     INTEGER            :: status, vId
         410             :
         411             :     ! Zero return value
         412           0 :     attValue = 0
         413             :
         414             :     ! Check if VARNAME is a valid variable
         415           0 :     status = NF90_Inq_VarId( fId, varName, vId )
         416             :
         417             :     ! Exit w/ error message if VARNAME is not valid
         418           0 :     IF ( status /= NF90_NOERR ) THEN
         419             :        errMsg = 'In NcGet_Var_Attr_I4_arr: ' // TRIM( varName )        // &
         420           0 :                  ', '                        // NF90_Strerror( status )
         421           0 :        CALL Do_Err_Out ( errMsg, .TRUE., 1, fId, 0, 0, 0.0d0, 0.0d0)
         422             :     ENDIF
         423             :
         424             :     ! Get the attribute
         425           0 :     status = NF90_Get_Att( fId, vId, attName, attValue )
         426             :
         427             :     ! Exit w/ error message if unsuccessful
         428           0 :     IF ( status /= NF90_NOERR ) THEN
         429             :        errMsg = 'In NcGet_Var_Attr_I4_arr: cannot read attribute : ' // &
         430           0 :                  TRIM( attName )
         431           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
         432             :     endif
         433             :
         434           0 :   END SUBROUTINE NcGet_Var_Attr_I4_arr
         435             : !EOC
         436             : !------------------------------------------------------------------------------
         437             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
         438             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
         439             : !------------------------------------------------------------------------------
         440             : !BOP
         441             : !
         442             : ! !IROUTINE: NcGet_Var_Attr_R4_arr
         443             : !
         444             : ! !DESCRIPTION: Returns a vector variable attribute of type REAL*4.
         445             : !\\
         446             : !\\
         447             : ! !INTERFACE:
         448             : !
         449           0 :   SUBROUTINE NcGet_Var_Attr_R4_arr( fid, varName, attName, attValue )
         450             : !
         451             : ! USES:
         452             : !
         453             :     USE netCDF
         454             :     USE m_do_err_out
         455             : !
         456             : ! !INPUT PARAMETERS:
         457             : !
         458             :     INTEGER,          INTENT(IN)  :: fId          ! netCDF file ID
         459             :     CHARACTER(LEN=*), INTENT(IN)  :: varName      ! netCDF variable name
         460             :     CHARACTER(LEN=*), INTENT(IN)  :: attName      ! Name of variable attribute
         461             : !
         462             : ! !OUTPUT PARAMETERS:
         463             : !
         464             :     REAL*4,           INTENT(OUT) :: attValue(:)  ! Attribute value
         465             : !
         466             : ! !DESCRIPTION: Reads a variable attribute (REAL*4 type) from a netCDF file.
         467             : !\\
         468             : !\\
         469             : ! !AUTHOR:
         470             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
         471             : !
         472             : ! !REVISION HISTORY:
         473             : !  See https://github.com/geoschem/hemco for complete history
         474             : !EOP
         475             : !------------------------------------------------------------------------------
         476             : !BOC
         477             : !
         478             : ! !LOCAL VARIABLES:
         479             : !
         480             :     CHARACTER(LEN=512) :: errMsg
         481             :     INTEGER            :: status, vId
         482             :
         483             :     ! Zero return value
         484           0 :     attValue = 0e0
         485             :
         486             :     ! Check if VARNAME is a valid variable
         487           0 :     status = NF90_Inq_VarId( fId, varName, vId )
         488             :
         489             :     ! Exit w/ error message if VARNAME is not valid
         490           0 :     IF ( status /= NF90_NOERR ) THEN
         491             :        errMsg = 'In NcGet_Var_Attr_R4_arr: ' // TRIM( varName )        // &
         492           0 :                  ', '                        // NF90_Strerror( status )
         493           0 :        CALL Do_Err_Out ( errMsg, .TRUE., 1, fId, 0, 0, 0.0d0, 0.0d0)
         494             :     ENDIF
         495             :
         496             :     ! Get the attribute
         497           0 :     status = NF90_Get_Att( fId, vId, attName, attValue )
         498             :
         499             :     ! Exit w/ error message if unsuccessful
         500           0 :     IF ( status /= NF90_NOERR ) THEN
         501             :        errMsg = 'In NcGet_Var_Attr_R4_arr: cannot read attribute : ' // &
         502           0 :                  TRIM( attName )
         503           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
         504             :     endif
         505             :
         506           0 :   END SUBROUTINE NcGet_Var_Attr_R4_arr
         507             : !EOC
         508             : !------------------------------------------------------------------------------
         509             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
         510             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
         511             : !------------------------------------------------------------------------------
         512             : !BOP
         513             : !
         514             : ! !IROUTINE: NcGet_Var_Attr_R8_arr
         515             : !
         516             : ! !DESCRIPTION: Returns a vector variable attribute of type REAL*8.
         517             : !\\
         518             : !\\
         519             : ! !INTERFACE:
         520             : !
         521           0 :   SUBROUTINE NcGet_Var_Attr_R8_arr( fid, varName, attName, attValue )
         522             : !
         523             : ! USES:
         524             : !
         525             :     USE netCDF
         526             :     USE m_do_err_out
         527             : !
         528             : ! !INPUT PARAMETERS:
         529             : !
         530             :     INTEGER,          INTENT(IN)  :: fId          ! netCDF file ID
         531             :     CHARACTER(LEN=*), INTENT(IN)  :: varName      ! netCDF variable name
         532             :     CHARACTER(LEN=*), INTENT(IN)  :: attName      ! Name of variable attribute
         533             : !
         534             : ! !OUTPUT PARAMETERS:
         535             : !
         536             :     REAL*8,           INTENT(OUT) :: attValue(:)  ! Attribute value
         537             : !
         538             : ! !DESCRIPTION: Reads a variable attribute (REAL*4 type) from a netCDF file.
         539             : !\\
         540             : !\\
         541             : ! !AUTHOR:
         542             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
         543             : !
         544             : ! !REVISION HISTORY:
         545             : !  See https://github.com/geoschem/hemco for complete history
         546             : !EOP
         547             : !------------------------------------------------------------------------------
         548             : !BOC
         549             : !
         550             : ! !LOCAL VARIABLES:
         551             : !
         552             :     CHARACTER(LEN=512) :: errMsg
         553             :     INTEGER            :: status, vId
         554             :
         555             :     ! Zero return value
         556           0 :     attValue = 0d0
         557             :
         558             :     ! Check if VARNAME is a valid variable
         559           0 :     status = NF90_Inq_VarId( fId, varName, vId )
         560             :
         561             :     ! Exit w/ error message if VARNAME is not valid
         562           0 :     IF ( status /= NF90_NOERR ) THEN
         563             :        errMsg = 'In NcGet_Var_Attr_R8_arr: ' // TRIM( varName )        // &
         564           0 :                  ', '                        // NF90_Strerror( status )
         565           0 :        CALL Do_Err_Out ( errMsg, .TRUE., 1, fId, 0, 0, 0.0d0, 0.0d0)
         566             :     ENDIF
         567             :
         568             :     ! Get the attribute
         569           0 :     status = NF90_Get_Att( fId, vId, attName, attValue )
         570             :
         571             :     ! Exit w/ error message if unsuccessful
         572           0 :     IF ( status /= NF90_NOERR ) THEN
         573             :        errMsg = 'In NcGet_Var_Attr_R8_arr: cannot read attribute : ' // &
         574           0 :                  TRIM( attName )
         575           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
         576             :     endif
         577             :
         578           0 :   END SUBROUTINE NcGet_Var_Attr_R8_arr
         579             : !EOC
         580             : !------------------------------------------------------------------------------
         581             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
         582             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
         583             : !------------------------------------------------------------------------------
         584             : !BOP
         585             : !
         586             : ! !IROUTINE: NcGet_Glob_Attr_C
         587             : !
         588             : ! !DESCRIPTION: Returns a variable attribute of type CHARACTER.
         589             : !\\
         590             : !\\
         591             : ! !INTERFACE:
         592             : !
         593           0 :   SUBROUTINE NcGet_Glob_Attr_C( fid, attName, attValue )
         594             : !
         595             : ! USES:
         596             : !
         597             :     USE netCDF
         598             :     USE m_do_err_out
         599             : !
         600             : ! !INPUT PARAMETERS:
         601             : !
         602             :     INTEGER,          INTENT(IN)  :: fId        ! netCDF file ID
         603             :     CHARACTER(LEN=*), INTENT(IN)  :: attName    ! Name of variable attribute
         604             : !
         605             : ! !OUTPUT PARAMETERS:
         606             : !
         607             :     CHARACTER(LEN=*), INTENT(OUT) :: attValue   ! Attribute value
         608             : !
         609             : ! !DESCRIPTION: Reads a global attribute (CHARACTER type) from a netCDF file.
         610             : !\\
         611             : !\\
         612             : ! !AUTHOR:
         613             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
         614             : !
         615             : ! !REVISION HISTORY:
         616             : !  See https://github.com/geoschem/hemco for complete history
         617             : !EOP
         618             : !------------------------------------------------------------------------------
         619             : !BOC
         620             : !
         621             : ! !LOCAL VARIABLES:
         622             : !
         623             :     CHARACTER(LEN=512) :: errMsg, varName
         624             :     INTEGER            :: status
         625             :
         626             :     ! Zero return value
         627           0 :     attValue = ''
         628             :
         629             :     ! Get the attribute
         630           0 :     status = NF90_Get_Att( fId, NF90_GLOBAL, attName, attValue )
         631             :
         632             :     ! Exit w/ error message if unsuccessful
         633           0 :     IF ( status /= NF90_NOERR ) THEN
         634             :        errMsg = 'In NcGet_Glob_Attr_C: cannot read attribute : ' // &
         635           0 :                  TRIM( attName )
         636           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
         637             :     endif
         638             :
         639           0 :   END SUBROUTINE NcGet_Glob_Attr_C
         640             : !EOC
         641             : !------------------------------------------------------------------------------
         642             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
         643             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
         644             : !------------------------------------------------------------------------------
         645             : !BOP
         646             : !
         647             : ! !IROUTINE: NcGet_Glob_Attr_I4
         648             : !
         649             : ! !DESCRIPTION: Returns a variable attribute of type INTEGER*4.
         650             : !\\
         651             : !\\
         652             : ! !INTERFACE:
         653             : !
         654           0 :   SUBROUTINE NcGet_Glob_Attr_I4( fid, attName, attValue )
         655             : !
         656             : ! USES:
         657             : !
         658             :     USE netCDF
         659             :     USE m_do_err_out
         660             : !
         661             : ! !INPUT PARAMETERS:
         662             : !
         663             :     INTEGER,          INTENT(IN)  :: fId        ! netCDF file ID
         664             :     CHARACTER(LEN=*), INTENT(IN)  :: attName    ! Name of variable attribute
         665             : !
         666             : ! !OUTPUT PARAMETERS:
         667             : !
         668             :     INTEGER,          INTENT(OUT) :: attValue   ! Attribute value
         669             : !
         670             : ! !DESCRIPTION: Reads a global attribute (INTEGER type) from a netCDF file.
         671             : !\\
         672             : !\\
         673             : ! !AUTHOR:
         674             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
         675             : !
         676             : ! !REVISION HISTORY:
         677             : !  See https://github.com/geoschem/hemco for complete history
         678             : !EOP
         679             : !------------------------------------------------------------------------------
         680             : !BOC
         681             : !
         682             : ! !LOCAL VARIABLES:
         683             : !
         684             :     CHARACTER(LEN=512) :: errMsg, varName
         685             :     INTEGER            :: status
         686             :
         687             :     ! Zero return value
         688           0 :     attValue = 0
         689             :
         690             :     ! Get the attribute
         691           0 :     status = NF90_Get_Att( fId, NF90_GLOBAL, attName, attValue )
         692             :
         693             :     ! Exit w/ error message if unsuccessful
         694           0 :     IF ( status /= NF90_NOERR ) THEN
         695             :        errMsg = 'In NcGet_Glob_Attr_I4: cannot read attribute : ' // &
         696           0 :                  TRIM( attName )
         697           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
         698             :     endif
         699             :
         700           0 :   END SUBROUTINE NcGet_Glob_Attr_I4
         701             : !EOC
         702             : !------------------------------------------------------------------------------
         703             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
         704             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
         705             : !------------------------------------------------------------------------------
         706             : !BOP
         707             : !
         708             : ! !IROUTINE: NcGet_Glob_Attr_R4
         709             : !
         710             : ! !DESCRIPTION: Returns a variable attribute of type REAL*4.
         711             : !\\
         712             : !\\
         713             : ! !INTERFACE:
         714             : !
         715           0 :   SUBROUTINE NcGet_Glob_Attr_R4( fid, attName, attValue )
         716             : !
         717             : ! USES:
         718             : !
         719             :     USE netCDF
         720             :     USE m_do_err_out
         721             : !
         722             : ! !INPUT PARAMETERS:
         723             : !
         724             :     INTEGER,          INTENT(IN)  :: fId        ! netCDF file ID
         725             :     CHARACTER(LEN=*), INTENT(IN)  :: attName    ! Name of variable attribute
         726             : !
         727             : ! !OUTPUT PARAMETERS:
         728             : !
         729             :     REAL*4,           INTENT(OUT) :: attValue   ! Attribute value
         730             : !
         731             : ! !DESCRIPTION: Reads a global attribute (REAL*4 type) from a netCDF file.
         732             : !\\
         733             : !\\
         734             : ! !AUTHOR:
         735             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
         736             : !
         737             : ! !REVISION HISTORY:
         738             : !  See https://github.com/geoschem/hemco for complete history
         739             : !EOP
         740             : !------------------------------------------------------------------------------
         741             : !BOC
         742             : !
         743             : ! !LOCAL VARIABLES:
         744             : !
         745             :     CHARACTER(LEN=512) :: errMsg, varName
         746             :     INTEGER            :: status
         747             :
         748             :     ! Zero return value
         749           0 :     attValue = 0e0
         750             :
         751             :     ! Get the attribute
         752           0 :     status = NF90_Get_Att( fId, NF90_GLOBAL, attName, attValue )
         753             :
         754             :     ! Exit w/ error message if unsuccessful
         755           0 :     IF ( status /= NF90_NOERR ) THEN
         756             :        errMsg = 'In NcGet_Glob_Attr_R4: cannot read attribute : ' // &
         757           0 :                  TRIM( attName )
         758           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
         759             :     endif
         760             :
         761           0 :   END SUBROUTINE NcGet_Glob_Attr_R4
         762             : !EOC
         763             : !------------------------------------------------------------------------------
         764             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
         765             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
         766             : !------------------------------------------------------------------------------
         767             : !BOP
         768             : !
         769             : ! !IROUTINE: NcGet_Glob_Attr_R8
         770             : !
         771             : ! !DESCRIPTION: Returns a variable attribute of type REAL*8.
         772             : !\\
         773             : !\\
         774             : ! !INTERFACE:
         775             : !
         776           0 :   SUBROUTINE NcGet_Glob_Attr_R8( fid, attName, attValue )
         777             : !
         778             : ! USES:
         779             : !
         780             :     USE netCDF
         781             :     USE m_do_err_out
         782             : !
         783             : ! !INPUT PARAMETERS:
         784             : !
         785             :     INTEGER,          INTENT(IN)  :: fId        ! netCDF file ID
         786             :     CHARACTER(LEN=*), INTENT(IN)  :: attName    ! Name of variable attribute
         787             : !
         788             : ! !OUTPUT PARAMETERS:
         789             : !
         790             :     REAL*8,           INTENT(OUT) :: attValue   ! Attribute value
         791             : !
         792             : ! !DESCRIPTION: Reads a global attribute (REAL*8 type) from a netCDF file.
         793             : !\\
         794             : !\\
         795             : ! !AUTHOR:
         796             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
         797             : !
         798             : ! !REVISION HISTORY:
         799             : !  See https://github.com/geoschem/hemco for complete history
         800             : !EOP
         801             : !------------------------------------------------------------------------------
         802             : !BOC
         803             : !
         804             : ! !LOCAL VARIABLES:
         805             : !
         806             :     CHARACTER(LEN=512) :: errMsg, varName
         807             :     INTEGER            :: status
         808             :
         809             :     ! Zero return value
         810           0 :     attValue = 0d0
         811             :
         812             :     ! Get the attribute
         813           0 :     status = NF90_Get_Att( fId, NF90_GLOBAL, attName, attValue )
         814             :
         815             :     ! Exit w/ error message if unsuccessful
         816           0 :     IF ( status /= NF90_NOERR ) THEN
         817             :        errMsg = 'In NcGet_Glob_Attr_R8: cannot read attribute : ' // &
         818           0 :                  TRIM( attName )
         819           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
         820             :     endif
         821             :
         822           0 :   END SUBROUTINE NcGet_Glob_Attr_R8
         823             : !EOC
         824             : !------------------------------------------------------------------------------
         825             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
         826             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
         827             : !------------------------------------------------------------------------------
         828             : !BOP
         829             : !
         830             : ! !IROUTINE: NcGet_Glob_Attr_I4_arr
         831             : !
         832             : ! !DESCRIPTION: Returns a variable attribute of type INTEGER*4.
         833             : !\\
         834             : !\\
         835             : ! !INTERFACE:
         836             : !
         837           0 :   SUBROUTINE NcGet_Glob_Attr_I4_arr( fid, attName, attValue )
         838             : !
         839             : ! USES:
         840             : !
         841             :     USE netCDF
         842             :     USE m_do_err_out
         843             : !
         844             : ! !INPUT PARAMETERS:
         845             : !
         846             :     INTEGER,          INTENT(IN)  :: fId          ! netCDF file ID
         847             :     CHARACTER(LEN=*), INTENT(IN)  :: attName      ! Name of variable attribute
         848             : !
         849             : ! !OUTPUT PARAMETERS:
         850             : !
         851             :     INTEGER,          INTENT(OUT) :: attValue(:)  ! Attribute value
         852             : !
         853             : ! !DESCRIPTION: Reads a global attribute (INTEGER type) from a netCDF file.
         854             : !\\
         855             : !\\
         856             : ! !AUTHOR:
         857             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
         858             : !
         859             : ! !REVISION HISTORY:
         860             : !  See https://github.com/geoschem/hemco for complete history
         861             : !EOP
         862             : !------------------------------------------------------------------------------
         863             : !BOC
         864             : !
         865             : ! !LOCAL VARIABLES:
         866             : !
         867             :     CHARACTER(LEN=512) :: errMsg, varName
         868             :     INTEGER            :: status
         869             :
         870             :     ! Zero return value
         871           0 :     attValue = 0
         872             :
         873             :     ! Get the attribute
         874           0 :     status = NF90_Get_Att( fId, NF90_GLOBAL, attName, attValue )
         875             :
         876             :     ! Exit w/ error message if unsuccessful
         877           0 :     IF ( status /= NF90_NOERR ) THEN
         878             :        errMsg = 'In NcGet_Glob_Attr_I4_arr: cannot read attribute : ' // &
         879           0 :                  TRIM( attName )
         880           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
         881             :     endif
         882             :
         883           0 :   END SUBROUTINE NcGet_Glob_Attr_I4_arr
         884             : !EOC
         885             : !------------------------------------------------------------------------------
         886             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
         887             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
         888             : !------------------------------------------------------------------------------
         889             : !BOP
         890             : !
         891             : ! !IROUTINE: NcGet_Glob_Attr_R4_arr
         892             : !
         893             : ! !DESCRIPTION: Returns a variable attribute of type REAL*4.
         894             : !\\
         895             : !\\
         896             : ! !INTERFACE:
         897             : !
         898           0 :   SUBROUTINE NcGet_Glob_Attr_R4_arr( fid, attName, attValue )
         899             : !
         900             : ! USES:
         901             : !
         902             :     USE netCDF
         903             :     USE m_do_err_out
         904             : !
         905             : ! !INPUT PARAMETERS:
         906             : !
         907             :     INTEGER,          INTENT(IN)  :: fId          ! netCDF file ID
         908             :     CHARACTER(LEN=*), INTENT(IN)  :: attName      ! Name of variable attribute
         909             : !
         910             : ! !OUTPUT PARAMETERS:
         911             : !
         912             :     REAL*4,           INTENT(OUT) :: attValue(:)  ! Attribute value
         913             : !
         914             : ! !DESCRIPTION: Reads a global attribute (REAL*4 type) from a netCDF file.
         915             : !\\
         916             : !\\
         917             : ! !AUTHOR:
         918             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
         919             : !
         920             : ! !REVISION HISTORY:
         921             : !  See https://github.com/geoschem/hemco for complete history
         922             : !EOP
         923             : !------------------------------------------------------------------------------
         924             : !BOC
         925             : !
         926             : ! !LOCAL VARIABLES:
         927             : !
         928             :     CHARACTER(LEN=512) :: errMsg, varName
         929             :     INTEGER            :: status
         930             :
         931             :     ! Zero return value
         932           0 :     attValue = 0e0
         933             :
         934             :     ! Get the attribute
         935           0 :     status = NF90_Get_Att( fId, NF90_GLOBAL, attName, attValue )
         936             :
         937             :     ! Exit w/ error message if unsuccessful
         938           0 :     IF ( status /= NF90_NOERR ) THEN
         939             :        errMsg = 'In NcGet_Glob_Attr_R4_arr: cannot read attribute : ' // &
         940           0 :                  TRIM( attName )
         941           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
         942             :     endif
         943             :
         944           0 :   END SUBROUTINE NcGet_Glob_Attr_R4_arr
         945             : !EOC
         946             : !------------------------------------------------------------------------------
         947             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
         948             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
         949             : !------------------------------------------------------------------------------
         950             : !BOP
         951             : !
         952             : ! !IROUTINE: NcGet_Glob_Attr_R8
         953             : !
         954             : ! !DESCRIPTION: Returns a variable attribute of type REAL*8.
         955             : !\\
         956             : !\\
         957             : ! !INTERFACE:
         958             : !
         959           0 :   SUBROUTINE NcGet_Glob_Attr_R8_arr( fid, attName, attValue )
         960             : !
         961             : ! USES:
         962             : !
         963             :     USE netCDF
         964             :     USE m_do_err_out
         965             : !
         966             : ! !INPUT PARAMETERS:
         967             : !
         968             :     INTEGER,          INTENT(IN)  :: fId          ! netCDF file ID
         969             :     CHARACTER(LEN=*), INTENT(IN)  :: attName      ! Name of variable attribute
         970             : !
         971             : ! !OUTPUT PARAMETERS:
         972             : !
         973             :     REAL*8,           INTENT(OUT) :: attValue(:)  ! Attribute value
         974             : !
         975             : ! !DESCRIPTION: Reads a global attribute (REAL*8 type) from a netCDF file.
         976             : !\\
         977             : !\\
         978             : ! !AUTHOR:
         979             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
         980             : !
         981             : ! !REVISION HISTORY:
         982             : !  See https://github.com/geoschem/hemco for complete history
         983             : !EOP
         984             : !------------------------------------------------------------------------------
         985             : !BOC
         986             : !
         987             : ! !LOCAL VARIABLES:
         988             : !
         989             :     CHARACTER(LEN=512) :: errMsg, varName
         990             :     INTEGER            :: status
         991             :
         992             :     ! Zero return value
         993           0 :     attValue = 0d0
         994             :
         995             :     ! Get the attribute
         996           0 :     status = NF90_Get_Att( fId, NF90_GLOBAL, attName, attValue )
         997             :
         998             :     ! Exit w/ error message if unsuccessful
         999           0 :     IF ( status /= NF90_NOERR ) THEN
        1000             :        errMsg = 'In NcGet_Glob_Attr_R8_arr: cannot read attribute : ' // &
        1001           0 :                  TRIM( attName )
        1002           0 :        CALL Do_Err_Out( errMsg, .TRUE., 0, 0, 0, 0, 0.0d0, 0.0d0 )
        1003             :     endif
        1004             :
        1005           0 :   END SUBROUTINE NcGet_Glob_Attr_R8_arr
        1006             : !EOC
        1007             : !------------------------------------------------------------------------------
        1008             : !       NcdfUtilities: by Harvard Atmospheric Chemistry Modeling Group        !
        1009             : !                      and NASA/GSFC, SIVO, Code 610.3                        !
        1010             : !------------------------------------------------------------------------------
        1011             : !BOP
        1012             : !
        1013             : ! !IROUTINE: NcGet_Var_Attr_C_nostop
        1014             : !
        1015             : ! !DESCRIPTION: Returns a variable attribute of type CHARACTER.  Similar
        1016             : !  to NcGet_Var_Attr_C, but does not stop upon error,  Instead, a status
        1017             : !  flag is passed back to the calling routine.
        1018             : !\\
        1019             : !\\
        1020             : ! !INTERFACE:
        1021             : !
        1022           0 :   SUBROUTINE NcGet_Var_Attr_C_nostop( fId, varName, attName, attValue, RC )
        1023             : !
        1024             : ! USES:
        1025             : !
        1026             :     USE netCDF
        1027             :     USE m_do_err_out
        1028             : !
        1029             : ! !INPUT PARAMETERS:
        1030             : !
        1031             :     INTEGER,          INTENT(IN)  :: fId        ! netCDF file ID
        1032             :     CHARACTER(LEN=*), INTENT(IN)  :: varName    ! netCDF variable name
        1033             :     CHARACTER(LEN=*), INTENT(IN)  :: attName    ! Name of variable attribute
        1034             : !
        1035             : ! !OUTPUT PARAMETERS:
        1036             : !
        1037             :     CHARACTER(LEN=*), INTENT(OUT) :: attValue   ! Attribute value
        1038             :     INTEGER,          INTENT(OUT) :: RC         ! Success or failure?
        1039             : !
        1040             : ! !DESCRIPTION: Reads a variable attribute (CHARACTER type) from a netCDF file.
        1041             : !\\
        1042             : !\\
        1043             : ! !AUTHOR:
        1044             : !  Bob Yantosca (based on code by Jules Kouatchou and Maharaj Bhat)
        1045             : !
        1046             : ! !REVISION HISTORY:
        1047             : !  See https://github.com/geoschem/hemco for complete history
        1048             : !EOP
        1049             : !------------------------------------------------------------------------------
        1050             : !BOC
        1051             : !
        1052             : ! !LOCAL VARIABLES:
        1053             : !
        1054             :     CHARACTER(LEN=512) :: errMsg
        1055             :     INTEGER            :: status, vId
        1056             :
        1057             :     ! Zero return value
        1058           0 :     attValue = ''
        1059             :
        1060             :     ! Check if VARNAME is a valid variable
        1061           0 :     status = NF90_Inq_VarId( fId, varName, vId )
        1062             :
        1063             :     ! Exit w/ error message if VARNAME is not valid
        1064           0 :     IF ( status /= NF90_NOERR ) THEN
        1065           0 :        RC = status
        1066           0 :        RETURN
        1067             :     ENDIF
        1068             :
        1069             :     !  Get the attribute
        1070           0 :     status = NF90_Get_Att( fId, vId, attName, attValue )
        1071             :
        1072             :     ! Exit w/ error message if unsuccessful
        1073           0 :     IF ( status /= NF90_NOERR ) THEN
        1074           0 :        RC = status
        1075           0 :        RETURN
        1076             :     ENDIF
        1077             :
        1078           0 :   END SUBROUTINE NcGet_Var_Attr_C_nostop
        1079             : !EOC
        1080             : END MODULE HCO_m_netcdf_io_readattr

Generated by: LCOV version 1.14