equations_routines.f90

Go to the documentation of this file.

MODULE equations_routines

  USE base_routines
  USE equations_mapping_routines
  USE equations_matrices_routines
  USE equations_set_constants
  USE field_routines
  USE iso_varying_string
  USE kinds
  USE strings
  USE types

#include "macros.h"  

  IMPLICIT NONE

  PRIVATE


  INTEGER(INTG), PARAMETER :: equations_no_output=0
  INTEGER(INTG), PARAMETER :: equations_timing_output=1
  INTEGER(INTG), PARAMETER :: equations_matrix_output=2
  INTEGER(INTG), PARAMETER :: equations_element_matrix_output=3
  INTEGER(INTG), PARAMETER :: equations_nodal_matrix_output=4

  INTEGER(INTG), PARAMETER :: equations_sparse_matrices=1
  INTEGER(INTG), PARAMETER :: equations_full_matrices=2
 
  INTEGER(INTG), PARAMETER :: equations_unlumped_matrices=1
  INTEGER(INTG), PARAMETER :: equations_lumped_matrices=2
 
  !Module types

  !Module variables

  !Interfaces

  PUBLIC equations_no_output,equations_timing_output,equations_matrix_output,equations_element_matrix_output

  PUBLIC equations_nodal_matrix_output

  PUBLIC equations_sparse_matrices,equations_full_matrices

  PUBLIC equations_unlumped_matrices,equations_lumped_matrices
  
  PUBLIC equations_create_start,equations_create_finish

  PUBLIC equations_destroy

  PUBLIC equations_initialise,equations_finalise

  PUBLIC equations_linearity_type_get,equations_linearity_type_set

  PUBLIC equations_lumping_type_get,equations_lumping_type_set

  PUBLIC equations_output_type_get,equations_output_type_set

  PUBLIC equations_sparsity_type_get,equations_sparsity_type_set

  PUBLIC equations_time_dependence_type_get,equations_time_dependence_type_set

  PUBLIC equations_set_equations_get

  PUBLIC equations_derivedvariableget

  PUBLIC equations_numberoflinearmatricesget

  PUBLIC equations_numberofjacobianmatricesget

  PUBLIC equations_numberofdynamicmatricesget

  PUBLIC equations_linearmatrixget

  PUBLIC equations_jacobianmatrixget

  PUBLIC equations_dynamicmatrixget

  PUBLIC equations_dynamicmatrixgetbytype

  PUBLIC equations_dynamicmatrixtypeget

  PUBLIC equations_rhsvectorget

  PUBLIC equations_residualvectorget

  PUBLIC equations_residualnumberofvariablesget

  PUBLIC equations_residualvariablesget

  PUBLIC equations_sourcevectorget

CONTAINS

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

  SUBROUTINE equations_create_finish(EQUATIONS,ERR,ERROR,*)

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

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

    IF(ASSOCIATED(equations)) THEN
      IF(equations%EQUATIONS_FINISHED) THEN
        CALL flagerror("Equations have already been finished.",err,error,*999)        
      ELSE
        !Set the finished flag
        equations%EQUATIONS_FINISHED=.true.
      ENDIF
    ELSE
      CALL flagerror("Equations is not associated.",err,error,*999)
    ENDIF
       
    exits("EQUATIONS_CREATE_FINISH")
    RETURN
999 errorsexits("EQUATIONS_CREATE_FINISH",err,error)
    RETURN 1
    
  END SUBROUTINE equations_create_finish

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

  SUBROUTINE equations_create_start(EQUATIONS_SET,EQUATIONS,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_set_type), POINTER :: EQUATIONS_SET
    TYPE(equations_type), POINTER :: EQUATIONS
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables

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

    IF(ASSOCIATED(equations_set)) THEN
      IF(ASSOCIATED(equations_set%EQUATIONS)) THEN
        CALL flagerror("Equations are already associated for the equations set.",err,error,*999)        
      ELSE
        IF(ASSOCIATED(equations)) THEN
          CALL flagerror("Equations is already associated.",err,error,*999)
        ELSE
          !Initialise the equations
          CALL equations_initialise(equations_set,err,error,*999)
          !Return the pointer
          equations=>equations_set%EQUATIONS
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Equations set is not associated.",err,error,*999)
    ENDIF
       
    exits("EQUATIONS_CREATE_START")
    RETURN
999 errorsexits("EQUATIONS_CREATE_START",err,error)
    RETURN 1
    
  END SUBROUTINE equations_create_start

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

  SUBROUTINE equations_destroy(EQUATIONS,ERR,ERROR,*)

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

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

    IF(ASSOCIATED(equations)) THEN
      CALL equations_finalise(equations,err,error,*999)
    ELSE
      CALL flagerror("Equations is not associated.",err,error,*999)
    ENDIF
       
    exits("EQUATIONS_DESTROY")
    RETURN
999 errorsexits("EQUATIONS_DESTROY",err,error)
    RETURN 1
    
  END SUBROUTINE equations_destroy

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

  SUBROUTINE equations_finalise(EQUATIONS,ERR,ERROR,*)

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

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

    IF(ASSOCIATED(equations)) THEN
      CALL equations_interpolation_finalise(equations%INTERPOLATION,err,error,*999)
      IF(ASSOCIATED(equations%EQUATIONS_MAPPING)) CALL equations_mapping_destroy(equations%EQUATIONS_MAPPING,err,error,*999)
      IF(ASSOCIATED(equations%EQUATIONS_MATRICES)) CALL equations_matrices_destroy(equations%EQUATIONS_MATRICES,err,error,*999)
      DEALLOCATE(equations)
    ENDIF
       
    exits("EQUATIONS_FINALISE")
    RETURN
999 errorsexits("EQUATIONS_FINALISE",err,error)
    RETURN 1
  END SUBROUTINE equations_finalise

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

  SUBROUTINE equations_initialise(EQUATIONS_SET,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_set_type), POINTER :: EQUATIONS_SET
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: DUMMY_ERR
    TYPE(varying_string) :: DUMMY_ERROR
 
    enters("EQUATIONS_INITIALISE",err,error,*998)

    IF(ASSOCIATED(equations_set)) THEN
      IF(ASSOCIATED(equations_set%EQUATIONS)) THEN
        CALL flagerror("Equations is already associated for this equations set.",err,error,*998)
      ELSE
        ALLOCATE(equations_set%EQUATIONS,stat=err)
        IF(err/=0) CALL flagerror("Could not allocate equations.",err,error,*999)
        equations_set%EQUATIONS%EQUATIONS_SET=>equations_set
        equations_set%EQUATIONS%LINEARITY=equations_linear
        equations_set%EQUATIONS%TIME_DEPENDENCE=equations_static
        equations_set%EQUATIONS%OUTPUT_TYPE=equations_no_output
        equations_set%EQUATIONS%SPARSITY_TYPE=equations_sparse_matrices
        equations_set%EQUATIONS%LUMPING_TYPE=equations_unlumped_matrices
        NULLIFY(equations_set%EQUATIONS%INTERPOLATION)
        NULLIFY(equations_set%EQUATIONS%EQUATIONS_MAPPING)
        NULLIFY(equations_set%EQUATIONS%EQUATIONS_MATRICES)
        equations_set%EQUATIONS%EQUATIONS_FINISHED=.false.
        CALL equations_interpolation_initialise(equations_set%EQUATIONS,err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Equations set is not associated",err,error,*998)
    ENDIF
       
    exits("EQUATIONS_INITIALISE")
    RETURN
999 CALL equations_finalise(equations_set%EQUATIONS,dummy_err,dummy_error,*998)
998 errorsexits("EQUATIONS_INITIALISE",err,error)
    RETURN 1
    
  END SUBROUTINE equations_initialise
  
  !
  !================================================================================================================================
  !
  
  SUBROUTINE equations_interpolation_finalise(EQUATIONS_INTERPOLATION,ERR,ERROR,*)

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

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

    IF(ASSOCIATED(equations_interpolation)) THEN
      CALL field_interpolation_parameters_finalise(equations_interpolation%GEOMETRIC_INTERP_PARAMETERS,err,error,*999)
      CALL field_interpolation_parameters_finalise(equations_interpolation%FIBRE_INTERP_PARAMETERS,err,error,*999)
      CALL field_interpolation_parameters_finalise(equations_interpolation%DEPENDENT_INTERP_PARAMETERS,err,error,*999)
      CALL field_interpolation_parameters_finalise(equations_interpolation%INDEPENDENT_INTERP_PARAMETERS,err,error,*999)
      CALL field_interpolation_parameters_finalise(equations_interpolation%MATERIALS_INTERP_PARAMETERS,err,error,*999)
      CALL field_interpolation_parameters_finalise(equations_interpolation%SOURCE_INTERP_PARAMETERS,err,error,*999)
      CALL field_interpolated_points_finalise(equations_interpolation%GEOMETRIC_INTERP_POINT,err,error,*999)
      CALL field_interpolated_points_finalise(equations_interpolation%DEPENDENT_INTERP_POINT,err,error,*999)
      CALL field_interpolated_points_finalise(equations_interpolation%INDEPENDENT_INTERP_POINT,err,error,*999)
      CALL field_interpolated_points_finalise(equations_interpolation%FIBRE_INTERP_POINT,err,error,*999)
      CALL field_interpolated_points_finalise(equations_interpolation%MATERIALS_INTERP_POINT,err,error,*999)
      CALL field_interpolated_points_finalise(equations_interpolation%SOURCE_INTERP_POINT,err,error,*999)
      CALL field_physical_points_finalise(equations_interpolation%DEPENDENT_PHYSICAL_POINT,err,error,*999)
      CALL field_interpolatedpointsmetricsfinalise(equations_interpolation%DEPENDENT_INTERP_POINT_METRICS,err,error,*999)
      CALL field_interpolatedpointsmetricsfinalise(equations_interpolation%INDEPENDENT_INTERP_POINT_METRICS,err,error,*999)
      CALL field_interpolatedpointsmetricsfinalise(equations_interpolation%GEOMETRIC_INTERP_POINT_METRICS,err,error,*999)
      CALL field_interpolatedpointsmetricsfinalise(equations_interpolation%FIBRE_INTERP_POINT_METRICS,err,error,*999)
      DEALLOCATE(equations_interpolation)
    ENDIF
       
    exits("EQUATIONS_INTERPOLATION_FINALISE")
    RETURN
999 errorsexits("EQUATIONS_INTERPOLATION_FINALISE",err,error)
    RETURN 1
  END SUBROUTINE equations_interpolation_finalise

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

  SUBROUTINE equations_interpolation_initialise(EQUATIONS,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_type), POINTER :: EQUATIONS
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    INTEGER(INTG) :: DUMMY_ERR
    TYPE(equations_set_type), POINTER :: EQUATIONS_SET
    TYPE(varying_string) :: DUMMY_ERROR
    
    enters("EQUATIONS_INTERPOLATION_INITIALISE",err,error,*998)

    IF(ASSOCIATED(equations)) THEN
      equations_set=>equations%EQUATIONS_SET
      IF(ASSOCIATED(equations_set)) THEN
        IF(ASSOCIATED(equations%INTERPOLATION)) THEN
          CALL flagerror("Interpolation is already associated for these equations.",err,error,*998)
        ELSE
          ALLOCATE(equations%INTERPOLATION,stat=err)
          IF(err/=0) CALL flagerror("Could not allocate equations interpolation",err,error,*999)
          equations%INTERPOLATION%EQUATIONS=>equations
          NULLIFY(equations%INTERPOLATION%GEOMETRIC_INTERP_PARAMETERS)
          NULLIFY(equations%INTERPOLATION%FIBRE_INTERP_PARAMETERS)
          NULLIFY(equations%INTERPOLATION%DEPENDENT_INTERP_PARAMETERS)
          NULLIFY(equations%INTERPOLATION%INDEPENDENT_INTERP_PARAMETERS)
          NULLIFY(equations%INTERPOLATION%MATERIALS_INTERP_PARAMETERS)
          NULLIFY(equations%INTERPOLATION%SOURCE_INTERP_PARAMETERS)
          NULLIFY(equations%INTERPOLATION%GEOMETRIC_INTERP_POINT)
          NULLIFY(equations%INTERPOLATION%FIBRE_INTERP_POINT)
          NULLIFY(equations%INTERPOLATION%DEPENDENT_INTERP_POINT)
          NULLIFY(equations%INTERPOLATION%INDEPENDENT_INTERP_POINT)
          NULLIFY(equations%INTERPOLATION%MATERIALS_INTERP_POINT)
          NULLIFY(equations%INTERPOLATION%SOURCE_INTERP_POINT)
          NULLIFY(equations%INTERPOLATION%DEPENDENT_PHYSICAL_POINT)
          NULLIFY(equations%INTERPOLATION%DEPENDENT_INTERP_POINT_METRICS)
          NULLIFY(equations%INTERPOLATION%INDEPENDENT_INTERP_POINT_METRICS)
          NULLIFY(equations%INTERPOLATION%GEOMETRIC_INTERP_POINT_METRICS)
          NULLIFY(equations%INTERPOLATION%FIBRE_INTERP_POINT_METRICS)
          
          equations%INTERPOLATION%GEOMETRIC_FIELD=>equations_set%GEOMETRY%GEOMETRIC_FIELD
          equations%INTERPOLATION%FIBRE_FIELD=>equations_set%GEOMETRY%FIBRE_FIELD
          equations%INTERPOLATION%DEPENDENT_FIELD=>equations_set%DEPENDENT%DEPENDENT_FIELD
          IF(ASSOCIATED(equations_set%INDEPENDENT)) THEN
            equations%INTERPOLATION%INDEPENDENT_FIELD=>equations_set%INDEPENDENT%INDEPENDENT_FIELD
          ELSE
            NULLIFY(equations%INTERPOLATION%INDEPENDENT_FIELD)
          ENDIF
          IF(ASSOCIATED(equations_set%MATERIALS)) THEN
            equations%INTERPOLATION%MATERIALS_FIELD=>equations_set%MATERIALS%MATERIALS_FIELD
          ELSE
            NULLIFY(equations%INTERPOLATION%MATERIALS_FIELD)
          ENDIF
          IF(ASSOCIATED(equations_set%SOURCE)) THEN
            equations%INTERPOLATION%SOURCE_FIELD=>equations_set%SOURCE%SOURCE_FIELD
          ELSE
            NULLIFY(equations%INTERPOLATION%SOURCE_FIELD)
          ENDIF

          CALL field_interpolation_parameters_initialise(equations%INTERPOLATION%GEOMETRIC_FIELD, &
            & equations%INTERPOLATION%GEOMETRIC_INTERP_PARAMETERS,err,error,*999)
          CALL field_interpolated_points_initialise(equations%INTERPOLATION%GEOMETRIC_INTERP_PARAMETERS, &
            & equations%INTERPOLATION%GEOMETRIC_INTERP_POINT,err,error,*999)
          CALL field_interpolatedpointsmetricsinitialise(equations%INTERPOLATION%GEOMETRIC_INTERP_POINT, &
            & equations%INTERPOLATION%GEOMETRIC_INTERP_POINT_METRICS,err,error,*999)
          CALL field_interpolation_parameters_initialise(equations%INTERPOLATION%DEPENDENT_FIELD, &
            & equations%INTERPOLATION%DEPENDENT_INTERP_PARAMETERS,err,error,*999)
          CALL field_interpolated_points_initialise(equations%INTERPOLATION%DEPENDENT_INTERP_PARAMETERS, &
            & equations%INTERPOLATION%DEPENDENT_INTERP_POINT,err,error,*999)
!           CALL FIELD_PHYSICAL_POINTS_INITIALISE(EQUATIONS%INTERPOLATION%DEPENDENT_INTERP_POINT, &
!             & EQUATIONS%INTERPOLATION%GEOMETRIC_INTERP_POINT,EQUATIONS%INTERPOLATION%DEPENDENT_PHYSICAL_POINT, &
!             & ERR,ERROR,*999)
          IF(equations%INTERPOLATION%DEPENDENT_FIELD%TYPE==field_geometric_type.OR. &
            & equations%INTERPOLATION%DEPENDENT_FIELD%TYPE==field_fibre_type.OR. &
            & equations%INTERPOLATION%DEPENDENT_FIELD%TYPE==field_geometric_general_type) THEN
            CALL field_interpolatedpointsmetricsinitialise(equations%INTERPOLATION%DEPENDENT_INTERP_POINT, &
              & equations%INTERPOLATION%DEPENDENT_INTERP_POINT_METRICS,err,error,*999)
          ENDIF
          IF(ASSOCIATED(equations%INTERPOLATION%FIBRE_FIELD)) THEN
            CALL field_interpolation_parameters_initialise(equations%INTERPOLATION%FIBRE_FIELD, &
              & equations%INTERPOLATION%FIBRE_INTERP_PARAMETERS,err,error,*999)
            CALL field_interpolated_points_initialise(equations%INTERPOLATION%FIBRE_INTERP_PARAMETERS,  &
              & equations%INTERPOLATION%FIBRE_INTERP_POINT,err,error,*999)
            CALL field_interpolatedpointsmetricsinitialise(equations%INTERPOLATION%FIBRE_INTERP_POINT,  &
              & equations%INTERPOLATION%FIBRE_INTERP_POINT_METRICS,err,error,*999)
          ENDIF
          IF(ASSOCIATED(equations%INTERPOLATION%INDEPENDENT_FIELD)) THEN
            CALL field_interpolation_parameters_initialise(equations%INTERPOLATION%INDEPENDENT_FIELD, &
              & equations%INTERPOLATION%INDEPENDENT_INTERP_PARAMETERS,err,error,*999)
            CALL field_interpolated_points_initialise(equations%INTERPOLATION%INDEPENDENT_INTERP_PARAMETERS,  &
              & equations%INTERPOLATION%INDEPENDENT_INTERP_POINT,err,error,*999)
            IF(equations%INTERPOLATION%INDEPENDENT_FIELD%TYPE==field_geometric_type.OR. &
              & equations%INTERPOLATION%INDEPENDENT_FIELD%TYPE==field_fibre_type) THEN
              CALL field_interpolatedpointsmetricsinitialise(equations%INTERPOLATION%INDEPENDENT_INTERP_POINT,  &
                &  equations%INTERPOLATION%INDEPENDENT_INTERP_POINT_METRICS,err,error,*999)
            END IF
          ENDIF
          IF(ASSOCIATED(equations%INTERPOLATION%MATERIALS_FIELD)) THEN
            CALL field_interpolation_parameters_initialise(equations%INTERPOLATION%MATERIALS_FIELD, &
              & equations%INTERPOLATION%MATERIALS_INTERP_PARAMETERS,err,error,*999)
            CALL field_interpolated_points_initialise(equations%INTERPOLATION%MATERIALS_INTERP_PARAMETERS,  &
              & equations%INTERPOLATION%MATERIALS_INTERP_POINT,err,error,*999)
          ENDIF
          IF(ASSOCIATED(equations%INTERPOLATION%SOURCE_FIELD)) THEN
            CALL field_interpolation_parameters_initialise(equations%INTERPOLATION%SOURCE_FIELD, &
              & equations%INTERPOLATION%SOURCE_INTERP_PARAMETERS,err,error,*999)
            CALL field_interpolated_points_initialise(equations%INTERPOLATION%SOURCE_INTERP_PARAMETERS, &
              & equations%INTERPOLATION%SOURCE_INTERP_POINT,err,error,*999)
          ENDIF
          
        ENDIF
      ELSE
        CALL flagerror("Equations equation set is not associated",err,error,*998)
      ENDIF
    ELSE
      CALL flagerror("Equations is not associated",err,error,*998)
    ENDIF
       
    exits("EQUATIONS_INTERPOLATION_INITIALISE")
    RETURN
999 CALL equations_interpolation_finalise(equations%INTERPOLATION,dummy_err,dummy_error,*998)
998 errorsexits("EQUATIONS_INTERPOLATION_INITIALISE",err,error)
    RETURN 1
  END SUBROUTINE equations_interpolation_initialise

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

  SUBROUTINE equations_linearity_type_get(EQUATIONS,LINEARITY_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_type), POINTER :: EQUATIONS
    INTEGER(INTG), INTENT(OUT) :: LINEARITY_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
 
    enters("EQUATIONS_LINEARITY_TYPE_GET",err,error,*999)

    IF(ASSOCIATED(equations)) THEN
      IF(equations%EQUATIONS_FINISHED) THEN
        linearity_type=equations%LINEARITY
      ELSE
        CALL flagerror("Equations has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Equations is not associated.",err,error,*999)
    ENDIF
       
    exits("EQUATIONS_LINEARITY_TYPE_GET")
    RETURN
999 errorsexits("EQUATIONS_LINEARITY_TYPE_GET",err,error)
    RETURN 1
  END SUBROUTINE equations_linearity_type_get
  
  !
  !================================================================================================================================
  !

  SUBROUTINE equations_linearity_type_set(EQUATIONS,LINEARITY_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_type), POINTER :: EQUATIONS
    INTEGER(INTG), INTENT(IN) :: LINEARITY_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
 
    enters("EQUATIONS_LINEARITY_TYPE_SET",err,error,*999)

    IF(ASSOCIATED(equations)) THEN
      IF(equations%EQUATIONS_FINISHED) THEN
        CALL flagerror("Equations has already been finished.",err,error,*999)
      ELSE
        SELECT CASE(linearity_type)
        CASE(equations_linear)
          equations%LINEARITY=equations_linear
        CASE(equations_nonlinear)
          equations%LINEARITY=equations_nonlinear
        CASE(equations_nonlinear_bcs)
          equations%LINEARITY=equations_nonlinear_bcs
        CASE DEFAULT
          local_error="The specified linearity type of "//trim(number_to_vstring(linearity_type,"*",err,error))// &
            & " is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ENDIF
    ELSE
      CALL flagerror("Equations is not associated.",err,error,*999)
    ENDIF
       
    exits("EQUATIONS_LINEARITY_TYPE_SET")
    RETURN
999 errorsexits("EQUATIONS_LINEARITY_TYPE_SET",err,error)
    RETURN 1
  END SUBROUTINE equations_linearity_type_set
  
  !
  !================================================================================================================================
  !

  SUBROUTINE equations_lumping_type_get(EQUATIONS,LUMPING_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_type), POINTER :: EQUATIONS
    INTEGER(INTG), INTENT(OUT) :: LUMPING_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
 
    enters("EQUATIONS_LUMPING_TYPE_GET",err,error,*999)

    IF(ASSOCIATED(equations)) THEN
      IF(equations%EQUATIONS_FINISHED) THEN
        lumping_type=equations%LUMPING_TYPE
      ELSE
        CALL flagerror("Equations has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Equations is not associated.",err,error,*999)
    ENDIF
       
    exits("EQUATIONS_LUMPING_TYPE_GET")
    RETURN
999 errorsexits("EQUATIONS_LUMPING_TYPE_GET",err,error)
    RETURN 1
  END SUBROUTINE equations_lumping_type_get
  
  !
  !================================================================================================================================
  !

  SUBROUTINE equations_lumping_type_set(EQUATIONS,LUMPING_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_type), POINTER :: EQUATIONS
    INTEGER(INTG), INTENT(IN) :: LUMPING_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
 
    enters("EQUATIONS_LUMPING_TYPE_SET",err,error,*999)

    IF(ASSOCIATED(equations)) THEN
      IF(equations%EQUATIONS_FINISHED) THEN
        CALL flagerror("Equations has already been finished.",err,error,*999)
      ELSE
        IF(equations%TIME_DEPENDENCE==equations_first_order_dynamic.OR. &
          & equations%TIME_DEPENDENCE==equations_second_order_dynamic) THEN
          SELECT CASE(lumping_type)
          CASE(equations_unlumped_matrices)
            equations%LUMPING_TYPE=equations_unlumped_matrices
          CASE(equations_lumped_matrices)
            equations%LUMPING_TYPE=equations_lumped_matrices
          CASE DEFAULT
            local_error="The specified lumping type of "//trim(number_to_vstring(lumping_type,"*",err,error))// &
              & " is invalid."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          local_error="Invalid equations time dependence. The equations time dependence of "// &
            & trim(number_to_vstring(equations%TIME_DEPENDENCE,"*",err,error))// &
            & " does not correspond to dynamic equations. You can only set lumping for dynamic equations."
          CALL flagerror(local_error,err,error,*999)
        ENDIF
      ENDIF
    ELSE
      CALL flagerror("Equations is not associated.",err,error,*999)
    ENDIF
       
    exits("EQUATIONS_LUMPING_TYPE_SET")
    RETURN
999 errorsexits("EQUATIONS_LUMPING_TYPE_SET",err,error)
    RETURN 1
  END SUBROUTINE equations_lumping_type_set
  
  !
  !================================================================================================================================
  !

  SUBROUTINE equations_output_type_get(EQUATIONS,OUTPUT_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_type), POINTER :: EQUATIONS
    INTEGER(INTG), INTENT(OUT) :: OUTPUT_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
 
    enters("EQUATIONS_OUTPUT_TYPE_GET",err,error,*999)

    IF(ASSOCIATED(equations)) THEN
      IF(equations%EQUATIONS_FINISHED) THEN
        output_type=equations%OUTPUT_TYPE
      ELSE
        CALL flagerror("Equations has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Equations is not associated.",err,error,*999)
    ENDIF
       
    exits("EQUATIONS_OUTPUT_TYPE_GET")
    RETURN
999 errorsexits("EQUATIONS_OUTPUT_TYPE_GET",err,error)
    RETURN 1
  END SUBROUTINE equations_output_type_get
  
  !
  !================================================================================================================================
  !

  SUBROUTINE equations_output_type_set(EQUATIONS,OUTPUT_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_type), POINTER :: EQUATIONS
    INTEGER(INTG), INTENT(IN) :: OUTPUT_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
 
    enters("EQUATIONS_OUTPUT_TYPE_SET",err,error,*999)

    IF(ASSOCIATED(equations)) THEN
      IF(equations%EQUATIONS_FINISHED) THEN
        CALL flagerror("Equations has already been finished.",err,error,*999)
      ELSE
        SELECT CASE(output_type)
        CASE(equations_no_output)
          equations%OUTPUT_TYPE=equations_no_output
        CASE(equations_timing_output)
          equations%OUTPUT_TYPE=equations_timing_output
        CASE(equations_matrix_output)
          equations%OUTPUT_TYPE=equations_matrix_output
        CASE(equations_element_matrix_output)
          equations%OUTPUT_TYPE=equations_element_matrix_output
        CASE(equations_nodal_matrix_output)
          equations%OUTPUT_TYPE=equations_nodal_matrix_output
        CASE DEFAULT
          local_error="The specified output type of "//trim(number_to_vstring(output_type,"*",err,error))//" is invalid"
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ENDIF
    ELSE
      CALL flagerror("Equations is not associated.",err,error,*999)
    ENDIF
       
    exits("EQUATIONS_OUTPUT_TYPE_SET")
    RETURN
999 errorsexits("EQUATIONS_OUTPUT_TYPE_SET",err,error)
    RETURN 1
    
  END SUBROUTINE equations_output_type_set

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

  SUBROUTINE equations_sparsity_type_get(EQUATIONS,SPARSITY_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_type), POINTER :: EQUATIONS
    INTEGER(INTG), INTENT(OUT) :: SPARSITY_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
 
    enters("EQUATIONS_SPARSITY_TYPE_GET",err,error,*999)

    IF(ASSOCIATED(equations)) THEN
      IF(equations%EQUATIONS_FINISHED) THEN
        sparsity_type=equations%SPARSITY_TYPE
      ELSE
        CALL flagerror("Equations has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Equations is not associated.",err,error,*999)
    ENDIF
       
    exits("EQUATIONS_SPARSITY_TYPE_GET")
    RETURN
999 errorsexits("EQUATIONS_SPARSITY_TYPE_GET",err,error)
    RETURN 1
  END SUBROUTINE equations_sparsity_type_get
  
  !
  !================================================================================================================================
  !

  SUBROUTINE equations_sparsity_type_set(EQUATIONS,SPARSITY_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_type), POINTER :: EQUATIONS
    INTEGER(INTG), INTENT(IN) :: SPARSITY_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
 
    enters("EQUATIONS_SPARSITY_TYPE_SET",err,error,*999)

    IF(ASSOCIATED(equations)) THEN
      IF(equations%EQUATIONS_FINISHED) THEN
        CALL flagerror("Equations has already been finished.",err,error,*999)
      ELSE
        SELECT CASE(sparsity_type)
        CASE(equations_sparse_matrices)
          equations%SPARSITY_TYPE=equations_sparse_matrices
        CASE(equations_full_matrices)
          equations%SPARSITY_TYPE=equations_full_matrices
        CASE DEFAULT
          local_error="The specified sparsity type of "//trim(number_to_vstring(sparsity_type,"*",err,error))// &
            & " is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ENDIF
    ELSE
      CALL flagerror("Equations is not associated.",err,error,*999)
    ENDIF
       
    exits("EQUATIONS_SPARSITY_TYPE_SET")
    RETURN
999 errorsexits("EQUATIONS_SPARSITY_TYPE_SET",err,error)
    RETURN 1
  END SUBROUTINE equations_sparsity_type_set
  
  !
  !================================================================================================================================
  !

  SUBROUTINE equations_time_dependence_type_get(EQUATIONS,TIME_DEPENDENCE_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_type), POINTER :: EQUATIONS
    INTEGER(INTG), INTENT(OUT) :: TIME_DEPENDENCE_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
 
    enters("EQUATIONS_TIME_DEPENDENCE_TYPE_GET",err,error,*999)

    IF(ASSOCIATED(equations)) THEN
      IF(equations%EQUATIONS_FINISHED) THEN
        time_dependence_type=equations%TIME_DEPENDENCE
      ELSE
        CALL flagerror("Equations has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Equations is not associated.",err,error,*999)
    ENDIF
       
    exits("EQUATIONS_TIME_DEPENDENCE_TYPE_GET")
    RETURN
999 errorsexits("EQUATIONS_TIME_DEPENDENCE_TYPE_GET",err,error)
    RETURN 1
  END SUBROUTINE equations_time_dependence_type_get
  
  !
  !================================================================================================================================
  !

  SUBROUTINE equations_time_dependence_type_set(EQUATIONS,TIME_DEPENDENCE_TYPE,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_type), POINTER :: EQUATIONS
    INTEGER(INTG), INTENT(IN) :: TIME_DEPENDENCE_TYPE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
 
    enters("EQUATIONS_TIME_DEPENDENCE_TYPE_SET",err,error,*999)

    IF(ASSOCIATED(equations)) THEN
      IF(equations%EQUATIONS_FINISHED) THEN
        CALL flagerror("Equations has already been finished.",err,error,*999)
      ELSE
        SELECT CASE(time_dependence_type)
        CASE(equations_static)
          equations%TIME_DEPENDENCE=equations_static
        CASE(equations_quasistatic)
          equations%TIME_DEPENDENCE=equations_quasistatic
        CASE(equations_first_order_dynamic)
          equations%TIME_DEPENDENCE=equations_first_order_dynamic
        CASE(equations_second_order_dynamic)
          equations%TIME_DEPENDENCE=equations_second_order_dynamic
        CASE DEFAULT
          local_error="The specified time dependence type of "//trim(number_to_vstring(time_dependence_type,"*",err,error))// &
            & " is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      ENDIF
    ELSE
      CALL flagerror("Equations is not associated.",err,error,*999)
    ENDIF
       
    exits("EQUATIONS_TIME_DEPENDENCE_TYPE_SET")
    RETURN
999 errorsexits("EQUATIONS_TIME_DEPENDENCE_TYPE_SET",err,error)
    RETURN 1
  END SUBROUTINE equations_time_dependence_type_set

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

  SUBROUTINE equations_set_equations_get(EQUATIONS_SET,EQUATIONS,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_set_type), POINTER :: EQUATIONS_SET
    TYPE(equations_type), POINTER :: EQUATIONS
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
 
    enters("EQUATIONS_SET_EQUATIONS_GET",err,error,*999)

    IF(ASSOCIATED(equations_set)) THEN
      IF(equations_set%EQUATIONS_SET_FINISHED) THEN
        IF(ASSOCIATED(equations)) THEN
          CALL flagerror("Equations is already associated.",err,error,*999)
        ELSE
          equations=>equations_set%EQUATIONS
          IF(.NOT.ASSOCIATED(equations)) CALL flagerror("Equations set equations is not associated.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("Equations set has not been finished.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Equations set is not associated.",err,error,*999)
    ENDIF
       
    exits("EQUATIONS_SET_EQUATIONS_GET")
    RETURN
999 errorsexits("EQUATIONS_SET_EQUATIONS_GET",err,error)
    RETURN 1
    
  END SUBROUTINE equations_set_equations_get

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

  SUBROUTINE equations_derivedvariableget(equations,derivedType,fieldVariable,err,error,*)

    !Argument variables
    TYPE(equations_type), POINTER, INTENT(IN) :: equations
    INTEGER(INTG), INTENT(IN) :: derivedType
    TYPE(field_variable_type), POINTER, INTENT(INOUT) :: fieldVariable
    INTEGER(INTG), INTENT(OUT) :: err
    TYPE(varying_string), INTENT(OUT) :: error

    !Local variables
    TYPE(equations_set_type), POINTER :: equationsSet
    TYPE(field_type), POINTER :: derivedField
    INTEGER(INTG) :: fieldVariableType

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

    NULLIFY(derivedfield)

    !Check pointers
    IF(ASSOCIATED(equations)) THEN
      equationsset=>equations%equations_set
      IF(ASSOCIATED(equationsset)) THEN
        IF(.NOT.equationsset%EQUATIONS_SET_FINISHED) THEN
          CALL flagerror("Equations set has not been finished.",err,error,*999)
        END IF
      ELSE
        CALL flagerror("Equations set is not associated.",err,error,*999)
      END IF
      IF(ASSOCIATED(fieldvariable)) THEN
        CALL flagerror("Derived field variable is already associated.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("Equations are not associated.",err,error,*999)
    END IF

    IF(ASSOCIATED(equationsset%derived)) THEN
      IF(equationsset%derived%derivedFinished) THEN
        IF(ASSOCIATED(equationsset%derived%derivedField)) THEN
          IF(derivedtype>0.AND.derivedtype<=equations_set_number_of_derived_types) THEN
            fieldvariabletype=equationsset%derived%variableTypes(derivedtype)
            IF(fieldvariabletype/=0) THEN
              CALL field_variable_get(equationsset%derived%derivedField,fieldvariabletype,fieldvariable,err,error,*999)
            ELSE
              CALL flagerror("The field variable type for the derived variable type of "// &
                & trim(number_to_vstring(derivedtype,"*",err,error))//" has not been set.",err,error,*999)
            END IF
          ELSE
            CALL flagerror("The derived variable type of "//trim(number_to_vstring(derivedtype,"*",err,error))// &
              & " is invalid. It should be between 1 and "//trim(number_to_vstring(equations_set_number_of_derived_types,"*", &
              & err,error))//" inclusive.",err,error,*999)
          END IF
        ELSE
          CALL flagerror("Equations set derived field is not associated",err,error,*999)
        END IF
      ELSE
        CALL flagerror("Equations set derived information is not finished",err,error,*999)
      END IF
    END IF

    exits("Equations_DerivedVariableGet")
    RETURN
999 errorsexits("Equations_DerivedVariableGet",err,error)
    RETURN 1
  END SUBROUTINE equations_derivedvariableget

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

  SUBROUTINE equations_numberoflinearmatricesget(equations,numberOfMatrices,err,error,*)

    !Argument variables
    TYPE(equations_type), POINTER, INTENT(IN) :: equations
    INTEGER(INTG), INTENT(OUT) :: numberOfMatrices
    TYPE(varying_string), INTENT(OUT) :: error
    INTEGER(INTG), INTENT(OUT) :: err
    !Local variables
    TYPE(equations_matrices_type), POINTER :: equationsMatrices
    TYPE(equations_matrices_linear_type), POINTER :: linearMatrices

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

    IF(ASSOCIATED(equations)) THEN
      equationsmatrices=>equations%equations_matrices
      IF(ASSOCIATED(equationsmatrices)) THEN
        linearmatrices=>equationsmatrices%linear_matrices
        IF(ASSOCIATED(linearmatrices)) THEN
          numberofmatrices=linearmatrices%number_of_linear_matrices
        ELSE
          numberofmatrices=0
        END IF
      ELSE
        CALL flagerror("The equations matrices are not associated.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("The equations equations are not associated.",err,error,*999)
    END IF

    exits("Equations_NumberOfLinearMatricesGet")
    RETURN
999 errorsexits("Equations_NumberOfLinearMatricesGet",err,error)
    RETURN 1

  END SUBROUTINE equations_numberoflinearmatricesget

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

  SUBROUTINE equations_numberofjacobianmatricesget(equations,numberOfMatrices,err,error,*)

    !Argument variables
    TYPE(equations_type), POINTER, INTENT(IN) :: equations
    INTEGER(INTG), INTENT(OUT) :: numberOfMatrices
    TYPE(varying_string), INTENT(OUT) :: error
    INTEGER(INTG), INTENT(OUT) :: err
    !Local variables
    TYPE(equations_matrices_type), POINTER :: equationsMatrices
    TYPE(equations_matrices_nonlinear_type), POINTER :: nonlinearMatrices

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

    IF(ASSOCIATED(equations)) THEN
      equationsmatrices=>equations%equations_matrices
      IF(ASSOCIATED(equationsmatrices)) THEN
        nonlinearmatrices=>equationsmatrices%nonlinear_matrices
        IF(ASSOCIATED(nonlinearmatrices)) THEN
          numberofmatrices=nonlinearmatrices%number_of_jacobians
        ELSE
          numberofmatrices=0
        END IF
      ELSE
        CALL flagerror("The equations matrices are not associated.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("The equations are not associated.",err,error,*999)
    END IF

    exits("Equations_NumberOfJacobianMatricesGet")
    RETURN
999 errorsexits("Equations_NumberOfJacobianMatricesGet",err,error)
    RETURN 1

  END SUBROUTINE equations_numberofjacobianmatricesget

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

  SUBROUTINE equations_numberofdynamicmatricesget(equations,numberOfMatrices,err,error,*)

    !Argument variables
    TYPE(equations_type), POINTER, INTENT(IN) :: equations
    INTEGER(INTG), INTENT(OUT) :: numberOfMatrices
    TYPE(varying_string), INTENT(OUT) :: error
    INTEGER(INTG), INTENT(OUT) :: err
    !Local variables
    TYPE(equations_matrices_type), POINTER :: equationsMatrices
    TYPE(equations_matrices_dynamic_type), POINTER :: dynamicMatrices

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

    IF(ASSOCIATED(equations)) THEN
      equationsmatrices=>equations%equations_matrices
      IF(ASSOCIATED(equationsmatrices)) THEN
        dynamicmatrices=>equationsmatrices%dynamic_matrices
        IF(ASSOCIATED(dynamicmatrices)) THEN
          numberofmatrices=dynamicmatrices%number_of_dynamic_matrices
        ELSE
          numberofmatrices=0
        END IF
      ELSE
        CALL flagerror("The equations matrices are not associated.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("The equations are not associated.",err,error,*999)
    END IF

    exits("Equations_NumberOfDynamicMatricesGet")
    RETURN
999 errorsexits("Equations_NumberOfDynamicMatricesGet",err,error)
    RETURN 1

  END SUBROUTINE equations_numberofdynamicmatricesget

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

  SUBROUTINE equations_linearmatrixget(equations,matrixIndex,matrix,err,error,*)

    !Argument variables
    TYPE(equations_type), POINTER, INTENT(IN) :: equations
    INTEGER(INTG), INTENT(IN) :: matrixIndex
    TYPE(distributed_matrix_type), POINTER, INTENT(INOUT) :: matrix
    TYPE(varying_string), INTENT(OUT) :: error
    INTEGER(INTG), INTENT(OUT) :: err
    !Local variables
    TYPE(equations_matrix_type), POINTER :: equationsMatrix
    TYPE(equations_matrices_type), POINTER :: equationsMatrices
    TYPE(equations_matrices_linear_type), POINTER :: linearMatrices

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

    IF(ASSOCIATED(equations)) THEN
      equationsmatrices=>equations%equations_matrices
      IF(ASSOCIATED(equationsmatrices)) THEN
        linearmatrices=>equationsmatrices%linear_matrices
        IF(ASSOCIATED(linearmatrices)) THEN
          IF(matrixindex>0.AND.matrixindex<=linearmatrices%number_of_linear_matrices) THEN
            IF(.NOT.ASSOCIATED(matrix)) THEN
              equationsmatrix=>linearmatrices%matrices(matrixindex)%ptr
              IF(ASSOCIATED(equationsmatrix)) THEN
                matrix=>equationsmatrix%matrix
              ELSE
                CALL flagerror("The equations matrix is not associated.",err,error,*999)
              END IF
            ELSE
              CALL flagerror("The matrix is already associated.",err,error,*999)
            END IF
          ELSE
            CALL flagerror("Invalid matrix index. The matrix index must be greater than zero and less than or equal to "// &
              & trim(numbertovstring(linearmatrices%number_of_linear_matrices,"*",err,error))//".",err,error,*999)
          END IF
        ELSE
          CALL flagerror("The equations linear matrices are not associated.",err,error,*999)
        END IF
      ELSE
        CALL flagerror("The equations matrices are not associated.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("The equations are not associated.",err,error,*999)
    END IF

    exits("Equations_LinearMatrixGet")
    RETURN
999 errorsexits("Equations_LinearMatrixGet",err,error)
    RETURN 1

  END SUBROUTINE equations_linearmatrixget

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

  SUBROUTINE equations_jacobianmatrixget(equations,residualIndex,variableType,matrix,err,error,*)

    !Argument variables
    TYPE(equations_type), POINTER, INTENT(IN) :: equations
    INTEGER(INTG), INTENT(IN) :: residualIndex
    INTEGER(INTG), INTENT(IN) :: variableType
    TYPE(distributed_matrix_type), POINTER, INTENT(INOUT) :: matrix
    TYPE(varying_string), INTENT(OUT) :: error
    INTEGER(INTG), INTENT(OUT) :: err
    !Local variables
    INTEGER(INTG) :: matrixIndex,variableIndex
    TYPE(equations_mapping_type), POINTER :: equationsMapping
    TYPE(equations_mapping_nonlinear_type), POINTER :: nonlinearMapping
    TYPE(equations_jacobian_type), POINTER :: equationsJacobian

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

    !Check for pointer associations
    IF(ASSOCIATED(equations)) THEN
      equationsmapping=>equations%equations_mapping
      IF(ASSOCIATED(equationsmapping)) THEN
        nonlinearmapping=>equationsmapping%nonlinear_mapping
        IF(.NOT.ASSOCIATED(nonlinearmapping)) THEN
          CALL flagerror("The equations nonlinear mapping is not associated.",err,error,*999)
        END IF
      ELSE
        CALL flagerror("The equations mapping is not associated.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("The equations are not associated.",err,error,*999)
    END IF
    IF(ASSOCIATED(matrix)) THEN
      CALL flagerror("The matrix is already associated.",err,error,*999)
    END IF

    IF(residualindex/=1) THEN
      CALL flagerror("Multiple residual vectors are not yet implemented.",err,error,*999)
    END IF

    !Find Jacobian matrix index using the nonlinear equations mapping
    matrixindex=0
    DO variableindex=1,nonlinearmapping%number_of_residual_variables
      IF(nonlinearmapping%residual_variables(variableindex)%ptr%variable_type==variabletype) THEN
        matrixindex=nonlinearmapping%var_to_jacobian_map(variableindex)%jacobian_number
      END IF
    END DO
    IF(matrixindex==0) THEN
      CALL flagerror("Equations do not have a Jacobian matrix for residual index "// &
        & trim(numbertovstring(residualindex,"*",err,error))//" and variable type "// &
        & trim(numbertovstring(variabletype,"*",err,error))//".",err,error,*999)
    END IF

    !Now get Jacobian matrix using the matrix index
    equationsjacobian=>nonlinearmapping%jacobian_to_var_map(matrixindex)%jacobian
    IF(ASSOCIATED(equationsjacobian)) THEN
      matrix=>equationsjacobian%jacobian
    ELSE
      CALL flagerror("The equations Jacobian matrix is not associated.",err,error,*999)
    END IF

    exits("Equations_JacobianMatrixGet")
    RETURN
999 errorsexits("Equations_JacobianMatrixGet",err,error)
    RETURN 1

  END SUBROUTINE equations_jacobianmatrixget

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

  SUBROUTINE equations_dynamicmatrixget(equations,matrixIndex,matrix,err,error,*)

    !Argument variables
    TYPE(equations_type), POINTER, INTENT(IN) :: equations
    INTEGER(INTG), INTENT(IN) :: matrixIndex
    TYPE(distributed_matrix_type), POINTER, INTENT(INOUT) :: matrix
    TYPE(varying_string), INTENT(OUT) :: error
    INTEGER(INTG), INTENT(OUT) :: err
    !Local variables
    TYPE(equations_matrix_type), POINTER :: equationsMatrix
    TYPE(equations_matrices_type), POINTER :: equationsMatrices
    TYPE(equations_matrices_dynamic_type), POINTER :: dynamicMatrices

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

    IF(ASSOCIATED(equations)) THEN
      equationsmatrices=>equations%equations_matrices
      IF(ASSOCIATED(equationsmatrices)) THEN
        dynamicmatrices=>equationsmatrices%dynamic_matrices
        IF(ASSOCIATED(dynamicmatrices)) THEN
          IF(matrixindex>0.AND.matrixindex<=dynamicmatrices%number_of_dynamic_matrices) THEN
            IF(.NOT.ASSOCIATED(matrix)) THEN
              equationsmatrix=>dynamicmatrices%matrices(matrixindex)%ptr
              IF(ASSOCIATED(equationsmatrix)) THEN
                matrix=>equationsmatrix%matrix
              ELSE
                CALL flagerror("The equations matrix is not associated.",err,error,*999)
              END IF
            ELSE
              CALL flagerror("The matrix is already associated.",err,error,*999)
            END IF
          ELSE
            CALL flagerror("Invalid matrix index. The matrix index must be greater than zero and less than or equal to "// &
              & trim(numbertovstring(dynamicmatrices%number_of_dynamic_matrices,"*",err,error))//".",err,error,*999)
          END IF
        ELSE
          CALL flagerror("The equations dynamic matrices are not associated.",err,error,*999)
        END IF
      ELSE
        CALL flagerror("The equations matrices are not associated.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("The equations are not associated.",err,error,*999)
    END IF

    exits("Equations_DynamicMatrixGet")
    RETURN
999 errorsexits("Equations_DynamicMatrixGet",err,error)
    RETURN 1

  END SUBROUTINE equations_dynamicmatrixget

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

  SUBROUTINE equations_dynamicmatrixgetbytype(equations,matrixType,matrix,err,error,*)

    !Argument variables
    TYPE(equations_type), POINTER, INTENT(IN) :: equations
    INTEGER(INTG), INTENT(IN) :: matrixType
    TYPE(distributed_matrix_type), POINTER, INTENT(INOUT) :: matrix
    TYPE(varying_string), INTENT(OUT) :: error
    INTEGER(INTG), INTENT(OUT) :: err
    !Local variables
    INTEGER(INTG) :: matrixIndex
    TYPE(equations_matrix_type), POINTER :: equationsMatrix
    TYPE(equations_matrices_type), POINTER :: equationsMatrices
    TYPE(equations_matrices_dynamic_type), POINTER :: dynamicMatrices
    TYPE(equations_mapping_type), POINTER :: equationsMapping
    TYPE(equations_mapping_dynamic_type), POINTER :: dynamicMapping

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

    !Check all pointer associations
    IF(ASSOCIATED(equations)) THEN
      equationsmatrices=>equations%equations_matrices
      IF(ASSOCIATED(equationsmatrices)) THEN
        dynamicmatrices=>equationsmatrices%dynamic_matrices
        IF(.NOT.ASSOCIATED(dynamicmatrices)) THEN
          CALL flagerror("The equations dynamic matrices are not associated.",err,error,*999)
        END IF
      ELSE
        CALL flagerror("The equations matrices are not associated.",err,error,*999)
      END IF
      equationsmapping=>equations%equations_mapping
      IF(ASSOCIATED(equationsmapping)) THEN
        dynamicmapping=>equationsmapping%DYNAMIC_MAPPING
        IF(.NOT.ASSOCIATED(dynamicmapping)) THEN
          CALL flagerror("The equations dynamic mapping is not associated.",err,error,*999)
        END IF
      ELSE
        CALL flagerror("The equations mapping is not associated.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("The equations are not associated.",err,error,*999)
    END IF
    IF(ASSOCIATED(matrix)) THEN
      CALL flagerror("The matrix is already associated.",err,error,*999)
    END IF

    !Now get the dynamic matrix
    !Find matrix index using the equations mapping
    SELECT CASE(matrixtype)
    CASE(equations_matrix_stiffness)
      matrixindex=dynamicmapping%stiffness_matrix_number
    CASE(equations_matrix_damping)
      matrixindex=dynamicmapping%damping_matrix_number
    CASE(equations_matrix_mass)
      matrixindex=dynamicmapping%mass_matrix_number
    CASE DEFAULT
      CALL flagerror("Invalid dynamic matrix type "//trim(numbertovstring(matrixtype,"*",err,error))// &
        & " specified.",err,error,*999)
    END SELECT
    IF(matrixindex==0) THEN
      CALL flagerror("The equations dynamic matrices do not have a matrix with the specified type of "// &
        & trim(numbertovstring(matrixtype,"*",err,error))//".",err,error,*999)
    ELSE
      equationsmatrix=>dynamicmatrices%matrices(matrixindex)%ptr
      IF(ASSOCIATED(equationsmatrix)) THEN
        matrix=>equationsmatrix%matrix
      ELSE
        CALL flagerror("The equations dynamic matrix for index "// &
          & trim(numbertovstring(matrixindex,"*",err,error))//" is not associated.",err,error,*999)
      END IF
    END IF

    exits("Equations_DynamicMatrixGetByType")
    RETURN
999 errorsexits("Equations_DynamicMatrixGetByType",err,error)
    RETURN 1

  END SUBROUTINE equations_dynamicmatrixgetbytype

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

  SUBROUTINE equations_dynamicmatrixtypeget(equations,matrixIndex,matrixType,err,error,*)

    !Argument variables
    TYPE(equations_type), POINTER, INTENT(IN) :: equations
    INTEGER(INTG), INTENT(IN) :: matrixIndex
    INTEGER(INTG), INTENT(INOUT) :: matrixType
    TYPE(varying_string), INTENT(OUT) :: error
    INTEGER(INTG), INTENT(OUT) :: err
    !Local variables
    TYPE(equations_mapping_type), POINTER :: equationsMapping
    TYPE(equations_mapping_dynamic_type), POINTER :: dynamicMapping

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

    IF(ASSOCIATED(equations)) THEN
      equationsmapping=>equations%equations_mapping
      IF(ASSOCIATED(equationsmapping)) THEN
        dynamicmapping=>equationsmapping%DYNAMIC_MAPPING
        IF(ASSOCIATED(dynamicmapping)) THEN
          IF(matrixindex>0.AND.matrixindex<=dynamicmapping%number_of_dynamic_equations_matrices) THEN
            IF(matrixindex==dynamicmapping%stiffness_matrix_number) THEN
              matrixtype=equations_matrix_stiffness
            ELSE IF(matrixindex==dynamicmapping%damping_matrix_number) THEN
              matrixtype=equations_matrix_damping
            ELSE IF(matrixindex==dynamicmapping%mass_matrix_number) THEN
              matrixtype=equations_matrix_mass
            ELSE
              CALL flagerror("Could not find dynamic matrix type.",err,error,*999)
            END IF
          ELSE
            CALL flagerror("Invalid matrix index. The matrix index must be greater than zero and less than or equal to "// &
              & trim(numbertovstring(dynamicmapping%number_of_dynamic_equations_matrices,"*",err,error))//".",err,error,*999)
          END IF
        ELSE
          CALL flagerror("The equations dynamic mapping is not associated.",err,error,*999)
        END IF
      ELSE
        CALL flagerror("The equations mapping is not associated.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("The equations are not associated.",err,error,*999)
    END IF

    exits("Equations_DynamicMatrixTypeGet")
    RETURN
999 errorsexits("Equations_DynamicMatrixTypeGet",err,error)
    RETURN 1

  END SUBROUTINE equations_dynamicmatrixtypeget

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

  SUBROUTINE equations_rhsvectorget(equations,vector,err,error,*)

    !Argument variables
    TYPE(equations_type), POINTER, INTENT(IN) :: equations
    TYPE(distributed_vector_type), POINTER, INTENT(INOUT) :: vector
    TYPE(varying_string), INTENT(OUT) :: error
    INTEGER(INTG), INTENT(OUT) :: err
    !Local variables
    TYPE(equations_matrices_rhs_type), POINTER :: rhsVector
    TYPE(equations_matrices_type), POINTER :: equationsMatrices

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

    IF(ASSOCIATED(equations)) THEN
      equationsmatrices=>equations%equations_matrices
      IF(ASSOCIATED(equationsmatrices)) THEN
        rhsvector=>equationsmatrices%rhs_vector
        IF(ASSOCIATED(rhsvector)) THEN
          IF(.NOT.ASSOCIATED(vector)) THEN
            vector=>rhsvector%vector
          ELSE
            CALL flagerror("The vector is already associated.",err,error,*999)
          END IF
        ELSE
          CALL flagerror("The equations matrices right hand side vector is not associated.",err,error,*999)
        END IF
      ELSE
        CALL flagerror("The equations matrices are not associated.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("The equations are not associated.",err,error,*999)
    END IF

    exits("Equations_RhsVectorGet")
    RETURN
999 errorsexits("Equations_RhsVectorGet",err,error)
    RETURN 1

  END SUBROUTINE equations_rhsvectorget

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

  SUBROUTINE equations_residualvectorget(equations,residualIndex,vector,err,error,*)

    !Argument variables
    TYPE(equations_type), POINTER, INTENT(IN) :: equations
    INTEGER(INTG), INTENT(IN) :: residualIndex
    TYPE(distributed_vector_type), POINTER, INTENT(INOUT) :: vector
    TYPE(varying_string), INTENT(OUT) :: error
    INTEGER(INTG), INTENT(OUT) :: err
    !Local variables
    TYPE(equations_matrices_nonlinear_type), POINTER :: nonlinearMatrices
    TYPE(equations_matrices_type), POINTER :: equationsMatrices

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

    IF(ASSOCIATED(equations)) THEN
      equationsmatrices=>equations%equations_matrices
      IF(ASSOCIATED(equationsmatrices)) THEN
        nonlinearmatrices=>equationsmatrices%nonlinear_matrices
        IF(ASSOCIATED(nonlinearmatrices)) THEN
          IF(.NOT.ASSOCIATED(vector)) THEN
            IF(residualindex==1) THEN
              vector=>nonlinearmatrices%residual
            ELSE
              CALL flagerror("Multiple residual vectors are not yet implemented.",err,error,*999)
            END IF
          ELSE
            CALL flagerror("The vector is already associated.",err,error,*999)
          END IF
        ELSE
          CALL flagerror("The equations matrices nonlinear matrices are not associated.",err,error,*999)
        END IF
      ELSE
        CALL flagerror("The equations matrices are not associated.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("The equations are not associated.",err,error,*999)
    END IF

    exits("Equations_ResidualVectorGet")
    RETURN
999 errorsexits("Equations_ResidualVectorGet",err,error)
    RETURN 1

  END SUBROUTINE equations_residualvectorget

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

  SUBROUTINE equations_residualnumberofvariablesget(equations,residualIndex,numberOfVariables,err,error,*)

    !Argument variables
    TYPE(equations_type), POINTER, INTENT(IN) :: equations
    INTEGER(INTG), INTENT(IN) :: residualIndex
    INTEGER(INTG), INTENT(OUT) :: numberOfVariables
    TYPE(varying_string), INTENT(OUT) :: error
    INTEGER(INTG), INTENT(OUT) :: err
    !Local variables
    TYPE(equations_mapping_type), POINTER :: equationsMapping
    TYPE(equations_mapping_nonlinear_type), POINTER :: nonlinearMapping

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

    !Check for pointer associations
    IF(ASSOCIATED(equations)) THEN
      equationsmapping=>equations%equations_mapping
      IF(ASSOCIATED(equationsmapping)) THEN
        nonlinearmapping=>equationsmapping%nonlinear_mapping
        IF(.NOT.ASSOCIATED(nonlinearmapping)) THEN
          CALL flagerror("The equations nonlinear mapping is not associated.",err,error,*999)
        END IF
      ELSE
        CALL flagerror("The equations mapping is not associated.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("The equations are not associated.",err,error,*999)
    END IF

    IF(residualindex==1) THEN
      numberofvariables=nonlinearmapping%number_of_residual_variables
    ELSE
      CALL flagerror("Multiple residual vectors are not yet implemented.",err,error,*999)
    END IF

    exits("Equations_ResidualNumberOfVariablesGet")
    RETURN
999 errorsexits("Equations_ResidualNumberOfVariablesGet",err,error)
    RETURN 1

  END SUBROUTINE equations_residualnumberofvariablesget

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

  SUBROUTINE equations_residualvariablesget(equations,residualIndex,residualVariables,err,error,*)

    !Argument variables
    TYPE(equations_type), POINTER, INTENT(IN) :: equations
    INTEGER(INTG), INTENT(IN) :: residualIndex
    INTEGER(INTG), INTENT(OUT) :: residualVariables(:)
    TYPE(varying_string), INTENT(OUT) :: error
    INTEGER(INTG), INTENT(OUT) :: err
    !Local variables
    INTEGER(INTG) :: numberOfVariables,variableIdx
    TYPE(equations_mapping_type), POINTER :: equationsMapping
    TYPE(equations_mapping_nonlinear_type), POINTER :: nonlinearMapping

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

    !Check for pointer associations
    IF(ASSOCIATED(equations)) THEN
      equationsmapping=>equations%equations_mapping
      IF(ASSOCIATED(equationsmapping)) THEN
        nonlinearmapping=>equationsmapping%nonlinear_mapping
        IF(.NOT.ASSOCIATED(nonlinearmapping)) THEN
          CALL flagerror("The equations nonlinear mapping is not associated.",err,error,*999)
        END IF
      ELSE
        CALL flagerror("The equations mapping is not associated.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("The equations are not associated.",err,error,*999)
    END IF

    IF(residualindex==1) THEN
      numberofvariables=nonlinearmapping%number_of_residual_variables
      IF(SIZE(residualvariables,1)>=numberofvariables) THEN
        DO variableidx=1,numberofvariables
          residualvariables(variableidx)=nonlinearmapping%residual_variables(variableidx)%ptr%variable_type
        END DO
      ELSE
        CALL flagerror("residualVariables array must have size of at least "// &
          & trim(numbertovstring(numberofvariables,"*",err,error))//".",err,error,*999)
      END IF
    ELSE
      CALL flagerror("Multiple residual vectors are not yet implemented.",err,error,*999)
    END IF

    exits("Equations_ResidualVariablesGet")
    RETURN
999 errorsexits("Equations_ResidualVariablesGet",err,error)
    RETURN 1

  END SUBROUTINE equations_residualvariablesget

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

  SUBROUTINE equations_sourcevectorget(equations,vector,err,error,*)

    !Argument variables
    TYPE(equations_type), POINTER, INTENT(IN) :: equations
    TYPE(distributed_vector_type), POINTER, INTENT(INOUT) :: vector
    TYPE(varying_string), INTENT(OUT) :: error
    INTEGER(INTG), INTENT(OUT) :: err
    !Local variables
    TYPE(equations_matrices_source_type), POINTER :: matricesSource
    TYPE(equations_matrices_type), POINTER :: equationsMatrices

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

    IF(ASSOCIATED(equations)) THEN
      equationsmatrices=>equations%equations_matrices
      IF(ASSOCIATED(equationsmatrices)) THEN
        matricessource=>equationsmatrices%source_vector
        IF(ASSOCIATED(matricessource)) THEN
          IF(.NOT.ASSOCIATED(vector)) THEN
            vector=>matricessource%vector
          ELSE
            CALL flagerror("The vector is already associated.",err,error,*999)
          END IF
        ELSE
          CALL flagerror("The equations matrices source vector is not associated.",err,error,*999)
        END IF
      ELSE
        CALL flagerror("The equations matrices are not associated.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("The equations are not associated.",err,error,*999)
    END IF

    exits("Equations_SourceVectorGet")
    RETURN
999 errorsexits("Equations_SourceVectorGet",err,error)
    RETURN 1

  END SUBROUTINE equations_sourcevectorget

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

END MODULE equations_routines