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

Generated by: LCOV version 1.14