CRTM_SensorData_Define.f90

Go to the documentation of this file.

!
! CRTM_SensorData_Define
!
! Module defining the CRTM SensorData structure and containing
! routines to manipulate it.
!
!
! CREATION HISTORY:
!       Written by:     Paul van Delst, 23-Jul-2004
!                       paul.vandelst@noaa.gov
!

MODULE crtm_sensordata_define

  ! -----------------
  ! Environment setup
  ! -----------------
  ! Intrinsic modules
  USE iso_fortran_env      , ONLY: output_unit
  ! Module use
  USE type_kinds           , ONLY: fp
  USE message_handler      , ONLY: success, failure, warning, information, display_message
  USE compare_float_numbers, ONLY: default_n_sigfig, &
                                   OPERATOR(.equalto.), &
                                   compares_within_tolerance
  USE file_utility         , ONLY: file_open, file_exists
  USE binary_file_utility  , ONLY: open_binary_file      , &
                                   writegatts_binary_file, &
                                   readgatts_binary_file
  USE crtm_parameters      , ONLY: strlen, &
                                   invalid_wmo_satellite_id, &
                                   invalid_wmo_sensor_id
  ! Disable implicit typing
  IMPLICIT NONE


  ! ------------
  ! Visibilities
  ! ------------
  ! Everything private by default
  PRIVATE
  ! Parameters
  PUBLIC :: invalid_wmo_satellite_id
  PUBLIC :: invalid_wmo_sensor_id
  ! Datatypes
  PUBLIC :: crtm_sensordata_type
  ! Operators
  PUBLIC :: OPERATOR(==)
  PUBLIC :: OPERATOR(+)
  PUBLIC :: OPERATOR(-)
  ! Procedures
  PUBLIC :: crtm_sensordata_associated
  PUBLIC :: crtm_sensordata_destroy
  PUBLIC :: crtm_sensordata_create
  PUBLIC :: crtm_sensordata_zero
  PUBLIC :: crtm_sensordata_isvalid
  PUBLIC :: crtm_sensordata_inspect
  PUBLIC :: crtm_sensordata_defineversion
  PUBLIC :: crtm_sensordata_compare
  PUBLIC :: crtm_sensordata_inquirefile
  PUBLIC :: crtm_sensordata_readfile
  PUBLIC :: crtm_sensordata_writefile


  ! ---------------------
  ! Procedure overloading
  ! ---------------------
  INTERFACE OPERATOR(==)
    MODULE PROCEDURE crtm_sensordata_equal
  END INTERFACE OPERATOR(==)

  INTERFACE OPERATOR(+)
    MODULE PROCEDURE crtm_sensordata_add
  END INTERFACE OPERATOR(+)

  INTERFACE OPERATOR(-)
    MODULE PROCEDURE crtm_sensordata_subtract
  END INTERFACE OPERATOR(-)


  ! -----------------
  ! Module parameters
  ! -----------------
  CHARACTER(*), PARAMETER :: module_version_id = &
  '$Id: CRTM_SensorData_Define.f90 60152 2015-08-13 19:19:13Z paul.vandelst@noaa.gov $'
  ! Literal constants
  REAL(fp), PARAMETER :: zero = 0.0_fp
  REAL(fp), PARAMETER :: one  = 1.0_fp
  ! Message string length
  INTEGER, PARAMETER :: ml = 256
  ! File status on close after write error
  CHARACTER(*), PARAMETER :: write_error_status = 'DELETE'


  ! -------------------------------
  ! SensorData structure definition
  ! -------------------------------
  !:tdoc+:
  TYPE :: crtm_sensordata_type
    ! Allocation indicator
    LOGICAL :: is_allocated = .false.
    ! Dimension values
    INTEGER :: n_channels = 0  ! L
    ! The data sensor IDs
    CHARACTER(STRLEN) :: sensor_id        = ' '
    INTEGER           :: wmo_satellite_id = invalid_wmo_satellite_id
    INTEGER           :: wmo_sensor_id    = invalid_wmo_sensor_id
    ! The sensor channels and brightness temperatures
    INTEGER , ALLOCATABLE :: sensor_channel(:)   ! L
    REAL(fp), ALLOCATABLE :: tb(:)               ! L
  END TYPE crtm_sensordata_type
  !:tdoc-:


CONTAINS


!################################################################################
!################################################################################
!##                                                                            ##
!##                         ## PUBLIC MODULE ROUTINES ##                       ##
!##                                                                            ##
!################################################################################
!################################################################################

!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_SensorData_Associated
!
! PURPOSE:
!       Elemental function to test the status of the allocatable components
!       of a CRTM SensorData object.
!
! CALLING SEQUENCE:
!       Status = CRTM_SensorData_Associated( SensorData )
!
! OBJECTS:
!       SensorData:  SensorData structure which is to have its member's
!                    status tested.
!                    UNITS:      N/A
!                    TYPE:       CRTM_SensorData_type
!                    DIMENSION:  Scalar or any rank
!                    ATTRIBUTES: INTENT(IN)
!
! FUNCTION RESULT:
!       Status:      The return value is a logical value indicating the
!                    status of the SensorData members.
!                      .TRUE.  - if the array components are allocated.
!                      .FALSE. - if the array components are not allocated.
!                    UNITS:      N/A
!                    TYPE:       LOGICAL
!                    DIMENSION:  Same as input SensorData argument
!
!:sdoc-:
!--------------------------------------------------------------------------------

  ELEMENTAL FUNCTION crtm_sensordata_associated( SensorData ) RESULT( Status )
    TYPE(crtm_sensordata_type), INTENT(IN) :: sensordata
    LOGICAL :: status
    status = sensordata%Is_Allocated
  END FUNCTION crtm_sensordata_associated


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_SensorData_Destroy
!
! PURPOSE:
!       Elemental subroutine to re-initialize CRTM SensorData objects.
!
! CALLING SEQUENCE:
!       CALL CRTM_SensorData_Destroy( SensorData )
!
! OBJECTS:
!       SensorData:   Re-initialized SensorData structure.
!                     UNITS:      N/A
!                     TYPE:       CRTM_SensorData_type
!                     DIMENSION:  Scalar OR any rank
!                     ATTRIBUTES: INTENT(OUT)
!
!:sdoc-:
!--------------------------------------------------------------------------------

  ELEMENTAL SUBROUTINE crtm_sensordata_destroy( SensorData )
    TYPE(crtm_sensordata_type), INTENT(OUT) :: sensordata
    sensordata%Is_Allocated = .false.
  END SUBROUTINE crtm_sensordata_destroy


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_SensorData_Create
!
! PURPOSE:
!       Elemental subroutine to create an instance of the CRTM SensorData object.
!
! CALLING SEQUENCE:
!       CALL CRTM_SensorData_Create( SensorData, n_Channels )
!
! OBJECTS:
!       SensorData:   SensorData structure.
!                     UNITS:      N/A
!                     TYPE:       CRTM_SensorData_type
!                     DIMENSION:  Scalar or any rank
!                     ATTRIBUTES: INTENT(OUT)
!
! INPUTS:
!       n_Channels:   Number of sensor channels.
!                     Must be > 0.
!                     UNITS:      N/A
!                     TYPE:       INTEGER
!                     DIMENSION:  Same as SensorData object
!                     ATTRIBUTES: INTENT(IN)
!
!:sdoc-:
!--------------------------------------------------------------------------------

  ELEMENTAL SUBROUTINE crtm_sensordata_create( SensorData, n_Channels )
    ! Arguments
    TYPE(crtm_sensordata_type), INTENT(OUT) :: sensordata
    INTEGER,                    INTENT(IN)  :: n_channels
    ! Local variables
    INTEGER :: alloc_stat

    ! Check input
    IF ( n_channels < 1 ) RETURN

    ! Perform the allocation
    ALLOCATE( sensordata%Sensor_Channel( n_channels ), &
              sensordata%Tb( n_channels ), &
              stat = alloc_stat )
    IF ( alloc_stat /= 0 ) RETURN

    ! Initialise
    ! ...Dimensions
    sensordata%n_Channels = n_channels
    ! ...Arrays
    sensordata%Sensor_Channel = 0
    sensordata%Tb             = zero

    ! Set allocation indicator
    sensordata%Is_Allocated = .true.

  END SUBROUTINE crtm_sensordata_create


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_SensorData_Zero
!
! PURPOSE:
!       Elemental subroutine to zero out the data arrays in a
!       CRTM SensorData object.
!
! CALLING SEQUENCE:
!       CALL CRTM_SensorData_Zero( SensorData )
!
! OBJECTS:
!       SensorData:    CRTM SensorData structure in which the data arrays are
!                      to be zeroed out.
!                      UNITS:      N/A
!                      TYPE:       CRTM_SensorData_type
!                      DIMENSION:  Scalar or any rank
!                      ATTRIBUTES: INTENT(IN OUT)
!
! COMMENTS:
!       - The dimension components of the structure are *NOT* set to zero.
!       - The SensorData sensor id and channel components are *NOT* reset.
!
!:sdoc-:
!--------------------------------------------------------------------------------

  ELEMENTAL SUBROUTINE crtm_sensordata_zero( SensorData )
    TYPE(crtm_sensordata_type), INTENT(IN OUT) :: sensordata
    ! Do nothing if structure is unused
    IF ( .NOT. crtm_sensordata_associated(sensordata) ) RETURN
    ! Only zero out the data arrays
    sensordata%Tb = zero
  END SUBROUTINE crtm_sensordata_zero


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_SensorData_IsValid
!
! PURPOSE:
!       Non-pure function to perform some simple validity checks on a
!       CRTM SensorData object.
!
!       If invalid data is found, a message is printed to stdout.
!
! CALLING SEQUENCE:
!       result = CRTM_SensorData_IsValid( SensorData )
!
!         or
!
!       IF ( CRTM_SensorData_IsValid( SensorData ) ) THEN....
!
! OBJECTS:
!       SensorData:    CRTM SensorData object which is to have its
!                      contents checked.
!                      UNITS:      N/A
!                      TYPE:       CRTM_SensorData_type
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN)
!
! FUNCTION RESULT:
!       result:        Logical variable indicating whether or not the input
!                      passed the check.
!                      If == .FALSE., SensorData object is unused or contains
!                                     invalid data.
!                         == .TRUE.,  SensorData object can be used in CRTM.
!                      UNITS:      N/A
!                      TYPE:       LOGICAL
!                      DIMENSION:  Scalar
!
!:sdoc-:
!--------------------------------------------------------------------------------

  FUNCTION crtm_sensordata_isvalid( SensorData ) RESULT( IsValid )
    TYPE(crtm_sensordata_type), INTENT(IN) :: sensordata
    LOGICAL :: isvalid
    CHARACTER(*), PARAMETER :: routine_name = 'CRTM_SensorData_IsValid'
    CHARACTER(ML) :: msg

    ! Setup
    isvalid = .false.
    ! ...Check if structure is used
    IF ( .NOT. crtm_sensordata_associated(sensordata) ) THEN
      msg = 'SensorData structure not allocated'
      CALL display_message( routine_name, msg, information )
      RETURN
    ENDIF
    IF ( sensordata%n_channels < 1 ) THEN
      msg = 'SensorData structure dimension invalid'
      CALL display_message( routine_name, msg, information )
      RETURN
    ENDIF

    ! Check data
    ! ...Change default so all entries can be checked
    isvalid = .true.
    ! ...Data sensor ids
    IF ( len_trim(sensordata%Sensor_Id) == 0 ) THEN
      msg = 'Invalid Sensor Id found'
      CALL display_message( routine_name, msg, information )
      isvalid = .false.
    ENDIF
    IF ( sensordata%WMO_Satellite_Id == invalid_wmo_satellite_id ) THEN
      msg = 'Invalid WMO Satellite Id found. Continuing...'
      CALL display_message( routine_name, msg, warning )
    ENDIF
    IF ( sensordata%WMO_Sensor_Id == invalid_wmo_sensor_id ) THEN
      msg = 'Invalid WMO Sensor Id Continuing...'
      CALL display_message( routine_name, msg, warning )
    ENDIF
    ! ...Listed sensor channels
    IF ( any(sensordata%Sensor_Channel < 1) ) THEN
      msg = 'Invalid Sensor Channel found'
      CALL display_message( routine_name, msg, information )
      isvalid = .false.
    ENDIF
    ! ...Data
    IF ( all(sensordata%Tb < zero ) ) THEN
      msg = 'All input SensorData brightness temperatures are negative'
      CALL display_message( routine_name, msg, information )
      isvalid = .false.
    ENDIF

  END FUNCTION crtm_sensordata_isvalid


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_SensorData_Inspect
!
! PURPOSE:
!       Subroutine to print the contents of a CRTM SensorData object to stdout.
!
! CALLING SEQUENCE:
!       CALL CRTM_SensorData_Inspect( SensorData, Unit=unit )
!
! INPUTS:
!       SensorData:  CRTM SensorData object to display.
!                    UNITS:      N/A
!                    TYPE:       CRTM_SensorData_type
!                    DIMENSION:  Scalar
!                    ATTRIBUTES: INTENT(IN)
!
! OPTIONAL INPUTS:
!       Unit:        Unit number for an already open file to which the output  
!                    will be written.                                          
!                    If the argument is specified and the file unit is not     
!                    connected, the output goes to stdout.                     
!                    UNITS:      N/A                                           
!                    TYPE:       INTEGER                                       
!                    DIMENSION:  Scalar                                        
!                    ATTRIBUTES: INTENT(IN), OPTIONAL                          
!
!:sdoc-:
!--------------------------------------------------------------------------------

  SUBROUTINE crtm_sensordata_inspect( SensorData, Unit )
    ! Arguments
    TYPE(crtm_sensordata_type), INTENT(IN) :: sensordata
    INTEGER,          OPTIONAL, INTENT(IN) :: unit
    ! Local variables
    INTEGER :: fid
    
    ! Setup
    fid = output_unit
    IF ( PRESENT(unit) ) THEN
      IF ( file_open(unit) ) fid = unit
    END IF

    
    WRITE(fid,'(1x,"SENSORDATA OBJECT")')
    ! Dimensions
    WRITE(fid,'(3x,"n_Channels:",1x,i0)') sensordata%n_Channels
    ! Scalar components
    WRITE(fid,'(3x,"Sensor Id       :",1x,a)') sensordata%Sensor_Id
    WRITE(fid,'(3x,"WMO Satellite Id:",1x,i0)') sensordata%WMO_Satellite_Id
    WRITE(fid,'(3x,"WMO Sensor Id   :",1x,i0)') sensordata%WMO_Sensor_Id
    IF ( .NOT. crtm_sensordata_associated(sensordata) ) RETURN
    ! Array components
    WRITE(fid,'(3x,"Sensor channels:")')
    WRITE(fid,'(10(1x,i5))') sensordata%Sensor_Channel
    WRITE(fid,'(3x,"Brightness temperatures:")')
    WRITE(fid,'(10(1x,es13.6))') sensordata%Tb
  END SUBROUTINE crtm_sensordata_inspect


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_SensorData_DefineVersion
!
! PURPOSE:
!       Subroutine to return the module version information.
!
! CALLING SEQUENCE:
!       CALL CRTM_SensorData_DefineVersion( Id )
!
! OUTPUT ARGUMENTS:
!       Id:            Character string containing the version Id information
!                      for the module.
!                      UNITS:      N/A
!                      TYPE:       CHARACTER(*)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(OUT)
!
!:sdoc-:
!--------------------------------------------------------------------------------

  SUBROUTINE crtm_sensordata_defineversion( Id )
    CHARACTER(*), INTENT(OUT) :: id
    id = module_version_id
  END SUBROUTINE crtm_sensordata_defineversion


!------------------------------------------------------------------------------
!:sdoc+:
! NAME:
!       CRTM_SensorData_Compare
!
! PURPOSE:
!       Elemental function to compare two CRTM_SensorData objects to within
!       a user specified number of significant figures.
!
! CALLING SEQUENCE:
!       is_comparable = CRTM_SensorData_Compare( x, y, n_SigFig=n_SigFig )
!
! OBJECTS:
!       x, y:          Two CRTM SensorData objects to be compared.
!                      UNITS:      N/A
!                      TYPE:       CRTM_SensorData_type
!                      DIMENSION:  Scalar or any rank
!                      ATTRIBUTES: INTENT(IN)
!
! OPTIONAL INPUTS:
!       n_SigFig:      Number of significant figure to compare floating point
!                      components.
!                      UNITS:      N/A
!                      TYPE:       INTEGER
!                      DIMENSION:  Scalar or same as input
!                      ATTRIBUTES: INTENT(IN), OPTIONAL
!
! FUNCTION RESULT:
!       is_equal:      Logical value indicating whether the inputs are equal.
!                      UNITS:      N/A
!                      TYPE:       LOGICAL
!                      DIMENSION:  Same as inputs.
!:sdoc-:
!------------------------------------------------------------------------------

  ELEMENTAL FUNCTION crtm_sensordata_compare( &
    x, &
    y, &
    n_SigFig ) &
  result( is_comparable )
    TYPE(crtm_sensordata_type), INTENT(IN) :: x, y
    INTEGER,          OPTIONAL, INTENT(IN) :: n_sigfig
    LOGICAL :: is_comparable
    ! Variables
    INTEGER :: l, n

    ! Set up
    is_comparable = .false.
    IF ( PRESENT(n_sigfig) ) THEN
      n = abs(n_sigfig)
    ELSE
      n = default_n_sigfig
    END IF

    ! Check the structure association status
    IF ( (.NOT. crtm_sensordata_associated(x)) .OR. &
         (.NOT. crtm_sensordata_associated(y)) ) RETURN

    ! Check scalars
    IF ( (x%n_Channels       /= y%n_Channels      ) .OR. &
         (x%Sensor_Id        /= y%Sensor_Id       ) .OR. &
         (x%WMO_Satellite_ID /= y%WMO_Satellite_ID) .OR. &
         (x%WMO_Sensor_ID    /= y%WMO_Sensor_ID   ) ) RETURN

    ! Check arrays
    l = x%n_Channels
    IF ( any(x%Sensor_Channel(1:l) /= y%Sensor_Channel(1:l)) .OR. &
         (.NOT. all(compares_within_tolerance(x%Tb(1:l),y%Tb(1:l),n))) ) RETURN

    ! If we get here, the structures are comparable
    is_comparable = .true.

  END FUNCTION crtm_sensordata_compare


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_SensorData_InquireFile
!
! PURPOSE:
!       Function to inquire CRTM SensorData object files.
!
! CALLING SEQUENCE:
!       Error_Status = CRTM_SensorData_InquireFile( Filename           , &
!                                                   n_DataSets = n_DataSets  )
!
! INPUTS:
!       Filename:       Character string specifying the name of a
!                       CRTM SensorData data file to read.
!                       UNITS:      N/A
!                       TYPE:       CHARACTER(*)
!                       DIMENSION:  Scalar
!                       ATTRIBUTES: INTENT(IN)
!
! OPTIONAL OUTPUTS:
!       n_DataSets:     The number of datasets in the file.
!                       UNITS:      N/A
!                       TYPE:       INTEGER
!                       DIMENSION:  Scalar
!                       ATTRIBUTES: OPTIONAL, INTENT(OUT)
!
! FUNCTION RESULT:
!       Error_Status:   The return value is an integer defining the error status.
!                       The error codes are defined in the Message_Handler module.
!                       If == SUCCESS, the file inquire was successful
!                          == FAILURE, an unrecoverable error occurred.
!                       UNITS:      N/A
!                       TYPE:       INTEGER
!                       DIMENSION:  Scalar
!
!:sdoc-:
!------------------------------------------------------------------------------

  FUNCTION crtm_sensordata_inquirefile( &
    Filename  , &  ! Input
    n_DataSets) &  ! Optional output
  result( err_stat )
    ! Arguments
    CHARACTER(*),      INTENT(IN)  :: filename
    INTEGER, OPTIONAL, INTENT(OUT) :: n_datasets
    ! Function result
    INTEGER :: err_stat
    ! Function parameters
    CHARACTER(*), PARAMETER :: routine_name = 'CRTM_SensorData_InquireFile'
    ! Function variables
    CHARACTER(ML) :: msg
    INTEGER :: io_stat
    INTEGER :: fid
    INTEGER :: n

    ! Setup
    err_stat = success
    ! Check that the file exists
    IF ( .NOT. file_exists( trim(filename) ) ) THEN
      msg = 'File '//trim(filename)//' not found.'
      CALL inquire_cleanup(); RETURN
    END IF

    ! Open the SensorData data file
    err_stat = open_binary_file( filename, fid )
    IF ( err_stat /= success ) THEN
      msg = 'Error opening '//trim(filename)
      CALL inquire_cleanup(); RETURN
    END IF

    ! Read the dimensions
    READ( fid,iostat=io_stat ) n
    IF ( io_stat /= 0 ) THEN
      WRITE( msg,'("Error reading dataset dimensions from ",a,". IOSTAT = ",i0)' ) &
             trim(filename), io_stat
      CALL inquire_cleanup(close_file=.true.); RETURN
    END IF

    ! Close the file
    CLOSE( fid, iostat=io_stat )
    IF ( io_stat /= 0 ) THEN
      WRITE( msg,'("Error closing ",a,". IOSTAT = ",i0)' ) trim(filename), io_stat
      CALL inquire_cleanup(); RETURN
    END IF

    ! Set the return arguments
    IF ( PRESENT(n_datasets) ) n_datasets = n

  CONTAINS

    SUBROUTINE inquire_cleanup( Close_File )
      LOGICAL, OPTIONAL, INTENT(IN) :: Close_File
      ! Close file if necessary
      IF ( PRESENT(close_file) ) THEN
        IF ( close_file ) THEN
          CLOSE( fid,iostat=io_stat )
          IF ( io_stat /= success ) &
            msg = trim(msg)//'; Error closing input file during error cleanup'
        END IF
      END IF
      ! Set error status and print error message
      err_stat = failure
      CALL display_message( routine_name, trim(msg), err_stat )
    END SUBROUTINE inquire_cleanup

  END FUNCTION crtm_sensordata_inquirefile


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_SensorData_ReadFile
!
! PURPOSE:
!       Function to read CRTM SensorData object files.
!
! CALLING SEQUENCE:
!       Error_Status = CRTM_SensorData_ReadFile( Filename               , &
!                                                SensorData             , &
!                                                Quiet      = Quiet     , &
!                                                No_Close   = No_Close  , &
!                                                n_DataSets = n_DataSets  )
!
! INPUTS:
!       Filename:       Character string specifying the name of a
!                       SensorData format data file to read.
!                       UNITS:      N/A
!                       TYPE:       CHARACTER(*)
!                       DIMENSION:  Scalar
!                       ATTRIBUTES: INTENT(IN)
!
! OUTPUTS:
!       SensorData:     CRTM SensorData object array containing the sensor data.
!                       UNITS:      N/A
!                       TYPE:       CRTM_SensorData_type
!                       DIMENSION:  Rank-1
!                       ATTRIBUTES: INTENT(OUT)
!
! OPTIONAL INPUTS:
!       Quiet:          Set this logical argument to suppress INFORMATION
!                       messages being printed to stdout
!                       If == .FALSE., INFORMATION messages are OUTPUT [DEFAULT].
!                          == .TRUE.,  INFORMATION messages are SUPPRESSED.
!                       If not specified, default is .FALSE.
!                       UNITS:      N/A
!                       TYPE:       LOGICAL
!                       DIMENSION:  Scalar
!                       ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       No_Close:       Set this logical argument to NOT close the file upon exit.
!                       If == .FALSE., the input file is closed upon exit [DEFAULT]
!                          == .TRUE.,  the input file is NOT closed upon exit.
!                       If not specified, default is .FALSE.
!                       UNITS:      N/A
!                       TYPE:       LOGICAL
!                       DIMENSION:  Scalar
!                       ATTRIBUTES: INTENT(IN), OPTIONAL
!
! OPTIONAL OUTPUTS:
!       n_DataSets:     The actual number of datasets read in.
!                       UNITS:      N/A
!                       TYPE:       INTEGER
!                       DIMENSION:  Scalar
!                       ATTRIBUTES: OPTIONAL, INTENT(OUT)
!
! FUNCTION RESULT:
!       Error_Status:   The return value is an integer defining the error status.
!                       The error codes are defined in the Message_Handler module.
!                       If == SUCCESS, the file read was successful
!                          == FAILURE, an unrecoverable error occurred.
!                       UNITS:      N/A
!                       TYPE:       INTEGER
!                       DIMENSION:  Scalar
!
!:sdoc-:
!------------------------------------------------------------------------------

  FUNCTION crtm_sensordata_readfile( &
    Filename  , &  ! Input
    SensorData, &  ! Output
    Quiet     , &  ! Optional input
    No_Close  , &  ! Optional input
    n_DataSets, &  ! Optional output
    Debug     ) &  ! Optional input (Debug output control)
  result( err_stat )
    ! Arguments
    CHARACTER(*),               INTENT(IN)  :: filename
    TYPE(crtm_sensordata_type), INTENT(OUT) :: sensordata(:)
    LOGICAL,          OPTIONAL, INTENT(IN)  :: quiet
    LOGICAL,          OPTIONAL, INTENT(IN)  :: no_close
    INTEGER,          OPTIONAL, INTENT(OUT) :: n_datasets
    LOGICAL,          OPTIONAL, INTENT(IN)  :: debug
    ! Function result
    INTEGER :: err_stat
    ! Function parameters
    CHARACTER(*), PARAMETER :: routine_name = 'CRTM_SensorData_ReadFile'
    ! Function variables
    CHARACTER(ML) :: msg
    LOGICAL :: noisy
    LOGICAL :: yes_close
    INTEGER :: io_stat
    INTEGER :: fid
    INTEGER :: i, n

    ! Setup
    err_stat = success
    ! ...Check Quiet argument
    noisy = .true.
    IF ( PRESENT(quiet) ) noisy = .NOT. quiet
    ! ...Check file close argument
    yes_close = .true.
    IF ( PRESENT(no_close) ) yes_close = .NOT. no_close
    ! ...Override Quiet settings if debug set.
    IF ( PRESENT(debug) ) THEN
      IF ( debug ) noisy = .true.
    END IF


    ! Check if the file is open
    IF ( file_open( filename ) ) THEN
      ! Yes, the file is already open
      ! ...Get the file id
      INQUIRE( file=filename,number=fid )
      IF ( fid == -1 ) THEN
        msg = 'Error inquiring '//trim(filename)//' for its fid'
        CALL read_cleanup(); RETURN
      END IF
    ELSE
      ! No, the file is not open
      ! ...Check that the file exists
      IF ( .NOT. file_exists( filename ) ) THEN
        msg = 'File '//trim(filename)//' not found.'
        CALL read_cleanup(); RETURN
      END IF
      ! ...Open the file
      err_stat = open_binary_file( filename, fid )
      IF ( err_stat /= success ) THEN
        msg = 'Error opening '//trim(filename)
        CALL read_cleanup(); RETURN
      END IF
    END IF


    ! Read the dimensions
    READ( fid,iostat=io_stat ) n
    IF ( io_stat /= 0 ) THEN
      WRITE( msg,'("Error reading dataset dimensions from ",a,". IOSTAT = ",i0)' ) &
             trim(filename), io_stat
      CALL read_cleanup(close_file=.true.); RETURN
    END IF
    ! ...Check if output array large enough
    IF ( n > SIZE(sensordata) ) THEN
      WRITE( msg,'("Number of SensorData sets, ",i0," > size of the output ",&
             &"SensorData object array, ",i0,".")' ) &
             n, SIZE(sensordata)
      CALL read_cleanup(close_file=.true.); RETURN
    END IF


    ! Read the SensorData data
    sensordata_loop: DO i = 1, n
      err_stat = read_record( fid, sensordata(i) )
      IF ( err_stat /= success ) THEN
        WRITE( msg,'("Error reading SensorData element #",i0," from ",a)' ) &
               i, trim(filename)
        CALL read_cleanup(close_file=.true.); RETURN
      END IF
    END DO sensordata_loop


    ! Close the file
    IF ( yes_close ) THEN
      CLOSE( fid,iostat=io_stat )
      IF ( io_stat /= 0 ) THEN
        WRITE( msg,'("Error closing ",a,". IOSTAT = ",i0)' ) trim(filename), io_stat
        CALL read_cleanup(); RETURN
      END IF
    END IF


    ! Set the optional return values
    IF ( PRESENT(n_datasets) ) n_datasets = n


    ! Output an info message
    IF ( noisy ) THEN
      WRITE( msg,'("Number of datasets read from ",a,": ",i0)' ) trim(filename), n
      CALL display_message( routine_name, trim(msg), information )
    END IF

  CONTAINS

    SUBROUTINE read_cleanup( Close_File )
      LOGICAL, OPTIONAL, INTENT(IN) :: Close_File
      ! Close file if necessary
      IF ( PRESENT(close_file) ) THEN
        IF ( close_file ) THEN
          CLOSE( fid,iostat=io_stat )
          IF ( io_stat /= 0 ) &
            msg = trim(msg)//'; Error closing input file during error cleanup.'
        END IF
      END IF
      ! Destroy the structure
      CALL crtm_sensordata_destroy( sensordata )
      ! Set error status and print error message
      err_stat = failure
      CALL display_message( routine_name, trim(msg), err_stat )
    END SUBROUTINE read_cleanup

  END FUNCTION crtm_sensordata_readfile


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_SensorData_WriteFile
!
! PURPOSE:
!       Function to write CRTM SensorData object files.
!
! CALLING SEQUENCE:
!       Error_Status = CRTM_SensorData_WriteFile( Filename           , &
!                                                 SensorData         , &
!                                                 Quiet    = Quiet   , &
!                                                 No_Close = No_Close  )
!
! INPUTS:
!       Filename:       Character string specifying the name of the
!                       SensorData format data file to write.
!                       UNITS:      N/A
!                       TYPE:       CHARACTER(*)
!                       DIMENSION:  Scalar
!                       ATTRIBUTES: INTENT(IN)
!
!       SensorData:     CRTM SensorData object array containing the datasets.
!                       UNITS:      N/A
!                       TYPE:       CRTM_SensorData_type
!                       DIMENSION:  Rank-1
!                       ATTRIBUTES: INTENT(IN)
!
! OPTIONAL INPUTS:
!       Quiet:          Set this logical argument to suppress INFORMATION
!                       messages being printed to stdout
!                       If == .FALSE., INFORMATION messages are OUTPUT [DEFAULT].
!                          == .TRUE.,  INFORMATION messages are SUPPRESSED.
!                       If not specified, default is .FALSE.
!                       UNITS:      N/A
!                       TYPE:       LOGICAL
!                       DIMENSION:  Scalar
!                       ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       No_Close:       Set this logical argument to NOT close the file upon exit.
!                       If == .FALSE., the input file is closed upon exit [DEFAULT]
!                          == .TRUE.,  the input file is NOT closed upon exit.
!                       If not specified, default is .FALSE.
!                       UNITS:      N/A
!                       TYPE:       LOGICAL
!                       DIMENSION:  Scalar
!                       ATTRIBUTES: INTENT(IN), OPTIONAL
!
! FUNCTION RESULT:
!       Error_Status:   The return value is an integer defining the error status.
!                       The error codes are defined in the Message_Handler module.
!                       If == SUCCESS, the file write was successful
!                          == FAILURE, an unrecoverable error occurred.
!                       UNITS:      N/A
!                       TYPE:       INTEGER
!                       DIMENSION:  Scalar
!
! SIDE EFFECTS:
!       - If the output file already exists, it is overwritten.
!       - If an error occurs during *writing*, the output file is deleted before
!         returning to the calling routine.
!
!:sdoc-:
!------------------------------------------------------------------------------

  FUNCTION crtm_sensordata_writefile( &
    Filename  , &  ! Input
    SensorData, &  ! Input
    Quiet     , &  ! Optional input
    No_Close  , &  ! Optional input
    Debug     ) &  ! Optional input (Debug output control)
  result( err_stat )
    ! Arguments
    CHARACTER(*),               INTENT(IN) :: filename
    TYPE(crtm_sensordata_type), INTENT(IN) :: sensordata(:)
    LOGICAL,          OPTIONAL, INTENT(IN) :: quiet
    LOGICAL,          OPTIONAL, INTENT(IN) :: no_close
    LOGICAL,          OPTIONAL, INTENT(IN) :: debug
    ! Function result
    INTEGER :: err_stat
    ! Function parameters
    CHARACTER(*), PARAMETER :: routine_name = 'CRTM_SensorData_WriteFile'
    CHARACTER(*), PARAMETER :: file_status_on_error = 'DELETE'
    ! Function variables
    CHARACTER(ML) :: msg
    LOGICAL :: noisy
    LOGICAL :: yes_close
    INTEGER :: io_stat
    INTEGER :: fid
    INTEGER :: i, n

    ! Setup
    err_stat = success
    ! ...Check Quiet argument
    noisy = .true.
    IF ( PRESENT(quiet) ) noisy = .NOT. quiet
    ! ...Check file close argument
    yes_close = .true.
    IF ( PRESENT(no_close) ) yes_close = .NOT. no_close
    ! ...Override Quiet settings if debug set.
    IF ( PRESENT(debug) ) THEN
      IF ( debug ) noisy = .true.
    END IF

    ! Check the SensorData structure dimensions
    IF ( any(sensordata%n_Channels < 1) ) THEN
      msg = 'Dimensions of SensorData structures are < or = 0.'
      CALL write_cleanup(); RETURN
    END IF


    ! Check if the file is open
    IF ( file_open( filename ) ) THEN
      ! Yes, the file is already open
      INQUIRE( file=filename,number=fid )
      IF ( fid == -1 ) THEN
        msg = 'Error inquiring '//trim(filename)//' for its fid'
        CALL write_cleanup(); RETURN
      END IF
    ELSE
      ! No, the file is not open
      err_stat = open_binary_file( filename, fid, for_output = .true. )
      IF ( err_stat /= success ) THEN
        msg = 'Error opening '//trim(filename)
        CALL write_cleanup(); RETURN
      END IF
    END IF


    ! Write the number of SensorDatas dimension
    n = SIZE(sensordata)
    WRITE( fid,iostat=io_stat) n
    IF ( io_stat /= 0 ) THEN
      WRITE( msg,'("Error writing dataset dimensions to ",a,". IOSTAT = ",i0)' ) &
             trim(filename), io_stat
      CALL write_cleanup(close_file=.true.); RETURN
    END IF


    ! Write the SensorData data
    sensordata_loop: DO i = 1, n
      err_stat = write_record( fid, sensordata(i) )
      IF ( err_stat /= success ) THEN
        WRITE( msg,'("Error writing SensorData element #",i0," to ",a)' ) &
               i, trim(filename)
        CALL write_cleanup(close_file=.true.); RETURN
      END IF
    END DO sensordata_loop


    ! Close the file (if error, no delete)
    IF ( yes_close ) THEN
      CLOSE( fid,status='KEEP',iostat=io_stat )
      IF ( io_stat /= 0 ) THEN
        WRITE( msg,'("Error closing ",a,". IOSTAT = ",i0)' ) trim(filename), io_stat
        CALL write_cleanup(); RETURN
      END IF
    END IF


    ! Output an info message
    IF ( noisy ) THEN
      WRITE( msg,'("Number of datasets written to ",a,": ",i0)' ) trim(filename), n
      CALL display_message( routine_name, trim(msg), information )
    END IF

  CONTAINS

    SUBROUTINE write_cleanup( Close_File )
      LOGICAL, OPTIONAL, INTENT(IN) :: Close_File
      ! Close file if necessary
      IF ( PRESENT(close_file) ) THEN
        IF ( close_file ) THEN
          CLOSE( fid,status=write_error_status,iostat=io_stat )
          IF ( io_stat /= 0 ) &
            msg = trim(msg)//'; Error deleting output file during error cleanup.'
        END IF
      END IF
      ! Set error status and print error message
      err_stat = failure
      CALL display_message( routine_name, trim(msg), err_stat )
    END SUBROUTINE write_cleanup

  END FUNCTION crtm_sensordata_writefile


!##################################################################################
!##################################################################################
!##                                                                              ##
!##                          ## PRIVATE MODULE ROUTINES ##                       ##
!##                                                                              ##
!##################################################################################
!##################################################################################

!------------------------------------------------------------------------------
!
! NAME:
!       CRTM_SensorData_Equal
!
! PURPOSE:
!       Elemental function to test the equality of two CRTM_SensorData objects.
!       Used in OPERATOR(==) interface block.
!
! CALLING SEQUENCE:
!       is_equal = CRTM_SensorData_Equal( x, y )
!
!         or
!
!       IF ( x == y ) THEN
!         ...
!       END IF
!
! OBJECTS:
!       x, y:          Two CRTM SensorData objects to be compared.
!                      UNITS:      N/A
!                      TYPE:       CRTM_SensorData_type
!                      DIMENSION:  Scalar or any rank
!                      ATTRIBUTES: INTENT(IN)
!
! FUNCTION RESULT:
!       is_equal:      Logical value indicating whether the inputs are equal.
!                      UNITS:      N/A
!                      TYPE:       LOGICAL
!                      DIMENSION:  Same as inputs.
!
!------------------------------------------------------------------------------

  ELEMENTAL FUNCTION crtm_sensordata_equal( x, y ) RESULT( is_equal )
    TYPE(crtm_sensordata_type) , INTENT(IN)  :: x, y
    LOGICAL :: is_equal
    ! Variables
    INTEGER :: n

    ! Set up
    is_equal = .false.

    ! Check the structure association status
    IF ( (.NOT. crtm_sensordata_associated(x)) .OR. &
         (.NOT. crtm_sensordata_associated(y))      ) RETURN

    ! Check contents
    ! ...Scalars
    IF ( (x%n_Channels       /= y%n_Channels      ) .OR. &
         (x%Sensor_Id        /= y%Sensor_Id       ) .OR. &
         (x%WMO_Satellite_ID /= y%WMO_Satellite_ID) .OR. &
         (x%WMO_Sensor_ID    /= y%WMO_Sensor_ID   ) ) RETURN
    ! ...Arrays
    n = x%n_Channels
    IF ( all(x%Sensor_Channel(1:n) == y%Sensor_Channel(1:n)  ) .AND. &
         all(x%Tb(1:n) .equalto. y%Tb(1:n)) ) &
      is_equal = .true.

  END FUNCTION crtm_sensordata_equal


!--------------------------------------------------------------------------------
!
! NAME:
!       CRTM_SensorData_Add
!
! PURPOSE:
!       Pure function to add two CRTM SensorData objects.
!       Used in OPERATOR(+) interface block.
!
! CALLING SEQUENCE:
!       sDatasum = CRTM_SensorData_Add( sData1, sData2 )
!
!         or
!
!       sDatasum = sData1 + sData2
!
!
! INPUTS:
!       sData1, sData2: The SensorData objects to add.
!                       UNITS:      N/A
!                       TYPE:       CRTM_SensorData_type
!                       DIMENSION:  Scalar or any rank
!                       ATTRIBUTES: INTENT(IN OUT)
!
! RESULT:
!       sDatasum:       SensorData structure containing the added components.
!                       UNITS:      N/A
!                       TYPE:       CRTM_SensorData_type
!                       DIMENSION:  Same as input
!
!--------------------------------------------------------------------------------

  ELEMENTAL FUNCTION crtm_sensordata_add( sData1, sData2 ) RESULT( sDatasum )
    TYPE(crtm_sensordata_type), INTENT(IN) :: sdata1, sdata2
    TYPE(crtm_sensordata_type) :: sdatasum
    ! Variables
    INTEGER :: n

    ! Check input
    ! ...If input structures not used, do nothing
    IF ( .NOT. crtm_sensordata_associated( sdata1 ) .OR. &
         .NOT. crtm_sensordata_associated( sdata2 )      ) RETURN
    ! ...If input structure for different sensors, or sizes, do nothing
    IF ( sdata1%n_Channels         /= sdata2%n_Channels        .OR. &
         sdata1%Sensor_Id          /= sdata2%Sensor_Id         .OR. &
         sdata1%WMO_Satellite_ID   /= sdata2%WMO_Satellite_ID  .OR. &
         sdata1%WMO_Sensor_ID      /= sdata2%WMO_Sensor_ID     .OR. &
         any(sdata1%Sensor_Channel /= sdata2%Sensor_Channel) ) RETURN

    ! Copy the first structure
    sdatasum = sdata1

    ! And add its components to the second one
    n = sdata1%n_Channels
    sdatasum%Tb(1:n) = sdatasum%Tb(1:n) + sdata2%Tb(1:n)

  END FUNCTION crtm_sensordata_add

!--------------------------------------------------------------------------------
!
! NAME:
!       CRTM_SensorData_Subtract
!
! PURPOSE:
!       Pure function to subtract two CRTM SensorData objects.
!       Used in OPERATOR(-) interface block.
!
! CALLING SEQUENCE:
!       sDatadiff = CRTM_SensorData_Subtract( sData1, sData2 )
!
!         or
!
!       sDatadiff = sData1 - sData2
!
!
! INPUTS:
!       sData1, sData2: The SensorData objects to difference.
!                       UNITS:      N/A
!                       TYPE:       CRTM_SensorData_type
!                       DIMENSION:  Scalar or any rank
!                       ATTRIBUTES: INTENT(IN OUT)
!
! RESULT:
!       sDatadiff:      SensorData structure containing the differenced components.
!                       UNITS:      N/A
!                       TYPE:       CRTM_SensorData_type
!                       DIMENSION:  Same as input
!
!--------------------------------------------------------------------------------

  ELEMENTAL FUNCTION crtm_sensordata_subtract( sData1, sData2 ) RESULT( sDatadiff )
    TYPE(crtm_sensordata_type), INTENT(IN) :: sdata1, sdata2
    TYPE(crtm_sensordata_type) :: sdatadiff
    ! Variables
    INTEGER :: n

    ! Check input
    ! ...If input structures not used, do nothing
    IF ( .NOT. crtm_sensordata_associated( sdata1 ) .OR. &
         .NOT. crtm_sensordata_associated( sdata2 )      ) RETURN
    ! ...If input structure for different sensors, or sizes, do nothing
    IF ( sdata1%n_Channels         /= sdata2%n_Channels        .OR. &
         sdata1%Sensor_Id          /= sdata2%Sensor_Id         .OR. &
         sdata1%WMO_Satellite_ID   /= sdata2%WMO_Satellite_ID  .OR. &
         sdata1%WMO_Sensor_ID      /= sdata2%WMO_Sensor_ID     .OR. &
         any(sdata1%Sensor_Channel /= sdata2%Sensor_Channel) ) RETURN

    ! Copy the first structure
    sdatadiff = sdata1

    ! And subtract the second one's components from it
    n = sdata1%n_Channels
    sdatadiff%Tb(1:n) = sdatadiff%Tb(1:n) - sdata2%Tb(1:n)

  END FUNCTION crtm_sensordata_subtract


!----------------------------------------------------------------------------------
!
! NAME:
!       Read_Record
!
! PURPOSE:
!       Utility function to read a single CRTM SensorData object
!
! CALLING SEQUENCE:
!       Error_Status = Read_Record( FileID, SensorData )
!
! INPUTS:
!       FileID:       Logical unit number from which to read data.
!                     UNITS:      N/A
!                     TYPE:       INTEGER
!                     DIMENSION:  Scalar
!                     ATTRIBUTES: INTENT(IN)
!
! OUTPUTS:
!       SensorData:   CRTM SensorData object containing the data read in.
!                     UNITS:      N/A
!                     TYPE:       CRTM_SensorData_type
!                     DIMENSION:  Scalar
!                     ATTRIBUTES: INTENT(OUT)
!
! FUNCTION RESULT:
!       Error_Status: The return value is an integer defining the error status.
!                     The error codes are defined in the Message_Handler module.
!                     If == SUCCESS, the record read was successful
!                        == FAILURE, an unrecoverable error occurred.
!                     UNITS:      N/A
!                     TYPE:       INTEGER
!                     DIMENSION:  Scalar
!
!----------------------------------------------------------------------------------

  FUNCTION read_record( &
    fid       , &  ! Input
    SensorData) &  ! Output
  result( err_stat )
    ! Arguments
    INTEGER                   , INTENT(IN)  :: fid
    TYPE(crtm_sensordata_type), INTENT(OUT) :: sensordata
    ! Function result
    INTEGER :: err_stat
    ! Function parameters
    CHARACTER(*), PARAMETER :: routine_name = 'CRTM_SensorData_ReadFile(Record)'
    ! Function variables
    CHARACTER(ML) :: msg
    INTEGER :: io_stat
    INTEGER :: n_channels

    ! Set up
    err_stat = success


    ! Read the dimensions
    READ( fid,iostat=io_stat ) n_channels
    IF ( io_stat /= 0 ) THEN
      WRITE( msg,'("Error reading data dimensions. IOSTAT = ",i0)' ) io_stat
      CALL read_record_cleanup(); RETURN
    END IF


    ! Allocate the structure
    CALL crtm_sensordata_create( sensordata, n_channels )
    IF ( .NOT. crtm_sensordata_associated( sensordata ) ) THEN
      msg = 'SensorData object allocation failed.'
      CALL read_record_cleanup(); RETURN
    END IF


    ! Read the SensorData data
    READ( fid,iostat=io_stat ) sensordata%Sensor_Id       , &
                               sensordata%WMO_Satellite_ID, &
                               sensordata%WMO_Sensor_ID   , &
                               sensordata%Sensor_Channel  , &
                               sensordata%Tb
    IF ( io_stat /= 0 ) THEN
      WRITE( msg,'("Error reading SensorData data. IOSTAT = ",i0)' ) io_stat
      CALL read_record_cleanup(); RETURN
    END IF

  CONTAINS

    SUBROUTINE read_record_cleanup()
      ! Deallocate SensorData structure if necessary
      CALL crtm_sensordata_destroy( sensordata )
      ! Close input file
      CLOSE( fid,iostat=io_stat )
      IF ( io_stat /= success ) &
        msg = trim(msg)//'; Error closing file during error cleanup'
      ! Report error(s)
      err_stat = failure
      CALL display_message( routine_name, trim(msg), err_stat )
    END SUBROUTINE read_record_cleanup

  END FUNCTION read_record


!----------------------------------------------------------------------------------
!
! NAME:
!       Write_Record
!
! PURPOSE:
!       Function to write a single CRTM SensorData object
!
! CALLING SEQUENCE:
!       Error_Status = Write_Record( FileID, SensorData )
!
! INPUT ARGUMENTS:
!       FileID:       Logical unit number to which data is written
!                     UNITS:      N/A
!                     TYPE:       INTEGER
!                     DIMENSION:  Scalar
!                     ATTRIBUTES: INTENT(IN)
!
!       SensorData:   CRTM SensorData object containing the data to write.
!                     UNITS:      N/A
!                     TYPE:       CRTM_SensorData_type
!                     DIMENSION:  Scalar
!                     ATTRIBUTES: INTENT(IN)
!
! FUNCTION RESULT:
!       Error_Status: The return value is an integer defining the error status.
!                     The error codes are defined in the Message_Handler module.
!                     If == SUCCESS, the write was successful
!                        == FAILURE, an unrecoverable error occurred.
!                     UNITS:      N/A
!                     TYPE:       INTEGER
!                     DIMENSION:  Scalar
!
!----------------------------------------------------------------------------------

  FUNCTION write_record( &
    fid       , &  ! Input
    SensorData) &  ! Input
  result( err_stat )
    ! Arguments
    INTEGER                   , INTENT(IN) :: fid
    TYPE(crtm_sensordata_type), INTENT(IN) :: sensordata
    ! Function result
    INTEGER :: err_stat
    ! Function parameters
    CHARACTER(*), PARAMETER :: routine_name = 'CRTM_SensorData_WriteFile(Record)'
    ! Function variables
    CHARACTER(ML) :: msg
    INTEGER :: io_stat

    ! Setup
    err_stat = success
    IF ( .NOT. crtm_sensordata_associated( sensordata ) ) THEN
      msg = 'Input SensorData object is not used.'
      CALL write_record_cleanup(); RETURN
    END IF


    ! Write the dimensions
    WRITE( fid,iostat=io_stat ) sensordata%n_Channels
    IF ( io_stat /= 0 ) THEN
      WRITE( msg,'("Error writing dimensions. IOSTAT = ",i0)' ) io_stat
      CALL write_record_cleanup(); RETURN
    END IF


    ! Write the data
    WRITE( fid,iostat=io_stat ) sensordata%Sensor_Id       , &
                                sensordata%WMO_Satellite_ID, &
                                sensordata%WMO_Sensor_ID   , &
                                sensordata%Sensor_Channel  , &
                                sensordata%Tb
    IF ( io_stat /= 0 ) THEN
      WRITE( msg,'("Error writing SensorData data. IOSTAT = ",i0)' ) io_stat
      CALL write_record_cleanup(); RETURN
    END IF

  CONTAINS

    SUBROUTINE write_record_cleanup()
      ! Close and delete output file
      CLOSE( fid,status=write_error_status,iostat=io_stat )
      IF ( io_stat /= success ) &
        msg = trim(msg)//'; Error closing file during error cleanup'
      ! Report error(s)
      err_stat = failure
      CALL display_message( routine_name, trim(msg), err_stat )
    END SUBROUTINE write_record_cleanup

  END FUNCTION write_record

END MODULE crtm_sensordata_define