PAFV_Define.f90

Go to the documentation of this file.

!
! PAFV_Define
!
! Module defining the PAFV object.
!
!
! CREATION HISTORY:
!       Written by:     Paul van Delst, 21-Mar-2012
!                       paul.vandelst@noaa.gov

MODULE pafv_define

  ! -----------------
  ! Environment setup
  ! -----------------
  ! Module use
  USE type_kinds           , ONLY: fp
  USE message_handler      , ONLY: success, failure, information, display_message
  USE compare_float_numbers, ONLY: OPERATOR(.equalto.)
  USE file_utility         , ONLY: file_open, file_exists
  USE binary_file_utility  , ONLY: open_binary_file      , &
                                   writegatts_binary_file, &
                                   readgatts_binary_file
  ! Disable implicit typing
  IMPLICIT NONE


  ! ------------
  ! Visibilities
  ! ------------
  ! Everything private by default
  PRIVATE
  ! Datatypes
  PUBLIC :: pafv_type
  ! Operators
  PUBLIC :: OPERATOR(==)
  ! Procedures
  PUBLIC :: pafv_associated
  PUBLIC :: pafv_destroy
  PUBLIC :: pafv_create
  PUBLIC :: pafv_inspect
  PUBLIC :: pafv_validrelease
  PUBLIC :: pafv_info
  PUBLIC :: pafv_defineversion
  PUBLIC :: pafv_inquirefile
  PUBLIC :: pafv_readfile
  PUBLIC :: pafv_writefile


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


  ! -----------------
  ! Module parameters
  ! -----------------
  CHARACTER(*), PARAMETER :: module_version_id = &
    '$Id: PAFV_Define.f90 60152 2015-08-13 19:19:13Z paul.vandelst@noaa.gov $'
  ! Release and version
  INTEGER, PARAMETER :: pafv_release = 2  ! This determines structure and file formats.
  INTEGER, PARAMETER :: pafv_version = 1  ! This is just the default data version.
  ! Close status for write errors
  CHARACTER(*), PARAMETER :: write_error_status = 'DELETE'
  ! Literal constants
  REAL(fp), PARAMETER :: zero = 0.0_fp
  REAL(fp), PARAMETER :: one  = 1.0_fp
  ! String lengths
  INTEGER,  PARAMETER :: ml = 256 ! Message length
  ! Compact-OPTRAN data indicator
  INTEGER, PARAMETER :: data_missing = 0
  INTEGER, PARAMETER :: data_present = 1
  ! Compact-OPTRAN max. order and number of predictors
  INTEGER, PUBLIC, PARAMETER :: max_optran_order = 10
  INTEGER, PUBLIC, PARAMETER :: max_optran_predictors = 14
  INTEGER, PUBLIC, PARAMETER :: max_optran_used_predictors = 6


  ! -------------------------
  ! PAFV data type definition
  ! -------------------------
  !:tdoc+:
  TYPE :: pafv_type
    ! Allocation indicator
    LOGICAL :: is_allocated = .false.
    ! Release and version information
    INTEGER :: release = pafv_release
    INTEGER :: version = pafv_version
    ! Dimensions variables
    INTEGER :: n_odps_layers = 0   ! K
    INTEGER :: n_absorbers   = 0   ! J
    INTEGER :: n_user_layers = 0   ! uK
    ! ODPS Forward variables
    ! ...Index array for ODPS to user profile interpolations
    INTEGER,  ALLOCATABLE :: odps2user_idx(:,:) ! 2 x 0:uK
    ! ...Index array for user to ODPS profile interpolations
    INTEGER,  ALLOCATABLE :: interp_index(:,:) ! 2 x K
    ! ...Accumulated weighting factors array for user to ODPS profile interpolations
    REAL(fp), ALLOCATABLE :: acc_weighting(:,:) ! uK x K
    ! ...Profile data
    REAL(fp), ALLOCATABLE :: temperature(:)   ! K
    REAL(fp), ALLOCATABLE :: absorber(:,:)    ! K x J
    INTEGER,  ALLOCATABLE :: idx_map(:)       ! K
    INTEGER  :: h2o_idx = 0
    ! Pressure profiles for interpolations
    REAL(fp), ALLOCATABLE :: ref_lnpressure(:)    ! K
    REAL(fp), ALLOCATABLE :: user_lnpressure(:)   ! uK
    ! Predictor Forward variables
    REAL(fp), ALLOCATABLE :: pdp(:)      ! K
    REAL(fp), ALLOCATABLE :: tz_ref(:)   ! K
    REAL(fp), ALLOCATABLE :: tz(:)       ! K
    REAL(fp), ALLOCATABLE :: tzp_ref(:)  ! K
    REAL(fp), ALLOCATABLE :: tzp(:)      ! K
    ! ...
    REAL(fp), ALLOCATABLE :: gaz_ref(:,:)    ! K x J
    REAL(fp), ALLOCATABLE :: gaz_sum(:,:)    ! K x J
    REAL(fp), ALLOCATABLE :: gaz(:,:)        ! K x J
    REAL(fp), ALLOCATABLE :: gazp_ref(:,:)   ! K x J
    REAL(fp), ALLOCATABLE :: gazp_sum(:,:)   ! K x J
    REAL(fp), ALLOCATABLE :: gazp(:,:)       ! K x J
    REAL(fp), ALLOCATABLE :: gatzp_ref(:,:)  ! K x J
    REAL(fp), ALLOCATABLE :: gatzp_sum(:,:)  ! K x J
    REAL(fp), ALLOCATABLE :: gatzp(:,:)      ! K x J
    ! ...
    REAL(fp), ALLOCATABLE :: dt(:)          ! K
    REAL(fp), ALLOCATABLE :: t(:)           ! K
    REAL(fp), ALLOCATABLE :: t2(:)          ! K
    REAL(fp), ALLOCATABLE :: dt2(:)         ! K
    REAL(fp), ALLOCATABLE :: h2o(:)         ! K
    REAL(fp), ALLOCATABLE :: h2o_a(:)       ! K
    REAL(fp), ALLOCATABLE :: h2o_r(:)       ! K
    REAL(fp), ALLOCATABLE :: h2o_s(:)       ! K
    REAL(fp), ALLOCATABLE :: h2o_r4(:)      ! K
    REAL(fp), ALLOCATABLE :: h2odh2otzp(:)  ! K
    REAL(fp), ALLOCATABLE :: co2(:)         ! K
    REAL(fp), ALLOCATABLE :: o3(:)          ! K
    REAL(fp), ALLOCATABLE :: o3_a(:)        ! K
    REAL(fp), ALLOCATABLE :: o3_r(:)        ! K
    REAL(fp), ALLOCATABLE :: co(:)          ! K
    REAL(fp), ALLOCATABLE :: co_a(:)        ! K
    REAL(fp), ALLOCATABLE :: co_r(:)        ! K
    REAL(fp), ALLOCATABLE :: co_s(:)        ! K
    REAL(fp), ALLOCATABLE :: co_acodcozp(:) ! K
    REAL(fp), ALLOCATABLE :: n2o(:)         ! K
    REAL(fp), ALLOCATABLE :: n2o_a(:)       ! K
    REAL(fp), ALLOCATABLE :: n2o_r(:)       ! K
    REAL(fp), ALLOCATABLE :: n2o_s(:)       ! K
    REAL(fp), ALLOCATABLE :: ch4(:)         ! K
    REAL(fp), ALLOCATABLE :: ch4_a(:)       ! K
    REAL(fp), ALLOCATABLE :: ch4_r(:)       ! K
    REAL(fp), ALLOCATABLE :: ch4_ach4zp(:)  ! K
    ! Optical depth Forward variables
    REAL(fp), ALLOCATABLE :: od(:)       ! K
    REAL(fp), ALLOCATABLE :: od_path(:)  ! K
    ! Zeeman specific Forward variables
    REAL(fp) :: w1, w2  ! weights for two-points linear interpolation
    INTEGER  :: inode   ! node position
    ! Compact-OPTRAN Forward variables
    LOGICAL :: optran = .false.
    ! ...Dimensions
    INTEGER :: n_oused_pred  = max_optran_used_predictors   ! oI; No. of OPTRAN used predictors
    ! ...Predictor variables
    REAL(fp), ALLOCATABLE :: dpong(:)       ! K
    REAL(fp), ALLOCATABLE :: d_absorber(:)  ! K
    REAL(fp), ALLOCATABLE :: int_vapor(:)   ! K
    REAL(fp), ALLOCATABLE :: avea(:)        ! K
    REAL(fp), ALLOCATABLE :: inverse(:)     ! K
    REAL(fp), ALLOCATABLE :: s_t(:)         ! K
    REAL(fp), ALLOCATABLE :: s_p(:)         ! K
    REAL(fp), ALLOCATABLE :: ap1(:)         ! K
    ! ...Optical depth variables
    REAL(fp), ALLOCATABLE :: b(:,:)     ! K x 0:oI
    REAL(fp), ALLOCATABLE :: ln_chi(:)  ! K
    REAL(fp), ALLOCATABLE :: chi(:)     ! K
  END TYPE pafv_type
  !:tdoc-:


CONTAINS


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

  ELEMENTAL FUNCTION pafv_associated( self ) RESULT( Status )
    TYPE(pafv_type), INTENT(IN) :: self
    LOGICAL :: status
    status = self%Is_Allocated
  END FUNCTION pafv_associated


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       PAFV_Destroy
!
! PURPOSE:
!       Elemental subroutine to re-initialize PAFV objects.
!
! CALLING SEQUENCE:
!       CALL PAFV_Destroy( PAFV )
!
! OBJECTS:
!       PAFV:
!         Re-initialized PAFV structure.
!         UNITS:      N/A
!         TYPE:       PAFV_type
!         DIMENSION:  Scalar or any rank
!         ATTRIBUTES: INTENT(OUT)
!
!:sdoc-:
!--------------------------------------------------------------------------------

  ELEMENTAL SUBROUTINE pafv_destroy( self )
    TYPE(pafv_type), INTENT(OUT) :: self
    self%Is_Allocated = .false.
  END SUBROUTINE pafv_destroy


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       PAFV_Create
!
! PURPOSE:
!       Elemental subroutine to create an instance of an PAFV object.
!
! CALLING SEQUENCE:
!       CALL PAFV_Create( &
!              PAFV         , &
!              n_ODPS_Layers, &
!              n_User_Layers, &
!              n_Absorbers  , &
!              No_OPTRAN = No_OPTRAN )
!
! OBJECTS:
!       PAFV:
!         PAFV object structure.
!         UNITS:      N/A
!         TYPE:       PAFV_type
!         DIMENSION:  Scalar or any rank
!         ATTRIBUTES: INTENT(OUT)
!
! INPUTS:
!       n_ODPS_Layers:
!         Number of internal ODPS layers that are defined
!         in the ODPS TauCoeff data file.
!         Must be > 0.
!         UNITS:      N/A
!         TYPE:       INTEGER
!         DIMENSION:  Conformable with the PAFV object
!         ATTRIBUTES: INTENT(IN)
!
!       n_User_Layers:
!         Number of atmospheric layers defined by user.
!         Must be > 0.
!         UNITS:      N/A
!         TYPE:       INTEGER
!         DIMENSION:  Conformable with the PAFV object
!         ATTRIBUTES: INTENT(IN)
!
!       n_Absorbers:
!         Number of gaseous absorbers.
!         Must be > 0.
!         UNITS:      N/A
!         TYPE:       INTEGER
!         DIMENSION:  Conformable with the PAFV object
!         ATTRIBUTES: INTENT(IN)
!
! OPTIONAL INPUTS:
!       No_OPTRAN:
!         Logical switch to disable allocation of Compact-OPTRAN
!         arrays for use with water vapour absorption.
!         If == .FALSE., arrays are allocated [DEFAULT]
!            == .TRUE.,  arrays are NOT allocated
!         If not specified, arrays are allocated.
!         UNITS:      N/A
!         TYPE:       LOGICAL
!         DIMENSION:  Conformable with the PAFV object
!         ATTRIBUTES: INTENT(IN), OPTIONAL
!
!:sdoc-:
!--------------------------------------------------------------------------------

  ELEMENTAL SUBROUTINE pafv_create( &
    self         , &  ! Output
    n_ODPS_Layers, &  ! Input
    n_User_Layers, &  ! Input
    n_Absorbers  , &  ! Input
    No_OPTRAN      )  ! Optional Input

    ! Arguments
    TYPE(pafv_type),   INTENT(OUT) :: self
    INTEGER,           INTENT(IN)  :: n_odps_layers
    INTEGER,           INTENT(IN)  :: n_user_layers
    INTEGER,           INTENT(IN)  :: n_absorbers
    LOGICAL, OPTIONAL, INTENT(IN)  :: no_optran
    ! Local variables
    LOGICAL :: use_optran
    INTEGER :: alloc_stat

    ! Check input
    IF ( n_odps_layers < 1 .OR. &
         n_absorbers   < 1 .OR. &
         n_user_layers < 1 ) RETURN
    ! ...Process options
    use_optran = .true.
    IF ( PRESENT(no_optran) ) use_optran = .NOT. no_optran

    ! Perform the ODPS allocations
    ! ...ODPS Forward variables
    ALLOCATE( self%ODPS2User_Idx(2, 0:n_user_layers), &
              self%interp_index(2, n_odps_layers),  &
              self%Acc_Weighting(n_user_layers,n_odps_layers), &
              self%Temperature(n_odps_layers), &
              self%Absorber(n_odps_layers, n_absorbers), &
              self%idx_map(n_absorbers), &
              stat = alloc_stat )
    IF ( alloc_stat /= 0 ) RETURN
    ! ...Pressure profiles for interpolations
    ALLOCATE( self%Ref_LnPressure(n_odps_layers), &
              self%User_LnPressure(n_user_layers), &
              stat = alloc_stat )
    IF ( alloc_stat /= 0 ) RETURN
    ! Predictor forward variables
    ! ...
    ALLOCATE( self%PDP(n_odps_layers), &
              self%Tz_ref(n_odps_layers), &
              self%Tz(n_odps_layers), &
              self%Tzp_ref(n_odps_layers), &
              self%Tzp(n_odps_layers), &
              self%GAz_ref(n_odps_layers, n_absorbers), &
              self%GAz_sum(n_odps_layers, n_absorbers), &
              self%GAz(n_odps_layers, n_absorbers), &
              self%GAzp_ref(n_odps_layers, n_absorbers), &
              self%GAzp_sum(n_odps_layers, n_absorbers), &
              self%GAzp(n_odps_layers, n_absorbers), &
              self%GATzp_ref(n_odps_layers, n_absorbers), &
              self%GATzp_sum(n_odps_layers, n_absorbers), &
              self%GATzp(n_odps_layers, n_absorbers), &
              stat = alloc_stat )
    IF ( alloc_stat /= 0 ) RETURN
    ! ...
    ALLOCATE( self%DT(n_odps_layers),           &
              self%T(n_odps_layers),            &
              self%T2(n_odps_layers),           &
              self%DT2(n_odps_layers),          &
              self%H2O(n_odps_layers),          &
              self%H2O_A(n_odps_layers),        &
              self%H2O_R(n_odps_layers),        &
              self%H2O_S(n_odps_layers),        &
              self%H2O_R4(n_odps_layers),       &
              self%H2OdH2OTzp(n_odps_layers),   &
              self%CO2(n_odps_layers),          &
              self%O3(n_odps_layers),           &
              self%O3_A(n_odps_layers),         &
              self%O3_R(n_odps_layers),         &
              self%CO(n_odps_layers),           &
              self%CO_A(n_odps_layers),         &
              self%CO_R(n_odps_layers),         &
              self%CO_S(n_odps_layers),         &
              self%CO_ACOdCOzp(n_odps_layers),  &
              self%N2O(n_odps_layers),          &
              self%N2O_A(n_odps_layers),        &
              self%N2O_R(n_odps_layers),        &
              self%N2O_S(n_odps_layers),        &
              self%CH4(n_odps_layers),          &
              self%CH4_A(n_odps_layers),        &
              self%CH4_R(n_odps_layers),        &
              self%CH4_ACH4zp(n_odps_layers),   &
              stat = alloc_stat )
    IF ( alloc_stat /= 0 ) RETURN
    ! ...Optical depth variables
    ALLOCATE( self%OD(n_odps_layers),           &
              self%OD_path(0:n_odps_layers),    &
              stat = alloc_stat )
    IF ( alloc_stat /= 0 ) RETURN

    ! Initialise dimensions (not arrays)
    self%n_ODPS_Layers = n_odps_layers
    self%n_Absorbers   = n_absorbers
    self%n_User_Layers = n_user_layers


    ! Allocate OPTRAN if required
    IF ( use_optran ) THEN
      ALLOCATE( self%dPonG(n_odps_layers), &
                self%d_Absorber(n_odps_layers), &
                self%Int_vapor(n_odps_layers), &
                self%AveA(n_odps_layers), &
                self%Inverse(n_odps_layers), &
                self%s_t(n_odps_layers), &
                self%s_p(n_odps_layers), &
                self%Ap1(n_odps_layers), &
                self%b(n_odps_layers, 0:max_optran_used_predictors), &
                self%LN_Chi(n_odps_layers), &
                self%Chi(n_odps_layers), &
                stat = alloc_stat )
      IF ( alloc_stat /= 0 ) RETURN
      ! ...Initialise dimensions
      self%n_OUsed_Pred  = max_optran_used_predictors
      ! ...Flag OPTRAN section as usuable
      self%OPTRAN = .true.
    END IF

    ! Set allocation indicator
    self%Is_Allocated = .true.

  END SUBROUTINE pafv_create


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       PAFV_Inspect
!
! PURPOSE:
!       Subroutine to print the contents of a PAFV object to stdout.
!
! CALLING SEQUENCE:
!       CALL PAFV_Inspect( PAFV )
!
! OBJECTS:
!       PAFV:
!         PAFV object to display.
!         UNITS:      N/A
!         TYPE:       PAFV_type
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(IN)
!
!:sdoc-:
!--------------------------------------------------------------------------------

  SUBROUTINE pafv_inspect(self)
    TYPE(pafv_type), INTENT(IN) :: self
    WRITE(*,'(1x,"PAFV OBJECT")')
    ! Release/version info
    WRITE(*,'(3x,"Release.Version     :",1x,i0,".",i0)') self%Release, self%Version
    ! Dimensions
    WRITE(*,'(3x,"n_ODPS_Layers :",1x,i0)') self%n_ODPS_Layers
    WRITE(*,'(3x,"n_User_Layers :",1x,i0)') self%n_User_Layers
    WRITE(*,'(3x,"n_Absorbers   :",1x,i0)') self%n_Absorbers
    IF ( .NOT. pafv_associated(self) ) RETURN
    ! ODPS data arrays
    WRITE(*,'(3x,"ODPS data arrays :")')
    ! ...ODPS Forward variables
    WRITE(*,'(5x,"ODPS2User_Idx :")'); WRITE(*,'(10(1x,i3,:))') self%ODPS2User_Idx
    WRITE(*,'(5x,"interp_index  :")'); WRITE(*,'(10(1x,i3,:))') self%interp_index
    WRITE(*,'(5x,"Acc_Weighting :")'); WRITE(*,'(5(1x,es13.6,:))') self%Acc_Weighting
    WRITE(*,'(5x,"Temperature   :")'); WRITE(*,'(5(1x,es13.6,:))') self%Temperature
    WRITE(*,'(5x,"Absorber      :")'); WRITE(*,'(5(1x,es13.6,:))') self%Absorber
    WRITE(*,'(5x,"idx_map       :")'); WRITE(*,'(10(1x,i3,:))') self%idx_map
    WRITE(*,'(5x,"H2O_idx       :",1x,i0)') self%H2O_idx
    ! ...Pressure profiles for interpolations
    WRITE(*,'(5x,"Ref_LnPressure  :")'); WRITE(*,'(5(1x,es13.6,:))') self%Ref_LnPressure
    WRITE(*,'(5x,"User_LnPressure :")'); WRITE(*,'(5(1x,es13.6,:))') self%User_LnPressure
    ! ...Predictor forward variables
    WRITE(*,'(5x,"PDP         :")'); WRITE(*,'(5(1x,es13.6,:))') self%PDP
    WRITE(*,'(5x,"Tz_ref      :")'); WRITE(*,'(5(1x,es13.6,:))') self%Tz_ref
    WRITE(*,'(5x,"Tz          :")'); WRITE(*,'(5(1x,es13.6,:))') self%Tz
    WRITE(*,'(5x,"Tzp_ref     :")'); WRITE(*,'(5(1x,es13.6,:))') self%Tzp_ref
    WRITE(*,'(5x,"Tzp         :")'); WRITE(*,'(5(1x,es13.6,:))') self%Tzp
    WRITE(*,'(5x,"GAz_ref     :")'); WRITE(*,'(5(1x,es13.6,:))') self%GAz_ref
    WRITE(*,'(5x,"GAz_sum     :")'); WRITE(*,'(5(1x,es13.6,:))') self%GAz_sum
    WRITE(*,'(5x,"GAz         :")'); WRITE(*,'(5(1x,es13.6,:))') self%GAz
    WRITE(*,'(5x,"GAzp_ref    :")'); WRITE(*,'(5(1x,es13.6,:))') self%GAzp_ref
    WRITE(*,'(5x,"GAzp_sum    :")'); WRITE(*,'(5(1x,es13.6,:))') self%GAzp_sum
    WRITE(*,'(5x,"GAzp        :")'); WRITE(*,'(5(1x,es13.6,:))') self%GAzp
    WRITE(*,'(5x,"GATzp_ref   :")'); WRITE(*,'(5(1x,es13.6,:))') self%GATzp_ref
    WRITE(*,'(5x,"GATzp_sum   :")'); WRITE(*,'(5(1x,es13.6,:))') self%GATzp_sum
    WRITE(*,'(5x,"GATzp       :")'); WRITE(*,'(5(1x,es13.6,:))') self%GATzp
    WRITE(*,'(5x,"DT          :")'); WRITE(*,'(5(1x,es13.6,:))') self%DT
    WRITE(*,'(5x,"T           :")'); WRITE(*,'(5(1x,es13.6,:))') self%T
    WRITE(*,'(5x,"T2          :")'); WRITE(*,'(5(1x,es13.6,:))') self%T2
    WRITE(*,'(5x,"DT2         :")'); WRITE(*,'(5(1x,es13.6,:))') self%DT2
    WRITE(*,'(5x,"H2O         :")'); WRITE(*,'(5(1x,es13.6,:))') self%H2O
    WRITE(*,'(5x,"H2O_A       :")'); WRITE(*,'(5(1x,es13.6,:))') self%H2O_A
    WRITE(*,'(5x,"H2O_R       :")'); WRITE(*,'(5(1x,es13.6,:))') self%H2O_R
    WRITE(*,'(5x,"H2O_S       :")'); WRITE(*,'(5(1x,es13.6,:))') self%H2O_S
    WRITE(*,'(5x,"H2O_R4      :")'); WRITE(*,'(5(1x,es13.6,:))') self%H2O_R4
    WRITE(*,'(5x,"H2OdH2OTzp  :")'); WRITE(*,'(5(1x,es13.6,:))') self%H2OdH2OTzp
    WRITE(*,'(5x,"CO2         :")'); WRITE(*,'(5(1x,es13.6,:))') self%CO2
    WRITE(*,'(5x,"O3          :")'); WRITE(*,'(5(1x,es13.6,:))') self%O3
    WRITE(*,'(5x,"O3_A        :")'); WRITE(*,'(5(1x,es13.6,:))') self%O3_A
    WRITE(*,'(5x,"O3_R        :")'); WRITE(*,'(5(1x,es13.6,:))') self%O3_R
    WRITE(*,'(5x,"CO          :")'); WRITE(*,'(5(1x,es13.6,:))') self%CO
    WRITE(*,'(5x,"CO_A        :")'); WRITE(*,'(5(1x,es13.6,:))') self%CO_A
    WRITE(*,'(5x,"CO_R        :")'); WRITE(*,'(5(1x,es13.6,:))') self%CO_R
    WRITE(*,'(5x,"CO_S        :")'); WRITE(*,'(5(1x,es13.6,:))') self%CO_S
    WRITE(*,'(5x,"CO_ACOdCOzp :")'); WRITE(*,'(5(1x,es13.6,:))') self%CO_ACOdCOzp
    WRITE(*,'(5x,"N2O         :")'); WRITE(*,'(5(1x,es13.6,:))') self%N2O
    WRITE(*,'(5x,"N2O_A       :")'); WRITE(*,'(5(1x,es13.6,:))') self%N2O_A
    WRITE(*,'(5x,"N2O_R       :")'); WRITE(*,'(5(1x,es13.6,:))') self%N2O_R
    WRITE(*,'(5x,"N2O_S       :")'); WRITE(*,'(5(1x,es13.6,:))') self%N2O_S
    WRITE(*,'(5x,"CH4         :")'); WRITE(*,'(5(1x,es13.6,:))') self%CH4
    WRITE(*,'(5x,"CH4_A       :")'); WRITE(*,'(5(1x,es13.6,:))') self%CH4_A
    WRITE(*,'(5x,"CH4_R       :")'); WRITE(*,'(5(1x,es13.6,:))') self%CH4_R
    WRITE(*,'(5x,"CH4_ACH4zp  :")'); WRITE(*,'(5(1x,es13.6,:))') self%CH4_ACH4zp
    ! Optical depth variables
    WRITE(*,'(3x,"ODPS optical depth arrays :")')
    WRITE(*,'(5x,"OD      :")'); WRITE(*,'(5(1x,es13.6,:))') self%OD
    WRITE(*,'(5x,"OD_path :")'); WRITE(*,'(5(1x,es13.6,:))') self%OD_path
    ! Zeeman specific Forward variables
    WRITE(*,'(3x,"Zeeman-specific data :")')
    WRITE(*,'(5x,"w1, w2 :")'); WRITE(*,'(2(1x,es13.6))') self%w1, self%w2
    WRITE(*,'(5x,"inode  :")'); WRITE(*,'(1x,i0)') self%inode
    ! Compact-OPTRAN Forward variables
    IF ( self%OPTRAN ) THEN
      WRITE(*,'(3x,"Compact-OPTRAN option :")')
      WRITE(*,'(3x,"n_OUsed_Pred :",1x,i0)') self%n_OUsed_Pred
      WRITE(*,'(5x,"dPonG      :")'); WRITE(*,'(5(1x,es13.6,:))') self%dPonG
      WRITE(*,'(5x,"d_Absorber :")'); WRITE(*,'(5(1x,es13.6,:))') self%d_Absorber
      WRITE(*,'(5x,"Int_vapor  :")'); WRITE(*,'(5(1x,es13.6,:))') self%Int_vapor
      WRITE(*,'(5x,"AveA       :")'); WRITE(*,'(5(1x,es13.6,:))') self%AveA
      WRITE(*,'(5x,"Inverse    :")'); WRITE(*,'(5(1x,es13.6,:))') self%Inverse
      WRITE(*,'(5x,"s_t        :")'); WRITE(*,'(5(1x,es13.6,:))') self%s_t
      WRITE(*,'(5x,"s_p        :")'); WRITE(*,'(5(1x,es13.6,:))') self%s_p
      WRITE(*,'(5x,"Ap1        :")'); WRITE(*,'(5(1x,es13.6,:))') self%Ap1
      WRITE(*,'(5x,"b          :")'); WRITE(*,'(5(1x,es13.6,:))') self%b
      WRITE(*,'(5x,"LN_Chi     :")'); WRITE(*,'(5(1x,es13.6,:))') self%LN_Chi
      WRITE(*,'(5x,"Chi        :")'); WRITE(*,'(5(1x,es13.6,:))') self%Chi
    END IF
  END SUBROUTINE pafv_inspect


!----------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       PAFV_ValidRelease
!
! PURPOSE:
!       Function to check the PAFV Release value.
!
! CALLING SEQUENCE:
!       IsValid = PAFV_ValidRelease( PAFV )
!
! INPUTS:
!       PAFV:
!         PAFV object for which the Release component
!         is to be checked.
!         UNITS:      N/A
!         TYPE:       PAFV_type
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(IN)
!
! FUNCTION RESULT:
!       IsValid:
!         Logical value defining the release validity.
!         UNITS:      N/A
!         TYPE:       LOGICAL
!         DIMENSION:  Scalar
!
!:sdoc-:
!----------------------------------------------------------------------------------

  FUNCTION pafv_validrelease( self ) RESULT( IsValid )
    ! Arguments
    TYPE(pafv_type), INTENT(IN) :: self
    ! Function result
    LOGICAL :: isvalid
    ! Local parameters
    CHARACTER(*), PARAMETER :: routine_name = 'PAFV_ValidRelease'
    ! Local variables
    CHARACTER(ML) :: msg

    ! Set up
    isvalid = .true.


    ! Check release is not too old
    IF ( self%Release < pafv_release ) THEN
      isvalid = .false.
      WRITE( msg,'("An PAFV data update is needed. ", &
                  &"PAFV release is ",i0,". Valid release is ",i0,"." )' ) &
                  self%Release, pafv_release
      CALL display_message( routine_name, msg, information ); RETURN
    END IF


    ! Check release is not too new
    IF ( self%Release > pafv_release ) THEN
      isvalid = .false.
      WRITE( msg,'("An PAFV software update is needed. ", &
                  &"PAFV release is ",i0,". Valid release is ",i0,"." )' ) &
                  self%Release, pafv_release
      CALL display_message( routine_name, msg, information ); RETURN
    END IF

  END FUNCTION pafv_validrelease


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       PAFV_Info
!
! PURPOSE:
!       Subroutine to return a string containing version and dimension
!       information about a PAFV object.
!
! CALLING SEQUENCE:
!       CALL PAFV_Info( PAFV, Info )
!
! OBJECTS:
!       PAFV:
!         PAFV object about which info is required.
!         UNITS:      N/A
!         TYPE:       PAFV_type
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(IN)
!
! OUTPUTS:
!       Info:
!         String containing version and dimension information
!         about the PAFV object.
!         UNITS:      N/A
!         TYPE:       CHARACTER(*)
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(OUT)
!
!:sdoc-:
!--------------------------------------------------------------------------------

  SUBROUTINE pafv_info( self, Info )
    ! Arguments
    TYPE(pafv_type), INTENT(IN)  :: self
    CHARACTER(*),          INTENT(OUT) :: info
    ! Parameters
    INTEGER, PARAMETER :: carriage_return = 13
    INTEGER, PARAMETER :: linefeed = 10
    ! Local variables
    CHARACTER(1000) :: s1, s2
    CHARACTER(2000) :: long_string

    ! Write the required data to the local string
    WRITE( s1, &
           '(a,1x,"PAFV RELEASE.VERSION: ",i2,".",i2.2,a,3x, &
           &"N_ODPS_LAYERS=",i0,2x,&
           &"N_ABSORBERS  =",i0,2x,&
           &"N_USER_LAYERS=",i0,2x)' ) &
           achar(carriage_return)//achar(linefeed), &
           self%Release, self%Version, &
           achar(carriage_return)//achar(linefeed), &
           self%n_ODPS_Layers, &
           self%n_Absorbers, &
           self%n_User_Layers
    ! Compact-OPTRAN Forward variables
    IF ( self%OPTRAN ) THEN
      WRITE( s2, &
           '(a,1x,"PAFV ODAS Option",a,3x, &
           &"N_OUSED_PRED=",i0,2x)' ) &
           achar(carriage_return)//achar(linefeed), &
           achar(carriage_return)//achar(linefeed), &
           self%n_OUsed_Pred
    END IF

    ! Trim the output based on the
    ! dummy argument string length
    long_string = trim(s1)//trim(s2)
    info = long_string(1:min(len(info), len_trim(long_string)))

  END SUBROUTINE pafv_info


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

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


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       PAFV_InquireFile
!
! PURPOSE:
!       Function to inquire PAFV object files.
!
! CALLING SEQUENCE:
!       Error_Status = PAFV_InquireFile( &
!                        Filename, &
!                        n_ODPS_Layers = n_ODPS_Layers, &
!                        n_Absorbers   = n_Absorbers  , &
!                        n_User_Layers = n_User_Layers, &
!                        Release       = Release      , &
!                        Version       = Version        )
!
! INPUTS:
!       Filename:
!         Character string specifying the name of the
!         data file to inquire.
!         UNITS:      N/A
!         TYPE:       CHARACTER(*)
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(IN)
!
! OPTIONAL OUTPUTS:
!       n_ODPS_Layers:
!         Number of internal ODPS layers that are defined
!         in the ODPS TauCoeff data file.
!         UNITS:      N/A
!         TYPE:       INTEGER
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       n_Absorbers:
!         Number of gaseous absorbers.
!         UNITS:      N/A
!         TYPE:       INTEGER
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       n_Layers:
!         Number of atmospheric layers defined by user.
!         UNITS:      N/A
!         TYPE:       INTEGER
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       Release:
!         The data/file release number. Used to check
!         for data/software mismatch.
!         UNITS:      N/A
!         TYPE:       INTEGER
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       Version:
!         The data/file version number. Used for
!         purposes only in identifying the dataset for
!         a particular release.
!         UNITS:      N/A
!         TYPE:       INTEGER
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(OUT), 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 inquire was successful
!            == FAILURE an unrecoverable error occurred.
!         UNITS:      N/A
!         TYPE:       INTEGER
!         DIMENSION:  Scalar
!
!:sdoc-:
!------------------------------------------------------------------------------

  FUNCTION pafv_inquirefile( &
    Filename     , &  ! Input
    n_ODPS_Layers, &  ! Optional output
    n_Absorbers  , &  ! Optional output
    n_User_Layers, &  ! Optional output
    Release      , &  ! Optional output
    Version      , &  ! Optional output
    Title        , &  ! Optional output
    History      , &  ! Optional output
    Comment      ) &  ! Optional output
  result( err_stat )
    ! Arguments
    CHARACTER(*),           INTENT(IN)  :: filename
    INTEGER     , OPTIONAL, INTENT(OUT) :: n_odps_layers
    INTEGER     , OPTIONAL, INTENT(OUT) :: n_absorbers
    INTEGER     , OPTIONAL, INTENT(OUT) :: n_user_layers
    INTEGER     , OPTIONAL, INTENT(OUT) :: release
    INTEGER     , OPTIONAL, INTENT(OUT) :: version
    CHARACTER(*), OPTIONAL, INTENT(OUT) :: title
    CHARACTER(*), OPTIONAL, INTENT(OUT) :: history
    CHARACTER(*), OPTIONAL, INTENT(OUT) :: comment
    ! Function result
    INTEGER :: err_stat
    ! Function parameters
    CHARACTER(*), PARAMETER :: routine_name = 'PAFV_InquireFile'
    ! Function variables
    CHARACTER(ML) :: msg
    CHARACTER(ML) :: io_msg
    INTEGER :: io_stat
    INTEGER :: fid
    INTEGER :: optran_present
    TYPE(pafv_type) :: pafv


    ! Setup
    err_stat = success
    ! ...Check that the file exists
    IF ( .NOT. file_exists( filename ) ) THEN
      msg = 'File '//trim(filename)//' not found.'
      CALL inquire_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 inquire_cleanup(); RETURN
    END IF


    ! Read the release and version
    READ( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%Release, &
      pafv%Version
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading Release/Version - '//trim(io_msg)
      CALL inquire_cleanup(); RETURN
    END IF
    IF ( .NOT. pafv_validrelease( pafv ) ) THEN
      msg = 'PAFV Release check failed.'
      CALL inquire_cleanup(); RETURN
    END IF


    ! Read the dimensions
    READ( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%n_ODPS_Layers, &
      pafv%n_Absorbers  , &
      pafv%n_User_Layers
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading dimension values from '//trim(filename)//' - '//trim(io_msg)
      CALL inquire_cleanup(); RETURN
    END IF


    ! Read Compact-OPTRAN data indicator
    READ( fid, iostat=io_stat, iomsg=io_msg ) optran_present
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading Compact-OPTRAN data indicator from '//trim(filename)//' - '//trim(io_msg)
      CALL inquire_cleanup(); RETURN
    END IF


    ! Read the global attributes
    err_stat = readgatts_binary_file( &
                 fid, &
                 title   = title  , &
                 history = history, &
                 comment = comment  )
    IF ( err_stat /= success ) THEN
      msg = 'Error reading global attributes'
      CALL inquire_cleanup(); RETURN
    END IF


    ! Close the file
    CLOSE( fid, iostat=io_stat, iomsg=io_msg )
    IF ( io_stat /= 0 ) THEN
      msg = 'Error closing '//trim(filename)//' - '//trim(io_msg)
      CALL inquire_cleanup(); RETURN
    END IF


    ! Assign the return arguments
    IF ( PRESENT(n_odps_layers) ) n_odps_layers = pafv%n_ODPS_Layers
    IF ( PRESENT(n_absorbers  ) ) n_absorbers   = pafv%n_Absorbers
    IF ( PRESENT(n_user_layers) ) n_user_layers = pafv%n_User_Layers
    IF ( PRESENT(release      ) ) release       = pafv%Release
    IF ( PRESENT(version      ) ) version       = pafv%Version

  CONTAINS

    SUBROUTINE inquire_cleanup()
      ! Close file if necessary
      IF ( file_open(fid) ) THEN
        CLOSE( fid, iostat=io_stat, iomsg=io_msg )
        IF ( io_stat /= 0 ) &
          msg = trim(msg)//'; Error closing input file during error cleanup - '//trim(io_msg)
      END IF
      ! Set error status and print error message
      err_stat = failure
      CALL display_message( routine_name, msg, err_stat )
    END SUBROUTINE inquire_cleanup

  END FUNCTION pafv_inquirefile


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       PAFV_ReadFile
!
! PURPOSE:
!       Function to read PAFV object files.
!
! CALLING SEQUENCE:
!       Error_Status = PAFV_ReadFile( &
!                        PAFV    , &
!                        Filename, &
!                        No_Close = No_Close, &
!                        Quiet    = Quiet     )
!
! OBJECTS:
!       PAFV:
!         PAFV object containing the data read from file.
!         UNITS:      N/A
!         TYPE:       PAFV_type
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(OUT)
!
! INPUTS:
!       Filename:
!         Character string specifying the name of a
!         PAFV data file to read.
!         UNITS:      N/A
!         TYPE:       CHARACTER(*)
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(IN)
!
! OPTIONAL INPUTS:
!       No_Close:
!         Set this logical argument to *NOT* close the datafile
!         upon exiting this routine. This option is required if
!         the PAFV data is embedded within another file.
!         If == .FALSE., File is closed upon function exit [DEFAULT].
!            == .TRUE.,  File is NOT closed upon function exit
!         If not specified, default is .FALSE.
!         UNITS:      N/A
!         TYPE:       LOGICAL
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       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
!
! 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 pafv_readfile( &
    PAFV, &  ! Output
    Filename  , &  ! Input
    No_Close  , &  ! Optional input
    Quiet     , &  ! Optional input
    Title     , &  ! Optional output
    History   , &  ! Optional output
    Comment   , &  ! Optional output
    Debug     ) &  ! Optional input (Debug output control)
  result( err_stat )
    ! Arguments
    TYPE(pafv_type),  INTENT(OUT) :: pafv
    CHARACTER(*),           INTENT(IN)  :: filename
    LOGICAL,      OPTIONAL, INTENT(IN)  :: no_close
    LOGICAL,      OPTIONAL, INTENT(IN)  :: quiet
    CHARACTER(*), OPTIONAL, INTENT(OUT) :: title
    CHARACTER(*), OPTIONAL, INTENT(OUT) :: history
    CHARACTER(*), OPTIONAL, INTENT(OUT) :: comment
    LOGICAL,      OPTIONAL, INTENT(IN)  :: debug
    ! Function result
    INTEGER :: err_stat
    ! Function parameters
    CHARACTER(*), PARAMETER :: routine_name = 'PAFV_ReadFile'
    ! Function variables
    CHARACTER(ML) :: msg
    CHARACTER(ML) :: io_msg
    LOGICAL :: close_file
    LOGICAL :: noisy
    INTEGER :: io_stat
    INTEGER :: fid
    INTEGER :: optran_present
    TYPE(pafv_type) :: dummy

    ! Setup
    err_stat = success
    ! ...Check No_Close argument
    close_file = .true.
    IF ( PRESENT(no_close) ) close_file = .NOT. no_close
    ! ...Check Quiet argument
    noisy = .true.
    IF ( PRESENT(quiet) ) noisy = .NOT. quiet
    ! ...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
      ! ...Inquire for the logical unit number
      INQUIRE( file=filename, number=fid )
      ! ...Ensure it's valid
      IF ( fid < 0 ) THEN
        msg = 'Error inquiring '//trim(filename)//' for its FileID'
        CALL read_cleanup(); RETURN
      END IF
    ELSE
      ! ...Open the file if it exists
      IF ( file_exists( filename ) ) THEN
        err_stat = open_binary_file( filename, fid )
        IF ( err_stat /= success ) THEN
          msg = 'Error opening '//trim(filename)
          CALL read_cleanup(); RETURN
        END IF
      ELSE
        msg = 'File '//trim(filename)//' not found.'
        CALL read_cleanup(); RETURN
      END IF
    END IF


    ! Read and check the release and version
    READ( fid, iostat=io_stat, iomsg=io_msg ) &
      dummy%Release, &
      dummy%Version
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading Release/Version - '//trim(io_msg)
      CALL read_cleanup(); RETURN
    END IF
    IF ( .NOT. pafv_validrelease( dummy ) ) THEN
      msg = 'PAFV Release check failed.'
      CALL read_cleanup(); RETURN
    END IF


    ! Read the dimensions
    READ( fid, iostat=io_stat, iomsg=io_msg ) &
      dummy%n_ODPS_Layers, &
      dummy%n_Absorbers  , &
      dummy%n_User_Layers
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading dimension values - '//trim(io_msg)
      CALL read_cleanup(); RETURN
    END IF


    ! Read Compact-OPTRAN data indicator
    READ( fid, iostat=io_stat, iomsg=io_msg ) optran_present
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading Compact-OPTRAN data indicator - '//trim(io_msg)
      CALL read_cleanup(); RETURN
    END IF


    ! Allocate the object
    CALL pafv_create( &
           pafv, &
           dummy%n_ODPS_Layers, &
           dummy%n_Absorbers  , &
           dummy%n_User_Layers , &
           no_optran = (optran_present == data_missing) )
    IF ( .NOT. pafv_associated( pafv ) ) THEN
      msg = 'PAFV object allocation failed.'
      CALL read_cleanup(); RETURN
    END IF
    ! ...Explicitly assign the version number
    pafv%Version = dummy%Version


    ! Read the global attributes
    err_stat = readgatts_binary_file( &
                 fid, &
                 title   = title  , &
                 history = history, &
                 comment = comment  )
    IF ( err_stat /= success ) THEN
      msg = 'Error reading global attributes'
      CALL read_cleanup(); RETURN
    END IF


    ! Read the ODPS forward variables
    READ( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%ODPS2User_Idx, &
      pafv%interp_index , &
      pafv%Acc_Weighting, &
      pafv%Temperature  , &
      pafv%Absorber     , &
      pafv%idx_map      , &
      pafv%H2O_idx
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading ODPS forward variables - '//trim(io_msg)
      CALL read_cleanup(); RETURN
    END IF


    ! Read the pressure profiles for interpolation
    READ( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%Ref_LnPressure, &
      pafv%User_LnPressure
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading pressure profiles - '//trim(io_msg)
      CALL read_cleanup(); RETURN
    END IF


    ! Read the predictor forward variables
    READ( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%PDP      , &
      pafv%Tz_ref   , &
      pafv%Tz       , &
      pafv%Tzp_ref  , &
      pafv%Tzp      , &
      pafv%GAz_ref  , &
      pafv%GAz_sum  , &
      pafv%GAz      , &
      pafv%GAzp_ref , &
      pafv%GAzp_sum , &
      pafv%GAzp     , &
      pafv%GATzp_ref, &
      pafv%GATzp_sum, &
      pafv%GATzp
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading predictor forward variables (set1) - '//trim(io_msg)
      CALL read_cleanup(); RETURN
    END IF
    READ( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%DT         , &
      pafv%T          , &
      pafv%T2         , &
      pafv%DT2        , &
      pafv%H2O        , &
      pafv%H2O_A      , &
      pafv%H2O_R      , &
      pafv%H2O_S      , &
      pafv%H2O_R4     , &
      pafv%H2OdH2OTzp , &
      pafv%CO2        , &
      pafv%O3         , &
      pafv%O3_A       , &
      pafv%O3_R       , &
      pafv%CO         , &
      pafv%CO_A       , &
      pafv%CO_R       , &
      pafv%CO_S       , &
      pafv%CO_ACOdCOzp, &
      pafv%N2O        , &
      pafv%N2O_A      , &
      pafv%N2O_R      , &
      pafv%N2O_S      , &
      pafv%CH4        , &
      pafv%CH4_A      , &
      pafv%CH4_R      , &
      pafv%CH4_ACH4zp
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading predictor forward variables (set2) - '//trim(io_msg)
      CALL read_cleanup(); RETURN
    END IF


    ! Read the optical depth variables
    READ( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%OD, &
      pafv%OD_path
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading optical depth variables - '//trim(io_msg)
      CALL read_cleanup(); RETURN
    END IF


    ! Read the Zeeman specific Forward variables
    READ( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%w1, &
      pafv%w2, &
      pafv%inode
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading Zeeman specific forward variables - '//trim(io_msg)
      CALL read_cleanup(); RETURN
    END IF


    ! Read the compact-OPTRAN Forward variables if necessary
    IF ( pafv%OPTRAN ) THEN
      READ( fid, iostat=io_stat, iomsg=io_msg ) &
        pafv%dPonG     , &
        pafv%d_Absorber, &
        pafv%Int_vapor , &
        pafv%AveA      , &
        pafv%Inverse   , &
        pafv%s_t       , &
        pafv%s_p       , &
        pafv%Ap1       , &
        pafv%b         , &
        pafv%LN_Chi    , &
        pafv%Chi
      IF ( io_stat /= 0 ) THEN
        msg = 'Error reading compact-OPTRAN variables - '//trim(io_msg)
        CALL read_cleanup(); RETURN
      END IF
    END IF


    ! Close the file
    IF ( close_file ) THEN
      CLOSE( fid, iostat=io_stat, iomsg=io_msg )
      IF ( io_stat /= 0 ) THEN
        msg = 'Error closing '//trim(filename)//' - '//trim(io_msg)
        CALL read_cleanup(); RETURN
      END IF
    END IF


    ! Output an info message
     IF ( noisy ) THEN
       CALL pafv_info( pafv, msg )
       CALL display_message( routine_name, 'FILE: '//trim(filename)//'; '//trim(msg), information )
     END IF

   CONTAINS

     SUBROUTINE read_cleanup()
       IF ( file_open(filename) ) THEN
         CLOSE( fid, iostat=io_stat, iomsg=io_msg )
         IF ( io_stat /= 0 ) &
           msg = trim(msg)//'; Error closing output file '//trim(filename)//&
                 ' during error cleanup - '//trim(io_msg)
       END IF
       CALL pafv_destroy( pafv )
       err_stat = failure
       CALL display_message( routine_name, msg, err_stat )
     END SUBROUTINE read_cleanup

  END FUNCTION pafv_readfile


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       PAFV_WriteFile
!
! PURPOSE:
!       Function to write PAFV object files.
!
! CALLING SEQUENCE:
!       Error_Status = PAFV_WriteFile( &
!                        PAFV    , &
!                        Filename, &
!                        No_Close = No_Close, &
!                        Quiet    = Quiet     )
!
! OBJECTS:
!       PAFV:
!         PAFV object containing the data to write to file.
!         UNITS:      N/A
!         TYPE:       PAFV_type
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(IN)
!
! INPUTS:
!       Filename:
!         Character string specifying the name of a
!         PAFV format data file to write.
!         UNITS:      N/A
!         TYPE:       CHARACTER(*)
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(IN)
!
! OPTIONAL INPUTS:
!       No_Close:
!         Set this logical argument to *NOT* close the datafile
!         upon exiting this routine. This option is required if
!         the PAFV data is embedded within another file.
!         If == .FALSE., File is closed upon function exit [DEFAULT].
!            == .TRUE.,  File is NOT closed upon function exit
!         If not specified, default is .FALSE.
!         UNITS:      N/A
!         TYPE:       LOGICAL
!         DIMENSION:  Scalar
!         ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       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
!
! 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
!
!:sdoc-:
!------------------------------------------------------------------------------

  FUNCTION pafv_writefile( &
    PAFV    , &  ! Input
    Filename, &  ! Input
    No_Close, &  ! Optional input
    Quiet   , &  ! Optional input
    Title   , &  ! Optional input
    History , &  ! Optional input
    Comment , &  ! Optional input
    Debug   ) &  ! Optional input (Debug output control)
  result( err_stat )
    ! Arguments
    TYPE(pafv_type),  INTENT(IN) :: pafv
    CHARACTER(*),           INTENT(IN) :: filename
    LOGICAL,      OPTIONAL, INTENT(IN) :: no_close
    LOGICAL,      OPTIONAL, INTENT(IN) :: quiet
    CHARACTER(*), OPTIONAL, INTENT(IN) :: title
    CHARACTER(*), OPTIONAL, INTENT(IN) :: history
    CHARACTER(*), OPTIONAL, INTENT(IN) :: comment
    LOGICAL,      OPTIONAL, INTENT(IN) :: debug
    ! Function result
    INTEGER :: err_stat
    ! Function parameters
    CHARACTER(*), PARAMETER :: routine_name = 'PAFV_WriteFile'
    ! Function variables
    CHARACTER(ML) :: msg
    CHARACTER(ML) :: io_msg
    LOGICAL :: close_file
    LOGICAL :: noisy
    INTEGER :: io_stat
    INTEGER :: fid
    INTEGER :: optran_present


    ! Setup
    err_stat = success
    ! ...Check No_Close argument
    close_file = .true.
    IF ( PRESENT(no_close) ) close_file = .NOT. no_close
    ! ...Check Quiet argument
    noisy = .true.
    IF ( PRESENT(quiet) ) noisy = .NOT. quiet
    ! ...Override Quiet settings if debug set.
    IF ( PRESENT(debug) ) THEN
      IF ( debug ) noisy = .true.
    END IF
    ! ...Check there is data to write
    IF ( .NOT. pafv_associated( pafv ) ) THEN
      msg = 'PAFV object is empty.'
      CALL write_cleanup(); RETURN
    END IF


    ! Check if the file is open.
    IF ( file_open( filename ) ) THEN
      ! ...Inquire for the logical unit number
      INQUIRE( file=filename, number=fid )
      ! ...Ensure it's valid
      IF ( fid < 0 ) THEN
        msg = 'Error inquiring '//trim(filename)//' for its FileID'
        CALL write_cleanup(); RETURN
      END IF
    ELSE
      ! ...Open the file for output
      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 release and version
    WRITE( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%Release, &
      pafv%Version
    IF ( io_stat /= 0 ) THEN
      msg = 'Error writing Release/Version - '//trim(io_msg)
      CALL write_cleanup(); RETURN
    END IF


    ! Write the dimensions
    WRITE( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%n_ODPS_Layers, &
      pafv%n_Absorbers  , &
      pafv%n_User_Layers
    IF ( io_stat /= 0 ) THEN
      msg = 'Error writing dimension values - '//trim(io_msg)
      CALL write_cleanup(); RETURN
    END IF


    ! Write Compact-OPTRAN data indicator
    IF ( pafv%OPTRAN) THEN
      optran_present = data_present
    ELSE
      optran_present = data_missing
    END IF
    WRITE( fid, iostat=io_stat, iomsg=io_msg ) optran_present
    IF ( io_stat /= 0 ) THEN
      msg = 'Error writing Compact-OPTRAN data indicator - '//trim(io_msg)
      CALL write_cleanup(); RETURN
    END IF


    ! Write the global attributes
    err_stat = writegatts_binary_file( &
                 fid, &
                 title   = title  , &
                 history = history, &
                 comment = comment  )
    IF ( err_stat /= success ) THEN
      msg = 'Error writing global attributes'
      CALL write_cleanup(); RETURN
    END IF


    ! Write the ODPS forward variables
    WRITE( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%ODPS2User_Idx, &
      pafv%interp_index , &
      pafv%Acc_Weighting, &
      pafv%Temperature  , &
      pafv%Absorber     , &
      pafv%idx_map      , &
      pafv%H2O_idx
    IF ( io_stat /= 0 ) THEN
      msg = 'Error writing ODPS forward variables - '//trim(io_msg)
      CALL write_cleanup(); RETURN
    END IF


    ! Write the pressure profiles for interpolation
    WRITE( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%Ref_LnPressure , &
      pafv%User_LnPressure
    IF ( io_stat /= 0 ) THEN
      msg = 'Error writing pressure profiles - '//trim(io_msg)
      CALL write_cleanup(); RETURN
    END IF


    ! Write the predictor forward variables
    WRITE( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%PDP      , &
      pafv%Tz_ref   , &
      pafv%Tz       , &
      pafv%Tzp_ref  , &
      pafv%Tzp      , &
      pafv%GAz_ref  , &
      pafv%GAz_sum  , &
      pafv%GAz      , &
      pafv%GAzp_ref , &
      pafv%GAzp_sum , &
      pafv%GAzp     , &
      pafv%GATzp_ref, &
      pafv%GATzp_sum, &
      pafv%GATzp
    IF ( io_stat /= 0 ) THEN
      msg = 'Error writing predictor forward variables (set1) - '//trim(io_msg)
      CALL write_cleanup(); RETURN
    END IF
    WRITE( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%DT         , &
      pafv%T          , &
      pafv%T2         , &
      pafv%DT2        , &
      pafv%H2O        , &
      pafv%H2O_A      , &
      pafv%H2O_R      , &
      pafv%H2O_S      , &
      pafv%H2O_R4     , &
      pafv%H2OdH2OTzp , &
      pafv%CO2        , &
      pafv%O3         , &
      pafv%O3_A       , &
      pafv%O3_R       , &
      pafv%CO         , &
      pafv%CO_A       , &
      pafv%CO_R       , &
      pafv%CO_S       , &
      pafv%CO_ACOdCOzp, &
      pafv%N2O        , &
      pafv%N2O_A      , &
      pafv%N2O_R      , &
      pafv%N2O_S      , &
      pafv%CH4        , &
      pafv%CH4_A      , &
      pafv%CH4_R      , &
      pafv%CH4_ACH4zp
    IF ( io_stat /= 0 ) THEN
      msg = 'Error writing predictor forward variables (set2) - '//trim(io_msg)
      CALL write_cleanup(); RETURN
    END IF


    ! Write the optical depth variables
    WRITE( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%OD, &
      pafv%OD_path
    IF ( io_stat /= 0 ) THEN
      msg = 'Error writing optical depth variables - '//trim(io_msg)
      CALL write_cleanup(); RETURN
    END IF


    ! Write the Zeeman specific Forward variables
    WRITE( fid, iostat=io_stat, iomsg=io_msg ) &
      pafv%w1, &
      pafv%w2, &
      pafv%inode
    IF ( io_stat /= 0 ) THEN
      msg = 'Error writing Zeeman specific forward variables - '//trim(io_msg)
      CALL write_cleanup(); RETURN
    END IF


    ! Write the compact-OPTRAN Forward variables if necessary
    IF ( pafv%OPTRAN ) THEN
      WRITE( fid, iostat=io_stat, iomsg=io_msg ) &
        pafv%dPonG     , &
        pafv%d_Absorber, &
        pafv%Int_vapor , &
        pafv%AveA      , &
        pafv%Inverse   , &
        pafv%s_t       , &
        pafv%s_p       , &
        pafv%Ap1       , &
        pafv%b         , &
        pafv%LN_Chi    , &
        pafv%Chi
      IF ( io_stat /= 0 ) THEN
        msg = 'Error writing compac-OPTRAN variables - '//trim(io_msg)
        CALL write_cleanup(); RETURN
      END IF
    END IF


    ! Close the file
    IF ( close_file ) THEN
      CLOSE( fid, iostat=io_stat, iomsg=io_msg )
      IF ( io_stat /= 0 ) THEN
        msg = 'Error closing '//trim(filename)//' - '//trim(io_msg)
        CALL write_cleanup(); RETURN
      END IF
    END IF


    ! Output an info message
     IF ( noisy ) THEN
       CALL pafv_info( pafv, msg )
       CALL display_message( routine_name, 'FILE: '//trim(filename)//'; '//trim(msg), information )
     END IF

   CONTAINS

     SUBROUTINE write_cleanup()
       IF ( file_open(filename) ) THEN
         CLOSE( fid, iostat=io_stat, iomsg=io_msg )
         IF ( io_stat /= 0 ) &
           msg = trim(msg)//'; Error closing output file '//trim(filename)//&
                 ' during error cleanup - '//trim(io_msg)
       END IF
       err_stat = failure
       CALL display_message( routine_name, msg, err_stat )
     END SUBROUTINE write_cleanup

  END FUNCTION pafv_writefile


!################################################################################
!################################################################################
!##                                                                            ##
!##                          ## PRIVATE PROCEDURES ##                          ##
!##                                                                            ##
!################################################################################
!################################################################################

!--------------------------------------------------------------------------------
!
! NAME:
!       PAFV_Equal
!
! PURPOSE:
!       Elemental function to test the equality of two PAFV objects.
!       Used in OPERATOR(==) interface block.
!
! CALLING SEQUENCE:
!       is_equal = PAFV_Equal( x, y )
!
!         or
!
!       IF ( x == y ) THEN
!         ...
!       END IF
!
! OBJECTS:
!       x, y:
!         Two PAFV objects to be compared.
!         UNITS:      N/A
!         TYPE:       PAFV_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 pafv_equal( x, y ) RESULT( is_equal )
    TYPE(pafv_type), INTENT(IN) :: x, y
    LOGICAL :: is_equal

    ! Set up
    is_equal = .false.

    ! Check the object association status
    IF ( (.NOT. pafv_associated(x)) .OR. &
         (.NOT. pafv_associated(y))      ) RETURN

   ! Check contents
    ! ...Release/version info
    IF ( (x%Release /= y%Release) .OR. &
         (x%Version /= y%Version) ) RETURN
    ! ...Dimensions
    IF ( (x%n_ODPS_Layers /= y%n_ODPS_Layers ) .OR. &
         (x%n_Absorbers   /= y%n_Absorbers   ) .OR. &
         (x%n_User_Layers /= y%n_User_Layers ) ) RETURN
    ! ...Compact-OPTRAN data indicator
    IF ( x%OPTRAN .NEQV. y%OPTRAN ) RETURN
    ! ...Arrays
    IF ( all(x%ODPS2User_Idx    ==     y%ODPS2User_Idx ) .AND. &
         all(x%interp_index     ==     y%interp_index  ) .AND. &
         all(x%Acc_Weighting .equalto. y%Acc_Weighting ) .AND. &
         all(x%Temperature   .equalto. y%Temperature   ) .AND. &
         all(x%Absorber      .equalto. y%Absorber      ) .AND. &
         all(x%idx_map          ==     y%idx_map       ) ) &
      is_equal = .true.
    IF ( all(x%Ref_LnPressure  .equalto. y%Ref_LnPressure  ) .AND. &
         all(x%User_LnPressure .equalto. y%User_LnPressure ) ) &
      is_equal = is_equal .EQV. .true.
    IF ( all(x%PDP        .equalto. y%PDP        ) .AND. &
         all(x%Tz_ref     .equalto. y%Tz_ref     ) .AND. &
         all(x%Tz         .equalto. y%Tz         ) .AND. &
         all(x%Tzp_ref    .equalto. y%Tzp_ref    ) .AND. &
         all(x%Tzp        .equalto. y%Tzp        ) .AND. &
         all(x%GAz_ref    .equalto. y%GAz_ref    ) .AND. &
         all(x%GAz_sum    .equalto. y%GAz_sum    ) .AND. &
         all(x%GAz        .equalto. y%GAz        ) .AND. &
         all(x%GAzp_ref   .equalto. y%GAzp_ref   ) .AND. &
         all(x%GAzp_sum   .equalto. y%GAzp_sum   ) .AND. &
         all(x%GAzp       .equalto. y%GAzp       ) .AND. &
         all(x%GATzp_ref  .equalto. y%GATzp_ref  ) .AND. &
         all(x%GATzp_sum  .equalto. y%GATzp_sum  ) .AND. &
         all(x%GATzp      .equalto. y%GATzp      ) ) &
      is_equal = is_equal .EQV. .true.
    IF ( all(x%DT          .equalto. y%DT          ) .AND. &
         all(x%T           .equalto. y%T           ) .AND. &
         all(x%T2          .equalto. y%T2          ) .AND. &
         all(x%DT2         .equalto. y%DT2         ) .AND. &
         all(x%H2O         .equalto. y%H2O         ) .AND. &
         all(x%H2O_A       .equalto. y%H2O_A       ) .AND. &
         all(x%H2O_R       .equalto. y%H2O_R       ) .AND. &
         all(x%H2O_S       .equalto. y%H2O_S       ) .AND. &
         all(x%H2O_R4      .equalto. y%H2O_R4      ) .AND. &
         all(x%H2OdH2OTzp  .equalto. y%H2OdH2OTzp  ) .AND. &
         all(x%CO2         .equalto. y%CO2         ) .AND. &
         all(x%O3          .equalto. y%O3          ) .AND. &
         all(x%O3_A        .equalto. y%O3_A        ) .AND. &
         all(x%O3_R        .equalto. y%O3_R        ) .AND. &
         all(x%CO          .equalto. y%CO          ) .AND. &
         all(x%CO_A        .equalto. y%CO_A        ) .AND. &
         all(x%CO_R        .equalto. y%CO_R        ) .AND. &
         all(x%CO_S        .equalto. y%CO_S        ) .AND. &
         all(x%CO_ACOdCOzp .equalto. y%CO_ACOdCOzp ) .AND. &
         all(x%N2O         .equalto. y%N2O         ) .AND. &
         all(x%N2O_A       .equalto. y%N2O_A       ) .AND. &
         all(x%N2O_R       .equalto. y%N2O_R       ) .AND. &
         all(x%N2O_S       .equalto. y%N2O_S       ) .AND. &
         all(x%CH4         .equalto. y%CH4         ) .AND. &
         all(x%CH4_A       .equalto. y%CH4_A       ) .AND. &
         all(x%CH4_R       .equalto. y%CH4_R       ) .AND. &
         all(x%CH4_ACH4zp  .equalto. y%CH4_ACH4zp  ) ) &
      is_equal = is_equal .EQV. .true.
    ! ...Optical depth variables
    IF ( all(x%OD      .equalto. y%OD      ) .AND. &
         all(x%OD_path .equalto. y%OD_path ) ) &
      is_equal = is_equal .EQV. .true.
    ! ...Zeeman variables
    IF ( (x%w1    .equalto. y%w1    ) .AND. &
         (x%w2    .equalto. y%w2    ) .AND. &
         (x%inode    ==     y%inode ) ) &
      is_equal = is_equal .EQV. .true.
    ! ...Compact-OPTRAN data
    IF ( x%OPTRAN .AND. y%OPTRAN ) THEN
      IF ( all(x%dPonG      .equalto. y%dPonG      ) .AND. &
           all(x%d_Absorber .equalto. y%d_Absorber ) .AND. &
           all(x%Int_vapor  .equalto. y%Int_vapor  ) .AND. &
           all(x%AveA       .equalto. y%AveA       ) .AND. &
           all(x%Inverse    .equalto. y%Inverse    ) .AND. &
           all(x%s_t        .equalto. y%s_t        ) .AND. &
           all(x%s_p        .equalto. y%s_p        ) .AND. &
           all(x%Ap1        .equalto. y%Ap1        ) .AND. &
           all(x%b          .equalto. y%b          ) .AND. &
           all(x%LN_Chi     .equalto. y%LN_Chi     ) .AND. &
           all(x%Chi        .equalto. y%Chi        ) ) &
        is_equal = is_equal .EQV. .true.
    END IF

  END FUNCTION pafv_equal

END MODULE pafv_define