distributed_matrix_vector.f90

Go to the documentation of this file.

MODULE distributed_matrix_vector

  USE base_routines
  USE cmiss_mpi
  USE cmisspetsc
  USE comp_environment
  USE input_output
  USE iso_varying_string
  USE iso_c_binding
  USE kinds
  USE matrix_vector
#ifndef NOMPIMOD
  USE mpi
#endif
  USE strings
  USE types
  USE linkedlist_routines

#include "macros.h"

  IMPLICIT NONE

  PRIVATE

#ifdef NOMPIMOD
#include "mpif.h"
#endif
#include "petscversion.h"
  
  !Module parameters

  INTEGER(INTG), PARAMETER :: distributed_matrix_vector_cmiss_type=library_cmiss_type 
  INTEGER(INTG), PARAMETER :: distributed_matrix_vector_petsc_type=library_petsc_type 
  
  INTEGER(INTG), PARAMETER :: distributed_matrix_vector_intg_type=matrix_vector_intg_type 
  INTEGER(INTG), PARAMETER :: distributed_matrix_vector_sp_type=matrix_vector_sp_type 
  INTEGER(INTG), PARAMETER :: distributed_matrix_vector_dp_type=matrix_vector_dp_type 
  INTEGER(INTG), PARAMETER :: distributed_matrix_vector_l_type=matrix_vector_l_type 

  INTEGER(INTG), PARAMETER :: distributed_matrix_block_storage_type=matrix_block_storage_type 
  INTEGER(INTG), PARAMETER :: distributed_matrix_diagonal_storage_type=matrix_diagonal_storage_type 
  INTEGER(INTG), PARAMETER :: distributed_matrix_column_major_storage_type=matrix_column_major_storage_type 
  INTEGER(INTG), PARAMETER :: distributed_matrix_row_major_storage_type=matrix_row_major_storage_type 
  INTEGER(INTG), PARAMETER :: distributed_matrix_compressed_row_storage_type=matrix_compressed_row_storage_type 
  INTEGER(INTG), PARAMETER :: distributed_matrix_compressed_column_storage_type=matrix_compressed_column_storage_type 
  INTEGER(INTG), PARAMETER :: distributed_matrix_row_column_storage_type=matrix_row_column_storage_type 
  
  INTEGER(INTG), PARAMETER :: distributed_matrix_vector_include_ghosts_type=1
  INTEGER(INTG), PARAMETER :: distributed_matrix_vector_no_ghosts_type=2
  
  !Module types

  !Module variables

  INTEGER(INTG), SAVE :: distributed_data_id=100000000

  !Interfaces

  INTERFACE distributed_matrix_all_values_set
    MODULE PROCEDURE distributed_matrix_all_values_set_intg
    MODULE PROCEDURE distributed_matrix_all_values_set_sp
    MODULE PROCEDURE distributed_matrix_all_values_set_dp
    MODULE PROCEDURE distributed_matrix_all_values_set_l
  END INTERFACE distributed_matrix_all_values_set

  INTERFACE distributedmatrix_allvaluesset
    MODULE PROCEDURE distributed_matrix_all_values_set_intg
    MODULE PROCEDURE distributed_matrix_all_values_set_sp
    MODULE PROCEDURE distributed_matrix_all_values_set_dp
    MODULE PROCEDURE distributed_matrix_all_values_set_l
  END INTERFACE distributedmatrix_allvaluesset

  INTERFACE distributedmatrix_createfinish
    MODULE PROCEDURE distributed_matrix_create_finish
  END INTERFACE distributedmatrix_createfinish

  INTERFACE distributedmatrix_createstart
    MODULE PROCEDURE distributed_matrix_create_start
  END INTERFACE distributedmatrix_createstart

  INTERFACE distributed_matrix_data_get
    MODULE PROCEDURE distributed_matrix_data_get_intg
    MODULE PROCEDURE distributed_matrix_data_get_sp
    MODULE PROCEDURE distributed_matrix_data_get_dp
    MODULE PROCEDURE distributed_matrix_data_get_l
  END INTERFACE distributed_matrix_data_get

  INTERFACE distributedmatrix_dataget
    MODULE PROCEDURE distributed_matrix_data_get_intg
    MODULE PROCEDURE distributed_matrix_data_get_sp
    MODULE PROCEDURE distributed_matrix_data_get_dp
    MODULE PROCEDURE distributed_matrix_data_get_l
  END INTERFACE distributedmatrix_dataget

  INTERFACE distributed_matrix_data_restore
    MODULE PROCEDURE distributed_matrix_data_restore_intg
    MODULE PROCEDURE distributed_matrix_data_restore_sp
    MODULE PROCEDURE distributed_matrix_data_restore_dp
    MODULE PROCEDURE distributed_matrix_data_restore_l
  END INTERFACE distributed_matrix_data_restore

  INTERFACE distributedmatrix_datarestore
    MODULE PROCEDURE distributed_matrix_data_restore_intg
    MODULE PROCEDURE distributed_matrix_data_restore_sp
    MODULE PROCEDURE distributed_matrix_data_restore_dp
    MODULE PROCEDURE distributed_matrix_data_restore_l
  END INTERFACE distributedmatrix_datarestore

  INTERFACE distributedmatrix_datatypeset
    MODULE PROCEDURE distributed_matrix_data_type_set
  END INTERFACE distributedmatrix_datatypeset

  INTERFACE distributedmatrix_destroy
    MODULE PROCEDURE distributed_matrix_destroy
  END INTERFACE distributedmatrix_destroy

  INTERFACE distributedmatrix_duplicate
    MODULE PROCEDURE distributed_matrix_duplicate
  END INTERFACE distributedmatrix_duplicate

  INTERFACE distributedmatrix_form
    MODULE PROCEDURE distributed_matrix_form
  END INTERFACE distributedmatrix_form

  INTERFACE distributedmatrix_ghostingtypeset
    MODULE PROCEDURE distributed_matrix_ghosting_type_set
  END INTERFACE distributedmatrix_ghostingtypeset

  INTERFACE distributedmatrix_librarytypeset
    MODULE PROCEDURE distributed_matrix_library_type_set
  END INTERFACE distributedmatrix_librarytypeset

  INTERFACE distributedmatrix_maxcolumnsperrowget
    MODULE PROCEDURE distributed_matrix_max_columns_per_row_get
  END INTERFACE distributedmatrix_maxcolumnsperrowget

  INTERFACE distributedmatrix_numbernonzerosget
    MODULE PROCEDURE distributed_matrix_number_non_zeros_get
  END INTERFACE distributedmatrix_numbernonzerosget

  INTERFACE distributedmatrix_numbernonzerosset
    MODULE PROCEDURE distributed_matrix_number_non_zeros_set
  END INTERFACE distributedmatrix_numbernonzerosset

  INTERFACE distributedmatrix_output
    MODULE PROCEDURE distributed_matrix_output
  END INTERFACE distributedmatrix_output

  INTERFACE distributedmatrix_overrideseton
    MODULE PROCEDURE distributed_matrix_override_set_on
  END INTERFACE distributedmatrix_overrideseton

  INTERFACE distributedmatrix_overridesetoff
    MODULE PROCEDURE distributed_matrix_override_set_off
  END INTERFACE distributedmatrix_overridesetoff

  INTERFACE distributedmatrix_storagelocationsget
    MODULE PROCEDURE distributed_matrix_storage_locations_get
  END INTERFACE distributedmatrix_storagelocationsget

  INTERFACE distributedmatrix_storagelocationsset
    MODULE PROCEDURE distributed_matrix_storage_locations_set
  END INTERFACE distributedmatrix_storagelocationsset

  INTERFACE distributedmatrix_storagetypeget
    MODULE PROCEDURE distributed_matrix_storage_type_get
  END INTERFACE distributedmatrix_storagetypeget

  INTERFACE distributedmatrix_storagetypeset
    MODULE PROCEDURE distributed_matrix_storage_type_set
  END INTERFACE distributedmatrix_storagetypeset

  INTERFACE distributedmatrix_updatefinish
    MODULE PROCEDURE distributed_matrix_update_finish
  END INTERFACE distributedmatrix_updatefinish

  INTERFACE distributedmatrix_updatestart
    MODULE PROCEDURE distributed_matrix_update_start
  END INTERFACE distributedmatrix_updatestart

  INTERFACE distributedmatrix_updateisfinished
    MODULE PROCEDURE distributed_matrix_update_isfinished
  END INTERFACE distributedmatrix_updateisfinished

  INTERFACE distributedmatrix_updatewaitfinished
    MODULE PROCEDURE distributed_matrix_update_waitfinished
  END INTERFACE distributedmatrix_updatewaitfinished

  INTERFACE distributed_matrix_values_add
    MODULE PROCEDURE distributed_matrix_values_add_intg
    MODULE PROCEDURE distributed_matrix_values_add_intg1
    MODULE PROCEDURE distributed_matrix_values_add_intg2
    MODULE PROCEDURE distributed_matrix_values_add_sp
    MODULE PROCEDURE distributed_matrix_values_add_sp1
    MODULE PROCEDURE distributed_matrix_values_add_sp2
    MODULE PROCEDURE distributed_matrix_values_add_dp
    MODULE PROCEDURE distributed_matrix_values_add_dp1
    MODULE PROCEDURE distributed_matrix_values_add_dp2
    MODULE PROCEDURE distributed_matrix_values_add_l
    MODULE PROCEDURE distributed_matrix_values_add_l1
    MODULE PROCEDURE distributed_matrix_values_add_l2
  END INTERFACE 

  INTERFACE distributedmatrix_valuesadd
    MODULE PROCEDURE distributed_matrix_values_add_intg
    MODULE PROCEDURE distributed_matrix_values_add_intg1
    MODULE PROCEDURE distributed_matrix_values_add_intg2
    MODULE PROCEDURE distributed_matrix_values_add_sp
    MODULE PROCEDURE distributed_matrix_values_add_sp1
    MODULE PROCEDURE distributed_matrix_values_add_sp2
    MODULE PROCEDURE distributed_matrix_values_add_dp
    MODULE PROCEDURE distributed_matrix_values_add_dp1
    MODULE PROCEDURE distributed_matrix_values_add_dp2
    MODULE PROCEDURE distributed_matrix_values_add_l
    MODULE PROCEDURE distributed_matrix_values_add_l1
    MODULE PROCEDURE distributed_matrix_values_add_l2
  END INTERFACE distributedmatrix_valuesadd

  INTERFACE distributed_matrix_values_get
    MODULE PROCEDURE distributed_matrix_values_get_intg
    MODULE PROCEDURE distributed_matrix_values_get_intg1
    MODULE PROCEDURE distributed_matrix_values_get_intg2
    MODULE PROCEDURE distributed_matrix_values_get_sp
    MODULE PROCEDURE distributed_matrix_values_get_sp1
    MODULE PROCEDURE distributed_matrix_values_get_sp2
    MODULE PROCEDURE distributed_matrix_values_get_dp
    MODULE PROCEDURE distributed_matrix_values_get_dp1
    MODULE PROCEDURE distributed_matrix_values_get_dp2
    MODULE PROCEDURE distributed_matrix_values_get_l
    MODULE PROCEDURE distributed_matrix_values_get_l1
    MODULE PROCEDURE distributed_matrix_values_get_l2
  END INTERFACE distributed_matrix_values_get

  INTERFACE distributedmatrix_valuesget
    MODULE PROCEDURE distributed_matrix_values_get_intg
    MODULE PROCEDURE distributed_matrix_values_get_intg1
    MODULE PROCEDURE distributed_matrix_values_get_intg2
    MODULE PROCEDURE distributed_matrix_values_get_sp
    MODULE PROCEDURE distributed_matrix_values_get_sp1
    MODULE PROCEDURE distributed_matrix_values_get_sp2
    MODULE PROCEDURE distributed_matrix_values_get_dp
    MODULE PROCEDURE distributed_matrix_values_get_dp1
    MODULE PROCEDURE distributed_matrix_values_get_dp2
    MODULE PROCEDURE distributed_matrix_values_get_l
    MODULE PROCEDURE distributed_matrix_values_get_l1
    MODULE PROCEDURE distributed_matrix_values_get_l2
  END INTERFACE distributedmatrix_valuesget

  INTERFACE distributed_matrix_values_set
    MODULE PROCEDURE distributed_matrix_values_set_intg
    MODULE PROCEDURE distributed_matrix_values_set_intg1
    MODULE PROCEDURE distributed_matrix_values_set_intg2
    MODULE PROCEDURE distributed_matrix_values_set_sp
    MODULE PROCEDURE distributed_matrix_values_set_sp1
    MODULE PROCEDURE distributed_matrix_values_set_sp2
    MODULE PROCEDURE distributed_matrix_values_set_dp
    MODULE PROCEDURE distributed_matrix_values_set_dp1
    MODULE PROCEDURE distributed_matrix_values_set_dp2
    MODULE PROCEDURE distributed_matrix_values_set_l
    MODULE PROCEDURE distributed_matrix_values_set_l1
    MODULE PROCEDURE distributed_matrix_values_set_l2
  END INTERFACE distributed_matrix_values_set

  INTERFACE distributedmatrix_valuesset
    MODULE PROCEDURE distributed_matrix_values_set_intg
    MODULE PROCEDURE distributed_matrix_values_set_intg1
    MODULE PROCEDURE distributed_matrix_values_set_intg2
    MODULE PROCEDURE distributed_matrix_values_set_sp
    MODULE PROCEDURE distributed_matrix_values_set_sp1
    MODULE PROCEDURE distributed_matrix_values_set_sp2
    MODULE PROCEDURE distributed_matrix_values_set_dp
    MODULE PROCEDURE distributed_matrix_values_set_dp1
    MODULE PROCEDURE distributed_matrix_values_set_dp2
    MODULE PROCEDURE distributed_matrix_values_set_l
    MODULE PROCEDURE distributed_matrix_values_set_l1
    MODULE PROCEDURE distributed_matrix_values_set_l2
  END INTERFACE distributedmatrix_valuesset

  INTERFACE distributedmatrix_matrixbyvectoradd
    MODULE PROCEDURE distributed_matrix_by_vector_add
  END INTERFACE distributedmatrix_matrixbyvectoradd
  
  INTERFACE distributed_vector_all_values_set
    MODULE PROCEDURE distributed_vector_all_values_set_intg
    MODULE PROCEDURE distributed_vector_all_values_set_sp
    MODULE PROCEDURE distributed_vector_all_values_set_dp
    MODULE PROCEDURE distributed_vector_all_values_set_l
  END INTERFACE distributed_vector_all_values_set

  INTERFACE distributedvector_allvaluesset
    MODULE PROCEDURE distributed_vector_all_values_set_intg
    MODULE PROCEDURE distributed_vector_all_values_set_sp
    MODULE PROCEDURE distributed_vector_all_values_set_dp
    MODULE PROCEDURE distributed_vector_all_values_set_l
  END INTERFACE distributedvector_allvaluesset

  INTERFACE distributed_vector_copy
    MODULE PROCEDURE distributed_vector_copy_intg
    MODULE PROCEDURE distributed_vector_copy_sp
    MODULE PROCEDURE distributed_vector_copy_dp
    MODULE PROCEDURE distributed_vector_copy_l
  END INTERFACE distributed_vector_copy
  
  INTERFACE distributedvector_copy
    MODULE PROCEDURE distributed_vector_copy_intg
    MODULE PROCEDURE distributed_vector_copy_sp
    MODULE PROCEDURE distributed_vector_copy_dp
    MODULE PROCEDURE distributed_vector_copy_l
  END INTERFACE distributedvector_copy

  INTERFACE distributedvector_createfinish
    MODULE PROCEDURE distributed_vector_create_finish
  END INTERFACE distributedvector_createfinish

  INTERFACE distributedvector_createstart
    MODULE PROCEDURE distributed_vector_create_start
  END INTERFACE distributedvector_createstart
  
  INTERFACE distributed_vector_data_get
    MODULE PROCEDURE distributed_vector_data_get_intg
    MODULE PROCEDURE distributed_vector_data_get_sp
    MODULE PROCEDURE distributed_vector_data_get_dp
    MODULE PROCEDURE distributed_vector_data_get_l
  END INTERFACE distributed_vector_data_get

  INTERFACE distributedvector_dataget
    MODULE PROCEDURE distributed_vector_data_get_intg
    MODULE PROCEDURE distributed_vector_data_get_sp
    MODULE PROCEDURE distributed_vector_data_get_dp
    MODULE PROCEDURE distributed_vector_data_get_l
  END INTERFACE distributedvector_dataget

  INTERFACE distributed_vector_data_restore
    MODULE PROCEDURE distributed_vector_data_restore_intg
    MODULE PROCEDURE distributed_vector_data_restore_sp
    MODULE PROCEDURE distributed_vector_data_restore_dp
    MODULE PROCEDURE distributed_vector_data_restore_l
  END INTERFACE distributed_vector_data_restore

  INTERFACE distributedvector_datarestore
    MODULE PROCEDURE distributed_vector_data_restore_intg
    MODULE PROCEDURE distributed_vector_data_restore_sp
    MODULE PROCEDURE distributed_vector_data_restore_dp
    MODULE PROCEDURE distributed_vector_data_restore_l
  END INTERFACE distributedvector_datarestore

  INTERFACE distributedvector_destroy
    MODULE PROCEDURE distributed_vector_destroy
  END INTERFACE distributedvector_destroy

  INTERFACE distributedvector_duplicate
    MODULE PROCEDURE distributed_vector_duplicate
  END INTERFACE distributedvector_duplicate

  INTERFACE distributedvector_ghostingtypeset
    MODULE PROCEDURE distributed_vector_ghosting_type_set
  END INTERFACE distributedvector_ghostingtypeset

  INTERFACE distributedvector_librarytypeset
    MODULE PROCEDURE distributed_vector_library_type_set
  END INTERFACE distributedvector_librarytypeset

  INTERFACE distributedvector_output
    MODULE PROCEDURE distributed_vector_output
  END INTERFACE distributedvector_output

  INTERFACE distributedvector_overrideseton
    MODULE PROCEDURE distributed_vector_override_set_on
  END INTERFACE distributedvector_overrideseton

  INTERFACE distributedvector_overridesetoff
    MODULE PROCEDURE distributed_vector_override_set_off
  END INTERFACE distributedvector_overridesetoff

  INTERFACE distributedvector_updatefinish
    MODULE PROCEDURE distributed_vector_update_finish
  END INTERFACE distributedvector_updatefinish

  INTERFACE distributedvector_updatestart
    MODULE PROCEDURE distributed_vector_update_start
  END INTERFACE distributedvector_updatestart

  INTERFACE distributedvector_updateisfinished
    MODULE PROCEDURE distributed_vector_update_isfinished
  END INTERFACE distributedvector_updateisfinished

  INTERFACE distributedvector_updatewaitfinished
    MODULE PROCEDURE distributed_vector_update_waitfinished
  END INTERFACE distributedvector_updatewaitfinished

  INTERFACE distributed_vector_values_add
    MODULE PROCEDURE distributed_vector_values_add_intg
    MODULE PROCEDURE distributed_vector_values_add_intg1
    MODULE PROCEDURE distributed_vector_values_add_sp
    MODULE PROCEDURE distributed_vector_values_add_sp1
    MODULE PROCEDURE distributed_vector_values_add_dp
    MODULE PROCEDURE distributed_vector_values_add_dp1
    MODULE PROCEDURE distributed_vector_values_add_l
    MODULE PROCEDURE distributed_vector_values_add_l1
  END INTERFACE distributed_vector_values_add

  INTERFACE distributedvector_valuesadd
    MODULE PROCEDURE distributed_vector_values_add_intg
    MODULE PROCEDURE distributed_vector_values_add_intg1
    MODULE PROCEDURE distributed_vector_values_add_sp
    MODULE PROCEDURE distributed_vector_values_add_sp1
    MODULE PROCEDURE distributed_vector_values_add_dp
    MODULE PROCEDURE distributed_vector_values_add_dp1
    MODULE PROCEDURE distributed_vector_values_add_l
    MODULE PROCEDURE distributed_vector_values_add_l1
  END INTERFACE distributedvector_valuesadd

  INTERFACE distributed_vector_values_get
    MODULE PROCEDURE distributed_vector_values_get_intg
    MODULE PROCEDURE distributed_vector_values_get_intg1
    MODULE PROCEDURE distributed_vector_values_get_sp
    MODULE PROCEDURE distributed_vector_values_get_sp1
    MODULE PROCEDURE distributed_vector_values_get_dp
    MODULE PROCEDURE distributed_vector_values_get_dp1
    MODULE PROCEDURE distributed_vector_values_get_l
    MODULE PROCEDURE distributed_vector_values_get_l1
  END INTERFACE distributed_vector_values_get

  INTERFACE distributedvector_valuesget
    MODULE PROCEDURE distributed_vector_values_get_intg
    MODULE PROCEDURE distributed_vector_values_get_intg1
    MODULE PROCEDURE distributed_vector_values_get_sp
    MODULE PROCEDURE distributed_vector_values_get_sp1
    MODULE PROCEDURE distributed_vector_values_get_dp
    MODULE PROCEDURE distributed_vector_values_get_dp1
    MODULE PROCEDURE distributed_vector_values_get_l
    MODULE PROCEDURE distributed_vector_values_get_l1
  END INTERFACE distributedvector_valuesget

  INTERFACE distributed_vector_values_set
    MODULE PROCEDURE distributed_vector_values_set_intg
    MODULE PROCEDURE distributed_vector_values_set_intg1
    MODULE PROCEDURE distributed_vector_values_set_sp
    MODULE PROCEDURE distributed_vector_values_set_sp1
    MODULE PROCEDURE distributed_vector_values_set_dp
    MODULE PROCEDURE distributed_vector_values_set_dp1
    MODULE PROCEDURE distributed_vector_values_set_l
    MODULE PROCEDURE distributed_vector_values_set_l1
  END INTERFACE distributed_vector_values_set

  INTERFACE distributedvector_valuesset
    MODULE PROCEDURE distributed_vector_values_set_intg
    MODULE PROCEDURE distributed_vector_values_set_intg1
    MODULE PROCEDURE distributed_vector_values_set_sp
    MODULE PROCEDURE distributed_vector_values_set_sp1
    MODULE PROCEDURE distributed_vector_values_set_dp
    MODULE PROCEDURE distributed_vector_values_set_dp1
    MODULE PROCEDURE distributed_vector_values_set_l
    MODULE PROCEDURE distributed_vector_values_set_l1
  END INTERFACE distributedvector_valuesset

  INTERFACE distributedvector_vecdot
    MODULE PROCEDURE distributedvector_vecdotintg
    MODULE PROCEDURE distributedvector_vecdotsp
    MODULE PROCEDURE distributedvector_vecdotdp
  END INTERFACE distributedvector_vecdot

  PUBLIC distributed_matrix_vector_cmiss_type,distributed_matrix_vector_petsc_type

  PUBLIC distributed_matrix_vector_intg_type,distributed_matrix_vector_sp_type,distributed_matrix_vector_dp_type, &
    & distributed_matrix_vector_l_type

  PUBLIC distributed_matrix_block_storage_type,distributed_matrix_diagonal_storage_type, &
    & distributed_matrix_column_major_storage_type,distributed_matrix_row_major_storage_type, &
    & distributed_matrix_compressed_row_storage_type,distributed_matrix_compressed_column_storage_type, &
    & distributed_matrix_row_column_storage_type

  PUBLIC distributed_matrix_vector_include_ghosts_type,distributed_matrix_vector_no_ghosts_type
  
  PUBLIC distributed_matrix_all_values_set

  PUBLIC distributedmatrix_allvaluesset

  PUBLIC distributed_matrix_create_finish,distributed_matrix_create_start

  PUBLIC distributedmatrix_createfinish,distributedmatrix_createstart

  PUBLIC distributed_matrix_data_get,distributed_matrix_data_restore

  PUBLIC distributedmatrix_dataget,distributedmatrix_datarestore

  PUBLIC distributed_matrix_data_type_set

  PUBLIC distributedmatrix_datatypeget,distributedmatrix_datatypeset

  PUBLIC distributedmatrix_dimensionsget

  PUBLIC distributed_matrix_destroy

  PUBLIC distributedmatrix_destroy

  PUBLIC distributed_matrix_duplicate

  PUBLIC distributedmatrix_duplicate

  PUBLIC distributed_matrix_form

  PUBLIC distributedmatrix_form

  PUBLIC distributed_matrix_ghosting_type_set

  PUBLIC distributedmatrix_ghostingtypeset

  PUBLIC distributed_matrix_library_type_set

  PUBLIC distributedmatrix_librarytypeset

  PUBLIC distributed_matrix_linklist_set,distributed_matrix_linklist_get

  PUBLIC distributed_matrix_max_columns_per_row_get

  PUBLIC distributedmatrix_maxcolumnsperrowget

  PUBLIC distributed_matrix_number_non_zeros_set,distributed_matrix_number_non_zeros_get

  PUBLIC distributedmatrix_numbernonzerosget,distributedmatrix_numbernonzerosset

  PUBLIC distributed_matrix_output

  PUBLIC distributedmatrix_output

  PUBLIC distributed_matrix_override_set_on,distributed_matrix_override_set_off

  PUBLIC distributedmatrix_overrideseton,distributedmatrix_overridesetoff

  PUBLIC distributed_matrix_storage_locations_get,distributed_matrix_storage_locations_set

  PUBLIC distributedmatrix_storagelocationsget,distributedmatrix_storagelocationsset

  PUBLIC distributed_matrix_storage_type_get,distributed_matrix_storage_type_set

  PUBLIC distributedmatrix_storagetypeget,distributedmatrix_storagetypeset

  PUBLIC distributed_matrix_update_start,distributed_matrix_update_finish

  PUBLIC distributedmatrix_updatefinish,distributedmatrix_updatestart

  PUBLIC distributed_matrix_update_isfinished,distributed_matrix_update_waitfinished

  PUBLIC distributedmatrix_updateisfinished,distributedmatrix_updatewaitfinished

  PUBLIC distributed_matrix_values_add

  PUBLIC distributedmatrix_valuesadd

  PUBLIC distributed_matrix_values_get,distributed_matrix_values_set

  PUBLIC distributedmatrix_valuesget,distributedmatrix_valuesset

  PUBLIC distributed_matrix_by_vector_add

  PUBLIC distributedmatrix_matrixbyvectoradd
  
  PUBLIC distributed_vector_all_values_set

  PUBLIC distributedvector_allvaluesset

  PUBLIC distributed_vector_copy

  PUBLIC distributedvector_copy

  PUBLIC distributed_vector_create_finish,distributed_vector_create_start

  PUBLIC distributedvector_createfinish,distributedvector_createstart

  PUBLIC distributed_vector_data_get,distributed_vector_data_restore

  PUBLIC distributedvector_dataget,distributedvector_datarestore

  PUBLIC distributed_vector_data_type_set

  PUBLIC distributedvector_datatypeget

  PUBLIC distributed_vector_destroy

  PUBLIC distributedvector_destroy

  PUBLIC distributed_vector_duplicate

  PUBLIC distributedvector_duplicate

  PUBLIC distributed_vector_ghosting_type_set

  PUBLIC distributedvector_ghostingtypeset

  PUBLIC distributed_vector_library_type_set

  PUBLIC distributedvector_librarytypeset

  PUBLIC distributedvector_l2norm

  PUBLIC distributed_vector_output

  PUBLIC distributedvector_output

  PUBLIC distributed_vector_override_set_on,distributed_vector_override_set_off

  PUBLIC distributedvector_overrideseton,distributedvector_overridesetoff

  PUBLIC distributed_vector_update_start,distributed_vector_update_finish

  PUBLIC distributedvector_updatefinish,distributedvector_updatestart

  PUBLIC distributed_vector_update_isfinished,distributed_vector_update_waitfinished

  PUBLIC distributedvector_updateisfinished,distributedvector_updatewaitfinished
  
  PUBLIC distributed_vector_values_add

  PUBLIC distributedvector_valuesadd

  PUBLIC distributedvector_vecdot

  PUBLIC distributed_vector_values_get,distributed_vector_values_set

  PUBLIC distributedvector_valuesget,distributedvector_valuesset

CONTAINS  
  
  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_all_values_set_intg(DISTRIBUTED_MATRIX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_ALL_VALUES_SET_INTG",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_all_values_set(distributed_matrix%CMISS%MATRIX,VALUE,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot set all values for an integer PETSc distributed matrix.",err,error,*999)
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF

    exits("DISTRIBUTED_MATRIX_ALL_VALUES_SET_INTG")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_ALL_VALUES_SET_INTG",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_all_values_set_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_all_values_set_sp(DISTRIBUTED_MATRIX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    REAL(SP), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_ALL_VALUES_SET_SP",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_all_values_set(distributed_matrix%CMISS%MATRIX,VALUE,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot set all values for a single precision PETSc distributed matrix.",err,error,*999)
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF

    exits("DISTRIBUTED_MATRIX_ALL_VALUES_SET_SP")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_ALL_VALUES_SET_SP",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_all_values_set_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_all_values_set_dp(DISTRIBUTED_MATRIX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    REAL(DP), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_ALL_VALUES_SET_DP",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_all_values_set(distributed_matrix%CMISS%MATRIX,VALUE,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix cmiss is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            IF(abs(VALUE)<=zero_tolerance) THEN
              IF(distributed_matrix%PETSC%USE_OVERRIDE_MATRIX) THEN
                CALL petsc_matzeroentries(distributed_matrix%PETSC%OVERRIDE_MATRIX,err,error,*999)
              ELSE
                CALL petsc_matzeroentries(distributed_matrix%PETSC%MATRIX,err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Not implemented.",err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed matrix petsc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF

    exits("DISTRIBUTED_MATRIX_ALL_VALUES_SET_DP")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_ALL_VALUES_SET_DP",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_all_values_set_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_all_values_set_l(DISTRIBUTED_MATRIX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    LOGICAL, INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_ALL_VALUES_SET_L",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_all_values_set(distributed_matrix%CMISS%MATRIX,VALUE,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot set all values for a logical PETSc distributed matrix.",err,error,*999)
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF

    exits("DISTRIBUTED_MATRIX_ALL_VALUES_SET_L")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_ALL_VALUES_SET_L",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_all_values_set_l

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_cmiss_create_finish(CMISS_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_cmiss_type), POINTER :: CMISS_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(domain_mapping_type), POINTER :: DOMAIN_MAPPING
    INTEGER(INTG) :: DUMMY_ERR
    TYPE(varying_string) :: DUMMY_ERROR
    
    enters("DISTRIBUTED_MATRIX_CMISS_CREATE_FINISH",err,error,*998)

    IF(ASSOCIATED(cmiss_matrix)) THEN
      cmiss_matrix%BASE_TAG_NUMBER=distributed_data_id
      domain_mapping=>cmiss_matrix%DISTRIBUTED_MATRIX%ROW_DOMAIN_MAPPING
      IF(ASSOCIATED(domain_mapping)) THEN
        IF(domain_mapping%NUMBER_OF_DOMAINS==1) THEN
          distributed_data_id=distributed_data_id+1
        ELSE
          distributed_data_id=distributed_data_id+ &
            & domain_mapping%ADJACENT_DOMAINS_PTR(domain_mapping%NUMBER_OF_DOMAINS)
        END IF
        CALL matrix_create_finish(cmiss_matrix%MATRIX,err,error,*999)
      ELSE
        CALL flagerror("Distributed matrix row domain mapping is not associated.",err,error,*998)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_CMISS_CREATE_FINISH")
    RETURN
999 CALL distributed_matrix_cmiss_finalise(cmiss_matrix,dummy_err,dummy_error,*998)
998 errorsexits("DISTRIBUTED_MATRIX_CMISS_CREATE_FINISH",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_cmiss_create_finish

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_cmiss_finalise(CMISS_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_cmiss_type), POINTER :: CMISS_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    
    enters("DISTRIBUTED_MATRIX_CMISS_FINALISE",err,error,*999)

    IF(ASSOCIATED(cmiss_matrix)) THEN
      CALL matrix_destroy(cmiss_matrix%MATRIX,err,error,*999)
      DEALLOCATE(cmiss_matrix)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_CMISS_FINALSE")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_CMISS_FINALISE",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_cmiss_finalise

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_cmiss_initialise(DISTRIBUTED_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: DUMMY_ERR
    TYPE(domain_mapping_type), POINTER :: ROW_DOMAIN_MAPPING,COLUMN_DOMAIN_MAPPING
    TYPE(varying_string) :: DUMMY_ERROR,LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_CMISS_INITIALISE",err,error,*998)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
        CALL flagerror("CMISS is already associated for this distributed matrix.",err,error,*998)
      ELSE
        row_domain_mapping=>distributed_matrix%ROW_DOMAIN_MAPPING
        column_domain_mapping=>distributed_matrix%COLUMN_DOMAIN_MAPPING
        IF(ASSOCIATED(row_domain_mapping)) THEN
          IF(ASSOCIATED(column_domain_mapping)) THEN
            ALLOCATE(distributed_matrix%CMISS,stat=err)
            IF(err/=0) CALL flagerror("Could not allocate CMISS distributed matrix.",err,error,*999)
            distributed_matrix%CMISS%DISTRIBUTED_MATRIX=>distributed_matrix
            distributed_matrix%LIBRARY_TYPE=distributed_matrix_vector_cmiss_type
            NULLIFY(distributed_matrix%CMISS%MATRIX)
            !Set the defaults
            CALL matrix_create_start(distributed_matrix%CMISS%MATRIX,err,error,*999)
            CALL matrix_data_type_set(distributed_matrix%CMISS%MATRIX,matrix_vector_dp_type,err,error,*999)
            CALL matrix_storage_type_set(distributed_matrix%CMISS%MATRIX,matrix_block_storage_type,err,error,*999)
            SELECT CASE(distributed_matrix%GHOSTING_TYPE)
            CASE(distributed_matrix_vector_include_ghosts_type)
              CALL matrix_size_set(distributed_matrix%CMISS%MATRIX,row_domain_mapping%TOTAL_NUMBER_OF_LOCAL, &
                & column_domain_mapping%NUMBER_OF_GLOBAL,err,error,*999)
            CASE(distributed_matrix_vector_no_ghosts_type)
              CALL matrix_size_set(distributed_matrix%CMISS%MATRIX,row_domain_mapping%NUMBER_OF_LOCAL, &
                & column_domain_mapping%NUMBER_OF_GLOBAL,err,error,*999)
            CASE DEFAULT
              local_error="The distributed matrix ghosting type of "// &
                & trim(numbertovstring(distributed_matrix%GHOSTING_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            CALL flagerror("Distributed matrix column domain mapping is not associated.",err,error,*998)
          ENDIF
        ELSE
          CALL flagerror("Distributed matrix row domain mapping is not associated.",err,error,*998)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_CMISS_INITIALSE")
    RETURN
999 IF(ASSOCIATED(distributed_matrix%CMISS)) &
      & CALL distributed_matrix_cmiss_finalise(distributed_matrix%CMISS,dummy_err,dummy_error,*999)
998 errorsexits("DISTRIBUTED_MATRIX_CMISS_INITIALISE",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_cmiss_initialise

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_create_finish(DISTRIBUTED_MATRIX,ERR,ERROR,*)

    !Argument variables 
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: DUMMY_ERR
    TYPE(varying_string) :: DUMMY_ERROR,LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_CREATE_FINISH",err,error,*998)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        CALL flagerror("The distributed matrix has been finished.",err,error,*998)
      ELSE
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          CALL distributed_matrix_cmiss_create_finish(distributed_matrix%CMISS,err,error,*999)
        CASE(distributed_matrix_vector_petsc_type)
          CALL distributed_matrix_petsc_create_finish(distributed_matrix%PETSC,err,error,*999)
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT        
        distributed_matrix%MATRIX_FINISHED=.true.
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_CREATE_FINISH")
    RETURN
999 CALL distributed_matrix_finalise(distributed_matrix,dummy_err,dummy_error,*998)
998 errorsexits("DISTRIBUTED_MATRIX_CREATE_FINISH",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_create_finish

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_create_start(ROW_DOMAIN_MAPPING,COLUMN_DOMAIN_MAPPING,DISTRIBUTED_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(domain_mapping_type), POINTER :: ROW_DOMAIN_MAPPING
    TYPE(domain_mapping_type), POINTER :: COLUMN_DOMAIN_MAPPING
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: DUMMY_ERR
    TYPE(varying_string) :: DUMMY_ERROR,LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_CREATE_START",err,error,*998)

    IF(ASSOCIATED(row_domain_mapping)) THEN
      IF(ASSOCIATED(column_domain_mapping)) THEN
        IF(ASSOCIATED(distributed_matrix)) THEN
          CALL flagerror("Distributed matrix is already associated.",err,error,*998)
        ELSE
          IF(row_domain_mapping%NUMBER_OF_DOMAINS==column_domain_mapping%NUMBER_OF_DOMAINS) THEN
            CALL distributed_matrix_initialise(row_domain_mapping,column_domain_mapping,distributed_matrix,err,error,*999)
            !Set the defaults
          ELSE
            local_error="The number of domains in the row domain mapping ("// &
              & trim(numbertovstring(row_domain_mapping%NUMBER_OF_DOMAINS,"*",err,error))// &
              & ") does not match the number of domains in the column domain mapping ("// &
              & trim(numbertovstring(column_domain_mapping%NUMBER_OF_DOMAINS,"*",err,error))//")."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ENDIF
      ELSE
        CALL flagerror("Column domain mapping is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Row domain mapping is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_CREATE_START")
    RETURN
999 CALL distributed_matrix_finalise(distributed_matrix,dummy_err,dummy_error,*998)
998 errorsexits("DISTRIBUTED_MATRIX_CREATE_START",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_create_start

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_data_get_intg(DISTRIBUTED_MATRIX,DATA,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), POINTER :: DATA(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_DATA_GET_INTG",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(ASSOCIATED(data)) THEN
        CALL flagerror("Data is already associated",err,error,*999)
      ELSE
        NULLIFY(data)
        IF(distributed_matrix%MATRIX_FINISHED) THEN
          SELECT CASE(distributed_matrix%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
              CALL matrix_data_get(distributed_matrix%CMISS%MATRIX,DATA,err,error,*999)
            ELSE
              CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot get data for an integer PETSc distributed matrix.",err,error,*999)
          CASE DEFAULT
            local_error="The distributed matrix library type of "// &
              & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_DATA_GET_INTG")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_DATA_GET_INTG",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_data_get_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_data_get_sp(DISTRIBUTED_MATRIX,DATA,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    REAL(SP), POINTER :: DATA(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_DATA_GET_SP",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(ASSOCIATED(data)) THEN
        CALL flagerror("Data is already associated.",err,error,*999)
      ELSE
        NULLIFY(data)
        IF(distributed_matrix%MATRIX_FINISHED) THEN
          SELECT CASE(distributed_matrix%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
              CALL matrix_data_get(distributed_matrix%CMISS%MATRIX,DATA,err,error,*999)
            ELSE
              CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot get data for a single precision PETSc distributed matrix.",err,error,*999)
          CASE DEFAULT
            local_error="The distributed matrix library type of "// &
              & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_DATA_GET_SP")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_DATA_GET_SP",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_data_get_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_data_get_dp(DISTRIBUTED_MATRIX,DATA,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    REAL(DP), POINTER :: DATA(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    REAL(DP), POINTER :: petscData(:,:)
    TYPE(varying_string) :: LOCAL_ERROR
    TYPE(c_ptr) :: TEMP_ME

    enters("DISTRIBUTED_MATRIX_DATA_GET_DP",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(ASSOCIATED(data)) THEN
        CALL flagerror("Data is already associated.",err,error,*999)
      ELSE
        NULLIFY(data)
        IF(distributed_matrix%MATRIX_FINISHED) THEN
          SELECT CASE(distributed_matrix%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
              CALL matrix_data_get(distributed_matrix%CMISS%MATRIX,DATA,err,error,*999)
            ELSE
              CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
              IF(distributed_matrix%PETSC%USE_OVERRIDE_MATRIX) THEN
                SELECT CASE(distributed_matrix%PETSC%STORAGE_TYPE)
                CASE(distributed_matrix_block_storage_type)
                  CALL petsc_matdensegetarrayf90(distributed_matrix%petsc%OVERRIDE_MATRIX,petscdata,err,error,*999)
                CASE(distributed_matrix_diagonal_storage_type)
                  CALL flagerror("Diagonal storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_column_major_storage_type)
                  CALL flagerror("Column major storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_row_major_storage_type)
                  CALL flagerror("Row major storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_compressed_row_storage_type)
                  CALL petsc_matseqaijgetarrayf90(distributed_matrix%petsc%OVERRIDE_MATRIX,petscdata,err,error,*999)
                CASE(distributed_matrix_compressed_column_storage_type)
                  CALL flagerror("Compressed column storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_row_column_storage_type)
                  CALL flagerror("Row column storage is not implemented for PETSc matrices.",err,error,*999)
                CASE DEFAULT
                  local_error="The PETSc matrix storage type of "//trim(numbertovstring( &
                    & distributed_matrix%PETSC%STORAGE_TYPE,"*",err,error))//" is invalid."
                  CALL flagerror(local_error,err,error,*999)
                END SELECT
              ELSE
                SELECT CASE(distributed_matrix%PETSC%STORAGE_TYPE)
                CASE(distributed_matrix_block_storage_type)
                  CALL petsc_matdensegetarrayf90(distributed_matrix%petsc%matrix,petscdata,err,error,*999)
                CASE(distributed_matrix_diagonal_storage_type)
                  CALL flagerror("Diagonal storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_column_major_storage_type)
                  CALL flagerror("Column major storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_row_major_storage_type)
                  CALL flagerror("Row major storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_compressed_row_storage_type)
                  CALL petsc_matseqaijgetarrayf90(distributed_matrix%petsc%matrix,petscdata,err,error,*999)
                CASE(distributed_matrix_compressed_column_storage_type)
                  CALL flagerror("Compressed column storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_row_column_storage_type)
                  CALL flagerror("Row column storage is not implemented for PETSc matrices.",err,error,*999)
                CASE DEFAULT
                  local_error="The PETSc matrix storage type of "//trim(numbertovstring( &
                    & distributed_matrix%PETSC%STORAGE_TYPE,"*",err,error))//" is invalid."
                  CALL flagerror(local_error,err,error,*999)
                END SELECT
              ENDIF
              ! Convert 2D array from PETSc to 1D array
              ! Using C_F_POINTER(C_LOC(... is a bit ugly but transfer doesn't work with pointers
              SELECT CASE(distributed_matrix%PETSC%STORAGE_TYPE)
              CASE(distributed_matrix_block_storage_type)
                temp_me = c_loc(petscdata(1,1))
                CALL c_f_pointer(temp_me,DATA,[distributed_matrix%PETSC%M*distributed_matrix%PETSC%N])
              CASE(distributed_matrix_diagonal_storage_type)
                CALL flagerror("Diagonal storage is not implemented for PETSc matrices.",err,error,*999)
              CASE(distributed_matrix_column_major_storage_type)
                CALL flagerror("Column major storage is not implemented for PETSc matrices.",err,error,*999)
              CASE(distributed_matrix_row_major_storage_type)
                CALL flagerror("Row major storage is not implemented for PETSc matrices.",err,error,*999)
              CASE(distributed_matrix_compressed_row_storage_type)
                !PETSc returns an m * n matrix rather than number non-zeros by 1, so the returned
                !2D array actually contains junk data outside of the actual matrix.
                !This is a bug in PETSc but we can get the correct 1D data here
                temp_me = c_loc(petscdata(1,1))
                CALL c_f_pointer(temp_me,DATA,[distributed_matrix%PETSC%NUMBER_NON_ZEROS])
              CASE(distributed_matrix_compressed_column_storage_type)
                CALL flagerror("Compressed column storage is not implemented for PETSc matrices.",err,error,*999)
              CASE(distributed_matrix_row_column_storage_type)
                CALL flagerror("Row column storage is not implemented for PETSc matrices.",err,error,*999)
              CASE DEFAULT
                local_error="The PETSc matrix storage type of "//trim(numbertovstring( &
                  & distributed_matrix%PETSC%STORAGE_TYPE,"*",err,error))//" is invalid."
                CALL flagerror(local_error,err,error,*999)
              END SELECT
            ELSE
              CALL flagerror("Distributed matris PETSc is not associated.",err,error,*999)
            ENDIF
          CASE DEFAULT
            local_error="The distributed matrix library type of "// &
              & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_DATA_GET_DP")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_DATA_GET_DP",err,error)
    RETURN 1
    
  END SUBROUTINE distributed_matrix_data_get_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_data_get_l(DISTRIBUTED_MATRIX,DATA,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    LOGICAL, POINTER :: DATA(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
 
    enters("DISTRIBUTED_MATRIX_DATA_GET_L",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(ASSOCIATED(data)) THEN
        CALL flagerror("Data is already associated",err,error,*999)
      ELSE
        NULLIFY(data)
        IF(distributed_matrix%MATRIX_FINISHED) THEN
          SELECT CASE(distributed_matrix%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
              CALL matrix_data_get(distributed_matrix%CMISS%MATRIX,DATA,err,error,*999)
            ELSE
              CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot get data for a logical PETSc distributed matrix.",err,error,*999)
          CASE DEFAULT
            local_error="The distributed matrix library type of "// &
              & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_DATA_GET_L")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_DATA_GET_L",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_data_get_l

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_data_restore_intg(DISTRIBUTED_MATRIX,DATA,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), POINTER :: DATA(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_DATA_RESTORE_INTG",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(ASSOCIATED(data)) THEN
        IF(distributed_matrix%MATRIX_FINISHED) THEN
          SELECT CASE(distributed_matrix%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            NULLIFY(data)              
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot restore data for an integer PETSc distributed matrix.",err,error,*999)
          CASE DEFAULT
            local_error="The distributed matrix library type of "// &
              & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("Data is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_DATA_RESTORE_INTG")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_DATA_RESTORE_INTG",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_data_restore_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_data_restore_sp(DISTRIBUTED_MATRIX,DATA,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    REAL(SP), POINTER :: DATA(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_DATA_RESTORE_SP",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(ASSOCIATED(data)) THEN
        IF(distributed_matrix%MATRIX_FINISHED) THEN
          SELECT CASE(distributed_matrix%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            NULLIFY(data)
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot restore data for a single precision PETSc distributed matrix.",err,error,*999)
          CASE DEFAULT
            local_error="The distributed matrix library type of "// &
              & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("Data is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_DATA_RESTORE_SP")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_DATA_RESTORE_SP",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_data_restore_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_data_restore_dp(DISTRIBUTED_MATRIX,DATA,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    REAL(DP), POINTER :: DATA(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    REAL(DP), POINTER :: petscData(:,:)
    TYPE(varying_string) :: LOCAL_ERROR
    TYPE(c_ptr) :: TEMP_ME
    
    enters("DISTRIBUTED_MATRIX_DATA_RESTORE_DP",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(ASSOCIATED(data)) THEN
        IF(distributed_matrix%MATRIX_FINISHED) THEN
          SELECT CASE(distributed_matrix%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            NULLIFY(data)
          CASE(distributed_matrix_vector_petsc_type)
            IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
              SELECT CASE(distributed_matrix%PETSC%STORAGE_TYPE)
              CASE(distributed_matrix_block_storage_type)
                !Convert 1D array to 2D
                temp_me = c_loc(DATA(1))
                CALL c_f_pointer(temp_me,petscdata,[distributed_matrix%PETSC%M,distributed_matrix%PETSC%N])
              CASE(distributed_matrix_diagonal_storage_type)
                CALL flagerror("Diagonal storage is not implemented for PETSc matrices.",err,error,*999)
              CASE(distributed_matrix_column_major_storage_type)
                CALL flagerror("Column major storage is not implemented for PETSc matrices.",err,error,*999)
              CASE(distributed_matrix_row_major_storage_type)
                CALL flagerror("Row major storage is not implemented for PETSc matrices.",err,error,*999)
              CASE(distributed_matrix_compressed_row_storage_type)
                !PETSc expects an m * n 2D matrix rather than a 1D array with length equal to number of non-zeros
                !This is a bug in PETSc so we have to give it a 2D matrix with junk at the end
                temp_me = c_loc(DATA(1))
                CALL c_f_pointer(temp_me,petscdata,[distributed_matrix%PETSC%M,distributed_matrix%PETSC%N])
              CASE(distributed_matrix_compressed_column_storage_type)
                CALL flagerror("Compressed column storage is not implemented for PETSc matrices.",err,error,*999)
              CASE(distributed_matrix_row_column_storage_type)
                CALL flagerror("Row column storage is not implemented for PETSc matrices.",err,error,*999)
              CASE DEFAULT
                local_error="The PETSc matrix storage type of "//trim(numbertovstring( &
                  & distributed_matrix%PETSC%STORAGE_TYPE,"*",err,error))//" is invalid."
                CALL flagerror(local_error,err,error,*999)
              END SELECT
              IF(distributed_matrix%PETSC%USE_OVERRIDE_MATRIX) THEN
                SELECT CASE(distributed_matrix%PETSC%STORAGE_TYPE)
                CASE(distributed_matrix_block_storage_type)
                  CALL petsc_matdenserestorearrayf90(distributed_matrix%PETSC%OVERRIDE_MATRIX,petscdata,err,error,*999)
                CASE(distributed_matrix_diagonal_storage_type)
                  CALL flagerror("Diagonal storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_column_major_storage_type)
                  CALL flagerror("Column major storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_row_major_storage_type)
                  CALL flagerror("Row major storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_compressed_row_storage_type)
                  CALL petsc_matseqaijrestorearrayf90(distributed_matrix%PETSC%OVERRIDE_MATRIX,petscdata,err,error,*999)
                CASE(distributed_matrix_compressed_column_storage_type)
                  CALL flagerror("Compressed column storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_row_column_storage_type)
                  CALL flagerror("Row column storage is not implemented for PETSc matrices.",err,error,*999)
                CASE DEFAULT
                  local_error="The PETSc matrix storage type of "//trim(numbertovstring( &
                    & distributed_matrix%PETSC%STORAGE_TYPE,"*",err,error))//" is invalid."
                  CALL flagerror(local_error,err,error,*999)
                END SELECT
              ELSE
                SELECT CASE(distributed_matrix%PETSC%STORAGE_TYPE)
                CASE(distributed_matrix_block_storage_type)
                  CALL petsc_matdenserestorearrayf90(distributed_matrix%PETSC%MATRIX,petscdata,err,error,*999)
                CASE(distributed_matrix_diagonal_storage_type)
                  CALL flagerror("Diagonal storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_column_major_storage_type)
                  CALL flagerror("Column major storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_row_major_storage_type)
                  CALL flagerror("Row major storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_compressed_row_storage_type)
                  CALL petsc_matseqaijrestorearrayf90(distributed_matrix%PETSC%MATRIX,petscdata,err,error,*999)
                CASE(distributed_matrix_compressed_column_storage_type)
                  CALL flagerror("Compressed column storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_row_column_storage_type)
                  CALL flagerror("Row column storage is not implemented for PETSc matrices.",err,error,*999)
                CASE DEFAULT
                  local_error="The PETSc matrix storage type of "//trim(numbertovstring( &
                    & distributed_matrix%PETSC%STORAGE_TYPE,"*",err,error))//" is invalid."
                  CALL flagerror(local_error,err,error,*999)
                END SELECT
              ENDIF
            ELSE
              CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
            ENDIF
          CASE DEFAULT
            local_error="The distributed matrix library type of "// &
              & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("Data is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_DATA_RESTORE_DP")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_DATA_RESTORE_DP",err,error)
    RETURN 1
    
  END SUBROUTINE distributed_matrix_data_restore_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_data_restore_l(DISTRIBUTED_MATRIX,DATA,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    LOGICAL, POINTER :: DATA(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
 
    enters("DISTRIBUTED_MATRIX_DATA_RESTORE_L",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(ASSOCIATED(data)) THEN
        IF(distributed_matrix%MATRIX_FINISHED) THEN
          SELECT CASE(distributed_matrix%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            NULLIFY(data)
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot restore data for a logical PETSc distributed matrix.",err,error,*999)
          CASE DEFAULT
            local_error="The distributed matrix library type of "// &
              & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("Data is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_DATA_RESTORE_L")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_DATA_RESTORE_L",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_data_restore_l
  
  !
  !================================================================================================================================
  !

  SUBROUTINE distributedmatrix_datatypeget(matrix,dataType,err,error,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: matrix
    INTEGER(INTG), INTENT(OUT) :: dataType
    INTEGER(INTG), INTENT(OUT) :: err
    TYPE(varying_string), INTENT(OUT) :: error

    enters("DistributedMatrix_DataTypeGet",err,error,*999)

    IF(ASSOCIATED(matrix)) THEN
      IF(.NOT.matrix%matrix_finished) THEN
        CALL flag_error("The matrix has not been finished.",err,error,*999)
      ELSE
        datatype=matrix%data_type
      END IF
    ELSE
      CALL flag_error("Distributed matrix is not associated.",err,error,*999)
    END IF

    exits("DistributedMatrix_DataTypeGet")
    RETURN
999 errorsexits("DistributedMatrix_DataTypeGet",err,error)
    RETURN 1
  END SUBROUTINE distributedmatrix_datatypeget

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_data_type_set(DISTRIBUTED_MATRIX,DATA_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: DATA_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_DATA_TYPE_SET",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        CALL flagerror("The distributed matrix has been finished.",err,error,*999)
      ELSE
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_data_type_set(distributed_matrix%CMISS%MATRIX,data_type,err,error,*999)
            distributed_matrix%DATA_TYPE=data_type
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          SELECT CASE(data_type)
          CASE(distributed_matrix_vector_intg_type)
            CALL flagerror("An integer distributed PETSc matrix is not implemented.",err,error,*999)
          CASE(distributed_matrix_vector_sp_type)
            CALL flagerror("A single precision distributed PETSc matrix is not implemented.",err,error,*999)
          CASE(distributed_matrix_vector_dp_type)
            distributed_matrix%DATA_TYPE=distributed_matrix_vector_dp_type
          CASE(distributed_matrix_vector_l_type)
            CALL flagerror("A logical distributed PETSc matrix is not implemented.",err,error,*999)
          CASE DEFAULT
            local_error="The specified data type of "//trim(numbertovstring(data_type,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_DATA_TYPE_SET")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_DATA_TYPE_SET",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_data_type_set

  !
  !================================================================================================================================
  !

  SUBROUTINE distributedmatrix_dimensionsget(distributedMatrix,m,n,err,error,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: distributedMatrix
    INTEGER(INTG), INTENT(OUT) :: m
    INTEGER(INTG), INTENT(OUT) :: n
    INTEGER(INTG), INTENT(OUT) :: err
    TYPE(varying_string), INTENT(OUT) :: error
    !Local variables
    TYPE(matrix_type), POINTER :: matrix
    TYPE(distributed_matrix_petsc_type), POINTER :: petscMatrix
    TYPE(varying_string) :: localError

    enters("DistributedMatrix_DimensionsGet",err,error,*999)

    IF(ASSOCIATED(distributedmatrix)) THEN
      SELECT CASE(distributedmatrix%library_type)
      CASE(distributed_matrix_vector_cmiss_type)
        IF(ASSOCIATED(distributedmatrix%cmiss)) THEN
          matrix=>distributedmatrix%cmiss%matrix
          IF(ASSOCIATED(matrix)) THEN
            IF(.NOT.matrix%matrix_finished) THEN
              CALL flag_error("The matrix has not been finished.",err,error,*999)
            ELSE
              m=matrix%m
              n=matrix%n
            END IF
          ELSE
            CALL flag_error("Distributed matrix CMISS matrix is not associated.",err,error,*999)
          END IF
        ELSE
          CALL flag_error("Distributed matrix CMISS is not associated.",err,error,*999)
        END IF
      CASE(distributed_matrix_vector_petsc_type)
        petscmatrix=>distributedmatrix%petsc
        IF(ASSOCIATED(petscmatrix)) THEN
          m=petscmatrix%m
          n=petscmatrix%n
        ELSE
          CALL flag_error("Distributed matrix PETSc is not associated.",err,error,*999)
        END IF
      CASE DEFAULT
        localerror="The distributed matrix library type of "// &
          & trim(number_to_vstring(distributedmatrix%library_type,"*",err,error))//" is invalid."
        CALL flag_error(localerror,err,error,*999)
      END SELECT
    ELSE
      CALL flag_error("Distributed matrix is not associated.",err,error,*999)
    END IF

    exits("DistributedMatrix_DimensionsGet")
    RETURN
999 errorsexits("DistributedMatrix_DimensionsGet",err,error)
    RETURN 1
  END SUBROUTINE distributedmatrix_dimensionsget

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_destroy(DISTRIBUTED_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables

    enters("DISTRIBUTED_MATRIX_DESTROY",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      CALL distributed_matrix_finalise(distributed_matrix,err,error,*999)
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_DESTROY")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_DESTROY",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_destroy

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_duplicate(DISTRIBUTED_MATRIX,NEW_DISTRIBUTED_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    TYPE(distributed_matrix_type), POINTER :: NEW_DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: DUMMY_ERR
    TYPE(varying_string) :: DUMMY_ERROR,LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_DUPLICATE",err,error,*998)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(ASSOCIATED(new_distributed_matrix)) THEN
        CALL flagerror("New distributed matrix is already associated.",err,error,*998)
      ELSE
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL distributed_matrix_create_start(distributed_matrix%ROW_DOMAIN_MAPPING,distributed_matrix%COLUMN_DOMAIN_MAPPING, &
              & new_distributed_matrix,err,error,*999)
            CALL matrix_duplicate(distributed_matrix%CMISS%MATRIX,new_distributed_matrix%CMISS%MATRIX,err,error,*999)
            CALL distributed_matrix_create_finish(new_distributed_matrix,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF          
        CASE(distributed_matrix_vector_petsc_type)
          CALL distributed_matrix_create_start(distributed_matrix%ROW_DOMAIN_MAPPING,distributed_matrix%COLUMN_DOMAIN_MAPPING, &
            & new_distributed_matrix,err,error,*999)
          CALL distributed_matrix_library_type_set(new_distributed_matrix,distributed_matrix_vector_petsc_type,err,error,*999)
          CALL distributed_matrix_create_finish(new_distributed_matrix,err,error,*999)
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_DUPLICATE")
    RETURN
999 CALL distributed_matrix_finalise(new_distributed_matrix,dummy_err,dummy_error,*999)
998 errorsexits("DISTRIBUTED_MATRIX_DUPLICATE",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_duplicate

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_finalise(DISTRIBUTED_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables

    enters("DISTRIBUTED_MATRIX_FINALISE",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      CALL distributed_matrix_cmiss_finalise(distributed_matrix%CMISS,err,error,*999)
      CALL distributed_matrix_petsc_finalise(distributed_matrix%PETSC,err,error,*999)        
      DEALLOCATE(distributed_matrix)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_FINALISE")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_FINALISE",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_finalise

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_form(DISTRIBUTED_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: column_idx,row
    TYPE(distributed_matrix_petsc_type), POINTER :: PETSC_MATRIX
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_FORM",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)          
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL flagerror("Not implemented.",err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          petsc_matrix=>distributed_matrix%PETSC
          IF(ASSOCIATED(petsc_matrix)) THEN
            SELECT CASE(petsc_matrix%STORAGE_TYPE)
            CASE(distributed_matrix_block_storage_type)
              CALL petsc_matzeroentries(petsc_matrix%MATRIX,err,error,*999)
            CASE(distributed_matrix_diagonal_storage_type)
              CALL flagerror("Diagonal storage is not implemented for PETSc matrices.",err,error,*999)
            CASE(distributed_matrix_column_major_storage_type)
              CALL flagerror("Column major storage is not implemented for PETSc matrices.",err,error,*999)
            CASE(distributed_matrix_row_major_storage_type)
              CALL flagerror("Row major storage is not implemented for PETSc matrices.",err,error,*999)
            CASE(distributed_matrix_compressed_row_storage_type)
              IF(petsc_matrix%USE_OVERRIDE_MATRIX) THEN
                DO row=1,petsc_matrix%M
                  DO column_idx=petsc_matrix%ROW_INDICES(row),petsc_matrix%ROW_INDICES(row+1)-1
                    CALL petsc_matsetvalue(petsc_matrix%OVERRIDE_MATRIX,petsc_matrix%GLOBAL_ROW_NUMBERS(row), &
                      & petsc_matrix%COLUMN_INDICES(column_idx)-1,0.0_dp,petsc_insert_values, &
                      & err,error,*999) !PETSc uses 0 indicies
                  ENDDO !column_idx
                ENDDO !row_idx
              ELSE
                DO row=1,petsc_matrix%M
                  DO column_idx=petsc_matrix%ROW_INDICES(row),petsc_matrix%ROW_INDICES(row+1)-1
                    CALL petsc_matsetvalue(petsc_matrix%MATRIX,petsc_matrix%GLOBAL_ROW_NUMBERS(row), &
                      & petsc_matrix%COLUMN_INDICES(column_idx)-1,0.0_dp,petsc_insert_values, &
                      & err,error,*999) !PETSc uses 0 indicies
                  ENDDO !column_idx
                ENDDO !row_idx
              ENDIF
            CASE(distributed_matrix_compressed_column_storage_type)
              CALL flagerror("Compressed column storage is not implemented for PETSc matrices.",err,error,*999)
            CASE(distributed_matrix_row_column_storage_type)
              CALL flagerror("Row column storage is not implemented for PETSc matrices.",err,error,*999)
            CASE DEFAULT
              local_error="The PETSc matrix storage type of "//trim(numbertovstring(petsc_matrix%STORAGE_TYPE,"*",err,error))// &
                & " is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
            IF(petsc_matrix%USE_OVERRIDE_MATRIX) THEN
              CALL petsc_matassemblybegin(petsc_matrix%OVERRIDE_MATRIX,petsc_mat_final_assembly,err,error,*999)
              CALL petsc_matassemblyend(petsc_matrix%OVERRIDE_MATRIX,petsc_mat_final_assembly,err,error,*999)
            ELSE
              CALL petsc_matassemblybegin(petsc_matrix%MATRIX,petsc_mat_final_assembly,err,error,*999)
              CALL petsc_matassemblyend(petsc_matrix%MATRIX,petsc_mat_final_assembly,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_FORM")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_FORM",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_form

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_ghosting_type_set(DISTRIBUTED_MATRIX,GHOSTING_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: GHOSTING_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(domain_mapping_type), POINTER :: ROW_DOMAIN_MAPPING,COLUMN_DOMAIN_MAPPING
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_GHOSTING_TYPE_SET",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        CALL flagerror("The distributed matrix has already been finished.",err,error,*999)
      ELSE
        row_domain_mapping=>distributed_matrix%ROW_DOMAIN_MAPPING
        column_domain_mapping=>distributed_matrix%COLUMN_DOMAIN_MAPPING
        IF(ASSOCIATED(row_domain_mapping)) THEN
          IF(ASSOCIATED(column_domain_mapping)) THEN
            SELECT CASE(distributed_matrix%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
                SELECT CASE(ghosting_type)
                CASE(distributed_matrix_vector_include_ghosts_type)
                  CALL matrix_size_set(distributed_matrix%CMISS%MATRIX,row_domain_mapping%TOTAL_NUMBER_OF_LOCAL, &
                    & column_domain_mapping%NUMBER_OF_GLOBAL,err,error,*999)
                CASE(distributed_matrix_vector_no_ghosts_type)
                  CALL matrix_size_set(distributed_matrix%CMISS%MATRIX,row_domain_mapping%NUMBER_OF_LOCAL, &
                    & column_domain_mapping%NUMBER_OF_GLOBAL,err,error,*999)
                CASE DEFAULT
                  local_error="The given ghosting type of "//trim(numbertovstring(ghosting_type,"*",err,error))//" is invalid."
                  CALL flagerror(local_error,err,error,*999)
                END SELECT
              ELSE
                CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
                SELECT CASE(ghosting_type)
                CASE(distributed_matrix_vector_include_ghosts_type)
                  distributed_matrix%PETSC%N=row_domain_mapping%TOTAL_NUMBER_OF_LOCAL
                CASE(distributed_matrix_vector_no_ghosts_type)
                  distributed_matrix%PETSC%N=row_domain_mapping%NUMBER_OF_LOCAL
                CASE DEFAULT
                  local_error="The given ghosting type of "//trim(numbertovstring(ghosting_type,"*",err,error))//" is invalid."
                  CALL flagerror(local_error,err,error,*999)
                END SELECT
              ELSE
                CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
              ENDIF
            CASE DEFAULT
              local_error="The distributed matrix library type of "// &
                & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
            distributed_matrix%GHOSTING_TYPE=ghosting_type
          ELSE
            CALL flagerror("Distributed matrix column domain mapping is not associated.",err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("Distributed matrix row domain mapping is not associated.",err,error,*999)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_GHOSTING_TYPE_SET")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_GHOSTING_TYPE_SET",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_ghosting_type_set

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_library_type_set(DISTRIBUTED_MATRIX,LIBRARY_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: LIBRARY_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: DUMMY_ERR,OLD_LIBRARY_TYPE
    TYPE(varying_string) :: DUMMY_ERROR,LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_LIBRARY_TYPE_SET",err,error,*998)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        CALL flagerror("The distributed matrix has already been finished.",err,error,*998)
      ELSE
        old_library_type=distributed_matrix%LIBRARY_TYPE
        IF(library_type/=old_library_type) THEN
          !Initialise the new library type
          SELECT CASE(library_type)
          CASE(distributed_matrix_vector_cmiss_type)
            CALL distributed_matrix_cmiss_initialise(distributed_matrix,err,error,*999)
          CASE(distributed_matrix_vector_petsc_type)
            CALL distributed_matrix_petsc_initialise(distributed_matrix,err,error,*999)
          CASE DEFAULT
            local_error="The library type of "//trim(numbertovstring(library_type,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
          !Finalise the old library type
          SELECT CASE(old_library_type)
          CASE(distributed_matrix_vector_cmiss_type)
            CALL distributed_matrix_cmiss_finalise(distributed_matrix%CMISS,err,error,*999)
          CASE(distributed_matrix_vector_petsc_type)
            CALL distributed_matrix_petsc_finalise(distributed_matrix%PETSC,err,error,*999)
          CASE DEFAULT
            local_error="The distributed matrix library type of "// &
              & trim(numbertovstring(old_library_type,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT          
          distributed_matrix%LIBRARY_TYPE=library_type
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_LIBRARY_TYPE_SET")
    RETURN
999 SELECT CASE(library_type)
    CASE(distributed_matrix_vector_cmiss_type)
      CALL distributed_matrix_cmiss_finalise(distributed_matrix%CMISS,dummy_err,dummy_error,*998)
    CASE(distributed_matrix_vector_petsc_type)
      CALL distributed_matrix_petsc_finalise(distributed_matrix%PETSC,dummy_err,dummy_error,*998)
    END SELECT
998 errorsexits("DISTRIBUTED_MATRIX_LIBRARY_TYPE_SET",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_library_type_set

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_initialise(ROW_DOMAIN_MAPPING,COLUMN_DOMAIN_MAPPING,DISTRIBUTED_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(domain_mapping_type), POINTER :: ROW_DOMAIN_MAPPING
    TYPE(domain_mapping_type), POINTER :: COLUMN_DOMAIN_MAPPING
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: DUMMY_ERR
    TYPE(varying_string) :: DUMMY_ERROR
    
    enters("DISTRIBUTED_MATRIX_INITIALISE",err,error,*998)

    IF(ASSOCIATED(row_domain_mapping)) THEN
      IF(ASSOCIATED(column_domain_mapping)) THEN
        IF(ASSOCIATED(distributed_matrix)) THEN
          CALL flagerror("Distributed matrix is already associated.",err,error,*998)
        ELSE
          ALLOCATE(distributed_matrix,stat=err)
          IF(err/=0) CALL flagerror("Could not allocated the distributed matrix.",err,error,*999)
          distributed_matrix%MATRIX_FINISHED=.false.
          distributed_matrix%LIBRARY_TYPE=0
          distributed_matrix%GHOSTING_TYPE=distributed_matrix_vector_include_ghosts_type
          distributed_matrix%ROW_DOMAIN_MAPPING=>row_domain_mapping
          distributed_matrix%COLUMN_DOMAIN_MAPPING=>column_domain_mapping
          distributed_matrix%DATA_TYPE=matrix_vector_dp_type
          NULLIFY(distributed_matrix%CMISS)
          NULLIFY(distributed_matrix%PETSC)
          CALL distributed_matrix_cmiss_initialise(distributed_matrix,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("Column domain mapping is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Row domain mapping is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_INITIALSE")
    RETURN
999 CALL distributed_matrix_finalise(distributed_matrix,dummy_err,dummy_error,*998)
998 errorsexits("DISTRIBUTED_MATRIX_INITIALISE",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_initialise

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_max_columns_per_row_get(DISTRIBUTED_MATRIX,MAX_COLUMNS_PER_ROW,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: MAX_COLUMNS_PER_ROW
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_MAX_COLUMNS_PER_ROW_GET",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
       SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_max_columns_per_row_get(distributed_matrix%CMISS%MATRIX,max_columns_per_row,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            max_columns_per_row=distributed_matrix%PETSC%MAXIMUM_COLUMN_INDICES_PER_ROW
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed mtrix is not associated.",err,error,*999)
    ENDIF

    exits("DISTRIBUTED_MATRIX_MAX_COLUMNS_PER_ROW_GET")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_MAX_COLUMNS_PER_ROW_GET",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_max_columns_per_row_get

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_number_non_zeros_set(DISTRIBUTED_MATRIX,NUMBER_NON_ZEROS,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: NUMBER_NON_ZEROS
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_NUMBER_NON_ZEROS_SET",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        CALL flagerror("The distributed matrix has been finished.",err,error,*999)
      ELSE
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_number_non_zeros_set(distributed_matrix%CMISS%MATRIX,number_non_zeros,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            IF(number_non_zeros>0) THEN
              distributed_matrix%PETSC%NUMBER_NON_ZEROS=number_non_zeros
            ELSE
              local_error="The specified number of non zeros ("//trim(numbertovstring(number_non_zeros,"*",err,error))// &
                & ") is invalid. The number must be > 0."
              CALL flagerror(local_error,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ENDIF
    ELSE
      CALL flagerror("Distributed mtrix is not associated.",err,error,*999)
    ENDIF

    exits("DISTRIBUTED_MATRIX_NUMBER_NON_ZEROS_SET")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_NUMBER_NON_ZEROS_SET",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_number_non_zeros_set

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_number_non_zeros_get(DISTRIBUTED_MATRIX,NUMBER_NON_ZEROS,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: NUMBER_NON_ZEROS
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_NUMBER_NON_ZEROS_GET",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_number_non_zeros_get(distributed_matrix%CMISS%MATRIX,number_non_zeros,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            number_non_zeros=distributed_matrix%PETSC%NUMBER_NON_ZEROS
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix is not finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF

    exits("DISTRIBUTED_MATRIX_NUMBER_NON_ZEROS_GET")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_NUMBER_NON_ZEROS_GET",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_number_non_zeros_get

  !
  !================================================================================================================================
  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_linklist_set(DISTRIBUTED_MATRIX,LIST,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    type(linkedlist),pointer :: list(:) 
    !INTEGER(INTG), INTENT(IN) :: NUMBER_NON_ZEROS !<The number of non zeros in the matrix to set
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_LINKLIST_SET",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        CALL flagerror("The distributed matrix has been finished.",err,error,*999)
      ELSE
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_linklist_set(distributed_matrix%CMISS%MATRIX,list,err,error,*999)
            !DISTRIBUTED_MATRIX%CMISS%list=list 
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            !IF(NUMBER_NON_ZEROS>0) THEN
              ! Check this
              distributed_matrix%PETSC%list=>list
            !ELSE
            !  LOCAL_ERROR="The specified number of non zeros ("//TRIM(NumberToVString(NUMBER_NON_ZEROS,"*",ERR,ERROR))// &
            !    & ") is invalid. The number must be > 0."
            !  CALL FlagError(LOCAL_ERROR,ERR,ERROR,*999)
            !ENDIF
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ENDIF
    ELSE
      CALL flagerror("Distributed mtrix is not associated.",err,error,*999)
    ENDIF

    exits("DISTRIBUTED_MATRIX_LIKLIST_SET")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_LINKLIST_SET",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_linklist_set

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_linklist_get(DISTRIBUTED_MATRIX,LIST,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    type(linkedlist),pointer :: list(:) 
!    INTEGER(INTG), INTENT(OUT) :: NUMBER_NON_ZEROS !<On return, the number of non zeros in the matrix to get
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_NUMBER_NON_ZEROS_GET",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            !list=DISTRIBUTED_MATRIX%CMISS%list
            CALL matrix_linklist_get(distributed_matrix%CMISS%MATRIX,list,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            list=>distributed_matrix%PETSC%list
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix is not finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF

    exits("DISTRIBUTED_MATRIX_LINKLIST_GET")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_LINKLIST_GET",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_linklist_get

  !
  !================================================================================================================================
  !
  SUBROUTINE distributed_matrix_output(ID,DISTRIBUTED_MATRIX,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
!    INTEGER(INTG) :: i,NUMBER_OF_COLUMNS
!    INTEGER(INTG), ALLOCATABLE :: COLUMNS(:)
!    REAL(DP), ALLOCATABLE :: VALUES(:)
!    CHARACTER(LEN=9) :: ROW_STRING
!    CHARACTER(LEN=39) :: INITIAL_STRING
    TYPE(varying_string) :: LOCAL_ERROR
     
    enters("DISTRIBUTED_MATRIX_OUTPUT",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_output(id,distributed_matrix%CMISS%MATRIX,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            IF(distributed_matrix%PETSC%USE_OVERRIDE_MATRIX) THEN 
              CALL petsc_matview(distributed_matrix%PETSC%OVERRIDE_MATRIX,petsc_viewer_stdout_world,err,error,*999) 
            ELSE 
              CALL petsc_matview(distributed_matrix%PETSC%MATRIX,petsc_viewer_stdout_world,err,error,*999) 
            ENDIF
            !ALLOCATE(COLUMNS(DISTRIBUTED_MATRIX%PETSC%MAXIMUM_COLUMN_INDICES_PER_ROW),STAT=ERR)
            !IF(ERR/=0) CALL FlagError("Could not allocate columns.",ERR,ERROR,*999)
            !ALLOCATE(VALUES(DISTRIBUTED_MATRIX%PETSC%MAXIMUM_COLUMN_INDICES_PER_ROW),STAT=ERR)
            !IF(ERR/=0) CALL FlagError("Could not allocate values.",ERR,ERROR,*999)
            !DO i=1,DISTRIBUTED_MATRIX%PETSC%M
            !  IF(DISTRIBUTED_MATRIX%PETSC%USE_OVERRIDE_MATRIX) THEN
            !    CALL Petsc_MatGetRow(DISTRIBUTED_MATRIX%PETSC%OVERRIDE_MATRIX,i-1,NUMBER_OF_COLUMNS,COLUMNS,VALUES, &
            !      & ERR,ERROR,*999)
            !  ELSE
            !    CALL Petsc_MatGetRow(DISTRIBUTED_MATRIX%PETSC%MATRIX,i-1,NUMBER_OF_COLUMNS,COLUMNS,VALUES,ERR,ERROR,*999)
            !  ENDIF
            !  ROW_STRING=NUMBER_TO_CHARACTER(i,"I9",ERR,ERROR)
            !  INITIAL_STRING='("Matrix('//ROW_STRING//',:):",8(X,E13.6))'
            !  CALL WRITE_STRING_VECTOR(ID,1,1,NUMBER_OF_COLUMNS,8,8,VALUES,INITIAL_STRING,'(20X,8(X,E13.6))', &
            !    & ERR,ERROR,*999)
            !  IF(DISTRIBUTED_MATRIX%PETSC%USE_OVERRIDE_MATRIX) THEN
            !    CALL Petsc_MatRestoreRow(DISTRIBUTED_MATRIX%PETSC%OVERRIDE_MATRIX,i-1,NUMBER_OF_COLUMNS,COLUMNS,VALUES, &
            !      & ERR,ERROR,*999)
            !  ELSE
            !    CALL Petsc_MatRestoreRow(DISTRIBUTED_MATRIX%PETSC%MATRIX,i-1,NUMBER_OF_COLUMNS,COLUMNS,VALUES,ERR,ERROR,*999)
            !  ENDIF
            !ENDDO !i
            !IF(ALLOCATED(VALUES)) DEALLOCATE(VALUES)
            !IF(ALLOCATED(COLUMNS)) DEALLOCATE(COLUMNS)
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("Distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_OUTPUT")
    RETURN
!999 IF(ALLOCATED(VALUES)) DEALLOCATE(VALUES)
!    IF(ALLOCATED(COLUMNS)) DEALLOCATE(COLUMNS)
999 errorsexits("DISTRIBUTED_MATRIX_OUTPUT",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_output

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_override_set_on(DISTRIBUTED_MATRIX,OVERRIDE_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    TYPE(petscmattype), INTENT(IN) :: OVERRIDE_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_OVERRIDE_SET_ON",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          CALL flagerror("Not implemented.",err,error,*999)          
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            distributed_matrix%PETSC%USE_OVERRIDE_MATRIX=.true.
            distributed_matrix%PETSC%OVERRIDE_MATRIX=override_matrix
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
       CALL flagerror("Distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_OVERRIDE_SET_ON")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_OVERRIDE_SET_ON",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_override_set_on

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_override_set_off(DISTRIBUTED_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("DISTRIBUTED_MATRIX_OVERRIDE_SET_OFF",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          CALL flagerror("Not implemented.",err,error,*999)          
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            distributed_matrix%PETSC%USE_OVERRIDE_MATRIX=.false.
            CALL petsc_matinitialise(distributed_matrix%PETSC%OVERRIDE_MATRIX,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("Distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_OVERRIDE_SET_OFF")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_OVERRIDE_SET_OFF",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_override_set_off

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_petsc_create_finish(PETSC_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_petsc_type), POINTER :: PETSC_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: DUMMY_ERR,i
    !INTEGER(INTG), ALLOCATABLE :: GLOBAL_NUMBERS(:)
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    TYPE(domain_mapping_type), POINTER :: ROW_DOMAIN_MAPPING,COLUMN_DOMAIN_MAPPING
    TYPE(varying_string) :: DUMMY_ERROR,LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_PETSC_CREATE_FINISH",err,error,*999)

    IF(ASSOCIATED(petsc_matrix)) THEN
      distributed_matrix=>petsc_matrix%DISTRIBUTED_MATRIX
      IF(ASSOCIATED(distributed_matrix)) THEN
        row_domain_mapping=>distributed_matrix%ROW_DOMAIN_MAPPING
        column_domain_mapping=>distributed_matrix%COLUMN_DOMAIN_MAPPING
        IF(ASSOCIATED(row_domain_mapping)) THEN
          IF(ASSOCIATED(column_domain_mapping)) THEN
            SELECT CASE(petsc_matrix%STORAGE_TYPE)
            CASE(distributed_matrix_block_storage_type)
              petsc_matrix%NUMBER_NON_ZEROS=petsc_matrix%M*petsc_matrix%GLOBAL_N
              petsc_matrix%MAXIMUM_COLUMN_INDICES_PER_ROW=petsc_matrix%GLOBAL_N
              petsc_matrix%DATA_SIZE=petsc_matrix%NUMBER_NON_ZEROS
              !Set up the Local to Global mappings
              ALLOCATE(petsc_matrix%GLOBAL_ROW_NUMBERS(petsc_matrix%M),stat=err)
              IF(err/=0) CALL flagerror("Could not allocate global row numbers for PETSc distributed matrix.",err,error,*999)
              DO i=1,petsc_matrix%M
                petsc_matrix%GLOBAL_ROW_NUMBERS(i)=row_domain_mapping%LOCAL_TO_GLOBAL_MAP(i)-1 !PETSc uses 0 based indexing
              ENDDO !i
              !Set up the matrix
              ALLOCATE(petsc_matrix%DATA_DP(petsc_matrix%DATA_SIZE),stat=err)
              IF(err/=0) CALL flagerror("Could not allocate PETSc matrix data.",err,error,*999)
              CALL petsc_matcreatedense(computational_environment%MPI_COMM,petsc_matrix%M,petsc_matrix%N, &
                & petsc_matrix%GLOBAL_M,petsc_matrix%GLOBAL_N,petsc_matrix%DATA_DP,petsc_matrix%MATRIX,err,error,*999)
            CASE(distributed_matrix_diagonal_storage_type)
              petsc_matrix%NUMBER_NON_ZEROS=petsc_matrix%M
              petsc_matrix%MAXIMUM_COLUMN_INDICES_PER_ROW=1
              petsc_matrix%DATA_SIZE=petsc_matrix%NUMBER_NON_ZEROS
              !Set up the Local to Global mappings
              ALLOCATE(petsc_matrix%GLOBAL_ROW_NUMBERS(petsc_matrix%M),stat=err)
              IF(err/=0) CALL flagerror("Could not allocate global row numbers for PETSc distributed matrix.",err,error,*999)
              DO i=1,petsc_matrix%M
                petsc_matrix%GLOBAL_ROW_NUMBERS(i)=row_domain_mapping%LOCAL_TO_GLOBAL_MAP(i)-1 !PETSc uses 0 based indexing
              ENDDO !i
              !Set up the matrix
              ALLOCATE(petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS(petsc_matrix%N),stat=err)
              IF(err/=0) CALL flagerror("Could not allocate diagonal number of non zeros.",err,error,*999)
              ALLOCATE(petsc_matrix%OFFDIAGONAL_NUMBER_NON_ZEROS(petsc_matrix%N),stat=err)
              IF(err/=0) CALL flagerror("Could not allocate off diagonal number of non zeros.",err,error,*999)
              petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS=1
              petsc_matrix%OFFDIAGONAL_NUMBER_NON_ZEROS=0
              !Create the PETsc AIJ matrix
              CALL petsc_matcreateaij(computational_environment%MPI_COMM,petsc_matrix%M,petsc_matrix%N, &
                & petsc_matrix%GLOBAL_M,petsc_matrix%GLOBAL_N,petsc_null_integer,petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS, &
                & petsc_null_integer,petsc_matrix%OFFDIAGONAL_NUMBER_NON_ZEROS,petsc_matrix%MATRIX,err,error,*999)
            CASE(distributed_matrix_column_major_storage_type)
              CALL flagerror("Column major storage is not implemented for PETSc matrices.",err,error,*999)
            CASE(distributed_matrix_row_major_storage_type)
              CALL flagerror("Row major storage is not implemented for PETSc matrices.",err,error,*999)
            CASE(distributed_matrix_compressed_row_storage_type)
              IF(ALLOCATED(petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS)) THEN
                IF(ALLOCATED(petsc_matrix%OFFDIAGONAL_NUMBER_NON_ZEROS)) THEN
                  !Create the PETSc AIJ matrix
                  CALL petsc_matcreateaij(computational_environment%MPI_COMM,petsc_matrix%M,petsc_matrix%N, &
                    & petsc_matrix%GLOBAL_M,petsc_matrix%GLOBAL_N,petsc_null_integer,petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS, &
                    & petsc_null_integer,petsc_matrix%OFFDIAGONAL_NUMBER_NON_ZEROS,petsc_matrix%MATRIX,err,error,*999)
                  !Set matrix options
                  CALL petsc_matsetoption(petsc_matrix%MATRIX,petsc_mat_new_nonzero_location_err,.true.,err,error,*999)
                  CALL petsc_matsetoption(petsc_matrix%MATRIX,petsc_mat_new_nonzero_allocation_err,.true.,err,error,*999)
                  CALL petsc_matsetoption(petsc_matrix%MATRIX,petsc_mat_unused_nonzero_location_err,.true.,err,error,*999)
                  !Set up the Local to Global mappings
                  ALLOCATE(petsc_matrix%GLOBAL_ROW_NUMBERS(petsc_matrix%M),stat=err)
                  IF(err/=0) CALL flagerror("Could not allocate global row numbers for PETSc distributed matrix.",err,error,*999)
                  petsc_matrix%MAXIMUM_COLUMN_INDICES_PER_ROW=0
                  DO i=1,petsc_matrix%M
                    petsc_matrix%GLOBAL_ROW_NUMBERS(i)=row_domain_mapping%LOCAL_TO_GLOBAL_MAP(i)-1 !PETSc uses 0 based indexing
                    IF((petsc_matrix%ROW_INDICES(i+1)-petsc_matrix%ROW_INDICES(i))>petsc_matrix%MAXIMUM_COLUMN_INDICES_PER_ROW) &
                      & petsc_matrix%MAXIMUM_COLUMN_INDICES_PER_ROW=petsc_matrix%ROW_INDICES(i+1)-petsc_matrix%ROW_INDICES(i)
                  ENDDO !i
                ELSE
                  CALL flagerror("Matrix off diagonal storage locations have not been set.",err,error,*999)
                ENDIF
              ELSE
                CALL flagerror("Matrix diagonal storage locations have not been set.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_compressed_column_storage_type)
              CALL flagerror("Compressed column storage is not implemented for PETSc matrices.",err,error,*999)
            CASE(distributed_matrix_row_column_storage_type)
              CALL flagerror("Row column storage is not implemented for PETSc matrices.",err,error,*999)
            CASE DEFAULT
              local_error="The PETSc matrix storage type of "//trim(numbertovstring(petsc_matrix%STORAGE_TYPE,"*",err,error))// &
                & " is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            CALL flagerror("PETSc matrix distributed matrix column domain mapping is not associated.",err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("PETSc matrix distributed matrix row domain mapping is not associated.",err,error,*999)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_PETSC_CREATE_FINISH")
    RETURN
999 CALL distributed_matrix_petsc_finalise(petsc_matrix,dummy_err,dummy_error,*998)
998 errorsexits("DISTRIBUTED_MATRIX_PETSC_CREATE_FINISH",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_petsc_create_finish

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_petsc_finalise(PETSC_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_petsc_type), POINTER :: PETSC_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    
    enters("DISTRIBUTED_MATRIX_PETSC_FINALISE",err,error,*999)

    IF(ASSOCIATED(petsc_matrix)) THEN
      IF(ALLOCATED(petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS)) DEALLOCATE(petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS)
      IF(ALLOCATED(petsc_matrix%OFFDIAGONAL_NUMBER_NON_ZEROS)) DEALLOCATE(petsc_matrix%OFFDIAGONAL_NUMBER_NON_ZEROS)
      IF(ALLOCATED(petsc_matrix%ROW_INDICES)) DEALLOCATE(petsc_matrix%ROW_INDICES)
      IF(ALLOCATED(petsc_matrix%COLUMN_INDICES)) DEALLOCATE(petsc_matrix%COLUMN_INDICES)
      IF(ALLOCATED(petsc_matrix%GLOBAL_ROW_NUMBERS)) DEALLOCATE(petsc_matrix%GLOBAL_ROW_NUMBERS)
      !IF(ALLOCATED(PETSC_MATRIX%DATA_DP)) DEALLOCATE(PETSC_MATRIX%DATA_DP)
      CALL petsc_matfinalise(petsc_matrix%MATRIX,err,error,*999)
      CALL petsc_matfinalise(petsc_matrix%OVERRIDE_MATRIX,err,error,*999)
      DEALLOCATE(petsc_matrix)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_PETSC_FINALSE")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_PETSC_FINALISE",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_petsc_finalise

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_petsc_initialise(DISTRIBUTED_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: DUMMY_ERR
    TYPE(domain_mapping_type), POINTER :: ROW_DOMAIN_MAPPING,COLUMN_DOMAIN_MAPPING
    TYPE(varying_string) :: DUMMY_ERROR,LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_PETSC_INITIALISE",err,error,*998)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
        CALL flagerror("PETSc is already associated for this distributed matrix",err,error,*998)
      ELSE
        row_domain_mapping=>distributed_matrix%ROW_DOMAIN_MAPPING
        column_domain_mapping=>distributed_matrix%COLUMN_DOMAIN_MAPPING
        IF(ASSOCIATED(row_domain_mapping)) THEN
          IF(ASSOCIATED(column_domain_mapping)) THEN
            ALLOCATE(distributed_matrix%PETSC,stat=err)
            IF(err/=0) CALL flagerror("Could not allocate PETSc distributed matrix.",err,error,*999)
            distributed_matrix%PETSC%DISTRIBUTED_MATRIX=>distributed_matrix
            distributed_matrix%LIBRARY_TYPE=distributed_matrix_vector_petsc_type
            !Set the defaults          
            SELECT CASE(distributed_matrix%GHOSTING_TYPE)
            CASE(distributed_matrix_vector_include_ghosts_type)
              distributed_matrix%PETSC%M=row_domain_mapping%TOTAL_NUMBER_OF_LOCAL            
            CASE(distributed_matrix_vector_no_ghosts_type)
              distributed_matrix%PETSC%M=row_domain_mapping%NUMBER_OF_LOCAL
            CASE DEFAULT
              local_error="The distributed matrix ghosting type of "// &
                & trim(numbertovstring(distributed_matrix%GHOSTING_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
            distributed_matrix%PETSC%N=column_domain_mapping%TOTAL_NUMBER_OF_LOCAL
            distributed_matrix%PETSC%GLOBAL_M=row_domain_mapping%NUMBER_OF_GLOBAL
            distributed_matrix%PETSC%GLOBAL_N=column_domain_mapping%NUMBER_OF_GLOBAL
            distributed_matrix%PETSC%STORAGE_TYPE=distributed_matrix_compressed_row_storage_type
            distributed_matrix%PETSC%DATA_SIZE=0
            distributed_matrix%PETSC%MAXIMUM_COLUMN_INDICES_PER_ROW=0
            distributed_matrix%PETSC%USE_OVERRIDE_MATRIX=.false.
            CALL petsc_matinitialise(distributed_matrix%PETSC%MATRIX,err,error,*999)
            CALL petsc_matinitialise(distributed_matrix%PETSC%OVERRIDE_MATRIX,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix column domain mapping is not associated.",err,error,*998)
          ENDIF
        ELSE
          CALL flagerror("Distributed matrix row domain mapping is not associated.",err,error,*998)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_PETSC_INITIALSE")
    RETURN
999 IF(ASSOCIATED(distributed_matrix%PETSC)) &
      & CALL distributed_matrix_petsc_finalise(distributed_matrix%PETSC,dummy_err,dummy_error,*998)
998 errorsexits("DISTRIBUTED_MATRIX_PETSC_INITIALISE",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_petsc_initialise

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_storage_locations_get(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), POINTER :: ROW_INDICES(:)
    INTEGER(INTG), POINTER :: COLUMN_INDICES(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(distributed_matrix_cmiss_type), POINTER :: CMISS_MATRIX
    TYPE(distributed_matrix_petsc_type), POINTER :: PETSC_MATRIX
    TYPE(varying_string) :: LOCAL_ERROR
     
    enters("DISTRIBUTED_MATRIX_STORAGE_LOCATIONS_GET",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          cmiss_matrix=>distributed_matrix%CMISS
          IF(ASSOCIATED(cmiss_matrix)) THEN
            CALL matrix_storage_locations_get(cmiss_matrix%MATRIX,row_indices,column_indices,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          petsc_matrix=>distributed_matrix%PETSC
          IF(ASSOCIATED(petsc_matrix)) THEN
            SELECT CASE(petsc_matrix%STORAGE_TYPE)
            CASE(distributed_matrix_block_storage_type)
              CALL flagerror("Cannot get matrix locations for a block storage matrix.",err,error,*999)
            CASE(distributed_matrix_diagonal_storage_type)
              CALL flagerror("Diagonal storage is not implemented for PETSc matrices.",err,error,*999)
            CASE(distributed_matrix_column_major_storage_type)
              CALL flagerror("Column major storage is not implemented for PETSc matrices.",err,error,*999)
            CASE(distributed_matrix_row_major_storage_type)
              CALL flagerror("Row major storage is not implemented for PETSc matrices.",err,error,*999)
            CASE(distributed_matrix_compressed_row_storage_type)
              row_indices=>distributed_matrix%PETSC%ROW_INDICES
              column_indices=>distributed_matrix%PETSC%COLUMN_INDICES
            CASE(distributed_matrix_compressed_column_storage_type)
              CALL flagerror("Compressed column storage is not implemented for PETSc matrices.",err,error,*999)
            CASE(distributed_matrix_row_column_storage_type)
              CALL flagerror("Row column storage is not implemented for PETSc matrices.",err,error,*999)
            CASE DEFAULT
              local_error="The matrix storage type of "// &
                & trim(numbertovstring(petsc_matrix%STORAGE_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_STORAGE_LOCATIONS_GET")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_STORAGE_LOCATIONS_GET",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_storage_locations_get

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_storage_locations_set(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: i,j,k,global_row_start,global_row_finish
    TYPE(distributed_matrix_cmiss_type), POINTER :: CMISS_MATRIX
    TYPE(distributed_matrix_petsc_type), POINTER :: PETSC_MATRIX
    TYPE(domain_mapping_type), POINTER :: ROW_DOMAIN_MAPPING,COLUMN_DOMAIN_MAPPING
    TYPE(varying_string) :: LOCAL_ERROR

    NULLIFY(cmiss_matrix)
    NULLIFY(petsc_matrix)
    
    enters("DISTRIBUTED_MATRIX_STORAGE_LOCATIONS_SET",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        CALL flagerror("The distributed matrix has been finished.",err,error,*999)
      ELSE
        row_domain_mapping=>distributed_matrix%ROW_DOMAIN_MAPPING
        column_domain_mapping=>distributed_matrix%COLUMN_DOMAIN_MAPPING
        IF(ASSOCIATED(row_domain_mapping)) THEN
          IF(ASSOCIATED(column_domain_mapping)) THEN
            SELECT CASE(distributed_matrix%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              cmiss_matrix=>distributed_matrix%CMISS
              IF(ASSOCIATED(cmiss_matrix)) THEN
                CALL matrix_storage_locations_set(cmiss_matrix%MATRIX,row_indices,column_indices,err,error,*999)
              ELSE
                CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              petsc_matrix=>distributed_matrix%PETSC
              IF(ASSOCIATED(petsc_matrix)) THEN
                SELECT CASE(petsc_matrix%STORAGE_TYPE)
                CASE(distributed_matrix_block_storage_type)
                  !Do nothing
                CASE(distributed_matrix_diagonal_storage_type)
                  CALL flagerror("Diagonal storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_column_major_storage_type)
                  CALL flagerror("Column major storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_row_major_storage_type)
                  CALL flagerror("Row major storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_compressed_row_storage_type)
                  IF(SIZE(row_indices,1)==petsc_matrix%M+1) THEN
                    IF(SIZE(column_indices,1)==petsc_matrix%NUMBER_NON_ZEROS) THEN
                      IF(row_indices(1)==1) THEN
                        !Check the row indicies are correct
                        IF(row_indices(petsc_matrix%M+1)==petsc_matrix%NUMBER_NON_ZEROS+1) THEN
                          DO i=2,petsc_matrix%M+1
                            IF(row_indices(i)<row_indices(i-1)) THEN
                              local_error="Invalid row indices. Row "//trim(numbertovstring(i,"*",err,error))// &
                                & " index number ("//trim(numbertovstring(row_indices(i),"*",err,error))//" &
                                & ) is less than row "//trim(numbertovstring(i-1,"*",err,error))//" index number ("// &
                                & trim(numbertovstring(row_indices(i-1),"*",err,error))//")."
                              CALL flagerror(local_error,err,error,*999)
                            ENDIF
                          ENDDO !i
                          !Allocate the PETSc sparsity storage arrays
                          ALLOCATE(petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS(petsc_matrix%M),stat=err)
                          IF(err/=0) CALL flagerror("Could not allocate PETSc matrix diagonal number of non zeros.",err,error,*999)
                          petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS=0
                          ALLOCATE(petsc_matrix%OFFDIAGONAL_NUMBER_NON_ZEROS(petsc_matrix%M),stat=err)
                          IF(err/=0) CALL flagerror("Could not allocate PETSc matrix off diagonal number of non zeros.", &
                            & err,error,*999)
                          petsc_matrix%OFFDIAGONAL_NUMBER_NON_ZEROS=0
                          ALLOCATE(petsc_matrix%ROW_INDICES(petsc_matrix%M+1),stat=err)
                          IF(err/=0) CALL flagerror("Could not allocate PETSc matrix row indices.",err,error,*999)
                          petsc_matrix%ROW_INDICES(1:petsc_matrix%M+1)=row_indices(1:petsc_matrix%M+1)
                          ALLOCATE(petsc_matrix%COLUMN_INDICES(petsc_matrix%NUMBER_NON_ZEROS),stat=err)
                          IF(err/=0) CALL flagerror("Could not allocate PETSc matrix column indices.",err,error,*999)
                          petsc_matrix%COLUMN_INDICES(1:petsc_matrix%NUMBER_NON_ZEROS)= &
                            & column_indices(1:petsc_matrix%NUMBER_NON_ZEROS)
                          !Check the column indices are correct and calculate number of diagonal and off-diagonal columns
                          global_row_start=row_domain_mapping%LOCAL_TO_GLOBAL_MAP(1)
                          global_row_finish=row_domain_mapping%LOCAL_TO_GLOBAL_MAP(petsc_matrix%M)
                          DO i=1,petsc_matrix%M
                            DO j=row_indices(i),row_indices(i+1)-1
                              k=column_indices(j)
                              IF(k>0) THEN
                                IF(k>petsc_matrix%GLOBAL_N) THEN
                                  local_error="Invalid column indices. Column index "//trim(numbertovstring(j,"*",err,error))// &
                                    & " ("//trim(numbertovstring(k,"*",err,error))// &
                                    & ") is greater than the number of columns ("// &
                                    & trim(numbertovstring(petsc_matrix%GLOBAL_N,"*",err,error))//")."
                                  CALL flagerror(local_error,err,error,*999)
                                ENDIF
                                IF(k>=global_row_start.AND.k<=global_row_finish) THEN
                                  petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS(i)=petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS(i)+1
                                ELSE
                                  petsc_matrix%OFFDIAGONAL_NUMBER_NON_ZEROS(i)=petsc_matrix%OFFDIAGONAL_NUMBER_NON_ZEROS(i)+1
                                ENDIF
                              ELSE
                                local_error="Invalid column indices. Column index "//trim(numbertovstring(j,"*",err,error))// &
                                  & " ("//trim(numbertovstring(k,"*",err,error))//") is less than zero."
                                CALL flagerror(local_error,err,error,*999)
                              ENDIF
                            ENDDO !j
                            !Enforce a place for the diagonal entry.
                            IF(petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS(i)==0) petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS(i)=1
                          ENDDO !i
                          IF(diagnostics3) THEN
                            CALL write_string(diagnostic_output_type,"PETSc distributed matrix sparsity:",err,error,*999)
                            CALL write_string_value(diagnostic_output_type,"  Storage type = ",petsc_matrix%STORAGE_TYPE, &
                              & err,error,*999)
                            CALL write_string_value(diagnostic_output_type,"  M = ",petsc_matrix%M,err,error,*999)
                            CALL write_string_value(diagnostic_output_type,"  N = ",petsc_matrix%N,err,error,*999)
                            CALL write_string_value(diagnostic_output_type,"  Global M = ",petsc_matrix%GLOBAL_M,err,error,*999)
                            CALL write_string_value(diagnostic_output_type,"  Global N = ",petsc_matrix%GLOBAL_N,err,error,*999)
                            CALL write_string_value(diagnostic_output_type,"  Number of non zeros = ",petsc_matrix% &
                              & number_non_zeros,err,error,*999)
                            CALL write_string_vector(diagnostic_output_type,1,1,petsc_matrix%M,8,8,petsc_matrix%&
                              & diagonal_number_non_zeros,'("  Diagonal number non zeros     :",8(X,I10))','(33X,8(X,I10))', &
                              & err,error,*999)
                            CALL write_string_vector(diagnostic_output_type,1,1,petsc_matrix%M,8,8,petsc_matrix%&
                              & offdiagonal_number_non_zeros,'("  Off-diagonal number non zeros :",8(X,I10))','(33X,8(X,I10))', &
                              & err,error,*999)
                            CALL write_string_vector(diagnostic_output_type,1,1,petsc_matrix%M+1,8,8,petsc_matrix%&
                              & row_indices,'("  Row indices                   :",8(X,I10))','(33X,8(X,I10))', &
                              & err,error,*999)
                            CALL write_string_vector(diagnostic_output_type,1,1,petsc_matrix%NUMBER_NON_ZEROS,8,8,petsc_matrix%&
                              & column_indices,'("  Column indices                :",8(X,I10))','(33X,8(X,I10))', &
                              & err,error,*999)
                          ENDIF
                        ELSE
                          local_error="Invalid row indices. The last row index ("// &
                            & trim(numbertovstring(row_indices(petsc_matrix%M+1),"*",err,error))// &
                            & ") does not equal the number of non-zeros + 1 ("// &
                            & trim(numbertovstring(petsc_matrix%NUMBER_NON_ZEROS+1,"*",err,error))//")."
                          CALL flagerror(local_error,err,error,*999)
                        ENDIF
                      ELSE
                        local_error="Invalid row indices. The first row index ("// &
                          & trim(numbertovstring(row_indices(1),"*",err,error))//") does not equal 1."
                        CALL flagerror(local_error,err,error,*999)
                      ENDIF
                    ELSE
                      local_error="The supplied number of column indices ("// &
                        & trim(numbertovstring(SIZE(column_indices,1),"*",err,error))// &
                        & ") does not match the number of non-zeros in the matrix ("// &
                        & trim(numbertovstring(petsc_matrix%NUMBER_NON_ZEROS,"*",err,error))//")."
                      CALL flagerror(local_error,err,error,*999)
                    ENDIF
                  ELSE
                    local_error="The supplied number of row indices ("// &
                      & trim(numbertovstring(SIZE(row_indices,1),"*",err,error))// &
                      & ") does not match the number of rows in the matrix + 1 ("// &
                      & trim(numbertovstring(petsc_matrix%M+1,"*",err,error))//")."
                    CALL flagerror(local_error,err,error,*999)
                  ENDIF
                CASE(distributed_matrix_compressed_column_storage_type)
                  CALL flagerror("Compressed column storage is not implemented for PETSc matrices.",err,error,*999)
                CASE(distributed_matrix_row_column_storage_type)
                  CALL flagerror("Row column storage is not implemented for PETSc matrices.",err,error,*999)
                CASE DEFAULT
                  local_error="The specified matrix storage type of "// &
                    & trim(numbertovstring(petsc_matrix%STORAGE_TYPE,"*",err,error))//" is invalid."
                  CALL flagerror(local_error,err,error,*999)
                END SELECT
              ELSE
                CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
              ENDIF
            CASE DEFAULT
              local_error="The distributed matrix library type of "// &
                & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            CALL flagerror("Distributed matrix column domain mapping is not associated.",err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("Distributed matrix row domain mapping is not associated.",err,error,*999)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_STORAGE_LOCATIONS_SET")
    RETURN
999 IF(ASSOCIATED(petsc_matrix)) THEN
      IF(ALLOCATED(petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS)) DEALLOCATE(petsc_matrix%DIAGONAL_NUMBER_NON_ZEROS)
      IF(ALLOCATED(petsc_matrix%OFFDIAGONAL_NUMBER_NON_ZEROS)) DEALLOCATE(petsc_matrix%OFFDIAGONAL_NUMBER_NON_ZEROS)
    ENDIF
    errorsexits("DISTRIBUTED_MATRIX_STORAGE_LOCATIONS_SET",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_storage_locations_set

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_storage_type_get(DISTRIBUTED_MATRIX,STORAGE_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: STORAGE_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_STORAGE_TYPE_GET",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_storage_type_get(distributed_matrix%CMISS%MATRIX,storage_type,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            storage_type=distributed_matrix%PETSC%STORAGE_TYPE
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_STORAGE_TYPE_GET")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_STORAGE_TYPE_GET",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_storage_type_get

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_storage_type_set(DISTRIBUTED_MATRIX,STORAGE_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: STORAGE_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_STORAGE_TYPE_SET",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        CALL flagerror("The distributed matrix has been finished.",err,error,*999)
      ELSE
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_storage_type_set(distributed_matrix%CMISS%MATRIX,storage_type,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            SELECT CASE(storage_type)
            CASE(distributed_matrix_block_storage_type)
              distributed_matrix%PETSC%STORAGE_TYPE=distributed_matrix_block_storage_type
            CASE(distributed_matrix_diagonal_storage_type)
              distributed_matrix%PETSC%STORAGE_TYPE=distributed_matrix_diagonal_storage_type
            CASE(distributed_matrix_column_major_storage_type)
              CALL flagerror("Column major storage is not implemented for PETSc matrices.",err,error,*999)
            CASE(distributed_matrix_row_major_storage_type)
              CALL flagerror("Row major storage is not implemented for PETSc matrices.",err,error,*999)
            CASE(distributed_matrix_compressed_row_storage_type)
              distributed_matrix%PETSC%STORAGE_TYPE=distributed_matrix_compressed_row_storage_type
            CASE(distributed_matrix_compressed_column_storage_type)
              CALL flagerror("Compressed column storage is not implemented for PETSc matrices.",err,error,*999)
            CASE(distributed_matrix_row_column_storage_type)
              CALL flagerror("Row column storage is not implemented for PETSc matrices.",err,error,*999)
            CASE DEFAULT
              local_error="The specified matrix storage type of "//trim(numbertovstring(storage_type,"*",err,error))// &
                & " is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            CALL flagerror("Distributed matrix PETSc is not implemented.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_STORAGE_TYPE_SET")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_STORAGE_TYPE_SET",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_storage_type_set

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_update_finish(DISTRIBUTED_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_UPDATE_FINISH",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          !Do nothing for now.
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            IF(distributed_matrix%PETSC%USE_OVERRIDE_MATRIX) THEN
              CALL petsc_matassemblyend(distributed_matrix%PETSC%OVERRIDE_MATRIX,petsc_mat_final_assembly,err,error,*999)
            ELSE
              CALL petsc_matassemblyend(distributed_matrix%PETSC%MATRIX,petsc_mat_final_assembly,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_UPDATE_FINISH")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_UPDATE_FINISH",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_update_finish

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_update_isfinished(DISTRIBUTED_MATRIX,ISFINISHED,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    LOGICAL, INTENT(OUT) :: ISFINISHED
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    
    enters("DISTRIBUTED_MATRIX_UPDATE_ISFINISHED",err,error,*999)

    isfinished=.false.
    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        !Do nothting for now.
        isfinished=.true.
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_UPDATE_ISFINISHED")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_UPDATE_ISFINISHED",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_update_isfinished

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_update_waitfinished(DISTRIBUTED_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    
    enters("DISTRIBUTED_MATRIX_UPDATE_WAITFINISHED",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        !Do nothing for now.
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_UPDATE_WAITFINISHED")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_UPDATE_WAITFINISHED",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_update_waitfinished

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_update_start(DISTRIBUTED_MATRIX,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_UPDATE_START",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          !Do nothing for now.
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            IF(distributed_matrix%PETSC%USE_OVERRIDE_MATRIX) THEN
              CALL petsc_matassemblybegin(distributed_matrix%PETSC%OVERRIDE_MATRIX,petsc_mat_final_assembly,err,error,*999)
            ELSE
              CALL petsc_matassemblybegin(distributed_matrix%PETSC%MATRIX,petsc_mat_final_assembly,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
     ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF

    exits("DISTRIBUTED_MATRIX_UPDATE_START")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_UPDATE_START",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_update_start

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_add_intg(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: VALUES(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_ADD_INTG",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_add(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Adding values to an integer PETSc distributed matrix is not implemented.",err,error,*999)
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_ADD_INTG")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_ADD_INTG",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_add_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_add_intg1(DISTRIBUTED_MATRIX,ROW_INDEX,COLUMN_INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDEX
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDEX
    INTEGER(INTG), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_ADD_INTG1",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_add(distributed_matrix%CMISS%MATRIX,row_index,column_index,VALUE,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Adding values to an integer PETSc distributed matrix is not implemented.",err,error,*999)
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_ADD_INTG1")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_ADD_INTG1",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_add_intg1

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_add_intg2(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: VALUES(:,:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_ADD_INTG2",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_add(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Adding values to an integer PETSc distributed matrix is not implemented.",err,error,*999)
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_ADD_INTG2")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_ADD_INTG2",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_add_intg2

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_add_sp(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    REAL(SP), INTENT(IN) :: VALUES(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_ADD_SP",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_add(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Adding values to a single precision PETSc distributed matrix is not implemented.",err,error,*999)
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_ADD_SP")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_ADD_SP",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_add_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_add_sp1(DISTRIBUTED_MATRIX,ROW_INDEX,COLUMN_INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDEX
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDEX
    REAL(SP), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_ADD_SP1",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_add(distributed_matrix%CMISS%MATRIX,row_index,column_index,VALUE,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Adding values to a single precision PETSc distributed matrix is not implemented.",err,error,*999)
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_ADD_SP1")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_ADD_SP1",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_add_sp1

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_add_sp2(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    REAL(SP), INTENT(IN) :: VALUES(:,:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
   
    enters("DISTRIBUTED_MATRIX_VALUES_ADD_SP2",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_add(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Adding values to a single precision PETSc distributed matrix is not implemented.",err,error,*999)
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_ADD_SP2")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_ADD_SP2",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_add_sp2

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_add_dp(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    REAL(DP), INTENT(IN) :: VALUES(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: i
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_ADD_DP",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_add(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            IF(SIZE(row_indices,1)==SIZE(values,1)) THEN
              IF(SIZE(column_indices,1)==SIZE(values,1)) THEN
                IF(distributed_matrix%PETSC%USE_OVERRIDE_MATRIX) THEN
                  DO i=1,SIZE(row_indices,1)
                    !Use global matrix row and column numbers
                    CALL petsc_matsetvalues(distributed_matrix%PETSC%OVERRIDE_MATRIX,1,distributed_matrix%PETSC% &
                      & global_row_numbers(row_indices(i:i)),1,column_indices(i:i)-1,values(i:i),petsc_add_values, &
                      & err,error,*999) !PETSc uses 0 indicies
                  ENDDO !i
                ELSE
                  DO i=1,SIZE(row_indices,1)
                    !Use global matrix row and column numbers
                    CALL petsc_matsetvalues(distributed_matrix%PETSC%MATRIX,1,distributed_matrix%PETSC% &
                      & global_row_numbers(row_indices(i:i)),1,column_indices(i:i)-1,values(i:i),petsc_add_values, &
                      & err,error,*999) !PETSc uses 0 indicies
                  ENDDO !i
                ENDIF
              ELSE
                local_error="The size of the column indices array ("// &
                  & trim(numbertovstring(SIZE(column_indices,1),"*",err,error))// &
                  & ") does not conform to the size of the values array ("// &
                  & trim(numbertovstring(SIZE(values,1),"*",err,error))//")."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              local_error="The size of the row indices array ("// &
                & trim(numbertovstring(SIZE(row_indices,1),"*",err,error))// &
                & ") does not conform to the size of the values array ("// &
                & trim(numbertovstring(SIZE(values,1),"*",err,error))//")."
              CALL flagerror(local_error,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("The distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_ADD_DP")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_ADD_DP",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_add_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_add_dp1(DISTRIBUTED_MATRIX,ROW_INDEX,COLUMN_INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDEX
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDEX
    REAL(DP), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: PETSC_COL_INDEX(1)
    REAL(DP) :: PETSC_VALUE(1)
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_ADD_DP1",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_add(distributed_matrix%CMISS%MATRIX,row_index,column_index,VALUE,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            !Use global matrix row and column numbers
            petsc_col_index(1)=column_index-1
            petsc_value(1)=VALUE
            IF(distributed_matrix%PETSC%USE_OVERRIDE_MATRIX) THEN
              CALL petsc_matsetvalue(distributed_matrix%PETSC%OVERRIDE_MATRIX,distributed_matrix%PETSC%GLOBAL_ROW_NUMBERS( &
                & row_index),column_index-1,VALUE,petsc_add_values,err,error,*999) !PETSc uses 0 based indices
            ELSE
              CALL petsc_matsetvalue(distributed_matrix%PETSC%MATRIX,distributed_matrix%PETSC%GLOBAL_ROW_NUMBERS( &
                & row_index),column_index-1,VALUE,petsc_add_values,err,error,*999) !PETSc uses 0 based indices
            ENDIF
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_ADD_DP1")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_ADD_DP1",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_add_dp1

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_add_dp2(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    REAL(DP), INTENT(IN) :: VALUES(:,:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: GLOBAL_ROW_INDICES(size(row_indices)),i
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_ADD_DP2",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_add(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            IF(SIZE(row_indices,1)==SIZE(values,1)) THEN
              IF(SIZE(column_indices,1)==SIZE(values,2)) THEN                
                DO i=1,SIZE(row_indices,1)
                  global_row_indices(i)=distributed_matrix%PETSC%GLOBAL_ROW_NUMBERS(row_indices(i))
                ENDDO !i
                IF(distributed_matrix%PETSC%USE_OVERRIDE_MATRIX) THEN
                  CALL petsc_matsetvalues(distributed_matrix%PETSC%OVERRIDE_MATRIX,SIZE(row_indices,1),global_row_indices, &
                    & SIZE(column_indices,1),column_indices-1,values,petsc_add_values,err,error,*999) !PETSc uses 0 based indices
                ELSE
                  CALL petsc_matsetvalues(distributed_matrix%PETSC%MATRIX,SIZE(row_indices,1),global_row_indices, &
                    & SIZE(column_indices,1),column_indices-1,values,petsc_add_values,err,error,*999) !PETSc uses 0 based indices
                ENDIF
              ELSE
                local_error="The size of the column indices array ("// &
                  & trim(numbertovstring(SIZE(column_indices,1),"*",err,error))// &
                  & ") does not conform to the number of columns in the values array ("// &
                  & trim(numbertovstring(SIZE(values,2),"*",err,error))//")."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              local_error="The size of the row indices array ("// &
                & trim(numbertovstring(SIZE(row_indices,1),"*",err,error))// &
                & ") does not conform to the number of rows in the values array ("// &
                & trim(numbertovstring(SIZE(values,1),"*",err,error))//")."
              CALL flagerror(local_error,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("The distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_ADD_DP2")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_ADD_DP2",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_add_dp2

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_add_l(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    LOGICAL, INTENT(IN) :: VALUES(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_ADD_L",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_add(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Adding values to a logical PETSc distributed matrix is not implemented.",err,error,*999)
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_ADD_L")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_ADD_L",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_add_l

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_add_l1(DISTRIBUTED_MATRIX,ROW_INDEX,COLUMN_INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDEX
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDEX
    LOGICAL, INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_ADD_L1",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_add(distributed_matrix%CMISS%MATRIX,row_index,column_index,VALUE,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Adding values to a logical PETSc distributed matrix is not implemented.",err,error,*999)
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_ADD_L1")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_ADD_L1",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_add_l1

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_add_l2(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    LOGICAL, INTENT(IN) :: VALUES(:,:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_ADD_L2",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_add(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Adding values to a logical PETSc distributed matrix is not implemented.",err,error,*999)
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_ADD_L2")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_ADD_L2",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_add_l2

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_get_intg(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    INTEGER(INTG), INTENT(OUT) :: VALUES(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_GET_INTG",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_get(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for an integer PETSc distributed matrix.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_GET_INTG")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_GET_INTG",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_get_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_get_intg1(DISTRIBUTED_MATRIX,ROW_INDEX,COLUMN_INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDEX
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDEX
    INTEGER(INTG), INTENT(OUT) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_GET_INTG1",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_get(distributed_matrix%CMISS%MATRIX,row_index,column_index,VALUE,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for an integer PETSc distributed matrix.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_GET_INTG1")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_GET_INTG1",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_get_intg1

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_get_intg2(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    INTEGER(INTG), INTENT(OUT) :: VALUES(:,:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_GET_INTG2",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_get(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for an integer PETSc distributed matrix.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_GET_INTG2")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_GET_INTG2",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_get_intg2

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_get_sp(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    REAL(SP), INTENT(OUT) :: VALUES(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_GET_SP",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_get(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for a single precision PETSc distributed matrix.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_GET_SP")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_GET_SP",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_get_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_get_sp1(DISTRIBUTED_MATRIX,ROW_INDEX,COLUMN_INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDEX
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDEX
    REAL(SP), INTENT(OUT) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_GET_SP1",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_get(distributed_matrix%CMISS%MATRIX,row_index,column_index,VALUE,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for a single precision PETSc distributed matrix.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_GET_SP1")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_GET_SP1",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_get_sp1

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_get_sp2(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    REAL(SP), INTENT(OUT) :: VALUES(:,:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_GET_SP2",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_get(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for a single precision PETSc distributed matrix.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_GET_SP2")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_GET_SP2",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_get_sp2

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_get_dp(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    REAL(DP), INTENT(OUT) :: VALUES(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: i
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_GET_DP",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_get(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            IF(SIZE(row_indices,1)==SIZE(values,1)) THEN
              IF(SIZE(column_indices,1)==SIZE(values,1)) THEN
                IF(distributed_matrix%PETSC%USE_OVERRIDE_MATRIX) THEN
                  DO i=1,SIZE(row_indices,1)
                    CALL petsc_matgetvalues(distributed_matrix%PETSC%OVERRIDE_MATRIX,1,distributed_matrix%PETSC% &
                      & global_row_numbers(row_indices(i:i)),1,column_indices(i:i)-1,values(i:i), &
                      & err,error,*999) !PETSc uses 0 based indices
                  ENDDO !i
                ELSE
                  DO i=1,SIZE(row_indices,1)
                    CALL petsc_matgetvalues(distributed_matrix%PETSC%MATRIX,1,distributed_matrix%PETSC%GLOBAL_ROW_NUMBERS( &
                      & row_indices(i:i)),1,column_indices(i:i)-1,values(i:i),err,error,*999) !PETSc uses 0 based indices
                  ENDDO !i
                ENDIF
              ELSE
                local_error="The size of the column indices array ("// &
                  & trim(numbertovstring(SIZE(column_indices,1),"*",err,error))// &
                  & ") does not conform to the size of the values array ("// &
                  & trim(numbertovstring(SIZE(values,1),"*",err,error))//")."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              local_error="The size of the row indices array ("// &
                & trim(numbertovstring(SIZE(row_indices,1),"*",err,error))// &
                & ") does not conform to the size of the values array ("// &
                & trim(numbertovstring(SIZE(values,1),"*",err,error))//")."
              CALL flagerror(local_error,err,error,*999)
            ENDIF            
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_GET_DP")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_GET_DP",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_get_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_get_dp1(DISTRIBUTED_MATRIX,ROW_INDEX,COLUMN_INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDEX
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDEX
    REAL(DP), INTENT(OUT) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: COLUMN_INDICES(1)
    REAL(DP) :: VALUES(1)
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_GET_DP1",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_get(distributed_matrix%CMISS%MATRIX,row_index,column_index,VALUE,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            column_indices(1)=column_index-1
            IF(distributed_matrix%PETSC%USE_OVERRIDE_MATRIX) THEN              
              CALL petsc_matgetvalues(distributed_matrix%PETSC%OVERRIDE_MATRIX,1,distributed_matrix%PETSC% &
                & global_row_numbers(row_index),1,column_indices,values,err,error,*999) !PETSc uses 0 based indices
            ELSE
              CALL petsc_matgetvalues(distributed_matrix%PETSC%MATRIX,1,distributed_matrix%PETSC%GLOBAL_ROW_NUMBERS(row_index), &
                & 1,column_indices,values,err,error,*999) !PETSc uses 0 based indices
            ENDIF
            VALUE=values(1)
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_GET_DP1")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_GET_DP1",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_get_dp1

  !
  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_get_dp2(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    REAL(DP), INTENT(OUT) :: VALUES(:,:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: GLOBAL_ROW_INDICES(size(row_indices,1)),i
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_GET_DP2",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_get(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for an integer precision PETSc distributed matrix.",err,error,*999)          
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            IF(SIZE(row_indices,1)==SIZE(values,1)) THEN
              IF(SIZE(column_indices,1)==SIZE(values,2)) THEN
                DO i=1,SIZE(row_indices,1)
                  global_row_indices(i)=distributed_matrix%PETSC%GLOBAL_ROW_NUMBERS(row_indices(i))
                ENDDO !i
                IF(distributed_matrix%PETSC%USE_OVERRIDE_MATRIX) THEN
                  CALL petsc_matgetvalues(distributed_matrix%PETSC%OVERRIDE_MATRIX,SIZE(row_indices,1),global_row_indices, &
                    & SIZE(column_indices,1),column_indices-1,values,err,error,*999) !PETSc uses 0 based row indices
                ELSE
                  CALL petsc_matgetvalues(distributed_matrix%PETSC%MATRIX,SIZE(row_indices,1),global_row_indices, &
                    & SIZE(column_indices,1),column_indices-1,values,err,error,*999) !PETSc uses 0 based row indices
                ENDIF
              ELSE
                local_error="The size of the column indices array ("// &
                  & trim(numbertovstring(SIZE(column_indices,1),"*",err,error))// &
                  & ") does not conform to the number of columns in the values array ("// &
                  & trim(numbertovstring(SIZE(values,2),"*",err,error))//")."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              local_error="The size of the row indices array ("// &
                & trim(numbertovstring(SIZE(row_indices,1),"*",err,error))// &
                & ") does not conform to the number of rows in the values array ("// &
                & trim(numbertovstring(SIZE(values,1),"*",err,error))//")."
              CALL flagerror(local_error,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_GET_DP2")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_GET_DP2",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_get_dp2

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_get_l(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    LOGICAL, INTENT(OUT) :: VALUES(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_GET_L",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_get(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for a logical PETSc distributed matrix.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_GET_L")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_GET_L",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_get_l

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_get_l1(DISTRIBUTED_MATRIX,ROW_INDEX,COLUMN_INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDEX
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDEX
    LOGICAL, INTENT(OUT) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
   
    enters("DISTRIBUTED_MATRIX_VALUES_GET_L1",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_get(distributed_matrix%CMISS%MATRIX,row_index,column_index,VALUE,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for a logical PETSc distributed matrix.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_GET_L1")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_GET_L1",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_get_l1

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_get_l2(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    LOGICAL, INTENT(OUT) :: VALUES(:,:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_GET_L2",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_get(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for a logical PETSc distributed matrix.",err,error,*999)                    
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_GET_L2")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_GET_L2",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_get_l2

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_set_intg(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: VALUES(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_SET_INTG",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_set(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for an integer PETSc distributed matrix.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_SET_INTG")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_SET_INTG",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_set_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_set_intg1(DISTRIBUTED_MATRIX,ROW_INDEX,COLUMN_INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDEX
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDEX
    INTEGER(INTG), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_SET_INTG1",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_set(distributed_matrix%CMISS%MATRIX,row_index,column_index,VALUE,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for an integer PETSc distributed matrix.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_SET_INTG1")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_SET_INTG1",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_set_intg1

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_set_intg2(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: VALUES(:,:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_SET_INTG2",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_set(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for an integer PETSc distributed matrix.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_SET_INTG2")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_SET_INTG2",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_set_intg2

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_set_sp(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    REAL(SP), INTENT(IN) :: VALUES(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_SET_SP",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_set(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for a single precision PETSc distributed matrix.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_SET_SP")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_SET_SP",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_set_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_set_sp1(DISTRIBUTED_MATRIX,ROW_INDEX,COLUMN_INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDEX
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDEX
    REAL(SP), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_SET_SP1",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_set(distributed_matrix%CMISS%MATRIX,row_index,column_index,VALUE,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for a single precision PETSc distributed matrix.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_SET_SP1")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_SET_SP1",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_set_sp1

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_set_sp2(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    REAL(SP), INTENT(IN) :: VALUES(:,:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_SET_SP2",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_set(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot get values for a single precision PETSc distributed matrix.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_SET_SP2")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_SET_SP2",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_set_sp2

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_set_dp(DISTRIBUTED_MATRIX,ROW_INDICES,COLUMN_INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG), INTENT(IN) :: ROW_INDICES(:)
    INTEGER(INTG), INTENT(IN) :: COLUMN_INDICES(:)
    REAL(DP), INTENT(IN) :: VALUES(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: i
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_SET_DP",err,error,*999)

    IF(ASSOCIATED(distributed_matrix)) THEN
      IF(distributed_matrix%MATRIX_FINISHED) THEN
        SELECT CASE(distributed_matrix%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_matrix%CMISS)) THEN
            CALL matrix_values_set(distributed_matrix%CMISS%MATRIX,row_indices,column_indices,values,err,error,*999)
          ELSE
            CALL flagerror("Distributed matrix CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            IF(SIZE(row_indices,1)==SIZE(values,1)) THEN
              IF(SIZE(column_indices,1)==SIZE(values,1)) THEN
                IF(distributed_matrix%PETSC%USE_OVERRIDE_MATRIX) THEN
                  DO i=1,SIZE(row_indices,1)
                    CALL petsc_matsetvalues(distributed_matrix%PETSC%OVERRIDE_MATRIX,1,distributed_matrix%PETSC% &
                      & global_row_numbers(row_indices(i:i)),1,column_indices(i:i)-1,values(i:i),petsc_insert_values, &
                      & err,error,*999) !0 based indices
                  ENDDO !i
                ELSE
                  DO i=1,SIZE(row_indices,1)
                    CALL petsc_matsetvalues(distributed_matrix%PETSC%MATRIX,1,distributed_matrix%PETSC%GLOBAL_ROW_NUMBERS( &
                      & row_indices(i:i)),1,column_indices(i:i)-1,values(i:i),petsc_insert_values,err,error,*999) !0 based indices
                  ENDDO !i
                ENDIF
              ELSE
                local_error="The size of the column indices array ("// &
                  & trim(numbertovstring(SIZE(column_indices,1),"*",err,error))// &
                  & ") does not conform to the size of the values array ("// &
                  & trim(numbertovstring(SIZE(values,1),"*",err,error))//")."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              local_error="The size of the row indices array ("// &
                & trim(numbertovstring(SIZE(row_indices,1),"*",err,error))// &
                & ") does not conform to the size of the values array ("// &
                & trim(numbertovstring(SIZE(values,1),"*",err,error))//")."
              CALL flagerror(local_error,err,error,*999)
            ENDIF            
          ELSE
            CALL flagerror("Distributed matrix PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed matrix library type of "// &
            & trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed matrix has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed matrix is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_MATRIX_VALUES_SET_DP")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_SET_DP",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_set_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_matrix_values_set_dp1(DISTRIBUTED_MATRIX,ROW_INDEX,COLUMN_INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    INTEGER(INTG)