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), 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
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_SET_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_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)
          IF(ASSOCIATED(distributed_matrix%PETSC)) THEN
            IF(distributed_matrix%PETSC%USE_OVERRIDE_MATRIX) THEN
              CALL petsc_matsetvalues(distributed_matrix%PETSC%OVERRIDE_MATRIX,1,distributed_matrix%PETSC%GLOBAL_ROW_NUMBERS( &
                & row_index),1,(/column_index-1/),(/VALUE/),petsc_insert_values,err,error,*999) !PETSc uses 0 based indices
            ELSE
              CALL petsc_matsetvalues(distributed_matrix%PETSC%MATRIX,1,distributed_matrix%PETSC%GLOBAL_ROW_NUMBERS(row_index), &
                & 1,(/column_index-1/),(/VALUE/),petsc_insert_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_SET_DP1")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_SET_DP1",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_set_dp1

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

  SUBROUTINE distributed_matrix_values_set_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,1)),i
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_MATRIX_VALUES_SET_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_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,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_insert_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_insert_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_SET_DP2")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_SET_DP2",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_set_dp2

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

  SUBROUTINE distributed_matrix_values_set_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_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_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 set 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_SET_L")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_SET_L",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_set_l

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

  SUBROUTINE distributed_matrix_values_set_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_SET_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_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 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_SET_L1")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_SET_L1",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_set_l1

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

  SUBROUTINE distributed_matrix_values_set_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_SET_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_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 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_SET_L2")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_VALUES_SET_L2",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_values_set_l2

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

  SUBROUTINE distributed_matrix_by_vector_add(ROW_SELECTION_TYPE,ALPHA,DISTRIBUTED_MATRIX,DISTRIBUTED_VECTOR,DISTRIBUTED_PRODUCT, &
    & err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ROW_SELECTION_TYPE
    REAL(DP), INTENT(IN) :: ALPHA
    TYPE(distributed_matrix_type), POINTER :: DISTRIBUTED_MATRIX
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_PRODUCT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: column_idx,local_column,global_column,NUMBER_OF_COLUMNS,NUMBER_OF_ROWS,row,row_idx
    REAL(DP) :: SUM
    TYPE(distributed_matrix_cmiss_type), POINTER :: CMISS_MATRIX
    TYPE(distributed_vector_cmiss_type), POINTER :: CMISS_VECTOR,CMISS_PRODUCT
    TYPE(domain_mapping_type), POINTER :: ROW_MAPPING,COLUMN_MAPPING
    TYPE(matrix_type), POINTER :: MATRIX
    TYPE(varying_string) :: LOCAL_ERROR

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

    IF(abs(alpha)>zero_tolerance) THEN
      IF(ASSOCIATED(distributed_matrix)) THEN
        IF(distributed_matrix%MATRIX_FINISHED) THEN
          IF(ASSOCIATED(distributed_vector)) THEN
            IF(distributed_vector%VECTOR_FINISHED) THEN
              IF(ASSOCIATED(distributed_product)) THEN
                IF(distributed_product%VECTOR_FINISHED) THEN
                  IF(distributed_matrix%LIBRARY_TYPE==distributed_vector%LIBRARY_TYPE) THEN
                    IF(distributed_matrix%LIBRARY_TYPE==distributed_product%LIBRARY_TYPE) THEN
                      column_mapping=>distributed_matrix%COLUMN_DOMAIN_MAPPING
                      IF(ASSOCIATED(column_mapping)) THEN
                        row_mapping=>distributed_matrix%ROW_DOMAIN_MAPPING
                        IF(ASSOCIATED(row_mapping)) THEN
                          IF(ASSOCIATED(column_mapping,distributed_vector%DOMAIN_MAPPING)) THEN
                            IF(ASSOCIATED(row_mapping,distributed_product%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
                                  matrix=>cmiss_matrix%MATRIX
                                  IF(ASSOCIATED(matrix)) THEN
                                    cmiss_vector=>distributed_vector%CMISS
                                    IF(ASSOCIATED(cmiss_vector)) THEN
                                      cmiss_product=>distributed_product%CMISS
                                      IF(ASSOCIATED(cmiss_product)) THEN
                                        SELECT CASE(row_selection_type)
                                        CASE(distributed_matrix_vector_include_ghosts_type)
                                          number_of_rows=row_mapping%TOTAL_NUMBER_OF_LOCAL
                                        CASE(distributed_matrix_vector_no_ghosts_type)
                                          number_of_rows=row_mapping%NUMBER_OF_LOCAL
                                        CASE DEFAULT
                                          local_error="The row selection type of "// &
                                            & trim(numbertovstring(row_selection_type,"*",err,error))//" is invalid."
                                          CALL flagerror(local_error,err,error,*999)
                                        END SELECT
                                        number_of_columns=column_mapping%NUMBER_OF_GLOBAL
                                        IF(matrix%DATA_TYPE==distributed_vector%DATA_TYPE) THEN
                                          IF(matrix%DATA_TYPE==distributed_product%DATA_TYPE) THEN
                                            SELECT CASE(matrix%DATA_TYPE)
                                            CASE(distributed_matrix_vector_intg_type)
                                              CALL flagerror("Not implemented.",err,error,*999)
                                            CASE(distributed_matrix_vector_sp_type)
                                              CALL flagerror("Not implemented.",err,error,*999)
                                            CASE(distributed_matrix_vector_dp_type)
                                              SELECT CASE(matrix%STORAGE_TYPE)
                                              CASE(matrix_block_storage_type)
                                                DO row=1,number_of_rows
                                                  sum=0.0_dp
                                                  DO local_column=1,column_mapping%TOTAL_NUMBER_OF_LOCAL
                                                    global_column=column_mapping%LOCAL_TO_GLOBAL_MAP(local_column)
                                                    sum=sum+matrix%DATA_DP(row+(global_column-1)*matrix%M)* &
                                                      & cmiss_vector%DATA_DP(local_column)
                                                  ENDDO !local_column
                                                  cmiss_product%DATA_DP(row)=cmiss_product%DATA_DP(row)+(alpha*sum)
                                                ENDDO !row
                                              CASE(matrix_diagonal_storage_type)
                                                DO row=1,number_of_rows
                                                  sum=matrix%DATA_DP(row)*cmiss_vector%DATA_DP(row)
                                                  cmiss_product%DATA_DP(row)=cmiss_product%DATA_DP(row)+(alpha*sum)
                                                ENDDO !row
                                              CASE(matrix_column_major_storage_type)
                                                DO row=1,number_of_rows
                                                  sum=0.0_dp
                                                  DO local_column=1,column_mapping%TOTAL_NUMBER_OF_LOCAL
                                                    global_column=column_mapping%LOCAL_TO_GLOBAL_MAP(local_column)
                                                    sum=sum+matrix%DATA_DP(row+(global_column-1)*matrix%MAX_M)* &
                                                      & cmiss_vector%DATA_DP(local_column)
                                                  ENDDO !local_column
                                                  cmiss_product%DATA_DP(row)=cmiss_product%DATA_DP(row)+(alpha*sum)
                                                ENDDO !row
                                              CASE(matrix_row_major_storage_type)
                                                DO row=1,number_of_rows
                                                  sum=0.0_dp
                                                  DO local_column=1,column_mapping%TOTAL_NUMBER_OF_LOCAL
                                                    global_column=column_mapping%LOCAL_TO_GLOBAL_MAP(local_column)
                                                    sum=sum+matrix%DATA_DP((row-1)*matrix%MAX_N+global_column)* &
                                                      & cmiss_vector%DATA_DP(local_column)
                                                  ENDDO !local_column
                                                  cmiss_product%DATA_DP(row)=cmiss_product%DATA_DP(row)+(alpha*sum)
                                                ENDDO !row
                                              CASE(matrix_compressed_row_storage_type)
                                                DO row=1,number_of_rows
                                                  sum=0.0_dp
                                                  DO column_idx=matrix%ROW_INDICES(row),matrix%ROW_INDICES(row+1)-1
                                                    global_column=matrix%COLUMN_INDICES(column_idx)
                                                    !This ranks global to local mappings are stored in the first position
                                                    local_column=column_mapping%GLOBAL_TO_LOCAL_MAP(global_column)%LOCAL_NUMBER(1)
                                                    sum=sum+matrix%DATA_DP(column_idx)* &
                                                      & cmiss_vector%DATA_DP(local_column)
                                                  ENDDO !local_column
                                                  cmiss_product%DATA_DP(row)=cmiss_product%DATA_DP(row)+(alpha*sum)
                                                ENDDO !row
                                              CASE(matrix_compressed_column_storage_type)
                                                DO column_idx=1,number_of_columns
                                                  DO row_idx=matrix%COLUMN_INDICES(column_idx),matrix%COLUMN_INDICES(column_idx+1)-1
                                                    row=matrix%ROW_INDICES(row_idx)
                                                    local_column=column_mapping%GLOBAL_TO_LOCAL_MAP(column_idx)%LOCAL_NUMBER(1)
                                                    sum=matrix%DATA_DP(row_idx)* &
                                                      & cmiss_vector%DATA_DP(local_column)
                                                    cmiss_product%DATA_DP(row)=cmiss_product%DATA_DP(row)+(alpha*sum)
                                                  ENDDO !local_row
                                                ENDDO !column_idx
                                              CASE(matrix_row_column_storage_type)
                                                CALL flagerror("Not implemented.",err,error,*999)
                                              CASE DEFAULT
                                                local_error="The matrix storage type of "// &
                                                  & trim(numbertovstring(matrix%STORAGE_TYPE,"*",err,error))//" is invalid."

                                                CALL flagerror(local_error,err,error,*999)
                                              END SELECT
                                            CASE(distributed_matrix_vector_l_type)
                                              CALL flagerror("Not implemented.",err,error,*999)
                                            CASE DEFAULT
                                              local_error="The distributed matrix vector data type of "// &
                                                & trim(numbertovstring(matrix%DATA_TYPE,"*",err,error))//" is invalid."
                                              CALL flagerror(local_error,err,error,*999)
                                            END SELECT
                                          ELSE
                                            local_error="The distributed product vector data type of "// &
                                              & trim(numbertovstring(distributed_product%DATA_TYPE,"*",err,error))// &
                                              & " does not match the distributed matrix data type of "// &
                                              & trim(numbertovstring(matrix%DATA_TYPE,"*",err,error))//"."
                                            CALL flagerror(local_error,err,error,*999)
                                          ENDIF
                                        ELSE
                                          local_error="The distributed vector data type of "// &
                                            & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
                                            & " does not match the distributed matrix data type of "// &
                                            & trim(numbertovstring(matrix%DATA_TYPE,"*",err,error))//"."
                                          CALL flagerror(local_error,err,error,*999)
                                        ENDIF
                                      ELSE
                                        CALL flagerror("Distributed product CMISS vector is not associated.",err,error,*999)
                                      ENDIF
                                    ELSE
                                      CALL flagerror("Distributed vector CMISS vector is not associated.",err,error,*999)
                                    ENDIF
                                  ELSE
                                    CALL flagerror("CMISS matrix matrix is not associated.",err,error,*999)
                                  ENDIF
                                ELSE
                                  CALL flagerror("Distrubuted matrix CMISS is not associated.",err,error,*999)
                                ENDIF
                              CASE(distributed_matrix_vector_petsc_type)
                                CALL flagerror("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 and the distributed product vector have different "// &
                                & "domain mappings.",err,error,*999)
                            ENDIF
                          ELSE
                            CALL flagerror("The distributed matrix and the distributed vector have different domain mappings.", &
                              & err,error,*999)
                          ENDIF
                        ELSE
                          CALL flagerror("The distributed matrix row domain mapping is not associated.",err,error,*999)
                        ENDIF
                      ELSE
                        CALL flagerror("The distributed matrix column domain mapping is not associated.",err,error,*999)
                      ENDIF
                    ELSE
                      local_error="The distributed product vector library type of "// &
                        & trim(numbertovstring(distributed_product%LIBRARY_TYPE,"*",err,error))// &
                        & " does not match the distributed matrix library type of "// &
                        &  trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//"."
                      CALL flagerror(local_error,err,error,*999)
                    ENDIF
                  ELSE
                    local_error="The distributed vector library type of "// &
                      & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))// &
                      & " does not match the distributed matrix library type of "// &
                      &  trim(numbertovstring(distributed_matrix%LIBRARY_TYPE,"*",err,error))//"."
                    CALL flagerror(local_error,err,error,*999)
                  ENDIF
                ELSE
                  CALL flagerror("The distributed product vector has not been finished.",err,error,*999)
                ENDIF
              ELSE
                CALL flagerror("The distributed product vector is not associated.",err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector has not been finished.",err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distrubuted vector is not associated.",err,error,*999)
          ENDIF
        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
    ENDIF
    exits("DISTRIBUTED_MATRIX_BY_VECTOR_ADD")
    RETURN
999 errorsexits("DISTRIBUTED_MATRIX_BY_VECTOR_ADD",err,error)
    RETURN 1
  END SUBROUTINE distributed_matrix_by_vector_add
  
  !
  !================================================================================================================================
  !
  
  SUBROUTINE distributed_vector_all_values_set_intg(DISTRIBUTED_VECTOR,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    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_VECTOR_ALL_VALUES_SET_INTG",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_intg_type) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              distributed_vector%CMISS%DATA_INTG=VALUE
            ELSE
              CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot get values for an integer PETSc distributed vector.",err,error,*999)          
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          local_error="The data type of "//trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the integer data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF

    exits("DISTRIBUTED_VECTOR_ALL_VALUES_SET_INTG")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_ALL_VALUES_SET_INTG",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_all_values_set_intg

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

  SUBROUTINE distributed_vector_all_values_set_sp(DISTRIBUTED_VECTOR,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    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_VECTOR_ALL_VALUES_SET_SP",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_sp_type) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              distributed_vector%CMISS%DATA_SP=VALUE
            ELSE
              CALL flagerror("Distributed vector 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 vector.",err,error,*999)          
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          local_error="The data type of "//trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the single precision data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF

    exits("DISTRIBUTED_VECTOR_ALL_VALUES_SET_SP")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_ALL_VALUES_SET_SP",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_all_values_set_sp

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

  SUBROUTINE distributed_vector_all_values_set_dp(DISTRIBUTED_VECTOR,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    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_VECTOR_ALL_VALUES_SET_DP",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_dp_type) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              distributed_vector%CMISS%DATA_DP=VALUE
            ELSE
              CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            IF(ASSOCIATED(distributed_vector%PETSC)) THEN
              IF(distributed_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
                CALL petsc_vecset(distributed_vector%PETSC%OVERRIDE_VECTOR,VALUE,err,error,*999)
              ELSE
                CALL petsc_vecset(distributed_vector%PETSC%VECTOR,VALUE,err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
            ENDIF
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          local_error="The data type of "//trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the double precision data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF

    exits("DISTRIBUTED_VECTOR_ALL_VALUES_SET_DP")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_ALL_VALUES_SET_DP",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_all_values_set_dp

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

  SUBROUTINE distributed_vector_all_values_set_l(DISTRIBUTED_VECTOR,VALUE,ERR,ERROR,*)

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

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

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_l_type) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              distributed_vector%CMISS%DATA_L=VALUE
            ELSE
              CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot get values for a logical PETSc distributed vector.",err,error,*999)          
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          local_error="The data type of "//trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the logical data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF

    exits("DISTRIBUTED_VECTOR_ALL_VALUES_SET_L")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_ALL_VALUES_SET_L",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_all_values_set_l

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

  SUBROUTINE distributed_vector_copy_intg(FROM_VECTOR,TO_VECTOR,ALPHA,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: FROM_VECTOR
    TYPE(distributed_vector_type), POINTER :: TO_VECTOR
    INTEGER(INTG), INTENT(IN) :: ALPHA
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_VECTOR_COPY_INTG",err,error,*999)

    IF(ASSOCIATED(from_vector)) THEN
      IF(from_vector%VECTOR_FINISHED) THEN
        IF(ASSOCIATED(to_vector)) THEN
          IF(to_vector%VECTOR_FINISHED) THEN
            IF(from_vector%DATA_TYPE==to_vector%DATA_TYPE) THEN
              IF(from_vector%DATA_TYPE==distributed_matrix_vector_intg_type) THEN
                IF(from_vector%LIBRARY_TYPE==to_vector%LIBRARY_TYPE) THEN
                  !Vectors are of the same library type
                  SELECT CASE(from_vector%LIBRARY_TYPE)
                  CASE(distributed_matrix_vector_cmiss_type)
                    IF(ASSOCIATED(from_vector%CMISS)) THEN
                      IF(ASSOCIATED(to_vector%CMISS)) THEN
                        IF(ASSOCIATED(from_vector%DOMAIN_MAPPING,to_vector%DOMAIN_MAPPING)) THEN
                          to_vector%CMISS%DATA_INTG(1:to_vector%CMISS%N)=alpha*from_vector%CMISS%DATA_INTG(1:from_vector%CMISS%N)
                        ELSE
                          CALL flagerror("The from vector does not have the same domain mapping as the to vector.",err,error,*999)
                        ENDIF
                      ELSE
                        CALL flagerror("To vector CMISS is not associated.",err,error,*999)
                      ENDIF
                    ELSE
                      CALL flagerror("From vector CMISS is not associated.",err,error,*999)
                    ENDIF
                  CASE(distributed_matrix_vector_petsc_type)
                    CALL flagerror("Cannot copy a vector fro an integer PETSc distributed vector.",err,error,*999)
                  CASE DEFAULT
                    local_error="The from vector library type of "// &
                      & trim(numbertovstring(from_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
                    CALL flagerror(local_error,err,error,*999)
                  END SELECT
                ELSE
                  !Vectors are of from different library types
                  CALL flagerror("Not implemented.",err,error,*999)
                ENDIF
              ELSE
                local_error="The from vector data type of "//trim(numbertovstring(from_vector%DATA_TYPE,"*",err,error))// &
                  & " does not match the integer data type of the supplied alpha value."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              local_error="The from vector data type of "// &
                & trim(numbertovstring(from_vector%DATA_TYPE,"*",err,error))// &
                & " does not match the to vector data type of "// &
                & trim(numbertovstring(to_vector%DATA_TYPE,"*",err,error))//"."
              CALL flagerror(local_error,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("To vector has not been finished.",err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("To vector is not associated.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("From vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("From vector is not associated.",err,error,*999)
    ENDIF
     
    exits("DISTRIBUTED_VECTOR_COPY_INTG")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_COPY_INTG",err,error)
    RETURN 1
    
  END SUBROUTINE distributed_vector_copy_intg

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

  SUBROUTINE distributed_vector_copy_dp(FROM_VECTOR,TO_VECTOR,ALPHA,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: FROM_VECTOR
    TYPE(distributed_vector_type), POINTER :: TO_VECTOR
    REAL(DP), INTENT(IN) :: ALPHA
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_VECTOR_COPY_DP",err,error,*999)

    IF(ASSOCIATED(from_vector)) THEN
      IF(from_vector%VECTOR_FINISHED) THEN
        IF(ASSOCIATED(to_vector)) THEN
          IF(to_vector%VECTOR_FINISHED) THEN
            IF(from_vector%DATA_TYPE==to_vector%DATA_TYPE) THEN
              IF(from_vector%DATA_TYPE==distributed_matrix_vector_dp_type) THEN
                IF(from_vector%LIBRARY_TYPE==to_vector%LIBRARY_TYPE) THEN
                  !Vectors are of the same library type
                  SELECT CASE(from_vector%LIBRARY_TYPE)
                  CASE(distributed_matrix_vector_cmiss_type)
                    IF(ASSOCIATED(from_vector%CMISS)) THEN
                      IF(ASSOCIATED(to_vector%CMISS)) THEN
                        IF(ASSOCIATED(from_vector%DOMAIN_MAPPING,to_vector%DOMAIN_MAPPING)) THEN
                          to_vector%CMISS%DATA_DP(1:to_vector%CMISS%N)=alpha*from_vector%CMISS%DATA_DP(1:from_vector%CMISS%N)
                        ELSE
                          CALL flagerror("The from vector does not have the same domain mapping as the to vector.",err,error,*999)
                        ENDIF
                      ELSE
                        CALL flagerror("To vector CMISS is not associated.",err,error,*999)
                      ENDIF
                    ELSE
                      CALL flagerror("From vector CMISS is not associated.",err,error,*999)
                    ENDIF
                  CASE(distributed_matrix_vector_petsc_type)
                    IF(ASSOCIATED(from_vector%PETSC)) THEN
                      IF(ASSOCIATED(to_vector%PETSC)) THEN
                        IF(from_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
                          IF(to_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
                            CALL petsc_veccopy(from_vector%PETSC%OVERRIDE_VECTOR,to_vector%PETSC%OVERRIDE_VECTOR,err,error,*999)
                            CALL petsc_vecscale(to_vector%PETSC%OVERRIDE_VECTOR,alpha,err,error,*999)
                          ELSE
                            CALL petsc_veccopy(from_vector%PETSC%OVERRIDE_VECTOR,to_vector%PETSC%VECTOR,err,error,*999)
                            CALL petsc_vecscale(to_vector%PETSC%VECTOR,alpha,err,error,*999)
                          ENDIF
                        ELSE
                          IF(to_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
                            CALL petsc_veccopy(from_vector%PETSC%VECTOR,to_vector%PETSC%OVERRIDE_VECTOR,err,error,*999)
                            CALL petsc_vecscale(to_vector%PETSC%OVERRIDE_VECTOR,alpha,err,error,*999)
                          ELSE
                            CALL petsc_veccopy(from_vector%PETSC%VECTOR,to_vector%PETSC%VECTOR,err,error,*999)
                            CALL petsc_vecscale(to_vector%PETSC%VECTOR,alpha,err,error,*999)
                          ENDIF
                        ENDIF
                      ELSE
                        CALL flagerror("To vector PETSc is not associated.",err,error,*999)
                      ENDIF
                    ELSE
                      CALL flagerror("From vector PETSc is not associated.",err,error,*999)
                    ENDIF
                  CASE DEFAULT
                    local_error="The from vector library type of "// &
                      & trim(numbertovstring(from_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
                    CALL flagerror(local_error,err,error,*999)
                  END SELECT
                ELSE
                  !Vectors are of from different library types
                  CALL flagerror("Not implemented.",err,error,*999)
                ENDIF
              ELSE
                local_error="The from vector data type of "//trim(numbertovstring(from_vector%DATA_TYPE,"*",err,error))// &
                  & " does not match the double precision data type of the supplied alpha value."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              local_error="The from vector data type of "// &
                & trim(numbertovstring(from_vector%DATA_TYPE,"*",err,error))// &
                & " does not match the to vector data type of "// &
                & trim(numbertovstring(to_vector%DATA_TYPE,"*",err,error))//"."
              CALL flagerror(local_error,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("To vector has not been finished.",err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("To vector is not associated.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("From vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("From vector is not associated.",err,error,*999)
    ENDIF
     
    exits("DISTRIBUTED_VECTOR_COPY_DP")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_COPY_DP",err,error)
    RETURN 1
    
  END SUBROUTINE distributed_vector_copy_dp

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

  SUBROUTINE distributed_vector_copy_sp(FROM_VECTOR,TO_VECTOR,ALPHA,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: FROM_VECTOR
    TYPE(distributed_vector_type), POINTER :: TO_VECTOR
    REAL(SP), INTENT(IN) :: ALPHA
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_VECTOR_COPY_SP",err,error,*999)

    IF(ASSOCIATED(from_vector)) THEN
      IF(from_vector%VECTOR_FINISHED) THEN
        IF(ASSOCIATED(to_vector)) THEN
          IF(to_vector%VECTOR_FINISHED) THEN
            IF(from_vector%DATA_TYPE==to_vector%DATA_TYPE) THEN
              IF(from_vector%DATA_TYPE==distributed_matrix_vector_sp_type) THEN
                IF(from_vector%LIBRARY_TYPE==to_vector%LIBRARY_TYPE) THEN
                  !Vectors are of the same library type
                  SELECT CASE(from_vector%LIBRARY_TYPE)
                  CASE(distributed_matrix_vector_cmiss_type)
                    IF(ASSOCIATED(from_vector%CMISS)) THEN
                      IF(ASSOCIATED(to_vector%CMISS)) THEN
                        IF(ASSOCIATED(from_vector%DOMAIN_MAPPING,to_vector%DOMAIN_MAPPING)) THEN
                          to_vector%CMISS%DATA_SP(1:to_vector%CMISS%N)=alpha*from_vector%CMISS%DATA_SP(1:from_vector%CMISS%N)
                        ELSE
                          CALL flagerror("The from vector does not have the same domain mapping as the to vector.",err,error,*999)
                        ENDIF
                      ELSE
                        CALL flagerror("To vector CMISS is not associated.",err,error,*999)
                      ENDIF
                    ELSE
                      CALL flagerror("From vector CMISS is not associated.",err,error,*999)
                    ENDIF
                  CASE(distributed_matrix_vector_petsc_type)
                    CALL flagerror("Cannot copy a vector for a single precision PETSc distributed vector.",err,error,*999)
                 CASE DEFAULT
                    local_error="The from vector library type of "// &
                      & trim(numbertovstring(from_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
                    CALL flagerror(local_error,err,error,*999)
                  END SELECT
                ELSE
                  !Vectors are of from different library types
                  CALL flagerror("Not implemented.",err,error,*999)
                ENDIF
              ELSE
                local_error="The from vector data type of "//trim(numbertovstring(from_vector%DATA_TYPE,"*",err,error))// &
                  & " does not match the single precision data type of the supplied alpha value."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              local_error="The from vector data type of "// &
                & trim(numbertovstring(from_vector%DATA_TYPE,"*",err,error))// &
                & " does not match the to vector data type of "// &
                & trim(numbertovstring(to_vector%DATA_TYPE,"*",err,error))//"."
              CALL flagerror(local_error,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("To vector has not been finished.",err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("To vector is not associated.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("From vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("From vector is not associated.",err,error,*999)
    ENDIF
     
    exits("DISTRIBUTED_VECTOR_COPY_SP")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_COPY_SP",err,error)
    RETURN 1
    
  END SUBROUTINE distributed_vector_copy_sp

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

  SUBROUTINE distributed_vector_copy_l(FROM_VECTOR,TO_VECTOR,ALPHA,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: FROM_VECTOR
    TYPE(distributed_vector_type), POINTER :: TO_VECTOR
    LOGICAL, INTENT(IN) :: ALPHA
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_VECTOR_COPY_L",err,error,*999)

    IF(ASSOCIATED(from_vector)) THEN
      IF(from_vector%VECTOR_FINISHED) THEN
        IF(ASSOCIATED(to_vector)) THEN
          IF(to_vector%VECTOR_FINISHED) THEN
            IF(from_vector%DATA_TYPE==to_vector%DATA_TYPE) THEN
              IF(from_vector%DATA_TYPE==distributed_matrix_vector_l_type) THEN
                IF(from_vector%LIBRARY_TYPE==to_vector%LIBRARY_TYPE) THEN
                  !Vectors are of the same library type
                  SELECT CASE(from_vector%LIBRARY_TYPE)
                  CASE(distributed_matrix_vector_cmiss_type)
                    IF(ASSOCIATED(from_vector%CMISS)) THEN
                      IF(ASSOCIATED(to_vector%CMISS)) THEN
                        IF(ASSOCIATED(from_vector%DOMAIN_MAPPING,to_vector%DOMAIN_MAPPING)) THEN
                          to_vector%CMISS%DATA_L(1:to_vector%CMISS%N)=alpha.AND.from_vector%CMISS%DATA_L(1:from_vector%CMISS%N)
                        ELSE
                          CALL flagerror("The from vector does not have the same domain mapping as the to vector.",err,error,*999)
                        ENDIF
                      ELSE
                        CALL flagerror("To vector CMISS is not associated.",err,error,*999)
                      ENDIF
                    ELSE
                      CALL flagerror("From vector CMISS is not associated.",err,error,*999)
                    ENDIF
                  CASE(distributed_matrix_vector_petsc_type)
                    CALL flagerror("Cannot copy a vector for an integer PETSc distributed vector.",err,error,*999)
                  CASE DEFAULT
                    local_error="The from vector library type of "// &
                      & trim(numbertovstring(from_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
                    CALL flagerror(local_error,err,error,*999)
                  END SELECT
                ELSE
                  !Vectors are of from different library types
                  CALL flagerror("Not implemented.",err,error,*999)
                ENDIF
              ELSE
                local_error="The from vector data type of "//trim(numbertovstring(from_vector%DATA_TYPE,"*",err,error))// &
                  & " does not match the logical data type of the supplied alpha value."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              local_error="The from vector data type of "// &
                & trim(numbertovstring(from_vector%DATA_TYPE,"*",err,error))// &
                & " does not match the to vector data type of "// &
                & trim(numbertovstring(to_vector%DATA_TYPE,"*",err,error))//"."
              CALL flagerror(local_error,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("To vector has not been finished.",err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("To vector is not associated.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("From vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("From vector is not associated.",err,error,*999)
    ENDIF
     
    exits("DISTRIBUTED_VECTOR_COPY_L")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_COPY_L",err,error)
    RETURN 1
    
  END SUBROUTINE distributed_vector_copy_l

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

  SUBROUTINE distributed_vector_cmiss_finalise(CMISS_VECTOR,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_cmiss_type), POINTER :: CMISS_VECTOR
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: domain_idx
    
    enters("DISTRIBUTED_VECTOR_CMISS_FINALISE",err,error,*999)

    IF(ASSOCIATED(cmiss_vector)) THEN
      IF(ALLOCATED(cmiss_vector%DATA_INTG)) DEALLOCATE(cmiss_vector%DATA_INTG)
      IF(ALLOCATED(cmiss_vector%DATA_SP)) DEALLOCATE(cmiss_vector%DATA_SP)
      IF(ALLOCATED(cmiss_vector%DATA_DP)) DEALLOCATE(cmiss_vector%DATA_DP)
      IF(ALLOCATED(cmiss_vector%DATA_L)) DEALLOCATE(cmiss_vector%DATA_L)
      IF(ALLOCATED(cmiss_vector%TRANSFERS)) THEN
        DO domain_idx=1,SIZE(cmiss_vector%TRANSFERS)
          CALL distributed_vector_cmiss_transfer_finalise(cmiss_vector,domain_idx,err,error,*999)
        ENDDO !domain_idx
        DEALLOCATE(cmiss_vector%TRANSFERS)
      ENDIF
      DEALLOCATE(cmiss_vector)
    ENDIF
     
    exits("DISTRIBUTED_VECTOR_CMISS_FINALSE")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_CMISS_FINALISE",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_cmiss_finalise

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

  SUBROUTINE distributed_vector_cmiss_initialise(DISTRIBUTED_VECTOR,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    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_VECTOR_CMISS_INITIALISE",err,error,*998)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(ASSOCIATED(distributed_vector%CMISS)) THEN
        CALL flagerror("CMISS is already associated for this distributed vector.",err,error,*998)
      ELSE
        IF(ASSOCIATED(distributed_vector%DOMAIN_MAPPING)) THEN
          ALLOCATE(distributed_vector%CMISS,stat=err)
          IF(err/=0) CALL flagerror("Could not allocated CMISS distributed vector.",err,error,*999)
          distributed_vector%CMISS%DISTRIBUTED_VECTOR=>distributed_vector
          distributed_vector%LIBRARY_TYPE=distributed_matrix_vector_cmiss_type
          !Set the defaults
          distributed_vector%CMISS%BASE_TAG_NUMBER=0
          SELECT CASE(distributed_vector%GHOSTING_TYPE)
          CASE(distributed_matrix_vector_include_ghosts_type)
            distributed_vector%CMISS%N=distributed_vector%DOMAIN_MAPPING%TOTAL_NUMBER_OF_LOCAL
          CASE(distributed_matrix_vector_no_ghosts_type)
            distributed_vector%CMISS%N=distributed_vector%DOMAIN_MAPPING%NUMBER_OF_LOCAL
          CASE DEFAULT
            local_error="The distributed vector ghosting type of "// &
              & trim(numbertovstring(distributed_vector%GHOSTING_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT         
          distributed_vector%CMISS%DATA_SIZE=0         
        ELSE
          CALL flagerror("Distributed vector domain mapping is not associated.",err,error,*998)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_CMISS_INITIALSE")
    RETURN
999 IF(ASSOCIATED(distributed_vector%CMISS)) &
      & CALL distributed_vector_cmiss_finalise(distributed_vector%CMISS,dummy_err,dummy_error,*998)
998 errorsexits("DISTRIBUTED_VECTOR_CMISS_INITIALISE",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_cmiss_initialise

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

  SUBROUTINE distributed_vector_cmiss_create_finish(CMISS_VECTOR,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_cmiss_type), POINTER :: CMISS_VECTOR
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: domain_idx,domain_idx2,domain_no,DUMMY_ERR,my_computational_node_number
    LOGICAL :: FOUND
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    TYPE(domain_mapping_type), POINTER :: DOMAIN_MAPPING
    TYPE(varying_string) :: DUMMY_ERROR,LOCAL_ERROR
    
    enters("DISTRIBUTED_VECTOR_CMISS_CREATE_FINISH",err,error,*999)

    IF(ASSOCIATED(cmiss_vector)) THEN
      distributed_vector=>cmiss_vector%DISTRIBUTED_VECTOR
      IF(ASSOCIATED(distributed_vector)) THEN
        domain_mapping=>distributed_vector%DOMAIN_MAPPING
        IF(ASSOCIATED(domain_mapping)) THEN
          cmiss_vector%DATA_SIZE=cmiss_vector%N
          SELECT CASE(distributed_vector%DATA_TYPE)
          CASE(matrix_vector_intg_type)
            ALLOCATE(cmiss_vector%DATA_INTG(cmiss_vector%DATA_SIZE),stat=err)
            IF(err/=0) CALL flagerror("Could not allocate CMISS distributed vector integer data.",err,error,*999)
          CASE(matrix_vector_sp_type)
            ALLOCATE(cmiss_vector%DATA_SP(cmiss_vector%DATA_SIZE),stat=err)
            IF(err/=0) CALL flagerror("Could not allocate CMISS distributed vector single precsion data.",err,error,*999)
          CASE(matrix_vector_dp_type)
            ALLOCATE(cmiss_vector%DATA_DP(cmiss_vector%DATA_SIZE),stat=err)
            IF(err/=0) CALL flagerror("Could not allocate CMISS distributed vector double precsion data.",err,error,*999)
          CASE(matrix_vector_l_type)
            ALLOCATE(cmiss_vector%DATA_L(cmiss_vector%DATA_SIZE),stat=err)
            IF(err/=0) CALL flagerror("Could not allocate CMISS distributed vector logical data.",err,error,*999)
          CASE DEFAULT
            local_error="The distributed vector data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
          cmiss_vector%BASE_TAG_NUMBER=distributed_data_id
          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
          IF(domain_mapping%NUMBER_OF_ADJACENT_DOMAINS>0) THEN
            my_computational_node_number=computational_node_number_get(err,error)
            IF(err/=0) GOTO 999
            IF(distributed_vector%GHOSTING_TYPE==distributed_matrix_vector_include_ghosts_type) THEN
              ALLOCATE(cmiss_vector%TRANSFERS(domain_mapping%NUMBER_OF_ADJACENT_DOMAINS),stat=err)
              IF(err/=0) CALL flagerror("Could not allocate CMISS distributed vector transfer buffers.",err,error,*999)
              DO domain_idx=1,domain_mapping%NUMBER_OF_ADJACENT_DOMAINS
                CALL distributedvector_cmisstransferinitialise(cmiss_vector,domain_idx,err,error,*999)
                cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_SIZE=domain_mapping%ADJACENT_DOMAINS(domain_idx)% &
                  & number_of_send_ghosts
                cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SIZE= &
                  & domain_mapping%ADJACENT_DOMAINS(domain_idx)%NUMBER_OF_RECEIVE_GHOSTS
                cmiss_vector%TRANSFERS(domain_idx)%DATA_TYPE=distributed_vector%DATA_TYPE
                cmiss_vector%TRANSFERS(domain_idx)%SEND_TAG_NUMBER=cmiss_vector%BASE_TAG_NUMBER + &
                  & domain_mapping%ADJACENT_DOMAINS_PTR(my_computational_node_number)+domain_idx-1
                domain_no=domain_mapping%ADJACENT_DOMAINS(domain_idx)%DOMAIN_NUMBER
                found=.false.
                DO domain_idx2=domain_mapping%ADJACENT_DOMAINS_PTR(domain_no),domain_mapping%ADJACENT_DOMAINS_PTR(domain_no+1)-1
                  IF(domain_mapping%ADJACENT_DOMAINS_LIST(domain_idx2)==my_computational_node_number) THEN
                    found=.true.
                    EXIT
                  ENDIF
                ENDDO !domain_idx2
                IF(found) THEN
                  domain_idx2=domain_idx2-domain_mapping%ADJACENT_DOMAINS_PTR(domain_no)+1
                  cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_TAG_NUMBER=cmiss_vector%BASE_TAG_NUMBER + &
                    & domain_mapping%ADJACENT_DOMAINS_PTR(domain_no)+domain_idx2-1
                ELSE
                  CALL flagerror("Could not find domain to set the receive tag number.",err,error,*999)
                ENDIF
                SELECT CASE(distributed_vector%DATA_TYPE)
                CASE(distributed_matrix_vector_intg_type)
                  ALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_INTG(cmiss_vector%TRANSFERS(domain_idx)% &
                    & send_buffer_size),stat=err)
                  IF(err/=0) CALL flagerror("Could not allocate distributed vector send integer transfer buffer.",err,error,*999)
                  ALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_INTG(cmiss_vector%TRANSFERS(domain_idx)% &
                    & receive_buffer_size),stat=err)
                  IF(err/=0) CALL flagerror("Could not allocate distributed vector receive integer transfer buffer.", &
                    & err,error,*999)
                CASE(distributed_matrix_vector_sp_type)
                  ALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_SP(cmiss_vector%TRANSFERS(domain_idx)% &
                    & send_buffer_size),stat=err)
                  IF(err/=0) CALL flagerror("Could not allocate distributed vector send single precision transfer buffer.", &
                    & err,error,*999)
                  ALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SP(cmiss_vector%TRANSFERS(domain_idx)% &
                    & receive_buffer_size),stat=err)
                  IF(err/=0) CALL flagerror("Could not allocate distributed vector receive single precision transfer buffer.", &
                    & err,error,*999)
                CASE(distributed_matrix_vector_dp_type)
                  ALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_DP(cmiss_vector%TRANSFERS(domain_idx)% &
                    & send_buffer_size),stat=err)
                  IF(err/=0) CALL flagerror("Could not allocate distributed vector send double precision transfer buffer.", &
                    & err,error,*999)
                  ALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_DP(cmiss_vector%TRANSFERS(domain_idx)% &
                    & receive_buffer_size),stat=err)
                  IF(err/=0) CALL flagerror("Could not allocate distributed vector receive double precision transfer buffer.", &
                    & err,error,*999)
                CASE(distributed_matrix_vector_l_type)
                  ALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_L(cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_SIZE), &
                    & stat=err)
                  IF(err/=0) CALL flagerror("Could not allocate distributed vector send logical transfer buffer.",err,error,*999)
                  ALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_L(cmiss_vector%TRANSFERS(domain_idx)% &
                    & receive_buffer_size),stat=err)
                  IF(err/=0) CALL flagerror("Could not allocate distributed vector receive logical transfer buffer.", &
                    & err,error,*999)
                CASE DEFAULT
                  local_error="The distributed vector data type of "// &
                    & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))//" is invalid."
                  CALL flagerror(local_error,err,error,*999)
                END SELECT
              ENDDO !domain_idx
            ENDIF
          ENDIF
        ELSE
          CALL flagerror("CMISS vector distributed vector domain mapping is not associated.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("CMISS vector distributed vector is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("CMISS vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_CMISS_CREATE_FINISH")
    RETURN
999 CALL distributed_vector_cmiss_finalise(cmiss_vector,dummy_err,dummy_error,*998)      
998 errorsexits("DISTRIBUTED_VECTOR_CMISS_CREATE_FINISH",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_cmiss_create_finish

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

  SUBROUTINE distributed_vector_create_finish(DISTRIBUTED_VECTOR,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    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_VECTOR_CREATE_FINISH",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        CALL flagerror("The distributed vector has already been finished.",err,error,*999)
      ELSE
        SELECT CASE(distributed_vector%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_vector%CMISS)) THEN
            CALL distributed_vector_cmiss_create_finish(distributed_vector%CMISS,err,error,*999)
          ELSE
            CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_vector%PETSC)) THEN
            CALL distributed_vector_petsc_create_finish(distributed_vector%PETSC,err,error,*999)
          ELSE
            CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed vector library type of "// &
            & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
        distributed_vector%VECTOR_FINISHED=.true.
      ENDIF
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_CREATE_FINISH")
    RETURN
999 IF(ASSOCIATED(distributed_vector)) CALL distributed_vector_finalise(distributed_vector,dummy_err,dummy_error,*998)
    DEALLOCATE(distributed_vector)
998 errorsexits("DISTRIBUTED_VECTOR_CREATE_FINISH",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_create_finish

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

  SUBROUTINE distributed_vector_create_start(DOMAIN_MAPPING,DISTRIBUTED_VECTOR,ERR,ERROR,*)

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

    IF(ASSOCIATED(domain_mapping)) THEN
      IF(ASSOCIATED(distributed_vector)) THEN
        CALL flagerror("Distributed vector is already associated.",err,error,*998)
      ELSE
        CALL distributed_vector_initialise(domain_mapping,distributed_vector,err,error,*999)
        !Set the default values
      ENDIF
    ELSE
      CALL flagerror("Domain mapping is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_CREATE_START")
    RETURN
999 CALL distributed_vector_finalise(distributed_vector,dummy_err,dummy_error,*998)
998 errorsexits("DISTRIBUTED_VECTOR_CREATE_START",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_create_start

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

  SUBROUTINE distributedvector_datatypeget(vector,dataType,err,error,*)

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

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

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

    exits("DistributedVector_DataTypeGet")
    RETURN
999 errorsexits("DistributedVector_DataTypeGet",err,error)
    RETURN 1
  END SUBROUTINE distributedvector_datatypeget

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

  SUBROUTINE distributed_vector_data_type_set(DISTRIBUTED_VECTOR,DATA_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    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_VECTOR_DATA_TYPE_SET",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        CALL flagerror("The distributed vector has been finished.",err,error,*999)
      ELSE
        SELECT CASE(distributed_vector%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          SELECT CASE(data_type)
          CASE(matrix_vector_intg_type)
            distributed_vector%DATA_TYPE=matrix_vector_intg_type
          CASE(matrix_vector_sp_type)
            distributed_vector%DATA_TYPE=matrix_vector_sp_type
          CASE(matrix_vector_dp_type)
            distributed_vector%DATA_TYPE=matrix_vector_dp_type
          CASE(matrix_vector_l_type)
            distributed_vector%DATA_TYPE=matrix_vector_l_type
          CASE DEFAULT
            local_error="The distributed data type of "//trim(numbertovstring(data_type,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        CASE(distributed_matrix_vector_petsc_type)
          SELECT CASE(data_type)
          CASE(matrix_vector_intg_type)
            CALL flagerror("An integer distributed PETSc vector is not implemented.",err,error,*999)
          CASE(matrix_vector_sp_type)
            CALL flagerror("A single precision distributed PETSc vector is not implemented.",err,error,*999)
          CASE(matrix_vector_dp_type)
            distributed_vector%DATA_TYPE=matrix_vector_dp_type
          CASE(matrix_vector_l_type)
            CALL flagerror("A logical distributed PETSc vector is not implemented.",err,error,*999)
          CASE DEFAULT
            local_error="The distributed 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 vector library type of "// &
            & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_DATA_TYPE_SET")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_DATA_TYPE_SET",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_data_type_set

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

  SUBROUTINE distributed_vector_destroy(DISTRIBUTED_VECTOR,ERR,ERROR,*)

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

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

    IF(ASSOCIATED(distributed_vector)) THEN
      CALL distributed_vector_finalise(distributed_vector,err,error,*999)
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_DESTROY")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_DESTROY",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_destroy

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

  SUBROUTINE distributed_vector_duplicate(DISTRIBUTED_VECTOR,NEW_DISTRIBUTED_VECTOR,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    TYPE(distributed_vector_type), POINTER :: NEW_DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: DUMMY_ERR
    TYPE(varying_string) :: DUMMY_ERROR

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

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(ASSOCIATED(new_distributed_vector)) THEN
        CALL flagerror("New distributed vector is already associated.",err,error,*998)
      ELSE
        CALL distributed_vector_create_start(distributed_vector%DOMAIN_MAPPING,new_distributed_vector,err,error,*999)
        CALL distributed_vector_library_type_set(new_distributed_vector,distributed_vector%LIBRARY_TYPE,err,error,*999)
        CALL distributed_vector_data_type_set(new_distributed_vector,distributed_vector%DATA_TYPE,err,error,*999)
        CALL distributed_vector_create_finish(new_distributed_vector,err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_DUPLICATE")
    RETURN
999 CALL distributed_vector_finalise(new_distributed_vector,dummy_err,dummy_error,*998)
998 errorsexits("DISTRIBUTED_VECTOR_DUPLICATE",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_duplicate

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

  SUBROUTINE distributed_vector_finalise(DISTRIBUTED_VECTOR,ERR,ERROR,*)

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

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

    IF(ASSOCIATED(distributed_vector)) THEN
      CALL distributed_vector_cmiss_finalise(distributed_vector%CMISS,err,error,*999)
      CALL distributed_vector_petsc_finalise(distributed_vector%PETSC,err,error,*999)        
      DEALLOCATE(distributed_vector)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_FINALISE")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_FINALISE",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_finalise

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

  SUBROUTINE distributed_vector_initialise(DOMAIN_MAPPING,DISTRIBUTED_VECTOR,ERR,ERROR,*)

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

    IF(ASSOCIATED(domain_mapping)) THEN
      IF(ASSOCIATED(distributed_vector)) THEN
        CALL flagerror("Distributed vector is already associated.",err,error,*998)
      ELSE
        ALLOCATE(distributed_vector,stat=err)
        IF(err/=0) CALL flagerror("Could not allocated the distributed vector.",err,error,*999)
        distributed_vector%VECTOR_FINISHED=.false.
        distributed_vector%LIBRARY_TYPE=0
        distributed_vector%GHOSTING_TYPE=distributed_matrix_vector_include_ghosts_type
        distributed_vector%DOMAIN_MAPPING=>domain_mapping
        distributed_vector%DATA_TYPE=matrix_vector_dp_type
        NULLIFY(distributed_vector%CMISS)
        NULLIFY(distributed_vector%PETSC)
        CALL distributed_vector_cmiss_initialise(distributed_vector,err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Domain mapping is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_INITIALISE")
    RETURN
999 CALL distributed_vector_finalise(distributed_vector,dummy_err,dummy_error,*998)
998 errorsexits("DISTRIBUTED_VECTOR_INITIALISE",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_initialise

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

  SUBROUTINE distributed_vector_data_get_intg(DISTRIBUTED_VECTOR,DATA,ERR,ERROR,*)

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

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

     IF(ASSOCIATED(distributed_vector)) THEN
      IF(ASSOCIATED(data)) THEN
        CALL flagerror("Data is already associated.",err,error,*999)
      ELSE
        NULLIFY(data)
        IF(distributed_vector%VECTOR_FINISHED) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_intg_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                data=>distributed_vector%CMISS%DATA_INTG
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              CALL flagerror("Cannot get data for an integer PETSc distributed vector.",err,error,*999)          
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the integer data type of the requested values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("The distributed vector has not been finished.",err,error,*999)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_DATA_GET_INTG")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_DATA_GET_INTG",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_data_get_intg

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

  SUBROUTINE distributed_vector_data_get_sp(DISTRIBUTED_VECTOR,DATA,ERR,ERROR,*)

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

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

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(ASSOCIATED(data)) THEN
        CALL flagerror("Data is already associated.",err,error,*999)
      ELSE
        NULLIFY(data)
        IF(distributed_vector%VECTOR_FINISHED) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_sp_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                data=>distributed_vector%CMISS%DATA_SP
              ELSE
                CALL flagerror("Distributed vector 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 vector.",err,error,*999)          
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the single precision data type of the requested values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("The distributed vector has not been finished.",err,error,*999)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_DATA_GET_SP")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_DATA_GET_SP",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_data_get_sp

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

  SUBROUTINE distributed_vector_data_get_dp(DISTRIBUTED_VECTOR,DATA,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    REAL(DP), POINTER :: DATA(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

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

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(ASSOCIATED(data)) THEN
        CALL flagerror("Data is already associated.",err,error,*999)
      ELSE
        NULLIFY(data)
        IF(distributed_vector%VECTOR_FINISHED) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_dp_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                data=>distributed_vector%CMISS%DATA_DP
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              IF(ASSOCIATED(distributed_vector%PETSC)) THEN
                IF(distributed_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
                  CALL petsc_vecgetarrayreadf90(distributed_vector%PETSC%OVERRIDE_VECTOR,DATA,err,error,*999)
                ELSE
                  CALL petsc_vecgetarrayreadf90(distributed_vector%PETSC%VECTOR,DATA,err,error,*999)
                ENDIF
              ELSE
                CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
              ENDIF
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the double precision data type of the requested values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("The distributed vector has not been finished.",err,error,*999)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_DATA_GET_DP")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_DATA_GET_DP",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_data_get_dp

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

  SUBROUTINE distributed_vector_data_get_l(DISTRIBUTED_VECTOR,DATA,ERR,ERROR,*)

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

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

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(ASSOCIATED(data)) THEN
        CALL flagerror("Data is already associated.",err,error,*999)
      ELSE
        NULLIFY(data)
        IF(distributed_vector%VECTOR_FINISHED) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_l_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                data=>distributed_vector%CMISS%DATA_L
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              CALL flagerror("Cannot get values for a logical PETSc distributed vector.",err,error,*999)          
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "//trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the logical data type of the requested values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("The distributed vector has not been finished.",err,error,*999)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_DATA_GET_L")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_DATA_GET_L",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_data_get_l

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

  SUBROUTINE distributed_vector_data_restore_intg(DISTRIBUTED_VECTOR,DATA,ERR,ERROR,*)

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

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

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(ASSOCIATED(data)) THEN
        IF(distributed_vector%VECTOR_FINISHED) THEN
          SELECT CASE(distributed_vector%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 vector.",err,error,*999)
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("The distributed vector has not been finished.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("Data is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_DATA_RESTORE_INTG")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_DATA_RESTORE_INTG",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_data_restore_intg

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

  SUBROUTINE distributed_vector_data_restore_sp(DISTRIBUTED_VECTOR,DATA,ERR,ERROR,*)

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

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

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(ASSOCIATED(data)) THEN
        IF(distributed_vector%VECTOR_FINISHED) THEN
          SELECT CASE(distributed_vector%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 vector.",err,error,*999)
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("The distributed vector has not been finished.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("Data is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_DATA_RESTORE_SP")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_DATA_RESTORE_SP",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_data_restore_sp

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

  SUBROUTINE distributed_vector_data_restore_dp(DISTRIBUTED_VECTOR,DATA,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    REAL(DP), POINTER :: DATA(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_VECTOR_DATA_RESTORE_DP",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(ASSOCIATED(data)) THEN
        IF(distributed_vector%VECTOR_FINISHED) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            NULLIFY(data)
          CASE(distributed_matrix_vector_petsc_type)
            IF(ASSOCIATED(distributed_vector%PETSC)) THEN
              IF(distributed_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
                CALL petsc_vecrestorearrayreadf90(distributed_vector%PETSC%OVERRIDE_VECTOR,DATA,err,error,*999)
              ELSE
                CALL petsc_vecrestorearrayreadf90(distributed_vector%PETSC%VECTOR,DATA,err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
            ENDIF
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("The distributed vector has not been finished.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("Data is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_DATA_RESTORE_DP")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_DATA_RESTORE_DP",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_data_restore_dp

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

  SUBROUTINE distributed_vector_data_restore_l(DISTRIBUTED_VECTOR,DATA,ERR,ERROR,*)

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

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(ASSOCIATED(data)) THEN
        IF(distributed_vector%VECTOR_FINISHED) THEN
          SELECT CASE(distributed_vector%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 vector.",err,error,*999)
          CASE DEFAULT
            local_error="The distributed matrix library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("The distributed vector has not been finished.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("Data is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_DATA_RESTORE_L")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_DATA_RESTORE_L",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_data_restore_l
  
  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_vector_ghosting_type_set(DISTRIBUTED_VECTOR,GHOSTING_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: GHOSTING_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

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

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        CALL flagerror("The distributed vector has already been finished.",err,error,*999)
      ELSE
        IF(ASSOCIATED(distributed_vector%DOMAIN_MAPPING)) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              SELECT CASE(ghosting_type)
              CASE(distributed_matrix_vector_include_ghosts_type)
                distributed_vector%CMISS%N=distributed_vector%DOMAIN_MAPPING%TOTAL_NUMBER_OF_LOCAL
              CASE(distributed_matrix_vector_no_ghosts_type)
                distributed_vector%CMISS%N=distributed_vector%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 vector CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            IF(ASSOCIATED(distributed_vector%PETSC)) THEN
              SELECT CASE(ghosting_type)
              CASE(distributed_matrix_vector_include_ghosts_type)
                distributed_vector%PETSC%N=distributed_vector%DOMAIN_MAPPING%TOTAL_NUMBER_OF_LOCAL
              CASE(distributed_matrix_vector_no_ghosts_type)
                distributed_vector%PETSC%N=distributed_vector%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 vector PETSc is not associated.",err,error,*999)
            ENDIF
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
          distributed_vector%GHOSTING_TYPE=ghosting_type
        ELSE
          CALL flagerror("Distributed vector domain mapping is not associated.",err,error,*999)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_GHOSTING_TYPE_SET")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_GHOSTING_TYPE_SET",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_ghosting_type_set

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

  SUBROUTINE distributed_vector_library_type_set(DISTRIBUTED_VECTOR,LIBRARY_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    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_VECTOR_LIBRARY_TYPE_SET",err,error,*998)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        CALL flagerror("The distributed vector has already been finished.",err,error,*998)
      ELSE
        old_library_type=distributed_vector%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_vector_cmiss_initialise(distributed_vector,err,error,*999)
          CASE(distributed_matrix_vector_petsc_type)
            CALL distributed_vector_petsc_initialise(distributed_vector,err,error,*999)
          CASE DEFAULT
            local_error="The distributed vector 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_vector_cmiss_finalise(distributed_vector%CMISS,err,error,*999)
          CASE(distributed_matrix_vector_petsc_type)
            CALL distributed_vector_petsc_finalise(distributed_vector%PETSC,err,error,*999)
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(old_library_type,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
          distributed_vector%LIBRARY_TYPE=library_type
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_LIBRARY_TYPE_SET")
    RETURN
999 SELECT CASE(library_type)
    CASE(distributed_matrix_vector_cmiss_type)
      CALL distributed_vector_cmiss_finalise(distributed_vector%CMISS,dummy_err,dummy_error,*998)
    CASE(distributed_matrix_vector_petsc_type)
      CALL distributed_vector_petsc_finalise(distributed_vector%PETSC,dummy_err,dummy_error,*998)
    END SELECT
998 errorsexits("DISTRIBUTED_VECTOR_LIBRARY_TYPE_SET",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_library_type_set

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

  SUBROUTINE distributed_vector_output(ID,DISTRIBUTED_VECTOR,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    REAL(DP), POINTER :: VECTOR(:)
    TYPE(varying_string) :: LOCAL_ERROR

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

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        SELECT CASE(distributed_vector%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_vector%CMISS)) THEN
            SELECT CASE(distributed_vector%DATA_TYPE)
            CASE(matrix_vector_intg_type)
              CALL write_string_vector(id,1,1,distributed_vector%CMISS%N,8,8,distributed_vector%CMISS%DATA_INTG, &
                & '("Vector(:)          :",8(X,I13))','(20X,8(X,I13))',err,error,*999)
            CASE(matrix_vector_sp_type)
              CALL write_string_vector(id,1,1,distributed_vector%CMISS%N,8,8,distributed_vector%CMISS%DATA_SP, &
                & '("Vector(:)          :",8(X,E13.6))','(20X,8(X,E13.6))',err,error,*999)
            CASE(matrix_vector_dp_type)
              CALL write_string_vector(id,1,1,distributed_vector%CMISS%N,8,8,distributed_vector%CMISS%DATA_DP, &
                & '("Vector(:)          :",8(X,E13.6))','(20X,8(X,E13.6))',err,error,*999)
            CASE(matrix_vector_l_type)            
              CALL write_string_vector(id,1,1,distributed_vector%CMISS%N,8,8,distributed_vector%CMISS%DATA_INTG, &
                & '("Vector(:)          :",8(X,L13))','(20X,8(X,L13))',err,error,*999)
            CASE DEFAULT
              local_error="The distributed vector data type of "// &
                & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_vector%PETSC)) THEN
            NULLIFY(vector)
            IF(distributed_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
              CALL petsc_vecgetarrayreadf90(distributed_vector%PETSC%OVERRIDE_VECTOR,vector,err,error,*999)
            ELSE              
              CALL petsc_vecgetarrayreadf90(distributed_vector%PETSC%VECTOR,vector,err,error,*999)
            ENDIF
            CALL write_string_vector(id,1,1,distributed_vector%PETSC%N,8,8,vector, &
              & '("Vector(:)          :",8(X,E13.6))','(20X,8(X,E13.6))',err,error,*999)
            IF(distributed_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
              CALL petsc_vecrestorearrayreadf90(distributed_vector%PETSC%OVERRIDE_VECTOR,vector,err,error,*999)
            ELSE              
              CALL petsc_vecrestorearrayreadf90(distributed_vector%PETSC%VECTOR,vector,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed vector library type of "// &
            & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
       CALL flagerror("Distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_OUTPUT")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_OUTPUT",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_output

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

  SUBROUTINE distributed_vector_override_set_on(DISTRIBUTED_VECTOR,OVERRIDE_VECTOR,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    TYPE(petscvectype), INTENT(IN) :: OVERRIDE_VECTOR
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

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

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        SELECT CASE(distributed_vector%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          CALL flagerror("Not implemented.",err,error,*999)          
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_vector%PETSC)) THEN
            distributed_vector%PETSC%USE_OVERRIDE_VECTOR=.true.
            distributed_vector%PETSC%OVERRIDE_VECTOR=override_vector
          ELSE
            CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed vector library type of "// &
            & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
       CALL flagerror("Distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_OVERRIDE_SET_ON")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_OVERRIDE_SET_ON",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_override_set_on

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

  SUBROUTINE distributed_vector_override_set_off(DISTRIBUTED_VECTOR,ERR,ERROR,*)

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

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

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        SELECT CASE(distributed_vector%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          CALL flagerror("Not implemented.",err,error,*999)          
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_vector%PETSC)) THEN
            distributed_vector%PETSC%USE_OVERRIDE_VECTOR=.false.
            CALL petsc_vecinitialise(distributed_vector%PETSC%OVERRIDE_VECTOR,err,error,*999)
          ELSE
            CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed vector library type of "// &
            & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
       CALL flagerror("Distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_OVERRIDE_SET_OFF")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_OVERRIDE_SET_OFF",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_override_set_off

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

  SUBROUTINE distributed_vector_petsc_create_finish(PETSC_VECTOR,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_petsc_type), POINTER :: PETSC_VECTOR
    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_vector_type), POINTER :: DISTRIBUTED_VECTOR
    TYPE(domain_mapping_type), POINTER :: DOMAIN_MAPPING
    TYPE(varying_string) :: DUMMY_ERROR
    
    enters("DISTRIBUTED_VECTOR_PETSC_CREATE_FINISH",err,error,*998)

    IF(ASSOCIATED(petsc_vector)) THEN
      distributed_vector=>petsc_vector%DISTRIBUTED_VECTOR
      IF(ASSOCIATED(distributed_vector)) THEN
        domain_mapping=>distributed_vector%DOMAIN_MAPPING
        IF(ASSOCIATED(domain_mapping)) THEN
          !Create the PETSc vector
          petsc_vector%DATA_SIZE=petsc_vector%N
          CALL petsc_veccreatempi(computational_environment%MPI_COMM,petsc_vector%N,petsc_vector%GLOBAL_N,petsc_vector%VECTOR, &
            & err,error,*999)
          !Set up the Local to Global Mappings
          DO i=1,petsc_vector%N
            petsc_vector%GLOBAL_NUMBERS(i)=domain_mapping%LOCAL_TO_GLOBAL_MAP(i)-1
          ENDDO !i
        ELSE
          CALL flagerror("PETSc vector distributed vector domain mapping is not associated.",err,error,*999)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("PETSc vector is not associated.",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_PETSC_CREATE_FINISH")
    RETURN
999 IF(ALLOCATED(global_numbers)) DEALLOCATE(global_numbers)
    CALL distributed_vector_petsc_finalise(petsc_vector,dummy_err,dummy_error,*998)
998 errorsexits("DISTRIBUTED_VECTOR_PETSC_CREATE_FINISH",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_petsc_create_finish

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

  SUBROUTINE distributed_vector_petsc_finalise(PETSC_VECTOR,ERR,ERROR,*)

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

    IF(ASSOCIATED(petsc_vector)) THEN
      IF(ALLOCATED(petsc_vector%GLOBAL_NUMBERS)) DEALLOCATE(petsc_vector%GLOBAL_NUMBERS)
      CALL petsc_vecfinalise(petsc_vector%VECTOR,err,error,*999)
      CALL petsc_vecfinalise(petsc_vector%OVERRIDE_VECTOR,err,error,*999)
      DEALLOCATE(petsc_vector)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_PETSC_FINALSE")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_PETSC_FINALISE",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_petsc_finalise

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

  SUBROUTINE distributed_vector_petsc_initialise(DISTRIBUTED_VECTOR,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    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_VECTOR_PETSC_INITIALISE",err,error,*998)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(ASSOCIATED(distributed_vector%PETSC)) THEN
        CALL flagerror("PETSc is already associated for this distributed vector.",err,error,*998)
      ELSE
        IF(ASSOCIATED(distributed_vector%DOMAIN_MAPPING)) THEN
          ALLOCATE(distributed_vector%PETSC,stat=err)
          IF(err/=0) CALL flagerror("Could not allocate PETSc distributed vector.",err,error,*999)
          distributed_vector%PETSC%DISTRIBUTED_VECTOR=>distributed_vector
          distributed_vector%LIBRARY_TYPE=distributed_matrix_vector_petsc_type
          !Set the defaults
          SELECT CASE(distributed_vector%GHOSTING_TYPE)
          CASE(distributed_matrix_vector_include_ghosts_type)
            distributed_vector%PETSC%N=distributed_vector%DOMAIN_MAPPING%TOTAL_NUMBER_OF_LOCAL
          CASE(distributed_matrix_vector_no_ghosts_type)
            distributed_vector%PETSC%N=distributed_vector%DOMAIN_MAPPING%NUMBER_OF_LOCAL
          CASE DEFAULT
            local_error="The distributed vector ghosting type of "// &
              & trim(numbertovstring(distributed_vector%GHOSTING_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
          distributed_vector%PETSC%GLOBAL_N=distributed_vector%DOMAIN_MAPPING%NUMBER_OF_GLOBAL
          ALLOCATE(distributed_vector%PETSC%GLOBAL_NUMBERS(distributed_vector%PETSC%N),stat=err)
          IF(err/=0) CALL flagerror("Could not allocate PETSc distributed vector global numbers.",err,error,*999)
          distributed_vector%PETSC%USE_OVERRIDE_VECTOR=.false.
          CALL petsc_vecinitialise(distributed_vector%PETSC%VECTOR,err,error,*999)
          CALL petsc_vecinitialise(distributed_vector%PETSC%OVERRIDE_VECTOR,err,error,*999)          
        ELSE
          CALL flagerror("Distributed vector domain mapping is not associated",err,error,*998)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated",err,error,*998)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_PETSC_INITIALSE")
    RETURN
999 IF(ASSOCIATED(distributed_vector%PETSC)) &
      & CALL distributed_vector_petsc_finalise(distributed_vector%PETSC,dummy_err,dummy_error,*998)
998 errorsexits("DISTRIBUTED_VECTOR_PETSC_INITIALISE",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_petsc_initialise

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

  SUBROUTINE distributed_vector_cmiss_transfer_finalise(CMISS_VECTOR,domain_idx,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_cmiss_type), POINTER :: CMISS_VECTOR
    INTEGER(INTG), INTENT(IN) :: domain_idx
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

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

    IF(ASSOCIATED(cmiss_vector)) THEN
      IF(ALLOCATED(cmiss_vector%TRANSFERS)) THEN
        IF(domain_idx>0.AND.domain_idx<=SIZE(cmiss_vector%TRANSFERS,1)) THEN
          NULLIFY(cmiss_vector%TRANSFERS(domain_idx)%CMISS_VECTOR)
          cmiss_vector%TRANSFERS(domain_idx)%DATA_TYPE=0
          cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_TAG_NUMBER=-1
          cmiss_vector%TRANSFERS(domain_idx)%SEND_TAG_NUMBER=-1
          cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_SIZE=0
          cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SIZE=0
          cmiss_vector%TRANSFERS(domain_idx)%MPI_SEND_REQUEST=mpi_request_null
          cmiss_vector%TRANSFERS(domain_idx)%MPI_RECEIVE_REQUEST=mpi_request_null
          IF(ALLOCATED(cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_INTG)) &
            & DEALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_INTG)
          IF(ALLOCATED(cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_SP)) &
            & DEALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_SP)
          IF(ALLOCATED(cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_DP)) &
            & DEALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_DP)
          IF(ALLOCATED(cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_L)) &
            & DEALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_L)
          IF(ALLOCATED(cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_INTG)) &
            & DEALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_INTG)
          IF(ALLOCATED(cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SP)) &
            & DEALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SP)
          IF(ALLOCATED(cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_DP)) &
            & DEALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_DP)
          IF(ALLOCATED(cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_L)) &
            & DEALLOCATE(cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_L)
        ELSE
          local_error="The domain index of "//trim(numbertovstring(domain_idx,"*",err,error))// &
            & " is invalid. It must be between 1 and "//trim(numbertovstring(SIZE(cmiss_vector%TRANSFERS,1),"*",err,error))//"."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ENDIF
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_CMISS_TRANSFER_FINALISE")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_CMISS_TRANSFER_FINALISE",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_cmiss_transfer_finalise

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

  SUBROUTINE distributedvector_cmisstransferinitialise(CMISS_VECTOR,domain_idx,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_cmiss_type), POINTER :: CMISS_VECTOR
    INTEGER(INTG), INTENT(IN) :: domain_idx
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

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

    IF(ASSOCIATED(cmiss_vector)) THEN
      IF(ALLOCATED(cmiss_vector%TRANSFERS)) THEN
        IF(domain_idx>0.AND.domain_idx<=SIZE(cmiss_vector%TRANSFERS,1)) THEN
          cmiss_vector%TRANSFERS(domain_idx)%CMISS_VECTOR=>cmiss_vector
          cmiss_vector%TRANSFERS(domain_idx)%DATA_TYPE=0
          cmiss_vector%TRANSFERS(domain_idx)%SEND_BUFFER_SIZE=0
          cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SIZE=0
          cmiss_vector%TRANSFERS(domain_idx)%SEND_TAG_NUMBER=-1
          cmiss_vector%TRANSFERS(domain_idx)%RECEIVE_TAG_NUMBER=-1
          cmiss_vector%TRANSFERS(domain_idx)%MPI_SEND_REQUEST=mpi_request_null
          cmiss_vector%TRANSFERS(domain_idx)%MPI_RECEIVE_REQUEST=mpi_request_null
        ELSE
          local_error="The domain index of "//trim(numbertovstring(domain_idx,"*",err,error))// &
            & " is invalid. It must be between 1 and "// &
            & trim(numbertovstring(SIZE(cmiss_vector%TRANSFERS,1),"*",err,error))//"."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("CMISS vector transfers is not allocated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("CMISS vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DistributedVector_CmissTransferInitialise")
    RETURN
999 errorsexits("DistributedVector_CmissTransferInitialise",err,error)
    RETURN 1
  END SUBROUTINE distributedvector_cmisstransferinitialise

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

  SUBROUTINE distributed_vector_update_finish(DISTRIBUTED_VECTOR,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: domain_idx,i,NUMBER_OF_COMPUTATIONAL_NODES
    TYPE(varying_string) :: LOCAL_ERROR
   
    enters("DISTRIBUTED_VECTOR_UPDATE_FINISH",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        SELECT CASE(distributed_vector%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_vector%CMISS)) THEN
            IF(ASSOCIATED(distributed_vector%DOMAIN_MAPPING)) THEN
              number_of_computational_nodes=computational_nodes_number_get(err,error)
              IF(err/=0) GOTO 999
              IF(number_of_computational_nodes>1) THEN
                CALL distributed_vector_update_waitfinished(distributed_vector,err,error,*999)
                !Copy the receive buffers back to the ghost positions in the data vector
                DO domain_idx=1,distributed_vector%DOMAIN_MAPPING%NUMBER_OF_ADJACENT_DOMAINS
                  SELECT CASE(distributed_vector%DATA_TYPE)
                  CASE(matrix_vector_intg_type)
                    DO i=1,distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%NUMBER_OF_RECEIVE_GHOSTS
                      distributed_vector%CMISS%DATA_INTG(distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)% &
                        & local_ghost_receive_indices(i))=distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_BUFFER_INTG(i)
                    ENDDO !i
                  CASE(matrix_vector_sp_type)
                    DO i=1,distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%NUMBER_OF_RECEIVE_GHOSTS
                      distributed_vector%CMISS%DATA_SP(distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)% &
                        & local_ghost_receive_indices(i))=distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SP(i)
                    ENDDO !i
                  CASE(matrix_vector_dp_type)
                    DO i=1,distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%NUMBER_OF_RECEIVE_GHOSTS
                      distributed_vector%CMISS%DATA_DP(distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)% &
                        & local_ghost_receive_indices(i))=distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_BUFFER_DP(i)
                    ENDDO !i
                  CASE(matrix_vector_l_type)
                    DO i=1,distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%NUMBER_OF_RECEIVE_GHOSTS
                      distributed_vector%CMISS%DATA_L(distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)% &
                        & local_ghost_receive_indices(i))=distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_BUFFER_L(i)
                    ENDDO !i
                  CASE DEFAULT
                    local_error="The distributed vector data type of "// &
                      & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))//" is invalid."
                    CALL flagerror(local_error,err,error,*999)
                  END SELECT
                ENDDO !domain_idx
              ENDIF
            ELSE
              CALL flagerror("Distributed vector domain mapping is not associated.",err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          IF(ASSOCIATED(distributed_vector%PETSC)) THEN
            IF(distributed_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
              CALL petsc_vecassemblyend(distributed_vector%PETSC%OVERRIDE_VECTOR,err,error,*999)
            ELSE
              CALL petsc_vecassemblyend(distributed_vector%PETSC%VECTOR,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed vector library type of "// &
            & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF

    IF(diagnostics1) THEN
      SELECT CASE(distributed_vector%LIBRARY_TYPE)
      CASE(distributed_matrix_vector_cmiss_type)
        IF(ASSOCIATED(distributed_vector%CMISS)) THEN
          CALL write_string(diagnostic_output_type,"Distributed vector :",err,error,*999)
          CALL write_string_value(diagnostic_output_type,"  Data type = ",distributed_vector%DATA_TYPE,err,error,*999)
          CALL write_string_value(diagnostic_output_type,"  Base tag number = ",distributed_vector%CMISS%BASE_TAG_NUMBER, &
            & err,error,*999)
          CALL write_string_value(diagnostic_output_type,"  Number of adjacent domains = ",distributed_vector%DOMAIN_MAPPING% &
            & number_of_adjacent_domains,err,error,*999)
          DO domain_idx=1,distributed_vector%DOMAIN_MAPPING%NUMBER_OF_ADJACENT_DOMAINS
            CALL write_string_value(diagnostic_output_type,"    Domain idx = ",domain_idx,err,error,*999)
            CALL write_string_value(diagnostic_output_type,"    Domain number = ",distributed_vector%DOMAIN_MAPPING% &
              & adjacent_domains(domain_idx)%DOMAIN_NUMBER,err,error,*999)
            CALL write_string_value(diagnostic_output_type,"    Receive tag number = ",distributed_vector%CMISS% &
              & transfers(domain_idx)%RECEIVE_TAG_NUMBER,err,error,*999)
            CALL write_string_value(diagnostic_output_type,"    Send tag number = ",distributed_vector%CMISS% &
              & transfers(domain_idx)%SEND_TAG_NUMBER,err,error,*999)
            CALL write_string_value(diagnostic_output_type,"    MPI send request = ",distributed_vector%CMISS% &
              & transfers(domain_idx)%MPI_SEND_REQUEST,err,error,*999)
            CALL write_string_value(diagnostic_output_type,"    MPI receive request = ",distributed_vector%CMISS% &
              & transfers(domain_idx)%MPI_RECEIVE_REQUEST,err,error,*999)
          ENDDO !domain_idx
          CALL write_string_value(diagnostic_output_type,"  Data size = ",distributed_vector%CMISS%DATA_SIZE,err,error,*999)
          SELECT CASE(distributed_vector%DATA_TYPE)
          CASE(matrix_vector_intg_type)
            CALL write_string_vector(diagnostic_output_type,1,1,distributed_vector%CMISS%DATA_SIZE,5,5,distributed_vector%CMISS% &
              & data_intg,'("  Data :",5(X,I13))','(8X,5(X,I13))',err,error,*999)      
          CASE(matrix_vector_sp_type)
            CALL write_string_vector(diagnostic_output_type,1,1,distributed_vector%CMISS%DATA_SIZE,5,5,distributed_vector%CMISS% &
              & data_sp,'("  Data :",5(X,E13.6))','(8X,5(X,E13.6))',err,error,*999)      
          CASE(matrix_vector_dp_type)
            CALL write_string_vector(diagnostic_output_type,1,1,distributed_vector%CMISS%DATA_SIZE,5,5,distributed_vector%CMISS% &
              & data_dp,'("  Data :",5(X,E13.6))','(8X,5(X,E13.6))',err,error,*999)      
          CASE(matrix_vector_l_type)
            CALL write_string_vector(diagnostic_output_type,1,1,distributed_vector%CMISS%DATA_SIZE,8,8,distributed_vector%CMISS% &
              & data_l,'("  Data :",8(X,L))','(8X,8(X,L))',err,error,*999)      
          CASE DEFAULT
            local_error="The distributed vector data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
        ENDIF
      CASE(distributed_matrix_vector_petsc_type)
        !Do nothing
      CASE DEFAULT
        local_error="The distributed vector library type of "// &
          & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
        CALL flagerror(local_error,err,error,*999)
      END SELECT
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_UPDATE_FINISH")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_UPDATE_FINISH",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_update_finish

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

  SUBROUTINE distributed_vector_update_isfinished(DISTRIBUTED_VECTOR,ISFINISHED,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    LOGICAL, INTENT(OUT) :: ISFINISHED
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: domain_idx
    INTEGER(INTG) :: MPI_IERROR,STATUS(mpi_status_size)
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_VECTOR_UPDATE_ISFINISHED",err,error,*999)

    isfinished=.false.
    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        SELECT CASE(distributed_vector%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_vector%CMISS)) THEN
            IF(ASSOCIATED(distributed_vector%DOMAIN_MAPPING)) THEN
!!TODO: USE MPI_TESTALL and store the request handles as big array.
              DO domain_idx=1,distributed_vector%DOMAIN_MAPPING%NUMBER_OF_ADJACENT_DOMAINS
                CALL mpi_test(distributed_vector%CMISS%TRANSFERS(domain_idx)%MPI_RECEIVE_REQUEST,isfinished,status,mpi_ierror)
                CALL mpi_error_check("MPI_TEST",mpi_ierror,err,error,*999)
                IF(.NOT.isfinished) EXIT
                !CALL MPI_TEST(DISTRIBUTED_VECTOR%TRANSFERS(domain_idx)%MPI_SEND_REQUEST,ISFINISHED,STATUS,MPI_IERROR)
                !CALL MPI_ERROR_CHECK("MPI_TEST",MPI_IERROR,ERR,ERROR,*999)
                !IF(.NOT.ISFINISHED) EXIT
              ENDDO !domain_idx
            ELSE
              CALL flagerror("Distributed vector domain mapping is not associated.",err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot test if update isfinished for a PETSc distributed vector.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed vector library type of "// &
            & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_UPDATE_ISFINISHED")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_UPDATE_ISFINISHED",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_update_isfinished

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

  SUBROUTINE distributed_vector_update_waitfinished(DISTRIBUTED_VECTOR,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: domain_idx
    INTEGER(INTG) :: MPI_IERROR,STATUS(mpi_status_size)
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_VECTOR_UPDATE_WAITFINISHED",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        SELECT CASE(distributed_vector%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_vector%CMISS)) THEN
            IF(ASSOCIATED(distributed_vector%DOMAIN_MAPPING)) THEN
!!TODO: USE MPI_WAITALL and store the request handles as big array.
              DO domain_idx=1,distributed_vector%DOMAIN_MAPPING%NUMBER_OF_ADJACENT_DOMAINS
                CALL mpi_wait(distributed_vector%CMISS%TRANSFERS(domain_idx)%MPI_RECEIVE_REQUEST,status,mpi_ierror)
                CALL mpi_error_check("MPI_WAIT",mpi_ierror,err,error,*999)
              ENDDO !domain_idx
            ELSE
              CALL flagerror("Distributed vector domain mapping is not associated.",err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot wait for finished for a PETSc distributed vector.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed vector library type of "// &
            & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_UPDATE_WAITFINISHED")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_UPDATE_WAITFINISHED",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_update_waitfinished

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

  SUBROUTINE distributed_vector_update_start(DISTRIBUTED_VECTOR,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: domain_idx,i,MPI_IERROR,NUMBER_OF_COMPUTATIONAL_NODES
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_VECTOR_UPDATE_START",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        SELECT CASE(distributed_vector%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_vector%CMISS)) THEN
            IF(ASSOCIATED(distributed_vector%DOMAIN_MAPPING)) THEN
              number_of_computational_nodes=computational_nodes_number_get(err,error)
              IF(err/=0) GOTO 999
              IF(number_of_computational_nodes>1) THEN
                IF(distributed_vector%DOMAIN_MAPPING%NUMBER_OF_ADJACENT_DOMAINS>0) THEN
                  !Fill in the send buffers with the send ghost values
                  DO domain_idx=1,distributed_vector%DOMAIN_MAPPING%NUMBER_OF_ADJACENT_DOMAINS
                    SELECT CASE(distributed_vector%DATA_TYPE)
                    CASE(matrix_vector_intg_type)
                      DO i=1,distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%NUMBER_OF_SEND_GHOSTS
                        distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_BUFFER_INTG(i)= &
                          & distributed_vector%CMISS%DATA_INTG(distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)% &
                          & local_ghost_send_indices(i))
                      ENDDO !i
                    CASE(matrix_vector_sp_type)
                      DO i=1,distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%NUMBER_OF_SEND_GHOSTS
                        distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_BUFFER_SP(i)= &
                          & distributed_vector%CMISS%DATA_SP(distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)% &
                          & local_ghost_send_indices(i))
                      ENDDO !i
                    CASE(matrix_vector_dp_type)
                      DO i=1,distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%NUMBER_OF_SEND_GHOSTS
                        distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_BUFFER_DP(i)= &
                          & distributed_vector%CMISS%DATA_DP(distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)% &
                          & local_ghost_send_indices(i))
                      ENDDO !i
                    CASE(matrix_vector_l_type)
                      DO i=1,distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%NUMBER_OF_SEND_GHOSTS
                        distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_BUFFER_L(i)= &
                          & distributed_vector%CMISS%DATA_L(distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)% &
                          & local_ghost_send_indices(i))
                      ENDDO !i
                    CASE DEFAULT
                      local_error="The distributed vector data type of "// &
                        & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))//" is invalid."
                      CALL flagerror(local_error,err,error,*999)
                    END SELECT
                  ENDDO !domain_idx
                  !Post all the receive calls first and then the send calls.
                  DO domain_idx=1,distributed_vector%DOMAIN_MAPPING%NUMBER_OF_ADJACENT_DOMAINS
                    SELECT CASE(distributed_vector%DATA_TYPE)
                    CASE(matrix_vector_intg_type)
                      CALL mpi_irecv(distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_BUFFER_INTG, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SIZE,mpi_integer, &
                        & distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%DOMAIN_NUMBER, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_TAG_NUMBER,computational_environment%MPI_COMM, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%MPI_RECEIVE_REQUEST,mpi_ierror)
                      CALL mpi_error_check("MPI_IRECV",mpi_ierror,err,error,*999)
                      IF(diagnostics5) THEN
                        CALL write_string(diagnostic_output_type,"MPI IRECV call posted:",err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive count = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SIZE,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive datatype = ",mpi_integer,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive source = ",distributed_vector%DOMAIN_MAPPING% &
                          & adjacent_domains(domain_idx)%DOMAIN_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive tag = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%RECEIVE_TAG_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive comm = ",computational_environment%MPI_COMM, &
                          & err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive request = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%MPI_RECEIVE_REQUEST,err,error,*999)                
                      ENDIF
                    CASE(matrix_vector_sp_type)
                      CALL mpi_irecv(distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SP, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SIZE,mpi_real, &
                        & distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%DOMAIN_NUMBER, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_TAG_NUMBER,computational_environment%MPI_COMM, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%MPI_RECEIVE_REQUEST,mpi_ierror)
                      CALL mpi_error_check("MPI_IRECV",mpi_ierror,err,error,*999)
                      IF(diagnostics5) THEN
                        CALL write_string(diagnostic_output_type,"MPI IRECV call posted:",err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive count = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SIZE,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive datatype = ",mpi_real,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive source = ",distributed_vector%DOMAIN_MAPPING% &
                          & adjacent_domains(domain_idx)%DOMAIN_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive tag = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%RECEIVE_TAG_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive comm = ",computational_environment%MPI_COMM, &
                          & err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive request = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%MPI_RECEIVE_REQUEST,err,error,*999)                
                      ENDIF
                    CASE(matrix_vector_dp_type)
                      CALL mpi_irecv(distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_BUFFER_DP, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SIZE,mpi_double_precision, &
                        & distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%DOMAIN_NUMBER, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_TAG_NUMBER,computational_environment%MPI_COMM, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%MPI_RECEIVE_REQUEST,mpi_ierror)
                      CALL mpi_error_check("MPI_IRECV",mpi_ierror,err,error,*999)
                      IF(diagnostics5) THEN
                        CALL write_string(diagnostic_output_type,"MPI IRECV call posted:",err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive count = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SIZE,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive datatype = ",mpi_double_precision,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive source = ",distributed_vector%DOMAIN_MAPPING% &
                          & adjacent_domains(domain_idx)%DOMAIN_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive tag = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%RECEIVE_TAG_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive comm = ",computational_environment%MPI_COMM, &
                          & err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive request = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%MPI_RECEIVE_REQUEST,err,error,*999)                
                      ENDIF
                    CASE(matrix_vector_l_type)
                      CALL mpi_irecv(distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_BUFFER_L, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SIZE,mpi_logical, &
                        & distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%DOMAIN_NUMBER, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%RECEIVE_TAG_NUMBER,computational_environment%MPI_COMM, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%MPI_RECEIVE_REQUEST,mpi_ierror)
                      CALL mpi_error_check("MPI_IRECV",mpi_ierror,err,error,*999)
                      IF(diagnostics5) THEN
                        CALL write_string(diagnostic_output_type,"MPI IRECV call posted:",err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive count = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%RECEIVE_BUFFER_SIZE,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive datatype = ",mpi_logical,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive source = ",distributed_vector%DOMAIN_MAPPING% &
                          & adjacent_domains(domain_idx)%DOMAIN_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive tag = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%RECEIVE_TAG_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive comm = ",computational_environment%MPI_COMM, &
                          & err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Receive request = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%MPI_RECEIVE_REQUEST,err,error,*999)                
                      ENDIF
                    CASE DEFAULT
                      local_error="The distributed vector data type of "// &
                        & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))//" is invalid."
                      CALL flagerror(local_error,err,error,*999)
                    END SELECT
                  ENDDO !domain_idx
                  !Post all the send calls.
                  DO domain_idx=1,distributed_vector%DOMAIN_MAPPING%NUMBER_OF_ADJACENT_DOMAINS
                    SELECT CASE(distributed_vector%DATA_TYPE)
                    CASE(matrix_vector_intg_type)
                      CALL mpi_isend(distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_BUFFER_INTG, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_BUFFER_SIZE,mpi_integer, &
                        & distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%DOMAIN_NUMBER, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_TAG_NUMBER,computational_environment%MPI_COMM, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%MPI_SEND_REQUEST,mpi_ierror)
                      CALL mpi_error_check("MPI_ISEND",mpi_ierror,err,error,*999)
                      IF(diagnostics5) THEN
                        CALL write_string(diagnostic_output_type,"MPI ISEND call posted:",err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send count = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%SEND_BUFFER_SIZE,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send datatype = ",mpi_integer,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send dest = ",distributed_vector%DOMAIN_MAPPING% &
                          & adjacent_domains(domain_idx)%DOMAIN_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send tag = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%SEND_TAG_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send comm = ",computational_environment%MPI_COMM, &
                          & err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send request = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%MPI_SEND_REQUEST,err,error,*999)                
                      ENDIF
                    CASE(matrix_vector_sp_type)
                      CALL mpi_isend(distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_BUFFER_SP, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_BUFFER_SIZE,mpi_real, &
                        & distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%DOMAIN_NUMBER, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_TAG_NUMBER,computational_environment%MPI_COMM, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%MPI_SEND_REQUEST,mpi_ierror)
                      CALL mpi_error_check("MPI_ISEND",mpi_ierror,err,error,*999)
                      IF(diagnostics5) THEN
                        CALL write_string(diagnostic_output_type,"MPI ISEND call posted:",err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send count = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%SEND_BUFFER_SIZE,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send datatype = ",mpi_real,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send dest = ",distributed_vector%DOMAIN_MAPPING% &
                          & adjacent_domains(domain_idx)%DOMAIN_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send tag = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%SEND_TAG_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send comm = ",computational_environment%MPI_COMM, &
                          & err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send request = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%MPI_SEND_REQUEST,err,error,*999)                
                      ENDIF
                    CASE(matrix_vector_dp_type)
                      CALL mpi_isend(distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_BUFFER_DP, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_BUFFER_SIZE,mpi_double_precision, &
                        & distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%DOMAIN_NUMBER, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_TAG_NUMBER,computational_environment%MPI_COMM, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%MPI_SEND_REQUEST,mpi_ierror)
                      CALL mpi_error_check("MPI_ISEND",mpi_ierror,err,error,*999)
                      IF(diagnostics5) THEN
                        CALL write_string(diagnostic_output_type,"MPI ISEND call posted:",err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send count = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%SEND_BUFFER_SIZE,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send datatype = ",mpi_double_precision,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send dest = ",distributed_vector%DOMAIN_MAPPING% &
                          & adjacent_domains(domain_idx)%DOMAIN_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send tag = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%SEND_TAG_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send comm = ",computational_environment%MPI_COMM, &
                          & err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send request = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%MPI_SEND_REQUEST,err,error,*999)                
                      ENDIF
                    CASE(matrix_vector_l_type)
                      CALL mpi_isend(distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_BUFFER_L, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_BUFFER_SIZE,mpi_logical, &
                        & distributed_vector%DOMAIN_MAPPING%ADJACENT_DOMAINS(domain_idx)%DOMAIN_NUMBER, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%SEND_TAG_NUMBER,computational_environment%MPI_COMM, &
                        & distributed_vector%CMISS%TRANSFERS(domain_idx)%MPI_SEND_REQUEST,mpi_ierror)
                      CALL mpi_error_check("MPI_ISEND",mpi_ierror,err,error,*999)
                      IF(diagnostics5) THEN
                        CALL write_string(diagnostic_output_type,"MPI ISEND call posted:",err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send count = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%SEND_BUFFER_SIZE,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send datatype = ",mpi_logical,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send dest = ",distributed_vector%DOMAIN_MAPPING% &
                          & adjacent_domains(domain_idx)%DOMAIN_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send tag = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%SEND_TAG_NUMBER,err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send comm = ",computational_environment%MPI_COMM, &
                          & err,error,*999)
                        CALL write_string_value(diagnostic_output_type,"  Send request = ",distributed_vector% &
                          & cmiss%TRANSFERS(domain_idx)%MPI_SEND_REQUEST,err,error,*999)                
                      ENDIF
                    CASE DEFAULT
                      local_error="The distributed vector data type of "// &
                        & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))//" is invalid."
                      CALL flagerror(local_error,err,error,*999)
                    END SELECT
                  ENDDO !domain_idx
                ENDIF
              ENDIF
            ELSE
              CALL flagerror("Domain mapping is not associated for the distributed vector.",err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)          
          IF(ASSOCIATED(distributed_vector%PETSC)) THEN
            IF(distributed_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
              CALL petsc_vecassemblybegin(distributed_vector%PETSC%OVERRIDE_VECTOR,err,error,*999)
            ELSE
              CALL petsc_vecassemblybegin(distributed_vector%PETSC%VECTOR,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
          ENDIF
        CASE DEFAULT
          local_error="The distributed vector library type of "// &
            & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    IF(diagnostics1) THEN
      SELECT CASE(distributed_vector%LIBRARY_TYPE)
      CASE(distributed_matrix_vector_cmiss_type)
        IF(ASSOCIATED(distributed_vector%CMISS)) THEN
          CALL write_string(diagnostic_output_type,"Distributed vector :",err,error,*999)
          CALL write_string_value(diagnostic_output_type,"  Data type = ",distributed_vector%DATA_TYPE,err,error,*999)
          CALL write_string_value(diagnostic_output_type,"  Base tag number = ",distributed_vector%CMISS%BASE_TAG_NUMBER, &
            & err,error,*999)
          CALL write_string_value(diagnostic_output_type,"  Number of adjacent domains = ",distributed_vector%DOMAIN_MAPPING% &
            & number_of_adjacent_domains,err,error,*999)
          DO domain_idx=1,distributed_vector%DOMAIN_MAPPING%NUMBER_OF_ADJACENT_DOMAINS
            CALL write_string_value(diagnostic_output_type,"    Domain idx = ",domain_idx,err,error,*999)
            CALL write_string_value(diagnostic_output_type,"    Domain number = ",distributed_vector%DOMAIN_MAPPING% &
              & adjacent_domains(domain_idx)%DOMAIN_NUMBER,err,error,*999)
            CALL write_string_value(diagnostic_output_type,"    Receive tag number = ",distributed_vector% &
              & cmiss%TRANSFERS(domain_idx)%RECEIVE_TAG_NUMBER,err,error,*999)
            CALL write_string_value(diagnostic_output_type,"    Send tag number = ",distributed_vector% &
              & cmiss%TRANSFERS(domain_idx)%SEND_TAG_NUMBER,err,error,*999)
            CALL write_string_value(diagnostic_output_type,"    MPI send request = ",distributed_vector% &
              & cmiss%TRANSFERS(domain_idx)%MPI_SEND_REQUEST,err,error,*999)
            CALL write_string_value(diagnostic_output_type,"    MPI receive request = ",distributed_vector% &
              & cmiss%TRANSFERS(domain_idx)%MPI_RECEIVE_REQUEST,err,error,*999)
          ENDDO !domain_idx
          CALL write_string_value(diagnostic_output_type,"  Data size = ",distributed_vector%CMISS%DATA_SIZE,err,error,*999)
          SELECT CASE(distributed_vector%DATA_TYPE)
          CASE(matrix_vector_intg_type)
            CALL write_string_vector(diagnostic_output_type,1,1,distributed_vector%CMISS%DATA_SIZE,5,5,distributed_vector%CMISS% &
              & data_intg,'("  Data :",5(X,I13))','(8X,5(X,I13))',err,error,*999)      
          CASE(matrix_vector_sp_type)
            CALL write_string_vector(diagnostic_output_type,1,1,distributed_vector%CMISS%DATA_SIZE,5,5,distributed_vector%CMISS% &
              & data_sp,'("  Data :",5(X,E13.6))','(8X,5(X,E13.6))',err,error,*999)      
          CASE(matrix_vector_dp_type)
            CALL write_string_vector(diagnostic_output_type,1,1,distributed_vector%CMISS%DATA_SIZE,5,5,distributed_vector%CMISS% &
              & data_dp,'("  Data :",5(X,E13.6))','(8X,5(X,E13.6))',err,error,*999)      
          CASE(matrix_vector_l_type)
            CALL write_string_vector(diagnostic_output_type,1,1,distributed_vector%CMISS%DATA_SIZE,8,8,distributed_vector%CMISS% &
              & data_l,'("  Data :",8(X,L))','(8X,8(X,L))',err,error,*999)      
          CASE DEFAULT
            local_error="The distributed vector data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
        ENDIF
      CASE(distributed_matrix_vector_petsc_type)
        !Do nothing
      CASE DEFAULT
        local_error="The distributed vector library type of "// &
          & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
        CALL flagerror(local_error,err,error,*999)
      END SELECT
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_UPDATE_START")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_UPDATE_START",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_update_start

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

  SUBROUTINE distributedvector_l2norm(distributedVector,norm,err,error,*)

    !Argument variables
    TYPE(distributed_vector_type), INTENT(IN), POINTER :: distributedVector
    REAL(DP), INTENT(OUT) :: norm
    INTEGER(INTG), INTENT(OUT) :: err
    TYPE(varying_string), INTENT(OUT) :: error
    !Local Variables
    INTEGER(INTG) :: i
    TYPE(varying_string) :: localError

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

    IF(ASSOCIATED(distributedvector)) THEN
      IF(distributedvector%VECTOR_FINISHED) THEN
        SELECT CASE(distributedvector%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          SELECT CASE(distributedvector%DATA_TYPE)
          CASE(matrix_vector_dp_type)
              IF(ASSOCIATED(distributedvector%CMISS)) THEN
                norm=0.0_dp
                DO i=1,distributedvector%CMISS%DATA_SIZE
                  norm=norm+(distributedvector%CMISS%DATA_DP(i)**2)
                ENDDO !i
                norm=sqrt(norm)
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
          CASE(matrix_vector_sp_type)
            CALL flagerror("Not implemented.",err,error,*999)
          CASE(matrix_vector_intg_type)
            CALL flagerror("Not implemented.",err,error,*999)
          CASE(matrix_vector_l_type)
            CALL flagerror("Not implemented.",err,error,*999)
          CASE DEFAULT
            localerror="The distributed data type of "// &
              & trim(numbertovstring(distributedvector%DATA_TYPE,"*",err,error))// &
              & " is invalid."
            CALL flagerror(localerror,err,error,*999)
          END SELECT
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot calculate norm for a PETSc distributed vector.",err,error,*999)
        CASE DEFAULT
          localerror="The distributed vector library type of "// &
            & trim(numbertovstring(distributedvector%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(localerror,err,error,*999)
        END SELECT
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF

    exits("DistributedVector_L2Norm")
    RETURN
999 errorsexits("DistributedVector_L2Norm",err,error)
    RETURN 1
  END SUBROUTINE distributedvector_l2norm
  
  !
  !================================================================================================================================
  !

  SUBROUTINE distributedvector_vecdotintg(distributedVectorA,distributedVectorB,dotProduct,err,error,*)

    !Argument variables
    TYPE(distributed_vector_type), INTENT(IN), POINTER :: distributedVectorA
    TYPE(distributed_vector_type), INTENT(IN), POINTER :: distributedVectorB
    INTEGER(INTG), INTENT(OUT) :: dotProduct
    INTEGER(INTG), INTENT(OUT) :: err
    TYPE(varying_string), INTENT(OUT) :: error
    !Local Variables
    INTEGER(INTG) :: dataTypeA,dataTypeB,i
    TYPE(varying_string) :: localError

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

    IF(ASSOCIATED(distributedvectora) .AND. ASSOCIATED(distributedvectorb)) THEN
      IF(distributedvectora%VECTOR_FINISHED .AND. distributedvectorb%VECTOR_FINISHED) THEN
        IF (distributedvectora%LIBRARY_TYPE==distributedvectorb%LIBRARY_TYPE) THEN
          CALL distributedvector_datatypeget(distributedvectora,datatypea,err,error,*999)
          CALL distributedvector_datatypeget(distributedvectorb,datatypeb,err,error,*999)
          IF(datatypea==datatypeb) THEN
            SELECT CASE(distributedvectora%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributedvectora%CMISS)) THEN
                IF(distributedvectora%CMISS%DATA_SIZE==distributedvectorb%CMISS%DATA_SIZE) THEN
                  IF(distributedvectora%DATA_TYPE==matrix_vector_intg_type) THEN
                    dotproduct=0
                    DO i=1,distributedvectora%CMISS%DATA_SIZE
                      dotproduct=dotproduct+(distributedvectora%CMISS%DATA_INTG(i)*distributedvectorb%CMISS%DATA_INTG(i))
                    ENDDO !i
                  ELSE
                    CALL flagerror("Input distributed vector data type does not match output.",err,error,*999)
                  ENDIF
                ELSE
                  CALL flagerror("The distributed vectors do not have the same size.",err,error,*999)
                ENDIF
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              CALL flagerror("Distributed vector PETSC is double-precision, output scalar should be DP",err,error,*999)
            CASE DEFAULT
              localerror="The distributed vector library type of "// &
                & trim(numbertovstring(distributedvectora%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(localerror,err,error,*999)
            END SELECT
          ELSE
            CALL flagerror("The distributed vectors do not have the same data type.",err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("The distributed vectors do not have the same library type.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF

    exits("DistributedVector_VecDotIntg")
    RETURN
999 errorsexits("DistributedVector_VecDotIntg",err,error)
    RETURN 1
  END SUBROUTINE distributedvector_vecdotintg
  
  !
  !================================================================================================================================
  !

  SUBROUTINE distributedvector_vecdotsp(distributedVectorA,distributedVectorB,dotProduct,err,error,*)

    !Argument variables
    TYPE(distributed_vector_type), INTENT(IN), POINTER :: distributedVectorA
    TYPE(distributed_vector_type), INTENT(IN), POINTER :: distributedVectorB
    REAL(SP), INTENT(OUT) :: dotProduct
    INTEGER(INTG), INTENT(OUT) :: err
    TYPE(varying_string), INTENT(OUT) :: error
    !Local Variables
    INTEGER(INTG) :: dataTypeA,dataTypeB,i
    TYPE(varying_string) :: localError

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

    IF(ASSOCIATED(distributedvectora) .AND. ASSOCIATED(distributedvectorb)) THEN
      IF(distributedvectora%VECTOR_FINISHED .AND. distributedvectorb%VECTOR_FINISHED) THEN
        IF (distributedvectora%LIBRARY_TYPE==distributedvectorb%LIBRARY_TYPE) THEN
          CALL distributedvector_datatypeget(distributedvectora,datatypea,err,error,*999)
          CALL distributedvector_datatypeget(distributedvectorb,datatypeb,err,error,*999)
          IF(datatypea==datatypeb) THEN
            SELECT CASE(distributedvectora%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributedvectora%CMISS)) THEN
                IF(distributedvectora%CMISS%DATA_SIZE==distributedvectorb%CMISS%DATA_SIZE) THEN
                  IF(distributedvectora%DATA_TYPE==matrix_vector_sp_type) THEN
                    dotproduct=0.0_sp
                    DO i=1,distributedvectora%CMISS%DATA_SIZE
                      dotproduct=dotproduct+(distributedvectora%CMISS%DATA_SP(i)*distributedvectorb%CMISS%DATA_SP(i))
                    ENDDO !i
                  ELSE
                    CALL flagerror("Input distributed vector data type does not match output.",err,error,*999)
                  ENDIF
                ELSE
                  CALL flagerror("The distributed vectors do not have the same size.",err,error,*999)
                ENDIF
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              CALL flagerror("Distributed vector PETSC is double-precision, output scalar should be DP",err,error,*999)
            CASE DEFAULT
              localerror="The distributed vector library type of "// &
                & trim(numbertovstring(distributedvectora%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(localerror,err,error,*999)
            END SELECT
          ELSE
            CALL flagerror("The distributed vectors do not have the same data type.",err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("The distributed vectors do not have the same library type.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF

    exits("DistributedVector_VecDotSp")
    RETURN
999 errorsexits("DistributedVector_VecDotSp",err,error)
    RETURN 1
  END SUBROUTINE distributedvector_vecdotsp

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

  SUBROUTINE distributedvector_vecdotdp(distributedVectorA,distributedVectorB,dotProduct,err,error,*)

    !Argument variables
    TYPE(distributed_vector_type), INTENT(IN), POINTER :: distributedVectorA
    TYPE(distributed_vector_type), INTENT(IN), POINTER :: distributedVectorB
    REAL(DP), INTENT(OUT) :: dotProduct
    INTEGER(INTG), INTENT(OUT) :: err
    TYPE(varying_string), INTENT(OUT) :: error
    !Local Variables
    INTEGER(INTG) :: dataTypeA,dataTypeB,i
    TYPE(varying_string) :: localError

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

    IF(ASSOCIATED(distributedvectora) .AND. ASSOCIATED(distributedvectorb)) THEN
      IF(distributedvectora%VECTOR_FINISHED .AND. distributedvectorb%VECTOR_FINISHED) THEN
        IF (distributedvectora%LIBRARY_TYPE==distributedvectorb%LIBRARY_TYPE) THEN
          CALL distributedvector_datatypeget(distributedvectora,datatypea,err,error,*999)
          CALL distributedvector_datatypeget(distributedvectorb,datatypeb,err,error,*999)
          IF(datatypea==datatypeb) THEN
            SELECT CASE(distributedvectora%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributedvectora%CMISS)) THEN
                IF(distributedvectora%CMISS%DATA_SIZE==distributedvectorb%CMISS%DATA_SIZE) THEN
                  IF(distributedvectora%DATA_TYPE==matrix_vector_dp_type) THEN
                    dotproduct=0.0_dp
                    DO i=1,distributedvectora%CMISS%DATA_SIZE
                      dotproduct=dotproduct+(distributedvectora%CMISS%DATA_DP(i)*distributedvectorb%CMISS%DATA_DP(i))
                    ENDDO !i
                  ELSE
                    CALL flagerror("Input distributed vector data type does not match output.",err,error,*999)
                  ENDIF
                ELSE
                  CALL flagerror("The distributed vectors do not have the same size.",err,error,*999)
                ENDIF
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              IF(ASSOCIATED(distributedvectora%PETSC)) THEN
                CALL petsc_vecdot(distributedvectora%PETSC%VECTOR,distributedvectorb%PETSC%VECTOR, &
                  & dotproduct,err,error,*999)
              ELSE
                CALL flagerror("Distributed vector PETSC is not associated.",err,error,*999)
              ENDIF
            CASE DEFAULT
              localerror="The distributed vector library type of "// &
                & trim(numbertovstring(distributedvectora%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(localerror,err,error,*999)
            END SELECT
          ELSE
            CALL flagerror("The distributed vectors do not have the same data type.",err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("The distributed vectors do not have the same library type.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF

    exits("DistributedVector_VecDotDp")
    RETURN
999 errorsexits("DistributedVector_VecDotDp",err,error)
    RETURN 1
  END SUBROUTINE distributedvector_vecdotdp
  
  !
  !================================================================================================================================
  !

  SUBROUTINE distributed_vector_values_add_intg(DISTRIBUTED_VECTOR,INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: INDICES(:)
    INTEGER(INTG), 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_VECTOR_VALUES_ADD_INTG",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(SIZE(indices,1)==SIZE(values,1)) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_intg_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                DO i=1,SIZE(indices,1)
                  !Allow all values added until dof mappings fixed. Ghost values that are added will not be propogated
                  IF(indices(i)>0.AND.indices(i)<=distributed_vector%CMISS%DATA_SIZE) THEN
                    distributed_vector%CMISS%DATA_INTG(indices(i))=distributed_vector%CMISS%DATA_INTG(indices(i))+values(i)
                  ELSE
                    local_error="Index "//trim(numbertovstring(indices(i),"*",err,error))// &
                      & " is invalid. The index must be between 1 and "// &
                      & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                    CALL flagerror(local_error,err,error,*999)
                  ENDIF
                ENDDO !i
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              CALL flagerror("Cannot add values for an integer PETSc distributed vector.",err,error,*999)                    
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the integer data type of the given values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          local_error="The size of the indicies array ("//trim(numbertovstring(SIZE(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 vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_ADD_INTG")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_ADD_INTG",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_add_intg

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

  SUBROUTINE distributed_vector_values_add_intg1(DISTRIBUTED_VECTOR,INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: 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_VECTOR_VALUES_ADD_INTG1",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_intg_type) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              !Allow all values to be added until dof mappings fixed. Ghost values that are added will not be propogated
              IF(index>0.AND.index<=distributed_vector%CMISS%DATA_SIZE) THEN
                distributed_vector%CMISS%DATA_INTG(index)=distributed_vector%CMISS%DATA_INTG(index)+VALUE
              ELSE
                local_error="Index "//trim(numbertovstring(index,"*",err,error))// &
                  & " is invalid. The index must be between 1 and "// &
                  & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot add values for an integer PETSc distributed vector.",err,error,*999)          
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          local_error="The distributed data type of "// &
            & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the integer data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_ADD_INTG1")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_ADD_INTG1",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_add_intg1

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

  SUBROUTINE distributed_vector_values_add_sp(DISTRIBUTED_VECTOR,INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: INDICES(:)
    REAL(SP), 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_VECTOR_VALUES_ADD_SP",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(SIZE(indices,1)==SIZE(values,1)) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_sp_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                DO i=1,SIZE(indices,1)
                  !Allow all values to be added until dof mappings fixed. Ghost values that are added will not be propogated
                  IF(indices(i)>0.AND.indices(i)<=distributed_vector%CMISS%DATA_SIZE) THEN
                    distributed_vector%CMISS%DATA_SP(indices(i))=distributed_vector%CMISS%DATA_SP(indices(i))+values(i)
                  ELSE
                    local_error="Index "//trim(numbertovstring(indices(i),"*",err,error))// &
                      & " is invalid. The index must be between 1 and "// &
                      & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                    CALL flagerror(local_error,err,error,*999)
                  ENDIF
                ENDDO !i
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              CALL flagerror("Cannot add values for a single precision PETSc distributed vector.",err,error,*999)          
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
         ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the single precision data type of the given values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          local_error="The size of the indices array ("//trim(numbertovstring(SIZE(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 vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_ADD_SP")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_ADD_SP",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_add_sp

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

  SUBROUTINE distributed_vector_values_add_sp1(DISTRIBUTED_VECTOR,INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: 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_VECTOR_VALUES_ADD_SP1",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_sp_type) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              !Allow all values to be added until dof mappings fixed. Ghost values that are added will not be propogated
              IF(index>0.AND.index<=distributed_vector%CMISS%DATA_SIZE) THEN
                distributed_vector%CMISS%DATA_SP(index)=distributed_vector%CMISS%DATA_SP(index)+VALUE
              ELSE
                local_error="Index "//trim(numbertovstring(index,"*",err,error))// &
                  & " is invalid. The index must be between 1 and "// &
                  & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot add values for a single precision PETSc distributed vector.",err,error,*999)          
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          local_error="The distributed data type of "// &
            & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the single precision data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_ADD_SP1")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_ADD_SP1",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_add_sp1

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

  SUBROUTINE distributed_vector_values_add_dp(DISTRIBUTED_VECTOR,INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: 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_VECTOR_VALUES_ADD_DP",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(SIZE(indices,1)==SIZE(values,1)) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_dp_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                DO i=1,SIZE(indices,1)
                  !Allow all values to be added until dof mappings fixed. Ghost values that are added will not be propogated
                  IF(indices(i)>0.AND.indices(i)<=distributed_vector%CMISS%DATA_SIZE) THEN
                    distributed_vector%CMISS%DATA_DP(indices(i))=distributed_vector%CMISS%DATA_DP(indices(i))+values(i)
                  ELSE
                    local_error="Index "//trim(numbertovstring(indices(i),"*",err,error))// &
                      & " is invalid. The index must be between 1 and "// &
                      & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                    CALL flagerror(local_error,err,error,*999)
                  ENDIF
                ENDDO !i
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              IF(ASSOCIATED(distributed_vector%PETSC)) THEN
                IF(distributed_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
                  CALL petsc_vecsetvalues(distributed_vector%PETSC%OVERRIDE_VECTOR,SIZE(indices,1),distributed_vector%PETSC% &
                    & global_numbers(indices),values,petsc_add_values,err,error,*999)
                ELSE
                  CALL petsc_vecsetvalues(distributed_vector%PETSC%VECTOR,SIZE(indices,1),distributed_vector%PETSC% &
                    & global_numbers(indices),values,petsc_add_values,err,error,*999)
                ENDIF
              ELSE
                CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
              ENDIF
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the double precision data type of the given values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          local_error="The size of the indices array ("//trim(numbertovstring(SIZE(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 vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_ADD_DP")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_ADD_DP",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_add_dp

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

  SUBROUTINE distributed_vector_values_add_dp1(DISTRIBUTED_VECTOR,INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: INDEX
    REAL(DP), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    REAL(DP) :: PETSC_VALUE(1)
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_VECTOR_VALUES_ADD_DP1",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_dp_type) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              !Allow all values to be added until dof mappings fixed. Ghost values that are added will not be propogated
              IF(index>0.AND.index<=distributed_vector%CMISS%DATA_SIZE) THEN
                distributed_vector%CMISS%DATA_DP(index)=distributed_vector%CMISS%DATA_DP(index)+VALUE
              ELSE
                local_error="Index "//trim(numbertovstring(index,"*",err,error))// &
                  & " is invalid. The index must be between 1 and "// &
                  & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            IF(ASSOCIATED(distributed_vector%PETSC)) THEN
              petsc_value(1)=VALUE
              IF(distributed_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
                CALL petsc_vecsetvalues(distributed_vector%PETSC%OVERRIDE_VECTOR,1,distributed_vector%PETSC%GLOBAL_NUMBERS(index), &
                  & petsc_value,petsc_add_values,err,error,*999)
              ELSE
                CALL petsc_vecsetvalues(distributed_vector%PETSC%VECTOR,1,distributed_vector%PETSC%GLOBAL_NUMBERS(index), &
                  & petsc_value,petsc_add_values,err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
            ENDIF
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT          
        ELSE
          local_error="The distributed data type of "// &
            & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the double precision data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_ADD_DP1")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_ADD_DP1",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_add_dp1

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

  SUBROUTINE distributed_vector_values_add_l(DISTRIBUTED_VECTOR,INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: INDICES(:)
    LOGICAL, 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_VECTOR_VALUES_ADDED_L",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(SIZE(indices,1)==SIZE(values,1)) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_l_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                DO i=1,SIZE(indices,1)
                  !Allow all values to be added until dof mappings fixed. Ghost values that are added will not be propogated
                  IF(indices(i)>0.AND.indices(i)<=distributed_vector%CMISS%DATA_SIZE) THEN
                    distributed_vector%CMISS%DATA_L(indices(i))=distributed_vector%CMISS%DATA_L(indices(i)).OR.values(i)
                  ELSE
                    local_error="Index "//trim(numbertovstring(indices(i),"*",err,error))// &
                      & " is invalid. The index must be between 1 and "// &
                      & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                    CALL flagerror(local_error,err,error,*999)
                  ENDIF
                ENDDO !i
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              CALL flagerror("Cannot add values for a logical PETSc distributed vector.",err,error,*999)          
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the logical data type of the given values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          local_error="The size of the indices array ("//trim(numbertovstring(SIZE(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 vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_ADD_L")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_ADD_L",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_add_l

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

  SUBROUTINE distributed_vector_values_add_l1(DISTRIBUTED_VECTOR,INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: 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_VECTOR_VALUES_ADD_L1",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_l_type) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              !Allow all values to be added until dof mappings fixed. Ghost values that are added will not be propogated
              IF(index>0.AND.index<=distributed_vector%CMISS%DATA_SIZE) THEN
                distributed_vector%CMISS%DATA_L(index)=distributed_vector%CMISS%DATA_L(index).OR.VALUE
              ELSE
                local_error="Index "//trim(numbertovstring(index,"*",err,error))// &
                  & " is invalid. The index must be between 1 and "// &
                  & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot add values for a logical PETSc distributed vector.",err,error,*999)          
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          local_error="The distributed data type of "// &
            & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the logical data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_ADD_L1")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_ADD_L1",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_add_l1

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

  SUBROUTINE distributed_vector_values_get_intg(DISTRIBUTED_VECTOR,INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: INDICES(:)
    INTEGER(INTG), 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_VECTOR_VALUES_GET_INTG",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(SIZE(indices,1)==SIZE(values,1)) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_intg_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                DO i=1,SIZE(indices,1)
                  IF(indices(i)>0.AND.indices(i)<=distributed_vector%CMISS%DATA_SIZE) THEN
                    values(i)=distributed_vector%CMISS%DATA_INTG(indices(i))
                  ELSE
                    local_error="Index "//trim(numbertovstring(indices(i),"*",err,error))// &
                      & " is invalid. The index must be between 1 and "// &

                      & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                    CALL flagerror(local_error,err,error,*999)
                  ENDIF
                ENDDO !i
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              CALL flagerror("Cannot set values for an integer PETSc distributed vector.",err,error,*999)          
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the integer data type of the given values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          local_error="The size of the indicies array ("//trim(numbertovstring(SIZE(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 vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_GET_INTG")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_GET_INTG",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_get_intg

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

  SUBROUTINE distributed_vector_values_get_intg1(DISTRIBUTED_VECTOR,INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: 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_VECTOR_VALUES_GET_INTG1",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_intg_type) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              IF(index>0.AND.index<=distributed_vector%CMISS%DATA_SIZE) THEN
                VALUE=distributed_vector%CMISS%DATA_INTG(index)
              ELSE
                local_error="Index "//trim(numbertovstring(index,"*",err,error))// &
                  & " is invalid. The index must be between 1 and "// &
                  & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot set values for an integer PETSc distributed vector.",err,error,*999)          
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          local_error="The distributed data type of "// &
            & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the integer data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_GET_INTG1")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_GET_INTG1",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_get_intg1

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

  SUBROUTINE distributed_vector_values_get_sp(DISTRIBUTED_VECTOR,INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: INDICES(:)
    REAL(SP), 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_VECTOR_VALUES_GET_SP",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(SIZE(indices,1)==SIZE(values,1)) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_sp_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                DO i=1,SIZE(indices,1)
                  IF(indices(i)>0.AND.indices(i)<=distributed_vector%CMISS%DATA_SIZE) THEN
                    values(i)=distributed_vector%CMISS%DATA_SP(indices(i))
                  ELSE
                    local_error="Index "//trim(numbertovstring(indices(i),"*",err,error))// &
                      & " is invalid. The index must be between 1 and "// &
                      & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                    CALL flagerror(local_error,err,error,*999)
                  ENDIF
                ENDDO !i
              ELSE
                CALL flagerror("Distributed vector 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 vector.",err,error,*999)          
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the single precision data type of the given values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          local_error="The size of the indices array ("//trim(numbertovstring(SIZE(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 vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_GET_SP")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_GET_SP",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_get_sp

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

  SUBROUTINE distributed_vector_values_get_sp1(DISTRIBUTED_VECTOR,INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: 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_VECTOR_VALUES_GET_SP1",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_sp_type) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              IF(index>0.AND.index<=distributed_vector%CMISS%DATA_SIZE) THEN
                VALUE=distributed_vector%CMISS%DATA_SP(index)
              ELSE
                local_error="Index "//trim(numbertovstring(index,"*",err,error))// &
                  & " is invalid. The index must be between 1 and "// &
                  & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot set values for a single precision PETSc distributed vector.",err,error,*999)          
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          local_error="The distributed data type of "// &
            & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the single precision data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_GET_SP1")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_GET_SP1",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_get_sp1

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

  SUBROUTINE distributed_vector_values_get_dp(DISTRIBUTED_VECTOR,INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: INDICES(:)
    REAL(DP), INTENT(OUT) :: VALUES(:)
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: i,PETSC_INDICES(size(indices,1))
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_VECTOR_VALUES_GET_DP",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(SIZE(indices,1)==SIZE(values,1)) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_dp_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                DO i=1,SIZE(indices,1)
                  IF(indices(i)>0.AND.indices(i)<=distributed_vector%CMISS%DATA_SIZE) THEN
                    values(i)=distributed_vector%CMISS%DATA_DP(indices(i))
                  ELSE
                    local_error="Index "//trim(numbertovstring(indices(i),"*",err,error))// &
                      & " is invalid. The index must be between 1 and "// &
                      & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                    CALL flagerror(local_error,err,error,*999)
                  ENDIF
                ENDDO !i
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              IF(ASSOCIATED(distributed_vector%PETSC)) THEN
                DO i=1,SIZE(indices,1)
                  petsc_indices(i)=distributed_vector%DOMAIN_MAPPING%LOCAL_TO_GLOBAL_MAP(indices(i))-1 !PETSc uses global 0-based indices
                ENDDO !i
                IF(distributed_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
                  CALL petsc_vecgetvalues(distributed_vector%PETSC%OVERRIDE_VECTOR,SIZE(indices,1),petsc_indices,values, &
                    & err,error,*999)
                ELSE
                  CALL petsc_vecgetvalues(distributed_vector%PETSC%VECTOR,SIZE(indices,1),petsc_indices,values,err,error,*999)
                ENDIF
              ELSE
                CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
              ENDIF
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the double precision data type of the given values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          local_error="The size of the indices array ("//trim(numbertovstring(SIZE(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 vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_GET_DP")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_GET_DP",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_get_dp

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

  SUBROUTINE distributed_vector_values_get_dp1(DISTRIBUTED_VECTOR,INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: INDEX
    REAL(DP), INTENT(OUT) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: PETSC_INDEX(1)
    REAL(DP) :: PETSC_VALUE(1)
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_VECTOR_VALUES_GET_DP1",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_dp_type) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              IF(index>0.AND.index<=distributed_vector%CMISS%DATA_SIZE) THEN
                VALUE=distributed_vector%CMISS%DATA_DP(index)
              ELSE
                local_error="Index "//trim(numbertovstring(index,"*",err,error))// &
                  & " is invalid. The index must be between 1 and "// &
                  & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            IF(ASSOCIATED(distributed_vector%PETSC)) THEN
              petsc_index=distributed_vector%DOMAIN_MAPPING%LOCAL_TO_GLOBAL_MAP(index)-1 !PETSc uses global 0-based indices
              IF(distributed_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
                CALL petsc_vecgetvalues(distributed_vector%PETSC%OVERRIDE_VECTOR,1,petsc_index,petsc_value,err,error,*999)
              ELSE
                CALL petsc_vecgetvalues(distributed_vector%PETSC%VECTOR,1,petsc_index,petsc_value,err,error,*999)
              ENDIF
              VALUE=petsc_value(1)
            ELSE
              CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
            ENDIF
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          local_error="The distributed data type of "// &
            & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the double precision data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_GET_DP1")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_GET_DP1",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_get_dp1

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

  SUBROUTINE distributed_vector_values_get_l(DISTRIBUTED_VECTOR,INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: INDICES(:)
    LOGICAL, 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_VECTOR_VALUES_GET_L",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(SIZE(indices,1)==SIZE(values,1)) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_l_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                DO i=1,SIZE(indices,1)
                  IF(indices(i)>0.AND.indices(i)<=distributed_vector%CMISS%DATA_SIZE) THEN
                    values(i)=distributed_vector%CMISS%DATA_L(indices(i))
                  ELSE
                    local_error="Index "//trim(numbertovstring(indices(i),"*",err,error))// &
                      & " is invalid. The index must be between 1 and "// &
                      & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                    CALL flagerror(local_error,err,error,*999)
                  ENDIF
                ENDDO !i
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              CALL flagerror("Cannot set values for a logical PETSc distributed vector.",err,error,*999)          
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the logical data type of the given values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          local_error="The size of the indices array ("//trim(numbertovstring(SIZE(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 vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_GET_L")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_GET_L",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_get_l

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

  SUBROUTINE distributed_vector_values_get_l1(DISTRIBUTED_VECTOR,INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: 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_VECTOR_VALUES_GET_L1",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_l_type) THEN
        SELECT CASE(distributed_vector%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_vector%CMISS)) THEN
            IF(index>0.AND.index<=distributed_vector%CMISS%DATA_SIZE) THEN
              VALUE=distributed_vector%CMISS%DATA_L(index)
            ELSE
              local_error="Index "//trim(numbertovstring(index,"*",err,error))// &
                & " is invalid. The index must be between 1 and "// &
                & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
              CALL flagerror(local_error,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot set values for a logical PETSc distributed vector.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed vector library type of "// &
            & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
        ELSE
          local_error="The distributed data type of "// &
            & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the logical data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_GET_L1")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_GET_L1",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_get_l1

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

  SUBROUTINE distributed_vector_values_set_intg(DISTRIBUTED_VECTOR,INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: INDICES(:)
    INTEGER(INTG), 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_VECTOR_VALUES_SET_INTG",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(SIZE(indices,1)==SIZE(values,1)) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_intg_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                DO i=1,SIZE(indices,1)
                  !Allow all values set until dof mappings fixed. Ghost values that are set will not be propogated
                  IF(indices(i)>0.AND.indices(i)<=distributed_vector%CMISS%DATA_SIZE) THEN
                    distributed_vector%CMISS%DATA_INTG(indices(i))=values(i)
                  ELSE
                    local_error="Index "//trim(numbertovstring(indices(i),"*",err,error))// &
                      & " is invalid. The index must be between 1 and "// &
                      & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                    CALL flagerror(local_error,err,error,*999)
                  ENDIF
                ENDDO !i
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              CALL flagerror("Cannot set values for an integer PETSc distributed vector.",err,error,*999)          
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the integer data type of the given values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          local_error="The size of the indicies array ("//trim(numbertovstring(SIZE(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 vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_SET_INTG")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_SET_INTG",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_set_intg

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

  SUBROUTINE distributed_vector_values_set_intg1(DISTRIBUTED_VECTOR,INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: 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_VECTOR_VALUES_SET_INTG1",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_intg_type) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              !Allow all values set until dof mappings fixed. Ghost values that are set will not be propogated
              IF(index>0.AND.index<=distributed_vector%CMISS%DATA_SIZE) THEN
                distributed_vector%CMISS%DATA_INTG(index)=VALUE
              ELSE
                local_error="Index "//trim(numbertovstring(index,"*",err,error))// &
                  & " is invalid. The index must be between 1 and "// &
                  & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot set values for an integer PETSc distributed vector.",err,error,*999)          
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          local_error="The distributed data type of "// &
            & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the integer data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_SET_INTG1")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_SET_INTG1",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_set_intg1

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

  SUBROUTINE distributed_vector_values_set_sp(DISTRIBUTED_VECTOR,INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: INDICES(:)
    REAL(SP), 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_VECTOR_VALUES_SET_SP",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(SIZE(indices,1)==SIZE(values,1)) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_sp_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                DO i=1,SIZE(indices,1)
                  !Allow all values set until dof mappings fixed. Ghost values that are set will not be propogated
                  IF(indices(i)>0.AND.indices(i)<=distributed_vector%CMISS%DATA_SIZE) THEN
                    distributed_vector%CMISS%DATA_SP(indices(i))=values(i)
                  ELSE
                    local_error="Index "//trim(numbertovstring(indices(i),"*",err,error))// &
                      & " is invalid. The index must be between 1 and "// &
                      & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                    CALL flagerror(local_error,err,error,*999)
                  ENDIF
                ENDDO !i
              ELSE
                CALL flagerror("Distributed vector 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 vector.",err,error,*999)          
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the single precision data type of the given values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          local_error="The size of the indices array ("//trim(numbertovstring(SIZE(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 vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_SET_SP")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_SET_SP",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_set_sp

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

  SUBROUTINE distributed_vector_values_set_sp1(DISTRIBUTED_VECTOR,INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: 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_VECTOR_VALUES_SET_SP1",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_sp_type) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              !Allow all values set until dof mappings fixed. Ghost values that are set will not be propogated
              IF(index>0.AND.index<=distributed_vector%CMISS%DATA_SIZE) THEN
                distributed_vector%CMISS%DATA_SP(index)=VALUE
              ELSE
                local_error="Index "//trim(numbertovstring(index,"*",err,error))// &
                  & " is invalid. The index must be between 1 and "// &
                  & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            CALL flagerror("Cannot set values for a single precision PETSc distributed vector.",err,error,*999)          
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          local_error="The distributed data type of "// &
            & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the single precision data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_SET_SP1")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_SET_SP1",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_set_sp1

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

  SUBROUTINE distributed_vector_values_set_dp(DISTRIBUTED_VECTOR,INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: 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_VECTOR_VALUES_SET_DP",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(SIZE(indices,1)==SIZE(values,1)) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_dp_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                DO i=1,SIZE(indices,1)
                  !Allow all values set until dof mappings fixed. Ghost values that are set will not be propogated
                  IF(indices(i)>0.AND.indices(i)<=distributed_vector%CMISS%DATA_SIZE) THEN
                    distributed_vector%CMISS%DATA_DP(indices(i))=values(i)
                  ELSE
                    local_error="Index "//trim(numbertovstring(indices(i),"*",err,error))// &
                      & " is invalid. The index must be between 1 and "// &
                      & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                    CALL flagerror(local_error,err,error,*999)
                  ENDIF
                ENDDO !i
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              IF(ASSOCIATED(distributed_vector%PETSC)) THEN
                IF(distributed_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
                  CALL petsc_vecsetvalues(distributed_vector%PETSC%OVERRIDE_VECTOR,SIZE(indices,1),distributed_vector%PETSC% &
                    & global_numbers(indices),values,petsc_insert_values,err,error,*999)
                ELSE
                  CALL petsc_vecsetvalues(distributed_vector%PETSC%VECTOR,SIZE(indices,1),distributed_vector%PETSC%GLOBAL_NUMBERS( &
                    & indices),values,petsc_insert_values,err,error,*999)
                ENDIF
              ELSE
                CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
              ENDIF
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the double precision data type of the given values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          local_error="The size of the indices array ("//trim(numbertovstring(SIZE(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 vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_SET_DP")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_SET_DP",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_set_dp

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

  SUBROUTINE distributed_vector_values_set_dp1(DISTRIBUTED_VECTOR,INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: INDEX
    REAL(DP), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: PETSC_INDEX(1)
    REAL(DP) :: PETSC_VALUE(1)
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DISTRIBUTED_VECTOR_VALUES_SET_DP1",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_dp_type) THEN
          SELECT CASE(distributed_vector%LIBRARY_TYPE)
          CASE(distributed_matrix_vector_cmiss_type)
            IF(ASSOCIATED(distributed_vector%CMISS)) THEN
              !Allow all values set until dof mappings fixed. Ghost values that are set will not be propogated
              IF(index>0.AND.index<=distributed_vector%CMISS%DATA_SIZE) THEN
                distributed_vector%CMISS%DATA_DP(index)=VALUE
              ELSE
                local_error="Index "//trim(numbertovstring(index,"*",err,error))// &
                  & " is invalid. The index must be between 1 and "// &
                  & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                CALL flagerror(local_error,err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
            ENDIF
          CASE(distributed_matrix_vector_petsc_type)
            IF(ASSOCIATED(distributed_vector%PETSC)) THEN
              petsc_index(1)=distributed_vector%PETSC%GLOBAL_NUMBERS(index)
              petsc_value(1)=VALUE
              IF(distributed_vector%PETSC%USE_OVERRIDE_VECTOR) THEN
                CALL petsc_vecsetvalues(distributed_vector%PETSC%OVERRIDE_VECTOR,1,petsc_index,petsc_value,petsc_insert_values, &
                  & err,error,*999)
              ELSE
                CALL petsc_vecsetvalues(distributed_vector%PETSC%VECTOR,1,petsc_index,petsc_value,petsc_insert_values, &
                  & err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Distributed vector PETSc is not associated.",err,error,*999)
            ENDIF
          CASE DEFAULT
            local_error="The distributed vector library type of "// &
              & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          local_error="The distributed data type of "// &
            & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the double precision data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_SET_DP1")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_SET_DP1",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_set_dp1

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

  SUBROUTINE distributed_vector_values_set_l(DISTRIBUTED_VECTOR,INDICES,VALUES,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: INDICES(:)
    LOGICAL, 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_VECTOR_VALUES_SET_L",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(SIZE(indices,1)==SIZE(values,1)) THEN
          IF(distributed_vector%DATA_TYPE==matrix_vector_l_type) THEN
            SELECT CASE(distributed_vector%LIBRARY_TYPE)
            CASE(distributed_matrix_vector_cmiss_type)
              IF(ASSOCIATED(distributed_vector%CMISS)) THEN
                DO i=1,SIZE(indices,1)
                  !Allow all values set until dof mappings fixed. Ghost values that are set will not be propogated
                  IF(indices(i)>0.AND.indices(i)<=distributed_vector%CMISS%DATA_SIZE) THEN
                    distributed_vector%CMISS%DATA_L(indices(i))=values(i)
                  ELSE
                    local_error="Index "//trim(numbertovstring(indices(i),"*",err,error))// &
                      & " is invalid. The index must be between 1 and "// &
                      & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
                    CALL flagerror(local_error,err,error,*999)
                  ENDIF
                ENDDO !i
              ELSE
                CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
              ENDIF
            CASE(distributed_matrix_vector_petsc_type)
              CALL flagerror("Cannot set values for a logical PETSc distributed vector.",err,error,*999)          
            CASE DEFAULT
              local_error="The distributed vector library type of "// &
                & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
              CALL flagerror(local_error,err,error,*999)
            END SELECT
          ELSE
            local_error="The distributed data type of "// &
              & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
              & " does not correspond to the logical data type of the given values."
            CALL flagerror(local_error,err,error,*999)
          ENDIF
        ELSE
          local_error="The size of the indices array ("//trim(numbertovstring(SIZE(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 vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_SET_L")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_SET_L",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_set_l

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

  SUBROUTINE distributed_vector_values_set_l1(DISTRIBUTED_VECTOR,INDEX,VALUE,ERR,ERROR,*)

    !Argument variables
    TYPE(distributed_vector_type), POINTER :: DISTRIBUTED_VECTOR
    INTEGER(INTG), INTENT(IN) :: 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_VECTOR_VALUES_SET_L1",err,error,*999)

    IF(ASSOCIATED(distributed_vector)) THEN
      IF(distributed_vector%VECTOR_FINISHED) THEN
        IF(distributed_vector%DATA_TYPE==matrix_vector_l_type) THEN
        SELECT CASE(distributed_vector%LIBRARY_TYPE)
        CASE(distributed_matrix_vector_cmiss_type)
          IF(ASSOCIATED(distributed_vector%CMISS)) THEN
            !Allow all values set until dof mappings fixed. Ghost values that are set will not be propogated
            IF(index>0.AND.index<=distributed_vector%CMISS%DATA_SIZE) THEN
              distributed_vector%CMISS%DATA_L(index)=VALUE
            ELSE
              local_error="Index "//trim(numbertovstring(index,"*",err,error))// &
                & " is invalid. The index must be between 1 and "// &
                & trim(numbertovstring(distributed_vector%CMISS%DATA_SIZE,"*",err,error))//"."
              CALL flagerror(local_error,err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Distributed vector CMISS is not associated.",err,error,*999)
          ENDIF
        CASE(distributed_matrix_vector_petsc_type)
          CALL flagerror("Cannot set values for a logical PETSc distributed vector.",err,error,*999)          
        CASE DEFAULT
          local_error="The distributed vector library type of "// &
            & trim(numbertovstring(distributed_vector%LIBRARY_TYPE,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
        ELSE
          local_error="The distributed data type of "// &
            & trim(numbertovstring(distributed_vector%DATA_TYPE,"*",err,error))// &
            & " does not correspond to the logical data type of the given value."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("The distributed vector has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Distributed vector is not associated.",err,error,*999)
    ENDIF
    
    exits("DISTRIBUTED_VECTOR_VALUES_SET_L1")
    RETURN
999 errorsexits("DISTRIBUTED_VECTOR_VALUES_SET_L1",err,error)
    RETURN 1
  END SUBROUTINE distributed_vector_values_set_l1

  !
  !================================================================================================================================
  !
  
END MODULE distributed_matrix_vector