2204 lines
75 KiB
Fortran
2204 lines
75 KiB
Fortran
! $Id: He4SwathModule.f90,v 1.1 2009/06/18 19:53:07 daven Exp $
|
|
MODULE He4SwathModule
|
|
|
|
!========================================================================
|
|
! Module He4SwathModule contains routines for reading data from swath
|
|
! data structures in HDF-EOS4 data files. (bmy, 1/17/06, 4/8/08)
|
|
!
|
|
! Module Variables:
|
|
! -----------------------------------------------------------------------
|
|
! (1 ) VERBOSE (LOGICAL ) : Flag for toggling verbose output
|
|
! (2 ) dataTypeName (CHARACTER) : Array w/ names of HDF-EOS4 data types
|
|
! (3 ) saveFileName (CHARACTER) : Shadow variable for filename
|
|
! (4 ) saveSwathName (CHARACTER) : Shadow variable for swath name
|
|
!
|
|
! Module Routines:
|
|
! -----------------------------------------------------------------------
|
|
! (1 ) He4VerboseOutput : Toggles verbose output for file I/O
|
|
! (2 ) He4FileOpen : Opens HDF4-EOS file; gets file ID #
|
|
! (3 ) He4FileClose : Closes HDF4-EOS file
|
|
! (4 ) He4SwathAttach : Attaches to swath; gets swath ID #
|
|
! (5 ) He4SwathDetach : Detaches from swath
|
|
! (6 ) He4SwathDimInfo : Gets dimension names, types, sizes
|
|
! (7 ) He4SwathGeoFldInfo : Gets info about swath geoloc fields
|
|
! (8 ) He4SwathDataFldInfo : Gets info about swath data fields
|
|
! (9 ) He4SwathFldInfo : Gets info about an individual field
|
|
! (10) He4SwathFillValue : Gets missing data fill values
|
|
! (11) He4SwathAttrs : Gets attributes from HDF4-EOS swath
|
|
! (11) He4SwathReadAttrChar : Reads CHARACTER attribute from swath
|
|
! (11) He4SwathReadAttrI2 : Reads INTEGER*2 attribute from swath
|
|
! (11) He4SwathReadAttrI4 : Reads INTEGER*4 attribute from swath
|
|
! (11) He4SwathReadAttrR4 : Reads REAL*4 attribute from swath
|
|
! (11) He4SwathReadAttrR8 : Reads REAL*8 attribute from swath
|
|
! (12) He4SwathReadData1dI2 : Reads 1-D INTEGER*2 data array
|
|
! (12) He4SwathReadData1dI4 : Reads 1-D INTEGER*4 data array
|
|
! (12) He4SwathReadData1dR4 : Reads 1-D REAL*4 data array
|
|
! (13) He4SwathReadData1dR8 : Reads 1-D REAL*8 data array
|
|
! (12) He4SwathReadData2dI2 : Reads 2-D INTEGER*2 data array
|
|
! (12) He4SwathReadData2dI4 : Reads 2-D INTEGER*4 data array
|
|
! (14) He4SwathReadData2dR4 : Reads 2-D REAL*4 data array
|
|
! (15) He4SwathReadData2dR8 : Reads 2-D REAL*8 data array
|
|
! (16) He4SwathReadData3dI2 : Reads 3-D INTEGER*2 data array
|
|
! (17) He4SwathReadData3dI4 : Reads 3-D INTEGER*4 data array
|
|
! (18) He4SwathReadData3dR4 : Reads 3-D REAL*4 data array
|
|
! (19) He4SwathReadData3dR8 : Reads 3-D REAL*8 data array
|
|
! (20) He4SwathReadData4dI2 : Reads 3-D INTEGER*2 data array
|
|
! (21) He4SwathReadData4dI4 : Reads 3-D INTEGER*4 data array
|
|
! (22) He4SwathReadData4dR4 : Reads 3-D REAL*4 data array
|
|
! (23) He4SwathReadData4dR8 : Reads 3-D REAL*8 data array
|
|
! (24) makeCharArrayFromCharList : Splits char list into char array
|
|
! (25) He4DataTypeName : Returns data type name from type #
|
|
!
|
|
! Module Interfaces:
|
|
! -----------------------------------------------------------------------
|
|
! (1 ) He4ReadSwathData -- overloads these routines
|
|
! (a) He4SwathReadData1dI2
|
|
! (b) He4SwathReadData1dI4
|
|
! (c) He4SwathReadData1dR4
|
|
! (d) He4SwathReadData1dR8
|
|
! (e) He4SwathReadData2dI2
|
|
! (f) He4SwathReadData2dI4
|
|
! (g) He4SwathReadData2dR4
|
|
! (h) He4SwathReadData2dR8
|
|
! (i) He4SwathReadData3dI2
|
|
! (j) He4SwathReadData3dI4
|
|
! (k) He4SwathReadData3dR4
|
|
! (l) He4SwathReadData3dR8
|
|
! (m) He4SwathReadData4dI2
|
|
! (n) He4SwathReadData4dI4
|
|
! (o) He4SwathReadData4dR4
|
|
! (p) He4SwathReadData4dR8
|
|
!
|
|
! (2 ) He4ReadSwathAttr -- overloads these routines
|
|
! (a) He4SwathReadAttrChar
|
|
! (b) He4SwathReadAttrI2
|
|
! (c) He4SwathReadAttrI4
|
|
! (d) He4SwathReadAttrR4
|
|
! (e) He4SwathReadAttrR8
|
|
!
|
|
! Other Information:
|
|
! -----------------------------------------------------------------------
|
|
! (1 ) The data type HE4-INTEGER (represented by parameter HE4_INT in
|
|
! He4IncludeModule) is either INTEGER*4 or INTEGER*8 depending
|
|
! on platform. However, most HDF4-EOS applications require
|
|
! INTEGER*4 dimension variables, etc.
|
|
! (2 ) You must select your machine type in the file "He4Define.h".
|
|
! This will automatically set parameter HE4_INT accordingly.
|
|
! (3 ) Data arrays which are passed to the HDF-EOS4 library function
|
|
! SwRdFld must be dimensioned with values of type HE4_INT.
|
|
! (4 ) Created interface for He4SwathReadAttr* functions. This is
|
|
! necessary to read attributes directly from the HDF4-EOS swath
|
|
! data structure. (bmy, 4/8/08)
|
|
!
|
|
! References:
|
|
! -----------------------------------------------------------------------
|
|
! (1 ) http://hdf.ncsa.uiuc.edu/HDF4/
|
|
! -- HDF4 home page
|
|
! (2 ) http://newsroom.gsfc.nasa.gov/sdptoolkit/toolkit.html
|
|
! -- ECS toolkit home page (home of HDF-EOS4)
|
|
!
|
|
! NOTES:
|
|
! (1 ) Added routines for 1dI2, IdI4, 2dI2, 2dI4, 3dI2, 3dI4 data types
|
|
! (bmy, 8/20/07)
|
|
! (2 ) Added routines for 4dI2, 4dI4, 4dR4, 4dR8 data types (bmy, 9/20/07)
|
|
!========================================================================
|
|
|
|
! References to F90 modules
|
|
USE He4ErrorModule
|
|
USE He4IncludeModule
|
|
|
|
! Force explicit data types
|
|
IMPLICIT NONE
|
|
|
|
!------------------------------------------------------------------------
|
|
! PRIVATE / PUBLIC DECLARATIONS
|
|
!------------------------------------------------------------------------
|
|
|
|
! Make everything PRIVATE ...
|
|
PRIVATE
|
|
|
|
! ... except these routines
|
|
PUBLIC :: He4VerboseOutput
|
|
PUBLIC :: He4FileOpen
|
|
PUBLIC :: He4FileClose
|
|
PUBLIC :: He4SwathAttach
|
|
PUBLIC :: He4SwathDetach
|
|
PUBLIC :: He4SwathDimInfo
|
|
PUBLIC :: He4SwathGeoFldInfo
|
|
PUBLIC :: He4SwathDataFldInfo
|
|
PUBLIC :: He4SwathFldInfo
|
|
PUBLIC :: He4SwathFillValue
|
|
PUBLIC :: He4SwathAttrs
|
|
PUBLIC :: He4SwathReadAttr
|
|
PUBLIC :: He4SwathReadData
|
|
|
|
!------------------------------------------------------------------------
|
|
! MODULE VARIABLES
|
|
!------------------------------------------------------------------------
|
|
LOGICAL :: VERBOSE = .FALSE.
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: dataTypeName(57)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: saveFileName
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: saveSwathName
|
|
|
|
!------------------------------------------------------------------------
|
|
! MODULE INTERFACES
|
|
!------------------------------------------------------------------------
|
|
INTERFACE He4SwathReadAttr
|
|
MODULE PROCEDURE He4SwathReadAttrChar
|
|
MODULE PROCEDURE He4SwathReadAttrI2
|
|
MODULE PROCEDURE He4SwathReadAttrI4
|
|
MODULE PROCEDURE He4SwathReadAttrR4
|
|
MODULE PROCEDURE He4SwathReadAttrR8
|
|
END INTERFACE
|
|
|
|
INTERFACE He4SwathReadData
|
|
MODULE PROCEDURE He4SwathReadData1dI2
|
|
MODULE PROCEDURE He4SwathReadData1dI4
|
|
MODULE PROCEDURE He4SwathReadData1dR4
|
|
MODULE PROCEDURE He4SwathReadData1dR8
|
|
MODULE PROCEDURE He4SwathReadData2dI2
|
|
MODULE PROCEDURE He4SwathReadData2dI4
|
|
MODULE PROCEDURE He4SwathReadData2dR4
|
|
MODULE PROCEDURE He4SwathReadData2dR8
|
|
MODULE PROCEDURE He4SwathReadData3dI2
|
|
MODULE PROCEDURE He4SwathReadData3dI4
|
|
MODULE PROCEDURE He4SwathReadData3dR4
|
|
MODULE PROCEDURE He4SwathReadData3dR8
|
|
MODULE PROCEDURE He4SwathReadData4dI2
|
|
MODULE PROCEDURE He4SwathReadData4dI4
|
|
MODULE PROCEDURE He4SwathReadData4dR4
|
|
MODULE PROCEDURE He4SwathReadData4dR8
|
|
END INTERFACE
|
|
|
|
CONTAINS
|
|
|
|
!------------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4VerboseOutput( v )
|
|
|
|
!======================================================================
|
|
! Subroutine He4VerboseOutput is used to trigger "extra" output from
|
|
! the routines in this module. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) v (LOGICAL) : TRUE or FALSE value
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
LOGICAL, INTENT(IN) :: v
|
|
|
|
! Set the value of verbose
|
|
VERBOSE = v
|
|
|
|
END SUBROUTINE He4VerboseOutput
|
|
|
|
!------------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4FileOpen( fileName, fId )
|
|
|
|
!======================================================================
|
|
! Subroutine He4FileOpen opens an HDF-EOS4 file and returns the
|
|
! file Id number. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) fileName (CHARACTER) : Name of HDF-EOS4 file to open
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (2) fId (INTEGER ) : HDF-EOS4 file ID number
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
CHARACTER(LEN=*), INTENT(IN) :: fileName
|
|
INTEGER, INTENT(OUT) :: fId
|
|
|
|
! Local variables
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwOpen
|
|
|
|
!--------------------------
|
|
! He4FileOpen begins here!
|
|
!--------------------------
|
|
|
|
! Store filename in a shadow variable
|
|
saveFileName = fileName
|
|
|
|
! Open HDF-EOS4 file and get file ID #
|
|
fId = SwOpen( fileName, DFACC_RDONLY )
|
|
|
|
! Error check
|
|
IF ( fId == FAILURE ) THEN
|
|
msg = 'Error opening file ' // TRIM( saveFileName )
|
|
loc = 'He4FileOpen ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( saveFileName )
|
|
WRITE( 6, 110 ) fId
|
|
100 FORMAT( '===> HDF-EOS4 file name : "', a, '"' )
|
|
110 FORMAT( '===> HDF-EOS4 file ID : ', i10 )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4FileOpen
|
|
|
|
!------------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4FileClose( fId )
|
|
|
|
!======================================================================
|
|
! Subroutine He4FileClose closes an HDF-EOS4 file. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) fId (INTEGER) : HDF-EOS4 file ID number
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: fId
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwClose
|
|
|
|
!---------------------------
|
|
! He4FileClose begins here!
|
|
!---------------------------
|
|
|
|
! Get HDF-EOS4 file ID
|
|
status = SwClose( fId )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error closing file ' // TRIM( savefileName )
|
|
loc = 'He4FileClose ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( saveFileName )
|
|
100 FORMAT( '===> Closed file "', a, '"' )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4FileClose
|
|
|
|
!------------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathAttach( fId, swathName, sId )
|
|
|
|
!======================================================================
|
|
! Subroutine He4SwathAttach attaches to an HDF-EOS4 swath data
|
|
! structure and returns the swath ID number. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) fId (INTEGER) : HDF-EOS4 file ID (see He4FileOpen)
|
|
! (2) swathName (CHARACTER) : Name of HDF-EOS4 swath to attach to
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (3) sId (INTEGER) : HDF-EOS4 swath ID number
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: fId
|
|
CHARACTER(LEN=*), INTENT(IN) :: swathName
|
|
INTEGER, INTENT(OUT) :: sId
|
|
|
|
! Local variables
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwAttach
|
|
|
|
!-----------------------------
|
|
! He4SwathAttach begins here!
|
|
!-----------------------------
|
|
|
|
! Save swathname in a shadow variable
|
|
saveSwathName = swathName
|
|
|
|
! Attach to swath
|
|
sId = SwAttach( fId, swathName )
|
|
|
|
! Error check
|
|
IF ( sId == FAILURE ) THEN
|
|
msg = 'Error attaching to swath ' // TRIM( saveSwathName )
|
|
loc = 'He4SwathAttach ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( saveSwathName )
|
|
WRITE( 6, 110 ) sId
|
|
100 FORMAT( '===> HDF-EOS4 swath name: "', a, '"' )
|
|
110 FORMAT( '===> HDF-EOS4 swath ID : ', i10 )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathAttach
|
|
|
|
!------------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathDetach( sId )
|
|
|
|
!======================================================================
|
|
! Subroutine He4SwathDetach detaches from an HDF-EOS4 swath
|
|
! data structure. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) sId (INTEGER) : HDF-EOS4 swath ID number (see He4SwathAttach)
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwDetach
|
|
|
|
!-----------------------------
|
|
! He4SwathDetach begins here!
|
|
!-----------------------------
|
|
|
|
! Detach from swath
|
|
status = SwDetach( sId )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error detaching from swath ' // TRIM( saveSwathName )
|
|
loc = 'He4SwathDetach ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( saveSwathName )
|
|
100 FORMAT( '===> Detached from swath "', a, '"' )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathDetach
|
|
|
|
!------------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathDimInfo( sId, nDims, dims, dimNames )
|
|
|
|
!======================================================================
|
|
! Subroutine He4SwathDetach detaches from an HDF-EOS4 swath
|
|
! data structure. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) sId (INTEGER) : HDF-EOS4 swath ID number (see He4SwathAttach)
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER, INTENT(OUT) :: nDims
|
|
INTEGER, INTENT(OUT) :: dims(HE4_MAX_DIMS)
|
|
CHARACTER(LEN=HE4_MAX_CHAR), INTENT(OUT) :: dimNames(HE4_MAX_DIMS)
|
|
|
|
! Local variables
|
|
INTEGER :: N, C
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc, dimList
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwInqDims
|
|
|
|
!------------------------------
|
|
! He4SwathDimInfo begins here!
|
|
!------------------------------
|
|
|
|
! Initialize
|
|
nDims = 0
|
|
dims(:) = 0
|
|
dimNames(:) = ''
|
|
|
|
! Get dimension info for this swath
|
|
nDims = SwInqDims( sId, dimList, dims )
|
|
|
|
! Make an array from the dimension list
|
|
CALL makeCharArrayFromCharList( dimList, ',', dimNames )
|
|
|
|
! Comment out for now (bmy, 8/20/07)
|
|
! ! NOTE: Sometimes every other element of DIMS is zero.
|
|
! ! I don't know why but we can just pack the array to be
|
|
! ! on the safe side. (bmy, 1/17/06)
|
|
! C = 0
|
|
! DO N = 1, 2*nDims+1
|
|
! IF ( dims(N) > 0 ) THEN
|
|
! C = C + 1
|
|
! dims(C) = dims(N)
|
|
! IF ( N > 1 ) dims(N) = 0
|
|
! ENDIF
|
|
! ENDDO
|
|
|
|
! Error check
|
|
IF ( nDims <= 0 ) THEN
|
|
msg = 'Error getting dim info from swath ' // TRIM( saveSwathName )
|
|
loc = 'He4SwathDetach ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) nDims
|
|
|
|
DO N = 1, nDims
|
|
WRITE( 6, 110 ) TRIM( dimNames(N) ), dims(N)
|
|
ENDDO
|
|
|
|
100 FORMAT( '===> There are ', i4, ' dimensions' )
|
|
110 FORMAT( '===> ', a25,' is of size ', i10 )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathDimInfo
|
|
|
|
!------------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathGeoFldInfo( sId, nGeo, geoRank, geoName, geoType )
|
|
|
|
!======================================================================
|
|
! Subroutine He4SwathGeoFieldInfo obtains information about the
|
|
! geolocation fields in the HDF-EOS4 swath data structure.
|
|
! (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) sId (INTEGER ) : HDF-EOS4 swath ID number
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (2) nGeo (INTEGER ) : Number of geolocation fields
|
|
! (3) geoRank (INTEGER ) : Number of dimensions for each geoloc field
|
|
! (4) geoName (CHARACTER) : Name of each geolocation field
|
|
! (5) geoType (CHARACTER) : Data type of each geolocation field
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER, INTENT(OUT) :: nGeo
|
|
INTEGER, INTENT(OUT) :: geoRank(HE4_MAX_FLDS)
|
|
CHARACTER(LEN=HE4_MAX_CHAR), INTENT(OUT) :: geoName(HE4_MAX_FLDS)
|
|
CHARACTER(LEN=HE4_MAX_CHAR), INTENT(OUT) :: geoType(HE4_MAX_FLDS)
|
|
|
|
! Local variables
|
|
INTEGER :: N
|
|
INTEGER :: typeNum(HE4_MAX_FLDS)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc, geoList
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwInqGFlds
|
|
|
|
!---------------------------------
|
|
! He4SwathGeoFldInfo begins here!
|
|
!---------------------------------
|
|
|
|
! Initialize
|
|
nGeo = 0
|
|
geoRank(:) = 0
|
|
geoName(:) = ''
|
|
geoType(:) = ''
|
|
|
|
! Get number of geo fields and related info
|
|
nGeo = SwInqGFlds( sId, geoList, geoRank, typeNum )
|
|
|
|
! Error check
|
|
IF ( nGeo <= 0 ) THEN
|
|
msg = 'Error getting geolocation field information!'
|
|
loc = 'He4SwathGeoFldInfo ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Separate list of field names into an array
|
|
CALL makeCharArrayFromCharList( geoList, ',', geoName )
|
|
|
|
! Get HDF-EOS4 data type names for each data type number
|
|
DO N = 1, nGeo
|
|
geoType(N) = He4DataTypeName( typeNum(N) )
|
|
ENDDO
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) nGeo
|
|
|
|
DO N = 1, nGeo
|
|
WRITE( 6, 110 ) TRIM( geoName(N) ), geoRank(N), TRIM( geoType(N) )
|
|
ENDDO
|
|
|
|
100 FORMAT( '===> There are ', i4, ' Geolocation Fields' )
|
|
110 FORMAT( '===> ', a25, ' has ', i4 , ' dimensions and is ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathGeoFldInfo
|
|
|
|
!------------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathDataFldInfo( sId, nData, dataRank, dataName, dataType )
|
|
|
|
!======================================================================
|
|
! Subroutine He4SwathDataFieldInfo obtains information about the
|
|
! data fields in the HDF-EOS4 swath data structure. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) sId (INTEGER ) : HDF-EOS4 swath ID number
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (2) nData (INTEGER ) : Number of data fields
|
|
! (3) dataRank (INTEGER ) : Number of dimensions for each data field
|
|
! (4) dataName (CHARACTER) : Name of each data field
|
|
! (5) dataType (CHARACTER) : Data type of each data field
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER, INTENT(OUT) :: ndata
|
|
INTEGER, INTENT(OUT) :: dataRank(HE4_MAX_FLDS)
|
|
CHARACTER(LEN=HE4_MAX_CHAR), INTENT(OUT) :: dataName(HE4_MAX_FLDS)
|
|
CHARACTER(LEN=HE4_MAX_CHAR), INTENT(OUT) :: dataType(HE4_MAX_FLDS)
|
|
|
|
! Local variables
|
|
INTEGER :: N
|
|
INTEGER :: typeNum(HE4_MAX_FLDS)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc, dataList
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwInqDFlds
|
|
|
|
!---------------------------------
|
|
! He4SwathGeoFldInfo begins here!
|
|
!---------------------------------
|
|
|
|
! Initialize
|
|
nData = 0
|
|
dataRank(:) = 0
|
|
dataName(:) = ''
|
|
dataType(:) = ''
|
|
|
|
! Get number of data fields and related info
|
|
nData = SwInqDFlds( sId, dataList, dataRank, typeNum )
|
|
|
|
! Error check
|
|
IF ( nData <= 0 ) THEN
|
|
msg = 'Error getting data field information!'
|
|
loc = 'He4SwathDataFldInfo ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Separate list of field names into an array
|
|
CALL makeCharArrayFromCharList( dataList, ',', dataName )
|
|
|
|
! Get HDF-EOS4 data type names for each data type number
|
|
DO N = 1, nData
|
|
dataType(N) = He4DataTypeName( typeNum(N) )
|
|
ENDDO
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) nData
|
|
|
|
DO N = 1, nData
|
|
WRITE( 6, 110 ) TRIM( dataName(N) ), dataRank(N), TRIM( dataType(N) )
|
|
ENDDO
|
|
|
|
100 FORMAT( '===> There are ', i6, ' Data Fields' )
|
|
110 FORMAT( '===> ', a40, ' has ', i4 , ' dimensions and is ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathDataFldInfo
|
|
|
|
!------------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathFldInfo( sId, name, typeName, rank, dims, dimNames )
|
|
|
|
!======================================================================
|
|
! Subroutine He4SwathFldInfo obtains information about a particular
|
|
! data field in the HDF-EOS4 swath data structure. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) sId (INTEGER ) : HDF-EOS4 swath ID number
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (2) nData (INTEGER ) : Number of data fields
|
|
! (3) typeName (CHARACTER) : Name of the data type for this field
|
|
! (4) rank (INTEGER ) : Number of dimensions for each data field
|
|
! (4) dims (INTEGER ) : Integer containing field dimensions
|
|
! (5) dimNames (CHARACTER) : Array containing names of each dimension
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
CHARACTER(LEN=*), INTENT(IN) :: name
|
|
INTEGER, INTENT(OUT) :: rank
|
|
INTEGER, INTENT(OUT) :: dims(HE4_MAX_DIMS)
|
|
CHARACTER(LEN=HE4_MAX_CHAR), INTENT(OUT) :: dimNames(HE4_MAX_DIMS)
|
|
CHARACTER(LEN=HE4_MAX_CHAR), INTENT(OUT) :: typeName
|
|
|
|
! Local variables
|
|
INTEGER :: C, N, status, typeNum
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc, dimList
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwFldInfo
|
|
|
|
!------------------------------
|
|
! He4SwathFldInfo begins here!
|
|
!------------------------------
|
|
|
|
! Initialize
|
|
rank = 0
|
|
dims = 0
|
|
dimNames = ''
|
|
|
|
! Get number of data fields and related info
|
|
status = SwFldInfo( sId, name, rank, dims, typeNum, dimList )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error getting info about field ' // TRIM( name )
|
|
loc = 'He4SwathFldInfo ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Separate list of dimension names into an array
|
|
CALL makeCharArrayFromCharList( dimList, ',', dimNames )
|
|
|
|
! Get HDF-EOS4 data type name
|
|
typeName = He4DataTypeName( typeNum )
|
|
|
|
! Comment out for now (bmy, 8/20/07)
|
|
! ! NOTE: Sometimes every other element of DIMS is zero.
|
|
! ! I don't know why but we can just pack the array to be
|
|
! ! on the safe side. (bmy, 1/17/06)
|
|
! C = 0
|
|
! DO N = 1, HE4_MAX_DIMS
|
|
! IF ( dims(N) > 0 ) THEN
|
|
! C = C + 1
|
|
! dims(C) = dims(N)
|
|
! IF ( N > 1 ) dims(N) = 0
|
|
! ENDIF
|
|
! ENDDO
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( name ), rank, TRIM( typeName )
|
|
WRITE( 6, 110 ) dims(1:rank)
|
|
100 FORMAT( '===> ', a25 ' has ', i4 , ' dimensions and is ', a )
|
|
110 FORMAT( '===> ', 25x,' its dimensions are: ', 10i7 )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathFldInfo
|
|
|
|
!------------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathFillValue( sId, dataName, dataFill )
|
|
|
|
!======================================================================
|
|
! Subroutine He4SwathFillValue reads the missing data "fill" value
|
|
! for a field contained in the HDF-EOS4 swath data structure.
|
|
! (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) sId (INTEGER ) : HDF-EOS4 swath ID
|
|
! (2) dataName (CHARACTER) : Name of the field to get fill value for
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (3) dataFill (REAL*4 ) : Fill value for missing data
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
CHARACTER(LEN=HE4_MAX_CHAR), INTENT(IN) :: dataName
|
|
REAL*4, INTENT(OUT) :: dataFill
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwGetFill
|
|
|
|
!--------------------------------
|
|
! He4SwathFillValue begins here!
|
|
!--------------------------------
|
|
|
|
! Get the fill value
|
|
status = SwGetFill( sId, TRIM( dataName ), dataFill )
|
|
|
|
! Set fill value to zero if it does not exist
|
|
IF ( status == FAILURE ) dataFill = 0.0
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( dataName ), dataFill
|
|
100 FORMAT( '===> Fill value for ', a, ' is ', es13.6 )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathFillValue
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathAttrs( sId, nAttrs, attrName, attrValue )
|
|
|
|
!======================================================================
|
|
! Subroutine He4SwathAttrs returns the global attributes associated
|
|
! with the swath data structure. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) sId (INTEGER ) : HDF-EOS4 swath ID number
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (2) nAttrs (INTEGER ) : Number of swath attributes
|
|
! (3) attrName (CHARACTER) : Array of attribute names
|
|
! (4) attrValue (CHARACTER) : Array of attribute values
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER, INTENT(OUT) :: nAttrs
|
|
CHARACTER(LEN=HE4_MAX_CHAR), INTENT(OUT) :: attrName(HE4_MAX_ATRS)
|
|
REAL*4, INTENT(OUT) :: attrValue(HE4_MAX_ATRS)
|
|
|
|
! Local variables
|
|
INTEGER :: N, status, strBufSize
|
|
REAL*4 :: value
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: attrList
|
|
|
|
! HDF_EOS5 library routines
|
|
INTEGER :: SwInqAttrs
|
|
INTEGER :: SwRdAttr
|
|
|
|
!----------------------------
|
|
! He4SwathAttrs begins here!
|
|
!----------------------------
|
|
|
|
! Get list of attribute names
|
|
nAttrs = SwInqAttrs( sId, attrList, strBufSize )
|
|
|
|
! Separate list into array
|
|
CALL makeCharArrayFromCharList( attrList, ',', attrName )
|
|
|
|
! Get the data value for each attribute
|
|
! For each attribute
|
|
DO N = 1, nAttrs
|
|
status = SwRdAttr( sId, TRIM( attrName(N) ), attrValue )
|
|
ENDDO
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) nAttrs
|
|
|
|
DO N = 1, nAttrs
|
|
WRITE( 6, 110 ) TRIM( attrName(N) ), attrValue(N)
|
|
ENDDO
|
|
|
|
100 FORMAT( '===> There are ', i6, ' Swath Attributes' )
|
|
110 FORMAT( '===> ', a20, ' has value ', es13.6 )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathAttrs
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadAttrChar( sId, attrName, attrValue )
|
|
|
|
!======================================================================
|
|
! Subroutine He4SwathAttrChar returns a global attributes of type
|
|
! CHARACTER associated with the swath data structure. (bmy, 4/8/08)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) sId (INTEGER ) : HDF-EOS4 swath ID number
|
|
! (2) attrName (CHARACTER) : Name of attribute to read from file
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (3) attrValue (CHARACTER) : Value of attribute
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
CHARACTER(LEN=*), INTENT(IN) :: attrName
|
|
CHARACTER(LEN=*), INTENT(OUT) :: attrValue
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
|
|
! HDF4-EOS library routines
|
|
INTEGER :: SwRdAttr
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadAttrChar begins here!
|
|
!-----------------------------------
|
|
|
|
! Read attribute
|
|
status = SwRdAttr( sId, TRIM( attrName ), attrValue )
|
|
|
|
END SUBROUTINE He4SwathReadAttrChar
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadAttrI2( sId, attrName, attrValue )
|
|
|
|
!======================================================================
|
|
! Subroutine He4SwathAttrI2 returns a global attributes of type
|
|
! INTEGER*2 associated with the swath data structure. (bmy, 4/8/08)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) sId (INTEGER ) : HDF-EOS4 swath ID number
|
|
! (2) attrName (CHARACTER) : Name of attribute to read from file
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (3) attrValue (INTEGER*2) : Value of attribute
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
CHARACTER(LEN=*), INTENT(IN) :: attrName
|
|
INTEGER*2, INTENT(OUT) :: attrValue
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
|
|
! HDF4-EOS library routines
|
|
INTEGER :: SwRdAttr
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadAttrI2 begins here!
|
|
!-----------------------------------
|
|
|
|
! Read attribute
|
|
status = SwRdAttr( sId, TRIM( attrName ), attrValue )
|
|
|
|
END SUBROUTINE He4SwathReadAttrI2
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadAttrI4( sId, attrName, attrValue )
|
|
|
|
!======================================================================
|
|
! Subroutine He4SwathAttrI4 returns a global attributes of type
|
|
! INTEGER*4 associated with the swath data structure. (bmy, 4/8/08)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) sId (INTEGER ) : HDF-EOS4 swath ID number
|
|
! (2) attrName (CHARACTER) : Name of attribute to read from file
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (3) attrValue (INTEGER*2) : Value of attribute
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
CHARACTER(LEN=*), INTENT(IN) :: attrName
|
|
INTEGER, INTENT(OUT) :: attrValue
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
|
|
! HDF4-EOS library routines
|
|
INTEGER :: SwRdAttr
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadAttrI4 begins here!
|
|
!-----------------------------------
|
|
|
|
! Read attribute
|
|
status = SwRdAttr( sId, TRIM( attrName ), attrValue )
|
|
|
|
END SUBROUTINE He4SwathReadAttrI4
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadAttrR4( sId, attrName, attrValue )
|
|
|
|
!======================================================================
|
|
! Subroutine He4SwathAttrR4 returns a global attributes of type
|
|
! REAL*4 associated with the swath data structure. (bmy, 4/8/08)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) sId (INTEGER ) : HDF-EOS4 swath ID number
|
|
! (2) attrName (CHARACTER) : Name of attribute to read from file
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (3) attrValue (INTEGER*2) : Value of attribute
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
CHARACTER(LEN=*), INTENT(IN) :: attrName
|
|
REAL*4, INTENT(OUT) :: attrValue
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
|
|
! HDF4-EOS library routines
|
|
INTEGER :: SwRdAttr
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadAttrR4 begins here!
|
|
!-----------------------------------
|
|
|
|
! Read attribute
|
|
status = SwRdAttr( sId, TRIM( attrName ), attrValue )
|
|
|
|
END SUBROUTINE He4SwathReadAttrR4
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadAttrR8( sId, attrName, attrValue )
|
|
|
|
!======================================================================
|
|
! Subroutine He4SwathAttrR8 returns a global attributes of type
|
|
! REAL*8 associated with the swath data structure. (bmy, 4/8/08)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1) sId (INTEGER ) : HDF-EOS4 swath ID number
|
|
! (2) attrName (CHARACTER) : Name of attribute to read from file
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (3) attrValue (INTEGER*2) : Value of attribute
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
CHARACTER(LEN=*), INTENT(IN) :: attrName
|
|
REAL*8, INTENT(OUT) :: attrValue
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
|
|
! HDF4-EOS library routines
|
|
INTEGER :: SwRdAttr
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadAttrR8 begins here!
|
|
!-----------------------------------
|
|
|
|
! Read attribute
|
|
status = SwRdAttr( sId, TRIM( attrName ), attrValue )
|
|
|
|
END SUBROUTINE He4SwathReadAttrR8
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData1dI2( sId, fldName, nX, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData1dI2 reads a 1-D INTEGER*2 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 8/20/07)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (4 ) fldData (INTEGER*2 ) : 1-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
INTEGER*2, INTENT(OUT) :: fldData(nX)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(1), stride(1), edge(1)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData1dI2 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read data for a given track
|
|
start = (/ 0 /)
|
|
stride = (/ 1 /)
|
|
edge = (/ nX /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData1dI2 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData1dI2
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData1dI4( sId, fldName, nX, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData1dI4 reads a 1-D INTEGER*4 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 8/20/07)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (4 ) fldData (REAL*4 ) : 1-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
INTEGER, INTENT(OUT) :: fldData(nX)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(1), stride(1), edge(1)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData1dI4 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read data for a given track
|
|
start = (/ 0 /)
|
|
stride = (/ 1 /)
|
|
edge = (/ nX /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData1dI4 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData1dI4
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData1dR4( sId, fldName, nX, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData1dR4 reads a 1-D REAL*4 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (4 ) fldData (REAL*4 ) : 1-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
REAL*4, INTENT(OUT) :: fldData(nX)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(1), stride(1), edge(1)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData1dR4 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read data for a given track
|
|
start = (/ 0 /)
|
|
stride = (/ 1 /)
|
|
edge = (/ nX /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData1dR4 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData1dR4
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData1dR8( sId, fldName, nX, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData1dR8 reads a 1-D REAL*8 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (4 ) fldData (REAL*8 ) : 1-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
REAL*8, INTENT(INOUT) :: fldData(nX)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(1), stride(1), edge(1)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData1dR8 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up dimension info
|
|
start = (/ 0 /)
|
|
stride = (/ 1 /)
|
|
edge = (/ nX /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData1dR8 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData1dR8
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData2dI2( sId, fldName, nX, nY, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData2dI2 reads a 2-D INTEGER*2 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 8/20/07)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
! (4 ) nY (HE4-INTEGER) : 2nd dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (5 ) fldData (INTEGER*2 ) : 2-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX, nY
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
INTEGER*2, INTENT(OUT) :: fldData(nX,nY)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(2), stride(2), edge(2)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData2dI2 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read entire field
|
|
start = (/ 0, 0 /)
|
|
stride = (/ 1, 1 /)
|
|
edge = (/ nX, nY /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData2dI2 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData2dI2
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData2dI4( sId, fldName, nX, nY, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData2dI4 reads a 2-D INTEGER*4 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 8/20/07)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
! (4 ) nY (HE4-INTEGER) : 2nd dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (5 ) fldData (INTEGER ) : 2-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX, nY
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
INTEGER, INTENT(OUT) :: fldData(nX,nY)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(2), stride(2), edge(2)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData2dI4 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read entire field
|
|
start = (/ 0, 0 /)
|
|
stride = (/ 1, 1 /)
|
|
edge = (/ nX, nY /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData2dI4 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData2dI4
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData2dR4( sId, fldName, nX, nY, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData2dR4 reads a 2-D REAL*4 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
! (4 ) nY (HE4-INTEGER) : 2nd dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (5 ) fldData (REAL*4 ) : 2-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX, nY
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
REAL*4, INTENT(OUT) :: fldData(nX,nY)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(2), stride(2), edge(2)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData2dR4 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read entire field
|
|
start = (/ 0, 0 /)
|
|
stride = (/ 1, 1 /)
|
|
edge = (/ nX, nY /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData2dR4 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData2dR4
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData2dR8( sId, fldName, nX, nY, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData2dR8 reads a 2-D REAL*8 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
! (4 ) nY (HE4-INTEGER) : 2nd dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (5 ) fldData (REAL*8 ) : 2-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX, nY
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
REAL*8, INTENT(OUT) :: fldData(nX,nY)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(2), stride(2), count(2)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData2dR8 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read entire field
|
|
start = (/ 0, 0 /)
|
|
stride = (/ 1, 1 /)
|
|
count = (/ nX, nY /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, count, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData2dR8 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData2dR8
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData3dI2( sId, fldName, nX, nY, nZ, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData3dI2 reads a 3-D INTEGER*2 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 8/20/07)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
! (4 ) nY (HE4-INTEGER) : 2nd dimension of data array
|
|
! (5 ) nZ (HE4-INTEGER) : 3rd dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (6 ) fldData (INTEGER*2 ) : 2-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX, nY, nZ
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
INTEGER*2, INTENT(OUT) :: fldData(nX,nY,nZ)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(3), stride(3), edge(3)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData3I2 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read entire field
|
|
start = (/ 0, 0, 0 /)
|
|
stride = (/ 1, 1, 1 /)
|
|
edge = (/ nX, nY, nZ /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData3dI2 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData3dI2
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData3dI4( sId, fldName, nX, nY, nZ, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData3dI4 reads a 3-D INTEGER*4 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 8/20/07)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
! (4 ) nY (HE4-INTEGER) : 2nd dimension of data array
|
|
! (5 ) nZ (HE4-INTEGER) : 2nd dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (6 ) fldData (INTEGER ) : 2-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX, nY, nZ
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
INTEGER, INTENT(OUT) :: fldData(nX,nY,nZ)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(3), stride(3), edge(3)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData3dI4 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read entire field
|
|
start = (/ 0, 0, 0 /)
|
|
stride = (/ 1, 1, 1 /)
|
|
edge = (/ nX, nY, nZ /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData3dI4 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData3dI4
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData3dR4( sId, fldName, nX, nY, nZ, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData3dR4 reads a 3-D REAL*4 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
! (4 ) nY (HE4-INTEGER) : 2nd dimension of data array
|
|
! (5 ) nZ (HE4-INTEGER) : 2nd dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (6 ) fldData (REAL*4 ) : 2-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX, nY, nZ
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
REAL*4, INTENT(OUT) :: fldData(nX,nY,nZ)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(3), stride(3), edge(3)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData3dR4 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read entire field
|
|
start = (/ 0, 0, 0 /)
|
|
stride = (/ 1, 1, 1 /)
|
|
edge = (/ nX, nY, nZ /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData3dR4 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData3dR4
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData3dR8( sId, fldName, nX, nY, nZ, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData3dR8 reads a 3-D REAL*8 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
! (4 ) nY (HE4-INTEGER) : 2nd dimension of data array
|
|
! (5 ) nZ (HE4-INTEGER) : 3rd dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (6 ) fldData (REAL*8 ) : 3-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX, nY, nZ
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
REAL*8, INTENT(OUT) :: fldData(nX,nY,nZ)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(3), stride(3), edge(3)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData3dR8 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read entire field
|
|
start = (/ 0, 0, 0 /)
|
|
stride = (/ 1, 1, 1 /)
|
|
edge = (/ nX, nY, nZ /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData3dR8 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData3dR8
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData4dI2( sId, fldName, nX, nY, nZ, nW, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData4dI2 reads a 4-D INTEGER*2 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 9/20/07)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
! (4 ) nY (HE4-INTEGER) : 2nd dimension of data array
|
|
! (5 ) nZ (HE4-INTEGER) : 3rd dimension of data array
|
|
! (6 ) nW (HE4-INTEGER) : 4th dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (7 ) fldData (INTEGER*2 ) : 4-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX, nY, nZ, nW
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
INTEGER*2, INTENT(OUT) :: fldData(nX,nY,nZ,nW)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(4), stride(4), edge(4)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData4dI2 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read entire field
|
|
start = (/ 0, 0, 0, 0 /)
|
|
stride = (/ 1, 1, 1, 1 /)
|
|
edge = (/ nX, nY, nZ, nW /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData4dI2 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData4dI2
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData4dI4( sId, fldName, nX, nY, nZ, nW, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData4dI4 reads a 4-D INTEGER*4 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 9/20/07)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
! (4 ) nY (HE4-INTEGER) : 2nd dimension of data array
|
|
! (5 ) nZ (HE4-INTEGER) : 2nd dimension of data array
|
|
! (6 ) nW (HE4-INTEGER) : 4th dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (7 ) fldData (INTEGER ) : 4-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX, nY, nZ, nW
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
INTEGER, INTENT(OUT) :: fldData(nX,nY,nZ,nW)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(4), stride(4), edge(4)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData4dI4 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read entire field
|
|
start = (/ 0, 0, 0, 0 /)
|
|
stride = (/ 1, 1, 1, 0 /)
|
|
edge = (/ nX, nY, nZ, nW /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData4dI4 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData4dI4
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData4dR4( sId, fldName, nX, nY, nZ, nW, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData4dR4 reads a 4-D REAL*4 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 9/20/07)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
! (4 ) nY (HE4-INTEGER) : 2nd dimension of data array
|
|
! (5 ) nZ (HE4-INTEGER) : 3rd dimension of data array
|
|
! (6 ) nW (HE4-INTEGER) : 4th dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (7 ) fldData (REAL*4 ) : 4-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX, nY, nZ, nW
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
REAL*4, INTENT(OUT) :: fldData(nX,nY,nZ,nW)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(4), stride(4), edge(4)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData4dR4 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read entire field
|
|
start = (/ 0, 0, 0, 0 /)
|
|
stride = (/ 1, 1, 1, 1 /)
|
|
edge = (/ nX, nY, nZ, nW /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData4dR4 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData4dR4
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE He4SwathReadData4dR8( sId, fldName, nX, nY, nZ, nW, fldData )
|
|
|
|
!======================================================================
|
|
! Routine He4SwathReadData4dR8 reads a 4-D REAL*8 data block from
|
|
! an HDF-EOS4 swath data structure. This routine is included in the
|
|
! module interface He4SwathReadData. (bmy, 9/20/07)
|
|
!
|
|
! Arguments as Input:
|
|
! ---------------------------------------------------------------------
|
|
! (1 ) sId (INTEGER ) : HDF-EOS4 Swath ID #
|
|
! (2 ) fldName (CHARACTER ) : Name of data array
|
|
! (3 ) nX (HE4-INTEGER) : 1st dimension of data array
|
|
! (4 ) nY (HE4-INTEGER) : 2nd dimension of data array
|
|
! (5 ) nZ (HE4-INTEGER) : 3rd dimension of data array
|
|
! (6 ) nW (HE4-INTEGER) : 3rd dimension of data array
|
|
!
|
|
! Arguments as Output:
|
|
! ---------------------------------------------------------------------
|
|
! (7 ) fldData (REAL*8 ) : 3-D array w/ data from HDF-EOS4 file
|
|
!
|
|
! NOTES:
|
|
!======================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: sId
|
|
INTEGER(HE4_INT), INTENT(IN) :: nX, nY, nZ, nW
|
|
CHARACTER(LEN=*), INTENT(IN) :: fldName
|
|
REAL*8, INTENT(OUT) :: fldData(nX,nY,nZ)
|
|
|
|
! Local variables
|
|
INTEGER :: status
|
|
INTEGER(HE4_INT) :: start(4), stride(4), edge(4)
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: msg, loc
|
|
|
|
! HDF-EOS4 library routines
|
|
INTEGER :: SwRdFld
|
|
|
|
!-----------------------------------
|
|
! He4SwathReadData4dR8 begins here!
|
|
!-----------------------------------
|
|
|
|
! Set up to read entire field
|
|
start = (/ 0, 0, 0, 0 /)
|
|
stride = (/ 1, 1, 1, 1 /)
|
|
edge = (/ nX, nY, nZ, nW /)
|
|
|
|
! Read data
|
|
status = SwRdFld( sId, fldName, start, stride, edge, fldData )
|
|
|
|
! Error check
|
|
IF ( status == FAILURE ) THEN
|
|
msg = 'Error reading data for ' // TRIM( fldName )
|
|
loc = 'HdfSwathReadData4dR8 ("He4SwathModule.f90")'
|
|
CALL He4ErrMsg( msg, loc )
|
|
ENDIF
|
|
|
|
! Verbose output
|
|
IF ( VERBOSE ) THEN
|
|
WRITE( 6, 100 ) TRIM( fldName )
|
|
100 FORMAT( '===> Successfully read data for ', a )
|
|
ENDIF
|
|
|
|
END SUBROUTINE He4SwathReadData4dR8
|
|
|
|
!-----------------------------------------------------------------------------
|
|
|
|
SUBROUTINE makeCharArrayFromCharList( list, separator, array )
|
|
|
|
!=====================================================================
|
|
! Subroutine makeCharArrayFromCharList takes a comma-separated word
|
|
! list, and places each word into a separate element of a character
|
|
! array. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! --------------------------------------------------------------------
|
|
! (1) list (CHARACTER) : String with comma-separated words
|
|
! (2) separator (CHARACTER) : String for separator text
|
|
!
|
|
! Arguments as output:
|
|
! --------------------------------------------------------------------
|
|
! (3) array (CHARACTER) : Array of substrings
|
|
!
|
|
! NOTES:
|
|
!=====================================================================
|
|
|
|
! Arguments
|
|
CHARACTER(LEN=HE4_MAX_CHAR), INTENT(IN) :: list
|
|
CHARACTER(LEN=1 ), INTENT(IN) :: separator
|
|
CHARACTER(LEN=HE4_MAX_CHAR), INTENT(OUT) :: array(:)
|
|
|
|
! local variables
|
|
INTEGER :: P, N, ind(255)
|
|
CHARACTER(LEN=1) :: C
|
|
|
|
!----------------------------------------
|
|
! makeCharArrayFromCharList begins here!
|
|
!----------------------------------------
|
|
|
|
! Initialize
|
|
N = 1
|
|
ind(:) = 0
|
|
|
|
! Find the positions of all the commas in LIST
|
|
DO P = 1, LEN( list )
|
|
|
|
! Look at each character individually
|
|
C = list(P:P)
|
|
|
|
! If a comma...
|
|
IF ( C == separator ) THEN
|
|
|
|
! Increment comma
|
|
N = N + 1
|
|
ind(N) = P
|
|
ENDIF
|
|
ENDDO
|
|
|
|
! Add the position of the end of the string into IND
|
|
ind(N+1) = LEN( list )
|
|
|
|
! Save text between the commas into ARRAY
|
|
DO P = 1, N
|
|
IF ( P == N ) THEN
|
|
array(P) = list( ind(P)+1:ind(P+1) )
|
|
ELSE
|
|
array(P) = list( ind(P)+1:ind(P+1)-1 )
|
|
ENDIF
|
|
ENDDO
|
|
|
|
END SUBROUTINE makeCharArrayFromCharList
|
|
|
|
!------------------------------------------------------------------------------
|
|
|
|
FUNCTION He4DataTypeName( nType ) RESULT( typeStr )
|
|
|
|
!=====================================================================
|
|
! Subroutine He4DataTypeName returns a descriptive string given a
|
|
! HDF-EOS4 data type number. (bmy, 1/17/06)
|
|
!
|
|
! Arguments as Input:
|
|
! --------------------------------------------------------------------
|
|
! (1) nType (INTEGER) : HDF-EOS number type
|
|
!
|
|
! NOTES:
|
|
!=====================================================================
|
|
|
|
! Arguments
|
|
INTEGER, INTENT(IN) :: nType
|
|
|
|
! Local varaibles
|
|
LOGICAL, SAVE :: FIRST = .TRUE.
|
|
CHARACTER(LEN=HE4_MAX_CHAR) :: typeStr
|
|
|
|
!------------------------------
|
|
! He4DataTypeName begins here!
|
|
!------------------------------
|
|
|
|
! First-time initialization
|
|
IF ( FIRST ) THEN
|
|
dataTypeName(:) = ''
|
|
dataTypeName(DFNT_INT16 ) = 'INTEGER*2'
|
|
dataTypeName(DFNT_UINT16 ) = 'Unsigned INTEGER*2'
|
|
dataTypeName(DFNT_INT32 ) = 'INTEGER*4'
|
|
dataTypeName(DFNT_UINT32 ) = 'Unsigned INTEGER*4'
|
|
dataTypeName(DFNT_INT64 ) = 'INTEGER*8'
|
|
dataTypeName(DFNT_UINT64 ) = 'Unsigned INTEGER*8'
|
|
dataTypeName(DFNT_FLOAT32 ) = 'REAL*4'
|
|
dataTypeName(DFNT_FLOAT64 ) = 'REAL*8'
|
|
dataTypeName(DFNT_FLOAT128) = 'REAL*16'
|
|
!dataTypeName(56 ) = 'LOGICAL'
|
|
!dataTypeName(67 ) = 'LOGICAL'
|
|
dataTypeName(DFNT_CHAR ) = 'CHARACTER'
|
|
dataTypeName(DFNT_CHAR16 ) = 'CHARACTER'
|
|
dataTypeName(DFNT_UCHAR16 ) = 'CHARACTER'
|
|
ENDIF
|
|
|
|
! Return value
|
|
typeStr = dataTypeName(nType)
|
|
|
|
END FUNCTION He4DataTypeName
|
|
|
|
!------------------------------------------------------------------------------
|
|
|
|
END MODULE He4SwathModule
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|