diffusion_advection_diffusion_routines.f90

Go to the documentation of this file.

MODULE diffusion_advection_diffusion_routines

  USE advection_diffusion_equation_routines
  USE base_routines
  USE basis_routines
  USE boundary_conditions_routines
  USE constants
  USE control_loop_routines
  USE coordinate_routines  
  USE diffusion_equation_routines
  USE distributed_matrix_vector
  USE domain_mappings
  USE equations_routines
  USE equations_mapping_routines
  USE equations_matrices_routines
  USE equations_set_constants
  USE field_routines
  USE fluid_mechanics_io_routines
  USE input_output
  USE iso_varying_string
  USE kinds
  USE maths  
  USE matrix_vector
  USE mesh_routines
  USE node_routines
  USE problem_constants
  USE strings
  USE solver_routines
  USE timer
  USE types

#include "macros.h"


  IMPLICIT NONE

  PUBLIC diffusionadvectiondiffusion_equationssetsetup
  PUBLIC diffusionadvectiondiffusion_equationssetspecset
  PUBLIC diffusionadvectiondiffusion_equationssetsolnmethodset

  PUBLIC diffusion_advection_diffusion_problem_setup
  PUBLIC diffusionadvectiondiffusion_problemspecificationset
  
  PUBLIC diffusionadvectiondiffusion_finiteelementcalculate

  PUBLIC diffusion_advection_diffusion_pre_solve
  PUBLIC diffusion_advection_diffusion_post_solve

  
CONTAINS

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

  SUBROUTINE diffusionadvectiondiffusion_equationssetsolnmethodset(EQUATIONS_SET,SOLUTION_METHOD,ERR,ERROR,*)

    !Argument variables
    TYPE(equations_set_type), POINTER :: EQUATIONS_SET
    INTEGER(INTG), INTENT(IN) :: SOLUTION_METHOD
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DiffusionAdvectionDiffusion_EquationsSetSolnMethodSet",err,error,*999)
    
    IF(ASSOCIATED(equations_set)) THEN
      IF(.NOT.ALLOCATED(equations_set%SPECIFICATION)) THEN
        CALL flagerror("Equations set specification is not allocated.",err,error,*999)
      ELSE IF(SIZE(equations_set%SPECIFICATION,1)/=3) THEN
        CALL flagerror("Equations set specification must have three entries for a "// &
          & "diffusion and advection-diffusion type equations set.",err,error,*999)
      END IF
      SELECT CASE(equations_set%SPECIFICATION(3))
      CASE(equations_set_coupled_source_diffusion_advec_diffusion_subtype)
        SELECT CASE(solution_method)
        CASE(equations_set_fem_solution_method)
          equations_set%SOLUTION_METHOD=equations_set_fem_solution_method
        CASE(equations_set_bem_solution_method)
          CALL flagerror("Not implemented.",err,error,*999)
        CASE(equations_set_fd_solution_method)
          CALL flagerror("Not implemented.",err,error,*999)
        CASE(equations_set_fv_solution_method)
          CALL flagerror("Not implemented.",err,error,*999)
        CASE(equations_set_gfem_solution_method)
          CALL flagerror("Not implemented.",err,error,*999)
        CASE(equations_set_gfv_solution_method)
          CALL flagerror("Not implemented.",err,error,*999)
        CASE DEFAULT
          local_error="The specified solution method of "//trim(number_to_vstring(solution_method,"*",err,error))//" is invalid."
          CALL flagerror(local_error,err,error,*999)
        END SELECT
      CASE DEFAULT
        local_error="Equations set subtype of "//trim(number_to_vstring(equations_set%SPECIFICATION(3),"*",err,error))// &
          & " is not valid for a diffusion & advection-diffusion equation type of a multi physics equations set class."
        CALL flagerror(local_error,err,error,*999)
      END SELECT
    ELSE
      CALL flagerror("Equations set is not associated.",err,error,*999)
    ENDIF
       
    exits("DiffusionAdvectionDiffusion_EquationsSetSolnMethodSet")
    RETURN
999 errors("DiffusionAdvectionDiffusion_EquationsSetSolnMethodSet",err,error)
    exits("DiffusionAdvectionDiffusion_EquationsSetSolnMethodSet")
    RETURN 1
    
  END SUBROUTINE diffusionadvectiondiffusion_equationssetsolnmethodset

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

  SUBROUTINE diffusionadvectiondiffusion_equationssetsetup(EQUATIONS_SET,EQUATIONS_SET_SETUP,ERR,ERROR,*)

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


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

    CALL flagerror("Not implemented.",err,error,*999)
             
    exits("DiffusionAdvectionDiffusion_EquationsSetSetup")
    RETURN
999 errors("DiffusionAdvectionDiffusion_EquationsSetSetup",err,error)
    exits("DiffusionAdvectionDiffusion_EquationsSetSetup")
    RETURN 1

  END SUBROUTINE diffusionadvectiondiffusion_equationssetsetup

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

  SUBROUTINE diffusionadvectiondiffusion_finiteelementcalculate(EQUATIONS_SET,ELEMENT_NUMBER,ERR,ERROR,*)

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

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

    CALL flagerror("Not implemented.",err,error,*999)
      
    exits("DiffusionAdvectionDiffusion_FiniteElementCalculate")
    RETURN
999 errors("DiffusionAdvectionDiffusion_FiniteElementCalculate",err,error)
    exits("DiffusionAdvectionDiffusion_FiniteElementCalculate")
    RETURN 1
    
  END SUBROUTINE diffusionadvectiondiffusion_finiteelementcalculate

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

  SUBROUTINE diffusionadvectiondiffusion_equationssetspecset(equationsSet,specification,err,error,*)

    !Argument variables
    TYPE(equations_set_type), POINTER :: equationsSet
    INTEGER(INTG), INTENT(IN) :: specification(:)
    INTEGER(INTG), INTENT(OUT) :: err
    TYPE(varying_string), INTENT(OUT) :: error

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

    CALL flagerror("Not implemented.",err,error,*999)

    exits("DiffusionAdvectionDiffusion_EquationsSetSpecSet")
    RETURN
999 errors("DiffusionAdvectionDiffusion_EquationsSetSpecSet",err,error)
    exits("DiffusionAdvectionDiffusion_EquationsSetSpecSet")
    RETURN 1
    
  END SUBROUTINE diffusionadvectiondiffusion_equationssetspecset

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

  SUBROUTINE diffusionadvectiondiffusion_problemspecificationset(problem,problemSpecification,err,error,*)

    !Argument variables
    TYPE(problem_type), POINTER :: problem
    INTEGER(INTG), INTENT(IN) :: problemSpecification(:)
    INTEGER(INTG), INTENT(OUT) :: err
    TYPE(varying_string), INTENT(OUT) :: error
    !Local Variables
    TYPE(varying_string) :: localError
    INTEGER(INTG) :: problemSubtype

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

    IF(ASSOCIATED(problem)) THEN
      IF(SIZE(problemspecification,1)==3) THEN
        SELECT CASE(problemsubtype)
        CASE(problem_coupled_source_diffusion_advec_diffusion_subtype)
          !ok
        CASE DEFAULT
          localerror="The third problem specification of "//trim(numbertovstring(problemsubtype,"*",err,error))// &
            & " is not valid for a coupled diffusion & advection-diffusion type of a multi physics problem."
          CALL flagerror(localerror,err,error,*999)
        END SELECT
        IF(ALLOCATED(problem%specification)) THEN
          CALL flagerror("Problem specification is already allocated.",err,error,*999)
        ELSE
          ALLOCATE(problem%specification(3),stat=err)
          IF(err/=0) CALL flagerror("Could not allocate problem specification.",err,error,*999)
        END IF
        problem%specification(1:3)=[problem_multi_physics_class,problem_diffusion_advection_diffusion_type, &
          & problemsubtype]
      ELSE
        CALL flagerror("Diffusion advection-diffusion transport problem specification must have 3 entries.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("Problem is not associated.",err,error,*999)
    END IF

    exits("DiffusionAdvectionDiffusion_ProblemSpecificationSet")
    RETURN
999 errors("DiffusionAdvectionDiffusion_ProblemSpecificationSet",err,error)
    exits("DiffusionAdvectionDiffusion_ProblemSpecificationSet")
    RETURN 1
    
  END SUBROUTINE diffusionadvectiondiffusion_problemspecificationset

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

  SUBROUTINE diffusion_advection_diffusion_problem_setup(PROBLEM,PROBLEM_SETUP,ERR,ERROR,*)

    !Argument variables
    TYPE(problem_type), POINTER :: PROBLEM
    TYPE(problem_setup_type), INTENT(INOUT) :: PROBLEM_SETUP
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local Variables
    TYPE(control_loop_type), POINTER :: CONTROL_LOOP,CONTROL_LOOP_ROOT
    TYPE(solver_type), POINTER :: SOLVER_DIFFUSION, SOLVER_ADVECTION_DIFFUSION
    TYPE(solver_equations_type), POINTER :: SOLVER_EQUATIONS_DIFFUSION, SOLVER_EQUATIONS_ADVECTION_DIFFUSION
    TYPE(solvers_type), POINTER :: SOLVERS
    TYPE(varying_string) :: LOCAL_ERROR
    
    enters("DIFFUSION_ADVECTION_DIFFUSION_PROBLEM_SETUP",err,error,*999)

    NULLIFY(control_loop)
    NULLIFY(solvers)
    NULLIFY(solver_diffusion)
    NULLIFY(solver_advection_diffusion)
    NULLIFY(solver_equations_diffusion)
    NULLIFY(solver_equations_advection_diffusion)
    IF(ASSOCIATED(problem)) THEN
      IF(.NOT.ALLOCATED(problem%specification)) THEN
        CALL flagerror("Problem specification is not allocated.",err,error,*999)
      ELSE IF(SIZE(problem%specification,1)<3) THEN
        CALL flagerror("Problem specification must have three entries for a diffusion-advection diffusion problem.", &
          & err,error,*999)
      END IF
      SELECT CASE(problem%SPECIFICATION(3))

      !--------------------------------------------------------------------
      !   coupled source diffusion--advection-diffusion
      !--------------------------------------------------------------------
      CASE(problem_coupled_source_diffusion_advec_diffusion_subtype)
        SELECT CASE(problem_setup%SETUP_TYPE)
        CASE(problem_setup_initial_type)
          SELECT CASE(problem_setup%ACTION_TYPE)
          CASE(problem_setup_start_action)
            !Do nothing????
          CASE(problem_setup_finish_action)
            !Do nothing???
          CASE DEFAULT
            local_error="The action type of "//trim(number_to_vstring(problem_setup%ACTION_TYPE,"*",err,error))// &
              & " for a setup type of "//trim(number_to_vstring(problem_setup%SETUP_TYPE,"*",err,error))// &
              & " is invalid for a diffusion & advection-diffusion equation."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        CASE(problem_setup_control_type)
          SELECT CASE(problem_setup%ACTION_TYPE)
          CASE(problem_setup_start_action)
            !Set up a time control loop
            CALL control_loop_create_start(problem,control_loop,err,error,*999)
            CALL control_loop_type_set(control_loop,problem_control_time_loop_type,err,error,*999)
          CASE(problem_setup_finish_action)
            !Finish the control loops
            control_loop_root=>problem%CONTROL_LOOP
            CALL control_loop_get(control_loop_root,control_loop_node,control_loop,err,error,*999)
            CALL control_loop_create_finish(control_loop,err,error,*999)            
          CASE DEFAULT
            local_error="The action type of "//trim(number_to_vstring(problem_setup%ACTION_TYPE,"*",err,error))// &
              & " for a setup type of "//trim(number_to_vstring(problem_setup%SETUP_TYPE,"*",err,error))// &
              & " is invalid for a coupled diffusion & advection-diffusion equation."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        CASE(problem_setup_solvers_type)
          !Get the control loop
          control_loop_root=>problem%CONTROL_LOOP
          CALL control_loop_get(control_loop_root,control_loop_node,control_loop,err,error,*999)
          SELECT CASE(problem_setup%ACTION_TYPE)
          CASE(problem_setup_start_action)
            !Start the solvers creation
            CALL solvers_create_start(control_loop,solvers,err,error,*999)
            CALL solvers_number_set(solvers,2,err,error,*999)
            !
            !Set the first solver to be a linear solver for the advection-diffusion problem
            CALL solvers_solver_get(solvers,1,solver_advection_diffusion,err,error,*999)
            CALL solver_type_set(solver_advection_diffusion,solver_dynamic_type,err,error,*999)
            CALL solver_dynamic_order_set(solver_advection_diffusion,solver_dynamic_first_order,err,error,*999)
            !Set solver defaults
            CALL solver_dynamic_degree_set(solver_advection_diffusion,solver_dynamic_first_degree,err,error,*999)
            CALL solver_dynamic_scheme_set(solver_advection_diffusion,solver_dynamic_crank_nicolson_scheme,err,error,*999)
            CALL solver_library_type_set(solver_advection_diffusion,solver_cmiss_library,err,error,*999)
            !
            !Set the second solver to be a linear solver for the diffusion problem
            CALL solvers_solver_get(solvers,2,solver_diffusion,err,error,*999)
            CALL solver_type_set(solver_diffusion,solver_dynamic_type,err,error,*999)
            CALL solver_dynamic_order_set(solver_diffusion,solver_dynamic_first_order,err,error,*999)
            !Set solver defaults
            CALL solver_dynamic_degree_set(solver_diffusion,solver_dynamic_first_degree,err,error,*999)
            CALL solver_dynamic_scheme_set(solver_diffusion,solver_dynamic_crank_nicolson_scheme,err,error,*999)
            CALL solver_library_type_set(solver_diffusion,solver_cmiss_library,err,error,*999)
            !
          CASE(problem_setup_finish_action)
            !Get the solvers
            CALL control_loop_solvers_get(control_loop,solvers,err,error,*999)
            !Finish the solvers creation
            CALL solvers_create_finish(solvers,err,error,*999)
          CASE DEFAULT
            local_error="The action type of "//trim(number_to_vstring(problem_setup%ACTION_TYPE,"*",err,error))// &
              & " for a setup type of "//trim(number_to_vstring(problem_setup%SETUP_TYPE,"*",err,error))// &
                & " is invalid for a coupled diffusion & advection-diffusion equation."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        CASE(problem_setup_solver_equations_type)
          SELECT CASE(problem_setup%ACTION_TYPE)
          CASE(problem_setup_start_action)
            !Get the control loop and solvers
            control_loop_root=>problem%CONTROL_LOOP
            CALL control_loop_get(control_loop_root,control_loop_node,control_loop,err,error,*999)
            CALL control_loop_solvers_get(control_loop,solvers,err,error,*999)
            !
            !Get the advection-diffusion solver and create the advection-diffusion solver equations
            CALL solvers_solver_get(solvers,1,solver_advection_diffusion,err,error,*999)
            CALL solver_equations_create_start(solver_advection_diffusion,solver_equations_advection_diffusion,err,error,*999)
            CALL solver_equations_linearity_type_set(solver_equations_advection_diffusion,solver_equations_linear,err,error,*999)
            CALL solver_equations_time_dependence_type_set(solver_equations_advection_diffusion, & 
              & solver_equations_first_order_dynamic,err,error,*999)
            CALL solver_equations_sparsity_type_set(solver_equations_advection_diffusion,solver_sparse_matrices,err,error,*999)
            !
            !Get the diffusion solver and create the diffusion solver equations
            CALL solvers_solver_get(solvers,2,solver_diffusion,err,error,*999)
            CALL solver_equations_create_start(solver_diffusion,solver_equations_diffusion,err,error,*999)
            CALL solver_equations_linearity_type_set(solver_equations_diffusion,solver_equations_linear,err,error,*999)
            CALL solver_equations_time_dependence_type_set(solver_equations_diffusion, & 
              & solver_equations_first_order_dynamic,err,error,*999)
            CALL solver_equations_sparsity_type_set(solver_equations_diffusion,solver_sparse_matrices,err,error,*999)
            !

          CASE(problem_setup_finish_action)
            !Get the control loop
            control_loop_root=>problem%CONTROL_LOOP
            CALL control_loop_get(control_loop_root,control_loop_node,control_loop,err,error,*999)
            CALL control_loop_solvers_get(control_loop,solvers,err,error,*999)
            !
            !Finish the creation of the advection-diffusion solver equations
            CALL solvers_solver_get(solvers,1,solver_advection_diffusion,err,error,*999)
            CALL solver_solver_equations_get(solver_advection_diffusion,solver_equations_advection_diffusion,err,error,*999)
            CALL solver_equations_create_finish(solver_equations_advection_diffusion,err,error,*999)             
            !
            !Finish the creation of the diffusion solver equations
            CALL solvers_solver_get(solvers,2,solver_diffusion,err,error,*999)
            CALL solver_solver_equations_get(solver_diffusion,solver_equations_diffusion,err,error,*999)
            CALL solver_equations_create_finish(solver_equations_diffusion,err,error,*999)             
            !
          
          CASE DEFAULT
            local_error="The action type of "//trim(number_to_vstring(problem_setup%ACTION_TYPE,"*",err,error))// &
              & " for a setup type of "//trim(number_to_vstring(problem_setup%SETUP_TYPE,"*",err,error))// &
              & " is invalid for a coupled diffusion & advection-diffusion equation."
            CALL flagerror(local_error,err,error,*999)
          END SELECT
        CASE DEFAULT
          local_error="The setup type of "//trim(number_to_vstring(problem_setup%SETUP_TYPE,"*",err,error))// &
            & " is invalid for a coupled diffusion & advection-diffusion equation."
          CALL flagerror(local_error,err,error,*999)
        END SELECT

      !-----------------------------------------------------------------
      !   c a s e   d e f a u l t
      !-----------------------------------------------------------------
      CASE DEFAULT
        local_error="The problem subtype of "//trim(number_to_vstring(problem%SPECIFICATION(3),"*",err,error))// &
          & " does not equal a coupled source diffusion & advection-diffusion equation subtype."
        CALL flagerror(local_error,err,error,*999)

      END SELECT
    ELSE
      CALL flagerror("Problem is not associated.",err,error,*999)
    ENDIF
       
    exits("DIFFUSION_ADVECTION_DIFFUSION_PROBLEM_SETUP")
    RETURN
999 errorsexits("DIFFUSION_ADVECTION_DIFFUSION_PROBLEM_SETUP",err,error)
    RETURN 1
  END SUBROUTINE diffusion_advection_diffusion_problem_setup

  !
  !================================================================================================================================
  !
 
  SUBROUTINE diffusion_advection_diffusion_pre_solve(CONTROL_LOOP,SOLVER,ERR,ERROR,*)

    !Argument variables
    TYPE(control_loop_type), POINTER :: CONTROL_LOOP
    TYPE(solver_type), POINTER :: SOLVER
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR

    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR


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

    IF(ASSOCIATED(control_loop)) THEN
      IF(ASSOCIATED(solver)) THEN
        IF(ASSOCIATED(control_loop%PROBLEM)) THEN
          IF(.NOT.ALLOCATED(control_loop%problem%specification)) THEN
            CALL flagerror("Problem specification is not allocated.",err,error,*999)
          ELSE IF(SIZE(control_loop%problem%specification,1)<3) THEN
            CALL flagerror("Problem specification must have three entries for a diffusion-advection diffusion problem.", &
              & err,error,*999)
          END IF
          SELECT CASE(control_loop%PROBLEM%SPECIFICATION(3))
            CASE(problem_coupled_source_diffusion_advec_diffusion_subtype)

              IF(solver%GLOBAL_NUMBER==1) THEN
                !copy current value of concentration_one to another variable
                CALL advectiondiffusion_presolvestorecurrentsoln(control_loop,solver,err,error,*999)
                !Set source term to be updated value of concentration_two
                !CALL ADVECTION_DIFFUSION_EQUATION_PRE_SOLVE_GET_SOURCE_VALUE(CONTROL_LOOP,SOLVER,ERR,ERROR,*999)
                
                !Update indpendent data fields
!                 CALL WRITE_STRING(GENERAL_OUTPUT_TYPE,"Read in vector data... ",ERR,ERROR,*999)
!                 CALL ADVECTION_DIFFUSION_PRE_SOLVE_UPDATE_INPUT_DATA(CONTROL_LOOP,SOLVER,ERR,ERROR,*999)
 
              ELSE IF(solver%GLOBAL_NUMBER==2) THEN
                !copy current value of concentration_one to another variable
                CALL diffusion_presolvestorecurrentsolution(control_loop,solver,err,error,*999)
                !compute value of constant source term - evaluated from lamdba*(0.5*(c_1^{t+1}+c_1^{t}) - c_2^{t})
                !CALL DIFFUSION_EQUATION_PRE_SOLVE_GET_SOURCE_VALUE(CONTROL_LOOP,SOLVER,ERR,ERROR,*999)
              ENDIF
            CASE DEFAULT
              local_error="Problem subtype "//trim(number_to_vstring(control_loop%PROBLEM%SPECIFICATION(3),"*",err,error))// &
                & " is not valid for a diffusion & advection-diffusion type of a multi physics problem class."
              CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("Problem is not associated.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("Solver is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Control loop is not associated.",err,error,*999)
    ENDIF

    exits("DIFFUSION_ADVECTION_DIFFUSION_PRE_SOLVE")
    RETURN
999 errorsexits("DIFFUSION_ADVECTION_DIFFUSION_PRE_SOLVE",err,error)
    RETURN 1
  END SUBROUTINE diffusion_advection_diffusion_pre_solve
      
  !   
  !================================================================================================================================
  !

  SUBROUTINE diffusion_advection_diffusion_post_solve(CONTROL_LOOP,SOLVER,ERR,ERROR,*)

    !Argument variables
    TYPE(control_loop_type), POINTER :: CONTROL_LOOP
    TYPE(solver_type), POINTER :: SOLVER
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR

    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

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

    IF(ASSOCIATED(control_loop)) THEN
      IF(ASSOCIATED(solver)) THEN
        IF(ASSOCIATED(control_loop%PROBLEM)) THEN 
          IF(.NOT.ALLOCATED(control_loop%problem%specification)) THEN
            CALL flagerror("Problem specification is not allocated.",err,error,*999)
          ELSE IF(SIZE(control_loop%problem%specification,1)<3) THEN
            CALL flagerror("Problem specification must have three entries for a diffusion-advection diffusion problem.", &
              & err,error,*999)
          END IF
          SELECT CASE(control_loop%PROBLEM%SPECIFICATION(3))
            CASE(problem_coupled_source_diffusion_advec_diffusion_subtype)
              IF(solver%GLOBAL_NUMBER==1) THEN
!              CALL ADVECTION_DIFFUSION_EQUATION_POST_SOLVE(CONTROL_LOOP,SOLVER,ERR,ERROR,*999)
              ELSE IF(solver%GLOBAL_NUMBER==2) THEN
!              CALL DIFFUSION_EQUATION_POST_SOLVE(CONTROL_LOOP,SOLVER,ERR,ERROR,*999)
              ENDIF
            CASE DEFAULT
              local_error="Problem subtype "//trim(number_to_vstring(control_loop%PROBLEM%SPECIFICATION(3),"*",err,error))// &
                & " is not valid for a diffusion & advection-diffusion type of a multi physics problem class."
              CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("Problem is not associated.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("Solver is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Control loop is not associated.",err,error,*999)
    ENDIF

    exits("DIFFUSION_ADVECTION_DIFFUSION_POST_SOLVE")
    RETURN
999 errorsexits("DIFFUSION_ADVECTION_DIFFUSION_POST_SOLVE",err,error)
    RETURN 1
  END SUBROUTINE diffusion_advection_diffusion_post_solve

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

  SUBROUTINE diffusionadvectiondiffusion_postsolveoutputdata(CONTROL_LOOP,SOLVER,ERR,ERROR,*)

    !Argument variables
    TYPE(control_loop_type), POINTER :: CONTROL_LOOP
    TYPE(solver_type), POINTER :: SOLVER
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR

    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

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

    IF(ASSOCIATED(control_loop)) THEN
      IF(ASSOCIATED(solver)) THEN
        IF(ASSOCIATED(control_loop%PROBLEM)) THEN
          IF(.NOT.ALLOCATED(control_loop%problem%specification)) THEN
            CALL flagerror("Problem specification is not allocated.",err,error,*999)
          ELSE IF(SIZE(control_loop%problem%specification,1)<3) THEN
            CALL flagerror("Problem specification must have three entries for a diffusion-advection diffusion problem.", &
              & err,error,*999)
          END IF
          SELECT CASE(control_loop%PROBLEM%SPECIFICATION(3))
            CASE(problem_coupled_source_diffusion_advec_diffusion_subtype)
                !CALL ADVECTION_DIFFUSION_EQUATION_POST_SOLVE_OUTPUT_DATA(CONTROL_LOOP,SOLVER,ERR,ERROR,*999)
                !CALL DIFFUSION_EQUATION_POST_SOLVE_OUTPUT_DATA(CONTROL_LOOP,SOLVER,ERR,ERROR,*999)
            CASE DEFAULT
              local_error="Problem subtype "//trim(number_to_vstring(control_loop%PROBLEM%SPECIFICATION(3),"*",err,error))// &
                & " is not valid for a diffusion & advection-diffusion type of a multi physics problem class."
              CALL flagerror(local_error,err,error,*999)
          END SELECT
        ELSE
          CALL flagerror("Problem is not associated.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("Solver is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Control loop is not associated.",err,error,*999)
    ENDIF
      
    exits("DiffusionAdvectionDiffusion_PostSolveOutputData")
    RETURN
999 errors("DiffusionAdvectionDiffusion_PostSolveOutputData",err,error)
    exits("DiffusionAdvectionDiffusion_PostSolveOutputData")
    RETURN 1
    
  END SUBROUTINE diffusionadvectiondiffusion_postsolveoutputdata
      
  !   
  !================================================================================================================================
  !


END MODULE diffusion_advection_diffusion_routines