CRTM_Aerosol_Define.f90

Go to the documentation of this file.

!
! CRTM_Aerosol_Define
!
! Module defining the CRTM Aerosol structure and containing
! routines to manipulate it.
!
!
! CREATION HISTORY:
!       Written by:     Yong Han,       yong.han@noaa.gov
!                       Quanhua Liu,    quanhua.liu@noaa.gov
!                       Paul van Delst, paul.vandelst@noaa.gov
!                       22-Feb-2005
!

MODULE crtm_aerosol_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
  ! Disable implicit typing
  IMPLICIT NONE


  ! ------------
  ! Visibilities
  ! ------------
  ! Everything private by default
  PRIVATE
  ! Aerosol parameters
  PUBLIC :: n_valid_aerosol_categories
  PUBLIC :: invalid_aerosol
  PUBLIC :: dust_aerosol
  PUBLIC :: seasalt_ssam_aerosol
  PUBLIC :: seasalt_sscm1_aerosol
  PUBLIC :: seasalt_sscm2_aerosol
  PUBLIC :: seasalt_sscm3_aerosol
  PUBLIC :: organic_carbon_aerosol
  PUBLIC :: black_carbon_aerosol
  PUBLIC :: sulfate_aerosol
  PUBLIC :: aerosol_category_name
  ! Datatypes
  PUBLIC :: crtm_aerosol_type
  ! Operators
  PUBLIC :: OPERATOR(==)
  PUBLIC :: OPERATOR(+)
  PUBLIC :: OPERATOR(-)
  ! Procedures
  PUBLIC :: crtm_aerosol_categoryname
  PUBLIC :: crtm_aerosol_categoryid
  PUBLIC :: crtm_aerosol_categorylist
  PUBLIC :: crtm_aerosol_associated
  PUBLIC :: crtm_aerosol_destroy
  PUBLIC :: crtm_aerosol_create
  PUBLIC :: crtm_aerosol_addlayercopy
  PUBLIC :: crtm_aerosol_zero
  PUBLIC :: crtm_aerosol_isvalid
  PUBLIC :: crtm_aerosol_inspect
  PUBLIC :: crtm_aerosol_defineversion
  PUBLIC :: crtm_aerosol_compare
  PUBLIC :: crtm_aerosol_setlayers
  PUBLIC :: crtm_aerosol_inquirefile
  PUBLIC :: crtm_aerosol_readfile
  PUBLIC :: crtm_aerosol_writefile


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

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

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

  INTERFACE crtm_aerosol_inspect
    MODULE PROCEDURE scalar_inspect
    MODULE PROCEDURE rank1_inspect
    MODULE PROCEDURE rank2_inspect
  END INTERFACE crtm_aerosol_inspect


  ! -----------------
  ! Module parameters
  ! -----------------
  CHARACTER(*), PARAMETER :: module_version_id = &
  '$Id: CRTM_Aerosol_Define.f90 60152 2015-08-13 19:19:13Z paul.vandelst@noaa.gov $'
  ! Aerosol types and names
  INTEGER, PARAMETER :: n_valid_aerosol_categories = 8
  INTEGER, PARAMETER ::        invalid_aerosol = 0
  INTEGER, PARAMETER ::           dust_aerosol = 1
  INTEGER, PARAMETER ::   seasalt_ssam_aerosol = 2
  INTEGER, PARAMETER ::  seasalt_sscm1_aerosol = 3
  INTEGER, PARAMETER ::  seasalt_sscm2_aerosol = 4
  INTEGER, PARAMETER ::  seasalt_sscm3_aerosol = 5
  INTEGER, PARAMETER :: organic_carbon_aerosol = 6
  INTEGER, PARAMETER ::   black_carbon_aerosol = 7
  INTEGER, PARAMETER ::        sulfate_aerosol = 8
  INTEGER, PARAMETER :: aerosol_category_list(0:n_valid_aerosol_categories) = &
    [        invalid_aerosol, &
                dust_aerosol, &
        seasalt_ssam_aerosol, &
       seasalt_sscm1_aerosol, &
       seasalt_sscm2_aerosol, &
       seasalt_sscm3_aerosol, &
      organic_carbon_aerosol, &
        black_carbon_aerosol, &
             sulfate_aerosol  ]
  CHARACTER(*), PARAMETER :: aerosol_category_name(0:n_valid_aerosol_categories) = &
    [ 'Invalid         ', &
      'Dust            ', &
      'Sea salt (SSAM) ', &
      'Sea salt (SSCM1)', &
      'Sea salt (SSCM2)', &
      'Sea salt (SSCM3)', &
      'Organic carbon  ', &
      'Black carbon    ', &
      'Sulfate         '  ]
  ! 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'


  ! ----------------------------
  ! Aerosol data type definition
  ! ----------------------------
  !:tdoc+:
  TYPE :: crtm_aerosol_type
    ! Allocation indicator
    LOGICAL :: is_allocated = .false.
    ! Dimension values
    INTEGER :: max_layers = 0  ! K dimension.
    INTEGER :: n_layers   = 0  ! Kuse dimension
    ! Number of added layers
    INTEGER :: n_added_layers = 0
    ! Aerosol type
    INTEGER :: Type = invalid_aerosol
    ! Aerosol state variables
    REAL(fp), ALLOCATABLE :: effective_radius(:)  ! K. Units are microns
    REAL(fp), ALLOCATABLE :: concentration(:)     ! K. Units are kg/m^2
  END TYPE crtm_aerosol_type
  !:tdoc-:


CONTAINS


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

  PURE FUNCTION crtm_aerosol_categoryid(aerosol) RESULT(id)
    TYPE(crtm_aerosol_type), INTENT(IN) :: aerosol
    INTEGER :: id
    id = aerosol%type
    IF ( id < 1 .OR. id > n_valid_aerosol_categories ) id = invalid_aerosol
  END FUNCTION crtm_aerosol_categoryid

  PURE FUNCTION crtm_aerosol_categoryname(aerosol) RESULT(name)
    TYPE(crtm_aerosol_type), INTENT(IN) :: aerosol
    CHARACTER(LEN(AEROSOL_CATEGORY_NAME(1))) :: name
    INTEGER  :: id
    id = crtm_aerosol_categoryid(aerosol)
    name = aerosol_category_name(id)
  END FUNCTION crtm_aerosol_categoryname

  FUNCTION crtm_aerosol_categorylist(list) RESULT(err_stat)
    INTEGER, ALLOCATABLE, INTENT(OUT) :: list(:)
    INTEGER :: err_stat
    CHARACTER(*), PARAMETER :: routine_name = 'CRTM_Aerosol_CategoryList'
    CHARACTER(ML) :: alloc_msg, msg
    INTEGER :: alloc_stat
    err_stat = success
    ALLOCATE( list(0:n_valid_aerosol_categories), stat=alloc_stat, errmsg=alloc_msg )
    IF ( alloc_stat /= 0 ) THEN
      err_stat = failure
      msg = 'Aerosol category list result not allocated -'//trim(alloc_msg)
      CALL display_message( routine_name, msg, err_stat )
      RETURN
    END IF
    list = aerosol_category_list
  END FUNCTION crtm_aerosol_categorylist


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_Aerosol_Associated
!
! PURPOSE:
!       Elemental function to test the status of the allocatable components
!       of a CRTM Aerosol object.
!
! CALLING SEQUENCE:
!       Status = CRTM_Aerosol_Associated( Aerosol )
!
! OBJECTS:
!       Aerosol: Aerosol structure which is to have its member's
!                status tested.
!                UNITS:      N/A
!                TYPE:       CRTM_Aerosol_type
!                DIMENSION:  Scalar or any rank
!                ATTRIBUTES: INTENT(IN)
!
! FUNCTION RESULT:
!       Status:  The return value is a logical value indicating the
!                status of the Aerosol 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 Aerosol argument
!
!:sdoc-:
!--------------------------------------------------------------------------------

  ELEMENTAL FUNCTION crtm_aerosol_associated( Aerosol ) RESULT( Status )
    TYPE(crtm_aerosol_type), INTENT(IN) :: aerosol
    LOGICAL :: status
    status = aerosol%Is_Allocated
  END FUNCTION crtm_aerosol_associated


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

  ELEMENTAL SUBROUTINE crtm_aerosol_destroy( Aerosol )
    TYPE(crtm_aerosol_type), INTENT(OUT) :: aerosol
    aerosol%Is_Allocated = .false.
  END SUBROUTINE crtm_aerosol_destroy


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_Aerosol_Create
!
! PURPOSE:
!       Elemental subroutine to create an instance of the CRTM Aerosol object.
!
! CALLING SEQUENCE:
!       CALL CRTM_Aerosol_Create( Aerosol, n_Layers )
!
! OBJECTS:
!       Aerosol:      Aerosol structure.
!                     UNITS:      N/A
!                     TYPE:       CRTM_Aerosol_type
!                     DIMENSION:  Scalar or any rank
!                     ATTRIBUTES: INTENT(OUT)
!
! INPUTS:
!       n_Layers:     Number of layers for which there is Aerosol data.
!                     Must be > 0.
!                     UNITS:      N/A
!                     TYPE:       INTEGER
!                     DIMENSION:  Same as Aerosol object
!                     ATTRIBUTES: INTENT(IN)
!
!:sdoc-:
!--------------------------------------------------------------------------------

  ELEMENTAL SUBROUTINE crtm_aerosol_create( Aerosol, n_Layers )
    ! Arguments
    TYPE(crtm_aerosol_type), INTENT(OUT) :: aerosol
    INTEGER,                 INTENT(IN)  :: n_layers
    ! Local variables
    INTEGER :: alloc_stat

    ! Check input
    IF ( n_layers < 1 ) RETURN

    ! Perform the allocation
    ALLOCATE( aerosol%Effective_Radius( n_layers ), &
              aerosol%Concentration( n_layers ), &
              stat = alloc_stat )
    IF ( alloc_stat /= 0 ) RETURN

    ! Initialise
    ! ...Dimensions
    aerosol%Max_Layers = n_layers
    aerosol%n_Layers   = n_layers
    ! ...Arrays
    aerosol%Effective_Radius = zero
    aerosol%Concentration    = zero

    ! Set allocation indicator
    aerosol%Is_Allocated = .true.

  END SUBROUTINE crtm_aerosol_create


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_Aerosol_AddLayerCopy
!
! PURPOSE:
!       Elemental function to copy an instance of the CRTM Aerosol object
!       with additional layers added to the TOA of the input.
!
! CALLING SEQUENCE:
!       aer_out = CRTM_Aerosol_AddLayerCopy( aer, n_Added_Layers )
!
! OBJECTS:
!       aer:             Aerosol structure to copy.
!                        UNITS:      N/A
!                        TYPE:       CRTM_Aerosol_type
!                        DIMENSION:  Scalar or any rank
!                        ATTRIBUTES: INTENT(OUT)
!
! INPUTS:
!       n_Added_Layers:  Number of layers to add to the function result.
!                        UNITS:      N/A
!                        TYPE:       INTEGER
!                        DIMENSION:  Same as Aerosol object
!                        ATTRIBUTES: INTENT(IN)
!
! FUNCTION RESULT:
!       aer_out:         Copy of the input Aerosol structure with space for
!                        extra layers added to TOA.
!                        UNITS:      N/A
!                        TYPE:       CRTM_Aerosol_type
!                        DIMENSION:  Same as input.
!                        ATTRIBUTES: INTENT(OUT)
!
!
!:sdoc-:
!--------------------------------------------------------------------------------

  ELEMENTAL FUNCTION crtm_aerosol_addlayercopy( &
    aer, &
    n_Added_Layers ) &
  result( aer_out )
    ! Arguments
    TYPE(crtm_aerosol_type), INTENT(IN) :: aer
    INTEGER,               INTENT(IN) :: n_added_layers
    ! Function result
    TYPE(crtm_aerosol_type) :: aer_out
    ! Local variables
    INTEGER :: na, no, nt

    ! Set the number of extra layers
    na = max(n_added_layers,0)

    ! Create the output structure
    CALL crtm_aerosol_create( aer_out, aer%n_Layers+na )
    IF ( .NOT. crtm_aerosol_associated(aer_out) ) RETURN

    ! Assign data
    aer_out%n_Added_Layers = aer%n_Added_Layers+na
    ! ...Layer independent data
    aer_out%Type = aer%Type
    ! ...Layer dependent data
    no = aer%n_Layers
    nt = aer_out%n_Layers
    aer_out%Effective_Radius(na+1:nt) = aer%Effective_Radius(1:no)
    aer_out%Concentration(na+1:nt)    = aer%Concentration(1:no)

  END FUNCTION crtm_aerosol_addlayercopy


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

  ELEMENTAL SUBROUTINE crtm_aerosol_zero( Aerosol )
    TYPE(crtm_aerosol_type), INTENT(IN OUT) :: aerosol
    ! Do nothing if structure is unused
    IF ( .NOT. crtm_aerosol_associated(aerosol) ) RETURN
    ! Only zero out the data arrays
    aerosol%Effective_Radius = zero
    aerosol%Concentration    = zero
  END SUBROUTINE crtm_aerosol_zero


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

  FUNCTION crtm_aerosol_isvalid( Aerosol ) RESULT( IsValid )
    TYPE(crtm_aerosol_type), INTENT(IN) :: aerosol
    LOGICAL :: isvalid
    CHARACTER(*), PARAMETER :: routine_name = 'CRTM_Aerosol_IsValid'
    CHARACTER(ML) :: msg

    ! Setup
    isvalid = .false.
    ! ...Check if structure is used
    IF ( .NOT. crtm_aerosol_associated(aerosol) ) THEN
      msg = 'Aerosol structure not allocated'
      CALL display_message( routine_name, trim(msg), information )
      RETURN
    ENDIF
    IF ( aerosol%n_Layers < 1 ) THEN
      msg = 'Aerosol structure dimension invalid'
      CALL display_message( routine_name, trim(msg), information )
      RETURN
    ENDIF

    ! Check data
    ! ...Change default so all entries can be checked
    isvalid = .true.
    ! ...The type of Aerosol
    IF ( aerosol%Type < 1 .OR. aerosol%Type > n_valid_aerosol_categories ) THEN
      msg = 'Invalid Aerosol type'
      CALL display_message( routine_name, trim(msg), information )
      isvalid = .false.
    ENDIF
    ! ...Data limits. Only checking negative values
    IF ( any(aerosol%Effective_Radius < zero ) ) THEN
      msg = 'Negative Aerosol effective radius found'
      CALL display_message( routine_name, trim(msg), information )
      isvalid = .false.
    ENDIF
    IF ( any(aerosol%Concentration < zero ) ) THEN
      msg = 'Negative Aerosol concentration found'
      CALL display_message( routine_name, trim(msg), information )
      isvalid = .false.
    ENDIF

  END FUNCTION crtm_aerosol_isvalid


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_Aerosol_Inspect
!
! PURPOSE:
!       Subroutine to print the contents of a CRTM Aerosol object to stdout.
!
! CALLING SEQUENCE:
!       CALL CRTM_Aerosol_Inspect( Aerosol, Unit=unit )
!
! INPUTS:
!       Aerosol:  CRTM Aerosol object to display.
!                 UNITS:      N/A
!                 TYPE:       CRTM_Aerosol_type
!                 DIMENSION:  Scalar, Rank-1, or Rank-2 array
!                 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 scalar_inspect( Aerosol, Unit )
    ! Arguments
    TYPE(CRTM_Aerosol_type), INTENT(IN) :: Aerosol
    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,"AEROSOL OBJECT")')
    ! Dimensions
    WRITE(fid,'(3x,"n_Layers :",1x,i0)') aerosol%n_Layers
    WRITE(fid,'(3x,"Category :",1x,a)') crtm_aerosol_categoryname(aerosol)
    IF ( .NOT. crtm_aerosol_associated(aerosol) ) RETURN
    WRITE(fid,'(3x,"Effective radius:")')
    WRITE(fid,'(5(1x,es13.6,:))') aerosol%Effective_Radius
    WRITE(fid,'(3x,"Concentration:")')
    WRITE(fid,'(5(1x,es13.6,:))') aerosol%Concentration
  END SUBROUTINE scalar_inspect

  SUBROUTINE rank1_inspect( Aerosol, Unit )
    TYPE(CRTM_Aerosol_type), INTENT(IN) :: Aerosol(:)
    INTEGER,       OPTIONAL, INTENT(IN) :: Unit
    INTEGER :: fid
    INTEGER :: i
    fid = output_unit
    IF ( PRESENT(unit) ) THEN
      IF ( file_open(unit) ) fid = unit
    END IF
    DO i = 1, SIZE(aerosol)
      WRITE(fid, fmt='(1x,"RANK-1 INDEX:",i0," - ")', advance='NO') i
      CALL scalar_inspect(aerosol(i), unit=unit)
    END DO
  END SUBROUTINE rank1_inspect

  SUBROUTINE rank2_inspect( Aerosol, Unit )
    TYPE(CRTM_Aerosol_type), INTENT(IN) :: Aerosol(:,:)
    INTEGER,       OPTIONAL, INTENT(IN) :: Unit
    INTEGER :: fid
    INTEGER :: i, j
    fid = output_unit
    IF ( PRESENT(unit) ) THEN
      IF ( file_open(unit) ) fid = unit
    END IF
    DO j = 1, SIZE(aerosol,2)
      DO i = 1, SIZE(aerosol,1)
        WRITE(fid, fmt='(1x,"RANK-2 INDEX:",i0,",",i0," - ")', advance='NO') i,j
        CALL scalar_inspect(aerosol(i,j), unit=unit)
      END DO
    END DO
  END SUBROUTINE rank2_inspect


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_Aerosol_DefineVersion
!
! PURPOSE:
!       Subroutine to return the module version information.
!
! CALLING SEQUENCE:
!       CALL CRTM_Aerosol_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 crtm_aerosol_defineversion( Id )
    CHARACTER(*), INTENT(OUT) :: id
    id = module_version_id
  END SUBROUTINE crtm_aerosol_defineversion


!------------------------------------------------------------------------------
!:sdoc+:
! NAME:
!       CRTM_Aerosol_Compare
!
! PURPOSE:
!       Elemental function to compare two CRTM_Aerosol objects to within
!       a user specified number of significant figures.
!
! CALLING SEQUENCE:
!       is_comparable = CRTM_Aerosol_Compare( x, y, n_SigFig=n_SigFig )
!
! OBJECTS:
!       x, y:          Two CRTM Aerosol objects to be compared.
!                      UNITS:      N/A
!                      TYPE:       CRTM_Aerosol_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_aerosol_compare( &
    x, &
    y, &
    n_SigFig ) &
  result( is_comparable )
    TYPE(crtm_aerosol_type), INTENT(IN) :: x, y
    INTEGER,       OPTIONAL, INTENT(IN) :: n_sigfig
    LOGICAL :: is_comparable
    ! Variables
    INTEGER :: 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_aerosol_associated(x)) .OR. &
         (.NOT. crtm_aerosol_associated(y)) ) RETURN

    ! Check scalars
    IF ( (x%n_Layers /= y%n_Layers) .OR. &
         (x%Type     /= y%Type    ) ) RETURN

    ! Check arrays
    IF ( (.NOT. all(compares_within_tolerance(x%Effective_Radius,y%Effective_Radius,n))) .OR. &
         (.NOT. all(compares_within_tolerance(x%Concentration   ,y%Concentration   ,n))) ) RETURN

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

  END FUNCTION crtm_aerosol_compare


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_Aerosol_SetLayers
!
! PURPOSE:
!       Elemental subroutine to set the working number of layers to use
!       in a CRTM Aerosol object.
!
! CALLING SEQUENCE:
!      CALL CRTM_Aerosol_SetLayers( Aerosol, n_Layers )
!
! OBJECT:
!       Aerosol:      CRTM Aerosol object which is to have its working number
!                     of layers updated.
!                     UNITS:      N/A
!                     TYPE:       CRTM_Aerosol_type
!                     DIMENSION:  Scalar or any rank
!                     ATTRIBUTES: INTENT(IN OUT)
!
! INPUTS:
!       n_Layers:     The value to set the n_Layers component of the
!                     Aerosol object.
!                     UNITS:      N/A
!                     TYPE:       CRTM_Aerosol_type
!                     DIMENSION:  Conformable with the Aerosol object argument
!                     ATTRIBUTES: INTENT(IN)
!
! COMMENTS:
!       - The object is zeroed upon output.
!
!       - If n_Layers <= Aerosol%Max_Layers, then only the dimension value
!         of the object is changed.
!
!       - If n_Layers > Aerosol%Max_Layers, then the object is reallocated
!         to the required number of layers.
!
!:sdoc-:
!--------------------------------------------------------------------------------

  ELEMENTAL SUBROUTINE crtm_aerosol_setlayers( Aerosol, n_Layers )
    TYPE(crtm_aerosol_type), INTENT(IN OUT) :: aerosol
    INTEGER,               INTENT(IN)       :: n_layers
    IF ( n_layers < aerosol%Max_Layers ) THEN
      aerosol%n_Layers = n_layers
      CALL crtm_aerosol_zero(aerosol)
    ELSE
      CALL crtm_aerosol_create( aerosol, n_layers )
    END IF
  END SUBROUTINE crtm_aerosol_setlayers


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_Aerosol_InquireFile
!
! PURPOSE:
!       Function to inquire CRTM Aerosol object files.
!
! CALLING SEQUENCE:
!       Error_Status = CRTM_Aerosol_InquireFile( Filename               , &
!                                                n_Aerosols = n_Aerosols  )
!
! INPUTS:
!       Filename:       Character string specifying the name of a
!                       CRTM Aerosol data file to read.
!                       UNITS:      N/A
!                       TYPE:       CHARACTER(*)
!                       DIMENSION:  Scalar
!                       ATTRIBUTES: INTENT(IN)
!
! OPTIONAL OUTPUTS:
!       n_Aerosols:     The number of Aerosol profiles in the data 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_aerosol_inquirefile( &
    Filename  , &  ! Input
    n_Aerosols) &  ! Optional output
  result( err_stat )
    ! Arguments
    CHARACTER(*),           INTENT(IN)  :: filename
    INTEGER     , OPTIONAL, INTENT(OUT) :: n_aerosols
    ! Function result
    INTEGER :: err_stat
    ! Function parameters
    CHARACTER(*), PARAMETER :: routine_name = 'CRTM_Aerosol_InquireFile'
    ! Function variables
    CHARACTER(ML) :: msg
    CHARACTER(ML) :: io_msg
    INTEGER :: io_stat
    INTEGER :: fid
    INTEGER :: na

    ! Setup
    err_stat = success


    ! Open the aerosol 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 number of aerosols dimension
    READ( fid,iostat=io_stat,iomsg=io_msg ) na
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading n_Aerosols dimension from '//trim(filename)//' - '//trim(io_msg)
      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


    ! Set the return arguments
    IF ( PRESENT(n_aerosols) ) n_aerosols = na

  CONTAINS

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

  END FUNCTION crtm_aerosol_inquirefile


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_Aerosol_ReadFile
!
! PURPOSE:
!       Function to read CRTM Aerosol object files.
!
! CALLING SEQUENCE:
!       Error_Status = CRTM_Aerosol_ReadFile( Filename               , &
!                                             Aerosol                , &
!                                             Quiet      = Quiet     , &
!                                             No_Close   = No_Close  , &
!                                             n_Aerosols = n_Aerosols  )
!
! INPUTS:
!       Filename:       Character string specifying the name of a
!                       Aerosol format data file to read.
!                       UNITS:      N/A
!                       TYPE:       CHARACTER(*)
!                       DIMENSION:  Scalar
!                       ATTRIBUTES: INTENT(IN)
!
! OUTPUTS:
!       Aerosol:        CRTM Aerosol object array containing the Aerosol data.
!                       UNITS:      N/A
!                       TYPE:       CRTM_Aerosol_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_Aerosols:     The actual number of aerosol profiles 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_aerosol_readfile( &
    Filename  , &  ! Input
    Aerosol   , &  ! Output
    Quiet     , &  ! Optional input
    No_Close  , &  ! Optional input
    n_Aerosols, &  ! Optional output
    Debug     ) &  ! Optional input (Debug output control)
  result( err_stat )
    ! Arguments
    CHARACTER(*),            INTENT(IN)  :: filename
    TYPE(crtm_aerosol_type), INTENT(OUT) :: aerosol(:)
    LOGICAL,       OPTIONAL, INTENT(IN)  :: quiet
    LOGICAL,       OPTIONAL, INTENT(IN)  :: no_close
    INTEGER,       OPTIONAL, INTENT(OUT) :: n_aerosols
    LOGICAL,       OPTIONAL, INTENT(IN)  :: debug
    ! Function result
    INTEGER :: err_stat
    ! Function parameters
    CHARACTER(*), PARAMETER :: routine_name = 'CRTM_Aerosol_ReadFile'
    ! Function variables
    CHARACTER(ML) :: msg
    CHARACTER(ML) :: io_msg
    INTEGER :: io_stat
    LOGICAL :: noisy
    LOGICAL :: yes_close
    INTEGER :: fid
    INTEGER :: m
    INTEGER :: na

    ! 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) ) noisy = debug


    ! 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 unit number'
        CALL read_cleanup(); RETURN
      END IF
    ELSE
      ! No, the file is not open
      ! ...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 number of aerosols dimension
    READ( fid,iostat=io_stat,iomsg=io_msg ) na
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading n_Aerosols data dimension from '//trim(filename)//' - '//trim(io_msg)
      CALL read_cleanup(); RETURN
    END IF
    ! ...Check if output array large enough
    IF ( na > SIZE(aerosol) ) THEN
      WRITE( msg,'("Number of aerosols, ",i0," > size of the output ",&
             &"Aerosol object array, ",i0,".")' ) na, SIZE(aerosol)
      CALL read_cleanup(); RETURN
    END IF


    ! Read the aerosol data
    aerosol_loop: DO m = 1, na
      err_stat = read_record( fid, aerosol(m) )
      IF ( err_stat /= success ) THEN
        WRITE( msg,'("Error reading Aerosol element #",i0," from ",a)' ) m, trim(filename)
        CALL read_cleanup(); RETURN
      END IF
    END DO aerosol_loop


    ! Close the file
    IF ( yes_close ) 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


    ! Set the optional return values
    IF ( PRESENT(n_aerosols) ) n_aerosols = na


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

  CONTAINS

    SUBROUTINE read_cleanup()
      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
      CALL crtm_aerosol_destroy( aerosol )
      err_stat = failure
      CALL display_message( routine_name, msg, err_stat )
    END SUBROUTINE read_cleanup

  END FUNCTION crtm_aerosol_readfile


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       CRTM_Aerosol_WriteFile
!
! PURPOSE:
!       Function to write CRTM Aerosol object files.
!
! CALLING SEQUENCE:
!       Error_Status = CRTM_Aerosol_WriteFile( Filename           , &
!                                              Aerosol            , &
!                                              Quiet    = Quiet   , &
!                                              No_Close = No_Close  )
!
! INPUTS:
!       Filename:       Character string specifying the name of the
!                       Aerosol format data file to write.
!                       UNITS:      N/A
!                       TYPE:       CHARACTER(*)
!                       DIMENSION:  Scalar
!                       ATTRIBUTES: INTENT(IN)
!
!       Aerosol:        CRTM Aerosol object array containing the Aerosol data.
!                       UNITS:      N/A
!                       TYPE:       CRTM_Aerosol_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_aerosol_writefile( &
    Filename, &  ! Input
    Aerosol , &  ! Input
    Quiet   , &  ! Optional input
    No_Close, &  ! Optional input
    Debug   ) &  ! Optional input (Debug output control)
  result( err_stat )
    ! Arguments
    CHARACTER(*),            INTENT(IN)  :: filename
    TYPE(crtm_aerosol_type), INTENT(IN)  :: aerosol(:)
    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_Aerosol_WriteFile'
    ! Function variables
    CHARACTER(ML) :: msg
    CHARACTER(ML) :: io_msg
    INTEGER :: io_stat
    LOGICAL :: noisy
    LOGICAL :: yes_close
    INTEGER :: fid
    INTEGER :: m, na

    ! 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) ) noisy = debug

    ! Check the Aerosol structure dimensions
    IF ( any(aerosol%n_Layers < 1) ) THEN
      msg = 'Dimensions of Aerosol 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 unit number'
        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 aerosols dimension
    na = SIZE(aerosol)
    WRITE( fid,iostat=io_stat,iomsg=io_msg ) na
    IF ( io_stat /= 0 ) THEN
      msg = 'Error writing n_Aerosols data dimension to '//trim(filename)//'- '//trim(io_msg)
      CALL write_cleanup(); RETURN
    END IF


    ! Write the aerosol data
    aerosol_loop: DO m = 1, na
      err_stat = write_record( fid, aerosol(m) )
      IF ( err_stat /= success ) THEN
        WRITE( msg,'("Error writing Aerosol element #",i0," to ",a)' ) m, trim(filename)
        CALL write_cleanup(); RETURN
      END IF
    END DO aerosol_loop


    ! Close the file (if error, no delete)
    IF ( yes_close ) THEN
      CLOSE( fid,status='KEEP',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
      WRITE( msg,'("Number of aerosols written to ",a,": ",i0)' ) trim(filename), na
      CALL display_message( routine_name, msg, information )
    END IF

  CONTAINS

    SUBROUTINE write_cleanup()
      IF ( file_open(fid) ) THEN
        CLOSE( fid,status=write_error_status,iostat=io_stat,iomsg=io_msg )
        IF ( io_stat /= 0 ) &
          msg = trim(msg)//'; Error deleting output file 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 crtm_aerosol_writefile



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

!------------------------------------------------------------------------------
!
! NAME:
!       CRTM_Aerosol_Equal
!
! PURPOSE:
!       Elemental function to test the equality of two CRTM_Aerosol structures.
!       Used in OPERATOR(==) interface block.
!
! CALLING SEQUENCE:
!       is_equal = CRTM_Aerosol_Equal( x, y )
!
!         or
!
!       IF ( x == y ) THEN
!         ...
!       END IF
!
! OBJECTS:
!       x, y:          Two CRTM_Aerosol objects to be compared.
!                      UNITS:      N/A
!                      TYPE:       CRTM_Aerosol_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_aerosol_equal( x, y ) RESULT( is_equal )
    TYPE(crtm_aerosol_type) , INTENT(IN)  :: x, y
    LOGICAL :: is_equal
    ! Variables
    INTEGER :: n

    ! Set up
    is_equal = .false.

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

    ! Check contents
    ! ...Scalars
    IF ( (x%n_Layers /= y%n_Layers) .OR. (x%Type /= y%Type) ) RETURN
    ! ...Arrays
    n = x%n_Layers
    IF ( all(x%Effective_Radius(1:n) .equalto. y%Effective_Radius(1:n) ) .AND. &
         all(x%Concentration(1:n)    .equalto. y%Concentration(1:n)    )       ) &
      is_equal = .true.

  END FUNCTION crtm_aerosol_equal


!--------------------------------------------------------------------------------
!
! NAME:
!       CRTM_Aerosol_Add
!
! PURPOSE:
!       Pure function to add two CRTM Aerosol objects.
!       Used in OPERATOR(+) interface block.
!
! CALLING SEQUENCE:
!       aersum = CRTM_Aerosol_Add( aer1, aer2 )
!
!         or
!
!       aersum = aer1 + aer2
!
!
! INPUTS:
!       aer1, aer2: The Aerosol objects to add.
!                   UNITS:      N/A
!                   TYPE:       CRTM_Aerosol_type
!                   DIMENSION:  Scalar
!                   ATTRIBUTES: INTENT(IN OUT)
!
! RESULT:
!       aersum:     Aerosol object containing the added components.
!                   UNITS:      N/A
!                   TYPE:       CRTM_Aerosol_type
!                   DIMENSION:  Scalar
!
!--------------------------------------------------------------------------------

  ELEMENTAL FUNCTION crtm_aerosol_add( aer1, aer2 ) RESULT( aersum )
    TYPE(crtm_aerosol_type), INTENT(IN) :: aer1, aer2
    TYPE(crtm_aerosol_type) :: aersum
    ! Variables
    INTEGER :: n

    ! Check input
    ! ...If input structures not used, do nothing
    IF ( .NOT. crtm_aerosol_associated( aer1 ) .OR. &
         .NOT. crtm_aerosol_associated( aer2 )      ) RETURN
    ! ...If input structure for different aerosols, or sizes, do nothing
    IF ( aer1%Type           /= aer2%Type           .OR. &
         aer1%n_Layers       /= aer2%n_Layers       .OR. &
         aer1%n_Added_Layers /= aer2%n_Added_Layers      ) RETURN

    ! Copy the first structure
    aersum = aer1

    ! And add its components to the second one
    n = aer1%n_Layers
    aersum%Effective_Radius(1:n) = aersum%Effective_Radius(1:n) + aer2%Effective_Radius(1:n)
    aersum%Concentration(1:n)    = aersum%Concentration(1:n)    + aer2%Concentration(1:n)

  END FUNCTION crtm_aerosol_add


!--------------------------------------------------------------------------------
!
! NAME:
!       CRTM_Aerosol_Subtract
!
! PURPOSE:
!       Pure function to subtract two CRTM Aerosol objects.
!       Used in OPERATOR(-) interface block.
!
! CALLING SEQUENCE:
!       aerdiff = CRTM_Aerosol_Subtract( aer1, aer2 )
!
!         or
!
!       aersum = aer1 - aer2
!
!
! INPUTS:
!       aer1, aer2: The Aerosol objects to difference.
!                   UNITS:      N/A
!                   TYPE:       CRTM_Aerosol_type
!                   DIMENSION:  Scalar
!                   ATTRIBUTES: INTENT(IN OUT)
!
! RESULT:
!       aerdiff:    Aerosol object containing the differenced components.
!                   UNITS:      N/A
!                   TYPE:       CRTM_Aerosol_type
!                   DIMENSION:  Scalar
!
!--------------------------------------------------------------------------------

  ELEMENTAL FUNCTION crtm_aerosol_subtract( aer1, aer2 ) RESULT( aerdiff )
    TYPE(crtm_aerosol_type), INTENT(IN) :: aer1, aer2
    TYPE(crtm_aerosol_type) :: aerdiff
    ! Variables
    INTEGER :: n

    ! Check input
    ! ...If input structures not used, do nothing
    IF ( .NOT. crtm_aerosol_associated( aer1 ) .OR. &
         .NOT. crtm_aerosol_associated( aer2 )      ) RETURN
    ! ...If input structure for different aerosols, or sizes, do nothing
    IF ( aer1%Type           /= aer2%Type           .OR. &
         aer1%n_Layers       /= aer2%n_Layers       .OR. &
         aer1%n_Added_Layers /= aer2%n_Added_Layers      ) RETURN

    ! Copy the first structure
    aerdiff = aer1

    ! And subtract the second one's components from it
    n = aer1%n_Layers
    aerdiff%Effective_Radius(1:n) = aerdiff%Effective_Radius(1:n) - aer2%Effective_Radius(1:n)
    aerdiff%Concentration(1:n)    = aerdiff%Concentration(1:n)    - aer2%Concentration(1:n)

  END FUNCTION crtm_aerosol_subtract


!
! NAME:
!       Read_Record
!
! PURPOSE:
!       Utility function to read a single CRTM Aerosol object in binary format
!
! CALLING SEQUENCE:
!       Error_Status = Read_Record( FileID, Aerosol )
!

  FUNCTION read_record( &
    fid    , &  ! Input
    aerosol) &  ! Output
  result( err_stat )
    ! Arguments
    INTEGER                , INTENT(IN)  :: fid
    TYPE(crtm_aerosol_type), INTENT(OUT) :: aerosol
    ! Function result
    INTEGER :: err_stat
    ! Function parameters
    CHARACTER(*), PARAMETER :: routine_name = 'CRTM_Aerosol_ReadFile(Binary Record)'
    ! Function variables
    CHARACTER(ML) :: msg
    CHARACTER(ML) :: io_msg
    INTEGER :: io_stat
    INTEGER :: n_layers

    ! Set up
    err_stat = success


    ! Read the dimensions
    READ( fid,iostat=io_stat,iomsg=io_msg ) n_layers
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading n_Layers dimension - '//trim(io_msg)
      CALL read_record_cleanup(); RETURN
    END IF


    ! Allocate the structure
    CALL crtm_aerosol_create( aerosol, n_layers )
    IF ( .NOT. crtm_aerosol_associated( aerosol ) ) THEN
      msg = 'Aerosol object allocation failed.'
      CALL read_record_cleanup(); RETURN
    END IF


    ! Read the aerosol data
    READ( fid,iostat=io_stat,iomsg=io_msg ) &
      aerosol%Type, &
      aerosol%Effective_Radius, &
      aerosol%Concentration
    IF ( io_stat /= 0 ) THEN
      msg = 'Error reading Aerosol data - '//trim(io_msg)
      CALL read_record_cleanup(); RETURN
    END IF

  CONTAINS

    SUBROUTINE read_record_cleanup()
      CALL crtm_aerosol_destroy( aerosol )
      CLOSE( fid,iostat=io_stat,iomsg=io_msg )
      IF ( io_stat /= success ) &
        msg = trim(msg)//'; Error closing file during error cleanup - '//trim(io_msg)
      err_stat = failure
      CALL display_message( routine_name, msg, err_stat )
    END SUBROUTINE read_record_cleanup

  END FUNCTION read_record


!
! NAME:
!       Write_Record
!
! PURPOSE:
!       Function to write a single CRTM Aerosol object in binary format
!

  FUNCTION write_record( &
    fid    , &  ! Input
    aerosol) &  ! Input
  result( err_stat )
    ! Arguments
    INTEGER                , INTENT(IN)  :: fid
    TYPE(crtm_aerosol_type), INTENT(IN)  :: aerosol
    ! Function result
    INTEGER :: err_stat
    ! Function parameters
    CHARACTER(*), PARAMETER :: routine_name = 'CRTM_Aerosol_WriteFile(Binary Record)'
    ! Function variables
    CHARACTER(ML) :: msg
    CHARACTER(ML) :: io_msg
    INTEGER :: io_stat

    ! Setup
    err_stat = success
    IF ( .NOT. crtm_aerosol_associated( aerosol ) ) THEN
      msg = 'Input Aerosol object is not used.'
      CALL write_record_cleanup(); RETURN
    END IF


    ! Write the dimensions
    WRITE( fid,iostat=io_stat,iomsg=io_msg ) aerosol%n_Layers
    IF ( io_stat /= 0 ) THEN
      msg = 'Error writing dimensions - '//trim(io_msg)
      CALL write_record_cleanup(); RETURN
    END IF


    ! Write the data
    WRITE( fid,iostat=io_stat,iomsg=io_msg ) &
      aerosol%Type, &
      aerosol%Effective_Radius(1:aerosol%n_Layers), &
      aerosol%Concentration(1:aerosol%n_Layers)
    IF ( io_stat /= 0 ) THEN
      msg = 'Error writing Aerosol data - '//trim(io_msg)
      CALL write_record_cleanup(); RETURN
    END IF

  CONTAINS

    SUBROUTINE write_record_cleanup()
      CLOSE( fid,status=write_error_status,iostat=io_stat,iomsg=io_msg )
      IF ( io_stat /= success ) &
        msg = trim(msg)//'; Error closing file during error cleanup'
      err_stat = failure
      CALL display_message( routine_name, trim(msg), err_stat )
    END SUBROUTINE write_record_cleanup

  END FUNCTION write_record

END MODULE crtm_aerosol_define