ACCoeff_Define.f90

Go to the documentation of this file.

!
! ACCoeff_Define
!
! Module defining the ACCoeff data structure and containing routines to 
! manipulate it.
!
! CREATION HISTORY:
!       Written by:  Paul van Delst, 25-Jan-2011
!                    paul.vandelst@noaa.gov
!

MODULE accoeff_define

  ! ------------------
  ! Environment set up
  ! ------------------
  ! Module use
  USE type_kinds,            ONLY: long, double
  USE message_handler      , ONLY: success, failure, information, display_message
  USE compare_float_numbers, ONLY: OPERATOR(.equalto.)
  USE subset_define        , ONLY: subset_type      , &
                                   subset_associated, &
                                   subset_getvalue  , &
                                   subset_generate
  USE sensorinfo_parameters, ONLY: invalid_wmo_satellite_id, &
                                   invalid_wmo_sensor_id   
  ! Disable implicit typing
  IMPLICIT NONE


  ! ------------
  ! Visibilities
  ! ------------
  ! Everything private by default
  PRIVATE
  ! Datatypes
  PUBLIC :: accoeff_type
  ! Operators
  PUBLIC :: OPERATOR(==)
  ! Procedures
  PUBLIC :: accoeff_associated
  PUBLIC :: accoeff_destroy
  PUBLIC :: accoeff_create
  PUBLIC :: accoeff_inspect
  PUBLIC :: accoeff_validrelease
  PUBLIC :: accoeff_info
  PUBLIC :: accoeff_defineversion
  PUBLIC :: accoeff_subset
  PUBLIC :: accoeff_concat
  PUBLIC :: accoeff_channelreindex


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


  ! -----------------
  ! Module parameters
  ! -----------------
  ! Version Id for the module
  CHARACTER(*), PARAMETER :: module_version_id = &
  '$Id: ACCoeff_Define.f90 60152 2015-08-13 19:19:13Z paul.vandelst@noaa.gov $'
  ! Literal constants
  REAL(Double), PARAMETER :: zero = 0.0_double
  REAL(Double), PARAMETER :: one  = 1.0_double
  ! Default message string length
  INTEGER, PARAMETER :: ml = 512
  ! Sensor id string length
  INTEGER, PARAMETER :: sl = 20
  ! Current valid release and version numbers
  INTEGER, PARAMETER :: accoeff_release = 1
  INTEGER, PARAMETER :: accoeff_version = 1


  ! -----------------------
  ! Derived type definition
  ! -----------------------
  TYPE :: accoeff_type
    ! Allocation indicator
    LOGICAL :: is_allocated = .false.
    ! Release and version information
    INTEGER(Long) :: release = accoeff_release
    INTEGER(Long) :: version = accoeff_version
    ! Dimensions
    INTEGER(Long) :: n_fovs     = 0  ! N
    INTEGER(Long) :: n_channels = 0  ! L
    ! Sensor info
    CHARACTER(SL)              :: sensor_id        = ''                     
    INTEGER(Long)              :: wmo_satellite_id = invalid_wmo_satellite_id
    INTEGER(Long)              :: wmo_sensor_id    = invalid_wmo_sensor_id
    INTEGER(Long), ALLOCATABLE :: sensor_channel(:)  ! L
    ! Antenna correction coefficients
    REAL(Double) , ALLOCATABLE :: a_earth(:,:)     ! N x L
    REAL(Double) , ALLOCATABLE :: a_space(:,:)     ! N x L
    REAL(Double) , ALLOCATABLE :: a_platform(:,:)  ! N x L
  END TYPE accoeff_type


CONTAINS


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

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

  ELEMENTAL FUNCTION accoeff_associated( ACCoeff ) RESULT( Status )
    TYPE(accoeff_type), INTENT(IN) :: accoeff
    LOGICAL :: status
    status = accoeff%Is_Allocated
  END FUNCTION accoeff_associated


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

  ELEMENTAL SUBROUTINE accoeff_destroy( ACCoeff )
    TYPE(accoeff_type), INTENT(OUT) :: accoeff
    accoeff%Is_Allocated = .false.
    accoeff%n_FOVs           = 0
    accoeff%n_Channels       = 0
    accoeff%Sensor_Id        = ''
    accoeff%WMO_Satellite_ID = invalid_wmo_satellite_id
    accoeff%WMO_Sensor_ID    = invalid_wmo_sensor_id
  END SUBROUTINE accoeff_destroy


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       ACCoeff_Create
! 
! PURPOSE:
!       Elemental subroutine to create an instance of an ACCoeff object.
!
! CALLING SEQUENCE:
!       CALL ACCoeff_Create( ACCoeff   , &
!                            n_FOVs    , &
!                            n_Channels  )         
!
! OBJECTS:
!       ACCoeff:            ACCoeff object structure.
!                           UNITS:      N/A
!                           TYPE:       ACCoeff_type
!                           DIMENSION:  Scalar or any rank
!                           ATTRIBUTES: INTENT(OUT)
!
! INPUTS:
!       n_FOVs:             Number of sensor fields-of-view (FOVs).
!                           Must be > 0.
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN)
!
!       n_Channels:         Number of sensor channels.
!                           Must be > 0.
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN)
!
!:sdoc-:
!--------------------------------------------------------------------------------

  ELEMENTAL SUBROUTINE accoeff_create( &
    ACCoeff   , &  ! Output
    n_FOVs    , &  ! Input
    n_Channels  )  ! Input
    ! Arguments
    TYPE(accoeff_type), INTENT(OUT) :: accoeff
    INTEGER           , INTENT(IN)  :: n_fovs
    INTEGER           , INTENT(IN)  :: n_channels
    ! Local variables
    INTEGER :: alloc_stat

    ! Check input
    IF ( n_fovs     < 1 .OR. &
         n_channels < 1 ) RETURN
    
    ! Perform the allocation
    ALLOCATE( accoeff%Sensor_Channel( 1:n_channels ), &
              accoeff%A_earth( 1:n_fovs, 1:n_channels ), &
              accoeff%A_space( 1:n_fovs, 1:n_channels ), &
              accoeff%A_platform( 1:n_fovs, 1:n_channels ), &
              stat = alloc_stat )
    IF ( alloc_stat /= 0 ) RETURN


    ! Initialise
    ! ...Dimensions
    accoeff%n_FOVs     = n_fovs
    accoeff%n_Channels = n_channels
    ! ...Arrays
    accoeff%Sensor_Channel = 0
    accoeff%A_earth        = one
    accoeff%A_space        = zero
    accoeff%A_platform     = zero


    ! Set allocation indicator
    accoeff%Is_Allocated = .true.

  END SUBROUTINE accoeff_create
  
  
!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       ACCoeff_Inspect
!
! PURPOSE:
!       Subroutine to print the contents of a ACCoeff object to stdout.
!
! CALLING SEQUENCE:
!       CALL ACCoeff_Inspect( ACCoeff )
!
! OBJECTS:
!       ACCoeff:       ACCoeff object to display.
!                      UNITS:      N/A
!                      TYPE:       ACCoeff_type
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN)
!
!:sdoc-:
!--------------------------------------------------------------------------------

  SUBROUTINE accoeff_inspect( ACCoeff )
    TYPE(accoeff_type), INTENT(IN) :: accoeff
    WRITE(*,'(1x,"ACCoeff OBJECT")')
    ! Release/version info
    WRITE(*,'(3x,"Release.Version  :",1x,i0,".",i0)') accoeff%Release, accoeff%Version
    ! Dimensions
    WRITE(*,'(3x,"n_FOVs           :",1x,i0)') accoeff%n_FOVs    
    WRITE(*,'(3x,"n_Channels       :",1x,i0)') accoeff%n_Channels
    IF ( .NOT. accoeff_associated(accoeff) ) RETURN
    ! Sensor info
    WRITE(*,'(3x,"Sensor_Id        :",1x,a )') trim(accoeff%Sensor_Id)
    WRITE(*,'(3x,"WMO_Satellite_ID :",1x,i0)') accoeff%WMO_Satellite_ID 
    WRITE(*,'(3x,"WMO_Sensor_ID    :",1x,i0)') accoeff%WMO_Sensor_ID
    WRITE(*,'(3x,"Sensor_Channel   :")')
    WRITE(*,'(10(1x,i5,:))') accoeff%Sensor_Channel
    ! Coefficient arrays
    WRITE(*,'(3x,"A_earth    :")')
    WRITE(*,'(5(1x,es13.6,:))') accoeff%A_earth   
    WRITE(*,'(3x,"A_space    :")')
    WRITE(*,'(5(1x,es13.6,:))') accoeff%A_space   
    WRITE(*,'(3x,"A_platform :")')
    WRITE(*,'(5(1x,es13.6,:))') accoeff%A_platform
    
  END SUBROUTINE accoeff_inspect
  
  
!----------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       ACCoeff_ValidRelease
!
! PURPOSE:
!       Function to check the ACCoeff Release value.
!
! CALLING SEQUENCE:
!       IsValid = ACCoeff_ValidRelease( ACCoeff )
!
! INPUTS:
!       ACCoeff:       ACCoeff object for which the Release component
!                      is to be checked.
!                      UNITS:      N/A
!                      TYPE:       ACCoeff_type
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN)
!
! FUNCTION RESULT:
!       IsValid:       Logical value defining the release validity.
!                      UNITS:      N/A
!                      TYPE:       LOGICAL
!                      DIMENSION:  Scalar
!
!:sdoc-:
!----------------------------------------------------------------------------------

  FUNCTION accoeff_validrelease( ACCoeff ) RESULT( IsValid )
    ! Arguments
    TYPE(accoeff_type), INTENT(IN) :: accoeff
    ! Function result
    LOGICAL :: isvalid
    ! Local parameters
    CHARACTER(*), PARAMETER :: routine_name = 'ACCoeff_ValidRelease'
    ! Local variables
    CHARACTER(ML) :: msg

    ! Set up
    isvalid = .true.


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


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

  END FUNCTION accoeff_validrelease


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

  SUBROUTINE accoeff_info( ACCoeff, Info )
    ! Arguments
    TYPE(accoeff_type), INTENT(IN)  :: accoeff
    CHARACTER(*),       INTENT(OUT) :: info
    ! Parameters
    INTEGER, PARAMETER :: carriage_return = 13
    INTEGER, PARAMETER :: linefeed = 10
    ! Local variables
    CHARACTER(2000) :: long_string

    ! Write the required data to the local string
    WRITE( long_string, &
           '(a,1x,"ACCoeff RELEASE.VERSION: ",i2,".",i2.2,a,3x, &
           &"N_FOVS=",i0,2x,&
           &"N_CHANNELS=",i0 )' ) &
           achar(carriage_return)//achar(linefeed), &
           accoeff%Release, accoeff%Version, &
           achar(carriage_return)//achar(linefeed), &
           accoeff%n_FOVs    , &
           accoeff%n_Channels
                       
    ! Trim the output based on the
    ! dummy argument string length
    info = long_string(1:min(len(info), len_trim(long_string)))

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


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       ACCoeff_Subset
!
! PURPOSE:
!       Subroutine to return a channel subset of the input ACCoeff object.
!
! CALLING SEQUENCE:
!       CALL ACCoeff_Subset( ACCoeff, Subset, AC_Subset )
!
! OBJECTS:
!       ACCoeff:      ACCoeff object which is to be subsetted.
!                     UNITS:      N/A
!                     TYPE:       ACCoeff_type
!                     DIMENSION:  Scalar
!                     ATTRIBUTES: INTENT(IN)
!
! INPUTS:
!       Subset:       Subset object containing the list of indices
!                     corresponding the channels to be extracted.
!                     UNITS:      N/A
!                     TYPE:       Subset_type
!                     DIMENSION:  Scalar
!                     ATTRIBUTES: INTENT(IN)
!
! OUTPUTS:
!       AC_Subset:    ACCoeff object containing the requested channel subset
!                     of the input ACCoeff data.
!                     UNITS:      N/A
!                     TYPE:       ACCoeff_type
!                     DIMENSION:  Scalar
!                     ATTRIBUTES: INTENT(OUT)
!
!:sdoc-:
!--------------------------------------------------------------------------------

  SUBROUTINE accoeff_subset( &
    ACCoeff       , &  ! Input
    Sensor_Channel, &  ! Input
    AC_Subset       )  ! Output
    ! Arguments
    TYPE(accoeff_type), INTENT(IN)  :: accoeff
    INTEGER           , INTENT(IN)  :: sensor_channel(:)
    TYPE(accoeff_type), INTENT(OUT) :: ac_subset
    ! Local variables
    TYPE(subset_type) :: subset
    INTEGER :: n_subset_channels
    INTEGER, ALLOCATABLE :: idx(:)
    
    ! Check input is valid
    IF ( .NOT. accoeff_associated(accoeff) ) RETURN
    
    
    ! Generate the subset list
    CALL subset_generate( &
           subset, &
           accoeff%Sensor_Channel, &
           sensor_channel )
    IF ( .NOT. subset_associated( subset ) ) RETURN
    
    
    ! Allocate the output subset ACCoeff object
    CALL subset_getvalue( subset, n_values = n_subset_channels, index = idx )
    CALL accoeff_create( ac_subset, accoeff%n_FOVs, n_subset_channels )
    IF ( .NOT. accoeff_associated(ac_subset) ) RETURN


    ! Extract out the subset channels
    ! ...First assign some scalars
    ac_subset%Version          = accoeff%Version
    ac_subset%Sensor_Id        = accoeff%Sensor_Id       
    ac_subset%WMO_Satellite_ID = accoeff%WMO_Satellite_ID
    ac_subset%WMO_Sensor_ID    = accoeff%WMO_Sensor_ID   
    ! ...and now extract the subset
    ac_subset%Sensor_Channel = accoeff%Sensor_Channel(idx)
    ac_subset%A_earth        = accoeff%A_earth(:,idx)
    ac_subset%A_space        = accoeff%A_space(:,idx)
    ac_subset%A_platform     = accoeff%A_platform(:,idx)

  END SUBROUTINE accoeff_subset


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       ACCoeff_Concat
!
! PURPOSE:
!       Subroutine to concatenate multiple ACCoeff objects along the channel
!       dimension into a single ACCoeff object.
!
! CALLING SEQUENCE:
!       CALL ACCoeff_Concat( ACCoeff, AC_Array, Sensor_Id=Sensor_Id )
!
! OBJECTS:
!       ACCoeff:      ACCoeff object containing the concatenated result.
!                     UNITS:      N/A
!                     TYPE:       ACCoeff_type
!                     DIMENSION:  Scalar
!                     ATTRIBUTES: INTENT(OUT)
!
! INPUTS:
!       AC_Array:     Array of ACCoeff objects to be concatenated.
!                     UNITS:      N/A
!                     TYPE:       ACCoeff_type
!                     DIMENSION:  Rank-1
!                     ATTRIBUTES: INTENT(IN)
!
! OPTIONAL INPUTS:
!       Sensor_Id:    Sensor id character to string to use for the concatenated
!                     result. If not specified, the sensor id of the first valid
!                     element of AC_Array is used.
!                     UNITS:      N/A
!                     TYPE:       CHARACTER(*)
!                     DIMENSION:  Scalar
!                     ATTRIBUTES: INTENT(IN), OPTIONAL
!
!:sdoc-:
!--------------------------------------------------------------------------------

  SUBROUTINE accoeff_concat( &
    ACCoeff  , &  ! Output
    AC_Array , &  ! Input
    Sensor_Id  )  ! Optional input
    ! Arguments
    TYPE(accoeff_type)    , INTENT(OUT) :: accoeff
    TYPE(accoeff_type)    , INTENT(IN)  :: ac_array(:)
    CHARACTER(*), OPTIONAL, INTENT(IN)  :: sensor_id
    ! Local variables
    INTEGER, ALLOCATABLE :: valid_index(:)
    INTEGER :: i, j, n_ac, n_valid, n_channels
    INTEGER :: ch1, ch2
    
    ! Set up
    ! ...Check input is valid
    n_ac = SIZE(ac_array)
    IF ( n_ac < 1 ) RETURN
    ! ...Count valid input
    n_valid = count(accoeff_associated(ac_array))
    IF ( n_valid == 0 ) RETURN
    ! ...Index the valid input
    ALLOCATE( valid_index(n_valid) )
    valid_index = pack( (/(i,i=1,n_ac)/), mask=accoeff_associated(ac_array) )
    ! ...Check non-channel dimensions and ids
    DO j = 1, n_valid
      i = valid_index(j)
      IF ( ac_array(i)%n_FOVs           /= ac_array(valid_index(1))%n_FOVs           .OR. &
           ac_array(i)%WMO_Satellite_ID /= ac_array(valid_index(1))%WMO_Satellite_ID .OR. &
           ac_array(i)%WMO_Sensor_ID    /= ac_array(valid_index(1))%WMO_Sensor_ID         ) THEN
        RETURN
      END IF
    END DO


    ! Sum channel dimensions
    n_channels = sum(ac_array(valid_index)%n_Channels)
    

    ! Allocate the output concatenated ACCoeff object
    CALL accoeff_create( &
           accoeff, &
           ac_array(valid_index(1))%n_FOVs, &
           n_channels )
    IF ( .NOT. accoeff_associated(accoeff) ) RETURN


    ! Concatenate the channel data
    ! ...First assign the non-channel dependent data
    accoeff%Version = ac_array(valid_index(1))%Version
    IF ( PRESENT(sensor_id) ) THEN
      accoeff%Sensor_Id = adjustl(sensor_id)
    ELSE
      accoeff%Sensor_Id = ac_array(valid_index(1))%Sensor_Id
    END IF
    accoeff%WMO_Satellite_ID = ac_array(valid_index(1))%WMO_Satellite_ID
    accoeff%WMO_Sensor_ID    = ac_array(valid_index(1))%WMO_Sensor_ID   
    ! ...and now concatenate the channel data
    ch1 = 1
    DO j = 1, n_valid
      i = valid_index(j)
      
      ch2 = ch1 + ac_array(i)%n_Channels - 1
      
      accoeff%Sensor_Channel(ch1:ch2) = ac_array(i)%Sensor_Channel
      accoeff%A_earth(:,ch1:ch2)      = ac_array(i)%A_earth
      accoeff%A_space(:,ch1:ch2)      = ac_array(i)%A_space
      accoeff%A_platform(:,ch1:ch2)   = ac_array(i)%A_platform
      
      ch1 = ch2 + 1
    END DO


    ! Cleanup
    DEALLOCATE( valid_index )

  END SUBROUTINE accoeff_concat


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       ACCoeff_ChannelReindex
!
! PURPOSE:
!       Subroutine to re-index an ACCoeff object for a different complete
!       channel set.
!
! CALLING SEQUENCE:
!       CALL ACCoeff_ChannelReindex( ACCoeff, Sensor_Channels )
!
! OBJECTS:
!       ACCoeff:        ACCoeff object to have its channel information reindexed.
!                       UNITS:      N/A
!                       TYPE:       ACCoeff_type
!                       DIMENSION:  Scalar
!                       ATTRIBUTES: INTENT(IN OUT)
!
! INPUTS:
!       Sensor_Channel: Array of channel numbers for which the ACCoeff object 
!                       is to be re-indexed against.
!                       UNITS:      N/A
!                       TYPE:       INTEGER
!                       DIMENSION:  Rank-1
!                       ATTRIBUTES: INTENT(IN)
!
!:sdoc-:
!--------------------------------------------------------------------------------

  SUBROUTINE accoeff_channelreindex( &
    ACCoeff       , &  ! In/output
    Sensor_Channel  )  ! Input
    ! Arguments
    TYPE(accoeff_type), INTENT(IN OUT) :: accoeff
    INTEGER           , INTENT(IN)     :: sensor_channel(:)
    ! Local variables
    TYPE(accoeff_type) :: ac_copy
    INTEGER :: i, i_orig
    INTEGER :: n_channels
    
    ! Setup
    IF ( .NOT. accoeff_associated(accoeff) ) RETURN
    n_channels = SIZE(sensor_channel)
    IF ( n_channels < 1 ) RETURN
    
    
    ! Copy the input structure
    ac_copy = accoeff
    
    
    ! Allocate the reindexed ACCoeff object
    CALL accoeff_create( &
           accoeff       , &
           ac_copy%n_FOVs, &
           n_channels      )
    IF ( .NOT. accoeff_associated(accoeff) ) RETURN
    
    
    ! Fill the new structure
    ! ...Copy over the non-channel related information
    accoeff%Version              = ac_copy%Version
    accoeff%Sensor_Id            = ac_copy%Sensor_Id
    accoeff%WMO_Satellite_ID     = ac_copy%WMO_Satellite_ID
    accoeff%WMO_Sensor_ID        = ac_copy%WMO_Sensor_ID   
    ! ...Copy over the all-channel related information
    accoeff%Sensor_Channel = sensor_channel
    
    
    ! Perform the channel reindexing
    i_orig = 1
    DO i = 1, n_channels
      IF ( accoeff%Sensor_Channel(i) == ac_copy%Sensor_Channel(i_orig) ) THEN
        accoeff%A_earth(:,i)    = ac_copy%A_earth(:,i_orig)
        accoeff%A_space(:,i)    = ac_copy%A_space(:,i_orig)
        accoeff%A_platform(:,i) = ac_copy%A_platform(:,i_orig)
        i_orig = i_orig + 1
      END IF
    END DO

    
    ! Clean up
    CALL accoeff_destroy(ac_copy)
    
  END SUBROUTINE accoeff_channelreindex



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

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

    ! Set up
    is_equal = .false.
   
    ! Check the object association status
    IF ( (.NOT. accoeff_associated(x)) .OR. &
         (.NOT. accoeff_associated(y))      ) RETURN

    ! Check contents
    ! ...Release/version info
    IF ( (x%Release /= y%Release) .OR. &
         (x%Version /= y%Version) ) RETURN
    ! ...Dimensions
    IF ( (x%n_FOVs     /= y%n_FOVs     ) .OR. &
         (x%n_Channels /= y%n_Channels ) ) RETURN
    ! ...Scalars
    IF ( (x%Sensor_Id        /= y%Sensor_Id       ) .OR. &
         (x%WMO_Satellite_ID /= y%WMO_Satellite_ID) .OR. &
         (x%WMO_Sensor_ID    /= y%WMO_Sensor_ID   ) ) RETURN
    ! ...Arrays
    IF ( all(x%Sensor_Channel     ==    y%Sensor_Channel ) .AND. &
         all(x%A_earth        .equalto. y%A_earth        ) .AND. &
         all(x%A_space        .equalto. y%A_space        ) .AND. &
         all(x%A_platform     .equalto. y%A_platform     ) ) &
      is_equal = .true.

  END FUNCTION accoeff_equal

END MODULE accoeff_define